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

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

Symbian

开发平台：

C/C++

vidrendf.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. #ifdef ENABLE_TRACE
  37. #define HX_TRACE_THINGY(x, m, l)
  38.     {
  39. FILE* f1;
  40. f1 = ::fopen(x, "a+");
  41. (f1)?(::fprintf(f1, "%ld - %s = %ld n", HX_GET_BETTERTICKCOUNT(), m, l), ::fclose(f1)):(0);
  42.     }
  43. #define STAMPBUF(x, m)
  44.     {
  45. FILE* f1;
  46. f1 = ::fopen(x, "a+");
  47. (f1)?(::fprintf(f1, "%ld - %sn", HX_GET_BETTERTICKCOUNT(), m), ::fclose(f1)):(0);
  48.     }
  49. #else // ENABLE_TRACE
  50. #define HX_TRACE_THINGY(x, m, l)
  52. #ifdef MEASURE_PERF
  53. #define LOGBUFFSIZE 100000
  54. char textmem[LOGBUFFSIZE];
  55. char *textptr = textmem;
  56. #define STAMPBUF(x, txt) { if (textptr - textmem < LOGBUFFSIZE) textptr += SafeSprintf(textptr, LOGBUFFSIZE - (textptr - textmem), "%s: %ld*n", txt, HX_GET_BETTERTICKCOUNT()); }
  57. #else // MEASURE_PERF
  58. #define STAMPBUF(x, txt)
  59. #endif // MEASURE_PERF
  61. #endif // ENABLE_TRACE
  63. /****************************************************************************
  64.  *  Defines
  65.  */
  66. #if !defined(HELIX_FEATURE_MIN_HEAP)
  67. #define MAX_BUFFERED_DECODED_FRAMES 12
  68. #else // HELIX_FEATURE_MIN_HEAP
  69. #define MAX_BUFFERED_DECODED_FRAMES 2
  70. #endif // HELIX_FEATURE_MIN_HEAP
  72. #if defined(HELIX_FEATURE_MIN_HEAP)
  73. #define FORMAT_MINIMUM_PREROLL 1000
  74. #define FORMAT_DEFAULT_PREROLL 2000
  75. #define FORMAT_MAXIMUM_PREROLL 3000
  76. #else
  77. #define FORMAT_MINIMUM_PREROLL 3000
  78. #define FORMAT_DEFAULT_PREROLL 5000
  79. #define FORMAT_MAXIMUM_PREROLL 15000
  80. #endif
  82. #define MAX_DECODE_SPIN 100
  85. /****************************************************************************
  86.  *  Includes
  87.  */
  88. #include "vidrendf.h"
  89. #include "vidrend.h"
  90. #include "hxtick.h"
  91. #include "hxassert.h"
  92. #include "hxstrutl.h"
  95. /****************************************************************************
  96.  *  Debug
  97.  */
  98. #ifdef ENABLE_FRAME_TRACE
  99. #define MAX_FRAME_TRACE_ENTRIES 100000
  100. ULONG32 ulFrameTraceIdx = 0;
  101. LONG32 frameTraceArray[MAX_FRAME_TRACE_ENTRIES][3];
  103. void DumpFrameEntries(void)
  104. {
  105.     FILE* pFile = NULL;
  106.     ULONG32 ulIdx;
  108.     if (ulFrameTraceIdx > 0)
  109.     {
  110. pFile = fopen("c:\buf.txt", "wb");
  111.     }
  113.     if (pFile)
  114.     {
  115. for (ulIdx = 0; ulIdx < ulFrameTraceIdx; ulIdx++)
  116. {
  117.     fprintf(pFile, "%c(%d) = %xn", (char) frameTraceArray[ulIdx][1], 
  118.    frameTraceArray[ulIdx][2], 
  119.    frameTraceArray[ulIdx][0]);
  120. }
  122. fclose(pFile);
  123.     }
  125.     ulFrameTraceIdx = 0;
  126. }
  127. #endif // ENABLE_FRAME_TRACE
  130. /****************************************************************************
  131.  *  Method:
  132.  *    CVideoFormat::CVideoFormat
  133.  *
  134.  */
  135. CVideoFormat::CVideoFormat(IHXCommonClassFactory* pCommonClassFactory,
  136.    CVideoRenderer* pVideoRenderer)
  137. : m_pCommonClassFactory(pCommonClassFactory)
  138. , m_pVideoRenderer(pVideoRenderer)
  139. , m_pMutex(NULL)
  140. , m_pAssemblerMutex(NULL)
  141. , m_pOutputQueue(NULL)
  142. , m_pFramePool(NULL)
  143. , m_lMaxBufferedDecodedFrames(MAX_BUFFERED_DECODED_FRAMES)
  144. , m_pHeader(NULL)
  145. , m_ulStartTime(0)
  146. , m_bDecodeSuspended(FALSE)
  147. , m_bRawPacketsDone(FALSE)
  148. , m_lRefCount(0)
  149. , m_LastError(HXR_OK)
  150. {
  151.     HX_ASSERT(m_pCommonClassFactory);
  153.     m_pCommonClassFactory->AddRef();
  154.     m_pVideoRenderer->AddRef();
  156. #ifdef THREADS_SUPPORTED
  157.     HXMutex::MakeMutex(m_pMutex);
  158.     HXMutex::MakeMutex(m_pAssemblerMutex);
  159.     HXMutex::MakeMutex(m_pDecoderMutex);
  160. #else
  161.     HXMutex::MakeStubMutex(m_pMutex);
  162.     HXMutex::MakeStubMutex(m_pAssemblerMutex);
  163.     HXMutex::MakeStubMutex(m_pDecoderMutex);
  164. #endif
  165. }
  168. /****************************************************************************
  169.  *  Method:
  170.  *    CVideoFormat::~CVideoFormat
  171.  *
  172.  */
  173. CVideoFormat::~CVideoFormat()
  174. {
  175.     _Reset();
  177.     HX_DELETE(m_pFramePool);
  178.     HX_DELETE(m_pOutputQueue);
  180.     HX_DELETE(m_pMutex);
  181.     HX_DELETE(m_pAssemblerMutex);
  182.     HX_DELETE(m_pDecoderMutex);
  184.     HX_RELEASE(m_pHeader);
  185.     HX_RELEASE(m_pVideoRenderer);
  186.     HX_RELEASE(m_pCommonClassFactory);
  188. #ifdef ENABLE_FRAME_TRACE
  189.     DumpFrameEntries();
  190. #endif // ENABLE_FRAME_TRACE
  191. }
  194. /****************************************************************************
  195.  *  Method:
  196.  *    CVideoFormat::Init
  197.  *
  198.  */
  199. HX_RESULT CVideoFormat::Init(IHXValues* pHeader)
  200. {
  201.     HX_RESULT retVal = HXR_OK;
  203.     HX_RELEASE(m_pHeader);
  204.     m_pHeader = pHeader;
  205.     if (m_pHeader)
  206.     {
  207. m_pHeader->AddRef();
  208.     }
  210.     if (SUCCEEDED(retVal))
  211.     {
  212. m_pFramePool = CreateBufferPool();
  213.     }
  215.     if (SUCCEEDED(retVal))
  216.     {
  217. m_lMaxBufferedDecodedFrames = GetMaxDecodedFrames();
  219. FlushOutputQueue();
  220. HX_DELETE(m_pOutputQueue);
  222. m_pOutputQueue = new CRingBuffer(m_lMaxBufferedDecodedFrames);
  224. retVal = HXR_OUTOFMEMORY;
  225. if (m_pOutputQueue)
  226. {
  227.     retVal = HXR_OK;
  228. }
  229.     }
  231.     return retVal;
  232. }
  235. /****************************************************************************
  236.  *  Method:
  237.  *    CVideoFormat::CreateBufferPool
  238.  *
  239.  */
  240. CHXBufferPool* CVideoFormat::CreateBufferPool(void)
  241. {
  242.     return new CHXBufferPool(
  243.     (BufferSizeFunc) CMediaPacket::GetBufferSize,
  244.     (BufferKillerFunc) CMediaPacket::DeletePacket);
  245. }
  247. /****************************************************************************
  248.  *  Method:
  249.  *    CVideoFormat::CreateAssembledPacket
  250.  *
  251.  */
  252. CMediaPacket* CVideoFormat::CreateAssembledPacket(IHXPacket* pPayloadData)
  253. {
  254.     CMediaPacket* pFramePacket = NULL;
  255.     BOOL bIsKeyframe = FALSE;
  257.     if (pPayloadData->IsLost())
  258.     {
  259. pFramePacket = NULL;
  260.     }
  261.     else
  262.     {
  263. IHXBuffer* pBuffer = pPayloadData->GetBuffer();
  265. if (pBuffer)
  266. {
  267.     pFramePacket = new CMediaPacket(pBuffer->GetBuffer(),
  268.     pBuffer->GetBuffer(), 
  269.     pBuffer->GetSize(),
  270.     pBuffer->GetSize(),
  271.     pPayloadData->GetTime(),
  272.     MDPCKT_USES_IHXBUFFER_FLAG,
  273.     NULL);
  275.     pBuffer->Release();
  276. }
  277.     }
  279.     return pFramePacket;
  280. }
  283. /****************************************************************************
  284.  *  Method:
  285.  *    CVideoFormat::ReturnAssembledPacket
  286.  *
  287.  */
  288. void CVideoFormat::ReturnAssembledPacket(CMediaPacket* pFramePacket)
  289. {
  290.     if (pFramePacket)
  291.     {
  292. m_pMutex->Lock();
  293. m_InputQueue.AddTail(pFramePacket);
  294. m_pMutex->Unlock();
  295.     }
  296. }
  299. /****************************************************************************
  300.  *  Method:
  301.  *    CVideoFormat::Enqueue
  302.  *
  303.  */
  304. BOOL CVideoFormat::Enqueue(IHXPacket* pPayloadData)
  305. {
  306.     BOOL bEnqueued = FALSE;
  307.     CMediaPacket* pFramePacket = NULL;
  308.     
  309.     m_pAssemblerMutex->Lock();
  311.     pFramePacket = CreateAssembledPacket(pPayloadData);
  312.   
  313.     if (pFramePacket != NULL)
  314.     {
  315. m_pMutex->Lock();
  316. m_InputQueue.AddTail(pFramePacket);
  317. m_pMutex->Unlock();
  319. bEnqueued = TRUE;
  320.     } 
  322.     m_pAssemblerMutex->Unlock();
  323.      
  324.     return bEnqueued;
  325. }
  327. /****************************************************************************
  328.  *  Method:
  329.  *    CVideoFormat::Requeue
  330.  *
  331.  */
  332. HX_RESULT CVideoFormat::Requeue(CMediaPacket* pFramePacket)
  333. {
  334.     if (pFramePacket != NULL)
  335.     {
  336. m_pMutex->Lock();
  337. m_InputQueue.AddHead(pFramePacket);
  338. m_pMutex->Unlock();
  339.     }
  341.     return HXR_OK;
  342. }
  344. /****************************************************************************
  345.  *  Method:
  346.  *    CVideoFormat::Dequeue
  347.  *
  348.  */
  349. CMediaPacket* CVideoFormat::Dequeue(void)
  350. {
  351.     CMediaPacket* pPacket = (CMediaPacket*) m_pOutputQueue->Get();
  353. #ifdef ENABLE_FRAME_TRACE
  354.     if (pPacket && (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES))
  355.     {
  356. frameTraceArray[ulFrameTraceIdx][2] = pPacket->m_ulTime;
  357. frameTraceArray[ulFrameTraceIdx][0] = 
  358.     (LONG32) pPacket->m_pData;
  359. frameTraceArray[ulFrameTraceIdx++][1] = 'G';
  360.     }
  361. #endif // ENABLE_FRAME_TRACE
  363.     return pPacket;
  364. }
  367. /****************************************************************************
  368.  *  Method:
  369.  *    CVideoFormat::Reset
  370.  *
  371.  */
  372. void CVideoFormat::Reset(void)
  373. {
  374.     _Reset();
  375. }
  377. void CVideoFormat::_Reset()
  378. {
  379.     m_pMutex->Lock();
  381.     CMediaPacket* pFrame;
  382.     
  383.     while (!m_InputQueue.IsEmpty())
  384.     {
  385. pFrame = (CMediaPacket*) m_InputQueue.RemoveHead();
  387. pFrame->Clear();
  388. delete pFrame;
  389.     }
  390.     
  391.     FlushOutputQueue();
  393.     m_pMutex->Unlock();
  394. }
  397. /****************************************************************************
  398.  *  Method:
  399.  *    CVideoFormat::DecodeFrame
  400.  *
  401.  */
  402. void CVideoFormat::FlushOutputQueue(void)
  403. {
  404.     CMediaPacket* pFrame;
  406.     if (m_pOutputQueue)
  407.     {
  408. while ((pFrame = (CMediaPacket*) m_pOutputQueue->Get()) != NULL)
  409. {
  410. #ifdef ENABLE_FRAME_TRACE
  411.     if (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES)
  412.     {
  413. frameTraceArray[ulFrameTraceIdx][2] = pFrame->m_ulTime;
  414. frameTraceArray[ulFrameTraceIdx][0] = 
  415.     (LONG32) pFrame->m_pData;
  416. frameTraceArray[ulFrameTraceIdx++][1] = 'F';
  417.     }
  418. #endif // ENABLE_FRAME_TRACE
  420.     pFrame->Clear();
  421.     delete pFrame;
  422. }
  423.     }
  424. }
  427. /****************************************************************************
  428.  *  Method:
  429.  *    CVideoFormat::DecodeFrame
  430.  *
  431.  */
  432. BOOL CVideoFormat::DecodeFrame(void)
  433. {
  434.     CMediaPacket* pEncodedPacket;
  435.     CMediaPacket* pDecodedPacket = NULL;
  436.     ULONG32 ulLoopCounter = 0;
  438.     m_pVideoRenderer->BltIfNeeded();
  440.     m_pDecoderMutex->Lock();
  441.     m_pMutex->Lock();
  442.     
  443.     if ((!m_InputQueue.IsEmpty()) &&
  444. (!m_pOutputQueue->IsFull()) &&
  445. (!m_bDecodeSuspended))
  446.     {
  447. do
  448. {
  449.     pEncodedPacket = (CMediaPacket*) m_InputQueue.RemoveHead();
  451.     m_pMutex->Unlock();
  453.     pDecodedPacket = CreateDecodedPacket(pEncodedPacket);
  455.     if (pDecodedPacket)
  456.     {
  457. #ifdef ENABLE_FRAME_TRACE
  458. if (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES)
  459. {
  460.     frameTraceArray[ulFrameTraceIdx][2] = pDecodedPacket->m_ulTime;
  461.     frameTraceArray[ulFrameTraceIdx][0] = 
  462. (LONG32) pDecodedPacket->m_pData;
  463.     frameTraceArray[ulFrameTraceIdx++][1] = 'D';
  464. }
  465. #endif // ENABLE_FRAME_TRACE
  467. m_pOutputQueue->Put(pDecodedPacket);
  469. if (pDecodedPacket->m_pData)
  470. {
  471.     m_pDecoderMutex->Unlock();
  472.     m_pVideoRenderer->BltIfNeeded();
  473.     return TRUE;
  474. }
  475.     }
  477.     m_pDecoderMutex->Unlock();
  479.             if( m_LastError == HXR_OUTOFMEMORY )
  480.             {
  481.                 m_bDecodeSuspended = TRUE;
  482.             }
  483.             else
  484.             {
  485.                 m_pVideoRenderer->BltIfNeeded();
  486.             }
  487.     ulLoopCounter++;
  489.     m_pDecoderMutex->Lock();
  490.     m_pMutex->Lock();
  491. } while ((!m_InputQueue.IsEmpty()) &&
  492.  (!m_pOutputQueue->IsFull()) &&
  493.  ((ulLoopCounter++) < MAX_DECODE_SPIN) &&
  494.  (!m_bDecodeSuspended));
  495.     }
  497.     m_pMutex->Unlock();
  498.     m_pDecoderMutex->Unlock();
  499.     
  500.     return pDecodedPacket ? TRUE : FALSE;
  501. }
  504. /****************************************************************************
  505.  *  Method:
  506.  *    CVideoFormat::ReturnDecodedPacket
  507.  *
  508.  */
  509. BOOL CVideoFormat::ReturnDecodedPacket(CMediaPacket* pDecodedPacket)
  510. {
  511.     BOOL bPacketAccepted = FALSE;
  513.     if (pDecodedPacket)
  514.     {
  515. #ifdef ENABLE_FRAME_TRACE
  516. if (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES)
  517. {
  518.     frameTraceArray[ulFrameTraceIdx][2] = pDecodedPacket->m_ulTime;
  519.     frameTraceArray[ulFrameTraceIdx][0] = 
  520. (LONG32) pDecodedPacket->m_pData;
  521.     frameTraceArray[ulFrameTraceIdx++][1] = 'D';
  522. }
  523. #endif // ENABLE_FRAME_TRACE
  524.     
  525. bPacketAccepted = m_pOutputQueue->Put(pDecodedPacket);
  526.     }
  528.     return bPacketAccepted;
  529. }
  532. /****************************************************************************
  533.  *  Method:
  534.  *    CVideoFormat::GetMaxDecodedFrames
  535.  *
  536.  */
  537. ULONG32 CVideoFormat::GetMaxDecodedFrames(void)
  538. {
  539.     return MAX_BUFFERED_DECODED_FRAMES;
  540. }
  543. /****************************************************************************
  544.  *  Method:
  545.  *    CVideoFormat::CreateDecodedPacket
  546.  *
  547.  */
  548. CMediaPacket* CVideoFormat::CreateDecodedPacket(CMediaPacket* pCodedPacket)
  549. {
  550.     CMediaPacket* pDecodedPacket = NULL;
  552.     if (pCodedPacket != NULL)
  553.     {
  554. pCodedPacket->Clear();
  555. delete pCodedPacket;
  556. pCodedPacket = NULL;
  557.     }
  559.     return pDecodedPacket;
  560. }
  563. /****************************************************************************
  564.  *  Method:
  565.  *    CVideoFormat::OnDecodedPacketRelease
  566.  *
  567.  */
  568. void CVideoFormat::OnDecodedPacketRelease(CMediaPacket* &pPacket)
  569. {
  570. #ifdef ENABLE_FRAME_TRACE
  571.     if (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES)
  572.     {
  573. frameTraceArray[ulFrameTraceIdx][2] = pPacket->m_ulTime;
  574. frameTraceArray[ulFrameTraceIdx][0] = 
  575.     (LONG32) pPacket->m_pData;
  576. frameTraceArray[ulFrameTraceIdx++][1] = 'R';
  577.     }
  578. #endif // ENABLE_FRAME_TRACE
  579.     ;
  580. }
  582. /****************************************************************************
  583.  *  Method:
  584.  *    CVideoFormat::InitBitmapInfoHeader
  585.  *
  586.  */
  587. HX_RESULT CVideoFormat::InitBitmapInfoHeader(
  588.     HXBitmapInfoHeader &BitmapInfoHeader,
  589.     CMediaPacket* pVideoPacket)
  591. {
  592.     HX_RESULT retVal = HXR_OK;
  594.     return retVal;
  595. }
  598. /****************************************************************************
  599.  *  Method:
  600.  *    CVideoFormat::GetDefaultPreroll
  601.  *
  602.  */
  603. ULONG32 CVideoFormat::GetDefaultPreroll(IHXValues* pValues)
  604. {
  605.     return FORMAT_DEFAULT_PREROLL;
  606. }
  609. /****************************************************************************
  610.  *  Method:
  611.  *    CVideoFormat::GetMinimumPreroll
  612.  *
  613.  */
  614. ULONG32 CVideoFormat::GetMinimumPreroll(IHXValues* pValues)
  615. {
  616.     return FORMAT_MINIMUM_PREROLL;
  617. }
  620. /****************************************************************************
  621.  *  Method:
  622.  *    CVideoFormat::GetMaximumPreroll
  623.  *
  624.  */
  625. ULONG32 CVideoFormat::GetMaximumPreroll(IHXValues* pValues)
  626. {
  627.     return FORMAT_MAXIMUM_PREROLL;
  628. }
  630. /****************************************************************************
  631.  *  Method:
  632.  *    CVideoFormat::GetMimeTypes
  633.  *
  634.  */
  635. const char** CVideoFormat::GetMimeTypes(void)
  636. {
  637.     return NULL;
  638. }
  641. // *** IUnknown methods ***
  643. /****************************************************************************
  644. *  IUnknown::AddRef                                            ref:  hxcom.h
  645. *
  646. *  This routine increases the object reference count in a thread safe
  647. *  manner. The reference count is used to manage the lifetime of an object.
  648. *  This method must be explicitly called by the user whenever a new
  649. *  reference to an object is used.
  650. */
  651. STDMETHODIMP_(ULONG32) CVideoFormat::AddRef()
  652. {
  653.     return InterlockedIncrement(&m_lRefCount);
  654. }
  656. /****************************************************************************
  657. *  IUnknown::Release                                           ref:  hxcom.h
  658. *
  659. *  This routine decreases the object reference count in a thread safe
  660. *  manner, and deletes the object if no more references to it exist. It must
  661. *  be called explicitly by the user whenever an object is no longer needed.
  662. */
  663. STDMETHODIMP_(ULONG32) CVideoFormat::Release()
  664. {
  665.     if (InterlockedDecrement(&m_lRefCount) > 0)
  666.     {
  667.         return m_lRefCount;
  668.     }
  669.     
  670.     delete this;
  671.     return 0;
  672. }
  674. /****************************************************************************
  675. *  IUnknown::QueryInterface                                    ref:  hxcom.h
  676. *
  677. *  This routine indicates which interfaces this object supports. If a given
  678. *  interface is supported, the object's reference count is incremented, and
  679. *  a reference to that interface is returned. Otherwise a NULL object and
  680. *  error code are returned. This method is called by other objects to
  681. *  discover the functionality of this object.
  682. */
  683. STDMETHODIMP CVideoFormat::QueryInterface(REFIID riid, void** ppvObj)
  684. {
  685.     if (IsEqualIID(riid, IID_IUnknown))
  686.     {
  687. AddRef();
  688. *ppvObj = (IUnknown*)(IHXPlugin*) this;
  689. return HXR_OK;
  690.     }
  691.     
  692.     *ppvObj = NULL;
  693.     return HXR_NOINTERFACE;
  694. }
  696. HX_RESULT
  697. CVideoFormat::GetLastError()
  698. {
  699.     return m_LastError;
  700. }