MediaSession Class Reference

#include <MediaSession.hh>

Inheritance diagram for MediaSession:

[legend]Collaboration diagram for MediaSession:

[legend]

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

---

Detailed Description

Definition at line 33 of file MediaSession.hh.

---

Constructor & Destructor Documentation

MediaSession::MediaSession

(

UsageEnvironment &

env

)

[protected]

Definition at line 62 of file MediaSession.cpp.

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

Referenced by createNew().

  : Medium(env),
    fSubsessionsHead(NULL), fSubsessionsTail(NULL),
    fConnectionEndpointName(NULL), fMaxPlayStartTime(0.0f), fMaxPlayEndTime(0.0f),
    fScale(1.0f), fMediaSessionType(NULL), fSessionName(NULL), fSessionDescription(NULL),
    fControlPath(NULL) {
#ifdef SUPPORT_REAL_RTSP
  RealInitSDPAttributes(this);
#endif
  fSourceFilterAddr.s_addr = 0;

  // Get our host name, and use this for the RTCP CNAME:
  const unsigned maxCNAMElen = 100;
  char CNAME[maxCNAMElen+1];
#ifndef CRIS
  gethostname((char*)CNAME, maxCNAMElen);
#else
  // "gethostname()" isn't defined for this platform
  sprintf(CNAME, "unknown host %d", (unsigned)(our_random()*0x7FFFFFFF));
#endif
  CNAME[maxCNAMElen] = '\0'; // just in case
  fCNAME = strDup(CNAME);
}

MediaSession::~MediaSession

(

)

[protected, virtual]

Definition at line 86 of file MediaSession.cpp.

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

                            {
  delete fSubsessionsHead;
  delete[] fCNAME;
  delete[] fConnectionEndpointName;
  delete[] fMediaSessionType;
  delete[] fSessionName;
  delete[] fSessionDescription;
  delete[] fControlPath;
#ifdef SUPPORT_REAL_RTSP
  RealReclaimSDPAttributes(this);
#endif
}

---

Member Function Documentation

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().

                                                                  {
  MediaSession* newSession = new MediaSession(env);
  if (newSession != NULL) {
    if (!newSession->initializeWithSDP(sdpDescription)) {
      delete newSession;
      return NULL;
    }
  }

  return newSession;
}

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.

                                                                 {
  resultSession = NULL; // unless we succeed

  Medium* medium;
  if (!Medium::lookupByName(env, instanceName, medium)) return False;

  if (!medium->isMediaSession()) {
    env.setResultMsg(instanceName, " is not a 'MediaSession' object");
    return False;
  }

  resultSession = (MediaSession*)medium;
  return True;
}

Boolean MediaSession::hasSubsessions

(

)

const [inline]

Definition at line 41 of file MediaSession.hh.

References fSubsessionsHead, and NULL.

Referenced by main().

{ 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().

{ 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().

{ return fMaxPlayEndTime; }

char* MediaSession::connectionEndpointName

(

)

const [inline]

Definition at line 44 of file MediaSession.hh.

References fConnectionEndpointName.

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

{ return fConnectionEndpointName; }

char const* MediaSession::CNAME

(

)

const [inline]

Definition at line 45 of file MediaSession.hh.

References fCNAME.

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

{ return fCNAME; }

struct in_addr const& MediaSession::sourceFilterAddr

(

)

const [inline, read]

Definition at line 46 of file MediaSession.hh.

References fSourceFilterAddr.

{ return fSourceFilterAddr; }

float& MediaSession::scale

(

)

[inline]

Definition at line 47 of file MediaSession.hh.

References fScale.

Referenced by RTSPClient::playMediaSession().

{ return fScale; }

char* MediaSession::mediaSessionType

(

)

const [inline]

Definition at line 48 of file MediaSession.hh.

References fMediaSessionType.

Referenced by RTSPClient::setupMediaSubsession().

{ return fMediaSessionType; }

char* MediaSession::sessionName

(

)

const [inline]

Definition at line 49 of file MediaSession.hh.

References fSessionName.

{ return fSessionName; }

char* MediaSession::sessionDescription

(

)

const [inline]

Definition at line 50 of file MediaSession.hh.

References fSessionDescription.

{ 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().

{ 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.

                                               {
  // Look through this session's subsessions for media that match "mimeType"
  resultSubsession = NULL;
  MediaSubsessionIterator iter(*this);
  MediaSubsession* subsession;
  while ((subsession = iter.next()) != NULL) {
    Boolean wasAlreadyInitiated = subsession->readSource() != NULL;
    if (!wasAlreadyInitiated) {
      // Try to create a source for this subsession:
      if (!subsession->initiate(useSpecialRTPoffset)) return False;
    }

    // Make sure the source's MIME type is one that we handle:
    if (strcmp(subsession->readSource()->MIMEtype(), mimeType) != 0) {
      if (!wasAlreadyInitiated) subsession->deInitiate();
      continue;
    }

    resultSubsession = subsession;
    break; // use this
  }

  if (resultSubsession == NULL) {
    envir().setResultMsg("Session has no usable media subsession");
    return False;
  }

  return True;
}

Boolean MediaSession::isMediaSession

(

)

const [protected, virtual]

Reimplemented from Medium.

Definition at line 99 of file MediaSession.cpp.

References True.

                                           {
  return True;
}

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().

                                                                  {
  if (sdpDescription == NULL) return False;

  // Begin by processing all SDP lines until we see the first "m="
  char const* sdpLine = sdpDescription;
  char const* nextSDPLine;
  while (1) {
    if (!parseSDPLine(sdpLine, nextSDPLine)) return False;
    //##### We should really check for: 
    // - "a=control:" attributes (to set the URL for aggregate control)
    // - the correct SDP version (v=0)
    if (sdpLine[0] == 'm') break;
    sdpLine = nextSDPLine;
    if (sdpLine == NULL) break; // there are no m= lines at all 

    // Check for various special SDP lines that we understand:
    if (parseSDPLine_s(sdpLine)) continue;
    if (parseSDPLine_i(sdpLine)) continue;
    if (parseSDPLine_c(sdpLine)) continue;
    if (parseSDPAttribute_control(sdpLine)) continue;
    if (parseSDPAttribute_range(sdpLine)) continue;
    if (parseSDPAttribute_type(sdpLine)) continue;
    if (parseSDPAttribute_source_filter(sdpLine)) continue;
#ifdef SUPPORT_REAL_RTSP
    if (RealParseSDPAttributes(this, sdpLine)) continue;
#endif
  }
    
  while (sdpLine != NULL) {
    // We have a "m=" line, representing a new sub-session:
    MediaSubsession* subsession = new MediaSubsession(*this);
    if (subsession == NULL) {
      envir().setResultMsg("Unable to create new MediaSubsession");
      return False;
    }

    // Parse the line as "m=<medium_name> <client_portNum> RTP/AVP <fmt>"
    // or "m=<medium_name> <client_portNum>/<num_ports> RTP/AVP <fmt>"
    // (Should we be checking for >1 payload format number here?)#####
    char* mediumName = strDupSize(sdpLine); // ensures we have enough space
    char* protocolName = NULL;
    unsigned payloadFormat;
    if ((sscanf(sdpLine, "m=%s %hu RTP/AVP %u",
                mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 ||
         sscanf(sdpLine, "m=%s %hu/%*u RTP/AVP %u",
                mediumName, &subsession->fClientPortNum, &payloadFormat) == 3)
        && payloadFormat <= 127) {
      protocolName = "RTP";
    } else if ((sscanf(sdpLine, "m=%s %hu UDP %u",
                       mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 ||
                sscanf(sdpLine, "m=%s %hu udp %u",
                       mediumName, &subsession->fClientPortNum, &payloadFormat) == 3 ||
                sscanf(sdpLine, "m=%s %hu RAW/RAW/UDP %u",
                       mediumName, &subsession->fClientPortNum, &payloadFormat) == 3)
               && payloadFormat <= 127) {
      // This is a RAW UDP source
      protocolName = "UDP";
    } else {
      // This "m=" line is bad; output an error message saying so:
      char* sdpLineStr;
      if (nextSDPLine == NULL) {
        sdpLineStr = (char*)sdpLine;
      } else {
        sdpLineStr = strDup(sdpLine);
        sdpLineStr[nextSDPLine-sdpLine] = '\0';
      }
      envir() << "Bad SDP \"m=\" line: " <<  sdpLineStr << "\n";
      if (sdpLineStr != (char*)sdpLine) delete[] sdpLineStr;

      delete[] mediumName;
      delete subsession;

      // Skip the following SDP lines, up until the next "m=":
      while (1) {
        sdpLine = nextSDPLine;
        if (sdpLine == NULL) break; // we've reached the end
        if (!parseSDPLine(sdpLine, nextSDPLine)) return False;

        if (sdpLine[0] == 'm') break; // we've reached the next subsession
      }
      continue;
    }

    // Insert this subsession at the end of the list:
    if (fSubsessionsTail == NULL) {
      fSubsessionsHead = fSubsessionsTail = subsession;
    } else {
      fSubsessionsTail->setNext(subsession);
      fSubsessionsTail = subsession;
    }

    subsession->serverPortNum = subsession->fClientPortNum; // by default

    char const* mStart = sdpLine;
    subsession->fSavedSDPLines = strDup(mStart);

    subsession->fMediumName = strDup(mediumName);
    delete[] mediumName;
    subsession->fProtocolName = strDup(protocolName);
    subsession->fRTPPayloadFormat = payloadFormat;

    // Process the following SDP lines, up until the next "m=":
    while (1) {
      sdpLine = nextSDPLine;
      if (sdpLine == NULL) break; // we've reached the end
      if (!parseSDPLine(sdpLine, nextSDPLine)) return False;

      if (sdpLine[0] == 'm') break; // we've reached the next subsession

      // Check for various special SDP lines that we understand:
      if (subsession->parseSDPLine_c(sdpLine)) continue;
      if (subsession->parseSDPAttribute_rtpmap(sdpLine)) continue;
      if (subsession->parseSDPAttribute_control(sdpLine)) continue;
      if (subsession->parseSDPAttribute_range(sdpLine)) continue;
      if (subsession->parseSDPAttribute_fmtp(sdpLine)) continue;
      if (subsession->parseSDPAttribute_source_filter(sdpLine)) continue;
      if (subsession->parseSDPAttribute_x_dimensions(sdpLine)) continue;
      if (subsession->parseSDPAttribute_framerate(sdpLine)) continue;
#ifdef SUPPORT_REAL_RTSP
      if (RealParseSDPAttributes(subsession, sdpLine)) continue;
#endif

      // (Later, check for malformed lines, and other valid SDP lines#####)
    }
    if (sdpLine != NULL) subsession->fSavedSDPLines[sdpLine-mStart] = '\0';

    // If we don't yet know the codec name, try looking it up from the
    // list of static payload types:
    if (subsession->fCodecName == NULL) {
      subsession->fCodecName
        = lookupPayloadFormat(subsession->fRTPPayloadFormat,
                              subsession->fRTPTimestampFrequency,
                              subsession->fNumChannels);
      if (subsession->fCodecName == NULL) {
        char typeStr[20];
        sprintf(typeStr, "%d", subsession->fRTPPayloadFormat);
        envir().setResultMsg("Unknown codec name for RTP payload type ",
                             typeStr);
        return False;
      }
    }

    // If we don't yet know this subsession's RTP timestamp frequency
    // (because it uses a dynamic payload type and the corresponding
    // SDP "rtpmap" attribute erroneously didn't specify it),
    // then guess it now:
    if (subsession->fRTPTimestampFrequency == 0) {
      subsession->fRTPTimestampFrequency
        = guessRTPTimestampFrequency(subsession->fMediumName,
                                     subsession->fCodecName);
    }
  }

  return True;
}

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().

                                                         {
  // Begin by finding the start of the next line (if any):
  nextLine = NULL;
  for (char const* ptr = inputLine; *ptr != '\0'; ++ptr) {
    if (*ptr == '\r' || *ptr == '\n') {
      // We found the end of the line
      ++ptr;
      while (*ptr == '\r' || *ptr == '\n') ++ptr;
      nextLine = ptr;
      if (nextLine[0] == '\0') nextLine = NULL; // special case for end
      break;
    }
  }

  // Then, check that this line is a SDP line of the form <char>=<etc>
  // (However, we also accept blank lines in the input.)
  if (inputLine[0] == '\r' || inputLine[0] == '\n') return True;
  if (strlen(inputLine) < 2 || inputLine[1] != '='
      || inputLine[0] < 'a' || inputLine[0] > 'z') {
    envir().setResultMsg("Invalid SDP line: ", inputLine);
    return False;
  }

  return True;
}

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().

                                                        {
  // Check for "s=<session name>" line
  char* buffer = strDupSize(sdpLine);
  Boolean parseSuccess = False;
  
  if (sscanf(sdpLine, "s=%[^\r\n]", buffer) == 1) {
    delete[] fSessionName; fSessionName = strDup(buffer);
    parseSuccess = True;
  }
  delete[] buffer;

  return parseSuccess;
}

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().

                                                        {
  // Check for "i=<session description>" line
  char* buffer = strDupSize(sdpLine);
  Boolean parseSuccess = False;
  
  if (sscanf(sdpLine, "i=%[^\r\n]", buffer) == 1) {
    delete[] fSessionDescription; fSessionDescription = strDup(buffer);
    parseSuccess = True;
  }
  delete[] buffer;

  return parseSuccess;
}  

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().

                                                        {
  // Check for "c=IN IP4 <connection-endpoint>"
  // or "c=IN IP4 <connection-endpoint>/<ttl+numAddresses>"
  // (Later, do something with <ttl+numAddresses> also #####)
  char* connectionEndpointName = parseCLine(sdpLine);
  if (connectionEndpointName != NULL) {
    delete[] fConnectionEndpointName;
    fConnectionEndpointName = connectionEndpointName;
    return True;
  }

  return False;
}

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().

                                                                {
  // Check for a "a=type:broadcast|meeting|moderated|test|H.332|recvonly" line:
  Boolean parseSuccess = False;

  char* buffer = strDupSize(sdpLine);
  if (sscanf(sdpLine, "a=type: %[^ ]", buffer) == 1) {
    delete[] fMediaSessionType;
    fMediaSessionType = strDup(buffer);
    parseSuccess = True;
  }
  delete[] buffer;

  return parseSuccess;
}

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().

                                                                   {
  // Check for a "a=control:<control-path>" line:
  Boolean parseSuccess = False;

  char* controlPath = strDupSize(sdpLine); // ensures we have enough space
  if (sscanf(sdpLine, "a=control: %s", controlPath) == 1) {
    parseSuccess = True;
    delete[] fControlPath; fControlPath = strDup(controlPath);
  }
  delete[] controlPath;

  return parseSuccess;
}

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().

                                                                 {
  // Check for a "a=range:npt=<startTime>-<endTime>" line:
  // (Later handle other kinds of "a=range" attributes also???#####)
  Boolean parseSuccess = False;

  float playStartTime;
  float playEndTime;
  if (parseRangeAttribute(sdpLine, playStartTime, playEndTime)) {
    parseSuccess = True;
    if (playStartTime > fMaxPlayStartTime) {
      fMaxPlayStartTime = playStartTime;
    }
    if (playEndTime > fMaxPlayEndTime) {
      fMaxPlayEndTime = playEndTime;
    }
  }

  return parseSuccess;
}

Boolean MediaSession::parseSDPAttribute_source_filter

(

char const *

sdpLine

)

[protected]

Definition at line 422 of file MediaSession.cpp.

References fSourceFilterAddr, and parseSourceFilterAttribute().

Referenced by initializeWithSDP().

                                                     {
  return parseSourceFilterAttribute(sdpLine, fSourceFilterAddr);
}

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().

                                                                       {
  // Look up the codec name and timestamp frequency for known (static)
  // RTP payload formats.
  char* temp = NULL;
  switch (rtpPayloadType) {
  case 0: {temp = "PCMU"; freq = 8000; nCh = 1; break;}
  case 2: {temp = "G726-32"; freq = 8000; nCh = 1; break;}
  case 3: {temp = "GSM"; freq = 8000; nCh = 1; break;}
  case 4: {temp = "G723"; freq = 8000; nCh = 1; break;}
  case 5: {temp = "DVI4"; freq = 8000; nCh = 1; break;}
  case 6: {temp = "DVI4"; freq = 16000; nCh = 1; break;}
  case 7: {temp = "LPC"; freq = 8000; nCh = 1; break;}
  case 8: {temp = "PCMA"; freq = 8000; nCh = 1; break;}
  case 9: {temp = "G722"; freq = 8000; nCh = 1; break;}
  case 10: {temp = "L16"; freq = 44100; nCh = 2; break;}
  case 11: {temp = "L16"; freq = 44100; nCh = 1; break;}
  case 12: {temp = "QCELP"; freq = 8000; nCh = 1; break;}
  case 14: {temp = "MPA"; freq = 90000; nCh = 1; break;}
    // 'number of channels' is actually encoded in the media stream
  case 15: {temp = "G728"; freq = 8000; nCh = 1; break;}
  case 16: {temp = "DVI4"; freq = 11025; nCh = 1; break;}
  case 17: {temp = "DVI4"; freq = 22050; nCh = 1; break;}
  case 18: {temp = "G729"; freq = 8000; nCh = 1; break;}
  case 25: {temp = "CELB"; freq = 90000; nCh = 1; break;}
  case 26: {temp = "JPEG"; freq = 90000; nCh = 1; break;}
  case 28: {temp = "NV"; freq = 90000; nCh = 1; break;}
  case 31: {temp = "H261"; freq = 90000; nCh = 1; break;}
  case 32: {temp = "MPV"; freq = 90000; nCh = 1; break;}
  case 33: {temp = "MP2T"; freq = 90000; nCh = 1; break;}
  case 34: {temp = "H263"; freq = 90000; nCh = 1; break;}
  };

  return strDup(temp);
}

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

Definition at line 462 of file MediaSession.cpp.

Referenced by initializeWithSDP().

                                                                         {
  // By default, we assume that audio sessions use a frequency of 8000,
  // and that video sessions use a frequency of 90000.
  // Begin by checking for known exceptions to this rule
  // (where the frequency is known unambiguously (e.g., not like "DVI4"))
  if (strcmp(codecName, "L16") == 0) return 44100;
  if (strcmp(codecName, "MPA") == 0
      || strcmp(codecName, "MPA-ROBUST") == 0
      || strcmp(codecName, "X-MP3-DRAFT-00")) return 90000;

  // No