protocols/systems/3g-324m_pvterminal/h223/src/logicalchannel.cpp

   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_rand.h"
  19
  20
  21 #include "pvmf_simple_media_buffer.h"
  22 #include "pvmf_media_data.h"
  23 #include "pvmf_media_cmd.h"
  24 #include "pvmf_media_msg_format_ids.h"
  25
  26 #ifndef OSCL_MIME_STRING_UTILS_H
  27 #include "pv_mime_string_utils.h"
  28 #endif
  29
  30 #include "logicalchannel.h"
  31
  32 #ifndef PER_COPIER
  33 #include "h245_copier.h"
  34 #endif
  35
  36 #ifndef PER_DELETER
  37 #include "h245_deleter.h"
  38 #endif
  39 // decreasing DEF_CHANNEL_BUFFER_SIZE_MS can result out of memory errors,
  40 // please change also PV_MAX_VIDEO_FRAME_SIZE to lower value.
  41 #define DEF_CHANNEL_BITRATE 64000
  42 #define DEF_INCOMING_CHANNEL_BUFFER_SIZE_MS 2800
  43 #define DEF_OUTGOING_CHANNEL_BUFFER_SIZE_MS 2800
  44 #define TIMESTAMP_MAX INT_MAX
  45 #define DEF_SEGMENTABLE_CHANNEL_OH_BPS 2000
  46 #define H223_INCOMING_CHANNEL_NUM_MEDIA_MSG 300
  47 #define H223_OUTGOING_CHANNEL_NUM_MEDIA_MSG 300
  48 #define H223_INCOMING_CHANNEL_FRAGMENT_SIZE 128
  49 #define H223_INCOMING_CHANNEL_NUM_MEDIA_DATA 300
  50 #define H223_INCOMING_CHANNEL_NUM_FRAGS_IN_MEDIA_DATA (3*1024/128)
  51 #define PV2WAY_BPS_TO_BYTES_PER_MSEC_RIGHT_SHIFT 13
  52 #define H223_LCN_IN_TIMESTAMP_BASE 40
  53 #ifdef LIP_SYNC_TESTING
  54
  55 #define H263_START_BYTE_1 0x00
  56 #define H263_START_BYTE_2 0x00
  57 #define H263_START_BYTE_3 0x80
  58
  59 #define VOP_START_BYTE_1 0x00
  60 #define VOP_START_BYTE_2 0x00
  61 #define VOP_START_BYTE_3 0x01
  62 #define VOP_START_BYTE_4 0xB6
  63 #define VOP_START_BYTE_5 0xB0
  64 #endif
  65
  66 #ifdef LIP_SYNC_TESTING
  67 /***********************Outgoing side********************/
  68 uint32  g_Checkcount = 0;
  69 int g_CheckSampleTime = -1;
  70 uint32  g_Incmtsmsec = 0;
  71 bool g_OnlyOneTime = true;
  72 /*****************************************************************/
  73 //Incoming side
  74 uint32 g_IncmAudioTS = 0;
  75 uint32  g_IncmVideoTS = 0;
  76 uint32 g_TotalCountIncm = 0;
  77 int g_DiffIncmVidAudTS = 0;
  78 int g_iSqrIncCalVidAudTS = 0;
  79 int  g_IncRtMnSqCalc = 0;
  80 /**********************************************************************/
  81 int  g_RecTimeStamp = 0;
  82
  83 #endif
  84
  85 H223LogicalChannel::H223LogicalChannel(TPVChannelId num,
  86                                        bool segmentable,
  87                                        OsclSharedPtr<AdaptationLayer>& al,
  88                                        PS_DataType data_type,
  89                                        LogicalChannelObserver* observer,
  90                                        uint32 bitrate,
  91                                        uint32 sample_interval,
  92                                        uint32 num_media_data)
  93         : PvmfPortBaseImpl(num, this),
  94         lcn(num),
  95         next(NULL),
  96         iAl(al),
  97         iBitrate(0),
  98         iSampleInterval(0),
  99         iObserver(observer),
 100         iFormatSpecificInfo(NULL),
 101         iFormatSpecificInfoLen(0),
 102         iLogger(NULL),
 103         iDataType(NULL),
 104         iAudioLatency(0),
 105         iVideoLatency(0)
 106 {
 107     iSegmentable = segmentable;
 108     iIncomingSkew = 0;
 109     iLastSduTimestamp = 0;
 110     iSampleInterval = sample_interval;
 111     uint32 bitrate_overhead = IsSegmentable() ? DEF_SEGMENTABLE_CHANNEL_OH_BPS :
 112                               (uint32)((2000 / sample_interval + 1) >> 1) * (al->GetHdrSz() + al->GetTrlrSz());
 113     iBitrate = bitrate + bitrate_overhead;
 114     iNumMediaData = num_media_data;
 115     iMaxSduSize = (uint16)(iAl->GetSduSize() - iAl->GetHdrSz() - iAl->GetTrlrSz());
 116     if (data_type)
 117     {
 118         iDataType = Copy_DataType(data_type);
 119     }
 120     iMediaType = GetFormatType();
 121     iPaused = false;
 122     iClock = NULL;
 123 }
 124
 125 H223LogicalChannel::~H223LogicalChannel()
 126 {
 127     if (iDataType)
 128     {
 129         Delete_DataType(iDataType);
 130         OSCL_DEFAULT_FREE(iDataType);
 131         iDataType = NULL;
 132     }
 133     if (iFormatSpecificInfo)
 134     {
 135         oscl_free(iFormatSpecificInfo);
 136         iFormatSpecificInfo = NULL;
 137         iFormatSpecificInfoLen = 0;
 138     }
 139
 140     // we need to clear the activity handler, since otherwise the PvmfPortBaseImpl destructor
 141     // ends up calling back onto our HandlePortActivity method, which no longer exists because
 142     // this objects's destructor has already been called.
 143     SetActivityHandler(NULL);
 144 }
 145
 146 void H223LogicalChannel::Init()
 147 {
 148     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223LogicalChannel::Init"));
 149     iSendFormatSpecificInfo = false;
 150 }
 151
 152 PVMFStatus H223LogicalChannel::SetFormatSpecificInfo(uint8* info, uint16 info_len)
 153 {
 154     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223LogicalChannel::SetFormatSpecificInfo lcn=%d, info_len=%d, info=%x", lcn, info_len, info));
 155     iSendFormatSpecificInfo = false;
 156     if (iFormatSpecificInfo)
 157     {
 158         oscl_free(iFormatSpecificInfo);
 159         iFormatSpecificInfo = NULL;
 160         iFormatSpecificInfoLen = 0;
 161     }
 162
 163     if (info == NULL || info_len == 0)
 164         return PVMFSuccess;
 165
 166     iFormatSpecificInfo = (uint8*)oscl_malloc(info_len);
 167     oscl_memcpy(iFormatSpecificInfo, info, info_len);
 168     iFormatSpecificInfoLen = info_len;
 169     iSendFormatSpecificInfo = true;
 170     return PVMFSuccess;
 171 }
 172
 173 const uint8* H223LogicalChannel::GetFormatSpecificInfo(uint32* info_len)
 174 {
 175     if (info_len == NULL)
 176     {
 177         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223LogicalChannel::GetFormatSpecificInfo ERROR info_len==NULL"));
 178         return NULL;
 179     }
 180     *info_len = iFormatSpecificInfoLen;
 181     return iFormatSpecificInfo;
 182 }
 183
 184
 185 OSCL_EXPORT_REF void H223LogicalChannel::QueryInterface(const PVUuid& aUuid, OsclAny*& aPtr)
 186 {
 187     aPtr = NULL;
 188     if (aUuid == PVMI_CAPABILITY_AND_CONFIG_PVUUID)
 189     {
 190         aPtr = (PvmiCapabilityAndConfig*)this;
 191     }
 192     else if (aUuid == PVH324MLogicalChannelInfoUuid)
 193     {
 194         aPtr = (LogicalChannelInfo*)this;
 195     }
 196     else
 197     {
 198         OSCL_LEAVE(OsclErrNotSupported);
 199     }
 200 }
 201
 202 void H223LogicalChannel::Pause()
 203 {
 204     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::Pause lcn=%d", lcn));
 205     iPaused = true;
 206     // flush any pending media data
 207     Flush();
 208 }
 209
 210 void H223LogicalChannel::Resume()
 211 {
 212     iPaused = false;
 213 }
 214
 215 H223OutgoingChannel::H223OutgoingChannel(TPVChannelId num,
 216         bool segmentable,
 217         OsclSharedPtr<AdaptationLayer>& al,
 218         PS_DataType data_type,
 219         LogicalChannelObserver* observer,
 220         uint32 bitrate,
 221         uint32 sample_interval,
 222         uint32 num_media_data)
 223         : H223LogicalChannel(num, segmentable, al, data_type, observer, bitrate, sample_interval, num_media_data),
 224         iMediaMsgMemoryPool(NULL),
 225         iMediaDataEntryAlloc(NULL),
 226         iMediaFragGroupAlloc(NULL),
 227         iPduPktMemPool(NULL),
 228         iMediaDataAlloc(&iMemAlloc)
 229
 230
 231
 232 {
 233     iLogger = PVLogger::GetLoggerObject("3g324m.h223.H223OutgoingChannel");
 234     iOutgoingVideoLogger = PVLogger::GetLoggerObject("datapath.outgoing.video.h223.lcn");
 235     iOutgoingAudioLogger = PVLogger::GetLoggerObject("datapath.outgoing.audio.h223.lcn");
 236
 237     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::H223OutgoingChannel - num(%d),segmentable(%d)", num, segmentable));
 238     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::H223OutgoingChannel - AL SDU size(%d), hdr(%d), trlr(%d)", iAl->GetSduSize(), iAl->GetHdrSz(), iAl->GetTrlrSz()));
 239     ResetStats();
 240     lastMediaData = NULL;
 241
 242     iSetBufferMediaMs = 0;
 243     iSetBufferMediaBytes = 0;
 244     iBufferMediaMs = 0;
 245     iBufferMediaBytes = 0;
 246     iCurPduTimestamp = 0;
 247     iNumPendingPdus = 0;
 248     iTsmsec = 0;
 249     iOnlyOnce = false;
 250 #ifdef LIP_SYNC_TESTING
 251     iAudioOutTS = 0;
 252     iVideoOutTS = 0;
 253     iDiffVideoAudioTS = 0;
 254     iSqrCalVidAudTS = 0;
 255     iRtMnSqCalc = 0;
 256     iTotalCountOut = 0;
 257     iParams = ShareParams::Instance();
 258 #endif
 259     iMuxingStarted = false;
 260     iWaitForRandomAccessPoint = false;
 261     iBufferSizeMs = DEF_OUTGOING_CHANNEL_BUFFER_SIZE_MS;
 262
 263 }
 264
 265 H223OutgoingChannel::~H223OutgoingChannel()
 266 {
 267     if (iDataType)
 268     {
 269         Delete_DataType(iDataType);
 270         OSCL_DEFAULT_FREE(iDataType);
 271         iDataType = NULL;
 272     }
 273     Flush();
 274     iMediaFragGroupAlloc->removeRef();
 275     OSCL_DELETE(iPduPktMemPool);
 276     OSCL_DELETE(iMediaDataEntryAlloc);
 277     OSCL_DELETE(iMediaMsgMemoryPool);
 278
 279 }
 280
 281 void H223OutgoingChannel::Init()
 282 {
 283     H223LogicalChannel::Init();
 284     iMediaMsgMemoryPool = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (H223_OUTGOING_CHANNEL_NUM_MEDIA_MSG));
 285     iMediaMsgMemoryPool->enablenullpointerreturn();
 286     iMediaDataEntryAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (iNumMediaData, sizeof(LCMediaDataEntry)));
 287     iMediaDataEntryAlloc->enablenullpointerreturn();
 288     iPduPktMemPool = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (iNumMediaData));
 289     iPduPktMemPool->enablenullpointerreturn();
 290     iMediaFragGroupAlloc = OSCL_NEW(PVMFMediaFragGroupCombinedAlloc<OsclMemAllocator>, (iNumMediaData, 10, iPduPktMemPool));
 291     iMediaFragGroupAlloc->create();
 292 }
 293
 294
 295 void H223OutgoingChannel::BufferMedia(uint16 aMs)
 296 {
 297     if (iBufferSizeMs && aMs > iBufferSizeMs)
 298     {
 299         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::BufferMedia ERROR buffer interval=%d > buffer size=%d", aMs, iBufferSizeMs));
 300     }
 301     iSetBufferMediaMs = iBufferMediaMs = aMs;
 302     iSetBufferMediaBytes = iBufferMediaBytes = ((iBufferSizeMs * iBitrate + 4000) / 8000);
 303     //PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0,"H223OutgoingChannel::BufferMedia ms=%d,bytes=%d", iBufferMediaMs,iBufferMediaBytes));
 304 }
 305
 306 void H223OutgoingChannel::Resume()
 307 {
 308     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::Resume lcn=%d", lcn));
 309     H223LogicalChannel::Resume();
 310     iPaused = false;
 311     // start muxing on a random access point
 312     //iWaitForRandomAccessPoint=true;
 313 }
 314
 315 void H223OutgoingChannel::SetBufferSizeMs(uint32 buffer_size_ms)
 316 {
 317     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingLogicalChannel::SetBufferSizeMs buffer_size_ms=%d", buffer_size_ms));
 318     iBufferSizeMs = buffer_size_ms;
 319 }
 320
 321
 322
 323 PVMFStatus H223OutgoingChannel::PutData(PVMFSharedMediaMsgPtr media_msg)
 324 {
 325     PVMFStatus ret = PVMFSuccess;
 326     PVMFSharedMediaDataPtr mediaData;
 327     convertToPVMFMediaData(mediaData, media_msg);
 328
 329     PV_STAT_SET_TIME(iStartTime, iNumPacketsIn)
 330     PV_STAT_INCR(iNumPacketsIn, 1)
 331
 332     /* zero through 255 is reserved for media data */
 333     if (media_msg->getFormatID() >= PVMF_MEDIA_CMD_FORMAT_IDS_START)
 334     {
 335         return PVMFSuccess;
 336     }
 337
 338     PV_STAT_INCR(iNumBytesIn, (mediaData->getFilledSize()))
 339     TimeValue timenow;
 340     if (iMediaType.isCompressed() && iMediaType.isAudio())
 341     {
 342         PVMF_OUTGOING_AUDIO_LOGDATATRAFFIC((0, "Outgoing audio frames received. Stats: Entry time=%ud, lcn=%d, size=%d", timenow.to_msec(), lcn, mediaData->getFilledSize()));
 343     }
 344     else if (iMediaType.isCompressed() && iMediaType.isVideo())
 345     {
 346         PVMF_OUTGOING_VIDEO_LOGDATATRAFFIC((0, "Outgoing video frames received.Stats: Entry time=%ud, lcn=%d, size=%d", timenow.to_msec(), lcn, mediaData->getFilledSize()));
 347     }
 348
 349     if (iNumPacketsIn % 20 == 0)
 350     {
 351         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData lcn=%d, size=%d, ts=%d", lcn, mediaData->getFilledSize(), mediaData->getTimestamp()));
 352     }
 353
 354     // Check for FormatSpecificInfo.  Sending FSI with data is being obsoleted, but there is no harm in leaving this in for now.
 355     if (mediaData->getFormatSpecificInfo(iFsiFrag) && iFsiFrag.getMemFragPtr() && iFsiFrag.getMemFragSize())
 356     {
 357         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData Received Format Specific Info, len=%d", iFsiFrag.getMemFragSize()));
 358         iObserver->ReceivedFormatSpecificInfo(lcn, (uint8*)iFsiFrag.getMemFragPtr(), iFsiFrag.getMemFragSize());
 359     }
 360
 361     if (IsSegmentable() && iWaitForRandomAccessPoint)
 362     {
 363         if ((mediaData->getMarkerInfo()&PVMF_MEDIA_DATA_MARKER_INFO_RANDOM_ACCESS_POINT_BIT) == 0)
 364         {
 365             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData Not random access point.  Dropping media data."));
 366             return PVMFErrInvalidState;
 367         }
 368         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData Found random access point."));
 369         iWaitForRandomAccessPoint = false;
 370     }
 371     else if (iNumPendingPdus == (iNumMediaData - 1))
 372     {
 373         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData - ERROR Overflow, iNumPendingPdus=%u", iNumPendingPdus));
 374         return PVMFErrOverflow;
 375     }
 376
 377     uint32 num_frags_required = 0;
 378     uint32 frag_num = 0;
 379     for (frag_num = 0; frag_num < mediaData->getNumFragments(); frag_num++)
 380     {
 381         OsclRefCounterMemFrag memfrag;
 382         mediaData->getMediaFragment(frag_num, memfrag);
 383         if (memfrag.getMemFragSize() > iMaxSduSize)
 384         {
 385             num_frags_required++;
 386         }
 387     }
 388
 389     if ((mediaData->getNumFragments() + num_frags_required + iNumPendingPdus) >= (iNumMediaData - 1))
 390     {
 391         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData - ERROR Overflow, iNumPendingPdus=%u, num_frags_required=%d,iNumMediaData=%d", iNumPendingPdus, num_frags_required, iNumMediaData));
 392         Flush();
 393         /* Start re-buffering */
 394         BufferMedia((uint16)iSetBufferMediaMs);
 395         return PVMFErrOverflow;
 396     }
 397
 398     /* Fragment the sdu if needed */
 399     PVMFSharedMediaDataPtr& fragmentedMediaData = mediaData;
 400     if (num_frags_required)
 401     {
 402         if (true != FragmentPacket(mediaData, fragmentedMediaData))
 403         {
 404             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData - Memory allocation failure on Fragment\n"));
 405             return PVMFErrOverflow;
 406         }
 407     }
 408
 409     uint32 sdu_size = 0;
 410     if (iCurPdu.GetRep())
 411     {
 412         sdu_size = iCurPdu->getFilledSize() - iAl->GetHdrSz();
 413         /* Is the timestamp different ? */
 414         if (iCurPduTimestamp != fragmentedMediaData->getTimestamp() || !IsSegmentable())
 415         {
 416             if (PVMFSuccess != CompletePdu())
 417             {
 418                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData - Memory allocation failure on CompletePdu\n"));
 419                 return PVMFErrOverflow;
 420             }
 421             sdu_size = 0;
 422         }
 423     }
 424     if (sdu_size == 0)
 425     {
 426         //PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0,"H223OutgoingChannel::PutData Sdu size == 0"));
 427         iCurPdu = StartAlPdu();
 428         if (!iCurPdu)
 429         {
 430             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
 431                             (0, "H223OutgoingChannel::PutData - Memory allocation failure on StartAlPdu\n"));
 432             return PVMFErrOverflow;
 433         }
 434
 435         if (iFsiFrag.getMemFragSize())
 436         {
 437             iCurPdu->appendMediaFragment(iFsiFrag);
 438             // reset the FSI frag
 439             OsclRefCounterMemFrag frag;
 440             iFsiFrag = frag;
 441         }
 442     }
 443
 444     for (frag_num = 0; frag_num < fragmentedMediaData->getNumFragments(); frag_num++)
 445     {
 446         OsclRefCounterMemFrag frag;
 447         fragmentedMediaData->getMediaFragment(frag_num, frag);
 448         OSCL_ASSERT(frag.getMemFragSize() <= iMaxSduSize);
 449
 450         if (sdu_size &&
 451                 ((sdu_size + frag.getMemFragSize() > iMaxSduSize) || !IsSegmentable()))
 452         {
 453             if (PVMFSuccess != CompletePdu())
 454             {
 455                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PutData - Memory allocation failure on CompletePdu\n"));
 456                 return PVMFErrOverflow;
 457             }
 458             sdu_size = 0;
 459
 460             iCurPdu = StartAlPdu();
 461
 462             if (!iCurPdu)
 463             {
 464                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
 465                                 (0, "H223OutgoingChannel::PutData - Memory allocation failure on StartAlPdu\n"));
 466                 return PVMFErrOverflow;
 467             }
 468         }
 469
 470         iCurPdu->appendMediaFragment(frag);
 471         sdu_size += frag.getMemFragSize();
 472         iCurPduTimestamp = fragmentedMediaData->getTimestamp();
 473
 474     }
 475
 476     if (iMediaType.isCompressed() && iMediaType.isAudio())
 477     {
 478         PVMF_OUTGOING_AUDIO_LOGDATATRAFFIC((0, "Stats of the outgoing audio SDU are: timestamp=%d, size=%d", iCurPduTimestamp, sdu_size));
 479     }
 480     else if (iMediaType.isCompressed() && iMediaType.isVideo())
 481     {
 482         PVMF_OUTGOING_VIDEO_LOGDATATRAFFIC((0, "Stats of the outgoing video SDU are: timestamp=%d, size=%d", iCurPduTimestamp, sdu_size));
 483     }
 484     return ret;
 485 }
 486
 487 bool H223OutgoingChannel::FragmentPacket(PVMFSharedMediaDataPtr& aMediaData, PVMFSharedMediaDataPtr& aFragmentedMediaData)
 488 {
 489     OsclRefCounterMemFrag memfrag;
 490     OsclSharedPtr<PVMFMediaDataImpl> newpack;
 491     newpack = iMediaFragGroupAlloc->allocate();
 492     if (!newpack.GetRep())
 493     {
 494         return false;
 495     }
 496
 497     int32 pkt_size = 0;
 498     PVMFTimestamp timestamp = aMediaData->getTimestamp();
 499     for (uint32 frag_num = 0; frag_num < aMediaData->getNumFragments(); frag_num++)
 500     {
 501         aMediaData->getMediaFragment(frag_num, memfrag);
 502         pkt_size = memfrag.getMemFragSize();
 503         if ((unsigned)pkt_size <= iMaxSduSize)
 504         {
 505             newpack->appendMediaFragment(memfrag);
 506         }
 507         else  /* Need to fragment it */
 508         {
 509             uint8* pos = (uint8*)memfrag.getMemFragPtr();
 510             int32 trim_frag_sz = iMaxSduSize;
 511             while (pkt_size)
 512             {
 513                 trim_frag_sz = ((unsigned)pkt_size > iMaxSduSize) ? iMaxSduSize : pkt_size;
 514                 pkt_size -= trim_frag_sz;
 515                 OsclRefCounterMemFrag trim_frag(memfrag);
 516                 trim_frag.getMemFrag().ptr = pos;
 517                 trim_frag.getMemFrag().len = trim_frag_sz;
 518                 newpack->appendMediaFragment(trim_frag);
 519                 pos += trim_frag_sz;
 520             }
 521         }
 522     }
 523     aFragmentedMediaData = PVMFMediaData::createMediaData(newpack, iMediaMsgMemoryPool);
 524     if (aFragmentedMediaData.GetRep())
 525     {
 526         aFragmentedMediaData->setTimestamp(timestamp);
 527         return true;
 528     }
 529     return false;
 530 }
 531
 532 OsclSharedPtr<PVMFMediaDataImpl> H223OutgoingChannel::StartAlPdu()
 533 {
 534     PV_STAT_INCR(iNumSdusIn, 1)
 535
 536     // allocate packet
 537     OsclSharedPtr<PVMFMediaDataImpl> pdu = iMediaFragGroupAlloc->allocate();
 538     if (pdu)
 539     {
 540         // Add header
 541         PVMFStatus status = iAl->StartPacket(pdu);
 542         if (status != PVMFSuccess)
 543         {
 544             pdu.Unbind();
 545             return pdu;
 546         }
 547         iNumPendingPdus++;
 548     }
 549
 550     return pdu;
 551 }
 552
 553 PVMFStatus H223OutgoingChannel::CompletePdu()
 554 {
 555     PVMFStatus status = iAl->CompletePacket(iCurPdu);
 556     if (status != PVMFSuccess)
 557     {
 558         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::CompletePdu Memory allocation failedlcn=%d, CompletePacket status=%d", lcn, status));
 559         return status;
 560     }
 561
 562
 563 #ifdef LIP_SYNC_TESTING
 564     if (iParams->iUncompressed == true)
 565     {
 566         AppendLipSyncTS();
 567     }
 568 #endif
 569
 570
 571     // Add it to the outgoing queue
 572     status = AppendOutgoingPkt(iCurPdu, iCurPduTimestamp);
 573     if (status != PVMFSuccess)
 574     {
 575         return status;
 576     }
 577     iCurPdu.Unbind();
 578     iCurPduTimestamp = 0;
 579     return PVMFSuccess;
 580 }
 581
 582 PVMFStatus H223OutgoingChannel::AppendOutgoingPkt(OsclSharedPtr<PVMFMediaDataImpl>& pdu,
 583         PVMFTimestamp timestamp,
 584         OsclRefCounterMemFrag* fsi)
 585 {
 586     PVMFSharedMediaDataPtr mediaData = PVMFMediaData::createMediaData(pdu, iMediaMsgMemoryPool);
 587     if (mediaData.GetRep() == NULL)
 588     {
 589         return PVMFErrNoMemory;
 590     }
 591
 592     mediaData->setTimestamp(timestamp);
 593     if (fsi)
 594     {
 595         mediaData->setFormatSpecificInfo(*fsi);
 596     }
 597     void* memory_for_entry = iMediaDataEntryAlloc->allocate(sizeof(LCMediaDataEntry));
 598     if (!memory_for_entry)
 599     {
 600         // if couldn't allocate memory - leave
 601         return PVMFErrNoMemory;
 602     }
 603     LCMediaDataEntry* entry = OSCL_PLACEMENT_NEW(memory_for_entry, LCMediaDataEntry());
 604     entry->mediaData = mediaData;
 605
 606     LCMediaDataEntry* first = entry;
 607     PVMFTimestamp lastTS = timestamp;
 608     if (lastMediaData)
 609     {
 610         first = lastMediaData->next;
 611         lastMediaData->next = entry;
 612         lastTS = lastMediaData->mediaData->getTimestamp();
 613     }
 614     lastMediaData = entry;
 615     entry->next = first;
 616
 617     /* Adjust buffering parameters */
 618     if (iBufferMediaMs)
 619     {
 620         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::AppendOutgoingPkt lcn=%d, last ts=%d,cur ts=%d", lcn, lastTS, timestamp));
 621         /* Compute delta_t from last media data */
 622         int32 delta_t = timestamp - lastTS;
 623         if (delta_t < 0)
 624             delta_t += TIMESTAMP_MAX;
 625         iBufferMediaMs -= delta_t;
 626         iBufferMediaBytes -= mediaData->getFilledSize();
 627         if (iBufferMediaMs <= 0 || iBufferMediaBytes <= 0)
 628         {
 629             iBufferMediaMs = 0;
 630             iBufferMediaBytes = 0;
 631         }
 632     }
 633     return PVMFSuccess;
 634 }
 635
 636 bool H223OutgoingChannel::GetNextPacket(PVMFSharedMediaDataPtr& aMediaData, PVMFStatus aStatus)
 637 {
 638
 639     if (!iMuxingStarted && aStatus == PVMFSuccess)
 640         iMuxingStarted = true;
 641
 642     if (lastMediaData == NULL)
 643     {
 644         return false;
 645     }
 646     if ((aStatus == PVMFSuccess) && iPaused)
 647     {
 648         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::GetNextPacket Logical channel %d paused.", lcn));
 649         return false;
 650
 651     }
 652     if ((aStatus == PVMFSuccess) && iBufferMediaMs && iBufferMediaBytes)
 653     {
 654         /* Still buffering */
 655         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::GetNextPacket Buffering lcn=%d, ms left=%d", lcn, iBufferMediaMs));
 656         return false;
 657     }
 658
 659     LCMediaDataEntry* first = lastMediaData->next;
 660     aMediaData = first->mediaData;
 661
 662     if (first == lastMediaData)
 663     {
 664         lastMediaData = NULL;
 665     }
 666     else
 667     {
 668         lastMediaData->next = first->next;
 669
 670     }
 671
 672
 673     first->~LCMediaDataEntry();
 674     iMediaDataEntryAlloc->deallocate(first);
 675
 676
 677     OSCL_ASSERT(iNumPendingPdus);
 678     iNumPendingPdus--;
 679     return true;
 680 }
 681
 682 OsclAny H223OutgoingChannel::ReleasePacket(PVMFSharedMediaDataPtr& aMediaData)
 683 {
 684     OsclSharedPtr<PVMFMediaDataImpl> aMediaDataImpl;
 685     aMediaData->getMediaDataImpl(aMediaDataImpl);
 686     aMediaDataImpl->clearMediaFragments();
 687 }
 688
 689 OsclAny H223OutgoingChannel::Flush()
 690 {
 691     //PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0,"H223OutgoingChannel::Flush\n"));
 692
 693     PVMFSharedMediaDataPtr aMediaData;
 694
 695     // clear messages in input queue
 696     ClearMsgQueues();
 697     // go through pending queue
 698     while (GetNextPacket(aMediaData, PVMFErrCancelled))
 699     {
 700         PV_STAT_INCR(iNumBytesFlushed, aMediaData->getFilledSize())
 701         OsclSharedPtr<PVMFMediaDataImpl> aMediaDataImpl;
 702         aMediaData->getMediaDataImpl(aMediaDataImpl);
 703         aMediaDataImpl->clearMediaFragments();
 704     }
 705     if (iCurPdu.GetRep())
 706     {
 707         iCurPdu->clearMediaFragments();
 708         iCurPdu.Unbind();
 709     }
 710     iCurPduTimestamp = 0;
 711     iNumPendingPdus = 0;
 712 }
 713 OsclAny H223OutgoingChannel::ResetStats()
 714 {
 715     iNumPacketsIn = 0;
 716     iNumSdusIn = 0;
 717     iNumBytesIn = 0;
 718     iNumSdusDropped = 0;
 719     iNumSdusOut = 0;
 720     iNumBytesOut = 0;
 721     iMaxPacketMuxTime = 0;
 722     iMaxSduMuxTime = 0;
 723     iNumFlush = 0;
 724     iNumBytesFlushed = 0;
 725 }
 726
 727 OsclAny H223OutgoingChannel::LogStats()
 728 {
 729     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Outgoing Logical Channel %d Statistics:\n", lcn));
 730     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Adaptation layer header bytes -  %d\n", iAl->GetHdrSz()));
 731     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Adaptation layer trailer bytes -  %d\n", iAl->GetTrlrSz()));
 732     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num packets received - %d\n", iNumPacketsIn));
 733     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num sdus received - %d\n", iNumSdusIn));
 734     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num bytes received - %d\n", iNumBytesIn));
 735     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num sdus dropped - %d\n", iNumSdusDropped));
 736     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num sdus output - %d\n", iNumSdusOut));
 737     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num bytes output - %d\n", iNumBytesOut));
 738     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Max packet mux time - %d\n", iMaxPacketMuxTime));
 739     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Max sdu mux time - %d\n", iMaxSduMuxTime));
 740     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num flush - %d\n", iNumFlush));
 741     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num bytes flushed - %d\n", iNumBytesFlushed));
 742 }
 743
 744 OSCL_EXPORT_REF PVMFStatus H223OutgoingChannel::Connect(PVMFPortInterface* aPort)
 745 {
 746     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::Connect, aPort=%x", aPort));
 747
 748     if (iConnectedPort)
 749     {
 750         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::Connect Error: Already connected"));
 751         return PVMFFailure;
 752     }
 753
 754     PvmiCapabilityAndConfig* config = NULL;
 755
 756     OsclAny* tempInterface = NULL;
 757     aPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, tempInterface);
 758     config = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*, tempInterface);
 759     if (!config)
 760     {
 761         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::Connect: Error - Peer port does not support capability interface"));
 762         return PVMFFailure;
 763     }
 764
 765     PVMFStatus status = NegotiateInputSettings(config);
 766
 767     if (status != PVMFSuccess)
 768     {
 769         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::Connect: Error - Settings negotiation failed. status=%d", status));
 770         return status;
 771     }
 772
 773     //Automatically connect the peer.
 774     if ((status = aPort->PeerConnect(this)) != PVMFSuccess)
 775     {
 776         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::Connect: Error - Peer Connect failed. status=%d", status));
 777         return status;
 778     }
 779
 780     iConnectedPort = aPort;
 781
 782     PortActivity(PVMF_PORT_ACTIVITY_CONNECT);
 783     return PVMFSuccess;
 784 }
 785 OSCL_EXPORT_REF PVMFStatus H223OutgoingChannel::PeerConnect(PVMFPortInterface* aPort)
 786 {
 787
 788     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::PeerConnect aPort=0x%x", this, aPort));
 789     if (!aPort)
 790     {
 791         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "0x%x H223OutgoingChannel::PeerConnect: Error - Connecting to invalid port", this));
 792         return PVMFErrArgument;
 793     }
 794     if (iConnectedPort)
 795     {
 796         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "0x%x H223OutgoingChannel::PeerConnect: Error - Already connected", this));
 797         return PVMFFailure;
 798     }
 799
 800     OsclAny* config = NULL;
 801     aPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, config);
 802     if (!config)
 803     {
 804         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::PeerConnect: Error - Peer port does not support capability interface"));
 805         return PVMFFailure;
 806     }
 807
 808
 809     PVMFStatus status = PVMFSuccess;
 810
 811     status = NegotiateInputSettings((PvmiCapabilityAndConfig*)config);
 812
 813     if (status != PVMFSuccess)
 814     {
 815         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::PeerConnect: Error - Settings negotiation failed. status=%d", status));
 816         // Ignore errors for now
 817         status = PVMFSuccess;
 818     }
 819
 820
 821     iConnectedPort = aPort;
 822     PortActivity(PVMF_PORT_ACTIVITY_CONNECT);
 823
 824     return status;
 825 }
 826
 827 PVMFStatus H223OutgoingChannel::NegotiateFSISettings(PvmiCapabilityAndConfig* aConfig)
 828 {
 829     PvmiKvp* kvp = NULL;
 830     int numParams = 0;
 831     // Preconfigured FSI
 832     uint8* pc_fsi = NULL;
 833     unsigned pc_fsilen = ::GetFormatSpecificInfo(iDataType, pc_fsi);
 834     if (pc_fsilen && pc_fsi)
 835     {
 836         /*
 837          * Create PvmiKvp for capability settings
 838          */
 839         OsclMemAllocator alloc;
 840         PvmiKvp kvp;
 841         kvp.key = NULL;
 842         kvp.length = oscl_strlen(PVMF_FORMAT_SPECIFIC_INFO_KEY) + 1; // +1 for \0
 843         kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length);
 844         if (kvp.key == NULL)
 845         {
 846             return PVMFFailure;
 847         }
 848         oscl_strncpy(kvp.key, PVMF_FORMAT_SPECIFIC_INFO_KEY, kvp.length);
 849
 850         kvp.value.key_specific_value = (OsclAny*)pc_fsi;
 851         kvp.capacity = pc_fsilen;
 852         kvp.length = pc_fsilen;
 853
 854         PvmiKvp* retKvp = NULL; // for return value
 855         int32 err;
 856         OSCL_TRY(err, aConfig->setParametersSync(NULL, &kvp, 1, retKvp););
 857         alloc.deallocate((OsclAny*)(kvp.key));
 858         if (err)
 859         {
 860             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::NegotiateFSISettings, Failed to set FSI on peer, err=%d", err));
 861         }
 862         // Temp change to return success. Enc node does not support setting FSI yet.  This will cause port connect to fail.
 863         return PVMFSuccess;
 864     }
 865
 866
 867     // No preconfigured FSI.  In this case try to get the FSI from the peer.
 868     PVMFStatus status = aConfig->getParametersSync(NULL, (PvmiKeyType)PVMF_FORMAT_SPECIFIC_INFO_KEY, kvp, numParams, NULL);
 869     if (status != PVMFSuccess || numParams != 1)
 870     {
 871         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateFSISettings: Failed to get FSI from peer"));
 872         return PVMFSuccess;
 873     }
 874     else
 875     {
 876         ReceivedFSIFromPeer(kvp);
 877         aConfig->releaseParameters(NULL, kvp, numParams);
 878     }
 879
 880     kvp = NULL;
 881     numParams = 0;
 882     return PVMFSuccess;
 883
 884 }
 885
 886 PVMFStatus H223OutgoingChannel::ReceivedFSIFromPeer(PvmiKvp* kvp)
 887 {
 888     // Create mem frag for VOL header
 889     OsclRefCounter* my_refcnt;
 890     OsclMemAllocDestructDealloc<uint8> my_alloc;
 891     uint aligned_refcnt_size = oscl_mem_aligned_size(sizeof(OsclRefCounterSA< OsclMemAllocDestructDealloc<uint8> >));
 892     uint8* my_ptr = (uint8*) my_alloc.allocate(aligned_refcnt_size + kvp->length);
 893     my_refcnt = OSCL_PLACEMENT_NEW(my_ptr, OsclRefCounterSA< OsclMemAllocDestructDealloc<uint8> >(my_ptr));
 894     my_ptr += aligned_refcnt_size;
 895
 896     oscl_memcpy(my_ptr, kvp->value.key_specific_value, kvp->length);
 897
 898     OsclMemoryFragment memfrag;
 899     memfrag.len = kvp->length;
 900     memfrag.ptr = my_ptr;
 901
 902     OsclRefCounterMemFrag configinfo(memfrag, my_refcnt, kvp->length);
 903     iFsiFrag = configinfo;
 904
 905     SetFormatSpecificInfo((uint8*)kvp->value.key_specific_value, kvp->length);
 906
 907     iObserver->ReceivedFormatSpecificInfo(lcn, (uint8*)kvp->value.key_specific_value, kvp->length);
 908     return PVMFSuccess;
 909 }
 910
 911
 912 PVMFStatus H223OutgoingChannel::NegotiateInputSettings(PvmiCapabilityAndConfig* aConfig)
 913 {
 914     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::NegotiateInputSettings, aConfig=%x", aConfig));
 915
 916     PvmiKvp* kvp = NULL;
 917     int numParams = 0;
 918     int32 i = 0;
 919
 920     // Get supported output formats from peer
 921     PVMFStatus status = aConfig->getParametersSync(NULL,
 922                         OSCL_CONST_CAST(char*, OUTPUT_FORMATS_CAP_QUERY),
 923                         kvp, numParams, NULL);
 924     if (status != PVMFSuccess || numParams == 0)
 925     {
 926         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings, Error:  getParametersSync failed.  status=%d", status));
 927         return status;
 928     }
 929
 930     PvmiKvp* selectedKvp = NULL;
 931     PVCodecType_t codec_type = GetCodecType(iDataType);
 932     PVMFFormatType lcn_format_type = PVCodecTypeToPVMFFormatType(codec_type);
 933
 934     for (i = 0; i < numParams && !selectedKvp; i++)
 935     {
 936         if (lcn_format_type == kvp[i].value.pChar_value)
 937             selectedKvp = &(kvp[i]);
 938     }
 939
 940     if (!selectedKvp)
 941     {
 942         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings, Error:  Input format not supported by peer"));
 943         return PVMFFailure;
 944     }
 945     if (PVMFSuccess != setConfigParametersSync(selectedKvp, aConfig))
 946     {
 947         return PVMFFailure;
 948     }
 949
 950     aConfig->releaseParameters(NULL, kvp, numParams);
 951     kvp = NULL;
 952     numParams = 0;
 953
 954
 955     if (iMediaType.isVideo())
 956     {
 957         // frame width negotiations
 958         uint32 width = GetVideoFrameSize(iDataType, true);
 959         status = aConfig->getParametersSync(NULL, (PvmiKeyType)VIDEO_OUTPUT_WIDTH_CAP_QUERY, kvp, numParams, NULL);
 960         if (status != PVMFSuccess || numParams != 1)
 961         {
 962             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings: Error - config->getParametersSync(cap width) failed"));
 963             // do not report error for now as enc nodes dont implemlement some parameters
 964
 965         }
 966         else
 967         {
 968             if (kvp[0].value.uint32_value > width)
 969             {
 970                 OsclMemAllocator alloc;
 971                 PvmiKvp kvp;
 972                 kvp.key = NULL;
 973                 kvp.length = oscl_strlen(VIDEO_OUTPUT_WIDTH_CUR_QUERY) + 1; // +1 for \0
 974                 kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length);
 975                 if (kvp.key == NULL)
 976                 {
 977                     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings: Error - alloc failed for VIDEO_OUTPUT_WIDTH_CUR_QUERY kvp "));
 978                     return PVMFErrNoMemory;
 979                 }
 980                 oscl_strncpy(kvp.key, VIDEO_OUTPUT_WIDTH_CUR_QUERY, kvp.length);
 981                 kvp.value.uint32_value = width;
 982
 983                 if (PVMFSuccess != setConfigParametersSync(&kvp, aConfig))
 984                 {
 985                     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings, Error:  setConfigParametersSync width failed"));
 986                     //dont return PVMFFailure for now ;
 987                 }
 988
 989
 990                 alloc.deallocate((OsclAny*)(kvp.key));
 991
 992             }
 993             aConfig->releaseParameters(NULL, kvp, numParams);
 994         }
 995
 996         kvp = NULL;
 997         numParams = 0;
 998
 999
1000
1001         // frame height negotiations
1002         uint32 height = GetVideoFrameSize(iDataType, false);
1003         status = aConfig->getParametersSync(NULL, (PvmiKeyType)VIDEO_OUTPUT_HEIGHT_CAP_QUERY, kvp, numParams, NULL);
1004         if (status != PVMFSuccess || numParams != 1)
1005         {
1006             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings: Error - config->getParametersSync(cap height) failed"));
1007             // do not report error for now as enc nodes dont implemlement some parameters
1008
1009         }
1010         else
1011         {
1012             if (kvp[0].value.uint32_value > height)
1013             {
1014                 OsclMemAllocator alloc;
1015                 PvmiKvp kvp;
1016                 kvp.key = NULL;
1017                 kvp.length = oscl_strlen(VIDEO_OUTPUT_HEIGHT_CUR_QUERY) + 1; // +1 for \0
1018                 kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length);
1019                 if (kvp.key == NULL)
1020                 {
1021                     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings: Error - alloc failed for VIDEO_OUTPUT_HEIGHT_CUR_QUERY kvp "));
1022                     return PVMFErrNoMemory;
1023                 }
1024                 oscl_strncpy(kvp.key, VIDEO_OUTPUT_HEIGHT_CUR_QUERY, kvp.length);
1025                 kvp.value.uint32_value = height;
1026
1027                 if (PVMFSuccess != setConfigParametersSync(&kvp, aConfig))
1028                 {
1029                     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings, Error:  setConfigParametersSync height failed"));
1030                     //dont return PVMFFailure for now;
1031                 }
1032                 alloc.deallocate((OsclAny*)(kvp.key));
1033
1034             }
1035             aConfig->releaseParameters(NULL, kvp, numParams);
1036         }
1037
1038         kvp = NULL;
1039         numParams = 0;
1040
1041         // frame rate negotiations
1042         uint32 framerate = GetMaxFrameRate(iDataType);
1043         // VIDEO_OUTPUT_FRAME_RATE_CAP_QUERY not available
1044         status = aConfig->getParametersSync(NULL, (PvmiKeyType)VIDEO_OUTPUT_FRAME_RATE_CUR_QUERY, kvp, numParams, NULL);
1045         if (status != PVMFSuccess || numParams != 1)
1046         {
1047             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings: Error - config->getParametersSync(cap frame rate failed"));
1048             // do not report error for now as enc nodes dont implemlement some parameters
1049
1050         }
1051         else
1052         {
1053             if (kvp[0].value.float_value > framerate)
1054             {
1055                 OsclMemAllocator alloc;
1056                 PvmiKvp kvp;
1057                 kvp.key = NULL;
1058                 kvp.length = oscl_strlen(VIDEO_OUTPUT_FRAME_RATE_CUR_QUERY) + 1; // +1 for \0
1059                 kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length);
1060                 if (kvp.key == NULL)
1061                 {
1062                     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings: Error - alloc failed for VIDEO_OUTPUT_FRAME_RATE_CUR_QUERY kvp "));
1063                     return PVMFErrNoMemory;
1064                 }
1065                 oscl_strncpy(kvp.key, VIDEO_OUTPUT_FRAME_RATE_CUR_QUERY, kvp.length);
1066                 kvp.value.float_value = (float)framerate;
1067
1068                 if (PVMFSuccess != setConfigParametersSync(&kvp, aConfig))
1069                 {
1070                     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "H223OutgoingChannel::NegotiateInputSettings, Error:  setConfigParametersSync frame rate failed"));
1071                     //dont return PVMFFailure for now ;
1072                 }
1073                 alloc.deallocate((OsclAny*)(kvp.key));
1074
1075             }
1076             aConfig->releaseParameters(NULL, kvp, numParams);
1077         }
1078
1079         kvp = NULL;
1080         numParams = 0;
1081     }
1082
1083     return NegotiateFSISettings(aConfig);
1084 }
1085 ////////////////////////////////////////////////////////////////////////////
1086 //                  PvmiCapabilityAndConfig
1087 ////////////////////////////////////////////////////////////////////////////
1088 OSCL_EXPORT_REF void H223OutgoingChannel::setObserver(PvmiConfigAndCapabilityCmdObserver* aObserver)
1089 {
1090     // Not supported
1091     OSCL_UNUSED_ARG(aObserver);
1092     OSCL_LEAVE(OsclErrNotSupported);
1093 }
1094
1095 ////////////////////////////////////////////////////////////////////////////
1096 OSCL_EXPORT_REF PVMFStatus H223OutgoingChannel::getParametersSync(PvmiMIOSession session,
1097         PvmiKeyType identifier,
1098         PvmiKvp*& parameters,
1099         int& num_parameter_elements,
1100         PvmiCapabilityContext context)
1101 {
1102     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::getParametersSync"));
1103     OSCL_UNUSED_ARG(session);
1104     OSCL_UNUSED_ARG(context);
1105
1106     parameters = NULL;
1107     num_parameter_elements = 0;
1108
1109     if (pv_mime_strcmp(identifier, INPUT_FORMATS_CAP_QUERY) == 0)
1110     {
1111         num_parameter_elements = 1;
1112         PVMFStatus status = AllocateKvp(iKvpMemAlloc, parameters,
1113                                         OSCL_CONST_CAST(char*, INPUT_FORMATS_VALTYPE),
1114                                         num_parameter_elements);
1115         if (status != PVMFSuccess)
1116         {
1117             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223OutgoingChannel::getParametersSync: Error - AllocateKvp failed. status=%d", status));
1118             return status;
1119         }
1120         PVCodecType_t codec_type = GetCodecType(iDataType);
1121
1122         PVMFFormatType format = PVCodecTypeToPVMFFormatType(codec_type).getMIMEStrPtr();
1123         if (format == PVMF_MIME_AMR_IF2)
1124             parameters[0].value.pChar_value = (char*) PVMF_MIME_AMR_IF2;
1125         else if (format == PVMF_MIME_PCM16)
1126             parameters[0].value.pChar_value = (char*) PVMF_MIME_PCM16;
1127         else if (format ==  PVMF_MIME_YUV420)
1128             parameters[0].value.pChar_value = (char*) PVMF_MIME_YUV420;
1129         else if (format ==  PVMF_MIME_M4V)
1130             parameters[0].value.pChar_value = (char*) PVMF_MIME_M4V;
1131         else if (format ==  PVMF_MIME_H2632000)
1132             parameters[0].value.pChar_value = (char*) PVMF_MIME_H2632000;
1133         else if (format ==  PVMF_MIME_H2631998)
1134             parameters[0].value.pChar_value = (char*) PVMF_MIME_H2631998;
1135         else
1136             parameters[0].value.pChar_value = (char*) PVMF_MIME_FORMAT_UNKNOWN;
1137     }
1138
1139     return PVMFSuccess;
1140 }
1141
1142 ////////////////////////////////////////////////////////////////////////////
1143 OSCL_EXPORT_REF PVMFStatus H223OutgoingChannel::releaseParameters(PvmiMIOSession session,
1144         PvmiKvp* parameters,
1145         int num_elements)
1146 {
1147     OSCL_UNUSED_ARG(session);
1148     OSCL_UNUSED_ARG(num_elements);
1149
1150     if (parameters)
1151     {
1152         iKvpMemAlloc.deallocate((OsclAny*)parameters);
1153         return PVMFSuccess;
1154     }
1155     else
1156     {
1157         return PVMFFailure;
1158     }
1159 }
1160
1161 ////////////////////////////////////////////////////////////////////////////
1162 OSCL_EXPORT_REF void H223OutgoingChannel::createContext(PvmiMIOSession session, PvmiCapabilityContext& context)
1163 {
1164     OSCL_UNUSED_ARG(session);
1165     OSCL_UNUSED_ARG(context);
1166 }
1167
1168 ////////////////////////////////////////////////////////////////////////////
1169 OSCL_EXPORT_REF void H223OutgoingChannel::setContextParameters(PvmiMIOSession session,
1170         PvmiCapabilityContext& context,
1171         PvmiKvp* parameters, int num_parameter_elements)
1172 {
1173     OSCL_UNUSED_ARG(session);
1174     OSCL_UNUSED_ARG(context);
1175     OSCL_UNUSED_ARG(parameters);
1176     OSCL_UNUSED_ARG(num_parameter_elements);
1177 }
1178
1179 ////////////////////////////////////////////////////////////////////////////
1180 OSCL_EXPORT_REF void H223OutgoingChannel::DeleteContext(PvmiMIOSession session, PvmiCapabilityContext& context)
1181 {
1182     OSCL_UNUSED_ARG(session);
1183     OSCL_UNUSED_ARG(context);
1184 }
1185
1186 ////////////////////////////////////////////////////////////////////////////
1187 OSCL_EXPORT_REF void H223OutgoingChannel::setParametersSync(PvmiMIOSession session, PvmiKvp* parameters,
1188         int num_elements, PvmiKvp*& ret_kvp)
1189 {
1190     OSCL_UNUSED_ARG(session);
1191     PVMFStatus status = PVMFSuccess;
1192     ret_kvp = NULL;
1193
1194     for (int32 i = 0; i < num_elements; i++)
1195     {
1196         status = VerifyAndSetParameter(&(parameters[i]), true);
1197         if (status != PVMFSuccess)
1198         {
1199             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223OutgoingChannel::setParametersSync: Error - VerifiyAndSetParameter failed on parameter #%d", i));
1200             ret_kvp = &(parameters[i]);
1201             /* Silently ignore unrecognized codecs untill CapEx is supported by peer */
1202             //OSCL_LEAVE(OsclErrArgument);
1203         }
1204     }
1205 }
1206
1207 PVMFStatus H223OutgoingChannel::VerifyAndSetParameter(PvmiKvp* aKvp, bool aSetParam)
1208 {
1209     OSCL_UNUSED_ARG(aSetParam);
1210     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223OutgoingChannel::VerifyAndSetParameter: aKvp=0x%x, aSetParam=%d", aKvp, aSetParam));
1211
1212     if (!aKvp)
1213     {
1214         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223OutgoingChannel::VerifyAndSetParameter: Error - Invalid key-value pair"));
1215         return PVMFFailure;
1216     }
1217
1218     if (iDataType == NULL)
1219     {
1220         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223OutgoingChannel::VerifyAndSetParameter: Error - DataType == NULL"));
1221         return PVMFErrNotSupported;
1222     }
1223
1224     if (pv_mime_strcmp(aKvp->key, INPUT_FORMATS_VALTYPE) == 0)
1225     {
1226         PVCodecType_t codec_type = GetCodecType(iDataType);
1227         PVMFFormatType lcn_format_type = PVCodecTypeToPVMFFormatType(codec_type);
1228         if (pv_mime_strcmp(lcn_format_type.getMIMEStrPtr(), aKvp->value.pChar_value) != 0)
1229         {
1230             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223OutgoingChannel::VerifyAndSetParameter: Error - Input format %s not supported", aKvp->value.pChar_value));
1231             return PVMFErrNotSupported;
1232         }
1233     }
1234     else if (pv_mime_strcmp(aKvp->key, PVMF_FORMAT_SPECIFIC_INFO_KEY) == 0)
1235     {
1236         ReceivedFSIFromPeer(aKvp);
1237     }
1238
1239     return PVMFSuccess;
1240 }
1241
1242 ////////////////////////////////////////////////////////////////////////////
1243 OSCL_EXPORT_REF PVMFCommandId H223OutgoingChannel::setParametersAsync(PvmiMIOSession session,
1244         PvmiKvp* parameters,
1245         int num_elements,
1246         PvmiKvp*& ret_kvp,
1247         OsclAny* context)
1248 {
1249     OSCL_UNUSED_ARG(session);
1250     OSCL_UNUSED_ARG(parameters);
1251     OSCL_UNUSED_ARG(num_elements);
1252     OSCL_UNUSED_ARG(ret_kvp);
1253     OSCL_UNUSED_ARG(context);
1254     return -1;
1255 }
1256
1257 ////////////////////////////////////////////////////////////////////////////
1258 OSCL_EXPORT_REF uint32 H223OutgoingChannel::getCapabilityMetric(PvmiMIOSession session)
1259 {
1260     OSCL_UNUSED_ARG(session);
1261     return 1;
1262 }
1263
1264 ////////////////////////////////////////////////////////////////////////////
1265 OSCL_EXPORT_REF PVMFStatus H223OutgoingChannel::verifyParametersSync(PvmiMIOSession session,
1266         PvmiKvp* parameters, int num_elements)
1267 {
1268     OSCL_UNUSED_ARG(session);
1269
1270     PVMFStatus status = PVMFSuccess;
1271     for (int32 i = 0; (i < num_elements) && (status == PVMFSuccess); i++)
1272         status = VerifyAndSetParameter(&(parameters[i]), true);
1273
1274     return status;
1275 }
1276
1277 void H223OutgoingChannel::HandlePortActivity(const PVMFPortActivity &aActivity)
1278 {
1279     if (aActivity.iType != PVMF_PORT_ACTIVITY_INCOMING_MSG &&
1280             aActivity.iType != PVMF_PORT_ACTIVITY_CONNECTED_PORT_READY)
1281     {
1282         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::HandlePortActivity Unhandled port activity: %d", aActivity.iType));
1283         return;
1284     }
1285     PVMFStatus aStatus;
1286     PVMFSharedMediaMsgPtr aMsg;
1287     while (IncomingMsgQueueSize())
1288     {
1289         aStatus = DequeueIncomingMsg(aMsg);
1290         if (aStatus == PVMFSuccess)
1291         {
1292
1293             DetectSkewInd(aMsg);
1294
1295             PutData(aMsg);
1296         }
1297         else
1298         {
1299             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223OutgoingChannel::HandlePortActivity Failed to DeQueue incoming message: %d", aStatus));
1300             break;
1301         }
1302     }
1303 }
1304
1305 OSCL_EXPORT_REF PVMFStatus H223OutgoingControlChannel::PeerConnect(PVMFPortInterface* aPort)
1306 {
1307     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingControlChannel::PeerConnect aPort=0x%x", this, aPort));
1308     if (!aPort)
1309     {
1310         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "0x%x H223OutgoingControlChannel::PeerConnect: Error - Connecting to invalid port", this));
1311         return PVMFErrArgument;
1312     }
1313     if (iConnectedPort)
1314     {
1315         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "0x%x H223OutgoingControlChannel::PeerConnect: Error - Already connected", this));
1316         return PVMFFailure;
1317     }
1318
1319     iConnectedPort = aPort;
1320     PortActivity(PVMF_PORT_ACTIVITY_CONNECT);
1321
1322     return PVMFSuccess;
1323
1324 }
1325 PVMFStatus H223OutgoingControlChannel::PutData(PVMFSharedMediaMsgPtr aMsg)
1326 {
1327     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingControlChannel::PutData - iNumPendingPdus=%u,iNumMediaData=%u\n", iNumPendingPdus, iNumMediaData));
1328
1329     PVMFSharedMediaDataPtr mediaData;
1330     convertToPVMFMediaData(mediaData, aMsg);
1331
1332     PV_STAT_SET_TIME(iStartTime, iNumPacketsIn)
1333     PV_STAT_INCR(iNumPacketsIn, 1)
1334     PV_STAT_INCR(iNumSdusIn, 1)
1335     PV_STAT_INCR(iNumBytesIn, (mediaData->getFilledSize()))
1336
1337     OsclSharedPtr<PVMFMediaDataImpl> pdu;
1338     pdu = StartAlPdu();
1339
1340     if (!pdu)
1341     {
1342         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingControlChannel::PutData - Memory allocation failure on iMediaFragGroupAlloc->allocate\n"));
1343         return PVMFErrNoMemory;
1344     }
1345
1346     TimeValue timenow;
1347     OsclRefCounterMemFrag frag;
1348     for (uint frag_num = 0; frag_num < mediaData->getNumFragments(); frag_num++)
1349     {
1350         mediaData->getMediaFragment(frag_num, frag);
1351         // Add data fragments
1352         pdu->appendMediaFragment(frag);
1353     }
1354
1355     PVMFStatus status = iAl->CompletePacket(pdu);
1356     if (status != PVMFSuccess)
1357     {
1358         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingControlChannel::PutData - Memory allocation failure on iAl->CompletePacket()"));
1359         return status;
1360     }
1361
1362     OsclRefCounterMemFrag fsi;
1363     bool fsi_available = mediaData->getFormatSpecificInfo(fsi);
1364     // Add it to the outgoing queue
1365     if (PVMFSuccess != AppendOutgoingPkt(pdu, timenow.to_msec(), (fsi_available ? &fsi : NULL)))
1366     {
1367         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingControlChannel::PutData - Memory allocation failure on AppendOutgoingPkt()"));
1368         return PVMFErrNoMemory;
1369     }
1370     return PVMFSuccess;
1371 }
1372
1373 void H223LogicalChannel::SetDatapathLatency(uint32 aLatency)
1374 {
1375     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223LogicalChannel::SetDatapathLatency lcn=%d, aLatency=%d", lcn, aLatency));
1376     iDatapathLatency = aLatency;
1377 }
1378
1379 PVMFStatus H223LogicalChannel::setConfigParametersSync(PvmiKvp* selectedKvp,
1380         PvmiCapabilityAndConfig* aConfig,
1381         PVMFFormatType lcn_format_type,
1382         bool aTryTwice)
1383 {
1384     int32 err = 0;
1385     PvmiKvp* retKvp = NULL;
1386     if (!aTryTwice)
1387     {
1388         OSCL_TRY(err, aConfig->setParametersSync(NULL, selectedKvp, 1, retKvp););
1389         OSCL_FIRST_CATCH_ANY(err,
1390                              PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223OutgoingChannel::setConfigParametersSync, Error:  setParametersSync failed, err=%d", err));
1391                              return PVMFFailure;
1392                             );
1393     }
1394     else
1395     {
1396         int32 err = 0;
1397         OSCL_TRY(err, aConfig->setParametersSync(NULL, selectedKvp, 1, retKvp););
1398         if (err)
1399         {
1400             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::setConfigParametersSync, Error:  setParametersSync failed for pChar value, trying uint32, err=%d", err));
1401             selectedKvp->value.pChar_value = OSCL_STATIC_CAST(mbchar*, lcn_format_type.getMIMEStrPtr());
1402             err = 0;
1403             OSCL_TRY(err, aConfig->setParametersSync(NULL, selectedKvp, 1, retKvp););
1404             if (err)
1405             {
1406                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::setConfigParametersSync, Error:  setParametersSync failed, err=%d", err));
1407                 return PVMFFailure;
1408             }
1409         }
1410     }
1411     return PVMFSuccess;
1412 }
1413 H223IncomingChannel::H223IncomingChannel(TPVChannelId num,
1414         bool segmentable,
1415         OsclSharedPtr<AdaptationLayer>& al,
1416         PS_DataType data_type,
1417         LogicalChannelObserver* observer,
1418         uint32 bitrate,
1419         uint32 sample_interval,
1420         uint32 num_media_data)
1421         : H223LogicalChannel(num, segmentable, al, data_type, observer, bitrate, sample_interval, num_media_data),
1422         iMediaMsgMemoryPool(NULL),
1423         iMediaFragGroupAlloc(NULL),
1424         iPduPktMemPool(NULL),
1425         iMediaDataAlloc(&iMemAlloc),
1426         iPduSize(al->GetPduSize()),
1427         iCurPduSize(0),
1428         iRenderingSkew(0)
1429
1430 {
1431 #ifdef LIP_SYNC_TESTING
1432     iParam = ShareParams::Instance();
1433 #endif
1434     iLogger = PVLogger::GetLoggerObject("3g324m.h223.H223IncomingChannel");
1435     iIncomingAudioLogger = PVLogger::GetLoggerObject("datapath.incoming.audio.h223.lcn");
1436     iIncomingVideoLogger = PVLogger::GetLoggerObject("datapath.incoming.video.h223.lcn");
1437     iAlPduFragPos = NULL;
1438
1439     ResetStats();
1440
1441 }
1442
1443 H223IncomingChannel::~H223IncomingChannel()
1444 {
1445     Flush();
1446     OsclRefCounterMemFrag frag;
1447     iAlPduFrag = frag;
1448     if (iMediaFragGroupAlloc)
1449     {
1450         iMediaFragGroupAlloc->removeRef();
1451     }
1452     if (iPduPktMemPool)
1453     {
1454         OSCL_DELETE(iPduPktMemPool);
1455     }
1456     if (iMediaMsgMemoryPool)
1457     {
1458         OSCL_DELETE(iMediaMsgMemoryPool);
1459     }
1460 }
1461
1462 void H223IncomingChannel::Init()
1463 {
1464     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Init"));
1465     H223LogicalChannel::Init();
1466
1467     int bitrate = (GetBitrate() > 0) ? GetBitrate() : DEF_CHANNEL_BITRATE;
1468     int mem_size = (DEF_INCOMING_CHANNEL_BUFFER_SIZE_MS * bitrate) >> PV2WAY_BPS_TO_BYTES_PER_MSEC_RIGHT_SHIFT;
1469     int num_fragments = (mem_size / H223_INCOMING_CHANNEL_FRAGMENT_SIZE) + 1;
1470     iMediaMsgMemoryPool = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (H223_INCOMING_CHANNEL_NUM_MEDIA_MSG));
1471     if (iMediaMsgMemoryPool == NULL)
1472     {
1473         OSCL_LEAVE(PVMFErrNoMemory);
1474     }
1475     iMediaMsgMemoryPool->enablenullpointerreturn();
1476
1477     iPduPktMemPool = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (H223_INCOMING_CHANNEL_NUM_MEDIA_DATA));
1478     if (iPduPktMemPool == NULL)
1479     {
1480         OSCL_LEAVE(PVMFErrNoMemory);
1481     }
1482     iPduPktMemPool->enablenullpointerreturn();
1483
1484     iMediaFragGroupAlloc = OSCL_NEW(PVMFMediaFragGroupCombinedAlloc<OsclMemAllocator>, (H223_INCOMING_CHANNEL_NUM_MEDIA_DATA, H223_INCOMING_CHANNEL_NUM_FRAGS_IN_MEDIA_DATA, iPduPktMemPool));
1485     if (iMediaFragGroupAlloc == NULL)
1486     {
1487         OSCL_LEAVE(PVMFErrNoMemory);
1488     }
1489     iMediaFragGroupAlloc->create();
1490
1491     iMemFragmentAlloc.SetLeaveOnAllocFailure(false);
1492     iMemFragmentAlloc.size((uint16)num_fragments, (uint16)H223_INCOMING_CHANNEL_FRAGMENT_SIZE);
1493
1494     ResetAlPdu();
1495     AllocateAlPdu();
1496     iCurTimestamp = 0;
1497     iNumSdusIn = 0;
1498     iNumPdusIn = 0;
1499 }
1500
1501 OsclAny H223IncomingChannel::ResetAlPdu()
1502 {
1503     iAlPduFragPos = NULL;
1504     iCurPduSize = 0;
1505     OsclRefCounterMemFrag frag;
1506     iAlPduFrag = frag;
1507     iAlPduMediaData.Unbind();
1508 }
1509
1510 OsclAny H223IncomingChannel::AllocateAlPdu()
1511 {
1512     iAlPduMediaData = iMediaFragGroupAlloc->allocate();
1513     if (iAlPduMediaData.GetRep() == NULL)
1514     {
1515         return;
1516     }
1517     AppendAlPduFrag();
1518 }
1519
1520 OsclAny H223IncomingChannel::AppendAlPduFrag()
1521 {
1522     OsclRefCounterMemFrag ref_counter_mem_frag = iMemFragmentAlloc.get();
1523     if (ref_counter_mem_frag.getMemFragPtr() == NULL)
1524     {
1525         return;
1526     }
1527     ref_counter_mem_frag.getMemFrag().len = 0;
1528     iAlPduFrag = ref_counter_mem_frag;
1529     iAlPduFragPos = (uint8*)iAlPduFrag.getMemFragPtr();
1530 }
1531
1532 uint32 H223IncomingChannel::CopyAlPduData(uint8* buf, uint16 len)
1533 {
1534     int32 remaining = len;
1535     uint32 copied = 0;
1536     do
1537     {
1538         copied = CopyToCurrentFrag(buf, (uint16)remaining);
1539         buf += copied;
1540         remaining -= copied;
1541     }
1542     while (remaining && copied);
1543     return (uint32)(len - remaining);
1544 }
1545
1546 uint32 H223IncomingChannel::CopyToCurrentFrag(uint8* buf, uint16 len)
1547 {
1548     if (iAlPduMediaData.GetRep() == NULL)
1549     {
1550         AllocateAlPdu();
1551     }
1552     else if (iAlPduFragPos == NULL)
1553     {
1554         AppendAlPduFrag();
1555     }
1556     if (iAlPduFragPos == NULL)
1557     {
1558         return 0;
1559     }
1560
1561     uint32 space_in_current_frag = ((uint8*)iAlPduFrag.getMemFragPtr() + iAlPduFrag.getCapacity() - iAlPduFragPos);
1562     OSCL_ASSERT(space_in_current_frag > 0);
1563     uint32 num_bytes_copied = (len > space_in_current_frag) ? space_in_current_frag : len;
1564     oscl_memcpy(iAlPduFragPos, buf, num_bytes_copied);
1565     iAlPduFrag.getMemFrag().len += num_bytes_copied;
1566     iAlPduFragPos += num_bytes_copied;
1567     space_in_current_frag -= num_bytes_copied;
1568     if (space_in_current_frag == 0)
1569     {
1570         iAlPduMediaData->appendMediaFragment(iAlPduFrag);
1571         iAlPduFragPos = NULL;
1572     }
1573     PVLOGGER_LOG_USE_ONLY(
1574         if (iAlPduMediaData->getFilledSize() > iPduSize)
1575 {
1576     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::CopyToCurrentFrag WARNING current pdu size=%d > iPduSize=%d", iAlPduMediaData->getFilledSize(), iPduSize));
1577     }
1578     );
1579     return num_bytes_copied;
1580 }
1581
1582 void H223IncomingChannel::PreAlPduData()
1583
1584 {
1585     if (iSendFormatSpecificInfo)
1586     {
1587         SendFormatSpecificInfo();
1588     }
1589
1590     if (iPaused)
1591     {
1592         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::PreAlPduData Logical channel paused.  Dropping media data."));
1593         return;
1594     }
1595 }
1596
1597 PVMFStatus H223IncomingChannel::AlPduData(uint8* buf, uint16 len)
1598 {
1599     PV_STAT_INCR(iNumBytesIn, len)
1600     PV_STAT_SET_TIME(iStartTime, iNumBytesIn)
1601
1602     PreAlPduData();
1603     if (PVMFSuccess != DispatchPendingSdus())
1604     {
1605         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::AlPduData lcn=%d, Failed to dispatch pending sdus", lcn));
1606     }
1607     if (iAlPduMediaData.GetRep() == NULL || iAlPduMediaData->getFilledSize() == 0)
1608     {
1609         bool overflow = false;
1610         if (lcn != 0 && iClock)
1611         {
1612             // not the control channel
1613             iClock->GetCurrentTime32(iCurTimestamp, overflow, PVMF_MEDIA_CLOCK_MSEC);
1614         }
1615     }
1616     uint32 copied = CopyAlPduData(buf, len);
1617     return (copied == len) ? PVMFSuccess : PVMFFailure;
1618 }
1619
1620 PVMFStatus H223IncomingChannel::AlDispatch()
1621 {
1622
1623     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::AlDispatch lcn=%d, iCurPduSize=%d, sn=%d", lcn, iCurPduSize, iNumSdusIn));
1624     IncomingALPduInfo info;
1625
1626     if (iPaused)
1627     {
1628         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::AlDispatch Logical channel paused."));
1629         return PVMFFailure;
1630     }
1631
1632     /*  Nothing to dispatch */
1633     if (!iAlPduMediaData.GetRep())
1634     {
1635         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::AlDispatch Nothing to dispatch."));
1636         ResetAlPdu();
1637         return PVMFSuccess;
1638     }
1639
1640     /*  Add pending fragment to the media message */
1641     if (iAlPduFragPos)
1642     {
1643         iAlPduMediaData->appendMediaFragment(iAlPduFrag);
1644     }
1645
1646     PVMFFormatType mediaType = GetFormatType();
1647 #ifdef LIP_SYNC_TESTING
1648     if ((mediaType.isVideo() && iParam->iUncompressed == true))
1649     {
1650         ExtractTimestamp();
1651     }
1652 #endif
1653
1654     /* Parse AL headers etc */
1655     iAl->ParsePacket(iAlPduMediaData, info);
1656     int32 len = info.sdu_size;
1657     if (len <= 0)
1658     {
1659         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::AlDispatch Empty SDU lcn=%d, len=%d", lcn, len));
1660         ResetAlPdu();
1661         return PVMFErrCorrupt;
1662     }
1663
1664     PV_STAT_INCR_COND(iNumCrcErrors, 1, info.crc_error)
1665     PV_STAT_INCR_COND(iNumSeqNumErrors, 1, info.seq_num_error)
1666     PVMFStatus status = PVMFSuccess;
1667
1668     // set the errors flag
1669     uint32 errorsFlag = 0;
1670     if (info.crc_error)
1671     {
1672         errorsFlag |= PVMF_MEDIA_DATA_BIT_ERRORS;
1673         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::AlDispatch CRC error lcn=%d, size=%d", lcn, len));
1674         status =  PVMFErrCorrupt;
1675     }
1676     else
1677     {
1678         PV_STAT_INCR(iNumSdusIn, 1)
1679     }
1680     if (info.seq_num_error)
1681     {
1682         errorsFlag |= PVMF_MEDIA_DATA_PACKET_LOSS;
1683         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::AlDispatch Sequence number error lcn=%d, size=%d", lcn, len));
1684         status = PVMFErrCorrupt;
1685     }
1686
1687     OsclSharedPtr<PVMFMediaData> aMediaData = PVMFMediaData::createMediaData(iAlPduMediaData, iMediaMsgMemoryPool);
1688     if (aMediaData.GetRep() == NULL)
1689     {
1690         return PVMFErrNoMemory;
1691     }
1692
1693
1694     PVMFTimestamp baseTimestamp = 0;
1695     SetSampleTimestamps(baseTimestamp);
1696     aMediaData->setTimestamp(baseTimestamp);
1697     aMediaData->setSeqNum(info.seq_num);
1698     iAlPduMediaData->setErrorsFlag(errorsFlag);
1699
1700     PVMFSharedMediaMsgPtr aMediaMsg;
1701     convertToPVMFMediaMsg(aMediaMsg, aMediaData);
1702
1703     if (mediaType.isCompressed() && mediaType.isAudio())
1704     {
1705         // we are using only full audio frames
1706         aMediaData->setMarkerInfo(PVMF_MEDIA_DATA_MARKER_INFO_M_BIT);
1707     }
1708 #ifdef LIP_SYNC_TESTING
1709
1710     if (mediaType.isAudio() || mediaType.isVideo())
1711     {
1712         OsclRefCounterMemFrag memFrag;
1713         aMediaData->getMediaFragment(0, memFrag);
1714         uint8* buf = (uint8*)memFrag.getMemFragPtr();
1715         // we are using only full audio frames
1716         DetectFrameBoundary(buf, baseTimestamp);
1717
1718     }
1719 #endif
1720
1721
1722     if (IsConnected())
1723     {
1724         if (mediaType.isCompressed() && mediaType.isAudio())
1725         {
1726             PVMF_INCOMING_AUDIO_LOGDATATRAFFIC((0, "Incoming audio SDU received. Stats: Entry time=%d, lcn=%d, size=%d,FmtType=%s", iCurTimestamp, lcn, aMediaData->getFilledSize(), mediaType.getMIMEStrPtr()));
1727         }
1728         else if (mediaType.isCompressed() && mediaType.isVideo())
1729         {
1730             PVMF_INCOMING_VIDEO_LOGDATATRAFFIC((0, "Incoming video SDU received.Stats: Entry time=%d, lcn=%d, size=%d,FmtType=%s", iCurTimestamp, lcn, aMediaData->getFilledSize(), mediaType.getMIMEStrPtr()));
1731         }
1732         PVMFStatus dispatch_status = QueueOutgoingMsg(aMediaMsg);
1733         if (dispatch_status != PVMFSuccess)
1734         {
1735             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::AlDispatch Failed to queue outgoing media message lcn=%d, size=%d, status=%d", lcn, len, dispatch_status));
1736             status = dispatch_status;
1737         }
1738     }
1739     else if (IsSegmentable())
1740     {
1741         iPendingSdus.push_back(aMediaMsg);
1742     }
1743     else
1744     {
1745         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::AlDispatchL Dropping pdu lcn=%d, iCurPduSize=%d", lcn, iCurPduSize));
1746         status = PVMFErrNotReady;
1747     }
1748     ResetAlPdu();
1749     AllocateAlPdu();
1750     return status;
1751 }
1752
1753 OsclAny H223IncomingChannel::Flush()
1754 {
1755     PV_STAT_INCR(iNumBytesFlushed, (iAlPduFragPos - (uint8*)iAlPduFrag.getMemFragPtr()))
1756     PV_STAT_INCR_COND(iNumAbort, 1, (iAlPduFragPos - (uint8*)iAlPduFrag.getMemFragPtr()))
1757     iPendingSdus.clear();
1758     ResetAlPdu();
1759
1760 }
1761
1762 PVMFStatus H223IncomingChannel::Connect(PVMFPortInterface* aPort)
1763 {
1764     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Connect lcn(%d)\n", lcn));
1765     if (iConnectedPort)
1766     {
1767         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Connect Error: Already connected"));
1768         return PVMFFailure;
1769     }
1770
1771
1772     PvmiCapabilityAndConfig* config = NULL;
1773     OsclAny * tempInterface = NULL;
1774     aPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, tempInterface);
1775     config = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*, tempInterface);
1776     if (!config)
1777     {
1778         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Connect: Error - Peer port does not support capability interface"));
1779         return PVMFFailure;
1780     }
1781
1782     PVMFStatus status = NegotiateOutputSettings(config);
1783
1784     if (status != PVMFSuccess)
1785     {
1786         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Connect: Error - Settings negotiation failed. status=%d", status));
1787         return status;
1788     }
1789
1790     //Automatically connect the peer.
1791     if ((status = aPort->PeerConnect(this)) != PVMFSuccess)
1792     {
1793         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Connect: Error - Peer Connect failed. status=%d", status));
1794         return status;
1795     }
1796
1797     iConnectedPort = aPort;
1798
1799     //Check the BOS command status
1800     status = SendBeginOfStreamMediaCommand();
1801
1802     if (status != PVMFSuccess)
1803     {
1804         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Connect: Failed to send BOS message status=%d", status));
1805         return status;
1806     }
1807
1808     /* Send any format specific info if available */
1809     if (iSendFormatSpecificInfo)
1810         SendFormatSpecificInfo();
1811
1812     DispatchPendingSdus();
1813
1814     PortActivity(PVMF_PORT_ACTIVITY_CONNECT);
1815
1816     return PVMFSuccess;
1817 }
1818
1819 OsclAny H223IncomingChannel::ResetStats()
1820 {
1821     iNumSdusIn = 0;
1822     iNumBytesIn = 0;
1823     iSduSizeExceededCnt = 0;
1824     iNumCrcErrors = 0;
1825     iNumSeqNumErrors = 0;
1826     iNumBytesFlushed = 0;
1827     iNumAbort = 0;
1828 }
1829
1830 OsclAny H223IncomingChannel::LogStats()
1831 {
1832     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Incoming Logical Channel %d Statistics:\n", lcn));
1833     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num sdus received - %d\n", iNumSdusIn));
1834     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num bytes received - %d\n", iNumBytesIn));
1835     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num times sdu size exceeded - %d\n", iSduSizeExceededCnt));
1836     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num sdus with CRC errors - %d\n", iNumCrcErrors));
1837     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num sdus with sequence number errors - %d\n", iNumSeqNumErrors));
1838     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num sdus aborted - %d\n", iNumAbort));
1839     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Num bytes aborted - %d\n", iNumBytesFlushed));
1840 }
1841
1842 PVMFStatus H223IncomingChannel::DispatchPendingSdus()
1843 {
1844     if (!iConnectedPort)
1845     {
1846         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::DispatchPendingSdus: Not connected"));
1847         return PVMFFailure;
1848     }
1849     if (iPendingSdus.size())
1850     {
1851         /* Dispatch any pending sdus */
1852         for (unsigned i = 0; i < iPendingSdus.size(); i++)
1853         {
1854             PVMFStatus status = QueueOutgoingMsg(iPendingSdus[i]);
1855             if (status != PVMFSuccess)
1856             {
1857                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Connect Error: PutData failed for buffered sdus lcn=%d, status=%d, i=%d", lcn, status, i));
1858                 iObserver->LogicalChannelError(INCOMING, lcn, status);
1859                 return PVMFFailure;
1860             }
1861         }
1862         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::Connect lcn=%d,num sdus=%d", lcn, iPendingSdus.size()));
1863         iPendingSdus.clear();
1864     }
1865     return PVMFSuccess;
1866 }
1867
1868 OsclAny H223IncomingChannel::SendFormatSpecificInfo()
1869 {
1870     //PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0,"H223IncomingChannel::SendFormatSpecificInfo lcn=%d, iFormatSpecificInfoLen=%d, iFormatSpecificInfo=%x", lcn,iFormatSpecificInfoLen,iFormatSpecificInfo));
1871     //printBuffer(iLogger, iFormatSpecificInfo, (uint16)iFormatSpecificInfoLen);
1872     if (!IsConnected())
1873     {
1874         //PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0,"H223IncomingChannel::SendFormatSpecificInfo ERROR Not connected."));
1875         //OSCL_LEAVE(PVMFErrNotReady);
1876         return;
1877     }
1878
1879     // Create mem frag for VOL header
1880     // Create new media data buffer for header fragment
1881     OsclSharedPtr<PVMFMediaDataImpl> hdrImpl = iMediaDataAlloc.allocate(iFormatSpecificInfoLen);
1882     if (!hdrImpl)
1883     {
1884         return;
1885     }
1886     PVMFSharedMediaDataPtr hdrMediaData = PVMFMediaData::createMediaData(hdrImpl);
1887     OsclRefCounterMemFrag myVolHeader;
1888     hdrMediaData->getMediaFragment(0, myVolHeader);
1889     oscl_memcpy(myVolHeader.getMemFragPtr(), iFormatSpecificInfo, iFormatSpecificInfoLen);
1890     myVolHeader.getMemFrag().len = iFormatSpecificInfoLen;
1891
1892     // Create new media data buffer for the message
1893     OsclSharedPtr<PVMFMediaDataImpl> emptyImpl = iMediaDataAlloc.allocate(0);
1894     if (!emptyImpl)
1895     {
1896         return;
1897     }
1898     PVMFSharedMediaDataPtr volData = PVMFMediaData::createMediaData(emptyImpl);
1899
1900     // Set format specific info in media data message
1901     volData->setFormatSpecificInfo(myVolHeader);
1902
1903     // Send VOL header to downstream node
1904     PVMFSharedMediaMsgPtr volMsg;
1905     convertToPVMFMediaMsg(volMsg, volData);
1906     PVMFStatus status = QueueOutgoingMsg(volMsg);
1907     if (status != PVMFSuccess)
1908     {
1909         OSCL_LEAVE(status);
1910     }
1911     iSendFormatSpecificInfo = false;
1912 }
1913
1914 MuxSduData::MuxSduData()
1915 {
1916     size = 0;
1917     cur_frag_num = 0;
1918     cur_pos = 0;
1919 }
1920 PVMFStatus H223IncomingChannel::NegotiateOutputSettings(PvmiCapabilityAndConfig* aConfig)
1921 {
1922     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::NegotiateInputSettings, aConfig=%x", aConfig));
1923
1924     PvmiKvp* kvp = NULL;
1925     int numParams = 0;
1926     int32 i = 0;
1927
1928     // Get supported input formats from peer
1929     PVMFStatus status = aConfig->getParametersSync(NULL,
1930                         OSCL_CONST_CAST(char*, INPUT_FORMATS_CAP_QUERY),
1931                         kvp, numParams, NULL);
1932
1933     if (status != PVMFSuccess)
1934     {
1935         status = aConfig->getParametersSync(NULL,
1936                                             OSCL_CONST_CAST(char*, "x-pvmf/video/decode/input_formats"),
1937                                             kvp, numParams, NULL);
1938     }
1939
1940     if (status != PVMFSuccess || numParams == 0)
1941     {
1942         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::NegotiateInputSettings, Error:  getParametersSync failed.  status=%d", status));
1943
1944         return PVMFSuccess;
1945     }
1946
1947     PvmiKvp* selectedKvp = NULL;
1948     PVCodecType_t codec_type = GetCodecType(iDataType);
1949     PVMFFormatType lcn_format_type = PVCodecTypeToPVMFFormatType(codec_type);
1950
1951     for (i = 0; i < numParams && !selectedKvp; i++)
1952     {
1953         if (lcn_format_type == kvp[i].value.pChar_value)
1954             selectedKvp = &(kvp[i]);
1955     }
1956
1957     if (!selectedKvp)
1958     {
1959         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::NegotiateInputSettings, Error:  Input format not supported by peer"));
1960         return PVMFFailure;
1961     }
1962
1963     /* This is for the silly problem of MIO components having the convention
1964        of returning uint32 for a query and requiring pChar for a setting
1965        we don't know if we are talking to an MIO or a decoder node
1966        (which will want a uint32), so we try both.  Try the pchar
1967        first, because if its expecting pchar and gets uint32, it will
1968        crash.
1969     */
1970     if (PVMFSuccess != setConfigParametersSync(selectedKvp, aConfig, lcn_format_type, true))
1971         return PVMFFailure;
1972
1973     aConfig->releaseParameters(NULL, kvp, numParams);
1974     kvp = NULL;
1975     numParams = 0;
1976
1977     return PVMFSuccess;
1978 }
1979
1980 ////////////////////////////////////////////////////////////////////////////
1981 //                  PvmiCapabilityAndConfig
1982 ////////////////////////////////////////////////////////////////////////////
1983 OSCL_EXPORT_REF void H223IncomingChannel::setObserver(PvmiConfigAndCapabilityCmdObserver* aObserver)
1984 {
1985     // Not supported
1986     OSCL_UNUSED_ARG(aObserver);
1987     OSCL_LEAVE(OsclErrNotSupported);
1988 }
1989
1990 ////////////////////////////////////////////////////////////////////////////
1991 OSCL_EXPORT_REF PVMFStatus H223IncomingChannel::getParametersSync(PvmiMIOSession session,
1992         PvmiKeyType identifier,
1993         PvmiKvp*& parameters,
1994         int& num_parameter_elements,
1995         PvmiCapabilityContext context)
1996 {
1997     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::getParametersSync"));
1998     OSCL_UNUSED_ARG(session);
1999     OSCL_UNUSED_ARG(context);
2000
2001     parameters = NULL;
2002     num_parameter_elements = 0;
2003
2004     if (pv_mime_strcmp(identifier, OUTPUT_FORMATS_CAP_QUERY) == 0)
2005     {
2006         num_parameter_elements = 1;
2007         PVMFStatus status = AllocateKvp(iKvpMemAlloc, parameters,
2008                                         OSCL_CONST_CAST(char*, OUTPUT_FORMATS_VALTYPE),
2009                                         num_parameter_elements);
2010         if (status != PVMFSuccess)
2011         {
2012             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::getParametersSync: Error - AllocateKvp failed. status=%d", status));
2013             return status;
2014         }
2015         PVCodecType_t codec_type = GetCodecType(iDataType);
2016         PVMFFormatType format = PVCodecTypeToPVMFFormatType(codec_type).getMIMEStrPtr();
2017         if (format == PVMF_MIME_AMR_IF2)
2018             parameters[0].value.pChar_value = (char*) PVMF_MIME_AMR_IF2;
2019         else if (format == PVMF_MIME_PCM16)
2020             parameters[0].value.pChar_value = (char*) PVMF_MIME_PCM16;
2021         else if (format ==  PVMF_MIME_YUV420)
2022             parameters[0].value.pChar_value = (char*) PVMF_MIME_YUV420;
2023         else if (format ==  PVMF_MIME_M4V)
2024             parameters[0].value.pChar_value = (char*) PVMF_MIME_M4V;
2025         else if (format ==  PVMF_MIME_H2632000)
2026             parameters[0].value.pChar_value = (char*) PVMF_MIME_H2632000;
2027         else if (format ==  PVMF_MIME_H2631998)
2028             parameters[0].value.pChar_value = (char*) PVMF_MIME_H2631998;
2029         else
2030             parameters[0].value.pChar_value = (char*) PVMF_MIME_FORMAT_UNKNOWN;
2031
2032     }
2033
2034     return PVMFSuccess;
2035 }
2036
2037 ////////////////////////////////////////////////////////////////////////////
2038 OSCL_EXPORT_REF PVMFStatus H223IncomingChannel::releaseParameters(PvmiMIOSession session,
2039         PvmiKvp* parameters,
2040         int num_elements)
2041 {
2042     OSCL_UNUSED_ARG(session);
2043     OSCL_UNUSED_ARG(num_elements);
2044
2045     if (parameters)
2046     {
2047         iKvpMemAlloc.deallocate((OsclAny*)parameters);
2048         return PVMFSuccess;
2049     }
2050     else
2051     {
2052         return PVMFFailure;
2053     }
2054 }
2055
2056 ////////////////////////////////////////////////////////////////////////////
2057 OSCL_EXPORT_REF void H223IncomingChannel::createContext(PvmiMIOSession session, PvmiCapabilityContext& context)
2058 {
2059     OSCL_UNUSED_ARG(session);
2060     OSCL_UNUSED_ARG(context);
2061 }
2062
2063 ////////////////////////////////////////////////////////////////////////////
2064 OSCL_EXPORT_REF void H223IncomingChannel::setContextParameters(PvmiMIOSession session,
2065         PvmiCapabilityContext& context,
2066         PvmiKvp* parameters, int num_parameter_elements)
2067 {
2068     OSCL_UNUSED_ARG(session);
2069     OSCL_UNUSED_ARG(context);
2070     OSCL_UNUSED_ARG(parameters);
2071     OSCL_UNUSED_ARG(num_parameter_elements);
2072 }
2073
2074 ////////////////////////////////////////////////////////////////////////////
2075 OSCL_EXPORT_REF void H223IncomingChannel::DeleteContext(PvmiMIOSession session, PvmiCapabilityContext& context)
2076 {
2077     OSCL_UNUSED_ARG(session);
2078     OSCL_UNUSED_ARG(context);
2079 }
2080
2081 ////////////////////////////////////////////////////////////////////////////
2082 OSCL_EXPORT_REF void H223IncomingChannel::setParametersSync(PvmiMIOSession session, PvmiKvp* parameters,
2083         int num_elements, PvmiKvp*& ret_kvp)
2084 {
2085     OSCL_UNUSED_ARG(session);
2086     PVMFStatus status = PVMFSuccess;
2087     ret_kvp = NULL;
2088
2089     for (int32 i = 0; i < num_elements; i++)
2090     {
2091         status = VerifyAndSetParameter(&(parameters[i]), true);
2092         if (status != PVMFSuccess)
2093         {
2094             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::setParametersSync: Error - VerifiyAndSetParameter failed on parameter #%d", i));
2095             ret_kvp = &(parameters[i]);
2096             /* Silently ignore unrecognized codecs untill CapEx is supported by peer */
2097             //OSCL_LEAVE(OsclErrArgument);
2098         }
2099     }
2100 }
2101
2102 PVMFStatus H223IncomingChannel::VerifyAndSetParameter(PvmiKvp* aKvp, bool aSetParam)
2103 {
2104     OSCL_UNUSED_ARG(aSetParam);
2105     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::VerifyAndSetParameter: aKvp=0x%x, aSetParam=%d", aKvp, aSetParam));
2106
2107     if (!aKvp)
2108     {
2109         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::VerifyAndSetParameter: Error - Invalid key-value pair"));
2110         return PVMFFailure;
2111     }
2112
2113     if (iDataType == NULL)
2114     {
2115         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::VerifyAndSetParameter: Error - DataType == NULL"));
2116         return PVMFErrNotSupported;
2117     }
2118
2119     if (pv_mime_strcmp(aKvp->key, OUTPUT_FORMATS_VALTYPE) == 0)
2120     {
2121         PVCodecType_t codec_type = GetCodecType(iDataType);
2122         PVMFFormatType lcn_format_type = PVCodecTypeToPVMFFormatType(codec_type);
2123         if (lcn_format_type != aKvp->value.pChar_value)
2124         {
2125             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::VerifyAndSetParameter: Error - Output format %s not supported", aKvp->value.pChar_value));
2126             return PVMFErrNotSupported;
2127         }
2128     }
2129
2130     return PVMFSuccess;
2131 }
2132
2133 ////////////////////////////////////////////////////////////////////////////
2134 OSCL_EXPORT_REF PVMFCommandId H223IncomingChannel::setParametersAsync(PvmiMIOSession session,
2135         PvmiKvp* parameters,
2136         int num_elements,
2137         PvmiKvp*& ret_kvp,
2138         OsclAny* context)
2139 {
2140     OSCL_UNUSED_ARG(session);
2141     OSCL_UNUSED_ARG(parameters);
2142     OSCL_UNUSED_ARG(num_elements);
2143     OSCL_UNUSED_ARG(ret_kvp);
2144     OSCL_UNUSED_ARG(context);
2145     return -1;
2146 }
2147
2148 ////////////////////////////////////////////////////////////////////////////
2149 OSCL_EXPORT_REF uint32 H223IncomingChannel::getCapabilityMetric(PvmiMIOSession session)
2150 {
2151     OSCL_UNUSED_ARG(session);
2152     return 1;
2153 }
2154
2155 ////////////////////////////////////////////////////////////////////////////
2156 OSCL_EXPORT_REF PVMFStatus H223IncomingChannel::verifyParametersSync(PvmiMIOSession session,
2157         PvmiKvp* parameters, int num_elements)
2158 {
2159     OSCL_UNUSED_ARG(session);
2160
2161     PVMFStatus status = PVMFSuccess;
2162     for (int32 i = 0; (i < num_elements) && (status == PVMFSuccess); i++)
2163         status = VerifyAndSetParameter(&(parameters[i]), true);
2164
2165     return status;
2166 }
2167
2168 void H223IncomingChannel::HandlePortActivity(const PVMFPortActivity &aActivity)
2169 {
2170     if (aActivity.iType != PVMF_PORT_ACTIVITY_OUTGOING_MSG &&
2171             aActivity.iType != PVMF_PORT_ACTIVITY_CONNECTED_PORT_READY)
2172     {
2173         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::HandlePortActivity Unhandled port activity: %d", aActivity.iType));
2174         return;
2175     }
2176     PVMFStatus aStatus;
2177     PVMFSharedMediaMsgPtr aMsg;
2178     while (OutgoingMsgQueueSize())
2179     {
2180         aStatus = Send();
2181         if (aStatus != PVMFSuccess)
2182         {
2183             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0, "H223IncomingChannel::HandlePortActivity Failed to DeQueue incoming message: %d", aStatus));
2184             break;
2185         }
2186     }
2187 }
2188
2189 PVMFStatus H223IncomingChannel::SendBeginOfStreamMediaCommand()
2190 {
2191     PVMFSharedMediaCmdPtr sharedMediaCmdPtr = PVMFMediaCmd::createMediaCmd();
2192     sharedMediaCmdPtr->setFormatID(PVMF_MEDIA_CMD_BOS_FORMAT_ID);
2193
2194     sharedMediaCmdPtr->setTimestamp(iCurTimestamp);
2195
2196     uint32 seqNum = 0;
2197     uint32 streamID = 0;
2198     sharedMediaCmdPtr->setSeqNum(seqNum);
2199
2200     PVMFSharedMediaMsgPtr mediaMsgOut;
2201     convertToPVMFMediaCmdMsg(mediaMsgOut, sharedMediaCmdPtr);
2202     mediaMsgOut->setStreamID(streamID);
2203
2204     PVMFStatus status = QueueOutgoingMsg(mediaMsgOut);
2205     if (status != PVMFSuccess)
2206     {
2207         // Output queue is busy, so wait for the output queue being ready
2208         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
2209                         (0, "H223IncomingChannel::SendBeginOfMediaStreamCommand: Outgoing queue busy. "));
2210         return status;
2211     }
2212     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223IncomingChannel::SendBeginOfMediaStreamCommand() BOS Sent StreamId %d ", streamID));
2213     return status;
2214 }
2215
2216 void H223IncomingChannel::SetSampleTimestamps(PVMFTimestamp& aTSOffset)
2217 {
2218     iRenderingSkew = iAudioLatency - iVideoLatency;
2219     uint32 skewDelta = 0;
2220     if (iRenderingSkew >= (int32)iIncomingSkew)
2221     {
2222         skewDelta = iRenderingSkew - iIncomingSkew;
2223         if (iMediaType.isCompressed() && iMediaType.isAudio())
2224         {
2225             aTSOffset = (PVMFTimestamp)(iAudioLatency);
2226         }
2227         else if (iMediaType.isCompressed() && iMediaType.isVideo())
2228         {
2229             aTSOffset = (PVMFTimestamp)(iVideoLatency + skewDelta + PARSING_JITTER_DURATION);
2230         }
2231     }
2232     else if (iRenderingSkew < (int32)iIncomingSkew)
2233     {
2234         skewDelta = iIncomingSkew - iRenderingSkew;
2235         if (iMediaType.isCompressed() && iMediaType.isAudio())
2236         {
2237             aTSOffset = (PVMFTimestamp)(iAudioLatency + skewDelta);
2238         }
2239         else if (iMediaType.isCompressed() && iMediaType.isVideo())
2240         {
2241             aTSOffset = (PVMFTimestamp)(iVideoLatency + PARSING_JITTER_DURATION);
2242         }
2243     }
2244
2245 #ifdef LIP_SYNC_TESTING
2246
2247     /**************************************************************************************************
2248        this is the check, to get unique sample TS on dummy output node side.So for this purpose, we are
2249        checking the original video TS with the previous TS.If this condition is true then only we are
2250        modifying the value of aTSOffset.
2251
2252      ***************************************************************************************************/
2253
2254     if ((g_CheckSampleTime != g_RecTimeStamp) && (iParam->iUncompressed == true))
2255     {
2256         g_CheckSampleTime = g_RecTimeStamp;
2257         g_Checkcount++;
2258         aTSOffset += g_Checkcount;
2259
2260     }
2261 #endif
2262
2263     aTSOffset += iCurTimestamp;
2264 }
2265
2266 /* *****************************************************************************************************
2267 *  Function : DetectSkewInd()
2268 *  Date     : 6/15/2009
2269 *  Purpose  : The purpose of this function is to calculate skew (difference b/w audio and video TS)
2270 *              on stack outgoing side.Audio and Video both sending TS through observer and we are calculating
2271                 actual skew in cpvh223multiplex.cpp. Function name CalculateSkew()
2272 *  INPUT    : aMsg
2273 *  Return   : NONE
2274 *
2275 *
2276 * *************************************************************************************************/
2277 void H223OutgoingChannel::DetectSkewInd(PVMFSharedMediaMsgPtr aMsg)
2278 {
2279
2280     PVMFFormatType mediaType = GetFormatType();
2281     uint32 audio = 0;
2282     uint32 video = 0;
2283     if (mediaType.isCompressed() && (mediaType.isAudio() || mediaType.isVideo()))
2284     {
2285         if (mediaType.isCompressed() && mediaType.isAudio())
2286         {
2287             audio = (uint32)aMsg->getTimestamp();
2288             iObserver->CalculateSkew(lcn, 0, audio, 0);
2289
2290         }
2291         else if (mediaType.isCompressed() && mediaType.isVideo())
2292         {
2293             video = (uint32)aMsg->getTimestamp();
2294             iObserver->CalculateSkew(lcn, 1, video, 0);
2295             CalcRMSInfo(video, audio);
2296
2297         }
2298     }
2299 }
2300 /* *****************************************************************************************************
2301 *  Function : CalcRMSInfo()
2302 *  Date     : 6/15/2009
2303 *  Purpose  : The purpose of this function is to Calculate skew on stack outgoing side.In this function we are
2304                reciving the video and audio TS. The main thing is that we are calculting the skew, when we
2305                recieves the video TS with last Audio TS.This function is also for lip-sync calculation
2306 *  INPUT    : VideoData,AudioData
2307 *  Return   : NONE
2308 *
2309 *
2310 * *************************************************************************************************/
2311 void H223OutgoingChannel::CalcRMSInfo(uint32 aVideoData, uint32 aAudioData)
2312 {
2313
2314     if (iOnlyOnce == false)
2315     {
2316
2317         uint32 tick_ct_val = OsclTickCount::TickCount();
2318         iTsmsec = OsclTickCount::TicksToMsec(tick_ct_val);
2319         iOnlyOnce = true;
2320     }
2321
2322     int Diff = aVideoData - iTsmsec;
2323     if (Diff >= 60000)
2324     {
2325         /*End Of TIMER EOT=1*/
2326
2327         iObserver->CalculateSkew(lcn, 0, 0, 1);
2328     }
2329
2330
2331
2332 }
2333
2334
2335 #ifdef LIP_SYNC_TESTING
2336
2337 /* *****************************************************************************************************
2338 *  Function : CalculateRMSInfo()
2339 *  Date     : 6/15/2009
2340 *  Purpose  : The purpose of this function is to Calculate skew on stack incoming side.In this function we are
2341                reciving the video and audio TS. The main thing is that we are calculting the skew, when we
2342                recieves the video TS with last Audio TS.
2343 *  INPUT    : VideoData,AudioData
2344 *  Return   : NONE
2345 *
2346 *
2347 * *************************************************************************************************/
2348 void H223IncomingChannel::CalculateRMSInfo(uint32 aVideoData, uint32 aAudioData)
2349 {
2350     g_DiffIncmVidAudTS = aVideoData - aAudioData;
2351     g_iSqrIncCalVidAudTS += (g_DiffIncmVidAudTS * g_DiffIncmVidAudTS);
2352
2353     if (g_OnlyOneTime)
2354     {
2355         uint32 tick_ct_val;
2356         tick_ct_val = OsclTickCount::TickCount();
2357         g_Incmtsmsec = OsclTickCount::TicksToMsec(tick_ct_val);
2358         g_OnlyOneTime = 0;
2359     }
2360
2361
2362
2363     int Diff = aVideoData - g_Incmtsmsec;
2364     if (Diff >= 60000)
2365     {
2366         if (g_TotalCountIncm == 0)
2367         {
2368             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2369                             (0, "Not be able to calculate RMS because Total count value is zero  TotalCount=%d", g_TotalCountIncm));
2370
2371         }
2372         else
2373         {
2374             g_IncRtMnSqCalc = (int32)sqrt(g_iSqrIncCalVidAudTS / g_TotalCountIncm);
2375         }
2376
2377     }
2378     g_TotalCountIncm++;
2379
2380 }
2381
2382 /* *****************************************************************************************************
2383 *  Function : DetectFrameBoundary()
2384 *  Date     : 6/15/2009
2385 *  Purpose  : The purpose of this function is to Detect frame boundary that whether the format is MPEG-4 or H263,
2386                In this function we are sending  original VideoTS to dummy output MIO node through observer.
2387                The reason is we dont want to pass the same to specific decoder, as decoder will modify the TS.
2388                This is we are doing for calculating lip-sync skew.
2389
2390 *  INPUT    : buf,aTimestamp
2391 *  Return   : NONE
2392 *
2393 *
2394 * *************************************************************************************************/
2395 void H223IncomingChannel::DetectFrameBoundary(uint8* aBuf, uint32 aTimestamp)
2396 {
2397     PVMFFormatType mediaType = GetFormatType();
2398
2399     /********************This is for MPEG-4 Header and H263 Header***********************************/
2400     if ((mediaType.isCompressed() && (mediaType.isAudio() || mediaType.isVideo())))
2401     {
2402
2403         if (mediaType.isCompressed() && mediaType.isAudio())
2404         {
2405             g_IncmAudioTS = *(((uint32*)aBuf));
2406
2407         }
2408
2409         if (mediaType.isCompressed() && mediaType.isVideo())
2410         {
2411             /*This check is for VOL header*/
2412             if ((aBuf[0] == VOP_START_BYTE_1) &&
2413                     (aBuf[1] == VOP_START_BYTE_2) &&
2414                     (aBuf[2] == VOP_START_BYTE_3) &&
2415                     (aBuf[3] == VOP_START_BYTE_5))
2416             {
2417
2418                 g_IncmVideoTS = g_RecTimeStamp;
2419                 CalculateRMSInfo(g_IncmVideoTS, g_IncmAudioTS);
2420                 iParam->iObserver->MIOFramesTimeStamps(0, g_RecTimeStamp, aTimestamp);
2421
2422             }
2423             /*This Check is for MP4 Header*/
2424             else if ((aBuf[0] == VOP_START_BYTE_1) &&
2425                      (aBuf[1] == VOP_START_BYTE_2) &&
2426                      (aBuf[2] == VOP_START_BYTE_3) &&
2427                      (aBuf[3] == VOP_START_BYTE_4))
2428             {
2429
2430                 g_IncmVideoTS = g_RecTimeStamp;
2431                 CalculateRMSInfo(g_IncmVideoTS, g_IncmAudioTS);
2432                 iParam->iObserver->MIOFramesTimeStamps(0, g_RecTimeStamp, aTimestamp);
2433
2434
2435
2436             }
2437             /*This check is for H263 Header*/
2438             else if ((aBuf[0] == H263_START_BYTE_1) &&
2439                      (aBuf[1] == H263_START_BYTE_2) &&
2440                      (aBuf[2] == H263_START_BYTE_3))
2441             {
2442
2443                 g_IncmVideoTS = *(((uint32*)aBuf) + 1);
2444                 CalculateRMSInfo(g_IncmVideoTS, g_IncmAudioTS);
2445
2446
2447
2448             }
2449
2450         }
2451
2452     }
2453
2454 }
2455 /* *****************************************************************************************************
2456 *  Function : ExtractTimestamp()
2457 *  Date     : 6/15/2009
2458 *  Purpose  : The purpose of this function is to extract original TS on stack incoming side.So for each SDU's
2459                we are extracting original video TS.This also we are doing for uncompressed video.Later we will
2460                add the same functionality for uncompressed audio only.This functionality is also for lip-sync
2461                detection.
2462 *  INPUT    : NONE
2463 *  Return   : NONE
2464 *
2465 *
2466 * *************************************************************************************************/
2467 void H223IncomingChannel::ExtractTimestamp()
2468 {
2469     PVMFFormatType mediaType = GetFormatType();
2470     if (lcn != 0)
2471     {
2472         if (mediaType.isCompressed() && mediaType.isVideo())
2473         {
2474             OsclRefCounterMemFrag MemFrag;
2475             OsclRefCounterMemFrag tsFrag;
2476             OsclRefCounterMemFrag frag;
2477             uint32 FragSize = 0;
2478             uint8* CheckTSbuff = 0;
2479             for (uint32 i = 0; i < iAlPduMediaData->getNumFragments(); i++)
2480             {
2481                 iAlPduMediaData->getMediaFragment(i, frag);
2482                 uint8* buf = (uint8*)frag.getMemFragPtr();
2483                 FragSize = frag.getMemFragSize();
2484                 CheckTSbuff = (uint8*)(buf + FragSize);
2485             }
2486             uint8* TimeStamp = (uint8*)(CheckTSbuff - 4);
2487             g_RecTimeStamp = (uint32)(*((uint32*)TimeStamp));
2488             iAlPduMediaData->getMediaFragment(0, tsFrag);
2489             iAlPduMediaData->setMediaFragFilledLen(iAlPduMediaData->getNumFragments() - 1, FragSize - 4);
2490
2491         }
2492     }
2493
2494 }
2495
2496
2497 /* ***********************************************************************************
2498 *  Function : AppendLipSyncTS()
2499 *  Date     : 6/15/2009
2500 *  Purpose  : The purpose of this function is to append four bytes(Video TS)
2501 *               on every sdu's.Here we are doing for Video only.this is
2502 *              we are doing for to get original Video TS at stack incoming side.
2503 *
2504 *  INPUT    : NONE
2505 *  Return   : NONE
2506 *
2507 *
2508 * **********************************************************************************/
2509 void  H223OutgoingChannel::AppendLipSyncTS()
2510 {
2511
2512
2513     if (iMediaType.isCompressed() && iMediaType.isVideo())
2514     {
2515         PVMFSharedMediaDataPtr hdrTSData;
2516         OsclRefCounterMemFrag tsFrag;
2517         OsclSharedPtr<PVMFMediaDataImpl> addTsImpl =  iMediaDataAlloc.allocate(4);
2518         hdrTSData = PVMFMediaData::createMediaData(addTsImpl);
2519
2520         hdrTSData->getMediaFragment(0, tsFrag);
2521         tsFrag.getMemFrag().len = 4;
2522         uint32* SendBuff = (uint32*) tsFrag.getMemFragPtr();
2523         SendBuff[0] = iCurPduTimestamp;
2524         iCurPdu->appendMediaFragment(tsFrag);
2525
2526     }
2527
2528
2529 }
2530 #endif
2531
2532