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

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

Symbian

开发平台：

Visual C++

winsurf2.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: winsurf2.cpp,v 1.23.2.2 2004/07/26 10:28:48 pankajgupta Exp $
  3.  *
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  *
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  *
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  *
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  *
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  *
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  *
  46.  * Contributor(s):
  47.  *
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hxtypes.h"
  51. #include <math.h>
  52. #include "ddraw.h"
  53. #include "hxcom.h"
  54. #include "hxwintyp.h"
  55. #include "hxvsurf.h"
  56. #include "hxslist.h"
  57. #include "ddhlpr.h"
  59. #include "winsurf.h"
  60. #include "vidsurf2.h"
  61. #include "winsurf2.h"
  62. #include "winsite.h"
  63. #include "colormap.h"
  64. #include "windraw2.h"
  65. #include "hxprefs.h"
  66. #include "hxtick.h"
  67. #include "hxheap.h"
  68. #include "hxevent.h"
  69. #include "hwmemobj.h"
  72. // these are defined in basesurf.cpp and should probably be moved to a .h file
  73. #define HX_OVER_KEYDEST    1
  74. #define HX_OVER_HIDE       2
  75. #define HX_OVER_SHOW       4
  76. #define OVERLAY_NOT_VISIBLE 0
  78. #ifdef _DEBUG
  79. #undef HX_THIS_FILE
  80. static const char HX_THIS_FILE[] = __FILE__;
  82. #include "winthrd.h"
  83. #endif
  85. #define OS_THREAD_QUANTUM 10
  86. #define MAX_PREEMPTION_CHECK_ATTEMPTS 3
  87. #define TIME_JITTER_FILTER_THRESHOLD 0.45
  89. #define MIN_ALLOWED_REGRESSION  0.95
  90. //#define HARDCODE_GRANULE
  91. #define SCHEDULE_GRANULE        5
  92. //#define LOG_JITTER_DATA
  93. #define JITTER_LOG_FILE "c:\temp\ts.txt"
  95. /****************************************************************************
  96.  *  Debug
  97.  */
  98. //#define ENABLE_SYNC_TRACE
  99. #ifdef ENABLE_SYNC_TRACE
  100. #define MAX_SYNC_TRACE_ENTRIES 10000
  101. ULONG32 ulSyncTraceIdx = 0;
  102. double syncTraceArray[MAX_SYNC_TRACE_ENTRIES][3];
  104. void DumpSyncEntries(void)
  105. {
  106.     FILE* pFile = NULL;
  107.     ULONG32 ulIdx;
  109.     if (ulSyncTraceIdx > 0)
  110.     {
  111. pFile = fopen("/tmp/getscanline.txt", "wb"); /* Flawfinder: ignore */
  112.     }
  114.     if (pFile)
  115.     {
  116. for (ulIdx = 0; ulIdx < (ulSyncTraceIdx < MAX_SYNC_TRACE_ENTRIES ?
  117.              ulSyncTraceIdx : MAX_SYNC_TRACE_ENTRIES); ulIdx++)
  118. {
  119.     fprintf(pFile, "%lft%lft%lfn", syncTraceArray[ulIdx][0],
  120.       syncTraceArray[ulIdx][1],
  121.                                               syncTraceArray[ulIdx][2]
  122.                                             );
  123. }
  125. fclose(pFile);
  126.     }
  128.     ulSyncTraceIdx = 0;
  129. }
  130. #endif // ENABLE_SYNC_TRACE
  132. //#define ENABLE_ERROR_TRACE
  133. #ifdef ENABLE_ERROR_TRACE
  134. #define MAX_ERROR_TRACE_ENTRIES 10000
  136. double g_error[MAX_ERROR_TRACE_ENTRIES][3];
  137. double g_alternateError[MAX_ERROR_TRACE_ENTRIES];
  138. ULONG32 g_ulFrameCount;
  140. UINT32 g_sleepError[MAX_ERROR_TRACE_ENTRIES];
  141. ULONG32 g_ulSleepCount;
  143. void DumpErrorEntries(void)
  144. {
  145.     FILE* pFile = NULL;
  146.     ULONG32 ulIdx;
  148.     if (g_ulFrameCount > 0)
  149.     {
  150. pFile = fopen("/tmp/vblankerror.txt", "wb"); /* Flawfinder: ignore */
  151.     }
  153.     if (pFile)
  154.     {
  155. for (ulIdx = 0; ulIdx < (g_ulFrameCount < MAX_SYNC_TRACE_ENTRIES ?
  156.              g_ulFrameCount : MAX_SYNC_TRACE_ENTRIES); ulIdx++)
  157. {
  158.     fprintf(pFile, "%lft%lft%lfn", g_error[ulIdx][0],
  159.                                          g_error[ulIdx][1],
  160.                                          g_error[ulIdx][2]);
  161. }
  163. fclose(pFile);
  164.     }
  166.     g_ulFrameCount = 0;
  167. }
  168. #endif // ENABLE_ERROR_TRACE
  170. // Using "this" in constructor initialzer
  171. #pragma warning(disable:4355)
  173. CWinSurface2::CWinSurface2(IUnknown* pContext, CHXBaseSite* pSite)
  174.  :  CWinSurface(pContext,pSite)
  175.  ,  CVideoSurface2((IUnknown*)(IHXVideoSurface*)this)
  176.  ,  m_hRenThread(0)
  177.  ,  m_hFrameSem(0)
  178.  ,  m_hReinit(0)
  179.  ,  m_hAbort(0)
  180.  ,  m_hForceRender(0)
  181.  ,  m_hSurfaceMutex(0)
  182.  ,  m_bCont(FALSE)
  183.  ,  m_bBoostRenderThread(TRUE)
  184.  ,  m_bDoAlphaCheck(TRUE)
  185.  ,  m_bQueryMonitorFreq(FALSE)
  186.  ,  m_bUseVBlankFlip(TRUE)
  187.  ,  m_bIngnorePresentIfReady(FALSE)
  188.  ,  m_bScratchSurface(FALSE)
  189.  ,  m_bGDISurface(FALSE)
  190.  ,  m_nScratchIndex(0)
  191.  ,  m_nLastDisplayTime(0)
  192.  ,  m_pListOfFrames(NULL)
  193.  ,  m_pTimeLine(NULL)
  194.  ,  m_hFallbackEmpty(0)
  195.  ,  m_nFallbackSurfaceCID(0)
  196.  ,  m_bFallbackSurfaceCreated(FALSE)
  197.  ,  m_pSysMemSurf(NULL)
  198.  ,  m_nSysMemSurfSize(0)
  199.  ,  m_nSysMemSurfCount(0)
  200.  ,  m_nSysMemSurfPitch(0)
  201.  ,  m_nSysMemSurfID(0)
  202.  ,  m_nNextSysMemBuffer(0)
  203.  ,  m_bUseSysMemSurface(FALSE)
  204.  ,  m_nGdiSurfaceCount(0)
  205.  ,  m_nLastGdiSurface(-1)
  206.  ,  m_nNextGdiSurface(0)
  207.  ,  m_nGdiSurfaceCID(0)
  208.  ,  m_bGdiSurfaceCreated(FALSE)
  209.  ,  m_ulFillColoryKeyCount(0)
  210.  ,  m_bFlushing(FALSE)
  211.  ,  m_bFrameHasHWAlphaBlend(FALSE)
  212.  ,  m_bSurfaceRequiresOverlay(FALSE)
  213.  ,  m_bSwitchingingOverlay(FALSE)
  214.  ,  m_bUseDDColorControls(FALSE)
  215.  ,  m_bWaitingForFlush(FALSE)
  216.  ,  m_bWasInVidSurf2(FALSE)
  217.  ,  m_dLastXScale(0.0)
  218.  ,  m_dLastYScale(0.0)
  219.  ,  m_nOverlayBackBuffersCreated(0)
  220.  ,  m_dLastBlitError(0)
  221. {
  222.     // initialize data so we don't have invalid ptrs floating around.
  223.     memset(&m_surface,0,sizeof(m_surface));
  224.     memset(&m_GDIsurface,0,sizeof(m_GDIsurface));
  225.     memset(&m_fallbackSurface,0,sizeof(m_fallbackSurface));
  226.     memset(&m_allocatedFallbackSize, 0, sizeof(m_allocatedFallbackSize));
  227.     memset(&m_allocatedSysMemSurfSize, 0, sizeof(m_allocatedSysMemSurfSize));
  228.     memset(&m_allocatedFallbackSize, 0, sizeof(m_allocatedFallbackSize));
  230.     memset(&m_rcLast, 0, sizeof(m_rcLast));
  232.     InitializeCriticalSection(&m_csDisplay);
  233.     InitializeCriticalSection(&m_csFallback);
  234.     InitializeCriticalSection(&m_csList);
  235.     InitializeCriticalSection(&m_csScale);
  237.     m_hAbort = CreateEvent(NULL, TRUE, FALSE, NULL);
  238.     m_hForceRender = CreateEvent(NULL, TRUE, FALSE, NULL);
  239.     m_hReinit = CreateEvent(NULL, TRUE, TRUE, NULL);
  240.     m_hFallbackEmpty = CreateEvent(NULL, TRUE, TRUE, NULL);
  242.     m_hSurfaceMutex = CreateMutex(NULL, FALSE, NULL);
  243.     m_pListOfFrames = new CHXSimpleList;
  245.     // Read some preferences
  246.     IHXPreferences*    pPreferences    = NULL;
  247.     IHXBuffer*         pBuffer         = NULL;
  249.     if (HXR_OK == m_pContext->QueryInterface(IID_IHXPreferences,(void**)&pPreferences))
  250.     {
  251.         // Use vblank flags for flipping
  252.         if (pPreferences->ReadPref("VideoBoost\DisableVBlankFlip", pBuffer) == HXR_OK)
  253.         {
  254.             m_bUseVBlankFlip = !(::atoi((char*) pBuffer->GetBuffer()) == 1);
  255.         }
  256.         HX_RELEASE(pBuffer);
  258.         // Turn-off render thread priority boosting
  259.         if (pPreferences->ReadPref("VideoBoost\DisablePriorityBoost", pBuffer) == HXR_OK)
  260.         {
  261.             m_bBoostRenderThread = !(::atoi((char*) pBuffer->GetBuffer()) == 1);
  262.         }
  263.         HX_RELEASE(pBuffer);
  265.         // Limit number of hw buffers
  266.         if (pPreferences->ReadPref("VideoBoost\MaxBuffers", pBuffer) == HXR_OK)
  267.         {
  268.             m_nMaxBackBuffers = ::atoi((char*) pBuffer->GetBuffer()) - 1;
  269.             m_nMaxBackBuffers = max(1, m_nMaxBackBuffers);
  270.         }
  271.         HX_RELEASE(pBuffer);
  272.     }
  275.     HX_RELEASE(pPreferences);
  276. }
  278. CWinSurface2::~CWinSurface2()
  279. {
  280.     if (m_hRenThread)
  281.     {
  282.         m_bCont = FALSE;
  283.         SetEvent(m_hAbort);
  285.         WaitForSingleObject(m_hRenThread, INFINITE);
  287.         CloseHandle(m_hFrameSem);
  288.         m_hFrameSem = 0;
  290.         CloseHandle(m_hRenThread);
  291.         m_hRenThread = 0;
  293.         DestroyFallbackSurface();
  294.         DestroySysMemSurface();
  295.         DestroyGdiSurface();
  296.     }
  298.     if (m_hAbort)
  299.     {
  300.         CloseHandle(m_hAbort);
  301.         m_hAbort = 0;
  302.     }
  304.     if (m_hForceRender)
  305.     {
  306.         CloseHandle(m_hForceRender);
  307.         m_hForceRender = 0;
  308.     }
  310.     if (m_hReinit)
  311.     {
  312.         CloseHandle(m_hReinit);
  313.         m_hReinit = 0;
  314.     }
  316.     if (m_hFallbackEmpty)
  317.     {
  318.         CloseHandle(m_hFallbackEmpty);
  319.         m_hFallbackEmpty = NULL;
  320.     }
  322.     if (m_hSurfaceMutex)
  323.     {
  324.         CloseHandle(m_hSurfaceMutex);
  325.         m_hSurfaceMutex = 0;
  326.     }
  328.     HX_DELETE(m_pListOfFrames);
  330.     DeleteCriticalSection(&m_csDisplay);
  331.     DeleteCriticalSection(&m_csFallback);
  332.     DeleteCriticalSection(&m_csList);
  333.     DeleteCriticalSection(&m_csScale);
  335.     HX_RELEASE(m_pTimeLine);
  336. }
  338. STDMETHODIMP CWinSurface2::QueryInterface(REFIID riid, void** ppvObj)
  339. {
  340.     if (IsEqualIID(riid, IID_IHXVideoSurface2))
  341.     {
  342.         return CVideoSurface2::QueryInterface(riid, ppvObj);
  343.     }
  345.     return CWinSurface::QueryInterface(riid, ppvObj);
  346. }
  348. STDMETHODIMP_(ULONG32) CWinSurface2::AddRef()
  349. {
  350.     return CWinSurface::AddRef();
  351. }
  353. STDMETHODIMP_(ULONG32) CWinSurface2::Release()
  354. {
  355.     return CWinSurface::Release();
  356. }
  358. STDMETHODIMP CWinSurface2::BeginOptimizedBlt(HXBitmapInfoHeader* pBitmapInfo)
  359. {
  360.     if (m_bWasInVidSurf2 &&
  361.         pBitmapInfo &&
  362.         m_pOptimizedFormat)
  363.     {
  364.         // Are the new parameters the same as the old paramaters? If not
  365.         // then delete the old surfaces.
  366.         if (pBitmapInfo->biWidth       != m_pOptimizedFormat->biWidth       ||
  367.             pBitmapInfo->biHeight      != m_pOptimizedFormat->biHeight      ||
  368.             pBitmapInfo->biPlanes      != m_pOptimizedFormat->biPlanes      ||
  369.             pBitmapInfo->biBitCount    != m_pOptimizedFormat->biBitCount    ||
  370.             pBitmapInfo->biCompression != m_pOptimizedFormat->biCompression ||
  371.             m_bWasInVidSurf2)
  372.         {
  373.             if (m_bWasInVidSurf2)
  374.                 _WaitForFlush();
  376.             DestroySurfaces();
  378.             if (m_bWasInVidSurf2)
  379.             {
  380.                 m_bVideoSurface2 = FALSE;
  381.                 m_bFlipOverlay = FALSE;
  382.                 m_nBackBufferCount = 0;
  383.             }
  384.         }
  385.     }
  387.     return CWinSurface::BeginOptimizedBlt(pBitmapInfo);
  388. }
  390. STDMETHODIMP CWinSurface2::Blt( UCHAR*               pImageData,
  391.                                 HXBitmapInfoHeader* pBitmapInfo,
  392.                                 REF(HXxRect)         rDestRect,
  393.                                 REF(HXxRect)         rSrcRect)
  394. {
  395.     m_pSite->_TLSLock();
  397.     // Handle VS2->VS1 transions
  398.     if (m_bWasInVidSurf2)
  399.     {
  400.         if (!m_pSite->_BordersActive() &&
  401.             !m_pSite->_FadeTransitionActive() &&
  402.             (!m_pSite->AreVideoControlsActive() || m_bUseDDColorControls) &&
  403.             !m_pSite->IsHigherZOrderTranstitionActive() &&
  404.             m_pSite->m_pUser && !m_LinkedSites.GetCount() &&
  405.             !m_pLinkedOverlay)
  406.         {
  407.             HXxEvent event = {HX_SURFACE_MODE_CHANGE, NULL, NULL,
  408.                               (void*)HX_VIDEOSURFACE1_NOT_RECOMMENDED, 0, 0};
  410.             m_bWasInVidSurf2 = FALSE;
  412.             // If we just turned off color controls inform the color converter
  413.             m_pSite->CheckColorSettings();
  415.             m_pSite->m_pUser->HandleEvent(&event);
  417.             // The renderer switched to VideoSurface1 so don't give them a buffer
  418.             if (event.handled)
  419.             {
  420.                 m_pSite->_TLSUnlock();
  421.                 return HXR_FAIL;
  422.             }
  423.             else
  424.                 m_bWasInVidSurf2 = TRUE;
  425.         }
  426.         else if (m_bVideoSurface2)
  427.         {
  428.             m_pSite->_TLSUnlock();
  429.             _WaitForFlush();
  430.             m_bVideoSurface2 = FALSE;
  431.             m_pSite->_TLSLock();
  432.         }
  433.     }
  435.     HX_RESULT hr = CWinSurface::Blt(pImageData, pBitmapInfo, rDestRect, rSrcRect);
  437.     m_pSite->_TLSUnlock();
  438.     return hr;
  439. }
  441. void CWinSurface2::_CreateBuffer()
  442. {
  443.     if (m_hRenThread)
  444.     {
  445.         WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  446.         EnterCriticalSection(&m_csDisplay);
  447.     }
  449.     CWinSurface::_CreateBuffer();
  450.     BOOL bCreated = FALSE;
  452.     if (m_surface.fMode & WINDRAW_DIRECTDRAW)
  453.     {
  454.         bCreated = (m_surface.dd.lpDDSurface != NULL);
  455.     }
  456.     else
  457.     {
  458.         bCreated = (m_surface.gdi.lpGDIBackBuffer[0] != NULL);
  459.     }
  461.     if (bCreated)
  462.     {
  463.         if (m_hRenThread)
  464.         {
  465.             // We create our surface, start servicing GetVidMem calls
  466.             SetEvent(m_hReinit);
  467.         }
  468.     }
  470.     if (m_hRenThread)
  471.     {
  472.         ReleaseMutex(m_hSurfaceMutex);
  473.         LeaveCriticalSection(&m_csDisplay);
  474.     }
  476. }
  478. HX_RESULT CWinSurface2::_CreateOverlay(BOOL bOverlay, int cid, int x, int y)
  479. {
  480.     if (m_hRenThread)
  481.     {
  482.         WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  483.         EnterCriticalSection(&m_csDisplay);
  484.     }
  486.     HX_RESULT hr = CWinSurface::_CreateOverlay(bOverlay, cid, x, y);
  488.     if (HXR_OK == hr && m_hRenThread)
  489.     {
  490.         // We created our surface, start servicing GetVidMem calls
  491.         SetEvent(m_hReinit);
  492.     }
  494.     if (m_hRenThread)
  495.     {
  496.         LeaveCriticalSection(&m_csDisplay);
  497.         ReleaseMutex(m_hSurfaceMutex);
  498.     }
  500.     return hr;
  501. }
  503. HX_RESULT
  504. CWinSurface2::ByPassCompositionSurface(UCHAR*               pImageData,
  505.                                        HXBitmapInfoHeader* pBitmapInfo,
  506.                                        REF(HXxRect)         rDestRect,
  507.                                        REF(HXxRect)         rSrcRect,
  508.                                        UCHAR*               pSurface,
  509.                                        INT32                nSurfPitch)
  511. {
  512.     // Check for vidsurf2-only dest surfaces
  513.     if (CID_I420 == GETBITMAPCOLOR( pBitmapInfo) &&
  514.         m_pHwMemObj)
  515.     {
  516.         HXxSize srcSize = {pBitmapInfo->biWidth, pBitmapInfo->biHeight};
  518.         UCHAR* pYUV[3] = {pImageData,
  519.                           pYUV[0] + pBitmapInfo->biHeight*nSurfPitch,
  520.                           pYUV[1] + pBitmapInfo->biHeight*nSurfPitch/4};
  521.         INT32 nYUVPitch[3] = {nSurfPitch, nSurfPitch/2, nSurfPitch/2};
  523.         SourceInputStruct input = {pYUV, nYUVPitch, 3};
  525.         INT32 nPitch;
  526.         UCHAR* pVidMem =
  527.          (UCHAR*)m_pHwMemObj->DeviceToRenderer(pImageData,
  528.                                                nPitch,
  529.                                                WRITE_VIDEO_TO_STRUCT);
  531.         AlignRect(&rSrcRect, pBitmapInfo->biWidth, pBitmapInfo->biHeight);
  532.         AlignRect(&rDestRect, m_surfaceSize.cx, m_surfaceSize.cy);
  534.         HX_RESULT hr =
  535.             ColorConvert(MapCIDtoFourCC(GETBITMAPCOLOR(pBitmapInfo)),
  536.                          &srcSize, &rSrcRect,
  537.                          &input, MapCIDtoFourCC(m_nSurfaceCID), pVidMem,
  538.                          &m_surfaceSize, &rDestRect, nSurfPitch);
  540.         m_pHwMemObj->RendererToDevice(pVidMem);
  542.         return hr;
  543.     }
  545.     return CWinSurface::ByPassCompositionSurface(pImageData,
  546.                                                  pBitmapInfo,
  547.                                                  rDestRect,
  548.                                                  rSrcRect,
  549.                                                  pSurface,
  550.                                                  nSurfPitch);
  553. }
  555. void CWinSurface2::_ReleaseSurface(CBaseRootSurface* pSurface)
  556. {
  557.     if (m_hRenThread)
  558.     {
  559.         Flush();
  561.         // Make the next GetVidMem wait on new surface creation
  562.         WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  564.         ResetEvent(m_hReinit);
  566.         Flush();
  567.         EnterCriticalSection(&m_csDisplay);
  568.     }
  570.     WINDRAW* pWindraw = ((CWinBaseRootSurface*)pSurface)->GetWinDraw();
  571.     DestroyFallbackSurface();
  572.     DestroyGdiSurface();
  574.     CWinSurface::_ReleaseSurface(pSurface);
  576.     memset(&m_lastSrcRect, 0, sizeof(m_lastSrcRect));
  578.     if (m_hRenThread)
  579.     {
  580.         LeaveCriticalSection(&m_csDisplay);
  581.         ReleaseMutex(m_hSurfaceMutex);
  582.     }
  584.     m_dLastXScale = 0.0;
  585.     m_dLastYScale = 0.0;
  586. }
  588. void CWinSurface2::_ReleaseSurface(CWinBaseRootSurface* pSurface)
  589. {
  590.     if (m_hRenThread)
  591.     {
  592.         Flush();
  594.         // Make the next GetVidMem wait on new surface creation
  595.         WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  596.         ResetEvent(m_hReinit);
  598.         Flush();
  599.         EnterCriticalSection(&m_csDisplay);
  600.     }
  602.     WINDRAW* pWindraw = pSurface->GetWinDraw();
  603.     DestroyFallbackSurface();
  604.     DestroyGdiSurface();
  606.     CWinSurface::_ReleaseSurface(pSurface);
  609.     memset(&m_lastSrcRect, 0, sizeof(m_lastSrcRect));
  611.     if (m_hRenThread)
  612.     {
  613.         LeaveCriticalSection(&m_csDisplay);
  614.         ReleaseMutex(m_hSurfaceMutex);
  615.     }
  617.     m_dLastXScale = 0.0;
  618.     m_dLastYScale = 0.0;
  619. }
  621. void CWinSurface2::_ReleaseSurface()
  622. {
  623.     if (m_hRenThread)
  624.     {
  625.         Flush();
  627.         // Make the next GetVidMem wait on new surface creation
  628.         WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  629.         ResetEvent(m_hReinit);
  631.         Flush();
  632.         EnterCriticalSection(&m_csDisplay);
  633.     }
  635.     CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  636.     if (pSurface)
  637.     {
  638.         WINDRAW* pWindraw = pSurface->GetWinDraw();
  639.         if (pWindraw)
  640.         {
  641.             DestroyFallbackSurface();
  642.             DestroyGdiSurface();
  643.             memset(&m_lastSrcRect, 0, sizeof(m_lastSrcRect));
  645.             CWinSurface::_ReleaseSurface();
  646.         }
  647.     }
  649.     if (m_hRenThread)
  650.     {
  651.         LeaveCriticalSection(&m_csDisplay);
  652.         ReleaseMutex(m_hSurfaceMutex);
  653.     }
  655.     m_dLastXScale = 0.0;
  656.     m_dLastYScale = 0.0;
  657. }
  659. void CWinSurface2::ReInitSurfaces()
  660. {
  661.     if ( (m_surface.fMode & WINDRAW_DIRECTDRAW) &&  m_surface.dd.lpDDSurface && m_bVideoSurface2)
  662.     {
  663.         return;
  664.     }
  666.     // Set yuv priority for vidsurf2 mode
  667.     if (m_hRenThread)
  668.     {
  669.         // Lock the surface mutex
  670.         WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  672.         m_pSite->_TLSLock();
  674.         int cid = GetBitmapColor((LPBITMAPINFO)m_pOptimizedFormat);
  675.         BOOL bRestore = SetYUVPriorityList(cid);
  677.         m_nBackBufferCount = m_nOverlayBackBuffersCreated;
  679.         CWinSurface::ReInitSurfaces();
  681.         if (bRestore)
  682.             RestoreColorspacePriorities(cid);
  684.         // We switched to a mode that does not support overlay...yikes!
  685.         if (m_bVideoSurface2 &&
  686.             (m_nBltMode != HX_OVERLAY_BLT || !m_nBackBufferCount))
  687.         {
  688.             m_bMultipleOverlay = TRUE;
  689.             ForceGDIMode(TRUE);
  690.         }
  691.         else
  692.         {
  693.             m_bMultipleOverlay = FALSE;
  694.         }
  696.         HXxSize rcSize = m_surfaceSize;
  697.         CreateFallbackSurface(m_nSurfaceCID, &rcSize);
  699.         m_pSite->_TLSUnlock();
  701.         ResetBufferTimes(0);
  702.         ReleaseMutex(m_hSurfaceMutex);
  704.     }
  705.     else
  706.         CWinSurface::ReInitSurfaces();
  707. }
  709. BOOL CWinSurface2::_IsDisplaySurfaceYuv()
  710. {
  711.     if (!m_bVideoSurface2)
  712.         return CWinSurface::_IsDisplaySurfaceYuv();
  714.     return IsYUV(MapFourCCtoCID(m_bmi.biCompression));
  715. }
  717. BOOL CWinSurface2::_AllowsOverlayShrinking()
  718. {
  719.     if (m_bSurfaceRequiresOverlay)
  720.         return TRUE;
  721.     else
  722.         return CWinSurface::_AllowsOverlayShrinking();
  723. }
  725. void CWinSurface2::_WaitForQueuedFrames()
  726. {
  727.     WaitForQueuedFrames();
  728. }
  730. void CWinSurface2::_LockBlitter()
  731. {
  732.     if (m_hSurfaceMutex)
  733.     {
  734.         // In the unlikely event that all of our hw buffers are
  735.         // full AND GetVideoMem is blocking with m_hSurfaceMutex
  736.         // while waiting for the time line to start, break
  737.         // out of the time line wait loop.
  738.         BOOL bOldValue = m_bWaitingForFlush;
  739.         m_bWaitingForFlush = TRUE;
  741.         WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  743.         m_bWaitingForFlush = bOldValue;
  744.     }
  745. }
  746. void CWinSurface2::_UnlockBlitter()
  747. {
  748.     if (m_hSurfaceMutex)
  749.         ReleaseMutex(m_hSurfaceMutex);
  750. }
  752. void CWinSurface2::_FlushSurfaces()
  753. {
  754.     Flush();
  755. }
  757. STDMETHODIMP CWinSurface2::SetProperties(HXBitmapInfoHeader* bmi,
  758.                                         REF(UINT32) ulNumBuffers,
  759.                                         IHXRenderTimeLine* pTimeLine)
  760. {
  761.     // Block GetVideoMem calls
  762.     WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  764.     ulNumBuffers = min(m_nMaxBackBuffers+1, (INT32)ulNumBuffers);
  766.     CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  767.     if (!pSurface)
  768.     {
  769.         ReleaseMutex(m_hSurfaceMutex);
  770.         return HXR_FAIL;
  771.     }
  773.     WINDRAW* pWindraw = pSurface->GetWinDraw();
  775.     // If we already have surfaces, destroy and recreate if necessary
  776.     if (m_hRenThread)
  777.     {
  778.         if (bmi->biWidth != m_bmi.biWidth ||
  779.             bmi->biHeight != m_bmi.biHeight ||
  780.             m_surface.dwBackBufferCount == 0 ||
  781.             ulNumBuffers != (UINT32)m_nBackBufferCount+1 ||
  782.             WAIT_OBJECT_0 != WaitForSingleObject(m_hReinit, 0))
  783.         {
  784.             // Wait for display buffers to render
  785.             if (HXR_OK != WaitForQueuedFrames())
  786.                 Flush();
  788.             DestroySurfaces();
  790.             m_nBackBufferCount = 0;
  791.             memset(&m_bmi, 0, sizeof(m_bmi));
  792.             memset(&m_lastSrcRect, 0, sizeof(m_lastSrcRect));
  793.         }
  794.         else
  795.         {
  796.             HX_RELEASE(m_pTimeLine);
  798.             m_pTimeLine = pTimeLine;
  799.             if (m_pTimeLine)
  800.                 m_pTimeLine->AddRef();
  802.             m_bVideoSurface2 = TRUE;
  804.             // If we are keeping our existing video buffers, reset
  805.             // the flipping chain indexes if we have DirectDraw.
  806.             if (!m_bLostHWAcceleration)
  807.                 WinDraw_ResetSurfaceIndexes(pWindraw, &m_surface);
  809.             ReleaseMutex(m_hSurfaceMutex);
  810.             return HXR_OK;
  811.         }
  812.     }
  814.     // If we do not have a render thread and we have an optimized
  815.     // format, we are in VS1 mode so fail the VS2 init.
  816.     else if (m_pOptimizedFormat)
  817.     {
  818.         ReleaseMutex(m_hSurfaceMutex);
  819.         return HXR_FAIL;
  820.     }
  822.     // Try and create an overlay flpping chain of pRequest->nNumBuffers buffers
  823.     m_nBackBufferCount = ulNumBuffers - 1;
  825.     if (m_nBackBufferCount)
  826.         m_bFlipOverlay = TRUE;
  828.     m_bSpamUpdateOverlay = FALSE;
  830.     int cid = GetBitmapColor((LPBITMAPINFO)bmi);
  831.     BOOL bRestore = SetYUVPriorityList(cid);
  833.     BeginOptimizedBlt(bmi);
  834.     int nBltMode = m_nBltMode;
  836.     if (bRestore)
  837.         RestoreColorspacePriorities(cid);
  839.     if (nBltMode != HX_OVERLAY_BLT ||
  840.         !m_nBackBufferCount)
  841.     {
  842.         DestroySurfaces();
  843.         ulNumBuffers = 0;
  844.         m_bVideoSurface2 = FALSE;
  846.         ReleaseMutex(m_hSurfaceMutex);
  847.         return HXR_FAIL;
  848.     }
  850.     m_nOverlayBackBuffersCreated = m_nBackBufferCount;
  851.     bmi->biCompression = MapCIDtoFourCC(m_nSurfaceCID);
  853.     // How odd, a dd driver that returns the wrong caps.
  854.     // I have not seen anything like since the last time I tried
  855.     // to use the caps.
  856.     //
  857.     // We will always try interval flips and swith to flip
  858.     // waits if flip returns an error.
  860. #if DIRECTDRAW_VERSION > 0x0500
  861.     // Can we use the flip interval flag
  862.     if ((pWindraw->dd.m_caps.dwCaps2 & DDCAPS2_FLIPINTERVAL) != DDCAPS2_FLIPINTERVAL)
  863.     {
  864.         m_bUseVBlankFlip = FALSE;
  865.     }
  866. #else
  867.     m_bUseVBlankFlip = FALSE;
  868. #endif
  870.     if (pWindraw->dwMaxScanLine && pWindraw->dMsPerVBlank > 0.0)
  871.         m_bOptimalVideoScheduler = TRUE;
  873.     // If we are using a DirectDraw surface represented by a structure,
  874.     // several of our post-processing functions will not work. Set the
  875.     // various modes here.  While we are generalizing here, most of
  876.     // these surface types are proprietary so disable anything suspicious.
  877.     if (IsStructured(m_nSurfaceCID))
  878.     {
  879.         m_bUseDDColorControls = TRUE;
  880.         m_bSurfaceRequiresOverlay = TRUE;
  882.         // Set default DD color controls
  883.         m_Brightness = DEF_BRIGHTNESS;
  884.         m_Contrast = DEF_CONTRAST;
  885.         m_Saturation = DEF_SATURATION;
  886.         m_Hue = DEF_HUE;
  887.         m_Sharpness = DEF_SHARPNESS;
  888.     }
  889.     else
  890.     {
  891.         m_bUseDDColorControls = FALSE;
  892.         m_bSurfaceRequiresOverlay = FALSE;
  893.     }
  895.     memset(&m_rcLast, 0, sizeof(m_rcLast));
  897.     // Store actual settings
  898.     m_bmi = *bmi;
  900.     // for _ConstructRects
  901.     m_bmiLastBlt = m_bmi;
  903.     m_bVideoSurface2 = TRUE;
  905.     // Schedule a recompute clip after I set m_bmiLastBlt to remove
  906.     // deafault alpha site.  This prevents us from playing in alpha
  907.     // blending mode for local clips.
  908.     if(m_pSite->m_pTopLevelSite)
  909.         m_pSite->m_pTopLevelSite->ScheduleCallback(CLIP, 0);
  911.     m_bmi.biSizeImage = m_nDDSurfaceSize;
  912.     m_bmi.biWidth = m_surfaceSize.cx;
  913.     m_bmi.biHeight = m_surfaceSize.cy;
  914.     m_bmi.biCompression = m_nSurfaceCID;
  915.     ulNumBuffers = m_nBackBufferCount+1;
  917. #ifdef _DEBUG
  918.     char szTmp[128]; /* Flawfinder: ignore */
  919.     char acid[5][5] = {{"I420"}, {"YV12"}, {"YVU9"}, {"YUY2"}, {"UYVY"}}; /* Flawfinder: ignore */
  920.     char dvpf[5] = "DVPF"; /* Flawfinder: ignore */
  921.     char *pCurrent = dvpf;
  923.     if (m_nSurfaceCID < 5)
  924.         pCurrent = acid[m_nSurfaceCID];
  926.     wsprintf(szTmp, "SetProperties Create %ld %s buffersn", ulNumBuffers, pCurrent);
  927.     OutputDebugString(szTmp);
  928. #endif
  930.     HXxSize rcSize = {m_bmi.biWidth, m_bmi.biHeight};
  931.     CreateFallbackSurface(m_nSurfaceCID, &rcSize);
  933.     // Kill render thread if running
  934.     if (m_hRenThread)
  935.     {
  936.         m_bCont = FALSE;
  937.         SetEvent(m_hAbort);
  939.         WaitForSingleObject(m_hRenThread, INFINITE);
  941.         CloseHandle(m_hRenThread);
  942.         m_hRenThread = 0;
  944.         CloseHandle(m_hFrameSem);
  945.         m_hFrameSem = 0;
  946.     }
  948.     HX_RELEASE(m_pTimeLine);
  950.     m_pTimeLine = pTimeLine;
  951.     if (m_pTimeLine)
  952.         m_pTimeLine->AddRef();
  954.     // Create the render thread
  955.     DWORD   dwId;
  956.     m_bCont = TRUE;
  957.     ResetEvent(m_hAbort);
  958.     m_hFrameSem = CreateSemaphore(NULL, 0, ulNumBuffers+1, NULL);
  960.     m_hRenThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE )ThreadProc,
  961.                                 this, 0, &dwId);
  963.     if (m_bBoostRenderThread)
  964.         SetThreadPriority(m_hRenThread, THREAD_PRIORITY_TIME_CRITICAL);
  966.     ReleaseMutex(m_hSurfaceMutex);
  967.     return HXR_OK;
  968. }
  970. BOOL CWinSurface2::SetYUVPriorityList(int cidIn)
  971. {
  972.     IHXPreferences*    pPreferences    = NULL;
  973.     IHXBuffer*         pBuffer         = NULL;
  975.     BOOL bUsePriorityScheme = TRUE;
  976.     BOOL bRestore = FALSE;
  977.     BOOL bUseHWPF = FALSE;
  979.     if (HXR_OK == m_pContext->QueryInterface(IID_IHXPreferences,(void**)&pPreferences))
  980.     {
  981.         // Disalbe our surface priority scheme?
  982.         if (pPreferences->ReadPref("VideoBoost\DisableSurfacePriority", pBuffer) == HXR_OK)
  983.         {
  984.             bUsePriorityScheme = !(::atoi((char*) pBuffer->GetBuffer()) == 1);
  985.         }
  986.         HX_RELEASE(pBuffer);
  988.         HX_RELEASE(pPreferences);
  989.     }
  991.     // Set the priority for the yuv format we use
  992.     if (bUsePriorityScheme)
  993.     {
  994.         int aList[5] = {0,0,0,0,0};
  995.         int *pList = aList;
  996.         int nListSize = 5;
  998.         bRestore = FALSE;
  1000.         if (NOERROR == WinDraw2_GetColorspacePriorities(cidIn, pList, nListSize) && nListSize)
  1001.         {
  1002.             SetColorspacePriorities(aList, nListSize, cidIn);
  1003.             bRestore = TRUE;
  1004.         }
  1005.     }
  1007.     return bRestore;
  1008. }
  1010. STDMETHODIMP CWinSurface2::GetVideoMem(VideoMemStruct* pVidStruct,
  1011.                                       UINT32 ulFlags)
  1012. {
  1014.     memset(pVidStruct, 0, sizeof(*pVidStruct));
  1016.     HXBitmapInfoHeader* bmi = &pVidStruct->bmi;
  1017.     UCHAR* pVidMem;
  1018.     INT32 nPitch = 0;
  1020.     // If we lost our surface, re-create them (if we are not
  1021.     // in the process of switching overlay via the OverlayManager or
  1022.     // in gdi because we lost DirectDraw).
  1023.     if (!m_surface.dd.lpDDSurface &&
  1024.         !m_bFallbackSurfaceCreated &&
  1025.         !m_bSwitchingingOverlay &&
  1026.         !m_bLostHWAcceleration)
  1027.     {
  1028.         // Make sure we have no locked surfaces
  1029.         if (WAIT_OBJECT_0 != WaitForSingleObject(m_hSurfaceMutex, 0))
  1030.         {
  1031.             if (ulFlags & HX_WAIT_NEVER)
  1032.                 return HXR_BUFFER_NOT_AVAILABLE;
  1034.             WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  1035.         }
  1037.         ReInitSurfaces();
  1039.         // Did not work...return an error
  1040.         if (!m_surface.dd.lpDDSurface &&
  1041.             !m_bFallbackSurfaceCreated &&
  1042.             !m_bGdiSurfaceCreated)
  1043.         {
  1044.             ReleaseMutex(m_hSurfaceMutex);
  1045.             return HXR_BUFFER_NOT_AVAILABLE;
  1046.         }
  1048.         ReleaseMutex(m_hSurfaceMutex);
  1049.     }
  1051.     // Return an error if there are not buffers available
  1052.     if (ulFlags & HX_WAIT_NEVER)
  1053.     {
  1054.         // Check m_hReinit is signaled.  If not, return an error
  1055.         if (WAIT_OBJECT_0 != WaitForSingleObject(m_hReinit, 0))
  1056.             return HXR_BUFFER_NOT_AVAILABLE;
  1058.         // Make sure we have no locked surfaces
  1059.         if (WAIT_OBJECT_0 != WaitForSingleObject(m_hSurfaceMutex, 0))
  1060.             return HXR_BUFFER_NOT_AVAILABLE;
  1062.         // If we lost our surface, return an error
  1063.         if (!m_surface.dd.lpDDSurface &&
  1064.             !m_bFallbackSurfaceCreated &&
  1065.             !m_bGdiSurfaceCreated)
  1066.         {
  1067.             ReleaseMutex(m_hSurfaceMutex);
  1068.             return HXR_BUFFER_NOT_AVAILABLE;
  1069.         }
  1070.     }
  1071.     // Wait until a buffer is available
  1072.     else
  1073.     {
  1074.         // Wait until our surfaces are created
  1075.         WaitForSingleObject(m_hReinit, INFINITE);
  1077.         // Wait for last lock
  1078.         WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  1080.         // If we lost our surface, return an error
  1081.         if (!m_surface.dd.lpDDSurface &&
  1082.             !m_bFallbackSurfaceCreated &&
  1083.             !m_bGdiSurfaceCreated)
  1084.         {
  1085.             ReleaseMutex(m_hSurfaceMutex);
  1086.             return HXR_BUFFER_NOT_AVAILABLE;
  1087.         }
  1088.     }
  1090.     if (m_bFlushing || m_bWasInVidSurf2)
  1091.     {
  1092.         ReleaseMutex(m_hSurfaceMutex);
  1093.         return HXR_BUFFER_NOT_AVAILABLE;
  1094.     }
  1096.     INT32 nIndex = -1;
  1097.     HX_RESULT hr = HXR_OK;
  1099.     pVidMem = NULL;
  1100.     nPitch = 0;
  1102.     if (m_pSite->_BordersActive() |
  1103.         m_pSite->_FadeTransitionActive() |
  1104.         (m_pSite->AreVideoControlsActive() && !m_bUseDDColorControls) |
  1105.         m_pSite->IsHigherZOrderTranstitionActive() |
  1106.         (m_LinkedSites.GetCount() > 0) |
  1107.         (m_pLinkedOverlay != NULL))
  1108.     {
  1109.         // Drop to VideoSurface1 for transitions
  1110.         if (m_pSite->m_pUser)
  1111.         {
  1112.             //Can't satisfy a HX_WAIT_NEVER and block without a
  1113.             //response object. :-)
  1114.             if( ulFlags & HX_WAIT_NEVER )
  1115.             {
  1116.                 ReleaseMutex(m_hSurfaceMutex);
  1117.                 return HXR_BUFFER_NOT_AVAILABLE;
  1118.             }
  1120.             HXxEvent event = {HX_SURFACE_MODE_CHANGE, NULL, NULL,
  1121.                               (void*)HX_VIDEOSURFACE1_RECOMMENDED, 0, 0};
  1123.             m_bWasInVidSurf2 = TRUE;
  1125.             _WaitForFlush();
  1127.             // Unlock the surface mutex so we can be torn down
  1128.             ReleaseMutex(m_hSurfaceMutex);
  1130.             m_pSite->m_pUser->HandleEvent(&event);
  1132.             // The renderer switched to VideoSurface1 so don't give them a buffer
  1133.             if (event.handled)
  1134.             {
  1135.                 // Reset or last scale since we are not bltting for a time
  1136.                 m_dLastXScale = 0.0;
  1137.                 m_dLastYScale = 0.0;
  1139.                 return HXR_BUFFER_NOT_AVAILABLE;
  1140.             }
  1141.             else
  1142.             {
  1143.                 m_bWasInVidSurf2 = FALSE;
  1145.                 // Need to lock the mutex since the switch failed
  1146.                 WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  1148.                 CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1149.                 WINDRAW* pWindraw = pSurface->GetWinDraw();
  1151.                 WinDraw_ResetSurfaceIndexes(pWindraw, &m_surface);
  1152.             }
  1153.         }
  1154.     }
  1156.     // Can we restore DirectDraw
  1157.     if (m_bLostHWAcceleration)
  1158.     {
  1159.         CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1160.         m_bLostHWAcceleration = !pSurface->_IsHardwareAccelerationAvail();
  1162.         if (!m_bLostHWAcceleration)
  1163.         {
  1164.             if (HXR_OK != WaitForQueuedFrames())
  1165.                 Flush();
  1167.             DestroyGdiSurface();
  1168.             pSurface->_AcquireHardwareAcceleration();
  1169.             ReInitSurfaces();
  1170.         }
  1171.     }
  1173. LOCK_VIDEO_BUFFER:
  1175.     int nBltMode = GetBestBltMode();
  1177.     BOOL bLockTLSMutex = FALSE;
  1178.     bLockTLSMutex = CanLockSurface(nIndex, nBltMode, (ulFlags & HX_WAIT_NEVER) != HX_WAIT_NEVER);
  1180.     if (m_bFlushing)
  1181.     {
  1182.         ReleaseMutex(m_hSurfaceMutex);
  1183.         return HXR_BUFFER_NOT_AVAILABLE;
  1184.     }
  1186.     if (bLockTLSMutex)
  1187.     {
  1188.         BOOL bRet = m_pSite->_TLSIsLocked();
  1190.         if( bRet && (ulFlags&HX_WAIT_NEVER) )
  1191.         {
  1192.             ReleaseMutex(m_hSurfaceMutex);
  1193.             return HXR_BUFFER_NOT_AVAILABLE;
  1194.         }
  1195.         m_pSite->_TLSLock();
  1196.     }
  1197.     else if (ulFlags & HX_WAIT_NEVER)
  1198.     {
  1199.         ReleaseMutex(m_hSurfaceMutex);
  1200.         return HXR_BUFFER_NOT_AVAILABLE;
  1201.     }
  1202.     else
  1203.     {
  1204.         //XXXgfw Removing a noisy assert for now. It appears that
  1205.         //NVidea GForce 2 MX 100/200 cards will fail to lock a surface
  1206.         //while resizing a video. This failure does not lead to video
  1207.         //artifacts or any other visible problems. However, with the
  1208.         //assert it makes it nearly impossible to debug.
  1209.         //HX_ASSERT(!bLockTLSMutex && (ulFlags & HX_WAIT_FOREVER));
  1211. // Some "error" is preventing us from locking the surface
  1212.         ReleaseMutex(m_hSurfaceMutex);
  1213.         return HXR_BUFFER_NOT_AVAILABLE;
  1214.     }
  1216.     // Use system mem if selected
  1217.     if (m_bUseSysMemSurface)
  1218.     {
  1219.         hr = LockSysMemSurface(pVidMem, nPitch, (ulFlags & HX_WAIT_NEVER) != HX_WAIT_NEVER);
  1221.         if (HXR_OK == hr)
  1222.         {
  1223.             //m_bmi.biCompression = m_nSysMemSurfID;
  1224.             m_bmi.biWidth = m_allocatedSysMemSurfSize.cx;
  1225.             m_bmi.biHeight = m_allocatedSysMemSurfSize.cy;
  1227.             *bmi = m_bmi;
  1228.             bmi->biCompression = m_nSysMemSurfID;
  1229.         }
  1230.     }
  1231.     // If DD is not avail, use rgb blts
  1232.     else if (nBltMode == HX_BASIC_BLT)
  1233.     {
  1234.         hr = LockGdiSurface(pVidMem, nPitch, (ulFlags & HX_WAIT_NEVER) != HX_WAIT_NEVER);
  1236.         if (HXR_OK == hr)
  1237.         {
  1238.             MakeBitmap((LPBITMAPINFO)&m_bmi, sizeof(BMI), m_nGdiSurfaceCID,
  1239.              m_allocatedGdiSize.cx, m_allocatedGdiSize.cy, NULL, NULL);
  1241.             *bmi = m_bmi;
  1242.             m_bmiLastBlt = m_bmi;
  1243.         }
  1244.         else if (DDERR_WRONGMODE == hr)
  1245.         {
  1246.             HandleDisplayModeChange();
  1247.         }
  1248.     }
  1250.     // If overlay is not enabled, use offscreen memory
  1251.     else if (nBltMode == HX_BLT_YUV_STRETCH)
  1252.     {
  1253.         hr = LockFallbackSurface(pVidMem, nPitch, (ulFlags & HX_WAIT_NEVER) != HX_WAIT_NEVER);
  1255.         if (HXR_OK == hr)
  1256.         {
  1257.             m_nScratchIndex = nIndex;
  1259.             MakeBitmap((LPBITMAPINFO)&m_bmi, sizeof(BMI), m_nFallbackSurfaceCID,
  1260.              m_allocatedFallbackSize.cx, m_allocatedFallbackSize.cy, NULL, NULL);
  1262.             *bmi = m_bmi;
  1263.             m_bmiLastBlt = m_bmi;
  1265.             // Restore thread priority
  1266.             if (m_nLastBltMode == HX_BASIC_BLT && m_bBoostRenderThread)
  1267.                 SetThreadPriority(m_hRenThread, THREAD_PRIORITY_TIME_CRITICAL);
  1269.         }
  1270.         else if (DDERR_WRONGMODE == hr)
  1271.         {
  1272.             HandleDisplayModeChange();
  1273.         }
  1274.         // Check if we lost DirectDraw
  1275.         else
  1276.         {
  1277.             if (HandleDirectDrawLoss(bLockTLSMutex))
  1278.             {
  1279.                 if (bLockTLSMutex)
  1280.                     bLockTLSMutex = FALSE;
  1282.                 goto LOCK_VIDEO_BUFFER;
  1283.             }
  1284.         }
  1285.     }
  1286.     else
  1287.     {
  1288.         CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1289.         WINDRAW* pWindraw = pSurface->GetWinDraw();
  1291.         hr = WinDraw_GetLockedSurface(pWindraw, &m_surface, pVidMem, nIndex,
  1292.                                       (ulFlags & HX_WAIT_NEVER) != HX_WAIT_NEVER);
  1294.         if (pVidMem)
  1295.         {
  1296.             nPitch = m_surface.dd.lPitch;
  1298.             MakeBitmap((LPBITMAPINFO)&m_bmi, sizeof(BMI), m_nSurfaceCID,
  1299.              m_surfaceSize.cx, m_surfaceSize.cy, NULL, NULL);
  1301.             *bmi = m_bmi;
  1302.             m_bmiLastBlt = m_bmi;
  1304.             if (m_pHwMemObj)
  1305.             {
  1306.                 pVidMem = (UCHAR*)m_pHwMemObj->DeviceToRenderer(pVidMem, nPitch);
  1307.             }
  1309.             // Restore thread priority
  1310.             if (m_nLastBltMode == HX_BASIC_BLT && m_bBoostRenderThread)
  1311.                 SetThreadPriority(m_hRenThread, THREAD_PRIORITY_TIME_CRITICAL);
  1312.         }
  1314.         // If the display mode was changed on us, destory and recreate the surfaces
  1315.         else if (DDERR_WRONGMODE == hr)
  1316.         {
  1317.             HandleDisplayModeChange();
  1318.         }
  1320.         // Could not lock a surface
  1321.         else if (DDERR_WASSTILLDRAWING == hr)
  1322.         {
  1323.             hr = HXR_BUFFER_NOT_AVAILABLE;
  1324.         }
  1325.         // Check if we lost DirectDraw
  1326.         else
  1327.         {
  1328.             if (HandleDirectDrawLoss(bLockTLSMutex))
  1329.             {
  1330.                 if (bLockTLSMutex)
  1331.                     bLockTLSMutex = FALSE;
  1333.                 goto LOCK_VIDEO_BUFFER;
  1334.             }
  1335.             else
  1336.             {
  1337.                 // Turn off overlay
  1338.                 m_bMultipleOverlay = TRUE;
  1340.                 if (bLockTLSMutex)
  1341.                     m_pSite->_TLSUnlock();
  1343.                 goto LOCK_VIDEO_BUFFER;
  1344.             }
  1345.         }
  1346.     }
  1348.     if (HXR_OK == hr)
  1349.     {
  1350.         // TLS mutex should be locked here...
  1351.         HX_ASSERT(bLockTLSMutex);
  1353.         // Since RGB formats are not supported in MapFourCCtoCID,
  1354.         // store the CID in biCompression.
  1355.         if (!IsYUV(MapFourCCtoCID(m_bmi.biCompression)))
  1356.         {
  1357.             bmi->biCompression = GetBitmapColor((LPBITMAPINFO)&m_bmi);
  1358.         }
  1360.         // Do we need an alpha blending region
  1361.         if (m_bDoAlphaCheck && !m_pHwMemObj)
  1362.         {
  1363.             CreateAlphaList(pVidStruct);
  1364.         }
  1366.         pVidStruct->pVidMem = pVidMem;
  1367.         pVidStruct->lPitch = nPitch;
  1368.     }
  1369.     else
  1370.     {
  1371.         // Did not lock a surface
  1372.         ReleaseMutex(m_hSurfaceMutex);
  1373.         hr = HXR_FAIL;
  1375.         if (bLockTLSMutex)
  1376.         {
  1377.             m_pSite->_TLSUnlock();
  1378.         }
  1379.     }
  1381.     return hr;
  1382. }
  1384. STDMETHODIMP CWinSurface2::ColorConvert(INT32  fourCCIn,
  1385.                                        HXxSize *pSrcSize,
  1386.                                        HXxRect *prSrcRect,
  1387.                                        SourceInputStruct *pInput,
  1388.                                        INT32   fourCCOut,
  1389.                                        UCHAR   *pDestBuffer,
  1390.                                        HXxSize *pDestSize,
  1391.                                        HXxRect *prDestRect,
  1392.                                        int     nDestPitch)
  1393. {
  1394.     // If the dest surface is a normal buffer, perform the transfer
  1395.     if (!IsStructured(MapFourCCtoCID(fourCCOut)))
  1396.         return CVideoSurface2::ColorConvert(fourCCIn, pSrcSize, prSrcRect,
  1397.                                             pInput, fourCCOut, pDestBuffer,
  1398.                                             pDestSize, prDestRect, nDestPitch);
  1400.     // Handle this proprietary surface write
  1401.     HX_ASSERT(m_pHwMemObj);
  1402.     m_pHwMemObj->ProcessCommand((UCHAR*)pInput,
  1403.                                 fourCCIn,
  1404.                                 pSrcSize,
  1405.                                 prSrcRect,
  1406.                                 pDestBuffer,
  1407.                                 fourCCOut,
  1408.                                 pDestSize,
  1409.                                 prDestRect);
  1411.     // Need to set pItem->bAlpha if we blended the frame!!!
  1412.     if (m_pHwMemObj->QueryOperation() & PERFORMED_HW_ALPHA_BLEND)
  1413.     {
  1414.         m_bFrameHasHWAlphaBlend = TRUE;
  1415.     }
  1417.     if (m_bUseDDColorControls)
  1418.     {
  1419.         m_pSite->CheckColorSettings();
  1421.         // Did color controls change
  1422.         float fBright = m_pSite->GetBrightness();
  1423.         float fContrast = m_pSite->GetContrast();
  1424.         float fSaturation = m_pSite->GetSaturation();
  1425.         float fHue = m_pSite->GetHue();
  1426.         float fSharpness = m_pSite->GetSharpness();
  1428.         if (m_Brightness != fBright ||
  1429.             m_Contrast != fContrast ||
  1430.             m_Saturation != fSaturation ||
  1431.             m_Hue != fHue ||
  1432.             m_Sharpness != fSharpness)
  1433.         {
  1434.             CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1435.             WINDRAW* pWindraw = pSurface->GetWinDraw();
  1437.             // Change DD color controls
  1438.             WinDrawSurface_SetColorControls(pWindraw,
  1439.                                             &m_surface,
  1440.                                             fBright,
  1441.                                             fContrast,
  1442.                                             fSaturation,
  1443.                                             fHue,
  1444.                                             fSharpness);
  1445.             m_Brightness = fBright;
  1446.             m_Contrast = fContrast;
  1447.             m_Saturation = fSaturation;
  1448.             m_Hue = fHue;
  1449.             m_Sharpness = fSharpness;
  1450.         }
  1451.     }
  1453.     return HXR_OK;
  1454. }
  1457. BOOL CWinSurface2::CanLockSurface(INT32 nIndex, int nBltMode, BOOL bBlock)
  1458. {
  1459.     UCHAR* pVidMem;
  1460.     HRESULT hr = HXR_FAIL;
  1462.     if (m_bUseSysMemSurface)
  1463.     {
  1464.         if (m_pSysMemSurf)
  1465.         {
  1466.             if (bBlock)
  1467.             {
  1468.                 HANDLE  aWait[2] = {m_pSysMemSurf[m_nNextSysMemBuffer].hEmpty, m_hAbort};
  1469.                 hr = WaitForMultipleObjects(2, aWait, FALSE, INFINITE);
  1470.             }
  1471.             else
  1472.                 hr = WaitForSingleObject(m_pSysMemSurf[m_nNextSysMemBuffer].hEmpty, 0);
  1474.             if (WAIT_OBJECT_0 == hr)
  1475.                 hr = HXR_OK;
  1476.         }
  1477.         else
  1478.             hr = HXR_OK;
  1479.     }
  1480.     // If DD is not avail, use rgb blts
  1481.     else if (HX_BASIC_BLT == nBltMode)
  1482.     {
  1483.         if (m_bGdiSurfaceCreated)
  1484.         {
  1485.             if (bBlock)
  1486.             {
  1487.                 HANDLE  aWait[2] = {m_GDIsurface.gdi.lpGDIBackBuffer[m_nNextGdiSurface]->hEmpty, m_hAbort};
  1488.                 hr = WaitForMultipleObjects(2, aWait, FALSE, INFINITE);
  1489.             }
  1490.             else
  1491.                 hr = WaitForSingleObject(m_GDIsurface.gdi.lpGDIBackBuffer[m_nNextGdiSurface]->hEmpty, 0);
  1493.             if (WAIT_OBJECT_0 == hr)
  1494.                 hr = HXR_OK;
  1495.         }
  1496.         else
  1497.             hr = HXR_OK;
  1498.     }
  1499.     else if (HX_BLT_YUV_STRETCH == nBltMode)
  1500.     {
  1501.         if (bBlock)
  1502.         {
  1503.             HANDLE  aObjects[2] = {m_hFallbackEmpty, m_hAbort};
  1504.             hr = WaitForMultipleObjects(2, aObjects, FALSE, INFINITE);
  1505.         }
  1506.         else
  1507.             hr = WaitForSingleObject(m_hFallbackEmpty, 0);
  1509.         if (WAIT_OBJECT_0 == hr)
  1510.             hr = HXR_OK;
  1511.     }
  1512.     else
  1513.     {
  1514.         CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1515.         WINDRAW* pWindraw = pSurface->GetWinDraw();
  1517.         int nNextIndex = nIndex;
  1518.         hr = WinDraw_CanLockSurface(pWindraw, &m_surface, pVidMem, nNextIndex, bBlock);
  1519.     }
  1521.     if (hr == HXR_OK)
  1522.         return TRUE;
  1523.     else
  1524.         return FALSE;
  1525. }
  1527. STDMETHODIMP CWinSurface2::ReleaseVideoMem(VideoMemStruct* pVidStruct)
  1528. {
  1529.     return ReleaseSurface(pVidStruct, TRUE);
  1530. }
  1533. STDMETHODIMP CWinSurface2::Present(VideoMemStruct *pVidStruct,
  1534.                                    INT32 lTime,
  1535.                                    UINT32 ulFlags,
  1536.                                    HXxRect *prDestRect,
  1537.                                    HXxRect *prSrcRect)
  1538. {
  1539. //#define _DEBUG_TIMEAHEAD
  1540. #ifdef _DEBUG_TIMEAHEAD
  1541.     UINT32 ulCurrentTime;
  1542.     HRESULT timelineResult = m_pTimeLine->GetTimeLineValue(ulCurrentTime);
  1544.     static INT32 lMaxQueueAhead = 0;
  1546.     if ((timelineResult != HXR_TIMELINE_SUSPENDED)
  1547.         && (lTime - (INT32) ulCurrentTime) > lMaxQueueAhead)
  1548.     {
  1549.         lMaxQueueAhead = lTime - (INT32) ulCurrentTime;
  1550.         HX_TRACE("New max queue ahead: %d", lMaxQueueAhead);
  1551.     }
  1552. #endif // _DEBUG_TIMEAHEAD
  1554.     if (m_bWasInVidSurf2)
  1555.         return HXR_FAIL;
  1557.     m_pSite->m_bBltHasBeenCalled = TRUE;
  1559.     if (ulFlags & HX_MODE_IMMEDIATE)
  1560.     {
  1561.         if (m_pListOfFrames->GetCount())
  1562.             return HXR_FAIL;
  1564.         else if( (HXEmptyRegion(m_pSite->m_Region) && !pVidStruct->ulCount  && !m_bFrameHasHWAlphaBlend)
  1565.                  || !m_pSite->IsSiteVisible())
  1566.             return HXR_COULD_NOT_DISPLAY;
  1567.         else
  1568.         {
  1569.             lTime = 0;
  1570.         }
  1571.     }
  1572.     else if (ulFlags & HX_MODE_REFRESH)
  1573.     {
  1574.         HRESULT hr = HXR_FAIL;
  1576.         // We do not have a visible region so we can not refresh
  1577.         if( (HXEmptyRegion(m_pSite->m_Region) ) || !m_pSite->IsSiteVisible())
  1578.             return HXR_COULD_NOT_DISPLAY;
  1580.         // We have not displayed a frame yet so we can not refresh
  1581.         else if (HX_NO_BLT == m_nLastBltMode)
  1582.             return HXR_COULD_NOT_DISPLAY;
  1584.         // If we are waiting on a surface re-init, fail
  1585.         else if (WAIT_OBJECT_0 != WaitForSingleObject(m_hReinit, 0))
  1586.             return HXR_BUFFER_NOT_AVAILABLE;
  1588.         else if (HX_OVERLAY_BLT == m_nLastBltMode)
  1589.         {
  1590.             // Need to lose overlay...so fail the refresh
  1591.             if ((IsShrinking() && !_AllowsOverlayShrinking()) ||
  1592.                 m_bMultipleOverlay)
  1593.                 return HXR_FAIL;
  1594.         }
  1595.         else if (HX_BLT_YUV_STRETCH == m_nLastBltMode)
  1596.         {
  1597.             // Need to restore overlay...so fail the refresh
  1598.             if ((!IsShrinking() || _AllowsOverlayShrinking()) &&
  1599.                 !m_bMultipleOverlay)
  1600.                 return HXR_FAIL;
  1601.         }
  1603.         int      nNumRects   = 0;
  1604.         HXxRect* paSrcRects  = NULL;
  1605.         HXxRect* paDestRects = NULL;
  1607.         // Try to display a queued frame
  1608.         if (m_pListOfFrames->GetCount())
  1609.         {
  1610.             hr = PresentIfReady();
  1611.         }
  1613.         if (hr != HXR_OK)
  1614.         {
  1615.             CWinBaseRootSurface *pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1617.             if (!pSurface)
  1618.                 return HXR_FAIL;
  1620.             WINDRAW *pWindraw = pSurface->GetWinDraw();
  1622.             // If no dest rect is specified, use surface
  1623.             if (!prDestRect->right && !prDestRect->bottom)
  1624.             {
  1625.                 HXxSize rcSize = {0,0};
  1626.                 m_pSite->GetSize(rcSize);
  1628.                 prDestRect->right = rcSize.cx;
  1629.                 prDestRect->bottom = rcSize.cy;
  1630.             }
  1632.             // Refresh the last rgb image
  1633.             //if (m_bLostHWAcceleration)
  1634.             if (HX_BASIC_BLT == m_nLastBltMode)
  1635.             {
  1636.                 // Do we have a gdi surface to refresh
  1637.                 if (m_nLastGdiSurface >= 0)
  1638.                 {
  1639.                     // If no src rect is specified, use surface
  1640.                     if (!prSrcRect->right && !prSrcRect->bottom)
  1641.                     {
  1642.                         prSrcRect->right = m_allocatedGdiSize.cx;
  1643.                         prSrcRect->bottom = m_allocatedGdiSize.cy;
  1644.                     }
  1646.                     SetLastScale(prSrcRect, prDestRect);
  1648.                     _ConstructRects( *prSrcRect,
  1649.                                      *prDestRect,
  1650.                                      FALSE,
  1651.                                      nNumRects,
  1652.                                      &paSrcRects,
  1653.                                      &paDestRects);
  1655.                     memcpy(&m_lastSrcRect, paSrcRects, sizeof(*paSrcRects)); /* Flawfinder: ignore */
  1657.                     // Do an rgb blt for each display rect
  1658.                     for( int j=0 ; j<nNumRects ; j++ )
  1659.                     {
  1660.                         hr = WinDrawSurface_Blt(pWindraw, &m_GDIsurface, (RECT*)&paDestRects[j], (RECT*)&paSrcRects[j], m_nLastGdiSurface);
  1661.                     }
  1663.                     HX_VECTOR_DELETE(paSrcRects);
  1664.                     HX_VECTOR_DELETE(paDestRects);
  1665.                 }
  1666.             }
  1668.             // If we have a visible overlay, update it
  1669.             else if (WinDraw2_IsSurfaceVisible(pWindraw, &m_surface) && !m_bYUVBlending)
  1670.             {
  1671.                 // If no src rect is specified, use surface
  1672.                 if (!prSrcRect->right && !prSrcRect->bottom)
  1673.                 {
  1674.                     prSrcRect->right = m_surfaceSize.cx;
  1675.                     prSrcRect->bottom = m_surfaceSize.cy;
  1676.                 }
  1678.                 SetLastScale(prSrcRect, prDestRect);
  1680.                 _ConstructRects( *prSrcRect,
  1681.                                  *prDestRect,
  1682.                                  FALSE,
  1683.                                  nNumRects,
  1684.                                  &paSrcRects,
  1685.                                  &paDestRects);
  1687.                 if (nNumRects != 1)
  1688.                 {
  1689.                     HXxPoint screenOffset = m_pSite->GetScreenOffset();
  1691.                     paSrcRects[0] = *prSrcRect;
  1692.                     paDestRects[0] = *prDestRect;
  1694.                     paSrcRects[0].left += screenOffset.x;
  1695.                     paSrcRects[0].top += screenOffset.y;
  1696.                     paSrcRects[0].right += screenOffset.x;
  1697.                     paSrcRects[0].bottom += screenOffset.y;
  1698.                 }
  1700.                 hr = ForceUpdateOverlay( &paDestRects[0],
  1701.                                          &paSrcRects[0], HX_OVER_SHOW|HX_OVER_KEYDEST);
  1703.                 if (HX_NO_BLT == m_nLastBltMode)
  1704.                     hr = HXR_FAIL;
  1705.                 else
  1706.                 {
  1707.                     memcpy(&m_lastSrcRect, paSrcRects, sizeof(*paSrcRects)); /* Flawfinder: ignore */
  1709.                     if (hr == HXR_OK)
  1710.                     {
  1711.                         if (m_bNeedColorKeyFilled && m_pSite->IsSiteVisible())
  1712.                         {
  1713.                             _FillColorKey();
  1714.                         }
  1715.                     }
  1716.                 }
  1718.                 HX_VECTOR_DELETE(paSrcRects);
  1719.                 HX_VECTOR_DELETE(paDestRects);
  1721. #if !defined(_GOLD) && 0
  1722.                 m_TimeStamps.AddSample();
  1723. #endif
  1724.             }
  1725.             else
  1726.             {
  1727.                 // If we are in fallback mode, make them manually redraw
  1728.                 if (m_bFallbackSurfaceCreated && HX_OVERLAY_BLT!=m_nBltMode && !m_bYUVBlending)
  1729.                 {
  1730.                     // If no src rect is specified, use surface
  1731.                     if (!prSrcRect->right && !prSrcRect->bottom)
  1732.                     {
  1733.                         prSrcRect->right = m_allocatedFallbackSize.cx;
  1734.                         prSrcRect->bottom = m_allocatedFallbackSize.cy;
  1735.                     }
  1737.                     SetLastScale(prSrcRect, prDestRect);
  1739.                     _ConstructRects( *prSrcRect,
  1740.                                      *prDestRect,
  1741.                                      FALSE,
  1742.                                      nNumRects,
  1743.                                      &paSrcRects,
  1744.                                      &paDestRects);
  1746.                     memcpy(&m_lastSrcRect, paSrcRects, sizeof(*paSrcRects)); /* Flawfinder: ignore */
  1748.                     EnterCriticalSection(&m_csFallback);
  1750.                     for( int j=0 ; j<nNumRects ; j++ )
  1751.                     {
  1752.                         hr = WinDrawSurface_Blt(pWindraw, &m_fallbackSurface, (RECT*)&paDestRects[j], (RECT*)&paSrcRects[j]);
  1753.                     }
  1755.                     LeaveCriticalSection(&m_csFallback);
  1757.                     HX_VECTOR_DELETE(paSrcRects);
  1758.                     HX_VECTOR_DELETE(paDestRects);
  1760. #if !defined(_GOLD) && 0
  1761.                     m_TimeStamps.AddSample();
  1762. #endif
  1763.                 }
  1764.             }
  1765.         }
  1767.         return hr;
  1768.     }
  1770.     if (m_bFlushing)
  1771.     {
  1772.         return HXR_COULD_NOT_DISPLAY;
  1773.     }
  1775.     INT32   nIndex = -1;
  1777.     // Add this frame to the list and alert the render thread
  1778.     tFrameElement *pItem = new tFrameElement;
  1780.     memset(pItem, 0, sizeof(*pItem));
  1781.     pItem->lTimeStamp = lTime;
  1782.     pItem->nBltMode = HX_OVERLAY_BLT;
  1783.     pItem->ulFlags = ulFlags;
  1784.     pItem->rcSrc = *prSrcRect;
  1785.     pItem->rcDst = *prDestRect;
  1786.     pItem->bAlpha = m_bFrameHasHWAlphaBlend;
  1787.     pItem->count  = pVidStruct->ulCount;
  1788.     pItem->bmi = m_bmi;
  1790.     // If we are in system memory mode, we must blt to hardware ourselves
  1791.     if (m_bUseSysMemSurface)
  1792.     {
  1793.         m_bUseSysMemSurface = FALSE;
  1795.         BOOL bAlphaCheck = m_bDoAlphaCheck;
  1797.         // Grab a hw buffer and convert the sys mem image to hw yuv.
  1798.         UCHAR *pScratchVidMem = NULL;
  1799.         INT32 nPitch = 0;
  1800.         HXBitmapInfoHeader bmiTemp;
  1801.         memset( &bmiTemp, 0, sizeof( bmiTemp ) );
  1803.         // We need a hw mem buffer, so disable the alpha blending check
  1804.         // that returns system mem.
  1805.         m_bDoAlphaCheck = FALSE;
  1807.         VideoMemStruct vs;
  1808.         memset(&vs, 0, sizeof(vs));
  1809.         GetVideoMem(&vs, HX_WAIT_FOREVER);
  1811.         pScratchVidMem = vs.pVidMem;
  1812.         nPitch = vs.lPitch;
  1813.         bmiTemp = vs.bmi;
  1815.         if (pScratchVidMem)
  1816.         {
  1817.             HXxSize srcSize = {bmiTemp.biWidth, bmiTemp.biHeight};
  1818.             SourceInputStruct input = {&m_pSysMemSurf[m_nNextSysMemBuffer].pBuffer,
  1819.                                        &m_nSysMemSurfPitch, 1};
  1821.             ColorConvert(m_nSysMemSurfID,
  1822.                          &m_allocatedSysMemSurfSize,
  1823.                          prSrcRect,
  1824.                          &input,
  1825.                          bmiTemp.biCompression,
  1826.                          pScratchVidMem,
  1827.                          &srcSize,
  1828.                          prDestRect,
  1829.                          nPitch);
  1831.             ReleaseSurface(&vs, FALSE);
  1832.         }
  1834.         m_bDoAlphaCheck = bAlphaCheck;
  1836.         if (!pScratchVidMem)
  1837.             goto FAILURE;
  1839.         pItem->nIndex = m_nNextSysMemBuffer;
  1840.         if (++m_nNextSysMemBuffer == m_nSysMemSurfCount)
  1841.             m_nNextSysMemBuffer = 0;
  1842.     }
  1844.     // Alpha blend if necessary
  1845.     if (pVidStruct->pAlphaList && pVidStruct->ulCount)
  1846.     {
  1847.         HXxSize size = {pVidStruct->bmi.biWidth, pVidStruct->bmi.biHeight};
  1849.         YuvAlphaBlend(pVidStruct->pAlphaList,
  1850.                       pVidStruct->ulCount,
  1851.                       pVidStruct->pVidMem,
  1852.                       pVidStruct->bmi.biCompression,
  1853.                       pVidStruct->lPitch,
  1854.                       &size);
  1855.     }
  1857.     // If our last lock was not using overlay, use our offscreen blt
  1858.     if (m_bScratchSurface)
  1859.     {
  1860.         if (!m_fallbackSurface.dd.lpDDSurface)
  1861.             goto FAILURE;
  1863.         pItem->nBltMode = HX_BLT_YUV_STRETCH;
  1864.         pItem->pAlphaList = pVidStruct->pAlphaList;
  1866.         ResetEvent(m_hFallbackEmpty);
  1867.     }
  1868.     // Our last lock was using gdi
  1869.     else if (m_bGDISurface)
  1870.     {
  1871.         pItem->nBltMode = HX_BASIC_BLT;
  1872.         pItem->pAlphaList = pVidStruct->pAlphaList;
  1873.         pItem->nIndex = m_nNextGdiSurface;
  1874.     }
  1875.     else
  1876.     {
  1877.         // Advance the overlay surface list
  1878.         int nNewIndex = nIndex;
  1880.         if (!m_surface.dd.lpDDSurface)
  1881.             goto FAILURE;
  1883.         CWinBaseRootSurface *pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1885.         if (!pSurface)
  1886.             goto FAILURE;
  1888.         WINDRAW *pWindraw = pSurface->GetWinDraw();
  1890.         if (HXR_OK != WinDraw_AdvanceSurface (pWindraw, &m_surface, nNewIndex))
  1891.             goto FAILURE;
  1893.         pItem->nIndex = nNewIndex;
  1894.         pItem->nBltMode = HX_OVERLAY_BLT;
  1895.     }
  1897.     // Increase the mutex lock count so another thread does not lock
  1898.     // it before we queue this frame or prevent us from drawing immediately.
  1899.     WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  1901.     // We delete the alphalist in DisplayFrame in yuv_stretch mode.
  1902.     ReleaseSurface(pVidStruct, FALSE, (pItem->nBltMode!=HX_BLT_YUV_STRETCH));
  1904.     // Immediate display...don't queue
  1905.     if (ulFlags & HX_MODE_IMMEDIATE)
  1906.     {
  1907.         HRESULT hr;
  1908.         tFrameElement lastItem;
  1910.         for (int i=0; i<5; i++)
  1911.         {
  1912.             pItem->dwDDFlags = DDFLIP_WAIT;
  1914.             lastItem = *pItem;
  1915.             hr = DisplayFrame(pItem);
  1917.             // Need to try again
  1918.             if (DDERR_WASSTILLDRAWING == hr)
  1919.             {
  1920.                 *pItem = lastItem;
  1921.                 WaitForSingleObject(m_hAbort, 10);
  1922.             }
  1923.             // Probably can not async flip, so turn it off
  1924.             else if (DDERR_INVALIDPARAMS == hr && m_bUseVBlankFlip)
  1925.             {
  1926.                 *pItem = lastItem;
  1927.                 m_bUseVBlankFlip = FALSE;
  1928.             }
  1929.             else
  1930.             {
  1931.                 // Abort this overaly surface on a failure
  1932.                 if (DD_OK != hr && pItem->nBltMode == HX_OVERLAY_BLT)
  1933.                 {
  1934.                     CWinBaseRootSurface *pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1935.                     if (!pSurface)
  1936.                         goto FAILURE;
  1938.                     WINDRAW *pWindraw = pSurface->GetWinDraw();
  1940.                     WinDraw_DisplaySurface(pWindraw, &m_surface, pItem->dwDDFlags, pItem->nIndex, TRUE);
  1941.                 }
  1943.                 break;
  1944.             }
  1945.         }
  1947.         ReleaseMutex(m_hSurfaceMutex);
  1948.         delete pItem;
  1950. #if !defined(_GOLD) && 0
  1951.         m_TimeStamps.AddSample();
  1952. #endif
  1953.         return HXR_OK;
  1954.     }
  1956.     EnterCriticalSection(&m_csList);
  1957.     m_pListOfFrames->AddTail((void*)pItem);
  1958.     LeaveCriticalSection(&m_csList);
  1960.     ReleaseSemaphore(m_hFrameSem, 1, NULL);
  1961.     ReleaseMutex(m_hSurfaceMutex);
  1963. #if !defined(_GOLD) && 0
  1964.     m_TimeStamps.AddSample();
  1965. #endif
  1966.     return HXR_OK;
  1968.   FAILURE:
  1969.     delete pItem;
  1971.     return HXR_FAIL;
  1973. }
  1975. STDMETHODIMP_(void) CWinSurface2::Flush()
  1976. {
  1977.     m_bFlushing = TRUE;
  1979.     //This needs to be before the wait on m_hSurfaceMutex because if
  1980.     //you hit stop before we start blt'ing frames you could be waiting
  1981.     //a long time before it wakes up. At least in the case for live
  1982.     //streams where we don't have the server/ff seek back to the
  1983.     //nearest keyframe and send data. Some streams have keyframes
  1984.     //every 10seconds or so.
  1985.     PulseEvent(m_hAbort);
  1987.     WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  1989.     CWinBaseRootSurface *pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1990.     WINDRAW *pWindraw = pSurface->GetWinDraw();
  1992.     // Cancel and pending frames
  1993.     WinDraw_CacelPendingDisplay (pWindraw, &m_surface);
  1994.     PulseEvent(m_hForceRender);
  1996.     Sleep(5);
  1998.     // Wait until our queue count reaches 0
  1999.     int nCount = m_pListOfFrames->GetCount();
  2001.     while (nCount)
  2002.     {
  2003.         WinDraw_CacelPendingDisplay (pWindraw, &m_surface);
  2004.         PulseEvent(m_hAbort);
  2005.         PulseEvent(m_hForceRender);
  2007.         Sleep(5);
  2009.         nCount = m_pListOfFrames->GetCount();
  2010.     }
  2012.     ResetBufferTimes(0);
  2013.     ReleaseMutex(m_hSurfaceMutex);
  2015.     m_bFlushing = FALSE;
  2016. }
  2018. void CWinSurface2::ResetBufferTimes(INT32 nTime)
  2019. {
  2020.     // Reset all buffer times
  2021.     if (m_surface.dwBackBufferCount)
  2022.     {
  2023.         for (UINT32 i=0; i<m_surface.dwBackBufferCount+1; i++)
  2024.             m_surface.dd.lpChain[i].dTimeAvailable = nTime;
  2025.     }
  2026. }
  2028. STDMETHODIMP CWinSurface2::PresentIfReady()
  2029. {
  2030.     HX_RESULT hr = E_FAIL;
  2032.     if (!m_pTimeLine | m_bIngnorePresentIfReady)
  2033.         return hr;
  2035.     UINT32 ulTime = 0;
  2036.     if (HXR_TIMELINE_SUSPENDED != m_pTimeLine->GetTimeLineValue(ulTime))
  2037.     {
  2038.         if (((m_nLastDisplayTime > 0) && (m_nLastDisplayTime - (INT32)ulTime < 0)))
  2039.         {
  2040.             #ifdef LOG_JITTER_DATA
  2041.             FILE *fp = fopen(JITTER_LOG_FILE, "a+");
  2042.             if (fp)
  2043.             {
  2044.                 fprintf(fp, "PresentIfReady Interrupt clock %ld last display %ldn", ulTime, m_nLastDisplayTime);
  2045.                 fclose(fp);
  2046.             }
  2048.             #endif
  2050.             PulseEvent(m_hForceRender);
  2051.             Sleep(0);
  2053. #ifdef _DEBUG
  2054.             //OutputDebugString("PresentIfReady Interruptn");
  2055. #endif
  2057.             hr = HXR_OK;
  2058.         }
  2059.     }
  2061.     return hr;
  2062. }
  2064. HX_RESULT CWinSurface2::DisplayFrame(tFrameElement* pItem)
  2065. {
  2066.     HRESULT hr = HXR_OK,
  2067.             hrTimeLine = HXR_OK;
  2068.     HXxSize rcSize = {0,0};
  2070.     int     nNumRects   = 0;
  2071.     BOOL    bSub1x = FALSE;
  2073.     m_pSite->_TLSLock();
  2075.     CWinBaseRootSurface *pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  2077.     if (!pSurface)
  2078.     {
  2079.         m_pSite->_TLSUnlock();
  2080.         return HXR_FAIL;
  2081.     }
  2083.     WINDRAW *pWindraw = pSurface->GetWinDraw();
  2085.     // Ensure our site is visible before displaying
  2086.     BOOL    bVisibleSite = (!HXEmptyRegion(m_pSite->m_Region)|| pItem->count || pItem->bAlpha)
  2087.                            && m_pSite->IsSiteVisible()
  2088.                            && !m_pSite->_FadeTransitionActive();
  2090.     if (pItem->nBltMode == HX_OVERLAY_BLT)
  2091.     {
  2092.         // If no src rect is specified, use surface
  2093.         if (!pItem->rcSrc.right && !pItem->rcSrc.bottom)
  2094.         {
  2095.             pItem->rcSrc.right = m_surfaceSize.cx;
  2096.             pItem->rcSrc.bottom = m_surfaceSize.cy;
  2097.         }
  2099.         // Put the frame on the screen
  2100.         int nIndex = pItem->nIndex-1;
  2101.         if (nIndex < 0)
  2102.             nIndex = m_nBackBufferCount;
  2104.         if (pItem->dwDDFlags & DDFLIP_WAIT == DDFLIP_WAIT)
  2105.         {
  2106.             // Immediate mode blits have no calculated timaAvailable; use
  2107.             // the current time:
  2108.             pItem->dTimeAvailable = GetMSTickDouble32();
  2109.         }
  2111.         m_surface.dd.lpChain[nIndex].dTimeAvailable = pItem->dTimeAvailable;
  2112.         m_surface.dd.lpChain[pItem->nIndex].dTimeAvailable = 0;
  2114.         hr = WinDraw_DisplaySurface(pWindraw, &m_surface, pItem->dwDDFlags, pItem->nIndex, m_bFlushing);
  2116. #ifdef LOG_JITTER_DATA
  2117.         UINT32 ulTimeAfter = 0;
  2118.         m_pTimeLine->GetTimeLineValue(ulTimeAfter);
  2120.         FILE *fp = fopen(JITTER_LOG_FILE, "a+");
  2121.         if (fp)
  2122.         {
  2123.             UINT32 dwScanLine = 0;
  2124.             WinDraw2_GetScanLine(pWindraw, &dwScanLine);
  2126.             fprintf(fp, "Calling flip: scan line %ld clock after %ld ts %ld jitter %ldnn", dwScanLine, ulTimeAfter, pItem->lTimeStamp, (INT32)(pItem->lTimeStamp-ulTimeAfter));
  2127.             fclose(fp);
  2128.         }
  2129. #endif //LOG_JITTER_DATA
  2131.         if (DD_OK == hr && bVisibleSite)
  2132.         {
  2133.             m_nLastBltMode = HX_OVERLAY_BLT;
  2135.             // Make sure we are painting colorkey in fullscreen mode.
  2136.             // We will fix this when fillcolor key is fixed.
  2137.             if (m_pSite->m_pTopLevelSite &&
  2138.                 m_pSite->m_pTopLevelSite->m_bInFullScreen)
  2139.             {
  2140.                 if (++m_ulFillColoryKeyCount < 15)
  2141.                     memset(&m_rcLast, 0, sizeof(m_rcLast));
  2142.             }
  2143.             else
  2144.                 m_ulFillColoryKeyCount = 0;
  2146.             if (!IsShrinking() || _AllowsOverlayShrinking())
  2147.             {
  2148.                 // Restore overlay
  2149.                 if (HX_OVERLAY_BLT != m_nBltMode)
  2150.                 {
  2151.                     ForceGDIMode(FALSE);
  2152.                 }
  2154.                 // If no src rect is specified, use surface
  2155.                 if (!pItem->rcDst.right && !pItem->rcDst.bottom)
  2156.                 {
  2157.                     m_pSite->GetSize(rcSize);