ddraw示例

最新推荐文章于 2016-12-15 15:43:18 发布
最新推荐文章于 2016-12-15 15:43:18 发布
阅读量582 收藏
点赞数

DirectDraw 在显示YUV图像的时候，由于 YUV 格式很多，显示不同格式的YUV图像都要针对不同格式专门写一些代码，这样很麻烦，同时也增加代码量。在网上看了一些 DirectDraw 示例以后，发现都是针对某一种格式的显示。我用最基本的 DirectDraw 显示方法，封装了几种格式的显示方法，我的显示器只支持示例中的 YUV 格式，所以只实现了几种格式，如有朋友还需要显示别的 YUV 格式可增加少量代码就可显示。

代码如下，

[cpp] view plain copy print ?
  1. #ifndef DirectDraw_H   
  2. #define DirectDraw_H   
  3.   
  4. //   
  5.   
  6. #include <DDraw.h>   
  7.   
  8. //   
  9.   
  10. #pragma comment(lib, "DDraw.lib")   
  11. #pragma comment(lib, "DxGuid.lib")   
  12.   
  13. //   
  14.   
  15. struct ImageSpace  
  16. {  
  17.     enum { SPACE_COUNT = 4, };  
  18.   
  19.     PBYTE pBuffer[SPACE_COUNT];  
  20.     DWORD dwLineSize[SPACE_COUNT];  
  21. };  
  22.   
  23. //   
  24.   
  25. struct FormatYV12  
  26. {  
  27.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  28.     {  
  29.         ZeroMemory(&ddsd, sizeof(ddsd));  
  30.   
  31.         ddsd.dwSize = sizeof(ddsd);  
  32.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  33.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  34.         ddsd.dwWidth    = dwWidth;  
  35.         ddsd.dwHeight   = dwHeight;  
  36.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  37.   
  38.         ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC|DDPF_YUV;  
  39.         ddsd.ddpfPixelFormat.dwYUVBitCount = 8;  
  40.         ddsd.ddpfPixelFormat.dwFourCC = MAKEFOURCC('Y','V','1','2');  
  41.     }  
  42.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  43.     {  
  44.         LPBYTE lpSrcY = imageSpace.pBuffer[0];  
  45.         LPBYTE lpSrcU = imageSpace.pBuffer[1];  
  46.         LPBYTE lpSrcV = imageSpace.pBuffer[2];  
  47.   
  48.         DWORD dwCopyLength = 0;  
  49.   
  50.         if (lpSrcY != NULL) {  
  51.             dwCopyLength = dwWidth;  
  52.             for (LONG i=0; i<dwHeight; ++i) {  
  53.                 CopyMemory(lpSurface, lpSrcY, dwCopyLength);  
  54.                 lpSrcY += imageSpace.dwLineSize[0];  
  55.                 lpSurface += lPitch;  
  56.             }  
  57.         }  
  58.         if (lpSrcV != NULL) {  
  59.             dwCopyLength = dwWidth >> 1;  
  60.             for (LONG i=0; i<dwHeight >> 1; ++i) {  
  61.                 CopyMemory(lpSurface, lpSrcV, dwCopyLength);  
  62.                 lpSrcV += imageSpace.dwLineSize[2];  
  63.                 lpSurface += lPitch >> 1;  
  64.             }  
  65.         }  
  66.         if (lpSrcU != NULL) {  
  67.             dwCopyLength = dwWidth >> 1;  
  68.             for (LONG i=0; i<dwHeight >> 1; ++i) {  
  69.                 CopyMemory(lpSurface, lpSrcU, dwCopyLength);  
  70.                 lpSrcU += imageSpace.dwLineSize[1];  
  71.                 lpSurface += lPitch >> 1;  
  72.             }  
  73.         }  
  74.     }  
  75. };  
  76.   
  77. struct FormatYUY2  
  78. {  
  79.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  80.     {  
  81.         ZeroMemory(&ddsd, sizeof(ddsd));  
  82.   
  83.         ddsd.dwSize = sizeof(ddsd);  
  84.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  85.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  86.         ddsd.dwWidth    = dwWidth;  
  87.         ddsd.dwHeight   = dwHeight;  
  88.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  89.   
  90.         ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC|DDPF_YUV;  
  91.         ddsd.ddpfPixelFormat.dwYUVBitCount = 8;  
  92.         ddsd.ddpfPixelFormat.dwFourCC = MAKEFOURCC('Y','U','Y','2');  
  93.     }  
  94.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  95.     {  
  96.         LPBYTE lpSrcY = imageSpace.pBuffer[0];  
  97.   
  98.         DWORD dwCopyLength = dwWidth << 1;  
  99.   
  100.         for (LONG i=0; i<dwHeight; ++i) {  
  101.             CopyMemory(lpSurface, lpSrcY, dwCopyLength);  
  102.             lpSrcY += imageSpace.dwLineSize[0];  
  103.             lpSurface += lPitch;  
  104.         }  
  105.     }  
  106. };  
  107.   
  108. struct FormatUYVY  
  109. {  
  110.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  111.     {  
  112.         ZeroMemory(&ddsd, sizeof(ddsd));  
  113.   
  114.         ddsd.dwSize = sizeof(ddsd);  
  115.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  116.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  117.         ddsd.dwWidth    = dwWidth;  
  118.         ddsd.dwHeight   = dwHeight;  
  119.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  120.   
  121.         ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC|DDPF_YUV;  
  122.         ddsd.ddpfPixelFormat.dwYUVBitCount = 8;  
  123.         ddsd.ddpfPixelFormat.dwFourCC = MAKEFOURCC('U','Y','V','Y');  
  124.     }  
  125.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  126.     {  
  127.         FormatYUY2::Copy(lpSurface, imageSpace, dwWidth, dwHeight, lPitch);  
  128.     }  
  129. };  
  130.   
  131. //   
  132.   
  133. struct FormatPAL8  
  134. {  
  135.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  136.     {  
  137.         ZeroMemory(&ddsd, sizeof(ddsd));  
  138.   
  139.         ddsd.dwSize = sizeof(ddsd);  
  140.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  141.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  142.         ddsd.dwWidth    = dwWidth;  
  143.         ddsd.dwHeight   = dwHeight;  
  144.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  145.   
  146.         ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB|DDPF_PALETTEINDEXED8;  
  147.         ddsd.ddpfPixelFormat.dwRGBBitCount = 8;  
  148.     }  
  149.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  150.     {  
  151.         LPBYTE lpSrcY = imageSpace.pBuffer[0];  
  152.   
  153.         DWORD dwCopyLength = dwWidth << 2;  
  154.   
  155.         for (LONG i=0; i<dwHeight; ++i) {  
  156.             CopyMemory(lpSurface, lpSrcY, dwCopyLength);  
  157.             lpSrcY += imageSpace.dwLineSize[0];  
  158.             lpSurface += lPitch;  
  159.         }  
  160.     }  
  161. };  
  162.   
  163. struct FormatRGB555  
  164. {  
  165.     enum  
  166.     {  
  167.         RBitMask = 0x7C00,   
  168.         GBitMask = 0x03E0,   
  169.         BBitMask = 0x001F,   
  170.     };  
  171.   
  172.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  173.     {  
  174.         ZeroMemory(&ddsd, sizeof(ddsd));  
  175.   
  176.         ddsd.dwSize = sizeof(ddsd);  
  177.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  178.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  179.         ddsd.dwWidth    = dwWidth;  
  180.         ddsd.dwHeight   = dwHeight;  
  181.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  182.   
  183.         ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;  
  184.         ddsd.ddpfPixelFormat.dwRGBBitCount = 16;  
  185.   
  186.         ddsd.ddpfPixelFormat.dwRBitMask = RBitMask;  
  187.         ddsd.ddpfPixelFormat.dwGBitMask = GBitMask;  
  188.         ddsd.ddpfPixelFormat.dwBBitMask = BBitMask;  
  189.   
  190.         ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0;  
  191.     }  
  192.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  193.     {  
  194.         PSHORT lpSrcY = (PSHORT) imageSpace.pBuffer[0];  
  195.         PSHORT lpDstY = (PSHORT) lpSurface;  
  196.   
  197.         for (LONG i=0; i<dwHeight; ++i) {  
  198.             ZeroMemory(lpDstY, dwWidth * sizeof(SHORT));  
  199.   
  200.             for (LONG j=0; j<dwWidth; ++j) {  
  201.                 lpDstY[j] |= (lpSrcY[j] & RBitMask) >> 10;  
  202.                 lpDstY[j] |= (lpSrcY[j] & GBitMask);  
  203.                 lpDstY[j] |= (lpSrcY[j] & BBitMask) << 10;  
  204.             }  
  205.   
  206.             lpSrcY += imageSpace.dwLineSize[0] / sizeof(SHORT);  
  207.             lpDstY += lPitch / sizeof(SHORT);  
  208.         }  
  209.     }  
  210. };  
  211.   
  212. struct FormatRGB565  
  213. {  
  214.     enum  
  215.     {  
  216.         RBitMask = 0xF800,   
  217.         GBitMask = 0x07E0,   
  218.         BBitMask = 0x001F,   
  219.     };  
  220.   
  221.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  222.     {  
  223.         ZeroMemory(&ddsd, sizeof(ddsd));  
  224.   
  225.         ddsd.dwSize = sizeof(ddsd);  
  226.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  227.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  228.         ddsd.dwWidth    = dwWidth;  
  229.         ddsd.dwHeight   = dwHeight;  
  230.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  231.   
  232.         ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;  
  233.         ddsd.ddpfPixelFormat.dwRGBBitCount = 16;  
  234.   
  235.         ddsd.ddpfPixelFormat.dwRBitMask = RBitMask;  
  236.         ddsd.ddpfPixelFormat.dwGBitMask = GBitMask;  
  237.         ddsd.ddpfPixelFormat.dwBBitMask = BBitMask;  
  238.   
  239.         ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0;  
  240.     }  
  241.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  242.     {  
  243.         PSHORT lpSrcY = (PSHORT) imageSpace.pBuffer[0];  
  244.         PSHORT lpDstY = (PSHORT) lpSurface;  
  245.   
  246.         for (LONG i=0; i<dwHeight; ++i) {  
  247.             ZeroMemory(lpDstY, dwWidth * sizeof(SHORT));  
  248.   
  249.             for (LONG j=0; j<dwWidth; ++j) {  
  250.                 lpDstY[j] |= (lpSrcY[j] & RBitMask) >> 11;  
  251.                 lpDstY[j] |= (lpSrcY[j] & GBitMask);  
  252.                 lpDstY[j] |= (lpSrcY[j] & BBitMask) << 11;  
  253.             }  
  254.   
  255.             lpSrcY += imageSpace.dwLineSize[0] / sizeof(SHORT);  
  256.             lpDstY += lPitch / sizeof(SHORT);  
  257.         }  
  258.     }  
  259. };  
  260.   
  261. struct FormatBGR24  
  262. {  
  263.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  264.     {  
  265.         ZeroMemory(&ddsd, sizeof(ddsd));  
  266.   
  267.         ddsd.dwSize = sizeof(ddsd);  
  268.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  269.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  270.         ddsd.dwWidth    = dwWidth;  
  271.         ddsd.dwHeight   = dwHeight;  
  272.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  273.   
  274.         ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;  
  275.         ddsd.ddpfPixelFormat.dwRGBBitCount = 32;  
  276.         ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0;  
  277.     }  
  278.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  279.     {  
  280.         LPBYTE lpSrcY = imageSpace.pBuffer[0];  
  281.         LPDWORD lpDstY = (LPDWORD) lpSurface;  
  282.   
  283.         for (LONG i=0; i<dwHeight; ++i) {  
  284.             ZeroMemory(lpDstY, dwWidth * sizeof(DWORD));  
  285.   
  286.             for (LONG j=0; j<dwWidth; ++j) {  
  287.                 lpDstY[j] |= (lpSrcY[3 * j]);  
  288.                 lpDstY[j] |= (lpSrcY[3 * j + 1] << 8);  
  289.                 lpDstY[j] |= (lpSrcY[3 * j + 2] << 16);  
  290.             }  
  291.   
  292.             lpSrcY += imageSpace.dwLineSize[0];  
  293.             lpDstY += lPitch / sizeof(DWORD);  
  294.         }  
  295.     }  
  296. };  
  297.   
  298. struct FormatRGB32  
  299. {  
  300.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  301.     {  
  302.         ZeroMemory(&ddsd, sizeof(ddsd));  
  303.   
  304.         ddsd.dwSize = sizeof(ddsd);  
  305.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  306.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  307.         ddsd.dwWidth    = dwWidth;  
  308.         ddsd.dwHeight   = dwHeight;  
  309.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  310.   
  311.         ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;  
  312.         ddsd.ddpfPixelFormat.dwRGBBitCount = 32;  
  313.         ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0;  
  314.     }  
  315.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  316.     {  
  317.         LPBYTE lpSrcY = imageSpace.pBuffer[0];  
  318.         LPDWORD lpDstY = (LPDWORD) lpSurface;  
  319.   
  320.         for (LONG i=0; i<dwHeight; ++i) {  
  321.             ZeroMemory(lpDstY, dwWidth * sizeof(DWORD));  
  322.   
  323.             for (LONG j=0; j<dwWidth; ++j) {  
  324.                 lpDstY[j] |= (lpSrcY[4 * j]);  
  325.                 lpDstY[j] |= (lpSrcY[4 * j + 1] << 8);  
  326.                 lpDstY[j] |= (lpSrcY[4 * j + 2] << 16);  
  327.                 lpDstY[j] |= (lpSrcY[4 * j + 3] << 24);  
  328.             }  
  329.   
  330.             lpSrcY += imageSpace.dwLineSize[0];  
  331.             lpDstY += lPitch / sizeof(DWORD);  
  332.         }  
  333.     }  
  334. };  
  335.   
  336. struct FormatBGR32  
  337. {  
  338.     static VOID Build(DDSURFACEDESC2 &ddsd, DWORD dwWidth, DWORD dwHeight)  
  339.     {  
  340.         ZeroMemory(&ddsd, sizeof(ddsd));  
  341.   
  342.         ddsd.dwSize = sizeof(ddsd);  
  343.         ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;  
  344.         ddsd.dwFlags    = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;  
  345.         ddsd.dwWidth    = dwWidth;  
  346.         ddsd.dwHeight   = dwHeight;  
  347.         ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);  
  348.   
  349.         ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;  
  350.         ddsd.ddpfPixelFormat.dwRGBBitCount = 32;  
  351.         ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0;  
  352.     }  
  353.     static VOID Copy(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch)  
  354.     {  
  355.         LPBYTE lpSrcY = imageSpace.pBuffer[0];  
  356.         LPDWORD lpDstY = (LPDWORD) lpSurface;  
  357.   
  358.         for (LONG i=0; i<dwHeight; ++i) {  
  359.             ZeroMemory(lpDstY, dwWidth * sizeof(DWORD));  
  360.   
  361.             for (LONG j=0; j<dwWidth; ++j) {  
  362.                 lpDstY[j] |= (lpSrcY[4 * j] << 16);  
  363.                 lpDstY[j] |= (lpSrcY[4 * j + 1] << 8);  
  364.                 lpDstY[j] |= (lpSrcY[4 * j + 2]);  
  365.                 lpDstY[j] |= (lpSrcY[4 * j + 3] << 24);  
  366.             }  
  367.   
  368.             lpSrcY += imageSpace.dwLineSize[0];  
  369.             lpDstY += lPitch / sizeof(DWORD);  
  370.         }  
  371.     }  
  372. };  
  373.   
  374. //   
  375.   
  376. class CDirectDraw  
  377. {  
  378.     typedef VOID (*CopyCallback)(LPBYTE lpSurface, const ImageSpace &imageSpace, DWORD dwWidth, DWORD dwHeight, LONG lPitch);  
  379.   
  380. public:  
  381.     CDirectDraw()  
  382.         :   m_hWnd(NULL),   
  383.             m_dwWidth(0),   
  384.             m_dwHeight(0),   
  385.             m_pClipper(NULL),   
  386.             m_pDirectDraw(NULL),   
  387.             m_pSurfacePrimary(NULL),   
  388.             m_pSurfaceOffScreen(NULL),   
  389.             m_copyCallback(NULL)  
  390.     {  
  391.     }  
  392.     ~CDirectDraw()  
  393.     {  
  394.         Release();  
  395.     }  
  396.   
  397.     HRESULT Draw(const ImageSpace &imageSpace)  
  398.     {  
  399.         HRESULT hr = E_INVALIDARG;  
  400.   
  401.         RECT rectSrc = { 0 };  
  402.         RECT rectDst = { 0 };  
  403.   
  404.         DDSURFACEDESC2 ddOffScreenSurfaceDesc = { 0 };  
  405.         if (m_copyCallback == NULL || m_pSurfaceOffScreen == NULL || m_dwWidth == 0 || m_dwHeight == 0) {  
  406.             goto Exit;  
  407.         }  
  408.   
  409.         ddOffScreenSurfaceDesc.dwSize = sizeof(ddOffScreenSurfaceDesc);  
  410.         hr = m_pSurfaceOffScreen->Lock(NULL, &ddOffScreenSurfaceDesc, DDLOCK_WAIT|DDLOCK_WRITEONLY, NULL);  
  411.         if (hr != S_OK) {  
  412.             goto Exit;  
  413.         }  
  414.   
  415.         m_copyCallback((LPBYTE) ddOffScreenSurfaceDesc.lpSurface, imageSpace, ddOffScreenSurfaceDesc.dwWidth, ddOffScreenSurfaceDesc.dwHeight, ddOffScreenSurfaceDesc.lPitch);  
  416.         m_pSurfaceOffScreen->Unlock(NULL);  
  417.   
  418.         rectSrc.right   = ddOffScreenSurfaceDesc.dwWidth;  
  419.         rectSrc.bottom  = ddOffScreenSurfaceDesc.dwHeight;  
  420.         ::GetClientRect(m_hWnd, &rectDst);  
  421.         ::ClientToScreen(m_hWnd, (LPPOINT) &(rectDst.left));  
  422.         ::ClientToScreen(m_hWnd, (LPPOINT) &(rectDst.right));  
  423.   
  424.         while (TRUE) {  
  425.             hr = m_pSurfacePrimary->Blt(&rectDst, m_pSurfaceOffScreen, &rectSrc, DDBLT_WAIT, NULL);  
  426.             if (hr == DDERR_SURFACELOST) {  
  427.                 m_pSurfacePrimary->Restore();  
  428.                 m_pSurfaceOffScreen->Restore();  
  429.             }  
  430.   
  431.             if (hr != DDERR_WASSTILLDRAWING) {  
  432.                 break;  
  433.             }  
  434.         }  
  435.   
  436.         hr = S_OK;  
  437.     Exit:  
  438.         return hr;  
  439.     }  
  440.   
  441.     template <typename PixelFormatT>  
  442.     HRESULT Create(HWND hWnd, DDSURFACEDESC2 &ddOffScreenSurfaceDesc)  
  443.     {  
  444.         Release();  
  445.   
  446.         HRESULT hr = DirectDrawCreateEx(NULL, (LPVOID *) &m_pDirectDraw, IID_IDirectDraw7, NULL);  
  447.         if (hr != S_OK) {  
  448.             goto Exit;  
  449.         }  
  450.   
  451.         hr = m_pDirectDraw->SetCooperativeLevel(hWnd, DDSCL_NORMAL);  
  452.         if (hr != S_OK) {  
  453.             goto Exit;  
  454.         }  
  455.   
  456.         {  
  457.             DDSURFACEDESC2 ddPrimarySurfaceDesc = { 0 };  
  458.             ZeroMemory(&ddPrimarySurfaceDesc, sizeof(ddPrimarySurfaceDesc));  
  459.             ddPrimarySurfaceDesc.dwSize         = sizeof(ddPrimarySurfaceDesc);  
  460.             ddPrimarySurfaceDesc.dwFlags        = DDSD_CAPS;  
  461.             ddPrimarySurfaceDesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;  
  462.             hr = m_pDirectDraw->CreateSurface(&ddPrimarySurfaceDesc, &m_pSurfacePrimary, NULL);  
  463.             if (hr != S_OK) {  
  464.                 goto Exit;  
  465.             }  
  466.             hr = m_pDirectDraw->CreateClipper(0, &m_pClipper, NULL);  
  467.             if (hr != S_OK) {  
  468.                 goto Exit;  
  469.             }  
  470.             hr = m_pClipper->SetHWnd(0, hWnd);  
  471.             if (hr != S_OK) {  
  472.                 goto Exit;  
  473.             }  
  474.             m_pSurfacePrimary->SetClipper(m_pClipper);  
  475.         }  
  476.   
  477.         hr = m_pDirectDraw->CreateSurface(&ddOffScreenSurfaceDesc, &m_pSurfaceOffScreen, NULL);  
  478.         if (hr != S_OK) {  
  479.             goto Exit;  
  480.         }  
  481.   
  482.         m_hWnd = hWnd;  
  483.         m_dwWidth = ddOffScreenSurfaceDesc.dwWidth;  
  484.         m_dwHeight = ddOffScreenSurfaceDesc.dwHeight;  
  485.         m_copyCallback = PixelFormatT::Copy;  
  486.   
  487.     Exit:  
  488.         if (hr != S_OK) {  
  489.             Release();  
  490.         }  
  491.         return hr;  
  492.     }  
  493.   
  494.     VOID Release()  
  495.     {  
  496.         m_hWnd = NULL;  
  497.         m_dwWidth = 0;  
  498.         m_dwHeight = 0;  
  499.         m_copyCallback = NULL;  
  500.   
  501.         if (m_pClipper != NULL) {  
  502.             m_pClipper->Release();  
  503.             m_pClipper = NULL;  
  504.         }  
  505.         if (m_pSurfacePrimary != NULL) {  
  506.             m_pSurfacePrimary->SetClipper(NULL);  
  507.             m_pSurfacePrimary->Release();  
  508.             m_pSurfacePrimary = NULL;  
  509.         }  
  510.         if (m_pSurfaceOffScreen != NULL) {  
  511.             m_pSurfaceOffScreen->SetClipper(NULL);  
  512.             m_pSurfaceOffScreen->Release();  
  513.             m_pSurfaceOffScreen = NULL;  
  514.         }  
  515.         if (m_pDirectDraw != NULL) {  
  516.             m_pDirectDraw->Release();  
  517.             m_pDirectDraw = NULL;  
  518.         }  
  519.     }  
  520.   
  521. private:  
  522.     LPDIRECTDRAW7 m_pDirectDraw;  
  523.     LPDIRECTDRAWCLIPPER m_pClipper;  
  524.     LPDIRECTDRAWSURFACE7 m_pSurfacePrimary;  
  525.     LPDIRECTDRAWSURFACE7 m_pSurfaceOffScreen;  
  526.   
  527.     HWND m_hWnd;  
  528.     DWORD m_dwWidth;  
  529.     DWORD m_dwHeight;  
  530.   
  531.     CopyCallback m_copyCallback;  
  532. };  
  533.   
  534. //   
  535.   
  536. #endif  

 

用法如下，

[cpp] view plain copy print ?
  1. //声明变量   
  2. CDirectDraw m_directDrawYV12;  
  3. CDirectDraw m_directDrawUYVY;  
  4. CDirectDraw m_directDrawYUY2;  
  5. CDirectDraw m_directDrawRGB555;  
  6. CDirectDraw m_directDrawRGB565;  
  7. CDirectDraw m_directDrawBGR24;  
  8. CDirectDraw m_directDrawRGB32;  
  9. CDirectDraw m_directDrawBGR32;  
  10.   
  11. //构造表面   
  12. DDSURFACEDESC2 ddsd = { 0 };  
  13.   
  14. FormatYV12::Build(ddsd, 176, 144);  
  15. m_directDrawYV12.Create<FormatYV12>(::GetDlgItem(m_hWnd, IDC_STATIC_YV12), ddsd);  
  16.   
  17. FormatYUY2::Build(ddsd, 176, 144);  
  18. m_directDrawYUY2.Create<FormatYUY2>(::GetDlgItem(m_hWnd, IDC_STATIC_YUY2), ddsd);  
  19.   
  20. FormatUYVY::Build(ddsd, 176, 144);  
  21. m_directDrawUYVY.Create<FormatUYVY>(::GetDlgItem(m_hWnd, IDC_STATIC_UYVY), ddsd);  
  22.   
  23. FormatRGB555::Build(ddsd, 176, 144);  
  24. m_directDrawRGB555.Create<FormatRGB555>(::GetDlgItem(m_hWnd, IDC_STATIC_RGB555), ddsd);  
  25.   
  26. FormatRGB565::Build(ddsd, 176, 144);  
  27. m_directDrawRGB565.Create<FormatRGB565>(::GetDlgItem(m_hWnd, IDC_STATIC_RGB565), ddsd);  
  28.   
  29. FormatBGR24::Build(ddsd, 176, 144);  
  30. m_directDrawBGR24.Create<FormatBGR24>(::GetDlgItem(m_hWnd, IDC_STATIC_BGR24), ddsd);  
  31.   
  32. FormatRGB32::Build(ddsd, 176, 144);  
  33. m_directDrawRGB32.Create<FormatRGB32>(::GetDlgItem(m_hWnd, IDC_STATIC_RGB32), ddsd);  
  34.   
  35. FormatBGR32::Build(ddsd, 176, 144);  
  36. m_directDrawBGR32.Create<FormatBGR32>(::GetDlgItem(m_hWnd, IDC_STATIC_BGR32), ddsd);  
  37.   
  38. //显示图像   
  39.     LPBYTE lpBuffer = NULL;  
  40.     UINT iLen = 0;  
  41.     FILE *f = NULL;  
  42.     ImageSpace imageSpace = { 0 };  
  43.   
  44. //*   
  45.     f = fopen("176X144-YUV420P.yuv", "rb");  
  46. //  f = fopen("176X144-YUVJ420P.yuv", "rb");   
  47. //  f = fopen("176X144-NV21.yuv", "rb");   
  48. //  f = fopen("176X144-NV12.yuv", "rb");   
  49.     lpBuffer = new BYTE[WIDTH * HEIGHT * 3 >> 1];  
  50.     fread(lpBuffer, 1, WIDTH * HEIGHT * 3 >> 1, f);  
  51.     imageSpace.pBuffer[0] = lpBuffer;  
  52.     imageSpace.pBuffer[1] = imageSpace.pBuffer[0] + WIDTH * HEIGHT;  
  53.     imageSpace.pBuffer[2] = imageSpace.pBuffer[1] + (WIDTH * HEIGHT >> 2);  
  54.   
  55.     imageSpace.dwLineSize[0]= WIDTH;  
  56.     imageSpace.dwLineSize[1]= WIDTH >> 1;  
  57.     imageSpace.dwLineSize[2]= WIDTH >> 1;  
  58.     m_directDrawYV12.Draw(imageSpace);  
  59.     fclose(f);  
  60.     delete []lpBuffer;  
  61. /**/  
  62. //*   
  63.     f = fopen("176X144-YUYV422.yuv", "rb");  
  64.     lpBuffer = new BYTE[WIDTH * HEIGHT << 1];  
  65.     iLen = fread(lpBuffer, 1, WIDTH * HEIGHT << 1, f);  
  66.     imageSpace.pBuffer[0]   = lpBuffer;  
  67.     imageSpace.dwLineSize[0]= WIDTH << 1;  
  68.     m_directDrawYUY2.Draw(imageSpace);  
  69.     fclose(f);  
  70.     delete []lpBuffer;  
  71. /**/  
  72. //*   
  73.     f = fopen("176X144-UYVY422.yuv", "rb");  
  74.     lpBuffer = new BYTE[WIDTH * HEIGHT << 1];  
  75.     iLen = fread(lpBuffer, 1, WIDTH * HEIGHT << 1, f);  
  76.     imageSpace.pBuffer[0]   = lpBuffer;  
  77.     imageSpace.dwLineSize[0]= WIDTH << 1;  
  78.     m_directDrawUYVY.Draw(imageSpace);  
  79.     fclose(f);  
  80.     delete []lpBuffer;  
  81. /**/  
  82. //*   
  83.     f = fopen("176X144-RGB555.yuv", "rb");  
  84.     lpBuffer = new BYTE[WIDTH * HEIGHT << 1];  
  85.     iLen = fread(lpBuffer, 1, WIDTH * HEIGHT << 1, f);  
  86.     imageSpace.pBuffer[0]   = lpBuffer;  
  87.     imageSpace.dwLineSize[0]= WIDTH << 1;  
  88.     m_directDrawRGB555.Draw(imageSpace);  
  89.     fclose(f);  
  90.     delete []lpBuffer;  
  91. /**/  
  92. //*   
  93.     f = fopen("176X144-RGB565.yuv", "rb");  
  94.     lpBuffer = new BYTE[WIDTH * HEIGHT << 1];  
  95.     iLen = fread(lpBuffer, 1, WIDTH * HEIGHT << 1, f);  
  96.     imageSpace.pBuffer[0] = lpBuffer;  
  97.     imageSpace.dwLineSize[0]= WIDTH << 1;  
  98.     m_directDrawRGB565.Draw(imageSpace);  
  99.     fclose(f);  
  100.     delete []lpBuffer;  
  101. /**/  
  102. //*   
  103.     f = fopen("176X144-BGR24.yuv", "rb");  
  104.     lpBuffer = new BYTE[WIDTH * HEIGHT * 3];  
  105.     iLen = fread(lpBuffer, 1, WIDTH * HEIGHT * 3, f);  
  106.     imageSpace.pBuffer[0] = lpBuffer;  
  107.     imageSpace.dwLineSize[0]= WIDTH * 3;  
  108.     m_directDrawBGR24.Draw(imageSpace);  
  109.     fclose(f);  
  110.     delete []lpBuffer;  
  111. /**/  
  112. //*   
  113.     f = fopen("176X144-RGB32.yuv", "rb");  
  114.     lpBuffer = new BYTE[WIDTH * HEIGHT << 2];  
  115.     iLen = fread(lpBuffer, 1, WIDTH * HEIGHT << 2, f);  
  116.     imageSpace.pBuffer[0] = lpBuffer;  
  117.     imageSpace.dwLineSize[0]= WIDTH << 2;  
  118.     m_directDrawRGB32.Draw(imageSpace);  
  119.     fclose(f);  
  120.     delete []lpBuffer;  
  121. /**/  
  122. //*   
  123.     f = fopen("176X144-BGR32.yuv", "rb");  
  124.     lpBuffer = new BYTE[WIDTH * HEIGHT << 2];  
  125.     iLen = fread(lpBuffer, 1, WIDTH * HEIGHT << 2, f);  
  126.     imageSpace.pBuffer[0] = lpBuffer;  
  127.     imageSpace.dwLineSize[0]= WIDTH << 2;  
  128.     m_directDrawBGR32.Draw(imageSpace);  
  129.     fclose(f);  
  130.     delete []lpBuffer;  
  131. /**/  

 

其中 RGB555 和 RGB565 可能是因为图像文件本身不对，导致红蓝颜色反了，显示方法应该没有问题。

amduser
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DirectDraw显示demo
06-16
研究yuv420流数据的播放，弄了个dll工程和一个测试demo，仅供参考
DDraw笔记-一个简单的DDraw应用程序
weixin_30878361的博客
05-13 232
一个简单的DDraw应用程序 方煜宽 2011.05.13 上次谈到DDraw是一个组件。组件由接口组成。 DDraw总共由五个接口组成： IUnknown：所有com接口都必须从这里继承的。（请看相关文章COM笔记-QueryInterface函数） IDirectDraw：使用DDraw必须创建的主接口对象。 IDirectDrawSurface：创建、控制和显示的实际显示表...
basic DirectDraw initialization demo 基本的directdraw初始化演示
清风一吹(清风博客)
11-25 870
// DEMO6_1.CPP basic DirectDraw initialization demo// INCLUDES ///////////////////////////////////////////////#define WIN32_LEAN_AND_MEAN  // just say no to MFC#define INITGUID // make sure dire
一个简单的DDraw应用程序2
weixin_30832983的博客
06-30 84
//------------------------------------------------------------------------- // 文件名 : 6_1.cpp// 创建者 : 方煜宽// 邮箱 ： fangyukuan@gmail.com// 创建时间 : 2010-12-1 23:37// 功能描述 : 一个简单的DDraw应用程序// ...
用DDraw来显示图片和文字
01-24 1353
#include #include "windows.h" #include using namespace std; #include #pragma   comment(lib,   "ddraw.lib") #pragma   comment(lib,   "Dxguid.lib") LRESULT CALLBACK WndProc(   HWND hWnd,
ch2_4.rar_ddraw
09-20
这个“ch2_4.rar_ddraw”压缩包可能包含的是关于DirectDraw基本概念的第四部分学习资料，特别是关于文字处理和其他简单图形操作的教程或代码示例。 DirectDraw的主要功能包括： 1. **加速2D图形**：通过直接访问...
yuv ddraw Simple application
12-15
"yuv ddraw 简单例子"可能是一个教学或示例项目，旨在展示如何在Windows应用程序中利用DirectDraw处理YUV格式的视频。这个项目可能包括以下步骤： 1. 初始化DirectDraw：创建DirectDraw接口，设置所需的显示模式，...
VC++基于Dx实现的截图程序示例代码
01-21
本文所述的程序示例为VC++图象特效的截图示例，需要DirectX 3.0以上版，代码中的GetScreen函数是本截图程序的关键。运行这个程序可用Esc键结束。代码中需要ddutil.h与ddutil.cpp文件,请自行下载添加。关于InitDDraw...
VC6.0写的一个简单DDraw入门程序
05-26
本程序是基于Visual C++ 6.0（简称VC6.0）编写的DDraw入门示例，旨在帮助初学者理解如何在Windows环境下利用DirectDraw进行图形处理。 首先，我们需要了解VC6.0。这是一款由微软发布的经典集成开发环境（IDE），在...
windows ce 6.0 DDRAW overlay(OSD)源代码！
12-26
在提供的压缩包文件“DDEX1”中，我们可以期待找到关于如何在Windows CE 6.0环境下实现DirectDraw Overlay功能的详细代码示例。这些代码可能包括以下几个关键部分： 1. 初始化DirectDraw：首先，开发者需要初始化...
基于DDraw的视频渲染实现
weixin_30593443的博客
02-02 231
基于DDraw实现视频渲染思路 要注意的事项 1、显卡对不同的显示模式支持不同，包括是否支持Overlay/colorkey、支持不同的FOURCC格式等。不考虑这个问题的话，很有可能创建离屏表面不成功。 2、视频解码出来的格式可能需要经过转换后方可通过DDRAW进行渲染。 实现思路： 1、创建视频解码格式（如YV12）到其他FOURCC格式的转换函数指针数组，并实现相关的转换函数...
用DirectDraw显示YV12图像,离屏表面blt主表面
smilestone322的专栏
06-11 3704
http://real.zdell.com/a/200512/818.html这个问题在我初学DirectX是困惑了我很久，贴出来为初学者提供一个参考。// yv12.cpp :  seac@tom.com, caohai 2005.1#define WIN32_LEAN_AND_MEAN        // 从 Windows 头中排除极少使用的资料#include #include
ddraw显示详解
郭智斌的专栏
12-16 6289
前些时间做过一个ddraw显示来代替原来的gdi显示，显示的速度快了许多，在不断的探索中，终于明白了ddraw的用法。现在记下来。本人文字功底欠佳，如有不明白的地方，一起讨论。1.ddraw 与 gdi的区别两者都可以用来显示，gdi是windows比较抵触的绘图方式，ddraw是用gdi来实现的，但是ddraw利用了硬件加速。ddraw更多的应用于游戏编程当中，在wince6.0上是可以使用ddraw的，所以手机编程中用draw会提程序速度。2。 我的开发环境是Windows Mobile 6.0 ，用d
DirectDraw Tutorial 2
NETTE DE BLOG
02-24 1506
DirectDraw Tutorial 2 Alpha混合 一、              基本alpha混合 Alhpa混合有多种算法，基本的计算公式如下：result = ALPHA * srcPixel + ( 1 - ALPHA ) * destPixel其中ALHPA的范围从0.0到1.0，result为混合后的颜色，srcPixel为前景色，destPixe
DirectX5.0最新游戏编程指南 DirectDraw篇 三、DirectDraw的要素(一）
holyfire的专栏
04-14 2468
 三、DirectDraw的要素    DirectDraw中最基本的要素有协作等级、显示模式、DirectDraw对象、表面、调色板、剪切板等，下面对各个要素逐一进行介绍。1、协作等级（Cooperative Level）   协作等级描述了DirectDraw如何同显示交互及对那些可能影响显示的事件的反应。你可以使用IDirectDraw2::SetCooperativeLevel方法来设
ddraw transparency (overlay 实现) 2
80后程序员的技术分享
09-28 2634
接上一篇： 今天终于把overlay alpha 透明通道实现了，我刚开始只在PC上测试，用的DDPIXELFORMAT像素格式值如下 {sizeof(DDPIXELFORMAT), DDPF_RGB|DDPF_ALPHAPIXELS, 0, 32, 0xFF000000,
DirectDraw各种表面操作备注
weixin_34199405的博客
12-15 192
1.DirectDraw主屏表面：　从离屏向主屏Blt(位移数据)，主屏矩形区域则是实际显示画面窗口相对于屏幕坐标的矩形区域(用::GetWindowRect取得)；2.DirectDraw离屏表面：　1)离屏表面要想调用GetDC得到HDC，就不能指定像素格式，　　即ddsd2.dwFlags不能设置DDSD_PIXELFORMAT；　2)两离屏表面Blt(位移数据)，...
使用6位高彩模式
假装狠牛逼
07-17 3171
16位高彩模式： Alpha.5.5.5---------用D15位存储一个Alpha分量(透明度)，其余15位均匀分配给红色、绿色、蓝色。每种色彩产生的变化数位2^5，每个调色板有32*32*32 = 32768种色彩。 X.5.5.5-----这种模式同Alpha.5.5.5类似，只是没有用到MSB(最高位)，共32768种色彩。 5.6.5---------这是16位色彩最常用的模式。
ddraw如何加速显示
最新发布
06-06
DDraw（DirectDraw）在显示图像时可以通过以下几种方式来加速显示： 1. 双缓冲 使用双缓冲可以避免屏幕闪烁，提高图像显示效率。 2. 裁剪 在只需要显示部分图像时，可以使用裁剪来减少需要显示的像素数量，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值