diff options
Diffstat (limited to 'src/osd/modules/render/drawdd.cpp')
-rw-r--r-- | src/osd/modules/render/drawdd.cpp | 1317 |
1 files changed, 1317 insertions, 0 deletions
diff --git a/src/osd/modules/render/drawdd.cpp b/src/osd/modules/render/drawdd.cpp new file mode 100644 index 00000000000..fb82dff3c1f --- /dev/null +++ b/src/osd/modules/render/drawdd.cpp @@ -0,0 +1,1317 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +//============================================================ +// +// drawdd.c - Win32 DirectDraw implementation +// +//============================================================ + +// standard windows headers +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +#include <mmsystem.h> +#include <ddraw.h> +#undef interface + +// MAME headers +#include "emu.h" +#include "render.h" +#include "rendutil.h" +#include "rendersw.inc" + +// MAMEOS headers +#include "winmain.h" +#include "window.h" + + + +//============================================================ +// TYPE DEFINITIONS +//============================================================ + +typedef HRESULT (WINAPI *directdrawcreateex_ptr)(GUID FAR *lpGuid, LPVOID *lplpDD, REFIID iid, IUnknown FAR *pUnkOuter); +typedef HRESULT (WINAPI *directdrawenumerateex_ptr)(LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags); + + +/* dd_info is the information about DirectDraw for the current screen */ +class renderer_dd : public osd_renderer +{ +public: + renderer_dd(osd_window *window) + : osd_renderer(window, FLAG_NONE), + width(0), + height(0), + refresh(0), + //adapter(0), + adapter_ptr(NULL), + clearouter(0), + blitwidth(0), blitheight(0), + //lastdest + ddraw(NULL), + primary(NULL), + back(NULL), + blit(NULL), + clipper(NULL), + gamma(NULL), + //DDSURFACEDESC2 primarydesc; + //DDSURFACEDESC2 blitdesc; + //DDSURFACEDESC2 origmode; + //ddcaps(0), + //helcaps(0), + membuffer(NULL), + membuffersize(0) + { } + + virtual ~renderer_dd() { } + + virtual int create() override; + virtual render_primitive_list *get_primitives() override; + virtual int draw(const int update) override; + virtual void save() override {}; + virtual void record() override {}; + virtual void toggle_fsfx() override {}; + virtual void destroy() override; + + int width, height; // current width, height + int refresh; // current refresh rate + +private: + + inline void update_outer_rects(); + + // surface management + int ddraw_create(); + int ddraw_create_surfaces(); + void ddraw_delete(); + void ddraw_delete_surfaces(); + int ddraw_verify_caps(); + int ddraw_test_cooperative(); + HRESULT create_surface(DDSURFACEDESC2 *desc, IDirectDrawSurface7 **surface, const char *type); + int create_clipper(); + + // drawing helpers + void compute_blit_surface_size(); + void blit_to_primary(int srcwidth, int srcheight); + + // video modes + int config_adapter_mode(); + void get_adapter_for_monitor(osd_monitor_info *monitor); + void pick_best_mode(); + + // various + void calc_fullscreen_margins(DWORD desc_width, DWORD desc_height, RECT *margins); + + + GUID adapter; // current display adapter + GUID * adapter_ptr; // pointer to current display adapter + int clearouter; // clear the outer areas? + + INT32 blitwidth, blitheight; // current blit width/height values + RECT lastdest; // last destination rectangle + + IDirectDraw7 * ddraw; // pointer to the DirectDraw object + IDirectDrawSurface7 * primary; // pointer to the primary surface object + IDirectDrawSurface7 * back; // pointer to the back buffer surface object + IDirectDrawSurface7 * blit; // pointer to the blit surface object + IDirectDrawClipper * clipper; // pointer to the clipper object + IDirectDrawGammaControl *gamma; // pointer to the gamma control object + + DDSURFACEDESC2 primarydesc; // description of the primary surface + DDSURFACEDESC2 blitdesc; // description of the blitting surface + DDSURFACEDESC2 origmode; // original video mode + + DDCAPS ddcaps; // capabilities of the device + DDCAPS helcaps; // capabilities of the hardware + + UINT8 * membuffer; // memory buffer for complex rendering + UINT32 membuffersize; // current size of the memory buffer +}; + + +/* monitor_enum_info holds information during a monitor enumeration */ +struct monitor_enum_info +{ + osd_monitor_info * monitor; // pointer to monitor we want + GUID guid; // GUID of the one we found + GUID * guid_ptr; // pointer to our GUID + int foundit; // TRUE if we found what we wanted +}; + + +/* mode_enum_info holds information during a display mode enumeration */ +struct mode_enum_info +{ + renderer_dd * renderer; + osd_window * window; + INT32 minimum_width, minimum_height; + INT32 target_width, target_height; + double target_refresh; + float best_score; +}; + + + +//============================================================ +// GLOBALS +//============================================================ + +static HINSTANCE dllhandle; +static directdrawcreateex_ptr directdrawcreateex; +static directdrawenumerateex_ptr directdrawenumerateex; + + + +//============================================================ +// INLINES +//============================================================ + +inline void renderer_dd::update_outer_rects() +{ + clearouter = (back != NULL) ? 3 : 1; +} + + +static inline int better_mode(int width0, int height0, int width1, int height1, float desired_aspect) +{ + float aspect0 = (float)width0 / (float)height0; + float aspect1 = (float)width1 / (float)height1; + return (fabs(desired_aspect - aspect0) < fabs(desired_aspect - aspect1)) ? 0 : 1; +} + + + +//============================================================ +// PROTOTYPES +//============================================================ + +// core functions +static void drawdd_exit(void); + + + +//============================================================ +// drawnone_create +//============================================================ + +static osd_renderer *drawdd_create(osd_window *window) +{ + return global_alloc(renderer_dd(window)); +} + + +//============================================================ +// drawdd_init +//============================================================ + +int drawdd_init(running_machine &machine, osd_draw_callbacks *callbacks) +{ + // dynamically grab the create function from ddraw.dll + dllhandle = LoadLibrary(TEXT("ddraw.dll")); + if (dllhandle == NULL) + { + osd_printf_verbose("DirectDraw: Unable to access ddraw.dll\n"); + return 1; + } + + // import the create function + directdrawcreateex = (directdrawcreateex_ptr)GetProcAddress(dllhandle, "DirectDrawCreateEx"); + if (directdrawcreateex == NULL) + { + osd_printf_verbose("DirectDraw: Unable to find DirectDrawCreateEx\n"); + FreeLibrary(dllhandle); + dllhandle = NULL; + return 1; + } + + // import the enumerate function + directdrawenumerateex = (directdrawenumerateex_ptr)GetProcAddress(dllhandle, "DirectDrawEnumerateExA"); + if (directdrawenumerateex == NULL) + { + osd_printf_verbose("DirectDraw: Unable to find DirectDrawEnumerateExA\n"); + FreeLibrary(dllhandle); + dllhandle = NULL; + return 1; + } + + // fill in the callbacks + memset(callbacks, 0, sizeof(*callbacks)); + callbacks->exit = drawdd_exit; + callbacks->create = drawdd_create; + + osd_printf_verbose("DirectDraw: Using DirectDraw 7\n"); + return 0; +} + + + +//============================================================ +// drawdd_exit +//============================================================ + +static void drawdd_exit(void) +{ + if (dllhandle != NULL) + FreeLibrary(dllhandle); +} + + + +//============================================================ +// drawdd_window_init +//============================================================ + +int renderer_dd::create() +{ + // configure the adapter for the mode we want + if (config_adapter_mode()) + { + osd_printf_error("Unable to configure adapter.\n"); + goto error; + } + + // create the ddraw object + if (ddraw_create()) + { + osd_printf_error("Unable to create ddraw object.\n"); + goto error; + } + + return 0; + +error: + destroy(); + osd_printf_error("Unable to initialize DirectDraw.\n"); + return 1; +} + + + +//============================================================ +// drawdd_window_destroy +//============================================================ + +void renderer_dd::destroy() +{ + // delete the ddraw object + ddraw_delete(); +} + + + +//============================================================ +// drawdd_window_get_primitives +//============================================================ + +render_primitive_list *renderer_dd::get_primitives() +{ + compute_blit_surface_size(); + window().target()->set_bounds(blitwidth, blitheight, 0); + window().target()->set_max_update_rate((refresh == 0) ? origmode.dwRefreshRate : refresh); + + return &window().target()->get_primitives(); +} + + + +//============================================================ +// drawdd_window_draw +//============================================================ + +int renderer_dd::draw(const int update) +{ + render_primitive *prim; + int usemembuffer = FALSE; + HRESULT result; + + // if we're updating, remember to erase the outer stuff + if (update) + update_outer_rects(); + + // if we have a ddraw object, check the cooperative level + if (ddraw_test_cooperative()) + return 1; + + // get the size; if we're too small, delete the existing surfaces + if (blitwidth > blitdesc.dwWidth || blitheight > blitdesc.dwHeight) + ddraw_delete_surfaces(); + + // if we need to create surfaces, do it now + if (blit == NULL && ddraw_create_surfaces() != 0) + return 1; + + // select our surface and lock it + result = IDirectDrawSurface7_Lock(blit, NULL, &blitdesc, DDLOCK_WAIT, NULL); + if (result == DDERR_SURFACELOST) + { + osd_printf_verbose("DirectDraw: Lost surfaces; deleting and retrying next frame\n"); + ddraw_delete_surfaces(); + return 1; + } + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X locking blit surface\n", (int)result); + return 1; + } + + // render to it + window().m_primlist->acquire_lock(); + + // scan the list of primitives for tricky stuff + for (prim = window().m_primlist->first(); prim != NULL; prim = prim->next()) + if (PRIMFLAG_GET_BLENDMODE(prim->flags) != BLENDMODE_NONE || + (prim->texture.base != NULL && PRIMFLAG_GET_TEXFORMAT(prim->flags) == TEXFORMAT_ARGB32)) + { + usemembuffer = TRUE; + break; + } + + // if we're using the memory buffer, draw offscreen first and then copy + if (usemembuffer) + { + int x, y; + + // based on the target format, use one of our standard renderers + switch (blitdesc.ddpfPixelFormat.dwRBitMask) + { + case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window().m_primlist, membuffer, blitwidth, blitheight, blitwidth); break; + case 0x000000ff: software_renderer<UINT32, 0,0,0, 0,8,16>::draw_primitives(*window().m_primlist, membuffer, blitwidth, blitheight, blitwidth); break; + case 0xf800: software_renderer<UINT16, 3,2,3, 11,5,0>::draw_primitives(*window().m_primlist, membuffer, blitwidth, blitheight, blitwidth); break; + case 0x7c00: software_renderer<UINT16, 3,3,3, 10,5,0>::draw_primitives(*window().m_primlist, membuffer, blitwidth, blitheight, blitwidth); break; + default: + osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)blitdesc.ddpfPixelFormat.dwRBitMask, (int)blitdesc.ddpfPixelFormat.dwGBitMask, (int)blitdesc.ddpfPixelFormat.dwBBitMask); + break; + } + + // handle copying to both 16bpp and 32bpp destinations + for (y = 0; y < blitheight; y++) + { + if (blitdesc.ddpfPixelFormat.dwRGBBitCount == 32) + { + UINT32 *src = (UINT32 *)membuffer + y * blitwidth; + UINT32 *dst = (UINT32 *)((UINT8 *)blitdesc.lpSurface + y * blitdesc.lPitch); + for (x = 0; x < blitwidth; x++) + *dst++ = *src++; + } + else if (blitdesc.ddpfPixelFormat.dwRGBBitCount == 16) + { + UINT16 *src = (UINT16 *)membuffer + y * blitwidth; + UINT16 *dst = (UINT16 *)((UINT8 *)blitdesc.lpSurface + y * blitdesc.lPitch); + for (x = 0; x < blitwidth; x++) + *dst++ = *src++; + } + } + + } + + // otherwise, draw directly + else + { + // based on the target format, use one of our standard renderers + switch (blitdesc.ddpfPixelFormat.dwRBitMask) + { + case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0, true>::draw_primitives(*window().m_primlist, blitdesc.lpSurface, blitwidth, blitheight, blitdesc.lPitch / 4); break; + case 0x000000ff: software_renderer<UINT32, 0,0,0, 0,8,16, true>::draw_primitives(*window().m_primlist, blitdesc.lpSurface, blitwidth, blitheight, blitdesc.lPitch / 4); break; + case 0xf800: software_renderer<UINT16, 3,2,3, 11,5,0, true>::draw_primitives(*window().m_primlist, blitdesc.lpSurface, blitwidth, blitheight, blitdesc.lPitch / 2); break; + case 0x7c00: software_renderer<UINT16, 3,3,3, 10,5,0, true>::draw_primitives(*window().m_primlist, blitdesc.lpSurface, blitwidth, blitheight, blitdesc.lPitch / 2); break; + default: + osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)blitdesc.ddpfPixelFormat.dwRBitMask, (int)blitdesc.ddpfPixelFormat.dwGBitMask, (int)blitdesc.ddpfPixelFormat.dwBBitMask); + break; + } + } + window().m_primlist->release_lock(); + + // unlock and blit + result = IDirectDrawSurface7_Unlock(blit, NULL); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X unlocking blit surface\n", (int)result); + + // sync to VBLANK + if ((video_config.waitvsync || video_config.syncrefresh) && window().machine().video().throttled() && (!window().fullscreen() || back == NULL)) + { + result = IDirectDraw7_WaitForVerticalBlank(ddraw, DDWAITVB_BLOCKBEGIN, NULL); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X waiting for VBLANK\n", (int)result); + } + + // complete the blitting + blit_to_primary(blitwidth, blitheight); + return 0; +} + + + +//============================================================ +// ddraw_create +//============================================================ + +int renderer_dd::ddraw_create() +{ + HRESULT result; + int verify; + + // if a device exists, free it + if (ddraw != NULL) + ddraw_delete(); + + // create the DirectDraw object + result = (*directdrawcreateex)(adapter_ptr, (LPVOID *)&ddraw, WRAP_REFIID(IID_IDirectDraw7), NULL); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X during DirectDrawCreateEx call\n", (int)result); + goto error; + } + + // verify the caps + verify = ddraw_verify_caps(); + if (verify == 2) + { + osd_printf_error("DirectDraw: Error - Device does not meet minimum requirements for DirectDraw rendering\n"); + goto error; + } + if (verify == 1) + osd_printf_verbose("DirectDraw: Warning - Device may not perform well for DirectDraw rendering\n"); + + // set the cooperative level + // for non-window modes, we will use full screen here + result = IDirectDraw7_SetCooperativeLevel(ddraw, win_window_list->m_hwnd, DDSCL_SETFOCUSWINDOW); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X during IDirectDraw7_SetCooperativeLevel(FOCUSWINDOW) call\n", (int)result); + goto error; + } + result = IDirectDraw7_SetCooperativeLevel(ddraw, window().m_hwnd, DDSCL_SETDEVICEWINDOW | (window().fullscreen() ? DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE : DDSCL_NORMAL)); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X during IDirectDraw7_SetCooperativeLevel(DEVICEWINDOW) call\n", (int)result); + goto error; + } + + // full screen mode: set the resolution + if (window().fullscreen() && video_config.switchres) + { + result = IDirectDraw7_SetDisplayMode(ddraw, width, height, 32, refresh, 0); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X attempting to set video mode %dx%d@%d call\n", (int)result, width, height, refresh); + goto error; + } + } + + return ddraw_create_surfaces(); + +error: + ddraw_delete(); + return 1; +} + + + +//============================================================ +// ddraw_create_surfaces +//============================================================ + +int renderer_dd::ddraw_create_surfaces() +{ + HRESULT result; + + // make a description of the primary surface + memset(&primarydesc, 0, sizeof(primarydesc)); + primarydesc.dwSize = sizeof(primarydesc); + primarydesc.dwFlags = DDSD_CAPS; + primarydesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; + + // for triple-buffered full screen mode, allocate flipping surfaces + if (window().fullscreen() && video_config.triplebuf) + { + primarydesc.dwFlags |= DDSD_BACKBUFFERCOUNT; + primarydesc.ddsCaps.dwCaps |= DDSCAPS_FLIP | DDSCAPS_COMPLEX; + primarydesc.dwBackBufferCount = 2; + } + + // create the primary surface and report errors + result = create_surface(&primarydesc, &primary, "primary"); + if (result != DD_OK) goto error; + + // full screen mode: get the back surface + back = NULL; + if (window().fullscreen() && video_config.triplebuf) + { + DDSCAPS2 caps = { DDSCAPS_BACKBUFFER }; + result = IDirectDrawSurface7_GetAttachedSurface(primary, &caps, &back); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X getting attached back surface\n", (int)result); + goto error; + } + } + + // now make a description of our blit surface, based on the primary surface + if (blitwidth == 0 || blitheight == 0) + compute_blit_surface_size(); + blitdesc = primarydesc; + blitdesc.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS; + blitdesc.dwWidth = blitwidth; + blitdesc.dwHeight = blitheight; + blitdesc.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY; + + // then create the blit surface, fall back to system memory if video mem doesn't work + result = create_surface(&blitdesc, &blit, "blit"); + if (result != DD_OK) + { + blitdesc.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY; + result = create_surface(&blitdesc, &blit, "blit"); + } + if (result != DD_OK) goto error; + + // create a memory buffer for offscreen drawing + if (membuffersize < blitwidth * blitheight * 4) + { + membuffersize = blitwidth * blitheight * 4; + global_free_array(membuffer); + membuffer = global_alloc_array(UINT8, membuffersize); + } + if (membuffer == NULL) + goto error; + + // create a clipper for windowed mode + if (!window().fullscreen() && create_clipper()) + goto error; + + // full screen mode: set the gamma + if (window().fullscreen()) + { + // only set the gamma if it's not 1.0f + windows_options &options = downcast<windows_options &>(window().machine().options()); + float brightness = options.full_screen_brightness(); + float contrast = options.full_screen_contrast(); + float fgamma = options.full_screen_gamma(); + if (brightness != 1.0f || contrast != 1.0f || fgamma != 1.0f) + { + // see if we can get a GammaControl object + result = IDirectDrawSurface_QueryInterface(primary, WRAP_REFIID(IID_IDirectDrawGammaControl), (void **)&gamma); + if (result != DD_OK) + { + osd_printf_warning("DirectDraw: Warning - device does not support full screen gamma correction.\n"); + this->gamma = NULL; + } + + // proceed if we can + if (this->gamma != NULL) + { + DDGAMMARAMP ramp; + int i; + + // create a standard ramp and set it + for (i = 0; i < 256; i++) + ramp.red[i] = ramp.green[i] = ramp.blue[i] = apply_brightness_contrast_gamma(i, brightness, contrast, fgamma) << 8; + + // attempt to set it + result = IDirectDrawGammaControl_SetGammaRamp(this->gamma, 0, &ramp); + if (result != DD_OK) + osd_printf_verbose("DirectDraw: Error %08X attempting to set gamma correction.\n", (int)result); + } + } + } + + // force some updates + update_outer_rects(); + return 0; + +error: + ddraw_delete_surfaces(); + return 1; +} + + + +//============================================================ +// ddraw_delete +//============================================================ + +void renderer_dd::ddraw_delete() +{ + // free surfaces + ddraw_delete_surfaces(); + + // restore resolutions + if (ddraw != NULL) + IDirectDraw7_RestoreDisplayMode(ddraw); + + // reset cooperative level + if (ddraw != NULL && window().m_hwnd != NULL) + IDirectDraw7_SetCooperativeLevel(ddraw, window().m_hwnd, DDSCL_NORMAL); + + // release the DirectDraw object itself + if (ddraw != NULL) + IDirectDraw7_Release(ddraw); + ddraw = NULL; +} + + + +//============================================================ +// ddraw_delete_surfaces +//============================================================ + +void renderer_dd::ddraw_delete_surfaces() +{ + // release the gamma control + if (gamma != NULL) + IDirectDrawGammaControl_Release(gamma); + gamma = NULL; + + // release the clipper + if (clipper != NULL) + IDirectDrawClipper_Release(clipper); + clipper = NULL; + + // free the memory buffer + global_free_array(membuffer); + membuffer = NULL; + membuffersize = 0; + + // release the blit surface + if (blit != NULL) + IDirectDrawSurface7_Release(blit); + blit = NULL; + + // release the back surface + if (back != NULL) + IDirectDrawSurface7_Release(back); + back = NULL; + + // release the primary surface + if (primary != NULL) + IDirectDrawSurface7_Release(primary); + primary = NULL; +} + + + +//============================================================ +// ddraw_verify_caps +//============================================================ + +int renderer_dd::ddraw_verify_caps() +{ + int retval = 0; + HRESULT result; + + // get the capabilities + ddcaps.dwSize = sizeof(ddcaps); + helcaps.dwSize = sizeof(helcaps); + result = IDirectDraw7_GetCaps(ddraw, &ddcaps, &helcaps); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X during IDirectDraw7_GetCaps call\n", (int)result); + return 1; + } + + // determine if hardware stretching is available + if ((ddcaps.dwCaps & DDCAPS_BLTSTRETCH) == 0) + { + osd_printf_verbose("DirectDraw: Warning - Device does not support hardware stretching\n"); + retval = 1; + } + + return retval; +} + + + +//============================================================ +// ddraw_test_cooperative +//============================================================ + +int renderer_dd::ddraw_test_cooperative() +{ + HRESULT result; + + // check our current status; if we lost the device, punt to GDI + result = IDirectDraw7_TestCooperativeLevel(ddraw); + switch (result) + { + // punt to GDI if someone else has exclusive mode + case DDERR_NOEXCLUSIVEMODE: + case DDERR_EXCLUSIVEMODEALREADYSET: + ddraw_delete_surfaces(); + return 1; + + // if we're ok, but we don't have a primary surface, create one + default: + case DD_OK: + if (primary == NULL) + return ddraw_create_surfaces(); + return 0; + } +} + + + +//============================================================ +// create_surface +//============================================================ + +HRESULT renderer_dd::create_surface(DDSURFACEDESC2 *desc, IDirectDrawSurface7 **surface, const char *type) +{ + HRESULT result; + + // create the surface as requested + result = IDirectDraw7_CreateSurface(ddraw, desc, surface, NULL); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X creating %s surface\n", (int)result, type); + return result; + } + + // get a description of the primary surface + result = IDirectDrawSurface7_GetSurfaceDesc(*surface, desc); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X getting %s surface desciption\n", (int)result, type); + IDirectDrawSurface7_Release(*surface); + *surface = NULL; + return result; + } + + // print out the good stuff + osd_printf_verbose("DirectDraw: %s surface created: %dx%dx%d (R=%08X G=%08X B=%08X)\n", + type, + (int)desc->dwWidth, + (int)desc->dwHeight, + (int)desc->ddpfPixelFormat.dwRGBBitCount, + (UINT32)desc->ddpfPixelFormat.dwRBitMask, + (UINT32)desc->ddpfPixelFormat.dwGBitMask, + (UINT32)desc->ddpfPixelFormat.dwBBitMask); + return result; +} + + + +//============================================================ +// create_clipper +//============================================================ + +int renderer_dd::create_clipper() +{ + HRESULT result; + + // create a clipper for the primary surface + result = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X creating clipper\n", (int)result); + return 1; + } + + // set the clipper's hwnd + result = IDirectDrawClipper_SetHWnd(clipper, 0, window().m_hwnd); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X setting clipper hwnd\n", (int)result); + return 1; + } + + // set the clipper on the primary surface + result = IDirectDrawSurface7_SetClipper(primary, clipper); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X setting clipper on primary surface\n", (int)result); + return 1; + } + return 0; +} + + + +//============================================================ +// compute_blit_surface_size +//============================================================ + +void renderer_dd::compute_blit_surface_size() +{ + INT32 newwidth, newheight; + int xscale, yscale; + RECT client; + + // start with the minimum size + window().target()->compute_minimum_size(newwidth, newheight); + + // get the window's client rectangle + GetClientRect(window().m_hwnd, &client); + + // hardware stretch case: apply prescale + if (video_config.hwstretch) + { + int prescale = (window().prescale() < 1) ? 1 : window().prescale(); + + // clamp the prescale to something smaller than the target bounds + xscale = prescale; + while (xscale > 1 && newwidth * xscale > rect_width(&client)) + xscale--; + yscale = prescale; + while (yscale > 1 && newheight * yscale > rect_height(&client)) + yscale--; + } + + // non stretch case + else + { + INT32 target_width = rect_width(&client); + INT32 target_height = rect_height(&client); + float desired_aspect = 1.0f; + + // compute the appropriate visible area if we're trying to keepaspect + if (video_config.keepaspect) + { + osd_monitor_info *monitor = window().winwindow_video_window_monitor(NULL); + window().target()->compute_visible_area(target_width, target_height, monitor->aspect(), window().target()->orientation(), target_width, target_height); + desired_aspect = (float)target_width / (float)target_height; + } + + // compute maximum integral scaling to fit the window + xscale = (target_width + 2) / newwidth; + yscale = (target_height + 2) / newheight; + + // try a little harder to keep the aspect ratio if desired + if (video_config.keepaspect) + { + // if we could stretch more in the X direction, and that makes a better fit, bump the xscale + while (newwidth * (xscale + 1) <= rect_width(&client) && + better_mode(newwidth * xscale, newheight * yscale, newwidth * (xscale + 1), newheight * yscale, desired_aspect)) + xscale++; + + // if we could stretch more in the Y direction, and that makes a better fit, bump the yscale + while (newheight * (yscale + 1) <= rect_height(&client) && + better_mode(newwidth * xscale, newheight * yscale, newwidth * xscale, newheight * (yscale + 1), desired_aspect)) + yscale++; + + // now that we've maxed out, see if backing off the maximally stretched one makes a better fit + if (rect_width(&client) - newwidth * xscale < rect_height(&client) - newheight * yscale) + { + while (xscale > 1 && better_mode(newwidth * xscale, newheight * yscale, newwidth * (xscale - 1), newheight * yscale, desired_aspect)) + xscale--; + } + else + { + while (yscale > 1 && better_mode(newwidth * xscale, newheight * yscale, newwidth * xscale, newheight * (yscale - 1), desired_aspect)) + yscale--; + } + } + } + + // ensure at least a scale factor of 1 + if (xscale == 0) xscale = 1; + if (yscale == 0) yscale = 1; + + // apply the final scale + newwidth *= xscale; + newheight *= yscale; + if (newwidth != blitwidth || newheight != blitheight) + { + // force some updates + update_outer_rects(); + osd_printf_verbose("DirectDraw: New blit size = %dx%d\n", newwidth, newheight); + } + blitwidth = newwidth; + blitheight = newheight; +} + + + +//============================================================ +// calc_fullscreen_margins +//============================================================ + +void renderer_dd::calc_fullscreen_margins(DWORD desc_width, DWORD desc_height, RECT *margins) +{ + margins->left = 0; + margins->top = 0; + margins->right = desc_width; + margins->bottom = desc_height; + + if (window().win_has_menu()) + { + static int height_with_menubar = 0; + if (height_with_menubar == 0) + { + RECT with_menu = { 100, 100, 200, 200 }; + RECT without_menu = { 100, 100, 200, 200 }; + AdjustWindowRect(&with_menu, WS_OVERLAPPED, TRUE); + AdjustWindowRect(&without_menu, WS_OVERLAPPED, FALSE); + height_with_menubar = (with_menu.bottom - with_menu.top) - (without_menu.bottom - without_menu.top); + } + margins->top = height_with_menubar; + } +} + + + +//============================================================ +// blit_to_primary +//============================================================ + +void renderer_dd::blit_to_primary(int srcwidth, int srcheight) +{ + IDirectDrawSurface7 *target = (back != NULL) ? back : primary; + osd_monitor_info *monitor = window().winwindow_video_window_monitor(NULL); + DDBLTFX blitfx = { sizeof(DDBLTFX) }; + RECT clear, outer, dest, source; + INT32 dstwidth, dstheight; + HRESULT result; + + // compute source rect + source.left = source.top = 0; + source.right = srcwidth; + source.bottom = srcheight; + + // compute outer rect -- windowed version + if (!window().fullscreen()) + { + GetClientRect(window().m_hwnd, &outer); + ClientToScreen(window().m_hwnd, &((LPPOINT)&outer)[0]); + ClientToScreen(window().m_hwnd, &((LPPOINT)&outer)[1]); + + // adjust to be relative to the monitor + osd_rect pos = monitor->position_size(); + outer.left -= pos.left(); + outer.right -= pos.left(); + outer.top -= pos.top(); + outer.bottom -= pos.top(); + } + + // compute outer rect -- full screen version + else + { + calc_fullscreen_margins(primarydesc.dwWidth, primarydesc.dwHeight, &outer); + } + + // if we're respecting the aspect ratio, we need to adjust to fit + dstwidth = rect_width(&outer); + dstheight = rect_height(&outer); + if (!video_config.hwstretch) + { + // trim the source if necessary + if (rect_width(&outer) < srcwidth) + { + source.left += (srcwidth - rect_width(&outer)) / 2; + source.right = source.left + rect_width(&outer); + } + if (rect_height(&outer) < srcheight) + { + source.top += (srcheight - rect_height(&outer)) / 2; + source.bottom = source.top + rect_height(&outer); + } + + // match the destination and source sizes + dstwidth = srcwidth = source.right - source.left; + dstheight = srcheight = source.bottom - source.top; + } + else if (video_config.keepaspect) + { + // compute the appropriate visible area + window().target()->compute_visible_area(rect_width(&outer), rect_height(&outer), monitor->aspect(), window().target()->orientation(), dstwidth, dstheight); + } + + // center within + dest.left = outer.left + (rect_width(&outer) - dstwidth) / 2; + dest.right = dest.left + dstwidth; + dest.top = outer.top + (rect_height(&outer) - dstheight) / 2; + dest.bottom = dest.top + dstheight; + + // compare against last destination; if different, force a redraw + if (dest.left != lastdest.left || dest.right != lastdest.right || dest.top != lastdest.top || dest.bottom != lastdest.bottom) + { + lastdest = dest; + update_outer_rects(); + } + + // clear outer rects if we need to + if (clearouter != 0) + { + clearouter--; + + // clear the left edge + if (dest.left > outer.left) + { + clear = outer; + clear.right = dest.left; + result = IDirectDrawSurface_Blt(target, &clear, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &blitfx); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X clearing the screen\n", (int)result); + } + + // clear the right edge + if (dest.right < outer.right) + { + clear = outer; + clear.left = dest.right; + result = IDirectDrawSurface_Blt(target, &clear, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &blitfx); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X clearing the screen\n", (int)result); + } + + // clear the top edge + if (dest.top > outer.top) + { + clear = outer; + clear.bottom = dest.top; + result = IDirectDrawSurface_Blt(target, &clear, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &blitfx); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X clearing the screen\n", (int)result); + } + + // clear the bottom edge + if (dest.bottom < outer.bottom) + { + clear = outer; + clear.top = dest.bottom; + result = IDirectDrawSurface_Blt(target, &clear, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &blitfx); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X clearing the screen\n", (int)result); + } + } + + // do the blit + result = IDirectDrawSurface7_Blt(target, &dest, blit, &source, DDBLT_WAIT, NULL); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X blitting to the screen\n", (int)result); + + // page flip if triple buffered + if (window().fullscreen() && back != NULL) + { + result = IDirectDrawSurface7_Flip(primary, NULL, DDFLIP_WAIT); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X waiting for VBLANK\n", (int)result); + } +} + + + +//============================================================ +// config_adapter_mode +//============================================================ + +int renderer_dd::config_adapter_mode() +{ + DDDEVICEIDENTIFIER2 identifier; + HRESULT result; + + // choose the monitor number + get_adapter_for_monitor(window().monitor()); + + // create a temporary DirectDraw object + result = (*directdrawcreateex)(adapter_ptr, (LPVOID *)&ddraw, WRAP_REFIID(IID_IDirectDraw7), NULL); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X during DirectDrawCreateEx call\n", (int)result); + return 1; + } + + // get the identifier + result = IDirectDraw7_GetDeviceIdentifier(ddraw, &identifier, 0); + if (result != DD_OK) + { + osd_printf_error("Error getting identifier for device\n"); + return 1; + } + osd_printf_verbose("DirectDraw: Configuring device %s\n", identifier.szDescription); + + // get the current display mode + memset(&origmode, 0, sizeof(origmode)); + origmode.dwSize = sizeof(origmode); + result = IDirectDraw7_GetDisplayMode(ddraw, &origmode); + if (result != DD_OK) + { + osd_printf_verbose("DirectDraw: Error %08X getting current display mode\n", (int)result); + IDirectDraw7_Release(ddraw); + return 1; + } + + // choose a resolution: full screen mode case + if (window().fullscreen()) + { + // default to the current mode exactly + width = origmode.dwWidth; + height = origmode.dwHeight; + refresh = origmode.dwRefreshRate; + + // if we're allowed to switch resolutions, override with something better + if (video_config.switchres) + pick_best_mode(); + } + + // release the DirectDraw object + IDirectDraw7_Release(ddraw); + ddraw = NULL; + + // if we're not changing resolutions, make sure we have a resolution we can handle + if (!window().fullscreen() || !video_config.switchres) + { + switch (origmode.ddpfPixelFormat.dwRBitMask) + { + case 0x00ff0000: + case 0x000000ff: + case 0xf800: + case 0x7c00: + break; + + default: + osd_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)origmode.ddpfPixelFormat.dwRBitMask, (int)origmode.ddpfPixelFormat.dwGBitMask, (int)origmode.ddpfPixelFormat.dwBBitMask); + return 1; + } + } + + return 0; +} + + + +//============================================================ +// monitor_enum_callback +//============================================================ + +static BOOL WINAPI monitor_enum_callback(GUID FAR *guid, LPSTR description, LPSTR name, LPVOID context, HMONITOR hmonitor) +{ + monitor_enum_info *einfo = (monitor_enum_info *)context; + + // do we match the desired monitor? + if (hmonitor == *((HMONITOR *)einfo->monitor->oshandle()) || (hmonitor == NULL && einfo->monitor->is_primary())) + { + einfo->guid_ptr = (guid != NULL) ? &einfo->guid : NULL; + if (guid != NULL) + einfo->guid = *guid; + einfo->foundit = TRUE; + } + return 1; +} + + + +//============================================================ +// get_adapter_for_monitor +//============================================================ + +void renderer_dd::get_adapter_for_monitor(osd_monitor_info *monitor) +{ + monitor_enum_info einfo; + HRESULT result; + + // try to find our monitor + memset(&einfo, 0, sizeof(einfo)); + einfo.monitor = monitor; + result = (*directdrawenumerateex)(monitor_enum_callback, &einfo, DDENUM_ATTACHEDSECONDARYDEVICES); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X during DirectDrawEnumerateEx call\n", (int)result); + + // set up the adapter + if (einfo.foundit && einfo.guid_ptr != NULL) + { + adapter = einfo.guid; + adapter_ptr = &adapter; + } + else + adapter_ptr = NULL; +} + + + +//============================================================ +// enum_modes_callback +//============================================================ + +static HRESULT WINAPI enum_modes_callback(LPDDSURFACEDESC2 desc, LPVOID context) +{ + float size_score, refresh_score, final_score; + mode_enum_info *einfo = (mode_enum_info *)context; + renderer_dd *dd = einfo->renderer; + + // skip non-32 bit modes + if (desc->ddpfPixelFormat.dwRGBBitCount != 32) + return DDENUMRET_OK; + + // compute initial score based on difference between target and current + size_score = 1.0f / (1.0f + fabs((float)((INT32)desc->dwWidth - einfo->target_width)) + fabs((float)((INT32)desc->dwHeight - einfo->target_height))); + + // if the mode is too small, give a big penalty + if (desc->dwWidth < einfo->minimum_width || desc->dwHeight < einfo->minimum_height) + size_score *= 0.01f; + + // if mode is smaller than we'd like, it only scores up to 0.1 + if (desc->dwWidth < einfo->target_width || desc->dwHeight < einfo->target_height) + size_score *= 0.1f; + + // if we're looking for a particular mode, that's a winner + if (desc->dwWidth == einfo->window->m_win_config.width && desc->dwHeight == einfo->window->m_win_config.height) + size_score = 2.0f; + + // compute refresh score + refresh_score = 1.0f / (1.0f + fabs((double)desc->dwRefreshRate - einfo->target_refresh)); + + // if refresh is smaller than we'd like, it only scores up to 0.1 + if ((double)desc->dwRefreshRate < einfo->target_refresh) + refresh_score *= 0.1f; + + // if we're looking for a particular refresh, make sure it matches + if (desc->dwRefreshRate == einfo->window->m_win_config.refresh) + refresh_score = 2.0f; + + // weight size and refresh equally + final_score = size_score + refresh_score; + + // best so far? + osd_printf_verbose(" %4dx%4d@%3dHz -> %f\n", (int)desc->dwWidth, (int)desc->dwHeight, (int)desc->dwRefreshRate, final_score * 1000.0f); + if (final_score > einfo->best_score) + { + einfo->best_score = final_score; + dd->width = desc->dwWidth; + dd->height = desc->dwHeight; + dd->refresh = desc->dwRefreshRate; + } + return DDENUMRET_OK; +} + + + +//============================================================ +// pick_best_mode +//============================================================ + +void renderer_dd::pick_best_mode() +{ + mode_enum_info einfo; + HRESULT result; + + // determine the minimum width/height for the selected target + // note: technically we should not be calling this from an alternate window + // thread; however, it is only done during init time, and the init code on + // the main thread is waiting for us to finish, so it is safe to do so here + window().target()->compute_minimum_size(einfo.minimum_width, einfo.minimum_height); + + // use those as the target for now + einfo.target_width = einfo.minimum_width * MAX(1, window().prescale()); + einfo.target_height = einfo.minimum_height * MAX(1, window().prescale()); + + // determine the refresh rate of the primary screen + einfo.target_refresh = 60.0; + const screen_device *primary_screen = window().machine().config().first_screen(); + if (primary_screen != NULL) + einfo.target_refresh = ATTOSECONDS_TO_HZ(primary_screen->refresh_attoseconds()); + printf("Target refresh = %f\n", einfo.target_refresh); + + // if we're not stretching, allow some slop on the minimum since we can handle it + if (!video_config.hwstretch) + { + einfo.minimum_width -= 4; + einfo.minimum_height -= 4; + } + + // if we are stretching, aim for a mode approximately 2x the game's resolution + else if (window().prescale() <= 1) + { + einfo.target_width *= 2; + einfo.target_height *= 2; + } + + // fill in the rest of the data + einfo.window = &window(); + einfo.renderer = this; + einfo.best_score = 0.0f; + + // enumerate the modes + osd_printf_verbose("DirectDraw: Selecting video mode...\n"); + result = IDirectDraw7_EnumDisplayModes(ddraw, DDEDM_REFRESHRATES, NULL, &einfo, enum_modes_callback); + if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X during EnumDisplayModes call\n", (int)result); + osd_printf_verbose("DirectDraw: Mode selected = %4dx%4d@%3dHz\n", width, height, refresh); +} |