[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 87 - (view) (download)

1 : jtarlton 41 /*
2 :     * This file is part of the Dialogic Woomera Server project.
3 :     *
4 :     *
5 :     * Copyright (C) 2009 Dialogic Corporation
6 :     * All Rights Reserved
7 :     *
8 :     */
9 :    
10 :     /*!
11 : jtarlton 45 * \file ipmdevice.cxx
12 : jtarlton 59 * \brief Dialogic IPM device
13 : jtarlton 41 * \author Antony Martin <antony.martin@dialogic.com>
14 : jtarlton 87 * \version 2-APR-2009
15 : jtarlton 41 */
16 :    
17 : jtarlton 87 /*------------------------------ Dependencies --------------------------------*/
18 : jtarlton 41
19 :     #include "logger.h"
20 :     #include "ipmdevice.h"
21 :    
22 : jtarlton 87 /*----------------------------------------------------------------------------*/
23 : jtarlton 41
24 :     /*
25 :     * ctor
26 :     */
27 : jtarlton 87 IpmDevice::IpmDevice( const std::string& name,
28 :     DialogicChannelManager& channelMgr )
29 :     : DialogicDevice(name, channelMgr)
30 : jtarlton 41 {
31 :     memset(&mediaInfo_, 0, sizeof(IPM_MEDIA_INFO));
32 :    
33 :     /* Number of steps in the initialisation sequence, decremented by event
34 :     * handlers. When zero state is changed to IDLE.
35 : jtarlton 64 *
36 :     * IPMEV_OPEN,
37 :     * DMEV_GET_RX_PORT_INFO,
38 :     * DMEV_GET_TX_PORT_INFO
39 : jtarlton 41 */
40 :     initStepsRemaining_ = 3;
41 :     }
42 :    
43 :    
44 :     /*
45 :     * dtor
46 :     */
47 :     IpmDevice::~IpmDevice()
48 :     {
49 :     }
50 :    
51 :    
52 :     /*
53 : jtarlton 64 * Open the device.
54 : jtarlton 41 */
55 : jtarlton 45 bool IpmDevice::open()
56 : jtarlton 41 {
57 : jtarlton 45 LOGDEBUG("IpmDevice::open() device: " << devName_);
58 :    
59 : jtarlton 41 devHandle_ = ipm_Open(devName_.c_str(), NULL, EV_ASYNC);
60 :     if ( devHandle_ < 0 )
61 :     {
62 :     LOGERROR("ipm_Open() failed");
63 :     return false;
64 :     }
65 :     state_ = IPM_OPENING;
66 :     return true;
67 :     }
68 :    
69 :    
70 :     /*
71 : jtarlton 64 * Close the device
72 : jtarlton 41 */
73 : jtarlton 45 bool IpmDevice::close()
74 : jtarlton 41 {
75 : jtarlton 45 LOGDEBUG("IpmDevice::close() device: " << devName_);
76 :    
77 : jtarlton 41 if ( devHandle_ > 0 )
78 :     {
79 :     if ( ipm_Close(devHandle_, NULL) < 0 )
80 :     {
81 :     LOGERROR ("ipm_Close() failed");
82 :     return false;
83 :     }
84 : jtarlton 64 devHandle_ = 0;
85 : jtarlton 41 }
86 :     return true;
87 :     }
88 :    
89 :    
90 :    
91 :     /*
92 : jtarlton 64 * Connect media.
93 : jtarlton 41 */
94 : jtarlton 45 bool IpmDevice::listen( DialogicDevice* other )
95 : jtarlton 41 {
96 : jtarlton 45 LOGDEBUG("IpmDevice::listen() device: " << devName_ <<
97 : jtarlton 50 " other: " << other->getDeviceName());
98 : jtarlton 41
99 :     SC_TSINFO tsinfo;
100 :    
101 :     tsinfo.sc_numts = 1;
102 : jtarlton 50 tsinfo.sc_tsarrayp = other->getTimeslot();
103 : jtarlton 41
104 :     if ( ipm_Listen(devHandle_, &tsinfo, EV_SYNC) == -1 )
105 :     {
106 :     LOGERROR("ipm_Listen() failed on device: " << devName_ <<
107 :     " " << ATDV_ERRMSGP(devHandle_));
108 :     return false;
109 :     }
110 :     return true;
111 :     }
112 :    
113 :    
114 :     /*
115 : jtarlton 64 * Disconnect media.
116 : jtarlton 41 */
117 : jtarlton 45 bool IpmDevice::unListen()
118 : jtarlton 41 {
119 : jtarlton 45 LOGDEBUG("IpmDevice::unListen() device: " << devName_);
120 : jtarlton 41
121 :     if (ipm_UnListen(devHandle_, EV_SYNC) == -1)
122 :     {
123 :     LOGERROR("ipm_UnListen() failed on device: " << devName_ <<
124 :     " " << ATDV_ERRMSGP(devHandle_));
125 :     return false;
126 :     }
127 :     return true;
128 :     }
129 :    
130 :    
131 :     /*
132 : jtarlton 64 * Forward to event specific handler.
133 : jtarlton 41 */
134 : jtarlton 45 bool IpmDevice::processEvent( METAEVENT& metaevent )
135 : jtarlton 41 {
136 :     switch ( metaevent.evttype )
137 :     {
138 :     case IPMEV_OPEN:
139 :     LOGDEBUG("Received IPMEV_OPEN for device: " << devName_);
140 :     onOpen();
141 :     break;
142 :    
143 :     case IPMEV_EVENT_ENABLED:
144 :     LOGDEBUG("Received IPMEV_EVENT_ENABLED for device: " << devName_);
145 : jtarlton 64 onEventEnabled ();
146 : jtarlton 41 break;
147 :    
148 :     case IPMEV_GET_LOCAL_MEDIA_INFO:
149 :     LOGDEBUG("Received IPMEV_GET_LOCAL_MEDIA_INFO for device: " << devName_);
150 :     decodeLocalMediaInfo((IPM_MEDIA_INFO*)metaevent.evtdatap);
151 :     break;
152 :    
153 :     case IPMEV_STARTMEDIA:
154 :     LOGDEBUG("Received IPMEV_STARTMEDIA for device: " << devName_);
155 :     onStartMedia();
156 :     break;
157 :    
158 :     case IPMEV_STOPPED:
159 :     LOGDEBUG("Received IPMEV_STOPPED for device: " << devName_);
160 :     onStopped ();
161 :     break;
162 :    
163 :     case IPMEV_ERROR:
164 :     LOGERROR("Received IPMEV_ERROR for device: " << devName_);
165 :     onError();
166 :     break;
167 :    
168 :     case DMEV_GET_TX_PORT_INFO:
169 :     LOGDEBUG("Received DMEV_GET_TX_PORT_INFO for device: " << devName_);
170 :     onGetTxPortInfo((DM_PORT_INFO_LIST*)metaevent.evtdatap);
171 :     break;
172 :    
173 :     case DMEV_GET_RX_PORT_INFO:
174 :     LOGDEBUG("Received DMEV_GET_RX_PORT_INFO for device: " << devName_);
175 :     onGetRxPortInfo((DM_PORT_INFO_LIST*)metaevent.evtdatap);
176 :     break;
177 :    
178 :     case DMEV_GET_TX_PORT_INFO_FAIL:
179 :     LOGERROR("Received DMEV_GET_TX_PORT_INFO_FAIL for device: " << devName_);
180 :     onPortGetFail();
181 :     break;
182 :    
183 :     case DMEV_GET_RX_PORT_INFO_FAIL:
184 :     LOGERROR("Received DMEV_GET_RX_PORT_INFO_FAIL for device: " << devName_);
185 :     onPortGetFail();
186 :     break;
187 :    
188 :     case DMEV_PORT_CONNECT:
189 :     LOGDEBUG("Received DMEV_PORT_CONNECT for device: " << devName_);
190 :     onPortConnect();
191 :     break;
192 :    
193 :     default:
194 :     LOGERROR("Received unhandled event: 0x" << std::hex << metaevent.evttype << " for device: " << devName_);
195 :     return false;
196 :     }
197 :     return true;
198 :     }
199 :    
200 :    
201 :     /*
202 : jtarlton 64 * Request local media information and store in mediaInfo_
203 : jtarlton 41 */
204 :     void IpmDevice::getLocalMediaInfo()
205 :     {
206 :     LOGDEBUG ("Calling ipm_GetLocalMediaInfo for device: " << devName_);
207 :    
208 :     mediaInfo_.unCount = 3;
209 :     mediaInfo_.MediaData[0].eMediaType = MEDIATYPE_AUDIO_LOCAL_RTP_INFO;
210 :     mediaInfo_.MediaData[1].eMediaType = MEDIATYPE_VIDEO_LOCAL_RTP_INFO;
211 :     mediaInfo_.MediaData[2].eMediaType = MEDIATYPE_NBUP_LOCAL_RTP_INFO;
212 :    
213 :     if ( ipm_GetLocalMediaInfo (devHandle_, &mediaInfo_, EV_ASYNC) == -1 )
214 :     {
215 :     LOGERROR("ipm_GetLocalMediaInfo failed for device: " <<
216 :     devName_ << " with error = " << ATDV_LASTERR(devHandle_));
217 :     }
218 :     }
219 :    
220 :    
221 :     /*
222 : jtarlton 64 * Search mediaInfo_ for the information.
223 : jtarlton 41 */
224 :     void IpmDevice::getAddrInfo( eIPM_MEDIA_TYPE type,
225 : jtarlton 50 std::string& ipAddr,
226 : jtarlton 41 unsigned short& port ) const
227 :     {
228 :     for ( unsigned int i = 0; i < mediaInfo_.unCount; i++ )
229 :     {
230 :     if ( type == mediaInfo_.MediaData[i].eMediaType )
231 :     {
232 : jtarlton 50 ipAddr = mediaInfo_.MediaData[i].mediaInfo.PortInfo.cIPAddress;
233 : jtarlton 41 port = mediaInfo_.MediaData[i].mediaInfo.PortInfo.unPortId;
234 :     break;
235 :     }
236 :     }
237 :     }
238 :    
239 :    
240 :     /*
241 : jtarlton 64 * Debug aid
242 : jtarlton 41 */
243 :     void IpmDevice::decodeLocalMediaInfo( IPM_MEDIA_INFO* mediaInfo )
244 :     {
245 :     memcpy(&mediaInfo_, mediaInfo, sizeof(IPM_MEDIA_INFO));
246 :    
247 :     std::stringstream ss;
248 :     for ( unsigned int i = 0; i < mediaInfo->unCount; i++ )
249 :     {
250 :     ss << "MediaType = ";
251 :     switch ( mediaInfo->MediaData[i].eMediaType )
252 :     {
253 :     case MEDIATYPE_VIDEO_LOCAL_RTP_INFO:
254 :     ss << "MEDIATYPE_VIDEO_LOCAL_RTP_INFO";
255 :     break;
256 :    
257 :     case MEDIATYPE_VIDEO_LOCAL_RTCP_INFO:
258 :     ss << "MEDIATYPE_VIDEO_LOCAL_RTCP_INFO";
259 :     break;
260 :    
261 :     case MEDIATYPE_AUDIO_LOCAL_RTP_INFO:
262 :     ss << "MEDIATYPE_AUDIO_LOCAL_RTP_INFO";
263 :     break;
264 :    
265 :     case MEDIATYPE_AUDIO_LOCAL_RTCP_INFO:
266 :     ss << "MEDIATYPE_AUDIO_LOCAL_RTCP_INFO";
267 :     break;
268 :    
269 :     case MEDIATYPE_NBUP_LOCAL_RTP_INFO:
270 :     ss << "MEDIATYPE_NBUP_LOCAL_RTP_INFO";
271 :     break;
272 :    
273 :     default:
274 :     ss << "MEDIATYPE_??? " << mediaInfo->MediaData[i].eMediaType;
275 :     break;
276 :     }
277 :     ss << " PortId = " << mediaInfo->MediaData[i].mediaInfo.PortInfo.unPortId;
278 :     ss << " IP = " << mediaInfo->MediaData[i].mediaInfo.PortInfo.cIPAddress;
279 :     ss << std::endl;
280 :     }
281 :     LOGDEBUG(ss.str());
282 :     }
283 :    
284 :    
285 :     /*
286 :     * Stop the IPM streaming and/or digit reception
287 :     */
288 :     bool IpmDevice::stop( eIPM_STOP_OPERATION operation )
289 :     {
290 :     if ( state_ == IPM_IDLE )
291 :     {
292 :     return false;
293 :     }
294 :    
295 :     if ( ipm_Stop(devHandle_, operation, EV_ASYNC) == -1 )
296 :     {
297 :     LOGERROR("ipm_Stop() on device: " << devName_ << " failed: " <<
298 :     ATDV_LASTERR(devHandle_));
299 :     return false;
300 :     }
301 :     state_ = IPM_STOPPING;
302 :     return true;
303 :     }
304 :    
305 :    
306 :     /*
307 :     * Start RTP streaming to peer.
308 :     */
309 :     bool IpmDevice::startMedia()
310 :     {
311 :     return startMedia(peerRtpIP_, peerRtcpIP_, peerRtpPort_, peerRtcpPort_);
312 :     }
313 :    
314 :    
315 :     /*
316 :     * Start RTP streaming using G.711 and local/remote port information.
317 :     * Will use G.711 - choose ALaw Ulaw from woomera msg?
318 :     * MU hardwired in for now.
319 :     */
320 :     bool IpmDevice::startMedia( const std::string& peerRtpIP,
321 :     const std::string& peerRtcpIP,
322 :     unsigned short peerRtpPort,
323 :     unsigned short peerRtcpPort )
324 :     {
325 :     if ( state_ != IPM_IDLE )
326 :     {
327 :     LOGERROR("IpmDevice::startMedia() device: " << devName_ << " is not in IDLE state");
328 :     return 1;
329 :     }
330 :    
331 :     IPM_MEDIA_INFO mediaInfo;
332 :     memset(&mediaInfo, 0, sizeof(IPM_MEDIA_INFO));
333 :    
334 :     int mediaCnt = 0;
335 :    
336 :     /* remote audio
337 :     */
338 :     mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_AUDIO_REMOTE_CODER_INFO;
339 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eCoderType = CODER_TYPE_G711ULAW64K;
340 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eFrameSize = CODER_FRAMESIZE_20;
341 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unFramesPerPkt = 1;
342 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eVadEnable = CODER_VAD_ENABLE;
343 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unCoderPayloadType = 0;
344 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unRedPayloadType = 0;
345 :     mediaCnt++;
346 :    
347 :     /* local audio
348 :     */
349 :     mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_AUDIO_LOCAL_CODER_INFO;
350 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eCoderType = CODER_TYPE_G711ULAW64K;
351 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eFrameSize = CODER_FRAMESIZE_20;
352 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unFramesPerPkt = 1;
353 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.eVadEnable = CODER_VAD_ENABLE;
354 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unCoderPayloadType = 0;
355 :     mediaInfo.MediaData[mediaCnt].mediaInfo.CoderInfo.unRedPayloadType = 0;
356 :     mediaCnt++;
357 :    
358 :     /* remote audio ports and IP addresses
359 :     */
360 :     mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_AUDIO_REMOTE_RTP_INFO;
361 :     strcpy(mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.cIPAddress, peerRtpIP.c_str());
362 :     mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.unPortId = peerRtpPort;
363 :     mediaCnt++;
364 :    
365 :     mediaInfo.MediaData[mediaCnt].eMediaType = MEDIATYPE_AUDIO_REMOTE_RTCP_INFO;
366 :     strcpy(mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.cIPAddress, peerRtcpIP.c_str());
367 :     mediaInfo.MediaData[mediaCnt].mediaInfo.PortInfo.unPortId = peerRtcpPort;
368 :     mediaCnt++;
369 :    
370 :     mediaInfo.unCount = mediaCnt;
371 :    
372 :     LOGDEBUG("IpmDevice::startMedia() starting RTP streaming on device: " << devName_ <<
373 :     " to: " << peerRtpIP << " using port: " << peerRtpPort);
374 :    
375 :     if ( ipm_StartMedia(devHandle_, &mediaInfo, DATA_IP_TDM_BIDIRECTIONAL, EV_ASYNC) == -1 )
376 :     {
377 :     LOGERROR("ipm_StartMediaInfo failed for device: " << devName_ <<
378 :     " with error: " << ATDV_ERRMSGP(devHandle_));
379 :     return false;
380 :     }
381 :     else
382 :     {
383 :     state_ = IPM_STARTING;
384 :     }
385 :     return true;
386 :     }
387 :    
388 :    
389 :     /*
390 : jtarlton 64 * Handler for IPMEV_OPEN events.
391 : jtarlton 41 */
392 :     void IpmDevice::onOpen()
393 :     {
394 :     SC_TSINFO tsinfo;
395 :    
396 :     tsinfo.sc_numts = 1;
397 : jtarlton 50 tsinfo.sc_tsarrayp = getTimeslot();
398 : jtarlton 41 if ( ipm_GetXmitSlot(devHandle_, &tsinfo, EV_SYNC) == -1 )
399 :     {
400 :     LOGERROR("ipm_GetXmitSlot() failed on " << devName_);
401 :     }
402 :    
403 :     int rc = dev_GetTransmitPortInfo(devHandle_, this);
404 :     if ( rc == -1 )
405 :     {
406 :     LOGERROR("dev_GetTransmitPortInfo() failed on " << devName_);
407 :     }
408 :     rc = dev_GetReceivePortInfo(devHandle_, this);
409 :     if ( rc == -1 )
410 :     {
411 :     LOGERROR("dev_GetReceivePortInfo() failed on " << devName_);
412 :     }
413 :    
414 :     getLocalMediaInfo();
415 :    
416 :     state_ = IPM_INITIALIZATION_START;
417 :     initStepsRemaining_--;
418 :     if ( initStepsRemaining_ == 0 )
419 :     {
420 :     state_ = IPM_IDLE;
421 :     }
422 :     }
423 :    
424 :    
425 :     /*
426 : jtarlton 64 * Handler for DMEV_GET_TX_PORT_INFO events.
427 : jtarlton 41 */
428 :     void IpmDevice::onGetTxPortInfo( DM_PORT_INFO_LIST* portInfo )
429 :     {
430 :     LOGDEBUG("onGetTxPortInfo() device: " << devName_);
431 :    
432 :     memcpy(&txPortInfoList_, sr_getevtdatap(), sr_getevtlen());
433 :    
434 :     printPortInfo(portInfo);
435 :    
436 :     initStepsRemaining_--;
437 :     if ( initStepsRemaining_ == 0 )
438 :     {
439 :     state_ = IPM_IDLE;
440 :     }
441 :     }
442 :    
443 :    
444 :     /*
445 : jtarlton 64 * Handler for DMEV_GET_RX_PORT_INFO events.
446 : jtarlton 41 */
447 :     void IpmDevice::onGetRxPortInfo( DM_PORT_INFO_LIST* portInfo )
448 :     {
449 :     LOGDEBUG("onGetRxPortInfo() device: " << devName_);
450 :    
451 :     memcpy(&rxPortInfoList_, sr_getevtdatap(), sr_getevtlen());
452 :    
453 :     printPortInfo(portInfo);
454 :    
455 :     initStepsRemaining_--;
456 :     if ( initStepsRemaining_ == 0 )
457 :     {
458 :     state_ = IPM_IDLE;
459 :     }
460 :     }
461 :    
462 :    
463 :     /*
464 : jtarlton 64 * Debug aid.
465 : jtarlton 41 */
466 :     void IpmDevice::printPortInfo( DM_PORT_INFO_LIST* portInfo ) const
467 :     {
468 :     std::stringstream ss;
469 :    
470 :     for ( unsigned int i = 0; i < portInfo->unCount; i++ )
471 :     {
472 :     DM_PORT_INFO& info = portInfo->port_info[i];
473 :     ss << "Port: " << i << " MediaType: " << info.port_media_type;
474 :     if ( info.port_media_type == DM_PORT_MEDIA_TYPE_AUDIO )
475 :     {
476 :     ss << "Audio";
477 :     }
478 :     else if ( info.port_media_type == DM_PORT_MEDIA_TYPE_VIDEO )
479 :     {
480 :     ss << "Video";
481 :     }
482 :     else if ( info.port_media_type == DM_PORT_MEDIA_TYPE_NBUP )
483 :     {
484 :     ss << "NBUP";
485 :     }
486 :     else
487 :     {
488 :     ss << info.port_media_type;
489 :     }
490 :     }
491 :     LOGDEBUG(ss.str());
492 :     }
493 :    
494 :    
495 :     /*
496 : jtarlton 64 * Handler for DMEV_PORT_CONNECT events.
497 : jtarlton 41 */
498 :     void IpmDevice::onPortConnect()
499 :     {
500 :     LOGDEBUG("Ipm::onPortConnect() device: " << devName_);
501 :     }
502 :    
503 :    
504 :     /*
505 : jtarlton 64 * Handler for DMEV_GET_TX_PORT_INFO_FAIL and DMEV_GET_RX_PORT_INFO_FAIL
506 :     * events.
507 : jtarlton 41 */
508 :     void IpmDevice::onPortGetFail()
509 :     {
510 :     LOGERROR("IpmDevice::onPortGetFail() device: " << devName_);
511 :     state_ = IPM_INVALID;
512 :     }
513 :    
514 :    
515 :     /*
516 : jtarlton 64 * Handler for IPMEV_ERROR events.
517 : jtarlton 41 */
518 :     void IpmDevice::onError()
519 :     {
520 :     LOGERROR("IpmDevice::onError() device: " << devName_ <<
521 :     " error: " << ATDV_ERRMSGP(devHandle_));
522 :     state_ = IPM_INVALID;
523 :     }
524 :    
525 :    
526 :     /*
527 : jtarlton 64 * Handler for IPMEV_EVENT_ENABLED events
528 : jtarlton 41 */
529 : jtarlton 64 void IpmDevice::onEventEnabled()
530 : jtarlton 41 {
531 : jtarlton 64 LOGDEBUG("IpmDevice::onEventEnabled() device: " << devName_);
532 : jtarlton 41 initStepsRemaining_--;
533 :     if ( initStepsRemaining_ == 0 )
534 :     {
535 :     state_ = IPM_IDLE;
536 :     }
537 :     }
538 :    
539 :    
540 :     /*
541 : jtarlton 64 * Handler for IPMEV_STARTMEDIA events.
542 : jtarlton 41 */
543 :     void IpmDevice::onStartMedia()
544 :     {
545 :     LOGDEBUG("IpmDevice::onStartMedia() device: " << devName_);
546 :     state_ = IPM_STREAMING;
547 :    
548 :     // JH - attempted to start media here, but looks like it's already been
549 :     // started as a result of the accept command from chan_woomera
550 :     // It would fail due to no session in the media map with ID of 1
551 :     }
552 :    
553 :    
554 :     /*
555 : jtarlton 64 * Handler for IPMEV_STOPPED events.
556 : jtarlton 41 */
557 :     void IpmDevice::onStopped()
558 :     {
559 :     LOGDEBUG("IpmDevice::onStopped() device: " << devName_);
560 :     state_ = IPM_IDLE;
561 :     }
562 :    
563 :    
564 :     /*
565 : jtarlton 64 * Save the peer params.
566 : jtarlton 41 */
567 :     void IpmDevice::setRemoteAddress( const std::string& peerRtpIP,
568 :     const std::string& peerRtcpIP,
569 :     unsigned short peerRtpPort,
570 :     unsigned short peerRtcpPort )
571 :     {
572 :     peerRtpIP_ = peerRtpIP;
573 :     peerRtcpIP_ = peerRtcpIP;
574 :     peerRtpPort_ = peerRtpPort;
575 :     peerRtcpPort_ = peerRtcpPort;
576 :     }
577 :    
578 :    
579 :     /* vim:ts=4:set nu:
580 :     * EOF
581 :     */
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.8