[server] / trunk / server / src / ipmdevice.cxx Repository:
ViewVC logotype

Annotation of /trunk/server/src/ipmdevice.cxx

Parent Directory Parent Directory | Revision Log Revision Log

Revision 419 - (view) (download)

1 : jtarlton 41 /*
2 : jtarlton 355 * This file is part of Project DiaStar Server.
3 : jtarlton 41 *
4 : amartin 143 * More information about this project can be found at:
5 : jtarlton 355 * http://www.projectdiastar.org.
6 : jtarlton 41 *
7 : amartin 143 * Copyright (C) 2009 Dialogic Corp.
8 : jtarlton 41 *
9 : amartin 143 * This program is free software; you can redistribute it and/or
10 :     * modify it under the terms of the GNU General Public License
11 :     * as published by the Free Software Foundation; either version 2
12 :     * of the License, or (at your option) any later version.
13 :     *
14 :     * This program is distributed in the hope that it will be useful,
15 :     * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 :     * GNU General Public License for more details.
18 :     *
19 :     * You should have received a copy of the GNU General Public License
20 :     * along with this program; if not, write to the Free Software
21 :     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 :     * 02110-1301, USA.
23 :     * Alternatively see <http://www.gnu.org/licenses/>.
24 :     * Or see the LICENSE file included within the source tree.
25 :     *
26 : jtarlton 41 */
27 :    
28 :     /*!
29 : jtarlton 45 * \file ipmdevice.cxx
30 : jtarlton 59 * \brief Dialogic IPM device
31 : jtarlton 41 * \author Antony Martin <antony.martin@dialogic.com>
32 : jtarlton 162 * \author John Tarlton <john.tarlton@dialogic.com>
33 : jtarlton 87 * \version 2-APR-2009
34 : jtarlton 41 */
35 :    
36 : jtarlton 87 /*------------------------------ Dependencies --------------------------------*/
37 : jtarlton 41
38 : jtarlton 413 #include <iomanip>
39 :    
40 : jtarlton 41 #include "logger.h"
41 : jtarlton 162 #include "string-util.h"
42 :    
43 : jtarlton 394 #include "dialogicchannelmanager.h"
44 : jtarlton 393 #include "mmdevice.h"
45 : jtarlton 395 #include "gciptdevice.h"
46 : jtarlton 41 #include "ipmdevice.h"
47 :    
48 : jtarlton 87 /*----------------------------------------------------------------------------*/
49 : jtarlton 41
50 : jtarlton 390
51 : jtarlton 41 /*
52 :     * ctor
53 :     */
54 : jtarlton 87 IpmDevice::IpmDevice( const std::string& name,
55 :     DialogicChannelManager& channelMgr )
56 :     : DialogicDevice(name, channelMgr)
57 : jtarlton 41 {
58 : jtarlton 395 ipt_ = 0; /* standalone mode */
59 : jtarlton 323 busy_ = false;
60 :    
61 : jtarlton 41 /* Number of steps in the initialisation sequence, decremented by event
62 : jtarlton 394 * handlers. When zero, state is changed to IDLE.
63 : jtarlton 64 *
64 :     * IPMEV_OPEN,
65 :     * DMEV_GET_RX_PORT_INFO,
66 :     * DMEV_GET_TX_PORT_INFO
67 : jtarlton 41 */
68 :     initStepsRemaining_ = 3;
69 :     }
70 :    
71 :    
72 :     /*
73 :     * dtor
74 :     */
75 :     IpmDevice::~IpmDevice()
76 :     {
77 :     }
78 :    
79 :    
80 :     /*
81 : jtarlton 321 * Process a command that was queueued because an async operation was in progress
82 :     * when it was initially requested.
83 :     */
84 :     void IpmDevice::processPendingCommand()
85 :     {
86 : jtarlton 418 while ( !busy_ && !pending_.empty() )
87 : jtarlton 321 {
88 : jtarlton 419 LOGDEBUG("IpmDevice::processPendingCommand()");
89 : jtarlton 321 switch( pending_.front().cmd )
90 :     {
91 :     case IpmCommand::START:
92 :     startMedia();
93 :     break;
94 :     case IpmCommand::STOP:
95 :     stop(pending_.front().operation);
96 :     break;
97 :     case IpmCommand::LISTEN:
98 :     listen(pending_.front().other);
99 :     break;
100 :     case IpmCommand::UNLISTEN:
101 :     unListen();
102 :     break;
103 : amartin 402 case IpmCommand::CONNECT:
104 :     connect(pending_.front().other);
105 :     break;
106 :     case IpmCommand::DISCONNECT:
107 :     disconnect();
108 :     break;
109 : jtarlton 321 default:
110 :     break;
111 :     }
112 :     pending_.pop();
113 :     }
114 :     }
115 :    
116 :    
117 :     /*
118 : jtarlton 64 * Open the device.
119 : jtarlton 41 */
120 : jtarlton 45 bool IpmDevice::open()
121 : jtarlton 41 {
122 : jtarlton 45 LOGDEBUG("IpmDevice::open() device: " << devName_);
123 :    
124 : jtarlton 41 devHandle_ = ipm_Open(devName_.c_str(), NULL, EV_ASYNC);
125 :     if ( devHandle_ < 0 )
126 :     {
127 :     LOGERROR("ipm_Open() failed");
128 :     return false;
129 :     }
130 :     state_ = IPM_OPENING;
131 :     return true;
132 :     }
133 :    
134 :    
135 :     /*
136 : jtarlton 64 * Close the device
137 : jtarlton 41 */
138 : jtarlton 45 bool IpmDevice::close()
139 : jtarlton 41 {
140 : jtarlton 45 LOGDEBUG("IpmDevice::close() device: " << devName_);
141 :    
142 : jtarlton 41 if ( devHandle_ > 0 )
143 :     {
144 :     if ( ipm_Close(devHandle_, NULL) < 0 )
145 :     {
146 : jtarlton 104 LOGERROR("ipm_Close() failed");
147 : jtarlton 41 return false;
148 :     }
149 : jtarlton 64 devHandle_ = 0;
150 : jtarlton 41 }
151 :     return true;
152 :     }
153 :    
154 :    
155 :     /*
156 : jtarlton 64 * Connect media.
157 : jtarlton 41 */
158 : jtarlton 45 bool IpmDevice::listen( DialogicDevice* other )
159 : jtarlton 41 {
160 : jtarlton 413 if ( busy_ )
161 :     {
162 :     pending_.push(IpmCommand(IpmCommand::LISTEN, other));
163 :     return true;
164 :     }
165 :    
166 : jtarlton 417 if ( other_ != other )
167 : jtarlton 316 {
168 :     LOGDEBUG("IpmDevice::listen() device: " << devName_ <<
169 : jtarlton 317 " other: " << other->getDeviceName());
170 : jtarlton 401
171 : jtarlton 317 SC_TSINFO tsinfo;
172 :     tsinfo.sc_numts = 1;
173 :     tsinfo.sc_tsarrayp = other->getXmitTimeslotPtr();
174 : jtarlton 41
175 : jtarlton 317 if ( ipm_Listen(devHandle_, &tsinfo, EV_ASYNC) == -1 )
176 :     {
177 :     LOGERROR("ipm_Listen() failed on device: " << devName_ <<
178 :     " " << ATDV_ERRMSGP(devHandle_));
179 :     return false;
180 :     }
181 : jtarlton 401
182 : jtarlton 417 other_ = other;
183 : jtarlton 401 busy_ = true;
184 :     }
185 :     return true;
186 :     }
187 :    
188 :    
189 :     /*
190 :     * Disconnect media.
191 :     */
192 :     bool IpmDevice::unListen()
193 :     {
194 : jtarlton 413 if ( busy_ )
195 :     {
196 :     pending_.push(IpmCommand(IpmCommand::UNLISTEN));
197 :     return true;
198 :     }
199 :    
200 : jtarlton 417 if ( other_ )
201 : jtarlton 401 {
202 :     LOGDEBUG("IpmDevice::unListen() device: " << devName_);
203 :    
204 :     if ( ipm_UnListen(devHandle_, EV_ASYNC) == -1)
205 :     {
206 :     LOGERROR("ipm_UnListen() failed on device: " << devName_ <<
207 :     " " << ATDV_ERRMSGP(devHandle_));
208 :     return false;
209 :     }
210 :    
211 : jtarlton 417 other_ = 0;
212 : jtarlton 401 busy_ = true;
213 :     }
214 :     return true;
215 :     }
216 :    
217 :    
218 :     /*
219 :     * Connect media.
220 :     */
221 :     bool IpmDevice::connect( DialogicDevice* other )
222 :     {
223 : jtarlton 413 if ( busy_ )
224 :     {
225 :     pending_.push(IpmCommand(IpmCommand::CONNECT, other));
226 :     return true;
227 :     }
228 :    
229 : jtarlton 417 if ( !other_ )
230 : jtarlton 401 {
231 :     LOGDEBUG("IpmDevice::connect() device: " << devName_ <<
232 : jtarlton 413 " to: " << other->getDeviceName());
233 : jtarlton 401
234 : jtarlton 390 DM_PORT_CONNECT_INFO_LIST portConnectInfoList;
235 : jtarlton 413 memset(&portConnectInfoList, 0, sizeof(portConnectInfoList));
236 : jtarlton 390 INIT_DM_PORT_CONNECT_INFO_LIST(&portConnectInfoList);
237 : jtarlton 393 int count = 0;
238 : jtarlton 390
239 : jtarlton 393 INIT_DM_PORT_CONNECT_INFO(&portConnectInfoList.port_connect_info[count]);
240 : jtarlton 413 portConnectInfoList.port_connect_info[count].unFlags = DMFL_TRANSCODE_ON;
241 : jtarlton 393 portConnectInfoList.port_connect_info[count].port_info_tx = getAudioTxPortInfo();
242 : jtarlton 401 portConnectInfoList.port_connect_info[count].port_info_rx = other->getAudioRxPortInfo();
243 : jtarlton 393 count++;
244 : jtarlton 390
245 : jtarlton 393 INIT_DM_PORT_CONNECT_INFO(&portConnectInfoList.port_connect_info[count]);
246 : jtarlton 413 portConnectInfoList.port_connect_info[count].unFlags = DMFL_TRANSCODE_ON;
247 : jtarlton 393 portConnectInfoList.port_connect_info[count].port_info_tx = getVideoTxPortInfo();
248 : jtarlton 401 portConnectInfoList.port_connect_info[count].port_info_rx = other->getVideoRxPortInfo();
249 : jtarlton 393 count++;
250 : jtarlton 416
251 : jtarlton 393 portConnectInfoList.unCount = count;
252 : jtarlton 390 if ( dev_PortConnect(devHandle_, &portConnectInfoList, NULL) != DEV_SUCCESS )
253 :     {
254 : amartin 403 LOGERROR("IpmDevice::connect() dev_PortConnect() failed on device: " << devName_ <<
255 : jtarlton 390 " " << ATDV_ERRMSGP(devHandle_));
256 :     return false;
257 :     }
258 :    
259 : jtarlton 417 other_ = other;
260 : jtarlton 321 busy_ = true;
261 : jtarlton 41 }
262 : amartin 405 else
263 :     {
264 : jtarlton 417 if ( other_ != other )
265 :     {
266 :     LOGERROR("IpmDevice::connect() " << devName_ <<
267 :     " unable to connect to device: " << other->getDeviceName() <<
268 :     " already connected to device: " << other_->getDeviceName());
269 :     }
270 : amartin 405 }
271 : jtarlton 41 return true;
272 :     }
273 :    
274 :    
275 :     /*
276 : jtarlton 64 * Disconnect media.
277 : jtarlton 41 */
278 : jtarlton 401 bool IpmDevice::disconnect()
279 : jtarlton 41 {
280 : jtarlton 413 if ( busy_ )
281 :     {
282 :     pending_.push(IpmCommand(IpmCommand::DISCONNECT));
283 :     return true;
284 :     }
285 :    
286 : jtarlton 417 if ( other_ )
287 : jtarlton 316 {
288 : jtarlton 413 LOGDEBUG("IpmDevice::disconnect() device: " << devName_ <<
289 : jtarlton 417 " from: " << other_->getDeviceName());
290 : jtarlton 316
291 : jtarlton 390 DM_PORT_CONNECT_INFO_LIST portConnectInfoList;
292 : jtarlton 413 memset(&portConnectInfoList, 0, sizeof(portConnectInfoList));
293 : jtarlton 390 INIT_DM_PORT_CONNECT_INFO_LIST(&portConnectInfoList);
294 : jtarlton 393 int count = 0;
295 : jtarlton 390
296 : jtarlton 393 INIT_DM_PORT_CONNECT_INFO(&portConnectInfoList.port_connect_info[count]);
297 :     portConnectInfoList.port_connect_info[count].port_info_tx = getAudioTxPortInfo();
298 : jtarlton 417 portConnectInfoList.port_connect_info[count].port_info_rx = other_->getAudioRxPortInfo(); //XXX
299 : jtarlton 393 count++;
300 : jtarlton 390
301 : jtarlton 393 INIT_DM_PORT_CONNECT_INFO(&portConnectInfoList.port_connect_info[count]);
302 :     portConnectInfoList.port_connect_info[count].port_info_tx = getVideoTxPortInfo();
303 : jtarlton 417 portConnectInfoList.port_connect_info[count].port_info_rx = other_->getVideoRxPortInfo(); //XXX
304 : jtarlton 393 count++;
305 : jtarlton 390
306 : jtarlton 393 portConnectInfoList.unCount = count;
307 : jtarlton 390 if ( dev_PortDisconnect(devHandle_, &portConnectInfoList, NULL) != DEV_SUCCESS )
308 :     {
309 : amartin 403 LOGERROR("IpmDevice::disconnect() dev_PortDisconnect() failed on device: " << devName_ <<
310 : jtarlton 390 " " << ATDV_ERRMSGP(devHandle_));
311 :     return false;
312 :     }
313 :    
314 : jtarlton 417 other_ = 0;
315 : jtarlton 321 busy_ = true;
316 : jtarlton 41 }
317 :     return true;
318 :     }
319 :    
320 :    
321 :     /*
322 : jtarlton 131 * Search localMediaInfo_ for the requested information.
323 : jtarlton 41 */
324 : jtarlton 390 bool IpmDevice::getLocalMediaInfo( eIPM_MEDIA_TYPE type,
325 : jtarlton 131 IpInfo& rtp_media ) const
326 : jtarlton 41 {
327 : jtarlton 390 switch ( type )
328 : jtarlton 41 {
329 : jtarlton 390 case MEDIATYPE_AUDIO_LOCAL_RTP_INFO:
330 :     rtp_media = localRtpAudio_;
331 : jtarlton 41 break;
332 : jtarlton 390
333 :     case MEDIATYPE_AUDIO_LOCAL_RTCP_INFO:
334 :     rtp_media = localRtcpAudio_;
335 :     break;
336 :    
337 :     case MEDIATYPE_VIDEO_LOCAL_RTP_INFO:
338 :     rtp_media = localRtpVideo_;
339 :     break;
340 :    
341 :     case MEDIATYPE_VIDEO_LOCAL_RTCP_INFO:
342 :     rtp_media = localRtcpVideo_;
343 :     break;
344 :    
345 :     default:
346 :     return false;
347 : jtarlton 41 }
348 : jtarlton 390 return true;
349 : jtarlton 41 }
350 :    
351 :    
352 :     /*
353 : jtarlton 131 * Save the remote params.
354 : jtarlton 41 */
355 : jtarlton 131 void IpmDevice::setRemoteMediaInfo( eIPM_MEDIA_TYPE type,
356 :     const IpInfo& rtp_info )
357 : jtarlton 41 {
358 : jtarlton 390 if ( type == MEDIATYPE_AUDIO_REMOTE_RTP_INFO )
359 : jtarlton 210 {
360 :     remoteRtpAudio_ = rtp_info;
361 :     remoteRtcpAudio_ = rtp_info;
362 : jtarlton 286 remoteRtcpAudio_.setPort(remoteRtpAudio_.getPort() + 1);
363 : jtarlton 411
364 :     LOGDEBUG("IpmDevice::setRemoteMediaInfo() device: " << devName_ <<
365 :     " a=" << remoteRtpAudio_);
366 : jtarlton 210 }
367 : jtarlton 390 if ( type == MEDIATYPE_VIDEO_REMOTE_RTP_INFO )
368 :     {
369 :     remoteRtpVideo_ = rtp_info;
370 :     remoteRtcpVideo_ = rtp_info;
371 :     remoteRtcpVideo_.setPort(remoteRtpVideo_.getPort() + 1);
372 : jtarlton 411 LOGDEBUG("IpmDevice::setRemoteMediaInfo() device: " << devName_ <<
373 :     " v=" << remoteRtpVideo_);
374 : jtarlton 390 }
375 : jtarlton 41 }
376 :    
377 :    
378 :     /*
379 :     * Stop the IPM streaming and/or digit reception
380 :     */
381 :     bool IpmDevice::stop( eIPM_STOP_OPERATION operation )
382 :     {
383 :     if ( state_ == IPM_IDLE )
384 :     {
385 : jtarlton 294 return true; /* already stopped */
386 : jtarlton 41 }
387 :    
388 : jtarlton 321 if ( busy_ )
389 :     {
390 :     pending_.push(IpmCommand(IpmCommand::STOP, operation));
391 :     return true;
392 :     }
393 :    
394 : jtarlton 41 if ( ipm_Stop(devHandle_, operation, EV_ASYNC) == -1 )
395 :     {
396 :     LOGERROR("ipm_Stop() on device: " << devName_ << " failed: " <<
397 :     ATDV_LASTERR(devHandle_));
398 :     return false;
399 :     }
400 : jtarlton 411
401 :     LOGDEBUG("IpmDevice::stopMedia() stopping RTP streaming on device: " <<
402 :     devName_);
403 :    
404 : jtarlton 41 state_ = IPM_STOPPING;
405 : jtarlton 321 busy_ = true;
406 :    
407 : jtarlton 41 return true;
408 :     }
409 :    
410 :    
411 :     /*
412 :     * Start RTP streaming to peer.
413 :     */
414 :     bool IpmDevice::startMedia()
415 :     {
416 : jtarlton 390 return startMedia(remoteRtpAudio_,
417 :     remoteRtcpAudio_,
418 :     remoteRtpVideo_,
419 :     remoteRtcpVideo_);
420 : jtarlton 41 }
421 :    
422 :    
423 :     /*
424 : jtarlton 294 * Start RTP streaming using G.711ulaw and local/remote port information.
425 : jtarlton 390 * XXX codecs from config
426 : jtarlton 41 */
427 : jtarlton 131 bool IpmDevice::startMedia( const IpInfo& remote_rtp_audio,
428 : jtarlton 390 const IpInfo& remote_rtcp_audio,
429 :     const IpInfo& remote_rtp_video,
430 :     const IpInfo& remote_rtcp_video )
431 : jtarlton 41 {
432 : jtarlton 411 if ( busy_ )
433 : jtarlton 41 {
434 : jtarlton 411 pending_.push(IpmCommand(IpmCommand::START));
435 :     return true;
436 : jtarlton 41 }
437 :    
438 : jtarlton 411 if ( state_ == IPM_STREAMING )
439 : jtarlton 321 {
440 : jtarlton 411 /* already started, ignore */
441 :     LOGDEBUG("IpmDevice::startMedia() already streaming on device: " <<
442 :     devName_);
443 : jtarlton 321 return true;
444 :     }
445 :    
446 : jtarlton 419 if ( !remote_rtp_audio.isValid() && !remote_rtp_video.isValid() )
447 :     {
448 :     LOGERROR("IpmDevice::startMedia() invalid destination address:port for device: " <<
449 :     devName_);
450 :     return false;
451 :     }
452 :    
453 : jtarlton 390 setDtmfMode(DTMF_RFC2833);
454 :    
455 : jtarlton 41 IPM_MEDIA_INFO mediaInfo;
456 :     memset(&mediaInfo, 0, sizeof(IPM_MEDIA_INFO));
457 :    
458 : jtarlton 131 int mediaCnt = 0; /* limit MAX_MEDIA_INFO */
459 : jtarlton 41
460 :     /* remote audio
461 :     */
462 : jtarlton 311 mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_AUDIO_REMOTE_CODER_INFO;
463 : jtarlton 41 mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eCoderType = CODER_TYPE_G711ULAW64K;
464 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eFrameSize = CODER_FRAMESIZE_20;
465 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unFramesPerPkt = 1;
466 : jtarlton 131 mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eVadEnable = CODER_VAD_ENABLE;
467 : jtarlton 41 mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unCoderPayloadType = 0;
468 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unRedPayloadType = 0;
469 :     mediaCnt++;
470 :    
471 :     /* local audio
472 : jtarlton 131 */
473 : jtarlton 311 mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_AUDIO_LOCAL_CODER_INFO;
474 : jtarlton 131 mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eCoderType = CODER_TYPE_G711ULAW64K;
475 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eFrameSize = CODER_FRAMESIZE_20;
476 : jtarlton 41 mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unFramesPerPkt = 1;
477 : jtarlton 131 mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eVadEnable = CODER_VAD_ENABLE;
478 : jtarlton 41 mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unCoderPayloadType = 0;
479 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unRedPayloadType = 0;
480 :     mediaCnt++;
481 :    
482 :     /* remote audio ports and IP addresses
483 :     */
484 :     mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_AUDIO_REMOTE_RTP_INFO;
485 : jtarlton 162 copy_string_to_c_array(remote_rtp_audio.getAddress(),
486 :     mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.cIPAddress,
487 : jtarlton 210 IP_ADDR_SIZE);
488 : jtarlton 131 mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.unPortId = remote_rtp_audio.getPort();
489 : jtarlton 41 mediaCnt++;
490 :    
491 : jtarlton 390 mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_AUDIO_REMOTE_RTCP_INFO;
492 : jtarlton 162 copy_string_to_c_array(remote_rtcp_audio.getAddress(),
493 :     mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.cIPAddress,
494 : jtarlton 210 IP_ADDR_SIZE);
495 : jtarlton 131 mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.unPortId = remote_rtcp_audio.getPort();
496 : jtarlton 41 mediaCnt++;
497 :    
498 : jtarlton 390 /* remote video
499 :     */
500 :     mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_VIDEO_REMOTE_CODER_INFO;
501 :     INIT_IPM_VIDEO_CODER_INFO(&mediaInfo.MediaData[mediaCnt].mediaInfo.VideoCoderInfo);
502 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eCoderType = CODER_TYPE_H263;
503 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unCoderPayloadType = 34;
504 :    
505 :     IPM_VIDEO_CODER_INFO_EX remoteVideoCoderInfoEx;
506 :     INIT_IPM_VIDEO_CODER_INFO_EX(&remoteVideoCoderInfoEx);
507 :     remoteVideoCoderInfoEx.eProfile = VIDEO_PROFILE_0_H263;
508 :     remoteVideoCoderInfoEx.eLevel = VIDEO_LEVEL_10_H263;
509 : jtarlton 411 remoteVideoCoderInfoEx.eImageWidth = VIDEO_IMAGE_WIDTH_352; //176;
510 :     remoteVideoCoderInfoEx.eImageHeight = VIDEO_IMAGE_HEIGHT_288; //144;
511 : jtarlton 390 remoteVideoCoderInfoEx.eFramesPerSec = VIDEO_FRAMESPERSEC_15;
512 :     remoteVideoCoderInfoEx.unBitRate = 90000;
513 :     remoteVideoCoderInfoEx.eSamplingRate = VIDEO_SAMPLING_RATE_DEFAULT;
514 :     remoteVideoCoderInfoEx.unVisualConfigSize = 0;
515 :     remoteVideoCoderInfoEx.szVisualConfiguration = NULL;
516 :     mediaInfo.MediaData[mediaCnt].mediaInfo.VideoCoderInfo.pExtraCoderInfo = &remoteVideoCoderInfoEx;
517 :     mediaCnt++;
518 :    
519 :     /* local video
520 :     */
521 :     mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_VIDEO_LOCAL_CODER_INFO;
522 :     INIT_IPM_VIDEO_CODER_INFO(&mediaInfo.MediaData[mediaCnt].mediaInfo.VideoCoderInfo);
523 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eCoderType = CODER_TYPE_H263;
524 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unCoderPayloadType = 34;
525 :    
526 :     IPM_VIDEO_CODER_INFO_EX localVideoCoderInfoEx;
527 :     INIT_IPM_VIDEO_CODER_INFO_EX(&localVideoCoderInfoEx);
528 :     localVideoCoderInfoEx.eProfile = VIDEO_PROFILE_0_H263;
529 :     localVideoCoderInfoEx.eLevel = VIDEO_LEVEL_10_H263;
530 : jtarlton 411 localVideoCoderInfoEx.eImageWidth = VIDEO_IMAGE_WIDTH_352; //176;
531 :     localVideoCoderInfoEx.eImageHeight = VIDEO_IMAGE_HEIGHT_288; //144;
532 : jtarlton 390 localVideoCoderInfoEx.eFramesPerSec = VIDEO_FRAMESPERSEC_15;
533 :     localVideoCoderInfoEx.unBitRate = 90000;
534 :     localVideoCoderInfoEx.eSamplingRate = VIDEO_SAMPLING_RATE_DEFAULT;
535 :     localVideoCoderInfoEx.unVisualConfigSize = 0;
536 :     localVideoCoderInfoEx.szVisualConfiguration = NULL;
537 :     mediaInfo.MediaData[mediaCnt].mediaInfo.VideoCoderInfo.pExtraCoderInfo = &localVideoCoderInfoEx;
538 :     mediaCnt++;
539 :    
540 :     /* remote video ports and IP addresses
541 :     */
542 :     mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_VIDEO_REMOTE_RTP_INFO;
543 :     copy_string_to_c_array(remote_rtp_video.getAddress(),
544 :     mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.cIPAddress,
545 :     IP_ADDR_SIZE);
546 :     mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.unPortId = remote_rtp_video.getPort();
547 :     mediaCnt++;
548 :    
549 : jtarlton 411 mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_VIDEO_REMOTE_RTCP_INFO;
550 : jtarlton 390 copy_string_to_c_array(remote_rtcp_video.getAddress(),
551 :     mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.cIPAddress,
552 :     IP_ADDR_SIZE);
553 :     mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.unPortId = remote_rtcp_video.getPort();
554 :     mediaCnt++;
555 :    
556 :     /* done
557 :     */
558 : jtarlton 41 mediaInfo.unCount = mediaCnt;
559 :    
560 : jtarlton 103 LOGDEBUG("IpmDevice::startMedia() starting RTP streaming on device: " <<
561 : jtarlton 390 devName_ <<
562 :     " remote_rtp_audio: " << remote_rtp_audio <<
563 :     " remote_rtcp_audio: " << remote_rtcp_audio <<
564 :     " remote_rtp_video: " << remote_rtp_video <<
565 :     " remote_rtcp_video: " << remote_rtcp_video);
566 : jtarlton 41
567 :     if ( ipm_StartMedia(devHandle_, &mediaInfo, DATA_IP_TDM_BIDIRECTIONAL, EV_ASYNC) == -1 )
568 :     {
569 : jtarlton 131 LOGERROR("ipm_StartMedia failed for device: " << devName_ <<
570 : jtarlton 41 " with error: " << ATDV_ERRMSGP(devHandle_));
571 :     return false;
572 :     }
573 : jtarlton 131
574 :     state_ = IPM_STARTING;
575 : jtarlton 321 busy_ = true;
576 :    
577 : jtarlton 41 return true;
578 :     }
579 :    
580 :    
581 :     /*
582 : jtarlton 103 * Forward to event specific handler.
583 :     */
584 :     bool IpmDevice::processEvent( METAEVENT& metaevent )
585 :     {
586 :     switch ( metaevent.evttype )
587 :     {
588 :     case IPMEV_OPEN:
589 :     onOpen();
590 :     break;
591 :    
592 :     case IPMEV_EVENT_ENABLED:
593 : jtarlton 131 onEventEnabled();
594 : jtarlton 103 break;
595 :    
596 :     case IPMEV_GET_LOCAL_MEDIA_INFO:
597 : jtarlton 154 onLocalMediaInfo((IPM_MEDIA_INFO*)sr_getevtdatap());
598 : jtarlton 103 break;
599 :    
600 :     case IPMEV_STARTMEDIA:
601 :     onStartMedia();
602 :     break;
603 :    
604 :     case IPMEV_STOPPED:
605 : jtarlton 275 onStopped();
606 : jtarlton 103 break;
607 :    
608 : amartin 307 case IPMEV_LISTEN:
609 :     onListen();
610 :     break;
611 :    
612 :     case IPMEV_UNLISTEN:
613 :     onUnListen();
614 :     break;
615 :    
616 : jtarlton 103 case IPMEV_ERROR:
617 :     onError();
618 :     break;
619 :    
620 : jtarlton 390 case IPMEV_TELEPHONY_EVENT:
621 : jtarlton 394 onTelephonyEvent((IPM_TELEPHONY_INFO*)sr_getevtdatap());
622 : jtarlton 390 break;
623 :    
624 : jtarlton 103 case DMEV_GET_TX_PORT_INFO:
625 : jtarlton 154 onGetTxPortInfo((DM_PORT_INFO_LIST*)sr_getevtdatap());
626 : jtarlton 103 break;
627 :    
628 :     case DMEV_GET_RX_PORT_INFO:
629 : jtarlton 154 onGetRxPortInfo((DM_PORT_INFO_LIST*)sr_getevtdatap());
630 : jtarlton 103 break;
631 :    
632 :     case DMEV_GET_TX_PORT_INFO_FAIL:
633 :     onPortGetFail();
634 :     break;
635 :    
636 :     case DMEV_GET_RX_PORT_INFO_FAIL:
637 :     onPortGetFail();
638 :     break;
639 :    
640 :     case DMEV_PORT_CONNECT:
641 :     onPortConnect();
642 :     break;
643 :    
644 : jtarlton 390 case DMEV_PORT_CONNECT_FAIL:
645 : amartin 403 onPortConnectFail();
646 : jtarlton 390 break;
647 :    
648 :     case DMEV_PORT_DISCONNECT:
649 :     onPortDisconnect();
650 :     break;
651 :    
652 :     case DMEV_PORT_DISCONNECT_FAIL:
653 : jtarlton 394 LOGERROR("IpmDevice::onPortDisconnectFail() device: " << devName_);
654 : jtarlton 390 break;
655 :    
656 : jtarlton 103 default:
657 : jtarlton 131 LOGWARN("IpmDevice::processEvent() unhandled event: 0x" <<
658 :     std::hex << metaevent.evttype << " for device: " << devName_);
659 : jtarlton 103 return false;
660 :     }
661 :     return true;
662 :     }
663 :    
664 :    
665 :     /*
666 : jtarlton 64 * Handler for IPMEV_OPEN events.
667 : jtarlton 41 */
668 :     void IpmDevice::onOpen()
669 :     {
670 : jtarlton 218 LOGINFO("IpmDevice::onOpen() device: " << devName_);
671 : jtarlton 41
672 : jtarlton 417 other_ = 0;
673 : jtarlton 316
674 : jtarlton 162 /* Get and save the transmit timeslot on CTBus
675 :     */
676 : jtarlton 103 SC_TSINFO tsinfo;
677 : jtarlton 41 tsinfo.sc_numts = 1;
678 : jtarlton 162 tsinfo.sc_tsarrayp = getXmitTimeslotPtr();
679 : jtarlton 41 if ( ipm_GetXmitSlot(devHandle_, &tsinfo, EV_SYNC) == -1 )
680 :     {
681 : jtarlton 140 LOGERROR("ipm_GetXmitSlot() failed" );
682 : jtarlton 41 }
683 :    
684 : jtarlton 394 /* Enable dtmf events.
685 :     */
686 :     eIPM_EVENT event = EVT_RFC2833;
687 :     if ( ipm_EnableEvents(devHandle_, &event, 1, EV_ASYNC) < 0 )
688 :     {
689 :     LOGERROR("ipm_EnableEvent() failed on device:" << devHandle_);
690 :     }
691 :    
692 : jtarlton 162 /* Request port info
693 :     */
694 : jtarlton 103 if ( dev_GetTransmitPortInfo(devHandle_, this) == -1 )
695 : jtarlton 41 {
696 : jtarlton 140 LOGERROR("dev_GetTransmitPortInfo() failed");
697 : jtarlton 41 }
698 : jtarlton 103 if ( dev_GetReceivePortInfo(devHandle_, this) == -1 )
699 : jtarlton 41 {
700 : jtarlton 140 LOGERROR("dev_GetReceivePortInfo() failed");
701 : jtarlton 41 }
702 :    
703 : jtarlton 390 /* Request the local media information.
704 : jtarlton 103 */
705 : jtarlton 390 IPM_MEDIA_INFO media_info;
706 :     memset(&media_info, 0, sizeof(IPM_MEDIA_INFO));
707 :     media_info.unCount = 2;
708 :     media_info.MediaData[0].eMediaType = MEDIATYPE_AUDIO_LOCAL_RTP_INFO;
709 :     media_info.MediaData[1].eMediaType = MEDIATYPE_VIDEO_LOCAL_RTP_INFO;
710 : jtarlton 41
711 : jtarlton 390 if ( ipm_GetLocalMediaInfo(devHandle_, &media_info, EV_ASYNC) == -1 )
712 : jtarlton 103 {
713 : jtarlton 390 LOGERROR("ipm_GetLocalMediaInfo() failed for device: " <<
714 : jtarlton 103 devName_ << " with error: " << ATDV_LASTERR(devHandle_));
715 :     }
716 :    
717 :     /* update init state
718 :     */
719 : jtarlton 41 state_ = IPM_INITIALIZATION_START;
720 :     initStepsRemaining_--;
721 :     if ( initStepsRemaining_ == 0 )
722 :     {
723 :     state_ = IPM_IDLE;
724 :     }
725 :     }
726 :    
727 :    
728 :     /*
729 : jtarlton 64 * Handler for DMEV_GET_TX_PORT_INFO events.
730 : jtarlton 41 */
731 : jtarlton 390 void IpmDevice::onGetTxPortInfo( DM_PORT_INFO_LIST* portInfoList )
732 : jtarlton 41 {
733 : jtarlton 218 LOGINFO("IpmDevice::onGetTxPortInfo() device: " << devName_);
734 : jtarlton 41
735 : jtarlton 390 txPortInfoList_ = *portInfoList;
736 : jtarlton 413 printPortInfoList(&txPortInfoList_);
737 : jtarlton 41
738 : jtarlton 390 for ( unsigned int i = 0; i < txPortInfoList_.unCount; i++ )
739 :     {
740 :     switch ( txPortInfoList_.port_info[i].port_media_type )
741 :     {
742 :     case DM_PORT_MEDIA_TYPE_AUDIO:
743 : jtarlton 413 //memcpy(&audioPortTxInfo_, &txPortInfoList_.port_info[i], sizeof(DM_PORT_INFO));
744 :     audioPortTxInfo_ = txPortInfoList_.port_info[i];
745 : jtarlton 390 break;
746 :    
747 :     case DM_PORT_MEDIA_TYPE_VIDEO:
748 : jtarlton 413 //memcpy(&videoPortTxInfo_, &txPortInfoList_.port_info[i], sizeof(DM_PORT_INFO));
749 :     videoPortTxInfo_ = txPortInfoList_.port_info[i];
750 : jtarlton 390 break;
751 :    
752 :     default:
753 :     break;
754 :     }
755 :     }
756 :    
757 : jtarlton 41 initStepsRemaining_--;
758 :     if ( initStepsRemaining_ == 0 )
759 :     {
760 :     state_ = IPM_IDLE;
761 :     }
762 :     }
763 :    
764 :    
765 :     /*
766 : jtarlton 64 * Handler for DMEV_GET_RX_PORT_INFO events.
767 : jtarlton 41 */
768 : jtarlton 390 void IpmDevice::onGetRxPortInfo( DM_PORT_INFO_LIST* portInfoList )
769 : jtarlton 41 {
770 : jtarlton 218 LOGINFO("IpmDevice::onGetRxPortInfo() device: " << devName_);
771 : jtarlton 41
772 : jtarlton 390 rxPortInfoList_ = *portInfoList;
773 : jtarlton 413 printPortInfoList(&rxPortInfoList_);
774 : jtarlton 41
775 : jtarlton 390 for ( unsigned int i = 0; i < rxPortInfoList_.unCount; i++ )
776 :     {
777 :     switch ( rxPortInfoList_.port_info[i].port_media_type )
778 :     {
779 :     case DM_PORT_MEDIA_TYPE_AUDIO:
780 : jtarlton 413 //memcpy(&audioPortRxInfo_, &rxPortInfoList_.port_info[i], sizeof(DM_PORT_INFO));
781 :     audioPortRxInfo_ = rxPortInfoList_.port_info[i];
782 : jtarlton 390 break;
783 :    
784 :     case DM_PORT_MEDIA_TYPE_VIDEO:
785 : jtarlton 413 //memcpy(&videoPortRxInfo_, &rxPortInfoList_.port_info[i], sizeof(DM_PORT_INFO));
786 :     videoPortRxInfo_ = rxPortInfoList_.port_info[i];
787 : jtarlton 390 break;
788 :    
789 :     default:
790 :     break;
791 :     }
792 :     }
793 :    
794 : jtarlton 41 initStepsRemaining_--;
795 :     if ( initStepsRemaining_ == 0 )
796 :     {
797 :     state_ = IPM_IDLE;
798 :     }
799 :     }
800 :    
801 :    
802 :     /*
803 : jtarlton 64 * Handler for DMEV_GET_TX_PORT_INFO_FAIL and DMEV_GET_RX_PORT_INFO_FAIL
804 :     * events.
805 : jtarlton 41 */
806 :     void IpmDevice::onPortGetFail()
807 :     {
808 : jtarlton 218 LOGINFO("IpmDevice::onPortGetFail() device: " << devName_);
809 : jtarlton 103
810 : jtarlton 41 state_ = IPM_INVALID;
811 :     }
812 :    
813 :    
814 :     /*
815 : jtarlton 64 * Handler for IPMEV_ERROR events.
816 : jtarlton 41 */
817 :     void IpmDevice::onError()
818 :     {
819 :     LOGERROR("IpmDevice::onError() device: " << devName_ <<
820 :     " error: " << ATDV_ERRMSGP(devHandle_));
821 : jtarlton 103
822 : jtarlton 41 state_ = IPM_INVALID;
823 :     }
824 :    
825 :    
826 :     /*
827 : jtarlton 394 * Handler for IPMEV_TELEPHONY_EVENT events.
828 :     */
829 :     void IpmDevice::onTelephonyEvent( IPM_TELEPHONY_INFO* info )
830 :     {
831 :     LOGINFO("IpmDevice::processEvent() IPMEV_TELEPHONY_EVENT device: " << devName_ );
832 :     const std::string dtmf = "0123456789*#";
833 :    
834 :     switch ( info->eTelInfoType )
835 :     {
836 :     case TEL_INFOTYPE_EVENT:
837 :     {
838 :     int event_id = info->TelephonyInfo.TelEvtInfo.eTelephonyEventID;
839 : jtarlton 396 LOGDEBUG("TelephonyEventID: 0x" << std::hex << event_id);
840 : jtarlton 394 if ( event_id >= 0 && event_id <= 11 )
841 :     {
842 : jtarlton 395 channelMgr_.onDtmf(ipt_, dtmf.substr(event_id, 1), 100); /* fake duration */
843 : jtarlton 394 }
844 :     break;
845 :     }
846 :    
847 :     default:
848 :     break;
849 :    
850 :     }
851 :     }
852 :    
853 :    
854 :     /*
855 : jtarlton 390 * Handler for IPMEV_GET_LOCAL_MEDIA_INFO events.
856 :     */
857 :     void IpmDevice::onLocalMediaInfo( IPM_MEDIA_INFO* mediaInfo )
858 :     {
859 :     LOGINFO("IpmDevice::onLocalMediaInfo() device: " << devName_);
860 :     printMediaInfo(mediaInfo);
861 :    
862 :     for( unsigned int i = 0; i < mediaInfo->unCount; i++ )
863 :     {
864 :     switch ( mediaInfo->MediaData[i].eMediaType )
865 :     {
866 :     case MEDIATYPE_AUDIO_LOCAL_RTP_INFO:
867 :     localRtpAudio_.setAddress(mediaInfo->MediaData[i].mediaInfo.PortInfo.cIPAddress);
868 :     localRtpAudio_.setPort(mediaInfo->MediaData[i].mediaInfo.PortInfo.unPortId);
869 :     break;
870 :    
871 :     case MEDIATYPE_AUDIO_LOCAL_RTCP_INFO:
872 :     localRtcpAudio_.setAddress(mediaInfo->MediaData[i].mediaInfo.PortInfo.cIPAddress);
873 :     localRtcpAudio_.setPort(mediaInfo->MediaData[i].mediaInfo.PortInfo.unPortId);
874 :     break;
875 :    
876 :     case MEDIATYPE_VIDEO_LOCAL_RTP_INFO:
877 :     localRtpVideo_.setAddress(mediaInfo->MediaData[i].mediaInfo.PortInfo.cIPAddress);
878 :     localRtpVideo_.setPort(mediaInfo->MediaData[i].mediaInfo.PortInfo.unPortId);
879 :     break;
880 :    
881 :     case MEDIATYPE_VIDEO_LOCAL_RTCP_INFO:
882 :     localRtcpVideo_.setAddress(mediaInfo->MediaData[i].mediaInfo.PortInfo.cIPAddress);
883 :     localRtcpVideo_.setPort(mediaInfo->MediaData[i].mediaInfo.PortInfo.unPortId);
884 :     break;
885 :    
886 :     default:
887 :     break;
888 :     }
889 :     }
890 :     }
891 :    
892 :    
893 :     /*
894 : jtarlton 64 * Handler for IPMEV_EVENT_ENABLED events
895 : jtarlton 41 */
896 : jtarlton 64 void IpmDevice::onEventEnabled()
897 : jtarlton 41 {
898 : jtarlton 218 LOGINFO("IpmDevice::onEventEnabled() device: " << devName_);
899 : jtarlton 103
900 : jtarlton 41 initStepsRemaining_--;
901 :     if ( initStepsRemaining_ == 0 )
902 :     {
903 :     state_ = IPM_IDLE;
904 :     }
905 :     }
906 :    
907 :    
908 :     /*
909 : jtarlton 64 * Handler for IPMEV_STARTMEDIA events.
910 : jtarlton 41 */
911 :     void IpmDevice::onStartMedia()
912 :     {
913 : jtarlton 218 LOGINFO("IpmDevice::onStartMedia() device: " << devName_);
914 : jtarlton 321 state_ = IPM_STREAMING;
915 :     busy_ = false;
916 :     processPendingCommand();
917 : jtarlton 41 }
918 :    
919 :    
920 :     /*
921 : jtarlton 64 * Handler for IPMEV_STOPPED events.
922 : jtarlton 41 */
923 :     void IpmDevice::onStopped()
924 :     {
925 : jtarlton 218 LOGINFO("IpmDevice::onStopped() device: " << devName_);
926 : jtarlton 41 state_ = IPM_IDLE;
927 : jtarlton 321 busy_ = false;
928 :     processPendingCommand();
929 : jtarlton 41 }
930 :    
931 :    
932 :     /*
933 : jtarlton 390 * Handler for IPMEV_LISTEN events.
934 : jtarlton 41 */
935 : jtarlton 390 void IpmDevice::onListen()
936 : jtarlton 41 {
937 : jtarlton 390 LOGINFO("IpmDevice::onListen() device: " << devName_);
938 :     busy_ = false;
939 :     processPendingCommand();
940 :     }
941 : jtarlton 103
942 : jtarlton 390
943 :     /*
944 :     * Handler for IPMEV__UNLISTEN events.
945 :     */
946 :     void IpmDevice::onUnListen()
947 :     {
948 :     LOGINFO("IpmDevice::onUnListen() device: " << devName_);
949 :     busy_ = false;
950 :     processPendingCommand();
951 : jtarlton 41 }
952 :    
953 : jtarlton 311
954 : amartin 307 /*
955 : jtarlton 390 * Handler for DMEV_PORT_CONNECT events.
956 : amartin 307 */
957 : jtarlton 390 void IpmDevice::onPortConnect()
958 : amartin 307 {
959 : jtarlton 390 LOGINFO("IpmDevice::onPortConnect() device: " << devName_);
960 : jtarlton 321 busy_ = false;
961 :     processPendingCommand();
962 : amartin 307 }
963 : jtarlton 41
964 : amartin 403 /*
965 :     * Handler for DMEV_PORT_CONNECT_FAIL events.
966 :     */
967 :     void IpmDevice::onPortConnectFail()
968 :     {
969 :     LOGERROR("IpmDevice::onPortConnectFail() device: " << devName_);
970 :     busy_ = false;
971 :     processPendingCommand();
972 :     }
973 : jtarlton 311
974 : amartin 307 /*
975 : jtarlton 390 * Handler for DMEV_PORT_DISCONNECT events.
976 : amartin 307 */
977 : jtarlton 390 void IpmDevice::onPortDisconnect()
978 : amartin 307 {
979 : jtarlton 390 LOGINFO("IpmDevice::onPortDisconnect() device: " << devName_);
980 : jtarlton 321 busy_ = false;
981 :     processPendingCommand();
982 : amartin 307 }
983 : jtarlton 103
984 : jtarlton 311
985 : jtarlton 103 /*
986 : jtarlton 413 * print all structs in the list
987 : jtarlton 103 */
988 : jtarlton 413 void IpmDevice::printPortInfoList( DM_PORT_INFO_LIST* portInfoList ) const
989 : jtarlton 103 {
990 : jtarlton 413 for ( unsigned int i = 0; i < portInfoList->unCount; i++ )
991 :     {
992 :     printPortInfo(&portInfoList->port_info[i]);
993 :     }
994 :     }
995 :    
996 :     /*
997 :     * print the struct
998 :     */
999 :     void IpmDevice::printPortInfo( DM_PORT_INFO* portInfo ) const
1000 :     {
1001 : jtarlton 103 std::stringstream ss;
1002 :    
1003 : jtarlton 413 ss << "MediaType: " << portInfo->port_media_type << " ";
1004 :     if ( portInfo->port_media_type == DM_PORT_MEDIA_TYPE_AUDIO )
1005 : jtarlton 103 {
1006 : jtarlton 413 ss << "Audio";
1007 : jtarlton 103 }
1008 : jtarlton 413 else if ( portInfo->port_media_type == DM_PORT_MEDIA_TYPE_VIDEO )
1009 :     {
1010 :     ss << "Video";
1011 :     }
1012 :     else if ( portInfo->port_media_type == DM_PORT_MEDIA_TYPE_NBUP )
1013 :     {
1014 :     ss << "NBUP";
1015 :     }
1016 :     else
1017 :     {
1018 :     ss << portInfo->port_media_type;
1019 :     }
1020 :     ss << " DeviceID: ";
1021 :     for ( size_t i = 0; i < sizeof(portInfo->device_ID); i++ )
1022 :     {
1023 :     ss << std::setw(2) << std::setfill('0') << std::hex << (unsigned int)portInfo->device_ID[i];
1024 :     }
1025 :     ss << " PortID: ";
1026 :     for ( size_t i = 0; i < sizeof(portInfo->port_ID); i++ )
1027 :     {
1028 :     ss << std::setw(2) << std::setfill('0') << std::hex << (unsigned int) portInfo->port_ID[i];
1029 :     }
1030 : jtarlton 103 LOGDEBUG(ss.str());
1031 :     }
1032 :    
1033 :    
1034 :     /*
1035 :     * Debug aid
1036 :     */
1037 :     void IpmDevice::printMediaInfo( IPM_MEDIA_INFO* mediaInfo ) const
1038 :     {
1039 :     std::stringstream ss;
1040 :     for ( unsigned int i = 0; i < mediaInfo->unCount; i++ )
1041 :     {
1042 :     ss << "MediaType = ";
1043 :     switch ( mediaInfo->MediaData[i].eMediaType )
1044 :     {
1045 :     case MEDIATYPE_VIDEO_LOCAL_RTP_INFO:
1046 :     ss << "MEDIATYPE_VIDEO_LOCAL_RTP_INFO";
1047 :     break;
1048 :    
1049 :     case MEDIATYPE_VIDEO_LOCAL_RTCP_INFO:
1050 :     ss << "MEDIATYPE_VIDEO_LOCAL_RTCP_INFO";
1051 :     break;
1052 :    
1053 :     case MEDIATYPE_AUDIO_LOCAL_RTP_INFO:
1054 :     ss << "MEDIATYPE_AUDIO_LOCAL_RTP_INFO";
1055 :     break;
1056 :    
1057 :     case MEDIATYPE_AUDIO_LOCAL_RTCP_INFO:
1058 :     ss << "MEDIATYPE_AUDIO_LOCAL_RTCP_INFO";
1059 :     break;
1060 :    
1061 :     case MEDIATYPE_NBUP_LOCAL_RTP_INFO:
1062 :     ss << "MEDIATYPE_NBUP_LOCAL_RTP_INFO";
1063 :     break;
1064 :    
1065 :     default:
1066 :     ss << "MEDIATYPE_??? " << mediaInfo->MediaData[i].eMediaType;
1067 :     break;
1068 :     }
1069 :     ss << " IP = " << mediaInfo->MediaData[i].mediaInfo.PortInfo.cIPAddress;
1070 :     ss << " Port = " << mediaInfo->MediaData[i].mediaInfo.PortInfo.unPortId;
1071 :     ss << std::endl;
1072 :     }
1073 :     LOGDEBUG(ss.str());
1074 :     }
1075 :    
1076 :    
1077 : jtarlton 390 /*
1078 :     * load local information into the sdp
1079 :     * XXX 'response' sdpS should return all 'm' (media) headers that were 'offered'
1080 :     * with unused/unsupported ones having their port set to 0.
1081 :     */
1082 :     void IpmDevice::buildLocalSdp( sdpSessionDescription& sdp ) const
1083 :     {
1084 :     /* get here so it can be used for the origin address */
1085 :     IpInfo audio_media;
1086 :     getLocalMediaInfo(MEDIATYPE_AUDIO_LOCAL_RTP_INFO, audio_media);
1087 :    
1088 :     sdp.version()->setVersion("0");
1089 :    
1090 :     sdp.origin()->setUserName("DiaStarServer");
1091 :     sdp.origin()->setNetworkType("IN");
1092 :     sdp.origin()->setAddressType("IP4");
1093 :     sdp.origin()->setAddress(audio_media.getAddress().c_str());
1094 :    
1095 :     time_t t;
1096 :     time(&t);
1097 :     std::stringstream sessionIdandVersion;
1098 :     sessionIdandVersion << t;
1099 :     sdp.origin()->setSessionId(sessionIdandVersion.str().c_str());
1100 :     sdp.origin()->setVersion(sessionIdandVersion.str().c_str());
1101 :    
1102 :     sdp.sessionName()->setName("DiaStarServer");
1103 :    
1104 :     sdpTimeDescription* timeDescription = sdp.timeDescriptionList()->addItem();
1105 :     timeDescription->time()->setStart(0);
1106 :     timeDescription->time()->setStop(0);
1107 :    
1108 :     /* media
1109 :     */
1110 :     sdpMediaDescriptionList* mdList = sdp.mediaDescriptionList();
1111 :     mdList->clear();
1112 :    
1113 :     /* audio
1114 :     */
1115 :     sdpMediaDescription* audioMD = mdList->addItem();
1116 :     audioMD->connection()->setNetworkType("IN");
1117 :     audioMD->connection()->setAddressType("IP4");
1118 :     audioMD->connection()->setAddress(audio_media.getAddress().c_str());
1119 :    
1120 :     sdpMedia* audioMedia = audioMD->media();
1121 :     audioMedia->setMedia("audio");
1122 :     audioMedia->setPort(audio_media.getPort());
1123 :     audioMedia->setTransport("RTP/AVP");
1124 :     audioMedia->setNumPorts(1);
1125 :     audioMedia->addFormat("0"); /* PCMU/8000 */
1126 :     audioMedia->addFormat("101"); /* telephone-event/8000 */
1127 :    
1128 :     sdpAttributeList* audioAttrList = audioMD->attributeList();
1129 :     sdpAttribute* audioAttribute = audioAttrList->addItem();
1130 :     audioAttribute->setProperty("rtpmap");
1131 :     audioAttribute->setPropertyValue("0 PCMU/8000");
1132 :    
1133 :     audioAttribute = audioAttrList->addItem();
1134 :     audioAttribute->setProperty("rtpmap");
1135 :     audioAttribute->setPropertyValue("101 telephone-event/8000");
1136 :    
1137 :     audioAttribute = audioAttrList->addItem();
1138 :     audioAttribute->setProperty("sendrecv");
1139 :     audioAttribute->setPropertyValue("");
1140 :    
1141 :     /* video
1142 :     */
1143 :     IpInfo video_media;
1144 :     if ( getLocalMediaInfo(MEDIATYPE_VIDEO_LOCAL_RTP_INFO, video_media) )
1145 :     {
1146 :     sdpMediaDescription* videoMD = mdList->addItem();
1147 :     videoMD->connection()->setNetworkType("IN");
1148 :     videoMD->connection()->setAddressType("IP4");
1149 :     videoMD->connection()->setAddress(video_media.getAddress().c_str());
1150 :    
1151 :     sdpMedia* videoMedia = videoMD->media();
1152 :     videoMedia->setMedia("video");
1153 :     videoMedia->setPort(video_media.getPort());
1154 :     videoMedia->setTransport("RTP/AVP");
1155 :     videoMedia->setNumPorts(1);
1156 :     videoMedia->addFormat("34"); /* H263/90000 */
1157 :    
1158 :     sdpAttributeList* videoAttrList = videoMD->attributeList();
1159 :     sdpAttribute* videoAttribute = videoAttrList->addItem();
1160 :     videoAttribute->setProperty("rtpmap");
1161 :     videoAttribute->setPropertyValue("34 H263/90000");
1162 :    
1163 :     videoAttribute = videoAttrList->addItem();
1164 :     videoAttribute->setProperty("fmtp");
1165 : jtarlton 412 videoAttribute->setPropertyValue("34 CIF=2");
1166 : jtarlton 390
1167 :     videoAttribute = videoAttrList->addItem();
1168 :     videoAttribute->setProperty("sendrecv");
1169 :     videoAttribute->setPropertyValue("");
1170 :    
1171 :     videoMD->bandwidth()->setModifier("AS");
1172 :     videoMD->bandwidth()->setBandwidthValue("90");
1173 :     }
1174 :     }
1175 :    
1176 :    
1177 :     /*
1178 :     * Set the dtmf signalling mode.
1179 :     */
1180 :     void IpmDevice::setDtmfMode( DtmfMode dtmf_mode )
1181 :     {
1182 :     IPM_PARM_INFO parmInfo;
1183 :    
1184 :     switch ( dtmf_mode )
1185 :     {
1186 :     case DTMF_RFC2833:
1187 :     {
1188 :     eIPM_DTMFXFERMODE value = DTMFXFERMODE_RFC2833;
1189 :     parmInfo.eParm = PARMCH_DTMFXFERMODE;
1190 :     parmInfo.pvParmValue = &value;
1191 :     LOGINFO("IpmDevice::setDtmfMode() using RFC2833");
1192 :     if ( ipm_SetParm(devHandle_, &parmInfo, EV_SYNC) < 0 )
1193 :     {
1194 :     LOGERROR("Error in ipm_SetParm()\n");
1195 :     }
1196 :    
1197 :     int rfc2833PayloadType = 101;
1198 :    
1199 :     parmInfo.eParm = PARMCH_RFC2833EVT_TX_PLT;
1200 :     parmInfo.pvParmValue = &rfc2833PayloadType;
1201 :     if ( ipm_SetParm(devHandle_, &parmInfo, EV_SYNC) < 0 )
1202 :     {
1203 :     LOGERROR("Error in ipm_SetParm()\n");
1204 :     }
1205 :    
1206 :     parmInfo.eParm = PARMCH_RFC2833EVT_RX_PLT;
1207 :     parmInfo.pvParmValue = &rfc2833PayloadType;
1208 :     if ( ipm_SetParm(devHandle_, &parmInfo, EV_SYNC) < 0 )
1209 :     {
1210 :     LOGERROR("Error in ipm_SetParm()\n");
1211 :     }
1212 :     }
1213 :     break;
1214 :    
1215 :     case DTMF_INBAND:
1216 :     {
1217 :     eIPM_DTMFXFERMODE value = DTMFXFERMODE_INBAND;
1218 :     parmInfo.eParm = PARMCH_DTMFXFERMODE;
1219 :     parmInfo.pvParmValue = &value;
1220 :    
1221 :     LOGINFO("IpmDevice::setDtmfMode() using inband audio");
1222 :     if ( ipm_SetParm(devHandle_, &parmInfo, EV_SYNC) < 0 )
1223 :     {
1224 :     LOGERROR("Error in ipm_SetParm()\n");
1225 :     }
1226 :     }
1227 :     break;
1228 :     }
1229 :     }
1230 :    
1231 :    
1232 : jtarlton 41 /* vim:ts=4:set nu:
1233 :     * EOF
1234 :     */
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.8