Mercurial > sdl-ios-xcode
changeset 4569:e1664f94f026
Andrey A.
I made a video driver GAPI/RAW for WinCE (SDL-1.3).
RAW mode has a priority, and also, GAPI mode works with environment
"SDL_VIDEO_RENDERER=gapi" and for RAW mode "SDL_VIDEO_RENDERER=raw".
I checked the work on the screens of VGA, WVGA, QVGA, WQVGA, HVGA,
+ tested all modes with WindowsMobile Emulator.
Also, correctly draws the pointer position and the scale of the pointer
for VGA/WVGA modes,
correctly draws top left position for DM orientation screen, and
portrait/landscape/square geometry the screen also correct.
Also, I added a small fix for GDI fullscreen mode.
Patch for latest revision SDL-1.3 in an attachment.
Also added small path for mingw32ce build.
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Tue, 27 Jul 2010 21:31:28 -0700 |
| parents | 25b9cd8bdc30 |
| children | 844b5ef4b149 |
| files | configure.in src/video/SDL_sysvideo.h src/video/SDL_video.c src/video/win32/SDL_ceddrawrender.c src/video/win32/SDL_d3drender.c src/video/win32/SDL_gapirender.c src/video/win32/SDL_gapirender.h src/video/win32/SDL_gapirender_c.h src/video/win32/SDL_gdirender.c src/video/win32/SDL_win32clipboard.c src/video/win32/SDL_win32events.c src/video/win32/SDL_win32modes.c src/video/win32/SDL_win32video.c src/video/win32/SDL_win32video.h src/video/win32/SDL_win32window.c src/video/win32/SDL_win32window.h |
| diffstat | 16 files changed, 1317 insertions(+), 731 deletions(-) [+] |
line wrap: on
line diff
--- a/configure.in Fri Jul 23 21:33:00 2010 -0700 +++ b/configure.in Tue Jul 27 21:31:28 2010 -0700 @@ -1917,7 +1917,7 @@ AC_MSG_CHECKING(Windows CE) have_wince=no AC_TRY_COMPILE([ -#ifndef _WIN32_WCE +#if !defined(_WIN32_WCE) && !defined(__MINGW32CE__) #error This is not Windows CE #endif ],[ @@ -2388,6 +2388,12 @@ SOURCES="$SOURCES $srcdir/src/atomic/win32/*.c" have_atomic=yes fi + # Set up dummy files for the joystick for now + if test x$enable_joystick = xyes; then + AC_DEFINE(SDL_JOYSTICK_DUMMY) + SOURCES="$SOURCES $srcdir/src/joystick/dummy/*.c" + have_joystick=yes + fi # Set up files for the thread library if test x$enable_threads = xyes; then AC_DEFINE(SDL_THREAD_WIN32) @@ -2411,10 +2417,20 @@ fi # Set up the system libraries we need EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lcoredll -lcommctrl -lmmtimer" + + # mingw32ce library + case "$host" in + *-mingw32ce) + EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lmingwex" + ;; + *) + ;; + esac + # The Win32 platform requires special setup SDLMAIN_SOURCES="$srcdir/src/main/win32/*.c" - SDL_CFLAGS="$SDL_CFLAGS -Dmain=SDL_main -D_WIN32_WCE=0x420" - SDL_LIBS="-lSDLmain $SDL_LIBS" + EXTRA_CFLAGS="$EXTRA_CFLAGS -Dmain=SDL_main -D_WIN32_WCE=0x420" + EXTRA_LDFLAGS="-lSDLmain $EXTRA_LDFLAGS" ;; *-*-cygwin* | *-*-mingw32*) ARCH=win32
--- a/src/video/SDL_sysvideo.h Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/SDL_sysvideo.h Tue Jul 27 21:31:28 2010 -0700 @@ -387,9 +387,6 @@ #if SDL_VIDEO_DRIVER_SVGALIB extern VideoBootStrap SVGALIB_bootstrap; #endif -#if SDL_VIDEO_DRIVER_GAPI -extern VideoBootStrap GAPI_bootstrap; -#endif #if SDL_VIDEO_DRIVER_WIN32 extern VideoBootStrap WIN32_bootstrap; #endif
--- a/src/video/SDL_video.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/SDL_video.c Tue Jul 27 21:31:28 2010 -0700 @@ -67,9 +67,6 @@ #if SDL_VIDEO_DRIVER_SVGALIB &SVGALIB_bootstrap, #endif -#if SDL_VIDEO_DRIVER_GAPI - &GAPI_bootstrap, -#endif #if SDL_VIDEO_DRIVER_WIN32 &WIN32_bootstrap, #endif
--- a/src/video/win32/SDL_ceddrawrender.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_ceddrawrender.c Tue Jul 27 21:31:28 2010 -0700 @@ -459,6 +459,8 @@ } data->ddraw = videodata->ddraw; + videodata->render = RENDER_DDRAW; + renderer->DisplayModeChanged = DDRAW_DisplayModeChanged; renderer->CreateTexture = DDRAW_CreateTexture; renderer->QueryTexturePixels = DDRAW_QueryTexturePixels;
--- a/src/video/win32/SDL_d3drender.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_d3drender.c Tue Jul 27 21:31:28 2010 -0700 @@ -451,6 +451,8 @@ } data->d3d = videodata->d3d; + videodata->render = RENDER_D3D; + renderer->DisplayModeChanged = D3D_DisplayModeChanged; renderer->CreateTexture = D3D_CreateTexture; renderer->QueryTexturePixels = D3D_QueryTexturePixels;
--- a/src/video/win32/SDL_gapirender.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_gapirender.c Tue Jul 27 21:31:28 2010 -0700 @@ -1,670 +1,1281 @@ -/* - SDL - Simple DirectMedia Layer - Copyright (C) 1997-2010 Sam Lantinga - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. +/*************************************************************************** + * Copyright (C) 2010 by Andrey Afletdinov <afletdinov@gmail.com> * + * * + * WinCE RAW/GAPI video driver * + * * + * Part of the SDL - (Simple DirectMedia Layer) * + * http://www.libsdl.org * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - - Sam Lantinga - slouken@libsdl.org - - Stefan Klug - klug.stefan@gmx.de -*/ #include "SDL_config.h" #if SDL_VIDEO_RENDER_GAPI #include "SDL_win32video.h" -//#include "../SDL_sysvideo.h" +#include "SDL_win32window.h" #include "../SDL_yuv_sw_c.h" -#include "../SDL_renderer_sw.h" -#include "SDL_gapirender_c.h" - -#define GAPI_RENDERER_DEBUG 1 - -/* GAPI renderer implementation */ +// RawFrameBufferInfo +typedef struct +{ + WORD wFormat; + WORD wBPP; + VOID *pFramePointer; + int cxStride; + int cyStride; + int cxPixels; + int cyPixels; +} RawFrameBufferInfo; -static SDL_Renderer *GAPI_CreateRenderer(SDL_Window * window, Uint32 flags); -static int GAPI_RenderDrawPoints(SDL_Renderer * renderer, - const SDL_Point * points, int count); -static int GAPI_RenderDrawLines(SDL_Renderer * renderer, - const SDL_Point * points, int count); -static int GAPI_RenderDrawRects(SDL_Renderer * renderer, - const SDL_Rect ** rects, int count); -static int GAPI_RenderFillRects(SDL_Renderer * renderer, - const SDL_Rect ** rects, int count); -static int GAPI_RenderCopy(SDL_Renderer * renderer, - SDL_Texture * texture, - const SDL_Rect * srcrect, - const SDL_Rect * dstrect); -static void GAPI_RenderPresent(SDL_Renderer * renderer); -static void GAPI_DestroyRenderer(SDL_Renderer * renderer); +// GXDeviceInfo +typedef struct +{ + long Version; + void* pvFrameBuffer; + unsigned long cbStride; + unsigned long cxWidth; + unsigned long cyHeight; + unsigned long cBPP; + unsigned long ffFormat; + char unknown[0x84 - 7 * 4]; +} GXDeviceInfo; - -SDL_RenderDriver GAPI_RenderDriver = { - GAPI_CreateRenderer, - { - "gapi", - (SDL_RENDERER_SINGLEBUFFER), - } +// wince: GXDisplayProperties +struct GXDisplayProperties +{ + DWORD cxWidth; + DWORD cyHeight; + long cbxPitch; + long cbyPitch; + long cBPP; + DWORD ffFormat; }; -static HMODULE g_hGapiLib = 0; +// gx.dll +typedef int (*PFNGXOpenDisplay)(HWND hWnd, DWORD dwFlags); +typedef int (*PFNGXCloseDisplay)(); +typedef void* (*PFNGXBeginDraw)(); +typedef int (*PFNGXEndDraw)(); +typedef struct GXDisplayProperties (*PFNGXGetDisplayProperties)(); +typedef int (*PFNGXSuspend)(); +typedef int (*PFNGXResume)(); -// for testing with GapiEmu -#define USE_GAPI_EMU 0 -#define EMULATE_AXIM_X30 0 +typedef struct +{ + // gx.dll + HMODULE hGapiLib; + PFNGXOpenDisplay GXOpenDisplay; + PFNGXCloseDisplay GXCloseDisplay; + PFNGXBeginDraw GXBeginDraw; + PFNGXEndDraw GXEndDraw; + PFNGXGetDisplayProperties GXGetDisplayProperties; + PFNGXSuspend GXSuspend; + PFNGXResume GXResume; +} GapiInfo; + +//#ifndef DM_DISPLAYORIENTATION +//#define DM_DISPLAYORIENTATION 0x00800000L +//#endif + +#define FORMAT_565 1 +#define FORMAT_555 2 +#define FORMAT_OTHER 3 + +#define GETRAWFRAMEBUFFER 0x00020001 +#define GETGXINFO 0x00020000 + +#define kfPalette 0x10 +#define kfDirect 0x20 +#define kfDirect555 0x40 +#define kfDirect565 0x80 -#if 0 -#define GAPI_LOG(...) printf(__VA_ARGS__) -#else -#define GAPI_LOG(...) -#endif +#define GX_FULLSCREEN 0x01 + +enum ScreenOrientation { ORIENTATION_UNKNOWN = -1, ORIENTATION_UP = DMDO_0, ORIENTATION_DOWN = DMDO_180, ORIENTATION_LEFT = DMDO_270, ORIENTATION_RIGHT = DMDO_90 }; +enum ScreenGeometry { GEOMETRY_UNKNOWN, GEOMETRY_PORTRAIT, GEOMETRY_LANDSCAPE, GEOMETRY_SQUARE }; +enum FrameBufferFlags { FB_SKIP_OFFSET = 0x0001, FB_RAW_MODE = 0x0002, FB_SUSPENDED = 0x0004 }; + +// private framebuffer info +typedef struct +{ + int width; + int height; + int xpitch; + int ypitch; + int offset; +} FrameBufferInfo; +// private display data +typedef struct +{ + unsigned char* pixels; // video memory + int format; // video format + FrameBufferInfo fb; // framebuffer geometry + GapiInfo* gapi; // GAPI module + int userOrientation; + int systemOrientation; + int hardwareGeometry; + int flags; // fb flags + float scale; // scale pointer position + int debug; -#if USE_GAPI_EMU && !REPORT_VIDEO_INFO -#pragma message("Warning: Using GapiEmu in release build. I assume you'd like to set USE_GAPI_EMU to zero.") -#endif +} WINCE_RenderData; + +typedef struct +{ + SDL_SW_YUVTexture *yuv; + Uint32 format; + void *pixels; + int pitch; + +} WINCE_TextureData; -static void -GAPI_SetError(const char *prefix, HRESULT result) -{ - const char *error; +// system func +SDL_Renderer* WINCE_CreateRenderer(SDL_Window* window, Uint32 flags); +void WINCE_DestroyRenderer(SDL_Renderer* renderer); + +int WINCE_CreateTexture(SDL_Renderer* renderer, SDL_Texture* texture); +void WINCE_DestroyTexture(SDL_Renderer* renderer, SDL_Texture* texture); +int WINCE_QueryTexturePixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch); +int WINCE_UpdateTexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch); +int WINCE_LockTexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int dirty, void** pixels, int* pitch); +void WINCE_UnlockTexture(SDL_Renderer* renderer, SDL_Texture* texture); + +int WINCE_Available(void); +void WINCE_SetupOrientation(WINCE_RenderData* data, int width, int height); + +int WINCE_RenderCopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srect, const SDL_Rect* drect); +void WINCE_ShowWindow(_THIS, SDL_Window* window, int visible); + +void WINCE_RenderPresent(SDL_Renderer* renderer); +int WINCE_RenderDrawPoints(SDL_Renderer* renderer, const SDL_Point* points, int count); +int WINCE_RenderDrawLines(SDL_Renderer* renderer, const SDL_Point* points, int count); +int WINCE_RenderDrawRects(SDL_Renderer* renderer, const SDL_Rect ** rects, int count); +int WINCE_RenderFillRects(SDL_Renderer* renderer, const SDL_Rect** rects, int count); + +void WINCE_PointerCoordinateTransform(SDL_Window* window, POINT* pt); +void WINCE_DumpVideoInfo(WINCE_RenderData* data); +void WINCE_PortraitTransform(WINCE_RenderData* data, int width, int height); +void WINCE_LandscapeTransform(WINCE_RenderData* data, int width, int height); +void WINCE_SquareTransform(WINCE_RenderData* data, int width, int height); +int WINCE_FixedGeometry(FrameBufferInfo* fb, int bpp, int debug); +int WINCE_GetDMOrientation(void); +int WINCE_SetDMOrientation(int orientation); +void WINCE_UpdateYUVTextureData(SDL_Texture* texture); + +// gapi engine specific +int GAPI_Init(WINCE_RenderData* data, HWND hwnd); +void GAPI_Quit(WINCE_RenderData* data); + +// raw engine specific +int RAW_Init(WINCE_RenderData* data); +void RAW_Quit(WINCE_RenderData* data); + +// tools +void FrameBufferRotate(FrameBufferInfo* src, int orientation); +int GetFrameBufferOrientation(const FrameBufferInfo* src); +void PointerRotate(POINT* pt, const FrameBufferInfo* fb, int orientation); +void FrameBufferInitialize(FrameBufferInfo* fb); +void FrameBufferDumpInfo(const FrameBufferInfo* fb, const char*); +const char* GetOrientationName(int orientation); +void UpdateLine16to16(const FrameBufferInfo* fb, const Uint16* src, Uint16* dst, Uint16 width); + +// stdlib +inline int __abs(int x){ return x < 0 ? -x : x; }; +inline void __swap(int* a, int* b){ int t = *a; *a = *b; *b = t; }; - switch (result) { - default: - error = "UNKNOWN"; - break; +#define GAPI_RENDER_NAME "gapi" +#define RAW_RENDER_NAME "raw" +// +SDL_RenderDriver GAPI_RenderDriver = { + WINCE_CreateRenderer, + { + GAPI_RENDER_NAME, + (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD), + (SDL_TEXTUREMODULATE_NONE), + (SDL_BLENDMODE_NONE), + (SDL_TEXTURESCALEMODE_NONE), + 7, + { + SDL_PIXELFORMAT_RGB555, + SDL_PIXELFORMAT_RGB565, + SDL_PIXELFORMAT_YV12, + SDL_PIXELFORMAT_IYUV, + SDL_PIXELFORMAT_YUY2, + SDL_PIXELFORMAT_UYVY, + SDL_PIXELFORMAT_YVYU + }, + 0, + 0 } - SDL_SetError("%s: %s", prefix, error); +}; + +SDL_RenderDriver RAW_RenderDriver = { + WINCE_CreateRenderer, + { + RAW_RENDER_NAME, + (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD), + (SDL_TEXTUREMODULATE_NONE), + (SDL_BLENDMODE_NONE), + (SDL_TEXTURESCALEMODE_NONE), + 7, + { + SDL_PIXELFORMAT_RGB555, + SDL_PIXELFORMAT_RGB565, + SDL_PIXELFORMAT_YV12, + SDL_PIXELFORMAT_IYUV, + SDL_PIXELFORMAT_YUY2, + SDL_PIXELFORMAT_UYVY, + SDL_PIXELFORMAT_YVYU + }, + 0, + 0 + } +}; + +int WINCE_Available(void) +{ + const char* preferably = SDL_getenv("SDL_VIDEO_RENDERER"); + + // raw check + RawFrameBufferInfo rfbi = { 0 }; + HDC hdc = GetDC(NULL); + int render_raw = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char *) &rfbi); + ReleaseDC(NULL, hdc); + + if(render_raw != 0 && rfbi.cxPixels != 0 && rfbi.cyPixels != 0 && + rfbi.pFramePointer != 0 && rfbi.cxStride != 0 && rfbi.cyStride != 0) + render_raw = 1; + + if(preferably && 0 == SDL_strcasecmp(preferably, RAW_RENDER_NAME)) return 0 != render_raw; + + // gapi check + HMODULE render_gapi = LoadLibrary(TEXT("\\Windows\\gx.dll")); + if(0 == render_gapi) + render_gapi = LoadLibrary(TEXT("gx.dll")); + FreeLibrary(render_gapi); + + if(preferably && 0 == SDL_strcasecmp(preferably, GAPI_RENDER_NAME)) return 0 != render_gapi; + + return 0 != render_raw || 0 != render_gapi; } -void -GAPI_AddRenderDriver(_THIS) +void WINCE_AddRenderDriver(_THIS) { - int i; + HDC hdc; + HMODULE render_gapi; + int render_raw, ii; + const char* preferably = SDL_getenv("SDL_VIDEO_RENDERER"); - /* TODO: should we check for support of GetRawFramebuffer here? - */ -#if USE_GAPI_EMU - g_hGapiLib = LoadLibrary(L"GAPI_Emu.dll"); -#else - g_hGapiLib = LoadLibrary(L"\\Windows\\gx.dll"); -#endif + // raw check + RawFrameBufferInfo rfbi = { 0 }; + hdc = GetDC(NULL); + render_raw = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char *) &rfbi); + ReleaseDC(NULL, hdc); - if (g_hGapiLib) { -#define LINK(name,import) gx.name = (PFN##name)GetProcAddress( g_hGapiLib, L##import ); + if(render_raw != 0 && rfbi.cxPixels != 0 && rfbi.cyPixels != 0 && + rfbi.pFramePointer != 0 && rfbi.cxStride != 0 && rfbi.cyStride != 0) + render_raw = 1; - LINK(GXOpenDisplay, "?GXOpenDisplay@@YAHPAUHWND__@@K@Z") - LINK(GXCloseDisplay, "?GXCloseDisplay@@YAHXZ") - LINK(GXBeginDraw, "?GXBeginDraw@@YAPAXXZ") - LINK(GXEndDraw, "?GXEndDraw@@YAHXZ") - LINK(GXOpenInput, "?GXOpenInput@@YAHXZ") - LINK(GXCloseInput, "?GXCloseInput@@YAHXZ") - LINK(GXGetDisplayProperties, - "?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ") - LINK(GXGetDefaultKeys, "?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z") - LINK(GXSuspend, "?GXSuspend@@YAHXZ") - LINK(GXResume, "?GXResume@@YAHXZ") - LINK(GXSetViewport, "?GXSetViewport@@YAHKKKK@Z") - LINK(GXIsDisplayDRAMBuffer, "?GXIsDisplayDRAMBuffer@@YAHXZ") + // gapi check + render_gapi = LoadLibrary(TEXT("\\Windows\\gx.dll")); + if(0 == render_gapi) + render_gapi = LoadLibrary(TEXT("gx.dll")); + + if(render_gapi) + FreeLibrary(render_gapi); - /* wrong gapi.dll */ - if (!gx.GXOpenDisplay) { - FreeLibrary(g_hGapiLib); - g_hGapiLib = 0; - } -#undef LINK - } - - for (i = 0; i < _this->num_displays; ++i) { - SDL_AddRenderDriver(&_this->displays[i], &GAPI_RenderDriver); + for(ii = 0; ii < _this->num_displays; ++ii) + { + if(preferably) + { + if(0 == SDL_strcasecmp(preferably, RAW_RENDER_NAME) && render_raw) + SDL_AddRenderDriver(&_this->displays[ii], &RAW_RenderDriver); + else + if(0 == SDL_strcasecmp(preferably, GAPI_RENDER_NAME) && render_gapi) + SDL_AddRenderDriver(&_this->displays[ii], &GAPI_RenderDriver); + } + else + { + if(render_raw) + SDL_AddRenderDriver(&_this->displays[ii], &RAW_RenderDriver); + if(render_gapi) + SDL_AddRenderDriver(&_this->displays[ii], &GAPI_RenderDriver); + } } } -typedef enum -{ - USAGE_GX_FUNCS = 0x0001, /* enable to use GXOpen/GXClose/GXBeginDraw... */ - USAGE_DATA_PTR_CONSTANT = 0x0002 /* the framebuffer is at a constant location, don't use values from GXBeginDraw() */ -} GAPI_UsageFlags; - - - -typedef struct -{ - int w; - int h; - int xPitch; /* bytes to move to go to the next pixel */ - int yPitch; /* bytes to move to go to the next line */ - int offset; /* data offset, to add to the data returned from GetFramebuffer, before processing */ - - void *data; - Uint32 usageFlags; /* these flags contain options to define screen handling and to reliably workarounds */ - - Uint32 format; /* pixel format as defined in SDL_pixels.h */ - -} GAPI_RenderData; - - -static Uint32 -GuessPixelFormatFromBpp(int bpp) +SDL_Renderer* WINCE_CreateRenderer(SDL_Window* window, Uint32 flags) { - switch (bpp) { - case 15: - return SDL_PIXELFORMAT_RGB555; - case 16: - return SDL_PIXELFORMAT_RGB565; - default: - return SDL_PIXELFORMAT_UNKNOWN; - break; - } -} + SDL_VideoDisplay* display = window->display; + SDL_DisplayMode* displayMode = &display->current_mode; + SDL_WindowData* windowdata = (SDL_WindowData *) window->driverdata; + SDL_Renderer* renderer; + WINCE_RenderData* data; + int bpp; + Uint32 Rmask, Gmask, Bmask, Amask; -static GAPI_RenderData * -FillRenderDataRawFramebuffer(SDL_Window * window) -{ - RawFrameBufferInfo rbi; - GAPI_RenderData *renderdata; - HDC hdc; + if(!(window->flags & SDL_WINDOW_FULLSCREEN)) + window->flags |= SDL_WINDOW_FULLSCREEN; - //TODO should we use the hdc of the window? - hdc = GetDC(NULL); - int result = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, - sizeof(RawFrameBufferInfo), - (char *) &rbi); - ReleaseDC(NULL, hdc); - - if (!(result > 0)) { + if(!SDL_PixelFormatEnumToMasks(displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) + { + SDL_SetError("Unknown display format"); return NULL; } - /* Asus A696 returns wrong results so we do a sanity check - See: - http://groups.google.com/group/microsoft.public.smartphone.developer/browse_thread/thread/4fde5bddd477de81 - */ - if (rbi.cxPixels <= 0 || - rbi.cyPixels <= 0 || - rbi.cxStride == 0 || rbi.cyStride == 0 || rbi.pFramePointer == 0) { - return NULL; + switch(window->fullscreen_mode.format) + { + case SDL_PIXELFORMAT_RGB555: + case SDL_PIXELFORMAT_RGB565: + break; + + default: + SDL_SetError("Support only 16 or 15 bpp"); + return NULL; } - - renderdata = (GAPI_RenderData *) SDL_calloc(1, sizeof(*renderdata)); - if (!renderdata) { + renderer = (SDL_Renderer*) SDL_calloc(1, sizeof(SDL_Renderer)); + if(!renderer) + { SDL_OutOfMemory(); return NULL; } - //Try to match the window size - //TODO add rotation support - if (rbi.cxPixels != window->w || rbi.cyPixels != window->h) { - SDL_free(renderdata); - return NULL; - } - //Check that the display uses a known display format - switch (rbi.wFormat) { - case FORMAT_565: - renderdata->format = SDL_PIXELFORMAT_RGB565; - break; - case FORMAT_555: - renderdata->format = SDL_PIXELFORMAT_RGB555; - break; - default: - //TODO we should add support for other formats - SDL_free(renderdata); - return NULL; - } - renderdata->usageFlags = USAGE_DATA_PTR_CONSTANT; - renderdata->data = rbi.pFramePointer; - renderdata->w = rbi.cxPixels; - renderdata->h = rbi.cyPixels; - renderdata->xPitch = rbi.cxStride; - renderdata->yPitch = rbi.cyStride; - - return renderdata; - -} - - -static GAPI_RenderData * -FillRenderDataGAPI(SDL_Window * window) -{ - GAPI_RenderData *renderdata; - struct GXDisplayProperties gxdp; - int tmp; - -#ifdef _ARM_ - WCHAR oemstr[100]; -#endif - - if (!g_hGapiLib) { - return NULL; - } - - renderdata = (GAPI_RenderData *) SDL_calloc(1, sizeof(GAPI_RenderData)); - if (!renderdata) { + data = (WINCE_RenderData*) SDL_calloc(1, sizeof(WINCE_RenderData)); + if(!data) + { + WINCE_DestroyRenderer(renderer); SDL_OutOfMemory(); return NULL; } - gxdp = gx.GXGetDisplayProperties(); - renderdata->usageFlags = USAGE_GX_FUNCS; - renderdata->w = gxdp.cxWidth; - renderdata->h = gxdp.cyHeight; - renderdata->xPitch = gxdp.cbxPitch; - renderdata->yPitch = gxdp.cbyPitch; - - //Check that the display uses a known display format - if (gxdp.ffFormat & kfDirect565) { - renderdata->format = SDL_PIXELFORMAT_RGB565; - } else if (gxdp.ffFormat & kfDirect555) { - renderdata->format = SDL_PIXELFORMAT_RGB555; - } else { - renderdata->format = SDL_PIXELFORMAT_UNKNOWN; - } - - /* apply some device specific corrections */ -#ifdef _ARM_ - SystemParametersInfo(SPI_GETOEMINFO, sizeof(oemstr), oemstr, 0); - - // buggy iPaq38xx - if ((oemstr[12] == 'H') && (oemstr[13] == '3') - && (oemstr[14] == '8') - && (gxdp.cbxPitch > 0)) { - renderdata->data = (void *) 0xac0755a0; - renderdata->xPitch = -640; - renderdata->yPitch = 2; - } -#if (EMULATE_AXIM_X30 == 0) - // buggy Dell Axim X30 - if (_tcsncmp(oemstr, L"Dell Axim X30", 13) == 0) -#endif + // initialize internal engine + if(!RAW_Init(data) && !GAPI_Init(data, windowdata->hwnd)) { - GXDeviceInfo gxInfo = { 0 }; - HDC hdc = GetDC(NULL); - int result; - - gxInfo.Version = 100; - result = - ExtEscape(hdc, GETGXINFO, 0, NULL, sizeof(gxInfo), - (char *) &gxInfo); - if (result > 0) { - renderdata->usageFlags = USAGE_DATA_PTR_CONSTANT; /* no more GAPI usage from now */ - renderdata->data = gxInfo.pvFrameBuffer; - this->hidden->needUpdate = 0; - renderdata->xPitch = 2; - renderdata->yPitch = 480; - renderdata->w = gxInfo.cxWidth; - renderdata->h = gxInfo.cyHeight; - - //Check that the display uses a known display format - switch (rbi->wFormat) { - case FORMAT_565: - renderdata->format = SDL_PIXELFORMAT_RGB565; - break; - case FORMAT_555: - renderdata->format = SDL_PIXELFORMAT_RGB555; - break; - default: - //TODO we should add support for other formats - SDL_free(renderdata); - return NULL; - } - } - } -#endif - - - if (renderdata->format == SDL_PIXELFORMAT_UNKNOWN) { - SDL_SetError("Gapi Pixelformat is unknown"); - SDL_free(renderdata); + WINCE_DestroyRenderer(renderer); return NULL; } - /* Gapi always returns values in standard orientation, so we manually apply - the current orientation - */ - DEVMODE settings; - SDL_memset(&settings, 0, sizeof(DEVMODE)); - settings.dmSize = sizeof(DEVMODE); - - settings.dmFields = DM_DISPLAYORIENTATION; - ChangeDisplaySettingsEx(NULL, &settings, NULL, CDS_TEST, NULL); - - if (settings.dmDisplayOrientation == DMDO_90) { - - tmp = renderdata->w; - renderdata->w = renderdata->h; - renderdata->h = tmp; - - tmp = renderdata->xPitch; - renderdata->xPitch = -renderdata->yPitch; - renderdata->yPitch = tmp; - - renderdata->offset = -renderdata->w * renderdata->xPitch; - - } else if (settings.dmDisplayOrientation == DMDO_180) { - - renderdata->xPitch = -renderdata->xPitch; - renderdata->yPitch = -renderdata->yPitch; + // set debug + data->debug = SDL_getenv("DEBUG_VIDEO_GAPI") || SDL_getenv("GAPI_RENDERER_DEBUG") ? 1 : 0; +#if defined(DEBUG_VIDEO_GAPI) || defined(GAPI_RENDERER_DEBUG) + data->debug = 1; +#endif - renderdata->offset = -renderdata->h * renderdata->yPitch - - renderdata->w * renderdata->xPitch; - - } else if (settings.dmDisplayOrientation == DMDO_270) { - - tmp = renderdata->w; - renderdata->w = renderdata->h; - renderdata->h = tmp; - - tmp = renderdata->xPitch; - renderdata->xPitch = renderdata->yPitch; - renderdata->yPitch = -tmp; + windowdata->videodata->render = data->gapi ? RENDER_GAPI : RENDER_RAW; + windowdata->videodata->CoordTransform = WINCE_PointerCoordinateTransform; - renderdata->offset = -renderdata->h * renderdata->yPitch; - - } + window->display->device->MaximizeWindow = NULL; + window->display->device->MinimizeWindow = NULL; - if (renderdata->w != window->w || renderdata->h != window->h) { - GAPI_LOG("GAPI open failed, wrong size %i %i %i %i\n", renderdata->w, - renderdata->h, renderdata->xPitch, renderdata->yPitch); - SDL_free(renderdata); - return NULL; - } - - return renderdata; - -} - + WINCE_SetupOrientation(data, window->w, window->h); -/* This function does the whole encapsulation of Gapi/RAWFRAMEBUFFER - it should handle all the device dependent details and fill the device INDEPENDENT - RenderData structure. - */ -GAPI_RenderData * -FillRenderData(SDL_Window * window) -{ - /* We try to match the requested window to the modes available by GAPI and RAWFRAMEBUFFER. - First RAWFRAMEBUFFER is tried, as it is the most reliable one - Look here for detailed discussions: - http://pdaphonehome.com/forums/samsung-i700/28087-just-saw.html - http://blogs.msdn.com/windowsmobile/archive/2007/08/13/have-you-migrated-to-directdraw-yet.aspx - */ - - GAPI_RenderData *res; - - res = FillRenderDataRawFramebuffer(window); - GAPI_LOG("FillRenderDataRawFramebuffer: %p\n", res); - if (res) { - return res; - } - //Now we try gapi - res = FillRenderDataGAPI(window); - GAPI_LOG("FillRenderDataGAPI: %p\n", res); - - return res; -} - -void * -GetFramebuffer() -{ - -} - + renderer->CreateTexture = WINCE_CreateTexture; + renderer->DestroyTexture = WINCE_DestroyTexture; + renderer->QueryTexturePixels = WINCE_QueryTexturePixels; + renderer->UpdateTexture = WINCE_UpdateTexture; + renderer->LockTexture = WINCE_LockTexture; + renderer->UnlockTexture = WINCE_UnlockTexture; -SDL_Renderer * -GAPI_CreateRenderer(SDL_Window * window, Uint32 flags) -{ - SDL_VideoDisplay *display = window->display; - SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata; - SDL_DisplayMode *displayMode = &display->current_mode; - SDL_Renderer *renderer; - GAPI_RenderData *data; - int i, n; - int bpp; - Uint32 Rmask, Gmask, Bmask, Amask; - - if (!(window->flags & SDL_WINDOW_FULLSCREEN)) { - SDL_SetError("Gapi supports only fullscreen windows"); - return NULL; - } - - if (!SDL_PixelFormatEnumToMasks - (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { - SDL_SetError("Unknown display format"); - return NULL; - } + renderer->RenderCopy = WINCE_RenderCopy; + renderer->DestroyRenderer = WINCE_DestroyRenderer; - renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer)); - if (!renderer) { - SDL_OutOfMemory(); - return NULL; - } + renderer->RenderPresent = WINCE_RenderPresent; + renderer->RenderDrawPoints = WINCE_RenderDrawPoints; + renderer->RenderDrawLines = WINCE_RenderDrawLines; + renderer->RenderDrawRects = WINCE_RenderDrawRects; + renderer->RenderFillRects = WINCE_RenderFillRects; - data = FillRenderData(window); - if (!data) { - GAPI_DestroyRenderer(renderer); - SDL_OutOfMemory(); - return NULL; - } + renderer->info = data->gapi ? GAPI_RenderDriver.info : RAW_RenderDriver.info; - renderer->RenderDrawPoints = GAPI_RenderDrawPoints; - renderer->RenderDrawLines = GAPI_RenderDrawLines; - renderer->RenderDrawRects = GAPI_RenderDrawRects; - renderer->RenderFillRects = GAPI_RenderFillRects; - renderer->RenderCopy = GAPI_RenderCopy; - renderer->RenderPresent = GAPI_RenderPresent; - renderer->DestroyRenderer = GAPI_DestroyRenderer; - renderer->info.name = GAPI_RenderDriver.info.name; - renderer->info.flags = 0; renderer->window = window; renderer->driverdata = data; - /* Gapi provides only a framebuffer so lets use software implementation */ - Setup_SoftwareRenderer(renderer); - -#ifdef GAPI_RENDERER_DEBUG - printf("Created gapi renderer\n"); - printf("use GX functions: %i\n", data->usageFlags & USAGE_GX_FUNCS); - printf("framebuffer is constant: %i\n", - data->usageFlags & USAGE_DATA_PTR_CONSTANT); - printf("w: %i h: %i\n", data->w, data->h); - printf("data ptr: %p\n", data->data); /* this can be 0 in case of GAPI usage */ - printf("xPitch: %i\n", data->xPitch); - printf("yPitch: %i\n", data->yPitch); - printf("offset: %i\n", data->offset); - printf("format: %x\n", data->format); -#endif - - if (data->usageFlags & USAGE_GX_FUNCS) { - if (gx.GXOpenDisplay(windowdata->hwnd, GX_FULLSCREEN) == 0) { - GAPI_DestroyRenderer(renderer); - return NULL; - } - } - return renderer; } -static int -GAPI_RenderDrawPoints(SDL_Renderer * renderer, - const SDL_Point * points, int count) +void WINCE_DestroyRenderer(SDL_Renderer* renderer) +{ + WINCE_RenderData *renderdata = (WINCE_RenderData*) renderer->driverdata; + + if(renderdata) + { + if(renderdata->gapi) + GAPI_Quit(renderdata); + else + RAW_Quit(renderdata); + + SDL_free(renderdata); + } + + SDL_free(renderer); +} + +int WINCE_CreateTexture(SDL_Renderer* renderer, SDL_Texture* texture) +{ + WINCE_TextureData* texturedata = (WINCE_TextureData*) SDL_calloc(1, sizeof(WINCE_TextureData)); + if(NULL == texturedata) + { + SDL_OutOfMemory(); + return -1; + } + + texturedata->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format); + texturedata->pixels = SDL_malloc(texture->h * texturedata->pitch); + if(NULL == texturedata->pixels) + { + SDL_OutOfMemory(); + return -1; + } + + if(SDL_ISPIXELFORMAT_FOURCC(texture->format)) + { + texturedata->yuv = SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h); + if(NULL == texturedata->yuv) + { + SDL_OutOfMemory(); + return -1; + } + SDL_Window* window = renderer->window; + SDL_VideoDisplay* display = window->display; + texturedata->format = display->current_mode.format; + } + else + { + texturedata->yuv = NULL; + texturedata->format = texture->format; + } + + texture->driverdata = texturedata; + + return 0; +} + +void WINCE_DestroyTexture(SDL_Renderer* renderer, SDL_Texture* texture) +{ + WINCE_TextureData *texturedata = (WINCE_TextureData*) texture->driverdata; + + if(texturedata) + { + if(texturedata->yuv) SDL_SW_DestroyYUVTexture(texturedata->yuv); + if(texturedata->pixels) SDL_free(texturedata->pixels); + SDL_free(texturedata); + texture->driverdata = NULL; + } +} + +int WINCE_QueryTexturePixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch) +{ + WINCE_TextureData* texturedata = (WINCE_TextureData*) texture->driverdata; + + if(texturedata->yuv) + return SDL_SW_QueryYUVTexturePixels(texturedata->yuv, pixels, pitch); + + *pixels = texturedata->pixels; + *pitch = texturedata->pitch; + + return 0; +} + +int WINCE_UpdateTexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch) { - // TODO implement + WINCE_TextureData* texturedata = (WINCE_TextureData*) texture->driverdata; + + if(texturedata->yuv) + { + if(SDL_SW_UpdateYUVTexture(texturedata->yuv, rect, pixels, pitch) < 0) + return -1; + WINCE_UpdateYUVTextureData(texture); + return 0; + } + + if(0 < rect->w && 0 < rect->h) + { + const unsigned char *src = ((const unsigned char*) pixels); + unsigned char *dst = ((unsigned char*) texturedata->pixels) + + rect->y * texturedata->pitch + + rect->x * SDL_BYTESPERPIXEL(texture->format); + int length = rect->w * SDL_BYTESPERPIXEL(texture->format); + int height = rect->h; + + while(height--) + { + SDL_memcpy(dst, src, length); + dst += texturedata->pitch; + src += pitch; + } + } + + return 0; +} + +int WINCE_LockTexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int dirty, void** pixels, int* pitch) +{ + WINCE_TextureData *texturedata = (WINCE_TextureData*) texture->driverdata; + + if(texturedata->yuv) + return SDL_SW_LockYUVTexture(texturedata->yuv, rect, dirty, pixels, pitch); + + *pixels = (void *) ((unsigned char*) texturedata->pixels + + rect->y * texturedata->pitch + + rect->x * SDL_BYTESPERPIXEL(texture->format)); + *pitch = texturedata->pitch; +} + +void WINCE_UnlockTexture(SDL_Renderer* renderer, SDL_Texture* texture) +{ + WINCE_TextureData *texturedata = (WINCE_TextureData*) texture->driverdata; + + if(texturedata->yuv) + { + SDL_SW_UnlockYUVTexture(texturedata->yuv); + WINCE_UpdateYUVTextureData(texture); + } +} + +int WINCE_RenderCopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srect, const SDL_Rect* drect) +{ + WINCE_RenderData* dstdata = (WINCE_RenderData*) renderer->driverdata; + WINCE_TextureData* srcdata = (WINCE_TextureData*) texture->driverdata; + + if((dstdata->flags & FB_SUSPENDED) || + 0 >= srect->w || 0 >= srect->h) return; + + // lock gapi + if(dstdata->gapi) dstdata->gapi->GXBeginDraw(); + + const unsigned char *src = ((const unsigned char*) srcdata->pixels); + unsigned char *dst = dstdata->pixels + (dstdata->flags & FB_SKIP_OFFSET ? 0 : dstdata->fb.offset) + + drect->y * dstdata->fb.ypitch + + drect->x * dstdata->fb.xpitch; + if(srcdata->yuv) + { + return SDL_SW_CopyYUVToRGB(srcdata->yuv, + srect, srcdata->format, + drect->w, drect->h, dst, + dstdata->fb.ypitch); + } + else + { + int height = drect->h; + int length = drect->w * SDL_BYTESPERPIXEL(texture->format); // in bytes + + while(height--) + { + switch(SDL_BYTESPERPIXEL(texture->format)) + { + case 2: UpdateLine16to16(&dstdata->fb, (Uint16*) src, (Uint16*) dst, length >> 1); break; + + default: break; + } + + dst += dstdata->fb.ypitch; + src += srcdata->pitch; + } + } + + // unlock gapi + if(dstdata->gapi) dstdata->gapi->GXEndDraw(); + + return 0; +} + +void WINCE_RenderPresent(SDL_Renderer* renderer) +{ +} + +int WINCE_RenderDrawPoints(SDL_Renderer* renderer, const SDL_Point* points, int count) +{ SDL_Unsupported(); return -1; } -static int -GAPI_RenderDrawLines(SDL_Renderer * renderer, - const SDL_Point * points, int count) +int WINCE_RenderDrawLines(SDL_Renderer* renderer, const SDL_Point* points, int count) { - // TODO implement SDL_Unsupported(); return -1; } -static int -GAPI_RenderDrawRects(SDL_Renderer * renderer, - const SDL_Rect ** rects, int count) +int WINCE_RenderDrawRects(SDL_Renderer* renderer, const SDL_Rect ** rects, int count) { - // TODO implement SDL_Unsupported(); return -1; } -static int -GAPI_RenderFillRects(SDL_Renderer * renderer, - const SDL_Rect ** rects, int count) +int WINCE_RenderFillRects(SDL_Renderer* renderer, const SDL_Rect** rects, int count) { - // TODO implement SDL_Unsupported(); return -1; } -/* Video memory is very slow so lets optimize as much as possible */ -static void -updateLine16to16(char *src, int srcXPitch, int srcYPitch, - char *dst, int dstXPitch, int dstYPitch, int width, - int height) + + +void WINCE_SetupOrientation(WINCE_RenderData* data, int width, int height) { - char *srcLine, *dstLine; - char *srcPix, *dstPix; + const float maxW1 = GetSystemMetrics(SM_CXSCREEN) > GetSystemMetrics(SM_CYSCREEN) ? GetSystemMetrics(SM_CXSCREEN) : GetSystemMetrics(SM_CYSCREEN); + const float maxW2 = data->fb.width > data->fb.height ? data->fb.width : data->fb.height; + + // scale define + data->scale = maxW2 / maxW1; + + // init fb values + FrameBufferInitialize(&data->fb); + + // orientation values + data->userOrientation = ORIENTATION_UP; + data->systemOrientation = WINCE_GetDMOrientation(); + data->hardwareGeometry = data->fb.width == data->fb.height ? GEOMETRY_SQUARE : + (data->fb.width < data->fb.height ? GEOMETRY_PORTRAIT : GEOMETRY_LANDSCAPE); + + if(data->debug) + WINCE_DumpVideoInfo(data); + + if(data->systemOrientation == ORIENTATION_UNKNOWN) + data->systemOrientation == ORIENTATION_UP; + + data->userOrientation = ORIENTATION_UP; - int x, y; + switch(data->hardwareGeometry) + { + case GEOMETRY_PORTRAIT: WINCE_PortraitTransform(data, width, height); break; + case GEOMETRY_LANDSCAPE: WINCE_LandscapeTransform(data, width, height); break; + case GEOMETRY_SQUARE: WINCE_SquareTransform(data, width, height); break; + default: break; + } + + // debug + if(data->debug) + { + printf("\n"); + printf("user video width: %d\n", width); + printf("user video height: %d\n", height); + FrameBufferDumpInfo(&data->fb, "user"); + } +} + +void WINCE_DumpVideoInfo(WINCE_RenderData* data) +{ + // get oem info + WCHAR oemInfo[48]; + SDL_memset(oemInfo, 0, sizeof(oemInfo)); + SystemParametersInfo(SPI_GETOEMINFO, sizeof(oemInfo) - sizeof(WCHAR), oemInfo, 0); + + printf("hardware oem: "); + wprintf(oemInfo); + printf("\n"); - //First dumb solution - if (srcXPitch == 2 && dstXPitch == 2) { - srcLine = src; - dstLine = dst; - y = height; - while (y--) { - SDL_memcpy(dstLine, srcLine, width * sizeof(Uint16)); - srcLine += srcYPitch; - dstLine += dstYPitch; - } - } else { - //printf("GAPI uses slow blit path %i, %i\n", dstXPitch, dstYPitch); - srcLine = src; - dstLine = dst; - y = height; - while (y--) { - srcPix = srcLine; - dstPix = dstLine; - x = width; - while (x--) { - *((Uint16 *) dstPix) = *((Uint16 *) srcPix); - dstPix += dstXPitch; - srcPix += srcXPitch; - } - srcLine += srcYPitch; - dstLine += dstYPitch; - } + printf("video driver mode: %s\n", (data->flags & FB_RAW_MODE ? RAW_RENDER_NAME : GAPI_RENDER_NAME)); + printf("GetSystemMetrics(SM_CXSCREEN): %d\n", GetSystemMetrics(SM_CXSCREEN)); + printf("GetSystemMetrics(SM_CYSCREEN): %d\n", GetSystemMetrics(SM_CYSCREEN)); + printf("scale coord: %f\n", data->scale); + + FrameBufferDumpInfo(&data->fb, "hardware"); + + printf("display format: %p\n", data->format); + printf("display bits per pixel: %d\n", SDL_BITSPERPIXEL(data->format)); + printf("display bytes per pixel: %d\n", SDL_BYTESPERPIXEL(data->format)); + printf("display memory: %p\n", data->pixels); + printf("system orientation: %d, %s\n", data->systemOrientation, GetOrientationName(data->systemOrientation)); + printf("hardware geometry: %d\n", data->hardwareGeometry); +} + +void WINCE_ShowWindow(_THIS, SDL_Window* window, int visible) +{ + SDL_WindowData* windowdata = (SDL_WindowData*) window->driverdata; + SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; + SDL_Renderer* renderer = (SDL_Renderer*) window->renderer; + + if(visible) + { + if(window->flags & SDL_WINDOW_FULLSCREEN) + { + if(videodata->SHFullScreen) + videodata->SHFullScreen(windowdata->hwnd, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON); + ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_HIDE); + } + + ShowWindow(windowdata->hwnd, SW_SHOW); + SetForegroundWindow(windowdata->hwnd); + + if(renderer && + (videodata->render == RENDER_GAPI || videodata->render == RENDER_RAW)) + { + WINCE_RenderData* renderdata = (WINCE_RenderData*) renderer->driverdata; + renderdata->flags &= ~FB_SUSPENDED; + if(renderdata->gapi) renderdata->gapi->GXResume(); + } + } + else + { + if(renderer && + (videodata->render == RENDER_GAPI || videodata->render == RENDER_RAW)) + { + WINCE_RenderData* renderdata = (WINCE_RenderData*) renderer->driverdata; + if(renderdata->gapi) renderdata->gapi->GXSuspend(); + renderdata->flags |= FB_SUSPENDED; + } + + ShowWindow(windowdata->hwnd, SW_HIDE); + + if(window->flags & SDL_WINDOW_FULLSCREEN) + { + if(videodata->SHFullScreen) + videodata->SHFullScreen(windowdata->hwnd, SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON | SHFS_SHOWSIPBUTTON); + ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_SHOW); + } } } -static int -GAPI_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, - const SDL_Rect * srcrect, const SDL_Rect * dstrect) + +void WINCE_PointerCoordinateTransform(SDL_Window* window, POINT* pt) +{ + WINCE_RenderData* data = (WINCE_RenderData*) window->renderer->driverdata; + + pt->x *= data->scale; + pt->y *= data->scale; + + PointerRotate(pt, &data->fb, data->userOrientation); +} + +void WINCE_PortraitTransform(WINCE_RenderData* data, int width, int height) +{ + if(data->systemOrientation != ORIENTATION_UP) + FrameBufferRotate(&data->fb, data->systemOrientation); + + if(data->fb.width != width || data->fb.height != height) + switch(data->systemOrientation) + { + case ORIENTATION_UP: + case ORIENTATION_LEFT: data->userOrientation = ORIENTATION_RIGHT; break; + case ORIENTATION_RIGHT: + case ORIENTATION_DOWN: data->userOrientation = ORIENTATION_LEFT; break; + default: break; + } + + if(data->userOrientation != ORIENTATION_UP) + FrameBufferRotate(&data->fb, data->userOrientation); +} + +void WINCE_LandscapeTransform(WINCE_RenderData* data, int width, int height) { - GAPI_RenderData *data = (GAPI_RenderData *) renderer->driverdata; - int bpp; - int bytespp; - int status; - Uint32 Rmask, Gmask, Bmask, Amask; + switch(data->systemOrientation) + { + case ORIENTATION_UP: FrameBufferRotate(&data->fb, ORIENTATION_LEFT); break; + case ORIENTATION_LEFT:FrameBufferRotate(&data->fb, ORIENTATION_DOWN); break; + case ORIENTATION_DOWN:FrameBufferRotate(&data->fb, ORIENTATION_RIGHT); break; + default: break; + } + + if(data->fb.width != width || data->fb.height != height) + switch(data->systemOrientation) + { + case ORIENTATION_UP: + case ORIENTATION_LEFT: data->userOrientation = ORIENTATION_RIGHT; break; + case ORIENTATION_RIGHT: + case ORIENTATION_DOWN: data->userOrientation = ORIENTATION_LEFT; break; + default: break; + } + + if(data->userOrientation != ORIENTATION_UP) + FrameBufferRotate(&data->fb, data->userOrientation); +} + +void WINCE_SquareTransform(WINCE_RenderData* data, int width, int height) +{ + WINCE_PortraitTransform(data, width, height); +} - if (texture->format != data->format) { - SDL_SetError("Gapi got wrong texture"); - return -1; +int WINCE_FixedGeometry(FrameBufferInfo* fb, int bpp, int debug) +{ + // check square + if(GetSystemMetrics(SM_CXSCREEN) == GetSystemMetrics(SM_CYSCREEN) && + fb->width != fb->height) + { + if(fb->width < fb->height) + fb->height = fb->width; + else + if(fb->height < fb->width) + fb->width = fb->height; + } + + // check width + if(__abs(fb->xpitch) == bpp && + fb->width != __abs(fb->ypitch) / bpp) + { + if(fb->height == __abs(fb->ypitch) / bpp) + { + __swap(&fb->width, &fb->height); + + if(debug) + printf("WINCE_FixedGeometry: width: %d, height: %d\n", fb->width, fb->height); + } + else + return -1; + } + else + // check height + if(__abs(fb->ypitch) == bpp && + fb->height != __abs(fb->xpitch) / bpp) + { + if(fb->width == __abs(fb->xpitch) / bpp) + { + __swap(&fb->width, &fb->height); + + if(debug) + printf("WINCE_FixedGeometry: width: %d, height: %d\n", fb->width, fb->height); + } + else + return -1; } - GAPI_LOG("GAPI_RenderCopy\n"); + return 0; +} + +void WINCE_UpdateYUVTextureData(SDL_Texture* texture) +{ + WINCE_TextureData* texturedata = (WINCE_TextureData*) texture->driverdata; + SDL_Rect rect; + + rect.x = 0; + rect.y = 0; + rect.w = texture->w; + rect.h = texture->h; + SDL_SW_CopyYUVToRGB(texturedata->yuv, &rect, texturedata->format, texture->w, texture->h, texturedata->pixels, texturedata->pitch); +} + +int GAPI_Init(WINCE_RenderData* data, HWND hwnd) +{ + if(NULL == data->gapi) + { + const char* preferably = SDL_getenv("SDL_VIDEO_RENDERER"); + if(preferably && 0 != SDL_strcasecmp(preferably, GAPI_RENDER_NAME)) return 0; + + data->gapi = (GapiInfo *) SDL_calloc(1, sizeof(GapiInfo)); + if(NULL == data->gapi) + { + SDL_OutOfMemory(); + return 0; + } + + data->gapi->hGapiLib = LoadLibrary(TEXT("\\Windows\\gx.dll")); + if(0 == data->gapi->hGapiLib) + { + data->gapi->hGapiLib = LoadLibrary(TEXT("gx.dll")); + if(0 == data->gapi->hGapiLib) return 0; + } + + // load gapi library +#define LINK(type,name,import) name=(PFN##type)GetProcAddress(data->gapi->hGapiLib,TEXT(import)) + LINK(GXOpenDisplay, data->gapi->GXOpenDisplay, "?GXOpenDisplay@@YAHPAUHWND__@@K@Z"); + LINK(GXCloseDisplay, data->gapi->GXCloseDisplay, "?GXCloseDisplay@@YAHXZ"); + LINK(GXBeginDraw, data->gapi->GXBeginDraw, "?GXBeginDraw@@YAPAXXZ"); + LINK(GXEndDraw, data->gapi->GXEndDraw, "?GXEndDraw@@YAHXZ"); + LINK(GXGetDisplayProperties,data->gapi->GXGetDisplayProperties,"?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ"); + LINK(GXSuspend, data->gapi->GXSuspend, "?GXSuspend@@YAHXZ"); + LINK(GXResume, data->gapi->GXResume, "?GXResume@@YAHXZ"); +#undef LINK + + int enable = data->gapi->GXGetDisplayProperties && data->gapi->GXCloseDisplay && data->gapi->GXOpenDisplay && + data->gapi->GXBeginDraw && data->gapi->GXEndDraw && data->gapi->GXSuspend && data->gapi->GXResume; + + if(!enable) + { + SDL_SetError("GAPI_Init: error gx.dll: internal error"); + GAPI_Quit(data); + return 0; + } + + if(0 == data->gapi->GXOpenDisplay(hwnd, GX_FULLSCREEN)) + { + SDL_SetError("GAPI_Init: couldn't initialize GAPI"); + GAPI_Quit(data); + return 0; + } + + struct GXDisplayProperties gxProperties = data->gapi->GXGetDisplayProperties(); - if (data->usageFlags & USAGE_GX_FUNCS) { - char *buffer; - buffer = gx.GXBeginDraw(); - if (!(data->usageFlags & USAGE_DATA_PTR_CONSTANT)) { - data->data = buffer; + // fill FrameBufferInfo + data->fb.xpitch = gxProperties.cbxPitch; + data->fb.ypitch = gxProperties.cbyPitch; + data->fb.width = gxProperties.cxWidth; + data->fb.height = gxProperties.cyHeight; + data->fb.offset = 0; + + if((gxProperties.ffFormat & kfDirect565) || 16 == gxProperties.cBPP) + data->format = SDL_PIXELFORMAT_RGB565; + else + if((gxProperties.ffFormat & kfDirect555) || 15 == gxProperties.cBPP) + data->format = SDL_PIXELFORMAT_RGB555; + else + data->format = 0; + + // get pixels + GXDeviceInfo gxInfo = { 0 }; + HDC hdc = GetDC(NULL); + + gxInfo.Version = 100; + int result = ExtEscape(hdc, GETGXINFO, 0, NULL, sizeof(gxInfo), (char *) &gxInfo); + ReleaseDC(NULL, hdc); + + if(result > 0) + { + // more debug + if(data->debug) + { + printf("GXDeviceInfo.pvFrameBuffer: %p\n", gxInfo.pvFrameBuffer); + printf("GXDeviceInfo.cxWidth: %d\n", gxInfo.cxWidth); + printf("GXDeviceInfo.cyHeight: %d\n", gxInfo.cyHeight); + printf("GXDeviceInfo.cbStride: %d\n", gxInfo.cbStride); + printf("GXDeviceInfo.cBPP: %d\n", gxInfo.cBPP); + printf("GXDeviceInfo.ffFormat: 0x%x\n", gxInfo.ffFormat); + + printf("GXDeviceInfo.unk:\n"); + int ii; for(ii = 0; ii < sizeof(gxInfo.unknown); ++ii) + printf("0x%02hhX,", gxInfo.unknown[ii]); + printf("\n"); + } + + if(gxInfo.ffFormat && gxInfo.ffFormat != gxProperties.ffFormat) + { + if((gxInfo.ffFormat & kfDirect565) || 16 == gxInfo.cBPP) + data->format = SDL_PIXELFORMAT_RGB565; + else + if((gxInfo.ffFormat & kfDirect555) || 15 == gxInfo.cBPP) + data->format = SDL_PIXELFORMAT_RGB555; + } + + data->pixels = gxInfo.pvFrameBuffer; } + else + { + data->flags |= FB_SKIP_OFFSET; + data->pixels = data->gapi->GXBeginDraw(); + data->gapi->GXEndDraw(); + + if(data->debug) + { + printf("GAPI_Init\n"); + printf("use GXBeginDraw: %p\n", data->pixels); + printf("use skip offset\n"); + } + } + + if(0 == data->format || + 0 > WINCE_FixedGeometry(&data->fb, SDL_BYTESPERPIXEL(data->format), data->debug)) + { + SDL_SetError("GAPI_Init: unknown hardware"); + GAPI_Quit(data); + return 0; + } } - GAPI_LOG("GAPI_RenderCopy blit\n"); - /* If our framebuffer has an xPitch which matches the pixelsize, we - can convert the framebuffer to a SDL_surface and blit there, - otherwise, we have to use our own blitting routine - */ - SDL_PixelFormatEnumToMasks(data->format, &bpp, &Rmask, &Gmask, &Bmask, - &Amask); - bytespp = bpp >> 3; - if (data->xPitch == bytespp && 0) { - SDL_Surface *screen = - SDL_CreateRGBSurfaceFrom(data->data, data->w, data->h, - bpp, data->yPitch, Rmask, Gmask, Bmask, - Amask); - status = - SDL_UpperBlit((SDL_Surface *) texture->driverdata, srcrect, - screen, dstrect); - SDL_FreeSurface(screen); - } else { /* screen is rotated, we have to blit on our own */ - SDL_Surface *surface = (SDL_Surface *) texture->driverdata; + return data->gapi && data->pixels ? 1 : 0; +} + +void GAPI_Quit(WINCE_RenderData* data) +{ + if(data->gapi) + { + if(data->gapi->GXCloseDisplay) data->gapi->GXCloseDisplay(); + if(data->gapi->hGapiLib) FreeLibrary(data->gapi->hGapiLib); + + SDL_free(data->gapi); + data->gapi = NULL; + } +} + +int RAW_Init(WINCE_RenderData* data) +{ + const char* preferably = SDL_getenv("SDL_VIDEO_RENDERER"); + if(preferably && 0 != SDL_strcasecmp(preferably, RAW_RENDER_NAME)) return 0; + + RawFrameBufferInfo rfbi = { 0 }; + HDC hdc = GetDC(NULL); + int result = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char *) &rfbi); + ReleaseDC(NULL, hdc); + + //disable + if(result == 0 || rfbi.pFramePointer == 0 || + rfbi.cxPixels == 0 || rfbi.cyPixels == 0 || + rfbi.cxStride == 0 || rfbi.cyStride == 0) return 0; + + data->flags = FB_RAW_MODE; + + // fill FrameBufferInfo + SDL_memset(&data->fb, 0, sizeof(FrameBufferInfo)); + + data->fb.xpitch = rfbi.cxStride; + data->fb.ypitch = rfbi.cyStride; + data->fb.width = rfbi.cxPixels; + data->fb.height = rfbi.cyPixels; + data->fb.offset = 0; - char *src, *dst; - src = surface->pixels; - src += srcrect->y * surface->pitch + srcrect->x * 2; + if((FORMAT_565 & rfbi.wFormat) || 16 == rfbi.wBPP) + data->format = SDL_PIXELFORMAT_RGB565; + else + if((FORMAT_555 & rfbi.wFormat) || 15 == rfbi.wBPP) + data->format = SDL_PIXELFORMAT_RGB555; + else + data->format = 0; + + if(0 == data->format || + 0 > WINCE_FixedGeometry(&data->fb, SDL_BYTESPERPIXEL(data->format), data->debug)) + { + SDL_SetError("RAW_Init: unknown hardware"); + RAW_Quit(data); + return 0; + } + + data->pixels = rfbi.pFramePointer; + + return data->pixels ? 1 : 0; +} + +void RAW_Quit(WINCE_RenderData* data) +{ +} - dst = data->data + data->offset; - dst += dstrect->y * data->yPitch + dstrect->x * data->xPitch; +void FrameBufferInitialize(FrameBufferInfo* fb) +{ + int orientation = GetFrameBufferOrientation(fb); + + // set correct start offset + switch(orientation) + { + case ORIENTATION_UP: + fb->offset = 0; + break; - updateLine16to16(src, 2, surface->pitch, - dst, data->xPitch, data->yPitch, - srcrect->w, srcrect->h); + case ORIENTATION_LEFT: + fb->offset = __abs(fb->ypitch * (fb->height - 1)); + break; + case ORIENTATION_RIGHT: + fb->offset = __abs(fb->xpitch * (fb->width - 1)); + break; + + case ORIENTATION_DOWN: + fb->offset = __abs(fb->xpitch * (fb->width - 1) + + fb->ypitch * (fb->height - 1)); + break; + + default: break; } - Uint32 ticks = SDL_GetTicks(); - if (data->usageFlags & USAGE_GX_FUNCS) { - gx.GXEndDraw(); + //if(orientation != ORIENTATION_UP) + switch(orientation) + { + case ORIENTATION_LEFT: FrameBufferRotate(fb, ORIENTATION_RIGHT); break; + case ORIENTATION_RIGHT:FrameBufferRotate(fb, ORIENTATION_LEFT); break; + case ORIENTATION_DOWN: FrameBufferRotate(fb, ORIENTATION_DOWN); break; + + default: break; } - GAPI_LOG("GAPI_RenderCopy %i\n", SDL_GetTicks() - ticks); - return status; +} + +int GetFrameBufferOrientation(const FrameBufferInfo* src) +{ + if(src->xpitch > 0 && src->ypitch > 0) + return ORIENTATION_UP; + else + if(src->xpitch > 0 && src->ypitch < 0) + return ORIENTATION_LEFT; + else + if(src->xpitch < 0 && src->ypitch > 0) + return ORIENTATION_RIGHT; + else + if(src->xpitch < 0 && src->ypitch < 0) + return ORIENTATION_DOWN; + + return ORIENTATION_UNKNOWN; } -static void -GAPI_RenderPresent(SDL_Renderer * renderer) +void FrameBufferRotate(FrameBufferInfo* dst, int orientation) { - /* Nothing todo as we rendered directly to the screen on RenderCopy */ + FrameBufferInfo src; + // copy dst -> src + SDL_memcpy(&src, dst, sizeof(FrameBufferInfo)); + + switch(orientation) + { + case ORIENTATION_LEFT: + dst->width = src.height; + dst->height = src.width; + dst->xpitch = src.ypitch; + dst->ypitch = -src.xpitch; + dst->offset = src.offset + src.xpitch * (src.width - 1); + break; + + case ORIENTATION_RIGHT: + dst->width = src.height; + dst->height = src.width; + dst->xpitch = -src.ypitch; + dst->ypitch = src.xpitch; + dst->offset = src.offset + src.ypitch * (src.height - 1); + break; + + case ORIENTATION_DOWN: + FrameBufferRotate(dst, ORIENTATION_LEFT); + FrameBufferRotate(dst, ORIENTATION_LEFT); + break; + + default: + break; + } +} + +void PointerRotate(POINT* pt, const FrameBufferInfo* fb, int orientation) +{ + switch(orientation) + { + case ORIENTATION_UP: + break; + + case ORIENTATION_LEFT: + { + int temp = pt->y; + pt->y = fb->height - pt->x; + pt->x = temp; + } + break; + + case ORIENTATION_RIGHT: + { + int temp = pt->x; + pt->x = fb->width - pt->y; + pt->y = temp; + } + break; + + case ORIENTATION_DOWN: + pt->x = fb->width - pt->x; + pt->y = fb->height - pt->y; + break; + + default: break; + } } -static void -GAPI_DestroyRenderer(SDL_Renderer * renderer) +const char* GetOrientationName(int orientation) +{ + switch(orientation) + { + case ORIENTATION_UP: return "UP"; + case ORIENTATION_DOWN: return "DOWN"; + case ORIENTATION_LEFT: return "LEFT"; + case ORIENTATION_RIGHT: return "RIGHT"; + default: break; + } + + return "UNKNOWN"; +} + +int WINCE_GetDMOrientation(void) { - GAPI_RenderData *data = (GAPI_RenderData *) renderer->driverdata; + DEVMODE sDevMode = {0}; + sDevMode.dmSize = sizeof(DEVMODE); + sDevMode.dmFields = DM_DISPLAYORIENTATION; + + // DMDO_0, DMDO_90, DMDO_180, DMDO_270 + if(DISP_CHANGE_BADMODE != ChangeDisplaySettingsEx(NULL, &sDevMode, 0, CDS_TEST, NULL)) + switch(sDevMode.dmDisplayOrientation) + { + case DMDO_0: return DMDO_0; + case DMDO_90: return DMDO_90; + case DMDO_180: return DMDO_180; + case DMDO_270: return DMDO_270; + default: break; + } - if (data->usageFlags & USAGE_GX_FUNCS) { - gx.GXCloseDisplay(); + SDL_SetError("WINCE_GetDMOrientation: ChangeDisplaySettingsEx return BADMODE"); + return -1; +} + +int WINCE_SetDMOrientation(int orientation) +{ + DEVMODE sDevMode = {0}; + sDevMode.dmSize = sizeof(DEVMODE); + sDevMode.dmFields = DM_DISPLAYORIENTATION; + + switch(orientation) + { + case DMDO_0: sDevMode.dmDisplayOrientation = DMDO_0; break; + case DMDO_90: sDevMode.dmDisplayOrientation = DMDO_90; break; + case DMDO_180: sDevMode.dmDisplayOrientation = DMDO_180; break; + case DMDO_270: sDevMode.dmDisplayOrientation = DMDO_270; break; + default: return 0; } - if (data) { - SDL_free(data); - } - SDL_free(renderer); + if(DISP_CHANGE_BADMODE != ChangeDisplaySettingsEx(NULL, &sDevMode, 0, CDS_RESET, NULL)) + return 1; + + SDL_SetError("WINCE_SetDMOrientation: ChangeDisplaySettingsEx return BADMODE"); + return -1; +} + +void FrameBufferDumpInfo(const FrameBufferInfo* fb, const char* name) +{ + printf("%s fb.width: %d\n", name, fb->width); + printf("%s fb.height: %d\n", name, fb->height); + printf("%s fb.xpitch: %d\n", name, fb->xpitch); + printf("%s fb.ypitch: %d\n", name, fb->ypitch); + printf("%s fb.offset: %d\n", name, fb->offset); + + int orientation = GetFrameBufferOrientation(fb); + printf("%s fb.orientation: %d, %s\n", name, orientation, GetOrientationName(orientation)); } -#endif /* SDL_VIDEO_RENDER_GAPI */ +void UpdateLine16to16(const FrameBufferInfo* fb, const Uint16* src, Uint16* dst, Uint16 width) +{ + if(2 == fb->xpitch) + { + switch(width) + { + case 1: + *dst = *src; + break; + + case 2: + *((Uint32*) dst) = *((Uint32*) src); + break; -/* vi: set ts=4 sw=4 expandtab: */ + default: + SDL_memcpy(dst, src, width * 2); + break; + } + } + else + if(-2 == fb->xpitch) + { + while(width--) + *dst-- = *src++; + } + else + { + while(width--) + { + *dst = *src++; + dst += fb->xpitch / 2; + } + } +} + +#endif // SDL_VIDEO_RENDER_GAPI
--- a/src/video/win32/SDL_gapirender.h Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_gapirender.h Tue Jul 27 21:31:28 2010 -0700 @@ -27,7 +27,11 @@ /* SDL surface based renderer implementation */ #if SDL_VIDEO_RENDER_GAPI -extern void GAPI_AddRenderDriver(_THIS); +extern void WINCE_AddRenderDriver(_THIS); +extern int WINCE_Available(void); +extern void WINCE_ShowWindow(_THIS, SDL_Window* window, int visible); +extern int WINCE_GetDMOrientation(void); +extern int WINCE_SetDMOrientation(int orientation); #endif /* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/win32/SDL_gapirender_c.h Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_gapirender_c.h Tue Jul 27 21:31:28 2010 -0700 @@ -22,100 +22,3 @@ Stefan Klug klug.stefan@gmx.de */ - -#define WIN32_LEAN_AND_MEAN -#include <windows.h> - -/* hi res definitions */ -typedef struct _RawFrameBufferInfo -{ - WORD wFormat; - WORD wBPP; - VOID *pFramePointer; - int cxStride; - int cyStride; - int cxPixels; - int cyPixels; -} RawFrameBufferInfo; - -#define GETRAWFRAMEBUFFER 0x00020001 - -#define FORMAT_565 1 -#define FORMAT_555 2 -#define FORMAT_OTHER 3 - - -/* From gx.h, since it's not really C compliant */ - -struct GXDisplayProperties -{ - DWORD cxWidth; - DWORD cyHeight; // notice lack of 'th' in the word height. - long cbxPitch; // number of bytes to move right one x pixel - can be negative. - long cbyPitch; // number of bytes to move down one y pixel - can be negative. - long cBPP; // # of bits in each pixel - DWORD ffFormat; // format flags. -}; - -struct GXKeyList -{ - short vkUp; // key for up - POINT ptUp; // x,y position of key/button. Not on screen but in screen coordinates. - short vkDown; - POINT ptDown; - short vkLeft; - POINT ptLeft; - short vkRight; - POINT ptRight; - short vkA; - POINT ptA; - short vkB; - POINT ptB; - short vkC; - POINT ptC; - short vkStart; - POINT ptStart; -}; - -typedef int (*PFNGXOpenDisplay) (HWND hWnd, DWORD dwFlags); -typedef int (*PFNGXCloseDisplay) (); -typedef void *(*PFNGXBeginDraw) (); -typedef int (*PFNGXEndDraw) (); -typedef int (*PFNGXOpenInput) (); -typedef int (*PFNGXCloseInput) (); -typedef struct GXDisplayProperties (*PFNGXGetDisplayProperties) (); -typedef struct GXKeyList (*PFNGXGetDefaultKeys) (int iOptions); -typedef int (*PFNGXSuspend) (); -typedef int (*PFNGXResume) (); -typedef int (*PFNGXSetViewport) (DWORD dwTop, DWORD dwHeight, - DWORD dwReserved1, DWORD dwReserved2); -typedef BOOL(*PFNGXIsDisplayDRAMBuffer) (); - -struct GapiFunc -{ - PFNGXOpenDisplay GXOpenDisplay; - PFNGXCloseDisplay GXCloseDisplay; - PFNGXBeginDraw GXBeginDraw; - PFNGXEndDraw GXEndDraw; - PFNGXOpenInput GXOpenInput; - PFNGXCloseInput GXCloseInput; - PFNGXGetDisplayProperties GXGetDisplayProperties; - PFNGXGetDefaultKeys GXGetDefaultKeys; - PFNGXSuspend GXSuspend; - PFNGXResume GXResume; - PFNGXSetViewport GXSetViewport; - PFNGXIsDisplayDRAMBuffer GXIsDisplayDRAMBuffer; -} gx; - -#define kfLandscape 0x8 // Screen is rotated 270 degrees -#define kfPalette 0x10 // Pixel values are indexes into a palette -#define kfDirect 0x20 // Pixel values contain actual level information -#define kfDirect555 0x40 // 5 bits each for red, green and blue values in a pixel. -#define kfDirect565 0x80 // 5 red bits, 6 green bits and 5 blue bits per pixel -#define kfDirect888 0x100 // 8 bits each for red, green and blue values in a pixel. -#define kfDirect444 0x200 // 4 red, 4 green, 4 blue -#define kfDirectInverted 0x400 - -#define GX_FULLSCREEN 0x01 // for OpenDisplay() -#define GX_NORMALKEYS 0x02 -#define GX_LANDSCAPEKEYS 0x03
--- a/src/video/win32/SDL_gdirender.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_gdirender.c Tue Jul 27 21:31:28 2010 -0700 @@ -184,6 +184,8 @@ return NULL; } + windowdata->videodata->render = RENDER_GDI; + renderer->DisplayModeChanged = GDI_DisplayModeChanged; renderer->CreateTexture = GDI_CreateTexture; renderer->QueryTexturePixels = GDI_QueryTexturePixels; @@ -267,6 +269,34 @@ } data->current_hbm = 0; +#ifdef _WIN32_WCE + // check size for GDI fullscreen and rotate + if((window->flags & SDL_WINDOW_FULLSCREEN) && + GetSystemMetrics(SM_CXSCREEN) != GetSystemMetrics(SM_CYSCREEN) && + ((GetSystemMetrics(SM_CXSCREEN) < GetSystemMetrics(SM_CYSCREEN) && window->w > window->h) || + (GetSystemMetrics(SM_CXSCREEN) > GetSystemMetrics(SM_CYSCREEN) && window->w < window->h))) + { + int orientation = WINCE_GetDMOrientation(); + switch(orientation) + { + case DMDO_0: orientation = DMDO_90; break; + case DMDO_270: orientation = DMDO_180; break; + case DMDO_90: orientation = DMDO_0; break; + case DMDO_180: orientation = DMDO_270; break; + + default: + GDI_DestroyRenderer(renderer); + return NULL; + } + + if(0 > WINCE_SetDMOrientation(orientation)) + { + GDI_DestroyRenderer(renderer); + return NULL; + } + } +#endif + return renderer; } @@ -416,6 +446,7 @@ WIN_SetError("Couldn't create bitmap"); return -1; } + return 0; }
--- a/src/video/win32/SDL_win32clipboard.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_win32clipboard.c Tue Jul 27 21:31:28 2010 -0700 @@ -95,7 +95,11 @@ WIN_SetError("Couldn't set clipboard data"); result = -1; } +#ifdef _WIN32_WCE + data->clipboard_count = 0; +#else data->clipboard_count = GetClipboardSequenceNumber(); +#endif } SDL_free(tstr); @@ -149,7 +153,11 @@ { DWORD count; +#ifdef _WIN32_WCE + count = 0; +#else count = GetClipboardSequenceNumber(); +#endif if (count != data->clipboard_count) { if (data->clipboard_count) { SDL_SendClipboardUpdate();
--- a/src/video/win32/SDL_win32events.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_win32events.c Tue Jul 27 21:31:28 2010 -0700 @@ -184,6 +184,22 @@ break; case WM_MOUSEMOVE: +#ifdef _WIN32_WCE + /* transform coords for VGA, WVGA... */ + { + SDL_VideoData *videodata = data->videodata; + if(videodata->CoordTransform && + (videodata->render == RENDER_GAPI || videodata->render == RENDER_RAW)) + { + POINT pt; + pt.x = LOWORD(lParam); + pt.y = HIWORD(lParam); + videodata->CoordTransform(data->window, &pt); + SDL_SendMouseMotion(data->window, 0, pt.x, pt.y); + break; + } + } +#endif SDL_SendMouseMotion(data->window, 0, LOWORD(lParam), HIWORD(lParam)); break;
--- a/src/video/win32/SDL_win32modes.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_win32modes.c Tue Jul 27 21:31:28 2010 -0700 @@ -203,10 +203,18 @@ { SDL_DisplayModeData *data = (SDL_DisplayModeData *) display->desktop_mode.driverdata; +#ifdef _WIN32_WCE + // WINCE: DEVMODE.dmPosition not found, or may be mingw32ce bug + rect->x = 0; + rect->y = 0; + rect->w = display->windows->w; + rect->h = display->windows->h; +#else rect->x = (int)data->DeviceMode.dmPosition.x; rect->y = (int)data->DeviceMode.dmPosition.y; rect->w = data->DeviceMode.dmPelsWidth; rect->h = data->DeviceMode.dmPelsHeight; +#endif return 0; }
--- a/src/video/win32/SDL_win32video.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_win32video.c Tue Jul 27 21:31:28 2010 -0700 @@ -30,6 +30,7 @@ #include "SDL_win32video.h" #include "SDL_d3drender.h" #include "SDL_gdirender.h" +#include "SDL_gapirender.h" /* Initialization/Query functions */ static int WIN_VideoInit(_THIS); @@ -48,6 +49,7 @@ SDL_free(message); } + /* WIN32 driver bootstrap functions */ static int @@ -74,6 +76,11 @@ FreeLibrary(data->ddrawDLL); } #endif +#ifdef _WIN32_WCE + if(data->hAygShell) { + FreeLibrary(data->hAygShell); + } +#endif SDL_free(device->driverdata); SDL_free(device); } @@ -138,6 +145,15 @@ } #endif /* SDL_VIDEO_RENDER_DDRAW */ +#ifdef _WIN32_WCE + data->hAygShell = LoadLibrary(TEXT("\\windows\\aygshell.dll")); + if(0 == data->hAygShell) + data->hAygShell = LoadLibrary(TEXT("aygshell.dll")); + data->SHFullScreen = (0 != data->hAygShell ? + (PFNSHFullScreen) GetProcAddress(data->hAygShell, TEXT("SHFullScreen")) : 0); + data->CoordTransform = NULL; +#endif + /* Set the function pointers */ device->VideoInit = WIN_VideoInit; device->VideoQuit = WIN_VideoQuit; @@ -186,10 +202,13 @@ } VideoBootStrap WIN32_bootstrap = { +#ifdef _WIN32_WCE + "wince", "SDL WinCE video driver", WINCE_Available, WIN_CreateDevice +#else "win32", "SDL Win32/64 video driver", WIN_Available, WIN_CreateDevice +#endif }; - int WIN_VideoInit(_THIS) { @@ -207,7 +226,7 @@ GDI_AddRenderDriver(_this); #endif #if SDL_VIDEO_RENDER_GAPI - GAPI_AddRenderDriver(_this); + WINCE_AddRenderDriver(_this); #endif WIN_InitKeyboard(_this);
--- a/src/video/win32/SDL_win32video.h Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_win32video.h Tue Jul 27 21:31:28 2010 -0700 @@ -28,7 +28,9 @@ #define WIN32_LEAN_AND_MEAN #define STRICT +#ifndef UNICODE #define UNICODE +#endif #undef WINVER #define WINVER 0x500 /* Need 0x410 for AlphaBlend() and 0x500 for EnumDisplayDevices() */ #include <windows.h> @@ -63,10 +65,17 @@ #endif extern void WIN_SetError(const char *prefix); +enum { RENDER_NONE, RENDER_D3D, RENDER_DDRAW, RENDER_GDI, RENDER_GAPI, RENDER_RAW }; + +typedef BOOL (*PFNSHFullScreen)(HWND, DWORD); +typedef void (*PFCoordTransform)(SDL_Window*, POINT*); + /* Private display data */ typedef struct SDL_VideoData { + int render; + #if SDL_VIDEO_RENDER_D3D HANDLE d3dDLL; IDirect3D9 *d3d; @@ -75,6 +84,11 @@ HANDLE ddrawDLL; IDirectDraw *ddraw; #endif +#ifdef _WIN32_WCE + HMODULE hAygShell; + PFNSHFullScreen SHFullScreen; + PFCoordTransform CoordTransform; +#endif DWORD clipboard_count;
--- a/src/video/win32/SDL_win32window.c Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_win32window.c Tue Jul 27 21:31:28 2010 -0700 @@ -34,44 +34,12 @@ #include "../../events/SDL_keyboard_c.h" #include "SDL_win32video.h" +#include "SDL_win32window.h" /* This is included after SDL_win32video.h, which includes windows.h */ #include "SDL_syswm.h" - - -#define SHFS_SHOWTASKBAR 0x0001 -#define SHFS_HIDETASKBAR 0x0002 -#define SHFS_SHOWSIPBUTTON 0x0004 -#define SHFS_HIDESIPBUTTON 0x0008 -#define SHFS_SHOWSTARTICON 0x0010 -#define SHFS_HIDESTARTICON 0x0020 - -#ifdef _WIN32_WCE -// dynamically load aygshell dll because we want SDL to work on HPC and be300 -int aygshell_loaded = 0; -BOOL(WINAPI * SHFullScreen) (HWND hwndRequester, DWORD dwState) = 0; - +#include "SDL_gapirender.h" -static BOOL -CE_SHFullScreen(HWND hwndRequester, DWORD dwState) -{ - if (SHFullScreen == 0 && aygshell_loaded == 0) { - aygshell_loaded = 0; - void *lib = SDL_LoadObject("aygshell.dll"); - if (lib) { - SHFullScreen = - (BOOL(WINAPI *) (HWND, DWORD)) SDL_LoadFunction(lib, - "SHFullScreen"); - } - } - - if (SHFullScreen) { - SHFullScreen(hwndRequester, dwState); - //printf("SHFullscreen(%i)\n",dwState); - } -} - -#endif /* Fake window to help with DirectInput events. */ HWND SDL_HelperWindow = NULL; @@ -472,32 +440,22 @@ void WIN_ShowWindow(_THIS, SDL_Window * window) { +#ifdef _WIN32_WCE + WINCE_ShowWindow(_this, window, 1); +#else HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd; - ShowWindow(hwnd, SW_SHOW); - -#ifdef _WIN32_WCE - if (window->flags & SDL_WINDOW_FULLSCREEN) { - CE_SHFullScreen(hwnd, - SHFS_HIDESTARTICON | SHFS_HIDETASKBAR | - SHFS_HIDESIPBUTTON); - } #endif } void WIN_HideWindow(_THIS, SDL_Window * window) { +#ifdef _WIN32_WCE + WINCE_ShowWindow(_this, window, 0); +#else HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd; - ShowWindow(hwnd, SW_HIDE); - -#ifdef _WIN32_WCE - if (window->flags & SDL_WINDOW_FULLSCREEN) { - CE_SHFullScreen(hwnd, - SHFS_SHOWSTARTICON | SHFS_SHOWTASKBAR | - SHFS_SHOWSIPBUTTON); - } #endif } @@ -513,45 +471,33 @@ top = HWND_NOTOPMOST; } SetWindowPos(hwnd, top, 0, 0, 0, 0, (SWP_NOMOVE | SWP_NOSIZE)); - -#ifdef _WIN32_WCE - if (window->flags & SDL_WINDOW_FULLSCREEN) { - CE_SHFullScreen(hwnd, - SHFS_HIDESTARTICON | SHFS_HIDETASKBAR | - SHFS_HIDESIPBUTTON); - } -#endif } void WIN_MaximizeWindow(_THIS, SDL_Window * window) { HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd; - - ShowWindow(hwnd, SW_MAXIMIZE); + SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; #ifdef _WIN32_WCE - if (window->flags & SDL_WINDOW_FULLSCREEN) { - CE_SHFullScreen(hwnd, - SHFS_HIDESTARTICON | SHFS_HIDETASKBAR | - SHFS_HIDESIPBUTTON); - } + if((window->flags & SDL_WINDOW_FULLSCREEN) && videodata->SHFullScreen) + videodata->SHFullScreen(hwnd, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON); #endif + + ShowWindow(hwnd, SW_MAXIMIZE); } void WIN_MinimizeWindow(_THIS, SDL_Window * window) { HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd; + SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; ShowWindow(hwnd, SW_MINIMIZE); #ifdef _WIN32_WCE - if (window->flags & SDL_WINDOW_FULLSCREEN) { - CE_SHFullScreen(hwnd, - SHFS_SHOWSTARTICON | SHFS_SHOWTASKBAR | - SHFS_SHOWSIPBUTTON); - } + if((window->flags & SDL_WINDOW_FULLSCREEN) && videodata->SHFullScreen) + videodata->SHFullScreen(hwnd, SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON | SHFS_SHOWSIPBUTTON); #endif } @@ -586,6 +532,9 @@ SDL_WindowData *data = (SDL_WindowData *) window->driverdata; if (data) { +#ifdef _WIN32_WCE + WINCE_ShowWindow(_this, window, 0); +#endif ReleaseDC(data->hwnd, data->hdc); if (data->created) { DestroyWindow(data->hwnd);
--- a/src/video/win32/SDL_win32window.h Fri Jul 23 21:33:00 2010 -0700 +++ b/src/video/win32/SDL_win32window.h Tue Jul 27 21:31:28 2010 -0700 @@ -24,6 +24,15 @@ #ifndef _SDL_win32window_h #define _SDL_win32window_h +#ifdef _WIN32_WCE +#define SHFS_SHOWTASKBAR 0x0001 +#define SHFS_HIDETASKBAR 0x0002 +#define SHFS_SHOWSIPBUTTON 0x0004 +#define SHFS_HIDESIPBUTTON 0x0008 +#define SHFS_SHOWSTARTICON 0x0010 +#define SHFS_HIDESTARTICON 0x0020 +#endif + typedef struct { SDL_Window *window;