1 /* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18 #ifndef __SDP_INFO_H__ 19 #include "sdp_info.h" 20 #endif 21 22 #ifndef SDPPARSER_CONFIG_H_INCLUDED 23 #include "sdpparser_config.h" 24 #endif 25 26 #ifndef SDPPARSER_HAS_REAL_MEDIA_SUPPORT 27 #error "sdp config file missing" 28 #endif 29 30 #if SDPPARSER_HAS_REAL_MEDIA_SUPPORT 31 #ifndef RM_MEDIAINFO_H 32 #include "rm_media_info.h" 33 #endif 34 #endif 35 36 37 OSCL_EXPORT_REF 38 SDPInfo::SDPInfo() 39 { 40 numMediaObjects = 0; 41 iMediaObjectIndex = 0; 42 segmentCount = 0; 43 for (int ii = 0; ii < MAX_SEGMENTS; ii++) 44 { 45 segmentInfo[ii].segmentActive = true; 46 segmentInfo[ii].segmentPayloadOrderPref = false; 47 } 48 } 49 50 OSCL_EXPORT_REF 51 SDPInfo::SDPInfo(const SDPInfo &sourceSdpInfo) 52 { 53 //expecting the = oper of sessionDescription to be overloaded 54 session_info = sourceSdpInfo.session_info; 55 SdpFilename = sourceSdpInfo.SdpFilename; 56 segmentCount = sourceSdpInfo.segmentCount; 57 iMediaObjectIndex = sourceSdpInfo.iMediaObjectIndex; 58 numMediaObjects = sourceSdpInfo.numMediaObjects; 59 60 for (int jj = 0; jj < MAX_SEGMENTS; jj++) 61 { 62 segmentInfo[jj] = sourceSdpInfo.segmentInfo[jj]; 63 } 64 65 for (int ii = 0; ii < MAX_MEDIA_OBJECTS; ii++) 66 { 67 Oscl_Vector< mediaInfo *, SDPParserAlloc>& destMediaInfoVect = pMediaInfo[ii]; 68 const Oscl_Vector< mediaInfo *, SDPParserAlloc>& srcMediaInfoVect = sourceSdpInfo.pMediaInfo[ii]; 69 const int32 srcMediaInfoVectSz = srcMediaInfoVect.size(); 70 for (int ss = 0; ss < srcMediaInfoVectSz; ss++) 71 { 72 mediaInfo* destMediaInfo = NULL; 73 const char *mimeType = srcMediaInfoVect[ss]->getMIMEType(); 74 bool alternateMedia = (0 == ss) ? false : true; 75 76 if (!oscl_strncmp(mimeType, "AAC", oscl_strlen("AAC")) || !oscl_strncmp(mimeType, "MP4A-LATM", oscl_strlen("MP4A-LATM"))) 77 { 78 aac_mediaInfo *pSourceAAC = OSCL_REINTERPRET_CAST(aac_mediaInfo*, srcMediaInfoVect[ss]); 79 void *memory = alloc(sizeof(aac_mediaInfo), alternateMedia); 80 aac_mediaInfo *pAAC = OSCL_PLACEMENT_NEW(memory, aac_mediaInfo()); 81 *pAAC = *pSourceAAC; 82 destMediaInfo = pAAC; 83 } 84 else if (!oscl_strncmp(mimeType, "AMR", oscl_strlen("AMR"))) 85 { 86 amr_mediaInfo *pSourceAMR = OSCL_REINTERPRET_CAST(amr_mediaInfo*, srcMediaInfoVect[ss]); 87 void *memory = alloc(sizeof(amr_mediaInfo), alternateMedia); 88 amr_mediaInfo *pAMR = OSCL_PLACEMENT_NEW(memory, amr_mediaInfo()); 89 *pAMR = *pSourceAMR; 90 destMediaInfo = pAMR; 91 } 92 else if (!oscl_strncmp(mimeType, "MP4V-ES", oscl_strlen("MP4V-ES"))) 93 { 94 m4v_mediaInfo *pSourceM4V = OSCL_REINTERPRET_CAST(m4v_mediaInfo*, srcMediaInfoVect[ss]); 95 void *memory = alloc(sizeof(m4v_mediaInfo), alternateMedia); 96 m4v_mediaInfo *pM4V = OSCL_PLACEMENT_NEW(memory, m4v_mediaInfo()); 97 *pM4V = *pSourceM4V; 98 destMediaInfo = pM4V; 99 } 100 else if (!oscl_strncmp(mimeType, "H263-1998", oscl_strlen("H263-1998")) || !oscl_strncmp(mimeType, "H263-2000", oscl_strlen("H263-2000"))) 101 { 102 h263_mediaInfo *pSourceH263 = OSCL_REINTERPRET_CAST(h263_mediaInfo*, srcMediaInfoVect[ss]); 103 void *memory = alloc(sizeof(h263_mediaInfo), alternateMedia); 104 h263_mediaInfo *pH263 = OSCL_PLACEMENT_NEW(memory, h263_mediaInfo()); 105 *pH263 = *pSourceH263; 106 destMediaInfo = pH263; 107 } 108 else if (!oscl_strncmp(mimeType, "PVMP4V-ES", oscl_strlen("PVMP4V-ES"))) 109 { 110 m4v_mediaInfo *pSourceM4V = OSCL_REINTERPRET_CAST(m4v_mediaInfo*, srcMediaInfoVect[ss]); 111 void *memory = alloc(sizeof(m4v_mediaInfo), alternateMedia); 112 m4v_mediaInfo *pM4V = OSCL_PLACEMENT_NEW(memory, m4v_mediaInfo()); 113 *pM4V = *pSourceM4V; 114 destMediaInfo = pM4V; 115 } 116 else if (!oscl_strncmp(mimeType, "mpeg4-generic", oscl_strlen("mpeg4-generic"))) 117 { 118 rfc3640_mediaInfo *pSourceRFC3640 = OSCL_REINTERPRET_CAST(rfc3640_mediaInfo*, srcMediaInfoVect[ss]); 119 void *memory = alloc(sizeof(rfc3640_mediaInfo), alternateMedia); 120 rfc3640_mediaInfo *pRFC3640 = OSCL_PLACEMENT_NEW(memory, rfc3640_mediaInfo()); 121 *pRFC3640 = *pSourceRFC3640; 122 destMediaInfo = pRFC3640; 123 } 124 else if (!oscl_strncmp(mimeType, "X-MP4V-IMAGE", oscl_strlen("X-MP4V-IMAGE"))) 125 { 126 still_image_mediaInfo *pSourceImage = OSCL_REINTERPRET_CAST(still_image_mediaInfo*, srcMediaInfoVect[ss]); 127 void *memory = alloc(sizeof(still_image_mediaInfo), alternateMedia); 128 still_image_mediaInfo *pImage = OSCL_PLACEMENT_NEW(memory, still_image_mediaInfo()); 129 *pImage = *pSourceImage; 130 destMediaInfo = pImage; 131 } 132 #if SDPPARSER_HAS_REAL_MEDIA_SUPPORT 133 else if (!oscl_strncmp(mimeType, "x-pn-realaudio", oscl_strlen("x-pn-realaudio")) || !oscl_strncmp(mimeType, "x-pn-realvideo", oscl_strlen("x-pn-realvideo"))) 134 { 135 rm_mediaInfo *rmSource = OSCL_REINTERPRET_CAST(rm_mediaInfo*, srcMediaInfoVect[ss]); 136 void *memory = alloc(sizeof(rm_mediaInfo), alternateMedia); 137 rm_mediaInfo *prm = OSCL_PLACEMENT_NEW(memory, rm_mediaInfo()); 138 *prm = *rmSource; 139 destMediaInfo = prm; 140 } 141 #endif 142 if (destMediaInfo) 143 destMediaInfoVect.push_back(destMediaInfo); 144 } 145 } 146 } 147 148 149 OSCL_EXPORT_REF 150 SDPInfo::~SDPInfo() 151 { 152 int ii = 0; 153 int ss = 0; 154 for (ii = 0; ii < numMediaObjects; ii++) 155 { 156 for (ss = 0; ss < (int)pMediaInfo[ii].size(); ss++) 157 { 158 pMediaInfo[ii][ss]->~mediaInfo(); 159 dealloc(pMediaInfo[ii][ss]); 160 } 161 } 162 numMediaObjects = 0; 163 164 } 165 166 OSCL_EXPORT_REF 167 void SDPInfo::freeLastMediaInfoObject(void) 168 { 169 if (numMediaObjects < 0) 170 { 171 return; 172 } 173 174 for (int ss = 0; ss < (int)pMediaInfo[numMediaObjects].size(); ss++) 175 { 176 pMediaInfo[numMediaObjects][ss]->~mediaInfo(); 177 dealloc(pMediaInfo[numMediaObjects][ss]); 178 } 179 } 180 181 OSCL_EXPORT_REF 182 sessionDescription* SDPInfo::getSessionInfo() 183 { 184 return &session_info; 185 } 186 187 OSCL_EXPORT_REF 188 Oscl_Vector<mediaInfo *, SDPParserAlloc> SDPInfo::getMediaInfo(int Object) 189 { 190 if ((Object >= 0) && (Object < MAX_MEDIA_OBJECTS)) 191 { 192 return pMediaInfo[Object]; 193 } 194 else 195 { 196 return 0; 197 } 198 } 199 200 OSCL_EXPORT_REF 201 Oscl_Vector<mediaInfo *, SDPParserAlloc> * SDPInfo::getMediaArray() 202 { 203 return pMediaInfo; 204 } 205 206 OSCL_EXPORT_REF 207 int SDPInfo::getNumMediaObjects() 208 { 209 return numMediaObjects; 210 } 211 212 OSCL_EXPORT_REF 213 void SDPInfo::dealloc(void *ptr) 214 { 215 oscl_free(ptr); 216 } 217 218 OSCL_EXPORT_REF 219 mediaInfo* SDPInfo::getMediaInfoBasedOnID(uint32 trackID) 220 { 221 int numObjects = getNumMediaObjects(); 222 223 for (int i = 0; i < numObjects; i++) 224 { 225 Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec; 226 mediaInfoVec = getMediaInfo(i); 227 228 for (uint32 j = 0; j < mediaInfoVec.size(); j++) 229 { 230 mediaInfo* minfo = mediaInfoVec[j]; 231 232 if (minfo != NULL) 233 { 234 if (minfo->getMediaInfoID() == trackID) 235 { 236 return minfo; 237 } 238 } 239 } 240 } 241 return NULL; 242 } 243 244 OSCL_EXPORT_REF 245 mediaInfo* SDPInfo::getMediaInfoBasedOnDependsOnID(uint32 trackID) 246 { 247 if (trackID == 0) 248 { 249 return NULL; 250 } 251 252 int numObjects = getNumMediaObjects(); 253 254 for (int i = 0; i < numObjects; i++) 255 { 256 Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec; 257 mediaInfoVec = getMediaInfo(i); 258 259 for (uint32 j = 0; j < mediaInfoVec.size(); j++) 260 { 261 mediaInfo* minfo = mediaInfoVec[j]; 262 263 if (minfo != NULL) 264 { 265 if ((uint32)(minfo->getControlTrackID()) == trackID) 266 { 267 return minfo; 268 } 269 } 270 } 271 } 272 return NULL; 273 } 274 275 OSCL_EXPORT_REF 276 void * SDPInfo::alloc(const int size, bool alternateMedia) 277 { 278 OSCL_UNUSED_ARG(alternateMedia); 279 280 if (numMediaObjects < MAX_MEDIA_OBJECTS) 281 { 282 void *mem = oscl_malloc(size * sizeof(char)); 283 if (mem != NULL) 284 { 285 iMediaObjectIndex++; 286 pMediaInfo[numMediaObjects].push_back((mediaInfo *)mem); 287 } 288 return mem; 289 } 290 else 291 { 292 return NULL; 293 } 294 } 295 296 OSCL_EXPORT_REF 297 void SDPInfo::IncrementAlternateMediaInfoVectorIndex() 298 { 299 pMediaInfo[numMediaObjects][0]->setSegmentNumber(segmentCount); 300 numMediaObjects++; 301 } 302 303 OSCL_EXPORT_REF 304 void SDPInfo::copyFmDefMedia(mediaInfo *media) 305 { 306 *media = *pMediaInfo[numMediaObjects][0]; 307 } 308 309 OSCL_EXPORT_REF 310 void SDPInfo::reset() 311 { 312 session_info.resetSessionDescription(); 313 int ii = 0; 314 int ss = 0; 315 for (ii = 0; ii < numMediaObjects; ii++) 316 { 317 for (ss = 0; ss < (int)pMediaInfo[ii].size(); ss++) 318 { 319 pMediaInfo[ii][ss]->~mediaInfo(); 320 dealloc(pMediaInfo[ii][ss]); 321 } 322 } 323 numMediaObjects = 0; 324 } 325 326 OSCL_EXPORT_REF 327 uint32 SDPInfo::getMediaObjectIndex() 328 { 329 return iMediaObjectIndex; 330 } 331 332 OSCL_EXPORT_REF 333 bool SDPInfo::getMediaInfoInSegment(int segment, Oscl_Vector< mediaInfo *, SDPParserAlloc>& segmentMediaInfo) 334 { 335 if (segmentCount == 0) 336 return false; 337 for (int ii = 0; ii < numMediaObjects; ii++) 338 { 339 if (pMediaInfo[ii][0]->getSegmentNumber() == (uint)segment) 340 { 341 segmentMediaInfo.push_back(pMediaInfo[ii][0]); 342 } 343 } 344 return true; 345 } 346 347 OSCL_EXPORT_REF 348 void SDPInfo::setSegmentCount(int count) 349 { 350 segmentCount = count; 351 } 352 353 OSCL_EXPORT_REF 354 int SDPInfo::getSegmentCount() 355 { 356 return segmentCount; 357 } 358 359 OSCL_EXPORT_REF 360 bool SDPInfo::setSegmentActive(int segment, bool status) 361 { 362 if (segment <= segmentCount) 363 { 364 segmentInfo[segment].segmentActive = status; 365 return true; 366 } 367 else 368 return false; 369 } 370 371 OSCL_EXPORT_REF 372 bool SDPInfo::isSegmentActive(int segment) 373 { 374 if (segment <= segmentCount) 375 return segmentInfo[segment].segmentActive; 376 else 377 return false; 378 } 379 380 OSCL_EXPORT_REF 381 bool SDPInfo::setSegmentPayloadOrderPref(int segment, int* payloadArray, int len) 382 { 383 segmentInfo[segment].segmentPayloadOrderPref = false; 384 if (segment <= segmentCount) 385 { 386 Oscl_Vector< mediaInfo *, SDPParserAlloc> segmentMediaInfo; 387 if (getMediaInfoInSegment(segment, segmentMediaInfo) == true) 388 { 389 for (int ii = 0; ii < len; ii++) 390 { 391 for (uint32 jj = 0; jj < segmentMediaInfo.size(); jj++) 392 { 393 if (segmentMediaInfo[jj]->getPayloadSpecificInfoVector()[0]->getPayloadNumber() == (uint32)payloadArray[ii]) 394 { 395 segmentMediaInfo[jj]->setPayloadPreference(ii); 396 break; 397 } 398 } 399 } 400 } 401 } 402 else 403 return false; 404 segmentInfo[segment].segmentPayloadOrderPref = true; 405 return true; 406 } 407 408 OSCL_EXPORT_REF 409 bool SDPInfo::isPayloadOrderPreferenceSet(int segment) 410 { 411 if (segment <= segmentCount) 412 return segmentInfo[segment].segmentPayloadOrderPref; 413 else 414 return false; 415 } 416 417 OSCL_EXPORT_REF 418 mediaInfo* SDPInfo::getPreferedMediaInfo(int segment) 419 { 420 mediaInfo* media = NULL; 421 Oscl_Vector< mediaInfo *, SDPParserAlloc> segmentMediaInfo; 422 if (getMediaInfoInSegment(segment, segmentMediaInfo) == true) 423 { 424 for (uint32 jj = 0; jj < segmentMediaInfo.size(); jj++) 425 { 426 if (segmentMediaInfo[jj]->isMatched() == true) 427 { 428 media = segmentMediaInfo[jj]; 429 break; 430 } 431 } 432 } 433 return media; 434 } 435 436 OSCL_EXPORT_REF 437 int SDPInfo::getPreferedPayloadNumber(int segment) 438 { 439 int payload = -1; 440 Oscl_Vector< mediaInfo *, SDPParserAlloc> segmentMediaInfo; 441 if (getMediaInfoInSegment(segment, segmentMediaInfo) == true) 442 { 443 for (uint32 jj = 0; jj < segmentMediaInfo.size(); jj++) 444 { 445 if (segmentMediaInfo[jj]->isMatched() == true) 446 { 447 payload = segmentMediaInfo[jj]->getPayloadSpecificInfoVector()[0]->getPayloadNumber(); 448 break; 449 } 450 } 451 } 452 return payload; 453 } 454 455 OSCL_EXPORT_REF 456 const oscl_wchar * SDPInfo::getSdpFilename(uint32 &retsize) 457 { 458 retsize = SdpFilename.get_size(); 459 return SdpFilename.get_cstr(); 460 } 461 462 OSCL_EXPORT_REF 463 void SDPInfo::setSDPFilename(OSCL_wString& aURL) 464 { 465 SdpFilename = aURL; 466 } 467
