/* ------------------------------------------------------------------
* Copyright (C) 1998-2009 PacketVideo
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied.
* See the License for the specific language governing permissions
* and limitations under the License.
* -------------------------------------------------------------------
*/
#include "base_media_info_parser.h"
#include "oscl_string_utils.h"
#include "oscl_string_containers.h"
#include "rtsp_range_utils.h"
/* Function to allocate temporary buffer, OSCL_TRY() put here to avoid */
/* compiler warnings */
static void newTmpBuf(uint32 len, char** buf)
{
int32 err;
*buf = NULL;
OSCL_TRY(err, *buf = OSCL_ARRAY_NEW(char, len));
if (err != OsclErrNone)
{
*buf = NULL;
}
}
SDP_ERROR_CODE
SDPBaseMediaInfoParser::baseMediaInfoParser(const char* buff,
mediaInfo* mediaStr,
const int index,
const int alt_id,
bool alt_def_id,
bool isSipSdp)
{
const char *current_start = buff; //Pointer to the beginning of the media text
const char *end = buff + index; //Pointer to the end of the media text
const char *line_start_ptr, *line_end_ptr;
bool a_range_found = false;
bool a_rtpmap_found = false;
bool a_control_found = false;
bool a_control_set = false;
OsclMemoryFragment memFrag;
while (get_next_line(current_start, end,
line_start_ptr, line_end_ptr))
{
if ((!alt_def_id && !alt_id) || (alt_def_id) ||
((!alt_def_id) && !oscl_strncmp(line_start_ptr, "a=alt:", oscl_strlen("a=alt:"))))
{
if (!alt_def_id && !oscl_strncmp(line_start_ptr, "a=alt:", oscl_strlen("a=alt:")))
{
line_start_ptr += oscl_strlen("a=alt:");
const char *end1 = line_start_ptr;
for (; *end1 != ':'; end1++);
uint32 id;
if (!PV_atoi(line_start_ptr, 'd' , end1 - line_start_ptr, id))
return SDP_BAD_MEDIA_ALT_ID;
if ((int)id != alt_id)
{
//check if id is already present
Oscl_Vector<int, SDPParserAlloc> alt_track = mediaStr->getalternateTrackId();
bool found = false;
for (int ss = 0; ss < (int)alt_track.size(); ss++)
{
if (alt_track[ss] == (int)id)
found = true;
}
if (!found)
mediaStr->setalternateTrackId(id);
current_start = line_end_ptr;
continue;
}
line_start_ptr = end1 + 1;
line_start_ptr = skip_whitespace(line_start_ptr, line_end_ptr);
}
switch (*line_start_ptr)
{
case 'm':
{
if (*(line_start_ptr + 1) != '=')
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format"));
return SDP_BAD_MEDIA_FORMAT;
}
// parse through each field
const char *sptr, *eptr;
//line_start_ptr+2 since we need to start looking beyond the '=' sign
//get the media type (audio, video, application)
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for media type"));
return SDP_BAD_MEDIA_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format"));
return SDP_BAD_MEDIA_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
mediaStr->setType(memFrag);
//get the suggested port number
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for suggested port"));
return SDP_BAD_MEDIA_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format"));
return SDP_BAD_MEDIA_FORMAT;
}
uint32 suggestedPort;
OSCL_HeapString<SDPParserAlloc> restOfLine(sptr, eptr - sptr);
const char *slash = oscl_strstr(restOfLine.get_cstr(), "/");
if (slash)
{
if (PV_atoi(restOfLine.get_cstr(), 'd', (slash - restOfLine.get_cstr()), suggestedPort) == true)
{
mediaStr->setSuggestedPort(suggestedPort);
// There must be number of ports info after the slash
uint32 numOfPorts;
const char *ports = oscl_strstr(sptr, "/");
ports++;
if (ports == NULL)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for ports info"));
return SDP_BAD_MEDIA_FORMAT;
}
if (PV_atoi(ports, 'd', (eptr - ports), numOfPorts) == true)
{
mediaStr->setNumOfPorts(numOfPorts);
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for ports info"));
return SDP_BAD_MEDIA_FORMAT;
}
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for ports info"));
return SDP_BAD_MEDIA_FORMAT;
}
}
else
{
if (PV_atoi(sptr, 'd', (eptr - sptr), suggestedPort) == true)
{
mediaStr->setSuggestedPort(suggestedPort);
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for ports info"));
return SDP_BAD_MEDIA_FORMAT;
}
}
//get the transport profile
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for tranport profile"));
return SDP_BAD_MEDIA_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for tranport profile"));
return SDP_BAD_MEDIA_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
if (oscl_strncmp(sptr, "RTP/AVP", (eptr - sptr)) && oscl_strncmp(sptr, "RTP/AVPF", (eptr - sptr)) && oscl_strncmp(sptr, "RTP/SAVP", (eptr - sptr)))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for tranport profile"));
return SDP_BAD_MEDIA_FORMAT;
}
else if ((suggestedPort % 2)) // port number should be even
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format - port number is not even"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setTransportProfile(memFrag);
//get the payload number
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for payload number"));
return SDP_BAD_MEDIA_FORMAT;
}
while (eptr < line_end_ptr)
{
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for payload number"));
return SDP_BAD_MEDIA_FORMAT;
}
uint32 payloadNumber; ;
if (PV_atoi(sptr, 'd', (eptr - sptr), payloadNumber) == true)
{
// Parse the payload number info only and see if there
// is any payload number in static range if yes rtpmap
// field may not be present for this
for (uint32 ii = 0; ii < mediaStr->getPayloadSpecificInfoVector().size(); ii++)
{
if (payloadNumber == mediaStr->getPayloadSpecificInfoVector()[ii]->getPayloadNumber())
{
// check if (FIRST_STATIC_PAYLOAD <= payloadNumber <= LAST_STATIC_PAYLOAD)
// since payloadNumber is unsigned and FIRST_STATIC_PAYLOAD == 0, only the upper
// boundary needs to be checked. Adding the lower boundary causes compiler warning.
if (payloadNumber <= LAST_STATIC_PAYLOAD)
a_rtpmap_found = true;
}
}
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad m= line format for payload number"));
return SDP_BAD_MEDIA_FORMAT;
}
sptr = skip_whitespace(eptr, line_end_ptr);
eptr = sptr;
}
// No rtpmap will come if port is 0 in sip sdp
if (isSipSdp && suggestedPort == 0)
{
a_rtpmap_found = true;
}
}
break;
case 'a':
{
if (*(line_start_ptr + 1) != '=')
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a= line format - '=' missing"));
return SDP_BAD_MEDIA_FORMAT;
}
// parse through each field
const char *sptr1, *eptr1;
if (!oscl_strncmp(line_start_ptr, "a=rtpmap:", oscl_strlen("a=rtpmap:")))
{
//get the payload number
sptr1 = line_start_ptr + oscl_strlen("a=rtpmap:");
sptr1 = skip_whitespace(sptr1, line_end_ptr);
a_rtpmap_found = true;
if (sptr1 >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format"));
return SDP_BAD_MEDIA_RTP_MAP;
}
eptr1 = skip_to_whitespace(sptr1, line_end_ptr);
if (eptr1 <= sptr1)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format"));
return SDP_BAD_MEDIA_RTP_MAP;
}
uint32 payloadNumber;
if (PV_atoi(sptr1, 'd', (eptr1 - sptr1), payloadNumber) == true)
{
int p;
if (!mediaStr->lookupPayloadNumber(payloadNumber, p))
{
break;
}
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format for payload number"));
return SDP_BAD_MEDIA_RTP_MAP;
}
// payloadNumber is present in the mediaInfo. get the payload
// Specific pointer corresponding to this payload
PayloadSpecificInfoTypeBase* payloadPtr =
mediaStr->getPayloadSpecificInfoTypePtr(payloadNumber);
if (payloadPtr == NULL)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Unable to get payload pointer for the payload"));
return SDP_PAYLOAD_MISMATCH;
}
PVMF_SDP_PARSER_LOGINFO((0, "SDPBaseMediaInfoParser::parseMediaInfo - processing payload number : %d", payloadNumber));
//get the MIME type and sample rate
sptr1 = skip_whitespace(eptr1, line_end_ptr);
if (sptr1 >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format for MIME Type & Sample rate"));
return SDP_BAD_MEDIA_RTP_MAP;
}
eptr1 = skip_to_whitespace(sptr1, line_end_ptr);
if (eptr1 <= sptr1)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format"));
return SDP_BAD_MEDIA_RTP_MAP;
}
//int ii = 0;
const char *tmp_end_ptr = NULL;
/*
for( ii = 0; ii < (eptr1-sptr1); ii++ )
{
if(sptr1[ii] == '/')
{
tmp_end_ptr = sptr1 + ii;
break;
}
}
*/
const char SDP_FWD_SLASH[] = "/";
tmp_end_ptr = oscl_strstr(sptr1, SDP_FWD_SLASH);
if (tmp_end_ptr == NULL)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format - nothing after '/' "));
return SDP_BAD_MEDIA_RTP_MAP;
}
//The below mentioned code converts the non standard MIME type to standard MIME type.
//For eg. earlier we have MIME type "AMR" and according to standard it should be
//like "audio/AMR". so tho whole logic implements the same.
uint32 tempBufLen = 0;
char *tmpBuf = NULL;
const char SDP_NULL[] = "\0";
tempBufLen = oscl_strlen(mediaStr->getType()) + (tmp_end_ptr - sptr1) + 2;
// "OSCL_TRY(err, OSCL_ARRAY_NEW(char, tempBufLen)" is in separate function to avoid warnings
newTmpBuf(tempBufLen, &tmpBuf);
if (NULL == tmpBuf)
{
return SDP_NO_MEMORY;
}
oscl_strncpy(tmpBuf, mediaStr->getType(), (oscl_strlen(mediaStr->getType()) + 1));
oscl_strcat(tmpBuf, SDP_FWD_SLASH);
oscl_strncat(tmpBuf, sptr1, (tmp_end_ptr - sptr1));
oscl_strcat(tmpBuf, SDP_NULL);
memFrag.ptr = (void*)tmpBuf;
memFrag.len = oscl_strlen(tmpBuf);
mediaStr->setMIMEType(memFrag);
OSCL_ARRAY_DELETE(tmpBuf);
tmpBuf = NULL;
//Till here
tmp_end_ptr++;
if (tmp_end_ptr >= eptr1)
{
return SDP_BAD_MEDIA_RTP_MAP;
}
tmp_end_ptr = skip_whitespace(tmp_end_ptr, eptr1);
if (tmp_end_ptr >= eptr1)
{
return SDP_BAD_MEDIA_RTP_MAP;
}
OSCL_HeapString<SDPParserAlloc> restOfLine(tmp_end_ptr, eptr1 - tmp_end_ptr);
const char *another_slash = oscl_strstr(restOfLine.get_cstr(), SDP_FWD_SLASH);
uint32 sampleRate;
if (another_slash)
{
if (PV_atoi(restOfLine.get_cstr(), 'd', (another_slash - restOfLine.get_cstr()), sampleRate) == true)
{
payloadPtr->setSampleRate(sampleRate);
// There must be channel numbers after the 2nd forward slash
uint32 channels;
tmp_end_ptr = oscl_strstr(tmp_end_ptr, SDP_FWD_SLASH);
if (tmp_end_ptr == NULL)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format for channel info"));
return SDP_BAD_MEDIA_RTP_MAP;
}
tmp_end_ptr++;
if (PV_atoi(tmp_end_ptr, 'd', (eptr1 - tmp_end_ptr), channels) == true)
{
payloadPtr->setNoOfChannels(channels);
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format for channel info"));
return SDP_BAD_MEDIA_RTP_MAP;
}
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtpmap line format for channel info"));
return SDP_BAD_MEDIA_RTP_MAP;
}
}
else
{
if (PV_atoi(tmp_end_ptr, 'd', (eptr1 - tmp_end_ptr), sampleRate) == true)
{
payloadPtr->setSampleRate(sampleRate);
}
else
{
return SDP_BAD_MEDIA_RTP_MAP;
}
}
}
if (!oscl_strncmp(line_start_ptr, "a=control:", oscl_strlen("a=control:")))
{
sptr1 = line_start_ptr + oscl_strlen("a=control:");
sptr1 = skip_whitespace(sptr1, line_end_ptr);
a_control_found = true;
if (sptr1 >= line_end_ptr)
{
return SDP_BAD_MEDIA_CONTROL_FIELD;
}
memFrag.ptr = (void*)sptr1;
memFrag.len = (line_end_ptr - sptr1);
mediaStr->setControlURL(memFrag);
for (int ii = 0; ii < (line_end_ptr - sptr1); ii++)
{
if (sptr1[ii] == '=')
{
uint32 trackID;
sptr1 = skip_whitespace((sptr1 + ii + 1), line_end_ptr);
if (sptr1 >= line_end_ptr)
{
break;
}
if ((PV_atoi(sptr1, 'd', 1, trackID) == true))
{
mediaStr->setControlTrackID(trackID);
}
break;
}
}
}
if (!oscl_strncmp(line_start_ptr, "a=range:", oscl_strlen("a=range:")))
{
sptr1 = line_start_ptr + oscl_strlen("a=range:");
sptr1 = skip_whitespace(sptr1, line_end_ptr);
a_range_found = true;
if (sptr1 >= line_end_ptr)
{
return SDP_BAD_MEDIA_RANGE_FIELD;
}
parseRtspRange(sptr1, line_end_ptr - sptr1, *(mediaStr->getRtspRange()));
}
if (!oscl_strncmp(line_start_ptr, "a=depends_on:", oscl_strlen("a=depends_on:")))
{
sptr1 = line_start_ptr + oscl_strlen("a=depends_on:");
memFrag.ptr = (void*)sptr1;
memFrag.len = (line_end_ptr - sptr1);
mediaStr->setDependsonURL(memFrag);
for (int ii = 0; ii < (line_end_ptr - sptr1); ii++)
{
if (sptr1[ii] == '=')
{
uint32 trackID;
sptr1 = skip_whitespace((sptr1 + ii + 1), line_end_ptr);
if (sptr1 >= line_end_ptr)
{
break;
}
if ((PV_atoi(sptr1, 'd', 1, trackID) == true))
{
mediaStr->setDependsOnTrackID(trackID);
}
break;
}
}
}
//Random access denied added for 3rd party content random positioning - 01/08/02
StrPtrLen random_access("a=random_access_denied");
if (!oscl_strncmp(line_start_ptr, random_access.c_str(), random_access.length()))
{
mediaStr->setRandomAccessDenied(true);
}
StrPtrLen qoe_metrics("a=3GPP-QoE-Metrics:");
if (!oscl_strncmp(line_start_ptr, qoe_metrics.c_str(), qoe_metrics.length()))
{
const char *sptr;
sptr = line_start_ptr + qoe_metrics.length();
QoEMetricsType qMetrics;
oscl_memset(qMetrics.name, 0, 7);
qMetrics.rateFmt = QoEMetricsType::VAL;
qMetrics.rateVal = 0;
qMetrics.paramFmt = QoEMetricsType::IDIGIT;
qMetrics.paramExtIdigit = 0;
if (!parseQoEMetrics(sptr, line_end_ptr, qMetrics))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=3GPP-QoE-Metrics: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setQoEMetrics(qMetrics);
}
StrPtrLen predec("a=X-predecbufsize:");
if (!oscl_strncmp(line_start_ptr, predec.c_str(), predec.length()))
{
const char *sptr;
sptr = line_start_ptr + predec.length();
uint32 size;
if (!PV_atoi(sptr, 'd', (line_end_ptr - sptr), size))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=X-predecbufsize: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setPreDecBuffSize(size);
}
StrPtrLen initpredec("a=X-initpredecbufperiod:");
if (!oscl_strncmp(line_start_ptr, initpredec.c_str(), initpredec.length()))
{
const char *sptr;
sptr = line_start_ptr + initpredec.length();
uint32 period;
if (!PV_atoi(sptr, 'd', (line_end_ptr - sptr), period))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=X-initpredecbufperiod: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setInitPreDecBuffPeriod(period);
}
StrPtrLen initpostdec("a=X-initpostdecbufperiod:");
if (!oscl_strncmp(line_start_ptr, initpostdec.c_str(), initpostdec.length()))
{
const char *sptr;
sptr = line_start_ptr + initpostdec.length();
uint32 period;
if (!PV_atoi(sptr, 'd', (line_end_ptr - sptr), period))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=X-initpostdecbufperiod: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setInitPostDecBuffPeriod(period);
}
StrPtrLen decbyterate("a=X-decbyterate:");
if (!oscl_strncmp(line_start_ptr, decbyterate.c_str(),
decbyterate.length()))
{
const char *sptr;
sptr = line_start_ptr + decbyterate.length();
uint32 rate;
if (!PV_atoi(sptr, 'd', (line_end_ptr - sptr), rate))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=X-decbyterate: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setDecByteRate(rate);
}
StrPtrLen adapt_supp("a=3GPP-Adaptation-Support:");
if (!oscl_strncmp(line_start_ptr, adapt_supp.c_str(),
adapt_supp.length()))
{
const char *sptr = line_start_ptr + adapt_supp.length();
sptr = skip_whitespace_and_line_term(sptr, line_end_ptr);
uint32 frequency;
if (!PV_atoi(sptr, 'd', line_end_ptr - sptr, frequency))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=3GPP-Adaptation-Support: line format - frequency not correct"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setReportFrequency(frequency);
}
StrPtrLen asset_info("a=3GPP-Asset-Information:");
if (!oscl_strncmp(line_start_ptr, asset_info.c_str(),
asset_info.length()))
{
const char *sptr = line_start_ptr + asset_info.length();
AssetInfoType assetInfo;
if (!parseAssetInfo(sptr, line_end_ptr, assetInfo))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=3GPP-Asset-Information: line format"));
return SDP_BAD_SESSION_FORMAT;
}
mediaStr->setAssetInfo(assetInfo);
}
StrPtrLen srtp("a=3GPP-SRTP-Config:");
if (!oscl_strncmp(line_start_ptr, srtp.c_str(),
srtp.length()))
{
const char *sptr = line_start_ptr + srtp.length();
const char *eptr;
sptr = skip_whitespace(sptr, line_end_ptr);
eptr = skip_to_whitespace(sptr, line_end_ptr);
memFrag.ptr = (void *)sptr;
memFrag.len = eptr - sptr;
mediaStr->setSRTPintg_nonce(memFrag);
eptr = eptr + 1;
sptr = eptr;
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=3GPP-SRTP-Config: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
eptr = skip_to_whitespace(eptr, line_end_ptr);
if (eptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=3GPP-SRTP-Config: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
memFrag.ptr = (void *)sptr;
memFrag.len = eptr - sptr;
mediaStr->setSRTPkey_salt(memFrag);
eptr = eptr + 1;
sptr = eptr;
if (!oscl_strncmp(sptr, "auth-tag-len=", oscl_strlen("auth-tag-len=")))
{
sptr = sptr + oscl_strlen("auth-tag-len=");
uint32 length;
if (!PV_atoi(sptr, 'd', 2, length))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=3GPP-SRTP-Config: line format for auth-tag-len= field"));
return SDP_BAD_MEDIA_FORMAT;
}
if ((length != 32) && (length != 80))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=3GPP-SRTP-Config: line format for auth-tag-len= field"));
return SDP_BAD_MEDIA_FORMAT;
}
else
mediaStr->setSRTPauth_tag_len(length);
}
else
{
memFrag.ptr = (void *)sptr;
memFrag.len = line_end_ptr - sptr;
mediaStr->setSRTPparam_ext(memFrag);
}
}
StrPtrLen rtcp_fb("a=rtcp-fb:");
if (!oscl_strncmp(line_start_ptr, rtcp_fb.c_str(), rtcp_fb.length()))
{
const char *sptr = line_start_ptr + rtcp_fb.length();
const char *eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtcp-fb: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
memFrag.ptr = (void *)sptr;
memFrag.len = eptr - sptr;
mediaStr->setrtcp_fb_pt(memFrag);
sptr = skip_whitespace(eptr, line_end_ptr);
eptr = skip_to_whitespace(sptr, line_end_ptr);
memFrag.ptr = (void *)sptr;
memFrag.len = eptr - sptr;
mediaStr->setrtcp_fb_val(memFrag);
if (eptr >= line_end_ptr)
break;
if (!oscl_strncmp(sptr, "trr-int", eptr - sptr))
{
sptr = skip_whitespace(eptr, line_end_ptr);
eptr = skip_to_line_term(sptr, line_end_ptr);
uint32 trr;
if (!PV_atoi(sptr, 'd', eptr - sptr, trr))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=rtcp-fb: line format for trr-int field"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setrtcp_fb_trr_val(trr);
}
else
{
sptr = skip_whitespace(eptr, line_end_ptr);
eptr = skip_to_line_term(sptr, line_end_ptr);
memFrag.ptr = (void *)sptr;
memFrag.len = eptr - sptr;
mediaStr->setrtcp_fb_val_param(memFrag);
}
}
if (!oscl_strncmp(line_start_ptr, "a=alt:", oscl_strlen("a=alt:")))
{
line_start_ptr += oscl_strlen("a=alt:");
const char *end1 = line_start_ptr;
for (; *end1 != ':'; end1++);
uint32 id;
if (!PV_atoi(line_start_ptr, 'd' , end1 - line_start_ptr, id))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad ID in a=alt: line format"));
return SDP_BAD_MEDIA_ALT_ID;
}
//check if id is already present
Oscl_Vector<int, SDPParserAlloc> alt_track = mediaStr->getalternateTrackId();
bool found = false;
for (int ss = 0; ss < (int)alt_track.size(); ss++)
{
if (alt_track[ss] == (int)id)
found = true;
}
if (!found)
mediaStr->setalternateTrackId(id);
}
if (!oscl_strncmp(line_start_ptr, "a=maxprate:", oscl_strlen("a=maxprate:")))
{
line_start_ptr += oscl_strlen("a=maxprate:");
OsclFloat rate;
if (!PV_atof(line_start_ptr, line_end_ptr - line_start_ptr, rate))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad a=maxprate: line format for rate field"));
return SDP_BAD_MEDIA_FORMAT;
}
mediaStr->setMaxprate(rate);
}
if (!oscl_strncmp(line_start_ptr, "a=X-allowrecord", oscl_strlen("a=X-allowrecord")))
{
mediaStr->setAllowRecord(true);
}
}
break;
case 'b':
{
if (!oscl_strncmp(line_start_ptr, "b=AS:", oscl_strlen("b=AS:")))
{
const char *sptr;
sptr = line_start_ptr + oscl_strlen("b=AS:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad b=AS: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
uint32 bitRate;
if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), bitRate) == true)
{
mediaStr->setBitrate(1000*bitRate);
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad b=AS: line format - bitrate incorrect"));
return SDP_BAD_MEDIA_FORMAT;
}
}
else if (!oscl_strncmp(line_start_ptr, "b=RS:", oscl_strlen("b=RS:")))
{
const char *sptr;
sptr = line_start_ptr + oscl_strlen("b=AS:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad b=RS: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
uint32 rtcpBWSender;
if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), rtcpBWSender) == true)
{
mediaStr->setRTCPSenderBitRate(rtcpBWSender);
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad b=RS: line format - Sender Bitrate incorrect"));
return SDP_BAD_MEDIA_FORMAT;
}
}
else if (!oscl_strncmp(line_start_ptr, "b=RR:", oscl_strlen("b=RR:")))
{
const char *sptr;
sptr = line_start_ptr + oscl_strlen("b=AS:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad b=RR: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
uint32 rtcpBWReceiver;
if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), rtcpBWReceiver) == true)
{
mediaStr->setRTCPReceiverBitRate(rtcpBWReceiver);
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad b=RR: line format - Receiver Bit rate incorrect"));
return SDP_BAD_MEDIA_FORMAT;
}
}
else if (!oscl_strncmp(line_start_ptr, "b=TIAS:", oscl_strlen("b=TIAS:")))
{
const char *sptr;
sptr = line_start_ptr + oscl_strlen("b=TIAS:");
sptr = skip_whitespace(sptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad b=T1AS: line format"));
return SDP_BAD_MEDIA_FORMAT;
}
uint32 bMod;
if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), bMod) == true)
{
mediaStr->setBWtias(1000 * bMod);
}
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad b=T1AS: line format - bMod incorrect"));
return SDP_BAD_MEDIA_FORMAT;
}
}
}
break;
case 'u':
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - u field not supported"));
return SDP_BAD_MEDIA_FORMAT;
}
case 'c':
{
if (*(line_start_ptr + 1) != '=')
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format - '=' missing after c"));
return SDP_BAD_SESSION_FORMAT;
}
mediaStr->setCFieldStatus(true);
// parse through each field
const char *sptr, *eptr;
// get the connection network type
sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format - connection network type missing"));
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format - part after connection network type missing"));
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
mediaStr->setCNetworkType(memFrag);
// get the address type
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format - address type missing"));
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr <= sptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format - part after address type missing"));
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
mediaStr->setCAddressType(memFrag);
// get the address
sptr = skip_whitespace(eptr, line_end_ptr);
if (sptr >= line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format - address missing"));
return SDP_BAD_SESSION_FORMAT;
}
eptr = skip_to_whitespace(sptr, line_end_ptr);
if (eptr < sptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format - part after address missing"));
return SDP_BAD_SESSION_FORMAT;
}
memFrag.ptr = (void*)sptr;
memFrag.len = (eptr - sptr);
mediaStr->setCAddress(memFrag);
uint32 len = OSCL_MIN((uint32)(eptr - sptr), oscl_strlen("IP4"));
if (oscl_strncmp(sptr, "IP4", len) == 0)
{
uint32 address;
const char *addrend = sptr;
for (; *addrend != '.'; ++addrend);
if (!PV_atoi(sptr, 'd', addrend - sptr, address))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format"));
return SDP_BAD_SESSION_FORMAT;
}
if (address >= 224 && address <= 239) //multicast address look for TTL
{
for (; (*sptr != '/') && (sptr < eptr); ++sptr);
if (sptr == eptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format"));
return SDP_BAD_SESSION_FORMAT; // no TTL found in multicast address.
}
else
{
uint32 ttl;
sptr = sptr + 1;
if (!PV_atoi(sptr, 'd', eptr - sptr, ttl))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format"));
return SDP_BAD_SESSION_FORMAT;
}
if (!(ttl <= 255))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format"));
return SDP_BAD_SESSION_FORMAT; // ttl out of range.
}
}
}
else // unicast address
{
for (; (*sptr != '/') && (sptr < eptr); ++sptr);
if (!oscl_strncmp(sptr, "/", 1))
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format"));
return SDP_BAD_SESSION_FORMAT; //unicast address can not have TTL.
}
}
if (eptr < line_end_ptr)
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad c= line format"));
return SDP_BAD_SESSION_FORMAT;
}
}
//use "len" here since "IP4" and "IP6" have same lengths
else if (oscl_strncmp(sptr, "IP6", len) == 0)
{
//TBD
}
break;
}
default:
{
//skip a line we don't understand
}
break;
}
}
current_start = line_end_ptr;
}
mediaStr->setmediaTrackId(alt_id);
if (!alt_def_id && alt_id)
{
uint32 defaultId;
getAltDefaultId(buff, buff + index, defaultId);
if (defaultId != 0)
mediaStr->setalternateTrackId(defaultId);
else
return SDP_BAD_MEDIA_ALT_ID;
}
if (!a_control_found)
{
uint32 addr;
connectionInfo ci;
mediaStr->getConnectionInformation(&ci);
PV_atoi(ci.connectionAddress.get_cstr(), 'd', addr);
//224.0.0.0 through 239.255.255.255 represent class D network addresses
//reserved for multicasting, which indicate a DVB connection
if (addr >= 224 && addr <= 239)
{
uint32 id = mediaStr->getMediaInfoID();
mediaStr->setControlTrackID(id);
a_control_set = true;
}
}
/*
* cannot assume that range is always going to be set at media level
*/
if ((isSipSdp && a_rtpmap_found) || (!alt_def_id && alt_id))
return SDP_SUCCESS;
else if ((a_rtpmap_found && a_control_found) || (!alt_def_id && alt_id) || (a_control_set))
return SDP_SUCCESS;
else
{
PVMF_SDP_PARSER_LOGERROR((0, "SDPBaseMediaInfoParser::parseMediaInfo - Bad Media - no rtpmap and control present"));
return SDP_BAD_MEDIA_FORMAT;
}
}
SDP_ERROR_CODE SDPBaseMediaInfoParser::getAltDefaultId(const char* start, const char *end, uint32 &defaultId)
{
const char *current_start = start;
const char *line_start_ptr, *line_end_ptr;
defaultId = 0;
while (get_next_line(current_start, end,
line_start_ptr, line_end_ptr))
{
switch (*line_start_ptr)
{
case 'a':
{
if (!oscl_strncmp(line_start_ptr, "a=alt-default-id:", oscl_strlen("a=alt-default-id:")))
{
line_start_ptr += oscl_strlen("a=alt-default-id:");
if (!PV_atoi(line_start_ptr, 'd', line_end_ptr - line_start_ptr, defaultId))
return SDP_BAD_MEDIA_ALT_ID;
else
return SDP_SUCCESS;
}
}
break;
default:
break;
}
current_start = line_end_ptr;
}
return SDP_SUCCESS;
}
SDP_ERROR_CODE SDPBaseMediaInfoParser::setDependentMediaId(const char *start, int length, mediaInfo *mediaPtr, int mediaId)
{
const char *startPtr = start;
const char *endLine = start + length;
while (startPtr < endLine)
{
for (; *startPtr != '='; ++startPtr);
startPtr = startPtr + 1;
if (startPtr > endLine)
return SDP_BAD_MEDIA_ALT_ID;
const char *endPtr = startPtr;
for (; (*endPtr != ';') && (endPtr != endLine); ++endPtr);
if (endPtr > endLine)
return SDP_BAD_MEDIA_ALT_ID;
if (lookForMediaId(startPtr, endPtr, mediaId))
{
while (startPtr < endPtr)
{
const char *end = startPtr;
for (; (*end != ',') && (end < endPtr) ; ++end);
uint32 id;
if (!PV_atoi(startPtr, 'd', end - startPtr, id))
return SDP_BAD_MEDIA_ALT_ID;
if ((int)id != mediaId)
mediaPtr->setdependentTrackId(id);
startPtr = end + 1;
}
}
else
startPtr = endPtr + 1;
}
return SDP_SUCCESS;
}
bool SDPBaseMediaInfoParser::lookForMediaId(const char *startPtr, const char* endPtr, int mediaId)
{
const char *end = startPtr;
while (startPtr < endPtr)
{
for (; (*end != ',') && (end < endPtr); ++end);
uint32 id;
PV_atoi(startPtr, 'd' , end - startPtr, id);
if ((int)id == mediaId)
return true;
end = end + 1;
startPtr = end;
}
return false;
}