vidrend.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:27k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. #ifndef _VIDREND_H_
  36. #define _VIDREND_H_
  37. /****************************************************************************
  38.  *  Includes
  39.  */
  40. #include "vidrendf.h"
  41. #include "hxplugn.h"
  42. #include "hxrendr.h"
  43. #include "hxwin.h"
  44. #include "hxsite2.h"
  45. #include "hxasm.h"
  46. #include "hxmon.h"
  47. #include "hxpcmkr.h"
  48. #include "hxcore.h"
  49. #include "hxprefs.h"
  50. #include "hxtick.h"
  51. #include "cringbuf.h"
  52. #include "vidstats.h"
  53. /****************************************************************************
  54.  *  CVideoRenderer
  55.  */
  56. class CVideoRenderer : public IHXPlugin, 
  57.        public IHXRenderer, 
  58.        public IHXSiteUser,
  59.        public IHXInterruptSafe,
  60.        public IHXCallback,
  61.        public IHXStatistics,
  62.        public IHXRenderTimeLine,
  63.        public IHXPaceMakerResponse,
  64. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  65.        public IHXUntimedRenderer,
  66. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  67.        public IHXUpdateProperties
  68. {
  69. private:
  70.     class CSetSizeCB : public IHXCallback
  71.     {
  72.     public:
  73. CSetSizeCB(IHXSite* pSite)
  74.     : m_lRefCount(0)
  75.     , m_pSite(pSite)
  76. {
  77.     HX_ASSERT(m_pSite);
  78.     m_pSite->AddRef();
  79.     m_szViewFrame.cx = 0;
  80.     m_szViewFrame.cy = 0;
  81. }
  82. ~CSetSizeCB()
  83. {
  84.     HX_RELEASE(m_pSite);
  85. }
  86. STDMETHOD(QueryInterface) (THIS_
  87.  REFIID riid,
  88.  void** ppvObj);
  89. STDMETHOD_(ULONG32,AddRef) (THIS);
  90. STDMETHOD_(ULONG32,Release) (THIS);
  91. STDMETHOD(Func) (THIS);
  92. void SetSize(HXxSize szViewFrame)
  93. {
  94.     m_szViewFrame = szViewFrame;
  95. }
  96.     private:
  97. LONG32     m_lRefCount;
  98. IHXSite*   m_pSite;
  99. HXxSize     m_szViewFrame;
  100.     };
  101.     typedef enum 
  102.     { 
  103. Stopped, 
  104. Buffering, 
  105. PlayStarting,
  106. Playing, 
  107. Paused, 
  108. Seeking
  109.     } PlayState;
  110.     static const char* const  zm_pDescription;
  111.     static const char* const zm_pCopyright;
  112.     static const char* const  zm_pMoreInfoURL;
  113.     static const char* const zm_pStreamMimeTypes[];
  114.     LONG32 m_lRefCount;
  115.     HXMutex* m_pMutex;
  116.     HXMutex* m_pBltMutex;
  117.     HXMutex* m_pVSMutex;
  118.     IHXScheduler* m_pScheduler;
  119.     IHXOptimizedScheduler* m_pOptimizedScheduler;
  120.     IHXPaceMaker* m_pDecoderPump;
  121.     IHXPaceMaker* m_pBltrPump;
  122.     ULONG32 m_ulDecoderPacemakerId;
  123.     ULONG32 m_ulBltrPacemakerId;
  124.     LONG32 m_lDecodePriority;
  125.     CVideoFormat* m_pDecoderVideoFormat;
  126.     CVideoFormat* m_pBltrVideoFormat;
  127. #if defined(HELIX_FEATURE_STATS)
  128.     CVideoStatistics* m_pVideoStats;
  129. #else
  130.     void*                               m_pVideoStats;
  131. #endif /* HELIX_FEATURE_STATS */
  132.     ULONG32 m_lTimeLineOffset;
  133.     ULONG32 m_ulStreamBaseTime;
  134.     ULONG32 m_ulBaseTime;
  135.     ULONG32 m_ulTimeNormalizationOffset;
  136.     BOOL m_bIsScheduledCB;
  137.     ULONG32 m_ulLateFrameTol;
  138.     ULONG32 m_ulEarlyFrameTol;
  139.     ULONG32 m_ulMaxOptimizedVideoLead;
  140.     ULONG32 m_ulNoFramesPollingInterval;
  141.     ULONG32 m_ulMaxSleepTime;
  142.     ULONG32 m_ulBltPacketQueueSize;
  143.     BOOL m_bSchedulerStartRequested;
  144.     BOOL m_bPendingCallback;
  145.     CallbackHandle m_hPendingHandle;
  146.     ULONG32 m_ulCallbackCounter;
  147.     BOOL m_bSiteAttached;
  148.     BOOL m_bDecoderRunning;
  149.     PlayState m_PlayState; 
  150.     ULONG32 m_ulBytesToBuffer;
  151.     ULONG32 m_ulAvgBitRate;
  152.     ULONG32 m_ulPreroll;
  153.     ULONG32 m_ulBufferingStartTime;
  154.     ULONG32 m_ulBufferingStopTime;
  155.     ULONG32 m_ulBufferingTimeOut;
  156.     BOOL m_bBufferingOccured;
  157.     BOOL m_bBufferingNeeded;
  158.     BOOL m_bFirstFrame;
  159.     BOOL m_bBaseTimeSet;
  160.     BOOL m_bFirstSurfaceUpdate;
  161.     BOOL m_bPendingRedraw;
  162.     BOOL m_bVS1UpdateInProgress;
  163.     HXBitmapInfoHeader m_BitmapInfoHeader;
  164.     HXBitmapInfoHeader* m_pVSurf2InputBIH;
  165.     CRingBuffer* m_pBltPacketQueue;
  166. protected:
  167.     BOOL m_bBitmapSet;
  168. private:
  169.     BOOL m_bFrameSizeInitialized;
  170.     BOOL m_bWinSizeFixed;
  171.     BOOL m_bOptimizedBlt;
  172.     BOOL m_bOSGranuleBoost;
  173.     BOOL m_bOSGranuleBoostVS2;
  174.     BOOL m_bTryVideoSurface2;
  175.     BOOL m_bUseVideoSurface2;
  176.     BOOL m_bVideoSurface2Transition;
  177.     BOOL m_bVideoSurface1Requested;
  178.     BOOL m_bVideoSurfaceInitialized;
  179.     BOOL m_bVideoSurfaceReinitRequested;
  180.     BOOL m_bVS2BufferUnavailableOnLastBlt;
  181.     BOOL m_bPresentInProgress;
  182.     ULONG32 m_ulHWBufCount;
  183.     ULONG32 m_ulConfigHWBufCount;
  184.     ULONG32 m_ulSyncInterval;
  185.     ULONG32 m_ulSyncSmoothingDepth;
  186.     ULONG32 m_ulSyncGoalSmoothingDepth;
  187.     ULONG32 m_ulSpeedupGoalSmoothingDepth;
  188.     ULONG32 m_ulBadSeqSampleCount;
  189.     ULONG32 m_ulGoodSeqSampleCount;
  190.     ULONG32 m_ulMaxBadSeqSamples;
  191.     double m_fTrendSyncDelta;
  192.     
  193.     HXxSize m_SetWinSize;
  194.     HXxSize m_LastSetSize;
  195.     HXxRect* m_pClipRect;
  196.     HXxRect m_rViewRect;
  197.     CSetSizeCB* m_pResizeCB;
  198.     void Render(BOOL bMarker, BYTE* pData, ULONG32 ulSize, BOOL bLate);
  199.     
  200.     HX_RESULT CheckStreamVersions (IHXValues* pHeader);
  201.     BOOL _ResizeViewFrame(HXxSize szViewFrame,
  202.   BOOL bMutex,
  203.   BOOL bForceSyncResize,
  204.   BOOL bDefaultResize);
  205.     HX_RESULT UpdateDisplay(HXxEvent* pEvent, 
  206.     BOOL bSystemEvent = FALSE,
  207.     BOOL bIsVisible = TRUE);
  208. protected:    
  209.     HX_RESULT UpdateVideoSurface(IHXVideoSurface* pVideoSurface,
  210.  CMediaPacket* pVideoPacket,
  211.  HXxRect &destRect,
  212.  HXxRect &sorcRect,
  213.  BOOL bOptimizedBlt);
  214.     HX_RESULT UpdateVideoSurface2(IHXVideoSurface* pVideoSurface,
  215.   HXxRect &destRect,
  216.   HXxRect &sorcRect,
  217.   BOOL bRefresh,
  218.   BOOL bSystemEvent);
  219. private:    
  220.     HX_RESULT FlushVideoSurface2(IHXSite* pSite);
  221.     inline HX_RESULT SwitchToVideoSurface1(void);
  222.     inline HX_RESULT SwitchToVideoSurface2(void);
  223.     BOOL ForceRefresh(void);
  224.     void ForceDisplayUpdate(BOOL bInternalSurfaceUpdateOnly = FALSE,
  225.     BOOL bHasVisibleSurface = TRUE);
  226.     inline HX_RESULT ForceDisplayUpdateOnSite(IHXSite* pSite, 
  227.       BOOL bInternalSurfaceUpdateOnly,
  228.       BOOL bHasVisibleSurface);
  229.     void PresentFrame(void);
  230.     HX_RESULT InitVideoSurface1(BOOL bUsedVideoSurface2,
  231. IHXVideoSurface* pVideoSurface = NULL);
  232.     HX_RESULT InitVideoSurface2(ULONG32 ulWidth, ULONG32 ulHeight);
  233.     HX_RESULT StartSchedulers(void);
  234.     inline BOOL ShouldKickStartScheduler();
  235.     HX_RESULT ScheduleCallback(UINT32 ulRelativeTime, 
  236.        BOOL bIsScheduled = FALSE,
  237.        UINT32 ulBaseTime = 0);
  238.     void SchedulerCallback(BOOL bIsScheduled,
  239.    BOOL bResched = TRUE,
  240.    BOOL bIsVS2Call = FALSE,
  241.    BOOL bProcessUndisplayableFramesOnly = FALSE);
  242.     
  243.     inline CallbackHandle ScheduleRelativeCallback(UINT32 ulRelativeTime,
  244.    IHXCallback* pCallback);
  245.     inline CallbackHandle ScheduleAbsoluteCallback(HXTimeval &hxTime,
  246.    IHXCallback* pCallback);
  247.     void RemoveCallback(CallbackHandle &hCallback);
  248.     HX_RESULT BeginOptimizedBlt(HXBitmapInfoHeader* pBitmapInfo);
  249.     void EndOptimizedBlt(void);
  250.     inline void RequestBuffering(void);
  251.     inline void RequestBufferingEnd(void);
  252.     HX_RESULT BeginBuffering(void);
  253.     HX_RESULT EndBuffering(void);
  254.     inline BOOL IsBufferingComplete(IHXPacket* pPacket = NULL);
  255.     void ReleasePacket(CMediaPacket* pPacket,
  256.        BOOL bForceKill = FALSE);
  257.     void ClearBltPacketQueue(void);
  258.     BOOL IsDecoderRunning(void)     { return m_bDecoderRunning; }
  259.     HX_RESULT OnDecoderStart(void);
  260.     HX_RESULT OnDecoderEnd(void);
  261.     BOOL OnDecode(void);
  262.     void DisplayMutex_Lock(void)
  263.     {
  264. m_pBltMutex->Lock();
  265. m_pVSMutex->Lock();
  266.     }
  267.     void DisplayMutex_Unlock(void)
  268.     {
  269. m_pVSMutex->Unlock();
  270. m_pBltMutex->Unlock();
  271.     }
  272. protected:
  273.     CVideoFormat* m_pVideoFormat;
  274. public:
  275.     /*
  276.      * Costructor
  277.      */
  278.     CVideoRenderer(void);
  279.     /*
  280.      * Destructor
  281.      */
  282.     virtual ~CVideoRenderer();
  283.     /*
  284.      * IUnknown methods
  285.      */
  286.     STDMETHOD(QueryInterface) (THIS_
  287. REFIID riid,
  288. void** ppvObj);
  289.     STDMETHOD_(ULONG32,AddRef) (THIS);
  290.     STDMETHOD_(ULONG32,Release) (THIS);
  291.     /*
  292.      * IHXPlugin methods
  293.      */
  294.     /************************************************************************
  295.      * Method:
  296.      *     IHXPlugin::GetPluginInfo
  297.      * Purpose:
  298.      *     Returns the basic information about this plugin. Including:
  299.      *
  300.      *     bLoadMultiple whether or not this plugin DLL can be loaded
  301.      * multiple times. All File Formats must set
  302.      * this value to TRUE.
  303.      *     pDescription which is used in about UIs (can be NULL)
  304.      *     pCopyright which is used in about UIs (can be NULL)
  305.      *     pMoreInfoURL which is used in about UIs (can be NULL)
  306.      */
  307.     STDMETHOD(GetPluginInfo) (THIS_
  308. REF(BOOL)  /*OUT*/ bLoadMultiple,
  309. REF(const char*) /*OUT*/ pDescription,
  310. REF(const char*) /*OUT*/ pCopyright,
  311. REF(const char*) /*OUT*/ pMoreInfoURL,
  312. REF(ULONG32)  /*OUT*/ ulVersionNumber
  313. );
  314.     /************************************************************************
  315.      * Method:
  316.      *     IHXPlugin::InitPlugin
  317.      * Purpose:
  318.      *     Initializes the plugin for use. This interface must always be
  319.      *     called before any other method is called. This is primarily needed 
  320.      *     so that the plugin can have access to the context for creation of
  321.      *     IHXBuffers and IMalloc.
  322.      */
  323.     STDMETHOD(InitPlugin)   (THIS_
  324.     IUnknown*   /*IN*/  pContext);
  325.     
  326.     /*
  327.      * IHXRenderer methods
  328.      */
  329.     /************************************************************************
  330.      * Method:
  331.      *     IHXRenderer::GetRendererInfo
  332.      * Purpose:
  333.      *     Returns information vital to the instantiation of rendering 
  334.      *     plugins.
  335.      */
  336.     STDMETHOD(GetRendererInfo) (THIS_
  337. REF(const char**) /*OUT*/ pStreamMimeTypes,
  338. REF(UINT32)      /*OUT*/ unInitialGranularity
  339. );
  340.     /////////////////////////////////////////////////////////////////////////
  341.     // Method:
  342.     //     IHXRenderer::StartStream
  343.     // Purpose:
  344.     //     Called by client engine to inform the renderer of the stream it
  345.     //     will be rendering. The stream interface can provide access to
  346.     //     its source or player. This method also provides access to the 
  347.     //     primary client controller interface.
  348.     //
  349.     STDMETHOD (StartStream) (THIS_
  350. IHXStream*     pStream,
  351. IHXPlayer*     pPlayer);
  352.     /////////////////////////////////////////////////////////////////////////
  353.     // Method:
  354.     //     IHXRenderer::EndStream
  355.     // Purpose:
  356.     //     Called by client engine to inform the renderer that the stream
  357.     //     is was rendering is closed.
  358.     //
  359.     STDMETHOD (EndStream) (THIS);
  360.     /////////////////////////////////////////////////////////////////////////
  361.     // Method:
  362.     // IHXRenderer::OnHeader
  363.     // Purpose:
  364.     // Called by client engine when a header for this renderer is 
  365.     // available. The header will arrive before any packets.
  366.     //
  367.     STDMETHOD (OnHeader) (THIS_
  368. IHXValues*     pHeader);
  369.     /////////////////////////////////////////////////////////////////////////
  370.     // Method:
  371.     //     IHXRenderer::OnPacket
  372.     // Purpose:
  373.     //     Called by client engine when a packet for this renderer is 
  374.     //     due.
  375.     //
  376.     STDMETHOD (OnPacket) (THIS_
  377. IHXPacket*     pPacket,
  378. LONG32     lTimeOffset);
  379.     /////////////////////////////////////////////////////////////////////////
  380.     // Method:
  381.     //     IHXRenderer::OnTimeSync
  382.     // Purpose:
  383.     //     Called by client engine to inform the renderer of the current
  384.     //     time relative to the streams synchronized time-line. The 
  385.     //     renderer should use this time value to update its display or
  386.     //     render it's stream data accordingly.
  387.     //
  388.     STDMETHOD (OnTimeSync) (THIS_
  389. ULONG32     ulTime);
  390.     /////////////////////////////////////////////////////////////////////////
  391.     //  Method:
  392.     //     IHXRenderer::OnPreSeek
  393.     //  Purpose:
  394.     //     Called by client engine to inform the renderer that a seek is
  395.     //     about to occur. The render is informed the last time for the 
  396.     //     stream's time line before the seek, as well as the first new
  397.     //     time for the stream's time line after the seek will be completed.
  398.     //
  399.     STDMETHOD (OnPreSeek) (THIS_
  400. ULONG32     ulOldTime,
  401. ULONG32     ulNewTime);
  402.     /////////////////////////////////////////////////////////////////////////
  403.     // Method:
  404.     //     IHXRenderer::OnPostSeek
  405.     // Purpose:
  406.     //     Called by client engine to inform the renderer that a seek has
  407.     //     just occured. The render is informed the last time for the 
  408.     //     stream's time line before the seek, as well as the first new
  409.     //     time for the stream's time line after the seek.
  410.     //
  411.     STDMETHOD (OnPostSeek) (THIS_
  412. ULONG32     ulOldTime,
  413. ULONG32     ulNewTime);
  414.     /////////////////////////////////////////////////////////////////////////
  415.     // Method:
  416.     //     IHXRenderer::OnPause
  417.     // Purpose:
  418.     //     Called by client engine to inform the renderer that a pause has
  419.     //     just occured. The render is informed the last time for the 
  420.     //     stream's time line before the pause.
  421.     //
  422.     STDMETHOD (OnPause) (THIS_
  423. ULONG32     ulTime);
  424.     /////////////////////////////////////////////////////////////////////////
  425.     // Method:
  426.     // IHXRenderer::OnBegin
  427.     // Purpose:
  428.     // Called by client engine to inform the renderer that a begin or
  429.     // resume has just occured. The render is informed the first time 
  430.     // for the stream's time line after the resume.
  431.     //
  432.     STDMETHOD (OnBegin) (THIS_
  433. ULONG32     ulTime);
  434.     /////////////////////////////////////////////////////////////////////////
  435.     // Method:
  436.     // IHXRenderer::OnBuffering
  437.     // Purpose:
  438.     // Called by client engine to inform the renderer that buffering
  439.     // of data is occuring. The render is informed of the reason for
  440.     // the buffering (start-up of stream, seek has occured, network
  441.     // congestion, etc.), as well as percentage complete of the 
  442.     // buffering process.
  443.     //
  444.     STDMETHOD (OnBuffering) (THIS_
  445. ULONG32     ulFlags,
  446. UINT16     unPercentComplete);
  447.     /////////////////////////////////////////////////////////////////////////
  448.     // Method:
  449.     // IHXRenderer::GetDisplayType
  450.     // Purpose:
  451.     // Called by client engine to ask the renderer for it's preferred
  452.     // display type. When layout information is not present, the 
  453.     // renderer will be asked for it's prefered display type. Depending
  454.     // on the display type a buffer of additional information may be 
  455.     // needed. This buffer could contain information about preferred
  456.     // window size.
  457.     //
  458.     STDMETHOD (GetDisplayType) (THIS_
  459. REF(HX_DISPLAY_TYPE) ulFlags,
  460. REF(IHXBuffer*) pBuffer);
  461.     /************************************************************************
  462.      * Method:
  463.      *     IHXRenderer::OnEndofPackets
  464.      * Purpose:
  465.      *     Called by client engine to inform the renderer that all the
  466.      *     packets have been delivered. However, if the user seeks before
  467.      *     EndStream() is called, renderer may start getting packets again
  468.      *     and the client engine will eventually call this function again.
  469.      */
  470.     STDMETHOD(OnEndofPackets) (THIS);
  471.     /*
  472.      * IHXSiteUser methods called by the "context" to 
  473.      * associate users with the site.
  474.      */
  475.     STDMETHOD(AttachSite) (THIS_
  476. IHXSite* /*IN*/ pSite);
  477.     STDMETHOD(DetachSite) (THIS);
  478.     STDMETHOD_(BOOL,NeedsWindowedSites) (THIS);
  479.     STDMETHOD_(BOOL, IsInterruptSafe) (THIS) { return TRUE; }
  480.     /*
  481.      * IHXSiteUser methods called to inform user of an event.
  482.      */
  483.     STDMETHOD(HandleEvent) (THIS_
  484. HXxEvent* /*IN*/ pEvent);
  485.     /*
  486.      * IHXCallback method - backbone of renderer scheduling
  487.      */
  488.     /************************************************************************
  489.      * Method:
  490.      *     IHXCallback::Func
  491.      * Purpose:
  492.      *     This is the function that will be called when a callback is
  493.      *     to be executed.
  494.      */
  495.     STDMETHOD(Func) (THIS);
  496.     /*
  497.      * IHXStatistics methods
  498.      */
  499.     STDMETHOD(InitializeStatistics) (THIS_ UINT32 ulRegistryID);
  500.     STDMETHOD(UpdateStatistics)     (THIS);
  501.     /*
  502.      * IHXUntimedRenderer methods
  503.      */
  504. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  505.     STDMETHOD_(BOOL,IsUntimedRendering)(THIS);
  506.     STDMETHOD_(HX_RESULT,SetUntimedRendering)(THIS_ BOOL);
  507. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  508.     /************************************************************************
  509.      * Method:
  510.      *     IHXUpdateProperties::UpdatePacketTimeOffset
  511.      * Purpose:
  512.      *     Call this method to update the timestamp offset of cached packets
  513.      */
  514.     STDMETHOD(UpdatePacketTimeOffset) (THIS_ INT32 lTimeOffset);
  515.     /************************************************************************
  516.      * Method:
  517.      *     IHXUpdateProperties::UpdatePlayTimes
  518.      * Purpose:
  519.      *     Call this method to update the playtime attributes
  520.      */
  521.     STDMETHOD(UpdatePlayTimes)       (THIS_
  522.        IHXValues* pProps);
  523.     /************************************************************************
  524.      *  Method:
  525.      *      IHXRenderTimeLine::GetTimeLineValue
  526.      *  Purpose:
  527.      *      Get the current presentation time
  528.      *
  529.      *  Notes:
  530.      *      returns HXR_TIMELINE_SUSPENDED when the time line is suspended
  531.      */
  532.     STDMETHOD (GetTimeLineValue) (THIS_ /*OUT*/ REF(UINT32) ulTime);
  533.     /*
  534.      * IHXPaceMakerResponse
  535.      */
  536.     STDMETHOD(OnPaceStart) (THIS_
  537. ULONG32 ulId);
  538.     STDMETHOD(OnPaceEnd) (THIS_
  539. ULONG32 ulId);
  540.     STDMETHOD(OnPace) (THIS_
  541. ULONG32 ulId);
  542.     /************************************************************************
  543.      * Public CVideoRenderer functions
  544.      */
  545.     virtual BOOL ResizeViewFrame(HXxSize szViewFrame, BOOL bMutex = TRUE);
  546.     
  547.     void BltIfNeeded(void) 
  548.     {
  549. if (m_bUseVideoSurface2)
  550. {
  551.     if (m_PlayState == Playing)
  552.     {
  553. if (m_bOSGranuleBoostVS2)
  554. {
  555.     ForceDisplayUpdate(TRUE);
  556. }
  557.     }
  558.     else
  559.     {
  560. SchedulerCallback(FALSE,    // not scheduled 
  561.   FALSE,    // do not resched    
  562.   TRUE,     // is VS2 call
  563.   TRUE);    // process non-displayable frames only
  564. if (m_pBltrPump)
  565. {
  566.     m_pBltrPump->Signal();
  567. }
  568.     }
  569. }
  570. else if (m_hPendingHandle != ((CallbackHandle) NULL))
  571. {
  572.             if ((!m_bVS1UpdateInProgress) &&
  573.                 (m_bOSGranuleBoost || (m_PlayState != Playing)))
  574.     {
  575. SchedulerCallback(m_bIsScheduledCB, FALSE);
  576.     }
  577. }
  578.     }
  579.     LONG32 ComputeTimeAhead(ULONG32 ulTime, 
  580.     ULONG32 ulTolerance, 
  581.     ULONG32* p_ulBaseTime = NULL)
  582.     {
  583. LONG32 lTimeAhead = ulTime;
  584. ULONG32 ulTimeNow = 0;
  585. if (m_PlayState == Playing)
  586. {
  587.     ulTimeNow = HX_GET_BETTERTICKCOUNT();
  588.     /***
  589.     lTimeAhead = ((LONG32) (ulTime - m_ulBaseTime + ulTolerance)) -
  590.   ((LONG32) (ulTimeNow - m_ulStreamBaseTime));
  591.     ***/
  592.     lTimeAhead = (LONG32) (ulTime + ulTolerance - 
  593.    ulTimeNow + m_ulTimeNormalizationOffset);
  594. }
  595. else
  596. {
  597.     lTimeAhead = (LONG32) (ulTime - m_ulBaseTime - m_lTimeLineOffset);
  598. }
  599. if (p_ulBaseTime)
  600. {
  601.     *p_ulBaseTime = ulTimeNow;
  602. }
  603. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  604. // In untimed mode, we have to present a false timeline so anybody calling this thinks
  605. //  we are running just a bit ahead of real time. The way we do this is relating the
  606. //  reference packet time (ulTime) to the current packet time, rather than against real
  607. //  time.
  608. if( m_bUntimedRendering )
  609. {
  610.     return ulTime - (INT32)m_ulActiveVideoTime;
  611. }
  612. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  613. return lTimeAhead;
  614.     }
  615.     LONG32 DiffTime(ULONG32 t1, ULONG32 t2)  { return ((LONG32) (t1 - t2)); }
  616.     IUnknown* GetContext(void)
  617.     {
  618. return m_pContext;
  619.     }
  620.     IHXPreferences* GetPreferences(void)
  621.     {
  622. return m_pPreferences;
  623.     }
  624.     const HXBitmapInfoHeader* GetCurrentBitmapInfo(void)
  625.     {
  626. return &m_BitmapInfoHeader;
  627.     }
  628.     IHXSite* GetAttachedSite(void)
  629.     {
  630. return m_pMISUSSite;
  631.     }
  632.     void ReleaseFramePacket(CMediaPacket *pPacket);
  633.     HX_RESULT LocalizeActiveVideoPacket(void);
  634.     inline BOOL IsActive(void)    { return (m_PlayState == Playing); }
  635.     inline BOOL IsSeeking(void)    { return (m_PlayState == Seeking); }
  636.     HX_RESULT SetDecodePriority(LONG32 lPriority);
  637. #if defined(HELIX_FEATURE_STATS)
  638.     /************************************************************************
  639.      * Public Statistics Methods
  640.      */
  641.     void ReportLostFrame(ULONG32 ulCount = 1)
  642.     {
  643. m_pVideoStats->ReportLostFrame(ulCount);
  644.     }
  645.     void ReportDroppedFrame(ULONG32 ulCount = 1)  
  646.     {
  647. m_pVideoStats->ReportDroppedFrame(ulCount);
  648.     }
  649.     HX_RESULT ReportStat(VideoStatEntryID eEntryID, const char* pVal)
  650.     {
  651. return m_pVideoStats->ReportStat(eEntryID, pVal);
  652.     }
  653.     
  654.     HX_RESULT ReportStat(VideoStatEntryID eEntryID, INT32 lVal)
  655.     {
  656. return m_pVideoStats->ReportStat(eEntryID, lVal);
  657.     }
  658. #else // HELIX_FEATURE_STATS
  659.     /************************************************************************
  660.      * Public Statistics Methods
  661.      */
  662.     void ReportLostFrame(ULONG32 ulCount = 1)
  663.     {
  664. return;
  665.     }
  666.     void ReportDroppedFrame(ULONG32 ulCount = 1)  
  667.     {
  668. return;
  669.     }
  670.     HX_RESULT ReportStat(VideoStatEntryID eEntryID, const char* pVal)
  671.     {
  672. return HXR_OK;
  673.     }
  674.     
  675.     HX_RESULT ReportStat(VideoStatEntryID eEntryID, INT32 lVal)
  676.     {
  677. return HXR_OK;
  678.     }
  679. #endif // HELIX_FEATURE_STATS
  680. protected:
  681.     /*
  682.      * Renderer's customizable fuctions - can be called any time
  683.      */
  684.     /*
  685.      * Fixed Renderer Configuration - must be callable at any time
  686.      */
  687.     virtual const char* GetUpgradeMimeType(void);
  688.     virtual const char* GetRendererName(void);
  689.     virtual const char* GetCodecName(void);
  690.     virtual const char* GetCodecFourCC(void);
  691.     /*
  692.      * Renderer Configuration - must be callable any time
  693.      *                           after reception of the header
  694.      */
  695.     virtual void GetStreamVersion(ULONG32 &ulThisMajorVersion, 
  696.   ULONG32 &ulThisMinorVersion);
  697.     virtual void GetContentVersion(ULONG32 &ulThisMajorVersion, 
  698.    ULONG32 &ulThisMinorVersion);
  699.     virtual ULONG32 GetLateFrameTolerance(void);
  700.     virtual ULONG32 GetEarlyFrameTolerance(void);
  701.     virtual ULONG32 GetMaxOptimizedVideoLead(void);
  702.     virtual ULONG32 GetBltPacketQueueSize(void);
  703.     virtual ULONG32 GetSyncGoalSmoothingDepth(void);
  704.     virtual ULONG32 GetSpeedupGoalSmoothingDepth(void);
  705.     virtual ULONG32 GetNoFramesPollingInterval(void);
  706.     virtual ULONG32 GetMaxSleepTime(void);
  707.     virtual ULONG32 GetMaxBadSeqSamples(void);
  708.     virtual LONG32 GetDecodePriority(void);
  709.     virtual CVideoFormat* CreateFormatObject(IHXValues* pHeader);
  710.     
  711.     /*
  712.      * Renderer Setup - must be callable after the renderer attaches the site
  713.      */
  714.     virtual void SetupBitmapDefaults(IHXValues* pHeader,
  715.      HXBitmapInfoHeader &bitmapInfoHeader);
  716.     virtual void FormatAndSetViewFrame(HXxRect* pClipRect,
  717.        HXBitmapInfoHeader &bitmapInfoHeader,
  718.        HXxRect &rViewRect,
  719.        BOOL bMutex = TRUE);
  720.     /*
  721.      * Renderer Execution - must be callable anytime
  722.      */
  723.     virtual HX_RESULT OnOptimizedVideo(HX_RESULT status,
  724.        const HXBitmapInfoHeader& sourceBIH,
  725.        HXBitmapInfoHeader &targetBIH, 
  726.        ULONG32 &ulTargetBufCount);
  727.     virtual void OffOptimizedVideo(void);
  728.     virtual HX_RESULT TransferOptimizedVideo(IHXVideoSurface2* pVideoSurface2,
  729.                                              VideoMemStruct* pVideoMemoryInfo,
  730.                                              CMediaPacket* pVideoPacket,
  731.                                              const HXBitmapInfoHeader& sorcBIH,
  732.                                              HXxRect &destRect,
  733.                                              HXxRect &sorcRect);
  734.     virtual void AdjustVideoMapping(HXxRect &destRect, 
  735.     HXxRect &sorcRect,
  736.     CMediaPacket*pActiveVideoPacket);
  737.     virtual HX_RESULT InitExtraStats(void);
  738.     /*
  739.      * Base Renderer Setup - must be called if the base renderer overrides
  740.      &       the report of the related values to the core
  741.      */
  742.     void SetSyncInterval(ULONG32 ulSyncInterval);
  743.     /*
  744.      * Renderer's member variables sharable with the derived renderer
  745.      */
  746.     IUnknown* m_pContext;
  747.     IHXStream* m_pStream;
  748.     IHXValues* m_pHeader;
  749.     
  750.     IHXBackChannel* m_pBackChannel;
  751.     IHXMultiInstanceSiteUserSupplier* m_pMISUS;
  752.     IHXSite* m_pMISUSSite;
  753.     IHXCommonClassFactory* m_pCommonClassFactory;
  754.     IHXPreferences* m_pPreferences;
  755.     IHXRegistry* m_pRegistry;
  756.     ULONG32 m_ulRegistryID;
  757.     CMediaPacket* m_pActiveVideoPacket;
  758.     ULONG32 m_ulActiveVideoTime;
  759. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  760.     BOOL m_bUntimedRendering;
  761. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  762.     BOOL m_bActiveVideoPacketLocalized;
  763. };
  764. #endif // _VIDREND_H_