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.27 by gbeauche, 2006-05-14T08:32:05Z

# 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-2005 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 + *  - Ctr-Tab for suspend/resume but how? SDL does not support that for non-Linux
31   *  - Ctrl-Fn doesn't generate SDL_KEYDOWN events (SDL bug?)
32   *  - Mouse acceleration, there is no API in SDL yet for that
33   *  - Force relative mode in Grab mode even if SDL provides absolute coordinates?
# Line 37 | Line 38
38   *    Besides, there can't seem to be a way to call SetVideoMode() from a child thread.
39   *  - Refresh performance is still slow. Use SDL_CreateRGBSurface()?
40   *  - Backport hw cursor acceleration to Basilisk II?
41 < *  - Move generic Native QuickDraw acceleration routines to gfxaccel.cpp
41 > *  - Factor out code
42   */
43  
44   #include "sysdeps.h"
# Line 57 | Line 58
58   #include "video.h"
59   #include "video_defs.h"
60   #include "video_blit.h"
61 + #include "vm_alloc.h"
62  
63   #define DEBUG 0
64   #include "debug.h"
# Line 82 | Line 84 | static int display_type = DISPLAY_WINDOW
84   #endif
85  
86   // Constants
87 + #ifdef WIN32
88 + const char KEYCODE_FILE_NAME[] = "BasiliskII_keycodes";
89 + #else
90   const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
91 + #endif
92  
93  
94   // Global variables
# Line 95 | Line 101 | static uint8 *the_buffer_copy = NULL;
101   static uint32 the_buffer_size;                                          // Size of allocated the_buffer
102  
103   static bool redraw_thread_active = false;                       // Flag: Redraw thread installed
104 + #ifndef USE_CPU_EMUL_SERVICES
105   static volatile bool redraw_thread_cancel;                      // Flag: Cancel Redraw thread
106   static SDL_Thread *redraw_thread = NULL;                        // Redraw thread
107 + #ifdef SHEEPSHAVER
108 + static volatile bool thread_stop_req = false;
109 + static volatile bool thread_stop_ack = false;           // Acknowledge for thread_stop_req
110 + #endif
111 + #endif
112  
113   #ifdef ENABLE_VOSF
114   static bool use_vosf = false;                                           // Flag: VOSF enabled
# Line 123 | Line 135 | static SDL_Color sdl_palette[256];                                     /
135   static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
136   static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
137  
138 + // Mutex to protect SDL events
139 + static SDL_mutex *sdl_events_lock = NULL;
140 + #define LOCK_EVENTS SDL_LockMutex(sdl_events_lock)
141 + #define UNLOCK_EVENTS SDL_UnlockMutex(sdl_events_lock)
142 +
143   // Mutex to protect palette
144   static SDL_mutex *sdl_palette_lock = NULL;
145   #define LOCK_PALETTE SDL_LockMutex(sdl_palette_lock)
# Line 146 | Line 163 | extern void SysMountFirstFloppy(void);
163  
164  
165   /*
166 + *  SDL surface locking glue
167 + */
168 +
169 + #ifdef ENABLE_VOSF
170 + #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE) do {                               \
171 +        if ((SURFACE)->flags & (SDL_HWSURFACE | SDL_FULLSCREEN))        \
172 +                the_host_buffer = (uint8 *)(SURFACE)->pixels;                   \
173 + } while (0)
174 + #else
175 + #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE)
176 + #endif
177 +
178 + #define SDL_VIDEO_LOCK_SURFACE(SURFACE) do {    \
179 +        if (SDL_MUSTLOCK(SURFACE)) {                            \
180 +                SDL_LockSurface(SURFACE);                               \
181 +                SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE);   \
182 +        }                                                                                       \
183 + } while (0)
184 +
185 + #define SDL_VIDEO_UNLOCK_SURFACE(SURFACE) do {  \
186 +        if (SDL_MUSTLOCK(SURFACE))                                      \
187 +                SDL_UnlockSurface(SURFACE);                             \
188 + } while (0)
189 +
190 +
191 + /*
192 + *  Framebuffer allocation routines
193 + */
194 +
195 + static void *vm_acquire_framebuffer(uint32 size)
196 + {
197 +        return vm_acquire(size);
198 + }
199 +
200 + static inline void vm_release_framebuffer(void *fb, uint32 size)
201 + {
202 +        vm_release(fb, size);
203 + }
204 +
205 +
206 + /*
207 + *  Windows message handler
208 + */
209 +
210 + #ifdef WIN32
211 + #include <dbt.h>
212 + static WNDPROC sdl_window_proc = NULL;                          // Window proc used by SDL
213 +
214 + extern void SysMediaArrived(void);
215 + extern void SysMediaRemoved(void);
216 + extern HWND GetMainWindowHandle(void);
217 +
218 + static LRESULT CALLBACK windows_message_handler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
219 + {
220 +        switch (msg) {
221 +        case WM_DEVICECHANGE:
222 +                if (wParam == DBT_DEVICEREMOVECOMPLETE) {
223 +                        DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
224 +                        if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
225 +                                SysMediaRemoved();
226 +                }
227 +                else if (wParam == DBT_DEVICEARRIVAL) {
228 +                        DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
229 +                        if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
230 +                                SysMediaArrived();
231 +                }
232 +                return 0;
233 +
234 +        default:
235 +                if (sdl_window_proc)
236 +                        return CallWindowProc(sdl_window_proc, hwnd, msg, wParam, lParam);
237 +        }
238 +
239 +        return DefWindowProc(hwnd, msg, wParam, lParam);
240 + }
241 + #endif
242 +
243 +
244 + /*
245   *  SheepShaver glue
246   */
247  
# Line 190 | Line 286 | static vector<monitor_desc *> VideoMonit
286   // Find Apple mode matching best specified dimensions
287   static int find_apple_resolution(int xsize, int ysize)
288   {
289 <        int apple_id;
290 <        if (xsize < 800)
291 <                apple_id = APPLE_640x480;
292 <        else if (xsize < 1024)
293 <                apple_id = APPLE_800x600;
294 <        else if (xsize < 1152)
295 <                apple_id = APPLE_1024x768;
296 <        else if (xsize < 1280) {
297 <                if (ysize < 900)
298 <                        apple_id = APPLE_1152x768;
299 <                else
300 <                        apple_id = APPLE_1152x900;
301 <        }
302 <        else if (xsize < 1600)
303 <                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;
289 >        if (xsize == 640 && ysize == 480)
290 >                return APPLE_640x480;
291 >        if (xsize == 800 && ysize == 600)
292 >                return APPLE_800x600;
293 >        if (xsize == 1024 && ysize == 768)
294 >                return APPLE_1024x768;
295 >        if (xsize == 1152 && ysize == 768)
296 >                return APPLE_1152x768;
297 >        if (xsize == 1152 && ysize == 900)
298 >                return APPLE_1152x900;
299 >        if (xsize == 1280 && ysize == 1024)
300 >                return APPLE_1280x1024;
301 >        if (xsize == 1600 && ysize == 1200)
302 >                return APPLE_1600x1200;
303 >        return APPLE_CUSTOM;
304   }
305  
306   // Display error alert
# Line 325 | Line 373 | static inline int bytes_per_pixel(int de
373   }
374  
375   // Map video_mode depth ID to numerical depth value
376 < static int sdl_depth_of_video_depth(int video_depth)
376 > static int mac_depth_of_video_depth(int video_depth)
377   {
378          int depth = -1;
379          switch (video_depth) {
# Line 353 | Line 401 | static int sdl_depth_of_video_depth(int
401          return depth;
402   }
403  
404 < // Check wether specified mode is available
405 < static bool has_mode(int type, int width, int height)
404 > // Map video_mode depth ID to SDL screen depth
405 > static int sdl_depth_of_video_depth(int video_depth)
406   {
407 <        // FIXME: no fullscreen support yet
408 <        if (type == DISPLAY_SCREEN)
409 <                return false;
407 >        return (video_depth <= VIDEO_DEPTH_8BIT) ? 8 : mac_depth_of_video_depth(video_depth);
408 > }
409 >
410 > // Get screen dimensions
411 > static void sdl_display_dimensions(int &width, int &height)
412 > {
413 >        static int max_width, max_height;
414 >        if (max_width == 0 && max_height == 0) {
415 >                max_width = 640 ; max_height = 480;
416 >                SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
417 >                if (modes && modes != (SDL_Rect **)-1) {
418 >                        // It turns out that on some implementations, and contrary to the documentation,
419 >                        // the returned list is not sorted from largest to smallest (e.g. Windows)
420 >                        for (int i = 0; modes[i] != NULL; i++) {
421 >                                const int w = modes[i]->w;
422 >                                const int h = modes[i]->h;
423 >                                if (w > max_width && h > max_height) {
424 >                                        max_width = w;
425 >                                        max_height = h;
426 >                                }
427 >                        }
428 >                }
429 >        }
430 >        width = max_width;
431 >        height = max_height;
432 > }
433 >
434 > static inline int sdl_display_width(void)
435 > {
436 >        int width, height;
437 >        sdl_display_dimensions(width, height);
438 >        return width;
439 > }
440 >
441 > static inline int sdl_display_height(void)
442 > {
443 >        int width, height;
444 >        sdl_display_dimensions(width, height);
445 >        return height;
446 > }
447  
448 + // Check wether specified mode is available
449 + static bool has_mode(int type, int width, int height, int depth)
450 + {
451   #ifdef SHEEPSHAVER
452 <        // Filter out Classic resolutiosn
452 >        // Filter out Classic resolutions
453          if (width == 512 && height == 384)
454                  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;
455   #endif
456 <        return false;
456 >
457 >        // Filter out out-of-bounds resolutions
458 >        if (width > sdl_display_width() || height > sdl_display_height())
459 >                return false;
460 >
461 >        // Rely on SDL capabilities
462 >        return SDL_VideoModeOK(width, height,
463 >                                                   sdl_depth_of_video_depth(depth),
464 >                                                   SDL_HWSURFACE | (type == DISPLAY_SCREEN ? SDL_FULLSCREEN : 0));
465   }
466  
467   // Add mode to list of supported modes
468   static void add_mode(int type, int width, int height, int resolution_id, int bytes_per_row, int depth)
469   {
470          // Filter out unsupported modes
471 <        if (!has_mode(type, width, height))
471 >        if (!has_mode(type, width, height, depth))
472                  return;
473  
474          // Fill in VideoMode entry
475          VIDEO_MODE mode;
476   #ifdef SHEEPSHAVER
477 <        // Recalculate dimensions to fit Apple modes
409 <        resolution_id = match_apple_resolution(width, height);
477 >        resolution_id = find_apple_resolution(width, height);
478          mode.viType = type;
479   #endif
480          VIDEO_MODE_X = width;
481          VIDEO_MODE_Y = height;
482          VIDEO_MODE_RESOLUTION = resolution_id;
483          VIDEO_MODE_ROW_BYTES = bytes_per_row;
484 <        VIDEO_MODE_DEPTH = depth;
484 >        VIDEO_MODE_DEPTH = (video_depth)depth;
485          VideoModes.push_back(mode);
486   }
487  
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
488   // Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
489   static void set_mac_frame_buffer(SDL_monitor_desc &monitor, int depth, bool native_byte_order)
490   {
# Line 469 | Line 524 | static void set_window_name(int name)
524   // Set mouse grab mode
525   static SDL_GrabMode set_grab_mode(SDL_GrabMode mode)
526   {
527 <        const SDL_VideoInfo *vi =SDL_GetVideoInfo();
527 >        const SDL_VideoInfo *vi = SDL_GetVideoInfo();
528          return (vi && vi->wm_available ? SDL_WM_GrabInput(mode) : SDL_GRAB_OFF);
529   }
530  
531 + // Migrate preferences items (XXX to be handled in MigratePrefs())
532 + static void migrate_screen_prefs(void)
533 + {
534 + #ifdef SHEEPSHAVER
535 +        // Look-up priorities are: "screen", "screenmodes", "windowmodes".
536 +        if (PrefsFindString("screen"))
537 +                return;
538 +
539 +        uint32 window_modes = PrefsFindInt32("windowmodes");
540 +        uint32 screen_modes = PrefsFindInt32("screenmodes");
541 +        int width = 0, height = 0;
542 +        if (screen_modes) {
543 +                static const struct {
544 +                        int id;
545 +                        int width;
546 +                        int height;
547 +                }
548 +                modes[] = {
549 +                        {  1,    640,    480 },
550 +                        {  2,    800,    600 },
551 +                        {  4,   1024,    768 },
552 +                        { 64,   1152,    768 },
553 +                        {  8,   1152,    900 },
554 +                        { 16,   1280,   1024 },
555 +                        { 32,   1600,   1200 },
556 +                        { 0, }
557 +                };
558 +                for (int i = 0; modes[i].id != 0; i++) {
559 +                        if (screen_modes & modes[i].id) {
560 +                                if (width < modes[i].width && height < modes[i].height) {
561 +                                        width = modes[i].width;
562 +                                        height = modes[i].height;
563 +                                }
564 +                        }
565 +                }
566 +        } else {
567 +                if (window_modes & 1)
568 +                        width = 640, height = 480;
569 +                if (window_modes & 2)
570 +                        width = 800, height = 600;
571 +        }
572 +        if (width && height) {
573 +                char str[32];
574 +                sprintf(str, "%s/%d/%d", screen_modes ? "dga" : "win", width, height);
575 +                PrefsReplaceString("screen", str);
576 +        }
577 + #endif
578 + }
579 +
580  
581   /*
582   *  Display "driver" classes
# Line 528 | Line 632 | private:
632          int mouse_last_x, mouse_last_y; // Last mouse position (for relative mode)
633   };
634  
635 + class driver_fullscreen : public driver_base {
636 + public:
637 +        driver_fullscreen(SDL_monitor_desc &monitor);
638 +        ~driver_fullscreen();
639 + };
640 +
641   static driver_base *drv = NULL; // Pointer to currently used driver object
642  
643   #ifdef ENABLE_VOSF
# Line 549 | Line 659 | driver_base::~driver_base()
659          if (s)
660                  SDL_FreeSurface(s);
661  
662 +        // the_buffer shall always be mapped through vm_acquire_framebuffer()
663 +        if (the_buffer != VM_MAP_FAILED) {
664 +                D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
665 +                vm_release_framebuffer(the_buffer, the_buffer_size);
666 +                the_buffer = NULL;
667 +        }
668 +
669          // Free frame buffer(s)
670          if (!use_vosf) {
554                if (the_buffer) {
555                        free(the_buffer);
556                        the_buffer = NULL;
557                }
671                  if (the_buffer_copy) {
672                          free(the_buffer_copy);
673                          the_buffer_copy = NULL;
# Line 562 | Line 675 | driver_base::~driver_base()
675          }
676   #ifdef ENABLE_VOSF
677          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                }
678                  if (the_host_buffer) {
679                          D(bug(" freeing the_host_buffer at %p\n", the_host_buffer));
680                          free(the_host_buffer);
# Line 578 | Line 685 | driver_base::~driver_base()
685                          free(the_buffer_copy);
686                          the_buffer_copy = NULL;
687                  }
688 +
689 +                // Deinitialize VOSF
690 +                video_vosf_exit();
691          }
692   #endif
693   }
# Line 587 | Line 697 | void driver_base::update_palette(void)
697   {
698          const VIDEO_MODE &mode = monitor.get_current_mode();
699  
700 <        if (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
700 >        if ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
701                  SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
702   }
703  
# Line 618 | Line 728 | driver_window::driver_window(SDL_monitor
728          ADBSetRelMouseMode(mouse_grabbed);
729  
730          // Create surface
731 <        int depth = (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
731 >        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
732          if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
733                  return;
734  
# Line 627 | Line 737 | driver_window::driver_window(SDL_monitor
737          // Allocate memory for frame buffer (SIZE is extended to page-boundary)
738          the_host_buffer = (uint8 *)s->pixels;
739          the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
740 <        the_buffer = (uint8 *)vm_acquire(the_buffer_size);
740 >        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
741          the_buffer_copy = (uint8 *)malloc(the_buffer_size);
742          D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
743  
# Line 651 | Line 761 | driver_window::driver_window(SDL_monitor
761                  // Allocate memory for frame buffer
762                  the_buffer_size = (aligned_height + 2) * s->pitch;
763                  the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
764 <                the_buffer = (uint8 *)calloc(1, the_buffer_size);
764 >                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
765                  D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
766          }
767          
# Line 676 | Line 786 | driver_window::driver_window(SDL_monitor
786          visualFormat.Rmask = f->Rmask;
787          visualFormat.Gmask = f->Gmask;
788          visualFormat.Bmask = f->Bmask;
789 <        Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(VIDEO_MODE_DEPTH));
789 >        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
790  
791          // Load gray ramp to 8->16/32 expand map
792          if (!IsDirectMode(mode))
# Line 743 | Line 853 | void driver_window::mouse_moved(int x, i
853          ADBMouseMoved(x, y);
854   }
855  
856 +
857 + /*
858 + *  Full-screen display driver
859 + */
860 +
861 + // Open display
862 + driver_fullscreen::driver_fullscreen(SDL_monitor_desc &m)
863 +        : driver_base(m)
864 + {
865 +        int width = VIDEO_MODE_X, height = VIDEO_MODE_Y;
866 +        int aligned_width = (width + 15) & ~15;
867 +        int aligned_height = (height + 15) & ~15;
868 +
869 +        // Set absolute mouse mode
870 +        ADBSetRelMouseMode(false);
871 +
872 +        // Create surface
873 +        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
874 +        if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE | SDL_FULLSCREEN)) == NULL)
875 +                return;
876 +
877 + #ifdef ENABLE_VOSF
878 +        use_vosf = true;
879 +        // Allocate memory for frame buffer (SIZE is extended to page-boundary)
880 +        the_host_buffer = (uint8 *)s->pixels;
881 +        the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
882 +        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
883 +        the_buffer_copy = (uint8 *)malloc(the_buffer_size);
884 +        D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
885 +
886 +        // Check whether we can initialize the VOSF subsystem and it's profitable
887 +        if (!video_vosf_init(m)) {
888 +                WarningAlert(STR_VOSF_INIT_ERR);
889 +                use_vosf = false;
890 +        }
891 +        else if (!video_vosf_profitable()) {
892 +                video_vosf_exit();
893 +                printf("VOSF acceleration is not profitable on this platform, disabling it\n");
894 +                use_vosf = false;
895 +        }
896 +        if (!use_vosf) {
897 +                free(the_buffer_copy);
898 +                vm_release(the_buffer, the_buffer_size);
899 +                the_host_buffer = NULL;
900 +        }
901 + #endif
902 +        if (!use_vosf) {
903 +                // Allocate memory for frame buffer
904 +                the_buffer_size = (aligned_height + 2) * s->pitch;
905 +                the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
906 +                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
907 +                D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
908 +        }
909 +        
910 +        // Hide cursor
911 +        SDL_ShowCursor(0);
912 +
913 +        // Init blitting routines
914 +        SDL_PixelFormat *f = s->format;
915 +        VisualFormat visualFormat;
916 +        visualFormat.depth = depth;
917 +        visualFormat.Rmask = f->Rmask;
918 +        visualFormat.Gmask = f->Gmask;
919 +        visualFormat.Bmask = f->Bmask;
920 +        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
921 +
922 +        // Load gray ramp to 8->16/32 expand map
923 +        if (!IsDirectMode(mode))
924 +                for (int i=0; i<256; i++)
925 +                        ExpandMap[i] = SDL_MapRGB(f, i, i, i);
926 +
927 +        // Set frame buffer base
928 +        set_mac_frame_buffer(monitor, VIDEO_MODE_DEPTH, true);
929 +
930 +        // Everything went well
931 +        init_ok = true;
932 + }
933 +
934 + // Close display
935 + driver_fullscreen::~driver_fullscreen()
936 + {
937 + #ifdef ENABLE_VOSF
938 +        if (use_vosf)
939 +                the_host_buffer = NULL; // don't free() in driver_base dtor
940 + #endif
941 +        if (s)
942 +                SDL_FreeSurface(s);
943 +
944 +        // Show cursor
945 +        SDL_ShowCursor(1);
946 + }
947 +
948 +
949   /*
950   *  Initialization
951   */
# Line 774 | Line 977 | static void keycode_init(void)
977                  SDL_VideoDriverName(video_driver, sizeof(video_driver));
978                  bool video_driver_found = false;
979                  char line[256];
980 +                int n_keys = 0;
981                  while (fgets(line, sizeof(line) - 1, f)) {
982                          // Read line
983                          int len = strlen(line);
# Line 786 | Line 990 | static void keycode_init(void)
990                                  continue;
991  
992                          if (video_driver_found) {
993 <                                // Skip aliases
993 >                                // Skip aliases as long as we have read keycodes yet
994 >                                // Otherwise, it's another mapping and we have to stop
995                                  static const char sdl_str[] = "sdl";
996 <                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0)
996 >                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0 && n_keys == 0)
997                                          continue;
998  
999                                  // Read keycode
1000                                  int x_code, mac_code;
1001                                  if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
1002 <                                        keycode_table[x_code & 0xff] = mac_code;
1002 >                                        keycode_table[x_code & 0xff] = mac_code, n_keys++;
1003                                  else
1004                                          break;
1005                          } else {
# Line 819 | Line 1024 | static void keycode_init(void)
1024                          WarningAlert(str);
1025                          return;
1026                  }
1027 +
1028 +                D(bug("Using SDL/%s keycodes table, %d key mappings\n", video_driver, n_keys));
1029          }
1030   }
1031  
# Line 837 | Line 1044 | bool SDL_monitor_desc::video_open(void)
1044          case DISPLAY_WINDOW:
1045                  drv = new(std::nothrow) driver_window(*this);
1046                  break;
1047 +        case DISPLAY_SCREEN:
1048 +                drv = new(std::nothrow) driver_fullscreen(*this);
1049 +                break;
1050          }
1051          if (drv == NULL)
1052                  return false;
# Line 846 | Line 1056 | bool SDL_monitor_desc::video_open(void)
1056                  return false;
1057          }
1058  
1059 + #ifdef WIN32
1060 +        // Chain in a new message handler for WM_DEVICECHANGE
1061 +        HWND the_window = GetMainWindowHandle();
1062 +        sdl_window_proc = (WNDPROC)GetWindowLongPtr(the_window, GWLP_WNDPROC);
1063 +        SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)windows_message_handler);
1064 + #endif
1065 +
1066          // Initialize VideoRefresh function
1067          VideoRefreshInit();
1068  
# Line 853 | Line 1070 | bool SDL_monitor_desc::video_open(void)
1070          LOCK_FRAME_BUFFER;
1071  
1072          // Start redraw/input thread
1073 + #ifndef USE_CPU_EMUL_SERVICES
1074          redraw_thread_cancel = false;
1075          redraw_thread_active = ((redraw_thread = SDL_CreateThread(redraw_func, NULL)) != NULL);
1076          if (!redraw_thread_active) {
1077                  printf("FATAL: cannot create redraw thread\n");
1078                  return false;
1079          }
1080 + #else
1081 +        redraw_thread_active = true;
1082 + #endif
1083          return true;
1084   }
1085  
# Line 879 | Line 1100 | bool VideoInit(bool classic)
1100   #endif
1101  
1102          // Create Mutexes
1103 +        if ((sdl_events_lock = SDL_CreateMutex()) == NULL)
1104 +                return false;
1105          if ((sdl_palette_lock = SDL_CreateMutex()) == NULL)
1106                  return false;
1107          if ((frame_buffer_lock = SDL_CreateMutex()) == NULL)
# Line 893 | Line 1116 | bool VideoInit(bool classic)
1116          mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1117  
1118          // Get screen mode from preferences
1119 +        migrate_screen_prefs();
1120          const char *mode_str = NULL;
897 #ifndef SHEEPSHAVER
1121          if (classic_mode)
1122                  mode_str = "win/512/342";
1123          else
1124                  mode_str = PrefsFindString("screen");
902 #endif
1125  
1126          // Determine display type and default dimensions
1127          int default_width, default_height;
# Line 915 | Line 1137 | bool VideoInit(bool classic)
1137          if (mode_str) {
1138                  if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
1139                          display_type = DISPLAY_WINDOW;
1140 <        }
1141 <        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;
1140 >                else if (sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2)
1141 >                        display_type = DISPLAY_SCREEN;
1142          }
1143          if (default_width <= 0)
1144 <                default_width = max_width;
1144 >                default_width = sdl_display_width();
1145 >        else if (default_width > sdl_display_width())
1146 >                default_width = sdl_display_width();
1147          if (default_height <= 0)
1148 <                default_height = max_height;
1148 >                default_height = sdl_display_height();
1149 >        else if (default_height > sdl_display_height())
1150 >                default_height = sdl_display_height();
1151  
1152          // Mac screen depth follows X depth
1153          screen_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
# Line 949 | Line 1167 | bool VideoInit(bool classic)
1167                  break;
1168          }
1169  
1170 +        // Initialize list of video modes to try
1171 +        struct {
1172 +                int w;
1173 +                int h;
1174 +                int resolution_id;
1175 +        }
1176 +        video_modes[] = {
1177 +                {   -1,   -1, 0x80 },
1178 +                {  512,  384, 0x80 },
1179 +                {  640,  480, 0x81 },
1180 +                {  800,  600, 0x82 },
1181 +                { 1024,  768, 0x83 },
1182 +                { 1152,  870, 0x84 },
1183 +                { 1280, 1024, 0x85 },
1184 +                { 1600, 1200, 0x86 },
1185 +                { 0, }
1186 +        };
1187 +        video_modes[0].w = default_width;
1188 +        video_modes[0].h = default_height;
1189 +
1190          // Construct list of supported modes
1191          if (display_type == DISPLAY_WINDOW) {
1192                  if (classic)
1193                          add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
1194                  else {
1195 <                        for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++) {
1196 <                                int bpp = (d <= VIDEO_DEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
1197 <                                if (SDL_VideoModeOK(max_width, max_height, bpp, SDL_HWSURFACE))
1198 <                                        add_window_modes(video_depth(d));
1195 >                        for (int i = 0; video_modes[i].w != 0; i++) {
1196 >                                const int w = video_modes[i].w;
1197 >                                const int h = video_modes[i].h;
1198 >                                if (i > 0 && (w >= default_width || h >= default_height))
1199 >                                        continue;
1200 >                                for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1201 >                                        add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1202                          }
1203                  }
1204 <        } else
1205 <                add_mode(display_type, default_width, default_height, 0x80, TrivialBytesPerRow(default_width, (video_depth)default_depth), default_depth);
1204 >        } else if (display_type == DISPLAY_SCREEN) {
1205 >                for (int i = 0; video_modes[i].w != 0; i++) {
1206 >                        const int w = video_modes[i].w;
1207 >                        const int h = video_modes[i].h;
1208 >                        if (i > 0 && (w >= default_width || h >= default_height))
1209 >                                continue;
1210 >                        if (w == 512 && h == 384)
1211 >                                continue;
1212 > #ifdef ENABLE_VOSF
1213 >                        for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1214 >                                add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1215 > #else
1216 >                        add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)default_depth), default_depth);
1217 > #endif
1218 >                }
1219 >        }
1220 >
1221          if (VideoModes.empty()) {
1222                  ErrorAlert(STR_NO_XVISUAL_ERR);
1223                  return false;
# Line 1032 | Line 1288 | void SDL_monitor_desc::video_close(void)
1288   {
1289          D(bug("video_close()\n"));
1290  
1291 + #ifdef WIN32
1292 +        // Remove message handler for WM_DEVICECHANGE
1293 +        HWND the_window = GetMainWindowHandle();
1294 +        SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)sdl_window_proc);
1295 + #endif
1296 +
1297          // Stop redraw thread
1298 + #ifndef USE_CPU_EMUL_SERVICES
1299          if (redraw_thread_active) {
1300                  redraw_thread_cancel = true;
1301                  SDL_WaitThread(redraw_thread, NULL);
1302          }
1303 + #endif
1304          redraw_thread_active = false;
1305  
1306          // Unlock frame buffer
1307          UNLOCK_FRAME_BUFFER;
1308          D(bug(" frame buffer unlocked\n"));
1309  
1046 #ifdef ENABLE_VOSF
1047        if (use_vosf) {
1048                // Deinitialize VOSF
1049                video_vosf_exit();
1050        }
1051 #endif
1052
1310          // Close display
1311          delete drv;
1312          drv = NULL;
# Line 1067 | Line 1324 | void VideoExit(void)
1324                  SDL_DestroyMutex(frame_buffer_lock);
1325          if (sdl_palette_lock)
1326                  SDL_DestroyMutex(sdl_palette_lock);
1327 +        if (sdl_events_lock)
1328 +                SDL_DestroyMutex(sdl_events_lock);
1329   }
1330  
1331  
# Line 1147 | Line 1406 | void SDL_monitor_desc::set_palette(uint8
1406          const VIDEO_MODE &mode = get_current_mode();
1407  
1408          // FIXME: how can we handle the gamma ramp?
1409 <        if (VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1409 >        if ((int)VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1410                  return;
1411  
1412          LOCK_PALETTE;
# Line 1208 | Line 1467 | int16 video_mode_change(VidLocals *csSav
1467                          csSave->saveData = ReadMacInt32(ParamPtr + csData);
1468                          csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1469  
1470 <                        // Disable interrupts
1470 >                        // Disable interrupts and pause redraw thread
1471                          DisableInterrupt();
1472 +                        thread_stop_ack = false;
1473 +                        thread_stop_req = true;
1474 +                        while (!thread_stop_ack) ;
1475  
1476                          cur_mode = i;
1477                          monitor_desc *monitor = VideoMonitors[0];
# Line 1220 | Line 1482 | int16 video_mode_change(VidLocals *csSav
1482                          csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1483                          csSave->saveMode=VModes[cur_mode].viAppleMode;
1484  
1485 <                        // Enable interrupts
1485 >                        // Enable interrupts and resume redraw thread
1486 >                        thread_stop_req = false;
1487                          EnableInterrupt();
1488                          return noErr;
1489                  }
# Line 1232 | Line 1495 | int16 video_mode_change(VidLocals *csSav
1495   void SDL_monitor_desc::switch_to_current_mode(void)
1496   {
1497          // Close and reopen display
1498 +        LOCK_EVENTS;
1499          video_close();
1500          video_open();
1501 +        UNLOCK_EVENTS;
1502  
1503          if (drv == NULL) {
1504                  ErrorAlert(STR_OPEN_WINDOW_ERR);
# Line 1267 | Line 1532 | void video_set_cursor(void)
1532  
1533  
1534   /*
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 /*
1535   *  Keyboard-related utilify functions
1536   */
1537  
# Line 1698 | Line 1601 | static int kc_decode(SDL_keysym const &
1601  
1602          case SDLK_1: case SDLK_EXCLAIM: return 0x12;
1603          case SDLK_2: case SDLK_AT: return 0x13;
1604 < //      case SDLK_3: case SDLK_numbersign: return 0x14;
1604 >        case SDLK_3: case SDLK_HASH: return 0x14;
1605          case SDLK_4: case SDLK_DOLLAR: return 0x15;
1606 < //      case SDLK_5: case SDLK_percent: return 0x17;
1606 >        case SDLK_5: return 0x17;
1607          case SDLK_6: return 0x16;
1608          case SDLK_7: return 0x1a;
1609          case SDLK_8: return 0x1c;
1610          case SDLK_9: return 0x19;
1611          case SDLK_0: return 0x1d;
1612  
1613 < //      case SDLK_BACKQUOTE: case SDLK_asciitilde: return 0x0a;
1613 >        case SDLK_BACKQUOTE: return 0x0a;
1614          case SDLK_MINUS: case SDLK_UNDERSCORE: return 0x1b;
1615          case SDLK_EQUALS: case SDLK_PLUS: return 0x18;
1616 < //      case SDLK_bracketleft: case SDLK_braceleft: return 0x21;
1617 < //      case SDLK_bracketright: case SDLK_braceright: return 0x1e;
1618 < //      case SDLK_BACKSLASH: case SDLK_bar: return 0x2a;
1616 >        case SDLK_LEFTBRACKET: return 0x21;
1617 >        case SDLK_RIGHTBRACKET: return 0x1e;
1618 >        case SDLK_BACKSLASH: return 0x2a;
1619          case SDLK_SEMICOLON: case SDLK_COLON: return 0x29;
1620 < //      case SDLK_apostrophe: case SDLK_QUOTEDBL: return 0x27;
1620 >        case SDLK_QUOTE: case SDLK_QUOTEDBL: return 0x27;
1621          case SDLK_COMMA: case SDLK_LESS: return 0x2b;
1622          case SDLK_PERIOD: case SDLK_GREATER: return 0x2f;
1623          case SDLK_SLASH: case SDLK_QUESTION: return 0x2c;
# Line 1746 | Line 1649 | static int kc_decode(SDL_keysym const &
1649          case SDLK_LMETA: return 0x3a;
1650          case SDLK_RMETA: return 0x3a;
1651   #endif
1652 +        case SDLK_LSUPER: return 0x3a; // "Windows" key
1653 +        case SDLK_RSUPER: return 0x3a;
1654          case SDLK_MENU: return 0x32;
1655          case SDLK_CAPSLOCK: return 0x39;
1656          case SDLK_NUMLOCK: return 0x47;
# Line 1962 | Line 1867 | static void update_display_static(driver
1867  
1868          // Check for first column from left and first column from right that have changed
1869          if (high) {
1870 <                if (VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1870 >                if ((int)VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1871                          const int src_bytes_per_row = bytes_per_row;
1872                          const int dst_bytes_per_row = drv->s->pitch;
1873                          const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;
# Line 2079 | Line 1984 | static void update_display_static(driver
1984          }
1985   }
1986  
1987 + // Static display update (fixed frame rate, bounding boxes based)
1988 + // XXX use NQD bounding boxes to help detect dirty areas?
1989 + static void update_display_static_bbox(driver_window *drv)
1990 + {
1991 +        const VIDEO_MODE &mode = drv->mode;
1992 +
1993 +        // Allocate bounding boxes for SDL_UpdateRects()
1994 +        const int N_PIXELS = 64;
1995 +        const int n_x_boxes = (VIDEO_MODE_X + N_PIXELS - 1) / N_PIXELS;
1996 +        const int n_y_boxes = (VIDEO_MODE_Y + N_PIXELS - 1) / N_PIXELS;
1997 +        SDL_Rect *boxes = (SDL_Rect *)alloca(sizeof(SDL_Rect) * n_x_boxes * n_y_boxes);
1998 +        int nr_boxes = 0;
1999 +
2000 +        // Lock surface, if required
2001 +        if (SDL_MUSTLOCK(drv->s))
2002 +                SDL_LockSurface(drv->s);
2003 +
2004 +        // Update the surface from Mac screen
2005 +        const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2006 +        const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2007 +        int x, y;
2008 +        for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2009 +                int h = N_PIXELS;
2010 +                if (h > VIDEO_MODE_Y - y)
2011 +                        h = VIDEO_MODE_Y - y;
2012 +                for (x = 0; x < VIDEO_MODE_X; x += N_PIXELS) {
2013 +                        int w = N_PIXELS;
2014 +                        if (w > VIDEO_MODE_X - x)
2015 +                                w = VIDEO_MODE_X - x;
2016 +                        const int xs = w * bytes_per_pixel;
2017 +                        const int xb = x * bytes_per_pixel;
2018 +                        bool dirty = false;
2019 +                        for (int j = y; j < (y + h); j++) {
2020 +                                const int yb = j * bytes_per_row;
2021 +                                if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2022 +                                        memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2023 +                                        Screen_blit((uint8 *)drv->s->pixels + yb + xb, the_buffer + yb + xb, xs);
2024 +                                        dirty = true;
2025 +                                }
2026 +                        }
2027 +                        if (dirty) {
2028 +                                boxes[nr_boxes].x = x;
2029 +                                boxes[nr_boxes].y = y;
2030 +                                boxes[nr_boxes].w = w;
2031 +                                boxes[nr_boxes].h = h;
2032 +                                nr_boxes++;
2033 +                        }
2034 +                }
2035 +        }
2036 +
2037 +        // Unlock surface, if required
2038 +        if (SDL_MUSTLOCK(drv->s))
2039 +                SDL_UnlockSurface(drv->s);
2040 +
2041 +        // Refresh display
2042 +        if (nr_boxes)
2043 +                SDL_UpdateRects(drv->s, nr_boxes, boxes);
2044 + }
2045 +
2046  
2047   // We suggest the compiler to inline the next two functions so that it
2048   // may specialise the code according to the current screen depth and
# Line 2139 | Line 2103 | static void video_refresh_dga_vosf(void)
2103                  tick_counter = 0;
2104                  if (mainBuffer.dirty) {
2105                          LOCK_VOSF;
2106 <                        update_display_dga_vosf();
2106 >                        update_display_dga_vosf(static_cast<driver_fullscreen *>(drv));
2107                          UNLOCK_VOSF;
2108                  }
2109          }
# Line 2173 | Line 2137 | static void video_refresh_window_static(
2137          static int tick_counter = 0;
2138          if (++tick_counter >= frame_skip) {
2139                  tick_counter = 0;
2140 <                update_display_static(static_cast<driver_window *>(drv));
2140 >                const VIDEO_MODE &mode = drv->mode;
2141 >                if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2142 >                        update_display_static_bbox(static_cast<driver_window *>(drv));
2143 >                else
2144 >                        update_display_static(static_cast<driver_window *>(drv));
2145          }
2146   }
2147  
# Line 2203 | Line 2171 | static void VideoRefreshInit(void)
2171          }
2172   }
2173  
2174 + static inline void do_video_refresh(void)
2175 + {
2176 +        // Handle SDL events
2177 +        handle_events();
2178 +
2179 +        // Update display
2180 +        video_refresh();
2181 +
2182 + #ifdef SHEEPSHAVER
2183 +        // Set new cursor image if it was changed
2184 +        if (cursor_changed && sdl_cursor) {
2185 +                cursor_changed = false;
2186 +                LOCK_EVENTS;
2187 +                SDL_FreeCursor(sdl_cursor);
2188 +                sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2189 +                if (sdl_cursor)
2190 +                        SDL_SetCursor(sdl_cursor);
2191 +                UNLOCK_EVENTS;
2192 +        }
2193 + #endif
2194 +
2195 +        // Set new palette if it was changed
2196 +        handle_palette_changes();
2197 + }
2198 +
2199 + // This function is called on non-threaded platforms from a timer interrupt
2200 + void VideoRefresh(void)
2201 + {
2202 +        // We need to check redraw_thread_active to inhibit refreshed during
2203 +        // mode changes on non-threaded platforms
2204 +        if (!redraw_thread_active)
2205 +                return;
2206 +
2207 +        // Process pending events and update display
2208 +        do_video_refresh();
2209 + }
2210 +
2211   const int VIDEO_REFRESH_HZ = 60;
2212   const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2213  
2214 + #ifndef USE_CPU_EMUL_SERVICES
2215   static int redraw_func(void *arg)
2216   {
2217          uint64 start = GetTicks_usec();
# Line 2223 | Line 2229 | static int redraw_func(void *arg)
2229                          next = GetTicks_usec();
2230                  ticks++;
2231  
2226                // Handle SDL events
2227                handle_events();
2228
2229                // Refresh display
2230                video_refresh();
2231
2232   #ifdef SHEEPSHAVER
2233 <                // Set new cursor image if it was changed
2234 <                if (cursor_changed && sdl_cursor) {
2235 <                        cursor_changed = false;
2236 <                        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);
2233 >                // Pause if requested (during video mode switches)
2234 >                if (thread_stop_req) {
2235 >                        thread_stop_ack = true;
2236 >                        continue;
2237                  }
2238   #endif
2239  
2240 <                // Set new palette if it was changed
2241 <                handle_palette_changes();
2240 >                // Process pending events and update display
2241 >                do_video_refresh();
2242          }
2243  
2244          uint64 end = GetTicks_usec();
2245          D(bug("%lld refreshes in %lld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
2246          return 0;
2247   }
2248 + #endif
2249 +
2250 +
2251 + /*
2252 + *  Record dirty area from NQD
2253 + */
2254 +
2255 + #ifdef SHEEPSHAVER
2256 + void video_set_dirty_area(int x, int y, int w, int h)
2257 + {
2258 +        const VIDEO_MODE &mode = drv->mode;
2259 +        const int screen_width = VIDEO_MODE_X;
2260 +        const int screen_height = VIDEO_MODE_Y;
2261 +        const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2262 +
2263 + #ifdef ENABLE_VOSF
2264 +        if (use_vosf) {
2265 +                vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2266 +                return;
2267 +        }
2268 + #endif
2269 +
2270 +        // XXX handle dirty bounding boxes for non-VOSF modes
2271 + }
2272 + #endif

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines