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

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

Symbian

开发平台：

C/C++

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