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

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

Symbian

开发平台：

C/C++

rvxvdfmt.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 _IGNORE_UNSUPPORTED
  41. #if !defined(HELIX_FEATURE_MIN_HEAP)
  42. #define MAX_BUFFERED_DECODED_RV_FRAMES 15
  43. #else // HELIX_FEATURE_MIN_HEAP
  44. #define MAX_BUFFERED_DECODED_RV_FRAMES 2
  45. #endif // HELIX_FEATURE_MIN_HEAP
  47. #define NON_KEYFRM_DCDE_FALLBEHIND_THRSHLD  66 // in milliseconds
  48. #if defined(HELIX_FEATURE_MIN_HEAP)
  49. #define RVXV_DEFAULT_PREROLL     2000 // in milliseconds
  50. #else
  51. #define RVXV_DEFAULT_PREROLL     3500 // in milliseconds
  52. #endif
  54. #define IMG_FORMAT_POSSIBLE_CHANGE     1
  55. #define IMG_FORMAT_FORCED_CHANGE     2
  57. #define DECODE_CALLBACK_RNGBUF_SIZE     10
  59. #define UNINITIALIZED_SEQ_NUMBER     0xFFFFFFFF
  61. #define MAX_KEY_CODED_FRAME_FALLBEHIND -1200
  62. #define MAX_NONKEY_CODED_FRAME_FALLBEHIND -800
  65. /****************************************************************************
  66.  *  Includes
  67.  */
  68. #include "rvxvdfmt.h"
  70. #include "hxasm.h"
  71. #include "hxwin.h"
  72. #include "hxvsurf.h"
  73. #include "hxvctrl.h"
  74. #include "hxsite2.h"
  75. #include "hxthread.h"
  77. #include "hxtick.h"
  78. #include "hxassert.h"
  79. #include "hxstrutl.h"
  80. #include "unkimp.h"
  81. #include "timeval.h"
  82. #include "cttime.h"
  83. #include "hxcodec.h"
  84. #include "hxmtypes.h"
  86. #include "rvxvideo.h"
  88. /****************************************************************************
  89.  *  Locals
  90.  */
  93. /****************************************************************************
  94.  *  Method:
  95.  *    CRVXVideoFormat::CQTVideoFormat
  96.  *
  97.  */
  98. CRVXVideoFormat::CRVXVideoFormat(IHXCommonClassFactory* pCommonClassFactory,
  99.  CRVXVideoRenderer* pRVXVideoRenderer)
  100.     : CVideoFormat(pCommonClassFactory, pRVXVideoRenderer)
  101.     , m_pRVXVideoRenderer(pRVXVideoRenderer)
  102.     , m_pRssm(NULL)
  103.     , m_pDecoder(NULL)
  104.     , m_pInputAllocator(NULL)
  105.     , m_ulMaxDecodedFrames(0)
  106.     , m_ulWidthContainedInSegment(0)
  107.     , m_ulHeightContainedInSegment(0)
  108.     , m_pCodecOutputBIH(NULL)
  109.     , m_pDecodedRngBuf(NULL)
  110.     , m_bFirstDecode(TRUE)
  111.     , m_ulLastSequenceNumber(UNINITIALIZED_SEQ_NUMBER)
  112.     , m_bFlushingToKeyFrame(FALSE)
  114. {
  115.     HX_ASSERT(m_pCommonClassFactory);
  116.     HX_ASSERT(pRVXVideoRenderer);
  118.     m_sMediaSize.cx = 0;
  119.     m_sMediaSize.cy = 0;
  121.     m_pRVXVideoRenderer->AddRef();
  123. }
  126. /****************************************************************************
  127.  *  Method:
  128.  *    CRVXVideoFormat::~CQTVideoFormat
  129.  *
  130.  */
  131. CRVXVideoFormat::~CRVXVideoFormat()
  132. {
  133.     CVideoFormat::Reset();
  135.     HX_RELEASE(m_pRVXVideoRenderer);
  137.     if (m_pRssm)
  138.     {
  139. m_pRssm->Close();
  140. m_pRssm->Release();
  141. m_pRssm = NULL;
  142.     }
  144.     FlushDecodedRngBuf();
  145.     HX_DELETE(m_pDecodedRngBuf);
  147.     HX_DELETE(m_pDecoder);
  149.     _Reset();
  151.     if (m_pInputAllocator)
  152.     {
  153.         m_pInputAllocator->Release();
  154.         m_pInputAllocator = NULL;
  155.     }
  156.     HX_DELETE(m_pCodecOutputBIH);
  158. }
  161. /****************************************************************************
  162.  *  Method:
  163.  *    CRVXVideoFormat::Init
  164.  */
  165. HX_RESULT CRVXVideoFormat::Init(IHXValues* pHeader)
  166. {
  167.     HX_RESULT retVal = CVideoFormat::Init(pHeader);
  169.     m_bFlushingToKeyFrame = FALSE;
  171.     // Create Decode callback to caller ring buffer
  172.     if (SUCCEEDED(retVal))
  173.     {
  174. m_pDecodedRngBuf = new CRingBuffer(DECODE_CALLBACK_RNGBUF_SIZE);
  175. retVal = HXR_OUTOFMEMORY;
  176. if (m_pDecodedRngBuf)
  177. {
  178.     retVal = HXR_OK;
  179. }
  180.     }
  182.     // Create memory allocators
  183.     if (SUCCEEDED(retVal))
  184.     {
  185. retVal = CreateAllocators();
  186.     }
  188.     // Create Packet Assembler
  189.     if (SUCCEEDED(retVal))
  190.     {
  191. retVal = HXR_OUTOFMEMORY;
  192. m_pRssm = new RVXPayloadFormat(m_pInputAllocator);
  193. if (m_pRssm)
  194. {
  195.     m_pRssm->AddRef();
  196.     retVal = HXR_OK;
  197. }
  198.     }
  199.     
  200.     // Create Decoder
  201.     if (SUCCEEDED(retVal))
  202.     {
  203. retVal = HXR_OUTOFMEMORY;
  204. m_pDecoder = CreateDecoder();
  205. if (m_pDecoder)
  206. {
  207.     retVal = HXR_OK;
  208. }
  209.     }
  211.     // Initialize Assembler
  212.     if (SUCCEEDED(retVal) && m_pRssm)
  213.     {
  214. retVal = m_pRssm->Init(m_pRVXVideoRenderer->GetContext(), 
  215.        FALSE);
  216.     }
  217.     
  218.     if (SUCCEEDED(retVal) && m_pRssm)
  219.     {
  220. retVal = m_pRssm->SetStreamHeader(pHeader);
  222. if (retVal == HXR_NO_DATA)
  223. {
  224.     retVal = HXR_OK;
  225. }
  227. #ifdef _IGNORE_UNSUPPORTED
  228. if (FAILED(retVal))
  229. {
  230.     HXxSize nullViewFrame = {1, 1};
  231.     m_pRVXVideoRenderer->ResizeViewFrame(nullViewFrame);
  232.     HX_RELEASE(m_pRssm);
  233.     retVal = HXR_OK;
  234. }
  235. #endif // _IGNORE_UNSUPPORTED
  237.     }
  239.     // Initialize Decoder
  240.     if (SUCCEEDED(retVal) && m_pRssm)
  241.     {
  242. retVal = m_pDecoder->Init(m_pRVXVideoRenderer->GetContext(),
  243.   this,
  244.   NULL,
  245.   m_pInputAllocator,
  246.   m_pRVXVideoRenderer->m_pOutputAllocator);
  248. if (SUCCEEDED(retVal))
  249. {
  250.     HX_MOF* pImageInfo;
  251.     
  252.     if (m_pDecoder->GetImageInfo(pImageInfo) == HXR_OK)
  253.     {
  254. retVal = SetupOutputFormat(pImageInfo, m_pDecoder->GetMofTagIn());
  256. if (SUCCEEDED(retVal))
  257. {
  258.     if ((m_sMediaSize.cx != 0) && (m_sMediaSize.cy != 0))
  259.     {
  260. m_pRVXVideoRenderer->ResizeViewFrame(m_sMediaSize);
  261.     }
  262. }
  263.     }
  264. }
  266. #ifdef _IGNORE_UNSUPPORTED
  267. if (FAILED(retVal))
  268. {
  269.     HXxSize nullViewFrame = {1, 1};
  270.     m_pRVXVideoRenderer->ResizeViewFrame(nullViewFrame);
  271.     HX_RELEASE(m_pRssm);
  272.     retVal = HXR_OK;
  273. }
  274. #endif // _IGNORE_UNSUPPORTED
  275.     }
  277.     m_bFirstDecode = TRUE;
  279.     m_ulMaxDecodedFrames = GetMaxDecodedFrames();
  281.     return retVal;
  282. }
  285. /****************************************************************************
  286.  *  Method:
  287.  *    CRVXVideoFormat::SetupOutputFormat
  288.  *
  289.  */
  290. HX_RESULT
  291. CRVXVideoFormat::SetupOutputFormat(HX_MOF* pMof, HX_MOFTAG moftagIn)
  292. {
  293.     HX_RESULT pnr = HXR_OK;
  294.     HX_FORMAT_IMAGE* pMofOutI = (HX_FORMAT_IMAGE*) pMof;
  296.     if (!m_pCodecOutputBIH)
  297.     {
  298. m_pCodecOutputBIH = new HXBitmapInfoHeader;
  299. if (!m_pCodecOutputBIH)
  300. {
  301.     return HXR_OUTOFMEMORY;
  302. }
  303.     }
  305.     m_pRVXVideoRenderer->m_ulPadWidthLeft = 0;
  306.     m_pRVXVideoRenderer->m_ulPadWidthRight = 0;
  307.     m_pRVXVideoRenderer->m_ulPadHeightTop = 0;
  308.     m_pRVXVideoRenderer->m_ulPadHeightBottom = 0;
  310.     m_sMediaSize.cy = pMofOutI->uiHeight;
  311.     m_sMediaSize.cx = pMofOutI->uiWidth;
  313.     m_pCodecOutputBIH->biWidth = pMofOutI->uiWidth;
  314.     m_pCodecOutputBIH->biHeight = pMofOutI->uiHeight;
  315.     m_pCodecOutputBIH->biPlanes = 1;
  316.  
  317.     switch(pMofOutI->submoftag)
  318.     {
  319.         case HX_RGB3_ID:
  320.         {
  321.             m_pCodecOutputBIH->biBitCount = pMofOutI->uiBitCount;
  322.             m_pCodecOutputBIH->biCompression = BI_RGB;
  323.         }
  324.         break;
  325.         case HX_YUV420_ID:
  326.         {
  327.             // fix up CLV1 screwed up bitcount
  328.             if (moftagIn == HX_CLEARVIDEO_ID)
  329.             {
  330.                 pMofOutI->uiBitCount = 12;
  331.             }
  333.             HX_ASSERT(pMofOutI->uiBitCount == 12);
  335.             m_pCodecOutputBIH->biBitCount = pMofOutI->uiBitCount;
  336.             m_pCodecOutputBIH->biCompression = HX_I420;
  337.         
  338.             if (pMofOutI->moftag == HX_MEDIA_IMAGE2)
  339.             {
  340.                 HX_FORMAT_IMAGE2* pMofOutI2 = (HX_FORMAT_IMAGE2*)pMof;
  342.                 // if we are getting YUV out, it is a format image 2 struct
  343.                 // and we need to include padding in this width and height
  344. m_pRVXVideoRenderer->m_ulPadWidthLeft = pMofOutI2->uiPadWidthLeft;
  345. m_pRVXVideoRenderer->m_ulPadWidthRight = pMofOutI2->uiPadWidthRight;
  346. m_pRVXVideoRenderer->m_ulPadHeightTop = pMofOutI2->uiPadHeightTop;
  347. m_pRVXVideoRenderer->m_ulPadHeightBottom = pMofOutI2->uiPadHeightBottom;
  348.             }
  349.         }
  350.         break;
  351. #ifdef _WINDOWS
  352.         case HX_RGB555_ID:
  353.         {
  354.             HX_ASSERT(pMofOutI->uiBitCount == 16);
  355.             m_pCodecOutputBIH->biBitCount = pMofOutI->uiBitCount;
  356.             m_pCodecOutputBIH->biCompression = BI_BITFIELDS;
  358.             m_pCodecOutputBIH->rcolor =   0x00007C00; // red
  359.             m_pCodecOutputBIH->gcolor =   0x000003E0; // green
  360.             m_pCodecOutputBIH->bcolor =   0x0000001F; // blue
  361.         }
  362.         break;
  363.         case HX_RGB565_ID:
  364.         {
  365.             HX_ASSERT(pMofOutI->uiBitCount == 16);
  366.             m_pCodecOutputBIH->biBitCount = pMofOutI->uiBitCount;
  367.             m_pCodecOutputBIH->biCompression = BI_BITFIELDS;
  368.             m_pCodecOutputBIH->rcolor =    0x0000F800; // red
  369.             m_pCodecOutputBIH->gcolor =    0x000007E0; // green
  370.             m_pCodecOutputBIH->bcolor =    0x0000001F; // blue
  371.         }
  372.         break;
  373. #endif
  374.         default:
  375.             pnr = HXR_DEC_TYPE_MISMATCH;
  376.     }
  378.     m_pCodecOutputBIH->biWidth += (m_pRVXVideoRenderer->m_ulPadWidthLeft + 
  379.    m_pRVXVideoRenderer->m_ulPadWidthRight);
  380.     m_pCodecOutputBIH->biHeight += (m_pRVXVideoRenderer->m_ulPadHeightTop + 
  381.     m_pRVXVideoRenderer->m_ulPadHeightBottom);
  382.     m_pCodecOutputBIH->biSizeImage =
  383. m_pCodecOutputBIH->biWidth * m_pCodecOutputBIH->biBitCount * 
  384. m_pCodecOutputBIH->biHeight / 8;
  386.     return pnr;
  387. }
  390. /****************************************************************************
  391.  *  Method:
  392.  *    CRVXVideoFormat::GetDefaultPreroll
  393.  *
  394.  */
  395. ULONG32 CRVXVideoFormat::GetDefaultPreroll(IHXValues* pValues)
  396. {
  397.     return RVXV_DEFAULT_PREROLL;
  398. }
  401. /****************************************************************************
  402.  *  Method:
  403.  *    CRVXVideoFormat::GetBitstreamHeaderSize
  404.  */
  405. ULONG32 CRVXVideoFormat::GetBitstreamHeaderSize(void)
  406. {
  407.     ULONG32 ulSize = 0;
  409.     if (m_pRssm)
  410.     {
  411. ulSize = m_pRssm->GetBitstreamHeaderSize();
  412.     }
  414.     return ulSize;
  415. }
  418. /****************************************************************************
  419.  *  Method:
  420.  *    CRVXVideoFormat::GetBitstreamHeader
  421.  */
  422. const HX_MOF* CRVXVideoFormat::GetBitstreamHeader(void)
  423. {
  424.     const HX_MOF* pHeader = NULL;
  426.     if (m_pRssm)
  427.     {
  428. pHeader = m_pRssm->GetBitstreamHeader();
  429.     }
  431.     return pHeader;
  432. }
  435. /****************************************************************************
  436.  *  Method:
  437.  *    CVideoFormat::GetMaxDecodedFrames
  438.  *
  439.  */
  440. ULONG32 CRVXVideoFormat::GetMaxDecodedFrames(void)
  441. {
  442.     return MAX_BUFFERED_DECODED_RV_FRAMES;
  443. }
  446. /****************************************************************************
  447.  *  Method:
  448.  *    CRVXVideoFormat::CreateAssembledPacket
  449.  */
  450. CMediaPacket* CRVXVideoFormat::CreateAssembledPacket(IHXPacket* pCodecData)
  451. {
  452.     HXCODEC_DATA* pCodecPacket = NULL;
  453.     CMediaPacket* pFramePacket = NULL;
  454.     IHXPacket* pPacket = NULL;
  455.     HX_RESULT retVal = HXR_OK;
  457. #ifdef _IGNORE_UNSUPPORTED
  458.     if (!m_pRssm)
  459.     {
  460. return NULL;
  461.     }
  462. #endif // _IGNORE_UNSUPPORTED
  464.     m_pRVXVideoRenderer->BltIfNeeded();
  466.     retVal = m_pRssm->SetPacket(pCodecData);
  467.     if( retVal == HXR_OUTOFMEMORY )
  468.     {
  469.         m_LastError = HXR_OUTOFMEMORY;
  470.         return NULL;
  471.     }
  472.     m_pRssm->CreateHXCodecPacket(pCodecPacket);
  474.     
  475.     while (pCodecPacket)
  476.     {
  477.         CheckPacketBuffer(pCodecPacket);
  479. pFramePacket = new CMediaPacket(
  480. pCodecPacket,
  481. (UINT8*) pCodecPacket, 
  482. pCodecPacket->dataLength,
  483. pCodecPacket->dataLength,
  484. pCodecPacket->timestamp,
  485. pCodecPacket->flags, //0,
  486. NULL);
  488. if (pFramePacket == NULL)
  489. {
  490.     HX_ASSERT(HXR_OUTOFMEMORY == HXR_OK);
  491.     KillInputBuffer(pCodecPacket, this);
  492.             m_LastError = HXR_OUTOFMEMORY;
  493.             return NULL;
  494. }
  495. else
  496. {
  497.     pFramePacket->SetBufferKiller(KillInputBuffer);
  498.     pFramePacket->m_pUserData = this;
  500.     // Report missing frames as dropped
  501.     if (m_ulLastSequenceNumber != UNINITIALIZED_SEQ_NUMBER)
  502.     {
  503. UINT16 uFramesDropped = pCodecPacket->sequenceNum -
  504. ((UINT16) m_ulLastSequenceNumber) - 1;
  505. if (uFramesDropped != 0)
  506. {
  507.     if (m_pRVXVideoRenderer->IsActive() ||
  508. (((LONG32) (pCodecPacket->timestamp - GetStartTime())) > 0))
  509.     {
  510. m_pRVXVideoRenderer->ReportDroppedFrame(uFramesDropped);
  511.     }
  512. }
  513.     }
  514.     
  515.     m_ulLastSequenceNumber = (ULONG32) pCodecPacket->sequenceNum;
  516. }
  518. m_pRVXVideoRenderer->BltIfNeeded();
  520. pCodecPacket = NULL;
  521. m_pRssm->CreateHXCodecPacket(pCodecPacket);
  523. if (pCodecPacket)
  524. {
  525.     ReturnAssembledPacket(pFramePacket);
  526.     pFramePacket = NULL;
  527. }
  528.     }
  529.     
  530.     return pFramePacket;
  531. }
  534. /****************************************************************************
  535.  *  Method:
  536.  *    CRVXVideoFormat::Reset
  537.  */
  538. void CRVXVideoFormat::Reset()
  539. {
  540.     _Reset();
  541.     CVideoFormat::Reset();
  542. }
  544. void CRVXVideoFormat::_Reset(void)
  545. {
  546.     if (m_pRssm)
  547.     {
  548. m_pRssm->Reset();
  549.     }
  551.     m_bFirstDecode = TRUE;
  552.     m_ulWidthContainedInSegment = 0;
  553.     m_ulHeightContainedInSegment = 0;
  554.     m_ulLastSequenceNumber = UNINITIALIZED_SEQ_NUMBER;
  555. }
  557. void CRVXVideoFormat::FlushDecodedRngBuf(void)
  558. {
  559.     if (m_pDecodedRngBuf)
  560.     {
  561. HXCODEC_DATA* pFrame;
  563. while (pFrame = ((HXCODEC_DATA*) m_pDecodedRngBuf->Get()))
  564. {
  565.     ReleaseDecodedPacket(pFrame);
  566. }
  567.     }
  568. }
  570. void CRVXVideoFormat::ReleaseDecodedPacket(HXCODEC_DATA* &pDecodedPacket)
  571. {
  572.     HX_ASSERT(pDecodedPacket);
  574.     if (pDecodedPacket)
  575.     {
  576. ULONG32* pFrameData = (ULONG32*) pDecodedPacket;
  578. if (pDecodedPacket->data && 
  579.     m_pRVXVideoRenderer && 
  580.     m_pRVXVideoRenderer->m_pOutputAllocator)
  581. {
  582.     m_pRVXVideoRenderer->m_pOutputAllocator->ReleasePacketPtr(pDecodedPacket->data);
  583. }
  585. delete [] pFrameData;
  586. pDecodedPacket = NULL;
  587.     }
  588. }
  591. /****************************************************************************
  592.  *  Method:
  593.  *    CRVXVideoFormat::CreateDecodedPacket
  594.  *
  595.  */
  596. CMediaPacket* CRVXVideoFormat::CreateDecodedPacket(CMediaPacket* pFrameToDecode)
  597. {
  598.     HXCODEC_DATA* pDecodedPacket = NULL;
  599.     CMediaPacket* pDecodedFrame = NULL;
  600.     UINT8* pData = NULL;
  601.     BOOL bFrameDecoded = FALSE;
  603.     HX_ASSERT(pFrameToDecode);
  605. #if defined(HELIX_FEATURE_VIDEO_REAL_DISCARD_LATE_ENCODED_FRAMES)
  606. // discard late frames before they are decoded
  607. BOOL bDecodeThisOne = TRUE;
  609.     if (m_pRVXVideoRenderer->IsActive()) // if playing
  610.     {
  611.         LONG32 lTimeAhead = m_pRVXVideoRenderer->ComputeTimeAhead(
  612.     pFrameToDecode->m_ulTime, 0); 
  613.         if (pFrameToDecode->m_ulFlags & HX_KEYFRAME_FLAG)
  614.         {
  615.             if (lTimeAhead < MAX_KEY_CODED_FRAME_FALLBEHIND)
  616.             {
  617.                 // Treat it as non key-frame: drop it
  618.                 bDecodeThisOne = FALSE;
  619.                 m_bFlushingToKeyFrame = TRUE;
  620.             }
  621.     else
  622.     { // we're going to display this key frame, so stop flushing
  623. m_bFlushingToKeyFrame = FALSE;
  624.     }
  625.         }
  626.         else
  627.         {
  628.             if (lTimeAhead < MAX_NONKEY_CODED_FRAME_FALLBEHIND)
  629.             { // discard this frame and all frames to the next key frame
  630.                 bDecodeThisOne = FALSE;
  631.                 m_bFlushingToKeyFrame = TRUE;
  632.             }
  633.     else
  634.     {
  635.     }
  636.         }
  637.     }
  638.     else
  639.     { // we're not playing, so decode when we start playing
  640. m_bFlushingToKeyFrame = FALSE;
  641.     }
  643.     if (bDecodeThisOne && !m_bFlushingToKeyFrame)
  644.     { // decode and display this frame
  645. ;
  646.     }
  647.     else
  648.     { // discard this frame before decode
  649. pFrameToDecode->Clear();
  650. delete pFrameToDecode; 
  651. m_pRVXVideoRenderer->ReportDroppedFrame();
  652. return NULL;
  653.     }
  654. #endif // HELIX_FEATURE_VIDEO_REAL_DISCARD_LATE_ENCODED_FRAMES
  657.     if (m_bFirstDecode)
  658.     {
  659. m_bFirstDecode = FALSE;
  660. FlushDecodedRngBuf();
  661. m_pDecoder->ResetSequence(GetStartTime());
  662.     }
  664.     pDecodedPacket = (HXCODEC_DATA*) m_pDecodedRngBuf->Get();
  666.     m_pRVXVideoRenderer->BltIfNeeded();
  669.     HX_RESULT retVal = m_pDecoder->Decode(pFrameToDecode, MAX_DECODE_QUALITY);
  671.     if( retVal == HXR_OUTOFMEMORY )
  672.     {
  673.         m_LastError = HXR_OUTOFMEMORY;
  674.         return NULL;
  675.     }
  676.     else
  677.     {
  678. do
  679. {
  680.     if (pDecodedPacket == NULL)
  681.     {
  682. pDecodedPacket = (HXCODEC_DATA*) m_pDecodedRngBuf->Get();
  683.     }
  685.     bFrameDecoded = (pDecodedPacket != NULL);
  687. #if !defined(HELIX_FEATURE_VIDEO_REAL_DISCARD_LATE_ENCODED_FRAMES)
  688. // don't discard decoded frames
  689.     if (pDecodedPacket)
  690.     {
  691. if (m_pRVXVideoRenderer->IsActive() &&
  692.     (m_pRVXVideoRenderer->ComputeTimeAhead(
  693. pDecodedPacket->timestamp, 
  694. 0) 
  695.      < -NON_KEYFRM_DCDE_FALLBEHIND_THRSHLD))
  696. {
  697.     ReleaseDecodedPacket(pDecodedPacket);
  698.     m_pRVXVideoRenderer->ReportDroppedFrame();
  699. }
  700.     }
  701. #endif // HELIX_FEATURE_VIDEO_REAL_DISCARD_LATE_ENCODED_FRAMES
  703. } while ((!pDecodedPacket) && bFrameDecoded);
  705. if (pDecodedPacket)
  706. {
  707.     CMediaPacket* pVideoPacket = NULL;
  709.     pVideoPacket = (CMediaPacket*) m_pFramePool->Get(0);
  711.     if (pVideoPacket == NULL)
  712.     {
  713. pVideoPacket = pFrameToDecode;
  714. pFrameToDecode = NULL;
  715.     }
  717.     if (pVideoPacket)
  718.     {
  719. pVideoPacket->SetBuffer(pDecodedPacket->data,
  720. pDecodedPacket->data,
  721. pDecodedPacket->dataLength,
  722. pDecodedPacket->dataLength,
  723. FALSE);
  725. pVideoPacket->Init(pDecodedPacket->data,
  726.    pDecodedPacket->dataLength,
  727.    pDecodedPacket->timestamp,
  728.    pDecodedPacket->flags,
  729.    pDecodedPacket); // sample description
  731. // Data is now linked through VideoPacket
  732. pDecodedPacket->data = NULL;
  733. pDecodedPacket->dataLength = 0;
  735. pVideoPacket->SetBufferKiller(KillOutputBuffer);
  736. pVideoPacket->SetSampleDescKiller(KillRVXSampleDesc);
  737. pVideoPacket->m_pUserData = m_pRVXVideoRenderer;
  739. pDecodedPacket = NULL;
  741. pDecodedFrame = pVideoPacket;
  742. pVideoPacket = NULL;
  743.     }
  745.     if (pVideoPacket)
  746.     {
  747. delete pVideoPacket;
  748.     }
  749. }
  750.     }
  752.     if (pFrameToDecode != NULL)
  753.     {
  754. pFrameToDecode->Clear(); 
  755. delete pFrameToDecode;
  756.     }
  758.     if (pDecodedPacket)
  759.     {
  760. ReleaseDecodedPacket(pDecodedPacket);
  761.     }
  764.     return pDecodedFrame;
  765. }
  767. CRVXVDecoder* CRVXVideoFormat::CreateDecoder()
  768. {
  769.     return new CRVXVDecoder();
  770. }
  772. /****************************************************************************
  773.  *  Method:
  774.  *    CRVXVideoFormat::DecodeDone
  775.  */
  776. HX_RESULT CRVXVideoFormat::DecodeDone(HXCODEC_DATA* pData)
  777. {
  778.     HX_RESULT retVal = HXR_OK;
  780.     m_pRVXVideoRenderer->BltIfNeeded();
  782.     if (pData)
  783.     {
  784. ULONG32 ulFrameSize = HXCODEC_PTR_POPULATED_SIZE(pData);
  785. HXCODEC_DATA* pFrame = (HXCODEC_DATA*) new ULONG32[ulFrameSize / 4 + 1];
  787. if (pFrame)
  788. {
  789.     memcpy(pFrame, pData, ulFrameSize); /* Flawfinder: ignore */
  791.     if (!m_pDecodedRngBuf->Put(pFrame))
  792.     {
  793. ReleaseDecodedPacket(pFrame);
  794. m_pRVXVideoRenderer->ReportDroppedFrame();
  795.     }
  796. }
  797. else
  798. {
  799.     if (pData->data)
  800.     {
  801. m_pRVXVideoRenderer->m_pOutputAllocator->ReleasePacketPtr(
  802.     pData->data);
  803. m_pRVXVideoRenderer->ReportDroppedFrame();
  804.     }
  805. }
  806.     }
  808.     return retVal;
  809. }
  812. /****************************************************************************
  813.  *  Method:
  814.  *    CRVXVideoFormat::IsBitmapFormatChanged
  815.  *
  816.  */
  817. BOOL CRVXVideoFormat::IsBitmapFormatChanged(
  818.     HXBitmapInfoHeader &BitmapInfoHeader,
  819.     CMediaPacket* pVideoPacket)
  820. {
  821.     BOOL bRetVal = (m_ulWidthContainedInSegment == 0);
  822.     HXCODEC_DATA* pData = (HXCODEC_DATA*) pVideoPacket->m_pSampleDesc;
  824.     if (pData &&
  825. (pData->flags & HX_SEGMENT_CONTAINS_OUTPUT_SIZE_FLAG))
  826.     {
  827. bRetVal = (bRetVal ||
  828.     ((m_ulWidthContainedInSegment != pData->Segments[1].ulSegmentOffset) ||
  829.      (m_ulHeightContainedInSegment != ((ULONG32) pData->Segments[1].bIsValid))));
  830.     }
  832.     return bRetVal;
  833. }
  836. /****************************************************************************
  837.  *  Method:
  838.  *    CRVXVideoFormat::InitBitmapInfoHeader
  839.  */
  840. HX_RESULT CRVXVideoFormat::InitBitmapInfoHeader(
  841.     HXBitmapInfoHeader &bitmapInfoHeader,
  842.     CMediaPacket* pVideoPacket)
  843. {
  844.     if (m_pCodecOutputBIH)
  845.     {
  846. HXCODEC_DATA* pData = (HXCODEC_DATA*) pVideoPacket->m_pSampleDesc;
  848. if (pData && (pData->flags & HX_SEGMENT_CONTAINS_OUTPUT_SIZE_FLAG))
  849. {
  850.     if ((m_ulWidthContainedInSegment != pData->Segments[1].ulSegmentOffset) ||
  851.         (m_ulHeightContainedInSegment != ((ULONG32) pData->Segments[1].bIsValid)))
  852.     {
  853. m_pCodecOutputBIH->biWidth =  m_ulWidthContainedInSegment = 
  854.     pData->Segments[1].ulSegmentOffset;
  855. m_pCodecOutputBIH->biHeight = m_ulHeightContainedInSegment = 
  856.     ((ULONG32) pData->Segments[1].bIsValid);
  858. m_pCodecOutputBIH->biWidth += (m_pRVXVideoRenderer->m_ulPadWidthLeft + 
  859.        m_pRVXVideoRenderer->m_ulPadWidthRight);
  860. m_pCodecOutputBIH->biHeight += (m_pRVXVideoRenderer->m_ulPadHeightTop + 
  861. m_pRVXVideoRenderer->m_ulPadHeightBottom);
  862. m_pCodecOutputBIH->biSizeImage =
  863.     m_pCodecOutputBIH->biWidth * m_pCodecOutputBIH->biBitCount * 
  864.     m_pCodecOutputBIH->biHeight / 8;
  865.     }
  866. }
  867. else
  868. {
  869.     m_ulWidthContainedInSegment = m_pCodecOutputBIH->biWidth;
  870.     m_ulHeightContainedInSegment = m_pCodecOutputBIH->biHeight;
  871. }
  872.          
  873. bitmapInfoHeader = *m_pCodecOutputBIH;
  874.     }
  876.     return HXR_OK;
  877. }
  880. /****************************************************************************
  881.  *  Method:
  882.  *    CRVXVideoFormat::CreateAllocators()
  883.  */
  884. HX_RESULT CRVXVideoFormat::CreateAllocators(void)
  885. {
  886.     HX_RESULT retVal = HXR_OK;
  887.     HX20ALLOCPROPS allocRequest, allocActual;
  889.     if (m_pInputAllocator)
  890.     {
  891.         m_pInputAllocator->Release();
  892.         m_pInputAllocator = NULL;
  893.     }
  894.     if (m_pRVXVideoRenderer->m_pOutputAllocator)
  895.     {
  896.         m_pRVXVideoRenderer->m_pOutputAllocator->Release();
  897.         m_pRVXVideoRenderer->m_pOutputAllocator = NULL;
  898.     }
  899.     
  900.     // setup the input allocator for the codec
  901.     if (retVal == HXR_OK)
  902.     {
  903. m_pInputAllocator = new CHXMemoryAllocator(TRUE);
  905. retVal = HXR_OUTOFMEMORY;
  906. if (m_pInputAllocator)
  907. {
  908.     m_pInputAllocator->AddRef();
  909.     m_pInputAllocator->GetProperties(&allocRequest);
  910.     allocRequest.nNumBuffers = 0;   // No retention
  911.     m_pInputAllocator->SetProperties(&allocRequest, 
  912.      &allocActual);
  913.     retVal = HXR_OK;
  914. }
  915.     }
  917.     // setup the output allocator for the codec
  918.     if (retVal == HXR_OK)
  919.     {
  920. m_pRVXVideoRenderer->m_pOutputAllocator = new CHXMemoryAllocator(TRUE);
  922. retVal = HXR_OUTOFMEMORY;
  923. if (m_pRVXVideoRenderer->m_pOutputAllocator)
  924. {
  925.     m_pRVXVideoRenderer->m_pOutputAllocator->AddRef();
  926.     m_pRVXVideoRenderer->m_pOutputAllocator->GetProperties(&allocRequest);
  927.     allocRequest.nNumBuffers = GetMaxDecodedFrames() * 2;
  928.     m_pRVXVideoRenderer->m_pOutputAllocator->SetProperties(&allocRequest, 
  929. &allocActual);
  930.     retVal = HXR_OK;
  931. }
  932.     }
  934. #if _MACINTOSH
  935.     // TODO: we want to pre-allocate the output buffers here so they come
  936.     // from the standard memory pools instead of the interrupt memory
  937.     // pools.
  938. #endif // _MACINTOSH
  940.     return retVal;
  941. }
  944. /****************************************************************************
  945.  *  Method:
  946.  *    CMP4VideoFormat::KillRVXSampleDesc
  947.  *
  948.  */
  949. void CRVXVideoFormat::KillRVXSampleDesc(void* pSampleDesc, void* pUserData)
  950. {
  951.     if (pSampleDesc)
  952.     {
  953. HXCODEC_DATA* pFrame = (HXCODEC_DATA*) pSampleDesc;
  954. ULONG32* pFrameData = (ULONG32*) pFrame;
  956. if (pFrame->data)
  957. {
  958.     KillOutputBuffer(pFrame->data, pUserData);
  959. }
  961. delete [] pFrameData;
  962.     }
  963. }
  966. /****************************************************************************
  967.  *  Method:
  968.  *    CRVXVideoFormat::KillInputBuffer
  969.  *
  970.  */
  971. void CRVXVideoFormat::KillInputBuffer(void* pBuffer, void* pUserData)
  972. {
  973.     if (pBuffer)
  974.     {
  975. HXCODEC_DATA* pDeadData = (HXCODEC_DATA*) pBuffer;
  976. CRVXVideoFormat* pVidFmt = (CRVXVideoFormat*) pUserData;
  978. HX_ASSERT(pUserData);
  980. if (pDeadData->data)
  981. {
  982.     pVidFmt->m_pInputAllocator->ReleasePacketPtr(pDeadData->data);
  983.     pDeadData->data = NULL;
  984. }
  986. if (pVidFmt->m_pRssm)
  987. {
  988.     pVidFmt->m_pRssm->DisposeHXCodecPacket(pDeadData);
  989. }
  990.     }
  991. }
  994. /****************************************************************************
  995.  *  Method:
  996.  *    CRVXVideoFormat::KillOutputBuffer
  997.  *
  998.  */
  999. void CRVXVideoFormat::KillOutputBuffer(void* pBuffer, void* pUserData)
  1000. {
  1001.     if (pBuffer)
  1002.     {
  1003. CRVXVideoRenderer* pVidRnd = (CRVXVideoRenderer*) pUserData;
  1004. HX_ASSERT(pUserData);
  1006. if (NULL == pVidRnd || NULL == pVidRnd->m_pOutputAllocator)
  1007.     return;
  1009. pVidRnd->m_pOutputAllocator->ReleasePacketPtr((UINT8*) pBuffer);
  1010.     }
  1011. }