HRESULT d3drm_device_create_surfaces_from_clipper(struct d3drm_device *object, IDirectDraw *ddraw, IDirectDrawClipper *clipper, int width, int height, IDirectDrawSurface **surface) { DDSURFACEDESC surface_desc; IDirectDrawSurface *primary_surface, *render_target; HWND window; HRESULT hr; hr = IDirectDrawClipper_GetHWnd(clipper, &window); if (FAILED(hr)) return hr; hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL); if (FAILED(hr)) return hr; memset(&surface_desc, 0, sizeof(surface_desc)); surface_desc.dwSize = sizeof(surface_desc); surface_desc.dwFlags = DDSD_CAPS; surface_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &primary_surface, NULL); if (FAILED(hr)) return hr; hr = IDirectDrawSurface_SetClipper(primary_surface, clipper); if (FAILED(hr)) { IDirectDrawSurface_Release(primary_surface); return hr; } memset(&surface_desc, 0, sizeof(surface_desc)); surface_desc.dwSize = sizeof(surface_desc); surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE; surface_desc.dwWidth = width; surface_desc.dwHeight = height; hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &render_target, NULL); if (FAILED(hr)) { IDirectDrawSurface_Release(primary_surface); return hr; } object->primary_surface = primary_surface; object->clipper = clipper; IDirectDrawClipper_AddRef(clipper); *surface = render_target; return D3DRM_OK; }
Err GE2DLibOpen() { DDSURFACEDESC Desc; HRESULT (WINAPI* DirectDrawCreate)( void*, LPDIRECTDRAW*, void* ); Module = LoadLibrary(T("DDRAW.DLL")); *(FARPROC*)&DirectDrawCreate = GetProcAddress(Module,"DirectDrawCreate"); if (!DirectDrawCreate) return 1; if (DirectDrawCreate(NULL,&DD,NULL)!=DD_OK) return 1; IDirectDraw_SetCooperativeLevel(DD, NULL, DDSCL_NORMAL); // get primary surface memset(&Desc,0,sizeof(DDSURFACEDESC)); Desc.dwSize = sizeof(DDSURFACEDESC); Desc.dwFlags = DDSD_CAPS; Desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; if (IDirectDraw_CreateSurface(DD,&Desc,&DDPrimary,NULL) != DD_OK) return 1; return errNone; }
Err GE2DShowOverlay(Coord left, Coord top, GE2DBitmapType *p) { DWORD Id; DDSURFACEDESC Desc; if (p->format != sonyGE2DFormatYCbCr420Planar) return 1; GE2DHideOverlay(); memset(&Desc,0,sizeof(DDSURFACEDESC)); Desc.dwSize = sizeof(DDSURFACEDESC); Desc.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT; Desc.dwWidth = p->width; Desc.dwHeight = p->height; Desc.ddpfPixelFormat.dwSize = sizeof(Desc.ddpfPixelFormat); Desc.ddpfPixelFormat.dwFlags = DDPF_FOURCC; Desc.ddpfPixelFormat.dwFourCC = FOURCC_YV12; Desc.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_OVERLAY; if (IDirectDraw_CreateSurface(DD,&Desc,&DDBuffer,NULL) != DD_OK) return 1; memset(&DDDst,-1,sizeof(DDDst)); DDTop = top; DDLeft = left; DDCopy(p); DDUpdate(p); ThreadRun = 1; Thread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)ThreadCopy,p,0,&Id); return 0; }
// DDCreateSurface // Create an offscreen surface hopefully in video memory // ---------------------------------------------------------------------------- LPDIRECTDRAWSURFACE DDCreateSurface(int width, int height, BOOL vram) { DDSURFACEDESC ddsd; HRESULT ddresult; LPDIRECTDRAWSURFACE lpdds; DDCOLORKEY ddck; if (_DDSysMemSurfacing && !vram) return DDCreateSysMemSurface(width, height); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = width; ddsd.dwHeight = height; // logentry("Creating %dx%d sysram/vidram surface.\n", width, height); ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &lpdds, NULL); if (ddresult != DD_OK) { logentry("DDRAW::CreateSurface err: %x\n", ddresult); return NULL; } return lpdds; }
static LPDIRECTDRAWSURFACE CreateBMP( win32_driver_t * win32_driver, int resource ) { LPDIRECTDRAWSURFACE bmp_surf; DDSURFACEDESC bmp_ddsd; HBITMAP bmp_hndl; BITMAP bmp_head; HDC hdc_dds; HDC hdc_mem; /* load our bitmap from a resource */ if( !( bmp_hndl = LoadBitmap( win32_driver->win32_visual->HInst, MAKEINTRESOURCE( resource ) ) ) ) { Error( 0, "CreateBitmap : could not load bmp resource" ); return 0; } /* create an off screen surface with * the same dimentions as our bitmap */ GetObject( bmp_hndl, sizeof( bmp_head ), &bmp_head ); memset( &bmp_ddsd, 0, sizeof( bmp_ddsd ) ); bmp_ddsd.dwSize = sizeof( bmp_ddsd ); bmp_ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; bmp_ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; bmp_ddsd.dwWidth = bmp_head.bmWidth; bmp_ddsd.dwHeight = bmp_head.bmHeight; if( IDirectDraw_CreateSurface( win32_driver->ddobj, &bmp_ddsd, &bmp_surf, 0 ) != DD_OK ) { Error( 0, "CreateSurface ( bitmap ) : could not create dd surface" ); return 0; } /* get a handle to our surface dc, * create a compat dc and load * our bitmap into the compat dc */ IDirectDrawSurface_GetDC( bmp_surf, &hdc_dds ); hdc_mem = CreateCompatibleDC( hdc_dds ); SelectObject( hdc_mem, bmp_hndl ); /* copy our bmp from the compat dc * into our dd surface */ BitBlt( hdc_dds, 0, 0, bmp_head.bmWidth, bmp_head.bmHeight, hdc_mem, 0, 0, SRCCOPY ); /* clean up */ DeleteDC( hdc_mem ); DeleteObject( bmp_hndl ); IDirectDrawSurface_ReleaseDC( bmp_surf, hdc_dds ); return bmp_surf; }
unsigned short dd_gfx_createbitmap2D(int w, int h) { int i, force; unsigned short handle; if (!dd_gfx_initialized) return 0; for (i = 0; i < MAX_GFX_BITMAPS; i++) if (!gfxBitmap[i].lpdds) { handle = (unsigned short)(i); break; } if (i == MAX_GFX_BITMAPS) return 0; // Only do this if we can benefit from it. // if (ddDriverCaps.hwcolorkey && ddDriverCaps.hwbltstretch) if (FindArg("-forcegfx")) force = 1; else force = 0; if (ddDriverCaps.hwcolorkey || force) { LPDIRECTDRAWSURFACE lpdds; DDSURFACEDESC ddsd; HRESULT ddresult; DDCOLORKEY ddck; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; ddsd.dwWidth = w; ddsd.dwHeight = h; ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &lpdds, NULL); if (ddresult != DD_OK) { mprintf((0, "DDGFX: Failed to create vidmem 2d bitmap (%x).\n", ddresult)); return 0; } ddck.dwColorSpaceLowValue = TRANSPARENCY_COLOR; ddck.dwColorSpaceHighValue = TRANSPARENCY_COLOR; IDirectDrawSurface_SetColorKey(lpdds, DDCKEY_SRCBLT, &ddck); gfxBitmap[handle].lpdds = lpdds; gfxBitmap[handle].w = w; gfxBitmap[handle].h = h; handle++; // Make it a valid handle } else handle = 0; return handle; }
static void createsurface(void) { DDSURFACEDESC ddsd; DDSCAPS ddscaps; HRESULT rc; ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX; ddsd.dwBackBufferCount = 1; rc = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSPrimary, NULL ); ok(rc==DD_OK,"CreateSurface returned: %x\n",rc); ddscaps.dwCaps = DDSCAPS_BACKBUFFER; rc = IDirectDrawSurface_GetAttachedSurface(lpDDSPrimary, &ddscaps, &lpDDSBack); ok(rc==DD_OK,"GetAttachedSurface returned: %x\n",rc); }
static int dx_alloc_buffers(char **b1, char **b2) { DWORD ddrval; DDSURFACEDESC ddsd; int i; currentbuff = 0; memset(surface, 0, sizeof(DDSURFACEDESC) * 2); memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(ddsd); if (IDirectDrawSurface_GetSurfaceDesc(lpSurfaces[0], &ddsd) != DD_OK) { DeInitDD(); x_error("Failed to get pixel format"); return 0; } for (i = 0; i < 2; i++) { ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS; ddsd.dwWidth = displayX; ddsd.dwHeight = displayY; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; ddrval = IDirectDraw_CreateSurface(lpDD, &ddsd, &BackSurface[i], NULL); if (ddrval != DD_OK) { DeInitDD(); x_error("Failed to create back surface"); return 0; } } for (i = 0; i < 2; i++) { surface[i].dwSize = sizeof(DDSURFACEDESC); ddrval = IDirectDrawSurface_Lock(BackSurface[i], NULL, surface + i, DDLOCK_WAIT, NULL); if (ddrval != DD_OK) { DeInitDD(); x_fatalerror("Failed to lock offscreen surfaces"); } } buffer1 = *b1 = (char *) surface[0].lpSurface; buffer2 = *b2 = (char *) surface[1].lpSurface; lineSize = surface[0].u1.lPitch; initialized = 1; return lineSize; }
static int DxCreatePrimarySurface(void) { DDSURFACEDESC2 ddsd; if (g_lpddsPrimary) { IDirectDrawSurface_Release(g_lpddsPrimary); g_lpddsPrimary = NULL; } ZeroMemory(&ddsd, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; if (IDirectDraw_CreateSurface(g_lpdd, &ddsd, &g_lpddsPrimary, NULL) == DD_OK) { return TRUE; } return FALSE; }
static int DxCreateOffbuffer(void) { DDSURFACEDESC2 ddsd; if (g_lpddsBack) { IDirectDrawSurface_Release(g_lpddsBack); g_lpddsBack = NULL; } ZeroMemory(&ddsd, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.dwWidth = g_image_width; ddsd.dwHeight = g_image_height; if (IDirectDraw_CreateSurface(g_lpdd, &ddsd, &g_lpddsBack, 0) != DD_OK) { return FALSE; } return TRUE; }
static void CapsTest(void) { DDSURFACEDESC ddsd; IDirectDraw *dd1 = createDD(); IDirectDrawSurface *surf; HRESULT hr; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_VIDEOMEMORY; ddsd.dwWidth = 64; ddsd.dwHeight = 64; hr = IDirectDraw_CreateSurface(dd1, &ddsd, &surf, NULL); if (hr == DDERR_UNSUPPORTEDMODE) { win_skip("Unsupported mode\n"); return; } ok(hr == DD_OK, "Creating a SYSMEM | VIDMEM surface returned 0x%08x, expected DD_OK\n", hr); if(surf) IDirectDrawSurface_Release(surf); IDirectDraw_Release(dd1); }
static void WINAPI VGA_DoSetMode(ULONG_PTR arg) { LRESULT res; ModeSet *par = (ModeSet *)arg; par->ret=1; if (lpddraw) VGA_DoExit(0); if (!lpddraw) { if (!pDirectDrawCreate) { HMODULE hmod = LoadLibraryA( "ddraw.dll" ); if (hmod) pDirectDrawCreate = (DirectDrawCreateProc)GetProcAddress( hmod, "DirectDrawCreate" ); if (!pDirectDrawCreate) { ERR("Can't lookup DirectDrawCreate from ddraw.dll.\n"); return; } } res = pDirectDrawCreate(NULL,&lpddraw,NULL); if (!lpddraw) { ERR("DirectDraw is not available (res = %lx)\n",res); return; } if (!vga_hwnd) { vga_hwnd = CreateWindowExA(0,"STATIC","WINEDOS VGA", WS_POPUP|WS_VISIBLE|SS_NOTIFY,0,0, par->Xres,par->Yres,0,0,0,NULL); if (!vga_hwnd) { ERR("Failed to create user window.\n"); IDirectDraw_Release(lpddraw); lpddraw=NULL; return; } } else SetWindowPos(vga_hwnd,0,0,0,par->Xres,par->Yres,SWP_NOMOVE|SWP_NOZORDER); if ((res=IDirectDraw_SetCooperativeLevel(lpddraw,vga_hwnd,DDSCL_FULLSCREEN|DDSCL_EXCLUSIVE))) { ERR("Could not set cooperative level to exclusive (%lx)\n",res); } if ((res=IDirectDraw_SetDisplayMode(lpddraw,par->Xres,par->Yres,par->Depth))) { ERR("DirectDraw does not support requested display mode (%dx%dx%d), res = %lx!\n",par->Xres,par->Yres,par->Depth,res); IDirectDraw_Release(lpddraw); lpddraw=NULL; return; } res=IDirectDraw_CreatePalette(lpddraw,DDPCAPS_8BIT,NULL,&lpddpal,NULL); if (res) { ERR("Could not create palette (res = %lx)\n",res); IDirectDraw_Release(lpddraw); lpddraw=NULL; return; } if ((res=IDirectDrawPalette_SetEntries(lpddpal,0,0,256,vga_def_palette))) { ERR("Could not set default palette entries (res = %lx)\n", res); } memset(&sdesc,0,sizeof(sdesc)); sdesc.dwSize=sizeof(sdesc); sdesc.dwFlags = DDSD_CAPS; sdesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; if (IDirectDraw_CreateSurface(lpddraw,&sdesc,&lpddsurf,NULL)||(!lpddsurf)) { ERR("DirectDraw surface is not available\n"); IDirectDraw_Release(lpddraw); lpddraw=NULL; return; } IDirectDrawSurface_SetPalette(lpddsurf,lpddpal); vga_retrace_vertical = vga_retrace_horizontal = FALSE; /* poll every 20ms (50fps should provide adequate responsiveness) */ VGA_InstallTimer(20); } par->ret=0; return; }
static HRESULT ddrawstreamsample_create(IDirectDrawMediaStream *parent, IDirectDrawSurface *surface, const RECT *rect, IDirectDrawStreamSample **ddraw_stream_sample) { IDirectDrawStreamSampleImpl *object; HRESULT hr; TRACE("(%p)\n", ddraw_stream_sample); object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); if (!object) return E_OUTOFMEMORY; object->IDirectDrawStreamSample_iface.lpVtbl = &DirectDrawStreamSample_Vtbl; object->ref = 1; object->parent = (IMediaStream*)parent; IMediaStream_AddRef(object->parent); if (surface) { object->surface = surface; IDirectDrawSurface_AddRef(surface); } else { DDSURFACEDESC desc; IDirectDraw *ddraw; hr = IDirectDrawMediaStream_GetDirectDraw(parent, &ddraw); if (FAILED(hr)) { IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface); return hr; } desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT; desc.dwHeight = 100; desc.dwWidth = 100; desc.ddpfPixelFormat.dwSize = sizeof(desc.ddpfPixelFormat); desc.ddpfPixelFormat.dwFlags = DDPF_RGB; desc.ddpfPixelFormat.dwRGBBitCount = 32; desc.ddpfPixelFormat.dwRBitMask = 0xff0000; desc.ddpfPixelFormat.dwGBitMask = 0x00ff00; desc.ddpfPixelFormat.dwBBitMask = 0x0000ff; desc.ddpfPixelFormat.dwRGBAlphaBitMask = 0; desc.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY|DDSCAPS_OFFSCREENPLAIN; desc.lpSurface = NULL; hr = IDirectDraw_CreateSurface(ddraw, &desc, &object->surface, NULL); IDirectDraw_Release(ddraw); if (FAILED(hr)) { ERR("failed to create surface, 0x%08x\n", hr); IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface); return hr; } } if (rect) object->rect = *rect; else if (object->surface) { DDSURFACEDESC desc = { sizeof(desc) }; hr = IDirectDrawSurface_GetSurfaceDesc(object->surface, &desc); if (hr == S_OK) { object->rect.left = object->rect.top = 0; object->rect.right = desc.dwWidth; object->rect.bottom = desc.dwHeight; } } *ddraw_stream_sample = &object->IDirectDrawStreamSample_iface; return S_OK; }
static void testcooperativelevels_normal(void) { BOOL sfw; HRESULT rc; DDSURFACEDESC surfacedesc; IDirectDrawSurface *surface = (IDirectDrawSurface *) 0xdeadbeef; memset(&surfacedesc, 0, sizeof(surfacedesc)); surfacedesc.dwSize = sizeof(surfacedesc); surfacedesc.ddpfPixelFormat.dwSize = sizeof(surfacedesc.ddpfPixelFormat); surfacedesc.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; surfacedesc.dwBackBufferCount = 1; surfacedesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP; rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_SETFOCUSWINDOW | DDSCL_CREATEDEVICEWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_SETFOCUSWINDOW | DDSCL_CREATEDEVICEWINDOW) returned: %x\n",rc); /* Do some tests with DDSCL_NORMAL mode */ /* Fullscreen mode + normal mode + exclusive mode */ rc = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_NORMAL); ok(rc==DDERR_INVALIDPARAMS, "Expected DDERR_INVALIDPARAMS, received: %x\n", rc); sfw=FALSE; if(hwnd2) sfw=SetForegroundWindow(hwnd2); else skip("Failed to create the second window\n"); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_NORMAL); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_NORMAL) returned: %x\n",rc); if(sfw) ok(GetForegroundWindow()==hwnd,"Expected the main windows (%p) for foreground, received the second one (%p)\n",hwnd, hwnd2); /* Try creating a double buffered primary in fullscreen + exclusive + normal mode */ rc = IDirectDraw_CreateSurface(lpDD, &surfacedesc, &surface, NULL); if (rc == DDERR_UNSUPPORTEDMODE) skip("Unsupported mode\n"); else { ok(rc == DD_OK, "IDirectDraw_CreateSurface returned %08x\n", rc); ok(surface!=NULL, "Returned NULL surface pointer\n"); } if(surface && surface != (IDirectDrawSurface *)0xdeadbeef) IDirectDrawSurface_Release(surface); /* Exclusive mode + normal mode */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_EXCLUSIVE | DDSCL_NORMAL); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_EXCLUSIVE | DDSCL_NORMAL) returned: %x\n",rc); /* Fullscreen mode + normal mode */ sfw=FALSE; if(hwnd2) sfw=SetForegroundWindow(hwnd2); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_FULLSCREEN | DDSCL_NORMAL); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_FULLSCREEN | DDSCL_NORMAL) returned: %x\n",rc); if(sfw) ok(GetForegroundWindow()==hwnd2,"Expected the second windows (%p) for foreground, received the main one (%p)\n",hwnd2, hwnd); rc = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_FULLSCREEN | DDSCL_NORMAL); ok(rc==DD_OK, "Expected DD_OK, received %x\n", rc); /* Try creating a double buffered primary in fullscreen + normal mode */ rc = IDirectDraw_CreateSurface(lpDD, &surfacedesc, &surface, NULL); if (rc == DDERR_UNSUPPORTEDMODE) skip("Unsupported mode\n"); else { ok(rc == DDERR_NOEXCLUSIVEMODE, "IDirectDraw_CreateSurface returned %08x\n", rc); ok(surface == NULL, "Returned surface pointer is %p\n", surface); } if(surface && surface != (IDirectDrawSurface *)0xdeadbeef) IDirectDrawSurface_Release(surface); /* switching from Fullscreen mode to Normal mode */ sfw=FALSE; if(hwnd2) sfw=SetForegroundWindow(hwnd2); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NORMAL); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_NORMAL) returned: %x\n",rc); if(sfw) ok(GetForegroundWindow()==hwnd2,"Expected the second windows (%p) for foreground, received the main one (%p)\n",hwnd2, hwnd); rc = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL); ok(rc==DD_OK, "Expected DD_OK, received %x\n", rc); /* Try creating a double buffered primary in normal mode */ rc = IDirectDraw_CreateSurface(lpDD, &surfacedesc, &surface, NULL); if (rc == DDERR_UNSUPPORTEDMODE) skip("Unsupported mode\n"); else { ok(rc == DDERR_NOEXCLUSIVEMODE, "IDirectDraw_CreateSurface returned %08x\n", rc); ok(surface == NULL, "Returned surface pointer is %p\n", surface); } if(surface && surface != (IDirectDrawSurface *)0xdeadbeef) IDirectDrawSurface_Release(surface); /* switching from Normal mode to Fullscreen + Normal mode */ sfw=FALSE; if(hwnd2) sfw=SetForegroundWindow(hwnd2); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NORMAL | DDSCL_FULLSCREEN); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_NORMAL | FULLSCREEN) returned: %x\n",rc); if(sfw) ok(GetForegroundWindow()==hwnd2,"Expected the second windows (%p) for foreground, received the main one (%p)\n",hwnd2, hwnd); rc = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_NORMAL | DDSCL_FULLSCREEN); ok(rc==DD_OK, "Expected DD_OK, received %x\n", rc); /* Set the focus window */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_SETFOCUSWINDOW | DDSCL_CREATEDEVICEWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_SETFOCUSWINDOW | DDSCL_CREATEDEVICEWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, NULL, DDSCL_SETFOCUSWINDOW); if (rc == DDERR_INVALIDPARAMS) { win_skip("NT4/Win95 do not support cooperative levels DDSCL_SETDEVICEWINDOW and DDSCL_SETFOCUSWINDOW\n"); return; } ok(rc==DD_OK, "Expected DD_OK, received %x\n", rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_SETFOCUSWINDOW); if (rc == DDERR_INVALIDPARAMS) { win_skip("NT4/Win95 do not support cooperative levels DDSCL_SETDEVICEWINDOW and DDSCL_SETFOCUSWINDOW\n"); return; } ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); /* Set the focus window a second time*/ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_SETFOCUSWINDOW); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_SETFOCUSWINDOW) the second time returned: %x\n",rc); /* Test DDSCL_SETFOCUSWINDOW with the other flags. They should all fail, except of DDSCL_NOWINDOWCHANGES */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NORMAL | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_NORMAL | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); /* This one succeeds */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NOWINDOWCHANGES | DDSCL_SETFOCUSWINDOW); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_NOWINDOWCHANGES | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_MULTITHREADED | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_MULTITHREADED | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_FPUSETUP | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_FPUSETUP | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_FPUPRESERVE | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_FPUPRESERVE | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_ALLOWREBOOT | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_ALLOWREBOOT | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_ALLOWMODEX | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_ALLOWMODEX | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); /* Set the device window without any other flags. Should give an error */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_SETDEVICEWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_SETDEVICEWINDOW) returned: %x\n",rc); /* Set device window with DDSCL_NORMAL */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NORMAL | DDSCL_SETDEVICEWINDOW); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_NORMAL | DDSCL_SETDEVICEWINDOW) returned: %x\n",rc); /* Also set the focus window. Should give an error */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_ALLOWMODEX | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_SETDEVICEWINDOW | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_NORMAL | DDSCL_SETDEVICEWINDOW | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); /* All done */ }
BOOL DDCreateScreen(int flags) { DDSCAPS ddscaps; DDCAPS ddcaps, ddcaps2; DDSURFACEDESC ddsd; HRESULT ddresult; memset(&ddcaps, 0, sizeof(ddcaps)); memset(&ddcaps2, 0, sizeof(ddcaps2)); ddcaps.dwSize = sizeof(ddcaps); ddcaps2.dwSize = sizeof(ddcaps); ddresult = IDirectDraw_GetCaps(_lpDD, &ddcaps, &ddcaps2); if (!CheckDDResult(ddresult, "DDCreateScreen::GetCaps")) return FALSE; logentry("DirectDraw HW Caps: %x\nDirectDraw HEL Caps: %x\n",ddcaps.dwCaps,ddcaps2.dwCaps); if (ddcaps.dwCaps & DDCAPS_BANKSWITCHED) { logentry("DirectDraw: Hardware is bank-switched. Using SRAM rendering.\n"); _DDSysMemSurfacing = TRUE; } else { logentry("DirectDraw: Hardware is not bank-switched. Using VRAM rendering.\n"); _DDSysMemSurfacing = FALSE; } // Determine GFX caps. if (ddcaps.dwCaps & DDCAPS_COLORKEYHWASSIST) ddDriverCaps.hwcolorkey = 1; else ddDriverCaps.hwcolorkey = 0; if (ddcaps.dwCaps & DDCAPS_BLTSTRETCH) ddDriverCaps.hwbltstretch = 1; else ddDriverCaps.hwbltstretch = 0; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); if (_DDFullScreen && GRMODEINFO(paged)) { // We should use page flipping ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; ddsd.dwBackBufferCount = 1; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX; ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &_lpDDSPrimary, NULL); if (!CheckDDResult(ddresult, "DDCreateScreen::CreateSurface -fullscreen")) return FALSE; ddscaps.dwCaps = DDSCAPS_BACKBUFFER; ddresult = IDirectDrawSurface_GetAttachedSurface(_lpDDSPrimary, &ddscaps, &_lpDDSBack); if (!CheckDDResult(ddresult, "DDCreateScreen::GetAttachedSurface")) return FALSE; } else { // We just create a primary and offscreen buffer if (GRMODEINFO(emul) && !_lpDDSPrimary) { // make sure we don't reinitialize the screen if we already made it // beforehand for windowed version ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &_lpDDSPrimary, NULL); if (!CheckDDResult(ddresult, "DDCreateScreen::CreateSurface -windowed")) return FALSE; } else if (!GRMODEINFO(emul)) { // If we aren't emulating ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &_lpDDSPrimary, NULL); if (!CheckDDResult(ddresult, "DDCreateScreen::CreateSurface -windowed")) return FALSE; } if (GRMODEINFO(emul)) { _lpDDSBack = DDCreateSurface(_DDModeList[W95DisplayMode].rw, _DDModeList[W95DisplayMode].rh, 1); if (!_lpDDSBack) { mprintf((0,"Call to create DDSBackBuffer failed.")); return FALSE; } } else _lpDDSBack = NULL; } // Create 8-bit palette { ubyte pal[768]; memset(pal, 0, 768); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); IDirectDrawSurface_GetSurfaceDesc(_lpDDSPrimary, &ddsd); logentry("Primary surface pixel format: %x, %d\n", ddsd.ddpfPixelFormat.dwFlags, ddsd.ddpfPixelFormat.dwRGBBitCount); _lpDDPalette = DDCreatePalette(pal); Assert(_lpDDPalette != NULL); DDSetPalette(_lpDDPalette); } return TRUE; }
HRESULT d3drm_device_init(struct d3drm_device *device, UINT version, IDirectDraw *ddraw, IDirectDrawSurface *surface, BOOL create_z_surface) { DDSCAPS caps = { DDSCAPS_ZBUFFER }; IDirectDrawSurface *ds = NULL; IDirect3DDevice *device1 = NULL; IDirect3DDevice2 *device2 = NULL; IDirect3D2 *d3d2 = NULL; DDSURFACEDESC desc, surface_desc; HRESULT hr; device->ddraw = ddraw; IDirectDraw_AddRef(ddraw); IDirect3DRM_AddRef(device->d3drm); device->render_target = surface; IDirectDrawSurface_AddRef(surface); desc.dwSize = sizeof(desc); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &desc); if (FAILED(hr)) return hr; if (!(desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE)) return DDERR_INVALIDCAPS; hr = IDirectDrawSurface_GetAttachedSurface(surface, &caps, &ds); if (SUCCEEDED(hr)) { create_z_surface = FALSE; IDirectDrawSurface_Release(ds); ds = NULL; } if (create_z_surface) { memset(&surface_desc, 0, sizeof(surface_desc)); surface_desc.dwSize = sizeof(surface_desc); surface_desc.dwFlags = DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_WIDTH | DDSD_HEIGHT; surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; surface_desc.u2.dwZBufferBitDepth = 16; surface_desc.dwWidth = desc.dwWidth; surface_desc.dwHeight = desc.dwHeight; hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &ds, NULL); if (FAILED(hr)) return hr; hr = IDirectDrawSurface_AddAttachedSurface(surface, ds); IDirectDrawSurface_Release(ds); if (FAILED(hr)) return hr; } if (version == 1) hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DRGBDevice, (void **)&device1); else { IDirectDraw_QueryInterface(ddraw, &IID_IDirect3D2, (void**)&d3d2); hr = IDirect3D2_CreateDevice(d3d2, &IID_IDirect3DRGBDevice, surface, &device2); IDirect3D2_Release(d3d2); } if (FAILED(hr)) { IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds); return hr; } if (version != 1) { hr = IDirect3DDevice2_QueryInterface(device2, &IID_IDirect3DDevice, (void**)&device1); IDirect3DDevice2_Release(device2); if (FAILED(hr)) { IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds); return hr; } } device->device = device1; device->width = desc.dwWidth; device->height = desc.dwHeight; return hr; }
/* get_dx_ver: * returns the DirectX dx_version number: * * 0 no DirectX installed * 0x100 DirectX 1 installed * 0x200 DirectX 2 installed * 0x300 DirectX 3 installed * 0x500 at least DirectX 5 installed * 0x600 at least DirectX 6 installed * 0x700 at least DirectX 7 installed */ int get_dx_ver(void) { HRESULT hr; HINSTANCE ddraw_hinst = NULL; HINSTANCE dinput_hinst = NULL; HINSTANCE dsetup_hinst = NULL; LPDIRECTDRAW directdraw = NULL; LPDIRECTDRAW2 directdraw2 = NULL; DIRECTDRAWCREATE DirectDrawCreate = NULL; DIRECTINPUTCREATE DirectInputCreate = NULL; DSETUPCREATE DSetupCreate = NULL; OSVERSIONINFO os_version; LPDIRECTDRAWSURFACE ddraw_surf = NULL; LPDIRECTDRAWSURFACE3 ddraw_surf3 = NULL; DWORD dsetup_revision; DWORD dsetup_version; INT dsetup_result; #if DIRECTX_SDK_VERSION >= 0x600 LPDIRECTDRAWSURFACE4 ddraw_surf4 = NULL; #if DIRECTX_SDK_VERSION >= 0x700 LPDIRECTDRAWSURFACE7 ddraw_surf7 = NULL; #endif #endif DDSURFACEDESC ddraw_surf_desc; LPVOID temp; int dx_version = 0; /* first get the Windows platform */ os_version.dwOSVersionInfoSize = sizeof(os_version); if (!GetVersionEx(&os_version)) return dx_version; if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT) { /* NT is easy... NT 4.0 is DX2, 4.0 SP3 is DX3, 5.0 is DX5 at least * and no DX on earlier versions */ if (os_version.dwMajorVersion < 4) { /* No DX on NT 3.51 or earlier */ return dx_version; } /* First check for DX 8 and 9 */ dsetup_hinst = LoadLibrary( "DSETUP.DLL" ); if ( dsetup_hinst ) { DSetupCreate = (DSETUPCREATE)GetProcAddress(dsetup_hinst, "DirectXSetupGetVersion"); if ( DSetupCreate ) { dsetup_result = DSetupCreate( &dsetup_version, &dsetup_revision ); // returns 0 on failure if ( dsetup_result ) { switch (dsetup_version) { case 0x00040005: dx_version = 0x500; break; case 0x00040006: dx_version = 0x600; break; case 0x00040007: dx_version = 0x700; break; case 0x00040008: /* v8.x */ dx_version = 0x800; switch (dsetup_revision) { case 0x0001032A: case 0x00010371: dx_version = 0x810; /* 8.1 */ dx_version = 0x810; /* 8.1 */ break; case 0x00010385: dx_version = 0x81a; /* 8.1a or b (stupid MS...) */ break; case 0x00020386: dx_version = 0x820; /* 8.2 */ break; default: dx_version = 0x800; /* 8.0 */ } /* switch (dsetup_revision) */ case 0x00040009: switch (dsetup_revision) { case 0x00000384: dx_version = 0x900; /* 9.0 */ break; case 0x00000385: dx_version = 0x90a; /* 9.0a */ break; case 0x00000386: dx_version = 0x90b; /* 9.0b */ break; case 0x00000387: dx_version = 0x90b; /* 9.0(b or c) */ break; case 0x00000388: dx_version = 0x90c; /* 9.0c */ break; default: dx_version = 0x900; } /* switch (dsetup_revision) */ } /* switch (dsetup_version) */ } } FreeLibrary( dsetup_hinst ); if ( dx_version ) return dx_version; } if (os_version.dwMajorVersion == 4) { /* NT4 up to SP2 is DX2, and SP3 onwards is DX3, so we are at least DX2 */ dx_version = 0x200; /* we are not supposed to be able to tell which SP we are on, so check for DInput */ dinput_hinst = LoadLibrary("DINPUT.DLL"); if (!dinput_hinst) { /* no DInput... must be DX2 on NT 4 pre-SP3 */ OutputDebugString("Couldn't LoadLibrary DInput\r\n"); return dx_version; } DirectInputCreate = (DIRECTINPUTCREATE) GetProcAddress(dinput_hinst, "DirectInputCreateA"); FreeLibrary(dinput_hinst); if (!DirectInputCreate) { /* no DInput... must DX2 on NT 4 pre-SP3 */ return dx_version; } /* DX3 on NT4 SP3 or higher */ dx_version = 0x300; return dx_version; } /* it's at least NT 5 and it's DX5a or higher: * drop through to Win9x tests for a test of DDraw */ } /* now we know we are in Windows 9x (or maybe 3.1), so anything's possible; * first see if DDRAW.DLL even exists. */ ddraw_hinst = LoadLibrary("DDRAW.DLL"); if (!ddraw_hinst) { dx_version = 0; goto End; } /* see if we can create the DirectDraw object */ DirectDrawCreate = (DIRECTDRAWCREATE) GetProcAddress(ddraw_hinst, "DirectDrawCreate"); if (!DirectDrawCreate) { dx_version = 0; goto End; } hr = DirectDrawCreate(NULL, &directdraw, NULL); if (FAILED(hr)) { dx_version = 0; goto End; } /* so DirectDraw exists, we are at least DX1 */ dx_version = 0x100; /* let's see if IDirectDraw2 exists */ hr = IDirectDraw_QueryInterface(directdraw, &IID_IDirectDraw2, &temp); if (FAILED(hr)) { /* no IDirectDraw2 exists... must be DX1 */ goto End; } directdraw2 = temp; /* IDirectDraw2 exists... must be at least DX2 */ IDirectDraw2_Release(directdraw2); dx_version = 0x200; /* see if we can create the DirectInput object */ dinput_hinst = LoadLibrary("DINPUT.DLL"); if (!dinput_hinst) { /* no DInput... must be DX2 */ goto End; } DirectInputCreate = (DIRECTINPUTCREATE) GetProcAddress(dinput_hinst, "DirectInputCreateA"); FreeLibrary(dinput_hinst); if (!DirectInputCreate) { /* no DInput... must be DX2 */ goto End; } /* DirectInputCreate exists; that's enough to tell us that we are at least DX3 */ dx_version = 0x300; /* we can tell if DX5 is present by checking for the existence of IDirectDrawSurface3; * first we need a surface to QI off of */ memset(&ddraw_surf_desc, 0, sizeof(ddraw_surf_desc)); ddraw_surf_desc.dwSize = sizeof(ddraw_surf_desc); ddraw_surf_desc.dwFlags = DDSD_CAPS; ddraw_surf_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw_SetCooperativeLevel(directdraw, NULL, DDSCL_NORMAL); if (FAILED(hr)) { /* failure: this means DDraw isn't properly installed */ dx_version = 0; goto End; } hr = IDirectDraw_CreateSurface(directdraw, &ddraw_surf_desc, &ddraw_surf, NULL); if (FAILED(hr)) { /* failure: this means DDraw isn't properly installed */ dx_version = 0; goto End; } /* try for the IDirectDrawSurface3 interface; if it works, we're on DX5 at least */ hr = IDirectDrawSurface_QueryInterface(ddraw_surf, &IID_IDirectDrawSurface3, &temp); if (FAILED(hr)) goto End; ddraw_surf3 = temp; /* QI for IDirectDrawSurface3 succeeded; we must be at least DX5 */ dx_version = 0x500; #if DIRECTX_SDK_VERSION >= 0x600 /* try for the IDirectDrawSurface4 interface; if it works, we're on DX6 at least */ hr = IDirectDrawSurface_QueryInterface(ddraw_surf, &IID_IDirectDrawSurface4, (LPVOID *) &ddraw_surf4); if (FAILED(hr)) goto End; /* QI for IDirectDrawSurface4 succeeded; we must be at least DX6 */ dx_version = 0x600; #if DIRECTX_SDK_VERSION >= 0x700 /* try for the IDirectDrawSurface7 interface; if it works, we're on DX7 at least */ hr = IDirectDrawSurface_QueryInterface(ddraw_surf, &IID_IDirectDrawSurface7, (LPVOID *) &ddraw_surf7); if (FAILED(hr)) goto End; /* QI for IDirectDrawSurface7 succeeded; we must be at least DX7 */ dx_version = 0x700; #endif #endif End: if (directdraw) IDirectDraw_Release(directdraw); if (ddraw_hinst) FreeLibrary(ddraw_hinst); return dx_version; }
int dd_gfx_loadbitmap2D(unsigned short handle, void *buf, int rleflag) { HRESULT ddresult; DDSURFACEDESC ddsd; char *ptr; int pitch, i; grs_bitmap tbmp; Assert(handle != 0); if (!dd_gfx_initialized) return 0; handle--; // Convert to valid handle RedoLock: memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddresult = IDirectDrawSurface_Lock(gfxBitmap[handle].lpdds, NULL, &ddsd, DDLOCK_WAIT, NULL); if (ddresult != DD_OK) { if (ddresult == DDERR_SURFACELOST) { ddresult = IDirectDrawSurface_Restore(gfxBitmap[handle].lpdds); if (ddresult != DD_OK) { if (ddresult != DDERR_WRONGMODE) { logentry("DDGFX::Restore::Surface err: %x\n", ddresult); return 1; } else { LPDIRECTDRAWSURFACE lpdds; DDCOLORKEY ddck; IDirectDrawSurface_Release(lpdds); gfxBitmap[handle].lpdds = NULL; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; ddsd.dwWidth = gfxBitmap[handle].w; ddsd.dwHeight = gfxBitmap[handle].h; ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &lpdds, NULL); if (ddresult != DD_OK) { mprintf((0, "DDGFX: Failed to restore vidmem 2d bitmap.\n")); return 1; } ddck.dwColorSpaceLowValue = TRANSPARENCY_COLOR; ddck.dwColorSpaceHighValue = TRANSPARENCY_COLOR; IDirectDrawSurface_SetColorKey(lpdds, DDCKEY_SRCBLT, &ddck); gfxBitmap[handle].lpdds = lpdds; } } goto RedoLock; } else { mprintf((0, "DDGFX:Unable to lock surface!!\n")); return 1; } } // Locked! ptr = ddsd.lpSurface; pitch = ddsd.lPitch; gr_init_bitmap(&tbmp, BM_LINEAR, 0,0,gfxBitmap[handle].w, gfxBitmap[handle].h, gfxBitmap[handle].w, buf); if (rleflag) tbmp.bm_flags = BM_FLAG_RLE; for(i = 0; i < gfxBitmap[handle].h; i++) { extern ubyte scale_rle_data[]; if (rleflag) { decode_row(&tbmp,i); memcpy(ptr+(i*pitch), scale_rle_data, gfxBitmap[handle].w); } else memcpy(ptr+(i*pitch), (ubyte*)(buf)+(i*gfxBitmap[handle].w), gfxBitmap[handle].w); } IDirectDrawSurface_Unlock(gfxBitmap[handle].lpdds, ptr); // Unlocked... return 0; }
static int DxCreateOverlay(void) { int i; DDSURFACEDESC2 ddsdOverlay; if (!g_lpdd || !g_lpddsPrimary) { return FALSE; } if (g_lpddsOverlay) { IDirectDrawSurface_Release(g_lpddsOverlay); g_lpddsOverlay = NULL; } if (g_lpddsBack) { IDirectDrawSurface_Release(g_lpddsBack); g_lpddsBack = NULL; } /* create double buffer overlay */ ZeroMemory(&ddsdOverlay, sizeof(ddsdOverlay)); ddsdOverlay.dwSize = sizeof(ddsdOverlay); ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_FLIP | DDSCAPS_COMPLEX | DDSCAPS_VIDEOMEMORY; ddsdOverlay.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_BACKBUFFERCOUNT | DDSD_PIXELFORMAT; ddsdOverlay.dwWidth = g_image_width; ddsdOverlay.dwHeight = g_image_height; ddsdOverlay.dwBackBufferCount = 1; /* try every pixfmt */ for (i = 0; i < NUM_FORMATS; i++) { ddsdOverlay.ddpfPixelFormat = g_ddpf[i].g_ddpfOverlay; if (IDirectDraw_CreateSurface(g_lpdd, &ddsdOverlay, &g_lpddsOverlay, NULL) == DD_OK) { g_image_format = g_ddpf[i].img_format; av_log(NULL, AV_LOG_INFO, "vo_dx: overlay with format %s created\n", g_ddpf[i].img_format_name); /* get the surface directly attached to the primary (the back buffer) */ ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; if (IDirectDrawSurface_GetAttachedSurface(g_lpddsOverlay, &ddsdOverlay.ddsCaps, &g_lpddsBack) != DD_OK) { av_log(NULL, AV_LOG_ERROR, "vo_dx: can't get back surface from overlay\n"); return FALSE; } return TRUE; } } g_doublebuffer = 0; /* create single buffer overlay */ av_log(NULL, AV_LOG_INFO, "vo_dx: try single buffer overlay now\n"); ddsdOverlay.dwBackBufferCount = 0; ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY; ddsdOverlay.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT; /* try every pixfmt */ for (i = 0; i < NUM_FORMATS; i++) { ddsdOverlay.ddpfPixelFormat = g_ddpf[i].g_ddpfOverlay; if (DD_OK == g_lpdd->lpVtbl->CreateSurface(g_lpdd, &ddsdOverlay, &g_lpddsOverlay, NULL)) { g_image_format = g_ddpf[i].img_format; av_log(NULL, AV_LOG_INFO, "vo_dx: overlay with format %s created\n", g_ddpf[i].img_format_name); break; } } if (i >= NUM_FORMATS) { return FALSE; } g_lpddsBack = g_lpddsOverlay; return TRUE; }
static void test_ddraw_objects(void) { HRESULT hr; unsigned long ref; IDirectDraw7 *DDraw7; IDirectDraw4 *DDraw4; IDirectDraw2 *DDraw2; IDirectDraw *DDraw1; IDirectDrawPalette *palette; IDirectDrawSurface7 *surface; IDirectDrawSurface *surface1; IDirectDrawSurface4 *surface4; PALETTEENTRY Table[256]; DDSURFACEDESC2 ddsd; hr = pDirectDrawCreateEx(NULL, (void **) &DDraw7, &IID_IDirectDraw7, NULL); ok(hr == DD_OK || hr==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreateEx returned: %x\n", hr); if(!DDraw7) { trace("Couldn't create DDraw interface, skipping tests\n"); return; } hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirectDraw4, (void **) &DDraw4); ok(hr == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", hr); hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirectDraw2, (void **) &DDraw2); ok(hr == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", hr); hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirectDraw, (void **) &DDraw1); ok(hr == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", hr); ref = getRefcount( (IUnknown *) DDraw7); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); /* Fails without a cooplevel */ hr = IDirectDraw7_CreatePalette(DDraw7, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DDERR_NOCOOPERATIVELEVELSET, "CreatePalette returned %08x\n", hr); /* This check is before the cooplevel check */ hr = IDirectDraw7_CreatePalette(DDraw7, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, (void *) 0xdeadbeef); ok(hr == CLASS_E_NOAGGREGATION, "CreatePalette returned %08x\n", hr); hr = IDirectDraw7_SetCooperativeLevel(DDraw7, 0, DDSCL_NORMAL); ok(hr == DD_OK, "SetCooperativeLevel failed with %08x\n", hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.dwWidth = 64; ddsd.dwHeight = 64; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat); U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB; U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 8; hr = IDirectDraw7_CreateSurface(DDraw7, &ddsd, &surface, NULL); ok(hr == DD_OK, "CreateSurface failed with %08x\n", hr); /* DDraw refcount increased by 1 */ ref = getRefcount( (IUnknown *) DDraw7); ok(ref == 2, "Got refcount %ld, expected 2\n", ref); /* Surface refcount starts with 1 */ ref = getRefcount( (IUnknown *) surface); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); hr = IDirectDraw7_CreatePalette(DDraw7, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DD_OK, "CreatePalette returned %08x\n", hr); /* DDraw refcount increased by 1 */ ref = getRefcount( (IUnknown *) DDraw7); ok(ref == 3, "Got refcount %ld, expected 3\n", ref); /* Palette starts with 1 */ ref = getRefcount( (IUnknown *) palette); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); /* Test attaching a palette to a surface */ hr = IDirectDrawSurface7_SetPalette(surface, palette); ok(hr == DD_OK, "IDirectDrawSurface_SetPalette failed with %08x\n", hr); /* Palette refcount increased, surface stays the same */ ref = getRefcount( (IUnknown *) palette); ok(ref == 2, "Got refcount %ld, expected 2\n", ref); ref = getRefcount( (IUnknown *) surface); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); IDirectDrawSurface7_Release(surface); /* Increased before - decrease now */ ref = getRefcount( (IUnknown *) DDraw7); ok(ref == 2, "Got refcount %ld, expected 2\n", ref); /* Releasing the surface detaches the palette */ ref = getRefcount( (IUnknown *) palette); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); IDirectDrawPalette_Release(palette); /* Increased before - decrease now */ ref = getRefcount( (IUnknown *) DDraw7); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); /* Not all interfaces are AddRefed when a palette is created */ hr = IDirectDraw4_CreatePalette(DDraw4, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DD_OK, "CreatePalette returned %08x\n", hr); ref = getRefcount( (IUnknown *) DDraw4); ok(ref == 2, "Got refcount %ld, expected 2\n", ref); IDirectDrawPalette_Release(palette); /* No addref here */ hr = IDirectDraw2_CreatePalette(DDraw2, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DD_OK, "CreatePalette returned %08x\n", hr); ref = getRefcount( (IUnknown *) DDraw2); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); IDirectDrawPalette_Release(palette); /* No addref here */ hr = IDirectDraw_CreatePalette(DDraw1, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, Table, &palette, NULL); ok(hr == DD_OK, "CreatePalette returned %08x\n", hr); ref = getRefcount( (IUnknown *) DDraw1); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); IDirectDrawPalette_Release(palette); /* Similar for surfaces */ hr = IDirectDraw4_CreateSurface(DDraw4, &ddsd, &surface4, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); ref = getRefcount( (IUnknown *) DDraw4); ok(ref == 2, "Got refcount %ld, expected 2\n", ref); IDirectDrawSurface4_Release(surface4); ddsd.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDraw2_CreateSurface(DDraw2, (DDSURFACEDESC *) &ddsd, &surface1, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); ref = getRefcount( (IUnknown *) DDraw2); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); IDirectDrawSurface_Release(surface1); hr = IDirectDraw_CreateSurface(DDraw1, (DDSURFACEDESC *) &ddsd, &surface1, NULL); ok(hr == DD_OK, "CreateSurface returned %08x\n", hr); ref = getRefcount( (IUnknown *) DDraw1); ok(ref == 1, "Got refcount %ld, expected 1\n", ref); IDirectDrawSurface_Release(surface1); IDirectDraw7_Release(DDraw7); IDirectDraw4_Release(DDraw4); IDirectDraw2_Release(DDraw2); IDirectDraw_Release(DDraw1); }
static boolean CreateSecondary( win32_driver_t * win32_driver, int width, int height, int format ) { DDSURFACEDESC ddsd; HRESULT result; if( format == XINE_IMGFMT_YV12 ) xprintf(win32_driver->xine, XINE_VERBOSITY_DEBUG, "vo_out_directx : switching to YV12 overlay type\n" ); if( format == XINE_IMGFMT_YUY2 ) xprintf(win32_driver->xine, XINE_VERBOSITY_DEBUG, "vo_out_directx : switching to YUY2 overlay type\n" ); #if RGB_SUPPORT if( format == IMGFMT_RGB ) xprintf(win32_driver->xine, XINE_VERBOSITY_DEBUG, "vo_out_directx : switching to RGB overlay type\n" ); #endif if( !win32_driver->ddobj ) return FALSE; /* store our reqested format, * width and height */ win32_driver->req_format = format; win32_driver->width = width; win32_driver->height = height; /* if we already have a secondary * surface then release it */ if( win32_driver->secondary ) IDirectDrawSurface_Release( win32_driver->secondary ); memset( &ddsd, 0, sizeof( ddsd ) ); ddsd.dwSize = sizeof( ddsd ); ddsd.dwWidth = width; ddsd.dwHeight = height; if (win32_driver->hwaccel <= VO_DIRECTX_HWACCEL_FULL) { if( format == XINE_IMGFMT_YV12 ) { /* the requested format is XINE_IMGFMT_YV12 */ ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_OVERLAY; ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC; ddsd.ddpfPixelFormat.dwYUVBitCount = 16; ddsd.ddpfPixelFormat.dwFourCC = mmioFOURCC( 'Y', 'V', '1', '2' ); lprintf("CreateSecondary() - act_format = (YV12) %d\n", XINE_IMGFMT_YV12); win32_driver->act_format = XINE_IMGFMT_YV12; } if( format == XINE_IMGFMT_YUY2 ) { /* the requested format is XINE_IMGFMT_YUY2 */ ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_OVERLAY; ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC; ddsd.ddpfPixelFormat.dwYUVBitCount = 16; ddsd.ddpfPixelFormat.dwFourCC = mmioFOURCC( 'Y', 'U', 'Y', '2' ); lprintf("CreateSecondary() - act_format = (YUY2) %d\n", XINE_IMGFMT_YUY2); win32_driver->act_format = XINE_IMGFMT_YUY2; } #if RGB_SUPPORT if( format == IMGFMT_RGB ) { /* the requested format is IMGFMT_RGB */ ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_OVERLAY; ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; ddsd.ddpfPixelFormat.dwYUVBitCount = 24; ddsd.ddpfPixelFormat.dwRBitMask = 0xff0000; ddsd.ddpfPixelFormat.dwGBitMask = 0x00ff00; ddsd.ddpfPixelFormat.dwBBitMask = 0x0000ff; lprintf("CreateSecondary() - act_format = (RGB) %d\n", IMGFMT_RGB); win32_driver->act_format = IMGFMT_RGB; } #endif /* RGB_SUPPORT */ lprintf("CreateSecondary() - IDirectDraw_CreateSurface()\n"); if( IDirectDraw_CreateSurface( win32_driver->ddobj, &ddsd, &win32_driver->secondary, 0 ) == DD_OK ) return TRUE; } if (win32_driver->hwaccel <= VO_DIRECTX_HWACCEL_SCALE) { /* Our fallback method is to create a back buffer * with the same image format as the primary surface */ lprintf("CreateSecondary() - Falling back to back buffer same as primary\n"); lprintf("CreateSecondary() - act_format = (NATIVE) %d\n", IMGFMT_NATIVE); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; ddsd.ddpfPixelFormat = win32_driver->primary_pixel_format; win32_driver->act_format = IMGFMT_NATIVE; if( IDirectDraw_CreateSurface( win32_driver->ddobj, &ddsd, &win32_driver->secondary, 0 ) == DD_OK ) return TRUE; } /* Our second fallback - all w/o HW acceleration */ lprintf("CreateSecondary() - Falling back, disabling HW acceleration \n"); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; win32_driver->act_format = IMGFMT_NATIVE; if( (result = IDirectDraw_CreateSurface( win32_driver->ddobj, &ddsd, &win32_driver->secondary, 0 )) == DD_OK ) return TRUE; /* This is bad. We cant even create a surface with * the same format as the primary surface. */ Error( 0, "CreateSurface ( Secondary ) : unable to create a suitable rendering surface: 0x%08lX", result ); return FALSE; }
static boolean CreatePrimary( win32_driver_t * win32_driver ) { LPDIRECTDRAW ddobj; DDSURFACEDESC ddsd; HRESULT result; /* create direct draw object */ result = DirectDrawCreate( 0, &ddobj, 0 ); if( result != DD_OK ) { Error( 0, "DirectDrawCreate : error %ld", result ); xprintf(win32_driver->xine, XINE_VERBOSITY_DEBUG, "vo_out_directx : DirectDrawCreate : error %ld\n", result ); return 0; } /* set cooperative level */ result = IDirectDraw_SetCooperativeLevel( ddobj, win32_driver->win32_visual->WndHnd, DDSCL_NORMAL ); if( result != DD_OK ) { Error( 0, "SetCooperativeLevel : error 0x%lx", result ); return 0; } /* try to get new interface */ result = IDirectDraw_QueryInterface( ddobj, &IID_IDirectDraw, (LPVOID *) &win32_driver->ddobj ); if( result != DD_OK ) { Error( 0, "ddobj->QueryInterface : DirectX required" ); return 0; } /* release our old interface */ IDirectDraw_Release( ddobj ); /* create primary_surface */ memset( &ddsd, 0, sizeof( ddsd ) ); ddsd.dwSize = sizeof( ddsd ); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; result = IDirectDraw_CreateSurface( win32_driver->ddobj, &ddsd, &win32_driver->primary, 0 ); if( result != DD_OK ) { Error( 0, "CreateSurface ( primary ) : error 0x%lx", result ); return 0; } /* create our clipper object */ result = IDirectDraw_CreateClipper( win32_driver->ddobj, 0, &win32_driver->ddclipper, 0 ); if( result != DD_OK ) { Error( 0, "CreateClipper : error 0x%lx", result ); return 0; } /* associate our clipper with our window */ result = IDirectDrawClipper_SetHWnd( win32_driver->ddclipper, 0, win32_driver->win32_visual->WndHnd ); if( result != DD_OK ) { Error( 0, "ddclipper->SetHWnd : error 0x%lx", result ); return 0; } /* associate our primary surface with our clipper */ result = IDirectDrawSurface_SetClipper( win32_driver->primary, win32_driver->ddclipper ); if( result != DD_OK ) { Error( 0, "ddclipper->SetHWnd : error 0x%lx", result ); return 0; } /* store our objects in our visual struct */ UpdateRect( win32_driver->win32_visual ); return 1; }
static void GetDCTest_main(DDSURFACEDESC *ddsd, DDSURFACEDESC2 *ddsd2, void (*testfunc)(IDirectDrawSurface *surf, int ddsdver)) { IDirectDrawSurface *surf; IDirectDrawSurface2 *surf2; IDirectDrawSurface2 *surf3; IDirectDrawSurface4 *surf4; HRESULT hr; IDirectDraw *dd1 = createDD(); IDirectDraw2 *dd2; IDirectDraw3 *dd3; IDirectDraw4 *dd4; hr = IDirectDraw_CreateSurface(dd1, ddsd, &surf, NULL); if (hr == DDERR_UNSUPPORTEDMODE) { win_skip("Unsupported mode\n"); return; } ok(hr == DD_OK, "IDirectDraw_CreateSurface failed: 0x%08x\n", hr); testfunc(surf, 1); IDirectDrawSurface_Release(surf); hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw2, (void **) &dd2); ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw2_CreateSurface(dd2, ddsd, &surf, NULL); ok(hr == DD_OK, "IDirectDraw2_CreateSurface failed: 0x%08x\n", hr); testfunc(surf, 1); hr = IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface2, (void **) &surf2); ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed: 0x%08x\n", hr); testfunc((IDirectDrawSurface *) surf2, 1); IDirectDrawSurface2_Release(surf2); IDirectDrawSurface_Release(surf); IDirectDraw2_Release(dd2); hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw3, (void **) &dd3); ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); hr = IDirectDraw3_CreateSurface(dd3, ddsd, &surf, NULL); ok(hr == DD_OK, "IDirectDraw3_CreateSurface failed: 0x%08x\n", hr); testfunc(surf, 1); hr = IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface3, (void **) &surf3); ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed: 0x%08x\n", hr); testfunc((IDirectDrawSurface *) surf3, 1); IDirectDrawSurface3_Release(surf3); IDirectDrawSurface_Release(surf); IDirectDraw3_Release(dd3); hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw4, (void **) &dd4); ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr); surf = NULL; hr = IDirectDraw4_CreateSurface(dd4, ddsd2, &surf4, NULL); ok(hr == DD_OK, "IDirectDraw4_CreateSurface failed: 0x%08x\n", hr); testfunc((IDirectDrawSurface *) surf4, 2); IDirectDrawSurface4_Release(surf4); IDirectDraw4_Release(dd4); IDirectDraw_Release(dd1); }
static void testcooperativelevels_normal(void) { HRESULT rc; DDSURFACEDESC surfacedesc; IDirectDrawSurface *surface = (IDirectDrawSurface *) 0xdeadbeef; memset(&surfacedesc, 0, sizeof(surfacedesc)); surfacedesc.dwSize = sizeof(surfacedesc); surfacedesc.ddpfPixelFormat.dwSize = sizeof(surfacedesc.ddpfPixelFormat); surfacedesc.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; surfacedesc.dwBackBufferCount = 1; surfacedesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP; /* Do some tests with DDSCL_NORMAL mode */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NORMAL); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_NORMAL) returned: %x\n",rc); /* Try creating a double buffered primary in normal mode */ rc = IDirectDraw_CreateSurface(lpDD, &surfacedesc, &surface, NULL); ok(rc == DDERR_NOEXCLUSIVEMODE, "IDirectDraw_CreateSurface returned %08x\n", rc); ok(surface == NULL, "Returned surface pointer is %p\n", surface); if(surface && surface != (IDirectDrawSurface *)0xdeadbeef) IDirectDrawSurface_Release(surface); /* Set the focus window */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_SETFOCUSWINDOW); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); /* Set the focus window a second time*/ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_SETFOCUSWINDOW); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_SETFOCUSWINDOW) the second time returned: %x\n",rc); /* Test DDSCL_SETFOCUSWINDOW with the other flags. They should all fail, except of DDSCL_NOWINDOWCHANGES */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NORMAL | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_NORMAL | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); /* This one succeeds */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NOWINDOWCHANGES | DDSCL_SETFOCUSWINDOW); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_NOWINDOWCHANGES | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_MULTITHREADED | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_MULTITHREADED | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_FPUSETUP | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_FPUSETUP | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_FPUPRESERVE | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_FPUPRESERVE | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_ALLOWREBOOT | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_ALLOWREBOOT | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_ALLOWMODEX | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_ALLOWMODEX | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); /* Set the device window without any other flags. Should give an error */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_SETDEVICEWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_SETDEVICEWINDOW) returned: %x\n",rc); /* Set device window with DDSCL_NORMAL */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NORMAL | DDSCL_SETDEVICEWINDOW); ok(rc==DD_OK,"SetCooperativeLevel(DDSCL_NORMAL | DDSCL_SETDEVICEWINDOW) returned: %x\n",rc); /* Also set the focus window. Should give an error */ rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_ALLOWMODEX | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_SETDEVICEWINDOW | DDSCL_SETFOCUSWINDOW); ok(rc==DDERR_INVALIDPARAMS,"SetCooperativeLevel(DDSCL_NORMAL | DDSCL_SETDEVICEWINDOW | DDSCL_SETFOCUSWINDOW) returned: %x\n",rc); /* All done */ }
EXPORT int CALL angrylionRomOpen (void) { #ifndef HAVE_DIRECTDRAW screen_width = SCREEN_WIDTH; screen_height = SCREEN_HEIGHT; blitter_buf = (uint32_t*)calloc(screen_width * screen_height, sizeof(uint32_t)); pitchindwords = screen_width * 4; screen_pitch = PRESCALE_WIDTH << 2; #else DDPIXELFORMAT ftpixel; LPDIRECTDRAWCLIPPER lpddcl; RECT bigrect, smallrect, statusrect; POINT p; int rightdiff; int bottomdiff; GetWindowRect(gfx.hWnd,&bigrect); GetClientRect(gfx.hWnd,&smallrect); rightdiff = screen_width - smallrect.right; bottomdiff = screen_height - smallrect.bottom; if (gfx.hStatusBar) { GetClientRect(gfx.hStatusBar, &statusrect); bottomdiff += statusrect.bottom; } MoveWindow(gfx.hWnd, bigrect.left, bigrect.top, bigrect.right - bigrect.left + rightdiff, bigrect.bottom - bigrect.top + bottomdiff, true); res = DirectDrawCreateEx(0, (LPVOID*)&lpdd, &IID_IDirectDraw7, 0); if (res != DD_OK) { DisplayError("Couldn't create a DirectDraw object."); return; /* to-do: move to InitiateGFX? */ } res = IDirectDraw_SetCooperativeLevel(lpdd, gfx.hWnd, DDSCL_NORMAL); if (res != DD_OK) { DisplayError("Couldn't set a cooperative level."); return; /* to-do: move to InitiateGFX? */ } zerobuf(&ddsd, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; res = IDirectDraw_CreateSurface(lpdd, &ddsd, &lpddsprimary, 0); if (res != DD_OK) { DisplayError("CreateSurface for a primary surface failed."); return; /* to-do: move to InitiateGFX? */ } ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = PRESCALE_WIDTH; ddsd.dwHeight = PRESCALE_HEIGHT; zerobuf(&ftpixel, sizeof(ftpixel)); ftpixel.dwSize = sizeof(ftpixel); ftpixel.dwFlags = DDPF_RGB; ftpixel.dwRGBBitCount = 32; ftpixel.dwRBitMask = 0xff0000; ftpixel.dwGBitMask = 0xff00; ftpixel.dwBBitMask = 0xff; ddsd.ddpfPixelFormat = ftpixel; res = IDirectDraw_CreateSurface(lpdd, &ddsd, &lpddsback, 0); if (res == DDERR_INVALIDPIXELFORMAT) { DisplayError( "ARGB8888 is not supported. You can try changing desktop color "\ "depth to 32-bit, but most likely that won't help."); return; /* InitiateGFX fails. */ } else if (res != DD_OK) { DisplayError("CreateSurface for a secondary surface failed."); return; /* InitiateGFX should fail. */ } res = IDirectDrawSurface_GetSurfaceDesc(lpddsback, &ddsd); if (res != DD_OK) { DisplayError("GetSurfaceDesc failed."); return; /* InitiateGFX should fail. */ } if ((ddsd.lPitch & 3) || ddsd.lPitch < (PRESCALE_WIDTH << 2)) { DisplayError( "Pitch of a secondary surface is either not 32 bit aligned or "\ "too small."); return; /* InitiateGFX should fail. */ } pitchindwords = ddsd.lPitch >> 2; res = IDirectDraw_CreateClipper(lpdd, 0, &lpddcl, 0); if (res != DD_OK) { DisplayError("Couldn't create a clipper."); return; /* InitiateGFX should fail. */ } res = IDirectDrawClipper_SetHWnd(lpddcl, 0, gfx.hWnd); if (res != DD_OK) { DisplayError("Couldn't register a windows handle as a clipper."); return; /* InitiateGFX should fail. */ } res = IDirectDrawSurface_SetClipper(lpddsprimary, lpddcl); if (res != DD_OK) { DisplayError("Couldn't attach a clipper to a surface."); return; /* InitiateGFX should fail. */ } src.top = src.left = 0; src.bottom = 0; #if SCREEN_WIDTH < PRESCALE_WIDTH src.right = PRESCALE_WIDTH - 1; /* fix for undefined video card behavior */ #else src.right = PRESCALE_WIDTH; #endif p.x = p.y = 0; GetClientRect(gfx.hWnd, &dst); ClientToScreen(gfx.hWnd, &p); OffsetRect(&dst, p.x, p.y); GetClientRect(gfx.hStatusBar, &statusrect); dst.bottom -= statusrect.bottom; #endif rdp_init(); overlay = 0; return 1; }
EXPORT void CALL RomOpen (void) { RECT bigrect, smallrect, statusrect; GetWindowRect(gfx.hWnd,&bigrect); GetClientRect(gfx.hWnd,&smallrect); int rightdiff = screen_width - smallrect.right; int bottomdiff = screen_height - smallrect.bottom; if (gfx.hStatusBar) { GetClientRect(gfx.hStatusBar, &statusrect); bottomdiff += statusrect.bottom; } MoveWindow(gfx.hWnd, bigrect.left, bigrect.top, bigrect.right - bigrect.left + rightdiff, bigrect.bottom - bigrect.top + bottomdiff, TRUE); DDPIXELFORMAT ftpixel; LPDIRECTDRAWCLIPPER lpddcl; res = DirectDrawCreateEx(0, (LPVOID*)&lpdd, IID_IDirectDraw7, 0); if(res != DD_OK) fatalerror("Couldn't create a DirectDraw object"); res = IDirectDraw_SetCooperativeLevel(lpdd, gfx.hWnd, DDSCL_NORMAL); if(res != DD_OK) fatalerror("Couldn't set a cooperative level. Error code %x", res); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; res = IDirectDraw_CreateSurface(lpdd, &ddsd, &lpddsprimary, 0); if(res != DD_OK) fatalerror("CreateSurface for a primary surface failed. Error code %x", res); ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; ddsd.dwWidth = PRESCALE_WIDTH; ddsd.dwHeight = PRESCALE_HEIGHT; memset(&ftpixel, 0, sizeof(ftpixel)); ftpixel.dwSize = sizeof(ftpixel); ftpixel.dwFlags = DDPF_RGB; ftpixel.dwRGBBitCount = 32; ftpixel.dwRBitMask = 0xff0000; ftpixel.dwGBitMask = 0xff00; ftpixel.dwBBitMask = 0xff; ddsd.ddpfPixelFormat = ftpixel; res = IDirectDraw_CreateSurface(lpdd, &ddsd, &lpddsback, 0); if (res == DDERR_INVALIDPIXELFORMAT) fatalerror("ARGB8888 is not supported. You can try changing desktop color depth to 32-bit, but most likely that won't help."); else if(res != DD_OK) fatalerror("CreateSurface for a secondary surface failed. Error code %x", res); res = IDirectDrawSurface_GetSurfaceDesc(lpddsback, &ddsd); if (res != DD_OK) fatalerror("GetSurfaceDesc failed."); if ((ddsd.lPitch & 3) || ddsd.lPitch < (PRESCALE_WIDTH << 2)) fatalerror("Pitch of a secondary surface is either not 32 bit aligned or two small."); pitchindwords = ddsd.lPitch >> 2; res = IDirectDraw_CreateClipper(lpdd, 0, &lpddcl, 0); if (res != DD_OK) fatalerror("Couldn't create a clipper."); res = IDirectDrawClipper_SetHWnd(lpddcl, 0, gfx.hWnd); if (res != DD_OK) fatalerror("Couldn't register a windows handle as a clipper."); res = IDirectDrawSurface_SetClipper(lpddsprimary, lpddcl); if (res != DD_OK) fatalerror("Couldn't attach a clipper to a surface."); src.top = src.left = 0; src.bottom = 0; src.right = PRESCALE_WIDTH; POINT p; p.x = p.y = 0; GetClientRect(gfx.hWnd, &dst); ClientToScreen(gfx.hWnd, &p); OffsetRect(&dst, p.x, p.y); GetClientRect(gfx.hStatusBar, &statusrect); dst.bottom -= statusrect.bottom; rdp_init(); }
static int ResizeDD(int fullscreen) { HRESULT ddrval; DDSURFACEDESC ddsd; /*DDCAPS2 ddscaps; */ LPDIRECTDRAWCLIPPER pClipper; int dxwidth; int dxheight; int dxbpp; // free DirectX objects if (lpSurfaces[0]) IDirectDrawSurface_Release(lpSurfaces[0]); lpSurfaces[0] = NULL; if (dxPalette) IDirectDrawPalette_Release(dxPalette); dxPalette = NULL; /* Set cooperative level */ ddrval = IDirectDraw2_SetCooperativeLevel(lpDD2, hWnd, fullscreen ? (DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT) : DDSCL_NORMAL); if (ddrval != DD_OK) { DeInitDD(); x_error("Failed to set cooperative level"); return 0; } if (fullscreen) { if (sscanf(dxsize, "%ix%ix%i", &dxwidth, &dxheight, &dxbpp) != 3) { dxwidth = DXWIDTH; dxheight = DXHEIGHT; dxbpp = DXBPP; } displayX = dxwidth; displayY = dxheight; bitDepth = dxbpp; if (bitDepth < 10) bitDepth = 8; if (bitDepth >= 10 && bitDepth < 20) bitDepth = 16; if (bitDepth >= 20 && bitDepth < 28) bitDepth = 24; if (bitDepth >= 32 && bitDepth < 32) bitDepth = 32; /* set resolution and bit depth */ ddrval = IDirectDraw2_SetDisplayMode(lpDD2, displayX, displayY, bitDepth, 0, 0); if (ddrval != DD_OK) { /* The display mode cannot be changed. The mode is either not supported or another application has exclusive mode. Try 320x200x256 and 640x480x256 modes before giving up */ displayX = 320; displayY = 200; bitDepth = 8; ddrval = IDirectDraw2_SetDisplayMode(lpDD2, displayX, displayY, bitDepth, 0, 0); if (ddrval != DD_OK) { displayY = 240; if (ddrval != DD_OK) { displayX = 640; displayY = 480; ddrval = IDirectDraw2_SetDisplayMode(lpDD2, displayX, displayY, bitDepth, 0, 0); if (ddrval != DD_OK) { /* Bad luck... give up. */ DeInitDD(); return 0; } } } } SetRect(&rcViewport, 0, 0, displayX, displayY); rcScreen = rcViewport; } else { /* Get the dimensions of the viewport and screen bounds */ GetClientRect(hWnd, &rcViewport); GetClientRect(hWnd, &rcScreen); ClientToScreen(hWnd, (POINT *) & rcScreen.left); ClientToScreen(hWnd, (POINT *) & rcScreen.right); /*bitDepth = GetDeviceCaps (hDC, BITSPIXEL); */ /* Create clipper object for window */ ddrval = IDirectDraw_CreateClipper(lpDD, 0, &pClipper, NULL); if (ddrval != DD_OK) { DeInitDD(); x_error("Failed to create clipper object"); return 0; } /* Asociate it */ IDirectDrawClipper_SetHWnd(pClipper, 0, hWnd); } /* Create the primary surface with one back buffer */ CalculateBITMAPINFO(); // calculate BITMAPINFO structure memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; ddrval = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSurfaces[0], NULL); if (ddrval != DD_OK) { DeInitDD(); x_error("Failed to create flipping surface"); return 0; } if (!fullscreen) { IDirectDrawSurface_SetClipper(lpSurfaces[0], pClipper); IDirectDrawClipper_Release(pClipper); if (IDirectDrawSurface_GetSurfaceDesc(lpSurfaces[0], &ddsd) != DD_OK) { DeInitDD(); x_error("Failed to get pixel format"); return 0; } bitDepth = ddsd.ddpfPixelFormat.u1.dwRGBBitCount; } if (bitDepth == 8) { /* create palette */ ddrval = IDirectDraw_CreatePalette(lpDD, DDPCAPS_8BIT, (LPPALETTEENTRY) bmp->bmiColors, &dxPalette, NULL); if (ddrval != DD_OK) { DeInitDD(); x_error("Failed to create palette"); return 0; } /* set palette */ IDirectDrawSurface_SetPalette(lpSurfaces[0], dxPalette); } if (fullscreen) SetCursor(NULL); needredraw = 1; return 1; }