static HRESULT d3drm_device_set_ddraw_device_d3d(struct d3drm_device *device, IDirect3D *d3d, IDirect3DDevice *d3d_device) { IDirectDraw *ddraw; IDirectDrawSurface *surface; IDirect3DDevice2 *d3d_device2 = NULL; DDSURFACEDESC desc; HRESULT hr; /* AddRef these interfaces beforehand for the intentional leak on reinitialization. */ if (FAILED(hr = IDirect3D_QueryInterface(d3d, &IID_IDirectDraw, (void **)&ddraw))) return hr; IDirect3DRM_AddRef(device->d3drm); IDirect3DDevice_AddRef(d3d_device); /* Fetch render target and get width/height from there */ if (FAILED(hr = IDirect3DDevice_QueryInterface(d3d_device, &IID_IDirectDrawSurface, (void **)&surface))) { if (FAILED(hr = IDirect3DDevice_QueryInterface(d3d_device, &IID_IDirect3DDevice2, (void **)&d3d_device2))) return hr; hr = IDirect3DDevice2_GetRenderTarget(d3d_device2, &surface); IDirect3DDevice2_Release(d3d_device2); if (FAILED(hr)) return hr; } if (device->ddraw) { if (d3d_device2) IDirectDrawSurface_Release(surface); return D3DRMERR_BADOBJECT; } desc.dwSize = sizeof(desc); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &desc); if (FAILED(hr)) { IDirectDrawSurface_Release(surface); return hr; } device->ddraw = ddraw; device->width = desc.dwWidth; device->height = desc.dwHeight; device->device = d3d_device; device->render_target = surface; return hr; }
static int dx_imgparams(void) { DDSURFACEDESC s; memset(&s, 0, sizeof(s)); s.dwSize = sizeof(s); if (IDirectDrawSurface_GetSurfaceDesc(lpSurfaces[0], &s) != DD_OK) { DeInitDD(); x_error("Failed to get pixel format"); return 0; } switch (s.ddpfPixelFormat.u1.dwRGBBitCount) { case 8: dxw_driver.imagetype = UI_C256; dxf_driver.imagetype = UI_C256; break; case 16: case 15: dxw_driver.imagetype = UI_TRUECOLOR16; dxf_driver.imagetype = UI_TRUECOLOR16; break; case 24: dxw_driver.imagetype = UI_TRUECOLOR24; dxf_driver.imagetype = UI_TRUECOLOR24; break; case 32: dxw_driver.imagetype = UI_TRUECOLOR; dxf_driver.imagetype = UI_TRUECOLOR; break; default: x_fatalerror ("Unsupported bit depth! Only 8bpp, 16bpp, 24bpp and 32bpp modes supported\n"); return 0; } dxw_driver.rmask = s.ddpfPixelFormat.u2.dwRBitMask; dxw_driver.gmask = s.ddpfPixelFormat.u3.dwGBitMask; dxw_driver.bmask = s.ddpfPixelFormat.u4.dwBBitMask; dxf_driver.rmask = s.ddpfPixelFormat.u2.dwRBitMask; dxf_driver.gmask = s.ddpfPixelFormat.u3.dwGBitMask; dxf_driver.bmask = s.ddpfPixelFormat.u4.dwBBitMask; dxf_driver.textwidth = fontWidth; dxf_driver.textheight = fontHeight; dxw_driver.textwidth = fontWidth; dxw_driver.textheight = fontHeight; return 1; }
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; }
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 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; }
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; }
static void test_IDirectDrawStreamSample(void) { DDSURFACEDESC desc = { sizeof(desc) }; IAMMultiMediaStream *pams; HRESULT hr; IMediaStream *pvidstream = NULL; IDirectDrawMediaStream *pddstream = NULL; IDirectDrawStreamSample *pddsample = NULL; IDirectDrawSurface7 *surface7; IDirectDrawSurface *surface, *surface2; IDirectDraw *ddraw, *ddraw2; IDirectDraw7 *ddraw7; RECT rect; if (!(pams = create_ammultimediastream())) return; if (!create_directdraw()) { IAMMultiMediaStream_Release(pams); return; } hr = IAMMultiMediaStream_Initialize(pams, STREAMTYPE_READ, 0, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IAMMultiMediaStream_AddMediaStream(pams, (IUnknown*)pdd7, &MSPID_PrimaryVideo, 0, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryVideo, &pvidstream); ok(hr == S_OK, "got 0x%08x\n", hr); if (FAILED(hr)) goto error; hr = IMediaStream_QueryInterface(pvidstream, &IID_IDirectDrawMediaStream, (LPVOID*)&pddstream); ok(hr == S_OK, "got 0x%08x\n", hr); if (FAILED(hr)) goto error; hr = IDirectDrawMediaStream_GetDirectDraw(pddstream, &ddraw); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IDirectDrawMediaStream_GetDirectDraw(pddstream, &ddraw2); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ddraw == ddraw2, "got %p, %p\n", ddraw, ddraw2); hr = IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw7, (void**)&ddraw7); ok(hr == S_OK, "got 0x%08x\n", hr); IDirectDraw7_Release(ddraw7); IDirectDraw_Release(ddraw2); IDirectDraw_Release(ddraw); hr = IDirectDrawMediaStream_CreateSample(pddstream, NULL, NULL, 0, &pddsample); ok(hr == S_OK, "got 0x%08x\n", hr); surface = NULL; hr = IDirectDrawStreamSample_GetSurface(pddsample, &surface, &rect); ok(hr == S_OK, "got 0x%08x\n", hr); ok(surface != NULL, "got %p\n", surface); hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface7, (void**)&surface7); ok(hr == S_OK, "got 0x%08x\n", hr); IDirectDrawSurface7_Release(surface7); hr = IDirectDrawSurface_GetSurfaceDesc(surface, &desc); ok(hr == S_OK, "got 0x%08x\n", hr); ok(desc.dwWidth == 100, "width %d\n", desc.dwWidth); ok(desc.dwHeight == 100, "height %d\n", desc.dwHeight); ok(desc.ddpfPixelFormat.dwFlags == DDPF_RGB, "format flags %08x\n", desc.ddpfPixelFormat.dwFlags); ok(desc.ddpfPixelFormat.dwRGBBitCount, "dwRGBBitCount %d\n", desc.ddpfPixelFormat.dwRGBBitCount); IDirectDrawSurface_Release(surface); IDirectDrawStreamSample_Release(pddsample); hr = IDirectDrawSurface7_QueryInterface(pdds7, &IID_IDirectDrawSurface, (void**)&surface); ok(hr == S_OK, "got 0x%08x\n", hr); EXPECT_REF(surface, 1); hr = IDirectDrawMediaStream_CreateSample(pddstream, surface, NULL, 0, &pddsample); ok(hr == S_OK, "got 0x%08x\n", hr); EXPECT_REF(surface, 2); surface2 = NULL; memset(&rect, 0, sizeof(rect)); hr = IDirectDrawStreamSample_GetSurface(pddsample, &surface2, &rect); ok(hr == S_OK, "got 0x%08x\n", hr); ok(surface == surface2, "got %p\n", surface2); ok(rect.right > 0 && rect.bottom > 0, "got %d, %d\n", rect.right, rect.bottom); EXPECT_REF(surface, 3); IDirectDrawSurface_Release(surface2); hr = IDirectDrawStreamSample_GetSurface(pddsample, NULL, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); IDirectDrawStreamSample_Release(pddsample); IDirectDrawSurface_Release(surface); error: if (pddstream) IDirectDrawMediaStream_Release(pddstream); if (pvidstream) IMediaStream_Release(pvidstream); release_directdraw(); IAMMultiMediaStream_Release(pams); }
static int DDCreateSurface(directx_priv *priv, ggi_mode *mode) { HRESULT hr; LPDIRECTDRAWCLIPPER pClipper; DDSURFACEDESC pddsd, bddsd; int i; if (!priv->fullscreen) IDirectDraw2_SetCooperativeLevel(priv->lpddext, priv->hWnd, DDSCL_NORMAL); else { /* Only the thread that has excluse access (Cooperative level) * may restore the surfaces when they are lost. Therefore * let the helper thread get exclusive access so that it can * later do restores. */ directx_fullscreen dxfull; dxfull.priv = priv; dxfull.mode = mode; dxfull.event = CreateEvent(NULL, FALSE, FALSE, NULL); PostThreadMessage(priv->nThreadID, WM_DDFULLSCREEN, 0, (long)&dxfull); WaitForSingleObject(dxfull.event, INFINITE); CloseHandle(dxfull.event); } /* create the primary surface */ memset(&pddsd, 0, sizeof(pddsd)); pddsd.dwSize = sizeof(pddsd); pddsd.dwFlags = DDSD_CAPS; pddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; if (priv->fullscreen) pddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY; hr = IDirectDraw2_CreateSurface(priv->lpddext, &pddsd, &priv->lppdds, NULL); if (hr != 0) { fprintf(stderr, "Init Primary Surface Failed RC = %lx. Exiting\n", hr); exit(-1); } IDirectDraw2_CreateClipper(priv->lpddext, 0, &pClipper, NULL); IDirectDrawClipper_SetHWnd(pClipper, 0, priv->hWnd); IDirectDrawSurface_SetClipper(priv->lppdds, pClipper); IDirectDrawClipper_Release(pClipper); pddsd.dwSize = sizeof(pddsd); IDirectDrawSurface_GetSurfaceDesc(priv->lppdds, &pddsd); DPRINT_MISC("DDraw pixel format:\n"); DPRINT_MISC(" Size %u\n", pddsd.ddpfPixelFormat.dwSize); DPRINT_MISC(" Flags %08x\n", pddsd.ddpfPixelFormat.dwFlags); DPRINT_MISC(" FourCC %08x\n", pddsd.ddpfPixelFormat.dwFourCC); DPRINT_MISC(" Count %u\n", pddsd.ddpfPixelFormat.dwRGBBitCount); DPRINT_MISC(" R-Mask(etc) %08x\n", pddsd.ddpfPixelFormat.dwRBitMask); DPRINT_MISC(" G-Mask(etc) %08x\n", pddsd.ddpfPixelFormat.dwGBitMask); DPRINT_MISC(" B-Mask(etc) %08x\n", pddsd.ddpfPixelFormat.dwBBitMask); DPRINT_MISC(" Z-Mask(etc) %08x\n", pddsd.ddpfPixelFormat.dwRGBZBitMask); /* create the back storages */ for (i = 0; i < mode->frames; ++i) { memset(&bddsd, 0, sizeof(bddsd)); bddsd.dwSize = sizeof(bddsd); bddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT; bddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; bddsd.dwWidth = mode->virt.x; bddsd.dwHeight = mode->virt.y; /* set up the pixel format */ ZeroMemory(&bddsd.ddpfPixelFormat, sizeof(DDPIXELFORMAT)); bddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); bddsd.ddpfPixelFormat.dwFlags = pddsd.ddpfPixelFormat.dwFlags; bddsd.ddpfPixelFormat.dwFourCC = pddsd.ddpfPixelFormat.dwFourCC; bddsd.ddpfPixelFormat.dwRGBBitCount = pddsd.ddpfPixelFormat.dwRGBBitCount; bddsd.ddpfPixelFormat.dwRBitMask = pddsd.ddpfPixelFormat.dwRBitMask; bddsd.ddpfPixelFormat.dwGBitMask = pddsd.ddpfPixelFormat.dwGBitMask; bddsd.ddpfPixelFormat.dwBBitMask = pddsd.ddpfPixelFormat.dwBBitMask; bddsd.ddpfPixelFormat.dwRGBAlphaBitMask = pddsd.ddpfPixelFormat.dwRGBAlphaBitMask; hr = IDirectDraw2_CreateSurface(priv->lpddext, &bddsd, &priv->lpbdds[i], NULL); if (hr) { fprintf(stderr, "Init Backup Failed RC = %lx. Exiting\n", hr); exit(-1); } IDirectDrawSurface2_Lock(priv->lpbdds[i], NULL, &bddsd, DDLOCK_SURFACEMEMORYPTR, NULL); priv->lpSurfaceAdd[i] = (char *) bddsd.lpSurface; IDirectDrawSurface2_Unlock(priv->lpbdds[i], bddsd.lpSurface); } /* set private mode parameters */ priv->maxX = mode->virt.x; priv->maxY = mode->virt.y; priv->ColorDepth = pddsd.ddpfPixelFormat.dwRGBBitCount; priv->pitch = bddsd.lPitch; if (pddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) { static PALETTEENTRY pal[256]; /* todo fill in pal */ hr = IDirectDraw_CreatePalette(priv->lpddext, DDPCAPS_8BIT|DDPCAPS_ALLOW256, pal, &priv->lpddp, NULL); if (hr) { fprintf(stderr, "Init Palette failed RC = %lx. Exiting\n", hr); exit(-1); } hr = IDirectDrawSurface_SetPalette(priv->lppdds, priv->lpddp); if (hr) { fprintf(stderr, "Install Palette failed RC = %lx. Exiting\n", hr); exit(-1); } } return 1; }
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; }
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; }
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; }