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 #include "oscl_base.h" 19 #include "oscl_mem.h" 20 21 #include "pvt_common.h" 22 #include "pvt_params.h" 23 24 25 /* CPVMediaParam */ 26 OSCL_EXPORT_REF CPVMediaParam::CPVMediaParam(PVCodecType_t aCodecType) 27 : iCodecType(aCodecType) 28 { 29 } 30 31 OSCL_EXPORT_REF CPVMediaParam::~CPVMediaParam() 32 { 33 34 } 35 36 OSCL_EXPORT_REF PVCodecType_t CPVMediaParam::GetCodecType() 37 { 38 return iCodecType; 39 } 40 41 42 43 /* CPVAudioParam */ 44 OSCL_EXPORT_REF CPVParam* CPVAudioParam::Copy() 45 { 46 return new CPVAudioParam(GetCodecType()); 47 } 48 49 OSCL_EXPORT_REF PV2WayMediaType CPVAudioParam::GetMediaType() 50 { 51 return PV_AUDIO; 52 } 53 54 CPVAudioParam::CPVAudioParam(PVCodecType_t aCodecType) : CPVMediaParam(aCodecType) 55 { 56 } 57 58 /* CPVVideoParam */ 59 OSCL_EXPORT_REF CPVVideoParam::~CPVVideoParam() 60 { 61 } 62 63 OSCL_EXPORT_REF PV2WayMediaType CPVVideoParam::GetMediaType() 64 { 65 return PV_VIDEO; 66 } 67 68 OSCL_EXPORT_REF CPVParam* CPVVideoParam::Copy() 69 { 70 return new CPVVideoParam(iWidth, iHeight, GetCodecType()); 71 } 72 73 OSCL_EXPORT_REF uint16 CPVVideoParam::GetWidth() 74 { 75 return iWidth; 76 } 77 78 OSCL_EXPORT_REF uint16 CPVVideoParam::GetHeight() 79 { 80 return iHeight; 81 } 82 83 CPVVideoParam::CPVVideoParam(uint16 aWidth, uint16 aHeight, PVCodecType_t aCodecType) 84 : CPVMediaParam(aCodecType), iWidth(aWidth), iHeight(aHeight) 85 { 86 } 87 88 89 OSCL_EXPORT_REF CPVM4vVideoParam::CPVM4vVideoParam(uint16 w, uint16 h, uint16 sz, uint8 *cfg) 90 : CPVVideoParam(w, h, PV_VID_TYPE_MPEG4), iSz(sz), iCfg(NULL) 91 { 92 if (iSz) 93 { 94 iCfg = (uint8 *)OSCL_DEFAULT_MALLOC(iSz); 95 oscl_memcpy(iCfg, cfg, iSz); 96 } 97 } 98 99 OSCL_EXPORT_REF CPVM4vVideoParam::~CPVM4vVideoParam() 100 { 101 if (iCfg) 102 { 103 OSCL_DEFAULT_FREE(iCfg); 104 iCfg = NULL; 105 } 106 } 107 108 OSCL_EXPORT_REF uint16 CPVM4vVideoParam::GetDecoderConfigSize() 109 { 110 return iSz; 111 } 112 113 OSCL_EXPORT_REF uint8 *CPVM4vVideoParam::GetDecoderConfig() 114 { 115 return iCfg; 116 } 117 118 OSCL_EXPORT_REF OsclAny CPVM4vVideoParam::Set(uint16 config_sz, uint8* cfg) 119 { 120 iSz = config_sz; 121 if (iCfg) 122 { 123 OSCL_DEFAULT_FREE(iCfg); 124 iCfg = NULL; 125 } 126 127 if (iSz) 128 { 129 iCfg = (uint8 *)OSCL_DEFAULT_MALLOC(iSz); 130 oscl_memcpy(iCfg, cfg, iSz); 131 } 132 } 133 134 OSCL_EXPORT_REF CPVParam* CPVM4vVideoParam::Copy() 135 { 136 return new CPVM4vVideoParam(GetWidth(), GetHeight(), iSz, iCfg); 137 } 138 139 /* CPVAMRAudioParam */ 140 OSCL_EXPORT_REF CPVAMRAudioParam::CPVAMRAudioParam() : CPVAudioParam(PV_AUD_TYPE_GSM) 141 { 142 } 143 144 OSCL_EXPORT_REF CPVAMRAudioParam::~CPVAMRAudioParam() 145 { 146 } 147 148 /* CPVG723AudioParam */ 149 OSCL_EXPORT_REF CPVG723AudioParam::CPVG723AudioParam() : CPVAudioParam(PV_AUD_TYPE_G723) 150 { 151 } 152 153 OSCL_EXPORT_REF CPVG723AudioParam::~CPVG723AudioParam() 154 { 155 156 } 157 158 /* CPVH263VideoParam */ 159 OSCL_EXPORT_REF CPVH263VideoParam::CPVH263VideoParam(uint16 w, uint16 h) : CPVVideoParam(w, h, PV_VID_TYPE_H263) 160 { 161 } 162 163 OSCL_EXPORT_REF CPVH263VideoParam::~CPVH263VideoParam() 164 { 165 166 } 167 168 169 170 /* CPVTrackInfo */ 171 OSCL_EXPORT_REF bool operator==(CPVTrackInfo &a, CPVTrackInfo &b) 172 { 173 return ((a.GetDirection() == b.GetDirection()) && (a.GetChannelId() == b.GetChannelId())); 174 } 175 176 /* CPVUserInputDtmf */ 177 OSCL_EXPORT_REF CPVUserInputDtmf::CPVUserInputDtmf(uint8 input, bool update, uint16 duration) 178 { 179 iInput = input; 180 iIsUpdate = update; 181 iDuration = duration; 182 } 183 184 OSCL_EXPORT_REF TPVUserInputType CPVUserInputDtmf::GetType() 185 { 186 return EDtmf; 187 } 188 189 OSCL_EXPORT_REF uint8 CPVUserInputDtmf::GetInput() 190 { 191 return iInput; 192 } 193 194 OSCL_EXPORT_REF bool CPVUserInputDtmf::IsUpdate() 195 { 196 return iIsUpdate; 197 } 198 199 OSCL_EXPORT_REF uint16 CPVUserInputDtmf::GetDuration() 200 { 201 return iDuration; 202 } 203 OSCL_EXPORT_REF CPVUserInput* CPVUserInputDtmf::Copy() 204 { 205 return new CPVUserInputDtmf(iInput, iIsUpdate, iDuration); 206 } 207 208 /* CPVUserInputAlphanumeric */ 209 OSCL_EXPORT_REF CPVUserInputAlphanumeric::CPVUserInputAlphanumeric(uint8* input, uint16 len): iInput(NULL), iLength(len) 210 { 211 if ((len > 0) && (input != NULL)) 212 { 213 iInput = (uint8*) OSCL_DEFAULT_MALLOC(len); 214 oscl_memcpy(iInput, input, len); 215 } 216 } 217 218 OSCL_EXPORT_REF CPVUserInputAlphanumeric::~CPVUserInputAlphanumeric() 219 { 220 if (iInput) 221 { 222 OSCL_DEFAULT_FREE(iInput); 223 } 224 } 225 226 OSCL_EXPORT_REF TPVUserInputType CPVUserInputAlphanumeric::GetType() 227 { 228 return EAlphanumeric ; 229 } 230 231 OSCL_EXPORT_REF uint8* CPVUserInputAlphanumeric::GetInput() 232 { 233 return iInput; 234 } 235 236 OSCL_EXPORT_REF uint16 CPVUserInputAlphanumeric::GetLength() 237 { 238 return iLength; 239 } 240 OSCL_EXPORT_REF CPVUserInput* CPVUserInputAlphanumeric::Copy() 241 { 242 return new CPVUserInputAlphanumeric(iInput, iLength); 243 } 244 245 /* TPVH245VendorObjectIdentifier */ 246 OSCL_EXPORT_REF TPVH245VendorObjectIdentifier::TPVH245VendorObjectIdentifier(uint8* vendor, uint16 vendorLength) 247 : iVendor(NULL), iVendorLength(vendorLength) 248 { 249 iVendor = (uint8*)OSCL_DEFAULT_MALLOC(iVendorLength); 250 oscl_memcpy(iVendor, vendor, iVendorLength); 251 } 252 253 OSCL_EXPORT_REF TPVH245VendorObjectIdentifier::~TPVH245VendorObjectIdentifier() 254 { 255 if (iVendor) 256 { 257 OSCL_DEFAULT_FREE(iVendor); 258 } 259 } 260 261 OSCL_EXPORT_REF TPVH245VendorType TPVH245VendorObjectIdentifier::GetVendorType() 262 { 263 return EObjectIdentifier; 264 } 265 266 OSCL_EXPORT_REF uint8* TPVH245VendorObjectIdentifier::GetVendor(uint16* length) 267 { 268 *length = iVendorLength; 269 return iVendor; 270 } 271 272 OSCL_EXPORT_REF TPVH245Vendor* TPVH245VendorObjectIdentifier::Copy() 273 { 274 return OSCL_NEW(TPVH245VendorObjectIdentifier, (iVendor, iVendorLength)); 275 } 276 277 278 /* TPVVendorH221NonStandard */ 279 OSCL_EXPORT_REF TPVVendorH221NonStandard::TPVVendorH221NonStandard(uint8 t35countryCode, uint8 t35extension, uint32 manufacturerCode): 280 iT35CountryCode(t35countryCode), iT35Extension(t35extension), iManufacturerCode(manufacturerCode) 281 { 282 } 283 284 OSCL_EXPORT_REF TPVVendorH221NonStandard::~TPVVendorH221NonStandard() 285 { 286 } 287 288 OSCL_EXPORT_REF TPVH245VendorType TPVVendorH221NonStandard::GetVendorType() 289 { 290 return EH221NonStandard; 291 } 292 293 OSCL_EXPORT_REF TPVH245Vendor* TPVVendorH221NonStandard::Copy() 294 { 295 return OSCL_NEW(TPVVendorH221NonStandard, (iT35CountryCode, iT35Extension, iManufacturerCode)); 296 } 297 298 OSCL_EXPORT_REF uint8 TPVVendorH221NonStandard::GetT35CountryCode() 299 { 300 return iT35CountryCode; 301 } 302 303 OSCL_EXPORT_REF uint8 TPVVendorH221NonStandard::GetT35Extension() 304 { 305 return iT35Extension; 306 } 307 308 OSCL_EXPORT_REF uint32 TPVVendorH221NonStandard::GetManufacturerCode() 309 { 310 return iManufacturerCode; 311 } 312 313 /* TPVVendorIdentification */ 314 OSCL_EXPORT_REF TPVVendorIdentification::TPVVendorIdentification() : iVendor(NULL), iProductNumber(NULL), iProductNumberLen(0), 315 iVersionNumber(NULL), iVersionNumberLen(0) 316 { 317 } 318 319 OSCL_EXPORT_REF TPVVendorIdentification::TPVVendorIdentification(TPVH245Vendor* vendor, 320 uint8* pn, uint16 pn_len, 321 uint8* vn, uint16 vn_len) 322 { 323 if (vendor) 324 { 325 iVendor = vendor->Copy(); 326 } 327 if (pn_len) 328 { 329 iProductNumber = (uint8*)OSCL_DEFAULT_MALLOC(pn_len); 330 oscl_memcpy(iProductNumber, pn, pn_len); 331 iProductNumberLen = pn_len; 332 } 333 if (vn_len) 334 { 335 iVersionNumber = (uint8*)OSCL_DEFAULT_MALLOC(vn_len); 336 oscl_memcpy(iVersionNumber, vn, vn_len); 337 iVersionNumberLen = vn_len; 338 } 339 } 340 341 OSCL_EXPORT_REF TPVVendorIdentification::~TPVVendorIdentification() 342 { 343 if (iVendor) 344 { 345 OSCL_DELETE(iVendor); 346 } 347 if (iProductNumber) 348 { 349 OSCL_DEFAULT_FREE(iProductNumber); 350 } 351 if (iVersionNumber) 352 { 353 OSCL_DEFAULT_FREE(iVersionNumber); 354 } 355 } 356 357 358 /* CPvtDiagnosticIndication */ 359 OSCL_EXPORT_REF CPvtDiagnosticIndication::CPvtDiagnosticIndication(TPVTerminalEvent aEvent, int aParam1, int aParam2, int aParam3) 360 : iEvent(aEvent), iParam1(aParam1), iParam2(aParam2), iParam3(aParam3) 361 { 362 } 363 364 OSCL_EXPORT_REF CPvtDiagnosticIndication::~CPvtDiagnosticIndication() 365 { 366 } 367 368 /* CPVGenericMuxParam */ 369 OSCL_EXPORT_REF CPVGenericMuxParam::CPVGenericMuxParam(TPVMuxType aMuxType): 370 discard_corrupt_video(PARAM_DEFAULT), 371 max_discard_video_sdu_size(0), 372 err_rate_threshold_to_req_I_frame(0), 373 audio_err_rate_update_interval(0), 374 audio_encode_frame_delay(0), 375 audio_decode_frame_delay(0), 376 iMuxType(aMuxType) 377 { 378 } 379 380 OSCL_EXPORT_REF TPVMuxType CPVGenericMuxParam::GetMuxType() 381 { 382 return iMuxType; 383 } 384 385 OSCL_EXPORT_REF CPVParam* CPVGenericMuxParam::Copy() 386 { 387 CPVGenericMuxParam* ret = new CPVGenericMuxParam(iMuxType); 388 ret->discard_corrupt_video = discard_corrupt_video; 389 ret->max_discard_video_sdu_size = max_discard_video_sdu_size; 390 ret->err_rate_threshold_to_req_I_frame = err_rate_threshold_to_req_I_frame; 391 ret->audio_err_rate_update_interval = audio_err_rate_update_interval; 392 ret->audio_encode_frame_delay = audio_encode_frame_delay; 393 ret->audio_decode_frame_delay = audio_decode_frame_delay; 394 return ret; 395 } 396 397 OSCL_EXPORT_REF OsclAny CPVGenericMuxParam::Copy(CPVGenericMuxParam* param) 398 { 399 param->discard_corrupt_video = discard_corrupt_video; 400 param->max_discard_video_sdu_size = max_discard_video_sdu_size; 401 param->err_rate_threshold_to_req_I_frame = err_rate_threshold_to_req_I_frame; 402 param->audio_err_rate_update_interval = audio_err_rate_update_interval; 403 param->audio_encode_frame_delay = audio_encode_frame_delay; 404 param->audio_decode_frame_delay = audio_decode_frame_delay; 405 return; 406 } 407 408 409 /* CPVH223MuxParam */ 410 OSCL_EXPORT_REF CPVH223MuxParam::CPVH223MuxParam() : CPVGenericMuxParam(MUX_H223), 411 iBitrate(PVT_NOT_SET), 412 iLevel(H223_LEVEL_UNKNOWN), 413 iMaxAl1SduSize(PVT_NOT_SET), 414 iMaxAl2SduSize(PVT_NOT_SET), 415 iMaxAl3SduSize(PVT_NOT_SET), 416 iMaxAl1SduSizeR(PVT_NOT_SET), 417 iMaxAl2SduSizeR(PVT_NOT_SET), 418 iMaxAl3SduSizeR(PVT_NOT_SET), 419 iParseOnResyncMarkers(false), 420 iOutgoingPduType(H223_PDU_COMBINED), 421 iMaxPduSize(0), 422 iIdleSyncType(H223_IDLE_SYNC_NONE), 423 iIdleSyncByte(0x00) 424 { 425 } 426 427 OSCL_EXPORT_REF CPVH223MuxParam::~CPVH223MuxParam() 428 { 429 } 430 431 OSCL_EXPORT_REF CPVParam* CPVH223MuxParam::Copy() 432 { 433 CPVH223MuxParam* ret = new CPVH223MuxParam(); 434 CPVGenericMuxParam::Copy(ret); 435 ret->iBitrate = iBitrate; 436 ret->iLevel = iLevel; 437 ret->iMaxAl1SduSize = iMaxAl1SduSize; 438 ret->iMaxAl2SduSize = iMaxAl2SduSize; 439 ret->iMaxAl3SduSize = iMaxAl3SduSize; 440 ret->iMaxAl1SduSizeR = iMaxAl1SduSizeR; 441 ret->iMaxAl2SduSizeR = iMaxAl2SduSizeR; 442 ret->iMaxAl3SduSizeR = iMaxAl3SduSizeR; 443 ret->iParseOnResyncMarkers = iParseOnResyncMarkers; 444 ret->iOutgoingPduType = iOutgoingPduType; 445 ret->iMaxPduSize = iMaxPduSize; 446 ret->iIdleSyncType = iIdleSyncType; 447 ret->iIdleSyncByte = iIdleSyncByte; 448 return ret; 449 } 450 451 /* CPVH245Param */ 452 OSCL_EXPORT_REF CPVH245Param::CPVH245Param() 453 { 454 } 455 456 OSCL_EXPORT_REF CPVParam* CPVH245Param::Copy() 457 { 458 CPVH245Param* ret = new CPVH245Param(); 459 return ret; 460 } 461 462 /* CPVSrpParam */ 463 OSCL_EXPORT_REF CPVSrpParam::CPVSrpParam() 464 { 465 466 } 467 468 OSCL_EXPORT_REF CPVParam* CPVSrpParam::Copy() 469 { 470 CPVSrpParam* ret = new CPVSrpParam(); 471 return ret; 472 } 473 474 /* CPVTerminalParam */ 475 OSCL_EXPORT_REF CPVTerminalParam::CPVTerminalParam(CPVGenericMuxParam* muxParam): iMuxParam(NULL) 476 { 477 if (muxParam) 478 { 479 iMuxParam = (CPVGenericMuxParam*)muxParam->Copy(); 480 } 481 } 482 483 OSCL_EXPORT_REF CPVTerminalParam::CPVTerminalParam(CPVTerminalParam& that): CPVParam(that), iMuxParam(NULL) 484 { 485 if (that.iMuxParam) 486 { 487 iMuxParam = (CPVGenericMuxParam*)that.iMuxParam->Copy(); 488 } 489 } 490 491 492 CPVTerminalParam::~CPVTerminalParam() 493 { 494 if (iMuxParam) 495 { 496 delete iMuxParam; 497 } 498 } 499 500 501 OSCL_EXPORT_REF OsclAny CPVTerminalParam::SetMuxParam(CPVGenericMuxParam* muxParam) 502 { 503 if (iMuxParam) 504 { 505 delete iMuxParam; 506 } 507 iMuxParam = (CPVGenericMuxParam*)muxParam->Copy(); 508 } 509 510 OSCL_EXPORT_REF CPVGenericMuxParam* CPVTerminalParam::GetMuxParam() 511 { 512 return iMuxParam; 513 } 514 515 /* CPVH324MParam */ 516 OSCL_EXPORT_REF CPVH324MParam::CPVH324MParam(CPVH223MuxParam* h223param) : CPVTerminalParam(h223param), iH245Param(NULL), iSrpParam(NULL) 517 { 518 iAllowAl1Video = false; 519 iAllowAl2Video = true; 520 iAllowAl3Video = true; 521 iUseAl1Video = true; 522 iUseAl2Video = true; 523 iUseAl3Video = true; 524 iVideoLayer = PVT_AL_UNKNOWN; 525 iMasterSlave = PVT_MSD_INDETERMINATE; 526 iForceVideoLayerIfMaster = PVT_AL_UNKNOWN; 527 iForceVideoLayerIfSlave = PVT_AL_UNKNOWN; 528 iSpecifyReceiveAndTransmitCapability = false; 529 iSendRme = false; 530 iSkipMsd = false; 531 iRequestMaxMuxPduSize = 0; 532 } 533 534 OSCL_EXPORT_REF CPVH324MParam::CPVH324MParam(const CPVH324MParam& that) : CPVTerminalParam((CPVTerminalParam&)that) 535 { 536 iAllowAl1Video = that.iAllowAl1Video; 537 iAllowAl2Video = that.iAllowAl2Video; 538 iAllowAl3Video = that.iAllowAl3Video; 539 iUseAl1Video = that.iUseAl1Video; 540 iUseAl2Video = that.iUseAl2Video; 541 iUseAl3Video = that.iUseAl3Video; 542 iVideoLayer = that.iVideoLayer; 543 iMasterSlave = that.iMasterSlave; 544 iForceVideoLayerIfMaster = that.iForceVideoLayerIfMaster; 545 iForceVideoLayerIfSlave = that.iForceVideoLayerIfSlave; 546 iSpecifyReceiveAndTransmitCapability = that.iSpecifyReceiveAndTransmitCapability; 547 iSendRme = that.iSendRme; 548 iSkipMsd = that.iSkipMsd; 549 iRequestMaxMuxPduSize = that.iRequestMaxMuxPduSize; 550 iH245Param = NULL; 551 if (that.iH245Param) 552 iH245Param = (CPVH245Param*)that.iH245Param->Copy(); 553 iSrpParam = NULL; 554 if (that.iSrpParam) 555 iSrpParam = (CPVSrpParam*)that.iSrpParam->Copy(); 556 } 557 558 OSCL_EXPORT_REF CPVH324MParam::~CPVH324MParam() 559 { 560 561 } 562 563 OSCL_EXPORT_REF TPVTerminalType CPVH324MParam::GetTerminalType() 564 { 565 return PV_324M; 566 } 567 568 OSCL_EXPORT_REF CPVParam* CPVH324MParam::Copy() 569 { 570 return new CPVH324MParam(*this); 571 } 572 573 OSCL_EXPORT_REF OsclAny CPVH324MParam::SetH223Param(CPVH223MuxParam* h223Param) 574 { 575 SetMuxParam(h223Param); 576 } 577 578 OSCL_EXPORT_REF CPVH223MuxParam* CPVH324MParam::GetH223Param() 579 { 580 return (CPVH223MuxParam*)GetMuxParam(); 581 } 582 583 OSCL_EXPORT_REF OsclAny CPVH324MParam::SetSRPParam(CPVSrpParam* srpParam) 584 { 585 iSrpParam = (CPVSrpParam*)srpParam->Copy(); 586 } 587 588 OSCL_EXPORT_REF OsclAny CPVH324MParam::SetH245Param(CPVH245Param* h245Param) 589 { 590 iH245Param = (CPVH245Param*)h245Param->Copy(); 591 } 592 593 OSCL_EXPORT_REF TPVVideoEncoderParam::TPVVideoEncoderParam(): 594 video_bitrate(KPVDefaultVideoBitRate), 595 codec(PV_VID_TYPE_MPEG4), 596 video_frame_rate(KPVDefaultFrameRate), 597 air(0), 598 intra_refresh(1), 599 data_partitioning(1), 600 advanced(0), 601 use_gov(0), 602 rvlc(0), 603 use_resync(480), 604 use_hec(0), 605 use_gobsync(0), 606 vos(0), 607 ref_frame_rate(15), 608 orig_frameskip(1), 609 chosen_frame_skip(3), 610 qp(10), 611 qpi(10), 612 cam_low_light_mode(1), 613 cam_saturation_level(55), 614 cam_contrast_level(90), 615 cam_edge_enhance(85), 616 cam_brightness(100), 617 deblocking_filter(0), 618 prefilter(0), 619 prefilter_coeff1(0), 620 prefilter_coeff2(0), 621 prefilter_coeff3(0), 622 buffer_backlog(-55000), 623 qp_max(31), 624 qp_min(1), 625 qp_delta_frame(30), 626 qp_delta_slice(30), 627 iframe_interval(KPVDefaultIFrameInterval), 628 iframe_request_interval(KPVDefaultIFrameRequestInterval) 629 {}; 630 631 632 OSCL_EXPORT_REF PVMFFormatType PVCodecTypeToPVMFFormatType(PVCodecType_t aCodecType) 633 { 634 PVMFFormatType aFormatType = PVMF_MIME_FORMAT_UNKNOWN; 635 switch (aCodecType) 636 { 637 case PV_AUD_TYPE_G723: 638 aFormatType = PVMF_MIME_G723; 639 break; 640 case PV_AUD_TYPE_GSM: 641 aFormatType = PVMF_MIME_AMR_IF2; 642 break; 643 case PV_VID_TYPE_H263: 644 aFormatType = PVMF_MIME_H2632000; 645 break; 646 case PV_VID_TYPE_MPEG4: 647 aFormatType = PVMF_MIME_M4V; 648 break; 649 default: 650 break; 651 } 652 return aFormatType; 653 } 654 655 OSCL_EXPORT_REF PVCodecType_t PVMFFormatTypeToPVCodecType(PVMFFormatType aFormatType) 656 { 657 PVCodecType_t aCodecType = PV_CODEC_TYPE_NONE; 658 659 if (aFormatType == PVMF_MIME_G723) 660 { 661 aCodecType = PV_AUD_TYPE_G723; 662 } 663 else if (aFormatType == PVMF_MIME_AMR_IF2) 664 { 665 aCodecType = PV_AUD_TYPE_GSM; 666 } 667 else if ((aFormatType == PVMF_MIME_H2632000) || (aFormatType == PVMF_MIME_H2631998)) 668 { 669 aCodecType = PV_VID_TYPE_H263; 670 } 671 else if (aFormatType == PVMF_MIME_M4V) 672 { 673 aCodecType = PV_VID_TYPE_MPEG4; 674 } 675 else if (aFormatType == PVMF_MIME_USERINPUT_BASIC_STRING) 676 { 677 aCodecType = PV_UI_BASIC_STRING; 678 } 679 else if (aFormatType == PVMF_MIME_USERINPUT_IA5_STRING) 680 { 681 aCodecType = PV_UI_IA5_STRING; 682 } 683 else if (aFormatType == PVMF_MIME_USERINPUT_GENERAL_STRING) 684 { 685 aCodecType = PV_UI_GENERAL_STRING; 686 } 687 else if (aFormatType == PVMF_MIME_USERINPUT_DTMF) 688 { 689 aCodecType = PV_UI_DTMF; 690 } 691 692 return aCodecType; 693 } 694 695 OSCL_EXPORT_REF PV2WayMediaType PVMFFormatTypeToPVMediaType(PVMFFormatType aFormatType) 696 { 697 PV2WayMediaType aMediaType = PV_MEDIA_NONE; 698 if (aFormatType.isAudio()) 699 { 700 aMediaType = PV_AUDIO; 701 } 702 if (aFormatType.isVideo()) 703 { 704 aMediaType = PV_VIDEO; 705 } 706 if (aFormatType.isUserInput()) 707 { 708 aMediaType = PV_USER_INPUT; 709 } 710 return aMediaType; 711 } 712 713 714 OSCL_EXPORT_REF int IndexForAdaptationLayer(TPVAdaptationLayer al) 715 { 716 int ret = -1; 717 switch (al) 718 { 719 case PVT_AL1: 720 ret = 2; 721 break; 722 case PVT_AL2: 723 ret = 3; 724 break; 725 case PVT_AL3: 726 ret = 5; 727 break; 728 default: 729 break; 730 } 731 return ret; 732 } 733 734 OSCL_EXPORT_REF TPVAdaptationLayer AdaptationLayerForIndex(int al_index) 735 { 736 TPVAdaptationLayer ret = PVT_AL1; 737 switch (al_index) 738 { 739 case 1: 740 case 2: 741 ret = PVT_AL1; 742 break; 743 case 3: 744 case 4: 745 ret = PVT_AL2; 746 break; 747 case 5: 748 ret = PVT_AL3; 749 break; 750 } 751 return ret; 752 } 753 754 OSCL_EXPORT_REF ErrorProtectionLevel_t EplForAdaptationLayer(TPVAdaptationLayer al) 755 { 756 ErrorProtectionLevel_t epl = E_EP_LOW; 757 switch (al) 758 { 759 case PVT_AL1: 760 epl = E_EP_LOW; 761 break; 762 case PVT_AL2: 763 epl = E_EP_MEDIUM; 764 break; 765 case PVT_AL3: 766 epl = E_EP_HIGH; 767 break; 768 default: 769 break; 770 } 771 return epl; 772 } 773 774 OSCL_EXPORT_REF PV2WayMediaType GetMediaType(PVCodecType_t codec) 775 { 776 PV2WayMediaType media_type = PV_MEDIA_NONE; 777 switch (codec) 778 { 779 case PV_AUD_TYPE_G723: 780 case PV_AUD_TYPE_GSM: 781 media_type = PV_AUDIO; 782 break; 783 case PV_VID_TYPE_H263: 784 case PV_VID_TYPE_MPEG4: 785 media_type = PV_VIDEO; 786 break; 787 case PV_UI_BASIC_STRING: 788 case PV_UI_IA5_STRING: 789 case PV_UI_GENERAL_STRING: 790 case PV_UI_DTMF: 791 media_type = PV_USER_INPUT; 792 break; 793 default: 794 break; 795 } 796 return media_type; 797 } 798 799 OSCL_EXPORT_REF H324ChannelParameters::H324ChannelParameters(TPVDirection dir, PVMFFormatType mediaType, unsigned bandwidth) 800 : iCodecs(NULL) 801 { 802 OSCL_UNUSED_ARG(mediaType); 803 iBandwidth = bandwidth; 804 iCodecs = new Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>(); 805 FormatCapabilityInfo codec_info; 806 codec_info.dir = dir; 807 } 808 809 OSCL_EXPORT_REF H324ChannelParameters::H324ChannelParameters(const H324ChannelParameters& that) 810 : iCodecs(NULL) 811 { 812 iBandwidth = that.iBandwidth; 813 814 if (that.iCodecs) 815 { 816 iCodecs = new Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>(*that.iCodecs); 817 } 818 } 819 820 OSCL_EXPORT_REF H324ChannelParameters::~H324ChannelParameters() 821 { 822 if (iCodecs) 823 OSCL_DELETE(iCodecs); 824 } 825 826 OSCL_EXPORT_REF PV2WayMediaType H324ChannelParameters::GetMediaType() 827 { 828 if (iCodecs == NULL) 829 { 830 return PV_MEDIA_NONE; 831 } 832 return PVMFFormatTypeToPVMediaType((*iCodecs)[0].format); 833 } 834 835 OSCL_EXPORT_REF unsigned H324ChannelParameters::GetBandwidth() 836 { 837 return iBandwidth; 838 } 839 840 OSCL_EXPORT_REF void H324ChannelParameters::SetCodecs(Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>& codecs) 841 { 842 if (iCodecs) 843 { 844 OSCL_DELETE(iCodecs); 845 iCodecs = NULL; 846 } 847 if (!codecs.size()) 848 return; 849 850 iCodecs = new Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>(codecs); 851 } 852 853 OSCL_EXPORT_REF Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>* H324ChannelParameters::GetCodecs() 854 { 855 return iCodecs; 856 } 857 858 OSCL_EXPORT_REF CodecCapabilityInfo::CodecCapabilityInfo() 859 : codec(PV_CODEC_TYPE_NONE), 860 dir(PV_DIRECTION_NONE), 861 max_bitrate(0), 862 min_sample_size(0), 863 max_sample_size(0) 864 { 865 } 866 867 OSCL_EXPORT_REF CodecCapabilityInfo* CodecCapabilityInfo::Copy() 868 { 869 CodecCapabilityInfo* ret = new CodecCapabilityInfo(); 870 ret->codec = codec; 871 ret->dir = dir; 872 ret->max_bitrate = max_bitrate; 873 return ret; 874 } 875 876 OSCL_EXPORT_REF VideoCodecCapabilityInfo::VideoCodecCapabilityInfo() 877 : codec_specific_info(NULL), 878 codec_specific_info_len(0) 879 { 880 } 881 882 OSCL_EXPORT_REF CodecCapabilityInfo* VideoCodecCapabilityInfo::Copy() 883 { 884 VideoCodecCapabilityInfo* ret = new VideoCodecCapabilityInfo(); 885 ret->codec = codec; 886 ret->dir = dir; 887 ret->max_bitrate = max_bitrate; 888 ret->resolutions = resolutions; 889 ret->codec_specific_info_len = codec_specific_info_len; 890 ret->codec_specific_info = (uint8*)OSCL_DEFAULT_MALLOC(codec_specific_info_len); 891 oscl_memcpy(ret->codec_specific_info, codec_specific_info, codec_specific_info_len); 892 return ret; 893 } 894 895 OSCL_EXPORT_REF const char* GetFormatsString(TPVDirection aDir, PV2WayMediaType aMediaType) 896 { 897 switch (aDir) 898 { 899 case OUTGOING: 900 switch (aMediaType) 901 { 902 case PV_AUDIO: 903 return PV_H324_AUDIO_INPUT_FORMATS; 904 case PV_VIDEO: 905 return PV_H324_VIDEO_INPUT_FORMATS; 906 case PV_MULTIPLEXED: 907 return PV_H324_MUX_INPUT_FORMATS; 908 default: 909 break; 910 } 911 break; 912 case INCOMING: 913 switch (aMediaType) 914 { 915 case PV_AUDIO: 916 return PV_H324_AUDIO_OUTPUT_FORMATS; 917 case PV_VIDEO: 918 return PV_H324_VIDEO_OUTPUT_FORMATS; 919 case PV_MULTIPLEXED: 920 return PV_H324_MUX_OUTPUT_FORMATS; 921 default: 922 break; 923 } 924 break; 925 default: 926 break; 927 } 928 return NULL; 929 } 930 931 OSCL_EXPORT_REF const char* GetFormatsValtypeString(TPVDirection aDir, PV2WayMediaType aMediaType) 932 { 933 switch (aDir) 934 { 935 case OUTGOING: 936 switch (aMediaType) 937 { 938 case PV_AUDIO: 939 return PV_H324_AUDIO_INPUT_FORMATS_VALTYPE; 940 case PV_VIDEO: 941 return PV_H324_VIDEO_INPUT_FORMATS_VALTYPE; 942 case PV_MULTIPLEXED: 943 return PV_H324_MUX_INPUT_FORMATS_VALTYPE; 944 default: 945 break; 946 } 947 break; 948 case INCOMING: 949 switch (aMediaType) 950 { 951 case PV_AUDIO: 952 return PV_H324_AUDIO_OUTPUT_FORMATS_VALTYPE; 953 case PV_VIDEO: 954 return PV_H324_VIDEO_OUTPUT_FORMATS_VALTYPE; 955 case PV_MULTIPLEXED: 956 return PV_H324_MUX_OUTPUT_FORMATS_VALTYPE; 957 default: 958 break; 959 } 960 break; 961 default: 962 break; 963 } 964 return NULL; 965 } 966 967 OSCL_EXPORT_REF void GetSampleSize(PVMFFormatType aFormatType, uint32* aMin, uint32* aMax) 968 { 969 *aMin = *aMax = 0; 970 if (aFormatType == PVMF_MIME_G723) 971 { 972 *aMin = 20; 973 *aMax = 24; 974 } 975 else if (aFormatType == PVMF_MIME_AMR_IF2) 976 { 977 *aMin = 13; 978 *aMax = 31; 979 } 980 } 981 982 983 OSCL_EXPORT_REF bool CodecRequiresFsi(PVCodecType_t codec) 984 { 985 bool ret = false; 986 switch (codec) 987 { 988 case PV_VID_TYPE_MPEG4: 989 ret = true; 990 break; 991 default: 992 break; 993 } 994 return ret; 995 } 996 997 998