Home | History | Annotate | Download | only in src 
      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