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

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

Symbian

开发平台：

C/C++

h263vidfmt.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 MP4V_RN_3GPP_H263_PAYLOAD_MIME_TYPE "video/X-RN-3GPP-H263"
  43. #if defined(HELIX_FEATURE_VIDEO_H263_FAVOR_CORRUPTEDFRAMES_OVER_JITTER)
  44. #define NON_KEYFRM_DCDE_FALLBEHIND_THRSHLD  -33 // in milliseconds
  45. #else
  46. #define NON_KEYFRM_DCDE_FALLBEHIND_THRSHLD  -800 // in milliseconds
  47. #endif // HELIX_FEATURE_VIDEO_H263_FAVOR_CORRUPTEDFRAMES_OVER_JITTER
  49. #define DFLT_MAX_IMG_WIDTH 176
  50. #define DFLT_MAX_IMG_HEIGHT 144
  52. #define CCCC_ENCODE(b1, b2, b3, b4) ((b1 << 24) |
  53.  (b2 << 16) |
  54.  (b3 << 8)  |
  55.  b4)
  58. /****************************************************************************
  59.  *  Includes
  60.  */
  62. #include "h263vidfmt.h"
  64. #include "hxasm.h"
  65. #include "hxwin.h"
  66. #include "hxvsurf.h"
  67. // #include "hxvctrl.h"
  68. #include "hxsite2.h"
  69. #include "hxthread.h"
  71. #include "hxtick.h"
  72. #include "hxassert.h"
  73. #include "hxstrutl.h"
  74. #include "hxmarsh.h"
  75. #include "unkimp.h"
  76. #include "timeval.h"
  77. #include "cttime.h"
  78. #include "hxcodec.h"
  80. // #include "qtbatom.h"
  82. #include "h263video.h"
  85. /****************************************************************************
  86.  *  Locals
  87.  */
  90. /****************************************************************************
  91.  *  Method:
  92.  *    CQTVideoFormat::CQTVideoFormat
  93.  *
  94.  */
  95. CH263VideoFormat::CH263VideoFormat(IHXCommonClassFactory* pCommonClassFactory,
  96.    CH263VideoRenderer* pH263VideoRenderer)
  97.     : CVideoFormat(pCommonClassFactory, pH263VideoRenderer)
  98.     , m_pH263VideoRenderer(pH263VideoRenderer)
  99.     , m_pRssm(NULL)
  100.     , m_pMaxDims(NULL)
  101.     , m_pAssmDims(NULL)
  102.     , m_pDecoder(NULL)
  103.     , m_ulDecoderBufSize(0)
  104. {
  105.     HX_ASSERT(m_pCommonClassFactory);
  106.     HX_ASSERT(pH263VideoRenderer);
  108.     m_pH263VideoRenderer->AddRef();
  109. }
  112. /****************************************************************************
  113.  *  Method:
  114.  *    CQTVideoFormat::~CQTVideoFormat
  115.  *
  116.  */
  117. CH263VideoFormat::~CH263VideoFormat()
  118. {
  119.     HX_RELEASE(m_pH263VideoRenderer);
  121.     if (m_pRssm)
  122.     {
  123. m_pRssm->Close();
  124. m_pRssm->Release();
  125. m_pRssm = NULL;
  126.     }
  128.     HX_DELETE(m_pDecoder);
  129.     HX_DELETE(m_pMaxDims);
  131.     _Reset();
  132. }
  135. /****************************************************************************
  136.  *  Method:
  137.  *    CQTVideoFormat::Init
  138.  *
  139.  */
  140. HX_RESULT CH263VideoFormat::Init(IHXValues* pHeader)
  141. {
  142.     IHXBuffer* pMimeType = NULL;
  143.     const char* pMimeTypeData = NULL;
  144.     HX_RESULT retVal = CVideoFormat::Init(pHeader);
  146.     if (SUCCEEDED(retVal))
  147.     {
  148. retVal = pHeader->GetPropertyCString("MimeType", pMimeType);
  149.     }
  151.     if (SUCCEEDED(retVal))
  152.     {
  153. pMimeTypeData = (char*) pMimeType->GetBuffer();
  155. retVal = HXR_FAIL;
  156. if (pMimeTypeData)
  157. {
  158.     retVal = HXR_OK;
  159. }
  160.     }
  162.     if (SUCCEEDED(retVal))
  163.     {
  164. if (strcasecmp(pMimeTypeData, 
  165.        MP4V_RN_3GPP_H263_PAYLOAD_MIME_TYPE) == 0)
  166. {
  167.     IHXBuffer* pConfigData = NULL;
  169.     retVal = pHeader->GetPropertyBuffer("OpaqueData", pConfigData);
  171.     if (SUCCEEDED(retVal))
  172.     {
  173. retVal = ConfigFrom3GPPHeader(pConfigData);
  174.     }
  176.     HX_RELEASE(pConfigData);
  178.     // This payload is raw H263 frames and needs no assembly
  179.     HX_RELEASE(m_pRssm);
  180. }
  181. else
  182. {
  183.     // Assume H263 payload - Create Packet Assembler
  184.     retVal = HXR_OUTOFMEMORY;
  185.     m_pRssm = new CH263PayloadFormat();
  186.     if (m_pRssm)
  187.     {
  188. m_pRssm->AddRef();
  189. retVal = HXR_OK;
  190.     }
  191. }
  192.     }
  194.     HX_RELEASE(pMimeType);
  196.     // Create Decoder
  197.     if (SUCCEEDED(retVal))
  198.     {
  199. retVal = HXR_OUTOFMEMORY;
  200.     m_pDecoder = CreateDecoder();
  201. if (m_pDecoder)
  202. {
  203.     retVal = HXR_OK;
  204. }
  205.     }
  207.     if (SUCCEEDED(retVal) && m_pRssm)
  208.     {
  209. retVal = m_pRssm->Init(m_pCommonClassFactory, FALSE);
  210.     }
  211.     
  212.     if (SUCCEEDED(retVal) && m_pRssm)
  213.     {
  214. retVal = m_pRssm->SetStreamHeader(pHeader);
  215.     }
  217.     m_DecoderDims.cx = 0;
  218.     m_DecoderDims.cy = 0;
  220.     return retVal;
  221. }
  224. /****************************************************************************
  225.  *  Method:
  226.  *    CQTVideoFormat::CreateAssembledPacket
  227.  *
  228.  */
  229. CMediaPacket* CH263VideoFormat::CreateAssembledPacket(IHXPacket* pCodecData)
  230. {
  231.     CMediaPacket* pFramePacket = NULL;
  232.     IHXPacket* pPacket = NULL;
  234.     m_pH263VideoRenderer->BltIfNeeded();
  236.     if (m_pRssm)
  237.     {
  238. m_LastError = m_pRssm->SetPacket(pCodecData);
  239.         if( m_LastError == HXR_OUTOFMEMORY )
  240.         {
  241.     return NULL;
  242.         }
  243. m_pRssm->GetPacket(pPacket);
  244.     }
  245.     else if (!pCodecData->IsLost())
  246.     {
  247. // Since there is no packet assembler - assume no assembly is needed
  248. pPacket = pCodecData;
  249. pPacket->AddRef();
  250.     }
  252.     if (pPacket)
  253.     {
  254. HXxSize FrameDims;
  255. HXxSize* pFrameDims = NULL;
  256. IHXBuffer* pBuffer = pPacket->GetBuffer();
  258. if (pBuffer)
  259. {
  260. #ifdef _TRUST_MAX_DIMS_WHEN_AVAILABLE
  261.     if (!m_pMaxDims)
  262. #endif // _TRUST_MAX_DIMS_WHEN_AVAILABLE
  263.     {
  264. HX_RESULT status = 
  265.     CH263PayloadFormat::GetFrameDimensions(pBuffer, FrameDims);
  267. if (status == HXR_NO_DATA)
  268. {
  269.     // This is a custom size H263+ and we do not parse the
  270.     // bitstream deep enough to get to the custom size
  271.     if (m_pMaxDims &&
  272. (m_pMaxDims->cx != 0) &&
  273. (m_pMaxDims->cy != 0))
  274.     {
  275. FrameDims = *m_pMaxDims;
  276.     }
  277.     else
  278.     {
  279. FrameDims.cx = DFLT_MAX_IMG_WIDTH;
  280. FrameDims.cy = DFLT_MAX_IMG_HEIGHT;
  281.     }
  282. }
  284. // Assembler can extract the frame dimensions
  285. if ((status == HXR_OK) || (status == HXR_NO_DATA))
  286. {
  287.     if (!m_pAssmDims)
  288.     {
  289. m_pAssmDims = new HXxSize;
  290. pFrameDims = new HXxSize;
  292. if (pFrameDims && m_pAssmDims)
  293. {
  294.     *m_pAssmDims = *pFrameDims = FrameDims;
  295.     if (status == HXR_OK)
  296.     {
  297. // we resize only on actual frame dimensions
  298. m_pH263VideoRenderer->ResizeViewFrame(FrameDims);
  299.     }
  300. }
  301. else
  302. {
  303.     HX_DELETE(m_pAssmDims);
  304.     HX_DELETE(pFrameDims);
  305. }
  306.     }
  307.     else
  308.     {
  309. if (*m_pAssmDims != FrameDims)
  310. {
  311.     pFrameDims = new HXxSize;
  312.     
  313.     if (pFrameDims)
  314.     {
  315. *pFrameDims = FrameDims;
  316.     }
  317.     else
  318.     {
  319. HX_DELETE(m_pAssmDims);
  320.     }
  321. }
  322.     }
  323. }
  324.     }
  325. #ifdef _TRUST_MAX_SIZE_WHEN_AVAILABLE
  326.     else if ((!m_pAssmDims) && m_pMaxDims)
  327.     {
  328. // If assembler is absent, we should have max. dimensions
  329. // from out-of and config. data
  330. m_pAssmDims = new HXxSize;
  331. pFrameDims = new HXxSize;
  333. if (pFrameDims && m_pAssmDims)
  334. {
  335.     *m_pAssmDims = *pFrameDims = *m_pMaxDims;
  336. }
  337. else
  338. {
  339.     HX_DELETE(m_pAssmDims);
  340.     HX_DELETE(pFrameDims);
  341. }
  342.     }
  343. #endif // _TRUST_MAX_DIMS_WHEN_AVAILABLE
  344.     
  345.     if (m_pAssmDims)
  346.     {
  347. ULONG32 ulDataSize = pBuffer->GetSize();
  348. ULONG32 ulNewBufferSize = ulDataSize;
  349. UINT8* pData = pBuffer->GetBuffer();
  350. UINT8* pNewBuffer = (UINT8*) pBuffer;
  351. ULONG32 ulFlags = MDPCKT_USES_IHXBUFFER_FLAG;
  353. #ifdef _OVERALLOC_CODEC_DATA
  354. // If Reassembler is present, it is responsible for overallocating
  355. // data if needed
  356. if (!m_pRssm)
  357. {
  358.     ulFlags = 0;
  359.     ulNewBufferSize += _OVERALLOC_CODEC_DATA;
  361.     pNewBuffer = new UINT8 [ulNewBufferSize];
  362.     if (pNewBuffer)
  363.     {
  364. memcpy(pNewBuffer, pData, ulDataSize); /* Flawfinder: ignore */
  365.     }
  366.     pData = pNewBuffer;
  367. }
  368. #endif // _OVERALLOC_CODEC_DATA
  370. if (pNewBuffer)
  371. {
  372.     pFramePacket = new CMediaPacket(
  373.     pNewBuffer,
  374.     pData, 
  375.     ulNewBufferSize,
  376.     ulDataSize,
  377.     pPacket->GetTime(),
  378.     ulFlags,
  379.     pFrameDims);
  380. }
  382. if (pFramePacket)
  383. {
  384.     pFramePacket->SetSampleDescKiller(KillH263ampleDesc);
  385. }
  386. else
  387. {
  388.                     m_LastError = HXR_OUTOFMEMORY;
  389. }
  390.     }
  392.     pBuffer->Release();
  393. }
  394.     
  395.         if( m_LastError != HXR_OUTOFMEMORY )
  396.         {
  397.     m_pH263VideoRenderer->BltIfNeeded();
  398.         }
  399.     
  400. pPacket->Release();
  401.     }
  402.     else
  403.     {
  404. if (pCodecData->IsLost())
  405. {
  406. #if defined(HELIX_FEATURE_STATS)
  407.     m_pH263VideoRenderer->ReportLostFrame();
  408. #endif /* #if defined(HELIX_FEATURE_STATS) */
  409. }
  410.     }
  412.     return pFramePacket;
  413. }
  416. /****************************************************************************
  417.  *  Method:
  418.  *    CQTVideoFormat::Reset
  419.  *
  420.  */
  421. void CH263VideoFormat::Reset()
  422. {
  423.     _Reset();
  424.     CVideoFormat::Reset();
  425. }
  427. void CH263VideoFormat::_Reset(void)
  428. {
  429.     HX_DELETE(m_pAssmDims);
  431.     if (m_pRssm)
  432.     {
  433. m_pRssm->Reset();
  434.     }
  436.     m_DecoderDims.cx = 0;
  437.     m_DecoderDims.cy = 0;
  439.     m_ulDecoderBufSize = 0;
  440. }
  443. /****************************************************************************
  444.  *  Method:
  445.  *    CQTVideoFormat::CreateDecodedPacket
  446.  *
  447.  */
  448. CMediaPacket* CH263VideoFormat::CreateDecodedPacket(CMediaPacket* pFrameToDecode)
  449. {
  450.     HXxSize currentFrameDims;
  451.     CMediaPacket* pDecodedFrame = NULL;
  452.     UINT8* pData = NULL;
  454.     HX_ASSERT(pFrameToDecode);
  456.     // Compute Decode Buffer Storage if info. available
  457.     if (pFrameToDecode->m_pSampleDesc)
  458.     {
  459. if (memcmp(pFrameToDecode->m_pSampleDesc, 
  460.    &m_DecoderDims, 
  461.    sizeof(HXxSize)) != 0)
  462. {
  463.     m_DecoderDims = *((HXxSize*) pFrameToDecode->m_pSampleDesc);
  464.     m_ulDecoderBufSize = m_DecoderDims.cx * 
  465.  m_DecoderDims.cy * 
  466.  H263_PIXEL_SIZE / 
  467.  8;
  468.     m_LastFrameDims = m_DecoderDims;
  470.     if (m_pDecoder->InitDecoder(&m_DecoderDims) != HXR_OK)
  471.     {
  472. m_DecoderDims.cx = 0;
  473. m_DecoderDims.cy = 0;
  474. m_ulDecoderBufSize = 0;
  475.     }
  476. }
  477.     }
  479.     // Get the storage for the Decode Buffer
  480.     if (m_ulDecoderBufSize > 0)
  481.     {
  482. CMediaPacket* pVideoPacket = NULL;
  484. pVideoPacket = (CMediaPacket*) m_pFramePool->Get(m_ulDecoderBufSize);
  486. if (pVideoPacket)
  487. {
  488.     pData = pVideoPacket->m_pData;
  489.     
  490.     HX_ASSERT(pData);
  491.     
  492.     pVideoPacket->Init(pData,
  493.        m_ulDecoderBufSize,
  494.        pFrameToDecode->m_ulTime,
  495.        0,
  496.        pFrameToDecode->m_pSampleDesc);
  497.     
  498.     pFrameToDecode->m_pSampleDesc = NULL;
  499.     
  500.     pDecodedFrame = pVideoPacket;
  501. }
  502. else
  503. {
  504.     pData = new UINT8 [m_ulDecoderBufSize];
  505. }
  506.     }
  508.     if (pData && m_pH263VideoRenderer->IsActive())
  509.     {
  510. LONG32 lTimeAhead;
  512. lTimeAhead = m_pH263VideoRenderer->ComputeTimeAhead(
  513. pFrameToDecode->m_ulTime, 
  514. 0);
  516. if (lTimeAhead < NON_KEYFRM_DCDE_FALLBEHIND_THRSHLD)
  517. {
  518.     // Throw away this frame
  519.     if (pDecodedFrame)
  520.     {
  521. m_pFramePool->Put(pDecodedFrame);
  522. pDecodedFrame = NULL;
  523. pData = NULL;
  524.     }
  525.     else
  526.     {
  527. delete [] pData;
  528. pData = NULL;
  529.     }
  531. #if defined(HELIX_FEATURE_STATS)
  532.     m_pH263VideoRenderer->ReportDroppedFrame();
  533. #endif /* #if defined(HELIX_FEATURE_STATS) */
  534. }
  535.     }
  537.     // Decode
  538.     if (pData)
  539.     {
  540. m_pH263VideoRenderer->BltIfNeeded();
  542. if (m_pDecoder->DecodeFrame(pFrameToDecode,
  543.     pData,
  544.     &currentFrameDims) != HXR_OK)
  545. {
  546.     // Throw away this frame
  547.     if (pDecodedFrame)
  548.     {
  549. m_pFramePool->Put(pDecodedFrame);
  550. pDecodedFrame = NULL;
  551. pData = NULL;
  552.     }
  553.     else
  554.     {
  555. delete [] pData;
  556. pData = NULL;
  557.     }
  559. #if defined(HELIX_FEATURE_STATS)
  560.     m_pH263VideoRenderer->ReportDroppedFrame();
  561. #endif /* #if defined(HELIX_FEATURE_STATS) */
  562. }
  563.     }
  565.     m_pH263VideoRenderer->BltIfNeeded();
  567.     // If the frame is not formed yet, form it
  568.     if (!pDecodedFrame)
  569.     {
  570. if (pData)
  571. {
  572.     // Data exists to form the docoded packet with
  573.     pFrameToDecode->SetBuffer(pData,
  574.       pData,
  575.       m_ulDecoderBufSize, 
  576.       m_ulDecoderBufSize);
  577.     
  578.     pDecodedFrame = pFrameToDecode;
  579.     pFrameToDecode = NULL;
  581.     // If there is a change in frame size, forward the change
  582.     if (m_LastFrameDims != currentFrameDims)
  583.     {
  584. HXxSize* pNewFrameDims = new HXxSize;
  586. HX_ASSERT(currentFrameDims.cx <= m_DecoderDims.cx);
  587. HX_ASSERT(currentFrameDims.cy <= m_DecoderDims.cy);
  589. if (pNewFrameDims)
  590. {
  591.     *pNewFrameDims = currentFrameDims;
  592.     pDecodedFrame->SetSampleDesc(pNewFrameDims);
  593.     m_LastFrameDims = currentFrameDims;
  594. }
  595.     }
  596. }
  597. else if (pFrameToDecode->m_pSampleDesc)
  598. {
  599.     // No data exists to form the frame with, but description
  600.     // exists and must be passed down the pipe - form empty 
  601.     // frame packet
  602.     pDecodedFrame = pFrameToDecode;
  603.     pDecodedFrame->m_pData = NULL;
  604.     pDecodedFrame->m_ulDataSize = 0;
  605.     pFrameToDecode = NULL; 
  606. }
  607.     }
  608.   
  609.     if (pFrameToDecode != NULL)
  610.     {
  611. pFrameToDecode->Clear();
  612. delete pFrameToDecode;
  613.     }
  614.     
  615.     return pDecodedFrame;
  616. }
  619. /****************************************************************************
  620.  *  Method:
  621.  *    CH263VideoFormat::CSecureH263VideoFormat
  622.  *
  623.  */
  624. CH263Decoder* CH263VideoFormat::CreateDecoder()
  625. {
  626.     return new CH263Decoder(m_pH263VideoRenderer->GetContext());
  627. }
  629. /****************************************************************************
  630.  *  Method:
  631.  *    CH263VideoFormat::ConfigFrom3GPPHeader
  632.  *
  633.  */
  634. HX_RESULT CH263VideoFormat::ConfigFrom3GPPHeader(IHXBuffer* pConfigData)
  635. {
  636.     UINT8* pData;
  637.     ULONG32 ulSize;
  638.     HX_RESULT retVal = HXR_FAIL;
  640.     HX_DELETE(m_pMaxDims);
  642.     if (pConfigData)
  643.     {
  644. pData = pConfigData->GetBuffer();
  645. ulSize = pConfigData->GetSize();
  647. m_pMaxDims = new HXxSize;
  649. retVal = HXR_OUTOFMEMORY;
  650.     }
  652.     if (m_pMaxDims)
  653.     {
  654. retVal = HXR_OK;
  656. // We'll assume unknown size
  657. m_pMaxDims->cx = 0;
  658. m_pMaxDims->cy = 0;
  660. if (ulSize >= sizeof(DecoderSpecificInfoV20))
  661. {
  662.     // Try 3GPP-v2.0 DecoderSpecificInfo
  663.     if (getlong(((DecoderSpecificInfoV20*) pData)->pType)
  664. == CCCC_ENCODE('d', '2', '6', '3'))
  665.     {
  666. // Looks good as 3GPP-v2.0 DecoderSpecificInfo
  667. ;
  668.     }
  669.     else if ((ulSize >= sizeof(DecoderSpecificInfoV10))&&
  670.      (((DecoderSpecificInfoV10*) pData)->pTag[0] == 0x05))
  671.     {
  672. // Looks good as 3GPP-v1.0 DecoderSpecificInfo
  673. m_pMaxDims->cx = getshort(
  674.     ((DecoderSpecificInfoV10*) pData)->pMaxWidth);
  675. m_pMaxDims->cy = getshort(
  676.     ((DecoderSpecificInfoV10*) pData)->pMaxHeight);
  677.     }
  678. }
  679.     }
  680.     
  681.     return retVal;
  682. }
  685. /****************************************************************************
  686.  *  Method:
  687.  *    CH263VideoFormat::IsBitmapFormatChanged
  688.  *
  689.  */
  690. BOOL CH263VideoFormat::IsBitmapFormatChanged(
  691.     HXBitmapInfoHeader &BitmapInfoHeader,
  692.     CMediaPacket* pVideoPacket)
  693. {
  694.     if (pVideoPacket->m_pSampleDesc != NULL)
  695.     {
  696. HXxSize* pDims = (HXxSize*) pVideoPacket->m_pSampleDesc;
  698. if ((BitmapInfoHeader.biWidth != pDims->cx) ||
  699.     (BitmapInfoHeader.biHeight != pDims->cy))
  700. {
  701.     return TRUE;
  702. }
  703.     }
  705.     return FALSE;
  706. }
  709. /****************************************************************************
  710.  *  Method:
  711.  *    CH263VideoFormat::InitBitmapInfoHeader
  712.  *
  713.  */
  714. HX_RESULT CH263VideoFormat::InitBitmapInfoHeader(
  715.     HXBitmapInfoHeader &bitmapInfoHeader,
  716.     CMediaPacket* pVideoPacket)
  717. {
  718.     HXxSize* pDims = (HXxSize*) pVideoPacket->m_pSampleDesc;
  720.     if (pDims)
  721.     {
  722. bitmapInfoHeader.biWidth = pDims->cx;
  723. bitmapInfoHeader.biHeight = pDims->cy;
  724. bitmapInfoHeader.biSizeImage = bitmapInfoHeader.biWidth * 
  725.        bitmapInfoHeader.biHeight * 
  726.        bitmapInfoHeader.biBitCount / 
  727.        8;
  728.     }
  730.     return HXR_OK;
  731. }
  734. /****************************************************************************
  735.  *  Method:
  736.  *    CH263VideoFormat::KillH263ampleDesc
  737.  *
  738.  */
  739. void CH263VideoFormat::KillH263ampleDesc(void* pSampleDesc, void* pUserData)
  740. {
  741.     if (pSampleDesc)
  742.     {
  743. HXxSize* pFrameDims = (HXxSize*) pSampleDesc;
  745. delete pFrameDims;
  746.     }
  747. }