MediaSession Class Reference

#include <MediaSession.hh>

Inheritance diagram for MediaSession:

[legend]Collaboration diagram for MediaSession:


Public Member Functions
Boolean	hasSubsessions () const
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
double &	playStartTime ()
double &	playEndTime ()
char *	absStartTime () const
char *	absEndTime () const
char *&	_absStartTime ()
char *&	_absEndTime ()
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 ()
virtual MediaSubsession *	createNewMediaSubsession ()
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
double	fMaxPlayStartTime
double	fMaxPlayEndTime
char *	fAbsStartTime
char *	fAbsEndTime
in_addr	fSourceFilterAddr
float	fScale
char *	fMediaSessionType
char *	fSessionName
char *	fSessionDescription
char *	fControlPath
Friends
class	MediaSubsessionIterator
class	MediaLookupTable

Detailed Description

Definition at line 58 of file MediaSession.hh.

Constructor & Destructor Documentation

MediaSession::MediaSession ( UsageEnvironment & env ) [protected]

Definition at line 59 of file MediaSession.cpp.

References CNAME(), fCNAME, fSourceFilterAddr, our_random(), and strDup().

Referenced by createNew().

00060   : Medium(env),
00061     fSubsessionsHead(NULL), fSubsessionsTail(NULL),
00062     fConnectionEndpointName(NULL),
00063     fMaxPlayStartTime(0.0f), fMaxPlayEndTime(0.0f), fAbsStartTime(NULL), fAbsEndTime(NULL),
00064     fScale(1.0f), fMediaSessionType(NULL), fSessionName(NULL), fSessionDescription(NULL),
00065     fControlPath(NULL) {
00066   fSourceFilterAddr.s_addr = 0;
00067 
00068   // Get our host name, and use this for the RTCP CNAME:
00069   const unsigned maxCNAMElen = 100;
00070   char CNAME[maxCNAMElen+1];
00071 #ifndef CRIS
00072   gethostname((char*)CNAME, maxCNAMElen);
00073 #else
00074   // "gethostname()" isn't defined for this platform
00075   sprintf(CNAME, "unknown host %d", (unsigned)(our_random()*0x7FFFFFFF));
00076 #endif
00077   CNAME[maxCNAMElen] = '\0'; // just in case
00078   fCNAME = strDup(CNAME);
00079 }

MediaSession::~MediaSession ( ) [protected, virtual]

Definition at line 81 of file MediaSession.cpp.

References fAbsEndTime, fAbsStartTime, fCNAME, fConnectionEndpointName, fControlPath, fMediaSessionType, fSessionDescription, fSessionName, and fSubsessionsHead.

00081                             {
00082   delete fSubsessionsHead;
00083   delete[] fCNAME;
00084   delete[] fConnectionEndpointName;
00085   delete[] fAbsStartTime; delete[] fAbsEndTime;
00086   delete[] fMediaSessionType;
00087   delete[] fSessionName;
00088   delete[] fSessionDescription;
00089   delete[] fControlPath;
00090 }

Member Function Documentation

MediaSession * MediaSession::createNew	(	UsageEnvironment &	env,
		char const *	sdpDescription
	)			`[static]`

Definition at line 29 of file MediaSession.cpp.

References env, initializeWithSDP(), MediaSession(), and NULL.

Referenced by continueAfterDESCRIBE(), ProxyServerMediaSession::continueAfterDESCRIBE(), and DarwinInjector::setDestination().

00030                                                                   {
00031   MediaSession* newSession = new MediaSession(env);
00032   if (newSession != NULL) {
00033     if (!newSession->initializeWithSDP(sdpDescription)) {
00034       delete newSession;
00035       return NULL;
00036     }
00037   }
00038 
00039   return newSession;
00040 }

Boolean MediaSession::lookupByName	(	UsageEnvironment &	env,
		char const *	sourceName,
		MediaSession *&	resultSession
	)			`[static]`

Definition at line 42 of file MediaSession.cpp.

References env, False, Medium::isMediaSession(), Medium::lookupByName(), NULL, and True.

00044                                                                  {
00045   resultSession = NULL; // unless we succeed
00046 
00047   Medium* medium;
00048   if (!Medium::lookupByName(env, instanceName, medium)) return False;
00049 
00050   if (!medium->isMediaSession()) {
00051     env.setResultMsg(instanceName, " is not a 'MediaSession' object");
00052     return False;
00053   }
00054 
00055   resultSession = (MediaSession*)medium;
00056   return True;
00057 }

Boolean MediaSession::hasSubsessions ( ) const [inline]

Definition at line 66 of file MediaSession.hh.

References fSubsessionsHead, and NULL.

Referenced by continueAfterDESCRIBE().

00066 { return fSubsessionsHead != NULL; }

char* MediaSession::connectionEndpointName ( ) const [inline]

Definition at line 68 of file MediaSession.hh.

References fConnectionEndpointName.

Referenced by MediaSubsession::connectionEndpointAddress(), and parseSDPLine_c().

00068 { return fConnectionEndpointName; }

char const* MediaSession::CNAME ( ) const [inline]

Definition at line 69 of file MediaSession.hh.

References fCNAME.

Referenced by MediaSubsession::initiate(), and MediaSession().

00069 { return fCNAME; }

struct in_addr const& MediaSession::sourceFilterAddr ( ) const [inline, read]

Definition at line 70 of file MediaSession.hh.

References fSourceFilterAddr.

00070 { return fSourceFilterAddr; }

float& MediaSession::scale ( ) [inline]

Definition at line 71 of file MediaSession.hh.

References fScale.

Referenced by RTSPClient::handlePLAYResponse(), and RTSPClient::sendRequest().

00071 { return fScale; }

char* MediaSession::mediaSessionType ( ) const [inline]

Definition at line 72 of file MediaSession.hh.

References fMediaSessionType.

00072 { return fMediaSessionType; }

char* MediaSession::sessionName ( ) const [inline]

Definition at line 73 of file MediaSession.hh.

References fSessionName.

00073 { return fSessionName; }

char* MediaSession::sessionDescription ( ) const [inline]

Definition at line 74 of file MediaSession.hh.

References fSessionDescription.

00074 { return fSessionDescription; }

char const* MediaSession::controlPath ( ) const [inline]

Definition at line 75 of file MediaSession.hh.

References fControlPath.

Referenced by parseSDPAttribute_control(), and RTSPClient::sessionURL().

00075 { return fControlPath; }

double& MediaSession::playStartTime ( ) [inline]

Definition at line 77 of file MediaSession.hh.

References fMaxPlayStartTime.

Referenced by continueAfterPLAY(), RTSPClient::handlePLAYResponse(), MediaSubsession::parseSDPAttribute_range(), parseSDPAttribute_range(), MediaSubsession::playStartTime(), and setupNextSubsession().

00077 { return fMaxPlayStartTime; }

double& MediaSession::playEndTime ( ) [inline]

Definition at line 78 of file MediaSession.hh.

References fMaxPlayEndTime.

00078 { return fMaxPlayEndTime; }

char * MediaSession::absStartTime ( ) const

Definition at line 494 of file MediaSession.cpp.

References MediaSubsession::_absStartTime(), fAbsStartTime, iter, MediaSubsessionIterator::next(), NULL, and subsession.

Referenced by MediaSubsession::absStartTime(), setupNextSubsession(), and setupStreams().

00494                                        {
00495   if (fAbsStartTime != NULL) return fAbsStartTime;
00496 
00497   // If a subsession has an 'absolute' start time, then use that:
00498   MediaSubsessionIterator iter(*this);
00499   MediaSubsession* subsession;
00500   while ((subsession = iter.next()) != NULL) {
00501     if (subsession->_absStartTime() != NULL) return subsession->_absStartTime();
00502   }
00503   return NULL;
00504 }

char * MediaSession::absEndTime ( ) const

Definition at line 506 of file MediaSession.cpp.

References MediaSubsession::_absEndTime(), fAbsEndTime, iter, MediaSubsessionIterator::next(), NULL, and subsession.

Referenced by MediaSubsession::absEndTime(), setupNextSubsession(), and setupStreams().

00506                                      {
00507   if (fAbsEndTime != NULL) return fAbsEndTime;
00508 
00509   // If a subsession has an 'absolute' end time, then use that:
00510   MediaSubsessionIterator iter(*this);
00511   MediaSubsession* subsession;
00512   while ((subsession = iter.next()) != NULL) {
00513     if (subsession->_absEndTime() != NULL) return subsession->_absEndTime();
00514   }
00515   return NULL;
00516 }

char*& MediaSession::_absStartTime ( ) [inline]

Definition at line 82 of file MediaSession.hh.

References fAbsStartTime.

Referenced by RTSPClient::handlePLAYResponse(), and parseSDPAttribute_range().

00082 { return fAbsStartTime; }

char*& MediaSession::_absEndTime ( ) [inline]

Definition at line 83 of file MediaSession.hh.

References fAbsEndTime.

Referenced by RTSPClient::handlePLAYResponse(), and parseSDPAttribute_range().

00083 { return fAbsEndTime; }

Boolean MediaSession::initiateByMediaType	(	char const *	mimeType,
		MediaSubsession *&	resultSubsession,
		int	useSpecialRTPoffset = `-1`
	)

Definition at line 519 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.

00521                                                {
00522   // Look through this session's subsessions for media that match "mimeType"
00523   resultSubsession = NULL;
00524   MediaSubsessionIterator iter(*this);
00525   MediaSubsession* subsession;
00526   while ((subsession = iter.next()) != NULL) {
00527     Boolean wasAlreadyInitiated = subsession->readSource() != NULL;
00528     if (!wasAlreadyInitiated) {
00529       // Try to create a source for this subsession:
00530       if (!subsession->initiate(useSpecialRTPoffset)) return False;
00531     }
00532 
00533     // Make sure the source's MIME type is one that we handle:
00534     if (strcmp(subsession->readSource()->MIMEtype(), mimeType) != 0) {
00535       if (!wasAlreadyInitiated) subsession->deInitiate();
00536       continue;
00537     }
00538 
00539     resultSubsession = subsession;
00540     break; // use this
00541   }
00542 
00543   if (resultSubsession == NULL) {
00544     envir().setResultMsg("Session has no usable media subsession");
00545     return False;
00546   }
00547 
00548   return True;
00549 }

Boolean MediaSession::isMediaSession ( ) const [protected, virtual]

Reimplemented from Medium.

Definition at line 92 of file MediaSession.cpp.

References True.

00092                                            {
00093   return True;
00094 }

MediaSubsession * MediaSession::createNewMediaSubsession ( ) [protected, virtual]

Definition at line 96 of file MediaSession.cpp.

Referenced by initializeWithSDP().

00096                                                         {
00097   // default implementation:
00098   return new MediaSubsession(*this);
00099 }

Boolean MediaSession::initializeWithSDP ( char const * sdpDescription ) [protected]

Definition at line 101 of file MediaSession.cpp.

Referenced by createNew().

00101                                                                   {
00102   if (sdpDescription == NULL) return False;
00103 
00104   // Begin by processing all SDP lines until we see the first "m="
00105   char const* sdpLine = sdpDescription;
00106   char const* nextSDPLine;
00107   while (1) {
00108     if (!parseSDPLine(sdpLine, nextSDPLine)) return False;
00109     //##### We should really check for:
00110     // - "a=control:" attributes (to set the URL for aggregate control)
00111     // - the correct SDP version (v=0)
00112     if (sdpLine[0] == 'm') break;
00113     sdpLine = nextSDPLine;
00114     if (sdpLine == NULL) break; // there are no m= lines at all
00115 
00116     // Check for various special SDP lines that we understand:
00117     if (parseSDPLine_s(sdpLine)) continue;
00118     if (parseSDPLine_i(sdpLine)) continue;
00119     if (parseSDPLine_c(sdpLine)) continue;
00120     if (parseSDPAttribute_control(sdpLine)) continue;
00121     if (parseSDPAttribute_range(sdpLine)) continue;
00122     if (parseSDPAttribute_type(sdpLine)) continue;
00123     if (parseSDPAttribute_source_filter(sdpLine)) continue;
00124   }
00125 
00126   while (sdpLine != NULL) {
00127     // We have a "m=" line, representing a new sub-session:
00128     MediaSubsession* subsession = createNewMediaSubsession();
00129     if (subsession == NULL) {
00130       envir().setResultMsg("Unable to create new MediaSubsession");
00131       return False;
00132     }
00133 
00134     // Parse the line as "m=<medium_name> <client_portNum> RTP/AVP <fmt>"
00135     // or "m=<medium_name> <client_portNum>/<num_ports> RTP/AVP <fmt>"
00136     // (Should we be checking for >1 payload format number here?)#####
00137     char* mediumName = strDupSize(sdpLine); // ensures we have enough space
00138     char const* protocolName = NULL;
00139     unsigned payloadFormat;
00140     if ((sscanf(sdpLine, "m=%s %hu RTP/AVP %u",
00141                 mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 ||
00142          sscanf(sdpLine, "m=%s %hu/%*u RTP/AVP %u",
00143                 mediumName, &subsession->fClientPortNum, &payloadFormat) == 3)
00144         && payloadFormat <= 127) {
00145       protocolName = "RTP";
00146     } else if ((sscanf(sdpLine, "m=%s %hu UDP %u",
00147                        mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 ||
00148                 sscanf(sdpLine, "m=%s %hu udp %u",
00149                        mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 ||
00150                 sscanf(sdpLine, "m=%s %hu RAW/RAW/UDP %u",
00151                        mediumName, &subsession->fClientPortNum, &payloadFormat) == 3)
00152                && payloadFormat <= 127) {
00153       // This is a RAW UDP source
00154       protocolName = "UDP";
00155     } else {
00156       // This "m=" line is bad; output an error message saying so:
00157       char* sdpLineStr;
00158       if (nextSDPLine == NULL) {
00159         sdpLineStr = (char*)sdpLine;
00160       } else {
00161         sdpLineStr = strDup(sdpLine);
00162         sdpLineStr[nextSDPLine-sdpLine] = '\0';
00163       }
00164       envir() << "Bad SDP \"m=\" line: " <<  sdpLineStr << "\n";
00165       if (sdpLineStr != (char*)sdpLine) delete[] sdpLineStr;
00166 
00167       delete[] mediumName;
00168       delete subsession;
00169 
00170       // Skip the following SDP lines, up until the next "m=":
00171       while (1) {
00172         sdpLine = nextSDPLine;
00173         if (sdpLine == NULL) break; // we've reached the end
00174         if (!parseSDPLine(sdpLine, nextSDPLine)) return False;
00175 
00176         if (sdpLine[0] == 'm') break; // we've reached the next subsession
00177       }
00178       continue;
00179     }
00180 
00181     // Insert this subsession at the end of the list:
00182     if (fSubsessionsTail == NULL) {
00183       fSubsessionsHead = fSubsessionsTail = subsession;
00184     } else {
00185       fSubsessionsTail->setNext(subsession);
00186       fSubsessionsTail = subsession;
00187     }
00188 
00189     subsession->serverPortNum = subsession->fClientPortNum; // by default
00190 
00191     char const* mStart = sdpLine;
00192     subsession->fSavedSDPLines = strDup(mStart);
00193 
00194     subsession->fMediumName = strDup(mediumName);
00195     delete[] mediumName;
00196     subsession->fProtocolName = strDup(protocolName);
00197     subsession->fRTPPayloadFormat = payloadFormat;
00198 
00199     // Process the following SDP lines, up until the next "m=":
00200     while (1) {
00201       sdpLine = nextSDPLine;
00202       if (sdpLine == NULL) break; // we've reached the end
00203       if (!parseSDPLine(sdpLine, nextSDPLine)) return False;
00204 
00205       if (sdpLine[0] == 'm') break; // we've reached the next subsession
00206 
00207       // Check for various special SDP lines that we understand:
00208       if (subsession->parseSDPLine_c(sdpLine)) continue;
00209       if (subsession->parseSDPLine_b(sdpLine)) continue;
00210       if (subsession->parseSDPAttribute_rtpmap(sdpLine)) continue;
00211       if (subsession->parseSDPAttribute_control(sdpLine)) continue;
00212       if (subsession->parseSDPAttribute_range(sdpLine)) continue;
00213       if (subsession->parseSDPAttribute_fmtp(sdpLine)) continue;
00214       if (subsession->parseSDPAttribute_source_filter(sdpLine)) continue;
00215       if (subsession->parseSDPAttribute_x_dimensions(sdpLine)) continue;
00216       if (subsession->parseSDPAttribute_framerate(sdpLine)) continue;
00217 
00218       // (Later, check for malformed lines, and other valid SDP lines#####)
00219     }
00220     if (sdpLine != NULL) subsession->fSavedSDPLines[sdpLine-mStart] = '\0';
00221 
00222     // If we don't yet know the codec name, try looking it up from the
00223     // list of static payload types:
00224     if (subsession->fCodecName == NULL) {
00225       subsession->fCodecName
00226         = lookupPayloadFormat(subsession->fRTPPayloadFormat,
00227                               subsession->fRTPTimestampFrequency,
00228                               subsession->fNumChannels);
00229       if (subsession->fCodecName == NULL) {
00230         char typeStr[20];
00231         sprintf(typeStr, "%d", subsession->fRTPPayloadFormat);
00232         envir().setResultMsg("Unknown codec name for RTP payload type ",
00233                              typeStr);
00234         return False;
00235       }
00236     }
00237 
00238     // If we don't yet know this subsession's RTP timestamp frequency
00239     // (because it uses a dynamic payload type and the corresponding
00240     // SDP "rtpmap" attribute erroneously didn't specify it),
00241     // then guess it now:
00242     if (subsession->fRTPTimestampFrequency == 0) {
00243       subsession->fRTPTimestampFrequency
00244         = guessRTPTimestampFrequency(subsession->fMediumName,
00245                                      subsession->fCodecName);
00246     }
00247   }
00248 
00249   return True;
00250 }

Boolean MediaSession::parseSDPLine	(	char const *	input,
		char const *&	nextLine
	)			`[protected]`

Definition at line 252 of file MediaSession.cpp.

References Medium::envir(), False, NULL, and True.

Referenced by initializeWithSDP().

00253                                                          {
00254   // Begin by finding the start of the next line (if any):
00255   nextLine = NULL;
00256   for (char const* ptr = inputLine; *ptr != '\0'; ++ptr) {
00257     if (*ptr == '\r' || *ptr == '\n') {
00258       // We found the end of the line
00259       ++ptr;
00260       while (*ptr == '\r' || *ptr == '\n') ++ptr;
00261       nextLine = ptr;
00262       if (nextLine[0] == '\0') nextLine = NULL; // special case for end
00263       break;
00264     }
00265   }
00266 
00267   // Then, check that this line is a SDP line of the form <char>=<etc>
00268   // (However, we also accept blank lines in the input.)
00269   if (inputLine[0] == '\r' || inputLine[0] == '\n') return True;
00270   if (strlen(inputLine) < 2 || inputLine[1] != '='
00271       || inputLine[0] < 'a' || inputLine[0] > 'z') {
00272     envir().setResultMsg("Invalid SDP line: ", inputLine);
00273     return False;
00274   }
00275 
00276   return True;
00277 }

Boolean MediaSession::parseSDPLine_s ( char const * sdpLine ) [protected]

Definition at line 291 of file MediaSession.cpp.

References False, fSessionName, strDup(), strDupSize(), and True.

Referenced by initializeWithSDP().

00291                                                         {
00292   // Check for "s=<session name>" line
00293   char* buffer = strDupSize(sdpLine);
00294   Boolean parseSuccess = False;
00295 
00296   if (sscanf(sdpLine, "s=%[^\r\n]", buffer) == 1) {
00297     delete[] fSessionName; fSessionName = strDup(buffer);
00298     parseSuccess = True;
00299   }
00300   delete[] buffer;
00301 
00302   return parseSuccess;
00303 }

Boolean MediaSession::parseSDPLine_i ( char const * sdpLine ) [protected]

Definition at line 305 of file MediaSession.cpp.

References False, fSessionDescription, strDup(), strDupSize(), and True.

Referenced by initializeWithSDP().

00305                                                         {
00306   // Check for "i=<session description>" line
00307   char* buffer = strDupSize(sdpLine);
00308   Boolean parseSuccess = False;
00309 
00310   if (sscanf(sdpLine, "i=%[^\r\n]", buffer) == 1) {
00311     delete[] fSessionDescription; fSessionDescription = strDup(buffer);
00312     parseSuccess = True;
00313   }
00314   delete[] buffer;
00315 
00316   return parseSuccess;
00317 }

Boolean MediaSession::parseSDPLine_c ( char const * sdpLine ) [protected]

Definition at line 319 of file MediaSession.cpp.

References connectionEndpointName(), False, fConnectionEndpointName, NULL, parseCLine(), and True.

Referenced by initializeWithSDP().

00319                                                         {
00320   // Check for "c=IN IP4 <connection-endpoint>"
00321   // or "c=IN IP4 <connection-endpoint>/<ttl+numAddresses>"
00322   // (Later, do something with <ttl+numAddresses> also #####)
00323   char* connectionEndpointName = parseCLine(sdpLine);
00324   if (connectionEndpointName != NULL) {
00325     delete[] fConnectionEndpointName;
00326     fConnectionEndpointName = connectionEndpointName;
00327     return True;
00328   }
00329 
00330   return False;
00331 }

Boolean MediaSession::parseSDPAttribute_type ( char const * sdpLine ) [protected]

Definition at line 333 of file MediaSession.cpp.

References False, fMediaSessionType, strDup(), strDupSize(), and True.

Referenced by initializeWithSDP().

00333                                                                 {
00334   // Check for a "a=type:broadcast|meeting|moderated|test|H.332|recvonly" line:
00335   Boolean parseSuccess = False;
00336 
00337   char* buffer = strDupSize(sdpLine);
00338   if (sscanf(sdpLine, "a=type: %[^ ]", buffer) == 1) {
00339     delete[] fMediaSessionType;
00340     fMediaSessionType = strDup(buffer);
00341     parseSuccess = True;
00342   }
00343   delete[] buffer;
00344 
00345   return parseSuccess;
00346 }

Boolean MediaSession::parseSDPAttribute_control ( char const * sdpLine ) [protected]

Definition at line 348 of file MediaSession.cpp.

References controlPath(), False, fControlPath, strDup(), strDupSize(), and True.

Referenced by initializeWithSDP().

00348                                                                    {
00349   // Check for a "a=control:<control-path>" line:
00350   Boolean parseSuccess = False;
00351 
00352   char* controlPath = strDupSize(sdpLine); // ensures we have enough space
00353   if (sscanf(sdpLine, "a=control: %s", controlPath) == 1) {
00354     parseSuccess = True;
00355     delete[] fControlPath; fControlPath = strDup(controlPath);
00356   }
00357   delete[] controlPath;
00358 
00359   return parseSuccess;
00360 }

Boolean MediaSession::parseSDPAttribute_range ( char const * sdpLine ) [protected]

Definition at line 385 of file MediaSession.cpp.

References _absEndTime(), _absStartTime(), False, fMaxPlayEndTime, fMaxPlayStartTime, parseRangeAttribute(), playEndTime(), playStartTime(), and True.

Referenced by initializeWithSDP().

00385                                                                  {
00386   // Check for a "a=range:npt=<startTime>-<endTime>" line:
00387   // (Later handle other kinds of "a=range" attributes also???#####)
00388   Boolean parseSuccess = False;
00389 
00390   double playStartTime;
00391   double playEndTime;
00392   if (parseRangeAttribute(sdpLine, playStartTime, playEndTime)) {
00393     parseSuccess = True;
00394     if (playStartTime > fMaxPlayStartTime) {
00395       fMaxPlayStartTime = playStartTime;
00396     }
00397     if (playEndTime > fMaxPlayEndTime) {
00398       fMaxPlayEndTime = playEndTime;
00399     }
00400   } else if (parseRangeAttribute(sdpLine, _absStartTime(), _absEndTime())) {
00401     parseSuccess = True;
00402   }
00403 
00404   return parseSuccess;
00405 }

Boolean MediaSession::parseSDPAttribute_source_filter ( char const * sdpLine ) [protected]

Definition at line 436 of file MediaSession.cpp.

References fSourceFilterAddr, and parseSourceFilterAttribute().

Referenced by initializeWithSDP().

00436                                                      {
00437   return parseSourceFilterAttribute(sdpLine, fSourceFilterAddr);
00438 }

char * MediaSession::lookupPayloadFormat	(	unsigned char	rtpPayloadType,
		unsigned &	rtpTimestampFrequency,
		unsigned &	numChannels
	)			`[static, protected]`

Definition at line 440 of file MediaSession.cpp.

References NULL, and strDup().

Referenced by initializeWithSDP().

00441                                                                        {
00442   // Look up the codec name and timestamp frequency for known (static)
00443   // RTP payload formats.
00444   char const* temp = NULL;
00445   switch (rtpPayloadType) {
00446   case 0: {temp = "PCMU"; freq = 8000; nCh = 1; break;}
00447   case 2: {temp = "G726-32"; freq = 8000; nCh = 1; break;}
00448   case 3: {temp = "GSM"; freq = 8000; nCh = 1; break;}
00449   case 4: {temp = "G723"; freq = 8000; nCh = 1; break;}
00450   case 5: {temp = "DVI4"; freq = 8000; nCh = 1; break;}
00451   case 6: {temp = "DVI4"; freq = 16000; nCh = 1; break;}
00452   case 7: {temp = "LPC"; freq = 8000; nCh = 1; break;}
00453   case 8: {temp = "PCMA"; freq = 8000; nCh = 1; break;}
00454   case 9: {temp = "G722"; freq = 8000; nCh = 1; break;}
00455   case 10: {temp = "L16"; freq = 44100; nCh = 2; break;}
00456   case 11: {temp = "L16"; freq = 44100; nCh = 1; break;}
00457   case 12: {temp = "QCELP"; freq = 8000; nCh = 1; break;}
00458   case 14: {temp = "MPA"; freq = 90000; nCh = 1; break;}
00459     // 'number of channels' is actually encoded in the media stream
00460   case 15: {temp = "G728"; freq = 8000; nCh = 1; break;}
00461   case 16: {temp = "DVI4"; freq = 11025; nCh = 1; break;}
00462   case 17: {temp = "DVI4"; freq = 22050; nCh = 1; break;}
00463   case 18: {temp = "G729"; freq = 8000; nCh = 1; break;}
00464   case 25: {temp = "CELB"; freq = 90000; nCh = 1; break;}
00465   case 26: {temp = "JPEG"; freq = 90000; nCh = 1; break;}
00466   case 28: {temp = "NV"; freq = 90000; nCh = 1; break;}
00467   case 31: {temp = "H261"; freq = 90000; nCh = 1; break;}
00468   case 32: {temp = "MPV"; freq = 90000; nCh = 1; break;}
00469   case 33: {temp = "MP2T"; freq = 90000; nCh = 1; break;}
00470   case 34: {temp = "H263"; freq = 90000; nCh = 1; break;}
00471   };
00472 
00473   return strDup(temp);
00474 }

unsigned MediaSession::guessRTPTimestampFrequency	(	char const *	mediumName,
		char const *	codecName
	)			`[static, protected]`

Definition at line 476 of file MediaSession.cpp.

Referenced by initializeWithSDP().

00477                                                                          {
00478   // By default, we assume that audio sessions use a frequency of 8000,
00479   // video sessions use a frequency of 90000,
00480   // and text sessions use a frequency of 1000.
00481   // Begin by checking for known exceptions to this rule
00482   // (where the frequency is known unambiguously (e.g., not like "DVI4"))
00483   if (strcmp(codecName, "L16") == 0) return 44100;
00484   if (strcmp(codecName, "MPA") == 0
00485       || strcmp(codecName, "MPA-ROBUST") == 0
00486       || strcmp(codecName, "X-MP3-DRAFT-00")) return 90000;
00487 
00488   // Now, guess default values:
00489   if (strcmp(mediumName, "video") == 0) return 90000;
00490   else if (strcmp(mediumName, "text") == 0) return 1000;
00491   return 8000; // for "audio", and any other medium
00492 }

Boolean Medium::lookupByName	(	UsageEnvironment &	env,
		char const *	mediumName,
		Medium *&	resultMedium
	)			`[static, inherited]`

Definition at line 41 of file Media.cpp.

References env, False, MediaLookupTable::lookup(), NULL, MediaLookupTable::ourMedia(), UsageEnvironment::setResultMsg(), and True.

Referenced by ServerMediaSession::lookupByName(), RTSPServer::lookupByName(), RTSPClient::lookupByName(), RTCPInstance::lookupByName(), MediaSource::lookupByName(), MediaSink::lookupByName(), lookupByName(), and DarwinInjector::lookupByName().

00042                                                          {
00043   resultMedium = MediaLookupTable::ourMedia(env)->lookup(mediumName);
00044   if (resultMedium == NULL) {
00045     env.setResultMsg("Medium ", mediumName, " does not exist");
00046     return False;
00047   }
00048 
00049   return True;
00050 }

void Medium::close	(	UsageEnvironment &	env,
		char const *	mediumName
	)			`[static, inherited]`

Definition at line 52 of file Media.cpp.

References env, MediaLookupTable::ourMedia(), and MediaLookupTable::remove().

00052                                                           {
00053   MediaLookupTable::ourMedia(env)->remove(name);
00054 }

void Medium::close ( Medium * medium ) [static, inherited]

Definition at line 56 of file Media.cpp.

References Medium::close(), Medium::envir(), Medium::name(), and NULL.

00056                                  {
00057   if (medium == NULL) return;
00058 
00059   close(medium->envir(), medium->name());
00060 }

UsageEnvironment& Medium::envir ( ) const [inline, inherited]

Definition at line 59 of file Media.hh.

References Medium::fEnviron.

00059 {return fEnviron;}

char const* Medium::name ( ) const [inline, inherited]

Definition at line 61 of file Media.hh.

References Medium::fMediumName.

Referenced by QuickTimeFileSink::addAtom_hdlr2(), Medium::close(), MP3ADUTranscoder::createNew(), MP3FromADUSource::createNew(), ADUFromMP3Source::createNew(), and MP3FileSource::initializeStream().

00061 {return fMediumName;}

Boolean Medium::isSource ( ) const [virtual, inherited]

Reimplemented in MediaSource.

Definition at line 62 of file Media.cpp.

References False.

Referenced by MediaSource::lookupByName().

00062                                {
00063   return False; // default implementation
00064 }

Boolean Medium::isSink ( ) const [virtual, inherited]

Reimplemented in MediaSink.

Definition at line 66 of file Media.cpp.

References False.

Referenced by MediaSink::lookupByName().

00066                              {
00067   return False; // default implementation
00068 }

Boolean Medium::isRTCPInstance ( ) const [virtual, inherited]

Reimplemented in RTCPInstance.

Definition at line 70 of file Media.cpp.

References False.

Referenced by RTCPInstance::lookupByName().

00070                                      {
00071   return False; // default implementation
00072 }

Boolean Medium::isRTSPClient ( ) const [virtual, inherited]

Reimplemented in RTSPClient.

Definition at line 74 of file Media.cpp.

References False.

Referenced by RTSPClient::lookupByName().

00074                                    {
00075   return False; // default implementation
00076 }

Boolean Medium::isRTSPServer ( ) const [virtual, inherited]

Reimplemented in RTSPServer.

Definition at line 78 of file Media.cpp.

References False.

Referenced by RTSPServer::lookupByName().

00078                                    {
00079   return False; // default implementation
00080 }

Boolean Medium::isServerMediaSession ( ) const [virtual, inherited]

Reimplemented in ServerMediaSession.

Definition at line 86 of file Media.cpp.

References False.

Referenced by ServerMediaSession::lookupByName().

00086                                            {
00087   return False; // default implementation
00088 }

Boolean Medium::isDarwinInjector ( ) const [virtual, inherited]

Reimplemented in DarwinInjector.

Definition at line 90 of file Media.cpp.

References False.

Referenced by DarwinInjector::lookupByName().

00090                                        {
00091   return False; // default implementation
00092 }

TaskToken& Medium::nextTask ( ) [inline, protected, inherited]

Definition at line 78 of file Media.hh.

References Medium::fNextTask.

Referenced by BasicUDPSink::afterGettingFrame1(), MPEG4VideoFileServerMediaSubsession::afterPlayingDummy1(), H264VideoFileServerMediaSubsession::afterPlayingDummy1(), MPEG4VideoFileServerMediaSubsession::checkForAuxSDPLine1(), H264VideoFileServerMediaSubsession::checkForAuxSDPLine1(), MP3FileSource::doGetNextFrame(), AMRAudioFileSource::doGetNextFrame(), ADTSAudioFileSource::doGetNextFrame(), MultiFramedRTPSource::doGetNextFrame1(), WAVAudioFileSource::doReadFromFile(), ByteStreamFileSource::doReadFromFile(), MultiFramedRTPSource::doStopGettingFrames(), FramedSource::doStopGettingFrames(), ByteStreamFileSource::doStopGettingFrames(), RTCPInstance::reschedule(), RTCPInstance::schedule(), MultiFramedRTPSink::sendPacketIfNecessary(), and MediaSink::stopPlaying().

00078                         {
00079         return fNextTask;
00080   }

Friends And Related Function Documentation

friend class MediaSubsessionIterator [friend]

Definition at line 118 of file MediaSession.hh.

friend class MediaLookupTable [friend, inherited]

Definition at line 74 of file Media.hh.

Field Documentation

char* MediaSession::fCNAME [protected]

Definition at line 119 of file MediaSession.hh.

Referenced by CNAME(), MediaSession(), and ~MediaSession().

MediaSubsession* MediaSession::fSubsessionsHead [protected]

Definition at line 122 of file MediaSession.hh.

Referenced by hasSubsessions(), initializeWithSDP(), MediaSubsessionIterator::reset(), and ~MediaSession().

MediaSubsession* MediaSession::fSubsessionsTail [protected]

Definition at line 123 of file MediaSession.hh.

Referenced by initializeWithSDP().

char* MediaSession::fConnectionEndpointName [protected]

Definition at line 126 of file MediaSession.hh.

Referenced by connectionEndpointName(), parseSDPLine_c(), and ~MediaSession().

double MediaSession::fMaxPlayStartTime [protected]

Definition at line 127 of file MediaSession.hh.

Referenced by parseSDPAttribute_range(), and playStartTime().

double MediaSession::fMaxPlayEndTime [protected]

Definition at line 128 of file MediaSession.hh.

Referenced by parseSDPAttribute_range(), and playEndTime().

char* MediaSession::fAbsStartTime [protected]

Definition at line 129 of file MediaSession.hh.

Referenced by _absStartTime(), absStartTime(), and ~MediaSession().

char* MediaSession::fAbsEndTime [protected]

Definition at line 130 of file MediaSession.hh.

Referenced by _absEndTime(), absEndTime(), and ~MediaSession().

struct in_addr MediaSession::fSourceFilterAddr [read, protected]

Definition at line 131 of file MediaSession.hh.

Referenced by MediaSession(), parseSDPAttribute_source_filter(), and sourceFilterAddr().

float MediaSession::fScale [protected]

Definition at line 132 of file MediaSession.hh.

Referenced by scale().

char* MediaSession::fMediaSessionType [protected]

Definition at line 133 of file MediaSession.hh.

Referenced by mediaSessionType(), parseSDPAttribute_type(), and ~MediaSession().

char* MediaSession::fSessionName [protected]

Definition at line 134 of file MediaSession.hh.

Referenced by parseSDPLine_s(), sessionName(), and ~MediaSession().

char* MediaSession::fSessionDescription [protected]

Definition at line 135 of file MediaSession.hh.

Referenced by parseSDPLine_i(), sessionDescription(), and ~MediaSession().

char* MediaSession::fControlPath [protected]

Definition at line 136 of file MediaSession.hh.

Referenced by controlPath(), parseSDPAttribute_control(), and ~MediaSession().

The documentation for this class was generated from the following files:

liveMedia/include/MediaSession.hh
liveMedia/MediaSession.cpp

Generated on Mon Apr 29 13:31:44 2013 for live by

1.5.2

MediaSession Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation