关于bltFast问题，无法显示图像，在线等待，错误在draw_slide函数中的bitfast

flyukeer 2008-03-22 12:53:24

// PicSlide.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#define INITGUID
#include <stdio.h>
#include <ddraw.h>
#include <mmsystem.h>
static char szClass[]="XmplHr3Class";
static char szCaption[]="Example - Hour 3";

LPDIRECTDRAW7 lpDD=NULL;
LPDIRECTDRAWSURFACE7 lpDDSPrimary=NULL;
LPDIRECTDRAWSURFACE7 lpDDSBack=NULL;
LPDIRECTDRAWCLIPPER lpClip=NULL;
#define IMAGE_COUNT 7
char file_names[IMAGE_COUNT][256]={"23.bmp",
"24.bmp",
"25.bmp",
"26.bmp",
"27.bmp",
"28.bmp",
"29.bmp"
};
static BOOL Init(HINSTANCE hInstance,int nCmdShow);
LPDIRECTDRAWSURFACE7 lpSlides[IMAGE_COUNT];
int cur_image=0;
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LPDIRECTDRAWSURFACE7 bitmap_surface(LPCTSTR file_name);
void draw_slide();
#define SafeRelease(x) if (x) {x->Release();x=NULL;}
void Cleanup();

static BOOL Init(HINSTANCE hInstance,int nCmdShow)
{
WNDCLASS wcex;
HRESULT hRet;

wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = sizeof(DWORD);
wcex.hInstance = hInstance;
wcex.hIcon = NULL;
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szClass;
if (!RegisterClass(&wcex))
{
return FALSE;
}

int ScreenWidth=GetSystemMetrics(SM_CXSCREEN);
int ScreenHeight=GetSystemMetrics(SM_CYSCREEN);
HWND hWnd;
hWnd=CreateWindow(szClass,szCaption,WS_VISIBLE|WS_POPUP,0,0,ScreenWidth,ScreenHeight,NULL,NULL,hInstance,NULL);
if (!hWnd)
{
return FALSE;
}
ShowWindow(hWnd,nCmdShow);
UpdateWindow(hWnd);

hRet=DirectDrawCreateEx(NULL,(LPVOID *)&lpDD,IID_IDirectDraw7,NULL);
if (hRet != DD_OK)
{
return FALSE;
}

hRet=lpDD->SetCooperativeLevel(hWnd,DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN);
// hRet=lpDD->SetCooperativeLevel(hWnd,DDSCL_NORMAL);
if (hRet != DD_OK)
{
return FALSE;
}
hRet=lpDD->SetDisplayMode(1280,800,16,0,0);
if (hRet!=DD_OK)
{
return FALSE;
}
DDSCAPS2 ddscaps;
DDSURFACEDESC2 ddsd;
ZeroMemory(&ddscaps,sizeof(DDSCAPS2));
ZeroMemory(&ddsd,sizeof(ddsd));
ddsd.dwSize=sizeof(ddsd);
ddsd.dwFlags=DDSD_CAPS|DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE|DDSCAPS_FLIP|DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount=1;

hRet=lpDD->CreateSurface(&ddsd,&lpDDSPrimary,NULL);
if (hRet!=DD_OK)
{
return FALSE;
}

ddscaps.dwCaps=DDSCAPS_BACKBUFFER;
hRet=lpDDSPrimary->GetAttachedSurface(&ddscaps,&lpDDSBack);

if (hRet!=DD_OK)
{
return FALSE;
}
lpSlides[0]=bitmap_surface(file_names[0]);

draw_slide();

// hRet=lpDD->CreateClipper(NULL,&lpClip,NULL);
// if (hRet!=DD_OK)
// {
// return FALSE;
// }
// lpClip->SetHWnd(0,hWnd);
// lpDDSPrimary->SetClipper(lpClip);

return TRUE;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
// TODO: Place code here.
MSG msg;
if (!Init(hInstance,nCmdShow))
{
return FALSE;
}
while(GetMessage(&msg,NULL,NULL,NULL))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_DESTROY:
Cleanup();
PostQuitMessage(0);
break;
case WM_KEYDOWN:
switch(wParam)
{
case VK_LEFT:
cur_image--;
if(cur_image<0)
{
cur_image=IMAGE_COUNT-1;
}
draw_slide();
break;
case VK_RIGHT:
cur_image++;
if (cur_image>IMAGE_COUNT-1)
{
cur_image=0;
}
draw_slide();
break;
case VK_ESCAPE:
DestroyWindow(hWnd);
break;
default:
break;
}
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
LPDIRECTDRAWSURFACE7 bitmap_surface(LPCTSTR file_name)
{
HDC hdc;
HBITMAP bit;
LPDIRECTDRAWSURFACE7 surf;
bit=(HBITMAP)LoadImage(NULL,file_name,IMAGE_BITMAP,0,0,LR_DEFAULTSIZE|LR_LOADFROMFILE);
if (!bit)
return NULL;
BITMAP bitmap;
GetObject(bit,sizeof(BITMAP),&bitmap);
int surf_width=bitmap.bmWidth;
int surf_height=bitmap.bmHeight;

HRESULT hRet;
// ZeroMemory(surf,sizeof(LPDIRECTDRAWSURFACE7));
DDSURFACEDESC2 ddsd;
ZeroMemory(&ddsd,sizeof(ddsd));
ddsd.dwSize=sizeof(DDSURFACEDESC2);
ddsd.dwFlags=DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps=DDSCAPS_OFFSCREENPLAIN|DDSCAPS_SYSTEMMEMORY;
ddsd.dwWidth=surf_width;
ddsd.dwHeight=surf_height;
hRet=lpDD->CreateSurface(&ddsd,&surf,NULL);
if (hRet!=DD_OK)
{
DeleteObject(bit);
return NULL;
}
else
{
surf->GetDC(&hdc);
HDC bit_dc=CreateCompatibleDC(hdc);
SelectObject(bit_dc,bit);
BitBlt(hdc,0,0,surf_width,surf_height,bit_dc,0,0,SRCCOPY);
surf->ReleaseDC(bit_dc);
}
DeleteObject(bit);
return surf;
}
void draw_slide()
{
HRESULT hRet;
if (!lpSlides[cur_image])
{
lpSlides[cur_image]=bitmap_surface(file_names[cur_image]);
if (!lpSlides[cur_image])
return;
}
// hRet=lpDDSBack->BltFast(0,0,lpSlides[cur_image],NULL,DDBLTFAST_WAIT);
DDBLTFX ddbltfx;
hRet=lpDDSBack->Blt(NULL,lpSlides[cur_image],NULL,DDBLT_WAIT,&ddbltfx);
// switch(hRet)
// {
// case DDERR_EXCEPTION:
// MessageBox(NULL,"DDERR_EXCEPTION","错误",MB_OK);
// break;
// case DDERR_GENERIC:
// MessageBox(NULL,"DDERR_GENERIC","错误",MB_OK);
// break;
// case DDERR_INVALIDOBJECT:
// MessageBox(NULL,"DDERR_INVALIDOBJECT","错误",MB_OK);
// break;
// case DDERR_INVALIDPARAMS:
// MessageBox(NULL,"DDERR_INVALIDPARAMS","错误",MB_OK);
// break;
// case DDERR_INVALIDRECT:
// MessageBox(NULL,"DDERR_INVALIDRECT","错误",MB_OK);
// break;
// case DDERR_NOBLTHW:
// MessageBox(NULL,"DDERR_NOBLTHW","错误",MB_OK);
// break;
// case DDERR_SURFACEBUSY:
// MessageBox(NULL,"DDERR_SURFACEBUSY","错误",MB_OK);
// break;
// case DDERR_SURFACELOST:
// MessageBox(NULL,"DDERR_SURFACELOST","错误",MB_OK);
// break;
// case DDERR_UNSUPPORTED:
// MessageBox(NULL,"DDERR_UNSUPPORTED","错误",MB_OK);
// break;
// case DDERR_WASSTILLDRAWING:
// MessageBox(NULL,"DDERR_WASSTILLDRAWING","错误",MB_OK);
// break;
// }
HDC hdc;
if (DD_OK==lpDDSBack->GetDC(&hdc))
{
SetTextColor(hdc,0x00FF7F00);
SetBkColor(hdc,0x000000);
TextOut(hdc,20,700,"<-Previous Slide",16);
TextOut(hdc,1000,700,"Next Slide ->",13);
SetTextColor(hdc,0x0000FFFF);
TextOut(hdc,400,750,"Press Arrow Keys to Change Slides",33);
lpDDSBack->ReleaseDC(hdc);
}

lpDDSPrimary->Flip(0,DDFLIP_WAIT);

int next_slide=(cur_image>=IMAGE_COUNT-1)?0:cur_image+1;
if (!lpSlides[next_slide])
{
lpSlides[next_slide]=bitmap_surface(file_names[next_slide]);
}
int prev_slide=(cur_image<1)?IMAGE_COUNT-1:cur_image-1;
if (!lpSlides[prev_slide])
{
lpSlides[prev_slide]=bitmap_surface(file_names[prev_slide]);
}
}
void Cleanup()
{
for (int i=0;i<IMAGE_COUNT;i++)
{
SafeRelease(lpSlides[i]);
}
SafeRelease(lpDDSPrimary);
SafeRelease(lpDDSBack);
SafeRelease(lpDD);
}

...全文