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

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

Symbian

开发平台：

Visual C++

winsurf2.cpp：源码内容
  2.                     pItem->rcDst.right = rcSize.cx;
  3.                     pItem->rcDst.bottom = rcSize.cy;
  4.                 }
  6.                 SetLastScale(&pItem->rcSrc, &pItem->rcDst);
  8.                 double dScaleX = m_scaleFactorX,
  9.                        dScaleY = m_scaleFactorY;
  11.                 // Setup new src and dest rects....
  12.                 _ConstructRects( pItem->rcSrc,
  13.                                  pItem->rcDst,
  14.                                  FALSE,
  15.                                  nNumRects,
  16.                                  &m_paSrcRects,
  17.                                  &m_paDestRects);
  19.                 if (nNumRects != 1)
  20.                 {
  21.                     HXxPoint screenOffset = m_pSite->GetScreenOffset();
  23.                     if (!m_paSrcRects)
  24.                         m_paSrcRects = (HXxRect*)malloc(sizeof(HXxRect));
  26.                     if (!m_paDestRects)
  27.                         m_paDestRects = (HXxRect*)malloc(sizeof(HXxRect));;
  29.                     m_paSrcRects[0] = pItem->rcSrc;
  30.                     m_paDestRects[0] = pItem->rcDst;
  32.                     m_paSrcRects[0].left += screenOffset.x;
  33.                     m_paSrcRects[0].top += screenOffset.y;
  34.                     m_paSrcRects[0].right += screenOffset.x;
  35.                     m_paSrcRects[0].bottom += screenOffset.y;
  36.                 }
  38.                 if (m_paSrcRects && m_paDestRects)
  39.                 {
  40.                     ForceUpdateOverlay(&m_paDestRects[0], &m_paSrcRects[0], HX_OVER_SHOW|HX_OVER_KEYDEST, TRUE);
  41.                 }
  43.                 if (m_bNeedColorKeyFilled)
  44.                 {
  45.                     m_bDisableFillColorKey = FALSE;
  46.                     _FillColorKey();
  47.                 }
  49.                 // Alpha blended images are drawn before the video so the scaling gets messed up on
  50.                 // static images.  Force a redraw to correct the problem.
  51.                 if ((dScaleX != m_scaleFactorX || dScaleY != m_scaleFactorY) && m_pSite->IsFullScreen())
  52.                 {
  54.                     HXxRect dirty = {m_pSite->m_pTopLevelSite->m_topleft.x,
  55.                                      m_pSite->m_pTopLevelSite->m_topleft.y,
  56.                                      m_pSite->m_pTopLevelSite->m_topleft.x+m_pSite->m_pTopLevelSite->m_size.cx,
  57.                                      m_pSite->m_pTopLevelSite->m_topleft.y+m_pSite->m_pTopLevelSite->m_size.cy};
  59.                     m_pSite->m_pTopLevelSite->_RecursiveDamageRect(&dirty, TRUE);
  60.                     m_pSite->m_pTopLevelSite->_ForceRedrawAll();
  61.                 }
  62.             }
  63.         }
  64.         else if (HXR_FAIL == hr)
  65.         {
  66.             // Turn off overlay
  67.             m_bMultipleOverlay = TRUE;
  68.         }
  69.     }
  70.     else if (pItem->nBltMode == HX_BLT_YUV_STRETCH)
  71.     {
  72.         // If no src rect is specified, use surface
  73.         if (!pItem->rcSrc.right && !pItem->rcSrc.bottom)
  74.         {
  75.             pItem->rcSrc.right = m_allocatedFallbackSize.cx;
  76.             pItem->rcSrc.bottom = m_allocatedFallbackSize.cy;
  77.         }
  79.         // If no src rect is specified, use surface
  80.         if (!pItem->rcDst.right && !pItem->rcDst.bottom)
  81.         {
  82.             m_pSite->GetSize(rcSize);
  84.             pItem->rcDst.right = rcSize.cx;
  85.             pItem->rcDst.bottom = rcSize.cy;
  86.         }
  88.         SetLastScale(&pItem->rcSrc, &pItem->rcDst);
  90.         if (bVisibleSite && !m_bFlushing)
  91.         {
  92.             m_nLastBltMode = HX_BLT_YUV_STRETCH;
  94.             // Ok, this is great. We need to add the regions from our
  95.             // yuv alphablending rects to our m_Region so that
  96.             // constructrects will return the correct scaled rects for
  97.             // us to blt. We have to do this here because
  98.             // _ConstructRects doesn't know anything about YUV
  99.             // optimized alphablending.  It works in overlay because
  100.             // we have m_pAdditionalColorKey
  101.             //
  102.             HXREGION* pTmp = NULL;
  103.             if( pItem->pAlphaList && m_pSite->m_Region )
  104.             {
  105.                 pTmp = HXCreateRegion();
  106.                 HXUnionRegion( pTmp, m_pSite->m_Region, pTmp );
  108.                 for( int w=0 ; w<pItem->count; w++)
  109.                 {
  110.                     HXRECTANGLE pRect;
  111.                     pRect.x      = (short)pItem->pAlphaList[w].rcImageRect.left;
  112.                     pRect.y      = (short)pItem->pAlphaList[w].rcImageRect.top;
  113.                     pRect.width  = (short)HXxRECT_WIDTH(pItem->pAlphaList[w].rcImageRect);
  114.                     pRect.height = (short)HXxRECT_HEIGHT(pItem->pAlphaList[w].rcImageRect);
  116.                     //Add in our offsets from the corner of the
  117.                     //toplevel site.
  118.                     pRect.x += (short)m_pSite->m_topleft.x;
  119.                     pRect.y += (short)m_pSite->m_topleft.y;
  121.                     // We must scale this rect to the scale factor of
  122.                     // this surface. This really only comes into play
  123.                     // if we are shrinking the site to sub 1x and we
  124.                     // are still BLTing a YUV surface.
  125.                     pRect.x      = (int)((double)pRect.x*m_scaleFactorX+.5);
  126.                     pRect.y      = (int)((double)pRect.y*m_scaleFactorY+.5);
  128.                     HXUnionRectWithRegion( &pRect, pTmp, pTmp );
  129.                 }
  130.             }
  131.             // Setup new src and dest rects....
  132.             _ConstructRects( pItem->rcSrc,
  133.                              pItem->rcDst,
  134.                              FALSE,
  135.                              nNumRects,
  136.                              &m_paSrcRects,
  137.                              &m_paDestRects,
  138.                              pTmp);
  140.             if( pTmp )
  141.             {
  142.                 HXDestroyRegion(pTmp);
  143.             }
  145.             bSub1x = IsShrinking() && !_AllowsOverlayShrinking();
  147.             BOOL bLoseOverlay = FALSE;
  149.             // Lose overlay
  150.             if (HX_OVERLAY_BLT == m_nBltMode && bSub1x)
  151.             {
  152.                 bLoseOverlay = TRUE;
  153.                 m_bDisableFillColorKey = TRUE;
  154.             }
  156.             CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  157.             WINDRAW* pWindraw = pSurface->GetWinDraw();
  159.             EnterCriticalSection(&m_csFallback);
  161.             // Do an offscreen blt for each display rect
  162.             for( int j=0 ; j<nNumRects ; j++ )
  163.             {
  164.                 hr = WinDrawSurface_Blt(pWindraw, &m_fallbackSurface, (RECT*)&m_paDestRects[j], (RECT*)&m_paSrcRects[j]);
  166.                 if (hr != DD_OK)
  167.                 {
  168.                     // Some boards fail on yuv blts, so try a new format on strange errors
  169.                     if (DDERR_INVALIDRECT   != hr &&
  170.                         DDERR_INVALIDPARAMS != hr &&
  171.                         DDERR_SURFACEBUSY   != hr &&
  172.                         DDERR_SURFACELOST   != hr)
  173.                     {
  174.                         if (HXR_OK == TryNewFallback())
  175.                         {
  176.                             // we created a new surface, discard this frame
  177.                             break;
  178.                         }
  179.                     }
  181.                     break;
  182.                 }
  183.             }
  185.             LeaveCriticalSection(&m_csFallback);
  187.             if (bLoseOverlay)
  188.             {
  189.                 m_bDisableFillColorKey = TRUE;
  190.                 ForceUpdateOverlay(&m_paDestRects[0], &m_paSrcRects[0], HX_OVER_HIDE|HX_OVER_KEYDEST);
  192.                 ForceGDIMode(TRUE);
  193.             }
  195.         }
  197.         if (pItem->pAlphaList)
  198.         {
  199.             delete [] pItem->pAlphaList;
  200.         }
  202.         SetEvent(m_hFallbackEmpty);
  203.     }
  204.     else
  205.     {
  206.         INT32 nLastGdiSurface = m_nLastGdiSurface;
  208.         // If no src rect is specified, use surface
  209.         if (!pItem->rcSrc.right && !pItem->rcSrc.bottom)
  210.         {
  211.             pItem->rcSrc.right = m_allocatedGdiSize.cx;
  212.             pItem->rcSrc.bottom = m_allocatedGdiSize.cy;
  213.         }
  215.         // If no src rect is specified, use surface
  216.         if (!pItem->rcDst.right && !pItem->rcDst.bottom)
  217.         {
  218.             m_pSite->GetSize(rcSize);
  220.             pItem->rcDst.right = rcSize.cx;
  221.             pItem->rcDst.bottom = rcSize.cy;
  222.         }
  224.         SetLastScale(&pItem->rcSrc, &pItem->rcDst);
  226.         if (bVisibleSite && !m_bFlushing)
  227.         {
  228.             m_nLastBltMode = HX_BASIC_BLT;
  230.             // Setup new src and dest rects....
  231.             _ConstructRects( pItem->rcSrc,
  232.                              pItem->rcDst,
  233.                              FALSE,
  234.                              nNumRects,
  235.                              &m_paSrcRects,
  236.                              &m_paDestRects);
  238.             // Do a gdi blt for each display rect
  239.             for( int j=0 ; j<nNumRects ; j++ )
  240.             {
  241.                 hr = WinDrawSurface_Blt(pWindraw, &m_GDIsurface, (RECT*)&m_paDestRects[j], (RECT*)&m_paSrcRects[j], pItem->nIndex);
  242.             }
  244.             if (HX_OVERLAY_BLT == m_nBltMode)
  245.             {
  246.                 m_bDisableFillColorKey = TRUE;
  248.                 m_bDisableFillColorKey = TRUE;
  249.                 ForceUpdateOverlay(&m_paDestRects[0], &m_paSrcRects[0], HX_OVER_HIDE|HX_OVER_KEYDEST);
  251.                 ForceGDIMode(TRUE);
  252.             }
  253.         }
  255.         m_nLastGdiSurface = pItem->nIndex;
  257.         // Release the lock on this surface after we updated it.  We keep around the last
  258.         // image for refreshing.
  259.         if (nLastGdiSurface >= 0)
  260.         {
  261.             SetEvent(m_GDIsurface.gdi.lpGDIBackBuffer[nLastGdiSurface]->hEmpty);
  262.         }
  263.     }
  265.     //We are done blt'ing all our rects. Lets notify everyone that
  266.     //might be interested in alpha blending that we changed.
  267.     int nTot = m_pSite->m_AlphaBlendNotifiers.GetCount();
  268.     if( nTot>0 && !m_pSite->IsCompositionMode() && m_bOffBecauseofShinking)
  269.     {
  270.         //XXXgfw Once we have optimized YUV blenders, do even bother
  271.         //calling this as YUV blends from the bottom up and all this
  272.         //has already been done.
  273.         if( m_pSite && m_pSite->m_pTopLevelSite )
  274.             m_pSite->m_pTopLevelSite->ScheduleCallback(REDRAW_ALL, 0);
  275.     }
  278.     m_pSite->_TLSUnlock();
  280.     if (DDERR_WRONGMODE == hr)
  281.         hr = HXR_OK;
  283.     // Update blt stats
  284.     if (HXR_OK == hr && !m_bFlushing)
  285.     {
  286.         UpdateBltStats(&pItem->rcDst);
  287.     }
  289.     return hr;
  290. }
  292. DWORD WINAPI CWinSurface2::ThreadProc(CWinSurface2* pThis)
  293. {
  294.     return pThis->RenThread();
  295. }
  297. DWORD CWinSurface2::RenThread()
  298. {
  299.     BOOL    bMeasureJitter = FALSE;
  300.     HRESULT hr;
  301.     tFrameElement *pItem;
  302.     HANDLE  aObjects[2] = {m_hFrameSem, m_hAbort},
  303.     aRenderObjects[2] = {m_hForceRender, m_hAbort};
  304.     UINT32  nResolution = SCHEDULE_GRANULE;
  305.     tFrameElement lastItem;
  307. #ifdef ENABLE_ERROR_TRACE
  308.     g_ulFrameCount = 0;
  309.     g_ulSleepCount = 0;
  310. #endif // ENABLE_ERROR_TRACE
  312.     // Read some preferences
  313.     IHXPreferences*    pPreferences    = NULL;
  314.     IHXBuffer*         pBuffer         = NULL;
  316. #if !defined(_GOLD) && 0
  317.     CTimeSample  sample;
  318.     sample.Init(m_pContext, (void*)this);
  319. #endif
  321.     if (HXR_OK == m_pContext->QueryInterface(IID_IHXPreferences,(void**)&pPreferences))
  322.     {
  323.         // Use vblank flags for flipping
  324.         if (pPreferences->ReadPref("VideoBoost\MeasureJitter", pBuffer) == HXR_OK)
  325.             bMeasureJitter = ::atoi((char*) pBuffer->GetBuffer());
  327.         HX_RELEASE(pBuffer);
  329.         if (pPreferences->ReadPref("VideoBoost\SchedulerResolution", pBuffer) == HXR_OK)
  330.             nResolution = ::atoi((char*) pBuffer->GetBuffer());
  332.         if (pPreferences->ReadPref("VideoBoost\IgnorePresentIfReady", pBuffer) == HXR_OK)
  333.             m_bIngnorePresentIfReady = ::atoi((char*) pBuffer->GetBuffer());
  335.         HX_RELEASE(pPreferences);
  336.     }
  338.     CWinBaseRootSurface *pSurface = NULL;
  339.     WINDRAW *pWindraw = NULL;
  341.     pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  342.     if (pSurface)
  343.     {
  344.         pWindraw = pSurface->GetWinDraw();
  345.         pWindraw->nSchedulerResolution = nResolution;
  346.     }
  348. #ifdef HARDCODE_GRANULE
  349.     if (nResolution)
  350.         timeBeginPeriod(nResolution);
  351. #endif //HARDCODE_GRANULE
  353.     // Make sure timeline is active. If Wait returns and error,
  354.     // an abort message work it up, so check if our thread is
  355.     // supposed to keep running, and if so, wait again.
  356.     while (HXR_OK != WaitForTimeLine(0) && m_bCont && !m_bFlushing)
  357.         continue;
  359.     while (m_bCont)
  360.     {
  361.         m_nLastDisplayTime = -1;
  363.         // Wait for a frame or an abort
  364.         hr = WaitForMultipleObjects(2, aObjects, FALSE, INFINITE);
  366.         if (hr - WAIT_OBJECT_0 == 0 || hr - WAIT_OBJECT_0 == 1)
  367.         {
  368.             if (m_pListOfFrames->GetCount())
  369.             {
  370.                 // Grab the first frame off the list
  371.                 EnterCriticalSection(&m_csList);
  372.                 pItem = (tFrameElement*)m_pListOfFrames->GetHead();
  373.                 LeaveCriticalSection(&m_csList);
  375.                 EnterCriticalSection(&m_csDisplay);
  377. TIME_AND_BLT_AGAIN:
  378.                 pItem->dwDDFlags = 0;
  380.                 pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  381.                 HX_ASSERT(pSurface);
  383.                 // The root surface may have been destroyed
  384.                 if (pSurface)
  385.                 {
  386.                     pWindraw = pSurface->GetWinDraw();
  388.                     if (m_bQueryMonitorFreq)
  389.                     {
  390.                         HX_ASSERT(pWindraw->dRefreshRate != 0);
  391.                         HX_ASSERT(pWindraw->dwReportedHeight);
  392.                     }
  394.                     // Blocks until display time
  395.                     _ScheduleFrameForDisplay(pWindraw, pItem, nResolution);
  397.                     // Preserve our frame descriptor
  398.                     lastItem = *pItem;
  399.                     hr = DisplayFrame(pItem);
  401.                     // Check if the root surface was destroyed during the scheduling
  402.                     pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  403.                     if (pSurface)
  404.                         pWindraw = pSurface->GetWinDraw();
  406.                     // Need to try again
  407.                     if (DDERR_WASSTILLDRAWING == hr)
  408.                     {
  409.                         // Restore our frame descriptor
  410.                         *pItem = lastItem;
  411.                         WaitForMultipleObjects(2, aRenderObjects, FALSE, 10);
  412.                         goto TIME_AND_BLT_AGAIN;
  413.                     }
  414.                     // Probably can not async flip, so turn it off
  415.                     else if (DDERR_INVALIDPARAMS == hr && m_bUseVBlankFlip)
  416.                     {
  417.                         // Restore our frame descriptor
  418.                         *pItem = lastItem;
  419.                         m_bUseVBlankFlip = FALSE;
  420.                         goto TIME_AND_BLT_AGAIN;
  421.                     }
  422.                     else if (DD_OK != hr)
  423.                     {
  424.                         // Need to discard the overlay
  425.                         if (pItem->nBltMode == HX_OVERLAY_BLT && pSurface)
  426.                         {
  427.                             WinDraw_DisplaySurface(pWindraw, &m_surface, pItem->dwDDFlags, pItem->nIndex, TRUE);
  428.                         }
  430.                         hr = DD_OK;
  431.                     }
  433.                     if (m_bQueryMonitorFreq &&
  434.                         DD_OK == hr &&
  435.                         pSurface)
  436.                     {
  437.                         m_bQueryMonitorFreq = FALSE;
  438.                         WinDraw2_GetMonitorProperties(pWindraw);
  439.                     }
  441.                     if (HXR_OK == hr)
  442.                     {
  443.                         // Delete the frame element
  444.                         EnterCriticalSection(&m_csList);
  445.                         pItem = (tFrameElement*)m_pListOfFrames->RemoveHead();
  446.                         LeaveCriticalSection(&m_csList);
  448.                         delete pItem;
  449.                         pItem = NULL;
  450.                     }
  451.                 }
  453.                 LeaveCriticalSection(&m_csDisplay);
  454.             }
  455.         }
  456.     }
  458. #ifdef ENABLE_ERROR_TRACE
  460.     // Calculate mean and std. dev:
  461.     double dSum = 0;
  462.     double dAbsSum = 0;
  463.     double dMin = 1000000;
  464.     double dMax = -1000000;
  466.     UINT32 i;
  467.     // Skip first and last ten frames:
  468.     for (i = 10; i < min(g_ulFrameCount - 10, 10000); i++)
  469.     {
  470.         dSum += g_error[i][1];
  471.         dAbsSum += abs(g_error[i][1]);
  473.         if (g_error[i][1] < dMin)
  474.         {
  475.             dMin = g_error[i][1];
  476.         }
  477.         if (g_error[i][1] > dMax)
  478.         {
  479.             dMax = g_error[i][1];
  480.         }
  481.     }
  483.     HX_TRACE("Min:t%fn", dMin);
  484.     HX_TRACE("Max:t%fn", dMax);
  486.     double dMean = dSum / min(g_ulFrameCount - 20, 10000);
  487.     HX_TRACE("Mean:t%fn", dMean);
  488.     HX_TRACE("Abs. Mean:t%fn", dAbsSum / min(g_ulFrameCount - 20, 10000));
  490.     double dStdDev = 0;
  491.     for (i = 10; i < min(g_ulFrameCount - 10, 10000); i++)
  492.     {
  493.         dStdDev += pow(dMean - g_error[i][1], 2);
  494.     }
  496.     dStdDev /= min(g_ulFrameCount -20, 10000) - 1;
  497.     dStdDev = sqrt(dStdDev);
  499.     HX_TRACE("Std. dev:t%fn", dStdDev);
  501.     // Calculate alternate mean and std. dev:
  502.     dSum = 0;
  503.     dMin = 1000000;
  504.     dMax = -1000000;
  506.     for (i = 10; i < min(g_ulFrameCount - 10, 10000); i++)
  507.     {
  508.         dSum += g_alternateError[i];
  510.         if (g_alternateError[i] < dMin)
  511.         {
  512.             dMin = g_alternateError[i];
  513.         }
  514.         if (g_alternateError[i] > dMax)
  515.         {
  516.             dMax = g_alternateError[i];
  517.         }
  518.     }
  520.     HX_TRACE("Alternate min:t%fn", dMin);
  521.     HX_TRACE("Alternate Max:t%fn", dMax);
  523.     dMean = dSum / min(g_ulFrameCount - 20, 10000);
  524.     HX_TRACE("Alternate mean:t%fn", dMean);
  526.     dStdDev = 0;
  527.     for (i = 10; i < min(g_ulFrameCount - 10, 10000); i++)
  528.     {
  529.         dStdDev += pow(dMean - g_alternateError[i], 2);
  530.     }
  532.     dStdDev /= min(g_ulFrameCount - 20, 10000) - 1;
  533.     dStdDev = sqrt(dStdDev);
  535.     HX_TRACE("Alternate std. dev:t%fn", dStdDev);
  537.     DumpErrorEntries();
  538. #endif // ENABLE_ERROR_TRACE
  540. #ifdef ENABLE_SYNC_TRACE
  541.     DumpSyncEntries();
  542. #endif // ENABLE_SYNC_TRACE
  544. #ifdef HARDCODE_GRANULE
  545.     if (nResolution)
  546.         timeEndPeriod(nResolution);
  547. #endif //HARDCODE_GRANULE
  549.     return 0;
  550. }
  552. BOOL CWinSurface2::GetColorConverter(int cIdIn, int cIdOut)
  553. {
  554.     //grab the non padded converters...
  555.     BOOL bConverter = zm_pColorAcc->CheckColorConverter(cIdIn, cIdOut);
  556.     m_pSite->ColorConverterRequest(cIdIn, cIdOut, bConverter);
  558.     return bConverter;
  559. }
  561. BOOL CWinSurface2::GetColorConverter2(int cIdIn, int cIdOut)
  562. {
  563.     //grab the padded converters...
  564.     BOOL bConverter = zm_pColorAcc->CheckColorConverter2(cIdIn, cIdOut);
  565.     m_pSite->ColorConverterRequest(cIdIn, cIdOut, bConverter);
  567.     return bConverter;
  568. }
  570. int CWinSurface2::ColorConvert(INT32 cidOut, unsigned char *dest_ptr,
  571.                                int dest_width, int dest_height,
  572.                                int dest_pitch, int dest_x, int dest_y,
  573.                                int dest_dx, int dest_dy,
  574.                                INT32 cidIn, unsigned char *src_ptr,
  575.                                int src_width, int src_height,
  576.                                int src_pitch, int src_x, int src_y,
  577.                                int src_dx, int src_dy)
  578. {
  579.     return zm_pColorAcc->ColorConvert(cidOut, dest_ptr,
  580.                                       dest_width, dest_height,
  581.                                       dest_pitch, dest_x, dest_y,
  582.                                       dest_dx, dest_dy,
  583.                                       cidIn, src_ptr,
  584.                                       src_width, src_height,
  585.                                       src_pitch, src_x, src_y,
  586.                                       src_dx, src_dy);
  587. }
  589. int CWinSurface2::ColorConvert2(INT32 cidOut, unsigned char *dest_ptr,
  590.                                 int dest_width, int dest_height,
  591.                                 int dest_pitch, int dest_x, int dest_y,
  592.                                 int dest_dx, int dest_dy,
  593.                                 INT32 cidIn, unsigned char *pY,
  594.                                 unsigned char *pU, unsigned char *pV,
  595.                                 int src_width, int src_height,
  596.                                 int yPitch, int uPitch, int vPitch,
  597.                                 int src_x, int src_y, int src_dx, int src_dy)
  598. {
  599.     return zm_pColorAcc->ColorConvert2(cidOut, dest_ptr,
  600.                                        dest_width, dest_height,
  601.                                        dest_pitch, dest_x, dest_y,
  602.                                        dest_dx, dest_dy,
  603.                                        cidIn, pY, pU, pV,
  604.                                        src_width, src_height,
  605.                                        yPitch, uPitch, vPitch,
  606.                                        src_x, src_y, src_dx, src_dy);
  607. }
  609. HX_RESULT CWinSurface2::RelinquishOverlay()
  610. {
  611.     // Prevent access to video memory while we tear down our surfaces
  612.     WaitForSingleObject(m_hSurfaceMutex, INFINITE);
  614.     m_bSwitchingingOverlay = TRUE;
  615.     WaitForQueuedFrames();
  617.     HX_RESULT res = CWinSurface::RelinquishOverlay();
  619.     if (res == HXR_OK)
  620.     {
  621.         // Create a fallback and always use it
  622.         if (m_bVideoSurface2)
  623.         {
  624.             CreateFallbackSurface(m_nFallbackSurfaceCID, &m_allocatedFallbackSize);
  625.             m_bMultipleOverlay = TRUE;
  626.         }
  628.         // Force the renderer who lost overlay to redraw to cover the colorkey
  629.         HXxRect dirty = {m_pSite->m_topleft.x,
  630.                          m_pSite->m_topleft.y,
  631.                          m_pSite->m_topleft.x+m_pSite->m_size.cx,
  632.                          m_pSite->m_topleft.y+m_pSite->m_size.cy};
  634.         m_pSite->m_pTopLevelSite->_RecursiveDamageRect(&dirty, TRUE);
  635.         m_pSite->m_pTopLevelSite->ScheduleCallback(REPAINT, 0);
  636.     }
  638.     m_bSwitchingingOverlay = FALSE;
  640.     ReleaseMutex(m_hSurfaceMutex);
  642.     return res;
  643. }
  645. HX_RESULT CWinSurface2::AcquireOverlay()
  646. {
  647.     m_bSwitchingingOverlay = TRUE;
  649.     HX_RESULT res = HXR_FAIL;
  651.     if (m_bVideoSurface2)
  652.     {
  653.         _ReleaseSurface();
  654.         ReInitSurfaces();
  656.         res = HXR_OK;
  657.     }
  658.     else
  659.         res = CWinSurface::AcquireOverlay();
  661.     m_bSwitchingingOverlay = FALSE;
  663.     return res;
  664. }
  666. HX_RESULT CWinSurface2::CreateFallbackSurface(int nSurfaceCID, HXxSize* pSize, int *pcidList, int nListSize)
  667. {
  668.     if (m_bFallbackSurfaceCreated)
  669.     {
  670.         if (pSize->cx == m_allocatedFallbackSize.cx &&
  671.             pSize->cy == m_allocatedFallbackSize.cy)
  672.         {
  673.             return HXR_OK;
  674.         }
  675.         else
  676.         {
  677.             DestroyFallbackSurface();
  678.         }
  679.     }
  681.     //Get our windraw object from the root surface
  682.     CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  684.     if( !pSurface )
  685.         return HXR_FAIL;
  687.     EnterCriticalSection(&m_csFallback);
  689.     pSurface->OpenWindraw();
  690.     WINDRAW* pWindraw = pSurface->GetWinDraw();
  691.     BMI bmi;
  692.     memset(&bmi, 0, sizeof(BMI));
  694.     BOOL    bSuccess = FALSE;
  695.     int     fFlags = WINDRAWSURFACE_DIRECTDRAW | WINDRAWSURFACE_VIDEOMEMORY;
  696.     int     acid[4] = {nSurfaceCID, CID_YV12, CID_YUY2, CID_UYVY};
  697.     int     dwId;
  699.     if (!pcidList)
  700.     {
  701.         pcidList = &acid[0];
  702.         nListSize = sizeof(acid)/sizeof(acid[0]);
  703.     }
  705.     // Try video memory, then system memory
  706.     for (int j=0; j<2; j++, fFlags = WINDRAWSURFACE_DIRECTDRAW)
  707.     {
  708.         // If the dd driver can do color space conversion blts, create a yuv surface
  709.         if (pWindraw->dd.m_caps.dwCaps & DDCAPS_BLTFOURCC)
  710.         {
  711.             // Try to create an offscreen yuv surface
  712.             for (int i=0; i<nListSize && IsYUV(pcidList[i]); i++)
  713.             {
  714.                 MakeBitmap((LPBITMAPINFO)&bmi, sizeof(BMI), pcidList[i], pSize->cx, pSize->cy, NULL, NULL);
  715.                 memset(&m_fallbackSurface, 0, sizeof(m_fallbackSurface));
  717.                 if (NOERROR == WinDraw2_CreateSurface(pWindraw, &m_fallbackSurface, &bmi, fFlags, 0, 0))
  718.                 {
  719.                     // Test if blitting to the primary works (but don't let the user see it)
  720.                     RECT rcSrc = {0,0,pSize->cx, pSize->cy};
  721.                     RECT rcDst = {-pSize->cx, -pSize->cy, 0, 0};
  723.                     if (NOERROR == WinDrawSurface_Blt(pWindraw, &m_fallbackSurface, &rcDst, &rcSrc))
  724.                     {
  725.                         bSuccess = TRUE;
  726.                         dwId = pcidList[i];
  728. #ifdef _DEBUG
  729.                         char szTmp[128]; /* Flawfinder: ignore */
  730.                         char cid[6][5] = {{"I420"}, {"YV12"}, {"YVU9"}, {"YUY2"}, {"UYVY"}, {"DVPF"}}; /* Flawfinder: ignore */
  731.                         if (dwId == CID_DVPF)
  732.                             dwId = 5;
  733.                         wsprintf(szTmp, "CreateFallbackSurface Created 1 %s buffersn", cid[dwId]);
  734.                         OutputDebugString(szTmp);
  735. #endif
  737.                         break;
  738.                     }
  739.                 }
  740.             }
  741.         }
  743.         // Try to create an offscreen surface matching the primary format if
  744.         // yuv surface failed.
  745.         if (!bSuccess)
  746.         {
  747.             memset(&bmi, 0, sizeof(BMI));
  748.             WinDraw2_GetDisplayFormat(pWindraw, &bmi);
  749.             int cid = GetBitmapColor((LPBITMAPINFO)&bmi);
  751.             MakeBitmap((LPBITMAPINFO)&bmi, sizeof(BMI), cid, m_pOptimizedFormat->biWidth, m_pOptimizedFormat->biHeight, NULL, NULL);
  753.             // Don't use hardware rgb...it kills performance on some cards
  754.             fFlags = WINDRAWSURFACE_DIRECTDRAW;
  756.             if (NOERROR == WinDraw2_CreateSurface(pWindraw, &m_fallbackSurface, &bmi, fFlags, 0, 0))
  757.             {
  758.                 bSuccess = TRUE;
  759.                 dwId = cid;
  761. #ifdef _DEBUG
  762.                 OutputDebugString("Created RGB offscreen surfacen");
  763. #endif
  764.             }
  765.         }
  767.         if (bSuccess)
  768.         {
  769.             m_allocatedFallbackSize.cx = pSize->cx;
  770.             m_allocatedFallbackSize.cy = pSize->cy;
  771.             m_nFallbackSurfaceCID = dwId;
  773.             m_bFallbackSurfaceCreated = TRUE;
  775.             if (!m_nBitsPerPixel ||
  776.                 !m_nHozRes ||
  777.                 !m_nVertRes)
  778.             {
  779.                 // Store the display mode we were created in.
  780.                 m_pSite->_GetDeviceCaps(NULL, m_nBitsPerPixel, m_nHozRes, m_nVertRes);
  781.             }
  783.             if (m_hRenThread)
  784.             {
  785.                 // We create our surface, start servicing GetVidMem calls
  786.                 SetEvent(m_hReinit);
  787.             }
  789.             LeaveCriticalSection(&m_csFallback);
  790.             return HXR_OK;
  791.         }
  792.     }
  794. #if 1
  795.     LeaveCriticalSection(&m_csFallback);
  796.     return HXR_FAIL;
  797. #else
  798.     // Result to sys mem buffers
  799.     return CreateSysMemSurface(nSurfaceCID, pSize, 1);
  800. #endif
  801. }
  803. HX_RESULT CWinSurface2::DestroyFallbackSurface()
  804. {
  805.     if (!m_bFallbackSurfaceCreated)
  806.         return HXR_OK;
  808.     CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  809.     if (!pSurface)
  810.         return HXR_FAIL;
  812.     WINDRAW* pWindraw = pSurface->GetWinDraw();
  813.     if (!pWindraw)
  814.         return HXR_FAIL;
  816.     EnterCriticalSection(&m_csFallback);
  818.     WinDraw2_ReleaseSurface(pWindraw, &m_fallbackSurface);
  820.     m_bFallbackSurfaceCreated = FALSE;
  822.     LeaveCriticalSection(&m_csFallback);
  824.     return HXR_OK;
  825. }
  827. HX_RESULT CWinSurface2::LockFallbackSurface(UCHAR* &pVidMem, INT32 &nPitch, BOOL bBlock)
  828. {
  829.     if (!bBlock)
  830.     {
  831.         if (WAIT_OBJECT_0 != WaitForSingleObject(m_hFallbackEmpty, 0))
  832.             return HXR_BUFFER_NOT_AVAILABLE;
  833.     }
  835.     HANDLE  aObjects[2] = {m_hFallbackEmpty, m_hAbort};
  836.     if (WaitForMultipleObjects(2, aObjects, FALSE, INFINITE) - WAIT_OBJECT_0 == 0)
  837.     {
  838.         HRESULT hr;
  839.         CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  840.         WINDRAW* pWindraw = pSurface->GetWinDraw();
  842.         HXxSize rcSize = {m_surfaceSize.cx,m_surfaceSize.cy};
  844.         if (HXR_OK != CreateFallbackSurface(m_nSurfaceCID, &rcSize))
  845.             return HXR_FAIL;
  847.         LONG lPitch;
  848.         hr = WinDrawSurface_Lock (pWindraw, &m_fallbackSurface, 0, (void**)&pVidMem, &lPitch);
  850.         if (hr != HXR_OK)
  851.             return hr;
  853.         m_bScratchSurface = TRUE;
  854.         nPitch = lPitch;
  855.     }
  856.     else
  857.         return HXR_FAIL;
  859.     return HXR_OK;
  860. }
  862. HX_RESULT CWinSurface2::TryNewFallback()
  863. {
  864.     int nNewCID = 0;
  865.     int acid[5] = {m_nFallbackSurfaceCID, 0,0,0,0};
  867.     for (int i=0; i<5; i++)
  868.     {
  869.         // Try a new format for our offscreen buffer ending in rgb
  870.         switch (acid[i])
  871.         {
  872.            case CID_I420:  acid[i+1] = CID_YV12; nNewCID++; break;
  873.            case CID_YV12:  acid[i+1] = CID_YUY2; nNewCID++; break;
  874.            case CID_YUY2:  acid[i+1] = CID_UYVY; nNewCID++; break;
  875.            case CID_UYVY:  acid[i+1] = CID_RGB32; nNewCID++; break;
  877.            default:
  878.                i=5;    // jump out of loop
  879.         }
  880.     }
  882.     if (!nNewCID)
  883.         return HXR_FAIL;
  885.     EnterCriticalSection(&m_csFallback);
  887.     DestroyFallbackSurface();
  888.     HRESULT hr = CreateFallbackSurface(acid[1], &m_allocatedFallbackSize, &acid[1], nNewCID);
  890.     LeaveCriticalSection(&m_csFallback);
  892.     return hr;
  893. }
  895. HX_RESULT CWinSurface2::CreateSysMemSurface(int nSurfaceCID,
  896.                                             HXxSize* pSize,
  897.                                             int nBuffers)
  898. {
  899.     // Do we need to create new buffers?
  900.     if (m_pSysMemSurf)
  901.     {
  902.         if (nBuffers == m_nSysMemSurfCount &&
  903.             pSize->cx == m_bmi.biWidth &&
  904.             pSize->cy == m_bmi.biHeight)
  905.         {
  906.             return HXR_OK;
  907.         }
  909.         DestroySysMemSurface();
  910.     }
  912.     // Calculate the size of each frame buffer
  913.     m_nSysMemSurfSize = pSize->cx * pSize->cy * GetBitsPerPixel(CID_I420) / 8;
  915.     // Allocate the surface list
  916.     m_pSysMemSurf = new tSysMemSurf[nBuffers];
  917.     if (!m_pSysMemSurf)
  918.         return HXR_OUTOFMEMORY;
  920.     memset(m_pSysMemSurf, 0, sizeof(tSysMemSurf)*nBuffers);
  922.     // Allocate each buffer
  923.     for (int i=0; i<nBuffers; i++)
  924.     {
  925.         m_pSysMemSurf[i].pBuffer = new UCHAR[m_nSysMemSurfSize + 31 & ~31];
  927.         if (!m_pSysMemSurf[i].pBuffer)
  928.         {
  929.             DestroySysMemSurface();
  930.             return HXR_OUTOFMEMORY;
  931.         }
  933.         m_pSysMemSurf[i].hEmpty = CreateEvent(NULL, TRUE, TRUE, NULL);
  935.         ++m_nSysMemSurfCount;
  936.     }
  938.     m_allocatedSysMemSurfSize = *pSize;
  939.     m_nSysMemSurfID = CID_I420;
  940.     m_bUseSysMemSurface = TRUE;
  941.     m_nSysMemSurfPitch = pSize->cx;
  943.     if (!m_nBitsPerPixel ||
  944.         !m_nHozRes ||
  945.         !m_nVertRes)
  946.     {
  947.         // Store the display mode we were created in.
  948.         m_pSite->_GetDeviceCaps(NULL, m_nBitsPerPixel, m_nHozRes, m_nVertRes);
  950.     }
  952.     return HXR_OK;
  953. }
  955. HX_RESULT CWinSurface2::LockSysMemSurface(UCHAR* &pVidMem, INT32 &nPitch, BOOL bBlock)
  956. {
  957.     HXxSize rcSize = {m_bmi.biWidth,m_bmi.biHeight};
  959.     if (HXR_OK != CreateSysMemSurface(m_nSurfaceCID, &rcSize, 1))
  960.         return HXR_FAIL;
  962.     if (!bBlock)
  963.     {
  964.         if (WAIT_OBJECT_0 != WaitForSingleObject(m_pSysMemSurf[m_nNextSysMemBuffer].hEmpty, 0))
  965.             return HXR_BUFFER_NOT_AVAILABLE;
  966.     }
  968.     HANDLE  aWait[2] = {m_pSysMemSurf[m_nNextSysMemBuffer].hEmpty, m_hAbort};
  970.     if (WaitForMultipleObjects(2, aWait, FALSE, INFINITE) - WAIT_OBJECT_0 == 0)
  971.     {
  972.         pVidMem = m_pSysMemSurf[m_nNextSysMemBuffer].pBuffer;
  973.         nPitch = m_nSysMemSurfPitch;
  975.         return HXR_OK;
  976.     }
  977.     else
  978.         return HXR_FAIL;
  979. }
  981. HX_RESULT CWinSurface2::DestroySysMemSurface()
  982. {
  983.     if (!m_pSysMemSurf)
  984.         return HXR_OK;
  986.     for (int i=0; i<m_nSysMemSurfCount; i++)
  987.     {
  988.         if (m_pSysMemSurf[i].pBuffer)
  989.         {
  990.             delete [] m_pSysMemSurf[i].pBuffer;
  991.             m_pSysMemSurf[i].pBuffer = NULL;
  992.         }
  994.         if (m_pSysMemSurf[i].hEmpty)
  995.         {
  996.             CloseHandle(m_pSysMemSurf[i].hEmpty);
  997.             m_pSysMemSurf[i].hEmpty = 0;
  998.         }
  999.     }
  1001.     delete [] m_pSysMemSurf;
  1002.     m_pSysMemSurf = NULL;
  1004.     m_nSysMemSurfSize = 0;
  1005.     m_nSysMemSurfCount = 0;
  1006.     m_nNextSysMemBuffer = 0;
  1007.     m_nSysMemSurfPitch = 0;
  1009.     m_bUseSysMemSurface = FALSE;
  1011.     return HXR_OK;
  1012. }
  1014. INT32 CWinSurface2::GetBitsPerPixel(int nSurfaceID)
  1015. {
  1016.     switch (nSurfaceID)
  1017.     {
  1018.        case CID_YV12:
  1019.        case CID_I420:
  1020.            return 12;
  1022.        case CID_YUY2:
  1023.        case CID_UYVY:
  1024.            return 16;
  1026.        default:
  1027.            return 24;
  1028.     }
  1029. }
  1031. HX_RESULT CWinSurface2::CreateGdiSurface(HXxSize* pSize)
  1032. {
  1033.     HX_RESULT hr = HXR_OK;
  1035.     if (m_bGdiSurfaceCreated)
  1036.         return hr;
  1038.     // Create GDI buffers
  1039.     BMI bmi;
  1040.     memset(&bmi, 0, sizeof(BMI));
  1041.     CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1042.     WINDRAW* pWindraw = pSurface->GetWinDraw();
  1044.     WinDraw2_GetDisplayFormat(pWindraw, &bmi);
  1045.     int cid = GetBitmapColor((LPBITMAPINFO)&bmi);
  1046.     memset(&bmi, 0, sizeof(BMI));
  1047.     MakeBitmap((LPBITMAPINFO)&bmi, sizeof(BMI), cid, pSize->cx, pSize->cy, NULL, NULL);
  1049.     for (int nBuffers = m_nOverlayBackBuffersCreated; nBuffers; nBuffers--)
  1050.     {
  1051.         hr = WinDraw2_CreateSurface(pWindraw, &m_GDIsurface, &bmi, 0, nBuffers, 0);
  1053.         if (NOERROR == hr)
  1054.         {
  1055.             m_allocatedGdiSize = *pSize;
  1056.             m_nGdiSurfaceCID = cid;
  1057.             m_nGdiSurfaceCount = nBuffers+1;
  1058.             m_bGdiSurfaceCreated = TRUE;
  1059.             m_nLastGdiSurface = -1;
  1061.             if (m_hRenThread)
  1062.                 SetEvent(m_hReinit);
  1064.             break;
  1065.         }
  1066.     }
  1068.     return hr;
  1069. }
  1071. HX_RESULT CWinSurface2::LockGdiSurface(UCHAR* &pVidMem, INT32 &nPitch, BOOL bBlock)
  1072. {
  1073.     HX_RESULT hr = HXR_FAIL;
  1075.     // Create the gdi surface if necessary
  1076.     if (!m_bGdiSurfaceCreated)
  1077.     {
  1078.         HXxSize size = {m_pOptimizedFormat->biWidth,
  1079.                         m_pOptimizedFormat->biHeight};
  1080.         hr = CreateGdiSurface(&size);
  1082.         if (HXR_OK != hr)
  1083.             return hr;
  1084.     }
  1086.     // Do we have a surface available
  1087.     if (!bBlock)
  1088.     {
  1089.         if (WAIT_OBJECT_0 != WaitForSingleObject(m_GDIsurface.gdi.lpGDIBackBuffer[m_nNextGdiSurface]->hEmpty, 0))
  1090.             return HXR_BUFFER_NOT_AVAILABLE;
  1091.     }
  1093.     CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1094.     WINDRAW* pWindraw = pSurface->GetWinDraw();
  1096.     // Wait for the next surface
  1097.     HANDLE  aWait[2] = {m_GDIsurface.gdi.lpGDIBackBuffer[m_nNextGdiSurface]->hEmpty, m_hAbort};
  1099.     if (WaitForMultipleObjects(2, aWait, FALSE, INFINITE) - WAIT_OBJECT_0 == 0)
  1100.     {
  1101.         LPVOID  pTemp = NULL;
  1102.         LONG    lPitch = 0;
  1104.         hr = WinDrawSurface_Lock(pWindraw, &m_GDIsurface, m_nNextGdiSurface, &pTemp, &lPitch);
  1106.         if (HXR_OK == hr)
  1107.         {
  1108.             pVidMem = (UCHAR*)pTemp;
  1109.             nPitch = lPitch;
  1110.             m_bGDISurface = TRUE;
  1111.         }
  1112.     }
  1114.     return hr;
  1115. }
  1117. HX_RESULT CWinSurface2::DestroyGdiSurface()
  1118. {
  1119.     if (m_bGdiSurfaceCreated)
  1120.     {
  1121.         CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1122.         WINDRAW* pWindraw = pSurface->GetWinDraw();
  1124.         if (m_allocatedGdiSize.cx && m_allocatedGdiSize.cy)
  1125.         {
  1126.             WinDraw2_ReleaseSurface(pWindraw, &m_GDIsurface);
  1127.             memset(&m_GDIsurface,0,sizeof(m_GDIsurface));
  1128.             memset(&m_allocatedGdiSize,0,sizeof(m_allocatedGdiSize));
  1129.             m_nGdiSurfaceCID = 0;
  1130.         }
  1132.         m_bGdiSurfaceCreated = FALSE;
  1133.         m_nLastGdiSurface = -1;
  1134.     }
  1136.     return HXR_OK;
  1137. }
  1139. void CWinSurface2::SetLastScale(HXxRect *pSrc, HXxRect *pDest)
  1140. {
  1141.     EnterCriticalSection(&m_csScale);
  1143.     m_dLastXScale = (((double)pDest->right - (double)pDest->left) /
  1144.                      ((double)pSrc->right - (double)pSrc->left));
  1145.     m_dLastYScale = (((double)pDest->bottom - (double)pDest->top) /
  1146.                      ((double)pSrc->bottom - (double)pSrc->top));
  1148.     LeaveCriticalSection(&m_csScale);
  1149. }
  1151. int CWinSurface2::GetBestBltMode()
  1152. {
  1153.     // Here is our blt mode prority
  1154.     // 1. DD overlay
  1155.     // 2. DD offscreen (yuv then rgb)
  1156.     // 3. GDI
  1157.     BOOL    bSub1x = FALSE;
  1159.     int     nBltMode = HX_OVERLAY_BLT;
  1160.     int     nPreferredBltMode = nBltMode;
  1162.     if (IsShrinking() && !_AllowsOverlayShrinking())
  1163.         bSub1x = TRUE;
  1165.     // Drop to yuv stretch blts if
  1166.     // sub1x OR
  1167.     // another app has the overlay
  1168.     if (bSub1x | m_bMultipleOverlay)
  1169.     {
  1170.         nBltMode = HX_BLT_YUV_STRETCH;
  1171.     }
  1173.     // Drop to GDI if
  1174.     // DD not available
  1175.     if (m_bLostHWAcceleration)
  1176.     {
  1177.         nPreferredBltMode = nBltMode;
  1178.         nBltMode = HX_BASIC_BLT;
  1179.     }
  1181.     // Can we restore DirectDraw
  1182.     /*if (m_bLostHWAcceleration)
  1183.     {
  1184.         LPWINDRAWSURFACE lpwds = NULL;
  1185.         switch(nPreferredBltMode)
  1186.         {
  1187.             case HX_OVERLAY_BLT: lpwds = &m_surface; break;
  1188.             case HX_BLT_YUV_STRETCH: lpwds = &m_fallbackSurface; break;
  1189.             default: lpwds = &m_GDIsurface;
  1190.         }
  1192.         CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1193.         m_bLostHWAcceleration = !pSurface->_IsHardwareAccelerationAvail(lpwds);
  1195.         if (!m_bLostHWAcceleration)
  1196.         {
  1197.             if (HXR_OK != WaitForQueuedFrames())
  1198.                 Flush();
  1200.             DestroyGdiSurface();
  1201.             pSurface->_AcquireHardwareAcceleration();
  1202.             ReInitSurfaces();
  1203.         }
  1204.     }*/
  1206.     return nBltMode;
  1207. }
  1209. BOOL CWinSurface2::IsShrinking()
  1210. {
  1211.     BOOL bShrink = FALSE;
  1213.     EnterCriticalSection(&m_csScale);
  1215.     if (m_dLastXScale != 0.0 && m_dLastYScale != 0.0 &&
  1216.         (m_dLastXScale < 1.0 || m_dLastYScale < 1.0))
  1217.     {
  1218.         bShrink = TRUE;
  1219.     }
  1221.     LeaveCriticalSection(&m_csScale);
  1223.     return bShrink;
  1224. }
  1226. void CWinSurface2::_WaitForFlush()
  1227. {
  1228.     m_bWaitingForFlush = TRUE;
  1230.     // In the transition for VideoSurface2 to VideoSurface1, wait
  1231.     // until all frames are displayed.
  1232.     if (m_bWasInVidSurf2 && m_pListOfFrames)
  1233.     {
  1234.         while (m_pListOfFrames->GetCount())
  1235.         {
  1236.             Sleep(5);
  1237.         }
  1239.         // When switching to vidsurf1, set the backbuffer
  1240.         // to NULL so we do not flip the overlay.  The flipping
  1241.         // chain seems to get out of whack in the transition from
  1242.         // vidsurf1 to 2.
  1243.         m_surface.dd.lpDDBackBuffer = NULL;
  1244.     }
  1246.     m_bWaitingForFlush = FALSE;
  1247. }
  1249. HX_RESULT CWinSurface2::ForceUpdateOverlay(HXxRect *pDst, HXxRect *pSrc, DWORD dwFlags, BOOL bCheckPos)
  1250. {
  1251.     HXxRect destRect,
  1252.     srcRect = *pSrc;
  1254.     BOOL bUpdate = FALSE;
  1256.     if (HX_OVER_SHOW | dwFlags)
  1257.     {
  1258.         memset( &destRect, 0, sizeof(HXxRect) );
  1260.         _GetWindowDeviceCords(&destRect);
  1261.         destRect.right = destRect.left + pDst->right;
  1262.         destRect.bottom = destRect.top + pDst->bottom;
  1263.         destRect.left += pDst->left;
  1264.         destRect.top += pDst->top;
  1266.         // Ensure we limit update coordinates to screen res
  1267.         UINT16 uBitesPerPixel;
  1268.         UINT16 uHorzRes;
  1269.         UINT16 uVertRes;
  1271.         m_pSite->_GetDeviceCaps(NULL, uBitesPerPixel, uHorzRes, uVertRes);
  1273.         double ratio;
  1274.         if (destRect.left < 0)
  1275.         {
  1276.             ratio = ((double)abs(destRect.left)) / (double)(destRect.right - destRect.left);
  1277.             destRect.left = 0;
  1278.             srcRect.left = (int) (((double) m_surfaceSize.cx) * ratio);
  1279.         }
  1281.         if (destRect.right> uHorzRes)
  1282.         {
  1283.             ratio = ((double)(destRect.right - uHorzRes)) / (double)(destRect.right - destRect.left);
  1284.             destRect.right = uHorzRes;
  1285.             srcRect.right = (int) (((double) m_surfaceSize.cx) * (1.0 - ratio));
  1286.         }
  1288.         if (destRect.top < 0)
  1289.         {
  1290.             ratio = ((double)abs(destRect.top)) / (double)(destRect.bottom - destRect.top);
  1291.             destRect.top = 0;
  1292.             srcRect.top = (int) (((double) m_surfaceSize.cy) * ratio);
  1293.         }
  1295.         if (destRect.bottom > uVertRes)
  1296.         {
  1297.             ratio = ((double)(destRect.bottom - uVertRes)) / (double)(destRect.bottom - destRect.top);
  1298.             destRect.bottom = uVertRes;
  1299.             srcRect.bottom = (int) (((double) m_surfaceSize.cy) * (1.0 - ratio));
  1300.         }
  1302.         if (uBitesPerPixel != m_oldOverlayColorDepth)
  1303.         {
  1304.             m_oldOverlayColorDepth = uBitesPerPixel;
  1305.             // XXXAH Probably do not need this, but keeping it to make sure.
  1306.             m_convertedOverlayColor = _InsureColorMatch(GetOverlayColor());
  1307.         }
  1309.         if (bCheckPos)
  1310.         {
  1311.             CWinBaseRootSurface *pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1312.             WINDRAW *pWindraw = pSurface->GetWinDraw();
  1314.             // If the overlay is invisible or if it nees to be
  1315.             // moved update its position.
  1316.             if (!WinDraw2_IsSurfaceVisible(pWindraw, &m_surface) ||
  1318.                 ((m_lastUpdateDestRect.left   != destRect.left)   |
  1319.                  (m_lastUpdateDestRect.right  != destRect.right)  |
  1320.                  (m_lastUpdateDestRect.top    != destRect.top)    |
  1321.                  (m_lastUpdateDestRect.bottom != destRect.bottom) |
  1322.                  (m_lastUpdateSrcRect.left    != srcRect.left)    |
  1323.                  (m_lastUpdateSrcRect.right   != srcRect.right)   |
  1324.                  (m_lastUpdateSrcRect.top     != srcRect.top)     |
  1325.                  (m_lastUpdateSrcRect.bottom  != srcRect.bottom)))
  1326.             {
  1327.                 bUpdate = TRUE;
  1328.             }
  1329.         }
  1330.         else
  1331.         {
  1332.             bUpdate = TRUE;
  1333.         }
  1335.         memcpy(&m_lastUpdateDestRect, &destRect, sizeof(HXxRect)); /* Flawfinder: ignore */
  1336.         memcpy(&m_lastUpdateSrcRect,  &srcRect,  sizeof(HXxRect)); /* Flawfinder: ignore */
  1337.     }
  1339.     if (bUpdate)
  1340.     {
  1341.         _SetColorKey(m_convertedOverlayColor, m_convertedOverlayColor);
  1342.         _UpdateOverlay(&destRect, &srcRect, dwFlags);
  1343.     }
  1345.     return HXR_OK;
  1346. }
  1348. HX_RESULT CWinSurface2::HandleDisplayModeChange()
  1349. {
  1350.     UINT16  nBitDepth = 0,
  1351.         nHozRes = 0,
  1352.         nVertRes = 0;
  1354.     m_pSite->_GetDeviceCaps(NULL, nBitDepth, nHozRes, nVertRes);
  1356.     // The site handles surface reinit when bitdepth and
  1357.     // dimensions change.  If the mode changed in some other
  1358.     // way (like refresh rate), handle it here.
  1359.     if (m_pSite->zm_bInFullScreenTest ||
  1361.         (nBitDepth == m_nBitsPerPixel &&
  1362.          nHozRes == m_nHozRes &&
  1363.          nVertRes == m_nVertRes &&
  1364.          WAIT_OBJECT_0 == WaitForSingleObject(m_hReinit, 0)))
  1365.     {
  1366.         // Wait for display buffers to render
  1367.         Flush();
  1369.         DestroySurfaces();
  1370.         ReInitSurfaces();
  1372.         m_bQueryMonitorFreq = TRUE;
  1373.     }
  1374.     else
  1375.     {
  1376.         // Wait on the next GetVidMem call for new surface creation
  1377.         ResetEvent(m_hReinit);
  1379.         m_nBitsPerPixel = nBitDepth;
  1380.         m_nHozRes = nHozRes;
  1381.         m_nVertRes = nVertRes;
  1382.     }
  1384.     return HXR_OK;
  1385. }
  1387. BOOL CWinSurface2::HandleDirectDrawLoss(BOOL bLockedTLSMutex)
  1388. {
  1389.     BOOL bRet = FALSE;
  1391.     CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1392.     m_bLostHWAcceleration = !pSurface->_IsHardwareAccelerationAvail();
  1394.     if (m_bLostHWAcceleration)
  1395.     {
  1396.         if (bLockedTLSMutex)
  1397.             m_pSite->_TLSUnlock();
  1399.         DestroySurfaces();
  1400.         pSurface->_LoseHardwareAcceleration();
  1402.         // RGB blitting is expensive, so drop the render thread priority
  1403.         if (m_bBoostRenderThread)
  1404.             SetThreadPriority(m_hRenThread, THREAD_PRIORITY_NORMAL);
  1406.         bRet = TRUE;
  1407.     }
  1409.     return bRet;
  1410. }
  1412. HX_RESULT CWinSurface2::ReleaseSurface(VideoMemStruct* pVidStruct, BOOL bDiscard, BOOL bDeleteAlphaList)
  1413. {
  1414.     UCHAR* pVidMem = pVidStruct->pVidMem;
  1416.     if (pVidStruct->pAlphaList && bDeleteAlphaList)
  1417.     {
  1418.         delete [] pVidStruct->pAlphaList;
  1420.     }
  1422.     m_bFrameHasHWAlphaBlend = FALSE;
  1424.     CWinBaseRootSurface* pSurface = (CWinBaseRootSurface*)m_pSite->GetRootSurface();
  1425.     WINDRAW* pWindraw = pSurface->GetWinDraw();
  1427.     if (!m_bUseSysMemSurface)
  1428.     {
  1429.         if (m_bScratchSurface)
  1430.         {
  1431.             if (!bDiscard && m_pSite->HasFocusRect())
  1432.             {
  1433.                 pSurface->DrawFocusRect(//&m_fallbackSurface,
  1434.                     m_nFallbackSurfaceCID,
  1435.                     &m_allocatedFallbackSize,
  1436.                     pVidMem,
  1437.                     m_pSite);
  1438.             }
  1440.             WinDrawSurface_Unlock (pWindraw, &m_fallbackSurface, 0);
  1442.             if (bDiscard)
  1443.                 SetEvent(m_hFallbackEmpty);
  1445.             m_bScratchSurface = FALSE;
  1446.         }
  1447.         else if (m_bGDISurface)
  1448.         {
  1449.             if (!bDiscard && m_pSite->HasFocusRect())
  1450.             {
  1451.                 pSurface->DrawFocusRect(//&m_GDIsurface,
  1452.                     m_nGdiSurfaceCID,
  1453.                     &m_allocatedGdiSize,
  1454.                     pVidMem,
  1455.                     m_pSite);
  1456.             }
  1458.             WinDrawSurface_Unlock (pWindraw, &m_GDIsurface, m_nNextGdiSurface);
  1460.             if (!bDiscard)
  1461.             {
  1462.                 ResetEvent(m_GDIsurface.gdi.lpGDIBackBuffer[m_nNextGdiSurface]->hEmpty);
  1464.                 if (++m_nNextGdiSurface == m_nGdiSurfaceCount)
  1465.                     m_nNextGdiSurface = 0;
  1466.             }
  1468.             m_bGDISurface = FALSE;
  1470.         }
  1471.         else
  1472.         {
  1473.             if (m_pHwMemObj)
  1474.             {
  1475.                 pVidMem = (UCHAR*)m_pHwMemObj->RendererToDevice(pVidMem);
  1476.                 m_bFrameHasHWAlphaBlend = FALSE;
  1477.             }
  1479.             WinDraw_ReleaseLockedSurface (pWindraw, &m_surface, pVidMem, bDiscard);
  1480.         }
  1481.     }
  1483.     // Unlocked the surface
  1484.     ReleaseMutex(m_hSurfaceMutex);
  1485.     m_pSite->_TLSUnlock();
  1487.     return HXR_OK;
  1488. }
  1490. HX_RESULT CWinSurface2::WaitForTimeLine(INT32 lTimeStamp)
  1491. {
  1492.     HX_RESULT hr = HXR_OK;
  1494.     if (m_pTimeLine)
  1495.     {
  1496.         DWORD dwRet = 0;
  1497.         UINT32 ulTime = 0;
  1498.         HX_RESULT hrTimeLine = m_pTimeLine->GetTimeLineValue(ulTime);
  1500.         while (HXR_TIMELINE_SUSPENDED == hrTimeLine &&
  1501.                m_bCont &&
  1502.                !m_bFlushing &&
  1503.                !m_bWaitingForFlush)
  1504.         {
  1505.             dwRet = WaitForSingleObject(m_hAbort, 5);
  1507.             if (WAIT_TIMEOUT != dwRet)
  1508.             {
  1509.                 hr = HXR_FAIL;
  1510.                 break;
  1511.             }
  1512.             hrTimeLine = m_pTimeLine->GetTimeLineValue(ulTime);
  1513.         }
  1514.     }
  1516.     return hr;
  1517. }
  1519. HX_RESULT CWinSurface2::WaitForQueuedFrames()
  1520. {
  1521.     if (m_pTimeLine)
  1522.     {
  1523.         UINT32 ulTime = 0;
  1525.         if (HXR_TIMELINE_SUSPENDED == m_pTimeLine->GetTimeLineValue(ulTime))
  1526.             return HXR_FAIL;
  1527.     }
  1529.     // Wait until our queue count reaches 0
  1530.     int nCount = m_pListOfFrames->GetCount();
  1532.     while (nCount)
  1533.     {
  1534.         Sleep(5);
  1536.         nCount = m_pListOfFrames->GetCount();
  1537.     }
  1539.     return HXR_OK;
  1540. }
  1542. void CWinSurface2::CreateAlphaList(VideoMemStruct* pVidStruct)
  1543. {
  1544.     _SetUpBlendRects();
  1546.     if(m_imageBlocks.GetCount())
  1547.     {
  1548.         UCHAR*  pSysBuf = NULL;
  1549.         INT32   nPitch = 0;
  1551.         HRESULT hr = LockSysMemSurface(pSysBuf, nPitch, TRUE);
  1553.         // yuck..."sys mem" mode means we are passing system memory
  1554.         // buffers for the video but here we are using it for alpha blending,
  1555.         // so we need to set it to false.
  1556.         m_bUseSysMemSurface = FALSE;
  1558.         if (HXR_OK == hr)
  1559.         {
  1560.             ImageBlock* pBlock = NULL;
  1562.             // Create an alpha struct for every region rect
  1563.             pVidStruct->ulCount = m_imageBlocks.GetCount();
  1564.             pVidStruct->pAlphaList = new AlphaStruct[pVidStruct->ulCount];
  1566.             // Set each alpha struct rect as a pointer to a sys mem buffer
  1567.             // the size of one video frame.  rcImageRect is the subrect
  1568.             // we need copied.
  1569.             CHXSimpleList::Iterator j = m_imageBlocks.Begin();
  1570.             for (int i=0; j != m_imageBlocks.End(); ++i, ++j)
  1571.             {
  1572.                 pBlock = (ImageBlock*)*j;
  1574.                 pVidStruct->pAlphaList[i].rcImageRect = pBlock->rect;
  1575.                 pVidStruct->pAlphaList[i].ulImageWidth = m_allocatedSysMemSurfSize.cx;
  1576.                 pVidStruct->pAlphaList[i].ulImageHeight = m_allocatedSysMemSurfSize.cy;
  1578.                 pVidStruct->pAlphaList[i].ulFourCC = HX_I420;
  1579.                 pVidStruct->pAlphaList[i].lPitch = m_nSysMemSurfPitch;
  1580.                 pVidStruct->pAlphaList[i].pBuffer = pSysBuf;
  1582.                 // The alpha source is greater than our video...yikes
  1583.                 if (pBlock->rect.right > m_allocatedSysMemSurfSize.cx ||
  1584.                     pBlock->rect.bottom > m_allocatedSysMemSurfSize.cy ||
  1585.                     pBlock->rect.right-pBlock->rect.left > m_allocatedSysMemSurfSize.cx ||
  1586.                     pBlock->rect.bottom-pBlock->rect.top > m_allocatedSysMemSurfSize.cy)
  1587.                 {
  1588.                     pVidStruct->ulCount = 0;
  1589.                     HX_VECTOR_DELETE(pVidStruct->pAlphaList);
  1591.                     return;
  1592.                 }
  1593.             }
  1594.         }
  1595.     }
  1596.     m_bImageBlocksGood = TRUE;
  1597. }
  1599. void CWinSurface2::YuvAlphaBlend(AlphaStruct* pList,
  1600.                                  UINT32 ulCount,
  1601.                                  UCHAR* pDest,
  1602.                                  UINT32 ulFourCC,
  1603.                                  INT32  lPitch,
  1604.                                  HXxSize* pDestDim)
  1605. {
  1606.     // Alpha blend each list entry and blt on the video frame
  1607.     if (m_bImageBlocksGood)
  1608.     {
  1609.         if( _BlendYUVRects(pList, ulCount, HX_I420) )
  1610.         {
  1611.             BOOL bConverter;
  1612.             INT32 ulDestCID = MapFourCCtoCID(ulFourCC);
  1614.             if (CID_UNKNOWN == ulDestCID)
  1615.                 ulDestCID = ulFourCC;
  1617.             CHXSimpleList::Iterator gg = m_imageBlocks.Begin();
  1618.             for (int i=0; gg != m_imageBlocks.End(); ++i, ++gg)
  1619.             {
  1620.                 ImageBlock* pBlock = (ImageBlock*)*gg;
  1621.                 Image*      pTmp   = pBlock->pImage;
  1623.                 // Get a converter
  1624.                 bConverter = GetColorConverter(MapFourCCtoCID(pList[i].ulFourCC), ulDestCID);
  1626.                 if (bConverter)
  1627.                 {
  1628.                     ColorConvert( ulDestCID,
  1629.                                   pDest,
  1630.                                   pDestDim->cx,
  1631.                                   pDestDim->cy,
  1632.                                   lPitch,
  1633.                                   pBlock->rect.left,
  1634.                                   pBlock->rect.top,
  1635.                                   pBlock->rect.right-pBlock->rect.left,
  1636.                                   pBlock->rect.bottom-pBlock->rect.top,
  1638.                                   MapFourCCtoCID(pList[i].ulFourCC),
  1639.                                   pTmp->pucImage,
  1640.                                   pTmp->bmiImage.biWidth,
  1641.                                   pTmp->bmiImage.biHeight,
  1642.                                   GETBITMAPPITCH(&pTmp->bmiImage),
  1643.                                   0,
  1644.                                   0,
  1645.                                   pBlock->rect.right-pBlock->rect.left,
  1646.                                   pBlock->rect.bottom-pBlock->rect.top);
  1647.                 }
  1648.             }
  1649.         }
  1650.     }
  1651. }
  1653. /************************************************************************
  1654.  *  Method:
  1655.  *      _ScheduleFrameForDisplay
  1656.  *  Purpose:
  1657.  */
  1658. HX_RESULT CWinSurface2::_ScheduleFrameForDisplay(void* pOsData,
  1659.                                                  tFrameElement* pItem,
  1660.                                                  UINT32 nResolution)
  1661. {
  1662.     // Display immediately when we do not have a clock
  1663.     if (!m_pTimeLine)
  1664.         return HXR_OK;
  1666.     HX_RESULT   hr = HXR_OK;
  1667.     UINT32      ulTime = 0;
  1668.     HANDLE      aWaitObjects[2] = {m_hForceRender, m_hAbort};
  1670.     // Number of ms the frame is ahead of the clock
  1671.     INT32       nTimeAhead = 0;
  1673.     // Use default scheduler
  1674.     if (!m_bOptimalVideoScheduler)
  1675.     {
  1676.         if (HXR_OK != CWinSurface::_ScheduleFrameForDisplay(pOsData, pItem, nResolution))
  1677.         {
  1678.             m_pTimeLine->GetTimeLineValue(ulTime);
  1679.             nTimeAhead = pItem->lTimeStamp - ulTime;
  1681.             // Ignore scheduling during a flush
  1682.             if (!m_bFlushing &&
  1683.                 hr != HXR_TIMELINE_SUSPENDED &&
  1684.                 nTimeAhead > 0)
  1685.             {
  1686.                 m_nLastDisplayTime = ulTime + nTimeAhead;
  1688.                 if (nResolution)
  1689.                     timeBeginPeriod(nResolution);
  1691.                 WaitForMultipleObjects(2, aWaitObjects, FALSE, nTimeAhead);
  1693.                 if (nResolution)
  1694.                     timeEndPeriod(nResolution);
  1696.                 m_nLastDisplayTime = -1;
  1697.             }
  1698.         }
  1700.         pItem->dTimeAvailable = GetMSTickDouble32() + 15;
  1701.         return HXR_OK;
  1702.     }
  1704.     WINDRAW*    pWindraw = (WINDRAW*)pOsData;
  1705.     double      dTickAtStreamTime = 0;
  1706.     double      dPreemptionCheckTick = 0;
  1708.     // Number of ms to the next vertical retrace
  1709.     double      dMsToNextVBlank = 0;
  1710.     double      dCurrentError = 0;
  1712.     // Number of vblanks the display device can schedule the blt
  1713.     INT32       nMaxVBlanksPerSchedule = 0;
  1715.     // The display device's current vertical scan line
  1716.     UINT32      dwScanLine = 0;
  1717.     double      dFilteredScanLine = 0.0;
  1719.     // Number of vblanks until we need to display the frame
  1720.     double      dVblanksToWait = 0.0;
  1721.     double      dIdealVBlank = 0.0;
  1722.     INT32       nVblanksToWait = 0;
  1724.     // Fraction of a vertical trace the video starts on
  1725.     double      dWindowPosScanLine = 0;
  1727.     // Final window placement:
  1728.     HXxRect     windowRect = { 0, 0, 0, 0 };
  1730.     // Window of error for picking a vblank to flip on.
  1731.     double      dWindowOfError = .2;
  1733.     if (pItem->nBltMode == HX_OVERLAY_BLT)
  1734.     {
  1735.         // Some cards can schedule an overlay flip 4 vblanks in advance
  1736.         if (m_bUseVBlankFlip)
  1737.             nMaxVBlanksPerSchedule = 4;
  1738.         else
  1739.             nMaxVBlanksPerSchedule = 1;
  1740.     }
  1742.     while (1)
  1743.     {
  1744.         dTickAtStreamTime = GetMSTickDouble32();
  1745.         hr = m_pTimeLine->GetTimeLineValue(ulTime);
  1746.         dPreemptionCheckTick = GetMSTickDouble32();
  1748.         // Calculate how far the video is ahead of the clock in ms
  1749.         UINT32 i;
  1750.         for (i = 0; (dPreemptionCheckTick - dTickAtStreamTime > OS_THREAD_QUANTUM / 5.0)
  1751.                            && i < MAX_PREEMPTION_CHECK_ATTEMPTS; ++i)
  1752.         {
  1753.             HX_TRACE("Preemption!n");
  1754.             dTickAtStreamTime = GetMSTickDouble32();
  1755.             hr = m_pTimeLine->GetTimeLineValue(ulTime);
  1756.             dPreemptionCheckTick = GetMSTickDouble32();
  1757.         }
  1759.         nTimeAhead = pItem->lTimeStamp - ulTime;
  1761.         WinDraw2_GetScanLine(pWindraw, &dwScanLine);
  1763.         // GetScanLine is terribly noisy on the G400 - one can get better
  1764.         // results by using high precision timers!
  1765.         // dFilteredScanLine = FilterScanLine(dwScanLine, dTickAtStreamTime - dVblankTime, pWindraw);
  1766.         dFilteredScanLine = dwScanLine;
  1767.         HX_ASSERT(dFilteredScanLine < pWindraw->dwMaxScanLine + 1);
  1769. #ifdef ENABLE_SYNC_TRACE
  1770.         syncTraceArray[ulSyncTraceIdx % MAX_SYNC_TRACE_ENTRIES][0] = dTickAtStreamTime;
  1771.         syncTraceArray[ulSyncTraceIdx % MAX_SYNC_TRACE_ENTRIES][1] = dwScanLine;
  1772.         syncTraceArray[ulSyncTraceIdx++ % MAX_SYNC_TRACE_ENTRIES][2] = GetMSTickDouble32() - dPreemptionCheckTick;
  1773. #endif // ENABLE_SYNC_TRACE
  1775.         _GetWindowDeviceCords(&windowRect);
  1776.         dWindowPosScanLine = windowRect.top / (double) (pWindraw->dwMaxScanLine + 1);
  1778.         // How many ms until the next vblank
  1779.         dMsToNextVBlank = (1.0 - (dFilteredScanLine / (double) (pWindraw->dwMaxScanLine + 1))) * pWindraw->dMsPerVBlank;
  1781.         // How many vblanks after the current one, until display time
  1782.         dVblanksToWait = (nTimeAhead - dMsToNextVBlank) / pWindraw->dMsPerVBlank;
  1784. #ifdef KAYA_CODE
  1785.         // Pick the appropriate vblank to display our frame.  First truncate
  1786.         // dVblanksToWait then round up and down and pick the smallest error.
  1787.         // In the rounding code, use nWindowPosScanLine to increase the a/v sync
  1788.         // accuracy.  We want to draw the first line of video as close to
  1789.         // the time give to us in pItem.
  1791.         double dPrevVBlank = ((INT32) dVblanksToWait) + dWindowPosScanLine - 1;
  1792.         double dCurrentVBlank = dPrevVBlank + 1;
  1793.         double dNextVBlank = dCurrentVBlank + 1;
  1795.         dIdealVBlank = fabs(dPrevVBlank - dVblanksToWait)
  1796.             < fabs(dCurrentVBlank - dVblanksToWait) ? dPrevVBlank : dCurrentVBlank;
  1798.         dIdealVBlank = fabs(dIdealVBlank - dVblanksToWait)
  1799.             < fabs(dNextVBlank - dVblanksToWait) ? dIdealVBlank : dNextVBlank;
  1801.         // If the refresh rate is a close multiple of the frame rate, we may
  1802.         // see rapid +/- oscillation of choice of vblanks due to timing error.
  1803.         // We only want to snap once per beat, so bias to the previous frame's
  1804.         // error in this case.
  1805.         dCurrentError = dVblanksToWait - (((INT32) dIdealVBlank <= 0 ? 0 : (INT32) dIdealVBlank)
  1806.                   + dWindowPosScanLine);
  1808.         if (fabs(dCurrentError) > TIME_JITTER_FILTER_THRESHOLD)
  1809.         {
  1810.             if ((m_dLastBlitError < 0) && (dCurrentError > 0))
  1811.             {
  1812.                 //HX_TRACE("Error sign change: %fn", dCurrentError);
  1813.                 // Decrease error:
  1814.                 dIdealVBlank++;
  1815.             }
  1816.             else if ((m_dLastBlitError > 0) && (dCurrentError < 0))
  1817.             {
  1818.                 //HX_TRACE("Error sign change: %fn", dCurrentError);
  1819.                 // Increase error:
  1820.                 dIdealVBlank--;
  1821.             }
  1823.             // An error of zero indicates an unitialized value on
  1824.             // start of playback or an unlikely coincidence.  Don't dampen
  1825.             // arbitrarily on the first frame to reduce the odds
  1826.             // of an initial, preventable snap; coincidences are harmless
  1827.         }
  1829.         nVblanksToWait = (INT32) dIdealVBlank;
  1831.         if (nVblanksToWait < 0)
  1832.         {
  1833.             nVblanksToWait = 0;
  1834.         }
  1836. #else
  1837.         // Determine the appropriate time to schedule this frame for display.
  1838.         // The basic idea is to map the time stamp with a vertical retrace.
  1839.         // When the refresh rate is evenly divisible by video frame rate there
  1840.         // will be an even map but the rest of the time we must approximate.
  1841.         //
  1842.         // The approximation is simple, find the vtrace the time stamps maps
  1843.         // to, calculate the time of this vtrace and compare this value with
  1844.         // the next vtrace.  Select the one that is closest to the time stamp.
  1846.         double dBltTime1 = pItem->lTimeStamp - (dVblanksToWait-(INT32)dVblanksToWait)*pWindraw->dMsPerVBlank;
  1847.         double dBltTime2 = dBltTime1 + pWindraw->dMsPerVBlank;
  1848.         double dBltTime;
  1850.         if ( fabs(dBltTime1-pItem->lTimeStamp) < fabs( dBltTime2-pItem->lTimeStamp))
  1851.         {
  1852.             dBltTime = dBltTime1;
  1853.             nVblanksToWait = (INT32)dVblanksToWait;
  1854.         }
  1855.         else
  1856.         {
  1857.             dBltTime = dBltTime2;
  1858.             nVblanksToWait = (INT32)(dVblanksToWait + 1);
  1859.         }
  1861.         INT32 nScheduleTime = dBltTime - nMaxVBlanksPerSchedule*pWindraw->dMsPerVBlank;
  1863.         // Ignore scheduling when the clock stops updating to avoid an infinite loop
  1864.         if (m_bFlushing || hr == HXR_TIMELINE_SUSPENDED)
  1865.         {
  1866.             nVblanksToWait = max(min(nVblanksToWait,nMaxVBlanksPerSchedule-1), 0);
  1867.             ulTime = nScheduleTime+1;
  1868.         }
  1870. #endif //KAYA_CODE
  1872.         // If the clock is within our allowed scheduling time, schedule the blt
  1873.         if (ulTime > nScheduleTime)
  1874.         {
  1875.             #ifdef LOG_JITTER_DATA
  1876.             FILE *fp = fopen(JITTER_LOG_FILE, "a+");
  1877.             if (fp)
  1878.             {
  1879.                 fprintf(fp, "Ready to flip: ts %ld clock %ld scan line %ld mstvb %.3f vbw %.3f jitter %ldn",
  1880.                              pItem->lTimeStamp, ulTime, dwScanLine, dMsToNextVBlank, dVblanksToWait, (INT32)(pItem->lTimeStamp-(ulTime+dMsToNextVBlank+(INT32)nVblanksToWait*pWindraw->dMsPerVBlank)));
  1881.                 fclose(fp);
  1882.             }
  1883.             #endif //LOG_JITTER_DATA
  1885.             m_dLastBlitError = pItem->lTimeStamp-(ulTime+dMsToNextVBlank+(INT32)nVblanksToWait*pWindraw->dMsPerVBlank);
  1886.             nVblanksToWait = 0;
  1888.             break;
  1889.         }
  1890.         else
  1891.         {
  1892.             // We want to wake up as soon as we can display the frame
  1893.             long lSleep = nScheduleTime - ulTime + 1;
  1895.             m_nLastDisplayTime = ulTime + lSleep;
  1897.             #ifdef LOG_JITTER_DATA
  1898.             INT32 lB4Sleep = GetBetterTickCount();
  1899.             #endif //LOG_JITTER_DATA
  1901.             if (lSleep > 0)
  1902.             {
  1903.                 #ifndef HARDCODE_GRANULE
  1904.                 if (nResolution)
  1905.                     timeBeginPeriod(nResolution);
  1906.                 #endif //HARDCODE_GRANULE
  1908.                 WaitForMultipleObjects(2, aWaitObjects, FALSE, lSleep);
  1910.                 #ifndef HARDCODE_GRANULE
  1911.                 if (nResolution)
  1912.                     timeEndPeriod(nResolution);
  1913.                 #endif //HARDCODE_GRANULE
  1914.             }
  1916.             m_nLastDisplayTime = -1;
  1918.             #ifdef LOG_JITTER_DATA
  1919.             FILE *fp = fopen(JITTER_LOG_FILE, "a+");
  1920.             if (fp)
  1921.             {
  1922.                 fprintf(fp, "ts %ld clock %ld scan line %ld mstvb %.3f vbw %.3f sleep %ld sleep dur %ldn",
  1923.                               pItem->lTimeStamp, ulTime, dwScanLine, dMsToNextVBlank, dVblanksToWait, lSleep, GetBetterTickCount()-lB4Sleep);
  1924.                 fclose(fp);
  1925.             }
  1926.             #endif //LOG_JITTER_DATA
  1928.             if (lSleep < 0)
  1929.                 break;
  1930.         }
  1931.     }
  1933. #ifdef ENABLE_ERROR_TRACE
  1934.     //char szTmp[1000];
  1936.     //HX_TRACE("%lut:: blit error: %fn", pItem->lTimeStamp, (dIdealVBlank - dVblanksToWait)*pWindraw->dMsPerVBlank);
  1937.     //sprintf(szTmp, "Timing error: %fn", (dIdealVBlank - dVblanksToWait)*pWindraw->dMsPerVBlank);
  1938.     g_error[g_ulFrameCount % 10000][0] = dTickAtStreamTime;
  1939.     g_error[g_ulFrameCount % 10000][1] = m_dLastBlitError*pWindraw->dMsPerVBlank;
  1940.     g_error[g_ulFrameCount % 10000][2] = dIdealVBlank;
  1941.     g_alternateError[g_ulFrameCount++ % 10000] = pItem->lTimeStamp - (INT32) ulTime;
  1943.     // Get the DC and render this to the screen:
  1944.     //OutputDebugString(szTmp);
  1945. #endif // ENABLE_ERROR_TRACE
  1947.     // Set the minimum time this frame needs to be displayed (1 vblank)
  1948.     pItem->dTimeAvailable = dTickAtStreamTime + dMsToNextVBlank + (nVblanksToWait+1)*pWindraw->dMsPerVBlank + 1;
  1949.     HX_ASSERT(pItem->dTimeAvailable);
  1951.     // Set the DD flags for interval flipping
  1952.     if (pItem->nBltMode == HX_OVERLAY_BLT && m_bUseVBlankFlip)
  1953.     {
  1954.         switch((INT32)nVblanksToWait+1)
  1955.         {
  1956.             case 4: pItem->dwDDFlags = DDFLIP_INTERVAL4; break;
  1957.             case 3: pItem->dwDDFlags = DDFLIP_INTERVAL3; break;
  1958.             case 2: pItem->dwDDFlags = DDFLIP_INTERVAL2; break;
  1959.             default:pItem->dwDDFlags = 0;
  1960.         }
  1961.     }
  1963.     return hr;
  1964. }
  1966. double CWinSurface2::FilterScanLine(UINT32 ulScanLine, double dTickAtStreamTime,
  1967.                                     WINDRAW* pWindraw, BOOL bResetFilter)
  1968. {
  1969. #ifdef FILTER_SCAN_LINE
  1970.     // No mutex needed (for now) - this function is only called from the
  1971.     // render thread.
  1973.     // On reset, wait for vertical blank and reset m_ulScanLineFilterDepth:
  1974.     if (bResetFilter)
  1975.     {
  1976.         m_dMaxRegression = 0;
  1977.         m_ulScanLineFilterDepth = 0;
  1979.         return 0;
  1980.     }
  1982.     // This filter should adjust the max scan line (i.e. vertical refresh time),
  1983.     // refresh rate, and current scan line.  It is critical that we at least get
  1984.     // the phase (scan line) accurate.
  1986.     double currentRefresh = ulScanLine / pWindraw->dMsPerVBlank;
  1987.     UINT32 ulSamplesUsed = 0;
  1989.     double m;
  1990.     double b;
  1993.     // Ignore both zero and max scan line; some drivers play games with these.
  1994.     if (ulScanLine == 0 && ulScanLine != pWindraw->dwMaxScanLine)
  1995.     {
  1996.         // Add to filter:
  1997.         m_scanLineFilter[m_ulScanLineFilterDepth % SCAN_LINE_FILTER_DEPTH][0] = dTickAtStreamTime;
  1998.         m_scanLineFilter[m_ulScanLineFilterDepth++ % SCAN_LINE_FILTER_DEPTH][1]= currentRefresh;
  2000. #ifdef _DEBUG
  2001.         double dLastPhaseError;
  2002. #endif // _DEBUG
  2004.         // If we assume our refresh + scan line error is +/- 5%, then our
  2005.         // phase error should be monotonic to 20 past vblanks.
  2006.         // Perform a linear regression to correct our sample, if needed.
  2008.         double  sumX,
  2009.                 sumY,
  2010.                 sumXY,
  2011.                 sumXSquared,
  2012.                 sumYSquared = 0;
  2014.         for (int i = 1; i < m_ulScanLineFilterDepth && i < SCAN_LINE_FILTER_DEPTH; ++i)
  2015.         {
  2016.             double elapsedTime = m_scanLineFilter[(m_ulScanLineFilterDepth - i - 1) % SCAN_LINE_FILTER_DEPTH][0] -
  2017.                                  m_scanLineFilter[(m_ulScanLineFilterDepth - i) % SCAN_LINE_FILTER_DEPTH][0];
  2019.             if (elapsedTime >= 10*pWindraw->dMsPerVBlank)
  2020.             {
  2021.                 continue;
  2022.             }
  2024. #ifdef _DEBUG
  2025.             // Monotonic?
  2026. #endif // _DEBUG
  2028.             ulSamplesUsed++;
  2030.             double refresh = (m_scanLineFilter[(m_ulScanLineFilterDepth - i - 1) % SCAN_LINE_FILTER_DEPTH][1] / pWindraw->dMsPerVBlank) + fmod(elapsedTime, pWindraw->dMsPerVBlank);
  2031.             refresh = refresh - (INT32) refresh;
  2033.             double error = m_scanLineFilter[(m_ulScanLineFilterDepth - i) % SCAN_LINE_FILTER_DEPTH][1] - refresh;
  2035.             //HX_TRACE("terror : %lfn", error);
  2037.             sumX += elapsedTime;
  2038.             sumY += error;
  2039.             sumXY = elapsedTime*error;
  2040.             sumXSquared += elapsedTime*elapsedTime;
  2041.             sumYSquared += error*error;
  2042.         }
  2044.         if (ulSamplesUsed < 100)
  2045.         {
  2046.             //HX_TRACE("skipn");
  2047.             goto nofilter;
  2048.         }
  2050.         double meanX = sumX / ulSamplesUsed;
  2051.         double meanY = sumY / ulSamplesUsed;
  2053.         double sumSquaredErrorX = 0;
  2054.         double sumSquaredErrorY = 0;
  2056.         double sumErrorProduct = 0;
  2058.         for (i = 1; i < m_ulScanLineFilterDepth && i < SCAN_LINE_FILTER_DEPTH; ++i)
  2059.         {
  2060.             double elapsedTime = m_scanLineFilter[(m_ulScanLineFilterDepth - i - 1) % SCAN_LINE_FILTER_DEPTH][0] -
  2061.                                  m_scanLineFilter[(m_ulScanLineFilterDepth - i) % SCAN_LINE_FILTER_DEPTH][0];
  2063.             if (elapsedTime >= 10*pWindraw->dMsPerVBlank)
  2064.             {
  2065.                 continue;
  2066.             }
  2068.             double refresh = (m_scanLineFilter[(m_ulScanLineFilterDepth - i - 1) % SCAN_LINE_FILTER_DEPTH][1] / pWindraw->dMsPerVBlank) + fmod(elapsedTime, pWindraw->dMsPerVBlank);
  2069.             refresh = refresh - (INT32) refresh;
  2071.             double error = m_scanLineFilter[(m_ulScanLineFilterDepth - i) % SCAN_LINE_FILTER_DEPTH][1] - refresh;
  2073.             sumSquaredErrorX += (elapsedTime - meanX)*(elapsedTime - meanX);
  2074.             sumSquaredErrorY += (error - meanY)*(error - meanY);
  2076.             sumErrorProduct += (elapsedTime - meanX)*(error - meanY);
  2077.         }
  2079.         double rho = sumErrorProduct / sqrt(sumSquaredErrorX*sumSquaredErrorY);
  2081.         //double rho = (sumXY - ((sumX*sumY) / ulSamplesUsed)) /
  2082.         //             sqrt((sumXSquared - ((sumX*sumX) / ulSamplesUsed))*(sumYSquared - ((sumY*sumY) / ulSamplesUsed)));
  2084.         double stdDevX = sumSquaredErrorX / ulSamplesUsed - 1;
  2085.         double stdDevY = sumSquaredErrorY / ulSamplesUsed - 1;
  2087.         m = rho*stdDevY/stdDevX;
  2088.         b = meanY - (m*meanX);
  2090.         //HX_TRACE("current phase error: %lfn");
  2091.         //HX_TRACE("current refresh error: %lfn");
  2093.         // Do we have enough data to update our phase point
  2094. #if 0
  2095.         if (rho >= MIN_ALLOWED_REGRESSION)
  2096.         {
  2097.             m_dMaxRegression = rho;
  2099.             HX_TRACE("current rho: %lfn", rho);
  2100.             HX_TRACE("current m: %lfn", m);
  2101.             HX_TRACE("current b: %lfn", b);
  2103.             // Regression still has a sample delay; let's not worry about it for
  2104.             // now; nor any error due to an inaccurate max scan line.
  2106.             // Update refresh rate:
  2107.             // A negative slope = error decreasing back in time, increasing forwards in time.
  2108.             // Refresh rate should increase.
  2109.             // Positive slope = error increasing back in time, decreasing forwards in time.
  2110.             // Refresh rate should decrease.
  2111.             pWindraw->dRefreshRate -= m*1000;
  2112.             pWindraw->dMsPerVBlank = 1 / pWindraw->dRefreshRate;
  2114.             HX_TRACE("new refresh: %lfn", pWindraw->dRefreshRate);
  2116.             // Update phase point:
  2117.             currentRefresh -= b;
  2119.             if (currentRefresh > 0)
  2120.             {
  2121.                 m_dPhasePoint = dTickAtStreamTime - (currentRefresh)/pWindraw->dMsPerVBlank;
  2122.             }
  2123.             else
  2124.             {
  2125.                 m_dPhasePoint = dTickAtStreamTime - ((currentRefresh)+1)/pWindraw->dMsPerVBlank;
  2126.             }
  2127.         }
  2128. #endif // 0
  2129.     }
  2131.     //if (m_dMaxRegression >= MIN_ALLOWED_REGRESSION)
  2132.     {
  2133.         double dRefreshes = (dTickAtStreamTime - m_dPhasePoint) / pWindraw->dMsPerVBlank;
  2135.         HX_TRACE("current b: %lfn", b);
  2136.         dRefreshes -= b;
  2138.         if (dRefreshes < 0)
  2139.         {
  2140.             dRefreshes++;
  2141.         }
  2143.         double dScanLine = (dRefreshes - ((UINT32) dRefreshes))*(pWindraw->dwMaxScanLine + 1);
  2145.         // If we're off by less than 15%, let it slide?
  2146.         return fabs(dScanLine - ulScanLine) / (pWindraw->dwMaxScanLine + 1) > 15
  2147.             ? dScanLine : ulScanLine;
  2148.     }
  2149. #endif // FILTER_SCAN_LINE
  2151. #ifdef FILTER_SCAN_LINE
  2152. nofilter:
  2153. #endif
  2155.     return ulScanLine;
  2156. }