开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
mp4gpyld.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：38k
源码类别：

Symbian

开发平台：

C/C++

mp4gpyld.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: RCSL 1.0/RPSL 1.0
  3.  *
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved.
  5.  *
  6.  * The contents of this file, and the files included with this file, are
  7.  * subject to the current version of the RealNetworks Public Source License
  8.  * Version 1.0 (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the RealNetworks Community Source License Version 1.0
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl,
  12.  * in which case the RCSL will apply. You may also obtain the license terms
  13.  * directly from RealNetworks.  You may not use this file except in
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or
  16.  * RCSL for the rights, obligations and limitations governing use of the
  17.  * contents of the file.
  18.  *
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the
  20.  * developer of the Original Code and owns the copyrights in the portions
  21.  * it created.
  22.  *
  23.  * This file, and the files included with this file, is distributed and made
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  28.  *
  29.  * Technology Compatibility Kit Test Suite(s) Location:
  30.  *    http://www.helixcommunity.org/content/tck
  31.  *
  32.  * Contributor(s):
  33.  *
  34.  * ***** END LICENSE BLOCK ***** */
  36. /****************************************************************************
  37.  *  Defines
  38.  */
  39. #define _OVERALLOC_CODEC_DATA 3
  41. #define FLUSH_ALL_PACKETS   0xFFFFFFFF
  43. #define CHAR_LF 0x0a
  44. #define CHAR_CR 0x0d
  46. #define FORMAT_PARAMETERS_PREFIX "a=fmtp:0 "
  47. #define FORMAT_PARAMETERS_PREFIX_SIZE (sizeof(FORMAT_PARAMETERS_PREFIX) - 1)
  49. #define MAX_AUPACKETS_IN_RTPPACKET 50
  51. #define MAX_PACKET_FRAGMENTS 256
  52. #define MAX_AU_FRAGMENTS 256
  53. #define MAX_AU_PACKETS 256
  55. #define MAX_INT_TEXT_LENGTH 10
  58. /****************************************************************************
  59.  *  Includes
  60.  */
  61. #include "hxtypes.h"
  62. #include "hxwintyp.h"
  63. #include "hxcom.h"
  64. #include "hxcomm.h"
  66. #include "hxassert.h"
  67. #include "hxslist.h"
  68. #include "hxstrutl.h"
  69. #include "hxcomm.h"
  70. #include "ihxpckts.h"
  71. #include "hxformt.h"
  72. #include "hxrendr.h"
  73. #include "hxformt.h"
  74. #include "hxengin.h"
  76. #include "bitstuff.h"
  78. #include "sdpchunk.h"
  79. #include "sdptools.h"
  80. #include "mp4gpyld.h"
  83. MP4GPayloadFormat::MP4GPayloadFormat()
  84.     : m_lRefCount     (0)
  85.     , m_pClassFactory     (NULL)
  86.     , m_pStreamHeader     (NULL)
  87.     , m_bFlushed     (FALSE)
  88.     , m_bUsesRTPPackets     (FALSE)
  89.     , m_bRTPPacketTested    (FALSE)
  90.     , m_bPacketize     (FALSE)
  91.     , m_ulSamplesPerSecond  (1000)
  92.     , m_ulRTPSamplesPerSecond(0)
  93.     , m_bPriorLoss     (FALSE)
  94.     , m_pPacketFragments    (NULL)
  95.     , m_pAUFragments     (NULL)
  96.     , m_pAUPackets     (NULL)
  97.     , m_ulMaxPacketFragments(MAX_PACKET_FRAGMENTS)
  98.     , m_ulMaxAUFragments    (MAX_AU_FRAGMENTS)
  99.     , m_ulMaxAUPackets     (MAX_AU_PACKETS)
  100.     , m_ulNumPacketFragments(0)
  101.     , m_ulNumAUFragments    (0)
  102.     , m_ulNumAUPackets     (0)
  103.     , m_bStartPacket     (TRUE)
  104.     , m_ulAUDuration     (0)
  105.     , m_ulFrameCount     (0)
  106.     , m_bLastReapedSet     (FALSE)
  107.     , m_bEarliestDeintTimeKnown(FALSE)
  108. {
  109.     ;
  110. }
  112. MP4GPayloadFormat::~MP4GPayloadFormat()
  113. {
  114.     Reset();
  116.     HX_VECTOR_DELETE(m_pPacketFragments);
  117.     HX_VECTOR_DELETE(m_pAUFragments);
  118.     HX_VECTOR_DELETE(m_pAUPackets);
  120.     HX_RELEASE(m_pClassFactory);
  121.     HX_RELEASE(m_pStreamHeader);
  122. }
  124. HX_RESULT MP4GPayloadFormat::Build(REF(IMP4APayloadFormat*) pFmt)
  125. {
  126.     pFmt = new MP4GPayloadFormat();
  128.     HX_RESULT res = HXR_OUTOFMEMORY;
  129.     if (pFmt)
  130.     {
  131. pFmt->AddRef();
  132. res = HXR_OK;
  133.     }
  135.     return res;
  136. }
  138. // *** IUnknown methods ***
  140. /////////////////////////////////////////////////////////////////////////
  141. //  Method:
  142. // IUnknown::QueryInterface
  143. //  Purpose:
  144. // Implement this to export the interfaces supported by your
  145. // object.
  146. //
  147. STDMETHODIMP
  148. MP4GPayloadFormat::QueryInterface(REFIID riid, void** ppvObj)
  149. {
  150.     QInterfaceList qiList[] =
  151.     {
  152. { GET_IIDHANDLE(IID_IUnknown), this },
  153. { GET_IIDHANDLE(IID_IHXPayloadFormatObject), (IHXPayloadFormatObject*) this },
  154.     };
  155.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  156. }
  158. /////////////////////////////////////////////////////////////////////////
  159. //  Method:
  160. // IUnknown::AddRef
  161. //  Purpose:
  162. // Everyone usually implements this the same... feel free to use
  163. // this implementation.
  164. //
  165. STDMETHODIMP_(ULONG32)
  166. MP4GPayloadFormat::AddRef()
  167. {
  168.     return InterlockedIncrement(&m_lRefCount);
  169. }
  171. /////////////////////////////////////////////////////////////////////////
  172. //  Method:
  173. // IUnknown::Release
  174. //  Purpose:
  175. // Everyone usually implements this the same... feel free to use
  176. // this implementation.
  177. //
  178. STDMETHODIMP_(ULONG32)
  179. MP4GPayloadFormat::Release()
  180. {
  181.     if (InterlockedDecrement(&m_lRefCount) > 0)
  182.     {
  183.         return m_lRefCount;
  184.     }
  186.     delete this;
  187.     return 0;
  188. }
  191. STDMETHODIMP
  192. MP4GPayloadFormat::Init(IUnknown* pContext,
  193. BOOL bPacketize)
  194. {
  195.     HX_RESULT retVal = HXR_OK;
  197.     HX_RELEASE(m_pClassFactory);
  199.     m_bPacketize = bPacketize;
  201.     if (SUCCEEDED(retVal))
  202.     {
  203. retVal = pContext->QueryInterface(IID_IHXCommonClassFactory,
  204.   (void**) &m_pClassFactory);
  205.     }
  207.     if (SUCCEEDED(retVal))
  208.     {
  209. retVal = HXR_OUTOFMEMORY;
  211. m_pPacketFragments = new IHXPacket* [m_ulMaxPacketFragments];
  212. m_pAUFragments = new CAUPacket* [m_ulMaxAUFragments];
  213. m_pAUPackets = new CAUPacket* [m_ulMaxAUPackets];
  215. if (m_pPacketFragments &&
  216.     m_pAUFragments &&
  217.     m_pAUPackets)
  218. {
  219.     memset(m_pPacketFragments, 0, sizeof(IHXPacket*) * m_ulMaxPacketFragments);
  220.     memset(m_pAUFragments, 0, sizeof(CAUPacket*) * m_ulMaxAUFragments);
  221.     memset(m_pAUPackets, 0, sizeof(CAUPacket*) * m_ulMaxAUPackets);
  222.     retVal = HXR_OK;
  223. }
  224.     }
  226.     return retVal;
  227. }
  229. STDMETHODIMP
  230. MP4GPayloadFormat::Reset()
  231. {
  232.     // Release all input packets we have stored
  233.     FlushQueues();
  234.     FlushArrays();
  236.     m_bFlushed = FALSE;
  237.     m_bPriorLoss = FALSE;
  238.     m_bStartPacket = TRUE;
  239.     m_ulFrameCount = 0;
  241.     m_TSConverter.Reset();
  243.     return HXR_OK;
  244. }
  246. STDMETHODIMP
  247. MP4GPayloadFormat::SetStreamHeader(IHXValues* pHeader)
  248. {
  249.     HX_RESULT retVal;
  251.     if (pHeader)
  252.     {
  253. m_pStreamHeader = pHeader;
  254. m_pStreamHeader->AddRef();
  255.     }
  257.     if (m_bPacketize)
  258.     {
  259. retVal = SetPacketizerHeader(pHeader);
  260.     }
  261.     else
  262.     {
  263. retVal = SetAssemblerHeader(pHeader);
  264.     }
  266.     return retVal;
  267. }
  269. HX_RESULT MP4GPayloadFormat::SetPacketizerHeader(IHXValues* pHeader)
  270. {
  271.     return HXR_OK;
  272. }
  274. HX_RESULT MP4GPayloadFormat::SetAssemblerHeader(IHXValues* pHeader)
  275. {
  276.     IHXBuffer* pMimeType = NULL;
  277.     const char* pMimeTypeData = NULL;
  278.     HX_RESULT retVal = HXR_INVALID_PARAMETER;
  280.     if (pHeader)
  281.     {
  282. retVal = HXR_OK;
  283.     }
  285.     if (SUCCEEDED(retVal))
  286.     {
  287. retVal = pHeader->GetPropertyCString("MimeType", pMimeType);
  288.     }
  290.     if (SUCCEEDED(retVal))
  291.     {
  292. pMimeTypeData = (char*) pMimeType->GetBuffer();
  294. retVal = HXR_FAIL;
  295. if (pMimeTypeData)
  296. {
  297.     retVal = HXR_OK;
  298. }
  299.     }
  301.     // Determine payload type here based on mime type
  302.     if (SUCCEEDED(retVal))
  303.     {
  304. retVal = HXR_FAIL;
  305. if ((strcasecmp(pMimeTypeData, "audio/mpeg4-simple-A2") == 0) ||
  306.     (strcasecmp(pMimeTypeData, "audio/x-ralf-mpeg4-generic") == 0) ||
  307.     (strcasecmp(pMimeTypeData, "audio/mpeg4-generic") == 0) ||
  308.     (strcasecmp(pMimeTypeData, "video/mpeg4-generic") == 0))
  309. {
  310.     retVal = HXR_OK;
  311. }
  312.     }
  314.     if (SUCCEEDED(retVal))
  315.     {
  316. char *pData = NULL;
  317. char* pAllocData = NULL;
  318. IHXBuffer* pSDPData = NULL;
  319. IHXValues* pValues = NULL;
  320. ULONG32 ulTryIdx = 0;
  322. do
  323. {
  324.     if (ulTryIdx == 0)
  325.     {
  326. retVal = pHeader->GetPropertyCString("SDPData", pSDPData);
  328. if (SUCCEEDED(retVal))
  329. {
  330.     pData = (char*) pSDPData->GetBuffer();
  332.     retVal = HXR_FAIL;
  333.     if (pData)
  334.     {
  335. retVal = HXR_OK;
  336.     }
  337. }
  338.     }
  339.     else
  340.     {
  341. retVal = pHeader->GetPropertyCString("PayloadParameters", pSDPData);
  343. if (SUCCEEDED(retVal))
  344. {
  345.     ULONG32 ulDataLen;
  347.     pData = (char*) pSDPData->GetBuffer();
  348.     ulDataLen = strlen(pData);
  350.     pAllocData = new char [ulDataLen +
  351. FORMAT_PARAMETERS_PREFIX_SIZE +
  352. 2];
  354.     retVal = HXR_OUTOFMEMORY;
  355.     if (pAllocData)
  356.     {
  357. strcpy(pAllocData, FORMAT_PARAMETERS_PREFIX); /* Flawfinder: ignore */
  358. strcpy(pAllocData + FORMAT_PARAMETERS_PREFIX_SIZE, pData); /* Flawfinder: ignore */
  359. pAllocData[FORMAT_PARAMETERS_PREFIX_SIZE + ulDataLen] =
  360.     CHAR_LF;
  361. pAllocData[FORMAT_PARAMETERS_PREFIX_SIZE + 1 + ulDataLen] =
  362.     '';
  364. pData = pAllocData;
  365. retVal = HXR_OK;
  366.     }
  367. }
  368.     }
  370.     if (SUCCEEDED(retVal))
  371.     {
  372. retVal = SDPParseChunk(pData,
  373.     strlen(pData),
  374.     pValues,
  375.     m_pClassFactory,
  376.     SDPCTX_Renderer);
  377.     }
  379.     HX_VECTOR_DELETE(pAllocData);
  381.     if (SUCCEEDED(retVal))
  382.     {
  383. retVal = SetAssemblerConfig(pValues);
  384.     }
  386.     if (SUCCEEDED(retVal))
  387.     {
  388. m_ulAUDuration = m_Config.m_ulConstantDuration;
  389.     }
  391.     HX_RELEASE(pSDPData);
  392.     HX_RELEASE(pValues);
  394.     ulTryIdx++;
  395. } while (FAILED(retVal) && (ulTryIdx < 2));
  396.     }
  398.     if (SUCCEEDED(retVal))
  399.     {
  400. m_pStreamHeader->GetPropertyULONG32("SamplesPerSecond",
  401.     m_ulRTPSamplesPerSecond);
  402.     }
  404.     HX_RELEASE(pMimeType);
  406.     return retVal;
  407. }
  409. HX_RESULT MP4GPayloadFormat::SetAssemblerConfig(IHXValues* pFMTParams)
  410. {
  411.     return m_Config.Init(pFMTParams, m_pClassFactory);
  412. }
  414. HX_RESULT MP4GPayloadFormat::CFormatConfig::Init(IHXValues* pFMTParams,
  415.  IHXCommonClassFactory* pClassFactory)
  416. {
  417.     IHXBuffer* pConfigString = NULL;
  418.     IHXBuffer* pModeString = NULL;
  419.     HX_RESULT retVal = HXR_OK;
  421.     HX_ASSERT(pFMTParams);
  423.     // Obtain Required parameters
  424.     retVal = pFMTParams->GetPropertyULONG32("FMTPstreamtype",
  425.     m_ulStreamType);
  427.     if (SUCCEEDED(retVal))
  428.     {
  429. retVal = pFMTParams->GetPropertyULONG32("FMTPprofile-level-id",
  430. m_ulProfileLevelID);
  431.     }
  433.     if (SUCCEEDED(retVal))
  434.     {
  435. retVal = pFMTParams->GetPropertyCString("FMTPconfig",
  436. pConfigString);
  438. if (FAILED(retVal))
  439. {
  440.     ULONG32 ulConfigVal = 0;
  442.     retVal = pFMTParams->GetPropertyULONG32("FMTPconfig",
  443.     ulConfigVal);
  445.     if (SUCCEEDED(retVal))
  446.     {
  447. retVal = pClassFactory->CreateInstance(IID_IHXBuffer,
  448.        (void**) &pConfigString);
  449.     }
  451.     if (SUCCEEDED(retVal))
  452.     {
  453. retVal = pConfigString->SetSize(MAX_INT_TEXT_LENGTH + 1);
  454.     }
  456.     if (SUCCEEDED(retVal))
  457.     {
  458. SafeSprintf((char*) pConfigString->GetBuffer(), MAX_INT_TEXT_LENGTH + 1, "%ld",
  459. ulConfigVal);
  460.     }
  461. }
  462.     }
  464.     // Obtain optional parameters
  465.     if (SUCCEEDED(retVal))
  466.     {
  467. pFMTParams->GetPropertyCString("FMTPmode", pModeString);
  468. pFMTParams->GetPropertyULONG32("FMTPConstantSize", m_ulConstantSize);
  469. pFMTParams->GetPropertyULONG32("FMTPConstantDuration", m_ulConstantDuration);
  470. pFMTParams->GetPropertyULONG32("FMTPSizeLength", m_ulSizeLength);
  471. pFMTParams->GetPropertyULONG32("FMTPIndexLength", m_ulIndexLength);
  472. pFMTParams->GetPropertyULONG32("FMTPIndexDeltaLength", m_ulIndexDeltaLength);
  473. pFMTParams->GetPropertyULONG32("FMTPCTSDeltaLength", m_ulCTSDeltaLength);
  474. pFMTParams->GetPropertyULONG32("FMTPDTSDeltaLength", m_ulDTSDeltaLength);
  475. pFMTParams->GetPropertyULONG32("FMTPAuxDataSizeLength", m_ulAuxDataSizeLength);
  476. pFMTParams->GetPropertyULONG32("FMTPProfile", m_ulProfile);
  477.     }
  479.     // Perform any needed translations
  480.     if (SUCCEEDED(retVal))
  481.     {
  482. // Determine Mode from Mode String
  483. if (pModeString)
  484. {
  485.     const char* pMode = (char*) pModeString->GetBuffer();
  487.     if (pMode)
  488.     {
  489. if (strcasecmp(pMode, "A0") == 0)
  490. {
  491.     m_Mode = MODE_A0;
  492. }
  493. else if (strcasecmp(pMode, "A1") == 0)
  494. {
  495.     m_Mode = MODE_A1;
  496. }
  497. else if (strcasecmp(pMode, "A2") == 0)
  498. {
  499.     m_Mode = MODE_A2;
  500. }
  501.     }
  502. }
  504. // Convert decoder configuration from ascii hex to binary
  505. if (pConfigString)
  506. {
  507.     ULONG32 ulConfigSize;
  508.     const char* pConfig = (char*) pConfigString->GetBuffer();
  509.     IHXBuffer* pConfigBuffer = NULL;
  511.     if (pConfig)
  512.     {
  513. ulConfigSize = strlen(pConfig) / 2;
  515. if (ulConfigSize > 0)
  516. {
  517.     retVal = pClassFactory->CreateInstance(IID_IHXBuffer,
  518.    (void**) &pConfigBuffer);
  520.     if (SUCCEEDED(retVal))
  521.     {
  522. retVal = pConfigBuffer->SetSize(ulConfigSize);
  523.     }
  525.     if (SUCCEEDED(retVal))
  526.     {
  527. retVal = HexStringToBinary(pConfigBuffer->GetBuffer(),
  528.    pConfig);
  529.     }
  530. }
  531.     }
  533.     if (SUCCEEDED(retVal))
  534.     {
  535. m_pConfig = pConfigBuffer;
  537. if (m_pConfig)
  538. {
  539.     m_pConfig->AddRef();
  540. }
  541.     }
  543.     HX_RELEASE(pConfigBuffer);
  544. }
  545.     }
  547.     // Compute dervied parameter
  548.     if (SUCCEEDED(retVal))
  549.     {
  550. m_bHasAUHeaders = ((m_ulSizeLength != 0) ||
  551.    (m_ulIndexLength != 0) ||
  552.    (m_ulIndexDeltaLength != 0) ||
  553.    (m_ulCTSDeltaLength != 0) ||
  554.    (m_ulDTSDeltaLength != 0));
  555.     }
  557.     HX_RELEASE(pModeString);
  558.     HX_RELEASE(pConfigString);
  560.     return retVal;
  561. }
  563. STDMETHODIMP
  564. MP4GPayloadFormat::GetStreamHeader(REF(IHXValues*) pHeader)
  565. {
  566.     HX_RESULT retVal = HXR_FAIL;
  568.     if (m_pStreamHeader)
  569.     {
  570. retVal = HXR_OK;
  571. pHeader = m_pStreamHeader;
  572. pHeader->AddRef();
  573.     }
  575.     return retVal;
  576. }
  578. STDMETHODIMP
  579. MP4GPayloadFormat::SetPacket(IHXPacket* pPacket)
  580. {
  581.     HX_RESULT retVal = HXR_OK;
  583.     HX_ASSERT(pPacket);
  585.     if (!m_bRTPPacketTested)
  586.     {
  587. IHXRTPPacket* pRTPPacket = NULL;
  589. m_bUsesRTPPackets = (pPacket->QueryInterface(
  590. IID_IHXRTPPacket,
  591. (void**) &pRTPPacket)
  592.     == HXR_OK);
  594. m_bRTPPacketTested = TRUE;
  596. HX_RELEASE(pRTPPacket);
  598. if (m_bUsesRTPPackets)
  599. {
  600.     if (m_ulRTPSamplesPerSecond == 0)
  601.     {
  602. m_ulRTPSamplesPerSecond = m_ulSamplesPerSecond;
  603.     }
  605.     HX_ASSERT(m_ulSamplesPerSecond != 0);
  606. }
  607. else
  608. {
  609.     m_ulRTPSamplesPerSecond = 1000; // RDT time stamp
  610. }
  612. m_TSConverter.SetBase(m_ulRTPSamplesPerSecond,
  613.       m_ulSamplesPerSecond);
  614.     }
  616.     if (m_bPacketize)
  617.     {
  618. retVal = SetPacketizerPacket(pPacket);
  619.     }
  620.     else
  621.     {
  622. retVal = SetAssemblerPacket(pPacket);
  623.     }
  625.     if (retVal == HXR_OK)
  626.     {
  627. // Add this packet to our list of input packets
  628. pPacket->AddRef();
  629. m_InputQueue.AddTail(pPacket);
  630.     }
  631.     else if (retVal == HXR_NO_DATA)
  632.     {
  633. retVal = HXR_OK;
  634.     }
  636.     return retVal;
  637. }
  639. HX_RESULT MP4GPayloadFormat::SetPacketizerPacket(IHXPacket* pPacket)
  640. {
  641.     return HXR_NOTIMPL;
  642. }
  644. HX_RESULT MP4GPayloadFormat::SetAssemblerPacket(IHXPacket* pPacket)
  645. {
  646.     ULONG32 ulPacketTime;
  647.     HX_RESULT retVal = HXR_NO_DATA;
  649.     if (!pPacket->IsLost())
  650.     {
  651. ulPacketTime = GetPacketTime(pPacket);
  653. if (m_bStartPacket)
  654. {
  655.     m_bStartPacket = FALSE;
  656.     m_ulLastPacketTime = ulPacketTime;
  657. }
  658. else if (ulPacketTime != m_ulLastPacketTime)
  659. {
  660.     m_ulFrameCount++;
  661.     m_ulLastPacketTime = ulPacketTime;
  662. }
  664. if (pPacket->GetASMRuleNumber() == 1)
  665. {
  666.     m_ulFrameCount++;
  667.     m_bStartPacket = TRUE;
  668. }
  670. retVal = HXR_OK;
  671.     }
  673.     return retVal;
  674. }
  676. STDMETHODIMP
  677. MP4GPayloadFormat::GetPacket(REF(IHXPacket*) pOutPacket)
  678. {
  679.     HX_RESULT retVal = HXR_OK;
  681.     if (m_bPacketize)
  682.     {
  683. retVal = GetPacketizerPacket(pOutPacket);
  684.     }
  685.     else
  686.     {
  687. retVal = GetAssemblerPacket(pOutPacket);
  688.     }
  690.     return retVal;
  691. }
  693. HX_RESULT MP4GPayloadFormat::GetPacketizerPacket(IHXPacket* &pOutPacket)
  694. {
  695.     HX_RESULT retVal = HXR_NOTIMPL;
  697.     return retVal;
  698. }
  700. HX_RESULT MP4GPayloadFormat::GetAssemblerPacket(IHXPacket* &pOutPacket)
  701. {
  702.     HX_RESULT retVal = HXR_NOTIMPL;
  704.     return retVal;
  705. }
  708. HX_RESULT MP4GPayloadFormat::CreateMediaPacket(CMediaPacket* &pOutMediaPacket)
  709. {
  710.     HX_RESULT retVal = HXR_OK;
  711.     CMediaPacket* pMediaPacket;
  713.     pMediaPacket = StripPacket();
  715.     if (!pMediaPacket)
  716.     {
  717. retVal = ProducePackets();
  719. if (retVal == HXR_OK)
  720. {
  721.     pMediaPacket = StripPacket();
  722. }
  723. else if ((retVal == HXR_NO_DATA) &&
  724.          m_bFlushed)
  725. {
  726.     retVal = HXR_STREAM_DONE;
  727. }
  728.     }
  730.     if (retVal == HXR_OK)
  731.     {
  732. pOutMediaPacket = pMediaPacket;
  733.     }
  735.     return retVal;
  736. }
  738. HX_RESULT MP4GPayloadFormat::SetSamplingRate(ULONG32 ulSamplesPerSecond)
  739. {
  740.     HX_RESULT retVal = HXR_UNEXPECTED;
  742.     if (!m_bRTPPacketTested)
  743.     {
  744. m_ulSamplesPerSecond = ulSamplesPerSecond;
  745. retVal = HXR_OK;
  746.     }
  747.     
  748.     return retVal;
  749. }
  751. ULONG32 MP4GPayloadFormat::GetTimeBase(void)
  752. {
  753.     return m_ulSamplesPerSecond;
  754. }
  756. HX_RESULT MP4GPayloadFormat::SetAUDuration(ULONG32 ulAUDuration)
  757. {
  758.     HX_RESULT retVal = HXR_OK;
  760.     if (m_Config.m_ulConstantDuration == 0)
  761.     {
  762. CTSConverter tempConverter;
  764. tempConverter.SetBase(m_ulSamplesPerSecond, m_ulRTPSamplesPerSecond);
  765. m_ulAUDuration = tempConverter.ConvertVector(ulAUDuration);
  766.     }
  768.     return retVal;
  769. }
  771. HX_RESULT MP4GPayloadFormat::SetTimeAnchor(ULONG32 ulTimeMs)
  772. {
  773.     CTSConverter tempConverter;
  774.     ULONG32 ulSamplesAnchor;
  775.     ULONG32 ulRTPSamplesAnchor;
  777.     tempConverter.SetBase(1000, m_ulSamplesPerSecond);
  778.     ulSamplesAnchor = tempConverter.ConvertVector(ulTimeMs);
  780.     tempConverter.SetBase(1000, m_ulRTPSamplesPerSecond);
  781.     ulRTPSamplesAnchor = tempConverter.ConvertVector(ulTimeMs);
  783.     m_TSConverter.SetAnchor(ulRTPSamplesAnchor, ulSamplesAnchor);
  785.     return HXR_OK;
  786. }
  788. CMediaPacket* MP4GPayloadFormat::StripPacket(void)
  789. {
  790.     CMediaPacket* pMediaPacket = NULL;
  792.     if (!m_OutputQueue.IsEmpty())
  793.     {
  794. pMediaPacket = (CMediaPacket*) m_OutputQueue.RemoveHead();
  795.     }
  797.     return pMediaPacket;
  798. }
  801. HX_RESULT MP4GPayloadFormat::ProducePackets(void)
  802. {
  803.     BOOL bTryAgain;
  804.     HX_RESULT retVal = HXR_OK;
  806.     do
  807.     {
  808. bTryAgain = FALSE;
  810. retVal = CollectPacketFragments(m_pPacketFragments, // out
  811. m_ulNumPacketFragments, // out
  812. m_ulMaxPacketFragments);// out
  814. if (retVal == HXR_OK)
  815. {
  816.     retVal = ParsePacketFragments(m_pAUFragments,     // out
  817.   m_ulNumAUFragments,     // out
  818.   m_ulMaxAUFragments,     // in/out
  819.   m_pPacketFragments,     // in
  820.   m_ulNumPacketFragments);  // in
  822.     if (retVal == HXR_OK)
  823.     {
  824. retVal = AggregateAUFragments(m_pAUPackets,     // out
  825.       m_ulNumAUPackets,     // out
  826.       m_ulMaxAUPackets,     // in/out
  827.       m_pAUFragments,     // in
  828.       m_ulNumAUFragments);  // in
  829.     }
  831.     bTryAgain = (retVal != HXR_OK);
  833.     if (retVal == HXR_OK)
  834.     {
  835. retVal = DeinterleaveAUPackets(m_pAUPackets,
  836.        m_ulNumAUPackets);
  837.     }
  838. }
  839.     } while (bTryAgain);
  841.     if (SUCCEEDED(retVal))
  842.     {
  843. retVal = ReapMediaPacket(m_ulLastPacketTime);
  844.     }
  846.     return retVal;
  847. }
  850. HX_RESULT MP4GPayloadFormat::CollectPacketFragments(IHXPacket** &pPacketFragments,
  851.     ULONG32 &ulNumPacketFragments,
  852.     ULONG32 &ulMaxPacketFragments)
  853. {
  854.     ULONG32 ulPacketTime;
  855.     IHXPacket* pPacket;
  856.     HX_RESULT retVal = HXR_NO_DATA;
  858.     FlushPacketArray(pPacketFragments, ulNumPacketFragments);
  860.     if (m_ulFrameCount != 0)
  861.     {
  862. pPacket = (IHXPacket*) m_InputQueue.RemoveHead();
  863. pPacketFragments[ulNumPacketFragments++] = pPacket;
  865. if (pPacket->GetASMRuleNumber() == 0)
  866. {
  867.     ulPacketTime = GetPacketTime(pPacket);
  869.     pPacket = (IHXPacket*) m_InputQueue.GetHead();
  871.     while (GetPacketTime(pPacket) == ulPacketTime)
  872.     {
  873. pPacket = (IHXPacket*) m_InputQueue.RemoveHead();
  874. pPacketFragments[ulNumPacketFragments++] = pPacket;
  876. if (pPacket->GetASMRuleNumber() != 0)
  877. {
  878.     // the last fragment carries the M(arker) bit, which is
  879.     // signalled by a rule != 0
  880.     break;
  881. }
  883. pPacket = (IHXPacket*) m_InputQueue.GetHead();
  884.     }
  885. }
  887. HX_ASSERT(ulNumPacketFragments <= ulMaxPacketFragments);
  889. m_ulFrameCount--;
  890. retVal = HXR_OK;
  891.     }
  893.     return retVal;
  894. }
  897. HX_RESULT MP4GPayloadFormat::ParsePacketFragments(CAUPacket** &pAUFragments,
  898.   ULONG32 &ulNumAUFragments,
  899.   ULONG32 &ulMaxAUFragments,
  900.   IHXPacket** pPacketFragments,
  901.   ULONG32& ulNumPacketFragments)
  902. {
  903.     HX_RESULT retVal;
  904.     ULONG32 ulIdx = 0;
  906.     FlushAUArray(pAUFragments, ulNumAUFragments);
  908.     do
  909.     {
  910. retVal = ParsePacketFragment(pAUFragments,
  911.      ulNumAUFragments,
  912.      ulMaxAUFragments,
  913.      pPacketFragments[ulIdx]);
  915. pPacketFragments[ulIdx]->Release();
  916. pPacketFragments[ulIdx] = NULL;
  918. ulIdx++;
  919.     } while ((retVal == HXR_OK) && (ulIdx < ulNumPacketFragments));
  921.     if (ulIdx >= ulNumPacketFragments)
  922.     {
  923. ulNumPacketFragments = 0;
  924.     }
  926.     return retVal;
  927. }
  930. HX_RESULT MP4GPayloadFormat::ParsePacketFragment(CAUPacket** &pAUFragments,
  931.  ULONG32 &ulNumAUFragments,
  932.  ULONG32 &ulMaxAUFragments,
  933.  IHXPacket* pPacketFragment)
  934. {
  935.     ULONG32 ulFirstAUFragment = ulNumAUFragments;
  936.     ULONG32 ulStartCTS = GetPacketTime(pPacketFragment);
  937.     ULONG32 ulCTS = ulStartCTS;
  938.     ULONG32 ulDTS = ulCTS;
  939.     ULONG32 ulIdx = 0;
  940.     ULONG32 ulBaseIdx = 0;
  941.     ULONG32 ulVal = 0;
  942.     ULONG32 ulAUHdrStart = 0;
  943.     ULONG32 ulAUHdrLength = 0; // in bits
  944.     ULONG32 ulAUHdrSize = 0; // in bytes
  945.     ULONG32 ulAuxStart = 0;
  946.     ULONG32 ulAuxLength = 0; // in bits
  947.     ULONG32 ulAuxSize = 0; // in bytes
  948.     ULONG32 ulAUStart = 0;
  949.     ULONG32 ulAUSizeSum = 0;
  950.     ULONG32 ulAUSize = 0;
  951.     ULONG32 ulFixedSizeAUCount = 0;
  952.     IHXBuffer* pBuffer = NULL;
  953.     UINT8* pData = NULL;
  954.     LD bitInfo;
  955.     CAUPacket* pAUPacket = 0;
  956.     BOOL bFirstAU = TRUE;
  957.     HX_RESULT retVal = HXR_FAIL;
  959.     HX_ASSERT(pPacketFragment);
  961.     pBuffer = pPacketFragment->GetBuffer();
  962.     if (pBuffer)
  963.     {
  964. pData = pBuffer->GetBuffer();
  965. if (pData)
  966. {
  967.      retVal = HXR_OK;
  968. }
  969. pBuffer->Release();
  970.     }
  972.     if (retVal == HXR_OK)
  973.     {
  974. // AU-headers-length
  975. if (m_Config.m_bHasAUHeaders)
  976. {
  977.     ulAUHdrLength = (pData[0] << 8) + (pData[1]);
  978.     ulAUHdrSize = ulAUHdrLength / 8;
  979.     if ((ulAUHdrSize * 8) != ulAUHdrLength)
  980.     {
  981. ulAUHdrSize++;
  982.     }
  984.     ulAUHdrStart += 2;
  985. }
  987. if (ulAUHdrLength > 0)
  988. {
  989.     // AU headers are present
  990.     initbuffer(pData + ulAUHdrStart, &bitInfo);
  992.     // AU-headers
  993.     do
  994.     {
  995. pAUPacket = new CAUPacket;
  997. if (!pAUPacket)
  998. {
  999.     retVal = HXR_OUTOFMEMORY;
  1000.     break;
  1001. }
  1003. // Buffer
  1004. pAUPacket->m_pBuffer = pBuffer;
  1005. pBuffer->AddRef();
  1007. // Data
  1008. pAUPacket->m_pData = pData + ulAUSizeSum;
  1010. // AU - size
  1011. if (m_Config.m_ulSizeLength > 0)
  1012. {
  1013.     pAUPacket->m_ulSize = getbits(m_Config.m_ulSizeLength, &bitInfo);
  1014. }
  1015. else
  1016. {
  1017.     pAUPacket->m_ulSize = m_Config.m_ulConstantSize;
  1018. }
  1020. ulAUSizeSum += pAUPacket->m_ulSize;
  1022. // AU - index
  1023. if (bFirstAU)
  1024. {
  1025.     bFirstAU = FALSE;
  1026.     pAUPacket->m_bMinTime = FALSE;
  1028.     if (m_Config.m_ulIndexLength > 0)
  1029.     {
  1030. ulIdx = getbits(m_Config.m_ulIndexLength,
  1031. &bitInfo);
  1032.     }
  1033.     else
  1034.     {
  1035. ulIdx = 0;
  1036.     }
  1038.     ulBaseIdx = ulIdx;
  1039. }
  1040. else
  1041. {
  1042.     pAUPacket->m_bMinTime = TRUE;
  1044.     if (m_Config.m_ulIndexDeltaLength > 0)
  1045.     {
  1046. ulIdx += getbits(m_Config.m_ulIndexDeltaLength,
  1047.  &bitInfo);
  1048.     }
  1050.     ulIdx++;
  1051. }
  1053. pAUPacket->m_ulIdx = ulIdx;
  1055. // CTS
  1056. ulVal = 0;
  1057. if ((m_Config.m_ulCTSDeltaLength > 0) &&
  1058.     getbits1(&bitInfo))
  1059. {
  1060.     ulVal = getbits(m_Config.m_ulCTSDeltaLength, &bitInfo);
  1062.     ulVal = SignBitField(ulVal, m_Config.m_ulCTSDeltaLength);
  1064.     ulVal = m_TSConverter.ConvertVector(ulVal);
  1066.     pAUPacket->m_bMinTime = FALSE;
  1067. }
  1068. else
  1069. {
  1070.     ulVal = (ulIdx - ulBaseIdx) * m_TSConverter.ConvertVector(m_ulAUDuration);
  1071.     pAUPacket->m_bMinTime = (pAUPacket->m_bMinTime &&
  1072.      (ulVal == 0));
  1073. }
  1075. ulCTS = ulStartCTS + ulVal;
  1076. pAUPacket->m_ulCTS = ulCTS;
  1078. // DTS
  1079. ulVal = 0;
  1080. if (m_Config.m_ulDTSDeltaLength > 0)
  1081. {
  1082.     if (getbits1(&bitInfo))
  1083.     {
  1084. ulVal = getbits(m_Config.m_ulDTSDeltaLength, &bitInfo);
  1086. // can be negative value
  1087. if (ulVal >> (m_Config.m_ulDTSDeltaLength - 1))
  1088. {
  1089.     ulVal |= (~((1 << m_Config.m_ulDTSDeltaLength) - 1));
  1090. }
  1092. ulVal = m_TSConverter.ConvertVector(ulVal);
  1093.     }
  1094. }
  1096. ulDTS = ulCTS + ulVal;
  1097. pAUPacket->m_ulDTS = ulDTS;
  1099. pAUFragments[ulNumAUFragments++] = pAUPacket;
  1100.     } while (ulAUHdrLength > ((ULONG32) bitInfo.bitcnt) && ulMaxAUFragments > ulNumAUFragments);
  1101. }
  1102.     }
  1104.     if (retVal == HXR_OK)
  1105.     {
  1106. // auxiliary data length
  1107. ulAuxStart = ulAUHdrStart + ulAUHdrSize;
  1109. ulAuxLength = m_Config.m_ulAuxDataSizeLength;
  1110. if (ulAuxLength > 0)
  1111. {
  1112.     initbuffer(pData + ulAuxStart, &bitInfo);
  1113.     ulAuxLength += getbits(ulAuxLength, &bitInfo);
  1114. }
  1115. ulAuxSize = ulAuxLength / 8;
  1116. if ((ulAuxSize * 8) != ulAuxLength)
  1117. {
  1118.     ulAuxSize++;
  1119. }
  1121. ulAUStart = ulAuxStart + ulAuxSize;
  1123. if (ulAUHdrSize > 0)
  1124. {
  1125.     // AU Headers were present and locations of AUs is
  1126.     // known - just offset the AU location for inserted
  1127.     // auxiliary data
  1128.     for (ulIdx = ulFirstAUFragment; ulIdx < ulNumAUFragments; ulIdx++)
  1129.     {
  1130. pAUFragments[ulIdx]->m_pData += ulAUStart;
  1131.     }
  1132. }
  1133. else
  1134. {
  1135.     // AU Headers are not present - rely on
  1136.     // constant size configuration te determine the
  1137.     // AU offsets
  1138.     ulAUSizeSum = pBuffer->GetSize() - ulAUStart;
  1139.     ulAUSize = m_Config.m_ulConstantSize;
  1141.     if (ulAUSize == 0)
  1142.     {
  1143. ulAUSize = ulAUSizeSum;
  1144.     }
  1146.     if (ulAUSize > 0)
  1147.     {
  1148. if (ulAUSize <= ulAUSizeSum)
  1149. {
  1150.     ulFixedSizeAUCount = ulAUSizeSum / ulAUSize;
  1151. }
  1152. else
  1153. {
  1154.     // this can only happen if we have pre-configured AU sizes,
  1155.     // no AU headers, and this AU has been fragmented.
  1156.     if (ulAUSizeSum != 0)
  1157.     {
  1158. ulFixedSizeAUCount = 1;
  1159.     }
  1160. }
  1162. if (ulFixedSizeAUCount > 0)
  1163. {
  1164.     ulIdx = 0;
  1165.     retVal = HXR_OK;
  1167.     do
  1168.     {
  1169. pAUPacket = new CAUPacket;
  1171. if (!pAUPacket)
  1172. {
  1173.     retVal = HXR_OUTOFMEMORY;
  1174.     break;
  1175. }
  1177. // Buffer
  1178. pAUPacket->m_pBuffer = pBuffer;
  1179. pBuffer->AddRef();
  1181. // Data
  1182. pAUPacket->m_pData = pData + ulAUStart + ulIdx * ulAUSize;
  1184. // AU - size
  1185. pAUPacket->m_ulSize = ulAUSize;
  1187. // AU - index
  1188. pAUPacket->m_ulIdx = ulIdx;
  1190. // CTS
  1191. ulVal = ulIdx * m_TSConverter.ConvertVector(m_ulAUDuration);
  1192. pAUPacket->m_ulCTS = ulStartCTS + ulVal;
  1193. if ((ulVal == 0) && (ulIdx != 0))
  1194. {
  1195.     pAUPacket->m_bMinTime = TRUE;
  1196. }
  1198. // DTS
  1199. pAUPacket->m_ulDTS = pAUPacket->m_ulCTS;
  1201. ulIdx++;
  1202. pAUFragments[ulNumAUFragments++] = pAUPacket;
  1203.     } while (ulIdx < ulFixedSizeAUCount && ulNumAUFragments < ulMaxAUFragments);
  1204. }
  1205.     }
  1206. }
  1207.     }
  1209.     return retVal;
  1210. }
  1213. HX_RESULT MP4GPayloadFormat::AggregateAUFragments(CAUPacket** &pAUPackets,
  1214.   ULONG32 &ulNumAUPackets,
  1215.   ULONG32 &ulMaxAUPackets,
  1216.   CAUPacket** pAUFragments,
  1217.   ULONG32 &ulNumAUFragments)
  1218. {
  1219.     HX_RESULT retVal = HXR_OK;
  1221.     FlushAUArray(pAUPackets, ulNumAUPackets);
  1223.     if (IsFragmentCollection(pAUFragments, ulNumAUFragments))
  1224.     {
  1225. // Compute actual fragment collection size
  1226. ULONG32 ulFragmentyIdx;
  1227. UINT32 ulHeaderSize;
  1228. ULONG32 ulActualCollectionSize = 0;
  1230. for (ulFragmentyIdx = 0;
  1231.      ulFragmentyIdx < ulNumAUFragments;
  1232.      ulFragmentyIdx++)
  1233. {
  1234.     ulHeaderSize = (UINT32) (pAUFragments[ulFragmentyIdx]->m_pData -
  1235.      pAUFragments[ulFragmentyIdx]->m_pBuffer->GetBuffer());
  1236.     ulActualCollectionSize += (pAUFragments[ulFragmentyIdx]->m_pBuffer->GetSize() -
  1237.        ulHeaderSize);
  1238. }
  1240. if (ulActualCollectionSize == pAUFragments[0]->m_ulSize)
  1241. {
  1242.     // All fragments are accounted for - aggregate all
  1243.     IHXBuffer* pBuffer = NULL;
  1244.     CAUPacket* pAUPacket = new CAUPacket;
  1246.     retVal = HXR_OUTOFMEMORY;
  1248.     if (pAUPacket)
  1249.     {
  1250. retVal = HXR_OK;
  1251.     }
  1253.     // Create Buffer
  1254.     if (SUCCEEDED(retVal))
  1255.     {
  1256. retVal = m_pClassFactory->CreateInstance(IID_IHXBuffer,
  1257.  (void**) &pBuffer);
  1258.     }
  1260.     if (SUCCEEDED(retVal))
  1261.     {
  1262. retVal = pBuffer->SetSize(ulActualCollectionSize);
  1263.     }
  1265.     // Aggregate into the Buffer
  1266.     if (SUCCEEDED(retVal))
  1267.     {
  1268. UINT8* pDataWriter = pBuffer->GetBuffer();
  1269. UINT32 ulFragmentSize;
  1271. for (ulFragmentyIdx = 0;
  1272.      ulFragmentyIdx < ulNumAUFragments;
  1273.      ulFragmentyIdx++)
  1274. {
  1275.     ulHeaderSize = (UINT32) (pAUFragments[ulFragmentyIdx]->m_pData -
  1276.      pAUFragments[ulFragmentyIdx]->m_pBuffer->GetBuffer());
  1277.     ulFragmentSize = pAUFragments[ulFragmentyIdx]->m_pBuffer->GetSize() -
  1278.      ulHeaderSize;
  1279.     memcpy(pDataWriter,     /* Flawfinder: ignore */
  1280.    pAUFragments[ulFragmentyIdx]->m_pData,
  1281.    ulFragmentSize);
  1283.     pDataWriter += ulFragmentSize;
  1284. }
  1285.     }
  1287.     // Populate the aggregated AUPacket
  1288.     if (SUCCEEDED(retVal))
  1289.     {
  1290. // Buffer
  1291. pAUPacket->m_pBuffer = pBuffer;
  1292. pBuffer = NULL;
  1294. // Data
  1295. pAUPacket->m_pData = pAUPacket->m_pBuffer->GetBuffer();
  1297. // AU - size
  1298. pAUPacket->m_ulSize = ulActualCollectionSize;
  1300. // AU - index
  1301. pAUPacket->m_ulIdx = pAUFragments[0]->m_ulIdx;
  1303. // CTS
  1304. pAUPacket->m_ulCTS = pAUFragments[0]->m_ulCTS;
  1305. pAUPacket->m_bMinTime = pAUFragments[0]->m_bMinTime;
  1307. // DTS
  1308. pAUPacket->m_ulDTS = pAUFragments[0]->m_ulDTS;
  1310. // Set to output
  1311. pAUPackets[0] = pAUPacket;
  1312. ulNumAUPackets = 1;
  1313. pAUPacket = NULL;
  1314.     }
  1316.     HX_RELEASE(pBuffer);
  1317.     HX_DELETE(pAUPacket);
  1318. }
  1319. else
  1320. {
  1321.     // Something is missing or is corrupted - discard data
  1322.     retVal = HXR_FAIL;
  1323. }
  1325. // Flush the input fragmants
  1326. FlushAUArray(pAUFragments, ulNumAUFragments);
  1327.     }
  1328.     else
  1329.     {
  1330. // No aggregation necessary
  1331. ulNumAUPackets = ulNumAUFragments;
  1332. memcpy(pAUPackets, pAUFragments, sizeof(CAUPacket*) * ulNumAUFragments); /* Flawfinder: ignore */
  1333. memset(pAUFragments, 0, sizeof(CAUPacket*) * ulNumAUFragments);
  1334. ulNumAUFragments = 0;
  1335.     }
  1336.     
  1337.     return retVal;
  1338. }
  1340. BOOL MP4GPayloadFormat::IsFragmentCollection(CAUPacket** pAUFragments,
  1341.      ULONG32 ulNumAUFragments)
  1342. {
  1343.     BOOL bRetVal = FALSE;
  1345.     if (ulNumAUFragments > 0)
  1346.     {
  1347. // Even if we have only one fragment, this could still be a fragment
  1348. // collection in which all but one fragment were lost
  1349. UINT32 ulHeaderSize = (UINT32) (pAUFragments[0]->m_pData -
  1350.         pAUFragments[0]->m_pBuffer->GetBuffer());
  1352. bRetVal = ((ulHeaderSize + pAUFragments[0]->m_ulSize)
  1353.    > pAUFragments[0]->m_pBuffer->GetSize());
  1354.     }
  1356.     return bRetVal;
  1357. }
  1360. HX_RESULT MP4GPayloadFormat::DeinterleaveAUPackets(CAUPacket** pAUPackets,
  1361.    ULONG32 &ulNumAUPackets)
  1362. {
  1363.     ULONG32 ulIdx;
  1364.     HX_RESULT retVal = HXR_OK;
  1366.     for (ulIdx = 0; ulIdx < ulNumAUPackets; ulIdx++)
  1367.     {
  1368. if (SUCCEEDED(DeinterleaveAUPacket(pAUPackets[ulIdx])))
  1369. {
  1370.     pAUPackets[ulIdx] = NULL;
  1371. }
  1372. else
  1373. {
  1374.     HX_DELETE(pAUPackets[ulIdx]);
  1375. }
  1376.     }
  1378.     ulNumAUPackets = 0;
  1380.     return retVal;
  1381. }
  1384. HX_RESULT MP4GPayloadFormat::DeinterleaveAUPacket(CAUPacket* pAUPacket)
  1385. {
  1386.     ULONG32 ulCount = m_DeinterleaveQueue.GetCount();
  1388.     if (ulCount == 0)
  1389.     {
  1390. m_DeinterleaveQueue.AddTail(pAUPacket);
  1391.     }
  1392.     else
  1393.     {
  1394. CAUPacket* pListAUPacket;
  1395. LISTPOSITION lPos = m_DeinterleaveQueue.GetTailPosition();
  1396. LISTPOSITION lInsertPos = lPos;
  1397. ULONG32 ulPrevIdx = 0xFFFFFFFF;
  1398. pListAUPacket = (CAUPacket*) m_DeinterleaveQueue.GetAt(lPos);
  1400. do
  1401. {
  1402.     if (!MayAUPacketPrecede(pAUPacket, pListAUPacket))
  1403.     {
  1404. m_DeinterleaveQueue.InsertAfter(lInsertPos, pAUPacket);
  1405. break;
  1406.     }
  1408.     ulCount--;
  1409.     if (ulCount == 0)
  1410.     {
  1411. CAUPacket lastReapedAUPacket;
  1413. lastReapedAUPacket.m_ulDTS = m_ulLastReapedDTS;
  1414. lastReapedAUPacket.m_ulIdx = m_ulLastReapedIdx;
  1415. lastReapedAUPacket.m_bMinTime = m_bLastReapedMinTime;
  1417. if (m_bLastReapedSet &&
  1418.     MayAUPacketPrecede(&lastReapedAUPacket, pAUPacket))
  1419. {
  1420.     m_DeinterleaveQueue.InsertBefore(lPos, pAUPacket);
  1421. }
  1422. else
  1423. {
  1424.     m_DeinterleaveQueue.InsertAfter(lInsertPos, pAUPacket);
  1425. }
  1426. break;
  1427.     }
  1429.     pListAUPacket = (CAUPacket*) m_DeinterleaveQueue.GetAtPrev(lPos);
  1431.     if (MayAUPacketPrecede(pListAUPacket, pAUPacket))
  1432.     {
  1433. lInsertPos = lPos;
  1434.     }
  1435. } while (TRUE);
  1436.     }
  1438.     return HXR_OK;
  1439. }
  1442. HX_RESULT MP4GPayloadFormat::ReapMediaPacket(ULONG32 ulLastPacketTime)
  1443. {
  1444.     CAUPacket* pAUPacket;
  1445.     CMediaPacket* pMediaPacket;
  1446.     HX_RESULT retVal = HXR_NO_DATA;
  1448.     if (!m_DeinterleaveQueue.IsEmpty())
  1449.     {
  1450. BOOL bTryAgain;
  1451. BOOL bUnknownTime;
  1453. if ((!m_bEarliestDeintTimeKnown) && (!m_bFlushed))
  1454. {
  1455.     m_bEarliestDeintTimeKnown = FindEarliestKnownDeintTime(m_ulEarliestDeintTimeKnown);
  1456. }
  1458. do
  1459. {
  1460.     bTryAgain = FALSE;
  1462.     pAUPacket = (CAUPacket*) m_DeinterleaveQueue.GetHead();
  1464.     if ((m_bEarliestDeintTimeKnown &&
  1465.  (!TestTimeGreater(m_ulEarliestDeintTimeKnown, m_ulLastPacketTime)))
  1466. ||
  1467. (m_bLastReapedSet &&
  1468.  (IndexDiff(pAUPacket->m_ulIdx, m_ulLastReapedIdx) == 1))
  1469. ||
  1470. m_bFlushed)
  1471.     {
  1472. ULONG32 ulFlags = MDPCKT_USES_IHXBUFFER_FLAG;
  1474. pAUPacket = (CAUPacket*) m_DeinterleaveQueue.GetHead();
  1476. bUnknownTime = pAUPacket->m_bMinTime;
  1478. if (bUnknownTime)
  1479. {
  1480.     ulFlags |= MDPCKT_HAS_UKNOWN_TIME_FLAG;
  1481. }
  1482. else
  1483. {
  1484.     m_bEarliestDeintTimeKnown = FALSE;
  1485. }
  1487. if (m_bLastReapedSet)
  1488. {
  1489.     if (IndexDiff(pAUPacket->m_ulIdx, m_ulLastReapedIdx) != 1)
  1490.     {
  1491. ulFlags |= MDPCKT_FOLLOWS_LOSS_FLAG;
  1492.     }
  1493. }
  1495. m_bLastReapedMinTime = pAUPacket->m_bMinTime;
  1496. m_ulLastReapedDTS = pAUPacket->m_ulCTS;
  1497. m_ulLastReapedIdx = pAUPacket->m_ulIdx;
  1498. m_bLastReapedSet = TRUE;
  1500. pMediaPacket = new CMediaPacket(pAUPacket->m_pBuffer,
  1501. pAUPacket->m_pData,
  1502. pAUPacket->m_ulSize,
  1503. pAUPacket->m_ulSize,
  1504. pAUPacket->m_ulCTS,
  1505. ulFlags,
  1506. NULL);
  1508. retVal = HXR_OUTOFMEMORY;
  1509. if (pMediaPacket)
  1510. {
  1511.     m_DeinterleaveQueue.RemoveHead();
  1512.     delete pAUPacket;
  1513.     m_OutputQueue.AddTail(pMediaPacket);
  1514.     bTryAgain = TRUE;
  1515.     retVal = HXR_OK;
  1516. }
  1517.     }
  1518.     else if ((!m_bEarliestDeintTimeKnown) && (!m_bFlushed))
  1519.     {
  1520. m_bEarliestDeintTimeKnown = FindEarliestKnownDeintTime(m_ulEarliestDeintTimeKnown);
  1521. bTryAgain = m_bEarliestDeintTimeKnown;
  1522.     }
  1523. } while (bTryAgain &&
  1524.  (!m_DeinterleaveQueue.IsEmpty()));
  1525.     }
  1527.     return retVal;
  1528. }
  1531. STDMETHODIMP
  1532. MP4GPayloadFormat::Flush()
  1533. {
  1534.     m_bFlushed = TRUE;
  1536.     return HXR_OK;
  1537. }
  1539. void MP4GPayloadFormat::FlushQueues(void)
  1540. {
  1541.     FlushInputQueue(FLUSH_ALL_PACKETS);
  1542.     FlushDeinterleaveQueue(FLUSH_ALL_PACKETS);
  1543.     FlushOutputQueue(FLUSH_ALL_PACKETS);
  1544. }
  1546. void MP4GPayloadFormat::FlushInputQueue(ULONG32 ulCount)
  1547. {
  1548.     IHXPacket* pDeadPacket;
  1550.     while ((ulCount > 0) && (!m_InputQueue.IsEmpty()))
  1551.     {
  1552. pDeadPacket = (IHXPacket*) m_InputQueue.RemoveHead();
  1553. HX_RELEASE(pDeadPacket);
  1554. if (ulCount != FLUSH_ALL_PACKETS)
  1555. {
  1556.     ulCount--;
  1557. }
  1558.     }
  1559. }
  1561. void MP4GPayloadFormat::FlushDeinterleaveQueue(ULONG32 ulCount)
  1562. {
  1563.     CAUPacket* pDeadPacket;
  1565.     while ((ulCount > 0) && (!m_DeinterleaveQueue.IsEmpty()))
  1566.     {
  1567. pDeadPacket = (CAUPacket*) m_DeinterleaveQueue.RemoveHead();
  1568. HX_DELETE(pDeadPacket);
  1569. if (ulCount != FLUSH_ALL_PACKETS)
  1570. {
  1571.     ulCount--;
  1572. }
  1573.     }
  1575.     m_bEarliestDeintTimeKnown = FALSE;
  1576.     m_bLastReapedSet = FALSE;
  1577. }
  1579. void MP4GPayloadFormat::FlushOutputQueue(ULONG32 ulCount)
  1580. {
  1581.     CMediaPacket* pDeadPacket;
  1583.     while ((ulCount > 0) && (!m_OutputQueue.IsEmpty()))
  1584.     {
  1585. pDeadPacket = (CMediaPacket*) m_OutputQueue.RemoveHead();
  1586. HX_DELETE(pDeadPacket);
  1587. if (ulCount != FLUSH_ALL_PACKETS)
  1588. {
  1589.     ulCount--;
  1590. }
  1591.     }
  1592. }
  1594. BOOL MP4GPayloadFormat::FindEarliestKnownDeintTime(ULONG32 &ulEarliestKnownDeintTime)
  1595. {
  1596.     ULONG32 ulCount;
  1597.     LISTPOSITION lPos;
  1598.     CAUPacket* pPacket;
  1600.     ulCount = m_DeinterleaveQueue.GetCount();
  1602.     if (ulCount > 0)
  1603.     {
  1604. lPos = m_DeinterleaveQueue.GetHeadPosition();
  1605. pPacket = (CAUPacket*) m_DeinterleaveQueue.GetHead();
  1607. do
  1608. {
  1609.     if (!pPacket->m_bMinTime)
  1610.     {
  1611. ulEarliestKnownDeintTime = pPacket->m_ulCTS;
  1612. return TRUE;
  1613.     }
  1615.     ulCount--;
  1617.     if (ulCount == 0)
  1618.     {
  1619. break;
  1620.     }
  1622.     pPacket = (CAUPacket*) m_DeinterleaveQueue.GetAtNext(lPos);
  1623. } while (TRUE);
  1624.     }
  1626.     return FALSE;
  1627. }
  1629. void MP4GPayloadFormat::FlushArrays(void)
  1630. {
  1631.     FlushPacketArray(m_pPacketFragments, m_ulNumPacketFragments);
  1632.     FlushAUArray(m_pAUFragments, m_ulNumAUFragments);
  1633.     FlushAUArray(m_pAUPackets, m_ulNumAUPackets);
  1634. }
  1637. ULONG32 MP4GPayloadFormat::GetPacketTime(IHXPacket* pPacket)
  1638. {
  1639.     ULONG32 ulTime;
  1641.     HX_ASSERT(pPacket);
  1643.     if (m_bUsesRTPPackets)
  1644.     {
  1645. ulTime = ((IHXRTPPacket*) pPacket)->GetRTPTime();
  1646.     }
  1647.     else
  1648.     {
  1649. ulTime = pPacket->GetTime();
  1650.     }
  1652.     ulTime = m_TSConverter.Convert(ulTime);
  1654.     return ulTime;
  1655. }
  1658. ULONG32 MP4GPayloadFormat::SignBitField(ULONG32 ulVal, ULONG32 ulNumBits)
  1659. {
  1660.     if (ulNumBits > 0)
  1661.     {
  1662. if (ulVal >> (ulNumBits - 1))
  1663. {
  1664.     ulVal = (0xFFFFFFFF & ulVal);
  1665. }
  1666.     }
  1667.     else
  1668.     {
  1669. ulVal = 0;
  1670.     }
  1672.     return ulVal;
  1673. }
  1676. BOOL MP4GPayloadFormat::TestIndexGreater(ULONG32 ulIdx1, ULONG32 ulIdx2)
  1677. {
  1678.     return (ulIdx1 > ulIdx2);
  1679. }
  1682. BOOL MP4GPayloadFormat::TestTimeGreater(ULONG32 ulTime1, ULONG32 ulTime2)
  1683. {
  1684.     return (((LONG32) (ulTime1 - ulTime2)) > 0);
  1685. }
  1687. LONG32 MP4GPayloadFormat::IndexDiff(ULONG32 ulIdx1, ULONG32 ulIdx2)
  1688. {
  1689.     return SignBitField(ulIdx1 - ulIdx2, m_Config.m_ulIndexLength);
  1690. }