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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
mp4apyld.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：21k
源码类别：

Symbian

开发平台：

Visual C++

mp4apyld.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. /****************************************************************************
  47.  *  Includes
  48.  */
  49. #include "hxtypes.h"
  50. #include "hxwintyp.h"
  51. #include "hxcom.h"
  52. #include "hxcomm.h"
  54. #include "hxassert.h"
  55. #include "hxslist.h"
  56. #include "hxstrutl.h"
  57. #include "hxcomm.h"
  58. #include "ihxpckts.h"
  59. #include "hxformt.h"
  60. #include "hxrendr.h"
  61. #include "hxformt.h"
  62. #include "hxengin.h"
  64. #include "mp4-latm-depack.h"
  66. #include "mp4desc.h"
  67. #include "mp4apyld.h"
  68. #include "mp4pyldutil.h"
  70. MP4APayloadFormat::MP4APayloadFormat()
  71.     : m_lRefCount     (0)
  72.     , m_pClassFactory     (NULL)
  73.     , m_pStreamHeader     (NULL)
  74.     , m_bFlushed     (FALSE)
  75.     , m_bUsesRTPPackets     (FALSE)
  76.     , m_bRTPPacketTested    (FALSE)
  77.     , m_bPacketize     (FALSE)
  78.     , m_pAudioConfig     (NULL)
  79.     , m_ulAudioConfigSize   (0)
  80.     , m_unAudioConfigType   (2)
  81.     , m_ulSamplesPerSecond  (1000)
  82.     , m_ulRTPSamplesPerSecond(0)
  83.     , m_PayloadID     (PYID_X_HX_MP4_RAWAU)
  84.     , m_bPriorLoss     (FALSE)
  85.     , m_pLATMDepack     (NULL)
  86. {
  87.     ;
  88. }
  90. MP4APayloadFormat::~MP4APayloadFormat()
  91. {
  92.     FlushPackets(FLUSH_ALL_PACKETS);
  94.     HX_VECTOR_DELETE(m_pAudioConfig);
  95.     HX_DELETE(m_pLATMDepack);
  96.     HX_RELEASE(m_pClassFactory);
  97.     HX_RELEASE(m_pStreamHeader);
  98. }
  100. HX_RESULT MP4APayloadFormat::Build(REF(IMP4APayloadFormat*) pFmt)
  101. {
  102.     pFmt = new MP4APayloadFormat();
  104.     HX_RESULT res = HXR_OUTOFMEMORY;
  105.     if (pFmt)
  106.     {
  107. pFmt->AddRef();
  108. res = HXR_OK;
  109.     }
  111.     return res;
  112. }
  114. // *** IUnknown methods ***
  116. /////////////////////////////////////////////////////////////////////////
  117. //  Method:
  118. // IUnknown::QueryInterface
  119. //  Purpose:
  120. // Implement this to export the interfaces supported by your
  121. // object.
  122. //
  123. STDMETHODIMP
  124. MP4APayloadFormat::QueryInterface(REFIID riid, void** ppvObj)
  125. {
  126.     QInterfaceList qiList[] =
  127.     {
  128. { GET_IIDHANDLE(IID_IUnknown), this },
  129. { GET_IIDHANDLE(IID_IHXPayloadFormatObject), (IHXPayloadFormatObject*) this },
  130.     };
  131.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  132. }
  134. /////////////////////////////////////////////////////////////////////////
  135. //  Method:
  136. // IUnknown::AddRef
  137. //  Purpose:
  138. // Everyone usually implements this the same... feel free to use
  139. // this implementation.
  140. //
  141. STDMETHODIMP_(ULONG32)
  142. MP4APayloadFormat::AddRef()
  143. {
  144.     return InterlockedIncrement(&m_lRefCount);
  145. }
  147. /////////////////////////////////////////////////////////////////////////
  148. //  Method:
  149. // IUnknown::Release
  150. //  Purpose:
  151. // Everyone usually implements this the same... feel free to use
  152. // this implementation.
  153. //
  154. STDMETHODIMP_(ULONG32)
  155. MP4APayloadFormat::Release()
  156. {
  157.     if (InterlockedDecrement(&m_lRefCount) > 0)
  158.     {
  159.         return m_lRefCount;
  160.     }
  162.     delete this;
  163.     return 0;
  164. }
  167. STDMETHODIMP
  168. MP4APayloadFormat::Init(IUnknown* pContext,
  169. BOOL bPacketize)
  170. {
  171.     HX_RESULT retVal = HXR_OK;
  173.     HX_RELEASE(m_pClassFactory);
  175.     m_bPacketize = bPacketize;
  177.     if (SUCCEEDED(retVal))
  178.     {
  179. retVal = pContext->QueryInterface(IID_IHXCommonClassFactory,
  180.   (void**) &m_pClassFactory);
  181.     }
  183.     return retVal;
  184. }
  186. STDMETHODIMP
  187. MP4APayloadFormat::Reset()
  188. {
  189.     // Release all input packets we have stored
  190.     FlushPackets(FLUSH_ALL_PACKETS);
  192.     m_bFlushed = FALSE;
  193.     m_bPriorLoss = FALSE;
  195.     if (m_pLATMDepack)
  196.     {
  197. m_pLATMDepack->Reset();
  198.     }
  200.     m_TSConverter.Reset();
  202.     return HXR_OK;
  203. }
  205. STDMETHODIMP
  206. MP4APayloadFormat::SetStreamHeader(IHXValues* pHeader)
  207. {
  208.     HX_RESULT retVal;
  210.     if (pHeader)
  211.     {
  212. m_pStreamHeader = pHeader;
  213. m_pStreamHeader->AddRef();
  214.     }
  216.     if (m_bPacketize)
  217.     {
  218. retVal = SetPacketizerHeader(pHeader);
  219.     }
  220.     else
  221.     {
  222. retVal = SetAssemblerHeader(pHeader);
  223.     }
  225.     return retVal;
  226. }
  228. HX_RESULT MP4APayloadFormat::SetPacketizerHeader(IHXValues* pHeader)
  229. {
  230.     return HXR_OK;
  231. }
  233. HX_RESULT MP4APayloadFormat::SetAssemblerHeader(IHXValues* pHeader)
  234. {
  235.     IHXBuffer* pMimeType = NULL;
  236.     const char* pMimeTypeData = NULL;
  237.     HX_RESULT retVal = HXR_INVALID_PARAMETER;
  239.     if (pHeader)
  240.     {
  241. retVal = HXR_OK;
  242.     }
  244.     if (SUCCEEDED(retVal))
  245.     {
  246. retVal = pHeader->GetPropertyCString("MimeType", pMimeType);
  247.     }
  249.     if (SUCCEEDED(retVal))
  250.     {
  251. pMimeTypeData = (char*) pMimeType->GetBuffer();
  253. retVal = HXR_FAIL;
  254. if (pMimeTypeData)
  255. {
  256.     retVal = HXR_OK;
  257. }
  258.     }
  260.     // Determine payload type here based on mime type
  261.     if (SUCCEEDED(retVal))
  262.     {
  263. if (strcasecmp(pMimeTypeData, "audio/X-RN-MP4-RAWAU") == 0)
  264. {
  265.     m_PayloadID = PYID_X_HX_MP4_RAWAU;
  266. }
  267. else if (strcasecmp(pMimeTypeData, "audio/mpeg4-simple-A2") == 0)
  268. {
  269.     m_PayloadID = PYID_MPEG4_SIMPLE_A2;
  270. }
  271. else if (strcasecmp(pMimeTypeData, "audio/MP4A-LATM") == 0)
  272. {
  273.     m_PayloadID = PYID_MP4A_LATM;
  274. }
  275. else if (strcasecmp(pMimeTypeData, "audio/X-HX-AAC-GENERIC") == 0)
  276. {
  277.     m_PayloadID = PYID_X_HX_AAC_GENERIC;
  278. }
  279. else
  280. {
  281.     retVal = HXR_FAIL;
  282. }
  283.     }
  285.     if (SUCCEEDED(retVal))
  286.     {
  287. switch (m_PayloadID)
  288. {
  289. case PYID_X_HX_MP4_RAWAU:
  290.     retVal = SetAssemblerHXHeader(pHeader);
  291.     break;
  292. case PYID_MP4A_LATM:
  293.     retVal = SetAssemblerLATMHeader(pHeader);
  294.     break;
  295. case PYID_X_HX_AAC_GENERIC:
  296.     retVal = SetAssemblerAACGenericHeader(pHeader);
  297.     break;
  298. default:
  299.     retVal = HXR_NOTIMPL;
  300.     break;
  301. }
  302.     }
  304.     if (SUCCEEDED(retVal))
  305.     {
  306. m_ulSamplesPerSecond = 0;
  307. m_pStreamHeader->GetPropertyULONG32("SamplesPerSecond",
  308.     m_ulRTPSamplesPerSecond);
  309.     }
  311.     HX_RELEASE(pMimeType);
  313.     return retVal;
  314. }
  316. HX_RESULT MP4APayloadFormat::SetAssemblerAACGenericHeader(IHXValues* pHeader)
  317. {
  318.     IHXBuffer *pBuffer = NULL;
  319.     UCHAR *pBuf = NULL;
  320.     HX_RESULT retVal = HXR_FAIL;
  322.     retVal = m_pStreamHeader->GetPropertyBuffer("OpaqueData",
  323. pBuffer);
  324.     if (SUCCEEDED(retVal))
  325.     {
  326.         m_pAudioConfig = NULL;
  327.         m_ulAudioConfigSize = pBuffer->GetSize();
  328.         if (m_ulAudioConfigSize)
  329.         {
  330.             pBuf = pBuffer->GetBuffer();
  331.             m_unAudioConfigType = pBuf[0];
  332.             if (--m_ulAudioConfigSize)
  333.             {
  334.                 m_pAudioConfig = new UINT8[m_ulAudioConfigSize];
  335.                 if (!m_pAudioConfig)
  336.                 {
  337.                     retVal = HXR_OUTOFMEMORY;
  338.                 }
  339.                 else
  340.                 {
  341.                     memcpy(m_pAudioConfig, &pBuf[1], m_ulAudioConfigSize);
  342.                 }
  343.             }
  344.         }
  345.         else
  346.         {
  347.             m_unAudioConfigType = 0; 
  348.         }
  349.     }
  350.     HX_RELEASE(pBuffer);
  351.     return retVal;
  352. }
  354. HX_RESULT MP4APayloadFormat::SetAssemblerHXHeader(IHXValues* pHeader)
  355. {
  356.     ES_Descriptor ESDesc;
  357.     DecoderConfigDescriptor* pDCDesc = NULL;
  358.     DecoderSpecifcInfo* pDSIDesc = NULL;
  359.     IHXBuffer* pESDescriptor = NULL;
  361.     UINT8* pESDescData;
  362.     ULONG32 ulESDescSize;
  364.     HX_RESULT retVal = HXR_OK;
  366.     HX_VECTOR_DELETE(m_pAudioConfig);
  367.     m_ulAudioConfigSize = 0;
  369.     retVal = m_pStreamHeader->GetPropertyBuffer("OpaqueData",
  370. pESDescriptor);
  372.     if (SUCCEEDED(retVal))
  373.     {
  374. retVal = HXR_INVALID_PARAMETER;
  375. if (pESDescriptor)
  376. {
  377.     retVal = HXR_OK;
  378. }
  379.     }
  381.     if (SUCCEEDED(retVal))
  382.     {
  383. pESDescData = pESDescriptor->GetBuffer();
  384. ulESDescSize = pESDescriptor->GetSize();
  386. retVal = ESDesc.Unpack(pESDescData, ulESDescSize);
  387.     }
  389.     HX_RELEASE(pESDescriptor);
  391.     if (SUCCEEDED(retVal))
  392.     {
  393. retVal = HXR_FAIL;
  394. pDCDesc = ESDesc.m_pDecConfigDescr;
  396. if (pDCDesc)
  397. {
  398.     pDSIDesc = pDCDesc->m_pDecSpecificInfo;
  399.     retVal = HXR_OK;
  400. }
  401.     }
  403.     if (SUCCEEDED(retVal) && pDSIDesc)
  404.     {
  405. m_ulAudioConfigSize = pDSIDesc->m_ulLength;
  407. if (m_ulAudioConfigSize > 0)
  408. {
  409.     m_pAudioConfig = new UINT8 [m_ulAudioConfigSize];
  411.     if (m_pAudioConfig == NULL)
  412.     {
  413. m_ulAudioConfigSize = 0;
  414. retVal = HXR_OUTOFMEMORY;
  415.     }
  416. }
  417.     }
  419.     if (SUCCEEDED(retVal))
  420.     {
  421. if (m_ulAudioConfigSize > 0)
  422. {
  423.     memcpy(m_pAudioConfig, pDSIDesc->m_pData, m_ulAudioConfigSize); /* Flawfinder: ignore */
  424. }
  425.     }
  427.     return retVal;
  428. }
  430. HX_RESULT MP4APayloadFormat::SetAssemblerLATMHeader(IHXValues* pHeader)
  431. {
  432.     HX_RESULT retVal = SetAssemblerLATMConfig(pHeader);
  434.     if (SUCCEEDED(retVal))
  435.     {
  436. m_pStreamHeader->GetPropertyULONG32("SamplesPerSecond",
  437.     m_ulRTPSamplesPerSecond);
  438.     }
  440.     return retVal;
  441. }
  443. HX_RESULT MP4APayloadFormat::SetAssemblerLATMConfig(IHXValues* pFMTParams)
  444. {
  445.     IHXBuffer* pConfigBuffer = NULL;
  446.     ULONG32 ulObject = 0;
  447.     ULONG32 ulProfileID = 0;
  448.     ULONG32 ulBitrate = 0;
  449.     ULONG32 bConfigPresent = TRUE;
  450.     HX_RESULT retVal = HXR_OK;
  452.     HX_ASSERT(pFMTParams);
  454.     // Obtain Required parameters
  455.     retVal = CHXMP4PayloadUtil::GetFMTPConfig(pFMTParams, m_pClassFactory,
  456.       pConfigBuffer);
  458.     // Obtain optional parameters
  459.     if (SUCCEEDED(retVal))
  460.     {
  461. ULONG32 ulVal = 0;
  463. pFMTParams->GetPropertyULONG32("FMTPobject", ulObject);
  464. pFMTParams->GetPropertyULONG32("FMTPprofile-level-id", ulProfileID);
  465. if (SUCCEEDED(pFMTParams->GetPropertyULONG32("FMTPcpresent", ulVal)))
  466. {
  467.     bConfigPresent = (ulVal != 0);
  468. }
  469. pFMTParams->GetPropertyULONG32("FMTPbitrate", ulBitrate);
  470.     }
  472.     // Create and initialize the MP4A-LATM depacketizer
  473.     if (SUCCEEDED(retVal))
  474.     {
  475. HX_DELETE(m_pLATMDepack);
  476. m_pLATMDepack = new MP4LATMDepack;
  478. retVal = HXR_OUTOFMEMORY;
  479. if (m_pLATMDepack)
  480. {
  481.     retVal = HXR_OK;
  482. }
  483.     }
  485.     if (SUCCEEDED(retVal))
  486.     {
  487. UINT8* pStreamMuxConfig = NULL;
  488. ULONG32 ulMuxConfigSize = 0;
  489. const UINT8* pCodecConfig = NULL;
  490. ULONG32 ulConfigSize = 0;
  493. if (pConfigBuffer)
  494. {
  495.     pStreamMuxConfig = pConfigBuffer->GetBuffer();
  496.     ulMuxConfigSize = pConfigBuffer->GetSize();
  497. }
  499. retVal = HXR_FAIL;
  500. if (m_pLATMDepack->Init(ulProfileID,
  501. ulObject,
  502. ulBitrate,
  503. bConfigPresent,
  504. pStreamMuxConfig,
  505. ulMuxConfigSize,
  506. OnFrameCallback,
  507. this))
  508. {
  509.     retVal = HXR_OK;
  510. }
  512. if (SUCCEEDED(retVal))
  513. {
  514.     if (!m_pLATMDepack->GetCodecConfig(pCodecConfig,
  515.        ulConfigSize))
  516.     {
  517. pCodecConfig = NULL;
  518. ulConfigSize = 0;
  519.     }
  520. }
  522. if (SUCCEEDED(retVal))
  523. {
  524.     m_ulAudioConfigSize = ulConfigSize;
  526.     if (m_ulAudioConfigSize > 0)
  527.     {
  528. m_pAudioConfig = new UINT8 [m_ulAudioConfigSize];
  530. if (m_pAudioConfig == NULL)
  531. {
  532.     m_ulAudioConfigSize = 0;
  533.     retVal = HXR_OUTOFMEMORY;
  534. }
  535.     }
  536. }
  538. if (SUCCEEDED(retVal))
  539. {
  540.     if (m_ulAudioConfigSize > 0)
  541.     {
  542. memcpy(m_pAudioConfig, pCodecConfig, m_ulAudioConfigSize); /* Flawfinder: ignore */
  543.     }
  544. }
  545.     }
  547.     HX_RELEASE(pConfigBuffer);
  549.     return retVal;
  550. }
  552. STDMETHODIMP
  553. MP4APayloadFormat::GetStreamHeader(REF(IHXValues*) pHeader)
  554. {
  555.     HX_RESULT retVal = HXR_FAIL;
  557.     if (m_pStreamHeader)
  558.     {
  559. retVal = HXR_OK;
  560. pHeader = m_pStreamHeader;
  561. pHeader->AddRef();
  562.     }
  564.     return retVal;
  565. }
  567. STDMETHODIMP
  568. MP4APayloadFormat::SetPacket(IHXPacket* pPacket)
  569. {
  570.     HX_RESULT retVal = HXR_OK;
  572.     HX_ASSERT(pPacket);
  574.     if (!m_bRTPPacketTested)
  575.     {
  576. IHXRTPPacket* pRTPPacket = NULL;
  578. m_bUsesRTPPackets = (pPacket->QueryInterface(
  579. IID_IHXRTPPacket,
  580. (void**) &pRTPPacket)
  581.     == HXR_OK);
  583. m_bRTPPacketTested = TRUE;
  585. HX_RELEASE(pRTPPacket);
  587. if (m_bUsesRTPPackets)
  588. {
  589.     if (m_ulRTPSamplesPerSecond == 0)
  590.     {
  591. m_ulRTPSamplesPerSecond = m_ulSamplesPerSecond;
  592.     }
  593. }
  594. else
  595. {
  596.     m_ulRTPSamplesPerSecond = 1000; // RDT time stamp
  597. }
  599. m_TSConverter.SetBase(m_ulRTPSamplesPerSecond,
  600.       m_ulSamplesPerSecond);
  601.     }
  603.     // Add this packet to our list of input packets
  604.     switch (m_PayloadID)
  605.     {
  606.     case PYID_X_HX_AAC_GENERIC:
  607.     case PYID_X_HX_MP4_RAWAU:
  608. pPacket->AddRef();
  609. m_InputPackets.AddTail(pPacket);
  610. break;
  612.     case PYID_MP4A_LATM:
  613. retVal = HXR_FAIL;
  614. if (m_pLATMDepack)
  615. {
  616.     if (pPacket->IsLost())
  617.     {
  618. if (m_pLATMDepack->OnLoss(1))
  619. {
  620.     retVal = HXR_OK;
  621. }
  622.     }
  623.     else
  624.     {
  625. IHXBuffer* pBuffer = pPacket->GetBuffer();
  627. if (pBuffer &&
  628.     m_pLATMDepack->OnPacket(GetPacketTime(pPacket),
  629.     pBuffer->GetBuffer(),
  630.     pBuffer->GetSize(),
  631.     (pPacket->GetASMRuleNumber() == 1)))
  632. {
  633.     retVal = HXR_OK;
  635.     pBuffer->Release();
  636. }
  637.     }
  638. }
  639. break;
  641.     default:
  642. retVal = HXR_NOTIMPL;
  643. break;
  644.     }
  646.     return retVal;
  647. }
  649. STDMETHODIMP
  650. MP4APayloadFormat::GetPacket(REF(IHXPacket*) pOutPacket)
  651. {
  652.     HX_RESULT retVal = HXR_OK;
  654.     if (m_bPacketize)
  655.     {
  656. retVal = GetPacketizerPacket(pOutPacket);
  657.     }
  658.     else
  659.     {
  660. retVal = GetAssemblerPacket(pOutPacket);
  661.     }
  663.     return retVal;
  664. }
  666. HX_RESULT MP4APayloadFormat::GetPacketizerPacket(IHXPacket* &pOutPacket)
  667. {
  668.     HX_RESULT retVal = HXR_INCOMPLETE;
  670.     if (!m_InputPackets.IsEmpty())
  671.     {
  672. pOutPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  673. retVal = HXR_OK;
  674.     }
  675.     else if (m_bFlushed)
  676.     {
  677. retVal = HXR_STREAM_DONE;
  678.     }
  680.     return retVal;
  681. }
  683. HX_RESULT MP4APayloadFormat::GetAssemblerPacket(IHXPacket* &pOutPacket)
  684. {
  685.     HX_RESULT retVal = HXR_NOTIMPL;
  687.     return retVal;
  688. }
  690. HX_RESULT MP4APayloadFormat::SetSamplingRate(ULONG32 ulSamplesPerSecond)
  691. {
  692.     HX_RESULT retVal = HXR_UNEXPECTED;
  694.     if (!m_bRTPPacketTested)
  695.     {
  696. m_ulSamplesPerSecond = ulSamplesPerSecond;
  697. retVal = HXR_OK;
  698.     }
  700.     return HXR_OK;
  701. }
  703. ULONG32 MP4APayloadFormat::GetTimeBase(void)
  704. {
  705.     return m_ulSamplesPerSecond;
  706. }
  708. HX_RESULT MP4APayloadFormat::SetAUDuration(ULONG32 ulAUDuration)
  709. {
  710.     HX_RESULT retVal = HXR_UNEXPECTED;
  712.     if (!m_bRTPPacketTested)
  713.     {
  714. switch (m_PayloadID)
  715. {
  716. case PYID_MP4A_LATM:
  717.     retVal = HXR_FAIL;
  718.     
  719.     if (m_pLATMDepack &&
  720. m_pLATMDepack->SetFrameDuration(ulAUDuration))
  721.     {
  722. retVal = HXR_OK;
  723.     }
  724.     break;
  725.     
  726. default:
  727.     retVal = HXR_NOTIMPL;
  728.     break;
  729. }
  730.     }
  732.     return retVal;
  733. }
  735. HX_RESULT MP4APayloadFormat::SetTimeAnchor(ULONG32 ulTimeMs)
  736. {
  737.     CTSConverter tempConverter;
  738.     ULONG32 ulSamplesAnchor;
  739.     ULONG32 ulRTPSamplesAnchor;
  741.     tempConverter.SetBase(1000, m_ulSamplesPerSecond);
  742.     ulSamplesAnchor = tempConverter.ConvertVector(ulTimeMs);
  744.     tempConverter.SetBase(1000, m_ulRTPSamplesPerSecond);
  745.     ulRTPSamplesAnchor = tempConverter.ConvertVector(ulTimeMs);
  747.     m_TSConverter.SetAnchor(ulRTPSamplesAnchor, ulSamplesAnchor);
  749.     return HXR_OK;
  750. }
  752. HX_RESULT MP4APayloadFormat::CreateMediaPacket(CMediaPacket* &pOutMediaPacket)
  753. {
  754.     HX_RESULT retVal = HXR_OK;
  756.     switch (m_PayloadID)
  757.     {
  758.     case PYID_X_HX_AAC_GENERIC:
  759.     case PYID_X_HX_MP4_RAWAU:
  760. retVal = CreateRawAUMediaPacket(pOutMediaPacket);
  761. break;
  763.     case PYID_MP4A_LATM:
  764. if (m_OutMediaPacketQueue.IsEmpty())
  765. {
  766.     if (m_bFlushed)
  767.     {
  768. // We have used up all available input
  769. retVal = HXR_STREAM_DONE;
  770.     }
  771.     else
  772.     {
  773. // We don't have enough input
  774. // data to produce a packet
  775. retVal = HXR_INCOMPLETE;
  776.     }
  777. }
  778. else
  779. {
  780.     pOutMediaPacket = (CMediaPacket*) m_OutMediaPacketQueue.RemoveHead();
  781. }
  782. break;
  784.     default:
  785. retVal = HXR_NOTIMPL;
  786. break;
  787.     }
  789.     return retVal;
  790. }
  792. HX_RESULT MP4APayloadFormat::OnFrame(ULONG32 ulTime,
  793.      const UINT8* pData,
  794.      ULONG32 ulSize,
  795.      BOOL bPreviousLoss)
  796. {
  797.     ULONG32 ulFlags = 0;
  798.     CMediaPacket* pMediaPacket = NULL;
  799.     HX_RESULT retVal = HXR_OK;
  801.     if (pData && (ulSize != 0))
  802.     {
  803. ULONG32 ulNewSize;
  805. if (bPreviousLoss)
  806. {
  807.     ulFlags |= MDPCKT_FOLLOWS_LOSS_FLAG;
  808. }
  810. #ifdef _OVERALLOC_CODEC_DATA
  811. ulNewSize = ulSize + _OVERALLOC_CODEC_DATA;
  812. #else // _OVERALLOC_CODEC_DATA
  813. ulNewSize = ulSize;
  814. #endif // _OVERALLOC_CODEC_DATA
  816. UINT8* pNewData = new UINT8 [ulNewSize];
  818. if (pData)
  819. {
  820.     memcpy(pNewData, pData, ulSize); /* Flawfinder: ignore */
  822.     pMediaPacket = new CMediaPacket(pNewData,
  823.     pNewData,
  824.     ulNewSize,
  825.     ulSize,
  826.     ulTime,
  827.     ulFlags,
  828.     NULL);
  829. }
  830.     }
  832.     if (pMediaPacket)
  833.     {
  834. m_OutMediaPacketQueue.AddTail(pMediaPacket);
  835.     }
  837.     return retVal;
  838. }
  840. void MP4APayloadFormat::OnFrameCallback(void* pUserData,
  841. ULONG32 ulTime,
  842. const UINT8* pData,
  843. ULONG32 ulSize,
  844. BOOL bPreviousLoss)
  845. {
  846.     MP4APayloadFormat* pObject = (MP4APayloadFormat*) pUserData;
  848.     pObject->OnFrame(ulTime, pData, ulSize, bPreviousLoss);
  849. }
  851. HX_RESULT MP4APayloadFormat::CreateRawAUMediaPacket(CMediaPacket* &pOutMediaPacket)
  852. {
  853.     CMediaPacket* pMediaPacket;
  854.     IHXPacket* pPacket = NULL;
  855.     HX_RESULT retVal = HXR_OK;
  857.     if (m_InputPackets.IsEmpty())
  858.     {
  859. if (m_bFlushed)
  860. {
  861.     // We have used up all available input
  862.     retVal = HXR_STREAM_DONE;
  863. }
  864. else
  865. {
  866.     // We don't have enough input
  867.     // data to produce a packet
  868.     retVal = HXR_INCOMPLETE;
  869. }
  870.     }
  871.     else
  872.     {
  873. ULONG32 ulFlags = MDPCKT_USES_IHXBUFFER_FLAG;
  874. IHXBuffer* pBuffer = NULL;
  875. pPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  877. if (!pPacket->IsLost())
  878. {
  879.     pBuffer = pPacket->GetBuffer();
  881.     if (pBuffer)
  882.     {
  883. if (m_bPriorLoss)
  884. {
  885.     ulFlags |= MDPCKT_FOLLOWS_LOSS_FLAG;
  886.     m_bPriorLoss = FALSE;
  887. }
  889. pMediaPacket = BuildMediaPacket(pBuffer,
  890. GetPacketTime(pPacket),
  891. ulFlags);
  893. retVal = HXR_OUTOFMEMORY;
  894. if (pMediaPacket)
  895. {
  896.     pOutMediaPacket = pMediaPacket;
  897.     retVal = HXR_OK;
  898. }
  900. pBuffer->Release();
  901.     }
  902.     else
  903.     {
  904. m_bPriorLoss = TRUE;
  905. retVal = HXR_INCOMPLETE;
  906.     }
  908.     pPacket->Release();
  909. }
  910. else
  911. {
  912.     m_bPriorLoss = TRUE;
  913.     retVal = HXR_INCOMPLETE;
  914. }
  915.     }
  917.     return retVal;
  918. }
  921. CMediaPacket* MP4APayloadFormat::BuildMediaPacket(IHXBuffer* pBuffer,
  922.   ULONG32 ulTime,
  923.   ULONG32 ulFlags)
  924. {
  925.     CMediaPacket* pMediaPacket = NULL;
  926. #ifdef _OVERALLOC_CODEC_DATA
  927.     UINT8* pData = new UINT8 [pBuffer->GetSize() + _OVERALLOC_CODEC_DATA];
  929.     if (pData)
  930.     {
  931. memcpy(pData, pBuffer->GetBuffer(), pBuffer->GetSize()); /* Flawfinder: ignore */
  933. ulFlags &= (~MDPCKT_USES_IHXBUFFER_FLAG);
  934. pMediaPacket = new CMediaPacket(pData,
  935. pData,
  936. pBuffer->GetSize() + 3,
  937. pBuffer->GetSize(),
  938. ulTime,
  939. ulFlags,
  940. NULL);
  941.     }
  942. #else // _OVERALLOC_CODEC_DATA
  943.     pMediaPacket = new CMediaPacket(pBuffer,
  944.     pBuffer->GetBuffer(),
  945.     pBuffer->GetSize(),
  946.     pBuffer->GetSize(),
  947.     ulTime,
  948.     ulFlags,
  949.     NULL);
  951. #endif // _OVERALLOC_CODEC_DATA
  953.     return pMediaPacket;
  954. }
  956. STDMETHODIMP
  957. MP4APayloadFormat::Flush()
  958. {
  959.     if (m_pLATMDepack)
  960.     {
  961. m_pLATMDepack->Flush();
  962.     }
  964.     m_bFlushed = TRUE;
  966.     return HXR_OK;
  967. }
  969. void MP4APayloadFormat::FlushPackets(ULONG32 ulCount)
  970. {
  971.     IHXPacket* pDeadPacket;
  972.     CMediaPacket* pDeadMediaPacket;
  974.     while ((ulCount > 0) && (!m_InputPackets.IsEmpty()))
  975.     {
  976. pDeadPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  977. HX_RELEASE(pDeadPacket);
  978. if (ulCount != FLUSH_ALL_PACKETS)
  979. {
  980.     ulCount--;
  981. }
  982.     }
  984.     while ((ulCount > 0) && (!m_OutMediaPacketQueue.IsEmpty()))
  985.     {
  986. pDeadMediaPacket = (CMediaPacket*) m_OutMediaPacketQueue.RemoveHead();
  987. HX_DELETE(pDeadMediaPacket);
  988. if (ulCount != FLUSH_ALL_PACKETS)
  989. {
  990.     ulCount--;
  991. }
  992.     }
  993. }
  995. ULONG32 MP4APayloadFormat::GetPacketTime(IHXPacket* pPacket)
  996. {
  997.     ULONG32 ulTime;
  999.     HX_ASSERT(pPacket);
  1001.     if (m_bUsesRTPPackets)
  1002.     {
  1003. ulTime = ((IHXRTPPacket*) pPacket)->GetRTPTime();
  1004.     }
  1005.     else
  1006.     {
  1007. ulTime = pPacket->GetTime();
  1008.     }
  1010.     ulTime = m_TSConverter.Convert(ulTime);
  1012.     return ulTime;
  1013. }