| /* ------------------------------------------------------------------ |
| * 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 "sdp_parser.h" |
| #include "sdp_mediaparser_registry.h" |
| #include "oscl_string_utils.h" |
| #include "oscl_string_containers.h" |
| #include "oscl_str_ptr_len.h" |
| #include "base_media_info_parser.h" |
| #include "aac_media_info_parser.h" |
| #include "amr_media_info_parser.h" |
| #include "h263_media_info_parser.h" |
| #include "m4v_media_info_parser.h" |
| #include "still_image_media_info_parser.h" |
| #include "pcma_media_info_parser.h" |
| #include "pcmu_media_info_parser.h" |
| #include "oscl_vector.h" |
| #include "oscl_dll.h" |
| |
| OSCL_DLL_ENTRY_POINT_DEFAULT() |
| struct mime_payload_pair |
| { |
| OsclMemoryFragment mime; |
| Oscl_Vector<int, SDPParserAlloc> payload_no; |
| }; |
| |
| OSCL_EXPORT_REF SDP_Parser::SDP_Parser(SDPMediaParserRegistry*& regTable, bool sipSdp): |
| iLogger(NULL), |
| _pSDPMediaParserRegistry(regTable), |
| mediaArrayIndex(0), |
| applicationFlag(false), |
| isSipSdp(sipSdp) |
| { |
| iLogger = PVLogger::GetLoggerObject("SDP_Parser"); |
| } |
| |
| |
| OSCL_EXPORT_REF SDP_Parser::~SDP_Parser() |
| { |
| } |
| |
| bool SDP_Parser::parse_rtpmap(const char *start, const char *end, int& rtp_payload, |
| OsclMemoryFragment& encoding_name) |
| { |
| const int len_of_rtpmap = 9; |
| |
| // grab the endpoints |
| const char *sptr = start + len_of_rtpmap; |
| const char *eptr; |
| |
| // skip to the first whitespace character |
| eptr = skip_to_whitespace(sptr, end); |
| if (eptr < sptr) |
| { |
| return false; |
| } |
| uint32 rtpPayload; |
| if (PV_atoi(sptr, 'd', (eptr - sptr), rtpPayload) == false) |
| { |
| return false; |
| } |
| rtp_payload = (int)rtpPayload; |
| |
| // now get the encoding name |
| sptr = skip_whitespace(eptr, end); |
| if (sptr >= end) |
| { |
| return false; |
| } |
| |
| // now skip to end of the encoding name |
| for (eptr = sptr; eptr < end && |
| (*eptr != ' ' && *eptr != '\t' && *eptr != '/'); |
| ++eptr); |
| |
| if (eptr >= end) |
| { |
| return false; |
| } |
| |
| encoding_name.ptr = (void *) sptr; |
| encoding_name.len = eptr - sptr; |
| |
| return true; |
| } |
| |
| |
| int SDP_Parser::validate_media_line(const char *start, const char *end, Oscl_Vector<int, SDPParserAlloc>& payload_type, uint32& portNumber) |
| { |
| int len; |
| const char *sptr, *eptr; |
| |
| sptr = start + 2; // start after the "m=" |
| // skip to end of media type |
| eptr = skip_to_whitespace(sptr, end); |
| if (eptr >= end) |
| { |
| return 0; |
| } |
| |
| |
| len = eptr - sptr; |
| // make sure type is supported |
| if (!oscl_CIstrncmp(sptr, "audio", len) || !oscl_CIstrncmp(sptr, "video", len) || |
| !oscl_CIstrncmp(sptr, "application", len)) |
| { |
| // the type is supported |
| // make sure there is only one payload type in the format list |
| |
| // skip to start of port number |
| sptr = skip_whitespace(eptr, end); |
| if (sptr >= end) |
| { |
| return 0; |
| } |
| |
| // skip to end of port number |
| eptr = skip_to_whitespace(sptr, end); |
| if (eptr <= sptr) |
| { |
| return 0; |
| } |
| |
| const char *tmp_end_ptr = sptr; |
| const char SDP_FWD_SLASH[] = "/"; |
| |
| OSCL_HeapString<SDPParserAlloc> restOfLine(tmp_end_ptr, eptr - tmp_end_ptr); |
| const char *slash = oscl_strstr(restOfLine.get_cstr(), SDP_FWD_SLASH); |
| |
| if (slash == NULL) |
| { |
| // Get the port number |
| if (PV_atoi(sptr, 'd', (eptr - sptr), portNumber) == false) |
| { |
| return 0; |
| } |
| } |
| else |
| { |
| // Get the port number |
| if (PV_atoi(restOfLine.get_cstr(), 'd', (slash - restOfLine.get_cstr()), portNumber) == false) |
| { |
| return 0; |
| } |
| } |
| |
| // skip to start of transport |
| sptr = skip_whitespace(eptr, end); |
| if (sptr >= end) |
| { |
| return 0; |
| } |
| |
| // skip to end of transport |
| eptr = skip_to_whitespace(sptr, end); |
| if (eptr <= sptr) |
| { |
| return 0; |
| } |
| |
| // skip to start of format list |
| sptr = skip_whitespace(eptr, end); |
| if (sptr >= end) |
| { |
| return 0; |
| } |
| |
| // skip to end of first payload arg |
| eptr = skip_to_whitespace(sptr, end); |
| if (eptr <= sptr) |
| { |
| return 0; |
| } |
| |
| // record the payload type for non-application m= lines |
| if (oscl_strncmp(start + 2, "application", len)) |
| { |
| uint32 payloadType; |
| |
| while (sptr < end) |
| { |
| if (PV_atoi(sptr, 'd', (eptr - sptr), payloadType) == false) |
| { |
| return 0; |
| } |
| |
| payload_type.push_back(payloadType); |
| |
| sptr = skip_to_whitespace(sptr, end); |
| sptr = skip_whitespace_and_line_term(eptr, end); |
| eptr = skip_whitespace_and_line_term(eptr, end); |
| eptr = skip_to_whitespace(eptr, end); |
| } |
| } |
| else |
| { |
| uint32 len = OSCL_MIN((uint32)(eptr - start), oscl_strlen("IMAGE")); |
| if (!oscl_strncmp(start, "IMAGE", len)) |
| { |
| applicationFlag = true; |
| } |
| else //don't support this media. so skip the section |
| return 0; |
| } |
| |
| if (sptr < end) |
| { |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| return 0; |
| |
| } |
| |
| OSCL_EXPORT_REF |
| SDP_ERROR_CODE SDP_Parser::parseSDP(const char *sdpText, int text_length, SDPInfo *sdp) |
| { |
| int index = 0, sdpIndex = 0; |
| |
| const char *end_ptr = sdpText + text_length ; // Point just beyond the end |
| const char *section_start_ptr; |
| const char *section_end_ptr; |
| const char *line_start_ptr, *line_end_ptr; |
| bool session_info_parsed = false; |
| |
| /**************************************************************************/ |
| |
| // The purpose of this outer loop is to partition the SDP into different |
| // sections to be passed off to session-level parsers or media-level parsers. |
| // We just need to find the boundaries and pass the appropriate sections |
| // of code to the subparsers. |
| |
| sdpIndex = 0; |
| index = 0; |
| |
| // these track whether media and session-level sections have already |
| // been found |
| int media_sections_found = 0; |
| int session_section_found = 0; |
| |
| // skip any leading whitespace including line terminators |
| section_start_ptr = skip_whitespace_and_line_term(sdpText, end_ptr); |
| |
| while ((section_start_ptr - sdpText) < text_length) |
| { |
| if (!get_next_line(section_start_ptr, end_ptr, |
| line_start_ptr, line_end_ptr)) |
| { |
| break; |
| } |
| |
| // figure out the type of section |
| if (!oscl_strncmp(line_start_ptr, "v=", 2)) |
| { |
| // this is the session-level |
| if (media_sections_found || session_section_found) |
| { |
| // there were already media sections or already a session-level section |
| // so a session-level section at this point is not allowed. |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Duplicate Session Sections")); |
| return SDP_BAD_FORMAT; |
| } |
| |
| section_end_ptr = line_end_ptr; |
| |
| // record that the session-level section has been found |
| session_section_found = 1; |
| |
| while (get_next_line(section_end_ptr, end_ptr, |
| line_start_ptr, line_end_ptr)) |
| { |
| // check if this is the start of another section |
| if (!oscl_strncmp(line_start_ptr, "v=", 2) || |
| !oscl_strncmp(line_start_ptr, "m=", 2)) |
| { |
| break; |
| } |
| section_end_ptr = line_end_ptr; |
| } |
| |
| |
| OsclMemoryFragment session_frag; |
| session_frag.ptr = (void *)section_start_ptr; |
| session_frag.len = section_end_ptr - section_start_ptr; |
| |
| SDP_ERROR_CODE retval = |
| parseSDPSessionInfo(section_start_ptr, |
| section_end_ptr - section_start_ptr, |
| sdp); |
| if (retval != SDP_SUCCESS) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - parseSDPSessionInfo Failed=%d", retval)); |
| return retval; |
| } |
| else |
| { |
| session_info_parsed = true; |
| } |
| } |
| else if (!oscl_strncmp(line_start_ptr, "m=", 2)) |
| { |
| |
| // now look for the end of the section |
| section_end_ptr = line_end_ptr; |
| bool supported_media = true; |
| |
| ++media_sections_found; |
| sdp->setSegmentCount(media_sections_found); |
| |
| /* SUPPORTING MULTIPLE PAYLOAD TYPE PER MEDIA NOW */ |
| // check to see how many payload types are present |
| Oscl_Vector<int, SDPParserAlloc> payload_type; |
| Oscl_Vector<int, SDPParserAlloc> rtpmap_pt; |
| Oscl_Vector<OsclMemoryFragment, SDPParserAlloc> encoding_name_vector; |
| |
| uint32 portNumber = 0; |
| if (!validate_media_line(line_start_ptr, line_end_ptr, payload_type, portNumber)) |
| { |
| // skip this section |
| supported_media = false; |
| } |
| else |
| { |
| PVMF_SDP_PARSER_LOGINFO((0, "SDP_Parser::parseSDP - Validated MediaSection")); |
| } |
| |
| int rtpmap_lines = 0; |
| |
| // get the next line |
| OsclMemoryFragment encoding_name; |
| encoding_name.ptr = NULL; |
| encoding_name.len = 0; |
| |
| Oscl_Vector<int, SDPParserAlloc> AltId; |
| while (get_next_line(section_end_ptr, end_ptr, line_start_ptr, line_end_ptr)) |
| { |
| // check if this is the start of another section |
| if (!oscl_strncmp(line_start_ptr, "v=", 2) || |
| !oscl_strncmp(line_start_ptr, "m=", 2)) |
| { |
| break; |
| } |
| if (supported_media && (applicationFlag == false)) |
| { |
| // check for lines which will give the media type |
| // so the parser can be allocated. Simply look for |
| // the "a=rtpmap" lines which contain the MIME type. |
| StrPtrLen rtpmap_str("a=rtpmap:"); |
| if (!oscl_strncmp(line_start_ptr, rtpmap_str.c_str(), rtpmap_str.length())) |
| { |
| ++rtpmap_lines; |
| int rtpmap_cu; |
| // get encoding name |
| if (!parse_rtpmap(line_start_ptr, line_end_ptr, rtpmap_cu, encoding_name)) |
| { |
| // invalid format |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - parse_rtpmap Failed")); |
| return SDP_BAD_MEDIA_FORMAT; |
| } |
| rtpmap_pt.push_back(rtpmap_cu); |
| encoding_name_vector.push_back(encoding_name); |
| OSCL_StackString<15> mime((const char*)(encoding_name.ptr), encoding_name.len); |
| PVMF_SDP_PARSER_LOGINFO((0, "SDP_Parser::parseSDP - a=rtpmap mime=%s", mime.get_cstr())); |
| } |
| StrPtrLen alt_def("a=alt-default-id:"); |
| if (!oscl_strncmp(line_start_ptr, alt_def.c_str(), alt_def.length())) |
| { |
| uint32 id; |
| const char *sptr = line_start_ptr + alt_def.length(); |
| sptr = skip_whitespace(sptr, line_end_ptr); |
| if (!PV_atoi(sptr, 'd', line_end_ptr - sptr, id)) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Parsing a=alt-default-id: Failed")); |
| return SDP_BAD_MEDIA_ALT_ID; |
| } |
| AltId.push_back(id); |
| } |
| StrPtrLen alt_id("a=alt:"); |
| if (!oscl_strncmp(line_start_ptr, alt_id.c_str(), alt_id.length())) |
| { |
| uint32 id; |
| const char *sptr = line_start_ptr + alt_id.length(); |
| sptr = skip_whitespace(sptr, line_end_ptr); |
| const char *eptr = sptr; |
| for (; *eptr != ':'; eptr++); |
| if (!PV_atoi(sptr, 'd', eptr - sptr, id)) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Parsing a=alt: Failed")); |
| return SDP_BAD_MEDIA_ALT_ID; |
| } |
| if (AltId.back() != (int)id) |
| AltId.push_back(id); |
| } |
| |
| // fmtp and framesize payload check is provided below |
| // this is done to make sure that the payload coming in these fields |
| // is one of the payloads in the m= segment |
| StrPtrLen fmtp("a=fmtp:"); |
| if (!oscl_strncmp(line_start_ptr, fmtp.c_str(), fmtp.length())) |
| { |
| uint32 payload; |
| const char *sptr = line_start_ptr + fmtp.length(); |
| sptr = skip_whitespace(sptr, line_end_ptr); |
| const char* eptr = skip_to_whitespace(sptr, line_end_ptr); |
| if (!PV_atoi(sptr, 'd', eptr - sptr, payload)) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Parsing a=fmtp: Failed")); |
| return SDP_BAD_MEDIA_FORMAT; |
| } |
| // The format is proper match the payload with payloads in m= segment |
| bool matched = false; |
| for (uint32 ii = 0; ii < payload_type.size(); ii++) |
| { |
| if (payload == (uint32)payload_type[ii]) |
| { |
| matched = true; |
| break; |
| } |
| } |
| if (!matched) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Payload Mismatch in fmtp line")); |
| return SDP_PAYLOAD_MISMATCH; |
| } |
| } |
| StrPtrLen framesize("a=framesize:"); |
| if (!oscl_strncmp(line_start_ptr, framesize.c_str(), framesize.length())) |
| { |
| uint32 payload; |
| const char *sptr = line_start_ptr + framesize.length(); |
| sptr = skip_whitespace(sptr, line_end_ptr); |
| const char* eptr = skip_to_whitespace(sptr, line_end_ptr); |
| if (!PV_atoi(sptr, 'd', eptr - sptr, payload)) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Parsing a=framesize: Failed")); |
| return SDP_BAD_MEDIA_FORMAT; |
| } |
| // The format is proper match the payload with payloads in m= segment |
| bool matched = false; |
| for (uint32 ii = 0; ii < payload_type.size(); ii++) |
| { |
| if (payload == (uint32)payload_type[ii]) |
| { |
| matched = true; |
| break; |
| } |
| } |
| if (!matched) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Payload Mismatch in a=framesize: line")); |
| return SDP_PAYLOAD_MISMATCH; |
| } |
| } |
| |
| } // end if media is supported |
| else |
| { |
| PVMF_SDP_PARSER_LOGINFO((0, "SDP_Parser::parseSDP - Skipping over an entire m= section")); |
| } |
| |
| section_end_ptr = line_end_ptr; |
| } // end loop over the entire media section |
| |
| |
| // The checking for rtpmap vs payloads is not required if the port number is 0 in case it is a sip sdp |
| bool check_for_rtpmap = true; |
| if (isSipSdp && portNumber == 0) |
| { |
| check_for_rtpmap = false; |
| } |
| |
| // Checking for rtpmap with the payloads |
| if (supported_media && check_for_rtpmap) |
| { |
| // Validate the payload type and rtpmap if required |
| int static_payload_count = 0; |
| int ii = 0; |
| for (; ii < (int)payload_type.size(); ii++) |
| { |
| // If any payload_type is in static range we do not care |
| // for the rtpmap field. We will process for this static payload type sdp |
| // the dynamic payload type if any will be ignored if it's rtpmap |
| // is missing |
| if ((payload_type[ii] >= FIRST_STATIC_PAYLOAD) && |
| (payload_type[ii] <= LAST_STATIC_PAYLOAD)) |
| { |
| PVMF_SDP_PARSER_LOGINFO((0, "SDP_Parser::parseSDP - Static Payload =%d", payload_type[ii])); |
| static_payload_count++; |
| } |
| } |
| if (static_payload_count == 0) |
| { |
| // The payload type present are all in the dynamic range |
| if (rtpmap_pt.size() != payload_type.size()) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Mismatch between number of payloads and rtpmap lines")); |
| return SDP_BAD_MEDIA_FORMAT; |
| } |
| for (int ii = 0; ii < (int)rtpmap_pt.size(); ii++) |
| { |
| if (rtpmap_pt[ii] != payload_type[ii]) |
| { |
| // this is an error |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Incorrect payload number in rtpmap line")); |
| return SDP_PAYLOAD_MISMATCH; |
| } |
| } |
| } |
| else if (static_payload_count >= 1) |
| { |
| // All of the payloads can either be static or one of them |
| // for every dynamic payload there should be matching rtpmap field |
| if (rtpmap_pt.size() != (payload_type.size() - static_payload_count)) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Mismatch between number of payloads and rtpmap lines")); |
| return SDP_BAD_MEDIA_FORMAT; |
| } |
| for (uint32 rtpmap_count = 0; rtpmap_count < rtpmap_pt.size(); rtpmap_count++) |
| { |
| bool match_found = false; |
| for (int jj = 0; jj < (int)payload_type.size(); jj++) |
| { |
| if (rtpmap_pt[rtpmap_count] == payload_type[jj]) |
| { |
| match_found = true; |
| break; |
| } |
| } |
| if (match_found == false) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - No matching rtpmap line")); |
| // this is an error |
| return SDP_PAYLOAD_MISMATCH; |
| } |
| } |
| } |
| } |
| |
| if (session_info_parsed == false) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Missing Session Section")); |
| return SDP_BAD_FORMAT; |
| } |
| |
| if (supported_media) |
| { |
| StrPtrLen image("X-MP4V-IMAGE"); |
| if (applicationFlag == true) |
| { |
| if (rtpmap_lines == 0) |
| { |
| rtpmap_lines++; |
| encoding_name.ptr = (void *) image.c_str(); |
| encoding_name.len = image.length(); |
| applicationFlag = false; |
| encoding_name_vector.push_back(encoding_name); |
| } |
| } |
| |
| // Compose all media encoding names and put them in one vector |
| // this will carry all encoding names including static and dynamic PT |
| StrPtrLen pcma(PVMF_MIME_PCMA); |
| StrPtrLen pcmu(PVMF_MIME_PCMU); |
| StrPtrLen amr("AMR"); |
| Oscl_Vector<OsclMemoryFragment, SDPParserAlloc> all_media_encoding_names; |
| uint32 ii = 0; |
| uint32 jj = 0; |
| for (; ii < payload_type.size(); ii++) |
| { |
| if (payload_type[ii] == PVMF_PCMU) |
| { |
| rtpmap_lines++; |
| encoding_name.ptr = (void *) pcmu.c_str(); |
| encoding_name.len = pcmu.length(); |
| } |
| else if (payload_type[ii] == PVMF_PCMA) |
| { |
| rtpmap_lines++; |
| encoding_name.ptr = (void *) pcma.c_str(); |
| encoding_name.len = pcma.length(); |
| } |
| else if (check_for_rtpmap == false) |
| { |
| // This means that the port is 0 and they payload is in dynamic range |
| // rtpmap field is not present. |
| // To map it internally let's put it under PCMU again |
| rtpmap_lines++; |
| encoding_name.ptr = (void *) pcmu.c_str(); |
| encoding_name.len = pcmu.length(); |
| } |
| else |
| { |
| // All other payload encoding names are already present in the |
| // encoding_name_vector. |
| if (jj < encoding_name_vector.size()) |
| { |
| encoding_name = encoding_name_vector[jj]; |
| jj++; |
| } |
| } |
| all_media_encoding_names.push_back(encoding_name); |
| } |
| |
| // compose all the above information in the following format |
| // Any Mime type coming repeatedly with different payload numbers |
| // Then club them together |
| Oscl_Vector<mime_payload_pair, SDPParserAlloc> mime_payload_pair_vector; |
| |
| for (uint32 ll = 0; ll < payload_type.size(); ll++) |
| { |
| if (check_for_rtpmap == true) |
| { |
| bool matched = false; |
| uint32 ii = 0; |
| for (; ii < mime_payload_pair_vector.size(); ii++) |
| { |
| if (oscl_strncmp((char*)mime_payload_pair_vector[ii].mime.ptr, |
| (char*)all_media_encoding_names[ll].ptr, |
| all_media_encoding_names[ll].len) == 0) |
| { |
| matched = true; |
| break; |
| } |
| } |
| if (matched) |
| { |
| mime_payload_pair_vector[ii].payload_no.push_back(payload_type[ll]); |
| } |
| else |
| { |
| mime_payload_pair mpp; |
| mpp.payload_no.push_back(payload_type[ll]); |
| mpp.mime.len = all_media_encoding_names[ll].len; |
| mpp.mime.ptr = all_media_encoding_names[ll].ptr; |
| mime_payload_pair_vector.push_back(mpp); |
| } |
| } |
| else |
| { |
| // It is a sip sdp with port = 0. Hence do not make specific checks |
| mime_payload_pair mpp; |
| mpp.payload_no.push_back(payload_type[ll]); |
| mpp.mime.len = all_media_encoding_names[ll].len; |
| mpp.mime.ptr = all_media_encoding_names[ll].ptr; |
| mime_payload_pair_vector.push_back(mpp); |
| } |
| |
| } |
| |
| if (rtpmap_lines >= 1) |
| { |
| SDPMediaParserFactory *mediaParserFactory; |
| SDPBaseMediaInfoParser *mediaParser; |
| SDP_ERROR_CODE retval; |
| |
| for (uint32 kk = 0; kk < mime_payload_pair_vector.size(); kk++) |
| { |
| encoding_name = mime_payload_pair_vector[kk].mime; |
| if ((mediaParserFactory = |
| _pSDPMediaParserRegistry->lookupSDPMediaParserFactory(encoding_name)) != NULL) |
| { |
| mediaParser = mediaParserFactory->createSDPMediaParserInstance(); |
| if (mediaParser == NULL) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Unable to create media parser")); |
| return SDP_FAILURE; |
| } |
| if (AltId.size() > 0) |
| { |
| int alt_id; |
| bool alt_def_id = false; |
| for (int ss = 0; ss < (int)AltId.size(); ss++) |
| { |
| if (ss == 0) alt_def_id = true; |
| else alt_def_id = false; |
| |
| alt_id = AltId[ss]; |
| |
| if ((retval = mediaParser->parseMediaInfo(section_start_ptr, section_end_ptr - section_start_ptr, sdp, mime_payload_pair_vector[kk].payload_no, isSipSdp, alt_id, alt_def_id)) != SDP_SUCCESS) |
| { |
| OSCL_StackString<8> mime((const char*)(encoding_name.ptr), encoding_name.len); |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Parsing m= section failed, mime=%s", mime.get_cstr())); |
| OSCL_DELETE((mediaParser)); |
| sdp->freeLastMediaInfoObject(); |
| return retval; |
| } |
| |
| } |
| } |
| else |
| { |
| if ((retval = mediaParser->parseMediaInfo(section_start_ptr, section_end_ptr - section_start_ptr, sdp, mime_payload_pair_vector[kk].payload_no, isSipSdp)) != SDP_SUCCESS) |
| { |
| OSCL_StackString<8> mime((const char*)(encoding_name.ptr), encoding_name.len); |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Parsing m= section failed, mime=%s", mime.get_cstr())); |
| OSCL_DELETE((mediaParser)); |
| sdp->freeLastMediaInfoObject(); |
| return retval; |
| } |
| } |
| sdp->IncrementAlternateMediaInfoVectorIndex(); |
| OSCL_DELETE((mediaParser)); |
| } |
| mediaParser = NULL; |
| } // End of for |
| } |
| if (rtpmap_lines == 0) // no rtpmap found in media |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Parsing m= section failed, No rtpmap line")); |
| return SDP_BAD_MEDIA_MISSING_RTPMAP; |
| } |
| } |
| } // end this is a media section |
| else |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Unrecognized Syntax")); |
| // unknown section type -- this is an error |
| return SDP_FAILURE; |
| } |
| |
| section_start_ptr = skip_whitespace_and_line_term(section_end_ptr, end_ptr); |
| |
| } |
| { |
| //for SDP which doesn't have session level range, set the session level range |
| //to be the MAX of media ranges. |
| if (NULL == sdp->getSessionInfo()) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Missing Session Info")); |
| return SDP_BAD_FORMAT; |
| } |
| RtspRangeType *mySdpRange = ((RtspRangeType *)sdp->getSessionInfo()->getRange()); |
| if (NULL == mySdpRange) |
| { |
| PVMF_SDP_PARSER_LOGERROR((0, "SDP_Parser::parseSDP - Unable to retrieve session range")); |
| return SDP_BAD_FORMAT; |
| } |
| if (mySdpRange->format == RtspRangeType::INVALID_RANGE) |
| { |
| PVMF_SDP_PARSER_LOGINFO((0, "SDP_Parser::parseSDP - No Valid Session Range - Setting it to Max of all media ranges")); |
| for (int32 i = sdp->getNumMediaObjects() - 1; i >= 0; i--) |
| { |
| Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec = |
| sdp->getMediaInfo(i); |
| for (uint32 j = 0; j < mediaInfoVec.size(); j++) |
| { |
| mediaInfo* mInfo = mediaInfoVec[j]; |
| if (mInfo == NULL) |
| { |
| continue; |
| } |
| const RtspRangeType *mInfoSdpRange = mInfo->getRtspRange(); |
| if (NULL == mInfoSdpRange) |
| { |
| continue; |
| } |
| if (mInfoSdpRange->format != RtspRangeType::NPT_RANGE) |
| { |
| continue; |
| } |
| if (mySdpRange->format == RtspRangeType::INVALID_RANGE) |
| { |
| *mySdpRange = *mInfoSdpRange; |
| } |
| if (!mInfoSdpRange->end_is_set) |
| {//live streaming |
| *mySdpRange = *mInfoSdpRange; |
| mySdpRange->start_is_set = true;//just to make sure |
| mySdpRange->npt_start.npt_format = NptTimeFormat::NOW; |
| return SDP_SUCCESS; |
| } |
| if (mInfoSdpRange->npt_start.npt_format == NptTimeFormat::NPT_SEC) |
| { |
| if (mInfoSdpRange->npt_start.npt_sec.sec < mySdpRange->npt_start.npt_sec.sec) |
| { |
| mySdpRange->npt_start.npt_sec = mInfoSdpRange->npt_start.npt_sec; |
| } |
| else if ((mInfoSdpRange->npt_start.npt_sec.sec == mySdpRange->npt_start.npt_sec.sec) |
| && ((mInfoSdpRange->npt_start.npt_sec.milli_sec < mySdpRange->npt_start.npt_sec.milli_sec))) |
| { |
| mySdpRange->npt_start.npt_sec = mInfoSdpRange->npt_start.npt_sec; |
| } |
| } |
| if (mInfoSdpRange->npt_end.npt_format == NptTimeFormat::NPT_SEC) |
| { |
| if (mInfoSdpRange->npt_end.npt_sec.sec > mySdpRange->npt_end.npt_sec.sec) |
| { |
| mySdpRange->npt_end.npt_sec = mInfoSdpRange->npt_end.npt_sec; |
| } |
| else if ((mInfoSdpRange->npt_end.npt_sec.sec == mySdpRange->npt_end.npt_sec.sec) |
| && ((mInfoSdpRange->npt_end.npt_sec.milli_sec > mySdpRange->npt_end.npt_sec.milli_sec))) |
| { |
| mySdpRange->npt_end.npt_sec = mInfoSdpRange->npt_end.npt_sec; |
| } |
| } |
| } |
| } |
| } |
| } |
| return SDP_SUCCESS; |
| } |
| |
| OSCL_EXPORT_REF SDP_ERROR_CODE |
| SDP_Parser::parseSDPDownload(const char *sdpText, |
| int length, |
| SDPInfo *sdp, |
| movieInfo *mv) |
| { |
| SDP_ERROR_CODE retval = parseSDP(sdpText, length, sdp); |
| if (retval != SDP_SUCCESS) |
| { |
| mv->trackCount = 0; |
| mv->movieName[0] = '\0'; |
| mv->creationDate[0] = '\0'; |
| return retval; |
| } |
| else |
| { |
| /*Get Movie name*/ |
| int len = oscl_strlen(sdp->getSessionInfo()->getSessionName()); |
| if (len >= MAX_STRING_LEN) |
| { |
| oscl_strncpy(mv->movieName, sdp->getSessionInfo()->getSessionName(), (MAX_STRING_LEN - 1)); |
| mv->movieName[MAX_STRING_LEN-1] = '\0'; |
| } |
| else |
| { |
| oscl_strncpy(mv->movieName, sdp->getSessionInfo()->getSessionName(), len); |
| mv->movieName[len] = '\0'; |
| } |
| |
| /*Get creation date*/ |
| len = oscl_strlen(sdp->getSessionInfo()->getCreationDate()); |
| if (len >= MAX_STRING_LEN) |
| { |
| oscl_strncpy(mv->creationDate, sdp->getSessionInfo()->getCreationDate(), (MAX_STRING_LEN - 1)); |
| mv->creationDate[MAX_STRING_LEN-1] = '\0'; |
| } |
| else |
| { |
| oscl_strncpy(mv->creationDate, sdp->getSessionInfo()->getCreationDate(), len); |
| mv->creationDate[len] = '\0'; |
| } |
| |
| /*Get number of tracks*/ |
| mv->trackCount = sdp->getNumMediaObjects(); |
| |
| /*Get start stop times*/ |
| convertToMilliSec(*sdp->getSessionInfo()->getRange(), mv->duration.startTime, mv->duration.stopTime); |
| |
| /*Get MIMEType and other track info*/ |
| for (int ii = 0; ii < mv->trackCount; ii++) |
| { |
| Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec = |
| sdp->getMediaInfo(ii); |
| |
| /* |
| * There would only be one element in this vector |
| * for fast track download content. |
| */ |
| mediaInfo* minfo = mediaInfoVec[0]; |
| |
| mv->TrackArray[ii].bitrate = minfo->getBitrate(); |
| len = oscl_strlen(minfo->getMIMEType()); |
| if (len >= MAX_STRING_LEN) |
| { |
| oscl_strncpy(mv->TrackArray[ii].codec_type, |
| minfo->getMIMEType(), |
| (MAX_STRING_LEN - 1)); |
| mv->TrackArray[ii].codec_type[MAX_STRING_LEN-1] = '\0'; |
| } |
| else |
| { |
| oscl_strncpy(mv->TrackArray[ii].codec_type, |
| minfo->getMIMEType(), |
| len); |
| mv->TrackArray[ii].codec_type[len] = '\0'; |
| } |
| const char *trackID = minfo->getControlURL(); |
| int track = 0; |
| if (trackID != NULL) |
| { |
| const char *locateID = oscl_strstr(trackID, "="); |
| if (locateID != NULL) |
| { |
| locateID += 1; |
| uint32 atoi_tmp; |
| PV_atoi(locateID, 'd', atoi_tmp); |
| track = atoi_tmp; |
| } |
| } |
| mv->TrackArray[ii].trackID = track; |
| } |
| } |
| return SDP_SUCCESS; |
| } |
| |
| |
| int |
| SDP_Parser::convertToMilliSec(RtspRangeType range , int &startTime, int &stopTime) |
| { |
| switch (range.format) |
| { |
| case RtspRangeType::NPT_RANGE: |
| { |
| if (range.start_is_set) |
| { |
| switch (range.npt_start.npt_format) |
| { |
| case NptTimeFormat::NOW: |
| { |
| startTime = 0; |
| } |
| break; |
| case NptTimeFormat::NPT_SEC: |
| { |
| startTime = (int)(1000 * ((float)range.npt_start.npt_sec.sec + range.npt_start.npt_sec.milli_sec)); |
| } |
| break; |
| case NptTimeFormat::NPT_HHMMSS: |
| { |
| startTime = 3600000 * range.npt_start.npt_hhmmss.hours + 60000 * range.npt_start.npt_hhmmss.min + 1000 * range.npt_start.npt_hhmmss.sec + (int)(10 * range.npt_start.npt_hhmmss.frac_sec); |
| } |
| break; |
| } |
| } |
| else |
| { |
| startTime = 0; |
| } |
| if (range.end_is_set) |
| { |
| switch (range.npt_end.npt_format) |
| { |
| case NptTimeFormat::NOW: |
| { |
| stopTime = 0; |
| } |
| break; |
| case NptTimeFormat::NPT_SEC: |
| { |
| stopTime = (int)(1000 * ((float)range.npt_end.npt_sec.sec + range.npt_end.npt_sec.milli_sec)); |
| } |
| break; |
| case NptTimeFormat::NPT_HHMMSS: |
| { |
| stopTime = 3600000 * range.npt_end.npt_hhmmss.hours + 60000 * range.npt_end.npt_hhmmss.min + 1000 * range.npt_end.npt_hhmmss.sec + (int)(100 * range.npt_end.npt_hhmmss.frac_sec); |
| } |
| break; |
| } |
| } |
| else |
| { |
| stopTime = false; |
| } |
| } |
| break; |
| case RtspRangeType::SMPTE_RANGE: |
| case RtspRangeType::SMPTE_25_RANGE: |
| case RtspRangeType::SMPTE_30_RANGE: |
| { |
| if (range.start_is_set) |
| { |
| startTime = 3600000 * range.smpte_start.hours + 60000 * range.smpte_start.minutes + 1000 * range.smpte_start.seconds; |
| } |
| else |
| { |
| startTime = 0; |
| } |
| if (range.end_is_set) |
| { |
| stopTime = 3600000 * range.smpte_end.hours + 60000 * range.smpte_end.minutes + 1000 * range.smpte_end.seconds; |
| } |
| else |
| { |
| stopTime = 0; |
| } |
| } |
| break; |
| case RtspRangeType::ABS_RANGE: |
| { |
| startTime = 0; |
| stopTime = 0; |
| } |
| break; |
| case RtspRangeType::UNKNOWN_RANGE: |
| case RtspRangeType::INVALID_RANGE: |
| { |
| startTime = 0; |
| stopTime = 0; |
| return -1; |
| } |
| // break; This statement was removed to avoid compiler warning for Unreachable Code |
| |
| default: |
| { |
| startTime = 0; |
| stopTime = 0; |
| return -1; |
| } |
| // break; This statement was removed to avoid compiler warning for Unreachable Code |
| } |
| return 0; |
| } |
| |
| OSCL_EXPORT_REF int SDP_Parser::getNumberOfTracks() |
| { |
| return mediaArrayIndex; |
| } |
| |
| OSCL_EXPORT_REF int SDP_Parser::setNumberOfTracks(int tracks) |
| { |
| return (mediaArrayIndex = tracks); |
| } |
| |
| |
