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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
vidrend.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：112k
源码类别：

Symbian

开发平台：

Visual C++

vidrend.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: vidrend.cpp,v 1.30.2.4 2004/07/09 01:55:01 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. /****************************************************************************
  51.  *  Debug Settings
  52.  */
  53. // #define ENABLE_TRACE
  54. // #define ENABLE_SYNC_TRACE
  55. // #define ENABLE_SCHED_TRACE
  56. // #define ENABLE_FETCH_TRACE
  57. // #define ENABLE_INPUT_TRACE
  60. /****************************************************************************
  61.  *  Operational Compile-time Settings
  62.  */
  63. // #define SYNC_RESIZE_OK
  64. // #define SYNC_VS_SWITCHING
  65. // #define REBUFFER_ON_VIDEO
  66. #define SET_NONZERO_VIEWFRAME_ONLY
  67. #define RESIZE_AFTER_SITE_ATTACHED
  68. #define DO_ABSOLUTE_TIMING
  69. #ifdef HELIX_FEATURE_VIDREND_SYNCSMOOTHING
  70. #define SYNC_SMOOTHING
  71. #define SYNC_PRE_SMOOTHING
  72. #endif // HELIX_FEATURE_VIDREND_SYNCSMOOTHING
  73. #define DEFAULT_VS2_TARGETRECT
  75. #define MAX_ULONG32_AS_DOUBLE ((double) ((ULONG32) 0xFFFFFFFF))
  76. #define MAX_LONG32_AS_DOUBLE ((double) ((LONG32) 0x7FFFFFFF))
  77. #define MIN_LONG32_AS_DOUBLE ((double) ((LONG32) 0x80000000))
  79. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  80. #define OSGRANULE_BOOSTING_ENABLED  FALSE
  81. #else // _MACINTOSH
  82. #define OSGRANULE_BOOSTING_ENABLED  TRUE
  83. #endif // _MACINTOSH
  85. /****************************************************************************
  86.  *  Debug Macros
  87.  */
  88. #ifdef ENABLE_TRACE
  89. #define HX_TRACE_THINGY(x, m, l)
  90.     {
  91. FILE* f1;
  92. f1 = ::fopen(x, "a+");
  93. (f1)?(::fprintf(f1, "%ld - %s = %ld n", HX_GET_BETTERTICKCOUNT(), m, l), ::fclose(f1)):(0);
  94.     }
  95. #else // ENABLE_TRACE
  96. #define HX_TRACE_THINGY(x, m, l)
  97. #endif // ENABLE_TRACE
  100. /****************************************************************************
  101.  *  Defines
  102.  */
  103. #define BASE_VIDEO_RENDERER_NAME    "Basic Video"
  104. #define NAME_STATS_EXT     ".name"
  105. #define C4CC_STATS_EXT     ".CodecFourCC"
  107. #if defined(HELIX_FEATURE_VIDREND_NO_DEFAULT_WINDOW_SIZE)
  108. #define DEFAULT_WIN_SIZE_X     0
  109. #define DEFAULT_WIN_SIZE_Y     0
  110. #else
  111. #define DEFAULT_WIN_SIZE_X     160
  112. #define DEFAULT_WIN_SIZE_Y     120
  113. #endif
  115. #define SYNC_INTERVAL     20     // in milliseconds
  116. #define EARLY_FRAME_TOL     3     // in milliseconds
  117. #define LATE_FRAME_TOL     30     // in milliseconds
  118. #define NO_FRAMES_POLLING_INTERVAL  20     // in milliseconds
  119. #define MAX_SLEEP_TIME     132     // in milliseconds
  120. #define BLT_PACKET_QUEUE_SIZE     3     // in packets
  121. #define SYNC_GOAL_SMOOTHING_DEPTH   30     // number of samples
  122. #define SPEEDUP_GOAL_SMOOTHING_DEPTH 8     // number of samples
  123. #define MAX_BAD_SAMPLE_INTERVAL     1000    // in milliseconds
  125. #define VIDEO_STAT_INTERVAL     1000    // in milliseconds
  126. #define VIDEO_STAT_INTERVAL_COUNT   2     // number of intervals to average over
  128. #define MAX_OPTIMIZED_VIDEO_LEAD 200 // in milliseconds
  129. #define DEFAULT_HARDWARE_BUFFER_COUNT 4
  131. #define AUDIO_SKEW_POWER     4     // Maximum Audio Speedup Slope as
  132.     // 1/(2^AUDIO_SKEW_POWER)
  133. #define MIN_BAD_PERSISTENCE_COUNT   0     // Minimum number of consecutive
  134.     // bad sync samples for the
  135.     // resync probation period to start
  136. #define MIN_GOOD_PERSISTENCE_COUNT  0     // Minimum number of consecutive
  137.     // good sync samples for the
  138.     // resync probation period to be
  139.     // cancelled
  141. #define MAX_BLT_LOOPS     3
  142. #define BLT_RELIEF_DELAY     1     // in milliseconds
  144. // Absolute timing settings
  145. #define N_STABILIZATION_ITERATIONS  5
  146. #define MAX_ALLOWED_TIMING_ERROR    2
  147. #define SMALLEST_TIMABLE_PERIOD     2
  149. // Default Decoding Priority
  150. #ifdef _WIN32
  151.     #ifdef HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  152.     // on ce we need to get this started quickly, otherwise the initial packets expire
  153.     // we set the priority so we can check in onpace to reset only once
  154.     #define DFLT_DECODE_PRIORITY     THREAD_PRIORITY_HIGHEST
  155.     #define DFLT_PRESENT_PRIORITY     THREAD_PRIORITY_ABOVE_NORMAL
  156.     #else
  157.     #define DFLT_DECODE_PRIORITY     THREAD_PRIORITY_BELOW_NORMAL
  158.     #define DFLT_PRESENT_PRIORITY     THREAD_PRIORITY_ABOVE_NORMAL
  159.     #endif // HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  160. #else // _WIN32
  161. #define DFLT_DECODE_PRIORITY     0
  162. #define DFLT_PRESENT_PRIORITY     0
  163. #endif // _WIN32
  165. // Lowest acceptable version numbers
  166. #define STREAM_MAJOR_VERSION  0
  167. #define STREAM_MINOR_VERSION  0
  169. #define CONTENT_MAJOR_VERSION 0
  170. #define CONTENT_MINOR_VERSION 0
  172. #define DECODER_INTERVAL 5
  173. #define BLTR_INTERVAL 5
  175. #ifdef _WIN32
  176. #define GETBITMAPCOLOR(x) GetBitmapColor( (LPBITMAPINFO)(x) )
  177. #else // _WIN32
  178. #define GETBITMAPCOLOR(x) GetBitmapColor( (HXBitmapInfo*)(x))
  179. #endif // _WIN32
  182. /****************************************************************************
  183.  *  Includes
  184.  */
  185. #include "hlxclib/stdio.h"
  186. #include "vidrend.ver"
  187. #include "hxtypes.h"
  188. #ifdef _WINDOWS
  189. #include <windows.h>
  190. #endif
  193. #if defined(_UNIX) && !defined(_MAC_UNIX)
  195. #include <stdio.h>
  196. #include <stdlib.h>
  197. #include <unistd.h>
  199. #ifndef QWS
  200. #include <X11/Intrinsic.h>
  201. #include <X11/StringDefs.h>
  202. #include <X11/Shell.h>
  203. #endif /* QWS */
  205. #endif
  207. #include "hxwintyp.h"
  208. #include "hxcom.h"
  209. #include "hxcomm.h"
  210. #include "hxthread.h"
  212. // for sync
  213. #include "hxengin.h"
  214. #include "hxprefs.h"
  215. #include "hxtick.h"
  216. #include "timeval.h"
  217. #include "hxevent.h"
  218. #include "hxvsurf.h"
  220. #include "ihxpckts.h"
  221. #include "hxfiles.h"
  222. #include "hxcore.h"
  223. #include "hxerror.h"
  224. #include "hxrendr.h"
  225. #include "addupcol.h"
  226. // #include "hxhyper.h"
  227. #include "hxplugn.h"
  228. #include "hxwin.h"
  229. // #include "hxasm.h"
  230. #include "hxmon.h"
  231. #include "hxbuffer.h" // for CHXBuffer
  233. #include "hxassert.h" // for HX_ASSERT()
  234. #include "hxheap.h" // for heap checking
  235. #include "hxslist.h" // CHXSimpleList
  237. #include "chxbufpl.h"
  239. #include "sdpchunk.h"
  241. #include "vidrend.h"
  242. #include "cpacemkr.h"
  243. #include "hxver.h"
  245. #if defined(_WINDOWS) && !defined(WIN32_PLATFORM_PSPC)
  246. #include "ddraw.h"
  247. #endif /* defined(_WINDOWS) && !defined(WIN32_PLATFORM_PSPC) */
  249. // #include "coloracc.h"
  250. #include "colormap.h"
  252. #include "chxxtype.h"   // For CHXxSize
  254. #if defined(HELIX_FEATURE_PREFERENCES)
  255. #include "hxprefs.h"
  256. #include "hxprefutil.h"
  257. #endif /* HELIX_FEATURE_PREFERENCES */
  259. /****************************************************************************
  260.  *  Debug
  261.  */
  262. #ifdef ENABLE_SYNC_TRACE
  263. #define MAX_SYNC_TRACE_ENTRIES 10000
  264. ULONG32 ulSyncTraceIdx = 0;
  265. ULONG32 syncTraceArray[MAX_SYNC_TRACE_ENTRIES][3];
  267. void DumpSyncEntries(void)
  268. {
  269.     FILE* pFile = NULL;
  270.     ULONG32 ulIdx;
  272.     if (ulSyncTraceIdx > 0)
  273.     {
  274. pFile = fopen("\helix\sync.txt", "wb");
  275.     }
  277.     if (pFile)
  278.     {
  279. for (ulIdx = 0; ulIdx < ulSyncTraceIdx; ulIdx++)
  280. {
  281.     fprintf(pFile, "%ut%ut%un", syncTraceArray[ulIdx][0],
  282.    syncTraceArray[ulIdx][1],
  283.    syncTraceArray[ulIdx][2]);
  284. }
  286. fclose(pFile);
  287.     }
  289.     ulSyncTraceIdx = 0;
  290. }
  291. #endif // ENABLE_SYNC_TRACE
  294. #ifdef ENABLE_SCHED_TRACE
  295. #define MAX_SCHED_TRACE_ENTRIES 10000
  296. ULONG32 ulSchedTraceIdx = 0;
  297. LONG32 schedTraceArray[MAX_SCHED_TRACE_ENTRIES];
  299. void DumpSchedEntries(void)
  300. {
  301.     FILE* pFile = NULL;
  302.     ULONG32 ulIdx;
  304.     if (ulSchedTraceIdx > 0)
  305.     {
  306. pFile = fopen("\helix\sched.txt", "wb");
  307.     }
  309.     if (pFile)
  310.     {
  311. for (ulIdx = 0; ulIdx < ulSchedTraceIdx; ulIdx++)
  312. {
  313.     fprintf(pFile, "%dn", schedTraceArray[ulIdx]);
  314. }
  316. fclose(pFile);
  317.     }
  319.     ulSchedTraceIdx = 0;
  320. }
  321. #endif // ENABLE_SCHED_TRACE
  324. #ifdef ENABLE_FETCH_TRACE
  325. #define MAX_FETCH_TRACE_ENTRIES 10000
  326. ULONG32 ulFetchTraceIdx = 0;
  327. LONG32 fetchTraceArray[MAX_FETCH_TRACE_ENTRIES];
  329. void DumpFetchEntries(void)
  330. {
  331.     FILE* pFile = NULL;
  332.     ULONG32 ulIdx;
  334.     if (ulFetchTraceIdx > 0)
  335.     {
  336. pFile = fopen("\helix\fetch.txt", "wb");
  337.     }
  339.     if (pFile)
  340.     {
  341. for (ulIdx = 0; ulIdx < ulFetchTraceIdx; ulIdx++)
  342. {
  343.     fprintf(pFile, "%dn", fetchTraceArray[ulIdx]);
  344. }
  346. fclose(pFile);
  347.     }
  349.     ulFetchTraceIdx = 0;
  350. }
  351. #endif // ENABLE_FETCH_TRACE
  354. #ifdef ENABLE_INPUT_TRACE
  355. #define MAX_INPUT_TRACE_ENTRIES 10000
  356. ULONG32 ulInputTraceIdx = 0;
  357. LONG32 inputTraceArray[MAX_INPUT_TRACE_ENTRIES];
  359. void DumpInputEntries(void)
  360. {
  361.     FILE* pFile = NULL;
  362.     ULONG32 ulIdx;
  364.     if (ulInputTraceIdx > 0)
  365.     {
  366. pFile = fopen("\helix\input.txt", "wb");
  367.     }
  369.     if (pFile)
  370.     {
  371. for (ulIdx = 0; ulIdx < ulInputTraceIdx; ulIdx++)
  372. {
  373.     fprintf(pFile, "%dn", inputTraceArray[ulIdx]);
  374. }
  376. fclose(pFile);
  377.     }
  379.     ulInputTraceIdx = 0;
  380. }
  381. #endif // ENABLE_INPUT_TRACE
  384. /****************************************************************************
  385.  *  Constants
  386.  */
  387. const char* const CVideoRenderer::zm_pDescription    = "RealNetworks Video Renderer Plugin";
  388. const char* const CVideoRenderer::zm_pCopyright      = HXVER_COPYRIGHT;
  389. const char* const CVideoRenderer::zm_pMoreInfoURL    = HXVER_MOREINFO;
  391. const char* const CVideoRenderer::zm_pStreamMimeTypes[] =
  392. {
  393.     NULL
  394. };
  397. /************************************************************************
  398.  *  CVideoRenderer
  399.  */
  400. /************************************************************************
  401.  *  Constructor/Destructor
  402.  */
  403. CVideoRenderer::CVideoRenderer(void)
  404. : m_lRefCount(0)
  405. , m_pContext(NULL)
  406. , m_pStream(NULL)
  407. , m_pHeader(NULL)
  408. , m_pMutex(NULL)
  409. , m_pBltMutex(NULL)
  410. , m_pVSMutex(NULL)
  411. , m_pDecoderPump(NULL)
  412. , m_pBltrPump(NULL)
  413. , m_ulDecoderPacemakerId(0)
  414. , m_ulBltrPacemakerId(0)
  415. , m_pDecoderVideoFormat(NULL)
  416. , m_pBltrVideoFormat(NULL)
  417. , m_pBackChannel(0)
  418. , m_pCommonClassFactory(0)
  419. , m_ulRegistryID(0)
  420. , m_pVideoStats(NULL)
  421. , m_pMISUS(NULL)
  422. , m_pMISUSSite(NULL)
  423. , m_ulEarlyFrameTol(EARLY_FRAME_TOL)
  424. , m_ulLateFrameTol(LATE_FRAME_TOL)
  425. , m_ulNoFramesPollingInterval(NO_FRAMES_POLLING_INTERVAL)
  426. , m_ulMaxSleepTime(MAX_SLEEP_TIME)
  427. , m_ulBltPacketQueueSize(BLT_PACKET_QUEUE_SIZE)
  428. , m_ulSyncGoalSmoothingDepth(SYNC_GOAL_SMOOTHING_DEPTH)
  429. , m_ulSpeedupGoalSmoothingDepth(SPEEDUP_GOAL_SMOOTHING_DEPTH)
  430. , m_ulMaxBadSeqSamples(0)
  431. , m_lTimeLineOffset(0)
  432. , m_lDecodePriority(DFLT_DECODE_PRIORITY)
  433. , m_ulStreamBaseTime(0)
  434. , m_ulBaseTime(0)
  435. , m_ulTimeNormalizationOffset(0)
  436. , m_bBitmapSet(FALSE)
  437. , m_bFrameSizeInitialized(FALSE)
  438. , m_bWinSizeFixed(FALSE)
  439. , m_bOSGranuleBoost(OSGRANULE_BOOSTING_ENABLED)
  440. , m_bOSGranuleBoostVS2(OSGRANULE_BOOSTING_ENABLED)
  441. , m_bOptimizedBlt(FALSE)
  442. , m_bUseVideoSurface2(FALSE)
  443. #if defined(_WINDOWS) && defined(HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO)
  444. , m_bTryVideoSurface2(TRUE)
  445. #else // _WINDOWS
  446. , m_bTryVideoSurface2(FALSE)
  447. #endif // _WINDOWS
  448. , m_bVideoSurface2Transition(FALSE)
  449. , m_bVideoSurface1Requested(FALSE)
  450. , m_bVideoSurfaceInitialized(FALSE)
  451. , m_bVideoSurfaceReinitRequested(FALSE)
  452. , m_bPresentInProgress(FALSE)
  453. , m_bVS2BufferUnavailableOnLastBlt(FALSE)
  454. , m_ulHWBufCount(DEFAULT_HARDWARE_BUFFER_COUNT)
  455. , m_ulConfigHWBufCount(DEFAULT_HARDWARE_BUFFER_COUNT)
  456. , m_pClipRect(NULL)
  457. , m_pPreferences(NULL)
  458. , m_pRegistry(NULL)
  459. , m_pScheduler(NULL)
  460. , m_pOptimizedScheduler(NULL)
  461. , m_bPendingCallback(FALSE)
  462. , m_bSchedulerStartRequested(FALSE)
  463. , m_hPendingHandle(0)
  464. , m_ulCallbackCounter(0)
  465. , m_bDecoderRunning(FALSE)
  466. , m_bSiteAttached(FALSE)
  467. , m_PlayState(Stopped)
  468. , m_ulBytesToBuffer(0)
  469. , m_ulAvgBitRate(0)
  470. , m_ulPreroll(0)
  471. , m_ulBufferingStartTime(0)
  472. , m_ulBufferingStopTime(0)
  473. , m_ulBufferingTimeOut(0)
  474. , m_bBufferingOccured(FALSE)
  475. , m_bBufferingNeeded(FALSE)
  476. , m_pVideoFormat(NULL)
  477. , m_pBltPacketQueue(NULL)
  478. , m_pActiveVideoPacket(NULL)
  479. , m_ulActiveVideoTime(0)
  480. , m_bFirstFrame(TRUE)
  481. , m_bBaseTimeSet(FALSE)
  482. , m_bFirstSurfaceUpdate(TRUE)
  483. , m_bPendingRedraw(FALSE)
  484. , m_bVS1UpdateInProgress(FALSE)
  485. , m_ulSyncSmoothingDepth(0)
  486. , m_ulSyncInterval(SYNC_INTERVAL)
  487. , m_ulBadSeqSampleCount(0)
  488. , m_ulGoodSeqSampleCount(0)
  489. , m_fTrendSyncDelta(0.0)
  490. , m_pResizeCB(NULL)
  491. , m_pVSurf2InputBIH(NULL)
  492. , m_bIsScheduledCB(0)
  493. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  494. , m_bUntimedRendering(FALSE)
  495. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  496. , m_bActiveVideoPacketLocalized(FALSE)
  497. {
  498.     m_SetWinSize.cx = 0;
  499.     m_SetWinSize.cy = 0;
  500.     m_LastSetSize.cx = 0;
  501.     m_LastSetSize.cy = 0;
  503.     m_rViewRect.left   = 0;
  504.     m_rViewRect.top    = 0;
  505.     m_rViewRect.right  = 0;
  506.     m_rViewRect.bottom = 0; 
  508.     memset(&m_BitmapInfoHeader, 0, sizeof(HXBitmapInfoHeader));
  509. }
  511. CVideoRenderer::~CVideoRenderer()
  512. {
  513.     // NOTE: You should do your renderer cleanup here, instead of
  514.     // in EndStream(), because your renderer is still left around
  515.     // after the stream is ended in case it is a display renderer
  516.     // and it needs to "paint" it's display area.
  517.     EndOptimizedBlt();
  519.     if (m_pActiveVideoPacket)
  520.     {
  521. m_pActiveVideoPacket->Clear();
  522. delete m_pActiveVideoPacket;
  523. m_pActiveVideoPacket = NULL;
  524. m_ulActiveVideoTime = 0;
  525.     }
  527.     HX_RELEASE(m_pHeader);
  528.     HX_RELEASE(m_pContext);
  529.     HX_RELEASE(m_pCommonClassFactory);
  531.     if (m_pVideoFormat)
  532.     {
  533.         m_pVideoFormat->Release();
  534.         m_pVideoFormat = NULL;
  535.     }
  537.     HX_DELETE(m_pVSurf2InputBIH);
  538.     HX_DELETE(m_pClipRect);
  539.     HX_DELETE(m_pMutex);
  540.     HX_DELETE(m_pBltMutex);
  541.     HX_DELETE(m_pVSMutex);
  543.     RemoveCallback(m_hPendingHandle);
  544.     m_bPendingCallback = FALSE;
  546.     HX_RELEASE(m_pOptimizedScheduler);
  547.     HX_RELEASE(m_pScheduler);
  549.     HX_RELEASE(m_pPreferences);
  550.     HX_RELEASE(m_pRegistry);
  552.     ClearBltPacketQueue();
  553.     HX_DELETE(m_pBltPacketQueue);
  555.     HX_RELEASE(m_pResizeCB);
  557. #if defined(HELIX_FEATURE_STATS)
  558.     HX_DELETE(m_pVideoStats);
  559. #endif /* HELIX_FEATURE_STATS */
  560. }
  563. /************************************************************************
  564.  *  IHXPlugin Methods
  565.  */
  566. /************************************************************************
  567.  *  Method:
  568.  *    IHXPlugin::InitPlugin
  569.  *  Purpose:
  570.  *    Initializes the plugin for use. This interface must always be
  571.  *    called before any other method is called. This is primarily needed
  572.  *    so that the plugin can have access to the context for creation of
  573.  *    IHXBuffers and IMalloc.
  574.  */
  575. STDMETHODIMP CVideoRenderer::InitPlugin(IUnknown* /*IN*/ pContext)
  576. {
  577.     HX_RESULT retVal = HXR_OK;
  579.     HX_ASSERT(pContext);
  581.     m_pContext = pContext;
  582.     m_pContext->AddRef();
  584.     retVal = m_pContext->QueryInterface(IID_IHXCommonClassFactory,
  585. (void**) &m_pCommonClassFactory);
  587.     if (SUCCEEDED(retVal))
  588.     {
  589. m_pContext->QueryInterface(IID_IHXPreferences,
  590.                                    (void**) &m_pPreferences);
  591.     }
  593.     m_pContext->QueryInterface(IID_IHXRegistry, (void**) &m_pRegistry);
  595.     if (SUCCEEDED(retVal))
  596.     {
  597. retVal = m_pContext->QueryInterface(IID_IHXScheduler,
  598.     (void **) &m_pScheduler);
  599.     }
  601.     if (SUCCEEDED(retVal) && !m_pMutex)
  602.     {
  603. #ifdef THREADS_SUPPORTED
  604. retVal = HXMutex::MakeMutex(m_pMutex);
  605. #else  // THREADS_SUPPORTED
  606. retVal = HXMutex::MakeStubMutex(m_pMutex);
  607. #endif  // THREADS_SUPPORTED
  608.     }
  610.     if (SUCCEEDED(retVal) && !m_pBltMutex)
  611.     {
  612. #ifdef THREADS_SUPPORTED
  613. retVal = HXMutex::MakeMutex(m_pBltMutex);
  614. #else  // THREADS_SUPPORTED
  615. retVal = HXMutex::MakeStubMutex(m_pBltMutex);
  616. #endif  // THREADS_SUPPORTED
  617.     }
  619.     if (SUCCEEDED(retVal) && !m_pVSMutex)
  620.     {
  621. #ifdef THREADS_SUPPORTED
  622. retVal = HXMutex::MakeMutex(m_pVSMutex);
  623. #else  // THREADS_SUPPORTED
  624. retVal = HXMutex::MakeStubMutex(m_pVSMutex);
  625. #endif  // THREADS_SUPPORTED
  626.     }
  628. #if defined(HELIX_FEATURE_STATS)
  629.     if (SUCCEEDED(retVal))
  630.     {
  631. m_pVideoStats = new CVideoStatistics(m_pContext,
  632.      VIDEO_STAT_INTERVAL_COUNT);
  634. retVal = HXR_OUTOFMEMORY;
  635. if (m_pVideoStats)
  636. {
  637.     retVal = HXR_OK;
  638. }
  639.     }
  640. #endif /* HELIX_FEATURE_STATS */
  642.     if (FAILED(retVal))
  643.     {
  644. HX_RELEASE(m_pCommonClassFactory);
  645. HX_RELEASE(m_pPreferences);
  646. HX_RELEASE(m_pRegistry);
  647. HX_RELEASE(m_pScheduler);
  648.     }
  650.     return retVal;
  651. }
  653. /************************************************************************
  654.  *  Method:
  655.  *    IHXPlugin::GetPluginInfo
  656.  *  Purpose:
  657.  *    Returns the basic information about this plugin. Including:
  658.  *
  659.  *    bLoadMultiple whether or not this plugin DLL can be loaded
  660.  * multiple times. All File Formats must set
  661.  * this value to TRUE.
  662.  *    pDescription which is used in about UIs (can be NULL)
  663.  *    pCopyright which is used in about UIs (can be NULL)
  664.  *    pMoreInfoURL which is used in about UIs (can be NULL)
  665.  */
  666. STDMETHODIMP CVideoRenderer::GetPluginInfo
  667. (
  668.    REF(BOOL)        /*OUT*/ bLoadMultiple,
  669.    REF(const char*) /*OUT*/ pDescription,
  670.    REF(const char*) /*OUT*/ pCopyright,
  671.    REF(const char*) /*OUT*/ pMoreInfoURL,
  672.    REF(ULONG32)     /*OUT*/ ulVersionNumber
  673. )
  674. {
  675.     bLoadMultiple = TRUE;   // Must be true for file formats.
  677.     pDescription    = zm_pDescription;
  678.     pCopyright     = zm_pCopyright;
  679.     pMoreInfoURL    = zm_pMoreInfoURL;
  680.     ulVersionNumber = TARVER_ULONG32_VERSION;
  682.     return HXR_OK;
  683. }
  685. /************************************************************************
  686.  *  Method:
  687.  *    IHXPlugin::GetRendererInfo
  688.  *  Purpose:
  689.  *    If this object is a file format object this method returns
  690.  *    information vital to the instantiation of file format plugins.
  691.  *    If this object is not a file format object, it should return
  692.  *    HXR_UNEXPECTED.
  693.  */
  694. STDMETHODIMP CVideoRenderer::GetRendererInfo
  695. (
  696.  REF(const char**) /*OUT*/ pStreamMimeTypes,
  697.  REF(UINT32)      /*OUT*/ unInitialGranularity
  698. )
  699. {
  700.     pStreamMimeTypes = (const char**) zm_pStreamMimeTypes;
  701.     unInitialGranularity = SYNC_INTERVAL;
  702.     return HXR_OK;
  703. }
  708. /************************************************************************
  709.  *  IHXRenderer Methods
  710.  */
  711. /////////////////////////////////////////////////////////////////////////
  712. //  Method:
  713. // IHXRenderer::StartStream
  714. //  Purpose:
  715. // Called by client engine to inform the renderer of the stream it
  716. // will be rendering. The stream interface can provide access to
  717. // its source or player. This method also provides access to the
  718. // primary client controller interface.
  719. //
  720. STDMETHODIMP CVideoRenderer::StartStream(IHXStream* pStream,
  721.    IHXPlayer* pPlayer)
  722. {
  723.     m_pStream  = pStream;
  725.     if (m_pStream)
  726.     {
  727. m_pStream->AddRef();
  728.     }
  730. #if defined (HELIX_FEATURE_MISU)
  731.     m_pCommonClassFactory->CreateInstance(
  732. CLSID_IHXMultiInstanceSiteUserSupplier,
  733. (void**) &m_pMISUS);
  735.     if (m_pMISUS)
  736.     {
  737. m_pMISUS->SetSingleSiteUser((IUnknown*)(IHXSiteUser*) this);
  738.     }
  739. #endif //HELIX_FEATURE_MISU
  741.     if (m_pStream)
  742.     {
  743. IHXStreamSource* pSource = 0;
  744. if (m_pStream->GetSource(pSource) == HXR_OK)
  745. {
  746.     /* It is OK if the source does not support backchannel. Reasons:
  747.      *
  748.      * 1. This stream may not be coming from h261 fileformat.
  749.      *   It may instead be merged into a container fileformat which
  750.      *   may be does not support BackChannel.
  751.      *
  752.      * 2. The protocol used to serve this stream may not support
  753.      *   BackChannel.
  754.      */
  755.     pSource->QueryInterface(IID_IHXBackChannel, (void**) &m_pBackChannel);
  757.     pSource->Release();
  758. }
  759.     }
  761.     return HXR_OK;
  762. }
  764. /////////////////////////////////////////////////////////////////////////
  765. //  Method:
  766. // IHXRenderer::EndStream
  767. //  Purpose:
  768. // Called by client engine to inform the renderer that the stream
  769. // is was rendering is closed.
  770. //
  771. STDMETHODIMP CVideoRenderer::EndStream()
  772. {
  773.     // Stop Blts by changing state
  774.     m_pMutex->Lock();
  775.     m_PlayState = Stopped;
  776.     m_pMutex->Unlock();
  778.     // Stop Decoder
  779.     if (m_pDecoderPump)
  780.     {
  781. m_pDecoderPump->Stop();
  782. m_pDecoderPump->Signal();
  783. m_pDecoderPump->WaitForStop();
  784. m_pDecoderPump->Release();
  785. m_pDecoderPump = NULL;
  786.     }
  788.     // Wait for Blt if in progress and then flush packet queues
  789.     DisplayMutex_Lock();
  790.     if (m_pVideoFormat)
  791.     {
  792. m_pVideoFormat->Reset();
  793.     }
  794.     DisplayMutex_Unlock();
  796.     // IHXStream, IHXSourceStream or IHXBackChannel
  797.     // cannot be used after EndStream has been called.
  798.     HX_RELEASE(m_pStream);
  799.     HX_RELEASE(m_pBackChannel);
  801.     // Stop Bltr pump
  802.     if (m_pBltrPump)
  803.     {
  804. m_pBltrPump->Stop();
  805. m_pBltrPump->Signal();
  806.     }
  808.     // Flush Optimized Video Surface if used
  809.     if (m_bUseVideoSurface2 && m_pMISUSSite)
  810.     {
  811. FlushVideoSurface2(m_pMISUSSite);
  812.     }
  814.     if (m_pBltrPump)
  815.     {
  816. m_pBltrPump->WaitForStop();
  817. m_pBltrPump->Release();
  818. m_pBltrPump = NULL;
  819.     }
  821.     DisplayMutex_Lock();
  822.     if (m_pVideoFormat)
  823.     {
  824.         m_pVideoFormat->Release();
  825.         m_pVideoFormat = NULL;
  826.     }
  827.     DisplayMutex_Unlock();
  829. #ifdef ENABLE_SYNC_TRACE
  830.     DumpSyncEntries();
  831. #endif // ENABLE_SYNC_TRACE
  833. #ifdef ENABLE_SCHED_TRACE
  834.     DumpSchedEntries();
  835. #endif // ENABLE_SCHED_TRACE
  837. #ifdef ENABLE_FETCH_TRACE
  838.     DumpFetchEntries();
  839. #endif // ENABLE_FETCH_TRACE
  841. #ifdef ENABLE_INPUT_TRACE
  842.     DumpInputEntries();
  843. #endif // ENABLE_INPUT_TRACE
  845.     return HXR_OK;
  846. }
  848. /////////////////////////////////////////////////////////////////////////
  849. //  Method:
  850. // IHXRenderer::OnHeader
  851. //  Purpose:
  852. // Called by client engine when a header for this renderer is
  853. // available. The header will arrive before any packets.
  854. //
  855. STDMETHODIMP CVideoRenderer::OnHeader(IHXValues* pHeader)
  856. {
  857.     HX_RESULT retVal = HXR_OK;
  859.     HX_DELETE(m_pClipRect);
  861.     // Keep this for later use...
  862.     HX_RELEASE(m_pHeader);
  863.     m_pHeader = pHeader;
  864.     m_pHeader->AddRef();
  866.     m_ulStreamBaseTime = 0;
  867.     m_ulBaseTime = 0;
  868.     m_ulTimeNormalizationOffset = 0;
  870.     // check the stream versions
  871.     m_pHeader->AddRef();
  872.     retVal = CheckStreamVersions(m_pHeader);
  873.     m_pHeader->Release();
  875. #ifdef HELIX_FEATURE_QUICKTIME
  876.     IHXBuffer* pSDPData = NULL;
  878.     if (SUCCEEDED(retVal) &&
  879. SUCCEEDED(pHeader->GetPropertyCString("SDPData", pSDPData)))
  880.     {
  881. char *pData = (char*) pSDPData->GetBuffer();
  882. IHXValues *pValues = NULL;
  884. if (pData &&
  885.     SUCCEEDED(SDPParseChunk(pData,
  886.     strlen(pData),
  887.     pValues,
  888.     m_pCommonClassFactory,
  889.     SDPCTX_Renderer)))
  890. {
  891.     ULONG32 ulLeft;
  892.     ULONG32 ulRight;
  893.     ULONG32 ulTop;
  894.     ULONG32 ulBottom;
  896.     if (SUCCEEDED(pValues->GetPropertyULONG32(
  897.     "ClipFrameLeft", ulLeft)) &&
  898. SUCCEEDED(pValues->GetPropertyULONG32(
  899.     "ClipFrameRight", ulRight)) &&
  900. SUCCEEDED(pValues->GetPropertyULONG32(
  901.     "ClipFrameTop", ulTop)) &&
  902. SUCCEEDED(pValues->GetPropertyULONG32(
  903.     "ClipFrameBottom", ulBottom)))
  904.     {
  905. retVal = HXR_OUTOFMEMORY;
  907. m_pClipRect = (HXxRect*) new HXxRect;
  908. if (m_pClipRect)
  909. {
  910.     m_pClipRect->left = (INT32) ulLeft;
  911.     m_pClipRect->right = (INT32) ulRight;
  912.     m_pClipRect->top = (INT32) ulTop;
  913.     m_pClipRect->bottom = (INT32) ulBottom;
  914.     retVal = HXR_OK;
  915. }
  916.     }
  917. }
  919. HX_RELEASE(pValues);
  920.     }
  922.     HX_RELEASE(pSDPData);
  923. #endif // HELIX_FEATURE_QUICKTIME
  925.     if (SUCCEEDED(retVal))
  926.     {
  927. m_pVideoFormat = CreateFormatObject(m_pHeader);
  929. retVal = HXR_OUTOFMEMORY;
  930. if (m_pVideoFormat)
  931. {
  932.     m_pVideoFormat->AddRef();
  933.     retVal = HXR_OK;
  934. }
  935.     }
  937.     if (SUCCEEDED(retVal))
  938.     {
  939. retVal = m_pVideoFormat->Init(pHeader);
  940.     }
  942.     if (SUCCEEDED(retVal))
  943.     {
  944. m_ulEarlyFrameTol = GetEarlyFrameTolerance();
  945. m_ulLateFrameTol = GetLateFrameTolerance();
  946. m_ulMaxOptimizedVideoLead = GetMaxOptimizedVideoLead();
  948. m_ulMaxSleepTime = GetMaxSleepTime();
  949. m_ulNoFramesPollingInterval = GetNoFramesPollingInterval();
  950. m_ulBltPacketQueueSize = GetBltPacketQueueSize();
  951. m_ulSyncGoalSmoothingDepth = GetSyncGoalSmoothingDepth();
  952. m_ulSpeedupGoalSmoothingDepth = GetSpeedupGoalSmoothingDepth();
  953. m_ulMaxBadSeqSamples = GetMaxBadSeqSamples();
  954.     }
  956.     // Setup preroll
  957.     if (SUCCEEDED(retVal))
  958.     {
  959. BOOL bSetNewPreroll = FALSE;
  960.         m_ulPreroll = 0;
  961. ULONG32 ulMinPreroll = m_pVideoFormat->GetMinimumPreroll(pHeader);
  962. ULONG32 ulMaxPreroll = m_pVideoFormat->GetMaximumPreroll(pHeader);
  964.         // Check that the stream header has a preroll value. If not...
  965. pHeader->GetPropertyULONG32("Preroll", m_ulPreroll);
  966. if (m_ulPreroll == 0)
  967. {
  968.             // ... let's use default value.
  969.     m_ulPreroll = m_pVideoFormat->GetDefaultPreroll(pHeader);
  970.     bSetNewPreroll = TRUE;
  971. }
  972.         else if( m_ulPreroll > ulMaxPreroll )
  973.         {
  974.             m_ulPreroll = ulMaxPreroll;
  975.     bSetNewPreroll = TRUE;
  976.         }
  977. else if (m_ulPreroll < ulMinPreroll)
  978. {
  979.     m_ulPreroll = ulMinPreroll;
  980.     bSetNewPreroll = TRUE;
  981. }
  983. if (bSetNewPreroll)
  984. {
  985.     pHeader->SetPropertyULONG32("Preroll", m_ulPreroll);
  986. }
  987.     }
  989.     // Determine Average Bitrate
  990.     if (SUCCEEDED(retVal))
  991.     {
  992. if (FAILED(pHeader->GetPropertyULONG32("AvgBitRate", m_ulAvgBitRate)))
  993. {
  994.     m_ulAvgBitRate = 0;
  995. }
  996.     }
  998.     // Create Blt Queue
  999.     if (SUCCEEDED(retVal))
  1000.     {
  1001. m_pBltPacketQueue = new CRingBuffer(m_ulBltPacketQueueSize);
  1003. retVal = HXR_OUTOFMEMORY;
  1004. if (m_pBltPacketQueue)
  1005. {
  1006.     retVal = HXR_OK;
  1007. }
  1008.     }
  1010.     return retVal;
  1011. }
  1014. /////////////////////////////////////////////////////////////////////////////
  1015. //  Method:
  1016. // CVideoRenderer::CheckStreamVersions
  1017. //  copied from CRealAudioRenderer
  1018. HX_RESULT CVideoRenderer::CheckStreamVersions(IHXValues* pHeader)
  1019. {
  1020.     // check stream and content versions so an upgrade can
  1021.     // be called if necessary...
  1022.     HX_RESULT pnr = HXR_OK;
  1024.     BOOL bVersionOK = TRUE;
  1026.     UINT32 ulStreamVersion = 0;
  1027.     UINT32 ulContentVersion = 0;
  1029.     if(HXR_OK == pHeader->GetPropertyULONG32("StreamVersion",
  1030. ulStreamVersion))
  1031.     {
  1032. UINT32 ulMajorVersion = HX_GET_MAJOR_VERSION(ulStreamVersion);
  1033. UINT32 ulMinorVersion = HX_GET_MINOR_VERSION(ulStreamVersion);
  1034. ULONG32 ulThisMajorVersion = 0;
  1035. ULONG32 ulThisMinorVersion = 0;
  1037. GetStreamVersion(ulThisMajorVersion, ulThisMinorVersion);
  1039. if((ulMajorVersion > ulThisMajorVersion) ||
  1040.    ((ulMinorVersion > ulThisMinorVersion) &&
  1041.     (ulMajorVersion == ulThisMajorVersion)))
  1042. {
  1043.     bVersionOK = FALSE;
  1044. }
  1045.     }
  1047.     if(bVersionOK &&
  1048.        (HXR_OK == pHeader->GetPropertyULONG32("ContentVersion",
  1049.       ulContentVersion)))
  1050.     {
  1051. UINT32 ulMajorVersion = HX_GET_MAJOR_VERSION(ulContentVersion);
  1052. UINT32 ulMinorVersion = HX_GET_MINOR_VERSION(ulContentVersion);
  1053. ULONG32 ulThisMajorVersion = 0;
  1054. ULONG32 ulThisMinorVersion = 0;
  1056. GetContentVersion(ulThisMajorVersion, ulThisMinorVersion);
  1058. if((ulMajorVersion > ulThisMajorVersion) ||
  1059.    ((ulMinorVersion > ulThisMinorVersion) &&
  1060.     (ulMajorVersion == ulMajorVersion)))
  1061. {
  1062.     bVersionOK = FALSE;
  1063. }
  1064.     }
  1066.     if(!bVersionOK)
  1067.     {
  1068.         AddToAutoUpgradeCollection(GetUpgradeMimeType(), m_pContext);
  1070. pnr = HXR_FAIL;
  1071.     }
  1073.     return pnr;
  1074. }
  1077. /////////////////////////////////////////////////////////////////////////
  1078. //  Method:
  1079. // IHXRenderer::OnPacket
  1080. //  Purpose:
  1081. // Called by client engine when a packet for this renderer is
  1082. // due.
  1083. //
  1084. STDMETHODIMP CVideoRenderer::OnPacket(IHXPacket* pPacket, LONG32 lTimeOffset)
  1085. {
  1086.     m_lTimeLineOffset = lTimeOffset;
  1088. #ifdef ENABLE_INPUT_TRACE
  1089.     if (ulInputTraceIdx < MAX_INPUT_TRACE_ENTRIES)
  1090.     {
  1091. inputTraceArray[ulInputTraceIdx++] =
  1092.     ComputeTimeAhead(pPacket->GetTime(), 0);
  1093.     }
  1094. #endif // ENABLE_INPUT_TRACE
  1096.     if (m_bSchedulerStartRequested)
  1097.     {
  1098. StartSchedulers();
  1099.     }
  1101.     BOOL bQueueRet = m_pVideoFormat->Enqueue(pPacket);
  1102.     if(bQueueRet == FALSE && m_pVideoFormat->GetLastError() == HXR_OUTOFMEMORY)
  1103.     {
  1104.         return HXR_OUTOFMEMORY;
  1105.     }
  1107.     // try to decode a frame
  1108.     if (m_PlayState == Playing)
  1109.     {
  1110. if (!IsDecoderRunning() || NULL == m_pDecoderPump)
  1111. {
  1112.     BOOL bDecRet = m_pVideoFormat->DecodeFrame();
  1113.             if( bDecRet == FALSE && m_pVideoFormat->GetLastError() == HXR_OUTOFMEMORY )
  1114.             {
  1115.                 return HXR_OUTOFMEMORY;
  1116.             }
  1117. }
  1118. else
  1119. {
  1120.     m_pDecoderPump->Signal();
  1121. }
  1122.     }
  1123.     else
  1124.     {
  1125. if (!m_bBaseTimeSet)
  1126. {
  1127.     m_pMutex->Lock();
  1128.     if (m_PlayState != Playing)
  1129.     {
  1130. m_ulBaseTime = pPacket->GetTime();
  1131.     }
  1132.     m_pMutex->Unlock();
  1133.     m_bBaseTimeSet = TRUE;
  1134. }
  1136. // If we are seeking, this is a pre-seek packet and there is
  1137. // no need to decode it
  1138. if (m_PlayState != Seeking)
  1139. {
  1140.     if (!IsDecoderRunning() || NULL == m_pDecoderPump)
  1141.     {
  1142. m_pVideoFormat->DecodeFrame();
  1143.     }
  1144.     else
  1145.     {
  1146. m_pDecoderPump->Signal();
  1147.     }
  1149.     if (m_PlayState == Buffering)
  1150.     {
  1151. if (IsBufferingComplete(pPacket))
  1152. {
  1153.     RequestBufferingEnd();
  1154. }
  1155.     }
  1156. }
  1157.     }
  1159.     return HXR_OK;
  1160. }
  1163. /////////////////////////////////////////////////////////////////////////
  1164. //  Method:
  1165. // IHXRenderer::OnTimeSync
  1166. //  Purpose:
  1167. // Called by client engine to inform the renderer of the current
  1168. // time relative to the streams synchronized time-line. The
  1169. // renderer should use this time value to update its display or
  1170. // render it's stream data accordingly.
  1171. //
  1172. STDMETHODIMP CVideoRenderer::OnTimeSync(ULONG32 ulTime)
  1173. {
  1174.     ULONG32 ulStreamBaseTime = HX_GET_BETTERTICKCOUNT();
  1175.     ULONG32 ulBaseTime = ulTime;
  1176.     BOOL bGoodSample = TRUE;
  1178.     if (m_bSchedulerStartRequested)
  1179.     {
  1180. StartSchedulers();
  1181.     }
  1183. #ifdef HELIX_FEATURE_STATS
  1184.     if (((ULONG32) (ulStreamBaseTime - m_pVideoStats->GetLastSyncTime())) >=
  1185. VIDEO_STAT_INTERVAL)
  1186.     {
  1187. m_pVideoStats->SyncStats(ulStreamBaseTime);
  1188.     }
  1189. #endif /* HELIX_FEATURE_STATS */
  1191. #ifdef ENABLE_SYNC_TRACE
  1192.     ULONG32 ulOrigStreamBaseTime = ulStreamBaseTime;
  1193. #endif // ENABLE_SYNC_TRACE
  1195. #ifdef SYNC_SMOOTHING_OLD_SCHEME
  1196.     LONG32 lNewSyncDelta = (LONG32) (ulStreamBaseTime - m_lTrendSyncDelta - ulTime);
  1197.     m_lTrendSyncDelta += lNewSyncDelta / ((LONG32) (m_ulSyncSmoothingDepth + 1));
  1199.     ulStreamBaseTime = ulTime + m_lTrendSyncDelta;
  1201.     if (m_ulSyncSmoothingDepth < m_ulSyncGoalSmoothingDepth)
  1202.     {
  1203. m_ulSyncSmoothingDepth++;
  1204.     }
  1205. #endif // SYNC_SMOOTHING_OLD_SCHEME
  1207. #ifdef SYNC_PRE_SMOOTHING
  1208.     if (m_ulSyncSmoothingDepth > 0)
  1209.     {
  1210. LONG32 lStreamBaseDelta = ((LONG32) (ulStreamBaseTime - m_ulStreamBaseTime));
  1211. ULONG32 ulBaseDelta = ulBaseTime - m_ulBaseTime;
  1212. BOOL bSkipSmoothing = FALSE;
  1214. bGoodSample = ((lStreamBaseDelta <= 0) ||
  1215.        (((ULONG32) lStreamBaseDelta) <=
  1216.         (ulBaseDelta + (ulBaseDelta >> AUDIO_SKEW_POWER))) ||
  1217.        (bSkipSmoothing = ((m_ulBadSeqSampleCount++) > m_ulMaxBadSeqSamples)));
  1219. if (bSkipSmoothing)
  1220. {
  1221.     m_ulSyncSmoothingDepth = 0;
  1222.     m_fTrendSyncDelta = 0.0;
  1223. }
  1224.     }
  1225. #endif // SYNC_PRE_SMOOTHING
  1227.     if (bGoodSample)
  1228.     {
  1229. #ifdef SYNC_SMOOTHING
  1230. double fNewSyncDelta = (((double) ((ULONG32) (ulStreamBaseTime - ulTime))) -
  1231.        m_fTrendSyncDelta);
  1233. // If we have a m_fTrendSyncDelta, make sure we consider
  1234. // m_fTrendSyncDelta wrap-around in relation to fNewSyncDelta
  1235. if (m_ulSyncSmoothingDepth > 0)
  1236. {
  1237.     if (fNewSyncDelta > MAX_LONG32_AS_DOUBLE)
  1238.     {
  1239. fNewSyncDelta = MAX_ULONG32_AS_DOUBLE - fNewSyncDelta;
  1240.     }
  1241.     else if (fNewSyncDelta < MIN_LONG32_AS_DOUBLE)
  1242.     {
  1243. fNewSyncDelta += MAX_ULONG32_AS_DOUBLE;
  1244.     }
  1245. }
  1247. if (fNewSyncDelta < 0.0)
  1248. {
  1249.     // We are trying to speed up: use speed up smoothing criteria
  1250.     m_fTrendSyncDelta += (fNewSyncDelta /
  1251.   ((m_ulSyncSmoothingDepth >= m_ulSpeedupGoalSmoothingDepth) ?
  1252.    m_ulSpeedupGoalSmoothingDepth + 1 : m_ulSyncSmoothingDepth + 1));
  1253. }
  1254. else
  1255. {
  1256.     m_fTrendSyncDelta += fNewSyncDelta / (m_ulSyncSmoothingDepth + 1);
  1257. }
  1259. if (m_fTrendSyncDelta > MAX_ULONG32_AS_DOUBLE)
  1260. {
  1261.     m_fTrendSyncDelta -= MAX_ULONG32_AS_DOUBLE;
  1262. }
  1263. else if (m_fTrendSyncDelta < 0)
  1264. {
  1265.      m_fTrendSyncDelta += MAX_ULONG32_AS_DOUBLE;
  1266. }
  1268. ulStreamBaseTime = ulTime + ((ULONG32) (m_fTrendSyncDelta));
  1270. if (m_ulSyncSmoothingDepth < m_ulSyncGoalSmoothingDepth)
  1271. {
  1272.     m_ulSyncSmoothingDepth++;
  1273. }
  1274. #endif // SYNC_SMOOTHING
  1276. m_ulGoodSeqSampleCount++;
  1278. m_ulStreamBaseTime = ulStreamBaseTime;
  1279. m_ulBaseTime = ulBaseTime;
  1280. m_ulTimeNormalizationOffset = m_ulStreamBaseTime -
  1281.       m_ulBaseTime -
  1282.       m_lTimeLineOffset;
  1284. if (m_ulGoodSeqSampleCount >= MIN_GOOD_PERSISTENCE_COUNT)
  1285. {
  1286.     m_ulBadSeqSampleCount = 0;
  1287. }
  1288.     }
  1289.     else
  1290.     {
  1291. // This is a bad sample
  1292. if (m_ulBadSeqSampleCount >= MIN_BAD_PERSISTENCE_COUNT)
  1293. {
  1294.     m_ulGoodSeqSampleCount = 0;
  1295. }
  1296.     }
  1298. #ifdef ENABLE_SYNC_TRACE
  1299.     if (ulSyncTraceIdx < MAX_SYNC_TRACE_ENTRIES)
  1300.     {
  1301. syncTraceArray[ulSyncTraceIdx][0] = m_ulBaseTime;
  1302. syncTraceArray[ulSyncTraceIdx][1] = m_ulStreamBaseTime;
  1303. syncTraceArray[ulSyncTraceIdx++][2] = ulOrigStreamBaseTime;
  1304.     }
  1305. #endif // ENABLE_SYNC_TRACE
  1307.     if (m_PlayState == Playing)
  1308.     {
  1309. if (!IsDecoderRunning())
  1310. {
  1311.     m_pVideoFormat->DecodeFrame();
  1312. }
  1314. if (m_bBufferingNeeded)
  1315. {
  1316.     m_pMutex->Lock();
  1318.     if (m_PlayState == Playing)
  1319.     {
  1320. BeginBuffering();
  1321.     }
  1323.     m_pMutex->Unlock();
  1324. }
  1325.     }
  1326.     else if ((m_PlayState == PlayStarting) ||
  1327.      (m_PlayState == Buffering))
  1328.     {
  1329. m_pMutex->Lock();
  1331. m_bBaseTimeSet = TRUE;
  1333. // Reset the offset to avoid race condition
  1334. // with m_ulTimeNormalizationOffset setting in OnPacket()
  1335. if (bGoodSample)
  1336. {
  1337.     m_ulTimeNormalizationOffset = m_ulStreamBaseTime -
  1338.   m_ulBaseTime -
  1339.   m_lTimeLineOffset;
  1340. }
  1342. if (m_PlayState == Buffering)
  1343. {
  1344.     EndBuffering();
  1345.     m_PlayState = PlayStarting;
  1346. }
  1348. if (m_PlayState == PlayStarting)
  1349. {
  1350.     m_PlayState = Playing;
  1352.     BltIfNeeded();
  1354.     StartSchedulers();
  1356.     if (m_pBltrPump)
  1357.     {
  1358. m_pBltrPump->Signal();
  1359.     }
  1360. }
  1362. m_pMutex->Unlock();
  1363.     }
  1365.     return HXR_OK;
  1366. }
  1369. HX_RESULT CVideoRenderer::StartSchedulers(void)
  1370. {
  1371.     HX_RESULT retVal = HXR_OK;
  1374. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  1376.     // When running the decoder as fast as possible, we dont want to start the scheduler, so short
  1378.     // circuit this code. Additionally, calls such as BltIfNeeded() and ScheduleCallback() (which
  1380.     // may still be called) make assumptions based on the state of our interactions with the
  1382.     // scheduler, so we satisfy them by setting a pending handle representing a nonexistant callback.
  1384.     if( m_bUntimedRendering )
  1386.     {
  1388. m_hPendingHandle = 1;
  1390. return HXR_OK;
  1392.     }
  1394. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  1397.     m_bSchedulerStartRequested = FALSE;
  1399.     DisplayMutex_Lock();
  1401.     if (ShouldKickStartScheduler())
  1402.     {
  1403. m_bBufferingNeeded = FALSE;
  1404. ScheduleCallback(0);
  1405.     }
  1407.     if (SUCCEEDED(retVal) && (m_pDecoderPump == NULL))
  1408.     {
  1409. CVideoPaceMaker* pVideoPaceMaker;
  1410. retVal = HXR_OUTOFMEMORY;
  1412. pVideoPaceMaker = new CVideoPaceMaker;
  1414. if (pVideoPaceMaker)
  1415. {
  1416.     retVal = pVideoPaceMaker->QueryInterface(
  1417. IID_IHXPaceMaker,
  1418. (void**) &m_pDecoderPump);
  1420.     if (SUCCEEDED(retVal))
  1421.     {
  1422. pVideoPaceMaker = NULL;
  1423. m_pDecoderPump->Start(this,
  1424.     GetDecodePriority(),
  1425.     DECODER_INTERVAL,
  1426.     m_ulDecoderPacemakerId);
  1427.     }
  1428. }
  1430. HX_DELETE(pVideoPaceMaker);
  1431.     }
  1433.     if (SUCCEEDED(retVal) && (m_pBltrPump == NULL) && m_bTryVideoSurface2)
  1434.     {
  1435. CVideoPaceMaker* pVideoPaceMaker;
  1436. retVal = HXR_OUTOFMEMORY;
  1438. pVideoPaceMaker = new CVideoPaceMaker;
  1440. if (pVideoPaceMaker)
  1441. {
  1442.     retVal = pVideoPaceMaker->QueryInterface(
  1443. IID_IHXPaceMaker,
  1444. (void**) &m_pBltrPump);
  1446.     if (SUCCEEDED(retVal))
  1447.     {
  1448. pVideoPaceMaker = NULL;
  1449. m_pBltrPump->Start(this,
  1450.     DFLT_PRESENT_PRIORITY,
  1451.     BLTR_INTERVAL,
  1452.     m_ulBltrPacemakerId);
  1453.     }
  1454. }
  1456. HX_DELETE(pVideoPaceMaker);
  1457.     }
  1459.     DisplayMutex_Unlock();
  1461.     return retVal;
  1462. }
  1465. /////////////////////////////////////////////////////////////////////////
  1466. //  Method:
  1467. // IHXRenderer::OnPreSeek
  1468. //  Purpose:
  1469. // Called by client engine to inform the renderer that a seek is
  1470. // about to occur. The render is informed the last time for the
  1471. // stream's time line before the seek, as well as the first new
  1472. // time for the stream's time line after the seek will be completed.
  1473. //
  1474. STDMETHODIMP CVideoRenderer::OnPreSeek(ULONG32 ulOldTime, ULONG32 ulNewTime)
  1475. {
  1476.     // Change state to stop Blts
  1477.     m_pMutex->Lock();
  1478.     m_PlayState = Seeking;
  1479.     m_pMutex->Unlock();
  1481.     // Suspend the Decoder pump
  1482.     if (m_pDecoderPump)
  1483.     {
  1484. m_pDecoderPump->Suspend(TRUE);
  1485. m_pDecoderPump->Signal();
  1486. m_pDecoderPump->WaitForSuspend();
  1487.     }
  1489.     // Wait for Blt in progress to complete and reset
  1490.     // packet queues
  1491.     DisplayMutex_Lock();
  1493.     m_pVideoFormat->SetStartTime(ulNewTime);
  1494.     m_pVideoFormat->Reset();
  1495. #if defined(HELIX_FEATURE_STATS)
  1496.     m_pVideoStats->ResetSequence();
  1497. #endif /* HELIX_FEATURE_STATS */
  1499.     m_bFirstSurfaceUpdate = TRUE;
  1500.     m_bFirstFrame = TRUE;
  1501.     m_bBaseTimeSet = FALSE;
  1503.     DisplayMutex_Unlock();
  1505.     return HXR_OK;
  1506. }
  1508. /////////////////////////////////////////////////////////////////////////
  1509. //  Method:
  1510. // IHXRenderer::OnPostSeek
  1511. //  Purpose:
  1512. // Called by client engine to inform the renderer that a seek has
  1513. // just occured. The render is informed the last time for the
  1514. // stream's time line before the seek, as well as the first new
  1515. // time for the stream's time line after the seek.
  1516. //
  1517. STDMETHODIMP CVideoRenderer::OnPostSeek(ULONG32 ulOldTime, ULONG32 ulNewTime)
  1518. {
  1519.     DisplayMutex_Lock();
  1521.     // clean up the packet lists
  1522.     m_pVideoFormat->SetStartTime(ulNewTime);
  1523.     m_pVideoFormat->Reset();
  1525. #if defined(HELIX_FEATURE_STATS)
  1526.     m_pVideoStats->ResetSequence();
  1527. #endif /* HELIX_FEATURE_STATS */
  1529.     m_bFirstSurfaceUpdate = TRUE;
  1530.     m_bFirstFrame = TRUE;
  1531.     m_ulBaseTime = ulNewTime;
  1532.     m_bBaseTimeSet = TRUE;
  1533.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  1535.     if (m_pDecoderPump)
  1536.     {
  1537. m_pDecoderPump->Suspend(FALSE);
  1538. m_pDecoderPump->Signal();
  1539.     }
  1541.     if (m_bUseVideoSurface2 && m_pMISUSSite)
  1542.     {
  1543. FlushVideoSurface2(m_pMISUSSite);
  1544.     }
  1546.     DisplayMutex_Unlock();
  1548.     // PostSeek signals the proper packets are to start arriving
  1549.     m_pMutex->Lock();
  1550.     m_PlayState = PlayStarting;
  1551.     m_pMutex->Unlock();
  1553.     return HXR_OK;
  1554. }
  1556. /////////////////////////////////////////////////////////////////////////
  1557. //  Method:
  1558. // IHXRenderer::OnPause
  1559. //  Purpose:
  1560. // Called by client engine to inform the renderer that a pause has
  1561. // just occured. The render is informed the last time for the
  1562. // stream's time line before the pause.
  1563. //
  1564. STDMETHODIMP CVideoRenderer::OnPause(ULONG32 ulTime)
  1565. {
  1566.     m_pMutex->Lock();
  1568.     m_PlayState = Paused;
  1570.     m_pMutex->Unlock();
  1572.     return HXR_OK;
  1573. }
  1575. /////////////////////////////////////////////////////////////////////////
  1576. //  Method:
  1577. // IHXRenderer::OnBegin
  1578. //  Purpose:
  1579. // Called by client engine to inform the renderer that a begin or
  1580. // resume has just occured. The render is informed the first time
  1581. // for the stream's time line after the resume.
  1582. //
  1583. STDMETHODIMP CVideoRenderer::OnBegin(ULONG32 ulTime)
  1584. {
  1585.     HX_RESULT retVal = HXR_OK;
  1587.     m_pMutex->Lock();
  1589.     m_bBufferingOccured = FALSE;
  1590.     // If we are seeking, PostSeek will notify us when the play
  1591.     // will be starting
  1592.     if (m_PlayState != Seeking)
  1593.     {
  1594. m_PlayState = PlayStarting;
  1595.     }
  1597.     // No need to clear the Blt Packet queue here since
  1598.     // The Refresh event will always clear it and clearing
  1599.     // it here would create a race condition on Blt Packet
  1600.     // Queue (ring buffer) read.
  1601.     // ClearBltPacketQueue();
  1602.     m_ulSyncSmoothingDepth = 0;
  1603.     m_ulBadSeqSampleCount = 0;
  1604.     m_ulGoodSeqSampleCount = 0;
  1605.     m_bIsScheduledCB = 0;
  1606.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  1608.     retVal = StartSchedulers();
  1610.     m_pMutex->Unlock();
  1612. #ifdef HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  1613.     if (m_pDecoderPump)
  1614.     {
  1615.        //m_pDecoderPump->Suspend(TRUE);
  1616.        //m_pDecoderPump->WaitForSuspend();  // Wait for decoder thread to start and suspends itself
  1617.        //m_pDecoderPump->Suspend(FALSE);
  1618.        m_pDecoderPump->Signal();   // Kick-out decoder pump from suspension
  1619.     }
  1620. #endif  // HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  1622.     return retVal;
  1623. }
  1625. /////////////////////////////////////////////////////////////////////////
  1626. //  Method:
  1627. // IHXRenderer::OnBuffering
  1628. //  Purpose:
  1629. // Called by client engine to inform the renderer that buffering
  1630. // of data is occuring. The render is informed of the reason for
  1631. // the buffering (start-up of stream, seek has occured, network
  1632. // congestion, etc.), as well as percentage complete of the
  1633. // buffering process.
  1634. //
  1635. STDMETHODIMP CVideoRenderer::OnBuffering(ULONG32 ulFlags, UINT16 unPercentComplete)
  1636. {
  1637.     HX_RESULT retVal = HXR_OK;
  1639.     m_pMutex->Lock();
  1641.     if (m_PlayState == Buffering)
  1642.     {
  1643. if (IsBufferingComplete())
  1644. {
  1645.     EndBuffering();
  1646. }
  1647.     }
  1648.     else if (m_PlayState == Playing)
  1649.     {
  1650. m_PlayState = PlayStarting;
  1651.     }
  1653.     m_pMutex->Unlock();
  1655.     return retVal;
  1656. }
  1658. /////////////////////////////////////////////////////////////////////////
  1659. //  Method:
  1660. // IHXRenderer::GetDisplayType
  1661. //  Purpose:
  1662. // Called by client engine to ask the renderer for it's preferred
  1663. // display type. When layout information is not present, the
  1664. // renderer will be asked for it's prefered display type. Depending
  1665. // on the display type a buffer of additional information may be
  1666. // needed. This buffer could contain information about preferred
  1667. // window size.
  1668. //
  1669. STDMETHODIMP CVideoRenderer::GetDisplayType(REF(HX_DISPLAY_TYPE) ulFlags,
  1670.    REF(IHXBuffer*) pBuffer)
  1671. {
  1672.     ulFlags = HX_DISPLAY_WINDOW |
  1673.       HX_DISPLAY_SUPPORTS_RESIZE |
  1674.       HX_DISPLAY_SUPPORTS_FULLSCREEN |
  1675.       HX_DISPLAY_SUPPORTS_VIDCONTROLS;
  1677.     return HXR_OK;
  1678. }
  1680. /************************************************************************
  1681. * Method:
  1682. *     IHXRenderer::OnEndofPackets
  1683. * Purpose:
  1684. *     Called by client engine to inform the renderer that all the
  1685. *     packets have been delivered. However, if the user seeks before
  1686. *     EndStream() is called, renderer may start getting packets again
  1687. *     and the client engine will eventually call this function again.
  1688. */
  1689. STDMETHODIMP CVideoRenderer::OnEndofPackets(void)
  1690. {
  1691.     if (m_pVideoFormat)
  1692.     {
  1693. m_pVideoFormat->OnRawPacketsEnded();
  1694.     }
  1696.     return HXR_OK;
  1697. }
  1700. /************************************************************************
  1701.  *  IHXStatistics Methods
  1702.  */
  1703. /************************************************************************
  1704.  *  InitializeStatistics
  1705.  */
  1706. #define MAX_STAT_ENTRY_PAIRS 32
  1707. STDMETHODIMP CVideoRenderer::InitializeStatistics(UINT32 ulRegistryID)
  1708. {
  1709.     BOOL bCodecNameKnown = FALSE;
  1710.     char* pValue = NULL;
  1711.     HX_RESULT retVal = HXR_UNEXPECTED;
  1713.     m_ulRegistryID = ulRegistryID;
  1715. #if defined(HELIX_FEATURE_STATS)
  1716.     if (m_pVideoStats)
  1717.     {
  1718. retVal = HXR_OK;
  1719.     }
  1721.     if (SUCCEEDED(retVal))
  1722.     {
  1723. pValue = (char*) GetCodecName();
  1724. if (pValue != NULL)
  1725. {
  1726.     ReportStat(VS_CODEC_NAME, pValue);
  1727.     bCodecNameKnown = TRUE;
  1728. }
  1729.     }
  1731.     if (SUCCEEDED(retVal))
  1732.     {
  1733. pValue = (char*) GetRendererName();
  1734. if (pValue != NULL)
  1735. {
  1736.     ReportStat(VS_REND_NAME, pValue);
  1737.     // If Codec name is unknown, use a more generic renderer name
  1738.     if (!bCodecNameKnown)
  1739.     {
  1740. ReportStat(VS_CODEC_NAME, pValue);
  1741.     }
  1742. }
  1743.     }
  1745.     if (SUCCEEDED(retVal))
  1746.     {
  1747. pValue = (char*) GetCodecFourCC();
  1748. if (pValue != NULL)
  1749. {
  1750.     ReportStat(VS_CODEC_4CC, pValue);
  1751. }
  1752.     }
  1754.     if (SUCCEEDED(retVal))
  1755.     {
  1756. ReportStat(VS_CURRENT_FRAMERATE, "0.0");
  1757. ReportStat(VS_FRAMES_DISPLAYED, "100.0");
  1758. ReportStat(VS_FRAMES_DROPPED, (INT32) 0);
  1759. ReportStat(VS_FRAMES_LOST, (INT32) 0);
  1760. ReportStat(VS_SURESTREAM, "FALSE");
  1761. ReportStat(VS_IMAGE_WIDTH, (INT32) 0);
  1762. ReportStat(VS_IMAGE_HEIGHT, (INT32) 0);
  1763.     }
  1765.     if (SUCCEEDED(retVal))
  1766.     {
  1767. InitExtraStats();
  1768.     }
  1770.     if (SUCCEEDED(retVal))
  1771.     {
  1772. retVal = m_pVideoStats->DisplayStats(m_ulRegistryID);
  1773.     }
  1775.     return retVal;
  1776. #else
  1777.     return HXR_NOTIMPL;
  1778. #endif /* HELIX_FEATURE_STATS */
  1779. }
  1781. /************************************************************************
  1782.  *  UpdateStatistics
  1783.  */
  1784. STDMETHODIMP CVideoRenderer::UpdateStatistics()
  1785. {
  1786. #if defined(HELIX_FEATURE_STATS)
  1787.     HX_RESULT retVal = HXR_UNEXPECTED;
  1789.     if (m_pVideoStats)
  1790.     {
  1791. retVal = HXR_OK;
  1792.     }
  1794.     if (SUCCEEDED(retVal))
  1795.     {
  1796. retVal = m_pVideoStats->DisplayStats(m_ulRegistryID);
  1797.     }
  1799.     return retVal;
  1800. #else
  1801.     return HXR_NOTIMPL;
  1802. #endif /* HELIX_FEATURE_STATS */
  1803. }
  1806. /************************************************************************
  1807.  *  IHXUntimedDecoder Methods
  1808.  */
  1809. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  1810. STDMETHODIMP_(BOOL) CVideoRenderer::IsUntimedRendering()
  1811. {
  1812.     return m_bUntimedRendering;
  1813. }
  1814. STDMETHODIMP_(HX_RESULT) CVideoRenderer::SetUntimedRendering(BOOL bUntimedRendering)
  1815. {
  1817.     if( m_PlayState != Stopped && m_PlayState != PlayStarting )
  1819.     {
  1821. return HXR_UNEXPECTED;
  1823.     }
  1826.     m_bUntimedRendering = bUntimedRendering;
  1829.     return HXR_OK;
  1830. }
  1831. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  1833. /************************************************************************
  1834.  *  IHXUpdateProperties Methods
  1835.  */
  1836. /************************************************************************
  1837.  *  UpdatePacketTimeOffset
  1838.  * Call this method to update the timestamp offset of cached packets
  1839.  */
  1840. STDMETHODIMP CVideoRenderer::UpdatePacketTimeOffset(INT32 lTimeOffset)
  1841. {
  1842.     m_lTimeLineOffset -= lTimeOffset;
  1844.     return HXR_OK;
  1845. }
  1848. /************************************************************************
  1849.  * Method:
  1850.  *     IHXUpdateProperties::UpdatePlayTimes
  1851.  * Purpose:
  1852.  *     Call this method to update the playtime attributes
  1853.  */
  1854. STDMETHODIMP
  1855. CVideoRenderer::UpdatePlayTimes(IHXValues* pProps)
  1856. {
  1857.     return HXR_OK;
  1858. }
  1861. /************************************************************************
  1862.  *  IHXRenderTimeLine Methods
  1863.  */
  1864. /************************************************************************
  1865.  *  GetTimeLineValue
  1866.  */
  1867. STDMETHODIMP CVideoRenderer::GetTimeLineValue(REF(UINT32) ulTime)
  1868. {
  1869.     ulTime = ((ULONG32) -ComputeTimeAhead(0, 0));
  1871.     if (m_PlayState != Playing)
  1872.     {
  1873.         return HXR_TIMELINE_SUSPENDED;
  1874.     }
  1876.     return HXR_OK;
  1877. }
  1880. /************************************************************************
  1881.  *  IHXSiteUser Methods
  1882.  */
  1883. /************************************************************************
  1884.  *  AttachSite
  1885.  */
  1886. STDMETHODIMP CVideoRenderer::AttachSite(IHXSite* /*IN*/ pSite)
  1887. {
  1888.     if (m_pMISUSSite)
  1889.     {
  1890. return HXR_UNEXPECTED;
  1891.     }
  1893.     m_bSiteAttached = TRUE;
  1895.     m_pMISUSSite = pSite;
  1896.     m_pMISUSSite->AddRef();
  1898.     // for sync
  1899.     IHXInterruptSafe* pIHXInterruptSafe = NULL;
  1901.     if (HXR_OK == m_pMISUSSite->QueryInterface(IID_IHXInterruptSafe,
  1902.        (void**)&pIHXInterruptSafe))
  1903.     {
  1904. // Get the pref to use the optimized scheduler or not
  1905. BOOL bUseOptimized = TRUE;
  1906. IHXBuffer* pPrefBuffer;
  1908. if( m_pPreferences &&
  1909.             m_pPreferences->ReadPref("UseOptimizedScheduler",
  1910. pPrefBuffer) == HXR_OK)
  1911. {
  1912.     bUseOptimized = *(pPrefBuffer->GetBuffer()) == '1';
  1913.     HX_RELEASE(pPrefBuffer);
  1914. }
  1916. if (pIHXInterruptSafe->IsInterruptSafe() && bUseOptimized)
  1917. {
  1918.     HX_RELEASE(m_pOptimizedScheduler);
  1919.     if (HXR_OK !=
  1920.     m_pContext->QueryInterface(IID_IHXOptimizedScheduler,
  1921.     (void **) &m_pOptimizedScheduler))
  1922.     {
  1923. // just for good luck
  1924. m_pOptimizedScheduler = NULL;
  1925.     }
  1926. }
  1927.     }
  1928.     HX_RELEASE(pIHXInterruptSafe);
  1930. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  1931.     // Get Run Configuration
  1932.     // Use of VideoSurface2
  1933.     if (m_pPreferences)
  1934.     {
  1935. ReadPrefBOOL(m_pPreferences, "VideoBoost\NoFlip", m_bTryVideoSurface2);
  1936.     }
  1938.     // Use of OS Granule Boosting
  1939.     if (m_pPreferences)
  1940.     {
  1941. ReadPrefBOOL(m_pPreferences, "VideoBoost\NoOSGranuleBoost", m_bOSGranuleBoost);
  1942. m_bOSGranuleBoostVS2 = m_bOSGranuleBoost;
  1943.     }
  1945.     // Hardware buffer count to request from VideoSurface2
  1946.     if (m_bTryVideoSurface2 && m_pPreferences)
  1947.     {
  1948. ReadPrefINT32(m_pPreferences, "VideoBoost\InitialHSCount", m_ulConfigHWBufCount);
  1949.     }
  1951. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  1953.     /*
  1954.      * This is the best time to set the size of the site, we
  1955.      * know for example the the header has already been received
  1956.      * at this point.
  1957.      *
  1958.      * In most display renderers, you will store size information
  1959.      * in your stream header. In this example, we assume a specific
  1960.      * size, but we will initialize that size here as if it had
  1961.      * come from our header.
  1962.      *
  1963.      */
  1964.     SetupBitmapDefaults(m_pHeader, m_BitmapInfoHeader);
  1965.     FormatAndSetViewFrame(m_pClipRect,
  1966.   m_BitmapInfoHeader,
  1967.   m_rViewRect);
  1969.     m_bBitmapSet = ((m_BitmapInfoHeader.biWidth > 0) &&
  1970.     (m_BitmapInfoHeader.biHeight > 0));
  1972.     return HXR_OK;
  1973. }
  1976. STDMETHODIMP
  1977. CVideoRenderer::DetachSite()
  1978. {
  1979.     m_bSiteAttached = FALSE;
  1981.     HX_RELEASE(m_pMISUSSite);
  1983.     // We're done with these...
  1984.     if (m_pMISUS)
  1985.     {
  1986. m_pMISUS->ReleaseSingleSiteUser();
  1987.     }
  1989.     HX_RELEASE(m_pMISUS);
  1991.     return HXR_OK;
  1992. }
  1994. STDMETHODIMP_(BOOL)
  1995. CVideoRenderer::NeedsWindowedSites()
  1996. {
  1997.     return FALSE;
  1998. };
  2000. STDMETHODIMP
  2001. CVideoRenderer::HandleEvent(HXxEvent* /*IN*/ pEvent)
  2002. {
  2003.     HX_RESULT retVal = HXR_OK;
  2005.     pEvent->handled = FALSE;
  2006.     pEvent->result  = 0;
  2008.     switch (pEvent->event)
  2009.     {
  2010.     case HX_SURFACE_UPDATE:
  2011. m_pVSMutex->Lock();
  2012. retVal = UpdateDisplay(pEvent, TRUE);
  2013. m_pVSMutex->Unlock();
  2014. break;
  2016. #if defined(HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO)
  2017.     case HX_SURFACE_MODE_CHANGE:
  2018. switch ((int) pEvent->param2)
  2019. {
  2020. case HX_VIDEOSURFACE1_RECOMMENDED:
  2021.     pEvent->result = SwitchToVideoSurface1();
  2023.     if (SUCCEEDED(pEvent->result))
  2024.     {
  2025. pEvent->handled = TRUE;
  2026.     }
  2027.     break;
  2029. case HX_VIDEOSURFACE1_NOT_RECOMMENDED:
  2030.     pEvent->result = SwitchToVideoSurface2();
  2032.     if (SUCCEEDED(pEvent->result))
  2033.     {
  2034. pEvent->handled = TRUE;
  2035.     }
  2036.     break;
  2038. default:
  2039.     HX_ASSERT(FALSE);
  2040.     break;
  2041. }
  2042. break;
  2043. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  2045.     default:
  2046. // nothing to do
  2047. break;
  2048.     }
  2050.     return retVal;
  2051. }
  2053. // *** IUnknown methods ***
  2055. /****************************************************************************
  2056. *  IUnknown::AddRef                                            ref:  hxcom.h
  2057. *
  2058. *  This routine increases the object reference count in a thread safe
  2059. *  manner. The reference count is used to manage the lifetime of an object.
  2060. *  This method must be explicitly called by the user whenever a new
  2061. *  reference to an object is used.
  2062. */
  2063. STDMETHODIMP_(ULONG32) CVideoRenderer::AddRef()
  2064. {
  2065.     return InterlockedIncrement(&m_lRefCount);
  2066. }
  2068. /****************************************************************************
  2069. *  IUnknown::Release                                           ref:  hxcom.h
  2070. *
  2071. *  This routine decreases the object reference count in a thread safe
  2072. *  manner, and deletes the object if no more references to it exist. It must
  2073. *  be called explicitly by the user whenever an object is no longer needed.
  2074. */
  2075. STDMETHODIMP_(ULONG32) CVideoRenderer::Release()
  2076. {
  2077.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2078.     {
  2079.         return m_lRefCount;
  2080.     }
  2082.     delete this;
  2083.     return 0;
  2084. }
  2086. /****************************************************************************
  2087. *  IUnknown::QueryInterface                                    ref:  hxcom.h
  2088. *
  2089. *  This routine indicates which interfaces this object supports. If a given
  2090. *  interface is supported, the object's reference count is incremented, and
  2091. *  a reference to that interface is returned. Otherwise a NULL object and
  2092. *  error code are returned. This method is called by other objects to
  2093. *  discover the functionality of this object.
  2094. */
  2095. STDMETHODIMP CVideoRenderer::QueryInterface(REFIID riid, void** ppvObj)
  2096. {
  2097.     QInterfaceList  qiList[] =
  2098.     {
  2099. { GET_IIDHANDLE(IID_IHXCallback), (IHXCallback*)this},
  2100. { GET_IIDHANDLE(IID_IHXInterruptSafe), (IHXInterruptSafe*)this},
  2101. { GET_IIDHANDLE(IID_IHXUpdateProperties), (IHXUpdateProperties*)this},
  2102. { GET_IIDHANDLE(IID_IHXRenderTimeLine), (IHXRenderTimeLine*)this},
  2104. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  2106. { GET_IIDHANDLE(IID_IHXUntimedRenderer), (IHXUntimedRenderer*)this},
  2108. #endif
  2110. { GET_IIDHANDLE(IID_IHXPaceMakerResponse), (IHXPaceMakerResponse*)this},
  2111. { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPlugin*) this},
  2112. { GET_IIDHANDLE(IID_IHXPlugin), (IHXPlugin*)this},
  2113. { GET_IIDHANDLE(IID_IHXRenderer), (IHXRenderer*)this},
  2114. { GET_IIDHANDLE(IID_IHXSiteUser), (IHXSiteUser*)this},
  2115. { GET_IIDHANDLE(IID_IHXStatistics), (IHXStatistics*)this},
  2116.     };
  2118.     if (QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj) == HXR_OK)
  2119.     {
  2120. return HXR_OK ;
  2121.     }
  2122.     else if (m_pMISUS && IsEqualIID(riid, IID_IHXSiteUserSupplier))
  2123.     {
  2124. return m_pMISUS->QueryInterface(IID_IHXSiteUserSupplier,ppvObj);
  2125.     }
  2126.     else
  2127.     {
  2128. *ppvObj = NULL;
  2129. return HXR_NOINTERFACE;
  2130.     }
  2131. }
  2134. /****************************************************************************
  2135.  *  Renderer's customizable fuctions - can be called any time
  2136.  */
  2137. /****************************************************************************
  2138.  *  GetStreamVersion
  2139.  */
  2140. void CVideoRenderer::GetStreamVersion(ULONG32 &ulThisMajorVersion,
  2141.       ULONG32 &ulThisMinorVersion)
  2142. {
  2143.     ulThisMajorVersion = STREAM_MAJOR_VERSION;
  2144.     ulThisMinorVersion = STREAM_MINOR_VERSION;
  2145. }
  2147. /****************************************************************************
  2148.  *  GetContentVersion
  2149.  */
  2150. void CVideoRenderer::GetContentVersion(ULONG32 &ulThisMajorVersion,
  2151.        ULONG32 &ulThisMinorVersion)
  2152. {
  2153.     ulThisMajorVersion = CONTENT_MAJOR_VERSION;
  2154.     ulThisMinorVersion = CONTENT_MINOR_VERSION;
  2155. }
  2157. /****************************************************************************
  2158.  *  GetUpgradeMimeType
  2159.  */
  2160. const char* CVideoRenderer::GetUpgradeMimeType(void)
  2161. {
  2162.     const char** pStreamMimeTypes = NULL;
  2163.     UINT32 ulInitialGranularity;
  2165.     GetRendererInfo(pStreamMimeTypes, ulInitialGranularity);
  2167.     if (pStreamMimeTypes)
  2168.     {
  2169. return pStreamMimeTypes[0];
  2170.     }
  2172.     return NULL;
  2173. }
  2175. /****************************************************************************
  2176.  *  GetRendererName
  2177.  */
  2178. const char* CVideoRenderer::GetRendererName(void)
  2179. {
  2180.     return BASE_VIDEO_RENDERER_NAME;
  2181. }
  2183. /****************************************************************************
  2184.  *  GetCodecName
  2185.  */
  2186. const char* CVideoRenderer::GetCodecName(void)
  2187. {
  2188.     return NULL;
  2189. }
  2191. /****************************************************************************
  2192.  *  GetCodecFourCC
  2193.  */
  2194. const char* CVideoRenderer::GetCodecFourCC(void)
  2195. {
  2196.     return NULL;
  2197. }
  2199. /****************************************************************************
  2200.  *  GetLateFrameTolerance
  2201.  */
  2202. ULONG32 CVideoRenderer::GetLateFrameTolerance(void)
  2203. {
  2204.     return LATE_FRAME_TOL;
  2205. }
  2207. /****************************************************************************
  2208.  *  GetEarlyFrameTolerance
  2209.  */
  2210. ULONG32 CVideoRenderer::GetEarlyFrameTolerance(void)
  2211. {
  2212.     return EARLY_FRAME_TOL;
  2213. }
  2215. /****************************************************************************
  2216.  *  GetMaxOptimizedVideoLead
  2217.  */
  2218. ULONG32 CVideoRenderer::GetMaxOptimizedVideoLead(void)
  2219. {
  2220.     return MAX_OPTIMIZED_VIDEO_LEAD;
  2221. }
  2223. /****************************************************************************
  2224.  *  GetBltPacketQueueSize
  2225.  */
  2226. ULONG32 CVideoRenderer::GetBltPacketQueueSize(void)
  2227. {
  2228.     ULONG32 ulSize = BLT_PACKET_QUEUE_SIZE;
  2230.     if (m_pVideoFormat)
  2231.     {
  2232. m_pVideoFormat->GetMaxDecodedFrames();
  2233.     }
  2235.     return ulSize;
  2236. }
  2238. /****************************************************************************
  2239.  *  GetSyncGoalSmoothingDepth
  2240.  */
  2241. ULONG32 CVideoRenderer::GetSyncGoalSmoothingDepth(void)
  2242. {
  2243.     return SYNC_GOAL_SMOOTHING_DEPTH;
  2244. }
  2246. /****************************************************************************
  2247.  *  GetSpeedupGoalSmoothingDepth
  2248.  */
  2249. ULONG32 CVideoRenderer::GetSpeedupGoalSmoothingDepth(void)
  2250. {
  2251.     return SPEEDUP_GOAL_SMOOTHING_DEPTH;
  2252. }
  2254. /****************************************************************************
  2255.  *  GetNoFramesPollingInterval
  2256.  */
  2257. ULONG32 CVideoRenderer::GetNoFramesPollingInterval(void)
  2258. {
  2259.     return NO_FRAMES_POLLING_INTERVAL;
  2260. }
  2262. /****************************************************************************
  2263.  *  GetMaxSleepTime
  2264.  */
  2265. ULONG32 CVideoRenderer::GetMaxSleepTime(void)
  2266. {
  2267.     return m_ulMaxSleepTime;
  2268. }
  2271. /****************************************************************************
  2272.  *  GetMaxSleepTime
  2273.  */
  2274. ULONG32 CVideoRenderer::GetMaxBadSeqSamples(void)
  2275. {
  2276.     return MAX_BAD_SAMPLE_INTERVAL / m_ulSyncInterval;
  2277. }
  2280. /****************************************************************************
  2281.  *  GetDecodePriority
  2282.  */
  2283. LONG32 CVideoRenderer::GetDecodePriority(void)
  2284. {
  2285.     return m_lDecodePriority;
  2286. }
  2289. HX_RESULT CVideoRenderer::SetDecodePriority(LONG32 lPriority)
  2290. {
  2291.     HX_RESULT retVal = HXR_OK;
  2293.     if (m_pDecoderPump)
  2294.     {
  2295. retVal = m_pDecoderPump->SetPriority(lPriority);
  2296.     }
  2298.     if (SUCCEEDED(retVal))
  2299.     {
  2300. m_lDecodePriority = lPriority;
  2301.     }
  2303.     return retVal;
  2304. }
  2307. /****************************************************************************
  2308.  *  CreateFormatObject
  2309.  */
  2310. CVideoFormat* CVideoRenderer::CreateFormatObject(IHXValues* pHeader)
  2311. {
  2312.     return new CVideoFormat(m_pCommonClassFactory,
  2313.     this);
  2314. }
  2316. /****************************************************************************
  2317.  *  SetupBitmapDefaults
  2318.  */
  2319. void CVideoRenderer::SetupBitmapDefaults(IHXValues* pHeader,
  2320.    HXBitmapInfoHeader &bitmapInfoHeader)
  2321. {
  2322.     // size calculation is taken from crvvideo
  2323.     bitmapInfoHeader.biSize = sizeof (HXBitmapInfoHeader);
  2324.     bitmapInfoHeader.biWidth = 0; // 352; // unknown
  2325.     bitmapInfoHeader.biHeight = 0; // 288; // unknown
  2326.     bitmapInfoHeader.biPlanes = 1;
  2327.     bitmapInfoHeader.biBitCount = 24;
  2328.     bitmapInfoHeader.biCompression = HX_I420;
  2329.     bitmapInfoHeader.biSizeImage = bitmapInfoHeader.biWidth *
  2330.      bitmapInfoHeader.biHeight *
  2331.      bitmapInfoHeader.biBitCount /
  2332.      8;
  2333.     bitmapInfoHeader.biXPelsPerMeter = 0;
  2334.     bitmapInfoHeader.biYPelsPerMeter = 0;
  2335.     bitmapInfoHeader.biClrUsed = 0;
  2336.     bitmapInfoHeader.biClrImportant = 0;
  2337.     bitmapInfoHeader.rcolor = 0;
  2338.     bitmapInfoHeader.gcolor = 0;
  2339.     bitmapInfoHeader.bcolor = 0;
  2340. }
  2342. /****************************************************************************
  2343.  *  FormatAndSetViewFrame
  2344.  */
  2345. void CVideoRenderer::FormatAndSetViewFrame(HXxRect* pClipRect,
  2346.    HXBitmapInfoHeader &bitmapInfoHeader,
  2347.    HXxRect &rViewRect,
  2348.    BOOL bMutex)
  2349. {
  2350.     BOOL bAsDefault = TRUE;
  2351.     HXxSize szViewFrame;
  2353.     if (bMutex)
  2354.     {
  2355. DisplayMutex_Lock();
  2356.     }
  2358.     if (pClipRect)
  2359.     {
  2360. rViewRect = *pClipRect;
  2362. // Insure the ViewRect is inside the bitmap Rect
  2363. // Clip x
  2364. rViewRect.left = (rViewRect.left > 0) ?
  2365.     rViewRect.left : 0;
  2366. rViewRect.right = (rViewRect.right > 0) ?
  2367.     rViewRect.right : 0;
  2368. rViewRect.left = (rViewRect.left < bitmapInfoHeader.biWidth) ?
  2369.     rViewRect.left : bitmapInfoHeader.biWidth;
  2370. rViewRect.right = (rViewRect.right < bitmapInfoHeader.biWidth) ?
  2371.     rViewRect.right : bitmapInfoHeader.biWidth;
  2373. // Clip y
  2374. rViewRect.top = (rViewRect.top > 0) ?
  2375.     rViewRect.top : 0;
  2376. rViewRect.bottom = (rViewRect.bottom > 0) ?
  2377.     rViewRect.bottom : 0;
  2378. rViewRect.top = (rViewRect.top < bitmapInfoHeader.biHeight) ?
  2379.     rViewRect.top : bitmapInfoHeader.biHeight;
  2380. rViewRect.bottom = (rViewRect.bottom < bitmapInfoHeader.biHeight) ?
  2381.     rViewRect.bottom : bitmapInfoHeader.biHeight;
  2382.     }
  2383.     else
  2384.     {
  2385. rViewRect.left = 0;
  2386. rViewRect.top = 0;
  2387. rViewRect.right = bitmapInfoHeader.biWidth;
  2388. rViewRect.bottom = bitmapInfoHeader.biHeight;
  2389.     }
  2391.     // Compute Size
  2392.     szViewFrame.cx = rViewRect.right - rViewRect.left;
  2393.     szViewFrame.cy = rViewRect.bottom - rViewRect.top;
  2395.     if ((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0))
  2396.     {
  2397. if (m_pClipRect)
  2398. {
  2399.     szViewFrame.cx = m_pClipRect->right - m_pClipRect->left;
  2400.     szViewFrame.cy = m_pClipRect->bottom - m_pClipRect->top;
  2401. }
  2403. if ((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0))
  2404. {
  2405.     szViewFrame.cx = DEFAULT_WIN_SIZE_X;
  2406.     szViewFrame.cy = DEFAULT_WIN_SIZE_Y;
  2407. }
  2408.     }
  2410.     if (m_pClipRect)
  2411.     {
  2412. bAsDefault = FALSE;
  2413.     }
  2415.     _ResizeViewFrame(szViewFrame, FALSE, TRUE, bAsDefault);
  2417.     if (bMutex)
  2418.     {
  2419. DisplayMutex_Unlock();
  2420.     }
  2421. }
  2424. /****************************************************************************
  2425.  *  ResizeViewFrame
  2426.  */
  2427. BOOL CVideoRenderer::ResizeViewFrame(HXxSize szViewFrame,
  2428.      BOOL bMutex)
  2429. {
  2430.     HX_RESULT retVal;
  2432.     retVal = _ResizeViewFrame(szViewFrame,
  2433.       bMutex,
  2434.       FALSE,
  2435.       FALSE);
  2437.     return retVal;
  2438. }
  2440. BOOL CVideoRenderer::_ResizeViewFrame(HXxSize szViewFrame,
  2441.       BOOL bMutex,
  2442.       BOOL bForceSyncResize,
  2443.       BOOL bAsDefault)
  2444. {
  2445.     BOOL bRetVal = FALSE;
  2447.     if (m_bFrameSizeInitialized)
  2448.     {
  2449. return bRetVal;
  2450.     }
  2452.     if (bMutex)
  2453.     {
  2454. DisplayMutex_Lock();
  2455.     }
  2457.     if (!m_bFrameSizeInitialized)
  2458.     {
  2459. // If window size is already set, ignore further attempts to
  2460. // resize
  2461. if (m_bWinSizeFixed)
  2462. {
  2463.     szViewFrame.cx = m_SetWinSize.cx;
  2464.     szViewFrame.cy = m_SetWinSize.cy;
  2465. }
  2467. // If resulting size invalid, default to cliprect or bitmap size
  2468. if ((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0))
  2469. {
  2470.     if (((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0)) &&
  2471. m_pClipRect)
  2472.     {
  2473. szViewFrame.cx = m_pClipRect->right - m_pClipRect->left;
  2474. szViewFrame.cy = m_pClipRect->bottom - m_pClipRect->top;
  2475.     }
  2477.     if ((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0))
  2478.     {
  2479. szViewFrame.cx = m_BitmapInfoHeader.biWidth;
  2480. szViewFrame.cy = m_BitmapInfoHeader.biHeight;
  2481.     }
  2482. }
  2484. m_SetWinSize.cx = szViewFrame.cx;
  2485. m_SetWinSize.cy = szViewFrame.cy;
  2487. #if !defined(HELIX_FEATURE_VIDREND_DYNAMIC_RESIZE)
  2488. m_bWinSizeFixed = (m_bWinSizeFixed || (!bAsDefault));
  2489. #else
  2490.         HX_ASSERT(!m_bWinSizeFixed);
  2491. #endif
  2493. #ifdef RESIZE_AFTER_SITE_ATTACHED
  2494. if (m_bSiteAttached)
  2495. #endif // RESIZE_AFTER_SITE_ATTACHED
  2496. {
  2497. #ifdef SET_NONZERO_VIEWFRAME_ONLY
  2498.     if ((szViewFrame.cx > 0) && (szViewFrame.cy > 0))
  2499. #endif // SET_NONZERO_VIEWFRAME_ONLY
  2500.     {
  2501. #ifdef SYNC_RESIZE_OK
  2502. bForceSyncResize = TRUE;
  2503. #endif // SYNC_RESIZE_OK
  2505. if ((m_LastSetSize.cx != szViewFrame.cx) ||
  2506.     (m_LastSetSize.cy != szViewFrame.cy))
  2507. {
  2508.     m_LastSetSize = szViewFrame;
  2510.     if (bForceSyncResize)
  2511.     {
  2512. m_pMISUSSite->SetSize(szViewFrame);
  2513.     }
  2514.     else
  2515.     {
  2516. if (m_pResizeCB == NULL)
  2517. {
  2518.     m_pResizeCB = new CSetSizeCB(m_pMISUSSite);
  2520.     HX_ASSERT(m_pResizeCB);
  2522.     if (m_pResizeCB)
  2523.     {
  2524. m_pResizeCB->AddRef();
  2525.     }
  2526. }
  2528. if (m_pResizeCB)
  2529. {
  2530.     m_pResizeCB->SetSize(szViewFrame);
  2532.     HX_ASSERT(m_pScheduler);
  2534.     if (m_pScheduler)
  2535.     {
  2536. m_pScheduler->RelativeEnter(m_pResizeCB, 0);
  2537.     }
  2538. }
  2539.     }
  2540. }
  2541.     }
  2543.     // Once the the frame size is initialized, it is no longer
  2544.     // changable by the renderer.
  2545.     // The frame size can become initialzied only of the window
  2546.     // size is fixed. It can become fixed only if explicitly set
  2547.     // by non-default mode call to ResizeViewFrame.  ResizeViewFrame
  2548.     // can be called in non-default mode by either the video format
  2549.     // or the call can be made internally based on meta-header
  2550.     // specified information (e.g. clip rect.)
  2551.     if (m_bWinSizeFixed)
  2552.     {
  2553. m_bFrameSizeInitialized = TRUE;
  2554. bRetVal = TRUE;
  2555.     }
  2556. }
  2557.     }
  2559.     if (bMutex)
  2560.     {
  2561. DisplayMutex_Unlock();
  2562.     }
  2564.     return bRetVal;
  2565. }
  2568. /****************************************************************************
  2569.  *  SetSyncInterval
  2570.  */
  2571. void CVideoRenderer::SetSyncInterval(ULONG32 ulSyncInterval)
  2572. {
  2573.     if (ulSyncInterval != 0)
  2574.     {
  2575. m_ulSyncInterval = ulSyncInterval;
  2576.     }
  2577. }
  2580. /****************************************************************************
  2581.  *  InitExtraStats
  2582.  */
  2583. HX_RESULT CVideoRenderer::InitExtraStats(void)
  2584. {
  2585.     return HXR_OK;
  2586. }
  2589. /****************************************************************************
  2590.  *  Method:
  2591.  *    CVideoFormat::AdjustVideoMapping
  2592.  *
  2593.  */
  2594. void CVideoRenderer::AdjustVideoMapping(HXxRect &destRect,
  2595. HXxRect &sorcRect,
  2596. CMediaPacket*pActiveVideoPacket)
  2597. {
  2598.     return;
  2599. }
  2601. /****************************************************************************
  2602.  *  Renderer's private fuctions
  2603.  */
  2604. BOOL CVideoRenderer::ForceRefresh(void)
  2605. {
  2606.     BOOL bIsVisible;
  2608.     // Ask what the size was really set to!
  2609.     HXxSize finalSize;
  2610.     m_pMISUSSite->GetSize(finalSize);
  2612.     /* We now damage the entire rect all the time             */
  2613.     HXxRect damageRect = {0, 0, finalSize.cx, finalSize.cy};
  2615.     // Mark associated screen area as damaged as well...
  2616.     m_pMISUSSite->DamageRect(damageRect);
  2618.     HX_ASSERT(!m_bPendingRedraw);
  2619.     HX_ASSERT(!m_bVS1UpdateInProgress);
  2621.     m_bPendingRedraw = TRUE;
  2622.     m_bVS1UpdateInProgress = TRUE;
  2624.     m_pVSMutex->Unlock();
  2625.     m_pMISUSSite->ForceRedraw();
  2626.     m_pVSMutex->Lock();
  2627.     m_bVS1UpdateInProgress = FALSE;
  2629.     // If the redraw is still pending, it did not occur so assume the
  2630.     // surface is invisible
  2631.     bIsVisible = !m_bPendingRedraw;
  2632.     m_bPendingRedraw = FALSE;
  2634.     return bIsVisible;
  2635. }
  2637. HX_RESULT CVideoRenderer::UpdateDisplay(HXxEvent* pEvent,
  2638. BOOL bSystemEvent,
  2639. BOOL bIsVisible)
  2640. {
  2641.     IHXVideoSurface* pVideoSurface;
  2642.     CMediaPacket* pTmpPacket;
  2643.     CMediaPacket* pVideoPacket = NULL;
  2644.     BOOL bBitmapFormatChanged = FALSE;
  2645.     BOOL bNewFrameBlt = FALSE;
  2646.     HXxSize windowSize = {0, 0};
  2647.     LONG32 lFramesInBuffer;
  2648.     HX_RESULT retVal = HXR_OK;
  2650.     if (m_bVS1UpdateInProgress && m_bUseVideoSurface2)
  2651.     {
  2652. // Ignore update for incorrect surface
  2653. return HXR_OK;
  2654.     }
  2656.     lFramesInBuffer = m_pBltPacketQueue->Count();
  2658.     m_bPendingRedraw = FALSE;
  2660.     HX_TRACE_THINGY("C:/trace.txt", "Handle", m_hPendingHandle);
  2662.     if (!m_bUseVideoSurface2 || !bSystemEvent)
  2663.     {
  2664. do
  2665. {
  2666.     pVideoPacket = (CMediaPacket*) m_pBltPacketQueue->Get();
  2667.     lFramesInBuffer--;
  2670.     if ((lFramesInBuffer <= 0) ||
  2671. (!m_pVideoFormat->IsFrameSkippable(pVideoPacket)))
  2672.     {
  2673. bNewFrameBlt = TRUE;
  2674. break;
  2675.     }
  2677. #if defined(HELIX_FEATURE_STATS)
  2678.     m_pVideoStats->ReportDroppedFrame();
  2679. #endif /* HELIX_FEATURE_STATS */
  2681.     ReleasePacket(pVideoPacket);
  2682. } while (TRUE);
  2683.     }
  2685.     pVideoSurface = (IHXVideoSurface*) (pEvent->param1);
  2687.     if (pVideoPacket)
  2688.     {
  2689. if (m_bVS2BufferUnavailableOnLastBlt &&
  2690.     m_pActiveVideoPacket)
  2691. {
  2692.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  2693. #if defined(HELIX_FEATURE_STATS)
  2694.     m_pVideoStats->ReportDroppedFrame();
  2695. #endif /* HELIX_FEATURE_STATS */
  2696. }
  2698. pTmpPacket = pVideoPacket;
  2699. pVideoPacket = m_pActiveVideoPacket;
  2700. m_pActiveVideoPacket = pTmpPacket;
  2701. m_ulActiveVideoTime = pTmpPacket->m_ulTime;
  2703. bBitmapFormatChanged = (m_pActiveVideoPacket->m_pSampleDesc &&
  2704. m_pVideoFormat->IsBitmapFormatChanged(
  2705. m_BitmapInfoHeader,
  2706. m_pActiveVideoPacket));
  2707.     }
  2709.     if (((!m_bVideoSurfaceInitialized) && m_pActiveVideoPacket) ||
  2710. m_bVideoSurfaceReinitRequested ||
  2711. bBitmapFormatChanged)
  2712.     {
  2713. BOOL bUsedVideoSurface2 = m_bUseVideoSurface2;
  2715. if (bBitmapFormatChanged)
  2716. {
  2717.     m_pVideoFormat->InitBitmapInfoHeader(m_BitmapInfoHeader,
  2718.  m_pActiveVideoPacket);
  2719.     m_bBitmapSet = TRUE;
  2720.     m_bVideoSurfaceInitialized = FALSE; // Force full reinit
  2721. }
  2723. FormatAndSetViewFrame(m_pClipRect,
  2724.       m_BitmapInfoHeader,
  2725.       m_rViewRect,
  2726.       FALSE);
  2728. HX_ASSERT(m_bBitmapSet);
  2730. // If we do not have information on the bitmap configuration or if
  2731. // we do not have surface to cofigure - do not intialize
  2732. if (m_bBitmapSet && pVideoSurface)
  2733. {
  2734.     // Try VideoSurface2 first unless not desired
  2735.     if (m_bTryVideoSurface2 && (!m_bVideoSurface1Requested))
  2736.     {
  2737. InitVideoSurface2(m_SetWinSize.cx, m_SetWinSize.cy);
  2738.     }
  2740.     // Try VideoSurface1 if prefered or if VideoSurface2 would
  2741.     // not initialize
  2742.     if ((!m_bUseVideoSurface2) || m_bVideoSurface1Requested)
  2743.     {
  2744. // Video Surface1 must be used
  2745. InitVideoSurface1(bUsedVideoSurface2, pVideoSurface);
  2746.     }
  2748.     m_bVideoSurfaceInitialized = TRUE;
  2749.     m_bVideoSurfaceReinitRequested = FALSE;
  2751.     m_bSchedulerStartRequested = TRUE;
  2754.     // Force the cycle in the decoder pump to expedite the completion
  2755.     // of the scheduler start request.
  2756.     if (IsDecoderRunning())
  2757.     {
  2758. if (m_pDecoderPump)
  2759. {
  2760.     m_pDecoderPump->Signal();
  2761. }
  2762.     }
  2764. #if defined(HELIX_FEATURE_STATS)
  2765.     ReportStat(VS_IMAGE_WIDTH, (INT32) (m_rViewRect.right - m_rViewRect.left));
  2766.     ReportStat(VS_IMAGE_HEIGHT, (INT32) (m_rViewRect.bottom - m_rViewRect.top));
  2767. #endif /* #if defined(HELIX_FEATURE_STATS) */
  2768. }
  2770.         // Now that we have the video dimensions, check to see that this clip
  2771.         // is not going to be too taxing on the poor CPU.
  2772.         UINT32 ulMaxVidWidth = 0;
  2773.         UINT32 ulMaxVidHeight = 0;
  2774.         if( m_pPreferences && 
  2775.             ( HXR_OK == ReadPrefINT32( m_pPreferences, "MaxVideoWidth", ulMaxVidWidth ) ) &&
  2776.             ( HXR_OK == ReadPrefINT32( m_pPreferences, "MaxVideoHeight", ulMaxVidHeight ) ) )
  2777.         {
  2778.             ULONG32 ulMaxVidArea = ulMaxVidWidth * ulMaxVidHeight;
  2779.             INT32 nWidth = (INT32) (m_rViewRect.right - m_rViewRect.left);
  2780.             INT32 nHeight = (INT32) (m_rViewRect.bottom - m_rViewRect.top);
  2781.             if( (ULONG32)(nWidth*nHeight) > ulMaxVidArea )
  2782.             {
  2783.                 IHXErrorMessages * pErrMsg = NULL;
  2784.                 m_pContext->QueryInterface(IID_IHXErrorMessages, (void**)&pErrMsg);
  2785.                 if( pErrMsg )
  2786.                 {
  2787.                     pErrMsg->Report(HXLOG_ERR, HXR_SLOW_MACHINE, 0, NULL, NULL);
  2788.                     HX_RELEASE(pErrMsg);
  2789.                 }
  2790.             }
  2791.         }
  2792.     }
  2793.     
  2794.     if (m_pActiveVideoPacket && bIsVisible && pVideoSurface)
  2795.     {
  2796. HX_ASSERT(m_bVideoSurfaceInitialized);
  2798. if (m_bVideoSurfaceInitialized && m_pActiveVideoPacket->m_pData)
  2799. {
  2800. #ifdef DEFAULT_VS2_TARGETRECT
  2801.     if (!m_bUseVideoSurface2)
  2802. #endif // DEFAULT_VS2_TARGETRECT
  2803.     {
  2804. m_pMISUSSite->GetSize(windowSize);
  2805.     }
  2807.     HXxRect rDestRect = { 0, 0, windowSize.cx, windowSize.cy };
  2808.     HXxRect rSrcRect = m_rViewRect;
  2810.     AdjustVideoMapping(rDestRect, rSrcRect, m_pActiveVideoPacket);
  2812.     if (m_bUseVideoSurface2)
  2813.     {
  2814. pEvent->result = UpdateVideoSurface2(pVideoSurface,
  2815.      rDestRect,
  2816.      rSrcRect,
  2817.      !bNewFrameBlt,
  2818.      bSystemEvent);
  2820. if (pEvent->result == HXR_ABORT)
  2821. {
  2822.     pEvent->result = HXR_OK;
  2823.     retVal = HXR_ABORT;
  2824. }
  2825.     }
  2826.     else if (bSystemEvent)
  2827.     {
  2828. pEvent->result = UpdateVideoSurface(pVideoSurface,
  2829.     m_pActiveVideoPacket,
  2830.     rDestRect,
  2831.     rSrcRect,
  2832.     m_bOptimizedBlt);
  2834. if (FAILED(pEvent->result))
  2835. {
  2836.     if (m_bVideoSurfaceReinitRequested)
  2837.     {
  2838. HX_ASSERT(!m_bVideoSurface1Requested);
  2840. InitVideoSurface2(m_SetWinSize.cx, m_SetWinSize.cy);
  2842. if (m_bUseVideoSurface2)
  2843. {
  2844.     m_bVideoSurfaceInitialized = TRUE;
  2845.     m_bVideoSurfaceReinitRequested = FALSE;
  2847.     pEvent->result = UpdateVideoSurface2(pVideoSurface,
  2848.  rDestRect,
  2849.  rSrcRect,
  2850.  FALSE,
  2851.  bSystemEvent);
  2853.     if (pEvent->result == HXR_ABORT)
  2854.     {
  2855. pEvent->result = HXR_OK;
  2856.     }
  2857. }
  2858.     }
  2859.     else
  2860.     {
  2861. InitVideoSurface1(FALSE, pVideoSurface);
  2863. pEvent->result = UpdateVideoSurface(pVideoSurface,
  2864.     m_pActiveVideoPacket,
  2865.     rDestRect,
  2866.     rSrcRect,
  2867.     m_bOptimizedBlt);
  2868.     }
  2869. }
  2870.     }
  2871.     else
  2872.     {
  2873. // This is not a system event and this call is not under
  2874. // the protection of the top level site (TLS) mutex and
  2875. // it needs to be.
  2876. // Bring it under the TLS mutex protection by envoking
  2877. // forced refresh
  2878. bIsVisible = ForceRefresh();
  2880. pEvent->result = HXR_OK;
  2881. retVal = HXR_ABORT;
  2882.     }
  2884.     if (bNewFrameBlt && bIsVisible)
  2885.     {
  2886. #if defined(HELIX_FEATURE_STATS)
  2887. if (pEvent->result == HXR_OK)
  2888. {
  2889.     m_pVideoStats->ReportBlt(m_pActiveVideoPacket->m_ulTime);
  2890. }
  2891. else if (!m_bVS2BufferUnavailableOnLastBlt)
  2892. {
  2893.     // If buffer wasn't available, we'll try again
  2894.     m_pVideoStats->ReportDroppedFrame();
  2895. }
  2896. #endif /* HELIX_FEATURE_STATS */
  2897.     }
  2898. }
  2899.     }
  2901.     if (pVideoPacket)
  2902.     {
  2903. ReleasePacket(pVideoPacket, m_bActiveVideoPacketLocalized);
  2904. m_bActiveVideoPacketLocalized = FALSE;
  2905.     }
  2907.     pEvent->handled = TRUE;
  2909.     return retVal;
  2910. }
  2912. HX_RESULT CVideoRenderer::UpdateVideoSurface(IHXVideoSurface* pVideoSurface,
  2913.      CMediaPacket* pVideoPacket,
  2914.      HXxRect &destRect,
  2915.      HXxRect &sorcRect,
  2916.      BOOL bOptimizedBlt)
  2917. {
  2918.     HX_RESULT retVal;
  2920.     if (bOptimizedBlt)
  2921.     {
  2922. retVal = pVideoSurface->OptimizedBlt(
  2923.     pVideoPacket->m_pData,
  2924.     destRect,
  2925.     sorcRect);
  2926.     }
  2927.     else
  2928.     {
  2929. retVal = pVideoSurface->Blt(
  2930.     pVideoPacket->m_pData,
  2931.     &m_BitmapInfoHeader,
  2932.     destRect,
  2933.     sorcRect);
  2934.     }
  2936.     return retVal;
  2937. }
  2940. HX_RESULT CVideoRenderer::InitVideoSurface1(BOOL bUsedVideoSurface2,
  2941.     IHXVideoSurface* pVideoSurface)
  2942. {
  2943.     HX_RESULT retVal = HXR_OK;
  2945.     if (bUsedVideoSurface2)
  2946.     {
  2947. OffOptimizedVideo();
  2948.     }
  2950.     /***
  2951.     if (pVideoSurface)
  2952.     {
  2953. retVal = pVideoSurface->EndOptimizedBlt();
  2954.     }
  2955.     else
  2956.     {
  2957. EndOptimizedBlt();
  2958.     }
  2959.     ***/
  2961.     // Video Surface1 is needed - try optimized Blt setup
  2962.     if (!m_bVideoSurfaceInitialized)
  2963.     {
  2964. if (pVideoSurface)
  2965. {
  2966.     retVal = pVideoSurface->BeginOptimizedBlt(&m_BitmapInfoHeader);
  2967. }
  2968. else
  2969. {
  2970.     retVal = BeginOptimizedBlt(&m_BitmapInfoHeader);
  2971. }
  2973. if (SUCCEEDED(retVal))
  2974. {
  2975.     m_bOptimizedBlt = TRUE;
  2976. }
  2977. else
  2978. {
  2979.     m_bOptimizedBlt = FALSE;
  2980. }
  2982. retVal = HXR_OK;
  2983.     }
  2985.     if (SUCCEEDED(retVal))
  2986.     {
  2987. m_ulEarlyFrameTol = GetEarlyFrameTolerance();
  2988. HX_DELETE(m_pVSurf2InputBIH);
  2989. m_bUseVideoSurface2 = FALSE;
  2990. if (m_bVS2BufferUnavailableOnLastBlt)
  2991. {
  2992. #if defined(HELIX_FEATURE_STATS)
  2993.     m_pVideoStats->ReportDroppedFrame();
  2994. #endif /* HELIX_FEATURE_STATS */
  2995.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  2996. }
  2997.     }
  2999.     return retVal;
  3000. }
  3003. inline BOOL CVideoRenderer::ShouldKickStartScheduler()
  3004. {
  3005.     BOOL bShouldStart;
  3007.     bShouldStart = (!m_bPendingCallback && !m_bUseVideoSurface2);
  3009.     return bShouldStart;
  3010. }
  3013. HX_RESULT CVideoRenderer::ScheduleCallback(UINT32 ulRelativeTime,
  3014.    BOOL bIsScheduled,
  3015.    UINT32 ulBaseTime)
  3016. {
  3017.     IHXCallback* pCallback = (IHXCallback*) this;
  3018.     CallbackHandle hPendingHandle;
  3019.     ULONG32 ulThisCallbackCount;
  3021.     if (m_hPendingHandle == (CallbackHandle)NULL)
  3022.     {
  3023. m_bPendingCallback = TRUE;
  3024. m_ulCallbackCounter++;
  3025. if (m_ulCallbackCounter == 0)
  3026. {
  3027.     m_ulCallbackCounter++;
  3028. }
  3029. ulThisCallbackCount = m_ulCallbackCounter;
  3030. m_hPendingHandle = ulThisCallbackCount;
  3031. m_bIsScheduledCB = bIsScheduled;
  3033. if (ulRelativeTime > m_ulMaxSleepTime)
  3034. {
  3035.     ulRelativeTime = m_ulMaxSleepTime;
  3036.     m_bIsScheduledCB = FALSE;
  3037. }
  3039. HX_TRACE_THINGY("C:/trace.txt", "SchedCBTime", ulRelativeTime);
  3041. #ifdef DO_ABSOLUTE_TIMING
  3042. LONG32 lTimeOffset;
  3043. HXTimeval hxTime;
  3044. ULONG32 ulNTries = N_STABILIZATION_ITERATIONS;
  3045. ULONG32 ulCurrentTime1;
  3046. ULONG32 ulCurrentTime2;
  3048. if (bIsScheduled)
  3049. {
  3050.     // Obtain atomic time reading (avoid context switch)
  3051.     do
  3052.     {
  3053. ulCurrentTime1 = HX_GET_BETTERTICKCOUNT();
  3055. // Always use the optimized scheduler if we have one
  3056. if (m_pOptimizedScheduler != NULL)
  3057. {
  3058.     hxTime = m_pOptimizedScheduler->GetCurrentSchedulerTime();
  3059. }
  3060. else
  3061. {
  3062.     hxTime = m_pScheduler->GetCurrentSchedulerTime();
  3063. }
  3065. ulCurrentTime2 = HX_GET_BETTERTICKCOUNT();
  3067. lTimeOffset = (LONG32) (ulCurrentTime2 - ulBaseTime + ulRelativeTime);
  3069. ulNTries--;
  3070.     } while (((ulCurrentTime2 - ulCurrentTime1) > MAX_ALLOWED_TIMING_ERROR) &&
  3071. (ulNTries != 0) &&
  3072. (lTimeOffset > 0));
  3074.     if (lTimeOffset >= SMALLEST_TIMABLE_PERIOD)
  3075.     {
  3076. hxTime.tv_usec += (lTimeOffset * MILLISECOND);
  3077. if (hxTime.tv_usec >= SECOND)
  3078. {
  3079.     hxTime.tv_sec += (hxTime.tv_usec / SECOND);
  3080.     hxTime.tv_usec %= SECOND;
  3081. }
  3082.     }
  3084.     hPendingHandle = ScheduleAbsoluteCallback(hxTime, pCallback);
  3085. }
  3086. else
  3087. #endif  // DO_ABSOLUTE_TIMING
  3088. {
  3090.     hPendingHandle = ScheduleRelativeCallback(ulRelativeTime, pCallback);
  3092. }
  3094. HX_ASSERT(hPendingHandle);
  3096. // Remember the handle if callback did not already fire synchronously
  3097. if (m_hPendingHandle == ulThisCallbackCount)
  3098. {
  3099.     HX_TRACE_THINGY("C:/trace.txt", "SchedCBHandle", hPendingHandle);
  3101.     m_hPendingHandle = hPendingHandle;
  3102.     m_bPendingCallback = (m_hPendingHandle != ((CallbackHandle) NULL));
  3103. }
  3104.     }
  3106.     return HXR_OK;
  3107. }
  3110. inline CallbackHandle CVideoRenderer::ScheduleRelativeCallback
  3111. (
  3112.     UINT32 ulRelativeTime,
  3113.     IHXCallback* pCallback
  3114. )
  3115. {
  3116.     CallbackHandle hCallback;
  3118.     // Always use the optimized scheduler if we have one
  3119.     if (m_pOptimizedScheduler != NULL)
  3120.     {
  3121. hCallback = m_pOptimizedScheduler->RelativeEnter(
  3122.     pCallback, ulRelativeTime);
  3123.     }
  3124.     else
  3125.     {
  3126. hCallback = m_pScheduler->RelativeEnter(
  3127.     pCallback, ulRelativeTime);
  3128.     }
  3130.     return hCallback;
  3131. }
  3134. inline CallbackHandle CVideoRenderer::ScheduleAbsoluteCallback
  3135. (
  3136.     HXTimeval &hxTime,
  3137.     IHXCallback* pCallback
  3138. )
  3139. {
  3140.     CallbackHandle hCallback;
  3142.     // Always use the optimized scheduler if we have one
  3143.     if (m_pOptimizedScheduler != NULL)
  3144.     {
  3145. hCallback = m_pOptimizedScheduler->AbsoluteEnter(
  3146.     pCallback, hxTime);
  3147.     }
  3148.     else
  3149.     {
  3150. hCallback = m_pScheduler->AbsoluteEnter(
  3151.     pCallback, hxTime);
  3152.     }
  3154.     return hCallback;
  3155. }
  3158. void CVideoRenderer::RemoveCallback(CallbackHandle &hCallback)
  3159. {
  3160.     if (hCallback != (CallbackHandle)NULL)
  3161.     {
  3162. if (m_pOptimizedScheduler != NULL)
  3163. {
  3164.     m_pOptimizedScheduler->Remove(hCallback);
  3165. }
  3166. else if (m_pScheduler)
  3167. {
  3168.     m_pScheduler->Remove(hCallback);
  3169. }
  3171. hCallback = NULL;
  3172.     }
  3173. }
  3176. /*
  3177.  *   Draw any frame that's due, and schedule a new callback for the next
  3178.  *   frame
  3179.  */
  3180. void CVideoRenderer::SchedulerCallback(BOOL bIsScheduled,
  3181.        BOOL bResched,
  3182.        BOOL bIsVS2Call,
  3183.        BOOL bProcessUndisplayableFramesOnly)
  3184. {
  3185.     CMediaPacket* pPkt;
  3186.     LONG32 lTimeDelta;
  3187.     ULONG32 ulNextFrameTime;
  3188.     BOOL bFrameIsSkippable;
  3189.     ULONG32 ulBaseTime;
  3190.     BOOL bHaveNextFrame;
  3191.     BOOL bDisplayFrame;
  3192.     ULONG32 ulLoopCounter = 0;
  3194.     DisplayMutex_Lock();
  3196.     while ((m_PlayState == Playing) ||
  3197.    ((m_PlayState == PlayStarting) && m_bFirstFrame))
  3198.     {
  3199. if (m_bUseVideoSurface2)
  3200. {
  3201.     if (bIsVS2Call)
  3202.     {
  3203. m_bVideoSurface2Transition = FALSE;
  3204.     }
  3205.     else
  3206.     {
  3207. m_bPendingCallback = FALSE;
  3208. DisplayMutex_Unlock();
  3209. return;
  3210.     }
  3211. }
  3212. else
  3213. {
  3214.     if (bIsVS2Call)
  3215.     {
  3216. DisplayMutex_Unlock();
  3217. return;
  3218.     }
  3220.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  3221. }
  3223. #ifdef ENABLE_FETCH_TRACE
  3224. ULONG32 ulFetchTraceStart = HX_GET_BETTERTICKCOUNT();
  3225. #endif // ENABLE_FETCH_TRACE
  3227. bDisplayFrame = TRUE;
  3229. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  3230. if( !m_bUntimedRendering )
  3231. {
  3232. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  3233. while ((bHaveNextFrame = m_pVideoFormat->GetNextFrameTime(ulNextFrameTime)) != 0)
  3234. {
  3236. #ifdef ENABLE_FETCH_TRACE
  3237.     if (ulFetchTraceIdx < MAX_FETCH_TRACE_ENTRIES)
  3238.     {
  3239. fetchTraceArray[ulFetchTraceIdx++] =
  3240.     HX_GET_BETTERTICKCOUNT() - ulFetchTraceStart;
  3241.     }
  3242. #endif // ENABLE_FETCH_TRACE
  3244.     lTimeDelta = ComputeTimeAhead(ulNextFrameTime,
  3245.   0,
  3246.   &ulBaseTime);
  3248.     if (((lTimeDelta + ((LONG32) m_ulLateFrameTol)) >= 0) ||
  3249. bIsScheduled ||
  3250. m_bVS2BufferUnavailableOnLastBlt)
  3251.     {
  3252. break;
  3253.     }
  3254.     else
  3255.     {
  3256. #ifdef ENABLE_SCHED_TRACE
  3257. if (ulSchedTraceIdx < MAX_SCHED_TRACE_ENTRIES)
  3258. {
  3259.     schedTraceArray[ulSchedTraceIdx++] = lTimeDelta;
  3260. }
  3261. #endif // ENABLE_SCHED_TRACE
  3263. bFrameIsSkippable = TRUE;
  3265. m_pVideoFormat->IsNextFrameSkippable(bFrameIsSkippable);
  3267. if (!bFrameIsSkippable)
  3268. {
  3269.     if (m_bFirstFrame)
  3270.     {
  3271. bDisplayFrame = FALSE;
  3272.     }
  3273.     break;
  3274. }
  3275.     }
  3277. #ifdef ENABLE_FETCH_TRACE
  3278.     ulFetchTraceStart = HX_GET_BETTERTICKCOUNT();
  3279. #endif // ENABLE_FETCH_TRACE
  3281.     pPkt = m_pVideoFormat->Dequeue();
  3283. #ifdef ENABLE_FETCH_TRACE
  3284.     if (ulFetchTraceIdx < MAX_FETCH_TRACE_ENTRIES)
  3285.     {
  3286. fetchTraceArray[ulFetchTraceIdx++] =
  3287.     HX_GET_BETTERTICKCOUNT() - ulFetchTraceStart;
  3288.     }
  3289. #endif // ENABLE_FETCH_TRACE
  3291.     if (!m_bFirstFrame)
  3292.     {
  3293. #if defined(HELIX_FEATURE_STATS)
  3294. m_pVideoStats->ReportDroppedFrame();
  3295. #endif /* HELIX_FEATURE_STATS */
  3296.     }
  3298.     ReleasePacket(pPkt);
  3299. }
  3300. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  3301. } else {
  3302.          bHaveNextFrame = m_pVideoFormat->GetNextFrameTime(ulNextFrameTime);
  3303.     lTimeDelta = 0;
  3305.     ComputeTimeAhead( 0, 0, &ulBaseTime );
  3307. }
  3308. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  3310. if (bProcessUndisplayableFramesOnly && bDisplayFrame)
  3311. {
  3312.     DisplayMutex_Unlock();
  3313.     return;
  3314. }
  3316. if (!m_bVS2BufferUnavailableOnLastBlt)
  3317. {
  3318.     if (bHaveNextFrame)
  3319.     {
  3320. if ((lTimeDelta > ((LONG32) m_ulEarlyFrameTol)) &&
  3321.     (!m_bFirstFrame))
  3322. {
  3323.     if (bResched)
  3324.     {
  3325. ScheduleCallback(lTimeDelta, TRUE, ulBaseTime);
  3326.     }
  3328.     DisplayMutex_Unlock();
  3330.     return;
  3331. }
  3332.     }
  3333.     else
  3334.     {
  3335. if (bResched)
  3336. {
  3337.     // m_pVideoFormat->DecodeFrame();  MBO: Give user Input priority
  3338.     ScheduleCallback(m_ulNoFramesPollingInterval);
  3339. }
  3341. DisplayMutex_Unlock();
  3343. return;
  3344.     }
  3346.     // Render
  3347.     pPkt = m_pVideoFormat->Dequeue();
  3348. }
  3349. else
  3350. {
  3351.     // We need to reblt - but if there is a frame that's up to date
  3352.     // use it instead of old failed frame.
  3353.     pPkt = NULL;
  3354.     if (bHaveNextFrame && (lTimeDelta <= 0))
  3355.     {
  3356. pPkt = m_pVideoFormat->Dequeue();
  3357.     }
  3358. }
  3360. if (pPkt != NULL)
  3361. {
  3362. #ifdef ENABLE_SCHED_TRACE
  3363.     if (ulSchedTraceIdx < MAX_SCHED_TRACE_ENTRIES)
  3364.     {
  3365. schedTraceArray[ulSchedTraceIdx++] = lTimeDelta;
  3366.     }
  3367. #endif // ENABLE_SCHED_TRACE
  3369.     if (m_pMISUSSite &&
  3370. m_pBltPacketQueue->Put(pPkt))
  3371.     {
  3372. if (pPkt->m_pData && bDisplayFrame)
  3373. {
  3374.     m_bFirstFrame = FALSE;
  3375. }
  3377. if (m_bUseVideoSurface2)
  3378. {
  3379.     ForceDisplayUpdate(FALSE, bDisplayFrame);
  3381.     if (m_bVS2BufferUnavailableOnLastBlt)
  3382.     {
  3383. // We couldn't blt frame because video buffer
  3384. // wasn't available, try again a bit later
  3385. DisplayMutex_Unlock();
  3386. return;
  3387.     }
  3388. }
  3389. else
  3390. {
  3391.     if ((!bDisplayFrame) || (!ForceRefresh()))
  3392.     {
  3393. // Site redraw did not occur - treat this as if the surface
  3394. // is invisible
  3395. ForceDisplayUpdate(FALSE, FALSE);
  3396. HX_ASSERT(!m_bPendingRedraw);
  3397.     }
  3398. }
  3399.     }
  3400.     else
  3401.     {
  3402. #if defined(HELIX_FEATURE_STATS)
  3403. m_pVideoStats->ReportDroppedFrame();
  3404. #endif /* HELIX_FEATURE_STATS */
  3405. ReleasePacket(pPkt);
  3406.     }
  3407. }
  3408. else
  3409. {
  3410.     // This is a reblt servicing
  3411.     if (m_bUseVideoSurface2)
  3412.     {
  3413. HX_ASSERT(bDisplayFrame);
  3415. ForceDisplayUpdate(FALSE, bDisplayFrame);
  3417. if (m_bVS2BufferUnavailableOnLastBlt)
  3418. {
  3419.     // We couldn't blt frame because video buffer
  3420.     // wasn't available, try again a bit later
  3421.     DisplayMutex_Unlock();
  3422.     return;
  3423. }
  3424.     }
  3425. }
  3427. if (bResched)
  3428. {
  3429.     ulLoopCounter++;
  3431.     if (ulLoopCounter > MAX_BLT_LOOPS)
  3432.     {
  3433. ScheduleCallback(BLT_RELIEF_DELAY);
  3435. DisplayMutex_Unlock();
  3437. return;
  3438.     }
  3439. }
  3440. else
  3441. {
  3442.     if (!bIsVS2Call)
  3443.     {
  3444. DisplayMutex_Unlock();
  3446. return;
  3447.     }
  3448. }
  3450. bIsScheduled = FALSE;
  3451.     }
  3453.     if ((m_PlayState != Stopped) &&
  3454. bResched)
  3455.     {
  3456. ScheduleCallback(NO_FRAMES_POLLING_INTERVAL);
  3458. DisplayMutex_Unlock();
  3460. return;
  3461.     }
  3463.     m_bPendingCallback = FALSE;
  3465.     DisplayMutex_Unlock();
  3466. }
  3468. void CVideoRenderer::ForceDisplayUpdate(BOOL bInternalSurfaceUpdateOnly,
  3469. BOOL bHasVisibleSurface)
  3470. {
  3471.     // Create fake events for HandleSurfaceUpdate:
  3472.     HX_ASSERT(m_pMISUSSite);
  3474. #if defined (HELIX_FEATURE_MISU)
  3475.     IHXSiteEnumerator* pSiteEnumerator;
  3476.     if (SUCCEEDED(m_pMISUSSite->QueryInterface(IID_IHXSiteEnumerator,
  3477.        (void**) &pSiteEnumerator)))
  3478.     {
  3479. IHXSite* pSite;
  3480. IHXSiteEnumerator::SitePosition nextPosition;
  3482. if (FAILED(pSiteEnumerator->GetFirstSite(pSite, nextPosition)))
  3483. {
  3484.     HX_ASSERT(FALSE);
  3485. }
  3486. else
  3487. {
  3488.     BOOL bKeepUpdating = TRUE;
  3490.     do
  3491.     {
  3492. bKeepUpdating = (ForceDisplayUpdateOnSite(pSite, 
  3493.   bInternalSurfaceUpdateOnly, 
  3494.   bHasVisibleSurface) != HXR_ABORT);
  3495. pSite->Release();
  3496.     }
  3497.     while (bKeepUpdating &&
  3498.    SUCCEEDED(pSiteEnumerator->GetNextSite(pSite, nextPosition)));
  3499. }
  3501. pSiteEnumerator->Release();
  3502.     }
  3503.     else
  3504.     {
  3505. ForceDisplayUpdateOnSite(m_pMISUSSite,
  3506.  bInternalSurfaceUpdateOnly,
  3507.  bHasVisibleSurface);
  3508.     }
  3509. #else //HELIX_FEATURE_MISU
  3511.     ForceDisplayUpdateOnSite(m_pMISUSSite,
  3512.      bInternalSurfaceUpdateOnly,
  3513.      bHasVisibleSurface);
  3515. #endif //HELIX_FEATURE_MISU
  3517. }
  3519. HX_RESULT CVideoRenderer::ForceDisplayUpdateOnSite(IHXSite* pSite, 
  3520.    BOOL bInternalSurfaceUpdateOnly,
  3521.    BOOL bHasVisibleSurface)
  3522. {
  3523.     HX_RESULT retVal = HXR_OK;
  3525.     IHXVideoSurface2* pVideoSurface2;
  3526.     IHXSite2* pSite2 = NULL;
  3527.     IHXVideoSurface* pVideoSurface = NULL;
  3528.     
  3529.     if (SUCCEEDED(pSite->QueryInterface(IID_IHXSite2, (void**) &pSite2)))
  3530.     {
  3531. pSite2->GetVideoSurface(pVideoSurface);
  3532.     }
  3534.     if (bInternalSurfaceUpdateOnly)
  3535.     {
  3536. if (pVideoSurface)
  3537. {
  3538.     if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2, 
  3539. (void**) &pVideoSurface2)))
  3540.     {
  3541. pVideoSurface2->PresentIfReady();
  3542. pVideoSurface2->Release();
  3543.     }
  3544. }
  3545.     }
  3546.     else
  3547.     {
  3548. HXxEvent fakeEvent;
  3550. fakeEvent.param1 = (void*) pVideoSurface;
  3551. retVal = UpdateDisplay(&fakeEvent, FALSE, bHasVisibleSurface);
  3552.     }
  3553.     
  3554.     HX_RELEASE(pVideoSurface);
  3555.     HX_RELEASE(pSite2);
  3557.     return retVal;
  3558. }
  3561. STDMETHODIMP CVideoRenderer::Func(void)
  3562. {
  3563.     HX_TRACE_THINGY("C:/trace.txt", "Func", 0);
  3565.     m_hPendingHandle = NULL;
  3567.     SchedulerCallback(m_bIsScheduledCB);
  3569.     return HXR_OK;
  3570. }
  3573. HX_RESULT CVideoRenderer::BeginOptimizedBlt(HXBitmapInfoHeader* pBitmapInfo)
  3574. {
  3575.     HX_RESULT retVal = HXR_UNEXPECTED;
  3576.     IHXSite2* pMISUSSite2   = NULL;
  3577.     IHXVideoSurface* pVideoSurface = NULL;
  3579.     if (m_pMISUSSite)
  3580.     {
  3581.         m_pMISUSSite->QueryInterface(IID_IHXSite2, (void**)&pMISUSSite2);
  3582.         if (pBitmapInfo && pMISUSSite2)
  3583.         {
  3584.             if (SUCCEEDED(pMISUSSite2->GetVideoSurface(pVideoSurface)))
  3585.             {
  3586.                 retVal = pVideoSurface->BeginOptimizedBlt(pBitmapInfo);
  3587.                 if (retVal == HXR_OK)
  3588.                 {
  3589.                     m_bOptimizedBlt = TRUE;
  3590.                 }
  3591.                 HX_RELEASE(pVideoSurface);
  3592.             }
  3593.         }
  3594. HX_RELEASE(pMISUSSite2);
  3595.     }
  3597.     return retVal;
  3598. }
  3601. void CVideoRenderer::EndOptimizedBlt(void)
  3602. {
  3603.     IHXSite2* pMISUSSite2 = NULL;
  3604.     IHXVideoSurface* pVideoSurface = NULL;
  3606.     if (m_bOptimizedBlt && m_pMISUSSite)
  3607.     {
  3608. m_pMISUSSite->QueryInterface(IID_IHXSite2, (void**)&pMISUSSite2);
  3610. if (pMISUSSite2)
  3611. {
  3612.     pMISUSSite2->GetVideoSurface(pVideoSurface);
  3613.     if (pVideoSurface)
  3614.     {
  3615. pVideoSurface->EndOptimizedBlt();
  3616. m_bOptimizedBlt = FALSE;
  3617. HX_RELEASE(pVideoSurface);
  3618.     }
  3619. }
  3620.     }
  3622.     HX_RELEASE(pMISUSSite2);
  3623. }
  3626. inline void CVideoRenderer::RequestBuffering(void)
  3627. {
  3628.     m_bBufferingNeeded = TRUE;
  3629. }
  3632. inline void CVideoRenderer::RequestBufferingEnd(void)
  3633. {
  3634.     m_bBufferingNeeded = FALSE;
  3635. }
  3638. HX_RESULT CVideoRenderer::BeginBuffering(void)
  3639. {
  3640.     HX_RESULT retVal = HXR_FAIL;
  3641. #ifdef REBUFFER_ON_VIDEO
  3643.     m_ulBufferingStartTime = HX_GET_BETTERTICKCOUNT();
  3645.     // If this is a reccuring rebuffer, start buffering only if
  3646.     // the preroll period passed since the last buffering completion.
  3647.     // This is done to prevent buffering all the time.
  3648.     if (!m_bBufferingOccured ||
  3649. ((m_ulBufferingStartTime - m_ulBufferingStopTime) > m_ulPreroll))
  3650.     {
  3651. // Bytes to Buffer could be used for Predata
  3652. // - Predata was not found beneficial yet
  3653. m_ulBytesToBuffer = (ULONG32) (((double) m_ulPreroll) *
  3654.        ((double) m_ulAvgBitRate) /
  3655.        8000.0);
  3657. m_ulBufferingTimeOut = m_ulPreroll * 2;
  3659. if (m_ulBufferingTimeOut > 0)
  3660. {
  3661.     m_PlayState = Buffering;
  3663.     retVal = m_pStream->ReportRebufferStatus(1, 0);
  3664. }
  3665.     }
  3666. #endif // REBUFFER_ON_VIDEO
  3668.     return retVal;
  3669. }
  3672. HX_RESULT CVideoRenderer::EndBuffering(void)
  3673. {
  3674.     HX_RESULT retVal = HXR_UNEXPECTED;
  3676. #ifdef REBUFFER_ON_VIDEO
  3678.     if (m_PlayState == Buffering)
  3679.     {
  3680. m_PlayState = PlayStarting;
  3681. m_bBufferingOccured = TRUE;
  3682. m_ulBufferingStopTime = HX_GET_BETTERTICKCOUNT();
  3684. HX_ASSERT(m_pStream);
  3685. retVal = m_pStream->ReportRebufferStatus(1,1);
  3686.     }
  3687. #endif // REBUFFER_ON_VIDEO
  3689.     return retVal;
  3690. }
  3693. inline BOOL CVideoRenderer::IsBufferingComplete(IHXPacket *pPacket)
  3694. {
  3695. #ifdef REBUFFER_ON_VIDEO
  3696.     ULONG32 ulTimeNow = HX_GET_BETTERTICKCOUNT();
  3698.     if ((m_PlayState == Buffering) && (m_bBufferingNeeded))
  3699.     {
  3700. if (pPacket &&
  3701.     ((pPacket->GetTime() - m_ulBaseTime) > m_ulPreroll))
  3702. {
  3703.     return TRUE;
  3704. }
  3706. return ((ulTimeNow - m_ulBufferingStartTime) > m_ulBufferingTimeOut);
  3707.     }
  3708. #endif // REBUFFER_ON_VIDEO
  3710.     return TRUE;
  3711. }
  3714. HX_RESULT CVideoRenderer::LocalizeActiveVideoPacket(void)
  3715. {
  3716.     HX_RESULT retVal = HXR_IGNORE;
  3718.     DisplayMutex_Lock();
  3720.     if (m_pActiveVideoPacket && (!m_bActiveVideoPacketLocalized))
  3721.     {
  3722. CMediaPacket* pLocalPacket = NULL;
  3723. ULONG32 ulDataSize = m_pActiveVideoPacket->m_ulDataSize;
  3724. UINT8* pData = new UINT8 [ulDataSize];
  3726. retVal = HXR_OUTOFMEMORY;
  3727. if (pData)
  3728. {
  3729.     retVal = HXR_OK;
  3730. }
  3732. if (retVal == HXR_OK)
  3733. {
  3734.     pLocalPacket = new CMediaPacket(pData,
  3735.     pData,
  3736.     ulDataSize,
  3737.     ulDataSize,
  3738.     m_pActiveVideoPacket->m_ulTime,
  3739.     m_pActiveVideoPacket->m_ulFlags,
  3740.     NULL);
  3742.     retVal = HXR_OUTOFMEMORY;
  3743.     if (pLocalPacket)
  3744.     {
  3745. retVal = HXR_OK;
  3746.     }
  3747. }
  3749. if (retVal == HXR_OK)
  3750. {
  3751.     memcpy(pData, m_pActiveVideoPacket->m_pData, ulDataSize); /* Flawfinder: ignore */
  3752.     ReleasePacket(m_pActiveVideoPacket);
  3753.     m_pActiveVideoPacket = pLocalPacket;
  3754.     m_bActiveVideoPacketLocalized = TRUE;
  3755. }
  3756. else
  3757. {
  3758.     HX_VECTOR_DELETE(pData);
  3759.     HX_DELETE(pLocalPacket);
  3760. }
  3761.     }
  3763.     DisplayMutex_Unlock();
  3765.     return retVal;
  3766. }
  3769. void CVideoRenderer::ReleaseFramePacket(CMediaPacket* pPacket)
  3770. {
  3771.     ReleasePacket(pPacket);
  3772. }
  3775. void CVideoRenderer::ReleasePacket(CMediaPacket* pPacket,
  3776.   BOOL bForceKill)
  3777. {
  3778.     CHXBufferPool* pFramePool = NULL;
  3780.     if (m_pVideoFormat)
  3781.     {
  3782. m_pVideoFormat->OnDecodedPacketRelease(pPacket);
  3783. pFramePool = m_pVideoFormat->GetFramePool();
  3784.     }
  3786.     if (pPacket)
  3787.     {
  3788. if (pFramePool && (!bForceKill))
  3789. {
  3790.     pFramePool->Put(pPacket);
  3791. }
  3792. else
  3793. {
  3794.     pPacket->Clear();
  3795.     delete pPacket;
  3796. }
  3797.     }
  3799.     if (IsDecoderRunning())
  3800.     {
  3801. if (m_pDecoderPump)
  3802. {
  3803.     m_pDecoderPump->Signal();
  3804. }
  3805.     }
  3806.     else
  3807.     {
  3808. if (m_pVideoFormat)
  3809. {
  3810.     m_pVideoFormat->DecodeFrame();
  3811. }
  3812.     }
  3813. }
  3816. void CVideoRenderer::ClearBltPacketQueue(void)
  3817. {
  3818.     CMediaPacket* pVideoPacket;
  3820.     if (m_pBltPacketQueue)
  3821.     {
  3822. while ((pVideoPacket = (CMediaPacket*) m_pBltPacketQueue->Get()) != 0)
  3823. {
  3824.     ReleasePacket(pVideoPacket);
  3825. }
  3826.     }
  3827. }
  3830. /****************************************************************************
  3831.  *  CVideoRenderer::CSetSizeCB
  3832.  *  This routine increases the object reference count in a thread safe
  3833.  *  manner. The reference count is used to manage the lifetime of an object.
  3834.  *  This method must be explicitly called by the user whenever a new
  3835.  *  reference to an object is used.
  3836.  */
  3837. /****************************************************************************
  3838.  *  CVideoRenderer::CSetSizeCB::QueryInterface
  3839.  */
  3840. STDMETHODIMP CVideoRenderer::CSetSizeCB::QueryInterface(REFIID riid,
  3841.   void** ppvObj)
  3842. {
  3843.     QInterfaceList  qiList[] =
  3844.     {
  3845. { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPlugin*) this},
  3846. { GET_IIDHANDLE(IID_IHXCallback), (IHXCallback*)this},
  3847.     };
  3849.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  3850. }
  3852. /****************************************************************************
  3853.  *  CVideoRenderer::CSetSizeCB::AddRef                             
  3854.  */
  3855. STDMETHODIMP_(ULONG32) CVideoRenderer::CSetSizeCB::AddRef()
  3856. {
  3857.     return InterlockedIncrement(&m_lRefCount);
  3858. }
  3860. /****************************************************************************
  3861.  *  CVideoRenderer::CSetSizeCB::Release
  3862.  */
  3863. STDMETHODIMP_(ULONG32) CVideoRenderer::CSetSizeCB::Release()
  3864. {
  3865.     if (InterlockedDecrement(&m_lRefCount) > 0)
  3866.     {
  3867.         return m_lRefCount;
  3868.     }
  3870.     delete this;
  3871.     return 0;
  3872. }
  3874. /****************************************************************************
  3875.  *  CVideoRenderer::CSetSizeCB::Func
  3876.  */
  3877. STDMETHODIMP CVideoRenderer::CSetSizeCB::Func()
  3878. {
  3879.     return m_pSite->SetSize(m_szViewFrame);
  3880. }
  3883. /****************************************************************************
  3884.  *  CVideoRenderer::Pacemaker Responses
  3885.  */
  3886. STDMETHODIMP CVideoRenderer::OnPaceStart(ULONG32 ulId)
  3887. {
  3888.     if (ulId == m_ulDecoderPacemakerId)
  3889.     {
  3890. if (m_pVideoFormat)
  3891. {
  3892.     m_pDecoderVideoFormat = m_pVideoFormat;
  3893.     m_pDecoderVideoFormat->AddRef();
  3894. }
  3895. m_bDecoderRunning = TRUE;
  3896.     }
  3897.     else if (ulId == m_ulBltrPacemakerId)
  3898.     {
  3899. if (m_pVideoFormat)
  3900. {
  3901.     m_pBltrVideoFormat = m_pVideoFormat;
  3902.     m_pBltrVideoFormat->AddRef();
  3903. }
  3904.     }
  3906.     return HXR_OK;
  3907. }
  3909. STDMETHODIMP CVideoRenderer::OnPaceEnd(ULONG32 ulId)
  3910. {
  3911.     if (ulId == m_ulDecoderPacemakerId)
  3912.     {
  3913. m_bDecoderRunning = FALSE;
  3914.         if (m_pDecoderVideoFormat)
  3915.         {
  3916.             m_pDecoderVideoFormat->Release();
  3917.             m_pDecoderVideoFormat = NULL;
  3918.         }
  3919.     }
  3920.     else if (ulId == m_ulBltrPacemakerId)
  3921.     {
  3922.         if (m_pBltrVideoFormat)
  3923.         {
  3924.             m_pBltrVideoFormat->Release();
  3925.             m_pBltrVideoFormat = NULL;
  3926.         }
  3927.     }
  3929.     return HXR_OK;
  3930. }
  3932. STDMETHODIMP CVideoRenderer::OnPace(ULONG32 ulId)
  3933. {
  3934.     if (ulId == m_ulBltrPacemakerId)
  3935.     {
  3936. PresentFrame();
  3937.     }
  3938.     else if (ulId == m_ulDecoderPacemakerId)
  3939.     {
  3940. if (m_bSchedulerStartRequested)
  3941. {
  3942.     StartSchedulers();
  3943. }
  3945. while ((m_pDecoderVideoFormat->DecodeFrame()) != 0) ;
  3947. #ifdef HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  3948. // on ce we need to get this started quickly, otherwise the initial packets expire
  3949. if (THREAD_PRIORITY_BELOW_NORMAL != GetDecodePriority())
  3950. {
  3951.     SetDecodePriority(THREAD_PRIORITY_BELOW_NORMAL);
  3952.     return HXR_OK;
  3953. }
  3954. #endif
  3955.     }
  3957.     return HXR_OK;
  3958. }
  3961. /****************************************************************************
  3962.  *  Video Surface 2 Support
  3963.  */
  3964. HX_RESULT CVideoRenderer::InitVideoSurface2(ULONG32 ulWidth, ULONG32 ulHeight)
  3965. {
  3966. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  3967.     HX_RESULT retVal = HXR_FAIL;
  3969.     BOOL bTryVideoSurface2 = m_bTryVideoSurface2;
  3971.     if (bTryVideoSurface2)
  3972.     {
  3973.         HX_ASSERT(m_pMISUSSite);
  3974.         IHXVideoSurface* pVideoSurface = NULL;
  3975. IHXVideoSurface2* pVideoSurface2 = NULL;
  3976.         IHXSite2* pSite2 = NULL;
  3978. if (m_bUseVideoSurface2 &&
  3979.     m_pVSurf2InputBIH &&
  3980.     (m_pVSurf2InputBIH->biWidth == ((LONG32) ulWidth)) &&
  3981.     (m_pVSurf2InputBIH->biHeight == ((LONG32) ulHeight)))
  3982. {
  3983.     return HXR_OK;
  3984. }
  3986. // EndOptimizedBlt();
  3988. bTryVideoSurface2 = FALSE;
  3990.         m_pMISUSSite->QueryInterface(IID_IHXSite2, (void**) &pSite2);
  3991.         if (pSite2)
  3992.         {
  3993.             pSite2->GetVideoSurface(pVideoSurface);
  3994.         }
  3995. HX_RELEASE(pSite2);
  3997.         HX_ASSERT(pVideoSurface);
  3998.         if (pVideoSurface)
  3999.         {
  4000.             pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  4001.                                           (void**) &pVideoSurface2);
  4002.         }
  4003.         HX_RELEASE(pVideoSurface);
  4005.         if (pVideoSurface2)
  4006.         {
  4007.     HXBitmapInfoHeader userBIH;
  4008.     ULONG32 ulUserBufCount;
  4009.             IHXBuffer* pInitialCountBuffer = NULL;
  4010.     HX_RESULT status;
  4012.     m_ulHWBufCount = m_ulConfigHWBufCount;
  4014.     HX_RELEASE(pInitialCountBuffer);
  4016.     if (m_pVSurf2InputBIH == NULL)
  4017.     {
  4018. m_pVSurf2InputBIH = new HXBitmapInfoHeader;
  4019.     }
  4021.     retVal = HXR_OUTOFMEMORY;
  4022.     if (m_pVSurf2InputBIH)
  4023.     {
  4024. *m_pVSurf2InputBIH = m_BitmapInfoHeader;
  4025. m_pVSurf2InputBIH->biWidth = ulWidth;
  4026. m_pVSurf2InputBIH->biHeight = ulHeight;
  4027. retVal = HXR_OK;
  4028.     }
  4030.             if (SUCCEEDED(retVal))
  4031.     {
  4032. do
  4033. {
  4034.     // SetProperties should modify m_pVSurf2InputBIH
  4035.     status = pVideoSurface2->SetProperties(m_pVSurf2InputBIH,
  4036.    m_ulHWBufCount,
  4037.    (IHXRenderTimeLine*) this);
  4039.     /*** This code creates a leak - the renderer is not released
  4040.      *** Needs investigation.
  4041.     if (SUCCEEDED(status) && (m_ulHWBufCount > 0))
  4042.     {
  4043. UINT8* pVideoMem;
  4044. INT32 iPitch;
  4046. status = pVideoSurface2->GetVideoMem(pVideoMem,
  4047.      iPitch,
  4048.      HX_WAIT_FOREVER,
  4049.      m_pVSurf2InputBIH);
  4051. if (SUCCEEDED(status))
  4052. {
  4053.     pVideoSurface2->ReleaseVideoMem(pVideoMem);
  4054. }
  4055.     }
  4056.      ***/
  4058.     userBIH = *m_pVSurf2InputBIH;
  4059.     ulUserBufCount = m_ulHWBufCount;
  4061.     retVal = OnOptimizedVideo(status,
  4062.       m_BitmapInfoHeader,
  4063.       userBIH,
  4064.       ulUserBufCount);
  4066.     if (retVal == HXR_RETRY)
  4067.     {
  4068. *m_pVSurf2InputBIH = userBIH;
  4069. m_ulHWBufCount = ulUserBufCount;
  4070.     }
  4071. } while (retVal == HXR_RETRY);
  4072.     }
  4074.     if (SUCCEEDED(retVal) &&
  4075. SUCCEEDED(status) &&
  4076. (m_ulHWBufCount != 0))
  4077.     {
  4078. bTryVideoSurface2 = TRUE;
  4079.     }
  4080. }
  4082. if (bTryVideoSurface2)
  4083. {
  4084.     // Turning on video surface 2
  4085.     m_ulEarlyFrameTol = m_ulMaxOptimizedVideoLead;
  4086.     if (!m_bUseVideoSurface2)
  4087.     {
  4088. m_bVideoSurface2Transition = TRUE;
  4089. m_bUseVideoSurface2 = TRUE;
  4090. if (m_pBltrPump)
  4091. {
  4092.     // Wake up Bltr thread
  4093.     m_pBltrPump->Suspend(FALSE);
  4094.     m_pBltrPump->Signal();
  4095. }
  4096.     }
  4097. }
  4099. HX_RELEASE(pVideoSurface2);
  4100.     }
  4102.     if (FAILED(retVal))
  4103.     {
  4104. HX_DELETE(m_pVSurf2InputBIH);
  4105.     }
  4107.     m_bUseVideoSurface2 = bTryVideoSurface2;
  4109.     return retVal;
  4110. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4112.     return HXR_NOTIMPL;
  4113. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4114. }
  4117. HX_RESULT CVideoRenderer::UpdateVideoSurface2(IHXVideoSurface* pVideoSurface,
  4118.       HXxRect &destRect,
  4119.       HXxRect &sorcRect,
  4120.       BOOL bRefresh,
  4121.       BOOL bSystemEvent)
  4122. {
  4123. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4124.     VideoMemStruct videoMemoryInfo;
  4125.     IHXVideoSurface2* pVideoSurface2 = NULL;
  4126.     HX_RESULT retVal;
  4128.     HX_ASSERT(pVideoSurface);
  4130.     videoMemoryInfo.pVidMem = NULL;
  4132.     retVal = pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  4133.    (void**) &pVideoSurface2);
  4135.     if (!bRefresh)
  4136.     {
  4137. m_bPresentInProgress = TRUE;
  4139. // If we are in transition to video surface 2, we are not in
  4140. // natural Bltr thread, thus do not unlock the mutex to prevent
  4141. // other Blt entry points for interfering until the transition
  4142. // to natural queue thread is complete.
  4143. if (!m_bVideoSurface2Transition)
  4144. {
  4145.     DisplayMutex_Unlock();
  4146. }
  4148. if (SUCCEEDED(retVal))
  4149. {
  4150.     HX_ASSERT(m_bVideoSurface2Transition ? bSystemEvent : TRUE);
  4152.     retVal = pVideoSurface2->GetVideoMem(&videoMemoryInfo,
  4153.                                                  m_bVideoSurface2Transition ?
  4154.     HX_WAIT_NEVER : HX_WAIT_FOREVER);
  4156.     m_bVS2BufferUnavailableOnLastBlt = FAILED(retVal);
  4157. }
  4159. if (!m_bVideoSurface2Transition)
  4160. {
  4161.     DisplayMutex_Lock();
  4163.     // If the switch to VS1 occured after we successfully obtained video
  4164.     // memory, fail this VS2 Blt
  4165.     if ((!m_bUseVideoSurface2) && SUCCEEDED(retVal))
  4166.     {
  4167. retVal = HXR_FAIL;
  4168.     }
  4169. }
  4171. if (SUCCEEDED(retVal))
  4172. {
  4173.     retVal = TransferOptimizedVideo(pVideoSurface2,
  4174.                                             &videoMemoryInfo,
  4175.     m_pActiveVideoPacket,
  4176.     m_BitmapInfoHeader,
  4177.     sorcRect,
  4178.     sorcRect);
  4179. }
  4181. if (SUCCEEDED(retVal))
  4182. {
  4183.     if (m_bFirstSurfaceUpdate)
  4184.     {
  4185. m_bFirstSurfaceUpdate = FALSE;
  4187. if (bSystemEvent)
  4188. {
  4189.     retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4190.      m_pActiveVideoPacket->m_ulTime,
  4191.      HX_MODE_IMMEDIATE,
  4192.      &destRect,
  4193.      &sorcRect);
  4195.     // We'll fail if the site is hidden by SMIL:
  4196.     if (FAILED(retVal))
  4197.     {
  4198. retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4199.  m_pActiveVideoPacket->m_ulTime,
  4200.  HX_MODE_TIMED,
  4201.  &destRect,
  4202.  &sorcRect);
  4203.     }
  4204. }
  4205. else
  4206. {
  4207.     // Unless this is a system event we are not under the protection of the
  4208.     // top level site mutex and present immediate will acquire TLS mutex.
  4209.     // We must avoid deadlock with HandleEvent by relinquishing
  4210.     // VS mutex and forcing refresh.
  4211.     m_bPresentInProgress = FALSE;
  4212.     BOOL bIsVisible = ForceRefresh();
  4214.     // We'll fail if the site is not visible
  4215.     if (bIsVisible)
  4216.     {
  4217. // Abort any further updates for multiple site users since
  4218. // ForceRefresh will take care of all of them
  4219. retVal = HXR_ABORT;
  4220.     }
  4221.     else
  4222.     {
  4223. retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4224.  m_pActiveVideoPacket->m_ulTime,
  4225.  HX_MODE_TIMED,
  4226.  &destRect,
  4227.  &sorcRect);
  4228.     }
  4229. }
  4230.     }
  4231.     else
  4232.     {
  4233. retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4234.  m_pActiveVideoPacket->m_ulTime,
  4235.  HX_MODE_TIMED,
  4236.  &destRect,
  4237.  &sorcRect);
  4238.     }
  4240.     if (SUCCEEDED(retVal))
  4241.     {
  4242. videoMemoryInfo.pVidMem = NULL;
  4243.     }
  4244. }
  4246. m_bPresentInProgress = FALSE;
  4247.     }
  4248.     else if (!m_bPresentInProgress)
  4249.     {
  4250. HX_ASSERT(bSystemEvent);
  4252. retVal = pVideoSurface2->Present(NULL,
  4253.  0,
  4254.  HX_MODE_REFRESH,
  4255.  &destRect,
  4256.  &sorcRect);
  4258. // If no frames in video surface - make one and present it
  4259. if (FAILED(retVal) && bSystemEvent)
  4260. {
  4261.     retVal = pVideoSurface2->GetVideoMem(&videoMemoryInfo,
  4262.                                                  HX_WAIT_NEVER);
  4264.     if (SUCCEEDED(retVal))
  4265.     {
  4266. retVal = TransferOptimizedVideo(pVideoSurface2,
  4267.         &videoMemoryInfo,
  4268. m_pActiveVideoPacket,
  4269. m_BitmapInfoHeader,
  4270. sorcRect,
  4271. sorcRect);
  4273. if (SUCCEEDED(retVal))
  4274. {
  4275.     retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4276.      m_pActiveVideoPacket->m_ulTime,
  4277.      HX_MODE_IMMEDIATE,
  4278.      &destRect,
  4279.      &sorcRect);
  4281.     if (FAILED(retVal))
  4282.     {
  4283. pVideoSurface2->ReleaseVideoMem(&videoMemoryInfo);
  4284. retVal = pVideoSurface2->Present(NULL,
  4285.  0,
  4286.  HX_MODE_REFRESH,
  4287.  &destRect,
  4288.  &sorcRect);
  4289.     }
  4291.     videoMemoryInfo.pVidMem = NULL;
  4292. }
  4293.     }
  4294.     else
  4295.     {
  4296. retVal = pVideoSurface2->Present(NULL,
  4297.  0,
  4298.  HX_MODE_REFRESH,
  4299.  &destRect,
  4300.  &sorcRect);
  4301.     }
  4302. }
  4303.     }
  4305.     if (videoMemoryInfo.pVidMem != NULL)
  4306.     {
  4307. pVideoSurface2->ReleaseVideoMem(&videoMemoryInfo);
  4308.     }
  4310.     HX_RELEASE(pVideoSurface2);
  4312.     return retVal;
  4313. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4315.     return HXR_NOTIMPL;
  4316. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4317. }
  4320. HX_RESULT CVideoRenderer::FlushVideoSurface2(IHXSite* pSite)
  4321. {
  4322. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4323.     HX_RESULT retVal = HXR_FAIL;
  4325.     IHXVideoSurface* pVideoSurface;
  4326.     IHXVideoSurface2* pVideoSurface2;
  4327.     IHXSite2* pSite2;
  4329.     HX_ASSERT(pSite);
  4331.     if (SUCCEEDED(pSite->QueryInterface(IID_IHXSite2, (void**) &pSite2)))
  4332.     {
  4333. if (SUCCEEDED(pSite2->GetVideoSurface(pVideoSurface)))
  4334. {
  4335.     if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  4336. (void**) &pVideoSurface2)))
  4337.     {
  4338. pVideoSurface2->Flush();
  4339. pVideoSurface2->Release();
  4340. retVal = HXR_OK;
  4341.     }
  4343.     pVideoSurface->Release();
  4344. }
  4346. pSite2->Release();
  4347.     }
  4349.     HX_ASSERT(SUCCEEDED(retVal));
  4351.     return retVal;
  4352. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4354.     return HXR_NOTIMPL;
  4355. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4356. }
  4359. inline HX_RESULT CVideoRenderer::SwitchToVideoSurface1(void)
  4360. {
  4361. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4362.     HX_RESULT retVal = HXR_OK;
  4364.     m_pVSMutex->Lock();
  4366.     m_bVideoSurface1Requested = TRUE;
  4367.     if (m_bUseVideoSurface2)
  4368.     {
  4369. HX_TRACE_THINGY("C:/trace.txt", "-->Switch to VS1", 0);
  4371. #ifdef SYNC_VS_SWITCHING
  4372. InitVideoSurface1(TRUE);
  4373. StartSchedulers();
  4374. #else // SYNC_VS_SWITCHING
  4375. // Force Video Surface reinitialization
  4376. m_bVideoSurfaceReinitRequested = TRUE;
  4377. #endif // SYNC_VS_SWITCHING
  4378.     }
  4380.     m_pVSMutex->Unlock();
  4382.     return retVal;
  4383. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4385.     return HXR_NOTIMPL;
  4386. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4387. }
  4390. inline HX_RESULT CVideoRenderer::SwitchToVideoSurface2(void)
  4391. {
  4392. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4393.     HX_RESULT retVal = HXR_OK;
  4395.     m_pVSMutex->Lock();
  4397.     m_bVideoSurface1Requested = FALSE;
  4398.     if (!m_bUseVideoSurface2)
  4399.     {
  4400. if (m_bTryVideoSurface2)
  4401. {
  4402.     HX_TRACE_THINGY("C:/trace.txt", "-->Switch to VS2", 0);
  4404. #ifdef SYNC_VS_SWITCHING
  4405.     InitVideoSurface2(m_SetWinSize.cx, m_SetWinSize.cy);
  4406.     StartSchedulers();
  4407. #else // SYNC_VS_SWITCHING
  4408.     // Force Video Surface reinitialization
  4409.     m_bVideoSurfaceReinitRequested = TRUE;
  4410. #endif // SYNC_VS_SWITCHING
  4411. }
  4412. else
  4413. {
  4414.     // VideoSurface2 is not allowed
  4415.     HX_TRACE_THINGY("C:/trace.txt", "-->Switch to VS2 Denied!", 0);
  4417.     retVal = HXR_FAIL;
  4418. }
  4419.     }
  4421.     m_pVSMutex->Unlock();
  4423.     return retVal;
  4424. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4426.     return HXR_NOTIMPL;
  4427. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4428. }
  4431. /****************************************************************************
  4432.  *  Method:
  4433.  *    CVideoFormat::OnOptimizedVideo
  4434.  *
  4435.  */
  4436. HX_RESULT CVideoRenderer::OnOptimizedVideo(HX_RESULT status,
  4437.    const HXBitmapInfoHeader& sourceBIH,
  4438.    HXBitmapInfoHeader &targetBIH,
  4439.    ULONG32 &ulTargetBufCount)
  4440. {
  4441. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4442.     HX_RESULT retVal = HXR_FAIL;
  4444.     if (SUCCEEDED(status) &&
  4445. (ulTargetBufCount > 0) &&
  4446. (GETBITMAPCOLOR(&sourceBIH) == CID_I420))
  4447.     {
  4448.         retVal = HXR_OK;
  4449.     }
  4451.     return retVal;
  4452. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4454.     return HXR_NOTIMPL;
  4455. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4456. }
  4459. /****************************************************************************
  4460.  *  Method:
  4461.  *    CVideoFormat::OffOptimizedVideo
  4462.  *
  4463.  */
  4464. void CVideoRenderer::OffOptimizedVideo(void)
  4465. {
  4466.     return;
  4467. }
  4470. /****************************************************************************
  4471.  *  Method:
  4472.  *    CVideoFormat::TransferOptimizedVideo
  4473.  *
  4474.  */
  4475. HX_RESULT CVideoRenderer::TransferOptimizedVideo(IHXVideoSurface2* pVideoSurface2,
  4476.                                                  VideoMemStruct* pVideoMemoryInfo,
  4477.                                                  CMediaPacket* pVideoPacket,
  4478.                                                  const HXBitmapInfoHeader& sorcBIH,
  4479.                                                  HXxRect &destRect,
  4480.                                                  HXxRect &sorcRect)
  4481. {
  4482. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4483.     SourceInputStruct input;
  4484.     UINT8* aSrcInput[3];
  4485.     INT32 aSrcPitch[3];
  4486.     HX_RESULT retVal = HXR_FAIL;
  4488.     input.aSrcInput = aSrcInput;
  4489.     input.aSrcPitch = aSrcPitch;
  4490.     input.nNumInputs = 3;
  4492.     if (GETBITMAPCOLOR(&sorcBIH) == CID_I420)
  4493.     {
  4494. aSrcInput[0] = pVideoPacket->m_pData;
  4495. aSrcInput[1] = aSrcInput[0] + (sorcBIH.biWidth * sorcBIH.biHeight);
  4496. aSrcInput[2] = aSrcInput[1] +
  4497.        ((sorcBIH.biWidth / 2) * (sorcBIH.biHeight / 2));
  4499. aSrcPitch[0] = sorcBIH.biWidth;
  4500. aSrcPitch[1] = sorcBIH.biWidth / 2;
  4501. aSrcPitch[2] = sorcBIH.biWidth / 2;
  4503.         CHXxSize sorcSize(sorcBIH.biWidth, sorcBIH.biHeight);
  4505.         retVal = pVideoSurface2->ColorConvert(HX_I420,
  4506.                                               &sorcSize,
  4507.                                               &sorcRect,
  4508.                                               &input,
  4509.                                               pVideoMemoryInfo->bmi.biCompression,
  4510.                                               pVideoMemoryInfo->pVidMem,
  4511.                                               &CHXxSize(pVideoMemoryInfo->bmi.biWidth,
  4512.                                                         pVideoMemoryInfo->bmi.biHeight),
  4513.                                               &destRect,
  4514.                                               pVideoMemoryInfo->lPitch);
  4516.         // Alpha blend subrects:
  4517.         for (UINT32 i = 0; i < pVideoMemoryInfo->ulCount; ++i)
  4518.         {
  4519.             HX_RESULT localResult = pVideoSurface2->ColorConvert(
  4520.                              HX_I420,
  4521.                              &sorcSize,
  4522.                              &pVideoMemoryInfo->pAlphaList[i].rcImageRect,
  4523.                              &input,
  4524.                              pVideoMemoryInfo->pAlphaList[i].ulFourCC,
  4525.                              pVideoMemoryInfo->pAlphaList[i].pBuffer,
  4526.                              &CHXxSize(pVideoMemoryInfo->pAlphaList[i].ulImageWidth,
  4527.                                        pVideoMemoryInfo->pAlphaList[i].ulImageHeight),
  4528.                              &pVideoMemoryInfo->pAlphaList[i].rcImageRect,
  4529.                              pVideoMemoryInfo->pAlphaList[i].lPitch);
  4530.             if (SUCCEEDED(retVal))
  4531.             {
  4532.                 retVal = localResult;
  4533.             }
  4534.         }
  4535.     }
  4537.     return retVal;
  4538. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4540.     return HXR_NOTIMPL;
  4541. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4542. }
  4545. void CVideoRenderer::PresentFrame(void)
  4546. {
  4547. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4548.     if (m_bUseVideoSurface2)
  4549.     {
  4550. SchedulerCallback(FALSE,    // not scheduled
  4551.   FALSE,    // do not resched
  4552.   TRUE);    // is VS2 call
  4553.     }
  4554.     else
  4555.     {
  4556. // Video Surface2 has been turned off
  4557. IHXPaceMaker* pBltr = m_pBltrPump;
  4559. if (pBltr)
  4560. {
  4561.     if (m_bTryVideoSurface2)
  4562.     {
  4563. // We might try VideoSurface2 again later - suspend the
  4564. // Bltr thread for now
  4565. pBltr->Suspend(TRUE);
  4566.     }
  4567.     else
  4568.     {
  4569. // We are not to try VideoSurface2 any more - stop the
  4570. // Bltr thread
  4571. pBltr->Stop();
  4572. pBltr->Signal();
  4573.     }
  4574. }
  4575.     }
  4576. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4578.     ;
  4579. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4580. }