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

Comparing BasiliskII/src/Unix/video_x.cpp (file contents):
Revision 1.28 by cebix, 2000-11-03T12:23:49Z vs.
Revision 1.29 by cebix, 2000-11-03T18:21:43Z

# Line 122 | Line 122 | static Colormap cmap[2];                                                       // Two co
122   static XColor black, white;
123   static unsigned long black_pixel, white_pixel;
124   static int eventmask;
125 < static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | FocusChangeMask | ExposureMask;
126 < static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
125 > static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask | StructureNotifyMask;
126 > static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask;
127 > static Atom WM_DELETE_WINDOW = (Atom)0;
128  
129   static XColor palette[256];                                                     // Color palette for 8-bit mode
130   static bool palette_changed = false;                            // Flag: Palette changed, redraw thread must set new colors
131   #ifdef HAVE_PTHREADS
132   static pthread_mutex_t palette_lock = PTHREAD_MUTEX_INITIALIZER;        // Mutex to protect palette
133 + #define LOCK_PALETTE pthread_mutex_lock(&palette_lock)
134 + #define UNLOCK_PALETTE pthread_mutex_unlock(&palette_lock)
135 + #else
136 + #define LOCK_PALETTE
137 + #define UNLOCK_PALETTE
138   #endif
139  
140   // Variables for window mode
# Line 149 | Line 155 | static Window suspend_win;                                                     // "Sus
155   static void *fb_save = NULL;                                            // Saved frame buffer for suspend
156   #ifdef HAVE_PTHREADS
157   static pthread_mutex_t frame_buffer_lock = PTHREAD_MUTEX_INITIALIZER;   // Mutex to protect frame buffer
158 + #define LOCK_FRAME_BUFFER pthread_mutex_lock(&frame_buffer_lock);
159 + #define UNLOCK_FRAME_BUFFER pthread_mutex_unlock(&frame_buffer_lock);
160 + #else
161 + #define LOCK_FRAME_BUFFER
162 + #define UNLOCK_FRAME_BUFFER
163   #endif
164  
165   // Variables for fbdev DGA mode
# Line 168 | Line 179 | static const bool use_vosf = false;
179   #endif
180  
181   #ifdef ENABLE_VOSF
182 < static uint8 * the_host_buffer;                                         // Host frame buffer in VOSF mode
182 > // Variables for Video on SEGV support (taken from the Win32 port)
183 > static uint8 *the_host_buffer;                                          // Host frame buffer in VOSF mode
184   static uint32 the_buffer_size;                                          // Size of allocated the_buffer
173 #endif
185  
175 #ifdef ENABLE_VOSF
176 // Variables for Video on SEGV support (taken from the Win32 port)
186   struct ScreenPageInfo {
187      int top, bottom;                    // Mapping between this virtual page and Mac scanlines
188   };
# Line 215 | Line 224 | static bool Screen_fault_handler_init();
224   static struct sigaction vosf_sa;
225  
226   #ifdef HAVE_PTHREADS
227 < static pthread_mutex_t Screen_draw_lock = PTHREAD_MUTEX_INITIALIZER;    // Mutex to protect frame buffer (dirtyPages in fact)
227 > static pthread_mutex_t vosf_lock = PTHREAD_MUTEX_INITIALIZER;   // Mutex to protect frame buffer (dirtyPages in fact)
228 > #define LOCK_VOSF pthread_mutex_lock(&vosf_lock);
229 > #define UNLOCK_VOSF pthread_mutex_unlock(&vosf_lock);
230 > #else
231 > #define LOCK_VOSF
232 > #define UNLOCK_VOSF
233   #endif
234  
235   static int log_base_2(uint32 x)
# Line 237 | Line 251 | static void (*video_refresh)(void);
251  
252   // Prototypes
253   static void *redraw_func(void *arg);
254 < static int event2keycode(XKeyEvent *ev);
254 > static int event2keycode(XKeyEvent &ev);
255  
256  
257   // From main_unix.cpp
# Line 307 | Line 321 | void set_video_monitor(int width, int he
321          VideoMonitor.bytes_per_row = bytes_per_row;
322   }
323  
324 + // Set window name and class
325 + static void set_window_name(Window w, int name)
326 + {
327 +        const char *str = GetString(name);
328 +        XStoreName(x_display, w, str);
329 +        XSetIconName(x_display, w, str);
330 +
331 +        XClassHint *hints;
332 +        hints = XAllocClassHint();
333 +        if (hints) {
334 +                hints->res_name = "BasiliskII";
335 +                hints->res_class = "BasiliskII";
336 +                XSetClassHint(x_display, w, hints);
337 +                XFree((char *)hints);
338 +        }
339 + }
340 +
341 + // Set window input focus flag
342 + static void set_window_focus(Window w)
343 + {
344 +        XWMHints *hints = XAllocWMHints();
345 +        if (hints) {
346 +                hints->input = True;
347 +                hints->initial_state = NormalState;
348 +                hints->flags = InputHint | StateHint;
349 +                XSetWMHints(x_display, w, hints);
350 +                XFree((char *)hints);
351 +        }
352 + }
353 +
354 + // Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget)
355 + static void set_window_delete_protocol(Window w)
356 + {
357 +        WM_DELETE_WINDOW = XInternAtom(x_display, "WM_DELETE_WINDOW", false);
358 +        XSetWMProtocols(x_display, w, &WM_DELETE_WINDOW, 1);
359 + }
360 +
361 + // Wait until window is mapped/unmapped
362 + void wait_mapped(Window w)
363 + {
364 +        XEvent e;
365 +        do {
366 +                XMaskEvent(x_display, StructureNotifyMask, &e);
367 +        } while ((e.type != MapNotify) || (e.xmap.event != w));
368 + }
369 +
370 + void wait_unmapped(Window w)
371 + {
372 +        XEvent e;
373 +        do {
374 +                XMaskEvent(x_display, StructureNotifyMask, &e);
375 +        } while ((e.type != UnmapNotify) || (e.xmap.event != w));
376 + }
377 +
378   // Trap SHM errors
379   static bool shm_error = false;
380   static int (*old_error_handler)(Display *, XErrorEvent *);
# Line 336 | Line 404 | static bool init_window(int width, int h
404          XSetWindowAttributes wattr;
405          wattr.event_mask = eventmask = win_eventmask;
406          wattr.background_pixel = black_pixel;
407 +        wattr.colormap = cmap[0];
408  
340        XSync(x_display, false);
409          the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
410 <                InputOutput, vis, CWEventMask | CWBackPixel, &wattr);
410 >                InputOutput, vis, CWEventMask | CWBackPixel | (depth == 8 ? CWColormap : 0), &wattr);
411 >
412 >        // Set window name/class
413 >        set_window_name(the_win, STR_WINDOW_TITLE);
414  
415          // Indicate that we want keyboard input
416 <        {
417 <                XWMHints *hints = XAllocWMHints();
418 <                if (hints) {
419 <                        hints->input = True;
349 <                        hints->flags = InputHint;
350 <                        XSetWMHints(x_display, the_win, hints);
351 <                        XFree((char *)hints);
352 <                }
353 <        }
416 >        set_window_focus(the_win);
417 >
418 >        // Set delete protocol property
419 >        set_window_delete_protocol(the_win);
420  
421          // Make window unresizable
422          {
# Line 366 | Line 432 | static bool init_window(int width, int h
432                  }
433          }
434          
369        // Set window title
370        XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE));
371
372        // Set window class
373        {
374                XClassHint *hints;
375                hints = XAllocClassHint();
376                if (hints) {
377                        hints->res_name = "BasiliskII";
378                        hints->res_class = "BasiliskII";
379                        XSetClassHint(x_display, the_win, hints);
380                        XFree((char *)hints);
381                }
382        }
383
435          // Show window
436 <        XSync(x_display, false);
437 <        XMapRaised(x_display, the_win);
387 <        XFlush(x_display);
388 <
389 <        // Set colormap
390 <        if (depth == 8)
391 <                XSetWindowColormap(x_display, the_win, cmap[0]);
436 >        XMapWindow(x_display, the_win);
437 >        wait_mapped(the_win);
438  
439          // Try to create and attach SHM image
440          have_shm = false;
# Line 561 | Line 607 | static bool init_fbdev_dga(char *in_fb_n
607          
608          // Create window
609          XSetWindowAttributes wattr;
610 <        wattr.event_mask                = eventmask = dga_eventmask;
611 <        wattr.background_pixel  = white_pixel;
612 <        wattr.override_redirect = True;
610 >        wattr.event_mask = eventmask = dga_eventmask;
611 >        wattr.background_pixel = white_pixel;
612 >        wattr.override_redirect = True;
613 >        wattr.colormap = cmap[0];
614          
568        XSync(x_display, false);
615          the_win = XCreateWindow(x_display, rootwin,
616                  0, 0, width, height,
617                  0, xdepth, InputOutput, vis,
618 <                CWEventMask | CWBackPixel | CWOverrideRedirect,
618 >                CWEventMask | CWBackPixel | CWOverrideRedirect | (depth == 8 ? CWColormap : 0),
619                  &wattr);
620 <        XSync(x_display, false);
620 >
621 >        // Set window name/class
622 >        set_window_name(the_win, STR_WINDOW_TITLE);
623 >
624 >        // Indicate that we want keyboard input
625 >        set_window_focus(the_win);
626 >
627 >        // Show window
628          XMapRaised(x_display, the_win);
629 <        XSync(x_display, false);
629 >        wait_mapped(the_win);
630          
631          // Grab mouse and keyboard
632          XGrabKeyboard(x_display, the_win, True,
# Line 582 | Line 635 | static bool init_fbdev_dga(char *in_fb_n
635                  PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
636                  GrabModeAsync, GrabModeAsync, the_win, None, CurrentTime);
637          
585        // Set colormap
586        if (depth == 8)
587                XSetWindowColormap(x_display, the_win, cmap[0]);
588        
638          // Set VideoMonitor
639          int bytes_per_row = width;
640          switch (depth) {
# Line 665 | Line 714 | static bool init_xf86_dga(int width, int
714                  }
715                  XF86VidModeSwitchToMode(x_display, screen, x_video_modes[best]);
716                  XF86VidModeSetViewPort(x_display, screen, 0, 0);
717 +                XSync(x_display, false);
718          }
719   #endif
720  
# Line 673 | Line 723 | static bool init_xf86_dga(int width, int
723          wattr.event_mask = eventmask = dga_eventmask;
724          wattr.override_redirect = True;
725  
676        XSync(x_display, false);
726          the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
727                  InputOutput, vis, CWEventMask | CWOverrideRedirect, &wattr);
728 <        XSync(x_display, false);
729 <        XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE));
728 >
729 >        // Set window name/class
730 >        set_window_name(the_win, STR_WINDOW_TITLE);
731 >
732 >        // Indicate that we want keyboard input
733 >        set_window_focus(the_win);
734 >
735 >        // Show window
736          XMapRaised(x_display, the_win);
737 <        XSync(x_display, false);
737 >        wait_mapped(the_win);
738  
739          // Establish direct screen connection
740          XMoveResizeWindow(x_display, the_win, 0, 0, width, height);
# Line 698 | Line 753 | static bool init_xf86_dga(int width, int
753                  XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]);
754                  XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
755          }
756 +        XSync(x_display, false);
757  
758          // Set VideoMonitor
759          int bytes_per_row = (v_width + 7) & ~7;
# Line 1036 | Line 1092 | bool VideoInit(bool classic)
1092                          break;
1093          }
1094  
1039 #ifdef HAVE_PTHREADS
1095          // Lock down frame buffer
1096 <        pthread_mutex_lock(&frame_buffer_lock);
1042 < #endif
1096 >        LOCK_FRAME_BUFFER;
1097  
1098   #if !REAL_ADDRESSING && !DIRECT_ADDRESSING
1099          // Set variables for UAE memory mapping
# Line 1104 | Line 1158 | void VideoExit(void)
1158          }
1159   #endif
1160  
1107 #ifdef HAVE_PTHREADS
1161          // Unlock frame buffer
1162 <        pthread_mutex_unlock(&frame_buffer_lock);
1110 < #endif
1162 >        UNLOCK_FRAME_BUFFER;
1163  
1164          // Close window and server connection
1165          if (x_display != NULL) {
# Line 1210 | Line 1262 | void VideoInterrupt(void)
1262          if (emerg_quit)
1263                  QuitEmulator();
1264  
1213 #ifdef HAVE_PTHREADS
1265          // Temporarily give up frame buffer lock (this is the point where
1266          // we are suspended when the user presses Ctrl-Tab)
1267 <        pthread_mutex_unlock(&frame_buffer_lock);
1268 <        pthread_mutex_lock(&frame_buffer_lock);
1218 < #endif
1267 >        UNLOCK_FRAME_BUFFER;
1268 >        LOCK_FRAME_BUFFER;
1269   }
1270  
1271  
# Line 1225 | Line 1275 | void VideoInterrupt(void)
1275  
1276   void video_set_palette(uint8 *pal)
1277   {
1278 < #ifdef HAVE_PTHREADS
1229 <        pthread_mutex_lock(&palette_lock);
1230 < #endif
1278 >        LOCK_PALETTE;
1279  
1280          // Convert colors to XColor array
1281          for (int i=0; i<256; i++) {
# Line 1241 | Line 1289 | void video_set_palette(uint8 *pal)
1289          // Tell redraw thread to change palette
1290          palette_changed = true;
1291  
1292 < #ifdef HAVE_PTHREADS
1245 <        pthread_mutex_unlock(&palette_lock);
1246 < #endif
1292 >        UNLOCK_PALETTE;
1293   }
1294  
1295  
# Line 1259 | Line 1305 | static void suspend_emul(void)
1305                  ADBKeyUp(0x36);
1306                  ctrl_down = false;
1307  
1262 #ifdef HAVE_PTHREADS
1308                  // Lock frame buffer (this will stop the MacOS thread)
1309 <                pthread_mutex_lock(&frame_buffer_lock);
1265 < #endif
1309 >                LOCK_FRAME_BUFFER;
1310  
1311                  // Save frame buffer
1312                  fb_save = malloc(VideoMonitor.y * VideoMonitor.bytes_per_row);
# Line 1276 | Line 1320 | static void suspend_emul(void)
1320                  XUngrabPointer(x_display, CurrentTime);
1321                  XUngrabKeyboard(x_display, CurrentTime);
1322                  XUnmapWindow(x_display, the_win);
1323 <                XSync(x_display, false);
1323 >                wait_unmapped(the_win);
1324  
1325                  // Open "suspend" window
1326                  XSetWindowAttributes wattr;
1327                  wattr.event_mask = KeyPressMask;
1328                  wattr.background_pixel = black_pixel;
1285                wattr.backing_store = WhenMapped;
1286                wattr.backing_planes = xdepth;
1287                wattr.colormap = DefaultColormap(x_display, screen);
1329                  
1289                XSync(x_display, false);
1330                  suspend_win = XCreateWindow(x_display, rootwin, 0, 0, 512, 1, 0, xdepth,
1331 <                        InputOutput, vis, CWEventMask | CWBackPixel | CWBackingStore |
1332 <                        CWBackingPlanes | (xdepth == 8 ? CWColormap : 0), &wattr);
1333 <                XSync(x_display, false);
1334 <                XStoreName(x_display, suspend_win, GetString(STR_SUSPEND_WINDOW_TITLE));
1295 <                XMapRaised(x_display, suspend_win);
1296 <                XSync(x_display, false);
1331 >                        InputOutput, vis, CWEventMask | CWBackPixel, &wattr);
1332 >                set_window_name(suspend_win, STR_SUSPEND_WINDOW_TITLE);
1333 >                set_window_focus(suspend_win);
1334 >                XMapWindow(x_display, suspend_win);
1335                  emul_suspended = true;
1336          }
1337   }
# Line 1306 | Line 1344 | static void resume_emul(void)
1344  
1345          // Reopen full screen display
1346          XMapRaised(x_display, the_win);
1347 +        wait_mapped(the_win);
1348          XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
1310        XSync(x_display, false);
1349          XGrabKeyboard(x_display, rootwin, 1, GrabModeAsync, GrabModeAsync, CurrentTime);
1350          XGrabPointer(x_display, rootwin, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
1351   #ifdef ENABLE_XF86_DGA
# Line 1321 | Line 1359 | static void resume_emul(void)
1359          // not necessary.
1360   #ifdef ENABLE_VOSF
1361          if (use_vosf) {
1362 < #ifdef HAVE_PTHREADS
1325 <                pthread_mutex_lock(&Screen_draw_lock);
1326 < #endif
1362 >                LOCK_VOSF;
1363                  PFLAG_SET_ALL;
1364 < #ifdef HAVE_PTHREADS
1329 <                pthread_mutex_unlock(&Screen_draw_lock);
1330 < #endif
1364 >                UNLOCK_VOSF;
1365                  memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y);
1366          }
1367   #endif
# Line 1348 | Line 1382 | static void resume_emul(void)
1382                  XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1383   #endif
1384  
1351 #ifdef HAVE_PTHREADS
1385          // Unlock frame buffer (and continue MacOS thread)
1386 <        pthread_mutex_unlock(&frame_buffer_lock);
1386 >        UNLOCK_FRAME_BUFFER;
1387          emul_suspended = false;
1355 #endif
1388   }
1389   #endif
1390  
# Line 1506 | Line 1538 | static int kc_decode(KeySym ks)
1538          return -1;
1539   }
1540  
1541 < static int event2keycode(XKeyEvent *ev)
1541 > static int event2keycode(XKeyEvent &ev)
1542   {
1543          KeySym ks;
1544          int as;
1545          int i = 0;
1546  
1547          do {
1548 <                ks = XLookupKeysym(ev, i++);
1548 >                ks = XLookupKeysym(&ev, i++);
1549                  as = kc_decode(ks);
1550                  if (as != -1)
1551                          return as;
# Line 1529 | Line 1561 | static int event2keycode(XKeyEvent *ev)
1561  
1562   static void handle_events(void)
1563   {
1564 <        XEvent event;
1565 <        for (;;) {
1566 <                if (!XCheckMaskEvent(x_display, eventmask, &event))
1535 <                        break;
1564 >        while (XPending(x_display)) {
1565 >                XEvent event;
1566 >                XNextEvent(x_display, &event);
1567  
1568                  switch (event.type) {
1569                          // Mouse button
1570                          case ButtonPress: {
1571 <                                unsigned int button = ((XButtonEvent *)&event)->button;
1571 >                                unsigned int button = event.xbutton.button;
1572                                  if (button < 4)
1573                                          ADBMouseDown(button - 1);
1574                                  else if (button < 6) {  // Wheel mouse
# Line 1556 | Line 1587 | static void handle_events(void)
1587                                  break;
1588                          }
1589                          case ButtonRelease: {
1590 <                                unsigned int button = ((XButtonEvent *)&event)->button;
1590 >                                unsigned int button = event.xbutton.button;
1591                                  if (button < 4)
1592                                          ADBMouseUp(button - 1);
1593                                  break;
# Line 1564 | Line 1595 | static void handle_events(void)
1595  
1596                          // Mouse moved
1597                          case EnterNotify:
1567                                ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y);
1568                                break;
1598                          case MotionNotify:
1599 <                                ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y);
1599 >                                ADBMouseMoved(event.xmotion.x, event.xmotion.y);
1600                                  break;
1601  
1602                          // Keyboard
1603                          case KeyPress: {
1604                                  int code;
1605                                  if (use_keycodes) {
1606 <                                        event2keycode((XKeyEvent *)&event);     // This is called to process the hotkeys
1607 <                                        code = keycode_table[((XKeyEvent *)&event)->keycode & 0xff];
1606 >                                        event2keycode(event.xkey);      // This is called to process the hotkeys
1607 >                                        code = keycode_table[event.xkey.keycode & 0xff];
1608                                  } else
1609 <                                        code = event2keycode((XKeyEvent *)&event);
1609 >                                        code = event2keycode(event.xkey);
1610                                  if (code != -1) {
1611                                          if (!emul_suspended) {
1612                                                  if (code == 0x39) {     // Caps Lock pressed
# Line 1604 | Line 1633 | static void handle_events(void)
1633                          case KeyRelease: {
1634                                  int code;
1635                                  if (use_keycodes) {
1636 <                                        event2keycode((XKeyEvent *)&event);     // This is called to process the hotkeys
1637 <                                        code = keycode_table[((XKeyEvent *)&event)->keycode & 0xff];
1636 >                                        event2keycode(event.xkey);      // This is called to process the hotkeys
1637 >                                        code = keycode_table[event.xkey.keycode & 0xff];
1638                                  } else
1639 <                                        code = event2keycode((XKeyEvent *)&event);
1639 >                                        code = event2keycode(event.xkey);
1640                                  if (code != -1 && code != 0x39) {       // Don't propagate Caps Lock releases
1641                                          ADBKeyUp(code);
1642                                          if (code == 0x36)
# Line 1621 | Line 1650 | static void handle_events(void)
1650                                  if (display_type == DISPLAY_WINDOW) {
1651   #ifdef ENABLE_VOSF
1652                                          if (use_vosf) {                 // VOSF refresh
1653 < #ifdef HAVE_PTHREADS
1625 <                                                pthread_mutex_lock(&Screen_draw_lock);
1626 < #endif
1653 >                                                LOCK_VOSF;
1654                                                  PFLAG_SET_ALL;
1655 < #ifdef HAVE_PTHREADS
1629 <                                                pthread_mutex_unlock(&Screen_draw_lock);
1630 < #endif
1655 >                                                UNLOCK_VOSF;
1656                                                  memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y);
1657                                          }
1658                                          else
# Line 1643 | Line 1668 | static void handle_events(void)
1668                                  }
1669                                  break;
1670  
1671 <                        case FocusIn:
1672 <                        case FocusOut:
1671 >                        // Window "close" widget clicked
1672 >                        case ClientMessage:
1673 >                                if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW)
1674 >                                        XBell(x_display, 0);
1675                                  break;
1676                  }
1677          }
# Line 1902 | Line 1929 | static inline void possibly_quit_dga_mod
1929  
1930   static inline void handle_palette_changes(int depth, int display_type)
1931   {
1932 < #ifdef HAVE_PTHREADS
1933 <        pthread_mutex_lock(&palette_lock);
1907 < #endif
1932 >        LOCK_PALETTE;
1933 >
1934          if (palette_changed) {
1935                  palette_changed = false;
1936                  if (depth == 8) {
1937                          XStoreColors(x_display, cmap[0], palette, 256);
1938                          XStoreColors(x_display, cmap[1], palette, 256);
1939 +                        XSync(x_display, false);
1940                                  
1941   #ifdef ENABLE_XF86_DGA
1942                          if (display_type == DISPLAY_DGA) {
# Line 1919 | Line 1946 | static inline void handle_palette_change
1946   #endif
1947                  }
1948          }
1949 < #ifdef HAVE_PTHREADS
1950 <        pthread_mutex_unlock(&palette_lock);
1924 < #endif
1949 >
1950 >        UNLOCK_PALETTE;
1951   }
1952  
1953   static void video_refresh_dga(void)
# Line 1953 | Line 1979 | static void video_refresh_dga_vosf(void)
1979          static int tick_counter = 0;
1980          if (++tick_counter >= frame_skip) {
1981                  tick_counter = 0;
1982 < #ifdef HAVE_PTHREADS
1957 <                pthread_mutex_lock(&Screen_draw_lock);
1958 < #endif
1982 >                LOCK_VOSF;
1983                  update_display_dga_vosf();
1984 < #ifdef HAVE_PTHREADS
1961 <                pthread_mutex_unlock(&Screen_draw_lock);
1962 < #endif
1984 >                UNLOCK_VOSF;
1985          }
1986   }
1987   #endif
# Line 1979 | Line 2001 | static void video_refresh_window_vosf(vo
2001          static int tick_counter = 0;
2002          if (++tick_counter >= frame_skip) {
2003                  tick_counter = 0;
2004 < #ifdef HAVE_PTHREADS
1983 <                pthread_mutex_lock(&Screen_draw_lock);
1984 < #endif
2004 >                LOCK_VOSF;
2005                  update_display_window_vosf();
2006 < #ifdef HAVE_PTHREADS
1987 <                pthread_mutex_unlock(&Screen_draw_lock);
1988 < #endif
2006 >                UNLOCK_VOSF;
2007          }
2008   }
2009   #endif // def ENABLE_VOSF
# Line 2055 | Line 2073 | void VideoRefresh(void)
2073          video_refresh();
2074   }
2075  
2058 #if 0
2059 void VideoRefresh(void)
2060 {
2061 #if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA)
2062        // Quit DGA mode if requested
2063        if (quit_full_screen) {
2064                quit_full_screen = false;
2065                if (display_type == DISPLAY_DGA) {
2066 #ifdef ENABLE_XF86_DGA
2067                        XF86DGADirectVideo(x_display, screen, 0);
2068 #endif
2069                        XUngrabPointer(x_display, CurrentTime);
2070                        XUngrabKeyboard(x_display, CurrentTime);
2071                        XUnmapWindow(x_display, the_win);
2072                        XSync(x_display, false);
2073                }
2074        }
2075 #endif
2076
2077        // Handle X events
2078        handle_events();
2079
2080        // Handle palette changes
2081 #ifdef HAVE_PTHREADS
2082        pthread_mutex_lock(&palette_lock);
2083 #endif
2084        if (palette_changed) {
2085                palette_changed = false;
2086                if (depth == 8) {
2087                        XStoreColors(x_display, cmap[0], palette, 256);
2088                        XStoreColors(x_display, cmap[1], palette, 256);
2089                                
2090 #ifdef ENABLE_XF86_DGA
2091                        if (display_type == DISPLAY_DGA) {
2092                                current_dga_cmap ^= 1;
2093                                XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
2094                        }
2095 #endif
2096                }
2097        }
2098 #ifdef HAVE_PTHREADS
2099        pthread_mutex_unlock(&palette_lock);
2100 #endif
2101
2102        // In window mode, update display
2103        static int tick_counter = 0;
2104        if (display_type == DISPLAY_WINDOW) {
2105                tick_counter++;
2106                if (frame_skip == 0)
2107                        update_display_dynamic(tick_counter);
2108                else if (tick_counter >= frame_skip) {
2109                        tick_counter = 0;
2110                        update_display_static();
2111                }
2112        }
2113 }
2114 #endif
2115
2076   #ifdef HAVE_PTHREADS
2077   static void *redraw_func(void *arg)
2078   {
# Line 2120 | Line 2080 | static void *redraw_func(void *arg)
2080          int64 ticks = 0;
2081          uint64 next = GetTicks_usec();
2082          while (!redraw_thread_cancel) {
2123 //              VideoRefresh();
2083                  video_refresh();
2084                  next += 16667;
2085                  int64 delay = next - GetTicks_usec();

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines