ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/SDL/video_sdl.cpp
(Generate patch)

Comparing BasiliskII/src/SDL/video_sdl.cpp (file contents):
Revision 1.9 by gbeauche, 2004-06-27T17:31:21Z vs.
Revision 1.34 by gbeauche, 2008-01-01T09:40:32Z

# Line 1 | Line 1
1   /*
2   *  video_sdl.cpp - Video/graphics emulation, SDL specific stuff
3   *
4 < *  Basilisk II (C) 1997-2004 Christian Bauer
4 > *  Basilisk II (C) 1997-2008 Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 21 | Line 21
21   /*
22   *  NOTES:
23   *    The Ctrl key works like a qualifier for special actions:
24 < *      Ctrl-Tab = suspend DGA mode
24 > *      Ctrl-Tab = suspend DGA mode (TODO)
25   *      Ctrl-Esc = emergency quit
26   *      Ctrl-F1 = mount floppy
27   *      Ctrl-F5 = grab mouse (in windowed mode)
28   *
29   *  FIXMEs and TODOs:
30 + *  - Windows requires an extra mouse event to update the actual cursor image?
31 + *  - Ctr-Tab for suspend/resume but how? SDL does not support that for non-Linux
32   *  - Ctrl-Fn doesn't generate SDL_KEYDOWN events (SDL bug?)
33   *  - Mouse acceleration, there is no API in SDL yet for that
34   *  - Force relative mode in Grab mode even if SDL provides absolute coordinates?
33 *  - Fullscreen mode
35   *  - Gamma tables support is likely to be broken here
36   *  - Events processing is bound to the general emulation thread as SDL requires
37   *    to PumpEvents() within the same thread as the one that called SetVideoMode().
38   *    Besides, there can't seem to be a way to call SetVideoMode() from a child thread.
38 *  - Refresh performance is still slow. Use SDL_CreateRGBSurface()?
39   *  - Backport hw cursor acceleration to Basilisk II?
40 < *  - Move generic Native QuickDraw acceleration routines to gfxaccel.cpp
40 > *  - Factor out code
41   */
42  
43   #include "sysdeps.h"
# Line 48 | Line 48
48   #include <errno.h>
49   #include <vector>
50  
51 + #ifdef WIN32
52 + #include <malloc.h> /* alloca() */
53 + #endif
54 +
55   #include "cpu_emulation.h"
56   #include "main.h"
57   #include "adb.h"
# Line 57 | Line 61
61   #include "video.h"
62   #include "video_defs.h"
63   #include "video_blit.h"
64 + #include "vm_alloc.h"
65  
66   #define DEBUG 0
67   #include "debug.h"
# Line 82 | Line 87 | static int display_type = DISPLAY_WINDOW
87   #endif
88  
89   // Constants
90 + #ifdef WIN32
91 + const char KEYCODE_FILE_NAME[] = "BasiliskII_keycodes";
92 + #else
93   const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
94 + #endif
95  
96  
97   // Global variables
# Line 95 | Line 104 | static uint8 *the_buffer_copy = NULL;
104   static uint32 the_buffer_size;                                          // Size of allocated the_buffer
105  
106   static bool redraw_thread_active = false;                       // Flag: Redraw thread installed
107 + #ifndef USE_CPU_EMUL_SERVICES
108   static volatile bool redraw_thread_cancel;                      // Flag: Cancel Redraw thread
109   static SDL_Thread *redraw_thread = NULL;                        // Redraw thread
110 + #ifdef SHEEPSHAVER
111 + static volatile bool thread_stop_req = false;
112 + static volatile bool thread_stop_ack = false;           // Acknowledge for thread_stop_req
113 + #endif
114 + #endif
115  
116   #ifdef ENABLE_VOSF
117   static bool use_vosf = false;                                           // Flag: VOSF enabled
# Line 123 | Line 138 | static SDL_Color sdl_palette[256];                                     /
138   static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
139   static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
140  
141 + // Mutex to protect SDL events
142 + static SDL_mutex *sdl_events_lock = NULL;
143 + #define LOCK_EVENTS SDL_LockMutex(sdl_events_lock)
144 + #define UNLOCK_EVENTS SDL_UnlockMutex(sdl_events_lock)
145 +
146   // Mutex to protect palette
147   static SDL_mutex *sdl_palette_lock = NULL;
148   #define LOCK_PALETTE SDL_LockMutex(sdl_palette_lock)
# Line 146 | Line 166 | extern void SysMountFirstFloppy(void);
166  
167  
168   /*
169 + *  SDL surface locking glue
170 + */
171 +
172 + #ifdef ENABLE_VOSF
173 + #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE) do {                               \
174 +        if ((SURFACE)->flags & (SDL_HWSURFACE | SDL_FULLSCREEN))        \
175 +                the_host_buffer = (uint8 *)(SURFACE)->pixels;                   \
176 + } while (0)
177 + #else
178 + #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE)
179 + #endif
180 +
181 + #define SDL_VIDEO_LOCK_SURFACE(SURFACE) do {    \
182 +        if (SDL_MUSTLOCK(SURFACE)) {                            \
183 +                SDL_LockSurface(SURFACE);                               \
184 +                SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE);   \
185 +        }                                                                                       \
186 + } while (0)
187 +
188 + #define SDL_VIDEO_UNLOCK_SURFACE(SURFACE) do {  \
189 +        if (SDL_MUSTLOCK(SURFACE))                                      \
190 +                SDL_UnlockSurface(SURFACE);                             \
191 + } while (0)
192 +
193 +
194 + /*
195 + *  Framebuffer allocation routines
196 + */
197 +
198 + static void *vm_acquire_framebuffer(uint32 size)
199 + {
200 +        // always try to reallocate framebuffer at the same address
201 +        static void *fb = VM_MAP_FAILED;
202 +        if (fb != VM_MAP_FAILED) {
203 +                if (vm_acquire_fixed(fb, size) < 0) {
204 + #ifndef SHEEPSHAVER
205 +                        printf("FATAL: Could not reallocate framebuffer at previous address\n");
206 + #endif
207 +                        fb = VM_MAP_FAILED;
208 +                }
209 +        }
210 +        if (fb == VM_MAP_FAILED)
211 +                fb = vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_32BIT);
212 +        return fb;
213 + }
214 +
215 + static inline void vm_release_framebuffer(void *fb, uint32 size)
216 + {
217 +        vm_release(fb, size);
218 + }
219 +
220 +
221 + /*
222 + *  Windows message handler
223 + */
224 +
225 + #ifdef WIN32
226 + #include <dbt.h>
227 + static WNDPROC sdl_window_proc = NULL;                          // Window proc used by SDL
228 +
229 + extern void SysMediaArrived(void);
230 + extern void SysMediaRemoved(void);
231 + extern HWND GetMainWindowHandle(void);
232 +
233 + static LRESULT CALLBACK windows_message_handler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
234 + {
235 +        switch (msg) {
236 +        case WM_DEVICECHANGE:
237 +                if (wParam == DBT_DEVICEREMOVECOMPLETE) {
238 +                        DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
239 +                        if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
240 +                                SysMediaRemoved();
241 +                }
242 +                else if (wParam == DBT_DEVICEARRIVAL) {
243 +                        DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
244 +                        if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
245 +                                SysMediaArrived();
246 +                }
247 +                return 0;
248 +
249 +        default:
250 +                if (sdl_window_proc)
251 +                        return CallWindowProc(sdl_window_proc, hwnd, msg, wParam, lParam);
252 +        }
253 +
254 +        return DefWindowProc(hwnd, msg, wParam, lParam);
255 + }
256 + #endif
257 +
258 +
259 + /*
260   *  SheepShaver glue
261   */
262  
# Line 190 | Line 301 | static vector<monitor_desc *> VideoMonit
301   // Find Apple mode matching best specified dimensions
302   static int find_apple_resolution(int xsize, int ysize)
303   {
304 <        int apple_id;
305 <        if (xsize < 800)
306 <                apple_id = APPLE_640x480;
307 <        else if (xsize < 1024)
308 <                apple_id = APPLE_800x600;
309 <        else if (xsize < 1152)
310 <                apple_id = APPLE_1024x768;
311 <        else if (xsize < 1280) {
312 <                if (ysize < 900)
313 <                        apple_id = APPLE_1152x768;
314 <                else
315 <                        apple_id = APPLE_1152x900;
316 <        }
317 <        else if (xsize < 1600)
318 <                apple_id = APPLE_1280x1024;
208 <        else
209 <                apple_id = APPLE_1600x1200;
210 <        return apple_id;
211 < }
212 <
213 < // Set parameters to specified Apple mode
214 < static void set_apple_resolution(int apple_id, int &xsize, int &ysize)
215 < {
216 <        switch (apple_id) {
217 <        case APPLE_640x480:
218 <                xsize = 640;
219 <                ysize = 480;
220 <                break;
221 <        case APPLE_800x600:
222 <                xsize = 800;
223 <                ysize = 600;
224 <                break;
225 <        case APPLE_1024x768:
226 <                xsize = 1024;
227 <                ysize = 768;
228 <                break;
229 <        case APPLE_1152x768:
230 <                xsize = 1152;
231 <                ysize = 768;
232 <                break;
233 <        case APPLE_1152x900:
234 <                xsize = 1152;
235 <                ysize = 900;
236 <                break;
237 <        case APPLE_1280x1024:
238 <                xsize = 1280;
239 <                ysize = 1024;
240 <                break;
241 <        case APPLE_1600x1200:
242 <                xsize = 1600;
243 <                ysize = 1200;
244 <                break;
245 <        default:
246 <                abort();
247 <        }
248 < }
249 <
250 < // Match Apple mode matching best specified dimensions
251 < static int match_apple_resolution(int &xsize, int &ysize)
252 < {
253 <        int apple_id = find_apple_resolution(xsize, ysize);
254 <        set_apple_resolution(apple_id, xsize, ysize);
255 <        return apple_id;
304 >        if (xsize == 640 && ysize == 480)
305 >                return APPLE_640x480;
306 >        if (xsize == 800 && ysize == 600)
307 >                return APPLE_800x600;
308 >        if (xsize == 1024 && ysize == 768)
309 >                return APPLE_1024x768;
310 >        if (xsize == 1152 && ysize == 768)
311 >                return APPLE_1152x768;
312 >        if (xsize == 1152 && ysize == 900)
313 >                return APPLE_1152x900;
314 >        if (xsize == 1280 && ysize == 1024)
315 >                return APPLE_1280x1024;
316 >        if (xsize == 1600 && ysize == 1200)
317 >                return APPLE_1600x1200;
318 >        return APPLE_CUSTOM;
319   }
320  
321   // Display error alert
# Line 325 | Line 388 | static inline int bytes_per_pixel(int de
388   }
389  
390   // Map video_mode depth ID to numerical depth value
391 < static int sdl_depth_of_video_depth(int video_depth)
391 > static int mac_depth_of_video_depth(int video_depth)
392   {
393          int depth = -1;
394          switch (video_depth) {
# Line 353 | Line 416 | static int sdl_depth_of_video_depth(int
416          return depth;
417   }
418  
419 < // Check wether specified mode is available
420 < static bool has_mode(int type, int width, int height)
419 > // Map video_mode depth ID to SDL screen depth
420 > static int sdl_depth_of_video_depth(int video_depth)
421   {
422 <        // FIXME: no fullscreen support yet
423 <        if (type == DISPLAY_SCREEN)
424 <                return false;
422 >        return (video_depth <= VIDEO_DEPTH_8BIT) ? 8 : mac_depth_of_video_depth(video_depth);
423 > }
424 >
425 > // Get screen dimensions
426 > static void sdl_display_dimensions(int &width, int &height)
427 > {
428 >        static int max_width, max_height;
429 >        if (max_width == 0 && max_height == 0) {
430 >                max_width = 640 ; max_height = 480;
431 >                SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
432 >                if (modes && modes != (SDL_Rect **)-1) {
433 >                        // It turns out that on some implementations, and contrary to the documentation,
434 >                        // the returned list is not sorted from largest to smallest (e.g. Windows)
435 >                        for (int i = 0; modes[i] != NULL; i++) {
436 >                                const int w = modes[i]->w;
437 >                                const int h = modes[i]->h;
438 >                                if (w > max_width && h > max_height) {
439 >                                        max_width = w;
440 >                                        max_height = h;
441 >                                }
442 >                        }
443 >                }
444 >        }
445 >        width = max_width;
446 >        height = max_height;
447 > }
448 >
449 > static inline int sdl_display_width(void)
450 > {
451 >        int width, height;
452 >        sdl_display_dimensions(width, height);
453 >        return width;
454 > }
455 >
456 > static inline int sdl_display_height(void)
457 > {
458 >        int width, height;
459 >        sdl_display_dimensions(width, height);
460 >        return height;
461 > }
462  
463 + // Check wether specified mode is available
464 + static bool has_mode(int type, int width, int height, int depth)
465 + {
466   #ifdef SHEEPSHAVER
467 <        // Filter out Classic resolutiosn
467 >        // Filter out Classic resolutions
468          if (width == 512 && height == 384)
469                  return false;
367
368        // Read window modes prefs
369        static uint32 window_modes = 0;
370        static uint32 screen_modes = 0;
371        if (window_modes == 0 || screen_modes == 0) {
372                window_modes = PrefsFindInt32("windowmodes");
373                screen_modes = PrefsFindInt32("screenmodes");
374                if (window_modes == 0 || screen_modes == 0)
375                        window_modes |= 3;                      // Allow at least 640x480 and 800x600 window modes
376        }
377
378        if (type == DISPLAY_WINDOW) {
379                int apple_mask, apple_id = find_apple_resolution(width, height);
380                switch (apple_id) {
381                case APPLE_640x480:             apple_mask = 0x01; break;
382                case APPLE_800x600:             apple_mask = 0x02; break;
383                case APPLE_1024x768:    apple_mask = 0x04; break;
384                case APPLE_1152x768:    apple_mask = 0x40; break;
385                case APPLE_1152x900:    apple_mask = 0x08; break;
386                case APPLE_1280x1024:   apple_mask = 0x10; break;
387                case APPLE_1600x1200:   apple_mask = 0x20; break;
388                default:                                apple_mask = 0x00; break;
389                }
390                return (window_modes & apple_mask);
391        }
392 #else
393        return true;
470   #endif
471 <        return false;
471 >
472 >        // Filter out out-of-bounds resolutions
473 >        if (width > sdl_display_width() || height > sdl_display_height())
474 >                return false;
475 >
476 >        // Rely on SDL capabilities
477 >        return SDL_VideoModeOK(width, height,
478 >                                                   sdl_depth_of_video_depth(depth),
479 >                                                   SDL_HWSURFACE | (type == DISPLAY_SCREEN ? SDL_FULLSCREEN : 0));
480   }
481  
482   // Add mode to list of supported modes
483   static void add_mode(int type, int width, int height, int resolution_id, int bytes_per_row, int depth)
484   {
485          // Filter out unsupported modes
486 <        if (!has_mode(type, width, height))
486 >        if (!has_mode(type, width, height, depth))
487                  return;
488  
489          // Fill in VideoMode entry
490          VIDEO_MODE mode;
491   #ifdef SHEEPSHAVER
492 <        // Recalculate dimensions to fit Apple modes
409 <        resolution_id = match_apple_resolution(width, height);
492 >        resolution_id = find_apple_resolution(width, height);
493          mode.viType = type;
494   #endif
495          VIDEO_MODE_X = width;
496          VIDEO_MODE_Y = height;
497          VIDEO_MODE_RESOLUTION = resolution_id;
498          VIDEO_MODE_ROW_BYTES = bytes_per_row;
499 <        VIDEO_MODE_DEPTH = depth;
499 >        VIDEO_MODE_DEPTH = (video_depth)depth;
500          VideoModes.push_back(mode);
501   }
502  
420 // Add standard list of windowed modes for given color depth
421 static void add_window_modes(int depth)
422 {
423        video_depth vdepth = (video_depth)depth;
424        add_mode(DISPLAY_WINDOW, 512, 384, 0x80, TrivialBytesPerRow(512, vdepth), depth);
425        add_mode(DISPLAY_WINDOW, 640, 480, 0x81, TrivialBytesPerRow(640, vdepth), depth);
426        add_mode(DISPLAY_WINDOW, 800, 600, 0x82, TrivialBytesPerRow(800, vdepth), depth);
427        add_mode(DISPLAY_WINDOW, 1024, 768, 0x83, TrivialBytesPerRow(1024, vdepth), depth);
428        add_mode(DISPLAY_WINDOW, 1152, 870, 0x84, TrivialBytesPerRow(1152, vdepth), depth);
429        add_mode(DISPLAY_WINDOW, 1280, 1024, 0x85, TrivialBytesPerRow(1280, vdepth), depth);
430        add_mode(DISPLAY_WINDOW, 1600, 1200, 0x86, TrivialBytesPerRow(1600, vdepth), depth);
431 }
432
503   // Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
504   static void set_mac_frame_buffer(SDL_monitor_desc &monitor, int depth, bool native_byte_order)
505   {
# Line 469 | Line 539 | static void set_window_name(int name)
539   // Set mouse grab mode
540   static SDL_GrabMode set_grab_mode(SDL_GrabMode mode)
541   {
542 <        const SDL_VideoInfo *vi =SDL_GetVideoInfo();
542 >        const SDL_VideoInfo *vi = SDL_GetVideoInfo();
543          return (vi && vi->wm_available ? SDL_WM_GrabInput(mode) : SDL_GRAB_OFF);
544   }
545  
546 + // Migrate preferences items (XXX to be handled in MigratePrefs())
547 + static void migrate_screen_prefs(void)
548 + {
549 + #ifdef SHEEPSHAVER
550 +        // Look-up priorities are: "screen", "screenmodes", "windowmodes".
551 +        if (PrefsFindString("screen"))
552 +                return;
553 +
554 +        uint32 window_modes = PrefsFindInt32("windowmodes");
555 +        uint32 screen_modes = PrefsFindInt32("screenmodes");
556 +        int width = 0, height = 0;
557 +        if (screen_modes) {
558 +                static const struct {
559 +                        int id;
560 +                        int width;
561 +                        int height;
562 +                }
563 +                modes[] = {
564 +                        {  1,    640,    480 },
565 +                        {  2,    800,    600 },
566 +                        {  4,   1024,    768 },
567 +                        { 64,   1152,    768 },
568 +                        {  8,   1152,    900 },
569 +                        { 16,   1280,   1024 },
570 +                        { 32,   1600,   1200 },
571 +                        { 0, }
572 +                };
573 +                for (int i = 0; modes[i].id != 0; i++) {
574 +                        if (screen_modes & modes[i].id) {
575 +                                if (width < modes[i].width && height < modes[i].height) {
576 +                                        width = modes[i].width;
577 +                                        height = modes[i].height;
578 +                                }
579 +                        }
580 +                }
581 +        } else {
582 +                if (window_modes & 1)
583 +                        width = 640, height = 480;
584 +                if (window_modes & 2)
585 +                        width = 800, height = 600;
586 +        }
587 +        if (width && height) {
588 +                char str[32];
589 +                sprintf(str, "%s/%d/%d", screen_modes ? "dga" : "win", width, height);
590 +                PrefsReplaceString("screen", str);
591 +        }
592 + #endif
593 + }
594 +
595  
596   /*
597   *  Display "driver" classes
# Line 528 | Line 647 | private:
647          int mouse_last_x, mouse_last_y; // Last mouse position (for relative mode)
648   };
649  
650 + class driver_fullscreen : public driver_base {
651 + public:
652 +        driver_fullscreen(SDL_monitor_desc &monitor);
653 +        ~driver_fullscreen();
654 + };
655 +
656   static driver_base *drv = NULL; // Pointer to currently used driver object
657  
658   #ifdef ENABLE_VOSF
# Line 549 | Line 674 | driver_base::~driver_base()
674          if (s)
675                  SDL_FreeSurface(s);
676  
677 +        // the_buffer shall always be mapped through vm_acquire_framebuffer()
678 +        if (the_buffer != VM_MAP_FAILED) {
679 +                D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
680 +                vm_release_framebuffer(the_buffer, the_buffer_size);
681 +                the_buffer = NULL;
682 +        }
683 +
684          // Free frame buffer(s)
685          if (!use_vosf) {
554                if (the_buffer) {
555                        free(the_buffer);
556                        the_buffer = NULL;
557                }
686                  if (the_buffer_copy) {
687                          free(the_buffer_copy);
688                          the_buffer_copy = NULL;
# Line 562 | Line 690 | driver_base::~driver_base()
690          }
691   #ifdef ENABLE_VOSF
692          else {
565                // the_buffer shall always be mapped through vm_acquire() so that we can vm_protect() it at will
566                if (the_buffer != VM_MAP_FAILED) {
567                        D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
568                        vm_release(the_buffer, the_buffer_size);
569                        the_buffer = NULL;
570                }
693                  if (the_host_buffer) {
694                          D(bug(" freeing the_host_buffer at %p\n", the_host_buffer));
695                          free(the_host_buffer);
# Line 578 | Line 700 | driver_base::~driver_base()
700                          free(the_buffer_copy);
701                          the_buffer_copy = NULL;
702                  }
703 +
704 +                // Deinitialize VOSF
705 +                video_vosf_exit();
706          }
707   #endif
708   }
# Line 587 | Line 712 | void driver_base::update_palette(void)
712   {
713          const VIDEO_MODE &mode = monitor.get_current_mode();
714  
715 <        if (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
715 >        if ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
716                  SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
717   }
718  
# Line 606 | Line 731 | void driver_base::restore_mouse_accel(vo
731   *  Windowed display driver
732   */
733  
734 + static bool SDL_display_opened = false;
735 +
736   // Open display
737   driver_window::driver_window(SDL_monitor_desc &m)
738          : driver_base(m), mouse_grabbed(false)
# Line 617 | Line 744 | driver_window::driver_window(SDL_monitor
744          // Set absolute mouse mode
745          ADBSetRelMouseMode(mouse_grabbed);
746  
747 +        // This is ugly:
748 +        // If we're switching resolutions (ie, not setting it for the first time),
749 +        // there's a bug in SDL where the SDL_Surface created will not be properly
750 +        // setup. The solution is to SDL_QuitSubSystem(SDL_INIT_VIDEO) before calling
751 +        // SDL_SetVideoMode for the second time (SDL_SetVideoMode will call SDL_Init()
752 +        // and all will be well). Without this, the video becomes corrupted (at least
753 +        // on Mac OS X), after the resolution switch.
754 +        if (SDL_display_opened)
755 +                SDL_QuitSubSystem(SDL_INIT_VIDEO);
756 +
757          // Create surface
758 <        int depth = (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
758 >        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
759          if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
760                  return;
761  
762 +        SDL_display_opened = true;
763 +
764   #ifdef ENABLE_VOSF
765          use_vosf = true;
766          // Allocate memory for frame buffer (SIZE is extended to page-boundary)
767          the_host_buffer = (uint8 *)s->pixels;
768          the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
769 <        the_buffer = (uint8 *)vm_acquire(the_buffer_size);
769 >        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
770          the_buffer_copy = (uint8 *)malloc(the_buffer_size);
771          D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
772  
# Line 651 | Line 790 | driver_window::driver_window(SDL_monitor
790                  // Allocate memory for frame buffer
791                  the_buffer_size = (aligned_height + 2) * s->pitch;
792                  the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
793 <                the_buffer = (uint8 *)calloc(1, the_buffer_size);
793 >                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
794                  D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
795          }
796          
# Line 676 | Line 815 | driver_window::driver_window(SDL_monitor
815          visualFormat.Rmask = f->Rmask;
816          visualFormat.Gmask = f->Gmask;
817          visualFormat.Bmask = f->Bmask;
818 <        Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(VIDEO_MODE_DEPTH));
818 >        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
819  
820          // Load gray ramp to 8->16/32 expand map
821          if (!IsDirectMode(mode))
# Line 743 | Line 882 | void driver_window::mouse_moved(int x, i
882          ADBMouseMoved(x, y);
883   }
884  
885 +
886 + /*
887 + *  Full-screen display driver
888 + */
889 +
890 + // Open display
891 + driver_fullscreen::driver_fullscreen(SDL_monitor_desc &m)
892 +        : driver_base(m)
893 + {
894 +        int width = VIDEO_MODE_X, height = VIDEO_MODE_Y;
895 +        int aligned_width = (width + 15) & ~15;
896 +        int aligned_height = (height + 15) & ~15;
897 +
898 +        // Set absolute mouse mode
899 +        ADBSetRelMouseMode(false);
900 +
901 +        // Create surface
902 +        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
903 +        if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE | SDL_FULLSCREEN)) == NULL)
904 +                return;
905 +
906 + #ifdef ENABLE_VOSF
907 +        use_vosf = true;
908 +        // Allocate memory for frame buffer (SIZE is extended to page-boundary)
909 +        the_host_buffer = (uint8 *)s->pixels;
910 +        the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
911 +        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
912 +        the_buffer_copy = (uint8 *)malloc(the_buffer_size);
913 +        D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
914 +
915 +        // Check whether we can initialize the VOSF subsystem and it's profitable
916 +        if (!video_vosf_init(m)) {
917 +                WarningAlert(STR_VOSF_INIT_ERR);
918 +                use_vosf = false;
919 +        }
920 +        else if (!video_vosf_profitable()) {
921 +                video_vosf_exit();
922 +                printf("VOSF acceleration is not profitable on this platform, disabling it\n");
923 +                use_vosf = false;
924 +        }
925 +        if (!use_vosf) {
926 +                free(the_buffer_copy);
927 +                vm_release(the_buffer, the_buffer_size);
928 +                the_host_buffer = NULL;
929 +        }
930 + #endif
931 +        if (!use_vosf) {
932 +                // Allocate memory for frame buffer
933 +                the_buffer_size = (aligned_height + 2) * s->pitch;
934 +                the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
935 +                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
936 +                D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
937 +        }
938 +        
939 +        // Hide cursor
940 +        SDL_ShowCursor(0);
941 +
942 +        // Init blitting routines
943 +        SDL_PixelFormat *f = s->format;
944 +        VisualFormat visualFormat;
945 +        visualFormat.depth = depth;
946 +        visualFormat.Rmask = f->Rmask;
947 +        visualFormat.Gmask = f->Gmask;
948 +        visualFormat.Bmask = f->Bmask;
949 +        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
950 +
951 +        // Load gray ramp to 8->16/32 expand map
952 +        if (!IsDirectMode(mode))
953 +                for (int i=0; i<256; i++)
954 +                        ExpandMap[i] = SDL_MapRGB(f, i, i, i);
955 +
956 +        // Set frame buffer base
957 +        set_mac_frame_buffer(monitor, VIDEO_MODE_DEPTH, true);
958 +
959 +        // Everything went well
960 +        init_ok = true;
961 + }
962 +
963 + // Close display
964 + driver_fullscreen::~driver_fullscreen()
965 + {
966 + #ifdef ENABLE_VOSF
967 +        if (use_vosf)
968 +                the_host_buffer = NULL; // don't free() in driver_base dtor
969 + #endif
970 +        if (s)
971 +                SDL_FreeSurface(s);
972 +
973 +        // Show cursor
974 +        SDL_ShowCursor(1);
975 + }
976 +
977 +
978   /*
979   *  Initialization
980   */
# Line 774 | Line 1006 | static void keycode_init(void)
1006                  SDL_VideoDriverName(video_driver, sizeof(video_driver));
1007                  bool video_driver_found = false;
1008                  char line[256];
1009 +                int n_keys = 0;
1010                  while (fgets(line, sizeof(line) - 1, f)) {
1011                          // Read line
1012                          int len = strlen(line);
# Line 786 | Line 1019 | static void keycode_init(void)
1019                                  continue;
1020  
1021                          if (video_driver_found) {
1022 <                                // Skip aliases
1022 >                                // Skip aliases as long as we have read keycodes yet
1023 >                                // Otherwise, it's another mapping and we have to stop
1024                                  static const char sdl_str[] = "sdl";
1025 <                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0)
1025 >                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0 && n_keys == 0)
1026                                          continue;
1027  
1028                                  // Read keycode
1029                                  int x_code, mac_code;
1030                                  if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
1031 <                                        keycode_table[x_code & 0xff] = mac_code;
1031 >                                        keycode_table[x_code & 0xff] = mac_code, n_keys++;
1032                                  else
1033                                          break;
1034                          } else {
# Line 819 | Line 1053 | static void keycode_init(void)
1053                          WarningAlert(str);
1054                          return;
1055                  }
1056 +
1057 +                D(bug("Using SDL/%s keycodes table, %d key mappings\n", video_driver, n_keys));
1058          }
1059   }
1060  
# Line 837 | Line 1073 | bool SDL_monitor_desc::video_open(void)
1073          case DISPLAY_WINDOW:
1074                  drv = new(std::nothrow) driver_window(*this);
1075                  break;
1076 +        case DISPLAY_SCREEN:
1077 +                drv = new(std::nothrow) driver_fullscreen(*this);
1078 +                break;
1079          }
1080          if (drv == NULL)
1081                  return false;
# Line 846 | Line 1085 | bool SDL_monitor_desc::video_open(void)
1085                  return false;
1086          }
1087  
1088 + #ifdef WIN32
1089 +        // Chain in a new message handler for WM_DEVICECHANGE
1090 +        HWND the_window = GetMainWindowHandle();
1091 +        sdl_window_proc = (WNDPROC)GetWindowLongPtr(the_window, GWLP_WNDPROC);
1092 +        SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)windows_message_handler);
1093 + #endif
1094 +
1095          // Initialize VideoRefresh function
1096          VideoRefreshInit();
1097  
# Line 853 | Line 1099 | bool SDL_monitor_desc::video_open(void)
1099          LOCK_FRAME_BUFFER;
1100  
1101          // Start redraw/input thread
1102 + #ifndef USE_CPU_EMUL_SERVICES
1103          redraw_thread_cancel = false;
1104          redraw_thread_active = ((redraw_thread = SDL_CreateThread(redraw_func, NULL)) != NULL);
1105          if (!redraw_thread_active) {
1106                  printf("FATAL: cannot create redraw thread\n");
1107                  return false;
1108          }
1109 + #else
1110 +        redraw_thread_active = true;
1111 + #endif
1112          return true;
1113   }
1114  
# Line 879 | Line 1129 | bool VideoInit(bool classic)
1129   #endif
1130  
1131          // Create Mutexes
1132 +        if ((sdl_events_lock = SDL_CreateMutex()) == NULL)
1133 +                return false;
1134          if ((sdl_palette_lock = SDL_CreateMutex()) == NULL)
1135                  return false;
1136          if ((frame_buffer_lock = SDL_CreateMutex()) == NULL)
# Line 893 | Line 1145 | bool VideoInit(bool classic)
1145          mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1146  
1147          // Get screen mode from preferences
1148 +        migrate_screen_prefs();
1149          const char *mode_str = NULL;
897 #ifndef SHEEPSHAVER
1150          if (classic_mode)
1151                  mode_str = "win/512/342";
1152          else
1153                  mode_str = PrefsFindString("screen");
902 #endif
1154  
1155          // Determine display type and default dimensions
1156          int default_width, default_height;
# Line 915 | Line 1166 | bool VideoInit(bool classic)
1166          if (mode_str) {
1167                  if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
1168                          display_type = DISPLAY_WINDOW;
1169 <        }
1170 <        int max_width = 640, max_height = 480;
920 <        SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
921 <        if (modes && modes != (SDL_Rect **)-1) {
922 <                max_width = modes[0]->w;
923 <                max_height = modes[0]->h;
924 <                if (default_width > max_width)
925 <                        default_width = max_width;
926 <                if (default_height > max_height)
927 <                        default_height = max_height;
1169 >                else if (sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2)
1170 >                        display_type = DISPLAY_SCREEN;
1171          }
1172          if (default_width <= 0)
1173 <                default_width = max_width;
1173 >                default_width = sdl_display_width();
1174 >        else if (default_width > sdl_display_width())
1175 >                default_width = sdl_display_width();
1176          if (default_height <= 0)
1177 <                default_height = max_height;
1177 >                default_height = sdl_display_height();
1178 >        else if (default_height > sdl_display_height())
1179 >                default_height = sdl_display_height();
1180  
1181          // Mac screen depth follows X depth
1182          screen_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
# Line 949 | Line 1196 | bool VideoInit(bool classic)
1196                  break;
1197          }
1198  
1199 +        // Initialize list of video modes to try
1200 +        struct {
1201 +                int w;
1202 +                int h;
1203 +                int resolution_id;
1204 +        }
1205 +        video_modes[] = {
1206 +                {   -1,   -1, 0x80 },
1207 +                {  512,  384, 0x80 },
1208 +                {  640,  480, 0x81 },
1209 +                {  800,  600, 0x82 },
1210 +                { 1024,  768, 0x83 },
1211 +                { 1152,  870, 0x84 },
1212 +                { 1280, 1024, 0x85 },
1213 +                { 1600, 1200, 0x86 },
1214 +                { 0, }
1215 +        };
1216 +        video_modes[0].w = default_width;
1217 +        video_modes[0].h = default_height;
1218 +
1219          // Construct list of supported modes
1220          if (display_type == DISPLAY_WINDOW) {
1221                  if (classic)
1222                          add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
1223                  else {
1224 <                        for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++) {
1225 <                                int bpp = (d <= VIDEO_DEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
1226 <                                if (SDL_VideoModeOK(max_width, max_height, bpp, SDL_HWSURFACE))
1227 <                                        add_window_modes(video_depth(d));
1224 >                        for (int i = 0; video_modes[i].w != 0; i++) {
1225 >                                const int w = video_modes[i].w;
1226 >                                const int h = video_modes[i].h;
1227 >                                if (i > 0 && (w >= default_width || h >= default_height))
1228 >                                        continue;
1229 >                                for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1230 >                                        add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1231                          }
1232                  }
1233 <        } else
1234 <                add_mode(display_type, default_width, default_height, 0x80, TrivialBytesPerRow(default_width, (video_depth)default_depth), default_depth);
1233 >        } else if (display_type == DISPLAY_SCREEN) {
1234 >                for (int i = 0; video_modes[i].w != 0; i++) {
1235 >                        const int w = video_modes[i].w;
1236 >                        const int h = video_modes[i].h;
1237 >                        if (i > 0 && (w >= default_width || h >= default_height))
1238 >                                continue;
1239 >                        if (w == 512 && h == 384)
1240 >                                continue;
1241 > #ifdef ENABLE_VOSF
1242 >                        for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1243 >                                add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1244 > #else
1245 >                        add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)default_depth), default_depth);
1246 > #endif
1247 >                }
1248 >        }
1249 >
1250          if (VideoModes.empty()) {
1251                  ErrorAlert(STR_NO_XVISUAL_ERR);
1252                  return false;
# Line 1032 | Line 1317 | void SDL_monitor_desc::video_close(void)
1317   {
1318          D(bug("video_close()\n"));
1319  
1320 + #ifdef WIN32
1321 +        // Remove message handler for WM_DEVICECHANGE
1322 +        HWND the_window = GetMainWindowHandle();
1323 +        SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)sdl_window_proc);
1324 + #endif
1325 +
1326          // Stop redraw thread
1327 + #ifndef USE_CPU_EMUL_SERVICES
1328          if (redraw_thread_active) {
1329                  redraw_thread_cancel = true;
1330                  SDL_WaitThread(redraw_thread, NULL);
1331          }
1332 + #endif
1333          redraw_thread_active = false;
1334  
1335          // Unlock frame buffer
1336          UNLOCK_FRAME_BUFFER;
1337          D(bug(" frame buffer unlocked\n"));
1338  
1046 #ifdef ENABLE_VOSF
1047        if (use_vosf) {
1048                // Deinitialize VOSF
1049                video_vosf_exit();
1050        }
1051 #endif
1052
1339          // Close display
1340          delete drv;
1341          drv = NULL;
# Line 1067 | Line 1353 | void VideoExit(void)
1353                  SDL_DestroyMutex(frame_buffer_lock);
1354          if (sdl_palette_lock)
1355                  SDL_DestroyMutex(sdl_palette_lock);
1356 +        if (sdl_events_lock)
1357 +                SDL_DestroyMutex(sdl_events_lock);
1358   }
1359  
1360  
# Line 1147 | Line 1435 | void SDL_monitor_desc::set_palette(uint8
1435          const VIDEO_MODE &mode = get_current_mode();
1436  
1437          // FIXME: how can we handle the gamma ramp?
1438 <        if (VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1438 >        if ((int)VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1439                  return;
1440  
1441          LOCK_PALETTE;
# Line 1208 | Line 1496 | int16 video_mode_change(VidLocals *csSav
1496                          csSave->saveData = ReadMacInt32(ParamPtr + csData);
1497                          csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1498  
1499 <                        // Disable interrupts
1499 >                        // Disable interrupts and pause redraw thread
1500                          DisableInterrupt();
1501 +                        thread_stop_ack = false;
1502 +                        thread_stop_req = true;
1503 +                        while (!thread_stop_ack) ;
1504  
1505                          cur_mode = i;
1506                          monitor_desc *monitor = VideoMonitors[0];
# Line 1220 | Line 1511 | int16 video_mode_change(VidLocals *csSav
1511                          csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1512                          csSave->saveMode=VModes[cur_mode].viAppleMode;
1513  
1514 <                        // Enable interrupts
1514 >                        // Enable interrupts and resume redraw thread
1515 >                        thread_stop_req = false;
1516                          EnableInterrupt();
1517                          return noErr;
1518                  }
# Line 1232 | Line 1524 | int16 video_mode_change(VidLocals *csSav
1524   void SDL_monitor_desc::switch_to_current_mode(void)
1525   {
1526          // Close and reopen display
1527 +        LOCK_EVENTS;
1528          video_close();
1529          video_open();
1530 +        UNLOCK_EVENTS;
1531  
1532          if (drv == NULL) {
1533                  ErrorAlert(STR_OPEN_WINDOW_ERR);
# Line 1267 | Line 1561 | void video_set_cursor(void)
1561  
1562  
1563   /*
1270 *  Install graphics acceleration
1271 */
1272
1273 #ifdef SHEEPSHAVER
1274 // Rectangle inversion
1275 template< int bpp >
1276 static inline void do_invrect(uint8 *dest, uint32 length)
1277 {
1278 #define INVERT_1(PTR, OFS) ((uint8  *)(PTR))[OFS] = ~((uint8  *)(PTR))[OFS]
1279 #define INVERT_2(PTR, OFS) ((uint16 *)(PTR))[OFS] = ~((uint16 *)(PTR))[OFS]
1280 #define INVERT_4(PTR, OFS) ((uint32 *)(PTR))[OFS] = ~((uint32 *)(PTR))[OFS]
1281 #define INVERT_8(PTR, OFS) ((uint64 *)(PTR))[OFS] = ~((uint64 *)(PTR))[OFS]
1282
1283 #ifndef UNALIGNED_PROFITABLE
1284        // Align on 16-bit boundaries
1285        if (bpp < 16 && (((uintptr)dest) & 1)) {
1286                INVERT_1(dest, 0);
1287                dest += 1; length -= 1;
1288        }
1289
1290        // Align on 32-bit boundaries
1291        if (bpp < 32 && (((uintptr)dest) & 2)) {
1292                INVERT_2(dest, 0);
1293                dest += 2; length -= 2;
1294        }
1295 #endif
1296
1297        // Invert 8-byte words
1298        if (length >= 8) {
1299                const int r = (length / 8) % 8;
1300                dest += r * 8;
1301
1302                int n = ((length / 8) + 7) / 8;
1303                switch (r) {
1304                case 0: do {
1305                                dest += 64;
1306                                INVERT_8(dest, -8);
1307                case 7: INVERT_8(dest, -7);
1308                case 6: INVERT_8(dest, -6);
1309                case 5: INVERT_8(dest, -5);
1310                case 4: INVERT_8(dest, -4);
1311                case 3: INVERT_8(dest, -3);
1312                case 2: INVERT_8(dest, -2);
1313                case 1: INVERT_8(dest, -1);
1314                                } while (--n > 0);
1315                }
1316        }
1317
1318        // 32-bit cell to invert?
1319        if (length & 4) {
1320                INVERT_4(dest, 0);
1321                if (bpp <= 16)
1322                        dest += 4;
1323        }
1324
1325        // 16-bit cell to invert?
1326        if (bpp <= 16 && (length & 2)) {
1327                INVERT_2(dest, 0);
1328                if (bpp <= 8)
1329                        dest += 2;
1330        }
1331
1332        // 8-bit cell to invert?
1333        if (bpp <= 8 && (length & 1))
1334                INVERT_1(dest, 0);
1335
1336 #undef INVERT_1
1337 #undef INVERT_2
1338 #undef INVERT_4
1339 #undef INVERT_8
1340 }
1341
1342 void NQD_invrect(uint32 p)
1343 {
1344        D(bug("accl_invrect %08x\n", p));
1345
1346        // Get inversion parameters
1347        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1348        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1349        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1350        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1351        D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1352        D(bug(" width %d, height %d, bytes_per_row %d\n", width, height, (int32)ReadMacInt32(p + acclDestRowBytes)));
1353
1354        //!!?? pen_mode == 14
1355
1356        // And perform the inversion
1357        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1358        const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1359        uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1360        width *= bpp;
1361        switch (bpp) {
1362        case 1:
1363                for (int i = 0; i < height; i++) {
1364                        do_invrect<8>(dest, width);
1365                        dest += dest_row_bytes;
1366                }
1367                break;
1368        case 2:
1369                for (int i = 0; i < height; i++) {
1370                        do_invrect<16>(dest, width);
1371                        dest += dest_row_bytes;
1372                }
1373                break;
1374        case 4:
1375                for (int i = 0; i < height; i++) {
1376                        do_invrect<32>(dest, width);
1377                        dest += dest_row_bytes;
1378                }
1379                break;
1380        }
1381 }
1382
1383 // Rectangle filling
1384 template< int bpp >
1385 static inline void do_fillrect(uint8 *dest, uint32 color, uint32 length)
1386 {
1387 #define FILL_1(PTR, OFS, VAL) ((uint8  *)(PTR))[OFS] = (VAL)
1388 #define FILL_2(PTR, OFS, VAL) ((uint16 *)(PTR))[OFS] = (VAL)
1389 #define FILL_4(PTR, OFS, VAL) ((uint32 *)(PTR))[OFS] = (VAL)
1390 #define FILL_8(PTR, OFS, VAL) ((uint64 *)(PTR))[OFS] = (VAL)
1391
1392 #ifndef UNALIGNED_PROFITABLE
1393        // Align on 16-bit boundaries
1394        if (bpp < 16 && (((uintptr)dest) & 1)) {
1395                FILL_1(dest, 0, color);
1396                dest += 1; length -= 1;
1397        }
1398
1399        // Align on 32-bit boundaries
1400        if (bpp < 32 && (((uintptr)dest) & 2)) {
1401                FILL_2(dest, 0, color);
1402                dest += 2; length -= 2;
1403        }
1404 #endif
1405
1406        // Fill 8-byte words
1407        if (length >= 8) {
1408                const uint64 c = (((uint64)color) << 32) | color;
1409                const int r = (length / 8) % 8;
1410                dest += r * 8;
1411
1412                int n = ((length / 8) + 7) / 8;
1413                switch (r) {
1414                case 0: do {
1415                                dest += 64;
1416                                FILL_8(dest, -8, c);
1417                case 7: FILL_8(dest, -7, c);
1418                case 6: FILL_8(dest, -6, c);
1419                case 5: FILL_8(dest, -5, c);
1420                case 4: FILL_8(dest, -4, c);
1421                case 3: FILL_8(dest, -3, c);
1422                case 2: FILL_8(dest, -2, c);
1423                case 1: FILL_8(dest, -1, c);
1424                                } while (--n > 0);
1425                }
1426        }
1427
1428        // 32-bit cell to fill?
1429        if (length & 4) {
1430                FILL_4(dest, 0, color);
1431                if (bpp <= 16)
1432                        dest += 4;
1433        }
1434
1435        // 16-bit cell to fill?
1436        if (bpp <= 16 && (length & 2)) {
1437                FILL_2(dest, 0, color);
1438                if (bpp <= 8)
1439                        dest += 2;
1440        }
1441
1442        // 8-bit cell to fill?
1443        if (bpp <= 8 && (length & 1))
1444                FILL_1(dest, 0, color);
1445
1446 #undef FILL_1
1447 #undef FILL_2
1448 #undef FILL_4
1449 #undef FILL_8
1450 }
1451
1452 void NQD_fillrect(uint32 p)
1453 {
1454        D(bug("accl_fillrect %08x\n", p));
1455
1456        // Get filling parameters
1457        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1458        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1459        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1460        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1461        uint32 color = htonl(ReadMacInt32(p + acclPenMode) == 8 ? ReadMacInt32(p + acclForePen) : ReadMacInt32(p + acclBackPen));
1462        D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1463        D(bug(" width %d, height %d\n", width, height));
1464        D(bug(" bytes_per_row %d color %08x\n", (int32)ReadMacInt32(p + acclDestRowBytes), color));
1465
1466        // And perform the fill
1467        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1468        const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1469        uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1470        width *= bpp;
1471        switch (bpp) {
1472        case 1:
1473                for (int i = 0; i < height; i++) {
1474                        memset(dest, color, width);
1475                        dest += dest_row_bytes;
1476                }
1477                break;
1478        case 2:
1479                for (int i = 0; i < height; i++) {
1480                        do_fillrect<16>(dest, color, width);
1481                        dest += dest_row_bytes;
1482                }
1483                break;
1484        case 4:
1485                for (int i = 0; i < height; i++) {
1486                        do_fillrect<32>(dest, color, width);
1487                        dest += dest_row_bytes;
1488                }
1489                break;
1490        }
1491 }
1492
1493 bool NQD_fillrect_hook(uint32 p)
1494 {
1495        D(bug("accl_fillrect_hook %08x\n", p));
1496
1497        // Check if we can accelerate this fillrect
1498        if (ReadMacInt32(p + 0x284) != 0 && ReadMacInt32(p + acclDestPixelSize) >= 8) {
1499                const int transfer_mode = ReadMacInt32(p + acclTransferMode);
1500                if (transfer_mode == 8) {
1501                        // Fill
1502                        WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_FILLRECT));
1503                        return true;
1504                }
1505                else if (transfer_mode == 10) {
1506                        // Invert
1507                        WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_INVRECT));
1508                        return true;
1509                }
1510        }
1511        return false;
1512 }
1513
1514 // Rectangle blitting
1515 // TODO: optimize for VOSF and target pixmap == screen
1516 void NQD_bitblt(uint32 p)
1517 {
1518        D(bug("accl_bitblt %08x\n", p));
1519
1520        // Get blitting parameters
1521        int16 src_X  = (int16)ReadMacInt16(p + acclSrcRect + 2) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 2);
1522        int16 src_Y  = (int16)ReadMacInt16(p + acclSrcRect + 0) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 0);
1523        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1524        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1525        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1526        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1527        D(bug(" src addr %08x, dest addr %08x\n", ReadMacInt32(p + acclSrcBaseAddr), ReadMacInt32(p + acclDestBaseAddr)));
1528        D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y));
1529        D(bug(" width %d, height %d\n", width, height));
1530
1531        // And perform the blit
1532        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclSrcPixelSize));
1533        width *= bpp;
1534        if ((int32)ReadMacInt32(p + acclSrcRowBytes) > 0) {
1535                const int src_row_bytes = (int32)ReadMacInt32(p + acclSrcRowBytes);
1536                const int dst_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1537                uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + (src_Y * src_row_bytes) + (src_X * bpp));
1538                uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dst_row_bytes) + (dest_X * bpp));
1539                for (int i = 0; i < height; i++) {
1540                        memmove(dst, src, width);
1541                        src += src_row_bytes;
1542                        dst += dst_row_bytes;
1543                }
1544        }
1545        else {
1546                const int src_row_bytes = -(int32)ReadMacInt32(p + acclSrcRowBytes);
1547                const int dst_row_bytes = -(int32)ReadMacInt32(p + acclDestRowBytes);
1548                uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp));
1549                uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp));
1550                for (int i = height - 1; i >= 0; i--) {
1551                        memmove(dst, src, width);
1552                        src -= src_row_bytes;
1553                        dst -= dst_row_bytes;
1554                }
1555        }
1556 }
1557
1558 /*
1559  BitBlt transfer modes:
1560  0 : srcCopy
1561  1 : srcOr
1562  2 : srcXor
1563  3 : srcBic
1564  4 : notSrcCopy
1565  5 : notSrcOr
1566  6 : notSrcXor
1567  7 : notSrcBic
1568  32 : blend
1569  33 : addPin
1570  34 : addOver
1571  35 : subPin
1572  36 : transparent
1573  37 : adMax
1574  38 : subOver
1575  39 : adMin
1576  50 : hilite
1577 */
1578
1579 bool NQD_bitblt_hook(uint32 p)
1580 {
1581        D(bug("accl_draw_hook %08x\n", p));
1582
1583        // Check if we can accelerate this bitblt
1584        if (ReadMacInt32(p + 0x018) + ReadMacInt32(p + 0x128) == 0 &&
1585                ReadMacInt32(p + 0x130) == 0 &&
1586                ReadMacInt32(p + acclSrcPixelSize) >= 8 &&
1587                ReadMacInt32(p + acclSrcPixelSize) == ReadMacInt32(p + acclDestPixelSize) &&
1588                (ReadMacInt32(p + acclSrcRowBytes) ^ ReadMacInt32(p + acclDestRowBytes)) >= 0 && // same sign?
1589                ReadMacInt32(p + acclTransferMode) == 0 &&                                                                               // srcCopy?
1590                ReadMacInt32(p + 0x15c) > 0) {
1591
1592                // Yes, set function pointer
1593                WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_BITBLT));
1594                return true;
1595        }
1596        return false;
1597 }
1598
1599 // Wait for graphics operation to finish
1600 bool NQD_sync_hook(uint32 arg)
1601 {
1602        D(bug("accl_sync_hook %08x\n", arg));
1603        return true;
1604 }
1605
1606 void VideoInstallAccel(void)
1607 {
1608        // Install acceleration hooks
1609        if (PrefsFindBool("gfxaccel")) {
1610                D(bug("Video: Installing acceleration hooks\n"));
1611                uint32 base;
1612
1613                SheepVar bitblt_hook_info(sizeof(accl_hook_info));
1614                base = bitblt_hook_info.addr();
1615                WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK));
1616                WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
1617                WriteMacInt32(base + 8, ACCL_BITBLT);
1618                NQDMisc(6, bitblt_hook_info.ptr());
1619
1620                SheepVar fillrect_hook_info(sizeof(accl_hook_info));
1621                base = fillrect_hook_info.addr();
1622                WriteMacInt32(base + 0, NativeTVECT(NATIVE_FILLRECT_HOOK));
1623                WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
1624                WriteMacInt32(base + 8, ACCL_FILLRECT);
1625                NQDMisc(6, fillrect_hook_info.ptr());
1626        }
1627 }
1628 #endif
1629
1630
1631 /*
1564   *  Keyboard-related utilify functions
1565   */
1566  
# Line 1698 | Line 1630 | static int kc_decode(SDL_keysym const &
1630  
1631          case SDLK_1: case SDLK_EXCLAIM: return 0x12;
1632          case SDLK_2: case SDLK_AT: return 0x13;
1633 < //      case SDLK_3: case SDLK_numbersign: return 0x14;
1633 >        case SDLK_3: case SDLK_HASH: return 0x14;
1634          case SDLK_4: case SDLK_DOLLAR: return 0x15;
1635 < //      case SDLK_5: case SDLK_percent: return 0x17;
1635 >        case SDLK_5: return 0x17;
1636          case SDLK_6: return 0x16;
1637          case SDLK_7: return 0x1a;
1638          case SDLK_8: return 0x1c;
1639          case SDLK_9: return 0x19;
1640          case SDLK_0: return 0x1d;
1641  
1642 < //      case SDLK_BACKQUOTE: case SDLK_asciitilde: return 0x0a;
1642 >        case SDLK_BACKQUOTE: return 0x0a;
1643          case SDLK_MINUS: case SDLK_UNDERSCORE: return 0x1b;
1644          case SDLK_EQUALS: case SDLK_PLUS: return 0x18;
1645 < //      case SDLK_bracketleft: case SDLK_braceleft: return 0x21;
1646 < //      case SDLK_bracketright: case SDLK_braceright: return 0x1e;
1647 < //      case SDLK_BACKSLASH: case SDLK_bar: return 0x2a;
1645 >        case SDLK_LEFTBRACKET: return 0x21;
1646 >        case SDLK_RIGHTBRACKET: return 0x1e;
1647 >        case SDLK_BACKSLASH: return 0x2a;
1648          case SDLK_SEMICOLON: case SDLK_COLON: return 0x29;
1649 < //      case SDLK_apostrophe: case SDLK_QUOTEDBL: return 0x27;
1649 >        case SDLK_QUOTE: case SDLK_QUOTEDBL: return 0x27;
1650          case SDLK_COMMA: case SDLK_LESS: return 0x2b;
1651          case SDLK_PERIOD: case SDLK_GREATER: return 0x2f;
1652          case SDLK_SLASH: case SDLK_QUESTION: return 0x2c;
# Line 1746 | Line 1678 | static int kc_decode(SDL_keysym const &
1678          case SDLK_LMETA: return 0x3a;
1679          case SDLK_RMETA: return 0x3a;
1680   #endif
1681 +        case SDLK_LSUPER: return 0x3a; // "Windows" key
1682 +        case SDLK_RSUPER: return 0x3a;
1683          case SDLK_MENU: return 0x32;
1684          case SDLK_CAPSLOCK: return 0x39;
1685          case SDLK_NUMLOCK: return 0x47;
# Line 1962 | Line 1896 | static void update_display_static(driver
1896  
1897          // Check for first column from left and first column from right that have changed
1898          if (high) {
1899 <                if (VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1899 >                if ((int)VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1900                          const int src_bytes_per_row = bytes_per_row;
1901                          const int dst_bytes_per_row = drv->s->pitch;
1902                          const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;
# Line 2079 | Line 2013 | static void update_display_static(driver
2013          }
2014   }
2015  
2016 + // Static display update (fixed frame rate, bounding boxes based)
2017 + // XXX use NQD bounding boxes to help detect dirty areas?
2018 + static void update_display_static_bbox(driver_window *drv)
2019 + {
2020 +        const VIDEO_MODE &mode = drv->mode;
2021 +
2022 +        // Allocate bounding boxes for SDL_UpdateRects()
2023 +        const int N_PIXELS = 64;
2024 +        const int n_x_boxes = (VIDEO_MODE_X + N_PIXELS - 1) / N_PIXELS;
2025 +        const int n_y_boxes = (VIDEO_MODE_Y + N_PIXELS - 1) / N_PIXELS;
2026 +        SDL_Rect *boxes = (SDL_Rect *)alloca(sizeof(SDL_Rect) * n_x_boxes * n_y_boxes);
2027 +        int nr_boxes = 0;
2028 +
2029 +        // Lock surface, if required
2030 +        if (SDL_MUSTLOCK(drv->s))
2031 +                SDL_LockSurface(drv->s);
2032 +
2033 +        // Update the surface from Mac screen
2034 +        const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2035 +        const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2036 +        int x, y;
2037 +        for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2038 +                int h = N_PIXELS;
2039 +                if (h > VIDEO_MODE_Y - y)
2040 +                        h = VIDEO_MODE_Y - y;
2041 +                for (x = 0; x < VIDEO_MODE_X; x += N_PIXELS) {
2042 +                        int w = N_PIXELS;
2043 +                        if (w > VIDEO_MODE_X - x)
2044 +                                w = VIDEO_MODE_X - x;
2045 +                        const int xs = w * bytes_per_pixel;
2046 +                        const int xb = x * bytes_per_pixel;
2047 +                        bool dirty = false;
2048 +                        for (int j = y; j < (y + h); j++) {
2049 +                                const int yb = j * bytes_per_row;
2050 +                                if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2051 +                                        memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2052 +                                        Screen_blit((uint8 *)drv->s->pixels + yb + xb, the_buffer + yb + xb, xs);
2053 +                                        dirty = true;
2054 +                                }
2055 +                        }
2056 +                        if (dirty) {
2057 +                                boxes[nr_boxes].x = x;
2058 +                                boxes[nr_boxes].y = y;
2059 +                                boxes[nr_boxes].w = w;
2060 +                                boxes[nr_boxes].h = h;
2061 +                                nr_boxes++;
2062 +                        }
2063 +                }
2064 +        }
2065 +
2066 +        // Unlock surface, if required
2067 +        if (SDL_MUSTLOCK(drv->s))
2068 +                SDL_UnlockSurface(drv->s);
2069 +
2070 +        // Refresh display
2071 +        if (nr_boxes)
2072 +                SDL_UpdateRects(drv->s, nr_boxes, boxes);
2073 + }
2074 +
2075  
2076   // We suggest the compiler to inline the next two functions so that it
2077   // may specialise the code according to the current screen depth and
# Line 2139 | Line 2132 | static void video_refresh_dga_vosf(void)
2132                  tick_counter = 0;
2133                  if (mainBuffer.dirty) {
2134                          LOCK_VOSF;
2135 <                        update_display_dga_vosf();
2135 >                        update_display_dga_vosf(static_cast<driver_fullscreen *>(drv));
2136                          UNLOCK_VOSF;
2137                  }
2138          }
# Line 2173 | Line 2166 | static void video_refresh_window_static(
2166          static int tick_counter = 0;
2167          if (++tick_counter >= frame_skip) {
2168                  tick_counter = 0;
2169 <                update_display_static(static_cast<driver_window *>(drv));
2169 >                const VIDEO_MODE &mode = drv->mode;
2170 >                if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2171 >                        update_display_static_bbox(static_cast<driver_window *>(drv));
2172 >                else
2173 >                        update_display_static(static_cast<driver_window *>(drv));
2174          }
2175   }
2176  
# Line 2203 | Line 2200 | static void VideoRefreshInit(void)
2200          }
2201   }
2202  
2203 + static inline void do_video_refresh(void)
2204 + {
2205 +        // Handle SDL events
2206 +        handle_events();
2207 +
2208 +        // Update display
2209 +        video_refresh();
2210 +
2211 + #ifdef SHEEPSHAVER
2212 +        // Set new cursor image if it was changed
2213 +        if (cursor_changed && sdl_cursor) {
2214 +                cursor_changed = false;
2215 +                LOCK_EVENTS;
2216 +                SDL_FreeCursor(sdl_cursor);
2217 +                sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2218 +                if (sdl_cursor) {
2219 +                        SDL_SetCursor(sdl_cursor);
2220 + #ifdef WIN32
2221 +                        // XXX Windows apparently needs an extra mouse event to
2222 +                        // make the new cursor image visible
2223 +                        int visible = SDL_ShowCursor(-1);
2224 +                        if (visible) {
2225 +                                int x, y;
2226 +                                SDL_GetMouseState(&x, &y);
2227 +                                SDL_WarpMouse(x, y);
2228 +                        }
2229 + #endif
2230 +                }
2231 +                UNLOCK_EVENTS;
2232 +        }
2233 + #endif
2234 +
2235 +        // Set new palette if it was changed
2236 +        handle_palette_changes();
2237 + }
2238 +
2239 + // This function is called on non-threaded platforms from a timer interrupt
2240 + void VideoRefresh(void)
2241 + {
2242 +        // We need to check redraw_thread_active to inhibit refreshed during
2243 +        // mode changes on non-threaded platforms
2244 +        if (!redraw_thread_active)
2245 +                return;
2246 +
2247 +        // Process pending events and update display
2248 +        do_video_refresh();
2249 + }
2250 +
2251   const int VIDEO_REFRESH_HZ = 60;
2252   const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2253  
2254 + #ifndef USE_CPU_EMUL_SERVICES
2255   static int redraw_func(void *arg)
2256   {
2257          uint64 start = GetTicks_usec();
# Line 2223 | Line 2269 | static int redraw_func(void *arg)
2269                          next = GetTicks_usec();
2270                  ticks++;
2271  
2226                // Handle SDL events
2227                handle_events();
2228
2229                // Refresh display
2230                video_refresh();
2231
2272   #ifdef SHEEPSHAVER
2273 <                // Set new cursor image if it was changed
2274 <                if (cursor_changed && sdl_cursor) {
2275 <                        cursor_changed = false;
2276 <                        SDL_FreeCursor(sdl_cursor);
2237 <                        sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2238 <                        if (sdl_cursor)
2239 <                                SDL_SetCursor(sdl_cursor);
2273 >                // Pause if requested (during video mode switches)
2274 >                if (thread_stop_req) {
2275 >                        thread_stop_ack = true;
2276 >                        continue;
2277                  }
2278   #endif
2279  
2280 <                // Set new palette if it was changed
2281 <                handle_palette_changes();
2280 >                // Process pending events and update display
2281 >                do_video_refresh();
2282          }
2283  
2284          uint64 end = GetTicks_usec();
2285          D(bug("%lld refreshes in %lld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
2286          return 0;
2287   }
2288 + #endif
2289 +
2290 +
2291 + /*
2292 + *  Record dirty area from NQD
2293 + */
2294 +
2295 + #ifdef SHEEPSHAVER
2296 + void video_set_dirty_area(int x, int y, int w, int h)
2297 + {
2298 +        const VIDEO_MODE &mode = drv->mode;
2299 +        const int screen_width = VIDEO_MODE_X;
2300 +        const int screen_height = VIDEO_MODE_Y;
2301 +        const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2302 +
2303 + #ifdef ENABLE_VOSF
2304 +        if (use_vosf) {
2305 +                vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2306 +                return;
2307 +        }
2308 + #endif
2309 +
2310 +        // XXX handle dirty bounding boxes for non-VOSF modes
2311 + }
2312 + #endif

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines