diff --git a/src/win/Makefile.mingw b/src/win/Makefile.mingw index 33be2f901..142acaadf 100644 --- a/src/win/Makefile.mingw +++ b/src/win/Makefile.mingw @@ -8,7 +8,7 @@ # # Makefile for Win32 (MinGW32) environment. # -# Version: @(#)Makefile.mingw 1.0.75 2017/11/11 +# Version: @(#)Makefile.mingw 1.0.75 2017/11/12 # # Authors: Miran Grca, # Fred N. van Kempen, @@ -378,7 +378,7 @@ VIDOBJ := video.o \ vid_voodoo.o PLATOBJ := win.o \ - win_ddraw.o win_ddraw_fs.o win_d3d.o win_d3d_fs.o \ + win_ddraw.o win_d3d.o win_d3d_fs.o win_png.o \ win_dynld.o win_thread.o $(WSERIAL) win_video.o \ win_cdrom.o win_cdrom_ioctl.o win_keyboard.o win_mouse.o \ win_joystick.o win_midi.o \ diff --git a/src/win/win_ddraw.cc b/src/win/win_ddraw.cc index 723623aeb..cef4de882 100644 --- a/src/win/win_ddraw.cc +++ b/src/win/win_ddraw.cc @@ -1,40 +1,53 @@ -/* Copyright holders: Sarah Walker, Tenshi - see COPYING for more details -*/ +/* + * 86Box A hypervisor and IBM PC system emulator that specializes in + * running old operating systems and software designed for IBM + * PC systems and compatibles from 1981 through fairly recent + * system designs based on the PCI bus. + * + * This file is part of the 86Box distribution. + * + * Rendering module for Microsoft DirectDraw 9. + * + * NOTES: This code should be re-merged into a single init() with a + * 'fullscreen' argument, indicating FS mode is requested. + * + * Version: @(#)win_ddraw.cc 1.0.2 2017/11/12 + * + * Authors: Sarah Walker, + * Miran Grca, + * Fred N. van Kempen, + * + * Copyright 2008-2017 Sarah Walker. + * Copyright 2016,2017 Miran Grca. + * Copyright 2017 Fred N. van Kempen. + */ #include #include #define UNICODE #define BITMAP WINDOWS_BITMAP #include #undef BITMAP +#include "../86box.h" +#include "../device.h" #include "../video/video.h" #include "../plat.h" #include "../ui.h" #include "win_ddraw.h" +#include "win_png.h" #include "win.h" -extern "C" void fatal(const char *format, ...); -extern "C" void pclog(const char *format, ...); - -extern "C" void device_force_redraw(void); - -extern "C" int ddraw_init(HWND h); -extern "C" int ddraw_pause(void); -extern "C" void ddraw_close(void); -extern "C" void ddraw_take_screenshot(wchar_t *fn); - - -static LPDIRECTDRAW lpdd = NULL; -static LPDIRECTDRAW7 lpdd7 = NULL; -static LPDIRECTDRAWSURFACE7 lpdds_pri = NULL; -static LPDIRECTDRAWSURFACE7 lpdds_back = NULL; -static LPDIRECTDRAWSURFACE7 lpdds_back2 = NULL; -static LPDIRECTDRAWCLIPPER lpdd_clipper = NULL; -static DDSURFACEDESC2 ddsd; -static HWND ddraw_hwnd; -static HBITMAP hbitmap; -static int xs, ys, ys2; +static LPDIRECTDRAW lpdd = NULL; +static LPDIRECTDRAW7 lpdd7 = NULL; +static LPDIRECTDRAWSURFACE7 lpdds_pri = NULL, + lpdds_back = NULL, + lpdds_back2 = NULL; +static LPDIRECTDRAWCLIPPER lpdd_clipper = NULL; +static DDSURFACEDESC2 ddsd; +static HWND ddraw_hwnd; +static HBITMAP hbitmap; +static int ddraw_w, ddraw_h, + xs, ys, ys2; static void @@ -142,40 +155,68 @@ SaveBitmap(wchar_t *szFilename, HBITMAP hBitmap) } -void -ddraw_common_take_screenshot(wchar_t *fn, IDirectDrawSurface7 *pDDSurface) +static void +ddraw_fs_size(RECT w_rect, RECT *r_dest, int w, int h) { - xs = xsize; - ys = ys2 = ysize; - /* For EGA/(S)VGA, the size is NOT adjusted for overscan. */ - if ((overscan_y > 16) && enable_overscan) - { - xs += overscan_x; - ys += overscan_y; - } - /* For CGA, the width is adjusted for overscan, but the height is not. */ - if (overscan_y == 16) - { - if (ys2 <= 250) - ys += (overscan_y >> 1); - else - ys += overscan_y; - } - CopySurface(pDDSurface); - SaveBitmap(fn, hbitmap); + int ratio_w, ratio_h; + + switch (video_fullscreen_scale) { + case FULLSCR_SCALE_FULL: + r_dest->left = 0; + r_dest->top = 0; + r_dest->right = (w_rect.right - w_rect.left) - 1; + r_dest->bottom = (w_rect.bottom - w_rect.top) - 1; + break; + + case FULLSCR_SCALE_43: + r_dest->top = 0; + r_dest->bottom = (w_rect.bottom - w_rect.top) - 1; + r_dest->left = ((w_rect.right - w_rect.left) / 2) - (((w_rect.bottom - w_rect.top) * 4) / (3 * 2)); + r_dest->right = ((w_rect.right - w_rect.left) / 2) + (((w_rect.bottom - w_rect.top) * 4) / (3 * 2)) - 1; + if (r_dest->left < 0) { + r_dest->left = 0; + r_dest->right = (w_rect.right - w_rect.left) - 1; + r_dest->top = ((w_rect.bottom - w_rect.top) / 2) - (((w_rect.right - w_rect.left) * 3) / (4 * 2)); + r_dest->bottom = ((w_rect.bottom - w_rect.top) / 2) + (((w_rect.right - w_rect.left) * 3) / (4 * 2)) - 1; + } + break; + + case FULLSCR_SCALE_SQ: + r_dest->top = 0; + r_dest->bottom = (w_rect.bottom - w_rect.top) - 1; + r_dest->left = ((w_rect.right - w_rect.left) / 2) - (((w_rect.bottom - w_rect.top) * w) / (h * 2)); + r_dest->right = ((w_rect.right - w_rect.left) / 2) + (((w_rect.bottom - w_rect.top) * w) / (h * 2)) - 1; + if (r_dest->left < 0) { + r_dest->left = 0; + r_dest->right = (w_rect.right - w_rect.left) - 1; + r_dest->top = ((w_rect.bottom - w_rect.top) / 2) - (((w_rect.right - w_rect.left) * h) / (w * 2)); + r_dest->bottom = ((w_rect.bottom - w_rect.top) / 2) + (((w_rect.right - w_rect.left) * h) / (w * 2)) - 1; + } + break; + + case FULLSCR_SCALE_INT: + ratio_w = (w_rect.right - w_rect.left) / w; + ratio_h = (w_rect.bottom - w_rect.top) / h; + if (ratio_h < ratio_w) + ratio_w = ratio_h; + r_dest->left = ((w_rect.right - w_rect.left) / 2) - ((w * ratio_w) / 2); + r_dest->right = ((w_rect.right - w_rect.left) / 2) + ((w * ratio_w) / 2) - 1; + r_dest->top = ((w_rect.bottom - w_rect.top) / 2) - ((h * ratio_w) / 2); + r_dest->bottom = ((w_rect.bottom - w_rect.top) / 2) + ((h * ratio_w) / 2) - 1; + break; + } } static void -blit_memtoscreen(int x, int y, int y1, int y2, int w, int h) +ddraw_blit_fs(int x, int y, int y1, int y2, int w, int h) { RECT r_src; RECT r_dest; + RECT w_rect; int yy; - POINT po; HRESULT hr; - -// pclog("Blit memtoscreen %i,%i %i %i %i,%i\n", x, y, y1, y2, w, h); + DDBLTFX ddbltfx; if (lpdds_back == NULL) { video_blit_complete(); @@ -190,13 +231,87 @@ blit_memtoscreen(int x, int y, int y1, int y2, int w, int h) memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); - hr = lpdds_back->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); + hr = lpdds_back->Lock(NULL, &ddsd, + DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); if (hr == DDERR_SURFACELOST) { lpdds_back->Restore(); - lpdds_back->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); + lpdds_back->Lock(NULL, &ddsd, + DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); device_force_redraw(); } - if (!ddsd.lpSurface) { + if (! ddsd.lpSurface) { + video_blit_complete(); + return; + } + + for (yy = y1; yy < y2; yy++) + memcpy((void *)((uintptr_t)ddsd.lpSurface + (yy * ddsd.lPitch)), &(((uint32_t *)buffer32->line[y + yy])[x]), w * 4); + video_blit_complete(); + lpdds_back->Unlock(NULL); + + w_rect.left = 0; + w_rect.top = 0; + w_rect.right = ddraw_w; + w_rect.bottom = ddraw_h; + ddraw_fs_size(w_rect, &r_dest, w, h); + + r_src.left = 0; + r_src.top = 0; + r_src.right = w; + r_src.bottom = h; + + ddbltfx.dwSize = sizeof(ddbltfx); + ddbltfx.dwFillColor = 0; + + lpdds_back2->Blt(&w_rect, NULL, NULL, + DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx); + + hr = lpdds_back2->Blt(&r_dest, lpdds_back, &r_src, DDBLT_WAIT, NULL); + if (hr == DDERR_SURFACELOST) { + lpdds_back2->Restore(); + lpdds_back2->Blt(&r_dest, lpdds_back, &r_src, DDBLT_WAIT, NULL); + } + + hr = lpdds_pri->Flip(NULL, DDFLIP_NOVSYNC); + if (hr == DDERR_SURFACELOST) { + lpdds_pri->Restore(); + lpdds_pri->Flip(NULL, DDFLIP_NOVSYNC); + } +} + + +static void +ddraw_blit(int x, int y, int y1, int y2, int w, int h) +{ + RECT r_src; + RECT r_dest; + POINT po; + HRESULT hr; + int yy; + + if (lpdds_back == NULL) { + video_blit_complete(); + return; /*Nothing to do*/ + } + + if ((y1 == y2) || (h <= 0)) { + video_blit_complete(); + return; + } + + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + + hr = lpdds_back->Lock(NULL, &ddsd, + DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); + if (hr == DDERR_SURFACELOST) { + lpdds_back->Restore(); + lpdds_back->Lock(NULL, &ddsd, + DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); + device_force_redraw(); + } + + if (! ddsd.lpSurface) { video_blit_complete(); return; } @@ -227,7 +342,6 @@ blit_memtoscreen(int x, int y, int y1, int y2, int w, int h) lpdds_back2->Unlock(NULL); -// pclog("Blit from %i,%i %i,%i to %i,%i %i,%i\n", r_src.left, r_src.top, r_src.right, r_src.bottom, r_dest.left, r_dest.top, r_dest.right, r_dest.bottom); hr = lpdds_pri->Blt(&r_dest, lpdds_back2, &r_src, DDBLT_WAIT, NULL); if (hr == DDERR_SURFACELOST) { lpdds_pri->Restore(); @@ -236,6 +350,32 @@ blit_memtoscreen(int x, int y, int y1, int y2, int w, int h) } +void +ddraw_take_screenshot(wchar_t *fn) +{ + xs = xsize; + ys = ys2 = ysize; + + /* For EGA/(S)VGA, the size is NOT adjusted for overscan. */ + if ((overscan_y > 16) && enable_overscan) { + xs += overscan_x; + ys += overscan_y; + } + + /* For CGA, the width is adjusted for overscan, but the height is not. */ + if (overscan_y == 16) { + if (ys2 <= 250) + ys += (overscan_y >> 1); + else + ys += overscan_y; + } + + CopySurface(lpdds_back2); + + SaveBitmap(fn, hbitmap); +} + + int ddraw_init(HWND h) { @@ -258,8 +398,6 @@ ddraw_init(HWND h) ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; if (FAILED(lpdd7->CreateSurface(&ddsd, &lpdds_pri, NULL))) return(0); - // memset(&ddsd, 0, sizeof(ddsd)); - // ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.dwWidth = 2048; ddsd.dwHeight = 2048; @@ -275,7 +413,6 @@ ddraw_init(HWND h) memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); - ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; ddsd.dwWidth = 2048; ddsd.dwHeight = 2048; @@ -297,7 +434,65 @@ ddraw_init(HWND h) ddraw_hwnd = h; - video_setblit(blit_memtoscreen); + video_setblit(ddraw_blit); + + return(1); +} + + +int +ddraw_init_fs(HWND h) +{ + ddraw_w = GetSystemMetrics(SM_CXSCREEN); + ddraw_h = GetSystemMetrics(SM_CYSCREEN); + + cgapal_rebuild(); + + if (FAILED(DirectDrawCreate(NULL, &lpdd, NULL))) return 0; + + if (FAILED(lpdd->QueryInterface(IID_IDirectDraw7, (LPVOID *)&lpdd7))) return 0; + + lpdd->Release(); + lpdd = NULL; + + atexit(ddraw_close); + + if (FAILED(lpdd7->SetCooperativeLevel(h, + DDSCL_SETFOCUSWINDOW | \ + DDSCL_CREATEDEVICEWINDOW | \ + DDSCL_EXCLUSIVE | \ + DDSCL_FULLSCREEN | \ + DDSCL_ALLOWREBOOT))) return 0; + + if (FAILED(lpdd7->SetDisplayMode(ddraw_w, ddraw_h, 32, 0 ,0))) return 0; + + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; + ddsd.dwBackBufferCount = 1; + ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP; + if (FAILED(lpdd7->CreateSurface(&ddsd, &lpdds_pri, NULL))) return 0; + + ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; + if (FAILED(lpdds_pri->GetAttachedSurface(&ddsd.ddsCaps, &lpdds_back2))) return 0; + + memset(&ddsd, 0, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; + ddsd.dwWidth = 2048; + ddsd.dwHeight = 2048; + ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; + if (FAILED(lpdd7->CreateSurface(&ddsd, &lpdds_back, NULL))) { + ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; + ddsd.dwWidth = 2048; + ddsd.dwHeight = 2048; + ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; + if (FAILED(lpdd7->CreateSurface(&ddsd, &lpdds_back, NULL))) return 0; + } + + ddraw_hwnd = h; + + video_setblit(ddraw_blit_fs); return(1); } @@ -334,10 +529,3 @@ ddraw_pause(void) { return(0); } - - -void -ddraw_take_screenshot(wchar_t *fn) -{ - ddraw_common_take_screenshot(fn, lpdds_back2); -} diff --git a/src/win/win_ddraw.h b/src/win/win_ddraw.h index fa47da60f..357ba4906 100644 --- a/src/win/win_ddraw.h +++ b/src/win/win_ddraw.h @@ -1,6 +1,21 @@ -/* Copyright holders: Sarah Walker, Tenshi - see COPYING for more details -*/ +/* + * 86Box A hypervisor and IBM PC system emulator that specializes in + * running old operating systems and software designed for IBM + * PC systems and compatibles from 1981 through fairly recent + * system designs based on the PCI bus. + * + * This file is part of the 86Box distribution. + * + * Definitions for the DirectDraw 9 rendering module. + * + * Version: @(#)win_ddraw.h 1.0.1 2017/11/12 + * + * Authors: Sarah Walker, + * Miran Grca, + * + * Copyright 2008-2017 Sarah Walker. + * Copyright 2016,2017 Miran Grca. + */ #ifndef WIN_DDRAW_H # define WIN_DDRAW_H # define UNICODE @@ -14,15 +29,11 @@ extern "C" { #endif extern int ddraw_init(HWND h); +extern int ddraw_init_fs(HWND h); extern void ddraw_close(void); extern int ddraw_pause(void); extern void ddraw_take_screenshot(wchar_t *fn); -extern int ddraw_fs_init(HWND h); -extern void ddraw_fs_close(void); -extern int ddraw_fs_pause(void); -extern void ddraw_fs_take_screenshot(wchar_t *fn); - #ifdef __cplusplus } #endif diff --git a/src/win/win_ddraw_fs.cc b/src/win/win_ddraw_fs.cc deleted file mode 100644 index 26976d6c6..000000000 --- a/src/win/win_ddraw_fs.cc +++ /dev/null @@ -1,250 +0,0 @@ -/* Copyright holders: Sarah Walker, Tenshi - see COPYING for more details -*/ -#include -#include "../86box.h" -#include "../device.h" -#include "../video/video.h" -#include "win_ddraw.h" - - -static LPDIRECTDRAW lpdd = NULL; -static LPDIRECTDRAW7 lpdd7 = NULL; -static LPDIRECTDRAWSURFACE7 lpdds_pri = NULL; -static LPDIRECTDRAWSURFACE7 lpdds_back = NULL; -static LPDIRECTDRAWSURFACE7 lpdds_back2 = NULL; -static LPDIRECTDRAWCLIPPER lpdd_clipper = NULL; -static DDSURFACEDESC2 ddsd; -static HWND ddraw_hwnd; -static int ddraw_w, ddraw_h; - - -extern void ddraw_common_take_screenshot(wchar_t *fn, IDirectDrawSurface7 *pDDSurface); - - -static void ddraw_fs_size(RECT window_rect, RECT *r_dest, int w, int h) -{ - int ratio_w, ratio_h; - switch (video_fullscreen_scale) - { - case FULLSCR_SCALE_FULL: - r_dest->left = 0; - r_dest->top = 0; - r_dest->right = (window_rect.right - window_rect.left) - 1; - r_dest->bottom = (window_rect.bottom - window_rect.top) - 1; - break; - case FULLSCR_SCALE_43: - r_dest->top = 0; - r_dest->bottom = (window_rect.bottom - window_rect.top) - 1; - r_dest->left = ((window_rect.right - window_rect.left) / 2) - (((window_rect.bottom - window_rect.top) * 4) / (3 * 2)); - r_dest->right = ((window_rect.right - window_rect.left) / 2) + (((window_rect.bottom - window_rect.top) * 4) / (3 * 2)) - 1; - if (r_dest->left < 0) - { - r_dest->left = 0; - r_dest->right = (window_rect.right - window_rect.left) - 1; - r_dest->top = ((window_rect.bottom - window_rect.top) / 2) - (((window_rect.right - window_rect.left) * 3) / (4 * 2)); - r_dest->bottom = ((window_rect.bottom - window_rect.top) / 2) + (((window_rect.right - window_rect.left) * 3) / (4 * 2)) - 1; - } - break; - case FULLSCR_SCALE_SQ: - r_dest->top = 0; - r_dest->bottom = (window_rect.bottom - window_rect.top) - 1; - r_dest->left = ((window_rect.right - window_rect.left) / 2) - (((window_rect.bottom - window_rect.top) * w) / (h * 2)); - r_dest->right = ((window_rect.right - window_rect.left) / 2) + (((window_rect.bottom - window_rect.top) * w) / (h * 2)) - 1; - if (r_dest->left < 0) - { - r_dest->left = 0; - r_dest->right = (window_rect.right - window_rect.left) - 1; - r_dest->top = ((window_rect.bottom - window_rect.top) / 2) - (((window_rect.right - window_rect.left) * h) / (w * 2)); - r_dest->bottom = ((window_rect.bottom - window_rect.top) / 2) + (((window_rect.right - window_rect.left) * h) / (w * 2)) - 1; - } - break; - case FULLSCR_SCALE_INT: - ratio_w = (window_rect.right - window_rect.left) / w; - ratio_h = (window_rect.bottom - window_rect.top) / h; - if (ratio_h < ratio_w) - ratio_w = ratio_h; - r_dest->left = ((window_rect.right - window_rect.left) / 2) - ((w * ratio_w) / 2); - r_dest->right = ((window_rect.right - window_rect.left) / 2) + ((w * ratio_w) / 2) - 1; - r_dest->top = ((window_rect.bottom - window_rect.top) / 2) - ((h * ratio_w) / 2); - r_dest->bottom = ((window_rect.bottom - window_rect.top) / 2) + ((h * ratio_w) / 2) - 1; - break; - } -} - - -static void blit_memtoscreen(int x, int y, int y1, int y2, int w, int h) -{ - RECT r_src; - RECT r_dest; - RECT window_rect; - int yy; - HRESULT hr; - DDBLTFX ddbltfx; - - if (lpdds_back == NULL) - { - video_blit_complete(); - return; /*Nothing to do*/ - } - - if ((y1 == y2) || (h <= 0)) { - video_blit_complete(); - return; - } - - memset(&ddsd, 0, sizeof(ddsd)); - ddsd.dwSize = sizeof(ddsd); - - hr = lpdds_back->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); - if (hr == DDERR_SURFACELOST) - { - lpdds_back->Restore(); - lpdds_back->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); - device_force_redraw(); - } - if (!ddsd.lpSurface) - { - video_blit_complete(); - return; - } - for (yy = y1; yy < y2; yy++) - memcpy((void *)((uintptr_t)ddsd.lpSurface + (yy * ddsd.lPitch)), &(((uint32_t *)buffer32->line[y + yy])[x]), w * 4); - video_blit_complete(); - lpdds_back->Unlock(NULL); - - window_rect.left = 0; - window_rect.top = 0; - window_rect.right = ddraw_w; - window_rect.bottom = ddraw_h; - ddraw_fs_size(window_rect, &r_dest, w, h); - - r_src.left = 0; - r_src.top = 0; - r_src.right = w; - r_src.bottom = h; - - ddbltfx.dwSize = sizeof(ddbltfx); - ddbltfx.dwFillColor = 0; - - lpdds_back2->Blt(&window_rect, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx); - - hr = lpdds_back2->Blt(&r_dest, lpdds_back, &r_src, DDBLT_WAIT, NULL); - if (hr == DDERR_SURFACELOST) - { - lpdds_back2->Restore(); - lpdds_back2->Blt(&r_dest, lpdds_back, &r_src, DDBLT_WAIT, NULL); - } - - hr = lpdds_pri->Flip(NULL, DDFLIP_NOVSYNC); - if (hr == DDERR_SURFACELOST) - { - lpdds_pri->Restore(); - lpdds_pri->Flip(NULL, DDFLIP_NOVSYNC); - } -} - - -int ddraw_fs_init(HWND h) -{ - ddraw_w = GetSystemMetrics(SM_CXSCREEN); - ddraw_h = GetSystemMetrics(SM_CYSCREEN); - - cgapal_rebuild(); - - if (FAILED(DirectDrawCreate(NULL, &lpdd, NULL))) - return 0; - - if (FAILED(lpdd->QueryInterface(IID_IDirectDraw7, (LPVOID *)&lpdd7))) - return 0; - - lpdd->Release(); - lpdd = NULL; - - atexit(ddraw_fs_close); - - if (FAILED(lpdd7->SetCooperativeLevel(h, DDSCL_SETFOCUSWINDOW | - DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT))) - return 0; - - if (FAILED(lpdd7->SetDisplayMode(ddraw_w, ddraw_h, 32, 0 ,0))) - return 0; - - memset(&ddsd, 0, sizeof(ddsd)); - ddsd.dwSize = sizeof(ddsd); - ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; - ddsd.dwBackBufferCount = 1; - ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP; - if (FAILED(lpdd7->CreateSurface(&ddsd, &lpdds_pri, NULL))) - return 0; - - ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; - if (FAILED(lpdds_pri->GetAttachedSurface(&ddsd.ddsCaps, &lpdds_back2))) - return 0; - - memset(&ddsd, 0, sizeof(ddsd)); - ddsd.dwSize = sizeof(ddsd); - ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; - ddsd.dwWidth = 2048; - ddsd.dwHeight = 2048; - ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; - if (FAILED(lpdd7->CreateSurface(&ddsd, &lpdds_back, NULL))) - { - ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; - ddsd.dwWidth = 2048; - ddsd.dwHeight = 2048; - ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; - if (FAILED(lpdd7->CreateSurface(&ddsd, &lpdds_back, NULL))) - return 0; - } - - pclog("DDRAW_INIT complete\n"); - ddraw_hwnd = h; - - video_setblit(blit_memtoscreen); - - return 1; -} - - -void ddraw_fs_close(void) -{ - if (lpdds_back2) - { - lpdds_back2->Release(); - lpdds_back2 = NULL; - } - if (lpdds_back) - { - lpdds_back->Release(); - lpdds_back = NULL; - } - if (lpdds_pri) - { - lpdds_pri->Release(); - lpdds_pri = NULL; - } - if (lpdd_clipper) - { - lpdd_clipper->Release(); - lpdd_clipper = NULL; - } - if (lpdd7) - { - lpdd7->Release(); - lpdd7 = NULL; - } -} - - -int -ddraw_fs_pause(void) -{ - return(0); -} - - -void ddraw_fs_take_screenshot(wchar_t *fn) -{ - ddraw_common_take_screenshot(fn, lpdds_back2); -} diff --git a/src/win/win_png.c b/src/win/win_png.c new file mode 100644 index 000000000..61fb1e57f --- /dev/null +++ b/src/win/win_png.c @@ -0,0 +1,508 @@ +/* + * 86Box A hypervisor and IBM PC system emulator that specializes in + * running old operating systems and software designed for IBM + * PC systems and compatibles from 1981 through fairly recent + * system designs based on the PCI bus. + * + * This file is part of the 86Box distribution. + * + * Simple PNG image file format handler. + * + * Adapted for use with 86Box. Writing of (very basic) PNG + * image files, mostly intended to be used for creating + * screenshots. We only support sRGB format (3-byte pixel + * data) with a color depth of 8 bits per sample- so, 24bpp. + * + * NOTES: This is a stripped-down version of my full library for PNG + * image file format support. All the 'reading' code has been + * removed, and some other stuff we don't need in 86Box. + * + * TODO: Compression is currently not supported, until I figure out + * how ZLIB works so I can interface with it here. + * + * Version: @(#)win_png.c 1.0.1 2017/11/11 + * + * Author: Fred N. van Kempen, + * + * Copyright 2017 Fred N. van Kempen. + */ +#include +#include +#include +#include +#include "../86Box.h" +#include "../plat.h" +#include "win_png.h" + + +#ifdef CRC_DYNAMIC +static uint32_t crc_table[256]; +static int crc_tblok = 0; + + +/* Pre-calculate the CRC table. */ +static void +crc_create(void) +{ + uint32_t crc; + int i, k; + + for (i=0; i<256; i++) { + crc = (uint32_t)i; + for (k=0; k<8; k++) { + if (crc & 1) + crc = 0xedb88320UL ^ (crc >> 1); + else + crc >>= 1; + } + crc_table[i] = crc; + } + + crc_tblok = 1; +} + + +#else +static uint32_t crc_table[256] = { + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, + 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, + 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, + 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, + 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, + 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, + 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, + 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, + 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, + 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, + 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, + 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, + 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, + 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, + 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, + 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, + 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, + 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, + 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, + 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, + 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, + 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, + 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, + 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, + 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, + 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, + 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, + 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, + 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, + 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, + 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, + 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, + 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, + 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, + 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, + 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, + 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, + 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, + 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, + 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, + 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, + 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, + 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, + 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, + 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, + 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, + 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, + 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, + 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, + 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, + 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, + 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, + 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, + 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, + 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, + 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, + 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, + 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d +}; +#endif + + +/* Standard Network CRC32. */ +static uint32_t +crc_upd(uint32_t crc, uint8_t *bufp, int buflen) +{ + int i; + +#ifdef CRC_DYNAMIC + if (! crc_tblok) + crc_create(); +#endif + + for (i=0; i> 8); + + return(crc); +} + + +static uint32_t +crc_init(void) +{ + return(0xffffffffUL); +} + + +static uint32_t +crc_finish(uint32_t crc) +{ + return(crc ^ 0xffffffffUL); +} + + +/* Perform CRC over the compressed data. */ +static uint32_t +png_dcrc(uint32_t state, const uint8_t *bufp, uint32_t buflen) +{ + uint16_t s1, s2; + uint32_t i; + + s1 = (uint16_t)(state & 0xffff); + s2 = (uint16_t)(state >> 16); + + for (i=0; ifp) != sizeof(buff)) { + pclog("PNG(%ls): could not write trailer chunk!\n", png->name); + return(-1); + } + + /* All is good! */ + return(0); +} + + +/* Write an IDAT chunk header to the file. */ +static uint32_t +png_wridat(png_t *png, uint32_t pixels) +{ + uint8_t buff[10]; + uint32_t cnt; + int i, fluff; + + /* + * We must know the size of the chunk we are about to write, + * and that is not straightforward. If compression is enabled, + * we won't know until we're done with the chunk, so we would + * have to just write a dummy, and then go back afterwards and + * fix up the chunk size. + * + * Without compression, we could do the same, or we can do some + * calculations on how much data we expect to generate, and use + * that. For now, we'll go with the latter option. + */ + cnt = png->lwidth; /* bytes per scanline */ + cnt += 1; /* filter type per line */ + cnt *= (pixels/png->width); /* number of full lines */ + cnt += (pixels%png->width); /* number of pixels */ + + /* + * We now have the total number of pixel bytes to write. + * + * All that is left is adding the expected overhead (since we + * are dealing with fixed-size blocks and their headers) and + * that should give us the grand total.. + */ + i = (cnt / DEFL_MAX_BLKSZ); /* number of full blocks */ + if ((cnt % DEFL_MAX_BLKSZ) != 0) i++; /* incomplete block */ + cnt += (i * 5); /* block header is 5 bytes */ + + /* + * We are not using compression, so we must account for + * the extra data we insert to fake that. Below you will + * see the two DEFLATE bytes (this makes it look like a + * real deflate stream.) Upon closing, we also add the + * four compressed-data CRC bytes, so, a total of 6. + */ + fluff = 6; + + i = 0; + png_putlong(&buff[i], cnt+fluff, &i); /* IDAT chunk */ + memcpy(&buff[i], "IDAT", 4); i += 4; + buff[i++] = 0x08; /* deflate data: zlib */ + buff[i++] = 0x1d; /* zlib method number */ + if (fwrite(buff, 1, i, png->fp) != i) { + pclog("PNG(%ls): unable to write IDAT header!\n", png->name); + png_close(png); + return(-1); + } + + /* Initialize IDAT CRC. */ + png->crc = crc_upd(png->crc, &buff[4], i-4); + + /* Initialize for writing data. */ + png->bufcnt = 0; /* no data in buffer */ + + return(cnt); +} + + +/* + * API: Write (more) data to the PNG file. + * + * To keep things semi-simple, we generate a single IDAT + * chunk for each write. So, if the application calls us + * with the entire image, we have one IDAT. If it calls + * us multiple times (for example, once per scanline), we + * get one IDAT per scanline. + */ +int +png_write(png_t *png, uint8_t *bitmap, uint32_t pixels) +{ + uint8_t buff[10]; + uint32_t cnt, n; + uint16_t s; + int i; + + /* Do they want to close up? */ + if (bitmap == NULL && pixels == 0) { + i = png_wriend(png); + return(i); + } + + if (png->line >= png->height) { + pclog("PNG(%ls): cannot write %u pixels!\n", png->name, pixels); + png_close(png); + return(-1); + } + + /* Start a new IDAT chunk. */ + cnt = png_wridat(png, pixels); + + /* Loop, writing all pixels to the file. */ + while (cnt > 0) { + if (png->bufcnt == 0) { + /* + * Initialize a new block header. + * + * Bit0: LastBlock + * Bits[2:1]: compression type (00=stored) + * Len: block size (MSB) + * Nlen: block size, negated (MSB) + */ + s = (cnt < DEFL_MAX_BLKSZ) ? cnt : DEFL_MAX_BLKSZ; + i = 0; + buff[i++] = (cnt <= DEFL_MAX_BLKSZ) ? 1:0; + buff[i++] = ((s >> 8) & 0xff); + buff[i++] = (s & 0xff); + buff[i++] = ((s >> 8) ^ 0xff); + buff[i++] = (s ^ 0xff); + if (fwrite(buff, 1, i, png->fp) != i) { + pclog("PNG(%ls): block header write failed!\n", + png->name); + png_close(png); + return(-1); + } + png->crc = crc_upd(png->crc, buff, i); + cnt -= i; + } + + if (png->col == 0) { + /* Beginning of line, write filter method. */ + buff[0] = 0x00; + if (fwrite(buff, 1, 1, png->fp) != 1) { + pclog("PNG(%ls): cannot write filter?!\n", png->name); + png_close(png); + return(-1); + } + png->crc = crc_upd(png->crc, buff, 1); + png->dcrc = png_dcrc(png->dcrc, buff, 1); + png->bufcnt++; + cnt--; + } + + /* See how many pixels we can write for this scanline. */ + n = cnt; + if ((png->lwidth - png->col) < n) + n = (png->lwidth - png->col); + if ((DEFL_MAX_BLKSZ - png->bufcnt) < n) + n = (DEFL_MAX_BLKSZ - png->bufcnt); + + /* Write the pixel data for this block. */ + if (fwrite(bitmap, 1, n, png->fp) != n) { + pclog("PNG(%ls): cannot write pixeldata?!\n", png->name); + png_close(png); + return(-1); + } + + /* Update the CRCs for these pixels. */ + png->crc = crc_upd(png->crc, bitmap, n); + png->dcrc = png_dcrc(png->dcrc, bitmap, n); + + /* Update stats. */ + bitmap += n; + png->bufcnt += n; + if (png->bufcnt == DEFL_MAX_BLKSZ) + png->bufcnt = 0; + cnt -= n; + + png->col += n; + if (png->col == png->lwidth) { + png->col = 0; + if (++png->line == png->height) { + if (cnt > 0) { + pclog("PNG(%ls): done, more data?!\n", + png->name); + png_close(png); + return(-1); + } + } + } + } + + /* Write the CRCs. */ + i = 0; + png_putlong(buff, png->dcrc, &i); + png->crc = crc_finish(crc_upd(png->crc, buff, i)); + png_putlong(&buff[i], png->crc, &i); + if (fwrite(buff, 1, i, png->fp) != i) { + pclog("PNG(%ls): cannot write IDAT trailer?!\n", png->name); + png_close(png); + return(-1); + } + + return(0); +} + + +/* Write an unsigned long 32bit value in MSB. */ +void +png_putlong(uint8_t *ptr, uint32_t val, int *off) +{ + *ptr++ = (val >> 24) & 0xff; + *ptr++ = (val >> 16) & 0xff; + *ptr++ = (val >> 8) & 0xff; + *ptr = val & 0xff; + + if (off != NULL) + *off += sizeof(uint32_t); +} + + +/* API: Close the current PNG file. */ +void +png_close(png_t *png) +{ + if (png->fp != NULL) { + fflush(png->fp); + (void)fclose(png->fp); + + free(png); + } +} + + +/* API: Create a new PNG file. */ +png_t * +png_create(wchar_t *fn, int width, int height, int bpp) +{ + uint8_t buff[33]; + uint32_t crc; + png_t *png; + int i; + + /* Make sure we can do this. */ + if ((bpp != 24) || + (width<=0 || width >= 65536) || + (height<=0 || height >= 65536)) { + pclog("PNG(%ls): invalid image parameters!\n", fn); + return(NULL); + } + + /* Allocate the control block. */ + png = (png_t *)malloc(sizeof(png_t)); + if (png == NULL) { + pclog("PNG(%ls): out of memory!\n", fn); + return(NULL); + } + memset(png, 0x00, sizeof(png_t)); + png->name = fn; + png->width = width; /* width, in pixels */ + png->height = height; /* height, in pixels */ + png->bpp = bpp; /* total bits per pixel */ + png->ctype = PNG_COLOR_TYPE; /* 02 - sRBG */ + png->cdepth = (bpp/3); /* bits per color sample */ + png->pwidth = (bpp/8); /* bytes per pixel */ + png->lwidth = (png->pwidth*width); /* line width in bytes */ + png->crc = crc_init(); /* initialize data CRC */ + png->dcrc = 1; /* compressed-data CRC */ + + /* Create the data file. */ + if ((png->fp = plat_fopen(fn, L"wb")) == NULL) { + pclog("PNG(%ls): unable to create file!\n", fn); + png_close(png); + return(NULL); + } + + /* Write out the basic header chunks. */ + i = 0; + buff[i++] = 0x89; /* standard PNG header */ + memcpy(&buff[i], "PNG", 3); i += 3; + buff[i++] = 0x0d; buff[i++] = 0x0a; + buff[i++] = 0x1a; buff[i++] = 0x0a; + + png_putlong(&buff[i], 13, &i); /* IHDR chunk */ + memcpy(&buff[i], "IHDR", 4); i += 4; + png_putlong(&buff[i], png->width, &i); /* width */ + png_putlong(&buff[i], png->height, &i); /* height */ + buff[i++] = png->cdepth; /* color depth (per color) */ + buff[i++] = png->ctype; /* color type (2=RGB) */ + buff[i++] = PNG_COMPRESSION_TYPE; /* compression (0=deflate) */ + buff[i++] = PNG_FILTER_TYPE; /* filter (0=adaptive) */ + buff[i++] = PNG_INTERLACE_MODE; /* interlace (0=none) */ + crc = crc_finish(crc_upd(crc_init(), &buff[12], 17)); + png_putlong(&buff[i], crc, &i); + if (fwrite(buff, 1, i, png->fp) != i) { + pclog("PNG(%ls): unable to write PNG header!\n", fn); + png_close(png); + return(NULL); + } + + i = 4; + memcpy(&buff[i], "tEXt", 4); i += 4; + memcpy(&buff[i], "Software", 8); i+= 8; + buff[i++] = 0x00; + memcpy(&buff[i], "86Box PNGlib", 12); i+= 12; + png_putlong(buff, i-8, NULL); + crc = crc_finish(crc_upd(crc_init(), &buff[4], i-4)); + png_putlong(&buff[i], crc, &i); + if (fwrite(buff, 1, i, png->fp) != i) { + pclog("PNG(%ls): unable to write chunk header!\n", fn); + png_close(png); + return(NULL); + } + + return(png); +} diff --git a/src/win/win_png.h b/src/win/win_png.h new file mode 100644 index 000000000..0cafdf5c8 --- /dev/null +++ b/src/win/win_png.h @@ -0,0 +1,66 @@ +/* + * 86Box A hypervisor and IBM PC system emulator that specializes in + * running old operating systems and software designed for IBM + * PC systems and compatibles from 1981 through fairly recent + * system designs based on the PCI bus. + * + * This file is part of the 86Box distribution. + * + * Definitions for the Simple PNG image file format handler. + * + * Version: @(#)win_png.h 1.0.1 2017/11/11 + * + * Author: Fred N. van Kempen, + * + * Copyright 2017 Fred N. van Kempen. + */ +#ifndef WIN_PNG_H +# define WIN_PNG_H + + +/* PNG defintions, as per the specification. */ +#define PNG_COLOR_TYPE 0x02 /* 3-sample sRGB */ +#define PNG_COMPRESSION_TYPE 0x00 /* deflate compression */ +#define PNG_FILTER_TYPE 0x00 /* no filtering */ +#define PNG_INTERLACE_MODE 0x00 /* no interlacing */ + +/* DEFLATE definition, as per RFC1950/1 specification. */ +#define DEFL_MAX_BLKSZ 65535 /* DEFLATE max block size */ + + +typedef struct { + wchar_t *name; /* name of datafile */ + FILE *fp; + + uint16_t width, /* configured with in pixels */ + height; /* configured with in pixels */ + uint8_t bpp, /* configured bits per pixel */ + ctype; /* configured color type */ + + uint16_t col, /* current column */ + line, /* current scanline */ + lwidth; /* line width in bytes */ + uint8_t cdepth, /* color depth in bits */ + pwidth; /* bytes per pixel */ + uint32_t crc; /* idat chunk crc */ + uint32_t dcrc; /* deflate data crc */ + + uint32_t bufcnt; /* #bytes in block */ +} png_t; + + +#ifdef __cplusplus +extern "C" { +#endif + +extern void png_putlong(uint8_t *ptr, uint32_t val, int *off); +extern void png_close(png_t *png); +extern png_t *png_create(wchar_t *fn, int width, int height, int bpp); +extern int png_write(png_t *png, uint8_t *bitmap, uint32_t pixels); + +#ifdef __cplusplus +} +#endif + + +#endif /*WIN_PNG_H*/ diff --git a/src/win/win_video.c b/src/win/win_video.c index 044c59614..cdb4014b0 100644 --- a/src/win/win_video.c +++ b/src/win/win_video.c @@ -8,7 +8,7 @@ * * Platform video API support for Win32. * - * Version: @(#)win_video.c 1.0.5 2017/11/11 + * Version: @(#)win_video.c 1.0.6 2017/11/12 * * Author: Fred N. van Kempen, * @@ -68,7 +68,7 @@ static struct { #endif }, { - { "DDraw", 1, (int(*)(void*))ddraw_fs_init, ddraw_fs_close, NULL, ddraw_fs_pause }, + { "DDraw", 1, (int(*)(void*))ddraw_init_fs, ddraw_close, NULL, ddraw_pause }, { "D3D", 1, (int(*)(void*))d3d_fs_init, d3d_fs_close, NULL, d3d_fs_pause }, #ifdef USE_VNC { "VNC", 0, vnc_init, vnc_close, vnc_resize, vnc_pause }, @@ -84,20 +84,6 @@ static struct { }; -#if 0 - /* Initialize the rendering window, or fullscreen. */ - if (start_in_fullscreen) { - startblit(); - vid_apis[0][vid_api].close(); - video_fullscreen = 1; - vid_apis[1][vid_api].init(hwndRender); - leave_fullscreen_flag = 0; - endblit(); - device_force_redraw(); - } -#endif - - /* Return the VIDAPI number for the given name. */ int plat_vidapi(char *name) @@ -273,10 +259,7 @@ take_screenshot(void) case 0: /* ddraw */ wcsftime(path, 128, L"%Y%m%d_%H%M%S.bmp", info); wcscat(path, fn); - if (video_fullscreen) - ddraw_fs_take_screenshot(path); - else - ddraw_take_screenshot(path); + ddraw_take_screenshot(path); pclog("Screenshot: fn='%ls'\n", path); break;