#include <MediaSession.hh>
Inheritance diagram for MediaSession:


Public Member Functions | |
| Boolean | hasSubsessions () const |
| float & | playStartTime () |
| float & | playEndTime () |
| char * | connectionEndpointName () const |
| char const * | CNAME () const |
| in_addr const & | sourceFilterAddr () const |
| float & | scale () |
| char * | mediaSessionType () const |
| char * | sessionName () const |
| char * | sessionDescription () const |
| char const * | controlPath () const |
| Boolean | initiateByMediaType (char const *mimeType, MediaSubsession *&resultSubsession, int useSpecialRTPoffset=-1) |
| UsageEnvironment & | envir () const |
| char const * | name () const |
| virtual Boolean | isSource () const |
| virtual Boolean | isSink () const |
| virtual Boolean | isRTCPInstance () const |
| virtual Boolean | isRTSPClient () const |
| virtual Boolean | isRTSPServer () const |
| virtual Boolean | isServerMediaSession () const |
| virtual Boolean | isDarwinInjector () const |
Static Public Member Functions | |
| static MediaSession * | createNew (UsageEnvironment &env, char const *sdpDescription) |
| static Boolean | lookupByName (UsageEnvironment &env, char const *sourceName, MediaSession *&resultSession) |
| static Boolean | lookupByName (UsageEnvironment &env, char const *mediumName, Medium *&resultMedium) |
| static void | close (UsageEnvironment &env, char const *mediumName) |
| static void | close (Medium *medium) |
Protected Member Functions | |
| virtual Boolean | isMediaSession () const |
| MediaSession (UsageEnvironment &env) | |
| virtual | ~MediaSession () |
| Boolean | initializeWithSDP (char const *sdpDescription) |
| Boolean | parseSDPLine (char const *input, char const *&nextLine) |
| Boolean | parseSDPLine_s (char const *sdpLine) |
| Boolean | parseSDPLine_i (char const *sdpLine) |
| Boolean | parseSDPLine_c (char const *sdpLine) |
| Boolean | parseSDPAttribute_type (char const *sdpLine) |
| Boolean | parseSDPAttribute_control (char const *sdpLine) |
| Boolean | parseSDPAttribute_range (char const *sdpLine) |
| Boolean | parseSDPAttribute_source_filter (char const *sdpLine) |
| TaskToken & | nextTask () |
Static Protected Member Functions | |
| static char * | lookupPayloadFormat (unsigned char rtpPayloadType, unsigned &rtpTimestampFrequency, unsigned &numChannels) |
| static unsigned | guessRTPTimestampFrequency (char const *mediumName, char const *codecName) |
Protected Attributes | |
| char * | fCNAME |
| MediaSubsession * | fSubsessionsHead |
| MediaSubsession * | fSubsessionsTail |
| char * | fConnectionEndpointName |
| float | fMaxPlayStartTime |
| float | fMaxPlayEndTime |
| in_addr | fSourceFilterAddr |
| float | fScale |
| char * | fMediaSessionType |
| char * | fSessionName |
| char * | fSessionDescription |
| char * | fControlPath |
Friends | |
| class | MediaSubsessionIterator |
Definition at line 33 of file MediaSession.hh.
| MediaSession::MediaSession | ( | UsageEnvironment & | env | ) | [protected] |
Definition at line 62 of file MediaSession.cpp.
References CNAME(), fCNAME, fSourceFilterAddr, our_random(), and strDup().
Referenced by createNew().
00063 : Medium(env), 00064 fSubsessionsHead(NULL), fSubsessionsTail(NULL), 00065 fConnectionEndpointName(NULL), fMaxPlayStartTime(0.0f), fMaxPlayEndTime(0.0f), 00066 fScale(1.0f), fMediaSessionType(NULL), fSessionName(NULL), fSessionDescription(NULL), 00067 fControlPath(NULL) { 00068 #ifdef SUPPORT_REAL_RTSP 00069 RealInitSDPAttributes(this); 00070 #endif 00071 fSourceFilterAddr.s_addr = 0; 00072 00073 // Get our host name, and use this for the RTCP CNAME: 00074 const unsigned maxCNAMElen = 100; 00075 char CNAME[maxCNAMElen+1]; 00076 #ifndef CRIS 00077 gethostname((char*)CNAME, maxCNAMElen); 00078 #else 00079 // "gethostname()" isn't defined for this platform 00080 sprintf(CNAME, "unknown host %d", (unsigned)(our_random()*0x7FFFFFFF)); 00081 #endif 00082 CNAME[maxCNAMElen] = '\0'; // just in case 00083 fCNAME = strDup(CNAME); 00084 }
| MediaSession::~MediaSession | ( | ) | [protected, virtual] |
Definition at line 86 of file MediaSession.cpp.
References fCNAME, fConnectionEndpointName, fControlPath, fMediaSessionType, fSessionDescription, fSessionName, and fSubsessionsHead.
00086 { 00087 delete fSubsessionsHead; 00088 delete[] fCNAME; 00089 delete[] fConnectionEndpointName; 00090 delete[] fMediaSessionType; 00091 delete[] fSessionName; 00092 delete[] fSessionDescription; 00093 delete[] fControlPath; 00094 #ifdef SUPPORT_REAL_RTSP 00095 RealReclaimSDPAttributes(this); 00096 #endif 00097 }
| MediaSession * MediaSession::createNew | ( | UsageEnvironment & | env, | |
| char const * | sdpDescription | |||
| ) | [static] |
Definition at line 32 of file MediaSession.cpp.
References env, initializeWithSDP(), MediaSession(), and NULL.
Referenced by main(), and DarwinInjector::setDestination().
00033 { 00034 MediaSession* newSession = new MediaSession(env); 00035 if (newSession != NULL) { 00036 if (!newSession->initializeWithSDP(sdpDescription)) { 00037 delete newSession; 00038 return NULL; 00039 } 00040 } 00041 00042 return newSession; 00043 }
| Boolean MediaSession::lookupByName | ( | UsageEnvironment & | env, | |
| char const * | sourceName, | |||
| MediaSession *& | resultSession | |||
| ) | [static] |
Definition at line 45 of file MediaSession.cpp.
References env, False, Medium::isMediaSession(), Medium::lookupByName(), NULL, and True.
00047 { 00048 resultSession = NULL; // unless we succeed 00049 00050 Medium* medium; 00051 if (!Medium::lookupByName(env, instanceName, medium)) return False; 00052 00053 if (!medium->isMediaSession()) { 00054 env.setResultMsg(instanceName, " is not a 'MediaSession' object"); 00055 return False; 00056 } 00057 00058 resultSession = (MediaSession*)medium; 00059 return True; 00060 }
| Boolean MediaSession::hasSubsessions | ( | ) | const [inline] |
Definition at line 41 of file MediaSession.hh.
References fSubsessionsHead, and NULL.
Referenced by main().
00041 { return fSubsessionsHead != NULL; }
| float& MediaSession::playStartTime | ( | ) | [inline] |
Definition at line 42 of file MediaSession.hh.
References fMaxPlayStartTime.
Referenced by MediaSubsession::parseSDPAttribute_range(), parseSDPAttribute_range(), RTSPClient::playMediaSession(), and MediaSubsession::playStartTime().
00042 { return fMaxPlayStartTime; }
| float& MediaSession::playEndTime | ( | ) | [inline] |
Definition at line 43 of file MediaSession.hh.
References fMaxPlayEndTime.
Referenced by MediaSubsession::parseSDPAttribute_range(), parseSDPAttribute_range(), MediaSubsession::playEndTime(), RTSPClient::playMediaSession(), RTSPClient::setupMediaSubsession(), and startPlayingStreams().
00043 { return fMaxPlayEndTime; }
| char* MediaSession::connectionEndpointName | ( | ) | const [inline] |
Definition at line 44 of file MediaSession.hh.
References fConnectionEndpointName.
Referenced by MediaSubsession::connectionEndpointAddress(), and parseSDPLine_c().
00044 { return fConnectionEndpointName; }
| char const* MediaSession::CNAME | ( | ) | const [inline] |
Definition at line 45 of file MediaSession.hh.
References fCNAME.
Referenced by MediaSubsession::initiate(), and MediaSession().
00045 { return fCNAME; }
| struct in_addr const& MediaSession::sourceFilterAddr | ( | ) | const [inline, read] |
Definition at line 46 of file MediaSession.hh.
References fSourceFilterAddr.
00046 { return fSourceFilterAddr; }
| float& MediaSession::scale | ( | ) | [inline] |
Definition at line 47 of file MediaSession.hh.
References fScale.
Referenced by RTSPClient::playMediaSession().
00047 { return fScale; }
| char* MediaSession::mediaSessionType | ( | ) | const [inline] |
Definition at line 48 of file MediaSession.hh.
References fMediaSessionType.
Referenced by RTSPClient::setupMediaSubsession().
00048 { return fMediaSessionType; }
| char* MediaSession::sessionName | ( | ) | const [inline] |
Definition at line 49 of file MediaSession.hh.
References fSessionName.
00049 { return fSessionName; }
| char* MediaSession::sessionDescription | ( | ) | const [inline] |
Definition at line 50 of file MediaSession.hh.
References fSessionDescription.
00050 { return fSessionDescription; }
| char const* MediaSession::controlPath | ( | ) | const [inline] |
Definition at line 51 of file MediaSession.hh.
References fControlPath.
Referenced by parseSDPAttribute_control(), and RTSPClient::sessionURL().
00051 { return fControlPath; }
| Boolean MediaSession::initiateByMediaType | ( | char const * | mimeType, | |
| MediaSubsession *& | resultSubsession, | |||
| int | useSpecialRTPoffset = -1 | |||
| ) |
Definition at line 479 of file MediaSession.cpp.
References MediaSubsession::deInitiate(), Medium::envir(), False, MediaSubsession::initiate(), iter, MediaSource::MIMEtype(), MediaSubsessionIterator::next(), NULL, MediaSubsession::readSource(), UsageEnvironment::setResultMsg(), subsession, and True.
00481 { 00482 // Look through this session's subsessions for media that match "mimeType" 00483 resultSubsession = NULL; 00484 MediaSubsessionIterator iter(*this); 00485 MediaSubsession* subsession; 00486 while ((subsession = iter.next()) != NULL) { 00487 Boolean wasAlreadyInitiated = subsession->readSource() != NULL; 00488 if (!wasAlreadyInitiated) { 00489 // Try to create a source for this subsession: 00490 if (!subsession->initiate(useSpecialRTPoffset)) return False; 00491 } 00492 00493 // Make sure the source's MIME type is one that we handle: 00494 if (strcmp(subsession->readSource()->MIMEtype(), mimeType) != 0) { 00495 if (!wasAlreadyInitiated) subsession->deInitiate(); 00496 continue; 00497 } 00498 00499 resultSubsession = subsession; 00500 break; // use this 00501 } 00502 00503 if (resultSubsession == NULL) { 00504 envir().setResultMsg("Session has no usable media subsession"); 00505 return False; 00506 } 00507 00508 return True; 00509 }
| Boolean MediaSession::isMediaSession | ( | ) | const [protected, virtual] |
Reimplemented from Medium.
Definition at line 99 of file MediaSession.cpp.
References True.
00099 { 00100 return True; 00101 }
| Boolean MediaSession::initializeWithSDP | ( | char const * | sdpDescription | ) | [protected] |
Definition at line 103 of file MediaSession.cpp.
References Medium::envir(), False, MediaSubsession::fClientPortNum, MediaSubsession::fCodecName, MediaSubsession::fMediumName, MediaSubsession::fNumChannels, MediaSubsession::fProtocolName, MediaSubsession::fRTPPayloadFormat, MediaSubsession::fRTPTimestampFrequency, MediaSubsession::fSavedSDPLines, fSubsessionsHead, fSubsessionsTail, guessRTPTimestampFrequency(), lookupPayloadFormat(), NULL, MediaSubsession::parseSDPAttribute_control(), parseSDPAttribute_control(), MediaSubsession::parseSDPAttribute_fmtp(), MediaSubsession::parseSDPAttribute_framerate(), MediaSubsession::parseSDPAttribute_range(), parseSDPAttribute_range(), MediaSubsession::parseSDPAttribute_rtpmap(), MediaSubsession::parseSDPAttribute_source_filter(), parseSDPAttribute_source_filter(), parseSDPAttribute_type(), MediaSubsession::parseSDPAttribute_x_dimensions(), parseSDPLine(), MediaSubsession::parseSDPLine_c(), parseSDPLine_c(), parseSDPLine_i(), parseSDPLine_s(), MediaSubsession::serverPortNum, MediaSubsession::setNext(), UsageEnvironment::setResultMsg(), strDup(), strDupSize(), subsession, and True.
Referenced by createNew().
00103 { 00104 if (sdpDescription == NULL) return False; 00105 00106 // Begin by processing all SDP lines until we see the first "m=" 00107 char const* sdpLine = sdpDescription; 00108 char const* nextSDPLine; 00109 while (1) { 00110 if (!parseSDPLine(sdpLine, nextSDPLine)) return False; 00111 //##### We should really check for: 00112 // - "a=control:" attributes (to set the URL for aggregate control) 00113 // - the correct SDP version (v=0) 00114 if (sdpLine[0] == 'm') break; 00115 sdpLine = nextSDPLine; 00116 if (sdpLine == NULL) break; // there are no m= lines at all 00117 00118 // Check for various special SDP lines that we understand: 00119 if (parseSDPLine_s(sdpLine)) continue; 00120 if (parseSDPLine_i(sdpLine)) continue; 00121 if (parseSDPLine_c(sdpLine)) continue; 00122 if (parseSDPAttribute_control(sdpLine)) continue; 00123 if (parseSDPAttribute_range(sdpLine)) continue; 00124 if (parseSDPAttribute_type(sdpLine)) continue; 00125 if (parseSDPAttribute_source_filter(sdpLine)) continue; 00126 #ifdef SUPPORT_REAL_RTSP 00127 if (RealParseSDPAttributes(this, sdpLine)) continue; 00128 #endif 00129 } 00130 00131 while (sdpLine != NULL) { 00132 // We have a "m=" line, representing a new sub-session: 00133 MediaSubsession* subsession = new MediaSubsession(*this); 00134 if (subsession == NULL) { 00135 envir().setResultMsg("Unable to create new MediaSubsession"); 00136 return False; 00137 } 00138 00139 // Parse the line as "m=<medium_name> <client_portNum> RTP/AVP <fmt>" 00140 // or "m=<medium_name> <client_portNum>/<num_ports> RTP/AVP <fmt>" 00141 // (Should we be checking for >1 payload format number here?)##### 00142 char* mediumName = strDupSize(sdpLine); // ensures we have enough space 00143 char* protocolName = NULL; 00144 unsigned payloadFormat; 00145 if ((sscanf(sdpLine, "m=%s %hu RTP/AVP %u", 00146 mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 || 00147 sscanf(sdpLine, "m=%s %hu/%*u RTP/AVP %u", 00148 mediumName, &subsession->fClientPortNum, &payloadFormat) == 3) 00149 && payloadFormat <= 127) { 00150 protocolName = "RTP"; 00151 } else if ((sscanf(sdpLine, "m=%s %hu UDP %u", 00152 mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 || 00153 sscanf(sdpLine, "m=%s %hu udp %u", 00154 mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 || 00155 sscanf(sdpLine, "m=%s %hu RAW/RAW/UDP %u", 00156 mediumName, &subsession->fClientPortNum, &payloadFormat) == 3) 00157 && payloadFormat <= 127) { 00158 // This is a RAW UDP source 00159 protocolName = "UDP"; 00160 } else { 00161 // This "m=" line is bad; output an error message saying so: 00162 char* sdpLineStr; 00163 if (nextSDPLine == NULL) { 00164 sdpLineStr = (char*)sdpLine; 00165 } else { 00166 sdpLineStr = strDup(sdpLine); 00167 sdpLineStr[nextSDPLine-sdpLine] = '\0'; 00168 } 00169 envir() << "Bad SDP \"m=\" line: " << sdpLineStr << "\n"; 00170 if (sdpLineStr != (char*)sdpLine) delete[] sdpLineStr; 00171 00172 delete[] mediumName; 00173 delete subsession; 00174 00175 // Skip the following SDP lines, up until the next "m=": 00176 while (1) { 00177 sdpLine = nextSDPLine; 00178 if (sdpLine == NULL) break; // we've reached the end 00179 if (!parseSDPLine(sdpLine, nextSDPLine)) return False; 00180 00181 if (sdpLine[0] == 'm') break; // we've reached the next subsession 00182 } 00183 continue; 00184 } 00185 00186 // Insert this subsession at the end of the list: 00187 if (fSubsessionsTail == NULL) { 00188 fSubsessionsHead = fSubsessionsTail = subsession; 00189 } else { 00190 fSubsessionsTail->setNext(subsession); 00191 fSubsessionsTail = subsession; 00192 } 00193 00194 subsession->serverPortNum = subsession->fClientPortNum; // by default 00195 00196 char const* mStart = sdpLine; 00197 subsession->fSavedSDPLines = strDup(mStart); 00198 00199 subsession->fMediumName = strDup(mediumName); 00200 delete[] mediumName; 00201 subsession->fProtocolName = strDup(protocolName); 00202 subsession->fRTPPayloadFormat = payloadFormat; 00203 00204 // Process the following SDP lines, up until the next "m=": 00205 while (1) { 00206 sdpLine = nextSDPLine; 00207 if (sdpLine == NULL) break; // we've reached the end 00208 if (!parseSDPLine(sdpLine, nextSDPLine)) return False; 00209 00210 if (sdpLine[0] == 'm') break; // we've reached the next subsession 00211 00212 // Check for various special SDP lines that we understand: 00213 if (subsession->parseSDPLine_c(sdpLine)) continue; 00214 if (subsession->parseSDPAttribute_rtpmap(sdpLine)) continue; 00215 if (subsession->parseSDPAttribute_control(sdpLine)) continue; 00216 if (subsession->parseSDPAttribute_range(sdpLine)) continue; 00217 if (subsession->parseSDPAttribute_fmtp(sdpLine)) continue; 00218 if (subsession->parseSDPAttribute_source_filter(sdpLine)) continue; 00219 if (subsession->parseSDPAttribute_x_dimensions(sdpLine)) continue; 00220 if (subsession->parseSDPAttribute_framerate(sdpLine)) continue; 00221 #ifdef SUPPORT_REAL_RTSP 00222 if (RealParseSDPAttributes(subsession, sdpLine)) continue; 00223 #endif 00224 00225 // (Later, check for malformed lines, and other valid SDP lines#####) 00226 } 00227 if (sdpLine != NULL) subsession->fSavedSDPLines[sdpLine-mStart] = '\0'; 00228 00229 // If we don't yet know the codec name, try looking it up from the 00230 // list of static payload types: 00231 if (subsession->fCodecName == NULL) { 00232 subsession->fCodecName 00233 = lookupPayloadFormat(subsession->fRTPPayloadFormat, 00234 subsession->fRTPTimestampFrequency, 00235 subsession->fNumChannels); 00236 if (subsession->fCodecName == NULL) { 00237 char typeStr[20]; 00238 sprintf(typeStr, "%d", subsession->fRTPPayloadFormat); 00239 envir().setResultMsg("Unknown codec name for RTP payload type ", 00240 typeStr); 00241 return False; 00242 } 00243 } 00244 00245 // If we don't yet know this subsession's RTP timestamp frequency 00246 // (because it uses a dynamic payload type and the corresponding 00247 // SDP "rtpmap" attribute erroneously didn't specify it), 00248 // then guess it now: 00249 if (subsession->fRTPTimestampFrequency == 0) { 00250 subsession->fRTPTimestampFrequency 00251 = guessRTPTimestampFrequency(subsession->fMediumName, 00252 subsession->fCodecName); 00253 } 00254 } 00255 00256 return True; 00257 }
| Boolean MediaSession::parseSDPLine | ( | char const * | input, | |
| char const *& | nextLine | |||
| ) | [protected] |
Definition at line 259 of file MediaSession.cpp.
References Medium::envir(), False, NULL, and True.
Referenced by initializeWithSDP().
00260 { 00261 // Begin by finding the start of the next line (if any): 00262 nextLine = NULL; 00263 for (char const* ptr = inputLine; *ptr != '\0'; ++ptr) { 00264 if (*ptr == '\r' || *ptr == '\n') { 00265 // We found the end of the line 00266 ++ptr; 00267 while (*ptr == '\r' || *ptr == '\n') ++ptr; 00268 nextLine = ptr; 00269 if (nextLine[0] == '\0') nextLine = NULL; // special case for end 00270 break; 00271 } 00272 } 00273 00274 // Then, check that this line is a SDP line of the form <char>=<etc> 00275 // (However, we also accept blank lines in the input.) 00276 if (inputLine[0] == '\r' || inputLine[0] == '\n') return True; 00277 if (strlen(inputLine) < 2 || inputLine[1] != '=' 00278 || inputLine[0] < 'a' || inputLine[0] > 'z') { 00279 envir().setResultMsg("Invalid SDP line: ", inputLine); 00280 return False; 00281 } 00282 00283 return True; 00284 }
| Boolean MediaSession::parseSDPLine_s | ( | char const * | sdpLine | ) | [protected] |
Definition at line 298 of file MediaSession.cpp.
References False, fSessionName, strDup(), strDupSize(), and True.
Referenced by initializeWithSDP().
00298 { 00299 // Check for "s=<session name>" line 00300 char* buffer = strDupSize(sdpLine); 00301 Boolean parseSuccess = False; 00302 00303 if (sscanf(sdpLine, "s=%[^\r\n]", buffer) == 1) { 00304 delete[] fSessionName; fSessionName = strDup(buffer); 00305 parseSuccess = True; 00306 } 00307 delete[] buffer; 00308 00309 return parseSuccess; 00310 }
| Boolean MediaSession::parseSDPLine_i | ( | char const * | sdpLine | ) | [protected] |
Definition at line 312 of file MediaSession.cpp.
References False, fSessionDescription, strDup(), strDupSize(), and True.
Referenced by initializeWithSDP().
00312 { 00313 // Check for "i=<session description>" line 00314 char* buffer = strDupSize(sdpLine); 00315 Boolean parseSuccess = False; 00316 00317 if (sscanf(sdpLine, "i=%[^\r\n]", buffer) == 1) { 00318 delete[] fSessionDescription; fSessionDescription = strDup(buffer); 00319 parseSuccess = True; 00320 } 00321 delete[] buffer; 00322 00323 return parseSuccess; 00324 }
| Boolean MediaSession::parseSDPLine_c | ( | char const * | sdpLine | ) | [protected] |
Definition at line 326 of file MediaSession.cpp.
References connectionEndpointName(), False, fConnectionEndpointName, NULL, parseCLine(), and True.
Referenced by initializeWithSDP().
00326 { 00327 // Check for "c=IN IP4 <connection-endpoint>" 00328 // or "c=IN IP4 <connection-endpoint>/<ttl+numAddresses>" 00329 // (Later, do something with <ttl+numAddresses> also #####) 00330 char* connectionEndpointName = parseCLine(sdpLine); 00331 if (connectionEndpointName != NULL) { 00332 delete[] fConnectionEndpointName; 00333 fConnectionEndpointName = connectionEndpointName; 00334 return True; 00335 } 00336 00337 return False; 00338 }
| Boolean MediaSession::parseSDPAttribute_type | ( | char const * | sdpLine | ) | [protected] |
Definition at line 340 of file MediaSession.cpp.
References False, fMediaSessionType, strDup(), strDupSize(), and True.
Referenced by initializeWithSDP().
00340 { 00341 // Check for a "a=type:broadcast|meeting|moderated|test|H.332|recvonly" line: 00342 Boolean parseSuccess = False; 00343 00344 char* buffer = strDupSize(sdpLine); 00345 if (sscanf(sdpLine, "a=type: %[^ ]", buffer) == 1) { 00346 delete[] fMediaSessionType; 00347 fMediaSessionType = strDup(buffer); 00348 parseSuccess = True; 00349 } 00350 delete[] buffer; 00351 00352 return parseSuccess; 00353 }
| Boolean MediaSession::parseSDPAttribute_control | ( | char const * | sdpLine | ) | [protected] |
Definition at line 359 of file MediaSession.cpp.
References controlPath(), False, fControlPath, strDup(), strDupSize(), and True.
Referenced by initializeWithSDP().
00359 { 00360 // Check for a "a=control:<control-path>" line: 00361 Boolean parseSuccess = False; 00362 00363 char* controlPath = strDupSize(sdpLine); // ensures we have enough space 00364 if (sscanf(sdpLine, "a=control: %s", controlPath) == 1) { 00365 parseSuccess = True; 00366 delete[] fControlPath; fControlPath = strDup(controlPath); 00367 } 00368 delete[] controlPath; 00369 00370 return parseSuccess; 00371 }
| Boolean MediaSession::parseSDPAttribute_range | ( | char const * | sdpLine | ) | [protected] |
Definition at line 373 of file MediaSession.cpp.
References False, fMaxPlayEndTime, fMaxPlayStartTime, parseRangeAttribute(), playEndTime(), playStartTime(), and True.
Referenced by initializeWithSDP().
00373 { 00374 // Check for a "a=range:npt=<startTime>-<endTime>" line: 00375 // (Later handle other kinds of "a=range" attributes also???#####) 00376 Boolean parseSuccess = False; 00377 00378 float playStartTime; 00379 float playEndTime; 00380 if (parseRangeAttribute(sdpLine, playStartTime, playEndTime)) { 00381 parseSuccess = True; 00382 if (playStartTime > fMaxPlayStartTime) { 00383 fMaxPlayStartTime = playStartTime; 00384 } 00385 if (playEndTime > fMaxPlayEndTime) { 00386 fMaxPlayEndTime = playEndTime; 00387 } 00388 } 00389 00390 return parseSuccess; 00391 }
| Boolean MediaSession::parseSDPAttribute_source_filter | ( | char const * | sdpLine | ) | [protected] |
Definition at line 422 of file MediaSession.cpp.
References fSourceFilterAddr, and parseSourceFilterAttribute().
Referenced by initializeWithSDP().
00422 { 00423 return parseSourceFilterAttribute(sdpLine, fSourceFilterAddr); 00424 }
| char * MediaSession::lookupPayloadFormat | ( | unsigned char | rtpPayloadType, | |
| unsigned & | rtpTimestampFrequency, | |||
| unsigned & | numChannels | |||
| ) | [static, protected] |
Definition at line 426 of file MediaSession.cpp.
References NULL, and strDup().
Referenced by initializeWithSDP().
00427 { 00428 // Look up the codec name and timestamp frequency for known (static) 00429 // RTP payload formats. 00430 char* temp = NULL; 00431 switch (rtpPayloadType) { 00432 case 0: {temp = "PCMU"; freq = 8000; nCh = 1; break;} 00433 case 2: {temp = "G726-32"; freq = 8000; nCh = 1; break;} 00434 case 3: {temp = "GSM"; freq = 8000; nCh = 1; break;} 00435 case 4: {temp = "G723"; freq = 8000; nCh = 1; break;} 00436 case 5: {temp = "DVI4"; freq = 8000; nCh = 1; break;} 00437 case 6: {temp = "DVI4"; freq = 16000; nCh = 1; break;} 00438 case 7: {temp = "LPC"; freq = 8000; nCh = 1; break;} 00439 case 8: {temp = "PCMA"; freq = 8000; nCh = 1; break;} 00440 case 9: {temp = "G722"; freq = 8000; nCh = 1; break;} 00441 case 10: {temp = "L16"; freq = 44100; nCh = 2; break;} 00442 case 11: {temp = "L16"; freq = 44100; nCh = 1; break;} 00443 case 12: {temp = "QCELP"; freq = 8000; nCh = 1; break;} 00444 case 14: {temp = "MPA"; freq = 90000; nCh = 1; break;} 00445 // 'number of channels' is actually encoded in the media stream 00446 case 15: {temp = "G728"; freq = 8000; nCh = 1; break;} 00447 case 16: {temp = "DVI4"; freq = 11025; nCh = 1; break;} 00448 case 17: {temp = "DVI4"; freq = 22050; nCh = 1; break;} 00449 case 18: {temp = "G729"; freq = 8000; nCh = 1; break;} 00450 case 25: {temp = "CELB"; freq = 90000; nCh = 1; break;} 00451 case 26: {temp = "JPEG"; freq = 90000; nCh = 1; break;} 00452 case 28: {temp = "NV"; freq = 90000; nCh = 1; break;} 00453 case 31: {temp = "H261"; freq = 90000; nCh = 1; break;} 00454 case 32: {temp = "MPV"; freq = 90000; nCh = 1; break;} 00455 case 33: {temp = "MP2T"; freq = 90000; nCh = 1; break;} 00456 case 34: {temp = "H263"; freq = 90000; nCh = 1; break;} 00457 }; 00458 00459 return strDup(temp); 00460 }
| unsigned MediaSession::guessRTPTimestampFrequency | ( | char const * | mediumName, | |
| char const * | codecName | |||
| ) | [static, protected] |
Definition at line 462 of file MediaSession.cpp.
Referenced by initializeWithSDP().
00463 { 00464 // By default, we assume that audio sessions use a frequency of 8000, 00465 // and that video sessions use a frequency of 90000. 00466 // Begin by checking for known exceptions to this rule 00467 // (where the frequency is known unambiguously (e.g., not like "DVI4")) 00468 if (strcmp(codecName, "L16") == 0) return 44100; 00469 if (strcmp(codecName, "MPA") == 0 00470 || strcmp(codecName, "MPA-ROBUST") == 0 00471 || strcmp(codecName, "X-MP3-DRAFT-00")) return 90000; 00472 00473 // No