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

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

Symbian

开发平台：

C/C++

mp4vdfmt.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0 and Exhibits. 
  3.  * REALNETWORKS CONFIDENTIAL--NOT FOR DISTRIBUTION IN SOURCE CODE FORM 
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. 
  5.  * All Rights Reserved. 
  6.  * 
  7.  * The contents of this file, and the files included with this file, are 
  8.  * subject to the current version of the RealNetworks Community Source 
  9.  * License Version 1.0 (the "RCSL"), including Attachments A though H, 
  10.  * all available at http://www.helixcommunity.org/content/rcsl. 
  11.  * You may also obtain the license terms directly from RealNetworks. 
  12.  * You may not use this file except in compliance with the RCSL and 
  13.  * its Attachments. There are no redistribution rights for the source 
  14.  * code of this file. Please see the applicable RCSL for the rights, 
  15.  * obligations and limitations governing use of the contents of the file. 
  16.  * 
  17.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  18.  * developer of the Original Code and owns the copyrights in the portions 
  19.  * it created. 
  20.  * 
  21.  * This file, and the files included with this file, is distributed and made 
  22.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  23.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  24.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  25.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  26.  * 
  27.  * Technology Compatibility Kit Test Suite(s) Location: 
  28.  * https://rarvcode-tck.helixcommunity.org 
  29.  * 
  30.  * Contributor(s): 
  31.  * 
  32.  * ***** END LICENSE BLOCK ***** */ 
  35. /****************************************************************************
  36.  *  Defines
  37.  */
  38. #define _IGNORE_UNSUPPORTED
  40. #define NON_KEYFRM_DCDE_FALLBEHIND_THRSHLD  33 // in milliseconds
  41. #if defined(HELIX_FEATURE_MIN_HEAP)
  42. #define MP4V_DEFAULT_PREROLL     2000 // in milliseconds
  43. #else
  44. #define MP4V_DEFAULT_PREROLL     3500 // in milliseconds
  45. #endif
  47. #define MAX_NONKEY_CODED_FRAME_FALLBEHIND -800
  49. /****************************************************************************
  50.  *  Includes
  51.  */
  52. #include "mp4vdfmt.h"
  54. #include "hxasm.h"
  55. #include "hxwin.h"
  56. #include "hxvsurf.h"
  57. #include "hxvctrl.h"
  58. #include "hxsite2.h"
  59. #include "hxthread.h"
  61. #include "hxtick.h"
  62. #include "hxassert.h"
  63. #include "hxstrutl.h"
  64. #include "unkimp.h"
  65. #include "timeval.h"
  66. #include "cttime.h"
  67. #include "hxcodec.h"
  69. #include "mp4video.h"
  71. /****************************************************************************
  72.  *  Locals
  73.  */
  76. /****************************************************************************
  77.  *  Method:
  78.  *    CMP4VideoFormat::CQTVideoFormat
  79.  *
  80.  */
  81. CMP4VideoFormat::CMP4VideoFormat(IHXCommonClassFactory* pCommonClassFactory,
  82.  CMP4VideoRenderer* pMP4VideoRenderer,
  83.  BOOL bSecure)
  84.     : CVideoFormat(pCommonClassFactory, pMP4VideoRenderer)
  85.     , m_pMP4VideoRenderer(pMP4VideoRenderer)
  86.     , m_pRssm(NULL)
  87.     , m_pDecoder(NULL)
  88.     , m_pInputAllocator(NULL)
  89.     , m_ulMaxDecodedFrames(0)
  90. {
  91.     HX_ASSERT(m_pCommonClassFactory);
  92.     HX_ASSERT(pMP4VideoRenderer);
  94.     m_DecodedPacket.dataLength = 0;
  95.     m_DecodedPacket.data = NULL;
  97.     m_DecoderDims.cx = 0;
  98.     m_DecoderDims.cy = 0;
  100.     m_pMP4VideoRenderer->AddRef();
  101. }
  104. /****************************************************************************
  105.  *  Method:
  106.  *    CMP4VideoFormat::~CQTVideoFormat
  107.  *
  108.  */
  109. CMP4VideoFormat::~CMP4VideoFormat()
  110. {
  111.     CVideoFormat::Reset();
  113.     HX_RELEASE(m_pMP4VideoRenderer);
  115.     if (m_pRssm)
  116.     {
  117. m_pRssm->Close();
  118. m_pRssm->Release();
  119. m_pRssm = NULL;
  120.     }
  122.     HX_DELETE(m_pDecoder);
  124.     _Reset();
  126.     HX_DELETE(m_pInputAllocator);
  127. }
  130. /****************************************************************************
  131.  *  Method:
  132.  *    CMP4VideoFormat::Init
  133.  */
  134. HX_RESULT CMP4VideoFormat::Init(IHXValues* pHeader)
  135. {
  136.     HX_RESULT retVal = CVideoFormat::Init(pHeader);
  138.     // Create memory allocators
  139.     if (SUCCEEDED(retVal))
  140.     {
  141. retVal = CreateAllocators();
  142.     }
  144.     // Create Packet Assembler
  145.     if (SUCCEEDED(retVal))
  146.     {
  147. retVal = HXR_OUTOFMEMORY;
  148. m_pRssm = new MP4VPayloadFormat(m_pInputAllocator);
  149. if (m_pRssm)
  150. {
  151.     m_pRssm->AddRef();
  152.     retVal = HXR_OK;
  153. }
  154.     }
  155.     
  156.     // Create Decoder
  157.     if (SUCCEEDED(retVal))
  158.     {
  159. retVal = HXR_OUTOFMEMORY;
  160.     m_pDecoder = CreateDecoder();
  161. if (m_pDecoder)
  162. {
  163.     retVal = HXR_OK;
  164. }
  165.     }
  167.     // Initialize Assembler
  168.     if (SUCCEEDED(retVal) && m_pRssm)
  169.     {
  170. retVal = m_pRssm->Init(m_pCommonClassFactory, FALSE);
  171.     }
  172.     
  173.     if (SUCCEEDED(retVal) && m_pRssm)
  174.     {
  175. retVal = m_pRssm->SetStreamHeader(pHeader);
  177. if (retVal == HXR_NO_DATA)
  178. {
  179.     retVal = HXR_OK;
  180. }
  182. #ifdef _IGNORE_UNSUPPORTED
  183. if (FAILED(retVal))
  184. {
  185.     HXxSize nullViewFrame = {1, 1};
  186.     m_pMP4VideoRenderer->ResizeViewFrame(nullViewFrame);
  187.     HX_RELEASE(m_pRssm);
  188.     retVal = HXR_OK;
  189. }
  190. #endif // _IGNORE_UNSUPPORTED
  192.     }
  194.     // Initialize Decoder
  195.     if (SUCCEEDED(retVal) && m_pRssm)
  196.     {
  197. retVal = m_pDecoder->Init(m_pMP4VideoRenderer->GetContext(),
  198.   this,
  199.   NULL,
  200.   m_pInputAllocator,
  201.   m_pMP4VideoRenderer->m_pOutputAllocator);
  203. #ifdef _IGNORE_UNSUPPORTED
  204. if (FAILED(retVal))
  205. {
  206.     HXxSize nullViewFrame = {1, 1};
  207.     m_pMP4VideoRenderer->ResizeViewFrame(nullViewFrame);
  208.     HX_RELEASE(m_pRssm);
  209.     retVal = HXR_OK;
  210. }
  211. #endif // _IGNORE_UNSUPPORTED
  212.     }
  214.     m_DecoderDims.cx = 0;
  215.     m_DecoderDims.cy = 0;
  217.     m_ulMaxDecodedFrames = GetMaxDecodedFrames();
  219.     return retVal;
  220. }
  223. /****************************************************************************
  224.  *  Method:
  225.  *    CVideoFormat::GetDefaultPreroll
  226.  *
  227.  */
  228. ULONG32 CMP4VideoFormat::GetDefaultPreroll(IHXValues* pValues)
  229. {
  230.     return MP4V_DEFAULT_PREROLL;
  231. }
  234. /****************************************************************************
  235.  *  Method:
  236.  *    CQTVideoFormat::GetBitstreamHeaderSize
  237.  */
  238. ULONG32 CMP4VideoFormat::GetBitstreamHeaderSize(void)
  239. {
  240.     ULONG32 ulSize = 0;
  242.     if (m_pRssm)
  243.     {
  244. ulSize = m_pRssm->GetBitstreamHeaderSize();
  245.     }
  247.     return ulSize;
  248. }
  251. /****************************************************************************
  252.  *  Method:
  253.  *    CQTVideoFormat::GetBitstreamHeader
  254.  */
  255. const UINT8* CMP4VideoFormat::GetBitstreamHeader(void)
  256. {
  257.     const UINT8* pHeader = NULL;
  259.     if (m_pRssm)
  260.     {
  261. pHeader = m_pRssm->GetBitstreamHeader();
  262.     }
  264.     return pHeader;
  265. }
  268. /****************************************************************************
  269.  *  Method:
  270.  *    CQTVideoFormat::CreateAssembledPacket
  271.  */
  272. CMediaPacket* CMP4VideoFormat::CreateAssembledPacket(IHXPacket* pCodecData)
  273. {
  274.     ULONG32* pCodecPacketRaw = NULL;
  275.     HXCODEC_DATA* pCodecPacket;
  276.     CMediaPacket* pFramePacket = NULL;
  277.     IHXPacket* pPacket = NULL;
  279. #ifdef _IGNORE_UNSUPPORTED
  280.     if (!m_pRssm)
  281.     {
  282. return NULL;
  283.     }
  284. #endif // _IGNORE_UNSUPPORTED
  286.     m_pMP4VideoRenderer->BltIfNeeded();
  288.     m_LastError = m_pRssm->SetPacket(pCodecData);
  289.     if( m_LastError == HXR_OUTOFMEMORY )
  290.     {
  291.         return NULL;
  292.     }
  293.     m_pRssm->CreateHXCodecPacket(pCodecPacketRaw);
  294.     pCodecPacket = (HXCODEC_DATA*) pCodecPacketRaw;
  295.     
  296.     if (pCodecPacket)
  297.     {
  298. pFramePacket = new CMediaPacket(
  299. pCodecPacket,
  300. (UINT8*) pCodecPacket, 
  301. pCodecPacket->dataLength,
  302. pCodecPacket->dataLength,
  303. pCodecPacket->timestamp,
  304. pCodecPacket->flags, //0,
  305. NULL);
  307. if (pFramePacket == NULL)
  308. {
  309.     HX_ASSERT(HXR_OUTOFMEMORY == HXR_OK);
  310.     KillInputBuffer(pCodecPacket, this);
  311.             m_LastError == HXR_OUTOFMEMORY;
  312.             return NULL;
  313. }
  314. else
  315. {
  316.     pFramePacket->SetBufferKiller(KillInputBuffer);
  317.     pFramePacket->m_pUserData = this;
  318. }
  320. m_pMP4VideoRenderer->BltIfNeeded();
  321.     }
  322.     
  323.     return pFramePacket;
  324. }
  327. /****************************************************************************
  328.  *  Method:
  329.  *    CMP4VideoFormat::Reset
  330.  */
  331. void CMP4VideoFormat::Reset()
  332. {
  333.     _Reset();
  334.     CVideoFormat::Reset();
  335. }
  337. void CMP4VideoFormat::_Reset(void)
  338. {
  339.     ReleaseDecodedPacket(&m_DecodedPacket);
  341.     if (m_pRssm)
  342.     {
  343. m_pRssm->Reset();
  344. m_pRssm->SetTimeAnchor(GetStartTime());
  345.     }
  347.     m_DecoderDims.cx = 0;
  348.     m_DecoderDims.cy = 0;
  349. }
  351. void CMP4VideoFormat::ReleaseDecodedPacket(HXCODEC_DATA* pDecodedPacket)
  352. {
  353.     HX_ASSERT(pDecodedPacket);
  355.     if (pDecodedPacket->data && 
  356. m_pMP4VideoRenderer && 
  357. m_pMP4VideoRenderer->m_pOutputAllocator)
  358.     {
  359. m_pMP4VideoRenderer->m_pOutputAllocator->ReleasePacketPtr(pDecodedPacket->data);
  360. pDecodedPacket->data = NULL;
  361. pDecodedPacket->dataLength = NULL;
  362.     }
  363. }
  366. /****************************************************************************
  367.  *  Method:
  368.  *    CMP4VideoFormat::CreateDecodedPacket
  369.  *
  370.  */
  371. CMediaPacket* CMP4VideoFormat::CreateDecodedPacket(CMediaPacket* pFrameToDecode)
  372. {
  373.     HXCODEC_DATA oldDecodedPacket;
  374.     HXCODEC_DATA* pDecodedPacket = NULL;
  375.     CMediaPacket* pDecodedFrame = NULL;
  376.     UINT8* pData = NULL;
  377.  
  378.     HX_ASSERT(pFrameToDecode);
  380. #if defined(HELIX_FEATURE_VIDEO_MPEG4_DISCARD_LATE_ENCODED_FRAMES)
  381. // discard late frames before they are decoded
  383.     if (m_pMP4VideoRenderer->IsActive())
  384.     {
  385. LONG32 lTimeAhead;
  387. lTimeAhead = m_pMP4VideoRenderer->ComputeTimeAhead(
  388. pFrameToDecode->m_ulTime, 
  389. 0);
  391. if (lTimeAhead < MAX_NONKEY_CODED_FRAME_FALLBEHIND)
  392. {
  393.     // Throw away this frame
  394.     pFrameToDecode->Clear();
  395.     delete pFrameToDecode;
  396.     pFrameToDecode = NULL;
  398. #if defined(HELIX_FEATURE_STATS)
  399.     m_pMP4VideoRenderer->ReportDroppedFrame();
  400. #endif /* #if defined(HELIX_FEATURE_STATS) */
  401. }
  402.     }
  403. #endif // HELIX_FEATURE_VIDEO_MPEG4_DISCARD_LATE_ENCODED_FRAMES
  405.     if (m_DecodedPacket.data)
  406.     {
  407. oldDecodedPacket = m_DecodedPacket;
  408. m_DecodedPacket.data = NULL;
  409. m_DecodedPacket.dataLength = 0;
  410. pDecodedPacket = &oldDecodedPacket;
  411.     }
  413.     m_pMP4VideoRenderer->BltIfNeeded();
  415.     if (pFrameToDecode)
  416.         ProcessAssembledFrame(pFrameToDecode);
  418.     if (pFrameToDecode && 
  419. m_pDecoder->Decode(pFrameToDecode, MAX_DECODE_QUALITY) == HXR_OK)
  420.     {
  421. if ((pDecodedPacket == NULL) && (m_DecodedPacket.data))
  422. {
  423.     pDecodedPacket = &m_DecodedPacket;
  424. }
  426. #if !defined(HELIX_FEATURE_VIDEO_MPEG4_DISCARD_LATE_ENCODED_FRAMES)
  427. if (pDecodedPacket)
  428. {
  429.     if (m_pMP4VideoRenderer->ComputeTimeAhead(
  430.     pDecodedPacket->timestamp, 
  431.     0) 
  432. < NON_KEYFRM_DCDE_FALLBEHIND_THRSHLD)
  433.     {
  434. ReleaseDecodedPacket(pDecodedPacket);
  435. pDecodedPacket = NULL;
  436.     }
  437. }
  438. #endif // HELIX_FEATURE_VIDEO_MPEG4_DISCARD_LATE_ENCODED_FRAMES
  440. if (pDecodedPacket)
  441. {
  442.     CMediaPacket* pVideoPacket = NULL;
  443.     HXxSize* pSampleDesc = NULL;
  445.     // Obtain frame dimensions if not set
  446.     if (m_DecoderDims.cx == 0) 
  447.     {
  448. HX_FORMAT_IMAGE imageInfo;
  450. if (m_pDecoder->GetImageInfo(imageInfo) == HXR_OK)
  451. {
  452.     pSampleDesc = new HXxSize;
  453.     if (pSampleDesc)
  454.     {
  455. pSampleDesc->cx = m_DecoderDims.cx = imageInfo.uiWidth;
  456. pSampleDesc->cy = m_DecoderDims.cy = imageInfo.uiHeight;
  457. m_pMP4VideoRenderer->ResizeViewFrame(m_DecoderDims);
  458.     }
  459. }
  460.     }
  462.     // Form decoded media packets if dimensions set
  463.     if (m_DecoderDims.cx != 0)
  464.     {
  465. pVideoPacket = (CMediaPacket*) m_pFramePool->Get(0);
  467. if (pVideoPacket == NULL)
  468. {
  469.     pVideoPacket = pFrameToDecode;
  470.     pFrameToDecode = NULL;
  471. }
  473. if (pVideoPacket)
  474. {
  475.     pVideoPacket->SetBuffer(pDecodedPacket->data,
  476.     pDecodedPacket->data,
  477.     pDecodedPacket->dataLength,
  478.     pDecodedPacket->dataLength,
  479.     FALSE);
  481.     pVideoPacket->Init(pDecodedPacket->data,
  482.        pDecodedPacket->dataLength,
  483.        pDecodedPacket->timestamp,
  484.        pDecodedPacket->flags,
  485.        pSampleDesc);
  487.     pVideoPacket->SetSampleDescKiller(KillMP4VSampleDesc);
  488.     pVideoPacket->SetBufferKiller(KillOutputBuffer);
  489.     pVideoPacket->m_pUserData = m_pMP4VideoRenderer;
  491.     pDecodedPacket->data = NULL;
  492.     pDecodedPacket->dataLength = 0;
  493.     pDecodedPacket = NULL;
  495.     pSampleDesc = NULL;
  497.     pDecodedFrame = pVideoPacket;
  499.     pVideoPacket = NULL;
  500. }
  501.     }
  503.     if (pVideoPacket)
  504.     {
  505. delete pVideoPacket;
  506.     }
  508.     if (pSampleDesc)
  509.     {
  510. delete pSampleDesc;
  511.     }
  512. }
  513.     }
  515.     if (pFrameToDecode != NULL)
  516.     {
  517. pFrameToDecode->Clear();
  518. delete pFrameToDecode;
  519.     }
  521.     if (pDecodedPacket)
  522.     {
  523. ReleaseDecodedPacket(pDecodedPacket);
  524.     }
  526.     return pDecodedFrame;
  527. }
  529. CMP4VDecoder* CMP4VideoFormat::CreateDecoder()
  530. {
  531.     return new CMP4VDecoder();
  532. }
  534. /****************************************************************************
  535.  *  Method:
  536.  *    CMP4VideoFormat::DecodeDone
  537.  */
  538. HX_RESULT CMP4VideoFormat::DecodeDone(HXCODEC_DATA* pData)
  539. {
  540.     HX_RESULT retVal = HXR_OK;
  542.     m_pMP4VideoRenderer->BltIfNeeded();
  544.     if (pData)
  545.     {
  546. HX_ASSERT(m_DecodedPacket.data == NULL);
  548. retVal = HXR_UNEXPECTED;
  549. if (m_DecodedPacket.data == NULL)
  550. {
  551.     m_DecodedPacket = *pData;
  552.     retVal = HXR_OK;
  553. }
  554.     }
  556.     return retVal;
  557. }
  560. /****************************************************************************
  561.  *  Method:
  562.  *    CMP4VideoFormat::IsBitmapFormatChanged
  563.  *
  564.  */
  565. BOOL CMP4VideoFormat::IsBitmapFormatChanged(
  566.     HXBitmapInfoHeader &BitmapInfoHeader,
  567.     CMediaPacket* pVideoPacket)
  568. {
  569.     if (pVideoPacket->m_pSampleDesc != NULL)
  570.     {
  571. HXxSize* pDims = (HXxSize*) pVideoPacket->m_pSampleDesc;
  573. if ((BitmapInfoHeader.biWidth != pDims->cx) ||
  574.     (BitmapInfoHeader.biHeight != pDims->cy))
  575. {
  576.     return TRUE;
  577. }
  578.     }
  580.     return FALSE;
  581. }
  584. /****************************************************************************
  585.  *  Method:
  586.  *    CMP4VideoFormat::InitBitmapInfoHeader
  587.  */
  588. HX_RESULT CMP4VideoFormat::InitBitmapInfoHeader(
  589.     HXBitmapInfoHeader &bitmapInfoHeader,
  590.     CMediaPacket* pVideoPacket)
  591. {
  592.     HXxSize* pDims = (HXxSize*) pVideoPacket->m_pSampleDesc;
  594.     if (pDims)
  595.     {
  596. bitmapInfoHeader.biWidth = pDims->cx;
  597. bitmapInfoHeader.biHeight = pDims->cy;
  598. bitmapInfoHeader.biSizeImage = bitmapInfoHeader.biWidth * 
  599.        bitmapInfoHeader.biHeight * 
  600.        bitmapInfoHeader.biBitCount / 
  601.        8;
  602.     }
  604.     return HXR_OK;
  605. }
  608. /****************************************************************************
  609.  *  Method:
  610.  *    CMP4VideoFormat::CreateAllocators()
  611.  */
  612. HX_RESULT CMP4VideoFormat::CreateAllocators(void)
  613. {
  614.     HX_RESULT retVal = HXR_OK;
  615.     HX20ALLOCPROPS allocRequest, allocActual;
  617.     HX_RELEASE(m_pInputAllocator);
  618.     HX_DELETE(m_pMP4VideoRenderer->m_pOutputAllocator);
  619.     
  620.     // setup the input allocator for the codec
  621.     if (retVal == HXR_OK)
  622.     {
  623. m_pInputAllocator = new CHXBufferMemoryAllocator(TRUE);
  625. retVal = HXR_OUTOFMEMORY;
  626. if (m_pInputAllocator)
  627. {
  628.     m_pInputAllocator->AddRef();
  629.     m_pInputAllocator->GetProperties(&allocRequest);
  630.     allocRequest.nNumBuffers = 0;   // No retention
  631.     m_pInputAllocator->SetProperties(&allocRequest, 
  632.      &allocActual);
  633.     retVal = HXR_OK;
  634. }
  635.     }
  637.     // setup the output allocator for the codec
  638.     if (retVal == HXR_OK)
  639.     {
  640. m_pMP4VideoRenderer->m_pOutputAllocator = new CHXMemoryAllocator(TRUE);
  642. retVal = HXR_OUTOFMEMORY;
  643. if (m_pMP4VideoRenderer->m_pOutputAllocator)
  644. {
  645.     m_pMP4VideoRenderer->m_pOutputAllocator->AddRef();
  646.     m_pMP4VideoRenderer->m_pOutputAllocator->GetProperties(&allocRequest);
  647.     allocRequest.nNumBuffers = GetMaxDecodedFrames() * 2;
  648.     m_pMP4VideoRenderer->m_pOutputAllocator->SetProperties(&allocRequest, 
  649. &allocActual);
  650.     retVal = HXR_OK;
  651. }
  652.     }
  654. #if _MACINTOSH
  655.     // TODO: we want to pre-allocate the output buffers here so they come
  656.     // from the standard memory pools instead of the interrupt memory
  657.     // pools.
  658. #endif // _MACINTOSH
  660.     return retVal;
  661. }
  664. /****************************************************************************
  665.  *  Method:
  666.  *    CMP4VideoFormat::KillMP4VSampleDesc
  667.  *
  668.  */
  669. void CMP4VideoFormat::KillMP4VSampleDesc(void* pSampleDesc, void* pUserData)
  670. {
  671.     if (pSampleDesc)
  672.     {
  673. HXxSize* pFrameDims = (HXxSize*) pSampleDesc;
  675. delete pFrameDims;
  676.     }
  677. }
  680. /****************************************************************************
  681.  *  Method:
  682.  *    CMP4VideoFormat::KillInputBuffer
  683.  *
  684.  */
  685. void CMP4VideoFormat::KillInputBuffer(void* pBuffer, void* pUserData)
  686. {
  687.     if (pBuffer)
  688.     {
  689. HXCODEC_DATA* pDeadData = (HXCODEC_DATA*) pBuffer;
  690. CMP4VideoFormat* pVidFmt = (CMP4VideoFormat*) pUserData;
  692. HX_ASSERT(pUserData);
  694. if (pDeadData->data)
  695. {
  696.     pVidFmt->m_pInputAllocator->ReleasePacketPtr(pDeadData->data);
  697. }
  699. delete[] ((ULONG32*) pDeadData);
  700.     }
  701. }
  704. /****************************************************************************
  705.  *  Method:
  706.  *    CMP4VideoFormat::KillOutputBuffer
  707.  *
  708.  */
  709. void CMP4VideoFormat::KillOutputBuffer(void* pBuffer, void* pUserData)
  710. {
  711.     if (pBuffer)
  712.     {
  713. CMP4VideoRenderer* pVidRnd = (CMP4VideoRenderer*) pUserData;
  714. HX_ASSERT(pUserData);
  716. pVidRnd->m_pOutputAllocator->ReleasePacketPtr((UINT8*) pBuffer);
  717.     }
  718. }