Mercurial > sdl-ios-xcode

comparison src/video/gapi/SDL_gapivideo.c @ 1895:c121d94672cb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.
author Sam Lantinga <slouken@libsdl.org>
date Mon, 10 Jul 2006 21:04:37 +0000
parents 8d9bb0cf2c2a
children e1da92da346c
comparison
equal deleted inserted replaced
1894:c69cee13dd76 1895:c121d94672cb
48 #include "../SDL_sysvideo.h" 48 #include "../SDL_sysvideo.h"
49 #include "../SDL_pixels_c.h" 49 #include "../SDL_pixels_c.h"
50 #include "../../events/SDL_events_c.h" 50 #include "../../events/SDL_events_c.h"
51 #include "../wincommon/SDL_syswm_c.h" 51 #include "../wincommon/SDL_syswm_c.h"
52 #include "../wincommon/SDL_sysmouse_c.h" 52 #include "../wincommon/SDL_sysmouse_c.h"
53 #include "../windib/SDL_dibevents_c.h" 53 #include "../windib/SDL_dibevents_c.h"
54 54
55 #include "SDL_gapivideo.h" 55 #include "SDL_gapivideo.h"
56 56
57 #define GAPIVID_DRIVER_NAME "gapi" 57 #define GAPIVID_DRIVER_NAME "gapi"
58 58
75 extern HINSTANCE aygshell; 75 extern HINSTANCE aygshell;
76 extern void SDL_UnregisterApp(); 76 extern void SDL_UnregisterApp();
77 extern int DIB_AddMode(_THIS, int bpp, int w, int h); 77 extern int DIB_AddMode(_THIS, int bpp, int w, int h);
78 78
79 /* Initialization/Query functions */ 79 /* Initialization/Query functions */
80 static int GAPI_VideoInit(_THIS, SDL_PixelFormat *vformat); 80 static int GAPI_VideoInit(_THIS, SDL_PixelFormat * vformat);
81 static SDL_Rect **GAPI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); 81 static SDL_Rect **GAPI_ListModes(_THIS, SDL_PixelFormat * format,
82 static SDL_Surface *GAPI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); 82 Uint32 flags);
83 static int GAPI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); 83 static SDL_Surface *GAPI_SetVideoMode(_THIS, SDL_Surface * current,
84 int width, int height, int bpp,
85 Uint32 flags);
86 static int GAPI_SetColors(_THIS, int firstcolor, int ncolors,
87 SDL_Color * colors);
84 static void GAPI_VideoQuit(_THIS); 88 static void GAPI_VideoQuit(_THIS);
85 89
86 /* Hardware surface functions */ 90 /* Hardware surface functions */
87 static int GAPI_AllocHWSurface(_THIS, SDL_Surface *surface); 91 static int GAPI_AllocHWSurface(_THIS, SDL_Surface * surface);
88 static int GAPI_LockHWSurface(_THIS, SDL_Surface *surface); 92 static int GAPI_LockHWSurface(_THIS, SDL_Surface * surface);
89 static void GAPI_UnlockHWSurface(_THIS, SDL_Surface *surface); 93 static void GAPI_UnlockHWSurface(_THIS, SDL_Surface * surface);
90 static void GAPI_FreeHWSurface(_THIS, SDL_Surface *surface); 94 static void GAPI_FreeHWSurface(_THIS, SDL_Surface * surface);
91 95
92 /* Windows message handling functions, will not be processed */ 96 /* Windows message handling functions, will not be processed */
93 static void GAPI_RealizePalette(_THIS); 97 static void GAPI_RealizePalette(_THIS);
94 static void GAPI_PaletteChanged(_THIS, HWND window); 98 static void GAPI_PaletteChanged(_THIS, HWND window);
95 static void GAPI_WinPAINT(_THIS, HDC hdc); 99 static void GAPI_WinPAINT(_THIS, HDC hdc);
96 100
97 /* etc. */ 101 /* etc. */
98 static void GAPI_UpdateRects(_THIS, int numrects, SDL_Rect *rects); 102 static void GAPI_UpdateRects(_THIS, int numrects, SDL_Rect * rects);
99 103
100 static HMODULE g_hGapiLib = 0; 104 static HMODULE g_hGapiLib = 0;
101 #define LINK(type,name,import) \ 105 #define LINK(type,name,import) \
102 if( g_hGapiLib ) \ 106 if( g_hGapiLib ) \
103 name = (PFN##type)GetProcAddress( g_hGapiLib, _T(import) ); 107 name = (PFN##type)GetProcAddress( g_hGapiLib, _T(import) );
104 108
105 static char g_bRawBufferAvailable = 0; 109 static char g_bRawBufferAvailable = 0;
106 110
107 /* GAPI driver bootstrap functions */ 111 /* GAPI driver bootstrap functions */
108 112
109 /* hi res definitions */ 113 /* hi res definitions */
110 typedef struct _RawFrameBufferInfo 114 typedef struct _RawFrameBufferInfo
111 { 115 {
112 WORD wFormat; 116 WORD wFormat;
113 WORD wBPP; 117 WORD wBPP;
114 VOID *pFramePointer; 118 VOID *pFramePointer;
115 int cxStride; 119 int cxStride;
116 int cyStride; 120 int cyStride;
117 int cxPixels; 121 int cxPixels;
118 int cyPixels; 122 int cyPixels;
119 } RawFrameBufferInfo; 123 } RawFrameBufferInfo;
120 124
121 static struct _RawFrameBufferInfo g_RawFrameBufferInfo = {0}; 125 static struct _RawFrameBufferInfo g_RawFrameBufferInfo = { 0 };
122 126
123 #define GETRAWFRAMEBUFFER 0x00020001 127 #define GETRAWFRAMEBUFFER 0x00020001
124 128
125 #define FORMAT_565 1 129 #define FORMAT_565 1
126 #define FORMAT_555 2 130 #define FORMAT_555 2
132 */ 136 */
133 #define GETGXINFO 0x00020000 137 #define GETGXINFO 0x00020000
134 138
135 typedef struct GXDeviceInfo 139 typedef struct GXDeviceInfo
136 { 140 {
137 long Version; //00 (should filled with 100 before calling ExtEscape) 141 long Version; //00 (should filled with 100 before calling ExtEscape)
138 void * pvFrameBuffer; //04 142 void *pvFrameBuffer; //04
139 unsigned long cbStride; //08 143 unsigned long cbStride; //08
140 unsigned long cxWidth; //0c 144 unsigned long cxWidth; //0c
141 unsigned long cyHeight; //10 145 unsigned long cyHeight; //10
142 unsigned long cBPP; //14 146 unsigned long cBPP; //14
143 unsigned long ffFormat; //18 147 unsigned long ffFormat; //18
144 char Unused[0x84-7*4]; 148 char Unused[0x84 - 7 * 4];
145 } GXDeviceInfo; 149 } GXDeviceInfo;
146 150
147 static int GAPI_Available(void) 151 static int
148 { 152 GAPI_Available(void)
149 // try to use VGA display, even on emulator 153 {
150 HDC hdc = GetDC(NULL); 154 // try to use VGA display, even on emulator
151 int result = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char *)&g_RawFrameBufferInfo); 155 HDC hdc = GetDC(NULL);
152 ReleaseDC(NULL, hdc); 156 int result = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL,
153 g_bRawBufferAvailable = result > 0; 157 sizeof(RawFrameBufferInfo),
158 (char *) &g_RawFrameBufferInfo);
159 ReleaseDC(NULL, hdc);
160 g_bRawBufferAvailable = result > 0;
154 161
155 #if WITHOUT_GAPI 162 #if WITHOUT_GAPI
156 return g_bRawBufferAvailable; 163 return g_bRawBufferAvailable;
157 #endif 164 #endif
158 165
159 #if USE_GAPI_EMU 166 #if USE_GAPI_EMU
160 g_hGapiLib = LoadLibrary(_T("GAPI_Emu.dll")); 167 g_hGapiLib = LoadLibrary(_T("GAPI_Emu.dll"));
161 if( !g_hGapiLib ) 168 if (!g_hGapiLib) {
162 { 169 SDL_SetError("Gapi Emu not found!");
163 SDL_SetError("Gapi Emu not found!"); 170 }
164 } 171 return g_hGapiLib != 0;
165 return g_hGapiLib != 0;
166 #endif 172 #endif
167 173
168 // try to find gx.dll 174 // try to find gx.dll
169 g_hGapiLib = LoadLibrary(_T("\\Windows\\gx.dll")); 175 g_hGapiLib = LoadLibrary(_T("\\Windows\\gx.dll"));
170 if( !g_hGapiLib ) 176 if (!g_hGapiLib) {
171 { 177 g_hGapiLib = LoadLibrary(_T("gx.dll"));
172 g_hGapiLib = LoadLibrary(_T("gx.dll")); 178 if (!g_hGapiLib)
173 if( !g_hGapiLib ) return g_bRawBufferAvailable; 179 return g_bRawBufferAvailable;
174 } 180 }
175 181
176 return(1); 182 return (1);
177 } 183 }
178 184
179 static int cmpmodes(const void *va, const void *vb) 185 static int
180 { 186 cmpmodes(const void *va, const void *vb)
181 SDL_Rect *a = *(SDL_Rect **)va; 187 {
182 SDL_Rect *b = *(SDL_Rect **)vb; 188 SDL_Rect *a = *(SDL_Rect **) va;
183 if ( a->w == b->w ) 189 SDL_Rect *b = *(SDL_Rect **) vb;
190 if (a->w == b->w)
184 return b->h - a->h; 191 return b->h - a->h;
185 else 192 else
186 return b->w - a->w; 193 return b->w - a->w;
187 } 194 }
188 195
189 static int GAPI_AddMode(_THIS, int bpp, int w, int h) 196 static int
190 { 197 GAPI_AddMode(_THIS, int bpp, int w, int h)
191 SDL_Rect *mode; 198 {
192 int i, index; 199 SDL_Rect *mode;
193 int next_mode; 200 int i, index;
194 201 int next_mode;
195 /* Check to see if we already have this mode */ 202
196 if ( bpp < 8 ) { /* Not supported */ 203 /* Check to see if we already have this mode */
197 return(0); 204 if (bpp < 8) { /* Not supported */
198 } 205 return (0);
199 index = ((bpp+7)/8)-1; 206 }
200 for ( i=0; i<gapi->SDL_nummodes[index]; ++i ) { 207 index = ((bpp + 7) / 8) - 1;
201 mode = gapi->SDL_modelist[index][i]; 208 for (i = 0; i < gapi->SDL_nummodes[index]; ++i) {
202 if ( (mode->w == w) && (mode->h == h) ) { 209 mode = gapi->SDL_modelist[index][i];
203 return(0); 210 if ((mode->w == w) && (mode->h == h)) {
204 } 211 return (0);
205 } 212 }
206 213 }
207 /* Set up the new video mode rectangle */ 214
208 mode = (SDL_Rect *)SDL_malloc(sizeof *mode); 215 /* Set up the new video mode rectangle */
209 if ( mode == NULL ) { 216 mode = (SDL_Rect *) SDL_malloc(sizeof *mode);
210 SDL_OutOfMemory(); 217 if (mode == NULL) {
211 return(-1); 218 SDL_OutOfMemory();
212 } 219 return (-1);
213 mode->x = 0; 220 }
214 mode->y = 0; 221 mode->x = 0;
215 mode->w = w; 222 mode->y = 0;
216 mode->h = h; 223 mode->w = w;
217 224 mode->h = h;
218 /* Allocate the new list of modes, and fill in the new mode */ 225
219 next_mode = gapi->SDL_nummodes[index]; 226 /* Allocate the new list of modes, and fill in the new mode */
220 gapi->SDL_modelist[index] = (SDL_Rect **) 227 next_mode = gapi->SDL_nummodes[index];
221 SDL_realloc(gapi->SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); 228 gapi->SDL_modelist[index] = (SDL_Rect **)
222 if ( gapi->SDL_modelist[index] == NULL ) { 229 SDL_realloc(gapi->SDL_modelist[index],
223 SDL_OutOfMemory(); 230 (1 + next_mode + 1) * sizeof(SDL_Rect *));
224 gapi->SDL_nummodes[index] = 0; 231 if (gapi->SDL_modelist[index] == NULL) {
225 SDL_free(mode); 232 SDL_OutOfMemory();
226 return(-1); 233 gapi->SDL_nummodes[index] = 0;
227 } 234 SDL_free(mode);
228 gapi->SDL_modelist[index][next_mode] = mode; 235 return (-1);
229 gapi->SDL_modelist[index][next_mode+1] = NULL; 236 }
230 gapi->SDL_nummodes[index]++; 237 gapi->SDL_modelist[index][next_mode] = mode;
231 238 gapi->SDL_modelist[index][next_mode + 1] = NULL;
232 return(0); 239 gapi->SDL_nummodes[index]++;
233 } 240
234 241 return (0);
235 static void GAPI_DeleteDevice(SDL_VideoDevice *device) 242 }
236 { 243
237 if( g_hGapiLib ) 244 static void
238 { 245 GAPI_DeleteDevice(SDL_VideoDevice * device)
239 FreeLibrary(g_hGapiLib); 246 {
240 g_hGapiLib = 0; 247 if (g_hGapiLib) {
241 } 248 FreeLibrary(g_hGapiLib);
242 SDL_free(device->hidden); 249 g_hGapiLib = 0;
243 SDL_free(device); 250 }
244 } 251 SDL_free(device->hidden);
245 252 SDL_free(device);
246 static SDL_VideoDevice *GAPI_CreateDevice(int devindex) 253 }
247 { 254
248 SDL_VideoDevice *device; 255 static SDL_VideoDevice *
249 256 GAPI_CreateDevice(int devindex)
250 if( !g_hGapiLib && !g_bRawBufferAvailable) 257 {
251 { 258 SDL_VideoDevice *device;
252 if( !GAPI_Available() ) 259
253 { 260 if (!g_hGapiLib && !g_bRawBufferAvailable) {
254 SDL_SetError("GAPI dll is not found and VGA mode is not available!"); 261 if (!GAPI_Available()) {
255 return 0; 262 SDL_SetError
256 } 263 ("GAPI dll is not found and VGA mode is not available!");
257 } 264 return 0;
258 265 }
259 /* Initialize all variables that we clean on shutdown */ 266 }
260 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); 267
261 if ( device ) { 268 /* Initialize all variables that we clean on shutdown */
262 SDL_memset(device, 0, (sizeof *device)); 269 device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
263 device->hidden = (struct SDL_PrivateVideoData *) 270 if (device) {
264 SDL_malloc((sizeof *device->hidden)); 271 SDL_memset(device, 0, (sizeof *device));
265 } 272 device->hidden = (struct SDL_PrivateVideoData *)
266 if ( (device == NULL) || (device->hidden == NULL) ) { 273 SDL_malloc((sizeof *device->hidden));
267 SDL_OutOfMemory(); 274 }
268 if ( device ) { 275 if ((device == NULL) || (device->hidden == NULL)) {
269 SDL_free(device); 276 SDL_OutOfMemory();
270 } 277 if (device) {
271 return(0); 278 SDL_free(device);
272 } 279 }
273 SDL_memset(device->hidden, 0, (sizeof *device->hidden)); 280 return (0);
274 281 }
275 /* Set the function pointers */ 282 SDL_memset(device->hidden, 0, (sizeof *device->hidden));
276 device->VideoInit = GAPI_VideoInit; 283
277 device->ListModes = GAPI_ListModes; 284 /* Set the function pointers */
278 device->SetVideoMode = GAPI_SetVideoMode; 285 device->VideoInit = GAPI_VideoInit;
279 device->UpdateMouse = WIN_UpdateMouse; 286 device->ListModes = GAPI_ListModes;
280 device->CreateYUVOverlay = NULL; 287 device->SetVideoMode = GAPI_SetVideoMode;
281 device->SetColors = GAPI_SetColors; 288 device->UpdateMouse = WIN_UpdateMouse;
282 device->UpdateRects = GAPI_UpdateRects; 289 device->CreateYUVOverlay = NULL;
283 device->VideoQuit = GAPI_VideoQuit; 290 device->SetColors = GAPI_SetColors;
284 device->AllocHWSurface = GAPI_AllocHWSurface; 291 device->UpdateRects = GAPI_UpdateRects;
285 device->CheckHWBlit = NULL; 292 device->VideoQuit = GAPI_VideoQuit;
286 device->FillHWRect = NULL; 293 device->AllocHWSurface = GAPI_AllocHWSurface;
287 device->SetHWColorKey = NULL; 294 device->CheckHWBlit = NULL;
288 device->SetHWAlpha = NULL; 295 device->FillHWRect = NULL;
289 device->LockHWSurface = GAPI_LockHWSurface; 296 device->SetHWColorKey = NULL;
290 device->UnlockHWSurface = GAPI_UnlockHWSurface; 297 device->SetHWAlpha = NULL;
291 device->FlipHWSurface = NULL; 298 device->LockHWSurface = GAPI_LockHWSurface;
292 device->FreeHWSurface = GAPI_FreeHWSurface; 299 device->UnlockHWSurface = GAPI_UnlockHWSurface;
293 device->SetCaption = WIN_SetWMCaption; 300 device->FlipHWSurface = NULL;
294 device->SetIcon = WIN_SetWMIcon; 301 device->FreeHWSurface = GAPI_FreeHWSurface;
295 device->IconifyWindow = WIN_IconifyWindow; 302 device->SetCaption = WIN_SetWMCaption;
296 device->GrabInput = WIN_GrabInput; 303 device->SetIcon = WIN_SetWMIcon;
297 device->GetWMInfo = WIN_GetWMInfo; 304 device->IconifyWindow = WIN_IconifyWindow;
298 device->FreeWMCursor = WIN_FreeWMCursor; 305 device->GrabInput = WIN_GrabInput;
299 device->CreateWMCursor = WIN_CreateWMCursor; 306 device->GetWMInfo = WIN_GetWMInfo;
300 device->ShowWMCursor = WIN_ShowWMCursor; 307 device->FreeWMCursor = WIN_FreeWMCursor;
301 device->WarpWMCursor = WIN_WarpWMCursor; 308 device->CreateWMCursor = WIN_CreateWMCursor;
309 device->ShowWMCursor = WIN_ShowWMCursor;
310 device->WarpWMCursor = WIN_WarpWMCursor;
302 device->CheckMouseMode = WIN_CheckMouseMode; 311 device->CheckMouseMode = WIN_CheckMouseMode;
303 device->InitOSKeymap = DIB_InitOSKeymap; 312 device->InitOSKeymap = DIB_InitOSKeymap;
304 device->PumpEvents = DIB_PumpEvents; 313 device->PumpEvents = DIB_PumpEvents;
305 314
306 /* Set up the windows message handling functions */ 315 /* Set up the windows message handling functions */
307 WIN_RealizePalette = GAPI_RealizePalette; 316 WIN_RealizePalette = GAPI_RealizePalette;
308 WIN_PaletteChanged = GAPI_PaletteChanged; 317 WIN_PaletteChanged = GAPI_PaletteChanged;
309 WIN_WinPAINT = GAPI_WinPAINT; 318 WIN_WinPAINT = GAPI_WinPAINT;
310 HandleMessage = DIB_HandleMessage; 319 HandleMessage = DIB_HandleMessage;
311 320
312 device->free = GAPI_DeleteDevice; 321 device->free = GAPI_DeleteDevice;
313 322
314 /* Load gapi library */ 323 /* Load gapi library */
315 #define gx device->hidden->gxFunc 324 #define gx device->hidden->gxFunc
316 325
317 LINK( GXOpenDisplay, gx.GXOpenDisplay, "?GXOpenDisplay@@YAHPAUHWND__@@K@Z" ) 326 LINK(GXOpenDisplay, gx.GXOpenDisplay,
318 LINK( GXCloseDisplay, gx.GXCloseDisplay, "?GXCloseDisplay@@YAHXZ" ) 327 "?GXOpenDisplay@@YAHPAUHWND__@@K@Z") LINK(GXCloseDisplay,
319 LINK( GXBeginDraw, gx.GXBeginDraw, "?GXBeginDraw@@YAPAXXZ" ) 328 gx.GXCloseDisplay,
320 LINK( GXEndDraw, gx.GXEndDraw, "?GXEndDraw@@YAHXZ" ) 329 "?GXCloseDisplay@@YAHXZ")
321 LINK( GXOpenInput, gx.GXOpenInput, "?GXOpenInput@@YAHXZ" ) 330 LINK(GXBeginDraw, gx.GXBeginDraw,
322 LINK( GXCloseInput, gx.GXCloseInput, "?GXCloseInput@@YAHXZ" ) 331 "?GXBeginDraw@@YAPAXXZ") LINK(GXEndDraw, gx.GXEndDraw,
323 LINK( GXGetDisplayProperties, gx.GXGetDisplayProperties,"?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ" ) 332 "?GXEndDraw@@YAHXZ")
324 LINK( GXGetDefaultKeys, gx.GXGetDefaultKeys, "?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z" ) 333 LINK(GXOpenInput, gx.GXOpenInput,
325 LINK( GXSuspend, gx.GXSuspend, "?GXSuspend@@YAHXZ" ) 334 "?GXOpenInput@@YAHXZ") LINK(GXCloseInput, gx.GXCloseInput,
326 LINK( GXResume, gx.GXResume, "?GXResume@@YAHXZ" ) 335 "?GXCloseInput@@YAHXZ")
327 LINK( GXSetViewport, gx.GXSetViewport, "?GXSetViewport@@YAHKKKK@Z" ) 336 LINK(GXGetDisplayProperties, gx.GXGetDisplayProperties,
328 LINK( GXIsDisplayDRAMBuffer, gx.GXIsDisplayDRAMBuffer, "?GXIsDisplayDRAMBuffer@@YAHXZ" ) 337 "?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ")
329 338 LINK(GXGetDefaultKeys, gx.GXGetDefaultKeys,
330 /* wrong gapi.dll */ 339 "?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z") LINK(GXSuspend,
331 if( !gx.GXOpenDisplay ) 340 gx.GXSuspend,
332 { 341 "?GXSuspend@@YAHXZ")
333 if( g_hGapiLib ) 342 LINK(GXResume, gx.GXResume, "?GXResume@@YAHXZ") LINK(GXSetViewport,
334 { 343 gx.
335 FreeLibrary(g_hGapiLib); 344 GXSetViewport,
336 g_hGapiLib = 0; 345 "?GXSetViewport@@YAHKKKK@Z")
337 } 346 LINK(GXIsDisplayDRAMBuffer, gx.GXIsDisplayDRAMBuffer,
338 } 347 "?GXIsDisplayDRAMBuffer@@YAHXZ")
339 348 /* wrong gapi.dll */
340 if( !gx.GXOpenDisplay && !g_bRawBufferAvailable) 349 if (!gx.GXOpenDisplay) {
341 { 350 if (g_hGapiLib) {
342 SDL_SetError("Error: damaged or unknown gapi.dll!\n"); 351 FreeLibrary(g_hGapiLib);
343 GAPI_DeleteDevice(device); 352 g_hGapiLib = 0;
344 return 0; 353 }
345 } 354 }
346 355
347 return device; 356 if (!gx.GXOpenDisplay && !g_bRawBufferAvailable) {
357 SDL_SetError("Error: damaged or unknown gapi.dll!\n");
358 GAPI_DeleteDevice(device);
359 return 0;
360 }
361
362 return device;
348 } 363 }
349 364
350 VideoBootStrap GAPI_bootstrap = { 365 VideoBootStrap GAPI_bootstrap = {
351 GAPIVID_DRIVER_NAME, "WinCE GAPI video driver", 366 GAPIVID_DRIVER_NAME, "WinCE GAPI video driver",
352 GAPI_Available, GAPI_CreateDevice 367 GAPI_Available, GAPI_CreateDevice
353 }; 368 };
354 369
355 static void FillStructs(_THIS, BOOL useVga) 370 static void
371 FillStructs(_THIS, BOOL useVga)
356 { 372 {
357 #ifdef _ARM_ 373 #ifdef _ARM_
358 WCHAR oemstr[100]; 374 WCHAR oemstr[100];
359 #endif 375 #endif
360 /* fill a device properties */ 376 /* fill a device properties */
361 377
362 if( !useVga ) 378 if (!useVga) {
363 { 379 this->hidden->gxProperties =
364 this->hidden->gxProperties = this->hidden->gxFunc.GXGetDisplayProperties(); 380 this->hidden->gxFunc.GXGetDisplayProperties();
365 this->hidden->needUpdate = 1; 381 this->hidden->needUpdate = 1;
366 this->hidden->hiresFix = 0; 382 this->hidden->hiresFix = 0;
367 this->hidden->useVga = 0; 383 this->hidden->useVga = 0;
368 this->hidden->useGXOpenDisplay = 1; 384 this->hidden->useGXOpenDisplay = 1;
369 385
370 #ifdef _ARM_ 386 #ifdef _ARM_
371 /* check some devices and extract addition info */ 387 /* check some devices and extract addition info */
372 SystemParametersInfo( SPI_GETOEMINFO, sizeof( oemstr ), oemstr, 0 ); 388 SystemParametersInfo(SPI_GETOEMINFO, sizeof(oemstr), oemstr, 0);
373 389
374 // buggy iPaq38xx 390 // buggy iPaq38xx
375 if ((oemstr[12] == 'H') && (oemstr[13] == '3') && (oemstr[14] == '8') && (this->hidden->gxProperties.cbxPitch > 0)) 391 if ((oemstr[12] == 'H') && (oemstr[13] == '3')
376 { 392 && (oemstr[14] == '8')
377 this->hidden->videoMem = (PIXEL*)0xac0755a0; 393 && (this->hidden->gxProperties.cbxPitch > 0)) {
378 this->hidden->gxProperties.cbxPitch = -640; 394 this->hidden->videoMem = (PIXEL *) 0xac0755a0;
379 this->hidden->gxProperties.cbyPitch = 2; 395 this->hidden->gxProperties.cbxPitch = -640;
380 this->hidden->needUpdate = 0; 396 this->hidden->gxProperties.cbyPitch = 2;
381 } 397 this->hidden->needUpdate = 0;
398 }
382 #if (EMULATE_AXIM_X30 == 0) 399 #if (EMULATE_AXIM_X30 == 0)
383 // buggy Dell Axim X30 400 // buggy Dell Axim X30
384 if( _tcsncmp(oemstr, L"Dell Axim X30", 13) == 0 ) 401 if (_tcsncmp(oemstr, L"Dell Axim X30", 13) == 0)
385 #endif 402 #endif
386 { 403 {
387 GXDeviceInfo gxInfo = {0}; 404 GXDeviceInfo gxInfo = { 0 };
388 HDC hdc = GetDC(NULL); 405 HDC hdc = GetDC(NULL);
389 int result; 406 int result;
390 407
391 gxInfo.Version = 100; 408 gxInfo.Version = 100;
392 result = ExtEscape(hdc, GETGXINFO, 0, NULL, sizeof(gxInfo), (char *)&gxInfo); 409 result =
393 if( result > 0 ) 410 ExtEscape(hdc, GETGXINFO, 0, NULL, sizeof(gxInfo),
394 { 411 (char *) &gxInfo);
395 this->hidden->useGXOpenDisplay = 0; 412 if (result > 0) {
396 this->hidden->videoMem = gxInfo.pvFrameBuffer; 413 this->hidden->useGXOpenDisplay = 0;
397 this->hidden->needUpdate = 0; 414 this->hidden->videoMem = gxInfo.pvFrameBuffer;
398 this->hidden->gxProperties.cbxPitch = 2; 415 this->hidden->needUpdate = 0;
399 this->hidden->gxProperties.cbyPitch = 480; 416 this->hidden->gxProperties.cbxPitch = 2;
400 this->hidden->gxProperties.cxWidth = gxInfo.cxWidth; 417 this->hidden->gxProperties.cbyPitch = 480;
401 this->hidden->gxProperties.cyHeight = gxInfo.cyHeight; 418 this->hidden->gxProperties.cxWidth = gxInfo.cxWidth;
402 this->hidden->gxProperties.ffFormat = gxInfo.ffFormat; 419 this->hidden->gxProperties.cyHeight = gxInfo.cyHeight;
403 } 420 this->hidden->gxProperties.ffFormat = gxInfo.ffFormat;
404 } 421 }
422 }
405 #endif 423 #endif
406 } else 424 } else {
407 { 425 this->hidden->needUpdate = 0;
408 this->hidden->needUpdate = 0; 426 this->hidden->hiresFix = 0;
409 this->hidden->hiresFix = 0; 427 this->hidden->gxProperties.cBPP = g_RawFrameBufferInfo.wBPP;
410 this->hidden->gxProperties.cBPP = g_RawFrameBufferInfo.wBPP; 428 this->hidden->gxProperties.cbxPitch = g_RawFrameBufferInfo.cxStride;
411 this->hidden->gxProperties.cbxPitch = g_RawFrameBufferInfo.cxStride; 429 this->hidden->gxProperties.cbyPitch = g_RawFrameBufferInfo.cyStride;
412 this->hidden->gxProperties.cbyPitch = g_RawFrameBufferInfo.cyStride; 430 this->hidden->gxProperties.cxWidth = g_RawFrameBufferInfo.cxPixels;
413 this->hidden->gxProperties.cxWidth = g_RawFrameBufferInfo.cxPixels; 431 this->hidden->gxProperties.cyHeight = g_RawFrameBufferInfo.cyPixels;
414 this->hidden->gxProperties.cyHeight = g_RawFrameBufferInfo.cyPixels; 432 this->hidden->videoMem = g_RawFrameBufferInfo.pFramePointer;
415 this->hidden->videoMem = g_RawFrameBufferInfo.pFramePointer; 433 this->hidden->useVga = 1;
416 this->hidden->useVga = 1; 434
417 435 switch (g_RawFrameBufferInfo.wFormat) {
418 switch( g_RawFrameBufferInfo.wFormat ) 436 case FORMAT_565:
419 { 437 this->hidden->gxProperties.ffFormat = kfDirect565;
420 case FORMAT_565: 438 break;
421 this->hidden->gxProperties.ffFormat = kfDirect565; 439 case FORMAT_555:
422 break; 440 this->hidden->gxProperties.ffFormat = kfDirect555;
423 case FORMAT_555: 441 break;
424 this->hidden->gxProperties.ffFormat = kfDirect555; 442 default:
425 break; 443 /* unknown pixel format, try define by BPP! */
426 default: 444 switch (g_RawFrameBufferInfo.wBPP) {
427 /* unknown pixel format, try define by BPP! */ 445 case 4:
428 switch( g_RawFrameBufferInfo.wBPP ) 446 case 8:
429 { 447 this->hidden->gxProperties.ffFormat = kfDirect;
430 case 4: 448 case 16:
431 case 8: 449 this->hidden->gxProperties.ffFormat = kfDirect565;
432 this->hidden->gxProperties.ffFormat = kfDirect; 450 default:
433 case 16: 451 this->hidden->gxProperties.ffFormat = kfDirect;
434 this->hidden->gxProperties.ffFormat = kfDirect565; 452 break;
435 default: 453 }
436 this->hidden->gxProperties.ffFormat = kfDirect; 454 }
437 break; 455 }
438 } 456
439 } 457 if (this->hidden->gxProperties.cBPP != 16) {
440 } 458 this->hidden->gapiOrientation = SDL_ORIENTATION_UP;
441 459 } else if ((this->hidden->gxProperties.cbxPitch > 0)
442 if( this->hidden->gxProperties.cBPP != 16 ) 460 && (this->hidden->gxProperties.cbyPitch > 0)) {
443 { 461 this->hidden->gapiOrientation = SDL_ORIENTATION_UP;
444 this->hidden->gapiOrientation = SDL_ORIENTATION_UP; 462 } else if ((this->hidden->gxProperties.cbxPitch > 0)
445 } else 463 && (this->hidden->gxProperties.cbyPitch < 0)) {
446 if( (this->hidden->gxProperties.cbxPitch > 0) && (this->hidden->gxProperties.cbyPitch > 0 )) 464 this->hidden->gapiOrientation = SDL_ORIENTATION_RIGHT; // ipaq 3660
447 { 465 } else if ((this->hidden->gxProperties.cbxPitch < 0)
448 this->hidden->gapiOrientation = SDL_ORIENTATION_UP; 466 && (this->hidden->gxProperties.cbyPitch > 0)) {
449 } else 467 this->hidden->gapiOrientation = SDL_ORIENTATION_LEFT; // ipaq 3800
450 if( (this->hidden->gxProperties.cbxPitch > 0) && (this->hidden->gxProperties.cbyPitch < 0 )) 468 }
451 { 469 }
452 this->hidden->gapiOrientation = SDL_ORIENTATION_RIGHT; // ipaq 3660 470
453 } else 471 static void
454 if( (this->hidden->gxProperties.cbxPitch < 0) && (this->hidden->gxProperties.cbyPitch > 0 )) 472 GAPI_CreatePalette(int ncolors, SDL_Color * colors)
455 { 473 {
456 this->hidden->gapiOrientation = SDL_ORIENTATION_LEFT; // ipaq 3800 474 // Setup a custom color palette
457 } 475 BYTE buffer[sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY)];
458 } 476 int i;
459 477 LOGPALETTE *pLogical = (LOGPALETTE *) buffer;
460 static void GAPI_CreatePalette(int ncolors, SDL_Color *colors) 478 PALETTEENTRY *entries = pLogical->palPalEntry;
461 { 479 HPALETTE hPalette;
462 // Setup a custom color palette 480 HDC hdc;
463 BYTE buffer[ sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY) ]; 481
464 int i; 482 for (i = 0; i < ncolors; ++i) {
465 LOGPALETTE* pLogical = (LOGPALETTE*)buffer; 483 // Find intensity by replicating the bit patterns over a byte
466 PALETTEENTRY* entries = pLogical->palPalEntry; 484 entries[i].peRed = colors[i].r;
467 HPALETTE hPalette; 485 entries[i].peGreen = colors[i].g;
468 HDC hdc; 486 entries[i].peBlue = colors[i].b;
469 487 entries[i].peFlags = 0;
470 for (i = 0; i < ncolors; ++i) 488 }
471 { 489
472 // Find intensity by replicating the bit patterns over a byte 490 // Create the GDI palette object
473 entries[i].peRed = colors[i].r; 491 pLogical->palVersion = 0x0300;
474 entries[i].peGreen = colors[i].g; 492 pLogical->palNumEntries = ncolors;
475 entries[i].peBlue = colors[i].b; 493
476 entries[i].peFlags = 0; 494 hPalette = CreatePalette(pLogical);
477 } 495 ASSERT(hPalette);
478 496
479 // Create the GDI palette object 497
480 pLogical->palVersion = 0x0300; 498 // Realize the palette
481 pLogical->palNumEntries = ncolors; 499 hdc = GetDC(0);
482 500
483 hPalette = CreatePalette( pLogical ); 501 SelectPalette(hdc, hPalette, FALSE);
484 ASSERT(hPalette); 502 RealizePalette(hdc);
485 503
486 504 ReleaseDC(0, hdc);
487 // Realize the palette 505 DeleteObject(hPalette);
488 hdc = GetDC(0); 506 }
489 507
490 SelectPalette( hdc, hPalette, FALSE ); 508 int
491 RealizePalette( hdc ); 509 GAPI_VideoInit(_THIS, SDL_PixelFormat * vformat)
492 510 {
493 ReleaseDC( 0, hdc ); 511 int i, bpp;
494 DeleteObject( hPalette ); 512
495 } 513 /* Create the window */
496 514 if (DIB_CreateWindow(this) < 0) {
497 int GAPI_VideoInit(_THIS, SDL_PixelFormat *vformat) 515 return (-1);
498 { 516 }
499 int i,bpp; 517
500 518 if (g_hGapiLib) {
501 /* Create the window */ 519 FillStructs(this, 0);
502 if ( DIB_CreateWindow(this) < 0 ) { 520
503 return(-1); 521 // SDL does not supports 2/4bpp mode, so use 16 bpp
504 } 522 bpp = gapi->gxProperties.cBPP < 8 ? 16 : gapi->gxProperties.cBPP;
505 523
506 if( g_hGapiLib ) 524 /* set up normal and landscape mode */
507 { 525 GAPI_AddMode(this, bpp, gapi->gxProperties.cyHeight,
508 FillStructs(this, 0); 526 gapi->gxProperties.cxWidth);
509 527 GAPI_AddMode(this, bpp, gapi->gxProperties.cxWidth,
510 // SDL does not supports 2/4bpp mode, so use 16 bpp 528 gapi->gxProperties.cyHeight);
511 bpp = gapi->gxProperties.cBPP < 8 ? 16 : gapi->gxProperties.cBPP; 529 }
512 530
513 /* set up normal and landscape mode */ 531 /* add hi-res mode */
514 GAPI_AddMode(this, bpp, gapi->gxProperties.cyHeight, gapi->gxProperties.cxWidth); 532 if (g_bRawBufferAvailable &&
515 GAPI_AddMode(this, bpp, gapi->gxProperties.cxWidth, gapi->gxProperties.cyHeight); 533 !((gapi->gxProperties.cxWidth ==
516 } 534 (unsigned) g_RawFrameBufferInfo.cxPixels)
517 535 && (gapi->gxProperties.cyHeight ==
518 /* add hi-res mode */ 536 (unsigned) g_RawFrameBufferInfo.cyPixels))) {
519 if( g_bRawBufferAvailable && 537 FillStructs(this, 1);
520 !((gapi->gxProperties.cxWidth == (unsigned)g_RawFrameBufferInfo.cxPixels) && (gapi->gxProperties.cyHeight == (unsigned)g_RawFrameBufferInfo.cyPixels))) 538
521 { 539 // SDL does not supports 2/4bpp mode, so use 16 bpp
522 FillStructs(this, 1); 540 bpp = gapi->gxProperties.cBPP < 8 ? 16 : gapi->gxProperties.cBPP;
523 541
524 // SDL does not supports 2/4bpp mode, so use 16 bpp 542 /* set up normal and landscape mode */
525 bpp = gapi->gxProperties.cBPP < 8 ? 16 : gapi->gxProperties.cBPP; 543 GAPI_AddMode(this, bpp, gapi->gxProperties.cyHeight,
526 544 gapi->gxProperties.cxWidth);
527 /* set up normal and landscape mode */ 545 GAPI_AddMode(this, bpp, gapi->gxProperties.cxWidth,
528 GAPI_AddMode(this, bpp, gapi->gxProperties.cyHeight, gapi->gxProperties.cxWidth); 546 gapi->gxProperties.cyHeight);
529 GAPI_AddMode(this, bpp, gapi->gxProperties.cxWidth, gapi->gxProperties.cyHeight); 547 }
530 } 548
531 549 /* Determine the current screen size */
532 /* Determine the current screen size */ 550 this->info.current_w = gapi->gxProperties.cxWidth;
533 this->info.current_w = gapi->gxProperties.cxWidth; 551 this->info.current_h = gapi->gxProperties.cyHeight;
534 this->info.current_h = gapi->gxProperties.cyHeight; 552
535 553 /* Sort the mode lists */
536 /* Sort the mode lists */ 554 for (i = 0; i < NUM_MODELISTS; ++i) {
537 for ( i=0; i<NUM_MODELISTS; ++i ) { 555 if (gapi->SDL_nummodes[i] > 0) {
538 if ( gapi->SDL_nummodes[i] > 0 ) { 556 SDL_qsort(gapi->SDL_modelist[i], gapi->SDL_nummodes[i],
539 SDL_qsort(gapi->SDL_modelist[i], gapi->SDL_nummodes[i], sizeof *gapi->SDL_modelist[i], cmpmodes); 557 sizeof *gapi->SDL_modelist[i], cmpmodes);
540 } 558 }
541 } 559 }
542 560
543 vformat->BitsPerPixel = this->hidden->gxProperties.cBPP < 8 ? 16 : (unsigned char)this->hidden->gxProperties.cBPP; 561 vformat->BitsPerPixel =
544 562 this->hidden->gxProperties.cBPP <
545 // Get color mask 563 8 ? 16 : (unsigned char) this->hidden->gxProperties.cBPP;
546 if (this->hidden->gxProperties.ffFormat & kfDirect565) { 564
547 vformat->BitsPerPixel = 16; 565 // Get color mask
548 vformat->Rmask = 0x0000f800; 566 if (this->hidden->gxProperties.ffFormat & kfDirect565) {
549 vformat->Gmask = 0x000007e0; 567 vformat->BitsPerPixel = 16;
550 vformat->Bmask = 0x0000001f; 568 vformat->Rmask = 0x0000f800;
551 this->hidden->videoMode = GAPI_DIRECT_565; 569 vformat->Gmask = 0x000007e0;
552 } 570 vformat->Bmask = 0x0000001f;
553 else 571 this->hidden->videoMode = GAPI_DIRECT_565;
554 if (this->hidden->gxProperties.ffFormat & kfDirect555) { 572 } else if (this->hidden->gxProperties.ffFormat & kfDirect555) {
555 vformat->BitsPerPixel = 16; 573 vformat->BitsPerPixel = 16;
556 vformat->Rmask = 0x00007c00; 574 vformat->Rmask = 0x00007c00;
557 vformat->Gmask = 0x000003e0; 575 vformat->Gmask = 0x000003e0;
558 vformat->Bmask = 0x0000001f; 576 vformat->Bmask = 0x0000001f;
559 this->hidden->videoMode = GAPI_DIRECT_555; 577 this->hidden->videoMode = GAPI_DIRECT_555;
560 } 578 } else if ((this->hidden->gxProperties.ffFormat & kfDirect)
561 else 579 && (this->hidden->gxProperties.cBPP < 8)) {
562 if ((this->hidden->gxProperties.ffFormat & kfDirect) && (this->hidden->gxProperties.cBPP < 8)) { 580 // We'll perform the conversion
563 // We'll perform the conversion 581 vformat->BitsPerPixel = 16;
564 vformat->BitsPerPixel = 16; 582 vformat->Rmask = 0x0000f800; // 16 bit 565
565 vformat->Rmask = 0x0000f800; // 16 bit 565 583 vformat->Gmask = 0x000007e0;
566 vformat->Gmask = 0x000007e0; 584 vformat->Bmask = 0x0000001f;
567 vformat->Bmask = 0x0000001f; 585 if (this->hidden->gxProperties.ffFormat & kfDirectInverted)
568 if (this->hidden->gxProperties.ffFormat & kfDirectInverted) 586 this->hidden->invert = (1 << this->hidden->gxProperties.cBPP) - 1;
569 this->hidden->invert = (1 << this->hidden->gxProperties.cBPP) - 1; 587 this->hidden->colorscale =
570 this->hidden->colorscale = this->hidden->gxProperties.cBPP < 8 ? 8 - this->hidden->gxProperties.cBPP : 0; 588 this->hidden->gxProperties.cBPP <
571 this->hidden->videoMode = GAPI_MONO; 589 8 ? 8 - this->hidden->gxProperties.cBPP : 0;
572 } 590 this->hidden->videoMode = GAPI_MONO;
573 else 591 } else if (this->hidden->gxProperties.ffFormat & kfPalette) {
574 if (this->hidden->gxProperties.ffFormat & kfPalette) { 592 this->hidden->videoMode = GAPI_PALETTE;
575 this->hidden->videoMode = GAPI_PALETTE; 593 }
576 } 594
577 595 /* We're done! */
578 /* We're done! */ 596 return (0);
579 return(0); 597 }
580 } 598
581 599 SDL_Rect **
582 SDL_Rect **GAPI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) 600 GAPI_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
583 { 601 {
584 return(this->hidden->SDL_modelist[((format->BitsPerPixel+7)/8)-1]); 602 return (this->hidden->SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1]);
585 // return (SDL_Rect **) -1; 603 // return (SDL_Rect **) -1;
586 } 604 }
587 605
588 SDL_Surface *GAPI_SetVideoMode(_THIS, SDL_Surface *current, 606 SDL_Surface *
589 int width, int height, int bpp, Uint32 flags) 607 GAPI_SetVideoMode(_THIS, SDL_Surface * current,
590 { 608 int width, int height, int bpp, Uint32 flags)
591 SDL_Surface *video; 609 {
592 Uint32 Rmask, Gmask, Bmask; 610 SDL_Surface *video;
593 DWORD style; 611 Uint32 Rmask, Gmask, Bmask;
594 SDL_Rect allScreen; 612 DWORD style;
595 613 SDL_Rect allScreen;
596 if( bpp < 4 ) 614
597 { 615 if (bpp < 4) {
598 SDL_SetError("1 bpp and 2 bpp modes is not implemented yet!"); 616 SDL_SetError("1 bpp and 2 bpp modes is not implemented yet!");
599 return 0; 617 return 0;
600 } 618 }
601 619
602 /* Recalculate bitmasks if necessary */ 620 /* Recalculate bitmasks if necessary */
603 if (bpp == current->format->BitsPerPixel) { 621 if (bpp == current->format->BitsPerPixel) {
604 video = current; 622 video = current;
605 } 623 } else {
606 else { 624 switch (bpp) {
607 switch(bpp) { 625 case 8:
608 case 8: 626 Rmask = 0;
609 Rmask = 0; 627 Gmask = 0;
610 Gmask = 0; 628 Bmask = 0;
611 Bmask = 0; 629 break;
612 break; 630 case 15:
613 case 15: 631 case 16:
614 case 16: 632 /* Default is 565 unless the display is specifically 555 */
615 /* Default is 565 unless the display is specifically 555 */ 633 if (this->hidden->gxProperties.ffFormat & kfDirect555) {
616 if (this->hidden->gxProperties.ffFormat & kfDirect555) { 634 Rmask = 0x00007c00;
617 Rmask = 0x00007c00; 635 Gmask = 0x000003e0;
618 Gmask = 0x000003e0; 636 Bmask = 0x0000001f;
619 Bmask = 0x0000001f; 637 } else {
620 } 638 Rmask = 0x0000f800;
621 else { 639 Gmask = 0x000007e0;
622 Rmask = 0x0000f800; 640 Bmask = 0x0000001f;
623 Gmask = 0x000007e0; 641 }
624 Bmask = 0x0000001f; 642 break;
625 } 643 case 24:
626 break; 644 case 32:
627 case 24: 645 Rmask = 0x00ff0000;
628 case 32: 646 Gmask = 0x0000ff00;
629 Rmask = 0x00ff0000; 647 Bmask = 0x000000ff;
630 Gmask = 0x0000ff00; 648 break;
631 Bmask = 0x000000ff; 649 default:
632 break; 650 SDL_SetError("Unsupported Bits Per Pixel format requested");
633 default: 651 return NULL;
634 SDL_SetError("Unsupported Bits Per Pixel format requested"); 652 }
635 return NULL; 653 video = SDL_CreateRGBSurface(SDL_SWSURFACE,
636 } 654 0, 0, bpp, Rmask, Gmask, Bmask, 0);
637 video = SDL_CreateRGBSurface(SDL_SWSURFACE, 655 if (video == NULL) {
638 0, 0, bpp, Rmask, Gmask, Bmask, 0); 656 SDL_OutOfMemory();
639 if ( video == NULL ) { 657 return (NULL);
640 SDL_OutOfMemory(); 658 }
641 return(NULL); 659 }
642 } 660
643 } 661 gapi->userOrientation = SDL_ORIENTATION_UP;
644 662 video->flags = SDL_FULLSCREEN; /* Clear flags, GAPI supports fullscreen only */
645 gapi->userOrientation = SDL_ORIENTATION_UP; 663
646 video->flags = SDL_FULLSCREEN; /* Clear flags, GAPI supports fullscreen only */ 664 /* GAPI or VGA? */
647 665 if (g_hGapiLib) {
648 /* GAPI or VGA? */ 666 FillStructs(this, 0);
649 if( g_hGapiLib ) 667 if ((((unsigned) width != gapi->gxProperties.cxWidth)
650 { 668 || ((unsigned) height != gapi->gxProperties.cyHeight))
651 FillStructs(this, 0); 669 && (((unsigned) width != gapi->gxProperties.cyHeight)
652 if( (((unsigned)width != gapi->gxProperties.cxWidth) || ((unsigned)height != gapi->gxProperties.cyHeight)) 670 || ((unsigned) height != gapi->gxProperties.cxWidth)))
653 && (((unsigned)width != gapi->gxProperties.cyHeight) || ((unsigned)height != gapi->gxProperties.cxWidth))) 671 FillStructs(this, 1); // gapi is found but we use VGA resolution
654 FillStructs(this, 1); // gapi is found but we use VGA resolution 672 } else
655 } else 673 FillStructs(this, 1);
656 FillStructs(this, 1); 674
657 675 if (!this->hidden->needUpdate && !this->hidden->videoMem) {
658 if ( !this->hidden->needUpdate && !this->hidden->videoMem) { 676 SDL_SetError
659 SDL_SetError("Couldn't get address of video memory, may be unsupported device or bug"); 677 ("Couldn't get address of video memory, may be unsupported device or bug");
660 return(NULL); 678 return (NULL);
661 } 679 }
662 680
663 /* detect user landscape mode */ 681 /* detect user landscape mode */
664 if( (width > height) && (GetSystemMetrics(SM_CXSCREEN) < GetSystemMetrics(SM_CYSCREEN))) 682 if ((width > height)
665 gapi->userOrientation = SDL_ORIENTATION_RIGHT; 683 && (GetSystemMetrics(SM_CXSCREEN) < GetSystemMetrics(SM_CYSCREEN)))
666 684 gapi->userOrientation = SDL_ORIENTATION_RIGHT;
667 /* shall we apply hires fix? for example when we do not use hires resource */ 685
668 gapi->hiresFix = 0; 686 /* shall we apply hires fix? for example when we do not use hires resource */
669 if( gapi->userOrientation == SDL_ORIENTATION_RIGHT ) 687 gapi->hiresFix = 0;
670 { 688 if (gapi->userOrientation == SDL_ORIENTATION_RIGHT) {
671 if( (width > GetSystemMetrics(SM_CYSCREEN)) || (height > GetSystemMetrics(SM_CXSCREEN))) 689 if ((width > GetSystemMetrics(SM_CYSCREEN))
672 gapi->hiresFix = 1; 690 || (height > GetSystemMetrics(SM_CXSCREEN)))
673 } else 691 gapi->hiresFix = 1;
674 if( (width > GetSystemMetrics(SM_CXSCREEN)) || (height > GetSystemMetrics(SM_CYSCREEN))) 692 } else if ((width > GetSystemMetrics(SM_CXSCREEN))
675 if( !((width == GetSystemMetrics(SM_CYSCREEN)) && (height == GetSystemMetrics(SM_CXSCREEN)))) // user portrait, device landscape 693 || (height > GetSystemMetrics(SM_CYSCREEN)))
676 gapi->hiresFix = 1; 694 if (!((width == GetSystemMetrics(SM_CYSCREEN)) && (height == GetSystemMetrics(SM_CXSCREEN)))) // user portrait, device landscape
677 695 gapi->hiresFix = 1;
678 switch( gapi->userOrientation ) 696
679 { 697 switch (gapi->userOrientation) {
680 case SDL_ORIENTATION_UP: 698 case SDL_ORIENTATION_UP:
681 gapi->startOffset = 0; 699 gapi->startOffset = 0;
682 gapi->dstLineStep = gapi->gxProperties.cbyPitch; 700 gapi->dstLineStep = gapi->gxProperties.cbyPitch;
683 gapi->dstPixelStep = gapi->gxProperties.cbxPitch; 701 gapi->dstPixelStep = gapi->gxProperties.cbxPitch;
684 break; 702 break;
685 case SDL_ORIENTATION_RIGHT: 703 case SDL_ORIENTATION_RIGHT:
686 switch( gapi->gapiOrientation ) 704 switch (gapi->gapiOrientation) {
687 { 705 case SDL_ORIENTATION_UP:
688 case SDL_ORIENTATION_UP: 706 case SDL_ORIENTATION_RIGHT:
689 case SDL_ORIENTATION_RIGHT: 707 case SDL_ORIENTATION_LEFT:
690 case SDL_ORIENTATION_LEFT: 708 if ((this->hidden->videoMode == GAPI_MONO))
691 if( (this->hidden->videoMode == GAPI_MONO) ) 709 gapi->startOffset = -gapi->gxProperties.cbxPitch + 1; // monochrome mode
692 gapi->startOffset = -gapi->gxProperties.cbxPitch + 1; // monochrome mode 710 else
693 else 711 gapi->startOffset =
694 gapi->startOffset = gapi->gxProperties.cbyPitch * (gapi->gxProperties.cyHeight - 1); 712 gapi->gxProperties.cbyPitch *
695 713 (gapi->gxProperties.cyHeight - 1);
696 gapi->dstLineStep = gapi->gxProperties.cbxPitch; 714
697 gapi->dstPixelStep = -gapi->gxProperties.cbyPitch; 715 gapi->dstLineStep = gapi->gxProperties.cbxPitch;
698 break; 716 gapi->dstPixelStep = -gapi->gxProperties.cbyPitch;
699 } 717 break;
700 } 718 }
701 719 }
702 video->w = this->hidden->w = width; 720
703 video->h = this->hidden->h = height; 721 video->w = this->hidden->w = width;
704 video->pitch = SDL_CalculatePitch(video); 722 video->h = this->hidden->h = height;
705 723 video->pitch = SDL_CalculatePitch(video);
706 /* Small fix for WinCE/Win32 - when activating window 724
707 SDL_VideoSurface is equal to zero, so activating code 725 /* Small fix for WinCE/Win32 - when activating window
708 is not called properly for fullscreen windows because 726 SDL_VideoSurface is equal to zero, so activating code
709 macros WINDIB_FULLSCREEN uses SDL_VideoSurface 727 is not called properly for fullscreen windows because
710 */ 728 macros WINDIB_FULLSCREEN uses SDL_VideoSurface
711 SDL_VideoSurface = video; 729 */
712 730 SDL_VideoSurface = video;
713 /* GAPI is always fullscreen, title bar is useless */ 731
714 style = 0; 732 /* GAPI is always fullscreen, title bar is useless */
715 733 style = 0;
716 if (!SDL_windowid) 734
717 SetWindowLong(SDL_Window, GWL_STYLE, style); 735 if (!SDL_windowid)
718 736 SetWindowLong(SDL_Window, GWL_STYLE, style);
719 /* Allocate bitmap */ 737
720 if(gapiBuffer) 738 /* Allocate bitmap */
721 { 739 if (gapiBuffer) {
722 SDL_free(gapiBuffer); 740 SDL_free(gapiBuffer);
723 gapiBuffer = NULL; 741 gapiBuffer = NULL;
724 } 742 }
725 gapiBuffer = SDL_malloc(video->h * video->pitch); 743 gapiBuffer = SDL_malloc(video->h * video->pitch);
726 video->pixels = gapiBuffer; 744 video->pixels = gapiBuffer;
727 745
728 if ( ! this->hidden->buffer ) { 746 if (!this->hidden->buffer) {
729 SDL_SetError("Couldn't allocate buffer for requested mode"); 747 SDL_SetError("Couldn't allocate buffer for requested mode");
730 return(NULL); 748 return (NULL);
731 } 749 }
732 750
733 SDL_memset(gapiBuffer, 255, video->h * video->pitch); 751 SDL_memset(gapiBuffer, 255, video->h * video->pitch);
734 MoveWindow(SDL_Window, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), FALSE); 752 MoveWindow(SDL_Window, 0, 0, GetSystemMetrics(SM_CXSCREEN),
735 ShowWindow(SDL_Window, SW_SHOW); 753 GetSystemMetrics(SM_CYSCREEN), FALSE);
736 SetForegroundWindow(SDL_Window); 754 ShowWindow(SDL_Window, SW_SHOW);
737 755 SetForegroundWindow(SDL_Window);
738 /* JC 14 Mar 2006 756
739 Flush the message loop or this can cause big problems later 757 /* JC 14 Mar 2006
740 Especially if the user decides to use dialog boxes or assert()! 758 Flush the message loop or this can cause big problems later
741 */ 759 Especially if the user decides to use dialog boxes or assert()!
742 WIN_FlushMessageQueue(); 760 */
743 761 WIN_FlushMessageQueue();
744 /* Open GAPI display */ 762
745 if( !gapi->useVga && this->hidden->useGXOpenDisplay ) 763 /* Open GAPI display */
746 if( !gapi->gxFunc.GXOpenDisplay(SDL_Window, GX_FULLSCREEN) ) 764 if (!gapi->useVga && this->hidden->useGXOpenDisplay)
747 { 765 if (!gapi->gxFunc.GXOpenDisplay(SDL_Window, GX_FULLSCREEN)) {
748 SDL_SetError("Couldn't initialize GAPI"); 766 SDL_SetError("Couldn't initialize GAPI");
749 return(NULL); 767 return (NULL);
750 } 768 }
751
752 #if REPORT_VIDEO_INFO 769 #if REPORT_VIDEO_INFO
753 printf("Video properties:\n"); 770 printf("Video properties:\n");
754 printf("display bpp: %d\n", gapi->gxProperties.cBPP); 771 printf("display bpp: %d\n", gapi->gxProperties.cBPP);
755 printf("display width: %d\n", gapi->gxProperties.cxWidth); 772 printf("display width: %d\n", gapi->gxProperties.cxWidth);
756 printf("display height: %d\n", gapi->gxProperties.cyHeight); 773 printf("display height: %d\n", gapi->gxProperties.cyHeight);
757 printf("x pitch: %d\n", gapi->gxProperties.cbxPitch); 774 printf("x pitch: %d\n", gapi->gxProperties.cbxPitch);
758 printf("y pitch: %d\n", gapi->gxProperties.cbyPitch); 775 printf("y pitch: %d\n", gapi->gxProperties.cbyPitch);
759 printf("gapi flags: 0x%x\n", gapi->gxProperties.ffFormat); 776 printf("gapi flags: 0x%x\n", gapi->gxProperties.ffFormat);
760 777
761 if( !gapi->useVga && this->hidden->useGXOpenDisplay && gapi->needUpdate) 778 if (!gapi->useVga && this->hidden->useGXOpenDisplay && gapi->needUpdate) {
762 { 779 gapi->videoMem = gapi->gxFunc.GXBeginDraw();
763 gapi->videoMem = gapi->gxFunc.GXBeginDraw(); 780 gapi->gxFunc.GXEndDraw();
764 gapi->gxFunc.GXEndDraw(); 781 }
765 } 782
766 783 printf("video memory: 0x%x\n", gapi->videoMem);
767 printf("video memory: 0x%x\n", gapi->videoMem); 784 printf("need update: %d\n", gapi->needUpdate);
768 printf("need update: %d\n", gapi->needUpdate); 785 printf("hi-res fix: %d\n", gapi->hiresFix);
769 printf("hi-res fix: %d\n", gapi->hiresFix); 786 printf("VGA is available on the device: %d\n", g_bRawBufferAvailable);
770 printf("VGA is available on the device: %d\n", g_bRawBufferAvailable); 787 printf("use raw framebuffer: %d\n", gapi->useVga);
771 printf("use raw framebuffer: %d\n", gapi->useVga); 788 printf("video surface bpp: %d\n", video->format->BitsPerPixel);
772 printf("video surface bpp: %d\n", video->format->BitsPerPixel); 789 printf("video surface width: %d\n", video->w);
773 printf("video surface width: %d\n", video->w); 790 printf("video surface height: %d\n", video->h);
774 printf("video surface height: %d\n", video->h);
775 #endif 791 #endif
776 792
777 793
778 /* Blank screen */ 794 /* Blank screen */
779 allScreen.x = allScreen.y = 0; 795 allScreen.x = allScreen.y = 0;
780 allScreen.w = video->w - 1; 796 allScreen.w = video->w - 1;
781 allScreen.h = video->h - 1; 797 allScreen.h = video->h - 1;
782 GAPI_UpdateRects(this, 1, &allScreen); 798 GAPI_UpdateRects(this, 1, &allScreen);
783 799
784 /* We're done */ 800 /* We're done */
785 return(video); 801 return (video);
786 } 802 }
787 803
788 /* We don't actually allow hardware surfaces other than the main one */ 804 /* We don't actually allow hardware surfaces other than the main one */
789 static int GAPI_AllocHWSurface(_THIS, SDL_Surface *surface) 805 static int
790 { 806 GAPI_AllocHWSurface(_THIS, SDL_Surface * surface)
791 return(-1); 807 {
792 } 808 return (-1);
793 static void GAPI_FreeHWSurface(_THIS, SDL_Surface *surface) 809 }
794 { 810 static void
795 return; 811 GAPI_FreeHWSurface(_THIS, SDL_Surface * surface)
812 {
813 return;
796 } 814 }
797 815
798 /* We need to wait for vertical retrace on page flipped displays */ 816 /* We need to wait for vertical retrace on page flipped displays */
799 static int GAPI_LockHWSurface(_THIS, SDL_Surface *surface) 817 static int
800 { 818 GAPI_LockHWSurface(_THIS, SDL_Surface * surface)
801 return(0); 819 {
802 } 820 return (0);
803 821 }
804 static void GAPI_UnlockHWSurface(_THIS, SDL_Surface *surface) 822
805 { 823 static void
806 return; 824 GAPI_UnlockHWSurface(_THIS, SDL_Surface * surface)
807 } 825 {
808 826 return;
809 static int updateLine8to8(_THIS, unsigned char *srcPointer, unsigned char *destPointer, int width, int height, int lines) 827 }
810 { 828
811 if( gapi->dstPixelStep == 1) /* optimized blitting on most devices */ 829 static int
812 { 830 updateLine8to8(_THIS, unsigned char *srcPointer, unsigned char *destPointer,
813 SDL_memcpy(destPointer, srcPointer, width); 831 int width, int height, int lines)
814 return 1; 832 {
815 } else 833 if (gapi->dstPixelStep == 1) { /* optimized blitting on most devices */
816 { 834 SDL_memcpy(destPointer, srcPointer, width);
817 // TODO: read 4 pixels, write DWORD 835 return 1;
818 int step = gapi->dstPixelStep; 836 } else {
819 while(width--) 837 // TODO: read 4 pixels, write DWORD
820 { 838 int step = gapi->dstPixelStep;
821 *destPointer = *srcPointer++; 839 while (width--) {
822 destPointer += step; 840 *destPointer = *srcPointer++;
823 } 841 destPointer += step;
824 } 842 }
825 return 1; 843 }
844 return 1;
826 } 845 }
827 846
828 /* Video memory is very slow so lets optimize as much as possible */ 847 /* Video memory is very slow so lets optimize as much as possible */
829 static int updateLine16to16(_THIS, PIXEL *srcPointer, PIXEL *destPointer, int width, int height, int lines) 848 static int
830 { 849 updateLine16to16(_THIS, PIXEL * srcPointer, PIXEL * destPointer, int width,
831 PIXEL *line1, *line2; 850 int height, int lines)
832 int step = gapi->dstPixelStep / 2; 851 {
833 852 PIXEL *line1, *line2;
834 if( step == 1 ) /* optimized blitting on most devices */ 853 int step = gapi->dstPixelStep / 2;
835 { 854
836 SDL_memcpy(destPointer, srcPointer, width * sizeof(PIXEL)); 855 if (step == 1) { /* optimized blitting on most devices */
837 return 1; 856 SDL_memcpy(destPointer, srcPointer, width * sizeof(PIXEL));
838 } 857 return 1;
839 else 858 } else {
840 { 859 if ((gapi->gapiOrientation != SDL_ORIENTATION_UP) && (gapi->userOrientation == SDL_ORIENTATION_UP)) // iPaq 3660/3800 and user orientation up
841 if( (gapi->gapiOrientation != SDL_ORIENTATION_UP) && 860 {
842 (gapi->userOrientation == SDL_ORIENTATION_UP )) // iPaq 3660/3800 and user orientation up 861 // to prevent data misalignment copy only one line
843 { 862 if (((((unsigned) destPointer & 3) != 0)
844 // to prevent data misalignment copy only one line 863 && (gapi->gapiOrientation == SDL_ORIENTATION_LEFT))
845 if( ((((unsigned)destPointer & 3) != 0) && (gapi->gapiOrientation == SDL_ORIENTATION_LEFT)) 864 || ((((unsigned) destPointer & 3) == 0)
846 || ((((unsigned)destPointer & 3) == 0) && (gapi->gapiOrientation != SDL_ORIENTATION_LEFT)) 865 && (gapi->gapiOrientation != SDL_ORIENTATION_LEFT))
847 || (lines == 1) ) 866 || (lines == 1)) {
848 { 867 while (width--) {
849 while(width--) 868 *destPointer = *srcPointer++;
850 { 869 destPointer += step;
851 *destPointer = *srcPointer++; 870 }
852 destPointer += step; 871 return 1;
853 } 872 }
854 return 1; 873
855 } 874 /* read two lines at the same time, write DWORD */
856 875 line1 = srcPointer;
857 /* read two lines at the same time, write DWORD */ 876 line2 = srcPointer + SDL_VideoSurface->pitch / 2;
858 line1 = srcPointer; 877
859 line2 = srcPointer + SDL_VideoSurface->pitch / 2; 878 if (gapi->gapiOrientation == SDL_ORIENTATION_LEFT)
860 879 while (width--) // iPaq 3800
861 if( gapi->gapiOrientation == SDL_ORIENTATION_LEFT ) 880 {
862 while(width--) // iPaq 3800 881 *(DWORD *) destPointer = (*line2++ << 16) | *line1++;
863 { 882 destPointer += step;
864 *(DWORD*)destPointer =(*line2++ << 16) | *line1++; 883 } else {
865 destPointer += step; 884 destPointer += gapi->gxProperties.cbyPitch / 2;
866 } 885
867 else 886 while (width--) // iPaq 3660
868 { 887 {
869 destPointer += gapi->gxProperties.cbyPitch / 2; 888 *(DWORD *) destPointer = (*line1++ << 16) | *line2++;
870 889 destPointer += step;
871 while(width--) // iPaq 3660 890 }
872 { 891 }
873 *(DWORD*)destPointer =(*line1++ << 16) | *line2++; 892 return 2;
874 destPointer += step; 893 } else {
875 } 894 // iPaq 3800 and user orientation landscape
876 } 895 if (gapi->gapiOrientation == SDL_ORIENTATION_LEFT) {
877 return 2; 896 int w1;
878 } else 897
879 { 898 // to prevent data misalignment copy only one pixel
880 // iPaq 3800 and user orientation landscape 899 if ((((unsigned) destPointer & 3) == 0) && (width > 0)) {
881 if( gapi->gapiOrientation == SDL_ORIENTATION_LEFT ) 900 *destPointer-- = *srcPointer++;
882 { 901 width--;
883 int w1; 902 }
884 903
885 // to prevent data misalignment copy only one pixel 904 destPointer--;
886 if( (((unsigned)destPointer & 3) == 0) && (width > 0)) 905
887 { 906 w1 = width / 2;
888 *destPointer-- = *srcPointer++; 907
889 width--; 908 while (w1--) {
890 } 909 DWORD p = *(DWORD *) srcPointer;
891 910 *((DWORD *) destPointer) = (p << 16) | (p >> 16);
892 destPointer--; 911 destPointer -= 2;
893 912 srcPointer += 2;
894 w1 = width / 2; 913 }
895 914
896 while(w1--) 915 if (width & 1) // copy the last pixel
897 { 916 {
898 DWORD p = *(DWORD*)srcPointer; 917 destPointer++;
899 *((DWORD*)destPointer) = (p << 16) | (p >> 16); 918 *destPointer = *srcPointer;
900 destPointer -= 2; 919 }
901 srcPointer += 2; 920
902 } 921 return 1;
903 922 }
904 if( width & 1 ) // copy the last pixel 923 // modern iPaqs and user orientation landscape
905 { 924 // read two pixels, write DWORD
906 destPointer++; 925
907 *destPointer = *srcPointer; 926 line1 = srcPointer;
908 } 927 line2 = srcPointer + SDL_VideoSurface->pitch / 2;
909 928
910 return 1; 929 if ((((unsigned) destPointer & 3) != 0) || (lines == 1)) {
911 } 930 while (width--) {
912 931 *destPointer = *srcPointer++;
913 // modern iPaqs and user orientation landscape 932 destPointer += step;
914 // read two pixels, write DWORD 933 }
915 934 return 1;
916 line1 = srcPointer; 935 }
917 line2 = srcPointer + SDL_VideoSurface->pitch / 2; 936
918 937 while (width--) {
919 if( (((unsigned)destPointer & 3) != 0) || (lines == 1) ) 938 *(DWORD *) destPointer = (*line2++ << 16) | *line1++;
920 { 939 destPointer -= gapi->gxProperties.cbyPitch / 2;
921 while(width--) 940 }
922 { 941 return 2;
923 *destPointer = *srcPointer++; 942 }
924 destPointer += step; 943 }
925 }
926 return 1;
927 }
928
929 while(width--)
930 {
931 *(DWORD*)destPointer =(*line2++ << 16) | *line1++;
932 destPointer -= gapi->gxProperties.cbyPitch / 2;
933 }
934 return 2;
935 }
936 }
937 } 944 }
938 945
939 // Color component masks for 565 946 // Color component masks for 565
940 #define REDMASK (31<<11) 947 #define REDMASK (31<<11)
941 #define GREENMASK (63<<5) 948 #define GREENMASK (63<<5)
942 #define BLUEMASK (31) 949 #define BLUEMASK (31)
943 950
944 951
945 static int updateLine16to4(_THIS, PIXEL *srcPointer, unsigned char *destPointer, int width, int height, int lines, int yNibble, int xNibble) 952 static int
946 { 953 updateLine16to4(_THIS, PIXEL * srcPointer, unsigned char *destPointer,
947 PIXEL *line1, *line2; 954 int width, int height, int lines, int yNibble, int xNibble)
948 int step = gapi->dstPixelStep; 955 {
949 956 PIXEL *line1, *line2;
950 if( gapi->userOrientation == SDL_ORIENTATION_UP ) 957 int step = gapi->dstPixelStep;
951 { 958
952 if( yNibble ) // copy bottom half of a line 959 if (gapi->userOrientation == SDL_ORIENTATION_UP) {
953 { 960 if (yNibble) // copy bottom half of a line
954 while(width--) 961 {
955 { 962 while (width--) {
956 PIXEL c1 = *srcPointer++; 963 PIXEL c1 = *srcPointer++;
957 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK); 964 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) +
958 *destPointer = (*destPointer & 0x0F) | ((~(c1 >> 3) << 4)); 965 (c1 & BLUEMASK);
959 destPointer += step; 966 *destPointer = (*destPointer & 0x0F) | ((~(c1 >> 3) << 4));
960 } 967 destPointer += step;
961 return 1; 968 }
962 } 969 return 1;
963 970 }
964 // either 1 pixel picture or tail, anyway this is the last line 971 // either 1 pixel picture or tail, anyway this is the last line
965 if( lines == 1 ) 972 if (lines == 1) {
966 { 973 while (width--) {
967 while(width--) 974 PIXEL c1 = *srcPointer++;
968 { 975 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) +
969 PIXEL c1 = *srcPointer++; 976 (c1 & BLUEMASK);
970 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK); 977 *destPointer = (*destPointer & 0xF0) | ((~(c1 >> 3) & 0xF));
971 *destPointer = (*destPointer & 0xF0) | ((~(c1 >> 3) & 0xF)); 978 destPointer += step;
972 destPointer += step; 979 }
973 } 980 return 1;
974 return 1; 981 }
975 } 982
976 983 line1 = srcPointer;
977 line1 = srcPointer; 984 line2 = srcPointer + SDL_VideoSurface->pitch / 2;
978 line2 = srcPointer + SDL_VideoSurface->pitch / 2; 985
979 986 while (width--) {
980 while(width--) 987 PIXEL c1 = *line1++;
981 { 988 PIXEL c2 = *line2++;
982 PIXEL c1 = *line1++; 989 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) +
983 PIXEL c2 = *line2++; 990 (c1 & BLUEMASK);
984 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK); 991 c2 = ((c2 & REDMASK) >> 11) + ((c2 & GREENMASK) >> 5) +
985 c2 = ((c2 & REDMASK) >> 11) + ((c2 & GREENMASK) >> 5) + (c2 & BLUEMASK); 992 (c2 & BLUEMASK);
986 *destPointer = ~((c1 >> 3) + ((c2 >> 3) << 4)); 993 *destPointer = ~((c1 >> 3) + ((c2 >> 3) << 4));
987 destPointer += step; 994 destPointer += step;
988 } 995 }
989 return 2; 996 return 2;
990 } else 997 } else {
991 { 998 int w1;
992 int w1; 999 w1 = width / 2;
993 w1 = width / 2; 1000
994 1001 if (xNibble) {
995 if( xNibble ) 1002 // copy one pixel
996 { 1003 PIXEL c1 = *srcPointer++;
997 // copy one pixel 1004 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) +
998 PIXEL c1 = *srcPointer++; 1005 (c1 & BLUEMASK);
999 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK); 1006 *destPointer = (*destPointer & 0xF0) | ((~(c1 >> 3) & 0xF));
1000 *destPointer = (*destPointer & 0xF0) | ((~(c1 >> 3) & 0xF)); 1007 destPointer++;
1001 destPointer++; 1008 }
1002 } 1009
1003 1010 while (w1--) {
1004 while(w1--) 1011 PIXEL c1 = *srcPointer;
1005 { 1012 PIXEL c2 = *(srcPointer + 1);
1006 PIXEL c1 = *srcPointer; 1013 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) +
1007 PIXEL c2 = *(srcPointer + 1); 1014 (c1 & BLUEMASK);
1008 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK); 1015 c2 = ((c2 & REDMASK) >> 11) + ((c2 & GREENMASK) >> 5) +
1009 c2 = ((c2 & REDMASK) >> 11) + ((c2 & GREENMASK) >> 5) + (c2 & BLUEMASK); 1016 (c2 & BLUEMASK);
1010 *destPointer++ = ~((c2 >> 3) + ((c1 >> 3) << 4)); 1017 *destPointer++ = ~((c2 >> 3) + ((c1 >> 3) << 4));
1011 srcPointer += 2; 1018 srcPointer += 2;
1012 } 1019 }
1013 1020
1014 // copy tail 1021 // copy tail
1015 if( (width & 1) && !xNibble ) 1022 if ((width & 1) && !xNibble) {
1016 { 1023 PIXEL c1 = *srcPointer;
1017 PIXEL c1 = *srcPointer; 1024 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) +
1018 c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK); 1025 (c1 & BLUEMASK);
1019 *destPointer = (*destPointer & 0x0F) | ((~(c1 >> 3) << 4)); 1026 *destPointer = (*destPointer & 0x0F) | ((~(c1 >> 3) << 4));
1020 } 1027 }
1021 1028
1022 return 1; 1029 return 1;
1023 } 1030 }
1024 } 1031 }
1025 1032
1026 static void GAPI_UpdateRectsMono(_THIS, int numrects, SDL_Rect *rects) 1033 static void
1027 { 1034 GAPI_UpdateRectsMono(_THIS, int numrects, SDL_Rect * rects)
1028 int i, height; 1035 {
1029 int linesProcessed; 1036 int i, height;
1030 int xNibble, yNibble; 1037 int linesProcessed;
1031 1038 int xNibble, yNibble;
1032 for (i=0; i<numrects; i++) 1039
1033 { 1040 for (i = 0; i < numrects; i++) {
1034 unsigned char *destPointer; 1041 unsigned char *destPointer;
1035 unsigned char *srcPointer; 1042 unsigned char *srcPointer;
1036 1043
1037 if( gapi->userOrientation == SDL_ORIENTATION_UP ) 1044 if (gapi->userOrientation == SDL_ORIENTATION_UP)
1038 destPointer = (unsigned char*) gapi->videoMem + gapi->startOffset - rects[i].y * gapi->gxProperties.cBPP / 8 + rects[i].x * gapi->dstPixelStep; 1045 destPointer =
1039 else 1046 (unsigned char *) gapi->videoMem + gapi->startOffset -
1040 destPointer = (unsigned char*) gapi->videoMem + gapi->startOffset + rects[i].x * gapi->gxProperties.cBPP / 8 + rects[i].y * gapi->dstLineStep; 1047 rects[i].y * gapi->gxProperties.cBPP / 8 +
1041 1048 rects[i].x * gapi->dstPixelStep;
1042 srcPointer = ((unsigned char*) SDL_VideoSurface->pixels) + rects[i].y * SDL_VideoSurface->pitch + rects[i].x * 2; 1049 else
1043 yNibble = rects[i].y & 1; // TODO: only for 4 bpp 1050 destPointer =
1044 xNibble = rects[i].x & 1; 1051 (unsigned char *) gapi->videoMem + gapi->startOffset +
1045 height = rects[i].h; 1052 rects[i].x * gapi->gxProperties.cBPP / 8 +
1046 while (height > 0) 1053 rects[i].y * gapi->dstLineStep;
1047 { 1054
1048 switch(gapi->gxProperties.cBPP) 1055 srcPointer =
1049 { 1056 ((unsigned char *) SDL_VideoSurface->pixels) +
1050 case 2: // TODO 1057 rects[i].y * SDL_VideoSurface->pitch + rects[i].x * 2;
1051 case 4: 1058 yNibble = rects[i].y & 1; // TODO: only for 4 bpp
1052 linesProcessed = updateLine16to4(this, (PIXEL*) srcPointer, destPointer, rects[i].w, rects[i].h, height, yNibble, xNibble); 1059 xNibble = rects[i].x & 1;
1053 yNibble = 0; 1060 height = rects[i].h;
1054 } 1061 while (height > 0) {
1055 height -= linesProcessed; 1062 switch (gapi->gxProperties.cBPP) {
1056 if( gapi->userOrientation == SDL_ORIENTATION_UP ) 1063 case 2: // TODO
1057 destPointer--; // always fill 1 byte 1064 case 4:
1058 else destPointer += gapi->dstLineStep; 1065 linesProcessed =
1059 srcPointer += SDL_VideoSurface->pitch * linesProcessed; // pitch in bytes 1066 updateLine16to4(this, (PIXEL *) srcPointer,
1060 } 1067 destPointer, rects[i].w,
1061 } 1068 rects[i].h, height, yNibble, xNibble);
1062 } 1069 yNibble = 0;
1063 1070 }
1064 static void GAPI_UpdateRectsColor(_THIS, int numrects, SDL_Rect *rects) 1071 height -= linesProcessed;
1065 { 1072 if (gapi->userOrientation == SDL_ORIENTATION_UP)
1066 int i, height; 1073 destPointer--; // always fill 1 byte
1067 int bytesPerPixel = (gapi->gxProperties.cBPP + 1) / 8; 1074 else
1068 int linesProcessed; 1075 destPointer += gapi->dstLineStep;
1069 for (i=0; i<numrects; i++) { 1076 srcPointer += SDL_VideoSurface->pitch * linesProcessed; // pitch in bytes
1070 unsigned char *destPointer = (unsigned char*) gapi->videoMem + gapi->startOffset + rects[i].y * gapi->dstLineStep + rects[i].x * gapi->dstPixelStep; 1077 }
1071 unsigned char *srcPointer = ((unsigned char*) SDL_VideoSurface->pixels) + rects[i].y * SDL_VideoSurface->pitch + rects[i].x * bytesPerPixel; 1078 }
1072 height = rects[i].h; 1079 }
1073 1080
1074 // fprintf(stderr, "Starting rect %dx%d, dst=0x%x, w = %d, h = %d\n", rects[i].w, rects[i].h,destPointer,rects[i].w,rects[i].h); 1081 static void
1075 // fflush(stderr); 1082 GAPI_UpdateRectsColor(_THIS, int numrects, SDL_Rect * rects)
1076 linesProcessed = height; 1083 {
1077 1084 int i, height;
1078 while (height > 0) { 1085 int bytesPerPixel = (gapi->gxProperties.cBPP + 1) / 8;
1079 switch(bytesPerPixel) 1086 int linesProcessed;
1080 { 1087 for (i = 0; i < numrects; i++) {
1081 case 1: 1088 unsigned char *destPointer =
1082 linesProcessed = updateLine8to8(this, srcPointer, (unsigned char *) destPointer, rects[i].w, rects[i].h, height); 1089 (unsigned char *) gapi->videoMem + gapi->startOffset +
1083 break; 1090 rects[i].y * gapi->dstLineStep + rects[i].x * gapi->dstPixelStep;
1084 case 2: 1091 unsigned char *srcPointer =
1092 ((unsigned char *) SDL_VideoSurface->pixels) +
1093 rects[i].y * SDL_VideoSurface->pitch + rects[i].x * bytesPerPixel;
1094 height = rects[i].h;
1095
1096 // fprintf(stderr, "Starting rect %dx%d, dst=0x%x, w = %d, h = %d\n", rects[i].w, rects[i].h,destPointer,rects[i].w,rects[i].h);
1097 // fflush(stderr);
1098 linesProcessed = height;
1099
1100 while (height > 0) {
1101 switch (bytesPerPixel) {
1102 case 1:
1103 linesProcessed =
1104 updateLine8to8(this, srcPointer,
1105 (unsigned char *) destPointer,
1106 rects[i].w, rects[i].h, height);
1107 break;
1108 case 2:
1085 #pragma warning(disable: 4133) 1109 #pragma warning(disable: 4133)
1086 linesProcessed = updateLine16to16(this, (PIXEL*) srcPointer, destPointer, rects[i].w, rects[i].h, height); 1110 linesProcessed =
1087 break; 1111 updateLine16to16(this, (PIXEL *) srcPointer,
1088 } 1112 destPointer, rects[i].w,
1089 height -= linesProcessed; 1113 rects[i].h, height);
1090 destPointer += gapi->dstLineStep * linesProcessed; 1114 break;
1091 srcPointer += SDL_VideoSurface->pitch * linesProcessed; // pitch in bytes 1115 }
1092 } 1116 height -= linesProcessed;
1093 // fprintf(stderr, "End of rect\n"); 1117 destPointer += gapi->dstLineStep * linesProcessed;
1094 // fflush(stderr); 1118 srcPointer += SDL_VideoSurface->pitch * linesProcessed; // pitch in bytes
1095 } 1119 }
1096 } 1120 // fprintf(stderr, "End of rect\n");
1097 1121 // fflush(stderr);
1098 1122 }
1099 static void GAPI_UpdateRects(_THIS, int numrects, SDL_Rect *rects) 1123 }
1100 { 1124
1101 // we do not want to corrupt video memory 1125
1102 if( gapi->suspended ) return; 1126 static void
1103 1127 GAPI_UpdateRects(_THIS, int numrects, SDL_Rect * rects)
1104 if( gapi->needUpdate ) 1128 {
1105 gapi->videoMem = gapi->gxFunc.GXBeginDraw(); 1129 // we do not want to corrupt video memory
1106 1130 if (gapi->suspended)
1107 if( gapi->gxProperties.cBPP < 8 ) 1131 return;
1108 GAPI_UpdateRectsMono(this, numrects, rects); 1132
1109 else 1133 if (gapi->needUpdate)
1110 GAPI_UpdateRectsColor(this, numrects, rects); 1134 gapi->videoMem = gapi->gxFunc.GXBeginDraw();
1111 1135
1112 if( gapi->needUpdate ) 1136 if (gapi->gxProperties.cBPP < 8)
1113 gapi->gxFunc.GXEndDraw(); 1137 GAPI_UpdateRectsMono(this, numrects, rects);
1138 else
1139 GAPI_UpdateRectsColor(this, numrects, rects);
1140
1141 if (gapi->needUpdate)
1142 gapi->gxFunc.GXEndDraw();
1114 } 1143 }
1115 1144
1116 /* Note: If we are terminated, this could be called in the middle of 1145 /* Note: If we are terminated, this could be called in the middle of
1117 another SDL video routine -- notably UpdateRects. 1146 another SDL video routine -- notably UpdateRects.
1118 */ 1147 */
1119 void GAPI_VideoQuit(_THIS) 1148 void
1120 { 1149 GAPI_VideoQuit(_THIS)
1121 int i, j; 1150 {
1122 /* Destroy the window and everything associated with it */ 1151 int i, j;
1123 if ( SDL_Window ) 1152 /* Destroy the window and everything associated with it */
1124 { 1153 if (SDL_Window) {
1125 if ((g_hGapiLib != 0) && this && this->hidden && this->hidden->gxFunc.GXCloseDisplay && !this->hidden->useVga) 1154 if ((g_hGapiLib != 0) && this && this->hidden
1126 this->hidden->gxFunc.GXCloseDisplay(); 1155 && this->hidden->gxFunc.GXCloseDisplay && !this->hidden->useVga)
1127 1156 this->hidden->gxFunc.GXCloseDisplay();
1128 if (this->screen->pixels != NULL) 1157
1129 { 1158 if (this->screen->pixels != NULL) {
1130 SDL_free(this->screen->pixels); 1159 SDL_free(this->screen->pixels);
1131 this->screen->pixels = NULL; 1160 this->screen->pixels = NULL;
1132 } 1161 }
1133 if ( screen_icn ) { 1162 if (screen_icn) {
1134 DestroyIcon(screen_icn); 1163 DestroyIcon(screen_icn);
1135 screen_icn = NULL; 1164 screen_icn = NULL;
1136 } 1165 }
1137 1166
1138 DIB_DestroyWindow(this); 1167 DIB_DestroyWindow(this);
1139 SDL_UnregisterApp(); 1168 SDL_UnregisterApp();
1140 1169
1141 SDL_Window = NULL; 1170 SDL_Window = NULL;
1142 #if defined(_WIN32_WCE) 1171 #if defined(_WIN32_WCE)
1143 1172
1144 // Unload wince aygshell library to prevent leak 1173 // Unload wince aygshell library to prevent leak
1145 if( aygshell ) 1174 if (aygshell) {
1146 { 1175 FreeLibrary(aygshell);
1147 FreeLibrary(aygshell); 1176 aygshell = NULL;
1148 aygshell = NULL; 1177 }
1149 }
1150 #endif 1178 #endif
1151 1179
1152 /* Free video mode lists */ 1180 /* Free video mode lists */
1153 for ( i=0; i<NUM_MODELISTS; ++i ) { 1181 for (i = 0; i < NUM_MODELISTS; ++i) {
1154 if ( gapi->SDL_modelist[i] != NULL ) { 1182 if (gapi->SDL_modelist[i] != NULL) {
1155 for ( j=0; gapi->SDL_modelist[i][j]; ++j ) 1183 for (j = 0; gapi->SDL_modelist[i][j]; ++j)
1156 SDL_free(gapi->SDL_modelist[i][j]); 1184 SDL_free(gapi->SDL_modelist[i][j]);
1157 SDL_free(gapi->SDL_modelist[i]); 1185 SDL_free(gapi->SDL_modelist[i]);
1158 gapi->SDL_modelist[i] = NULL; 1186 gapi->SDL_modelist[i] = NULL;
1159 } 1187 }
1160 } 1188 }
1161 1189
1162 } 1190 }
1163 1191
1164 } 1192 }
1165 1193
1166 static void GAPI_RealizePalette(_THIS) 1194 static void
1167 { 1195 GAPI_RealizePalette(_THIS)
1168 OutputDebugString(TEXT("GAPI_RealizePalette NOT IMPLEMENTED !\r\n")); 1196 {
1169 } 1197 OutputDebugString(TEXT("GAPI_RealizePalette NOT IMPLEMENTED !\r\n"));
1170 1198 }
1171 static void GAPI_PaletteChanged(_THIS, HWND window) 1199
1172 { 1200 static void
1173 OutputDebugString(TEXT("GAPI_PaletteChanged NOT IMPLEMENTED !\r\n")); 1201 GAPI_PaletteChanged(_THIS, HWND window)
1174 } 1202 {
1175 1203 OutputDebugString(TEXT("GAPI_PaletteChanged NOT IMPLEMENTED !\r\n"));
1176 static void GAPI_WinPAINT(_THIS, HDC hdc) 1204 }
1177 { 1205
1178 // draw current offscreen buffer on hdc 1206 static void
1179 1207 GAPI_WinPAINT(_THIS, HDC hdc)
1180 int bpp = 16; // we always use either 8 or 16 bpp internally 1208 {
1181 1209 // draw current offscreen buffer on hdc
1182 unsigned short *bitmapData; 1210
1183 HBITMAP hb; 1211 int bpp = 16; // we always use either 8 or 16 bpp internally
1184 HDC srcDC; 1212
1213 unsigned short *bitmapData;
1214 HBITMAP hb;
1215 HDC srcDC;
1185 1216
1186 // Create a DIB 1217 // Create a DIB
1187 BYTE buffer[sizeof(BITMAPINFOHEADER) + 3 * sizeof(RGBQUAD)] = {0}; 1218 BYTE buffer[sizeof(BITMAPINFOHEADER) + 3 * sizeof(RGBQUAD)] = { 0 };
1188 BITMAPINFO* pBMI = (BITMAPINFO*)buffer; 1219 BITMAPINFO *pBMI = (BITMAPINFO *) buffer;
1189 BITMAPINFOHEADER* pHeader = &pBMI->bmiHeader; 1220 BITMAPINFOHEADER *pHeader = &pBMI->bmiHeader;
1190 DWORD* pColors = (DWORD*)&pBMI->bmiColors; 1221 DWORD *pColors = (DWORD *) & pBMI->bmiColors;
1191 1222
1192 // CreateDIBSection does not support 332 pixel format on wce 1223 // CreateDIBSection does not support 332 pixel format on wce
1193 if( gapi->gxProperties.cBPP == 8 ) return; 1224 if (gapi->gxProperties.cBPP == 8)
1225 return;
1194 1226
1195 // DIB Header 1227 // DIB Header
1196 pHeader->biSize = sizeof(BITMAPINFOHEADER); 1228 pHeader->biSize = sizeof(BITMAPINFOHEADER);
1197 pHeader->biWidth = this->hidden->w; 1229 pHeader->biWidth = this->hidden->w;
1198 pHeader->biHeight = -this->hidden->h; 1230 pHeader->biHeight = -this->hidden->h;
1199 pHeader->biPlanes = 1; 1231 pHeader->biPlanes = 1;
1200 pHeader->biBitCount = bpp; 1232 pHeader->biBitCount = bpp;
1201 pHeader->biCompression = BI_RGB; 1233 pHeader->biCompression = BI_RGB;
1202 pHeader->biSizeImage = (this->hidden->w * this->hidden->h * bpp) / 8; 1234 pHeader->biSizeImage = (this->hidden->w * this->hidden->h * bpp) / 8;
1203 1235
1204 // Color masks 1236 // Color masks
1205 if( bpp == 16 ) 1237 if (bpp == 16) {
1206 { 1238 pColors[0] = REDMASK;
1207 pColors[0] = REDMASK; 1239 pColors[1] = GREENMASK;
1208 pColors[1] = GREENMASK; 1240 pColors[2] = BLUEMASK;
1209 pColors[2] = BLUEMASK; 1241 pHeader->biCompression = BI_BITFIELDS;
1210 pHeader->biCompression = BI_BITFIELDS; 1242 }
1211 }
1212 // Create the DIB 1243 // Create the DIB
1213 hb = CreateDIBSection( 0, pBMI, DIB_RGB_COLORS, (void**)&bitmapData, 0, 0 ); 1244 hb = CreateDIBSection(0, pBMI, DIB_RGB_COLORS, (void **) &bitmapData, 0,
1214 1245 0);
1215 // copy data 1246
1216 // FIXME: prevent misalignment, but I've never seen non aligned width of screen 1247 // copy data
1217 memcpy(bitmapData, this->hidden->buffer, pHeader->biSizeImage); 1248 // FIXME: prevent misalignment, but I've never seen non aligned width of screen
1218 srcDC = CreateCompatibleDC(hdc); 1249 memcpy(bitmapData, this->hidden->buffer, pHeader->biSizeImage);
1219 SelectObject(srcDC, hb); 1250 srcDC = CreateCompatibleDC(hdc);
1220 1251 SelectObject(srcDC, hb);
1221 BitBlt(hdc, 0, 0, this->hidden->w, this->hidden->h, srcDC, 0, 0, SRCCOPY); 1252
1222 1253 BitBlt(hdc, 0, 0, this->hidden->w, this->hidden->h, srcDC, 0, 0, SRCCOPY);
1223 DeleteObject(hb); 1254
1224 DeleteDC(srcDC); 1255 DeleteObject(hb);
1225 } 1256 DeleteDC(srcDC);
1226 1257 }
1227 int GAPI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) 1258
1228 { 1259 int
1229 GAPI_CreatePalette(ncolors, colors); 1260 GAPI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
1230 return 1; 1261 {
1231 } 1262 GAPI_CreatePalette(ncolors, colors);
1263 return 1;
1264 }
1265
1266 /* vi: set ts=4 sw=4 expandtab: */