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);
}
//
// - returns true if DirectDraw was initialized properly
//
int InitDirectDrawe (HWND appWin, int width, int height, int bpp, int fullScr)
{
DDSURFACEDESC ddsd; // DirectDraw surface description for allocating
DDSCAPS ddscaps;
HRESULT ddrval;
DWORD dwStyle;
RECT rect;
// enumerate directdraw devices
//if (FAILED(DirectDrawEnumerate (myEnumDDDevicesCallback, NULL)))
// I_Error("Error with DirectDrawEnumerate");
if (!DDr2)
CreateDirectDrawInstance();
// remember what screen mode we are in
bAppFullScreen = fullScr;
ScreenHeight = height;
ScreenWidth = width;
if (bAppFullScreen)
{
// Change window attributes
dwStyle = WS_POPUP | WS_VISIBLE;
SetWindowLong (appWin, GWL_STYLE, dwStyle);
SetWindowPos(appWin, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE |
SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
// Get exclusive mode
ddrval = IDirectDraw2_SetCooperativeLevel(DDr2, appWin, DDSCL_EXCLUSIVE |
DDSCL_FULLSCREEN |
DDSCL_ALLOWREBOOT);
if (ddrval != DD_OK)
I_Error("SetCooperativeLevel FAILED: %s\n", DXErrorToString(ddrval));
// Switch from windows desktop to fullscreen
#ifdef NT4COMPAT
ddrval = IDirectDraw2_SetDisplayMode(DDr2, width, height, bpp, 0, 0);
#else
ddrval = IDirectDraw2_SetDisplayMode(DDr2, width, height, bpp, 0, DDSDM_STANDARDVGAMODE);
#endif
if (ddrval != DD_OK)
I_Error("SetDisplayMode FAILED: %s\n", DXErrorToString(ddrval));
// This is not really needed, except in certain cases. One case
// is while using MFC. When the desktop is initally at 16bpp, a mode
// switch to 8bpp somehow causes the MFC window to not fully initialize
// and a CreateSurface will fail with DDERR_NOEXCLUSIVEMODE. This will
// ensure that the window is initialized properly after a mode switch.
ShowWindow(appWin, SW_SHOW);
// Create the primary surface with 1 back buffer. Always zero the
// DDSURFACEDESC structure and set the dwSize member!
ZeroMemory(&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
// for fullscreen we use page flipping, for windowed mode, we blit the hidden surface to
// the visible surface, in both cases we have a visible (or 'real') surface, and a hidden
// (or 'virtual', or 'backbuffer') surface.
ddsd.dwBackBufferCount = 2;
ddrval = IDirectDraw2_CreateSurface(DDr2,&ddsd, &ScreenReal, NULL);
if (ddrval != DD_OK)
I_Error("CreateSurface Primary Screen FAILED");
// Get a pointer to the back buffer
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
ddrval = IDirectDrawSurface_GetAttachedSurface(ScreenReal,&ddscaps, &ScreenVirtual);
if (ddrval != DD_OK)
I_Error("GetAttachedSurface FAILED");
}
else
{
rect.top = 0;
rect.left = 0;
rect.bottom = height;
rect.right = width;
// Change window attributes
dwStyle = GetWindowStyle(appWin);
dwStyle &= ~WS_POPUP;
dwStyle |= WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION;
SetWindowLong(appWin, GWL_STYLE, dwStyle);
// Resize the window so that the client area is the requested width/height
AdjustWindowRectEx(&rect, GetWindowStyle(appWin), GetMenu(appWin) != NULL,
GetWindowExStyle(appWin));
// Just in case the window was moved off the visible area of the
// screen.
SetWindowPos(appWin, NULL, 0, 0, rect.right-rect.left,
rect.bottom-rect.top, SWP_NOMOVE | SWP_NOZORDER |
SWP_NOACTIVATE);
SetWindowPos(appWin, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
// Exclusive mode is normal since it's in windowed mode and needs
// to cooperate with GDI
ddrval = IDirectDraw2_SetCooperativeLevel(DDr2,appWin, DDSCL_NORMAL);
if (ddrval != DD_OK)
I_Error("SetCooperativeLevel FAILED");
// Always zero the DDSURFACEDESC structure and set the dwSize member!
ZeroMemory(&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
// Create the primary surface
ddrval = IDirectDraw2_CreateSurface(DDr2,&ddsd, &ScreenReal, NULL);
if (ddrval != DD_OK)
I_Error("CreateSurface Primary Screen FAILED");
// Create a back buffer for offscreen rendering, this will be used to
// blt to the primary
ScreenVirtual = CreateNewSurface(width, height, DDSCAPS_OFFSCREENPLAIN |
DDSCAPS_SYSTEMMEMORY);
if (ScreenVirtual == NULL)
I_Error("CreateSurface Secondary Screen FAILED");
/// \todo get the desktop bit depth, and build a lookup table
/// for quick conversions of 8bit color indexes 0-255 to desktop colors
/// eg: 256 entries of equivalent of palette colors 0-255 in 15,16,24,32 bit format
/// when blit virtual to real, convert pixels through lookup table..
// Use a clipper object for clipping when in windowed mode
// (make sure our drawing doesn't affect other windows)
ddrval = IDirectDraw2_CreateClipper (DDr2, 0, &windclip, 0);
if (ddrval != DD_OK)
I_Error("CreateClipper FAILED");
// Associate the clipper with the window.
ddrval = IDirectDrawClipper_SetHWnd (windclip,0, appWin);
if (ddrval != DD_OK)
I_Error("Clipper -> SetHWnd FAILED");
// Attach the clipper to the surface.
ddrval = IDirectDrawSurface_SetClipper (ScreenReal,windclip);
if (ddrval != DD_OK)
I_Error("PrimaryScreen -> SetClipperClipper FAILED");
}
return TRUE;
}
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;
}
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;
}
