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

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

Symbian

开发平台：

C/C++

vidrend.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: RCSL 1.0/RPSL 1.0
  3.  *
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved.
  5.  *
  6.  * The contents of this file, and the files included with this file, are
  7.  * subject to the current version of the RealNetworks Public Source License
  8.  * Version 1.0 (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the RealNetworks Community Source License Version 1.0
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl,
  12.  * in which case the RCSL will apply. You may also obtain the license terms
  13.  * directly from RealNetworks.  You may not use this file except in
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or
  16.  * RCSL for the rights, obligations and limitations governing use of the
  17.  * contents of the file.
  18.  *
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the
  20.  * developer of the Original Code and owns the copyrights in the portions
  21.  * it created.
  22.  *
  23.  * This file, and the files included with this file, is distributed and made
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  28.  *
  29.  * Technology Compatibility Kit Test Suite(s) Location:
  30.  *    http://www.helixcommunity.org/content/tck
  31.  *
  32.  * Contributor(s):
  33.  *
  34.  * ***** END LICENSE BLOCK ***** */
  36. /****************************************************************************
  37.  *  Debug Settings
  38.  */
  39. // #define ENABLE_TRACE
  40. // #define ENABLE_SYNC_TRACE
  41. // #define ENABLE_SCHED_TRACE
  42. // #define ENABLE_FETCH_TRACE
  43. // #define ENABLE_INPUT_TRACE
  46. /****************************************************************************
  47.  *  Operational Compile-time Settings
  48.  */
  49. // #define SYNC_RESIZE_OK
  50. // #define SYNC_VS_SWITCHING
  51. // #define REBUFFER_ON_VIDEO
  52. #define SET_NONZERO_VIEWFRAME_ONLY
  53. #define RESIZE_AFTER_SITE_ATTACHED
  54. #define DO_ABSOLUTE_TIMING
  55. #ifdef HELIX_FEATURE_VIDREND_SYNCSMOOTHING
  56. #define SYNC_SMOOTHING
  57. #define SYNC_PRE_SMOOTHING
  58. #endif // HELIX_FEATURE_VIDREND_SYNCSMOOTHING
  59. #define DEFAULT_VS2_TARGETRECT
  61. #define MAX_ULONG32_AS_DOUBLE ((double) ((ULONG32) 0xFFFFFFFF))
  62. #define MAX_LONG32_AS_DOUBLE ((double) ((LONG32) 0x7FFFFFFF))
  63. #define MIN_LONG32_AS_DOUBLE ((double) ((LONG32) 0x80000000))
  65. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  66. #define OSGRANULE_BOOSTING_ENABLED  FALSE
  67. #else // _MACINTOSH
  68. #define OSGRANULE_BOOSTING_ENABLED  TRUE
  69. #endif // _MACINTOSH
  71. /****************************************************************************
  72.  *  Debug Macros
  73.  */
  74. #ifdef ENABLE_TRACE
  75. #define HX_TRACE_THINGY(x, m, l)
  76.     {
  77. FILE* f1;
  78. f1 = ::fopen(x, "a+");
  79. (f1)?(::fprintf(f1, "%ld - %s = %ld n", HX_GET_BETTERTICKCOUNT(), m, l), ::fclose(f1)):(0);
  80.     }
  81. #else // ENABLE_TRACE
  82. #define HX_TRACE_THINGY(x, m, l)
  83. #endif // ENABLE_TRACE
  86. /****************************************************************************
  87.  *  Defines
  88.  */
  89. #define BASE_VIDEO_RENDERER_NAME    "Basic Video"
  90. #define NAME_STATS_EXT     ".name"
  91. #define C4CC_STATS_EXT     ".CodecFourCC"
  93. #if defined(HELIX_FEATURE_VIDREND_NO_DEFAULT_WINDOW_SIZE)
  94. #define DEFAULT_WIN_SIZE_X     0
  95. #define DEFAULT_WIN_SIZE_Y     0
  96. #else
  97. #define DEFAULT_WIN_SIZE_X     160
  98. #define DEFAULT_WIN_SIZE_Y     120
  99. #endif
  101. #define SYNC_INTERVAL     20     // in milliseconds
  102. #define EARLY_FRAME_TOL     3     // in milliseconds
  103. #define LATE_FRAME_TOL     30     // in milliseconds
  104. #define NO_FRAMES_POLLING_INTERVAL  20     // in milliseconds
  105. #define MAX_SLEEP_TIME     132     // in milliseconds
  106. #define BLT_PACKET_QUEUE_SIZE     3     // in packets
  107. #define SYNC_GOAL_SMOOTHING_DEPTH   30     // number of samples
  108. #define SPEEDUP_GOAL_SMOOTHING_DEPTH 8     // number of samples
  109. #define MAX_BAD_SAMPLE_INTERVAL     1000    // in milliseconds
  111. #define VIDEO_STAT_INTERVAL     1000    // in milliseconds
  112. #define VIDEO_STAT_INTERVAL_COUNT   2     // number of intervals to average over
  114. #define MAX_OPTIMIZED_VIDEO_LEAD 200 // in milliseconds
  115. #define DEFAULT_HARDWARE_BUFFER_COUNT 4
  117. #define AUDIO_SKEW_POWER     4     // Maximum Audio Speedup Slope as
  118.     // 1/(2^AUDIO_SKEW_POWER)
  119. #define MIN_BAD_PERSISTENCE_COUNT   0     // Minimum number of consecutive
  120.     // bad sync samples for the
  121.     // resync probation period to start
  122. #define MIN_GOOD_PERSISTENCE_COUNT  0     // Minimum number of consecutive
  123.     // good sync samples for the
  124.     // resync probation period to be
  125.     // cancelled
  127. #define MAX_BLT_LOOPS     3
  128. #define BLT_RELIEF_DELAY     1     // in milliseconds
  130. // Absolute timing settings
  131. #define N_STABILIZATION_ITERATIONS  5
  132. #define MAX_ALLOWED_TIMING_ERROR    2
  133. #define SMALLEST_TIMABLE_PERIOD     2
  135. // Default Decoding Priority
  136. #ifdef _WIN32
  137.     #ifdef HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  138.     // on ce we need to get this started quickly, otherwise the initial packets expire
  139.     // we set the priority so we can check in onpace to reset only once
  140.     #define DFLT_DECODE_PRIORITY     THREAD_PRIORITY_HIGHEST
  141.     #define DFLT_PRESENT_PRIORITY     THREAD_PRIORITY_ABOVE_NORMAL
  142.     #else
  143.     #define DFLT_DECODE_PRIORITY     THREAD_PRIORITY_BELOW_NORMAL
  144.     #define DFLT_PRESENT_PRIORITY     THREAD_PRIORITY_ABOVE_NORMAL
  145.     #endif // HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  146. #else // _WIN32
  147. #define DFLT_DECODE_PRIORITY     0
  148. #define DFLT_PRESENT_PRIORITY     0
  149. #endif // _WIN32
  151. // Lowest acceptable version numbers
  152. #define STREAM_MAJOR_VERSION  0
  153. #define STREAM_MINOR_VERSION  0
  155. #define CONTENT_MAJOR_VERSION 0
  156. #define CONTENT_MINOR_VERSION 0
  158. #define DECODER_INTERVAL 5
  159. #define BLTR_INTERVAL 5
  161. #ifdef _WIN32
  162. #define GETBITMAPCOLOR(x) GetBitmapColor( (LPBITMAPINFO)(x) )
  163. #else // _WIN32
  164. #define GETBITMAPCOLOR(x) GetBitmapColor( (HXBitmapInfo*)(x))
  165. #endif // _WIN32
  168. /****************************************************************************
  169.  *  Includes
  170.  */
  171. #include "hlxclib/stdio.h"
  172. #include "vidrend.ver"
  173. #include "hxtypes.h"
  174. #ifdef _WINDOWS
  175. #include <windows.h>
  176. #endif
  179. #if defined(_UNIX) && !defined(_MAC_UNIX)
  181. #include <stdio.h>
  182. #include <stdlib.h>
  183. #include <unistd.h>
  185. #ifndef QWS
  186. #include <X11/Intrinsic.h>
  187. #include <X11/StringDefs.h>
  188. #include <X11/Shell.h>
  189. #endif /* QWS */
  191. #endif
  193. #include "hxwintyp.h"
  194. #include "hxcom.h"
  195. #include "hxcomm.h"
  196. #include "hxthread.h"
  198. // for sync
  199. #include "hxengin.h"
  200. #include "hxprefs.h"
  201. #include "hxtick.h"
  202. #include "timeval.h"
  203. #include "hxevent.h"
  204. #include "hxvsurf.h"
  206. #include "ihxpckts.h"
  207. #include "hxfiles.h"
  208. #include "hxcore.h"
  209. #include "hxerror.h"
  210. #include "hxrendr.h"
  211. #include "addupcol.h"
  212. // #include "hxhyper.h"
  213. #include "hxplugn.h"
  214. #include "hxwin.h"
  215. // #include "hxasm.h"
  216. #include "hxmon.h"
  217. #include "hxbuffer.h" // for CHXBuffer
  219. #include "hxassert.h" // for HX_ASSERT()
  220. #include "hxheap.h" // for heap checking
  221. #include "hxslist.h" // CHXSimpleList
  223. #include "chxbufpl.h"
  225. #include "sdpchunk.h"
  227. #include "vidrend.h"
  228. #include "cpacemkr.h"
  229. #include "hxver.h"
  231. #if defined(_WINDOWS) && !defined(WIN32_PLATFORM_PSPC)
  232. #include "ddraw.h"
  233. #endif /* defined(_WINDOWS) && !defined(WIN32_PLATFORM_PSPC) */
  235. // #include "coloracc.h"
  236. #include "colormap.h"
  238. #include "chxxtype.h"   // For CHXxSize
  240. #if defined(HELIX_FEATURE_PREFERENCES)
  241. #include "hxprefs.h"
  242. #include "hxprefutil.h"
  243. #endif /* HELIX_FEATURE_PREFERENCES */
  245. /****************************************************************************
  246.  *  Debug
  247.  */
  248. #ifdef ENABLE_SYNC_TRACE
  249. #define MAX_SYNC_TRACE_ENTRIES 10000
  250. ULONG32 ulSyncTraceIdx = 0;
  251. ULONG32 syncTraceArray[MAX_SYNC_TRACE_ENTRIES][3];
  253. void DumpSyncEntries(void)
  254. {
  255.     FILE* pFile = NULL;
  256.     ULONG32 ulIdx;
  258.     if (ulSyncTraceIdx > 0)
  259.     {
  260. pFile = fopen("\helix\sync.txt", "wb");
  261.     }
  263.     if (pFile)
  264.     {
  265. for (ulIdx = 0; ulIdx < ulSyncTraceIdx; ulIdx++)
  266. {
  267.     fprintf(pFile, "%ut%ut%un", syncTraceArray[ulIdx][0],
  268.    syncTraceArray[ulIdx][1],
  269.    syncTraceArray[ulIdx][2]);
  270. }
  272. fclose(pFile);
  273.     }
  275.     ulSyncTraceIdx = 0;
  276. }
  277. #endif // ENABLE_SYNC_TRACE
  280. #ifdef ENABLE_SCHED_TRACE
  281. #define MAX_SCHED_TRACE_ENTRIES 10000
  282. ULONG32 ulSchedTraceIdx = 0;
  283. LONG32 schedTraceArray[MAX_SCHED_TRACE_ENTRIES];
  285. void DumpSchedEntries(void)
  286. {
  287.     FILE* pFile = NULL;
  288.     ULONG32 ulIdx;
  290.     if (ulSchedTraceIdx > 0)
  291.     {
  292. pFile = fopen("\helix\sched.txt", "wb");
  293.     }
  295.     if (pFile)
  296.     {
  297. for (ulIdx = 0; ulIdx < ulSchedTraceIdx; ulIdx++)
  298. {
  299.     fprintf(pFile, "%dn", schedTraceArray[ulIdx]);
  300. }
  302. fclose(pFile);
  303.     }
  305.     ulSchedTraceIdx = 0;
  306. }
  307. #endif // ENABLE_SCHED_TRACE
  310. #ifdef ENABLE_FETCH_TRACE
  311. #define MAX_FETCH_TRACE_ENTRIES 10000
  312. ULONG32 ulFetchTraceIdx = 0;
  313. LONG32 fetchTraceArray[MAX_FETCH_TRACE_ENTRIES];
  315. void DumpFetchEntries(void)
  316. {
  317.     FILE* pFile = NULL;
  318.     ULONG32 ulIdx;
  320.     if (ulFetchTraceIdx > 0)
  321.     {
  322. pFile = fopen("\helix\fetch.txt", "wb");
  323.     }
  325.     if (pFile)
  326.     {
  327. for (ulIdx = 0; ulIdx < ulFetchTraceIdx; ulIdx++)
  328. {
  329.     fprintf(pFile, "%dn", fetchTraceArray[ulIdx]);
  330. }
  332. fclose(pFile);
  333.     }
  335.     ulFetchTraceIdx = 0;
  336. }
  337. #endif // ENABLE_FETCH_TRACE
  340. #ifdef ENABLE_INPUT_TRACE
  341. #define MAX_INPUT_TRACE_ENTRIES 10000
  342. ULONG32 ulInputTraceIdx = 0;
  343. LONG32 inputTraceArray[MAX_INPUT_TRACE_ENTRIES];
  345. void DumpInputEntries(void)
  346. {
  347.     FILE* pFile = NULL;
  348.     ULONG32 ulIdx;
  350.     if (ulInputTraceIdx > 0)
  351.     {
  352. pFile = fopen("\helix\input.txt", "wb");
  353.     }
  355.     if (pFile)
  356.     {
  357. for (ulIdx = 0; ulIdx < ulInputTraceIdx; ulIdx++)
  358. {
  359.     fprintf(pFile, "%dn", inputTraceArray[ulIdx]);
  360. }
  362. fclose(pFile);
  363.     }
  365.     ulInputTraceIdx = 0;
  366. }
  367. #endif // ENABLE_INPUT_TRACE
  370. /****************************************************************************
  371.  *  Constants
  372.  */
  373. const char* const CVideoRenderer::zm_pDescription    = "RealNetworks Video Renderer Plugin";
  374. const char* const CVideoRenderer::zm_pCopyright      = HXVER_COPYRIGHT;
  375. const char* const CVideoRenderer::zm_pMoreInfoURL    = HXVER_MOREINFO;
  377. const char* const CVideoRenderer::zm_pStreamMimeTypes[] =
  378. {
  379.     NULL
  380. };
  383. /************************************************************************
  384.  *  CVideoRenderer
  385.  */
  386. /************************************************************************
  387.  *  Constructor/Destructor
  388.  */
  389. CVideoRenderer::CVideoRenderer(void)
  390. : m_lRefCount(0)
  391. , m_pContext(NULL)
  392. , m_pStream(NULL)
  393. , m_pHeader(NULL)
  394. , m_pMutex(NULL)
  395. , m_pBltMutex(NULL)
  396. , m_pVSMutex(NULL)
  397. , m_pDecoderPump(NULL)
  398. , m_pBltrPump(NULL)
  399. , m_ulDecoderPacemakerId(0)
  400. , m_ulBltrPacemakerId(0)
  401. , m_pDecoderVideoFormat(NULL)
  402. , m_pBltrVideoFormat(NULL)
  403. , m_pBackChannel(0)
  404. , m_pCommonClassFactory(0)
  405. , m_ulRegistryID(0)
  406. , m_pVideoStats(NULL)
  407. , m_pMISUS(NULL)
  408. , m_pMISUSSite(NULL)
  409. , m_ulEarlyFrameTol(EARLY_FRAME_TOL)
  410. , m_ulLateFrameTol(LATE_FRAME_TOL)
  411. , m_ulNoFramesPollingInterval(NO_FRAMES_POLLING_INTERVAL)
  412. , m_ulMaxSleepTime(MAX_SLEEP_TIME)
  413. , m_ulBltPacketQueueSize(BLT_PACKET_QUEUE_SIZE)
  414. , m_ulSyncGoalSmoothingDepth(SYNC_GOAL_SMOOTHING_DEPTH)
  415. , m_ulSpeedupGoalSmoothingDepth(SPEEDUP_GOAL_SMOOTHING_DEPTH)
  416. , m_ulMaxBadSeqSamples(0)
  417. , m_lTimeLineOffset(0)
  418. , m_lDecodePriority(DFLT_DECODE_PRIORITY)
  419. , m_ulStreamBaseTime(0)
  420. , m_ulBaseTime(0)
  421. , m_ulTimeNormalizationOffset(0)
  422. , m_bBitmapSet(FALSE)
  423. , m_bFrameSizeInitialized(FALSE)
  424. , m_bWinSizeFixed(FALSE)
  425. , m_bOSGranuleBoost(OSGRANULE_BOOSTING_ENABLED)
  426. , m_bOSGranuleBoostVS2(OSGRANULE_BOOSTING_ENABLED)
  427. , m_bOptimizedBlt(FALSE)
  428. , m_bUseVideoSurface2(FALSE)
  429. #if defined(_WINDOWS) && defined(HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO)
  430. , m_bTryVideoSurface2(TRUE)
  431. #else // _WINDOWS
  432. , m_bTryVideoSurface2(FALSE)
  433. #endif // _WINDOWS
  434. , m_bVideoSurface2Transition(FALSE)
  435. , m_bVideoSurface1Requested(FALSE)
  436. , m_bVideoSurfaceInitialized(FALSE)
  437. , m_bVideoSurfaceReinitRequested(FALSE)
  438. , m_bPresentInProgress(FALSE)
  439. , m_bVS2BufferUnavailableOnLastBlt(FALSE)
  440. , m_ulHWBufCount(DEFAULT_HARDWARE_BUFFER_COUNT)
  441. , m_ulConfigHWBufCount(DEFAULT_HARDWARE_BUFFER_COUNT)
  442. , m_pClipRect(NULL)
  443. , m_pPreferences(NULL)
  444. , m_pRegistry(NULL)
  445. , m_pScheduler(NULL)
  446. , m_pOptimizedScheduler(NULL)
  447. , m_bPendingCallback(FALSE)
  448. , m_bSchedulerStartRequested(FALSE)
  449. , m_hPendingHandle(0)
  450. , m_ulCallbackCounter(0)
  451. , m_bDecoderRunning(FALSE)
  452. , m_bSiteAttached(FALSE)
  453. , m_PlayState(Stopped)
  454. , m_ulBytesToBuffer(0)
  455. , m_ulAvgBitRate(0)
  456. , m_ulPreroll(0)
  457. , m_ulBufferingStartTime(0)
  458. , m_ulBufferingStopTime(0)
  459. , m_ulBufferingTimeOut(0)
  460. , m_bBufferingOccured(FALSE)
  461. , m_bBufferingNeeded(FALSE)
  462. , m_pVideoFormat(NULL)
  463. , m_pBltPacketQueue(NULL)
  464. , m_pActiveVideoPacket(NULL)
  465. , m_ulActiveVideoTime(0)
  466. , m_bFirstFrame(TRUE)
  467. , m_bBaseTimeSet(FALSE)
  468. , m_bFirstSurfaceUpdate(TRUE)
  469. , m_bPendingRedraw(FALSE)
  470. , m_bVS1UpdateInProgress(FALSE)
  471. , m_ulSyncSmoothingDepth(0)
  472. , m_ulSyncInterval(SYNC_INTERVAL)
  473. , m_ulBadSeqSampleCount(0)
  474. , m_ulGoodSeqSampleCount(0)
  475. , m_fTrendSyncDelta(0.0)
  476. , m_pResizeCB(NULL)
  477. , m_pVSurf2InputBIH(NULL)
  478. , m_bIsScheduledCB(0)
  479. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  480. , m_bUntimedRendering(FALSE)
  481. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  482. , m_bActiveVideoPacketLocalized(FALSE)
  483. {
  484.     m_SetWinSize.cx = 0;
  485.     m_SetWinSize.cy = 0;
  486.     m_LastSetSize.cx = 0;
  487.     m_LastSetSize.cy = 0;
  489.     m_rViewRect.left   = 0;
  490.     m_rViewRect.top    = 0;
  491.     m_rViewRect.right  = 0;
  492.     m_rViewRect.bottom = 0; 
  494.     memset(&m_BitmapInfoHeader, 0, sizeof(HXBitmapInfoHeader));
  495. }
  497. CVideoRenderer::~CVideoRenderer()
  498. {
  499.     // NOTE: You should do your renderer cleanup here, instead of
  500.     // in EndStream(), because your renderer is still left around
  501.     // after the stream is ended in case it is a display renderer
  502.     // and it needs to "paint" it's display area.
  503.     EndOptimizedBlt();
  505.     if (m_pActiveVideoPacket)
  506.     {
  507. m_pActiveVideoPacket->Clear();
  508. delete m_pActiveVideoPacket;
  509. m_pActiveVideoPacket = NULL;
  510. m_ulActiveVideoTime = 0;
  511.     }
  513.     HX_RELEASE(m_pHeader);
  514.     HX_RELEASE(m_pContext);
  515.     HX_RELEASE(m_pCommonClassFactory);
  517.     if (m_pVideoFormat)
  518.     {
  519.         m_pVideoFormat->Release();
  520.         m_pVideoFormat = NULL;
  521.     }
  523.     HX_DELETE(m_pVSurf2InputBIH);
  524.     HX_DELETE(m_pClipRect);
  525.     HX_DELETE(m_pMutex);
  526.     HX_DELETE(m_pBltMutex);
  527.     HX_DELETE(m_pVSMutex);
  529.     RemoveCallback(m_hPendingHandle);
  530.     m_bPendingCallback = FALSE;
  532.     HX_RELEASE(m_pOptimizedScheduler);
  533.     HX_RELEASE(m_pScheduler);
  535.     HX_RELEASE(m_pPreferences);
  536.     HX_RELEASE(m_pRegistry);
  538.     ClearBltPacketQueue();
  539.     HX_DELETE(m_pBltPacketQueue);
  541.     HX_RELEASE(m_pResizeCB);
  543. #if defined(HELIX_FEATURE_STATS)
  544.     HX_DELETE(m_pVideoStats);
  545. #endif /* HELIX_FEATURE_STATS */
  546. }
  549. /************************************************************************
  550.  *  IHXPlugin Methods
  551.  */
  552. /************************************************************************
  553.  *  Method:
  554.  *    IHXPlugin::InitPlugin
  555.  *  Purpose:
  556.  *    Initializes the plugin for use. This interface must always be
  557.  *    called before any other method is called. This is primarily needed
  558.  *    so that the plugin can have access to the context for creation of
  559.  *    IHXBuffers and IMalloc.
  560.  */
  561. STDMETHODIMP CVideoRenderer::InitPlugin(IUnknown* /*IN*/ pContext)
  562. {
  563.     HX_RESULT retVal = HXR_OK;
  565.     HX_ASSERT(pContext);
  567.     m_pContext = pContext;
  568.     m_pContext->AddRef();
  570.     retVal = m_pContext->QueryInterface(IID_IHXCommonClassFactory,
  571. (void**) &m_pCommonClassFactory);
  573.     if (SUCCEEDED(retVal))
  574.     {
  575. m_pContext->QueryInterface(IID_IHXPreferences,
  576.                                    (void**) &m_pPreferences);
  577.     }
  579.     m_pContext->QueryInterface(IID_IHXRegistry, (void**) &m_pRegistry);
  581.     if (SUCCEEDED(retVal))
  582.     {
  583. retVal = m_pContext->QueryInterface(IID_IHXScheduler,
  584.     (void **) &m_pScheduler);
  585.     }
  587.     if (SUCCEEDED(retVal) && !m_pMutex)
  588.     {
  589. #ifdef THREADS_SUPPORTED
  590. retVal = HXMutex::MakeMutex(m_pMutex);
  591. #else  // THREADS_SUPPORTED
  592. retVal = HXMutex::MakeStubMutex(m_pMutex);
  593. #endif  // THREADS_SUPPORTED
  594.     }
  596.     if (SUCCEEDED(retVal) && !m_pBltMutex)
  597.     {
  598. #ifdef THREADS_SUPPORTED
  599. retVal = HXMutex::MakeMutex(m_pBltMutex);
  600. #else  // THREADS_SUPPORTED
  601. retVal = HXMutex::MakeStubMutex(m_pBltMutex);
  602. #endif  // THREADS_SUPPORTED
  603.     }
  605.     if (SUCCEEDED(retVal) && !m_pVSMutex)
  606.     {
  607. #ifdef THREADS_SUPPORTED
  608. retVal = HXMutex::MakeMutex(m_pVSMutex);
  609. #else  // THREADS_SUPPORTED
  610. retVal = HXMutex::MakeStubMutex(m_pVSMutex);
  611. #endif  // THREADS_SUPPORTED
  612.     }
  614. #if defined(HELIX_FEATURE_STATS)
  615.     if (SUCCEEDED(retVal))
  616.     {
  617. m_pVideoStats = new CVideoStatistics(m_pContext,
  618.      VIDEO_STAT_INTERVAL_COUNT);
  620. retVal = HXR_OUTOFMEMORY;
  621. if (m_pVideoStats)
  622. {
  623.     retVal = HXR_OK;
  624. }
  625.     }
  626. #endif /* HELIX_FEATURE_STATS */
  628.     if (FAILED(retVal))
  629.     {
  630. HX_RELEASE(m_pCommonClassFactory);
  631. HX_RELEASE(m_pPreferences);
  632. HX_RELEASE(m_pRegistry);
  633. HX_RELEASE(m_pScheduler);
  634.     }
  636.     return retVal;
  637. }
  639. /************************************************************************
  640.  *  Method:
  641.  *    IHXPlugin::GetPluginInfo
  642.  *  Purpose:
  643.  *    Returns the basic information about this plugin. Including:
  644.  *
  645.  *    bLoadMultiple whether or not this plugin DLL can be loaded
  646.  * multiple times. All File Formats must set
  647.  * this value to TRUE.
  648.  *    pDescription which is used in about UIs (can be NULL)
  649.  *    pCopyright which is used in about UIs (can be NULL)
  650.  *    pMoreInfoURL which is used in about UIs (can be NULL)
  651.  */
  652. STDMETHODIMP CVideoRenderer::GetPluginInfo
  653. (
  654.    REF(BOOL)        /*OUT*/ bLoadMultiple,
  655.    REF(const char*) /*OUT*/ pDescription,
  656.    REF(const char*) /*OUT*/ pCopyright,
  657.    REF(const char*) /*OUT*/ pMoreInfoURL,
  658.    REF(ULONG32)     /*OUT*/ ulVersionNumber
  659. )
  660. {
  661.     bLoadMultiple = TRUE;   // Must be true for file formats.
  663.     pDescription    = zm_pDescription;
  664.     pCopyright     = zm_pCopyright;
  665.     pMoreInfoURL    = zm_pMoreInfoURL;
  666.     ulVersionNumber = TARVER_ULONG32_VERSION;
  668.     return HXR_OK;
  669. }
  671. /************************************************************************
  672.  *  Method:
  673.  *    IHXPlugin::GetRendererInfo
  674.  *  Purpose:
  675.  *    If this object is a file format object this method returns
  676.  *    information vital to the instantiation of file format plugins.
  677.  *    If this object is not a file format object, it should return
  678.  *    HXR_UNEXPECTED.
  679.  */
  680. STDMETHODIMP CVideoRenderer::GetRendererInfo
  681. (
  682.  REF(const char**) /*OUT*/ pStreamMimeTypes,
  683.  REF(UINT32)      /*OUT*/ unInitialGranularity
  684. )
  685. {
  686.     pStreamMimeTypes = (const char**) zm_pStreamMimeTypes;
  687.     unInitialGranularity = SYNC_INTERVAL;
  688.     return HXR_OK;
  689. }
  694. /************************************************************************
  695.  *  IHXRenderer Methods
  696.  */
  697. /////////////////////////////////////////////////////////////////////////
  698. //  Method:
  699. // IHXRenderer::StartStream
  700. //  Purpose:
  701. // Called by client engine to inform the renderer of the stream it
  702. // will be rendering. The stream interface can provide access to
  703. // its source or player. This method also provides access to the
  704. // primary client controller interface.
  705. //
  706. STDMETHODIMP CVideoRenderer::StartStream(IHXStream* pStream,
  707.    IHXPlayer* pPlayer)
  708. {
  709.     m_pStream  = pStream;
  711.     if (m_pStream)
  712.     {
  713. m_pStream->AddRef();
  714.     }
  716. #if defined (HELIX_FEATURE_MISU)
  717.     m_pCommonClassFactory->CreateInstance(
  718. CLSID_IHXMultiInstanceSiteUserSupplier,
  719. (void**) &m_pMISUS);
  721.     if (m_pMISUS)
  722.     {
  723. m_pMISUS->SetSingleSiteUser((IUnknown*)(IHXSiteUser*) this);
  724.     }
  725. #endif //HELIX_FEATURE_MISU
  727.     if (m_pStream)
  728.     {
  729. IHXStreamSource* pSource = 0;
  730. if (m_pStream->GetSource(pSource) == HXR_OK)
  731. {
  732.     /* It is OK if the source does not support backchannel. Reasons:
  733.      *
  734.      * 1. This stream may not be coming from h261 fileformat.
  735.      *   It may instead be merged into a container fileformat which
  736.      *   may be does not support BackChannel.
  737.      *
  738.      * 2. The protocol used to serve this stream may not support
  739.      *   BackChannel.
  740.      */
  741.     pSource->QueryInterface(IID_IHXBackChannel, (void**) &m_pBackChannel);
  743.     pSource->Release();
  744. }
  745.     }
  747.     return HXR_OK;
  748. }
  750. /////////////////////////////////////////////////////////////////////////
  751. //  Method:
  752. // IHXRenderer::EndStream
  753. //  Purpose:
  754. // Called by client engine to inform the renderer that the stream
  755. // is was rendering is closed.
  756. //
  757. STDMETHODIMP CVideoRenderer::EndStream()
  758. {
  759.     // Stop Blts by changing state
  760.     m_pMutex->Lock();
  761.     m_PlayState = Stopped;
  762.     m_pMutex->Unlock();
  764.     // Stop Decoder
  765.     if (m_pDecoderPump)
  766.     {
  767. m_pDecoderPump->Stop();
  768. m_pDecoderPump->Signal();
  769. m_pDecoderPump->WaitForStop();
  770. m_pDecoderPump->Release();
  771. m_pDecoderPump = NULL;
  772.     }
  774.     // Wait for Blt if in progress and then flush packet queues
  775.     DisplayMutex_Lock();
  776.     if (m_pVideoFormat)
  777.     {
  778. m_pVideoFormat->Reset();
  779.     }
  780.     DisplayMutex_Unlock();
  782.     // IHXStream, IHXSourceStream or IHXBackChannel
  783.     // cannot be used after EndStream has been called.
  784.     HX_RELEASE(m_pStream);
  785.     HX_RELEASE(m_pBackChannel);
  787.     // Stop Bltr pump
  788.     if (m_pBltrPump)
  789.     {
  790. m_pBltrPump->Stop();
  791. m_pBltrPump->Signal();
  792.     }
  794.     // Flush Optimized Video Surface if used
  795.     if (m_bUseVideoSurface2 && m_pMISUSSite)
  796.     {
  797. FlushVideoSurface2(m_pMISUSSite);
  798.     }
  800.     if (m_pBltrPump)
  801.     {
  802. m_pBltrPump->WaitForStop();
  803. m_pBltrPump->Release();
  804. m_pBltrPump = NULL;
  805.     }
  807.     DisplayMutex_Lock();
  808.     if (m_pVideoFormat)
  809.     {
  810.         m_pVideoFormat->Release();
  811.         m_pVideoFormat = NULL;
  812.     }
  813.     DisplayMutex_Unlock();
  815. #ifdef ENABLE_SYNC_TRACE
  816.     DumpSyncEntries();
  817. #endif // ENABLE_SYNC_TRACE
  819. #ifdef ENABLE_SCHED_TRACE
  820.     DumpSchedEntries();
  821. #endif // ENABLE_SCHED_TRACE
  823. #ifdef ENABLE_FETCH_TRACE
  824.     DumpFetchEntries();
  825. #endif // ENABLE_FETCH_TRACE
  827. #ifdef ENABLE_INPUT_TRACE
  828.     DumpInputEntries();
  829. #endif // ENABLE_INPUT_TRACE
  831.     return HXR_OK;
  832. }
  834. /////////////////////////////////////////////////////////////////////////
  835. //  Method:
  836. // IHXRenderer::OnHeader
  837. //  Purpose:
  838. // Called by client engine when a header for this renderer is
  839. // available. The header will arrive before any packets.
  840. //
  841. STDMETHODIMP CVideoRenderer::OnHeader(IHXValues* pHeader)
  842. {
  843.     HX_RESULT retVal = HXR_OK;
  845.     HX_DELETE(m_pClipRect);
  847.     // Keep this for later use...
  848.     HX_RELEASE(m_pHeader);
  849.     m_pHeader = pHeader;
  850.     m_pHeader->AddRef();
  852.     m_ulStreamBaseTime = 0;
  853.     m_ulBaseTime = 0;
  854.     m_ulTimeNormalizationOffset = 0;
  856.     // check the stream versions
  857.     m_pHeader->AddRef();
  858.     retVal = CheckStreamVersions(m_pHeader);
  859.     m_pHeader->Release();
  861. #ifdef HELIX_FEATURE_QUICKTIME
  862.     IHXBuffer* pSDPData = NULL;
  864.     if (SUCCEEDED(retVal) &&
  865. SUCCEEDED(pHeader->GetPropertyCString("SDPData", pSDPData)))
  866.     {
  867. char *pData = (char*) pSDPData->GetBuffer();
  868. IHXValues *pValues = NULL;
  870. if (pData &&
  871.     SUCCEEDED(SDPParseChunk(pData,
  872.     strlen(pData),
  873.     pValues,
  874.     m_pCommonClassFactory,
  875.     SDPCTX_Renderer)))
  876. {
  877.     ULONG32 ulLeft;
  878.     ULONG32 ulRight;
  879.     ULONG32 ulTop;
  880.     ULONG32 ulBottom;
  882.     if (SUCCEEDED(pValues->GetPropertyULONG32(
  883.     "ClipFrameLeft", ulLeft)) &&
  884. SUCCEEDED(pValues->GetPropertyULONG32(
  885.     "ClipFrameRight", ulRight)) &&
  886. SUCCEEDED(pValues->GetPropertyULONG32(
  887.     "ClipFrameTop", ulTop)) &&
  888. SUCCEEDED(pValues->GetPropertyULONG32(
  889.     "ClipFrameBottom", ulBottom)))
  890.     {
  891. retVal = HXR_OUTOFMEMORY;
  893. m_pClipRect = (HXxRect*) new HXxRect;
  894. if (m_pClipRect)
  895. {
  896.     m_pClipRect->left = (INT32) ulLeft;
  897.     m_pClipRect->right = (INT32) ulRight;
  898.     m_pClipRect->top = (INT32) ulTop;
  899.     m_pClipRect->bottom = (INT32) ulBottom;
  900.     retVal = HXR_OK;
  901. }
  902.     }
  903. }
  905. HX_RELEASE(pValues);
  906.     }
  908.     HX_RELEASE(pSDPData);
  909. #endif // HELIX_FEATURE_QUICKTIME
  911.     if (SUCCEEDED(retVal))
  912.     {
  913. m_pVideoFormat = CreateFormatObject(m_pHeader);
  915. retVal = HXR_OUTOFMEMORY;
  916. if (m_pVideoFormat)
  917. {
  918.     m_pVideoFormat->AddRef();
  919.     retVal = HXR_OK;
  920. }
  921.     }
  923.     if (SUCCEEDED(retVal))
  924.     {
  925. retVal = m_pVideoFormat->Init(pHeader);
  926.     }
  928.     if (SUCCEEDED(retVal))
  929.     {
  930. m_ulEarlyFrameTol = GetEarlyFrameTolerance();
  931. m_ulLateFrameTol = GetLateFrameTolerance();
  932. m_ulMaxOptimizedVideoLead = GetMaxOptimizedVideoLead();
  934. m_ulMaxSleepTime = GetMaxSleepTime();
  935. m_ulNoFramesPollingInterval = GetNoFramesPollingInterval();
  936. m_ulBltPacketQueueSize = GetBltPacketQueueSize();
  937. m_ulSyncGoalSmoothingDepth = GetSyncGoalSmoothingDepth();
  938. m_ulSpeedupGoalSmoothingDepth = GetSpeedupGoalSmoothingDepth();
  939. m_ulMaxBadSeqSamples = GetMaxBadSeqSamples();
  940.     }
  942.     // Setup preroll
  943.     if (SUCCEEDED(retVal))
  944.     {
  945. BOOL bSetNewPreroll = FALSE;
  946.         m_ulPreroll = 0;
  947. ULONG32 ulMinPreroll = m_pVideoFormat->GetMinimumPreroll(pHeader);
  948. ULONG32 ulMaxPreroll = m_pVideoFormat->GetMaximumPreroll(pHeader);
  950.         // Check that the stream header has a preroll value. If not...
  951. pHeader->GetPropertyULONG32("Preroll", m_ulPreroll);
  952. if (m_ulPreroll == 0)
  953. {
  954.             // ... let's use default value.
  955.     m_ulPreroll = m_pVideoFormat->GetDefaultPreroll(pHeader);
  956.     bSetNewPreroll = TRUE;
  957. }
  958.         else if( m_ulPreroll > ulMaxPreroll )
  959.         {
  960.             m_ulPreroll = ulMaxPreroll;
  961.     bSetNewPreroll = TRUE;
  962.         }
  963. else if (m_ulPreroll < ulMinPreroll)
  964. {
  965.     m_ulPreroll = ulMinPreroll;
  966.     bSetNewPreroll = TRUE;
  967. }
  969. if (bSetNewPreroll)
  970. {
  971.     pHeader->SetPropertyULONG32("Preroll", m_ulPreroll);
  972. }
  973.     }
  975.     // Determine Average Bitrate
  976.     if (SUCCEEDED(retVal))
  977.     {
  978. if (FAILED(pHeader->GetPropertyULONG32("AvgBitRate", m_ulAvgBitRate)))
  979. {
  980.     m_ulAvgBitRate = 0;
  981. }
  982.     }
  984.     // Create Blt Queue
  985.     if (SUCCEEDED(retVal))
  986.     {
  987. m_pBltPacketQueue = new CRingBuffer(m_ulBltPacketQueueSize);
  989. retVal = HXR_OUTOFMEMORY;
  990. if (m_pBltPacketQueue)
  991. {
  992.     retVal = HXR_OK;
  993. }
  994.     }
  996.     return retVal;
  997. }
  1000. /////////////////////////////////////////////////////////////////////////////
  1001. //  Method:
  1002. // CVideoRenderer::CheckStreamVersions
  1003. //  copied from CRealAudioRenderer
  1004. HX_RESULT CVideoRenderer::CheckStreamVersions(IHXValues* pHeader)
  1005. {
  1006.     // check stream and content versions so an upgrade can
  1007.     // be called if necessary...
  1008.     HX_RESULT pnr = HXR_OK;
  1010.     BOOL bVersionOK = TRUE;
  1012.     UINT32 ulStreamVersion = 0;
  1013.     UINT32 ulContentVersion = 0;
  1015.     if(HXR_OK == pHeader->GetPropertyULONG32("StreamVersion",
  1016. ulStreamVersion))
  1017.     {
  1018. UINT32 ulMajorVersion = HX_GET_MAJOR_VERSION(ulStreamVersion);
  1019. UINT32 ulMinorVersion = HX_GET_MINOR_VERSION(ulStreamVersion);
  1020. ULONG32 ulThisMajorVersion = 0;
  1021. ULONG32 ulThisMinorVersion = 0;
  1023. GetStreamVersion(ulThisMajorVersion, ulThisMinorVersion);
  1025. if((ulMajorVersion > ulThisMajorVersion) ||
  1026.    ((ulMinorVersion > ulThisMinorVersion) &&
  1027.     (ulMajorVersion == ulThisMajorVersion)))
  1028. {
  1029.     bVersionOK = FALSE;
  1030. }
  1031.     }
  1033.     if(bVersionOK &&
  1034.        (HXR_OK == pHeader->GetPropertyULONG32("ContentVersion",
  1035.       ulContentVersion)))
  1036.     {
  1037. UINT32 ulMajorVersion = HX_GET_MAJOR_VERSION(ulContentVersion);
  1038. UINT32 ulMinorVersion = HX_GET_MINOR_VERSION(ulContentVersion);
  1039. ULONG32 ulThisMajorVersion = 0;
  1040. ULONG32 ulThisMinorVersion = 0;
  1042. GetContentVersion(ulThisMajorVersion, ulThisMinorVersion);
  1044. if((ulMajorVersion > ulThisMajorVersion) ||
  1045.    ((ulMinorVersion > ulThisMinorVersion) &&
  1046.     (ulMajorVersion == ulMajorVersion)))
  1047. {
  1048.     bVersionOK = FALSE;
  1049. }
  1050.     }
  1052.     if(!bVersionOK)
  1053.     {
  1054.         AddToAutoUpgradeCollection(GetUpgradeMimeType(), m_pContext);
  1056. pnr = HXR_FAIL;
  1057.     }
  1059.     return pnr;
  1060. }
  1063. /////////////////////////////////////////////////////////////////////////
  1064. //  Method:
  1065. // IHXRenderer::OnPacket
  1066. //  Purpose:
  1067. // Called by client engine when a packet for this renderer is
  1068. // due.
  1069. //
  1070. STDMETHODIMP CVideoRenderer::OnPacket(IHXPacket* pPacket, LONG32 lTimeOffset)
  1071. {
  1072.     m_lTimeLineOffset = lTimeOffset;
  1074. #ifdef ENABLE_INPUT_TRACE
  1075.     if (ulInputTraceIdx < MAX_INPUT_TRACE_ENTRIES)
  1076.     {
  1077. inputTraceArray[ulInputTraceIdx++] =
  1078.     ComputeTimeAhead(pPacket->GetTime(), 0);
  1079.     }
  1080. #endif // ENABLE_INPUT_TRACE
  1082.     if (m_bSchedulerStartRequested)
  1083.     {
  1084. StartSchedulers();
  1085.     }
  1087.     BOOL bQueueRet = m_pVideoFormat->Enqueue(pPacket);
  1088.     if(bQueueRet == FALSE && m_pVideoFormat->GetLastError() == HXR_OUTOFMEMORY)
  1089.     {
  1090.         return HXR_OUTOFMEMORY;
  1091.     }
  1093.     // try to decode a frame
  1094.     if (m_PlayState == Playing)
  1095.     {
  1096. if (!IsDecoderRunning() || NULL == m_pDecoderPump)
  1097. {
  1098.     BOOL bDecRet = m_pVideoFormat->DecodeFrame();
  1099.             if( bDecRet == FALSE && m_pVideoFormat->GetLastError() == HXR_OUTOFMEMORY )
  1100.             {
  1101.                 return HXR_OUTOFMEMORY;
  1102.             }
  1103. }
  1104. else
  1105. {
  1106.     m_pDecoderPump->Signal();
  1107. }
  1108.     }
  1109.     else
  1110.     {
  1111. if (!m_bBaseTimeSet)
  1112. {
  1113.     m_pMutex->Lock();
  1114.     if (m_PlayState != Playing)
  1115.     {
  1116. m_ulBaseTime = pPacket->GetTime();
  1117.     }
  1118.     m_pMutex->Unlock();
  1119.     m_bBaseTimeSet = TRUE;
  1120. }
  1122. // If we are seeking, this is a pre-seek packet and there is
  1123. // no need to decode it
  1124. if (m_PlayState != Seeking)
  1125. {
  1126.     if (!IsDecoderRunning() || NULL == m_pDecoderPump)
  1127.     {
  1128. m_pVideoFormat->DecodeFrame();
  1129.     }
  1130.     else
  1131.     {
  1132. m_pDecoderPump->Signal();
  1133.     }
  1135.     if (m_PlayState == Buffering)
  1136.     {
  1137. if (IsBufferingComplete(pPacket))
  1138. {
  1139.     RequestBufferingEnd();
  1140. }
  1141.     }
  1142. }
  1143.     }
  1145.     return HXR_OK;
  1146. }
  1149. /////////////////////////////////////////////////////////////////////////
  1150. //  Method:
  1151. // IHXRenderer::OnTimeSync
  1152. //  Purpose:
  1153. // Called by client engine to inform the renderer of the current
  1154. // time relative to the streams synchronized time-line. The
  1155. // renderer should use this time value to update its display or
  1156. // render it's stream data accordingly.
  1157. //
  1158. STDMETHODIMP CVideoRenderer::OnTimeSync(ULONG32 ulTime)
  1159. {
  1160.     ULONG32 ulStreamBaseTime = HX_GET_BETTERTICKCOUNT();
  1161.     ULONG32 ulBaseTime = ulTime;
  1162.     BOOL bGoodSample = TRUE;
  1164.     if (m_bSchedulerStartRequested)
  1165.     {
  1166. StartSchedulers();
  1167.     }
  1169. #ifdef HELIX_FEATURE_STATS
  1170.     if (((ULONG32) (ulStreamBaseTime - m_pVideoStats->GetLastSyncTime())) >=
  1171. VIDEO_STAT_INTERVAL)
  1172.     {
  1173. m_pVideoStats->SyncStats(ulStreamBaseTime);
  1174.     }
  1175. #endif /* HELIX_FEATURE_STATS */
  1177. #ifdef ENABLE_SYNC_TRACE
  1178.     ULONG32 ulOrigStreamBaseTime = ulStreamBaseTime;
  1179. #endif // ENABLE_SYNC_TRACE
  1181. #ifdef SYNC_SMOOTHING_OLD_SCHEME
  1182.     LONG32 lNewSyncDelta = (LONG32) (ulStreamBaseTime - m_lTrendSyncDelta - ulTime);
  1183.     m_lTrendSyncDelta += lNewSyncDelta / ((LONG32) (m_ulSyncSmoothingDepth + 1));
  1185.     ulStreamBaseTime = ulTime + m_lTrendSyncDelta;
  1187.     if (m_ulSyncSmoothingDepth < m_ulSyncGoalSmoothingDepth)
  1188.     {
  1189. m_ulSyncSmoothingDepth++;
  1190.     }
  1191. #endif // SYNC_SMOOTHING_OLD_SCHEME
  1193. #ifdef SYNC_PRE_SMOOTHING
  1194.     if (m_ulSyncSmoothingDepth > 0)
  1195.     {
  1196. LONG32 lStreamBaseDelta = ((LONG32) (ulStreamBaseTime - m_ulStreamBaseTime));
  1197. ULONG32 ulBaseDelta = ulBaseTime - m_ulBaseTime;
  1198. BOOL bSkipSmoothing = FALSE;
  1200. bGoodSample = ((lStreamBaseDelta <= 0) ||
  1201.        (((ULONG32) lStreamBaseDelta) <=
  1202.         (ulBaseDelta + (ulBaseDelta >> AUDIO_SKEW_POWER))) ||
  1203.        (bSkipSmoothing = ((m_ulBadSeqSampleCount++) > m_ulMaxBadSeqSamples)));
  1205. if (bSkipSmoothing)
  1206. {
  1207.     m_ulSyncSmoothingDepth = 0;
  1208.     m_fTrendSyncDelta = 0.0;
  1209. }
  1210.     }
  1211. #endif // SYNC_PRE_SMOOTHING
  1213.     if (bGoodSample)
  1214.     {
  1215. #ifdef SYNC_SMOOTHING
  1216. double fNewSyncDelta = (((double) ((ULONG32) (ulStreamBaseTime - ulTime))) -
  1217.        m_fTrendSyncDelta);
  1219. // If we have a m_fTrendSyncDelta, make sure we consider
  1220. // m_fTrendSyncDelta wrap-around in relation to fNewSyncDelta
  1221. if (m_ulSyncSmoothingDepth > 0)
  1222. {
  1223.     if (fNewSyncDelta > MAX_LONG32_AS_DOUBLE)
  1224.     {
  1225. fNewSyncDelta = MAX_ULONG32_AS_DOUBLE - fNewSyncDelta;
  1226.     }
  1227.     else if (fNewSyncDelta < MIN_LONG32_AS_DOUBLE)
  1228.     {
  1229. fNewSyncDelta += MAX_ULONG32_AS_DOUBLE;
  1230.     }
  1231. }
  1233. if (fNewSyncDelta < 0.0)
  1234. {
  1235.     // We are trying to speed up: use speed up smoothing criteria
  1236.     m_fTrendSyncDelta += (fNewSyncDelta /
  1237.   ((m_ulSyncSmoothingDepth >= m_ulSpeedupGoalSmoothingDepth) ?
  1238.    m_ulSpeedupGoalSmoothingDepth + 1 : m_ulSyncSmoothingDepth + 1));
  1239. }
  1240. else
  1241. {
  1242.     m_fTrendSyncDelta += fNewSyncDelta / (m_ulSyncSmoothingDepth + 1);
  1243. }
  1245. if (m_fTrendSyncDelta > MAX_ULONG32_AS_DOUBLE)
  1246. {
  1247.     m_fTrendSyncDelta -= MAX_ULONG32_AS_DOUBLE;
  1248. }
  1249. else if (m_fTrendSyncDelta < 0)
  1250. {
  1251.      m_fTrendSyncDelta += MAX_ULONG32_AS_DOUBLE;
  1252. }
  1254. ulStreamBaseTime = ulTime + ((ULONG32) (m_fTrendSyncDelta));
  1256. if (m_ulSyncSmoothingDepth < m_ulSyncGoalSmoothingDepth)
  1257. {
  1258.     m_ulSyncSmoothingDepth++;
  1259. }
  1260. #endif // SYNC_SMOOTHING
  1262. m_ulGoodSeqSampleCount++;
  1264. m_ulStreamBaseTime = ulStreamBaseTime;
  1265. m_ulBaseTime = ulBaseTime;
  1266. m_ulTimeNormalizationOffset = m_ulStreamBaseTime -
  1267.       m_ulBaseTime -
  1268.       m_lTimeLineOffset;
  1270. if (m_ulGoodSeqSampleCount >= MIN_GOOD_PERSISTENCE_COUNT)
  1271. {
  1272.     m_ulBadSeqSampleCount = 0;
  1273. }
  1274.     }
  1275.     else
  1276.     {
  1277. // This is a bad sample
  1278. if (m_ulBadSeqSampleCount >= MIN_BAD_PERSISTENCE_COUNT)
  1279. {
  1280.     m_ulGoodSeqSampleCount = 0;
  1281. }
  1282.     }
  1284. #ifdef ENABLE_SYNC_TRACE
  1285.     if (ulSyncTraceIdx < MAX_SYNC_TRACE_ENTRIES)
  1286.     {
  1287. syncTraceArray[ulSyncTraceIdx][0] = m_ulBaseTime;
  1288. syncTraceArray[ulSyncTraceIdx][1] = m_ulStreamBaseTime;
  1289. syncTraceArray[ulSyncTraceIdx++][2] = ulOrigStreamBaseTime;
  1290.     }
  1291. #endif // ENABLE_SYNC_TRACE
  1293.     if (m_PlayState == Playing)
  1294.     {
  1295. if (!IsDecoderRunning())
  1296. {
  1297.     m_pVideoFormat->DecodeFrame();
  1298. }
  1300. if (m_bBufferingNeeded)
  1301. {
  1302.     m_pMutex->Lock();
  1304.     if (m_PlayState == Playing)
  1305.     {
  1306. BeginBuffering();
  1307.     }
  1309.     m_pMutex->Unlock();
  1310. }
  1311.     }
  1312.     else if ((m_PlayState == PlayStarting) ||
  1313.      (m_PlayState == Buffering))
  1314.     {
  1315. m_pMutex->Lock();
  1317. m_bBaseTimeSet = TRUE;
  1319. // Reset the offset to avoid race condition
  1320. // with m_ulTimeNormalizationOffset setting in OnPacket()
  1321. if (bGoodSample)
  1322. {
  1323.     m_ulTimeNormalizationOffset = m_ulStreamBaseTime -
  1324.   m_ulBaseTime -
  1325.   m_lTimeLineOffset;
  1326. }
  1328. if (m_PlayState == Buffering)
  1329. {
  1330.     EndBuffering();
  1331.     m_PlayState = PlayStarting;
  1332. }
  1334. if (m_PlayState == PlayStarting)
  1335. {
  1336.     m_PlayState = Playing;
  1338.     BltIfNeeded();
  1340.     StartSchedulers();
  1342.     if (m_pBltrPump)
  1343.     {
  1344. m_pBltrPump->Signal();
  1345.     }
  1346. }
  1348. m_pMutex->Unlock();
  1349.     }
  1351.     return HXR_OK;
  1352. }
  1355. HX_RESULT CVideoRenderer::StartSchedulers(void)
  1356. {
  1357.     HX_RESULT retVal = HXR_OK;
  1360. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  1362.     // When running the decoder as fast as possible, we dont want to start the scheduler, so short
  1364.     // circuit this code. Additionally, calls such as BltIfNeeded() and ScheduleCallback() (which
  1366.     // may still be called) make assumptions based on the state of our interactions with the
  1368.     // scheduler, so we satisfy them by setting a pending handle representing a nonexistant callback.
  1370.     if( m_bUntimedRendering )
  1372.     {
  1374. m_hPendingHandle = 1;
  1376. return HXR_OK;
  1378.     }
  1380. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  1383.     m_bSchedulerStartRequested = FALSE;
  1385.     DisplayMutex_Lock();
  1387.     if (ShouldKickStartScheduler())
  1388.     {
  1389. m_bBufferingNeeded = FALSE;
  1390. ScheduleCallback(0);
  1391.     }
  1393.     if (SUCCEEDED(retVal) && (m_pDecoderPump == NULL))
  1394.     {
  1395. CVideoPaceMaker* pVideoPaceMaker;
  1396. retVal = HXR_OUTOFMEMORY;
  1398. pVideoPaceMaker = new CVideoPaceMaker;
  1400. if (pVideoPaceMaker)
  1401. {
  1402.     retVal = pVideoPaceMaker->QueryInterface(
  1403. IID_IHXPaceMaker,
  1404. (void**) &m_pDecoderPump);
  1406.     if (SUCCEEDED(retVal))
  1407.     {
  1408. pVideoPaceMaker = NULL;
  1409. m_pDecoderPump->Start(this,
  1410.     GetDecodePriority(),
  1411.     DECODER_INTERVAL,
  1412.     m_ulDecoderPacemakerId);
  1413.     }
  1414. }
  1416. HX_DELETE(pVideoPaceMaker);
  1417.     }
  1419.     if (SUCCEEDED(retVal) && (m_pBltrPump == NULL) && m_bTryVideoSurface2)
  1420.     {
  1421. CVideoPaceMaker* pVideoPaceMaker;
  1422. retVal = HXR_OUTOFMEMORY;
  1424. pVideoPaceMaker = new CVideoPaceMaker;
  1426. if (pVideoPaceMaker)
  1427. {
  1428.     retVal = pVideoPaceMaker->QueryInterface(
  1429. IID_IHXPaceMaker,
  1430. (void**) &m_pBltrPump);
  1432.     if (SUCCEEDED(retVal))
  1433.     {
  1434. pVideoPaceMaker = NULL;
  1435. m_pBltrPump->Start(this,
  1436.     DFLT_PRESENT_PRIORITY,
  1437.     BLTR_INTERVAL,
  1438.     m_ulBltrPacemakerId);
  1439.     }
  1440. }
  1442. HX_DELETE(pVideoPaceMaker);
  1443.     }
  1445.     DisplayMutex_Unlock();
  1447.     return retVal;
  1448. }
  1451. /////////////////////////////////////////////////////////////////////////
  1452. //  Method:
  1453. // IHXRenderer::OnPreSeek
  1454. //  Purpose:
  1455. // Called by client engine to inform the renderer that a seek is
  1456. // about to occur. The render is informed the last time for the
  1457. // stream's time line before the seek, as well as the first new
  1458. // time for the stream's time line after the seek will be completed.
  1459. //
  1460. STDMETHODIMP CVideoRenderer::OnPreSeek(ULONG32 ulOldTime, ULONG32 ulNewTime)
  1461. {
  1462.     // Change state to stop Blts
  1463.     m_pMutex->Lock();
  1464.     m_PlayState = Seeking;
  1465.     m_pMutex->Unlock();
  1467.     // Suspend the Decoder pump
  1468.     if (m_pDecoderPump)
  1469.     {
  1470. m_pDecoderPump->Suspend(TRUE);
  1471. m_pDecoderPump->Signal();
  1472. m_pDecoderPump->WaitForSuspend();
  1473.     }
  1475.     // Wait for Blt in progress to complete and reset
  1476.     // packet queues
  1477.     DisplayMutex_Lock();
  1479.     m_pVideoFormat->SetStartTime(ulNewTime);
  1480.     m_pVideoFormat->Reset();
  1481. #if defined(HELIX_FEATURE_STATS)
  1482.     m_pVideoStats->ResetSequence();
  1483. #endif /* HELIX_FEATURE_STATS */
  1485.     m_bFirstSurfaceUpdate = TRUE;
  1486.     m_bFirstFrame = TRUE;
  1487.     m_bBaseTimeSet = FALSE;
  1489.     DisplayMutex_Unlock();
  1491.     return HXR_OK;
  1492. }
  1494. /////////////////////////////////////////////////////////////////////////
  1495. //  Method:
  1496. // IHXRenderer::OnPostSeek
  1497. //  Purpose:
  1498. // Called by client engine to inform the renderer that a seek has
  1499. // just occured. The render is informed the last time for the
  1500. // stream's time line before the seek, as well as the first new
  1501. // time for the stream's time line after the seek.
  1502. //
  1503. STDMETHODIMP CVideoRenderer::OnPostSeek(ULONG32 ulOldTime, ULONG32 ulNewTime)
  1504. {
  1505.     DisplayMutex_Lock();
  1507.     // clean up the packet lists
  1508.     m_pVideoFormat->SetStartTime(ulNewTime);
  1509.     m_pVideoFormat->Reset();
  1511. #if defined(HELIX_FEATURE_STATS)
  1512.     m_pVideoStats->ResetSequence();
  1513. #endif /* HELIX_FEATURE_STATS */
  1515.     m_bFirstSurfaceUpdate = TRUE;
  1516.     m_bFirstFrame = TRUE;
  1517.     m_ulBaseTime = ulNewTime;
  1518.     m_bBaseTimeSet = TRUE;
  1519.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  1521.     if (m_pDecoderPump)
  1522.     {
  1523. m_pDecoderPump->Suspend(FALSE);
  1524. m_pDecoderPump->Signal();
  1525.     }
  1527.     if (m_bUseVideoSurface2 && m_pMISUSSite)
  1528.     {
  1529. FlushVideoSurface2(m_pMISUSSite);
  1530.     }
  1532.     DisplayMutex_Unlock();
  1534.     // PostSeek signals the proper packets are to start arriving
  1535.     m_pMutex->Lock();
  1536.     m_PlayState = PlayStarting;
  1537.     m_pMutex->Unlock();
  1539.     return HXR_OK;
  1540. }
  1542. /////////////////////////////////////////////////////////////////////////
  1543. //  Method:
  1544. // IHXRenderer::OnPause
  1545. //  Purpose:
  1546. // Called by client engine to inform the renderer that a pause has
  1547. // just occured. The render is informed the last time for the
  1548. // stream's time line before the pause.
  1549. //
  1550. STDMETHODIMP CVideoRenderer::OnPause(ULONG32 ulTime)
  1551. {
  1552.     m_pMutex->Lock();
  1554.     m_PlayState = Paused;
  1556.     m_pMutex->Unlock();
  1558.     return HXR_OK;
  1559. }
  1561. /////////////////////////////////////////////////////////////////////////
  1562. //  Method:
  1563. // IHXRenderer::OnBegin
  1564. //  Purpose:
  1565. // Called by client engine to inform the renderer that a begin or
  1566. // resume has just occured. The render is informed the first time
  1567. // for the stream's time line after the resume.
  1568. //
  1569. STDMETHODIMP CVideoRenderer::OnBegin(ULONG32 ulTime)
  1570. {
  1571.     HX_RESULT retVal = HXR_OK;
  1573.     m_pMutex->Lock();
  1575.     m_bBufferingOccured = FALSE;
  1576.     // If we are seeking, PostSeek will notify us when the play
  1577.     // will be starting
  1578.     if (m_PlayState != Seeking)
  1579.     {
  1580. m_PlayState = PlayStarting;
  1581.     }
  1583.     // No need to clear the Blt Packet queue here since
  1584.     // The Refresh event will always clear it and clearing
  1585.     // it here would create a race condition on Blt Packet
  1586.     // Queue (ring buffer) read.
  1587.     // ClearBltPacketQueue();
  1588.     m_ulSyncSmoothingDepth = 0;
  1589.     m_ulBadSeqSampleCount = 0;
  1590.     m_ulGoodSeqSampleCount = 0;
  1591.     m_bIsScheduledCB = 0;
  1592.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  1594.     retVal = StartSchedulers();
  1596.     m_pMutex->Unlock();
  1598. #ifdef HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  1599.     if (m_pDecoderPump)
  1600.     {
  1601.        //m_pDecoderPump->Suspend(TRUE);
  1602.        //m_pDecoderPump->WaitForSuspend();  // Wait for decoder thread to start and suspends itself
  1603.        //m_pDecoderPump->Suspend(FALSE);
  1604.        m_pDecoderPump->Signal();   // Kick-out decoder pump from suspension
  1605.     }
  1606. #endif  // HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  1608.     return retVal;
  1609. }
  1611. /////////////////////////////////////////////////////////////////////////
  1612. //  Method:
  1613. // IHXRenderer::OnBuffering
  1614. //  Purpose:
  1615. // Called by client engine to inform the renderer that buffering
  1616. // of data is occuring. The render is informed of the reason for
  1617. // the buffering (start-up of stream, seek has occured, network
  1618. // congestion, etc.), as well as percentage complete of the
  1619. // buffering process.
  1620. //
  1621. STDMETHODIMP CVideoRenderer::OnBuffering(ULONG32 ulFlags, UINT16 unPercentComplete)
  1622. {
  1623.     HX_RESULT retVal = HXR_OK;
  1625.     m_pMutex->Lock();
  1627.     if (m_PlayState == Buffering)
  1628.     {
  1629. if (IsBufferingComplete())
  1630. {
  1631.     EndBuffering();
  1632. }
  1633.     }
  1634.     else if (m_PlayState == Playing)
  1635.     {
  1636. m_PlayState = PlayStarting;
  1637.     }
  1639.     m_pMutex->Unlock();
  1641.     return retVal;
  1642. }
  1644. /////////////////////////////////////////////////////////////////////////
  1645. //  Method:
  1646. // IHXRenderer::GetDisplayType
  1647. //  Purpose:
  1648. // Called by client engine to ask the renderer for it's preferred
  1649. // display type. When layout information is not present, the
  1650. // renderer will be asked for it's prefered display type. Depending
  1651. // on the display type a buffer of additional information may be
  1652. // needed. This buffer could contain information about preferred
  1653. // window size.
  1654. //
  1655. STDMETHODIMP CVideoRenderer::GetDisplayType(REF(HX_DISPLAY_TYPE) ulFlags,
  1656.    REF(IHXBuffer*) pBuffer)
  1657. {
  1658.     ulFlags = HX_DISPLAY_WINDOW |
  1659.       HX_DISPLAY_SUPPORTS_RESIZE |
  1660.       HX_DISPLAY_SUPPORTS_FULLSCREEN |
  1661.       HX_DISPLAY_SUPPORTS_VIDCONTROLS;
  1663.     return HXR_OK;
  1664. }
  1666. /************************************************************************
  1667. * Method:
  1668. *     IHXRenderer::OnEndofPackets
  1669. * Purpose:
  1670. *     Called by client engine to inform the renderer that all the
  1671. *     packets have been delivered. However, if the user seeks before
  1672. *     EndStream() is called, renderer may start getting packets again
  1673. *     and the client engine will eventually call this function again.
  1674. */
  1675. STDMETHODIMP CVideoRenderer::OnEndofPackets(void)
  1676. {
  1677.     if (m_pVideoFormat)
  1678.     {
  1679. m_pVideoFormat->OnRawPacketsEnded();
  1680.     }
  1682.     return HXR_OK;
  1683. }
  1686. /************************************************************************
  1687.  *  IHXStatistics Methods
  1688.  */
  1689. /************************************************************************
  1690.  *  InitializeStatistics
  1691.  */
  1692. #define MAX_STAT_ENTRY_PAIRS 32
  1693. STDMETHODIMP CVideoRenderer::InitializeStatistics(UINT32 ulRegistryID)
  1694. {
  1695.     BOOL bCodecNameKnown = FALSE;
  1696.     char* pValue = NULL;
  1697.     HX_RESULT retVal = HXR_UNEXPECTED;
  1699.     m_ulRegistryID = ulRegistryID;
  1701. #if defined(HELIX_FEATURE_STATS)
  1702.     if (m_pVideoStats)
  1703.     {
  1704. retVal = HXR_OK;
  1705.     }
  1707.     if (SUCCEEDED(retVal))
  1708.     {
  1709. pValue = (char*) GetCodecName();
  1710. if (pValue != NULL)
  1711. {
  1712.     ReportStat(VS_CODEC_NAME, pValue);
  1713.     bCodecNameKnown = TRUE;
  1714. }
  1715.     }
  1717.     if (SUCCEEDED(retVal))
  1718.     {
  1719. pValue = (char*) GetRendererName();
  1720. if (pValue != NULL)
  1721. {
  1722.     ReportStat(VS_REND_NAME, pValue);
  1723.     // If Codec name is unknown, use a more generic renderer name
  1724.     if (!bCodecNameKnown)
  1725.     {
  1726. ReportStat(VS_CODEC_NAME, pValue);
  1727.     }
  1728. }
  1729.     }
  1731.     if (SUCCEEDED(retVal))
  1732.     {
  1733. pValue = (char*) GetCodecFourCC();
  1734. if (pValue != NULL)
  1735. {
  1736.     ReportStat(VS_CODEC_4CC, pValue);
  1737. }
  1738.     }
  1740.     if (SUCCEEDED(retVal))
  1741.     {
  1742. ReportStat(VS_CURRENT_FRAMERATE, "0.0");
  1743. ReportStat(VS_FRAMES_DISPLAYED, "100.0");
  1744. ReportStat(VS_FRAMES_DROPPED, (INT32) 0);
  1745. ReportStat(VS_FRAMES_LOST, (INT32) 0);
  1746. ReportStat(VS_SURESTREAM, "FALSE");
  1747. ReportStat(VS_IMAGE_WIDTH, (INT32) 0);
  1748. ReportStat(VS_IMAGE_HEIGHT, (INT32) 0);
  1749.     }
  1751.     if (SUCCEEDED(retVal))
  1752.     {
  1753. InitExtraStats();
  1754.     }
  1756.     if (SUCCEEDED(retVal))
  1757.     {
  1758. retVal = m_pVideoStats->DisplayStats(m_ulRegistryID);
  1759.     }
  1761.     return retVal;
  1762. #else
  1763.     return HXR_NOTIMPL;
  1764. #endif /* HELIX_FEATURE_STATS */
  1765. }
  1767. /************************************************************************
  1768.  *  UpdateStatistics
  1769.  */
  1770. STDMETHODIMP CVideoRenderer::UpdateStatistics()
  1771. {
  1772. #if defined(HELIX_FEATURE_STATS)
  1773.     HX_RESULT retVal = HXR_UNEXPECTED;
  1775.     if (m_pVideoStats)
  1776.     {
  1777. retVal = HXR_OK;
  1778.     }
  1780.     if (SUCCEEDED(retVal))
  1781.     {
  1782. retVal = m_pVideoStats->DisplayStats(m_ulRegistryID);
  1783.     }
  1785.     return retVal;
  1786. #else
  1787.     return HXR_NOTIMPL;
  1788. #endif /* HELIX_FEATURE_STATS */
  1789. }
  1792. /************************************************************************
  1793.  *  IHXUntimedDecoder Methods
  1794.  */
  1795. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  1796. STDMETHODIMP_(BOOL) CVideoRenderer::IsUntimedRendering()
  1797. {
  1798.     return m_bUntimedRendering;
  1799. }
  1800. STDMETHODIMP_(HX_RESULT) CVideoRenderer::SetUntimedRendering(BOOL bUntimedRendering)
  1801. {
  1803.     if( m_PlayState != Stopped && m_PlayState != PlayStarting )
  1805.     {
  1807. return HXR_UNEXPECTED;
  1809.     }
  1812.     m_bUntimedRendering = bUntimedRendering;
  1815.     return HXR_OK;
  1816. }
  1817. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  1819. /************************************************************************
  1820.  *  IHXUpdateProperties Methods
  1821.  */
  1822. /************************************************************************
  1823.  *  UpdatePacketTimeOffset
  1824.  * Call this method to update the timestamp offset of cached packets
  1825.  */
  1826. STDMETHODIMP CVideoRenderer::UpdatePacketTimeOffset(INT32 lTimeOffset)
  1827. {
  1828.     m_lTimeLineOffset -= lTimeOffset;
  1830.     return HXR_OK;
  1831. }
  1834. /************************************************************************
  1835.  * Method:
  1836.  *     IHXUpdateProperties::UpdatePlayTimes
  1837.  * Purpose:
  1838.  *     Call this method to update the playtime attributes
  1839.  */
  1840. STDMETHODIMP
  1841. CVideoRenderer::UpdatePlayTimes(IHXValues* pProps)
  1842. {
  1843.     return HXR_OK;
  1844. }
  1847. /************************************************************************
  1848.  *  IHXRenderTimeLine Methods
  1849.  */
  1850. /************************************************************************
  1851.  *  GetTimeLineValue
  1852.  */
  1853. STDMETHODIMP CVideoRenderer::GetTimeLineValue(REF(UINT32) ulTime)
  1854. {
  1855.     ulTime = ((ULONG32) -ComputeTimeAhead(0, 0));
  1857.     if (m_PlayState != Playing)
  1858.     {
  1859.         return HXR_TIMELINE_SUSPENDED;
  1860.     }
  1862.     return HXR_OK;
  1863. }
  1866. /************************************************************************
  1867.  *  IHXSiteUser Methods
  1868.  */
  1869. /************************************************************************
  1870.  *  AttachSite
  1871.  */
  1872. STDMETHODIMP CVideoRenderer::AttachSite(IHXSite* /*IN*/ pSite)
  1873. {
  1874.     if (m_pMISUSSite)
  1875.     {
  1876. return HXR_UNEXPECTED;
  1877.     }
  1879.     m_bSiteAttached = TRUE;
  1881.     m_pMISUSSite = pSite;
  1882.     m_pMISUSSite->AddRef();
  1884.     // for sync
  1885.     IHXInterruptSafe* pIHXInterruptSafe = NULL;
  1887.     if (HXR_OK == m_pMISUSSite->QueryInterface(IID_IHXInterruptSafe,
  1888.        (void**)&pIHXInterruptSafe))
  1889.     {
  1890. // Get the pref to use the optimized scheduler or not
  1891. BOOL bUseOptimized = TRUE;
  1892. IHXBuffer* pPrefBuffer;
  1894. if( m_pPreferences &&
  1895.             m_pPreferences->ReadPref("UseOptimizedScheduler",
  1896. pPrefBuffer) == HXR_OK)
  1897. {
  1898.     bUseOptimized = *(pPrefBuffer->GetBuffer()) == '1';
  1899.     HX_RELEASE(pPrefBuffer);
  1900. }
  1902. if (pIHXInterruptSafe->IsInterruptSafe() && bUseOptimized)
  1903. {
  1904.     HX_RELEASE(m_pOptimizedScheduler);
  1905.     if (HXR_OK !=
  1906.     m_pContext->QueryInterface(IID_IHXOptimizedScheduler,
  1907.     (void **) &m_pOptimizedScheduler))
  1908.     {
  1909. // just for good luck
  1910. m_pOptimizedScheduler = NULL;
  1911.     }
  1912. }
  1913.     }
  1914.     HX_RELEASE(pIHXInterruptSafe);
  1916. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  1917.     // Get Run Configuration
  1918.     // Use of VideoSurface2
  1919.     if (m_pPreferences)
  1920.     {
  1921. ReadPrefBOOL(m_pPreferences, "VideoBoost\NoFlip", m_bTryVideoSurface2);
  1922.     }
  1924.     // Use of OS Granule Boosting
  1925.     if (m_pPreferences)
  1926.     {
  1927. ReadPrefBOOL(m_pPreferences, "VideoBoost\NoOSGranuleBoost", m_bOSGranuleBoost);
  1928. m_bOSGranuleBoostVS2 = m_bOSGranuleBoost;
  1929.     }
  1931.     // Hardware buffer count to request from VideoSurface2
  1932.     if (m_bTryVideoSurface2 && m_pPreferences)
  1933.     {
  1934. ReadPrefINT32(m_pPreferences, "VideoBoost\InitialHSCount", m_ulConfigHWBufCount);
  1935.     }
  1937. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  1939.     /*
  1940.      * This is the best time to set the size of the site, we
  1941.      * know for example the the header has already been received
  1942.      * at this point.
  1943.      *
  1944.      * In most display renderers, you will store size information
  1945.      * in your stream header. In this example, we assume a specific
  1946.      * size, but we will initialize that size here as if it had
  1947.      * come from our header.
  1948.      *
  1949.      */
  1950.     SetupBitmapDefaults(m_pHeader, m_BitmapInfoHeader);
  1951.     FormatAndSetViewFrame(m_pClipRect,
  1952.   m_BitmapInfoHeader,
  1953.   m_rViewRect);
  1955.     m_bBitmapSet = ((m_BitmapInfoHeader.biWidth > 0) &&
  1956.     (m_BitmapInfoHeader.biHeight > 0));
  1958.     return HXR_OK;
  1959. }
  1962. STDMETHODIMP
  1963. CVideoRenderer::DetachSite()
  1964. {
  1965.     m_bSiteAttached = FALSE;
  1967.     HX_RELEASE(m_pMISUSSite);
  1969.     // We're done with these...
  1970.     if (m_pMISUS)
  1971.     {
  1972. m_pMISUS->ReleaseSingleSiteUser();
  1973.     }
  1975.     HX_RELEASE(m_pMISUS);
  1977.     return HXR_OK;
  1978. }
  1980. STDMETHODIMP_(BOOL)
  1981. CVideoRenderer::NeedsWindowedSites()
  1982. {
  1983.     return FALSE;
  1984. };
  1986. STDMETHODIMP
  1987. CVideoRenderer::HandleEvent(HXxEvent* /*IN*/ pEvent)
  1988. {
  1989.     HX_RESULT retVal = HXR_OK;
  1991.     pEvent->handled = FALSE;
  1992.     pEvent->result  = 0;
  1994.     switch (pEvent->event)
  1995.     {
  1996.     case HX_SURFACE_UPDATE:
  1997. m_pVSMutex->Lock();
  1998. retVal = UpdateDisplay(pEvent, TRUE);
  1999. m_pVSMutex->Unlock();
  2000. break;
  2002. #if defined(HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO)
  2003.     case HX_SURFACE_MODE_CHANGE:
  2004. switch ((int) pEvent->param2)
  2005. {
  2006. case HX_VIDEOSURFACE1_RECOMMENDED:
  2007.     pEvent->result = SwitchToVideoSurface1();
  2009.     if (SUCCEEDED(pEvent->result))
  2010.     {
  2011. pEvent->handled = TRUE;
  2012.     }
  2013.     break;
  2015. case HX_VIDEOSURFACE1_NOT_RECOMMENDED:
  2016.     pEvent->result = SwitchToVideoSurface2();
  2018.     if (SUCCEEDED(pEvent->result))
  2019.     {
  2020. pEvent->handled = TRUE;
  2021.     }
  2022.     break;
  2024. default:
  2025.     HX_ASSERT(FALSE);
  2026.     break;
  2027. }
  2028. break;
  2029. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  2031.     default:
  2032. // nothing to do
  2033. break;
  2034.     }
  2036.     return retVal;
  2037. }
  2039. // *** IUnknown methods ***
  2041. /****************************************************************************
  2042. *  IUnknown::AddRef                                            ref:  hxcom.h
  2043. *
  2044. *  This routine increases the object reference count in a thread safe
  2045. *  manner. The reference count is used to manage the lifetime of an object.
  2046. *  This method must be explicitly called by the user whenever a new
  2047. *  reference to an object is used.
  2048. */
  2049. STDMETHODIMP_(ULONG32) CVideoRenderer::AddRef()
  2050. {
  2051.     return InterlockedIncrement(&m_lRefCount);
  2052. }
  2054. /****************************************************************************
  2055. *  IUnknown::Release                                           ref:  hxcom.h
  2056. *
  2057. *  This routine decreases the object reference count in a thread safe
  2058. *  manner, and deletes the object if no more references to it exist. It must
  2059. *  be called explicitly by the user whenever an object is no longer needed.
  2060. */
  2061. STDMETHODIMP_(ULONG32) CVideoRenderer::Release()
  2062. {
  2063.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2064.     {
  2065.         return m_lRefCount;
  2066.     }
  2068.     delete this;
  2069.     return 0;
  2070. }
  2072. /****************************************************************************
  2073. *  IUnknown::QueryInterface                                    ref:  hxcom.h
  2074. *
  2075. *  This routine indicates which interfaces this object supports. If a given
  2076. *  interface is supported, the object's reference count is incremented, and
  2077. *  a reference to that interface is returned. Otherwise a NULL object and
  2078. *  error code are returned. This method is called by other objects to
  2079. *  discover the functionality of this object.
  2080. */
  2081. STDMETHODIMP CVideoRenderer::QueryInterface(REFIID riid, void** ppvObj)
  2082. {
  2083.     QInterfaceList  qiList[] =
  2084.     {
  2085. { GET_IIDHANDLE(IID_IHXCallback), (IHXCallback*)this},
  2086. { GET_IIDHANDLE(IID_IHXInterruptSafe), (IHXInterruptSafe*)this},
  2087. { GET_IIDHANDLE(IID_IHXUpdateProperties), (IHXUpdateProperties*)this},
  2088. { GET_IIDHANDLE(IID_IHXRenderTimeLine), (IHXRenderTimeLine*)this},
  2090. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  2092. { GET_IIDHANDLE(IID_IHXUntimedRenderer), (IHXUntimedRenderer*)this},
  2094. #endif
  2096. { GET_IIDHANDLE(IID_IHXPaceMakerResponse), (IHXPaceMakerResponse*)this},
  2097. { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPlugin*) this},
  2098. { GET_IIDHANDLE(IID_IHXPlugin), (IHXPlugin*)this},
  2099. { GET_IIDHANDLE(IID_IHXRenderer), (IHXRenderer*)this},
  2100. { GET_IIDHANDLE(IID_IHXSiteUser), (IHXSiteUser*)this},
  2101. { GET_IIDHANDLE(IID_IHXStatistics), (IHXStatistics*)this},
  2102.     };
  2104.     if (QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj) == HXR_OK)
  2105.     {
  2106. return HXR_OK ;
  2107.     }
  2108.     else if (m_pMISUS && IsEqualIID(riid, IID_IHXSiteUserSupplier))
  2109.     {
  2110. return m_pMISUS->QueryInterface(IID_IHXSiteUserSupplier,ppvObj);
  2111.     }
  2112.     else
  2113.     {
  2114. *ppvObj = NULL;
  2115. return HXR_NOINTERFACE;
  2116.     }
  2117. }
  2120. /****************************************************************************
  2121.  *  Renderer's customizable fuctions - can be called any time
  2122.  */
  2123. /****************************************************************************
  2124.  *  GetStreamVersion
  2125.  */
  2126. void CVideoRenderer::GetStreamVersion(ULONG32 &ulThisMajorVersion,
  2127.       ULONG32 &ulThisMinorVersion)
  2128. {
  2129.     ulThisMajorVersion = STREAM_MAJOR_VERSION;
  2130.     ulThisMinorVersion = STREAM_MINOR_VERSION;
  2131. }
  2133. /****************************************************************************
  2134.  *  GetContentVersion
  2135.  */
  2136. void CVideoRenderer::GetContentVersion(ULONG32 &ulThisMajorVersion,
  2137.        ULONG32 &ulThisMinorVersion)
  2138. {
  2139.     ulThisMajorVersion = CONTENT_MAJOR_VERSION;
  2140.     ulThisMinorVersion = CONTENT_MINOR_VERSION;
  2141. }
  2143. /****************************************************************************
  2144.  *  GetUpgradeMimeType
  2145.  */
  2146. const char* CVideoRenderer::GetUpgradeMimeType(void)
  2147. {
  2148.     const char** pStreamMimeTypes = NULL;
  2149.     UINT32 ulInitialGranularity;
  2151.     GetRendererInfo(pStreamMimeTypes, ulInitialGranularity);
  2153.     if (pStreamMimeTypes)
  2154.     {
  2155. return pStreamMimeTypes[0];
  2156.     }
  2158.     return NULL;
  2159. }
  2161. /****************************************************************************
  2162.  *  GetRendererName
  2163.  */
  2164. const char* CVideoRenderer::GetRendererName(void)
  2165. {
  2166.     return BASE_VIDEO_RENDERER_NAME;
  2167. }
  2169. /****************************************************************************
  2170.  *  GetCodecName
  2171.  */
  2172. const char* CVideoRenderer::GetCodecName(void)
  2173. {
  2174.     return NULL;
  2175. }
  2177. /****************************************************************************
  2178.  *  GetCodecFourCC
  2179.  */
  2180. const char* CVideoRenderer::GetCodecFourCC(void)
  2181. {
  2182.     return NULL;
  2183. }
  2185. /****************************************************************************
  2186.  *  GetLateFrameTolerance
  2187.  */
  2188. ULONG32 CVideoRenderer::GetLateFrameTolerance(void)
  2189. {
  2190.     return LATE_FRAME_TOL;
  2191. }
  2193. /****************************************************************************
  2194.  *  GetEarlyFrameTolerance
  2195.  */
  2196. ULONG32 CVideoRenderer::GetEarlyFrameTolerance(void)
  2197. {
  2198.     return EARLY_FRAME_TOL;
  2199. }
  2201. /****************************************************************************
  2202.  *  GetMaxOptimizedVideoLead
  2203.  */
  2204. ULONG32 CVideoRenderer::GetMaxOptimizedVideoLead(void)
  2205. {
  2206.     return MAX_OPTIMIZED_VIDEO_LEAD;
  2207. }
  2209. /****************************************************************************
  2210.  *  GetBltPacketQueueSize
  2211.  */
  2212. ULONG32 CVideoRenderer::GetBltPacketQueueSize(void)
  2213. {
  2214.     ULONG32 ulSize = BLT_PACKET_QUEUE_SIZE;
  2216.     if (m_pVideoFormat)
  2217.     {
  2218. m_pVideoFormat->GetMaxDecodedFrames();
  2219.     }
  2221.     return ulSize;
  2222. }
  2224. /****************************************************************************
  2225.  *  GetSyncGoalSmoothingDepth
  2226.  */
  2227. ULONG32 CVideoRenderer::GetSyncGoalSmoothingDepth(void)
  2228. {
  2229.     return SYNC_GOAL_SMOOTHING_DEPTH;
  2230. }
  2232. /****************************************************************************
  2233.  *  GetSpeedupGoalSmoothingDepth
  2234.  */
  2235. ULONG32 CVideoRenderer::GetSpeedupGoalSmoothingDepth(void)
  2236. {
  2237.     return SPEEDUP_GOAL_SMOOTHING_DEPTH;
  2238. }
  2240. /****************************************************************************
  2241.  *  GetNoFramesPollingInterval
  2242.  */
  2243. ULONG32 CVideoRenderer::GetNoFramesPollingInterval(void)
  2244. {
  2245.     return NO_FRAMES_POLLING_INTERVAL;
  2246. }
  2248. /****************************************************************************
  2249.  *  GetMaxSleepTime
  2250.  */
  2251. ULONG32 CVideoRenderer::GetMaxSleepTime(void)
  2252. {
  2253.     return m_ulMaxSleepTime;
  2254. }
  2257. /****************************************************************************
  2258.  *  GetMaxSleepTime
  2259.  */
  2260. ULONG32 CVideoRenderer::GetMaxBadSeqSamples(void)
  2261. {
  2262.     return MAX_BAD_SAMPLE_INTERVAL / m_ulSyncInterval;
  2263. }
  2266. /****************************************************************************
  2267.  *  GetDecodePriority
  2268.  */
  2269. LONG32 CVideoRenderer::GetDecodePriority(void)
  2270. {
  2271.     return m_lDecodePriority;
  2272. }
  2275. HX_RESULT CVideoRenderer::SetDecodePriority(LONG32 lPriority)
  2276. {
  2277.     HX_RESULT retVal = HXR_OK;
  2279.     if (m_pDecoderPump)
  2280.     {
  2281. retVal = m_pDecoderPump->SetPriority(lPriority);
  2282.     }
  2284.     if (SUCCEEDED(retVal))
  2285.     {
  2286. m_lDecodePriority = lPriority;
  2287.     }
  2289.     return retVal;
  2290. }
  2293. /****************************************************************************
  2294.  *  CreateFormatObject
  2295.  */
  2296. CVideoFormat* CVideoRenderer::CreateFormatObject(IHXValues* pHeader)
  2297. {
  2298.     return new CVideoFormat(m_pCommonClassFactory,
  2299.     this);
  2300. }
  2302. /****************************************************************************
  2303.  *  SetupBitmapDefaults
  2304.  */
  2305. void CVideoRenderer::SetupBitmapDefaults(IHXValues* pHeader,
  2306.    HXBitmapInfoHeader &bitmapInfoHeader)
  2307. {
  2308.     // size calculation is taken from crvvideo
  2309.     bitmapInfoHeader.biSize = sizeof (HXBitmapInfoHeader);
  2310.     bitmapInfoHeader.biWidth = 0; // 352; // unknown
  2311.     bitmapInfoHeader.biHeight = 0; // 288; // unknown
  2312.     bitmapInfoHeader.biPlanes = 1;
  2313.     bitmapInfoHeader.biBitCount = 24;
  2314.     bitmapInfoHeader.biCompression = HX_I420;
  2315.     bitmapInfoHeader.biSizeImage = bitmapInfoHeader.biWidth *
  2316.      bitmapInfoHeader.biHeight *
  2317.      bitmapInfoHeader.biBitCount /
  2318.      8;
  2319.     bitmapInfoHeader.biXPelsPerMeter = 0;
  2320.     bitmapInfoHeader.biYPelsPerMeter = 0;
  2321.     bitmapInfoHeader.biClrUsed = 0;
  2322.     bitmapInfoHeader.biClrImportant = 0;
  2323.     bitmapInfoHeader.rcolor = 0;
  2324.     bitmapInfoHeader.gcolor = 0;
  2325.     bitmapInfoHeader.bcolor = 0;
  2326. }
  2328. /****************************************************************************
  2329.  *  FormatAndSetViewFrame
  2330.  */
  2331. void CVideoRenderer::FormatAndSetViewFrame(HXxRect* pClipRect,
  2332.    HXBitmapInfoHeader &bitmapInfoHeader,
  2333.    HXxRect &rViewRect,
  2334.    BOOL bMutex)
  2335. {
  2336.     BOOL bAsDefault = TRUE;
  2337.     HXxSize szViewFrame;
  2339.     if (bMutex)
  2340.     {
  2341. DisplayMutex_Lock();
  2342.     }
  2344.     if (pClipRect)
  2345.     {
  2346. rViewRect = *pClipRect;
  2348. // Insure the ViewRect is inside the bitmap Rect
  2349. // Clip x
  2350. rViewRect.left = (rViewRect.left > 0) ?
  2351.     rViewRect.left : 0;
  2352. rViewRect.right = (rViewRect.right > 0) ?
  2353.     rViewRect.right : 0;
  2354. rViewRect.left = (rViewRect.left < bitmapInfoHeader.biWidth) ?
  2355.     rViewRect.left : bitmapInfoHeader.biWidth;
  2356. rViewRect.right = (rViewRect.right < bitmapInfoHeader.biWidth) ?
  2357.     rViewRect.right : bitmapInfoHeader.biWidth;
  2359. // Clip y
  2360. rViewRect.top = (rViewRect.top > 0) ?
  2361.     rViewRect.top : 0;
  2362. rViewRect.bottom = (rViewRect.bottom > 0) ?
  2363.     rViewRect.bottom : 0;
  2364. rViewRect.top = (rViewRect.top < bitmapInfoHeader.biHeight) ?
  2365.     rViewRect.top : bitmapInfoHeader.biHeight;
  2366. rViewRect.bottom = (rViewRect.bottom < bitmapInfoHeader.biHeight) ?
  2367.     rViewRect.bottom : bitmapInfoHeader.biHeight;
  2368.     }
  2369.     else
  2370.     {
  2371. rViewRect.left = 0;
  2372. rViewRect.top = 0;
  2373. rViewRect.right = bitmapInfoHeader.biWidth;
  2374. rViewRect.bottom = bitmapInfoHeader.biHeight;
  2375.     }
  2377.     // Compute Size
  2378.     szViewFrame.cx = rViewRect.right - rViewRect.left;
  2379.     szViewFrame.cy = rViewRect.bottom - rViewRect.top;
  2381.     if ((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0))
  2382.     {
  2383. if (m_pClipRect)
  2384. {
  2385.     szViewFrame.cx = m_pClipRect->right - m_pClipRect->left;
  2386.     szViewFrame.cy = m_pClipRect->bottom - m_pClipRect->top;
  2387. }
  2389. if ((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0))
  2390. {
  2391.     szViewFrame.cx = DEFAULT_WIN_SIZE_X;
  2392.     szViewFrame.cy = DEFAULT_WIN_SIZE_Y;
  2393. }
  2394.     }
  2396.     if (m_pClipRect)
  2397.     {
  2398. bAsDefault = FALSE;
  2399.     }
  2401.     _ResizeViewFrame(szViewFrame, FALSE, TRUE, bAsDefault);
  2403.     if (bMutex)
  2404.     {
  2405. DisplayMutex_Unlock();
  2406.     }
  2407. }
  2410. /****************************************************************************
  2411.  *  ResizeViewFrame
  2412.  */
  2413. BOOL CVideoRenderer::ResizeViewFrame(HXxSize szViewFrame,
  2414.      BOOL bMutex)
  2415. {
  2416.     HX_RESULT retVal;
  2418.     retVal = _ResizeViewFrame(szViewFrame,
  2419.       bMutex,
  2420.       FALSE,
  2421.       FALSE);
  2423.     return retVal;
  2424. }
  2426. BOOL CVideoRenderer::_ResizeViewFrame(HXxSize szViewFrame,
  2427.       BOOL bMutex,
  2428.       BOOL bForceSyncResize,
  2429.       BOOL bAsDefault)
  2430. {
  2431.     BOOL bRetVal = FALSE;
  2433.     if (m_bFrameSizeInitialized)
  2434.     {
  2435. return bRetVal;
  2436.     }
  2438.     if (bMutex)
  2439.     {
  2440. DisplayMutex_Lock();
  2441.     }
  2443.     if (!m_bFrameSizeInitialized)
  2444.     {
  2445. // If window size is already set, ignore further attempts to
  2446. // resize
  2447. if (m_bWinSizeFixed)
  2448. {
  2449.     szViewFrame.cx = m_SetWinSize.cx;
  2450.     szViewFrame.cy = m_SetWinSize.cy;
  2451. }
  2453. // If resulting size invalid, default to cliprect or bitmap size
  2454. if ((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0))
  2455. {
  2456.     if (((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0)) &&
  2457. m_pClipRect)
  2458.     {
  2459. szViewFrame.cx = m_pClipRect->right - m_pClipRect->left;
  2460. szViewFrame.cy = m_pClipRect->bottom - m_pClipRect->top;
  2461.     }
  2463.     if ((szViewFrame.cx <= 0) || (szViewFrame.cy <= 0))
  2464.     {
  2465. szViewFrame.cx = m_BitmapInfoHeader.biWidth;
  2466. szViewFrame.cy = m_BitmapInfoHeader.biHeight;
  2467.     }
  2468. }
  2470. m_SetWinSize.cx = szViewFrame.cx;
  2471. m_SetWinSize.cy = szViewFrame.cy;
  2473. #if !defined(HELIX_FEATURE_VIDREND_DYNAMIC_RESIZE)
  2474. m_bWinSizeFixed = (m_bWinSizeFixed || (!bAsDefault));
  2475. #else
  2476.         HX_ASSERT(!m_bWinSizeFixed);
  2477. #endif
  2479. #ifdef RESIZE_AFTER_SITE_ATTACHED
  2480. if (m_bSiteAttached)
  2481. #endif // RESIZE_AFTER_SITE_ATTACHED
  2482. {
  2483. #ifdef SET_NONZERO_VIEWFRAME_ONLY
  2484.     if ((szViewFrame.cx > 0) && (szViewFrame.cy > 0))
  2485. #endif // SET_NONZERO_VIEWFRAME_ONLY
  2486.     {
  2487. #ifdef SYNC_RESIZE_OK
  2488. bForceSyncResize = TRUE;
  2489. #endif // SYNC_RESIZE_OK
  2491. if ((m_LastSetSize.cx != szViewFrame.cx) ||
  2492.     (m_LastSetSize.cy != szViewFrame.cy))
  2493. {
  2494.     m_LastSetSize = szViewFrame;
  2496.     if (bForceSyncResize)
  2497.     {
  2498. m_pMISUSSite->SetSize(szViewFrame);
  2499.     }
  2500.     else
  2501.     {
  2502. if (m_pResizeCB == NULL)
  2503. {
  2504.     m_pResizeCB = new CSetSizeCB(m_pMISUSSite);
  2506.     HX_ASSERT(m_pResizeCB);
  2508.     if (m_pResizeCB)
  2509.     {
  2510. m_pResizeCB->AddRef();
  2511.     }
  2512. }
  2514. if (m_pResizeCB)
  2515. {
  2516.     m_pResizeCB->SetSize(szViewFrame);
  2518.     HX_ASSERT(m_pScheduler);
  2520.     if (m_pScheduler)
  2521.     {
  2522. m_pScheduler->RelativeEnter(m_pResizeCB, 0);
  2523.     }
  2524. }
  2525.     }
  2526. }
  2527.     }
  2529.     // Once the the frame size is initialized, it is no longer
  2530.     // changable by the renderer.
  2531.     // The frame size can become initialzied only of the window
  2532.     // size is fixed. It can become fixed only if explicitly set
  2533.     // by non-default mode call to ResizeViewFrame.  ResizeViewFrame
  2534.     // can be called in non-default mode by either the video format
  2535.     // or the call can be made internally based on meta-header
  2536.     // specified information (e.g. clip rect.)
  2537.     if (m_bWinSizeFixed)
  2538.     {
  2539. m_bFrameSizeInitialized = TRUE;
  2540. bRetVal = TRUE;
  2541.     }
  2542. }
  2543.     }
  2545.     if (bMutex)
  2546.     {
  2547. DisplayMutex_Unlock();
  2548.     }
  2550.     return bRetVal;
  2551. }
  2554. /****************************************************************************
  2555.  *  SetSyncInterval
  2556.  */
  2557. void CVideoRenderer::SetSyncInterval(ULONG32 ulSyncInterval)
  2558. {
  2559.     if (ulSyncInterval != 0)
  2560.     {
  2561. m_ulSyncInterval = ulSyncInterval;
  2562.     }
  2563. }
  2566. /****************************************************************************
  2567.  *  InitExtraStats
  2568.  */
  2569. HX_RESULT CVideoRenderer::InitExtraStats(void)
  2570. {
  2571.     return HXR_OK;
  2572. }
  2575. /****************************************************************************
  2576.  *  Method:
  2577.  *    CVideoFormat::AdjustVideoMapping
  2578.  *
  2579.  */
  2580. void CVideoRenderer::AdjustVideoMapping(HXxRect &destRect,
  2581. HXxRect &sorcRect,
  2582. CMediaPacket*pActiveVideoPacket)
  2583. {
  2584.     return;
  2585. }
  2587. /****************************************************************************
  2588.  *  Renderer's private fuctions
  2589.  */
  2590. BOOL CVideoRenderer::ForceRefresh(void)
  2591. {
  2592.     BOOL bIsVisible;
  2594.     // Ask what the size was really set to!
  2595.     HXxSize finalSize;
  2596.     m_pMISUSSite->GetSize(finalSize);
  2598.     /* We now damage the entire rect all the time             */
  2599.     HXxRect damageRect = {0, 0, finalSize.cx, finalSize.cy};
  2601.     // Mark associated screen area as damaged as well...
  2602.     m_pMISUSSite->DamageRect(damageRect);
  2604.     HX_ASSERT(!m_bPendingRedraw);
  2605.     HX_ASSERT(!m_bVS1UpdateInProgress);
  2607.     m_bPendingRedraw = TRUE;
  2608.     m_bVS1UpdateInProgress = TRUE;
  2610.     m_pVSMutex->Unlock();
  2611.     m_pMISUSSite->ForceRedraw();
  2612.     m_pVSMutex->Lock();
  2613.     m_bVS1UpdateInProgress = FALSE;
  2615.     // If the redraw is still pending, it did not occur so assume the
  2616.     // surface is invisible
  2617.     bIsVisible = !m_bPendingRedraw;
  2618.     m_bPendingRedraw = FALSE;
  2620.     return bIsVisible;
  2621. }
  2623. HX_RESULT CVideoRenderer::UpdateDisplay(HXxEvent* pEvent,
  2624. BOOL bSystemEvent,
  2625. BOOL bIsVisible)
  2626. {
  2627.     IHXVideoSurface* pVideoSurface;
  2628.     CMediaPacket* pTmpPacket;
  2629.     CMediaPacket* pVideoPacket = NULL;
  2630.     BOOL bBitmapFormatChanged = FALSE;
  2631.     BOOL bNewFrameBlt = FALSE;
  2632.     HXxSize windowSize = {0, 0};
  2633.     LONG32 lFramesInBuffer;
  2634.     HX_RESULT retVal = HXR_OK;
  2636.     if (m_bVS1UpdateInProgress && m_bUseVideoSurface2)
  2637.     {
  2638. // Ignore update for incorrect surface
  2639. return HXR_OK;
  2640.     }
  2642.     lFramesInBuffer = m_pBltPacketQueue->Count();
  2644.     m_bPendingRedraw = FALSE;
  2646.     HX_TRACE_THINGY("C:/trace.txt", "Handle", m_hPendingHandle);
  2648.     if (!m_bUseVideoSurface2 || !bSystemEvent)
  2649.     {
  2650. do
  2651. {
  2652.     pVideoPacket = (CMediaPacket*) m_pBltPacketQueue->Get();
  2653.     lFramesInBuffer--;
  2656.     if ((lFramesInBuffer <= 0) ||
  2657. (!m_pVideoFormat->IsFrameSkippable(pVideoPacket)))
  2658.     {
  2659. bNewFrameBlt = TRUE;
  2660. break;
  2661.     }
  2663. #if defined(HELIX_FEATURE_STATS)
  2664.     m_pVideoStats->ReportDroppedFrame();
  2665. #endif /* HELIX_FEATURE_STATS */
  2667.     ReleasePacket(pVideoPacket);
  2668. } while (TRUE);
  2669.     }
  2671.     pVideoSurface = (IHXVideoSurface*) (pEvent->param1);
  2673.     if (pVideoPacket)
  2674.     {
  2675. if (m_bVS2BufferUnavailableOnLastBlt &&
  2676.     m_pActiveVideoPacket)
  2677. {
  2678.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  2679. #if defined(HELIX_FEATURE_STATS)
  2680.     m_pVideoStats->ReportDroppedFrame();
  2681. #endif /* HELIX_FEATURE_STATS */
  2682. }
  2684. pTmpPacket = pVideoPacket;
  2685. pVideoPacket = m_pActiveVideoPacket;
  2686. m_pActiveVideoPacket = pTmpPacket;
  2687. m_ulActiveVideoTime = pTmpPacket->m_ulTime;
  2689. bBitmapFormatChanged = (m_pActiveVideoPacket->m_pSampleDesc &&
  2690. m_pVideoFormat->IsBitmapFormatChanged(
  2691. m_BitmapInfoHeader,
  2692. m_pActiveVideoPacket));
  2693.     }
  2695.     if (((!m_bVideoSurfaceInitialized) && m_pActiveVideoPacket) ||
  2696. m_bVideoSurfaceReinitRequested ||
  2697. bBitmapFormatChanged)
  2698.     {
  2699. BOOL bUsedVideoSurface2 = m_bUseVideoSurface2;
  2701. if (bBitmapFormatChanged)
  2702. {
  2703.     m_pVideoFormat->InitBitmapInfoHeader(m_BitmapInfoHeader,
  2704.  m_pActiveVideoPacket);
  2705.     m_bBitmapSet = TRUE;
  2706.     m_bVideoSurfaceInitialized = FALSE; // Force full reinit
  2707. }
  2709. FormatAndSetViewFrame(m_pClipRect,
  2710.       m_BitmapInfoHeader,
  2711.       m_rViewRect,
  2712.       FALSE);
  2714. HX_ASSERT(m_bBitmapSet);
  2716. // If we do not have information on the bitmap configuration or if
  2717. // we do not have surface to cofigure - do not intialize
  2718. if (m_bBitmapSet && pVideoSurface)
  2719. {
  2720.     // Try VideoSurface2 first unless not desired
  2721.     if (m_bTryVideoSurface2 && (!m_bVideoSurface1Requested))
  2722.     {
  2723. InitVideoSurface2(m_SetWinSize.cx, m_SetWinSize.cy);
  2724.     }
  2726.     // Try VideoSurface1 if prefered or if VideoSurface2 would
  2727.     // not initialize
  2728.     if ((!m_bUseVideoSurface2) || m_bVideoSurface1Requested)
  2729.     {
  2730. // Video Surface1 must be used
  2731. InitVideoSurface1(bUsedVideoSurface2, pVideoSurface);
  2732.     }
  2734.     m_bVideoSurfaceInitialized = TRUE;
  2735.     m_bVideoSurfaceReinitRequested = FALSE;
  2737.     m_bSchedulerStartRequested = TRUE;
  2740.     // Force the cycle in the decoder pump to expedite the completion
  2741.     // of the scheduler start request.
  2742.     if (IsDecoderRunning())
  2743.     {
  2744. if (m_pDecoderPump)
  2745. {
  2746.     m_pDecoderPump->Signal();
  2747. }
  2748.     }
  2750. #if defined(HELIX_FEATURE_STATS)
  2751.     ReportStat(VS_IMAGE_WIDTH, (INT32) (m_rViewRect.right - m_rViewRect.left));
  2752.     ReportStat(VS_IMAGE_HEIGHT, (INT32) (m_rViewRect.bottom - m_rViewRect.top));
  2753. #endif /* #if defined(HELIX_FEATURE_STATS) */
  2754. }
  2756.         // Now that we have the video dimensions, check to see that this clip
  2757.         // is not going to be too taxing on the poor CPU.
  2758.         UINT32 ulMaxVidWidth = 0;
  2759.         UINT32 ulMaxVidHeight = 0;
  2760.         if( m_pPreferences && 
  2761.             ( HXR_OK == ReadPrefINT32( m_pPreferences, "MaxVideoWidth", ulMaxVidWidth ) ) &&
  2762.             ( HXR_OK == ReadPrefINT32( m_pPreferences, "MaxVideoHeight", ulMaxVidHeight ) ) )
  2763.         {
  2764.             ULONG32 ulMaxVidArea = ulMaxVidWidth * ulMaxVidHeight;
  2765.             INT32 nWidth = (INT32) (m_rViewRect.right - m_rViewRect.left);
  2766.             INT32 nHeight = (INT32) (m_rViewRect.bottom - m_rViewRect.top);
  2767.             if( (ULONG32)(nWidth*nHeight) > ulMaxVidArea )
  2768.             {
  2769.                 IHXErrorMessages * pErrMsg = NULL;
  2770.                 m_pContext->QueryInterface(IID_IHXErrorMessages, (void**)&pErrMsg);
  2771.                 if( pErrMsg )
  2772.                 {
  2773.                     pErrMsg->Report(HXLOG_ERR, HXR_SLOW_MACHINE, 0, NULL, NULL);
  2774.                     HX_RELEASE(pErrMsg);
  2775.                 }
  2776.             }
  2777.         }
  2778.     }
  2779.     
  2780.     if (m_pActiveVideoPacket && bIsVisible && pVideoSurface)
  2781.     {
  2782. HX_ASSERT(m_bVideoSurfaceInitialized);
  2784. if (m_bVideoSurfaceInitialized && m_pActiveVideoPacket->m_pData)
  2785. {
  2786. #ifdef DEFAULT_VS2_TARGETRECT
  2787.     if (!m_bUseVideoSurface2)
  2788. #endif // DEFAULT_VS2_TARGETRECT
  2789.     {
  2790. m_pMISUSSite->GetSize(windowSize);
  2791.     }
  2793.     HXxRect rDestRect = { 0, 0, windowSize.cx, windowSize.cy };
  2794.     HXxRect rSrcRect = m_rViewRect;
  2796.     AdjustVideoMapping(rDestRect, rSrcRect, m_pActiveVideoPacket);
  2798.     if (m_bUseVideoSurface2)
  2799.     {
  2800. pEvent->result = UpdateVideoSurface2(pVideoSurface,
  2801.      rDestRect,
  2802.      rSrcRect,
  2803.      !bNewFrameBlt,
  2804.      bSystemEvent);
  2806. if (pEvent->result == HXR_ABORT)
  2807. {
  2808.     pEvent->result = HXR_OK;
  2809.     retVal = HXR_ABORT;
  2810. }
  2811.     }
  2812.     else if (bSystemEvent)
  2813.     {
  2814. pEvent->result = UpdateVideoSurface(pVideoSurface,
  2815.     m_pActiveVideoPacket,
  2816.     rDestRect,
  2817.     rSrcRect,
  2818.     m_bOptimizedBlt);
  2820. if (FAILED(pEvent->result))
  2821. {
  2822.     if (m_bVideoSurfaceReinitRequested)
  2823.     {
  2824. HX_ASSERT(!m_bVideoSurface1Requested);
  2826. InitVideoSurface2(m_SetWinSize.cx, m_SetWinSize.cy);
  2828. if (m_bUseVideoSurface2)
  2829. {
  2830.     m_bVideoSurfaceInitialized = TRUE;
  2831.     m_bVideoSurfaceReinitRequested = FALSE;
  2833.     pEvent->result = UpdateVideoSurface2(pVideoSurface,
  2834.  rDestRect,
  2835.  rSrcRect,
  2836.  FALSE,
  2837.  bSystemEvent);
  2839.     if (pEvent->result == HXR_ABORT)
  2840.     {
  2841. pEvent->result = HXR_OK;
  2842.     }
  2843. }
  2844.     }
  2845.     else
  2846.     {
  2847. InitVideoSurface1(FALSE, pVideoSurface);
  2849. pEvent->result = UpdateVideoSurface(pVideoSurface,
  2850.     m_pActiveVideoPacket,
  2851.     rDestRect,
  2852.     rSrcRect,
  2853.     m_bOptimizedBlt);
  2854.     }
  2855. }
  2856.     }
  2857.     else
  2858.     {
  2859. // This is not a system event and this call is not under
  2860. // the protection of the top level site (TLS) mutex and
  2861. // it needs to be.
  2862. // Bring it under the TLS mutex protection by envoking
  2863. // forced refresh
  2864. bIsVisible = ForceRefresh();
  2866. pEvent->result = HXR_OK;
  2867. retVal = HXR_ABORT;
  2868.     }
  2870.     if (bNewFrameBlt && bIsVisible)
  2871.     {
  2872. #if defined(HELIX_FEATURE_STATS)
  2873. if (pEvent->result == HXR_OK)
  2874. {
  2875.     m_pVideoStats->ReportBlt(m_pActiveVideoPacket->m_ulTime);
  2876. }
  2877. else if (!m_bVS2BufferUnavailableOnLastBlt)
  2878. {
  2879.     // If buffer wasn't available, we'll try again
  2880.     m_pVideoStats->ReportDroppedFrame();
  2881. }
  2882. #endif /* HELIX_FEATURE_STATS */
  2883.     }
  2884. }
  2885.     }
  2887.     if (pVideoPacket)
  2888.     {
  2889. ReleasePacket(pVideoPacket, m_bActiveVideoPacketLocalized);
  2890. m_bActiveVideoPacketLocalized = FALSE;
  2891.     }
  2893.     pEvent->handled = TRUE;
  2895.     return retVal;
  2896. }
  2898. HX_RESULT CVideoRenderer::UpdateVideoSurface(IHXVideoSurface* pVideoSurface,
  2899.      CMediaPacket* pVideoPacket,
  2900.      HXxRect &destRect,
  2901.      HXxRect &sorcRect,
  2902.      BOOL bOptimizedBlt)
  2903. {
  2904.     HX_RESULT retVal;
  2906.     if (bOptimizedBlt)
  2907.     {
  2908. retVal = pVideoSurface->OptimizedBlt(
  2909.     pVideoPacket->m_pData,
  2910.     destRect,
  2911.     sorcRect);
  2912.     }
  2913.     else
  2914.     {
  2915. retVal = pVideoSurface->Blt(
  2916.     pVideoPacket->m_pData,
  2917.     &m_BitmapInfoHeader,
  2918.     destRect,
  2919.     sorcRect);
  2920.     }
  2922.     return retVal;
  2923. }
  2926. HX_RESULT CVideoRenderer::InitVideoSurface1(BOOL bUsedVideoSurface2,
  2927.     IHXVideoSurface* pVideoSurface)
  2928. {
  2929.     HX_RESULT retVal = HXR_OK;
  2931.     if (bUsedVideoSurface2)
  2932.     {
  2933. OffOptimizedVideo();
  2934.     }
  2936.     /***
  2937.     if (pVideoSurface)
  2938.     {
  2939. retVal = pVideoSurface->EndOptimizedBlt();
  2940.     }
  2941.     else
  2942.     {
  2943. EndOptimizedBlt();
  2944.     }
  2945.     ***/
  2947.     // Video Surface1 is needed - try optimized Blt setup
  2948.     if (!m_bVideoSurfaceInitialized)
  2949.     {
  2950. if (pVideoSurface)
  2951. {
  2952.     retVal = pVideoSurface->BeginOptimizedBlt(&m_BitmapInfoHeader);
  2953. }
  2954. else
  2955. {
  2956.     retVal = BeginOptimizedBlt(&m_BitmapInfoHeader);
  2957. }
  2959. if (SUCCEEDED(retVal))
  2960. {
  2961.     m_bOptimizedBlt = TRUE;
  2962. }
  2963. else
  2964. {
  2965.     m_bOptimizedBlt = FALSE;
  2966. }
  2968. retVal = HXR_OK;
  2969.     }
  2971.     if (SUCCEEDED(retVal))
  2972.     {
  2973. m_ulEarlyFrameTol = GetEarlyFrameTolerance();
  2974. HX_DELETE(m_pVSurf2InputBIH);
  2975. m_bUseVideoSurface2 = FALSE;
  2976. if (m_bVS2BufferUnavailableOnLastBlt)
  2977. {
  2978. #if defined(HELIX_FEATURE_STATS)
  2979.     m_pVideoStats->ReportDroppedFrame();
  2980. #endif /* HELIX_FEATURE_STATS */
  2981.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  2982. }
  2983.     }
  2985.     return retVal;
  2986. }
  2989. inline BOOL CVideoRenderer::ShouldKickStartScheduler()
  2990. {
  2991.     BOOL bShouldStart;
  2993.     bShouldStart = (!m_bPendingCallback && !m_bUseVideoSurface2);
  2995.     return bShouldStart;
  2996. }
  2999. HX_RESULT CVideoRenderer::ScheduleCallback(UINT32 ulRelativeTime,
  3000.    BOOL bIsScheduled,
  3001.    UINT32 ulBaseTime)
  3002. {
  3003.     IHXCallback* pCallback = (IHXCallback*) this;
  3004.     CallbackHandle hPendingHandle;
  3005.     ULONG32 ulThisCallbackCount;
  3007.     if (m_hPendingHandle == (CallbackHandle)NULL)
  3008.     {
  3009. m_bPendingCallback = TRUE;
  3010. m_ulCallbackCounter++;
  3011. if (m_ulCallbackCounter == 0)
  3012. {
  3013.     m_ulCallbackCounter++;
  3014. }
  3015. ulThisCallbackCount = m_ulCallbackCounter;
  3016. m_hPendingHandle = ulThisCallbackCount;
  3017. m_bIsScheduledCB = bIsScheduled;
  3019. if (ulRelativeTime > m_ulMaxSleepTime)
  3020. {
  3021.     ulRelativeTime = m_ulMaxSleepTime;
  3022.     m_bIsScheduledCB = FALSE;
  3023. }
  3025. HX_TRACE_THINGY("C:/trace.txt", "SchedCBTime", ulRelativeTime);
  3027. #ifdef DO_ABSOLUTE_TIMING
  3028. LONG32 lTimeOffset;
  3029. HXTimeval hxTime;
  3030. ULONG32 ulNTries = N_STABILIZATION_ITERATIONS;
  3031. ULONG32 ulCurrentTime1;
  3032. ULONG32 ulCurrentTime2;
  3034. if (bIsScheduled)
  3035. {
  3036.     // Obtain atomic time reading (avoid context switch)
  3037.     do
  3038.     {
  3039. ulCurrentTime1 = HX_GET_BETTERTICKCOUNT();
  3041. // Always use the optimized scheduler if we have one
  3042. if (m_pOptimizedScheduler != NULL)
  3043. {
  3044.     hxTime = m_pOptimizedScheduler->GetCurrentSchedulerTime();
  3045. }
  3046. else
  3047. {
  3048.     hxTime = m_pScheduler->GetCurrentSchedulerTime();
  3049. }
  3051. ulCurrentTime2 = HX_GET_BETTERTICKCOUNT();
  3053. lTimeOffset = (LONG32) (ulCurrentTime2 - ulBaseTime + ulRelativeTime);
  3055. ulNTries--;
  3056.     } while (((ulCurrentTime2 - ulCurrentTime1) > MAX_ALLOWED_TIMING_ERROR) &&
  3057. (ulNTries != 0) &&
  3058. (lTimeOffset > 0));
  3060.     if (lTimeOffset >= SMALLEST_TIMABLE_PERIOD)
  3061.     {
  3062. hxTime.tv_usec += (lTimeOffset * MILLISECOND);
  3063. if (hxTime.tv_usec >= SECOND)
  3064. {
  3065.     hxTime.tv_sec += (hxTime.tv_usec / SECOND);
  3066.     hxTime.tv_usec %= SECOND;
  3067. }
  3068.     }
  3070.     hPendingHandle = ScheduleAbsoluteCallback(hxTime, pCallback);
  3071. }
  3072. else
  3073. #endif  // DO_ABSOLUTE_TIMING
  3074. {
  3076.     hPendingHandle = ScheduleRelativeCallback(ulRelativeTime, pCallback);
  3078. }
  3080. HX_ASSERT(hPendingHandle);
  3082. // Remember the handle if callback did not already fire synchronously
  3083. if (m_hPendingHandle == ulThisCallbackCount)
  3084. {
  3085.     HX_TRACE_THINGY("C:/trace.txt", "SchedCBHandle", hPendingHandle);
  3087.     m_hPendingHandle = hPendingHandle;
  3088.     m_bPendingCallback = (m_hPendingHandle != ((CallbackHandle) NULL));
  3089. }
  3090.     }
  3092.     return HXR_OK;
  3093. }
  3096. inline CallbackHandle CVideoRenderer::ScheduleRelativeCallback
  3097. (
  3098.     UINT32 ulRelativeTime,
  3099.     IHXCallback* pCallback
  3100. )
  3101. {
  3102.     CallbackHandle hCallback;
  3104.     // Always use the optimized scheduler if we have one
  3105.     if (m_pOptimizedScheduler != NULL)
  3106.     {
  3107. hCallback = m_pOptimizedScheduler->RelativeEnter(
  3108.     pCallback, ulRelativeTime);
  3109.     }
  3110.     else
  3111.     {
  3112. hCallback = m_pScheduler->RelativeEnter(
  3113.     pCallback, ulRelativeTime);
  3114.     }
  3116.     return hCallback;
  3117. }
  3120. inline CallbackHandle CVideoRenderer::ScheduleAbsoluteCallback
  3121. (
  3122.     HXTimeval &hxTime,
  3123.     IHXCallback* pCallback
  3124. )
  3125. {
  3126.     CallbackHandle hCallback;
  3128.     // Always use the optimized scheduler if we have one
  3129.     if (m_pOptimizedScheduler != NULL)
  3130.     {
  3131. hCallback = m_pOptimizedScheduler->AbsoluteEnter(
  3132.     pCallback, hxTime);
  3133.     }
  3134.     else
  3135.     {
  3136. hCallback = m_pScheduler->AbsoluteEnter(
  3137.     pCallback, hxTime);
  3138.     }
  3140.     return hCallback;
  3141. }
  3144. void CVideoRenderer::RemoveCallback(CallbackHandle &hCallback)
  3145. {
  3146.     if (hCallback != (CallbackHandle)NULL)
  3147.     {
  3148. if (m_pOptimizedScheduler != NULL)
  3149. {
  3150.     m_pOptimizedScheduler->Remove(hCallback);
  3151. }
  3152. else if (m_pScheduler)
  3153. {
  3154.     m_pScheduler->Remove(hCallback);
  3155. }
  3157. hCallback = NULL;
  3158.     }
  3159. }
  3162. /*
  3163.  *   Draw any frame that's due, and schedule a new callback for the next
  3164.  *   frame
  3165.  */
  3166. void CVideoRenderer::SchedulerCallback(BOOL bIsScheduled,
  3167.        BOOL bResched,
  3168.        BOOL bIsVS2Call,
  3169.        BOOL bProcessUndisplayableFramesOnly)
  3170. {
  3171.     CMediaPacket* pPkt;
  3172.     LONG32 lTimeDelta;
  3173.     ULONG32 ulNextFrameTime;
  3174.     BOOL bFrameIsSkippable;
  3175.     ULONG32 ulBaseTime;
  3176.     BOOL bHaveNextFrame;
  3177.     BOOL bDisplayFrame;
  3178.     ULONG32 ulLoopCounter = 0;
  3180.     DisplayMutex_Lock();
  3182.     while ((m_PlayState == Playing) ||
  3183.    ((m_PlayState == PlayStarting) && m_bFirstFrame))
  3184.     {
  3185. if (m_bUseVideoSurface2)
  3186. {
  3187.     if (bIsVS2Call)
  3188.     {
  3189. m_bVideoSurface2Transition = FALSE;
  3190.     }
  3191.     else
  3192.     {
  3193. m_bPendingCallback = FALSE;
  3194. DisplayMutex_Unlock();
  3195. return;
  3196.     }
  3197. }
  3198. else
  3199. {
  3200.     if (bIsVS2Call)
  3201.     {
  3202. DisplayMutex_Unlock();
  3203. return;
  3204.     }
  3206.     m_bVS2BufferUnavailableOnLastBlt = FALSE;
  3207. }
  3209. #ifdef ENABLE_FETCH_TRACE
  3210. ULONG32 ulFetchTraceStart = HX_GET_BETTERTICKCOUNT();
  3211. #endif // ENABLE_FETCH_TRACE
  3213. bDisplayFrame = TRUE;
  3215. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  3216. if( !m_bUntimedRendering )
  3217. {
  3218. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  3219. while ((bHaveNextFrame = m_pVideoFormat->GetNextFrameTime(ulNextFrameTime)) != 0)
  3220. {
  3222. #ifdef ENABLE_FETCH_TRACE
  3223.     if (ulFetchTraceIdx < MAX_FETCH_TRACE_ENTRIES)
  3224.     {
  3225. fetchTraceArray[ulFetchTraceIdx++] =
  3226.     HX_GET_BETTERTICKCOUNT() - ulFetchTraceStart;
  3227.     }
  3228. #endif // ENABLE_FETCH_TRACE
  3230.     lTimeDelta = ComputeTimeAhead(ulNextFrameTime,
  3231.   0,
  3232.   &ulBaseTime);
  3234.     if (((lTimeDelta + ((LONG32) m_ulLateFrameTol)) >= 0) ||
  3235. bIsScheduled ||
  3236. m_bVS2BufferUnavailableOnLastBlt)
  3237.     {
  3238. break;
  3239.     }
  3240.     else
  3241.     {
  3242. #ifdef ENABLE_SCHED_TRACE
  3243. if (ulSchedTraceIdx < MAX_SCHED_TRACE_ENTRIES)
  3244. {
  3245.     schedTraceArray[ulSchedTraceIdx++] = lTimeDelta;
  3246. }
  3247. #endif // ENABLE_SCHED_TRACE
  3249. bFrameIsSkippable = TRUE;
  3251. m_pVideoFormat->IsNextFrameSkippable(bFrameIsSkippable);
  3253. if (!bFrameIsSkippable)
  3254. {
  3255.     if (m_bFirstFrame)
  3256.     {
  3257. bDisplayFrame = FALSE;
  3258.     }
  3259.     break;
  3260. }
  3261.     }
  3263. #ifdef ENABLE_FETCH_TRACE
  3264.     ulFetchTraceStart = HX_GET_BETTERTICKCOUNT();
  3265. #endif // ENABLE_FETCH_TRACE
  3267.     pPkt = m_pVideoFormat->Dequeue();
  3269. #ifdef ENABLE_FETCH_TRACE
  3270.     if (ulFetchTraceIdx < MAX_FETCH_TRACE_ENTRIES)
  3271.     {
  3272. fetchTraceArray[ulFetchTraceIdx++] =
  3273.     HX_GET_BETTERTICKCOUNT() - ulFetchTraceStart;
  3274.     }
  3275. #endif // ENABLE_FETCH_TRACE
  3277.     if (!m_bFirstFrame)
  3278.     {
  3279. #if defined(HELIX_FEATURE_STATS)
  3280. m_pVideoStats->ReportDroppedFrame();
  3281. #endif /* HELIX_FEATURE_STATS */
  3282.     }
  3284.     ReleasePacket(pPkt);
  3285. }
  3286. #ifdef HELIX_FEATURE_VIDREND_UNTIMED_DECODE
  3287. } else {
  3288.          bHaveNextFrame = m_pVideoFormat->GetNextFrameTime(ulNextFrameTime);
  3289.     lTimeDelta = 0;
  3291.     ComputeTimeAhead( 0, 0, &ulBaseTime );
  3293. }
  3294. #endif /* HELIX_FEATURE_VIDREND_UNTIMED_DECODE */
  3296. if (bProcessUndisplayableFramesOnly && bDisplayFrame)
  3297. {
  3298.     DisplayMutex_Unlock();
  3299.     return;
  3300. }
  3302. if (!m_bVS2BufferUnavailableOnLastBlt)
  3303. {
  3304.     if (bHaveNextFrame)
  3305.     {
  3306. if ((lTimeDelta > ((LONG32) m_ulEarlyFrameTol)) &&
  3307.     (!m_bFirstFrame))
  3308. {
  3309.     if (bResched)
  3310.     {
  3311. ScheduleCallback(lTimeDelta, TRUE, ulBaseTime);
  3312.     }
  3314.     DisplayMutex_Unlock();
  3316.     return;
  3317. }
  3318.     }
  3319.     else
  3320.     {
  3321. if (bResched)
  3322. {
  3323.     // m_pVideoFormat->DecodeFrame();  MBO: Give user Input priority
  3324.     ScheduleCallback(m_ulNoFramesPollingInterval);
  3325. }
  3327. DisplayMutex_Unlock();
  3329. return;
  3330.     }
  3332.     // Render
  3333.     pPkt = m_pVideoFormat->Dequeue();
  3334. }
  3335. else
  3336. {
  3337.     // We need to reblt - but if there is a frame that's up to date
  3338.     // use it instead of old failed frame.
  3339.     pPkt = NULL;
  3340.     if (bHaveNextFrame && (lTimeDelta <= 0))
  3341.     {
  3342. pPkt = m_pVideoFormat->Dequeue();
  3343.     }
  3344. }
  3346. if (pPkt != NULL)
  3347. {
  3348. #ifdef ENABLE_SCHED_TRACE
  3349.     if (ulSchedTraceIdx < MAX_SCHED_TRACE_ENTRIES)
  3350.     {
  3351. schedTraceArray[ulSchedTraceIdx++] = lTimeDelta;
  3352.     }
  3353. #endif // ENABLE_SCHED_TRACE
  3355.     if (m_pMISUSSite &&
  3356. m_pBltPacketQueue->Put(pPkt))
  3357.     {
  3358. if (pPkt->m_pData && bDisplayFrame)
  3359. {
  3360.     m_bFirstFrame = FALSE;
  3361. }
  3363. if (m_bUseVideoSurface2)
  3364. {
  3365.     ForceDisplayUpdate(FALSE, bDisplayFrame);
  3367.     if (m_bVS2BufferUnavailableOnLastBlt)
  3368.     {
  3369. // We couldn't blt frame because video buffer
  3370. // wasn't available, try again a bit later
  3371. DisplayMutex_Unlock();
  3372. return;
  3373.     }
  3374. }
  3375. else
  3376. {
  3377.     if ((!bDisplayFrame) || (!ForceRefresh()))
  3378.     {
  3379. // Site redraw did not occur - treat this as if the surface
  3380. // is invisible
  3381. ForceDisplayUpdate(FALSE, FALSE);
  3382. HX_ASSERT(!m_bPendingRedraw);
  3383.     }
  3384. }
  3385.     }
  3386.     else
  3387.     {
  3388. #if defined(HELIX_FEATURE_STATS)
  3389. m_pVideoStats->ReportDroppedFrame();
  3390. #endif /* HELIX_FEATURE_STATS */
  3391. ReleasePacket(pPkt);
  3392.     }
  3393. }
  3394. else
  3395. {
  3396.     // This is a reblt servicing
  3397.     if (m_bUseVideoSurface2)
  3398.     {
  3399. HX_ASSERT(bDisplayFrame);
  3401. ForceDisplayUpdate(FALSE, bDisplayFrame);
  3403. if (m_bVS2BufferUnavailableOnLastBlt)
  3404. {
  3405.     // We couldn't blt frame because video buffer
  3406.     // wasn't available, try again a bit later
  3407.     DisplayMutex_Unlock();
  3408.     return;
  3409. }
  3410.     }
  3411. }
  3413. if (bResched)
  3414. {
  3415.     ulLoopCounter++;
  3417.     if (ulLoopCounter > MAX_BLT_LOOPS)
  3418.     {
  3419. ScheduleCallback(BLT_RELIEF_DELAY);
  3421. DisplayMutex_Unlock();
  3423. return;
  3424.     }
  3425. }
  3426. else
  3427. {
  3428.     if (!bIsVS2Call)
  3429.     {
  3430. DisplayMutex_Unlock();
  3432. return;
  3433.     }
  3434. }
  3436. bIsScheduled = FALSE;
  3437.     }
  3439.     if ((m_PlayState != Stopped) &&
  3440. bResched)
  3441.     {
  3442. ScheduleCallback(NO_FRAMES_POLLING_INTERVAL);
  3444. DisplayMutex_Unlock();
  3446. return;
  3447.     }
  3449.     m_bPendingCallback = FALSE;
  3451.     DisplayMutex_Unlock();
  3452. }
  3454. void CVideoRenderer::ForceDisplayUpdate(BOOL bInternalSurfaceUpdateOnly,
  3455. BOOL bHasVisibleSurface)
  3456. {
  3457.     // Create fake events for HandleSurfaceUpdate:
  3458.     HX_ASSERT(m_pMISUSSite);
  3460. #if defined (HELIX_FEATURE_MISU)
  3461.     IHXSiteEnumerator* pSiteEnumerator;
  3462.     if (SUCCEEDED(m_pMISUSSite->QueryInterface(IID_IHXSiteEnumerator,
  3463.        (void**) &pSiteEnumerator)))
  3464.     {
  3465. IHXSite* pSite;
  3466. IHXSiteEnumerator::SitePosition nextPosition;
  3468. if (FAILED(pSiteEnumerator->GetFirstSite(pSite, nextPosition)))
  3469. {
  3470.     HX_ASSERT(FALSE);
  3471. }
  3472. else
  3473. {
  3474.     BOOL bKeepUpdating = TRUE;
  3476.     do
  3477.     {
  3478. bKeepUpdating = (ForceDisplayUpdateOnSite(pSite, 
  3479.   bInternalSurfaceUpdateOnly, 
  3480.   bHasVisibleSurface) != HXR_ABORT);
  3481. pSite->Release();
  3482.     }
  3483.     while (bKeepUpdating &&
  3484.    SUCCEEDED(pSiteEnumerator->GetNextSite(pSite, nextPosition)));
  3485. }
  3487. pSiteEnumerator->Release();
  3488.     }
  3489.     else
  3490.     {
  3491. ForceDisplayUpdateOnSite(m_pMISUSSite,
  3492.  bInternalSurfaceUpdateOnly,
  3493.  bHasVisibleSurface);
  3494.     }
  3495. #else //HELIX_FEATURE_MISU
  3497.     ForceDisplayUpdateOnSite(m_pMISUSSite,
  3498.      bInternalSurfaceUpdateOnly,
  3499.      bHasVisibleSurface);
  3501. #endif //HELIX_FEATURE_MISU
  3503. }
  3505. HX_RESULT CVideoRenderer::ForceDisplayUpdateOnSite(IHXSite* pSite, 
  3506.    BOOL bInternalSurfaceUpdateOnly,
  3507.    BOOL bHasVisibleSurface)
  3508. {
  3509.     HX_RESULT retVal = HXR_OK;
  3511.     IHXVideoSurface2* pVideoSurface2;
  3512.     IHXSite2* pSite2 = NULL;
  3513.     IHXVideoSurface* pVideoSurface = NULL;
  3514.     
  3515.     if (SUCCEEDED(pSite->QueryInterface(IID_IHXSite2, (void**) &pSite2)))
  3516.     {
  3517. pSite2->GetVideoSurface(pVideoSurface);
  3518.     }
  3520.     if (bInternalSurfaceUpdateOnly)
  3521.     {
  3522. if (pVideoSurface)
  3523. {
  3524.     if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2, 
  3525. (void**) &pVideoSurface2)))
  3526.     {
  3527. pVideoSurface2->PresentIfReady();
  3528. pVideoSurface2->Release();
  3529.     }
  3530. }
  3531.     }
  3532.     else
  3533.     {
  3534. HXxEvent fakeEvent;
  3536. fakeEvent.param1 = (void*) pVideoSurface;
  3537. retVal = UpdateDisplay(&fakeEvent, FALSE, bHasVisibleSurface);
  3538.     }
  3539.     
  3540.     HX_RELEASE(pVideoSurface);
  3541.     HX_RELEASE(pSite2);
  3543.     return retVal;
  3544. }
  3547. STDMETHODIMP CVideoRenderer::Func(void)
  3548. {
  3549.     HX_TRACE_THINGY("C:/trace.txt", "Func", 0);
  3551.     m_hPendingHandle = NULL;
  3553.     SchedulerCallback(m_bIsScheduledCB);
  3555.     return HXR_OK;
  3556. }
  3559. HX_RESULT CVideoRenderer::BeginOptimizedBlt(HXBitmapInfoHeader* pBitmapInfo)
  3560. {
  3561.     HX_RESULT retVal = HXR_UNEXPECTED;
  3562.     IHXSite2* pMISUSSite2   = NULL;
  3563.     IHXVideoSurface* pVideoSurface = NULL;
  3565.     if (m_pMISUSSite)
  3566.     {
  3567.         m_pMISUSSite->QueryInterface(IID_IHXSite2, (void**)&pMISUSSite2);
  3568.         if (pBitmapInfo && pMISUSSite2)
  3569.         {
  3570.             if (SUCCEEDED(pMISUSSite2->GetVideoSurface(pVideoSurface)))
  3571.             {
  3572.                 retVal = pVideoSurface->BeginOptimizedBlt(pBitmapInfo);
  3573.                 if (retVal == HXR_OK)
  3574.                 {
  3575.                     m_bOptimizedBlt = TRUE;
  3576.                 }
  3577.                 HX_RELEASE(pVideoSurface);
  3578.             }
  3579.         }
  3580. HX_RELEASE(pMISUSSite2);
  3581.     }
  3583.     return retVal;
  3584. }
  3587. void CVideoRenderer::EndOptimizedBlt(void)
  3588. {
  3589.     IHXSite2* pMISUSSite2 = NULL;
  3590.     IHXVideoSurface* pVideoSurface = NULL;
  3592.     if (m_bOptimizedBlt && m_pMISUSSite)
  3593.     {
  3594. m_pMISUSSite->QueryInterface(IID_IHXSite2, (void**)&pMISUSSite2);
  3596. if (pMISUSSite2)
  3597. {
  3598.     pMISUSSite2->GetVideoSurface(pVideoSurface);
  3599.     if (pVideoSurface)
  3600.     {
  3601. pVideoSurface->EndOptimizedBlt();
  3602. m_bOptimizedBlt = FALSE;
  3603. HX_RELEASE(pVideoSurface);
  3604.     }
  3605. }
  3606.     }
  3608.     HX_RELEASE(pMISUSSite2);
  3609. }
  3612. inline void CVideoRenderer::RequestBuffering(void)
  3613. {
  3614.     m_bBufferingNeeded = TRUE;
  3615. }
  3618. inline void CVideoRenderer::RequestBufferingEnd(void)
  3619. {
  3620.     m_bBufferingNeeded = FALSE;
  3621. }
  3624. HX_RESULT CVideoRenderer::BeginBuffering(void)
  3625. {
  3626.     HX_RESULT retVal = HXR_FAIL;
  3627. #ifdef REBUFFER_ON_VIDEO
  3629.     m_ulBufferingStartTime = HX_GET_BETTERTICKCOUNT();
  3631.     // If this is a reccuring rebuffer, start buffering only if
  3632.     // the preroll period passed since the last buffering completion.
  3633.     // This is done to prevent buffering all the time.
  3634.     if (!m_bBufferingOccured ||
  3635. ((m_ulBufferingStartTime - m_ulBufferingStopTime) > m_ulPreroll))
  3636.     {
  3637. // Bytes to Buffer could be used for Predata
  3638. // - Predata was not found beneficial yet
  3639. m_ulBytesToBuffer = (ULONG32) (((double) m_ulPreroll) *
  3640.        ((double) m_ulAvgBitRate) /
  3641.        8000.0);
  3643. m_ulBufferingTimeOut = m_ulPreroll * 2;
  3645. if (m_ulBufferingTimeOut > 0)
  3646. {
  3647.     m_PlayState = Buffering;
  3649.     retVal = m_pStream->ReportRebufferStatus(1, 0);
  3650. }
  3651.     }
  3652. #endif // REBUFFER_ON_VIDEO
  3654.     return retVal;
  3655. }
  3658. HX_RESULT CVideoRenderer::EndBuffering(void)
  3659. {
  3660.     HX_RESULT retVal = HXR_UNEXPECTED;
  3662. #ifdef REBUFFER_ON_VIDEO
  3664.     if (m_PlayState == Buffering)
  3665.     {
  3666. m_PlayState = PlayStarting;
  3667. m_bBufferingOccured = TRUE;
  3668. m_ulBufferingStopTime = HX_GET_BETTERTICKCOUNT();
  3670. HX_ASSERT(m_pStream);
  3671. retVal = m_pStream->ReportRebufferStatus(1,1);
  3672.     }
  3673. #endif // REBUFFER_ON_VIDEO
  3675.     return retVal;
  3676. }
  3679. inline BOOL CVideoRenderer::IsBufferingComplete(IHXPacket *pPacket)
  3680. {
  3681. #ifdef REBUFFER_ON_VIDEO
  3682.     ULONG32 ulTimeNow = HX_GET_BETTERTICKCOUNT();
  3684.     if ((m_PlayState == Buffering) && (m_bBufferingNeeded))
  3685.     {
  3686. if (pPacket &&
  3687.     ((pPacket->GetTime() - m_ulBaseTime) > m_ulPreroll))
  3688. {
  3689.     return TRUE;
  3690. }
  3692. return ((ulTimeNow - m_ulBufferingStartTime) > m_ulBufferingTimeOut);
  3693.     }
  3694. #endif // REBUFFER_ON_VIDEO
  3696.     return TRUE;
  3697. }
  3700. HX_RESULT CVideoRenderer::LocalizeActiveVideoPacket(void)
  3701. {
  3702.     HX_RESULT retVal = HXR_IGNORE;
  3704.     DisplayMutex_Lock();
  3706.     if (m_pActiveVideoPacket && (!m_bActiveVideoPacketLocalized))
  3707.     {
  3708. CMediaPacket* pLocalPacket = NULL;
  3709. ULONG32 ulDataSize = m_pActiveVideoPacket->m_ulDataSize;
  3710. UINT8* pData = new UINT8 [ulDataSize];
  3712. retVal = HXR_OUTOFMEMORY;
  3713. if (pData)
  3714. {
  3715.     retVal = HXR_OK;
  3716. }
  3718. if (retVal == HXR_OK)
  3719. {
  3720.     pLocalPacket = new CMediaPacket(pData,
  3721.     pData,
  3722.     ulDataSize,
  3723.     ulDataSize,
  3724.     m_pActiveVideoPacket->m_ulTime,
  3725.     m_pActiveVideoPacket->m_ulFlags,
  3726.     NULL);
  3728.     retVal = HXR_OUTOFMEMORY;
  3729.     if (pLocalPacket)
  3730.     {
  3731. retVal = HXR_OK;
  3732.     }
  3733. }
  3735. if (retVal == HXR_OK)
  3736. {
  3737.     memcpy(pData, m_pActiveVideoPacket->m_pData, ulDataSize); /* Flawfinder: ignore */
  3738.     ReleasePacket(m_pActiveVideoPacket);
  3739.     m_pActiveVideoPacket = pLocalPacket;
  3740.     m_bActiveVideoPacketLocalized = TRUE;
  3741. }
  3742. else
  3743. {
  3744.     HX_VECTOR_DELETE(pData);
  3745.     HX_DELETE(pLocalPacket);
  3746. }
  3747.     }
  3749.     DisplayMutex_Unlock();
  3751.     return retVal;
  3752. }
  3755. void CVideoRenderer::ReleaseFramePacket(CMediaPacket* pPacket)
  3756. {
  3757.     ReleasePacket(pPacket);
  3758. }
  3761. void CVideoRenderer::ReleasePacket(CMediaPacket* pPacket,
  3762.   BOOL bForceKill)
  3763. {
  3764.     CHXBufferPool* pFramePool = NULL;
  3766.     if (m_pVideoFormat)
  3767.     {
  3768. m_pVideoFormat->OnDecodedPacketRelease(pPacket);
  3769. pFramePool = m_pVideoFormat->GetFramePool();
  3770.     }
  3772.     if (pPacket)
  3773.     {
  3774. if (pFramePool && (!bForceKill))
  3775. {
  3776.     pFramePool->Put(pPacket);
  3777. }
  3778. else
  3779. {
  3780.     pPacket->Clear();
  3781.     delete pPacket;
  3782. }
  3783.     }
  3785.     if (IsDecoderRunning())
  3786.     {
  3787. if (m_pDecoderPump)
  3788. {
  3789.     m_pDecoderPump->Signal();
  3790. }
  3791.     }
  3792.     else
  3793.     {
  3794. if (m_pVideoFormat)
  3795. {
  3796.     m_pVideoFormat->DecodeFrame();
  3797. }
  3798.     }
  3799. }
  3802. void CVideoRenderer::ClearBltPacketQueue(void)
  3803. {
  3804.     CMediaPacket* pVideoPacket;
  3806.     if (m_pBltPacketQueue)
  3807.     {
  3808. while ((pVideoPacket = (CMediaPacket*) m_pBltPacketQueue->Get()) != 0)
  3809. {
  3810.     ReleasePacket(pVideoPacket);
  3811. }
  3812.     }
  3813. }
  3816. /****************************************************************************
  3817.  *  CVideoRenderer::CSetSizeCB
  3818.  *  This routine increases the object reference count in a thread safe
  3819.  *  manner. The reference count is used to manage the lifetime of an object.
  3820.  *  This method must be explicitly called by the user whenever a new
  3821.  *  reference to an object is used.
  3822.  */
  3823. /****************************************************************************
  3824.  *  CVideoRenderer::CSetSizeCB::QueryInterface
  3825.  */
  3826. STDMETHODIMP CVideoRenderer::CSetSizeCB::QueryInterface(REFIID riid,
  3827.   void** ppvObj)
  3828. {
  3829.     QInterfaceList  qiList[] =
  3830.     {
  3831. { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPlugin*) this},
  3832. { GET_IIDHANDLE(IID_IHXCallback), (IHXCallback*)this},
  3833.     };
  3835.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  3836. }
  3838. /****************************************************************************
  3839.  *  CVideoRenderer::CSetSizeCB::AddRef                             
  3840.  */
  3841. STDMETHODIMP_(ULONG32) CVideoRenderer::CSetSizeCB::AddRef()
  3842. {
  3843.     return InterlockedIncrement(&m_lRefCount);
  3844. }
  3846. /****************************************************************************
  3847.  *  CVideoRenderer::CSetSizeCB::Release
  3848.  */
  3849. STDMETHODIMP_(ULONG32) CVideoRenderer::CSetSizeCB::Release()
  3850. {
  3851.     if (InterlockedDecrement(&m_lRefCount) > 0)
  3852.     {
  3853.         return m_lRefCount;
  3854.     }
  3856.     delete this;
  3857.     return 0;
  3858. }
  3860. /****************************************************************************
  3861.  *  CVideoRenderer::CSetSizeCB::Func
  3862.  */
  3863. STDMETHODIMP CVideoRenderer::CSetSizeCB::Func()
  3864. {
  3865.     return m_pSite->SetSize(m_szViewFrame);
  3866. }
  3869. /****************************************************************************
  3870.  *  CVideoRenderer::Pacemaker Responses
  3871.  */
  3872. STDMETHODIMP CVideoRenderer::OnPaceStart(ULONG32 ulId)
  3873. {
  3874.     if (ulId == m_ulDecoderPacemakerId)
  3875.     {
  3876. if (m_pVideoFormat)
  3877. {
  3878.     m_pDecoderVideoFormat = m_pVideoFormat;
  3879.     m_pDecoderVideoFormat->AddRef();
  3880. }
  3881. m_bDecoderRunning = TRUE;
  3882.     }
  3883.     else if (ulId == m_ulBltrPacemakerId)
  3884.     {
  3885. if (m_pVideoFormat)
  3886. {
  3887.     m_pBltrVideoFormat = m_pVideoFormat;
  3888.     m_pBltrVideoFormat->AddRef();
  3889. }
  3890.     }
  3892.     return HXR_OK;
  3893. }
  3895. STDMETHODIMP CVideoRenderer::OnPaceEnd(ULONG32 ulId)
  3896. {
  3897.     if (ulId == m_ulDecoderPacemakerId)
  3898.     {
  3899. m_bDecoderRunning = FALSE;
  3900.         if (m_pDecoderVideoFormat)
  3901.         {
  3902.             m_pDecoderVideoFormat->Release();
  3903.             m_pDecoderVideoFormat = NULL;
  3904.         }
  3905.     }
  3906.     else if (ulId == m_ulBltrPacemakerId)
  3907.     {
  3908.         if (m_pBltrVideoFormat)
  3909.         {
  3910.             m_pBltrVideoFormat->Release();
  3911.             m_pBltrVideoFormat = NULL;
  3912.         }
  3913.     }
  3915.     return HXR_OK;
  3916. }
  3918. STDMETHODIMP CVideoRenderer::OnPace(ULONG32 ulId)
  3919. {
  3920.     if (ulId == m_ulBltrPacemakerId)
  3921.     {
  3922. PresentFrame();
  3923.     }
  3924.     else if (ulId == m_ulDecoderPacemakerId)
  3925.     {
  3926. if (m_bSchedulerStartRequested)
  3927. {
  3928.     StartSchedulers();
  3929. }
  3931. while ((m_pDecoderVideoFormat->DecodeFrame()) != 0) ;
  3933. #ifdef HELIX_FEATURE_VIDREND_BOOSTDECODE_ON_STARTUP
  3934. // on ce we need to get this started quickly, otherwise the initial packets expire
  3935. if (THREAD_PRIORITY_BELOW_NORMAL != GetDecodePriority())
  3936. {
  3937.     SetDecodePriority(THREAD_PRIORITY_BELOW_NORMAL);
  3938.     return HXR_OK;
  3939. }
  3940. #endif
  3941.     }
  3943.     return HXR_OK;
  3944. }
  3947. /****************************************************************************
  3948.  *  Video Surface 2 Support
  3949.  */
  3950. HX_RESULT CVideoRenderer::InitVideoSurface2(ULONG32 ulWidth, ULONG32 ulHeight)
  3951. {
  3952. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  3953.     HX_RESULT retVal = HXR_FAIL;
  3955.     BOOL bTryVideoSurface2 = m_bTryVideoSurface2;
  3957.     if (bTryVideoSurface2)
  3958.     {
  3959.         HX_ASSERT(m_pMISUSSite);
  3960.         IHXVideoSurface* pVideoSurface = NULL;
  3961. IHXVideoSurface2* pVideoSurface2 = NULL;
  3962.         IHXSite2* pSite2 = NULL;
  3964. if (m_bUseVideoSurface2 &&
  3965.     m_pVSurf2InputBIH &&
  3966.     (m_pVSurf2InputBIH->biWidth == ((LONG32) ulWidth)) &&
  3967.     (m_pVSurf2InputBIH->biHeight == ((LONG32) ulHeight)))
  3968. {
  3969.     return HXR_OK;
  3970. }
  3972. // EndOptimizedBlt();
  3974. bTryVideoSurface2 = FALSE;
  3976.         m_pMISUSSite->QueryInterface(IID_IHXSite2, (void**) &pSite2);
  3977.         if (pSite2)
  3978.         {
  3979.             pSite2->GetVideoSurface(pVideoSurface);
  3980.         }
  3981. HX_RELEASE(pSite2);
  3983.         HX_ASSERT(pVideoSurface);
  3984.         if (pVideoSurface)
  3985.         {
  3986.             pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  3987.                                           (void**) &pVideoSurface2);
  3988.         }
  3989.         HX_RELEASE(pVideoSurface);
  3991.         if (pVideoSurface2)
  3992.         {
  3993.     HXBitmapInfoHeader userBIH;
  3994.     ULONG32 ulUserBufCount;
  3995.             IHXBuffer* pInitialCountBuffer = NULL;
  3996.     HX_RESULT status;
  3998.     m_ulHWBufCount = m_ulConfigHWBufCount;
  4000.     HX_RELEASE(pInitialCountBuffer);
  4002.     if (m_pVSurf2InputBIH == NULL)
  4003.     {
  4004. m_pVSurf2InputBIH = new HXBitmapInfoHeader;
  4005.     }
  4007.     retVal = HXR_OUTOFMEMORY;
  4008.     if (m_pVSurf2InputBIH)
  4009.     {
  4010. *m_pVSurf2InputBIH = m_BitmapInfoHeader;
  4011. m_pVSurf2InputBIH->biWidth = ulWidth;
  4012. m_pVSurf2InputBIH->biHeight = ulHeight;
  4013. retVal = HXR_OK;
  4014.     }
  4016.             if (SUCCEEDED(retVal))
  4017.     {
  4018. do
  4019. {
  4020.     // SetProperties should modify m_pVSurf2InputBIH
  4021.     status = pVideoSurface2->SetProperties(m_pVSurf2InputBIH,
  4022.    m_ulHWBufCount,
  4023.    (IHXRenderTimeLine*) this);
  4025.     /*** This code creates a leak - the renderer is not released
  4026.      *** Needs investigation.
  4027.     if (SUCCEEDED(status) && (m_ulHWBufCount > 0))
  4028.     {
  4029. UINT8* pVideoMem;
  4030. INT32 iPitch;
  4032. status = pVideoSurface2->GetVideoMem(pVideoMem,
  4033.      iPitch,
  4034.      HX_WAIT_FOREVER,
  4035.      m_pVSurf2InputBIH);
  4037. if (SUCCEEDED(status))
  4038. {
  4039.     pVideoSurface2->ReleaseVideoMem(pVideoMem);
  4040. }
  4041.     }
  4042.      ***/
  4044.     userBIH = *m_pVSurf2InputBIH;
  4045.     ulUserBufCount = m_ulHWBufCount;
  4047.     retVal = OnOptimizedVideo(status,
  4048.       m_BitmapInfoHeader,
  4049.       userBIH,
  4050.       ulUserBufCount);
  4052.     if (retVal == HXR_RETRY)
  4053.     {
  4054. *m_pVSurf2InputBIH = userBIH;
  4055. m_ulHWBufCount = ulUserBufCount;
  4056.     }
  4057. } while (retVal == HXR_RETRY);
  4058.     }
  4060.     if (SUCCEEDED(retVal) &&
  4061. SUCCEEDED(status) &&
  4062. (m_ulHWBufCount != 0))
  4063.     {
  4064. bTryVideoSurface2 = TRUE;
  4065.     }
  4066. }
  4068. if (bTryVideoSurface2)
  4069. {
  4070.     // Turning on video surface 2
  4071.     m_ulEarlyFrameTol = m_ulMaxOptimizedVideoLead;
  4072.     if (!m_bUseVideoSurface2)
  4073.     {
  4074. m_bVideoSurface2Transition = TRUE;
  4075. m_bUseVideoSurface2 = TRUE;
  4076. if (m_pBltrPump)
  4077. {
  4078.     // Wake up Bltr thread
  4079.     m_pBltrPump->Suspend(FALSE);
  4080.     m_pBltrPump->Signal();
  4081. }
  4082.     }
  4083. }
  4085. HX_RELEASE(pVideoSurface2);
  4086.     }
  4088.     if (FAILED(retVal))
  4089.     {
  4090. HX_DELETE(m_pVSurf2InputBIH);
  4091.     }
  4093.     m_bUseVideoSurface2 = bTryVideoSurface2;
  4095.     return retVal;
  4096. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4098.     return HXR_NOTIMPL;
  4099. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4100. }
  4103. HX_RESULT CVideoRenderer::UpdateVideoSurface2(IHXVideoSurface* pVideoSurface,
  4104.       HXxRect &destRect,
  4105.       HXxRect &sorcRect,
  4106.       BOOL bRefresh,
  4107.       BOOL bSystemEvent)
  4108. {
  4109. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4110.     VideoMemStruct videoMemoryInfo;
  4111.     IHXVideoSurface2* pVideoSurface2 = NULL;
  4112.     HX_RESULT retVal;
  4114.     HX_ASSERT(pVideoSurface);
  4116.     videoMemoryInfo.pVidMem = NULL;
  4118.     retVal = pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  4119.    (void**) &pVideoSurface2);
  4121.     if (!bRefresh)
  4122.     {
  4123. m_bPresentInProgress = TRUE;
  4125. // If we are in transition to video surface 2, we are not in
  4126. // natural Bltr thread, thus do not unlock the mutex to prevent
  4127. // other Blt entry points for interfering until the transition
  4128. // to natural queue thread is complete.
  4129. if (!m_bVideoSurface2Transition)
  4130. {
  4131.     DisplayMutex_Unlock();
  4132. }
  4134. if (SUCCEEDED(retVal))
  4135. {
  4136.     HX_ASSERT(m_bVideoSurface2Transition ? bSystemEvent : TRUE);
  4138.     retVal = pVideoSurface2->GetVideoMem(&videoMemoryInfo,
  4139.                                                  m_bVideoSurface2Transition ?
  4140.     HX_WAIT_NEVER : HX_WAIT_FOREVER);
  4142.     m_bVS2BufferUnavailableOnLastBlt = FAILED(retVal);
  4143. }
  4145. if (!m_bVideoSurface2Transition)
  4146. {
  4147.     DisplayMutex_Lock();
  4149.     // If the switch to VS1 occured after we successfully obtained video
  4150.     // memory, fail this VS2 Blt
  4151.     if ((!m_bUseVideoSurface2) && SUCCEEDED(retVal))
  4152.     {
  4153. retVal = HXR_FAIL;
  4154.     }
  4155. }
  4157. if (SUCCEEDED(retVal))
  4158. {
  4159.     retVal = TransferOptimizedVideo(pVideoSurface2,
  4160.                                             &videoMemoryInfo,
  4161.     m_pActiveVideoPacket,
  4162.     m_BitmapInfoHeader,
  4163.     sorcRect,
  4164.     sorcRect);
  4165. }
  4167. if (SUCCEEDED(retVal))
  4168. {
  4169.     if (m_bFirstSurfaceUpdate)
  4170.     {
  4171. m_bFirstSurfaceUpdate = FALSE;
  4173. if (bSystemEvent)
  4174. {
  4175.     retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4176.      m_pActiveVideoPacket->m_ulTime,
  4177.      HX_MODE_IMMEDIATE,
  4178.      &destRect,
  4179.      &sorcRect);
  4181.     // We'll fail if the site is hidden by SMIL:
  4182.     if (FAILED(retVal))
  4183.     {
  4184. retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4185.  m_pActiveVideoPacket->m_ulTime,
  4186.  HX_MODE_TIMED,
  4187.  &destRect,
  4188.  &sorcRect);
  4189.     }
  4190. }
  4191. else
  4192. {
  4193.     // Unless this is a system event we are not under the protection of the
  4194.     // top level site mutex and present immediate will acquire TLS mutex.
  4195.     // We must avoid deadlock with HandleEvent by relinquishing
  4196.     // VS mutex and forcing refresh.
  4197.     m_bPresentInProgress = FALSE;
  4198.     BOOL bIsVisible = ForceRefresh();
  4200.     // We'll fail if the site is not visible
  4201.     if (bIsVisible)
  4202.     {
  4203. // Abort any further updates for multiple site users since
  4204. // ForceRefresh will take care of all of them
  4205. retVal = HXR_ABORT;
  4206.     }
  4207.     else
  4208.     {
  4209. retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4210.  m_pActiveVideoPacket->m_ulTime,
  4211.  HX_MODE_TIMED,
  4212.  &destRect,
  4213.  &sorcRect);
  4214.     }
  4215. }
  4216.     }
  4217.     else
  4218.     {
  4219. retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4220.  m_pActiveVideoPacket->m_ulTime,
  4221.  HX_MODE_TIMED,
  4222.  &destRect,
  4223.  &sorcRect);
  4224.     }
  4226.     if (SUCCEEDED(retVal))
  4227.     {
  4228. videoMemoryInfo.pVidMem = NULL;
  4229.     }
  4230. }
  4232. m_bPresentInProgress = FALSE;
  4233.     }
  4234.     else if (!m_bPresentInProgress)
  4235.     {
  4236. HX_ASSERT(bSystemEvent);
  4238. retVal = pVideoSurface2->Present(NULL,
  4239.  0,
  4240.  HX_MODE_REFRESH,
  4241.  &destRect,
  4242.  &sorcRect);
  4244. // If no frames in video surface - make one and present it
  4245. if (FAILED(retVal) && bSystemEvent)
  4246. {
  4247.     retVal = pVideoSurface2->GetVideoMem(&videoMemoryInfo,
  4248.                                                  HX_WAIT_NEVER);
  4250.     if (SUCCEEDED(retVal))
  4251.     {
  4252. retVal = TransferOptimizedVideo(pVideoSurface2,
  4253.         &videoMemoryInfo,
  4254. m_pActiveVideoPacket,
  4255. m_BitmapInfoHeader,
  4256. sorcRect,
  4257. sorcRect);
  4259. if (SUCCEEDED(retVal))
  4260. {
  4261.     retVal = pVideoSurface2->Present(&videoMemoryInfo,
  4262.      m_pActiveVideoPacket->m_ulTime,
  4263.      HX_MODE_IMMEDIATE,
  4264.      &destRect,
  4265.      &sorcRect);
  4267.     if (FAILED(retVal))
  4268.     {
  4269. pVideoSurface2->ReleaseVideoMem(&videoMemoryInfo);
  4270. retVal = pVideoSurface2->Present(NULL,
  4271.  0,
  4272.  HX_MODE_REFRESH,
  4273.  &destRect,
  4274.  &sorcRect);
  4275.     }
  4277.     videoMemoryInfo.pVidMem = NULL;
  4278. }
  4279.     }
  4280.     else
  4281.     {
  4282. retVal = pVideoSurface2->Present(NULL,
  4283.  0,
  4284.  HX_MODE_REFRESH,
  4285.  &destRect,
  4286.  &sorcRect);
  4287.     }
  4288. }
  4289.     }
  4291.     if (videoMemoryInfo.pVidMem != NULL)
  4292.     {
  4293. pVideoSurface2->ReleaseVideoMem(&videoMemoryInfo);
  4294.     }
  4296.     HX_RELEASE(pVideoSurface2);
  4298.     return retVal;
  4299. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4301.     return HXR_NOTIMPL;
  4302. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4303. }
  4306. HX_RESULT CVideoRenderer::FlushVideoSurface2(IHXSite* pSite)
  4307. {
  4308. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4309.     HX_RESULT retVal = HXR_FAIL;
  4311.     IHXVideoSurface* pVideoSurface;
  4312.     IHXVideoSurface2* pVideoSurface2;
  4313.     IHXSite2* pSite2;
  4315.     HX_ASSERT(pSite);
  4317.     if (SUCCEEDED(pSite->QueryInterface(IID_IHXSite2, (void**) &pSite2)))
  4318.     {
  4319. if (SUCCEEDED(pSite2->GetVideoSurface(pVideoSurface)))
  4320. {
  4321.     if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  4322. (void**) &pVideoSurface2)))
  4323.     {
  4324. pVideoSurface2->Flush();
  4325. pVideoSurface2->Release();
  4326. retVal = HXR_OK;
  4327.     }
  4329.     pVideoSurface->Release();
  4330. }
  4332. pSite2->Release();
  4333.     }
  4335.     HX_ASSERT(SUCCEEDED(retVal));
  4337.     return retVal;
  4338. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4340.     return HXR_NOTIMPL;
  4341. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4342. }
  4345. inline HX_RESULT CVideoRenderer::SwitchToVideoSurface1(void)
  4346. {
  4347. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4348.     HX_RESULT retVal = HXR_OK;
  4350.     m_pVSMutex->Lock();
  4352.     m_bVideoSurface1Requested = TRUE;
  4353.     if (m_bUseVideoSurface2)
  4354.     {
  4355. HX_TRACE_THINGY("C:/trace.txt", "-->Switch to VS1", 0);
  4357. #ifdef SYNC_VS_SWITCHING
  4358. InitVideoSurface1(TRUE);
  4359. StartSchedulers();
  4360. #else // SYNC_VS_SWITCHING
  4361. // Force Video Surface reinitialization
  4362. m_bVideoSurfaceReinitRequested = TRUE;
  4363. #endif // SYNC_VS_SWITCHING
  4364.     }
  4366.     m_pVSMutex->Unlock();
  4368.     return retVal;
  4369. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4371.     return HXR_NOTIMPL;
  4372. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4373. }
  4376. inline HX_RESULT CVideoRenderer::SwitchToVideoSurface2(void)
  4377. {
  4378. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4379.     HX_RESULT retVal = HXR_OK;
  4381.     m_pVSMutex->Lock();
  4383.     m_bVideoSurface1Requested = FALSE;
  4384.     if (!m_bUseVideoSurface2)
  4385.     {
  4386. if (m_bTryVideoSurface2)
  4387. {
  4388.     HX_TRACE_THINGY("C:/trace.txt", "-->Switch to VS2", 0);
  4390. #ifdef SYNC_VS_SWITCHING
  4391.     InitVideoSurface2(m_SetWinSize.cx, m_SetWinSize.cy);
  4392.     StartSchedulers();
  4393. #else // SYNC_VS_SWITCHING
  4394.     // Force Video Surface reinitialization
  4395.     m_bVideoSurfaceReinitRequested = TRUE;
  4396. #endif // SYNC_VS_SWITCHING
  4397. }
  4398. else
  4399. {
  4400.     // VideoSurface2 is not allowed
  4401.     HX_TRACE_THINGY("C:/trace.txt", "-->Switch to VS2 Denied!", 0);
  4403.     retVal = HXR_FAIL;
  4404. }
  4405.     }
  4407.     m_pVSMutex->Unlock();
  4409.     return retVal;
  4410. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4412.     return HXR_NOTIMPL;
  4413. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4414. }
  4417. /****************************************************************************
  4418.  *  Method:
  4419.  *    CVideoFormat::OnOptimizedVideo
  4420.  *
  4421.  */
  4422. HX_RESULT CVideoRenderer::OnOptimizedVideo(HX_RESULT status,
  4423.    const HXBitmapInfoHeader& sourceBIH,
  4424.    HXBitmapInfoHeader &targetBIH,
  4425.    ULONG32 &ulTargetBufCount)
  4426. {
  4427. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4428.     HX_RESULT retVal = HXR_FAIL;
  4430.     if (SUCCEEDED(status) &&
  4431. (ulTargetBufCount > 0) &&
  4432. (GETBITMAPCOLOR(&sourceBIH) == CID_I420))
  4433.     {
  4434.         retVal = HXR_OK;
  4435.     }
  4437.     return retVal;
  4438. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4440.     return HXR_NOTIMPL;
  4441. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4442. }
  4445. /****************************************************************************
  4446.  *  Method:
  4447.  *    CVideoFormat::OffOptimizedVideo
  4448.  *
  4449.  */
  4450. void CVideoRenderer::OffOptimizedVideo(void)
  4451. {
  4452.     return;
  4453. }
  4456. /****************************************************************************
  4457.  *  Method:
  4458.  *    CVideoFormat::TransferOptimizedVideo
  4459.  *
  4460.  */
  4461. HX_RESULT CVideoRenderer::TransferOptimizedVideo(IHXVideoSurface2* pVideoSurface2,
  4462.                                                  VideoMemStruct* pVideoMemoryInfo,
  4463.                                                  CMediaPacket* pVideoPacket,
  4464.                                                  const HXBitmapInfoHeader& sorcBIH,
  4465.                                                  HXxRect &destRect,
  4466.                                                  HXxRect &sorcRect)
  4467. {
  4468. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4469.     SourceInputStruct input;
  4470.     UINT8* aSrcInput[3];
  4471.     INT32 aSrcPitch[3];
  4472.     HX_RESULT retVal = HXR_FAIL;
  4474.     input.aSrcInput = aSrcInput;
  4475.     input.aSrcPitch = aSrcPitch;
  4476.     input.nNumInputs = 3;
  4478.     if (GETBITMAPCOLOR(&sorcBIH) == CID_I420)
  4479.     {
  4480. aSrcInput[0] = pVideoPacket->m_pData;
  4481. aSrcInput[1] = aSrcInput[0] + (sorcBIH.biWidth * sorcBIH.biHeight);
  4482. aSrcInput[2] = aSrcInput[1] +
  4483.        ((sorcBIH.biWidth / 2) * (sorcBIH.biHeight / 2));
  4485. aSrcPitch[0] = sorcBIH.biWidth;
  4486. aSrcPitch[1] = sorcBIH.biWidth / 2;
  4487. aSrcPitch[2] = sorcBIH.biWidth / 2;
  4489.         CHXxSize sorcSize(sorcBIH.biWidth, sorcBIH.biHeight);
  4491.         retVal = pVideoSurface2->ColorConvert(HX_I420,
  4492.                                               &sorcSize,
  4493.                                               &sorcRect,
  4494.                                               &input,
  4495.                                               pVideoMemoryInfo->bmi.biCompression,
  4496.                                               pVideoMemoryInfo->pVidMem,
  4497.                                               &CHXxSize(pVideoMemoryInfo->bmi.biWidth,
  4498.                                                         pVideoMemoryInfo->bmi.biHeight),
  4499.                                               &destRect,
  4500.                                               pVideoMemoryInfo->lPitch);
  4502.         // Alpha blend subrects:
  4503.         for (UINT32 i = 0; i < pVideoMemoryInfo->ulCount; ++i)
  4504.         {
  4505.             HX_RESULT localResult = pVideoSurface2->ColorConvert(
  4506.                              HX_I420,
  4507.                              &sorcSize,
  4508.                              &pVideoMemoryInfo->pAlphaList[i].rcImageRect,
  4509.                              &input,
  4510.                              pVideoMemoryInfo->pAlphaList[i].ulFourCC,
  4511.                              pVideoMemoryInfo->pAlphaList[i].pBuffer,
  4512.                              &CHXxSize(pVideoMemoryInfo->pAlphaList[i].ulImageWidth,
  4513.                                        pVideoMemoryInfo->pAlphaList[i].ulImageHeight),
  4514.                              &pVideoMemoryInfo->pAlphaList[i].rcImageRect,
  4515.                              pVideoMemoryInfo->pAlphaList[i].lPitch);
  4516.             if (SUCCEEDED(retVal))
  4517.             {
  4518.                 retVal = localResult;
  4519.             }
  4520.         }
  4521.     }
  4523.     return retVal;
  4524. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4526.     return HXR_NOTIMPL;
  4527. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4528. }
  4531. void CVideoRenderer::PresentFrame(void)
  4532. {
  4533. #ifdef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4534.     if (m_bUseVideoSurface2)
  4535.     {
  4536. SchedulerCallback(FALSE,    // not scheduled
  4537.   FALSE,    // do not resched
  4538.   TRUE);    // is VS2 call
  4539.     }
  4540.     else
  4541.     {
  4542. // Video Surface2 has been turned off
  4543. IHXPaceMaker* pBltr = m_pBltrPump;
  4545. if (pBltr)
  4546. {
  4547.     if (m_bTryVideoSurface2)
  4548.     {
  4549. // We might try VideoSurface2 again later - suspend the
  4550. // Bltr thread for now
  4551. pBltr->Suspend(TRUE);
  4552.     }
  4553.     else
  4554.     {
  4555. // We are not to try VideoSurface2 any more - stop the
  4556. // Bltr thread
  4557. pBltr->Stop();
  4558. pBltr->Signal();
  4559.     }
  4560. }
  4561.     }
  4562. #else // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4564.     ;
  4565. #endif // HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO
  4566. }