home *** CD-ROM | disk | FTP | other *** search
/ Windows Game Programming for Dummies (2nd Edition) / WinGamProgFD.iso / pc / DirectX SDK / DXSDK / samples / Multimedia / DirectShow_WinXP / VMR / TxtPlayer / alloclib.cpp next >
Encoding:
C/C++ Source or Header  |  2001-10-08  |  7.8 KB  |  286 lines
  1. //------------------------------------------------------------------------------
  2. // File: alloclib.cpp
  3. //
  4. // Desc: DirectShow sample code
  5. //
  6. // Copyright (c) 2000-2001 Microsoft Corporation.  All rights reserved.
  7. //------------------------------------------------------------------------------
  8.  
  9. #include <streams.h>
  10. #include <malloc.h>
  11.  
  12. #include "AllocLib.h"
  13.  
  14.  
  15. /*****************************Private*Routine******************************\
  16. * YV12PaintSurfaceBlack
  17. *
  18. \**************************************************************************/
  19. HRESULT
  20. YV12PaintSurfaceBlack(
  21.     LPDIRECTDRAWSURFACE7 pDDrawSurface
  22.     )
  23. {
  24.     AMTRACE((TEXT("YV12PaintSurfaceBlack")));
  25.     HRESULT hr = NOERROR;
  26.     DDSURFACEDESC2 ddsd;
  27.  
  28.     // now lock the surface so we can start filling the surface with black
  29.     ddsd.dwSize = sizeof(ddsd);
  30.  
  31.     for ( ;; ) {
  32.  
  33.         hr = pDDrawSurface->Lock(NULL, &ddsd,
  34.                                  DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL);
  35.  
  36.         if (hr == DD_OK || hr != DDERR_WASSTILLDRAWING) {
  37.             break;
  38.         }
  39.  
  40.         Sleep(1);
  41.     }
  42.  
  43.     if (hr == DD_OK)
  44.     {
  45.         DWORD y;
  46.         LPBYTE pDst = (LPBYTE)ddsd.lpSurface;
  47.         LONG  OutStride = ddsd.lPitch;
  48.         DWORD VSize = ddsd.dwHeight;
  49.         DWORD HSize = ddsd.dwWidth;
  50.  
  51.         // Y Component
  52.         for (y = 0; y < VSize; y++) {
  53.             FillMemory(pDst, HSize, (BYTE)0x10);     // 1 line at a time
  54.             pDst += OutStride;
  55.         }
  56.  
  57.         HSize /= 2;
  58.         VSize /= 2;
  59.         OutStride /= 2;
  60.  
  61.         // Cb Component
  62.         for (y = 0; y < VSize; y++) {
  63.             FillMemory(pDst, HSize, (BYTE)0x80);     // 1 line at a time
  64.             pDst += OutStride;
  65.         }
  66.  
  67.         // Cr Component
  68.         for (y = 0; y < VSize; y++) {
  69.             FillMemory(pDst, HSize, (BYTE)0x80);     // 1 line at a time
  70.             pDst += OutStride;
  71.         }
  72.  
  73.         pDDrawSurface->Unlock(NULL);
  74.     }
  75.  
  76.     return hr;
  77. }
  78.  
  79.  
  80. /******************************Public*Routine******************************\
  81. * YUV16PaintSurfaceBlack
  82. *
  83. \**************************************************************************/
  84. HRESULT
  85. YUV16PaintSurfaceBlack(
  86.     LPDIRECTDRAWSURFACE7 pdds,
  87.     DWORD dwBlack
  88.     )
  89. {
  90.     AMTRACE((TEXT("YUV16PaintSurfaceBlack")));
  91.     HRESULT hr = NOERROR;
  92.     DDSURFACEDESC2 ddsd;
  93.  
  94.     // now lock the surface so we can start filling the surface with black
  95.     ddsd.dwSize = sizeof(ddsd);
  96.  
  97.     for ( ;; ) {
  98.  
  99.         hr = pdds->Lock(NULL, &ddsd, DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL);
  100.  
  101.         if (hr == DD_OK || hr != DDERR_WASSTILLDRAWING) {
  102.             break;
  103.         }
  104.  
  105.         Sleep(1);
  106.     }
  107.  
  108.     if (hr == DD_OK)
  109.     {
  110.         DWORD y, x;
  111.         LPDWORD pDst = (LPDWORD)ddsd.lpSurface;
  112.         LONG  OutStride = ddsd.lPitch;
  113.  
  114.         for (y = 0; y < ddsd.dwHeight; y++) {
  115.  
  116.             for (x = 0; x < ddsd.dwWidth / 2; x++) {
  117.                 pDst[x] = dwBlack;
  118.             }
  119.  
  120.             // Dont forget that the stride is a byte count
  121.             *((LPBYTE*)&pDst) += OutStride;
  122.         }
  123.  
  124.         pdds->Unlock(NULL);
  125.     }
  126.  
  127.     return hr;
  128. }
  129.  
  130.  
  131. /*****************************Private*Routine******************************\
  132. * BlackPaintProc
  133. *
  134. \**************************************************************************/
  135. HRESULT
  136. BlackPaintProc(
  137.     LPDIRECTDRAWSURFACE7 pDDrawSurface,
  138.     DDSURFACEDESC2* lpddSurfaceDesc
  139.     )
  140. {
  141.     AMTRACE((TEXT("BlackPaintProc")));
  142.  
  143.     //
  144.     // If the surface is YUV take care of the types that we
  145.     // know the pixel format for.  Those surfaces that we don't know
  146.     // about will get painted '0' which may be bright green for
  147.     // YUV surfaces.
  148.     //
  149.  
  150.     if (lpddSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_FOURCC) {
  151.  
  152.         //
  153.         // compute the black value if the fourCC code is suitable,
  154.         // otherwise can't handle it
  155.         //
  156.  
  157.         switch (lpddSurfaceDesc->ddpfPixelFormat.dwFourCC) {
  158.  
  159.         case mmioFOURCC('Y','V','1','2'):
  160.         case mmioFOURCC('I','4','2','0'):
  161.         case mmioFOURCC('I','Y','U','V'):
  162.             return YV12PaintSurfaceBlack(pDDrawSurface);
  163.  
  164.         case mmioFOURCC('Y','U','Y','2'):
  165.             return YUV16PaintSurfaceBlack(pDDrawSurface, 0x80108010);
  166.  
  167.         case mmioFOURCC('U','Y','V','Y'):
  168.             return YUV16PaintSurfaceBlack(pDDrawSurface, 0x10801080);
  169.         }
  170.     }
  171.  
  172.     DDBLTFX ddFX;
  173.     INITDDSTRUCT(ddFX);
  174.     return pDDrawSurface->Blt(NULL, NULL, NULL, DDBLT_COLORFILL, &ddFX);
  175. }
  176.  
  177.  
  178. /*****************************Private*Routine******************************\
  179. * PaintSurfaceBlack
  180. *
  181. \**************************************************************************/
  182. HRESULT
  183. PaintDDrawSurfaceBlack(
  184.     LPDIRECTDRAWSURFACE7 pDDrawSurface
  185.     )
  186. {
  187.     AMTRACE((TEXT("PaintDDrawSurfaceBlack")));
  188.  
  189.     LPDIRECTDRAWSURFACE7 *ppDDrawSurface = NULL;
  190.     DDSCAPS2 ddSurfaceCaps;
  191.     DDSURFACEDESC2 ddSurfaceDesc;
  192.     DWORD dwAllocSize;
  193.     DWORD i = 0, dwBackBufferCount = 0;
  194.  
  195.     // get the surface description
  196.     INITDDSTRUCT(ddSurfaceDesc);
  197.     HRESULT hr = pDDrawSurface->GetSurfaceDesc(&ddSurfaceDesc);
  198.     if (SUCCEEDED(hr)) {
  199.  
  200.         if (ddSurfaceDesc.dwFlags & DDSD_BACKBUFFERCOUNT) {
  201.             dwBackBufferCount = ddSurfaceDesc.dwBackBufferCount;
  202.         }
  203.  
  204.         hr = BlackPaintProc(pDDrawSurface, &ddSurfaceDesc);
  205.         if (FAILED(hr))
  206.         {
  207.             DbgLog((LOG_ERROR,1,
  208.                     TEXT("pDDrawSurface->Blt failed, hr = 0x%x"), hr));
  209.             return hr;
  210.         }
  211.  
  212.         if (dwBackBufferCount > 0) {
  213.  
  214.             dwAllocSize = (dwBackBufferCount + 1) * sizeof(LPDIRECTDRAWSURFACE);
  215.             ppDDrawSurface = (LPDIRECTDRAWSURFACE7*)_alloca(dwAllocSize);
  216.  
  217.             ZeroMemory(ppDDrawSurface, dwAllocSize);
  218.             ZeroMemory(&ddSurfaceCaps, sizeof(ddSurfaceCaps));
  219.             ddSurfaceCaps.dwCaps = DDSCAPS_FLIP | DDSCAPS_COMPLEX;
  220.  
  221.             if( DDSCAPS_OVERLAY & ddSurfaceDesc.ddsCaps.dwCaps ) {
  222.                 ddSurfaceCaps.dwCaps |= DDSCAPS_OVERLAY;
  223.             }
  224.  
  225.             for (i = 0; i < dwBackBufferCount; i++) {
  226.  
  227.                 LPDIRECTDRAWSURFACE7 pCurrentDDrawSurface = NULL;
  228.                 if (i == 0) {
  229.                     pCurrentDDrawSurface = pDDrawSurface;
  230.                 }
  231.                 else {
  232.                     pCurrentDDrawSurface = ppDDrawSurface[i];
  233.                 }
  234.                 ASSERT(pCurrentDDrawSurface);
  235.  
  236.  
  237.                 //
  238.                 // Get the back buffer surface and store it in the
  239.                 // next (in the circular sense) entry
  240.                 //
  241.  
  242.                 hr = pCurrentDDrawSurface->GetAttachedSurface(
  243.                         &ddSurfaceCaps,
  244.                         &ppDDrawSurface[i + 1]);
  245.  
  246.                 if (FAILED(hr))
  247.                 {
  248.                     DbgLog((LOG_ERROR,1,
  249.                             TEXT("Function pDDrawSurface->GetAttachedSurface ")
  250.                             TEXT("failed, hr = 0x%x"), hr ));
  251.                     break;
  252.                 }
  253.  
  254.                 ASSERT(ppDDrawSurface[i+1]);
  255.  
  256.                 //
  257.                 // Peform a DirectDraw colorfill BLT
  258.                 //
  259.  
  260.                 hr = BlackPaintProc(ppDDrawSurface[i + 1], &ddSurfaceDesc);
  261.                 if (FAILED(hr)) {
  262.                     DbgLog((LOG_ERROR,1,
  263.                             TEXT("ppDDrawSurface[i + 1]->Blt failed, ")
  264.                             TEXT("hr = 0x%x"), hr));
  265.                     break;
  266.                 }
  267.             }
  268.         }
  269.     }
  270.  
  271.     if (ppDDrawSurface) {
  272.         for (i = 0; i < dwBackBufferCount + 1; i++) {
  273.             if (ppDDrawSurface[i]) {
  274.                 ppDDrawSurface[i]->Release();
  275.             }
  276.         }
  277.     }
  278.  
  279.     if (hr != DD_OK) {
  280.         DbgLog((LOG_ERROR, 1, TEXT("PaintSurfaceBlack failed")));
  281.         hr = S_OK;
  282.     }
  283.  
  284.     return hr;
  285. }
  286.