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

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

Symbian

开发平台：

C/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.     return retVal;
  351. }
  353. HX_RESULT MP4APayloadFormat::SetAssemblerHXHeader(IHXValues* pHeader)
  354. {
  355.     ES_Descriptor ESDesc;
  356.     DecoderConfigDescriptor* pDCDesc = NULL;
  357.     DecoderSpecifcInfo* pDSIDesc = NULL;
  358.     IHXBuffer* pESDescriptor = NULL;
  360.     UINT8* pESDescData;
  361.     ULONG32 ulESDescSize;
  363.     HX_RESULT retVal = HXR_OK;
  365.     HX_VECTOR_DELETE(m_pAudioConfig);
  366.     m_ulAudioConfigSize = 0;
  368.     retVal = m_pStreamHeader->GetPropertyBuffer("OpaqueData",
  369. pESDescriptor);
  371.     if (SUCCEEDED(retVal))
  372.     {
  373. retVal = HXR_INVALID_PARAMETER;
  374. if (pESDescriptor)
  375. {
  376.     retVal = HXR_OK;
  377. }
  378.     }
  380.     if (SUCCEEDED(retVal))
  381.     {
  382. pESDescData = pESDescriptor->GetBuffer();
  383. ulESDescSize = pESDescriptor->GetSize();
  385. retVal = ESDesc.Unpack(pESDescData, ulESDescSize);
  386.     }
  388.     HX_RELEASE(pESDescriptor);
  390.     if (SUCCEEDED(retVal))
  391.     {
  392. retVal = HXR_FAIL;
  393. pDCDesc = ESDesc.m_pDecConfigDescr;
  395. if (pDCDesc)
  396. {
  397.     pDSIDesc = pDCDesc->m_pDecSpecificInfo;
  398.     retVal = HXR_OK;
  399. }
  400.     }
  402.     if (SUCCEEDED(retVal) && pDSIDesc)
  403.     {
  404. m_ulAudioConfigSize = pDSIDesc->m_ulLength;
  406. if (m_ulAudioConfigSize > 0)
  407. {
  408.     m_pAudioConfig = new UINT8 [m_ulAudioConfigSize];
  410.     if (m_pAudioConfig == NULL)
  411.     {
  412. m_ulAudioConfigSize = 0;
  413. retVal = HXR_OUTOFMEMORY;
  414.     }
  415. }
  416.     }
  418.     if (SUCCEEDED(retVal))
  419.     {
  420. if (m_ulAudioConfigSize > 0)
  421. {
  422.     memcpy(m_pAudioConfig, pDSIDesc->m_pData, m_ulAudioConfigSize); /* Flawfinder: ignore */
  423. }
  424.     }
  426.     return retVal;
  427. }
  429. HX_RESULT MP4APayloadFormat::SetAssemblerLATMHeader(IHXValues* pHeader)
  430. {
  431.     HX_RESULT retVal = SetAssemblerLATMConfig(pHeader);
  433.     if (SUCCEEDED(retVal))
  434.     {
  435. m_pStreamHeader->GetPropertyULONG32("SamplesPerSecond",
  436.     m_ulRTPSamplesPerSecond);
  437.     }
  439.     return retVal;
  440. }
  442. HX_RESULT MP4APayloadFormat::SetAssemblerLATMConfig(IHXValues* pFMTParams)
  443. {
  444.     IHXBuffer* pConfigBuffer = NULL;
  445.     ULONG32 ulObject = 0;
  446.     ULONG32 ulProfileID = 0;
  447.     ULONG32 ulBitrate = 0;
  448.     ULONG32 bConfigPresent = TRUE;
  449.     HX_RESULT retVal = HXR_OK;
  451.     HX_ASSERT(pFMTParams);
  453.     // Obtain Required parameters
  454.     retVal = CHXMP4PayloadUtil::GetFMTPConfig(pFMTParams, m_pClassFactory,
  455.       pConfigBuffer);
  457.     // Obtain optional parameters
  458.     if (SUCCEEDED(retVal))
  459.     {
  460. ULONG32 ulVal = 0;
  462. pFMTParams->GetPropertyULONG32("FMTPobject", ulObject);
  463. pFMTParams->GetPropertyULONG32("FMTPprofile-level-id", ulProfileID);
  464. if (SUCCEEDED(pFMTParams->GetPropertyULONG32("FMTPcpresent", ulVal)))
  465. {
  466.     bConfigPresent = (ulVal != 0);
  467. }
  468. pFMTParams->GetPropertyULONG32("FMTPbitrate", ulBitrate);
  469.     }
  471.     // Create and initialize the MP4A-LATM depacketizer
  472.     if (SUCCEEDED(retVal))
  473.     {
  474. HX_DELETE(m_pLATMDepack);
  475. m_pLATMDepack = new MP4LATMDepack;
  477. retVal = HXR_OUTOFMEMORY;
  478. if (m_pLATMDepack)
  479. {
  480.     retVal = HXR_OK;
  481. }
  482.     }
  484.     if (SUCCEEDED(retVal))
  485.     {
  486. UINT8* pStreamMuxConfig = NULL;
  487. ULONG32 ulMuxConfigSize = 0;
  488. const UINT8* pCodecConfig = NULL;
  489. ULONG32 ulConfigSize = 0;
  492. if (pConfigBuffer)
  493. {
  494.     pStreamMuxConfig = pConfigBuffer->GetBuffer();
  495.     ulMuxConfigSize = pConfigBuffer->GetSize();
  496. }
  498. retVal = HXR_FAIL;
  499. if (m_pLATMDepack->Init(ulProfileID,
  500. ulObject,
  501. ulBitrate,
  502. bConfigPresent,
  503. pStreamMuxConfig,
  504. ulMuxConfigSize,
  505. OnFrameCallback,
  506. this))
  507. {
  508.     retVal = HXR_OK;
  509. }
  511. if (SUCCEEDED(retVal))
  512. {
  513.     if (!m_pLATMDepack->GetCodecConfig(pCodecConfig,
  514.        ulConfigSize))
  515.     {
  516. pCodecConfig = NULL;
  517. ulConfigSize = 0;
  518.     }
  519. }
  521. if (SUCCEEDED(retVal))
  522. {
  523.     m_ulAudioConfigSize = ulConfigSize;
  525.     if (m_ulAudioConfigSize > 0)
  526.     {
  527. m_pAudioConfig = new UINT8 [m_ulAudioConfigSize];
  529. if (m_pAudioConfig == NULL)
  530. {
  531.     m_ulAudioConfigSize = 0;
  532.     retVal = HXR_OUTOFMEMORY;
  533. }
  534.     }
  535. }
  537. if (SUCCEEDED(retVal))
  538. {
  539.     if (m_ulAudioConfigSize > 0)
  540.     {
  541. memcpy(m_pAudioConfig, pCodecConfig, m_ulAudioConfigSize); /* Flawfinder: ignore */
  542.     }
  543. }
  544.     }
  546.     HX_RELEASE(pConfigBuffer);
  548.     return retVal;
  549. }
  551. STDMETHODIMP
  552. MP4APayloadFormat::GetStreamHeader(REF(IHXValues*) pHeader)
  553. {
  554.     HX_RESULT retVal = HXR_FAIL;
  556.     if (m_pStreamHeader)
  557.     {
  558. retVal = HXR_OK;
  559. pHeader = m_pStreamHeader;
  560. pHeader->AddRef();
  561.     }
  563.     return retVal;
  564. }
  566. STDMETHODIMP
  567. MP4APayloadFormat::SetPacket(IHXPacket* pPacket)
  568. {
  569.     HX_RESULT retVal = HXR_OK;
  571.     HX_ASSERT(pPacket);
  573.     if (!m_bRTPPacketTested)
  574.     {
  575. IHXRTPPacket* pRTPPacket = NULL;
  577. m_bUsesRTPPackets = (pPacket->QueryInterface(
  578. IID_IHXRTPPacket,
  579. (void**) &pRTPPacket)
  580.     == HXR_OK);
  582. m_bRTPPacketTested = TRUE;
  584. HX_RELEASE(pRTPPacket);
  586. if (m_bUsesRTPPackets)
  587. {
  588.     if (m_ulRTPSamplesPerSecond == 0)
  589.     {
  590. m_ulRTPSamplesPerSecond = m_ulSamplesPerSecond;
  591.     }
  592. }
  593. else
  594. {
  595.     m_ulRTPSamplesPerSecond = 1000; // RDT time stamp
  596. }
  598. m_TSConverter.SetBase(m_ulRTPSamplesPerSecond,
  599.       m_ulSamplesPerSecond);
  600.     }
  602.     // Add this packet to our list of input packets
  603.     switch (m_PayloadID)
  604.     {
  605.     case PYID_X_HX_AAC_GENERIC:
  606.     case PYID_X_HX_MP4_RAWAU:
  607. pPacket->AddRef();
  608. m_InputPackets.AddTail(pPacket);
  609. break;
  611.     case PYID_MP4A_LATM:
  612. retVal = HXR_FAIL;
  613. if (m_pLATMDepack)
  614. {
  615.     if (pPacket->IsLost())
  616.     {
  617. if (m_pLATMDepack->OnLoss(1))
  618. {
  619.     retVal = HXR_OK;
  620. }
  621.     }
  622.     else
  623.     {
  624. IHXBuffer* pBuffer = pPacket->GetBuffer();
  626. if (pBuffer &&
  627.     m_pLATMDepack->OnPacket(GetPacketTime(pPacket),
  628.     pBuffer->GetBuffer(),
  629.     pBuffer->GetSize(),
  630.     (pPacket->GetASMRuleNumber() == 1)))
  631. {
  632.     retVal = HXR_OK;
  634.     pBuffer->Release();
  635. }
  636.     }
  637. }
  638. break;
  640.     default:
  641. retVal = HXR_NOTIMPL;
  642. break;
  643.     }
  645.     return retVal;
  646. }
  648. STDMETHODIMP
  649. MP4APayloadFormat::GetPacket(REF(IHXPacket*) pOutPacket)
  650. {
  651.     HX_RESULT retVal = HXR_OK;
  653.     if (m_bPacketize)
  654.     {
  655. retVal = GetPacketizerPacket(pOutPacket);
  656.     }
  657.     else
  658.     {
  659. retVal = GetAssemblerPacket(pOutPacket);
  660.     }
  662.     return retVal;
  663. }
  665. HX_RESULT MP4APayloadFormat::GetPacketizerPacket(IHXPacket* &pOutPacket)
  666. {
  667.     HX_RESULT retVal = HXR_INCOMPLETE;
  669.     if (!m_InputPackets.IsEmpty())
  670.     {
  671. pOutPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  672. retVal = HXR_OK;
  673.     }
  674.     else if (m_bFlushed)
  675.     {
  676. retVal = HXR_STREAM_DONE;
  677.     }
  679.     return retVal;
  680. }
  682. HX_RESULT MP4APayloadFormat::GetAssemblerPacket(IHXPacket* &pOutPacket)
  683. {
  684.     HX_RESULT retVal = HXR_NOTIMPL;
  686.     return retVal;
  687. }
  689. HX_RESULT MP4APayloadFormat::SetSamplingRate(ULONG32 ulSamplesPerSecond)
  690. {
  691.     HX_RESULT retVal = HXR_UNEXPECTED;
  693.     if (!m_bRTPPacketTested)
  694.     {
  695. m_ulSamplesPerSecond = ulSamplesPerSecond;
  696. retVal = HXR_OK;
  697.     }
  699.     return HXR_OK;
  700. }
  702. ULONG32 MP4APayloadFormat::GetTimeBase(void)
  703. {
  704.     return m_ulSamplesPerSecond;
  705. }
  707. HX_RESULT MP4APayloadFormat::SetAUDuration(ULONG32 ulAUDuration)
  708. {
  709.     HX_RESULT retVal = HXR_UNEXPECTED;
  711.     if (!m_bRTPPacketTested)
  712.     {
  713. switch (m_PayloadID)
  714. {
  715. case PYID_MP4A_LATM:
  716.     retVal = HXR_FAIL;
  717.     
  718.     if (m_pLATMDepack &&
  719. m_pLATMDepack->SetFrameDuration(ulAUDuration))
  720.     {
  721. retVal = HXR_OK;
  722.     }
  723.     break;
  724.     
  725. default:
  726.     retVal = HXR_NOTIMPL;
  727.     break;
  728. }
  729.     }
  731.     return retVal;
  732. }
  734. HX_RESULT MP4APayloadFormat::SetTimeAnchor(ULONG32 ulTimeMs)
  735. {
  736.     CTSConverter tempConverter;
  737.     ULONG32 ulSamplesAnchor;
  738.     ULONG32 ulRTPSamplesAnchor;
  740.     tempConverter.SetBase(1000, m_ulSamplesPerSecond);
  741.     ulSamplesAnchor = tempConverter.ConvertVector(ulTimeMs);
  743.     tempConverter.SetBase(1000, m_ulRTPSamplesPerSecond);
  744.     ulRTPSamplesAnchor = tempConverter.ConvertVector(ulTimeMs);
  746.     m_TSConverter.SetAnchor(ulRTPSamplesAnchor, ulSamplesAnchor);
  748.     return HXR_OK;
  749. }
  751. HX_RESULT MP4APayloadFormat::CreateMediaPacket(CMediaPacket* &pOutMediaPacket)
  752. {
  753.     HX_RESULT retVal = HXR_OK;
  755.     switch (m_PayloadID)
  756.     {
  757.     case PYID_X_HX_AAC_GENERIC:
  758.     case PYID_X_HX_MP4_RAWAU:
  759. retVal = CreateRawAUMediaPacket(pOutMediaPacket);
  760. break;
  762.     case PYID_MP4A_LATM:
  763. if (m_OutMediaPacketQueue.IsEmpty())
  764. {
  765.     if (m_bFlushed)
  766.     {
  767. // We have used up all available input
  768. retVal = HXR_STREAM_DONE;
  769.     }
  770.     else
  771.     {
  772. // We don't have enough input
  773. // data to produce a packet
  774. retVal = HXR_INCOMPLETE;
  775.     }
  776. }
  777. else
  778. {
  779.     pOutMediaPacket = (CMediaPacket*) m_OutMediaPacketQueue.RemoveHead();
  780. }
  781. break;
  783.     default:
  784. retVal = HXR_NOTIMPL;
  785. break;
  786.     }
  788.     return retVal;
  789. }
  791. HX_RESULT MP4APayloadFormat::OnFrame(ULONG32 ulTime,
  792.      const UINT8* pData,
  793.      ULONG32 ulSize,
  794.      BOOL bPreviousLoss)
  795. {
  796.     ULONG32 ulFlags = 0;
  797.     CMediaPacket* pMediaPacket = NULL;
  798.     HX_RESULT retVal = HXR_OK;
  800.     if (pData && (ulSize != 0))
  801.     {
  802. ULONG32 ulNewSize;
  804. if (bPreviousLoss)
  805. {
  806.     ulFlags |= MDPCKT_FOLLOWS_LOSS_FLAG;
  807. }
  809. #ifdef _OVERALLOC_CODEC_DATA
  810. ulNewSize = ulSize + _OVERALLOC_CODEC_DATA;
  811. #else // _OVERALLOC_CODEC_DATA
  812. ulNewSize = ulSize;
  813. #endif // _OVERALLOC_CODEC_DATA
  815. UINT8* pNewData = new UINT8 [ulNewSize];
  817. if (pData)
  818. {
  819.     memcpy(pNewData, pData, ulSize); /* Flawfinder: ignore */
  821.     pMediaPacket = new CMediaPacket(pNewData,
  822.     pNewData,
  823.     ulNewSize,
  824.     ulSize,
  825.     ulTime,
  826.     ulFlags,
  827.     NULL);
  828. }
  829.     }
  831.     if (pMediaPacket)
  832.     {
  833. m_OutMediaPacketQueue.AddTail(pMediaPacket);
  834.     }
  836.     return retVal;
  837. }
  839. void MP4APayloadFormat::OnFrameCallback(void* pUserData,
  840. ULONG32 ulTime,
  841. const UINT8* pData,
  842. ULONG32 ulSize,
  843. BOOL bPreviousLoss)
  844. {
  845.     MP4APayloadFormat* pObject = (MP4APayloadFormat*) pUserData;
  847.     pObject->OnFrame(ulTime, pData, ulSize, bPreviousLoss);
  848. }
  850. HX_RESULT MP4APayloadFormat::CreateRawAUMediaPacket(CMediaPacket* &pOutMediaPacket)
  851. {
  852.     CMediaPacket* pMediaPacket;
  853.     IHXPacket* pPacket = NULL;
  854.     HX_RESULT retVal = HXR_OK;
  856.     if (m_InputPackets.IsEmpty())
  857.     {
  858. if (m_bFlushed)
  859. {
  860.     // We have used up all available input
  861.     retVal = HXR_STREAM_DONE;
  862. }
  863. else
  864. {
  865.     // We don't have enough input
  866.     // data to produce a packet
  867.     retVal = HXR_INCOMPLETE;
  868. }
  869.     }
  870.     else
  871.     {
  872. ULONG32 ulFlags = MDPCKT_USES_IHXBUFFER_FLAG;
  873. IHXBuffer* pBuffer = NULL;
  874. pPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  876. if (!pPacket->IsLost())
  877. {
  878.     pBuffer = pPacket->GetBuffer();
  880.     if (pBuffer)
  881.     {
  882. if (m_bPriorLoss)
  883. {
  884.     ulFlags |= MDPCKT_FOLLOWS_LOSS_FLAG;
  885.     m_bPriorLoss = FALSE;
  886. }
  888. pMediaPacket = BuildMediaPacket(pBuffer,
  889. GetPacketTime(pPacket),
  890. ulFlags);
  892. retVal = HXR_OUTOFMEMORY;
  893. if (pMediaPacket)
  894. {
  895.     pOutMediaPacket = pMediaPacket;
  896.     retVal = HXR_OK;
  897. }
  899. pBuffer->Release();
  900.     }
  901.     else
  902.     {
  903. m_bPriorLoss = TRUE;
  904. retVal = HXR_INCOMPLETE;
  905.     }
  907.     pPacket->Release();
  908. }
  909. else
  910. {
  911.     m_bPriorLoss = TRUE;
  912.     retVal = HXR_INCOMPLETE;
  913. }
  914.     }
  916.     return retVal;
  917. }
  920. CMediaPacket* MP4APayloadFormat::BuildMediaPacket(IHXBuffer* pBuffer,
  921.   ULONG32 ulTime,
  922.   ULONG32 ulFlags)
  923. {
  924.     CMediaPacket* pMediaPacket = NULL;
  925. #ifdef _OVERALLOC_CODEC_DATA
  926.     UINT8* pData = new UINT8 [pBuffer->GetSize() + _OVERALLOC_CODEC_DATA];
  928.     if (pData)
  929.     {
  930. memcpy(pData, pBuffer->GetBuffer(), pBuffer->GetSize()); /* Flawfinder: ignore */
  932. ulFlags &= (~MDPCKT_USES_IHXBUFFER_FLAG);
  933. pMediaPacket = new CMediaPacket(pData,
  934. pData,
  935. pBuffer->GetSize() + 3,
  936. pBuffer->GetSize(),
  937. ulTime,
  938. ulFlags,
  939. NULL);
  940.     }
  941. #else // _OVERALLOC_CODEC_DATA
  942.     pMediaPacket = new CMediaPacket(pBuffer,
  943.     pBuffer->GetBuffer(),
  944.     pBuffer->GetSize(),
  945.     pBuffer->GetSize(),
  946.     ulTime,
  947.     ulFlags,
  948.     NULL);
  950. #endif // _OVERALLOC_CODEC_DATA
  952.     return pMediaPacket;
  953. }
  955. STDMETHODIMP
  956. MP4APayloadFormat::Flush()
  957. {
  958.     if (m_pLATMDepack)
  959.     {
  960. m_pLATMDepack->Flush();
  961.     }
  963.     m_bFlushed = TRUE;
  965.     return HXR_OK;
  966. }
  968. void MP4APayloadFormat::FlushPackets(ULONG32 ulCount)
  969. {
  970.     IHXPacket* pDeadPacket;
  971.     CMediaPacket* pDeadMediaPacket;
  973.     while ((ulCount > 0) && (!m_InputPackets.IsEmpty()))
  974.     {
  975. pDeadPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  976. HX_RELEASE(pDeadPacket);
  977. if (ulCount != FLUSH_ALL_PACKETS)
  978. {
  979.     ulCount--;
  980. }
  981.     }
  983.     while ((ulCount > 0) && (!m_OutMediaPacketQueue.IsEmpty()))
  984.     {
  985. pDeadMediaPacket = (CMediaPacket*) m_OutMediaPacketQueue.RemoveHead();
  986. HX_DELETE(pDeadMediaPacket);
  987. if (ulCount != FLUSH_ALL_PACKETS)
  988. {
  989.     ulCount--;
  990. }
  991.     }
  992. }
  994. ULONG32 MP4APayloadFormat::GetPacketTime(IHXPacket* pPacket)
  995. {
  996.     ULONG32 ulTime;
  998.     HX_ASSERT(pPacket);
  1000.     if (m_bUsesRTPPackets)
  1001.     {
  1002. ulTime = ((IHXRTPPacket*) pPacket)->GetRTPTime();
  1003.     }
  1004.     else
  1005.     {
  1006. ulTime = pPacket->GetTime();
  1007.     }
  1009.     ulTime = m_TSConverter.Convert(ulTime);
  1011.     return ulTime;
  1012. }