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.65 by cebix, 2002-03-20T19:03:41Z vs.
Revision 1.66 by cebix, 2002-04-25T11:00:31Z

# Line 39 | Line 39
39  
40   #include <algorithm>
41  
42 #ifndef NO_STD_NAMESPACE
43 using std::sort;
44 #endif
45
42   #ifdef HAVE_PTHREADS
43   # include <pthread.h>
44   #endif
# Line 71 | Line 67 | using std::sort;
67   #include "debug.h"
68  
69  
70 + // Supported video modes
71 + static vector<video_mode> VideoModes;
72 +
73   // Display types
74   enum {
75          DISPLAY_WINDOW, // X11 window, using MIT SHM extensions if possible
# Line 140 | Line 139 | static int rshift, rloss, gshift, gloss,
139  
140   static Colormap cmap[2] = {0, 0};                                       // Colormaps for indexed modes (DGA needs two of them)
141  
142 < static XColor palette[256];                                                     // Color palette to be used as CLUT and gamma table
143 < static bool palette_changed = false;                            // Flag: Palette changed, redraw thread must set new colors
142 > static XColor x_palette[256];                                                   // Color palette to be used as CLUT and gamma table
143 > static bool x_palette_changed = false;                          // Flag: Palette changed, redraw thread must set new colors
144  
145   #ifdef ENABLE_FBDEV_DGA
146   static int fbdev_fd = -1;
# Line 154 | Line 153 | static int num_x_video_modes;
153  
154   // Mutex to protect palette
155   #ifdef HAVE_PTHREADS
156 < static pthread_mutex_t palette_lock = PTHREAD_MUTEX_INITIALIZER;
157 < #define LOCK_PALETTE pthread_mutex_lock(&palette_lock)
158 < #define UNLOCK_PALETTE pthread_mutex_unlock(&palette_lock)
156 > static pthread_mutex_t x_palette_lock = PTHREAD_MUTEX_INITIALIZER;
157 > #define LOCK_PALETTE pthread_mutex_lock(&x_palette_lock)
158 > #define UNLOCK_PALETTE pthread_mutex_unlock(&x_palette_lock)
159   #else
160   #define LOCK_PALETTE
161   #define UNLOCK_PALETTE
# Line 195 | Line 194 | extern void SysMountFirstFloppy(void);
194  
195  
196   /*
197 + *  monitor_desc subclass for X11 display
198 + */
199 +
200 + class X11_monitor_desc : public monitor_desc {
201 + public:
202 +        X11_monitor_desc(const vector<video_mode> &available_modes, video_depth default_depth, uint32 default_id) : monitor_desc(available_modes, default_depth, default_id) {}
203 +        ~X11_monitor_desc() {}
204 +
205 +        virtual void switch_to_current_mode(void);
206 +        virtual void set_palette(uint8 *pal, int num);
207 +
208 +        bool video_open(void);
209 +        void video_close(void);
210 + };
211 +
212 +
213 + /*
214   *  Utility functions
215   */
216  
# Line 332 | Line 348 | static void add_window_modes(video_depth
348   }
349  
350   // Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
351 < static void set_mac_frame_buffer(video_depth depth, bool native_byte_order)
351 > static void set_mac_frame_buffer(X11_monitor_desc &monitor, video_depth depth, bool native_byte_order)
352   {
353   #if !REAL_ADDRESSING && !DIRECT_ADDRESSING
354          int layout = FLAYOUT_DIRECT;
# Line 344 | Line 360 | static void set_mac_frame_buffer(video_d
360                  MacFrameLayout = layout;
361          else
362                  MacFrameLayout = FLAYOUT_DIRECT;
363 <        VideoMonitor.mac_frame_base = MacFrameBaseMac;
363 >        monitor.set_mac_frame_base(MacFrameBaseMac);
364  
365          // Set variables used by UAE memory banking
366 +        const video_mode &mode = monitor.get_current_mode();
367          MacFrameBaseHost = the_buffer;
368 <        MacFrameSize = VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y;
368 >        MacFrameSize = mode.bytes_per_row * mode.y;
369          InitFrameBufferMapping();
370   #else
371 <        VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
371 >        monitor.set_mac_frame_base(Host2MacAddr(the_buffer));
372   #endif
373 <        D(bug("VideoMonitor.mac_frame_base = %08x\n", VideoMonitor.mac_frame_base));
373 >        D(bug("monitor.mac_frame_base = %08x\n", monitor.get_mac_frame_base()));
374   }
375  
376   // Set window name and class
# Line 431 | Line 448 | static int error_handler(Display *d, XEr
448  
449   class driver_base {
450   public:
451 <        driver_base();
451 >        driver_base(X11_monitor_desc &m);
452          virtual ~driver_base();
453  
454          virtual void update_palette(void);
# Line 447 | Line 464 | public:
464          virtual void ungrab_mouse(void) {}
465  
466   public:
467 +        X11_monitor_desc &monitor; // Associated video monitor
468 +        const video_mode &mode;    // Video mode handled by the driver
469 +
470          bool init_ok;   // Initialization succeeded (we can't use exceptions because of -fomit-frame-pointer)
471          Window w;               // The window we draw into
472  
# Line 464 | Line 484 | class driver_window : public driver_base
484          friend void update_display_static(driver_window *drv);
485  
486   public:
487 <        driver_window(const video_mode &mode);
487 >        driver_window(X11_monitor_desc &monitor);
488          ~driver_window();
489  
490          void toggle_mouse_grab(void);
# Line 489 | Line 509 | static driver_base *drv = NULL;        // Point
509   # include "video_vosf.h"
510   #endif
511  
512 < driver_base::driver_base()
513 < : init_ok(false), w(0)
512 > driver_base::driver_base(X11_monitor_desc &m)
513 > : monitor(m), mode(m.get_current_mode()), init_ok(false), w(0)
514   {
515          the_buffer = NULL;
516          the_buffer_copy = NULL;
# Line 549 | Line 569 | void driver_base::update_palette(void)
569   {
570          if (color_class == PseudoColor || color_class == DirectColor) {
571                  int num = vis->map_entries;
572 <                if (!IsDirectMode(VideoMonitor.mode) && color_class == DirectColor)
572 >                if (!IsDirectMode(monitor.get_current_mode()) && color_class == DirectColor)
573                          return; // Indexed mode on true color screen, don't set CLUT
574 <                XStoreColors(x_display, cmap[0], palette, num);
575 <                XStoreColors(x_display, cmap[1], palette, num);
574 >                XStoreColors(x_display, cmap[0], x_palette, num);
575 >                XStoreColors(x_display, cmap[1], x_palette, num);
576          }
577          XSync(x_display, false);
578   }
# Line 575 | Line 595 | void driver_base::restore_mouse_accel(vo
595   */
596  
597   // Open display
598 < driver_window::driver_window(const video_mode &mode)
599 < : gc(0), img(NULL), have_shm(false), mac_cursor(0), mouse_grabbed(false)
598 > driver_window::driver_window(X11_monitor_desc &m)
599 > : driver_base(m), gc(0), img(NULL), have_shm(false), mac_cursor(0), mouse_grabbed(false)
600   {
601          int width = mode.x, height = mode.y;
602          int aligned_width = (width + 15) & ~15;
# Line 708 | Line 728 | driver_window::driver_window(const video
728          Screen_blitter_init(&visualInfo, native_byte_order, mode.depth);
729   #endif
730  
731 <        // Set VideoMonitor
732 <        VideoMonitor.mode = mode;
713 <        set_mac_frame_buffer(mode.depth, native_byte_order);
731 >        // Set frame buffer base
732 >        set_mac_frame_buffer(monitor, mode.depth, native_byte_order);
733  
734          // Everything went well
735          init_ok = true;
# Line 790 | Line 809 | void driver_window::mouse_moved(int x, i
809          // Warped mouse motion (this code is taken from SDL)
810  
811          // Post first mouse event
812 <        int width = VideoMonitor.mode.x, height = VideoMonitor.mode.y;
812 >        int width = monitor.get_current_mode().x, height = monitor.get_current_mode().y;
813          int delta_x = x - mouse_last_x, delta_y = y - mouse_last_y;
814          mouse_last_x = x; mouse_last_y = y;
815          ADBMouseMoved(delta_x, delta_y);
# Line 827 | Line 846 | void driver_window::mouse_moved(int x, i
846  
847   class driver_dga : public driver_base {
848   public:
849 <        driver_dga();
849 >        driver_dga(X11_monitor_desc &monitor);
850          ~driver_dga();
851  
852          void suspend(void);
# Line 838 | Line 857 | private:
857          void *fb_save;                  // Saved frame buffer for suspend/resume
858   };
859  
860 < driver_dga::driver_dga()
861 < : suspend_win(0), fb_save(NULL)
860 > driver_dga::driver_dga(X11_monitor_desc &m)
861 > : driver_base(m), suspend_win(0), fb_save(NULL)
862   {
863   }
864  
# Line 860 | Line 879 | void driver_dga::suspend(void)
879          LOCK_FRAME_BUFFER;
880  
881          // Save frame buffer
882 <        fb_save = malloc(VideoMonitor.mode.y * VideoMonitor.mode.bytes_per_row);
882 >        fb_save = malloc(mode.y * mode.bytes_per_row);
883          if (fb_save)
884 <                memcpy(fb_save, the_buffer, VideoMonitor.mode.y * VideoMonitor.mode.bytes_per_row);
884 >                memcpy(fb_save, the_buffer, mode.y * mode.bytes_per_row);
885  
886          // Close full screen display
887   #ifdef ENABLE_XF86_DGA
# Line 915 | Line 934 | void driver_dga::resume(void)
934                  LOCK_VOSF;
935                  PFLAG_SET_ALL;
936                  UNLOCK_VOSF;
937 <                memset(the_buffer_copy, 0, VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y);
937 >                memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
938          }
939   #endif
940          
# Line 925 | Line 944 | void driver_dga::resume(void)
944                  // Don't copy fb_save to the temporary frame buffer in VOSF mode
945                  if (!use_vosf)
946   #endif
947 <                memcpy(the_buffer, fb_save, VideoMonitor.mode.y * VideoMonitor.mode.bytes_per_row);
947 >                memcpy(the_buffer, fb_save, mode.y * mode.bytes_per_row);
948                  free(fb_save);
949                  fb_save = NULL;
950          }
# Line 947 | Line 966 | const char FBDEVICE_FILE_NAME[] = "/dev/
966  
967   class driver_fbdev : public driver_dga {
968   public:
969 <        driver_fbdev(const video_mode &mode);
969 >        driver_fbdev(X11_monitor_desc &monitor);
970          ~driver_fbdev();
971   };
972  
973   // Open display
974 < driver_fbdev::driver_fbdev(const video_mode &mode)
974 > driver_fbdev::driver_fbdev(X11_monitor_desc &m) : driver_dga(m)
975   {
976          int width = mode.x, height = mode.y;
977  
# Line 1081 | Line 1100 | driver_fbdev::driver_fbdev(const video_m
1100   #endif
1101   #endif
1102          
1103 <        // Set VideoMonitor
1104 <        VideoModes[0].bytes_per_row = bytes_per_row;
1105 <        VideoModes[0].depth = DepthModeForPixelDepth(fb_depth);
1087 <        VideoMonitor.mode = mode;
1103 >        // Set frame buffer base
1104 >        const_cast<video_mode *>(&mode)->bytes_per_row = bytes_per_row;
1105 >        const_cast<video_mode *>(&mode)->depth = DepthModeForPixelDepth(fb_depth);
1106          set_mac_frame_buffer(mode.depth, true);
1107  
1108          // Everything went well
# Line 1121 | Line 1139 | driver_fbdev::~driver_fbdev()
1139  
1140   class driver_xf86dga : public driver_dga {
1141   public:
1142 <        driver_xf86dga(const video_mode &mode);
1142 >        driver_xf86dga(X11_monitor_desc &monitor);
1143          ~driver_xf86dga();
1144  
1145          void update_palette(void);
# Line 1132 | Line 1150 | private:
1150   };
1151  
1152   // Open display
1153 < driver_xf86dga::driver_xf86dga(const video_mode &mode)
1154 < : current_dga_cmap(0)
1153 > driver_xf86dga::driver_xf86dga(X11_monitor_desc &m)
1154 > : driver_dga(m), current_dga_cmap(0)
1155   {
1156          int width = mode.x, height = mode.y;
1157  
# Line 1214 | Line 1232 | driver_xf86dga::driver_xf86dga(const vid
1232   #endif
1233   #endif
1234          
1235 <        // Set VideoMonitor
1235 >        // Set frame buffer base
1236          const_cast<video_mode *>(&mode)->bytes_per_row = bytes_per_row;
1237 <        VideoMonitor.mode = mode;
1220 <        set_mac_frame_buffer(mode.depth, true);
1237 >        set_mac_frame_buffer(monitor, mode.depth, true);
1238  
1239          // Everything went well
1240          init_ok = true;
# Line 1248 | Line 1265 | void driver_xf86dga::update_palette(void
1265   {
1266          driver_dga::update_palette();
1267          current_dga_cmap ^= 1;
1268 <        if (!IsDirectMode(VideoMonitor.mode) && cmap[current_dga_cmap])
1268 >        if (!IsDirectMode(monitor.get_current_mode()) && cmap[current_dga_cmap])
1269                  XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1270   }
1271  
# Line 1256 | Line 1273 | void driver_xf86dga::update_palette(void
1273   void driver_xf86dga::resume(void)
1274   {
1275          driver_dga::resume();
1276 <        if (!IsDirectMode(VideoMonitor.mode))
1276 >        if (!IsDirectMode(monitor.get_current_mode()))
1277                  XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1278   }
1279   #endif
# Line 1331 | Line 1348 | static void keycode_init(void)
1348          }
1349   }
1350  
1351 < // Open display for specified mode
1352 < static bool video_open(const video_mode &mode)
1351 > // Open display for current mode
1352 > bool X11_monitor_desc::video_open(void)
1353   {
1354          D(bug("video_open()\n"));
1355 +        const video_mode &mode = get_current_mode();
1356  
1357          // Find best available X visual
1358          if (!find_visual_for_depth(mode.depth)) {
# Line 1375 | Line 1393 | static bool video_open(const video_mode
1393                  int num = vis->map_entries;
1394                  for (int i=0; i<num; i++) {
1395                          int c = (i * 256) / num;
1396 <                        palette[i].pixel = map_rgb(c, c, c);
1397 <                        palette[i].flags = DoRed | DoGreen | DoBlue;
1396 >                        x_palette[i].pixel = map_rgb(c, c, c);
1397 >                        x_palette[i].flags = DoRed | DoGreen | DoBlue;
1398                  }
1399          } else if (color_class == PseudoColor) {
1400                  for (int i=0; i<256; i++) {
1401 <                        palette[i].pixel = i;
1402 <                        palette[i].flags = DoRed | DoGreen | DoBlue;
1401 >                        x_palette[i].pixel = i;
1402 >                        x_palette[i].flags = DoRed | DoGreen | DoBlue;
1403                  }
1404          }
1405  
# Line 1389 | Line 1407 | static bool video_open(const video_mode
1407          int num = (color_class == DirectColor ? vis->map_entries : 256);
1408          for (int i=0; i<num; i++) {
1409                  int c = (i * 256) / num;
1410 <                palette[i].red = c * 0x0101;
1411 <                palette[i].green = c * 0x0101;
1412 <                palette[i].blue = c * 0x0101;
1410 >                x_palette[i].red = c * 0x0101;
1411 >                x_palette[i].green = c * 0x0101;
1412 >                x_palette[i].blue = c * 0x0101;
1413          }
1414          if (color_class == PseudoColor || color_class == DirectColor) {
1415 <                XStoreColors(x_display, cmap[0], palette, num);
1416 <                XStoreColors(x_display, cmap[1], palette, num);
1415 >                XStoreColors(x_display, cmap[0], x_palette, num);
1416 >                XStoreColors(x_display, cmap[1], x_palette, num);
1417          }
1418  
1419   #ifdef ENABLE_VOSF
# Line 1408 | Line 1426 | static bool video_open(const video_mode
1426          // Create display driver object of requested type
1427          switch (display_type) {
1428                  case DISPLAY_WINDOW:
1429 <                        drv = new driver_window(mode);
1429 >                        drv = new driver_window(*this);
1430                          break;
1431   #ifdef ENABLE_FBDEV_DGA
1432                  case DISPLAY_DGA:
1433 <                        drv = new driver_fbdev(mode);
1433 >                        drv = new driver_fbdev(*this);
1434                          break;
1435   #endif
1436   #ifdef ENABLE_XF86_DGA
1437                  case DISPLAY_DGA:
1438 <                        drv = new driver_xf86dga(mode);
1438 >                        drv = new driver_xf86dga(*this);
1439                          break;
1440   #endif
1441          }
# Line 1432 | Line 1450 | static bool video_open(const video_mode
1450   #ifdef ENABLE_VOSF
1451          if (use_vosf) {
1452                  // Initialize the VOSF system
1453 <                if (!video_vosf_init()) {
1453 >                if (!video_vosf_init(*this)) {
1454                          ErrorAlert(STR_VOSF_INIT_ERR);
1455                  return false;
1456                  }
# Line 1494 | Line 1512 | bool VideoInit(bool classic)
1512                  ErrorAlert(STR_UNSUPP_DEPTH_ERR);
1513                  return false;
1514          }
1515 <        sort(avail_depths, avail_depths + num_depths);
1515 >        std::sort(avail_depths, avail_depths + num_depths);
1516          
1517   #ifdef ENABLE_FBDEV_DGA
1518          // Frame buffer name
# Line 1597 | Line 1615 | bool VideoInit(bool classic)
1615                  ErrorAlert(STR_NO_XVISUAL_ERR);
1616                  return false;
1617          }
1618 <        video_init_depth_list();
1618 >
1619 >        // Find requested default mode with specified dimensions
1620 >        uint32 default_id;
1621 >        std::vector<video_mode>::const_iterator i, end = VideoModes.end();
1622 >        for (i = VideoModes.begin(); i != end; ++i) {
1623 >                if (i->x == default_width && i->y == default_height && i->depth == default_depth) {
1624 >                        default_id = i->resolution_id;
1625 >                        break;
1626 >                }
1627 >        }
1628 >        if (i == end) { // not found, use first available mode
1629 >                default_depth = VideoModes[0].depth;
1630 >                default_id = VideoModes[0].resolution_id;
1631 >        }
1632  
1633   #if DEBUG
1634          D(bug("Available video modes:\n"));
1635 <        vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
1605 <        while (i != end) {
1635 >        for (i = VideoModes.begin(); i != end; ++i) {
1636                  int bits = 1 << i->depth;
1637                  if (bits == 16)
1638                          bits = 15;
1639                  else if (bits == 32)
1640                          bits = 24;
1641                  D(bug(" %dx%d (ID %02x), %d colors\n", i->x, i->y, i->resolution_id, 1 << bits));
1612                ++i;
1642          }
1643   #endif
1644  
1645 <        // Find requested default mode and open display
1646 <        if (VideoModes.size() == 1)
1647 <                return video_open(VideoModes[0]);
1648 <        else {
1649 <                // Find mode with specified dimensions
1650 <                std::vector<video_mode>::const_iterator i, end = VideoModes.end();
1622 <                for (i = VideoModes.begin(); i != end; ++i) {
1623 <                        if (i->x == default_width && i->y == default_height && i->depth == default_depth)
1624 <                                return video_open(*i);
1625 <                }
1626 <                return video_open(VideoModes[0]);
1627 <        }
1645 >        // Create X11_monitor_desc for this (the only) display
1646 >        X11_monitor_desc *monitor = new X11_monitor_desc(VideoModes, default_depth, default_id);
1647 >        VideoMonitors.push_back(monitor);
1648 >
1649 >        // Open display
1650 >        return monitor->video_open();
1651   }
1652  
1653  
# Line 1633 | Line 1656 | bool VideoInit(bool classic)
1656   */
1657  
1658   // Close display
1659 < static void video_close(void)
1659 > void X11_monitor_desc::video_close(void)
1660   {
1661          D(bug("video_close()\n"));
1662  
# Line 1678 | Line 1701 | static void video_close(void)
1701  
1702   void VideoExit(void)
1703   {
1704 <        // Close display
1705 <        video_close();
1704 >        // Close displays
1705 >        vector<monitor_desc *>::iterator i, end = VideoMonitors.end();
1706 >        for (i = VideoMonitors.begin(); i != end; ++i)
1707 >                dynamic_cast<X11_monitor_desc *>(*i)->video_close();
1708  
1709   #ifdef ENABLE_XF86_VIDMODE
1710          // Free video mode list
# Line 1737 | Line 1762 | void VideoInterrupt(void)
1762   *  Set palette
1763   */
1764  
1765 < void video_set_palette(uint8 *pal, int num_in)
1765 > void X11_monitor_desc::set_palette(uint8 *pal, int num_in)
1766   {
1767 +        const video_mode &mode = get_current_mode();
1768 +
1769          LOCK_PALETTE;
1770  
1771          // Convert colors to XColor array
1772          int num_out = 256;
1773          bool stretch = false;
1774 <        if (IsDirectMode(VideoMonitor.mode)) {
1774 >        if (IsDirectMode(mode)) {
1775                  // If X is in 565 mode we have to stretch the gamma table from 32 to 64 entries
1776                  num_out = vis->map_entries;
1777                  stretch = true;
1778          }
1779 <        XColor *p = palette;
1779 >        XColor *p = x_palette;
1780          for (int i=0; i<num_out; i++) {
1781                  int c = (stretch ? (i * num_in) / num_out : i);
1782                  p->red = pal[c*3 + 0] * 0x0101;
# Line 1760 | Line 1787 | void video_set_palette(uint8 *pal, int n
1787  
1788   #ifdef ENABLE_VOSF
1789          // Recalculate pixel color expansion map
1790 <        if (!IsDirectMode(VideoMonitor.mode) && xdepth > 8) {
1790 >        if (!IsDirectMode(mode) && xdepth > 8) {
1791                  for (int i=0; i<256; i++) {
1792                          int c = i & (num_in-1); // If there are less than 256 colors, we repeat the first entries (this makes color expansion easier)
1793                          ExpandMap[i] = map_rgb(pal[c*3+0], pal[c*3+1], pal[c*3+2]);
# Line 1770 | Line 1797 | void video_set_palette(uint8 *pal, int n
1797                  LOCK_VOSF;
1798                  PFLAG_SET_ALL;
1799                  UNLOCK_VOSF;
1800 <                memset(the_buffer_copy, 0, VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y);
1800 >                memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
1801          }
1802   #endif
1803  
1804          // Tell redraw thread to change palette
1805 <        palette_changed = true;
1805 >        x_palette_changed = true;
1806  
1807          UNLOCK_PALETTE;
1808   }
# Line 1785 | Line 1812 | void video_set_palette(uint8 *pal, int n
1812   *  Switch video mode
1813   */
1814  
1815 < void video_switch_to_mode(const video_mode &mode)
1815 > void X11_monitor_desc::switch_to_current_mode(void)
1816   {
1817          // Close and reopen display
1818          video_close();
1819 <        video_open(mode);
1819 >        video_open();
1820  
1821          if (drv == NULL) {
1822                  ErrorAlert(STR_OPEN_WINDOW_ERR);
# Line 2059 | Line 2086 | static void handle_events(void)
2086                          // Hidden parts exposed, force complete refresh of window
2087                          case Expose:
2088                                  if (display_type == DISPLAY_WINDOW) {
2089 +                                        const video_mode &mode = VideoMonitors[0]->get_current_mode();
2090   #ifdef ENABLE_VOSF
2091                                          if (use_vosf) {                 // VOSF refresh
2092                                                  LOCK_VOSF;
2093                                                  PFLAG_SET_ALL;
2094                                                  UNLOCK_VOSF;
2095 <                                                memset(the_buffer_copy, 0, VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y);
2095 >                                                memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
2096                                          }
2097                                          else
2098   #endif
# Line 2075 | Line 2103 | static void handle_events(void)
2103                                                          updt_box[x1][y1] = true;
2104                                                  nr_boxes = 16 * 16;
2105                                          } else                                  // Static refresh
2106 <                                                memset(the_buffer_copy, 0, VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y);
2106 >                                                memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
2107                                  }
2108                                  break;
2109  
# Line 2101 | Line 2129 | static void update_display_dynamic(int t
2129          int y1, y2, y2s, y2a, i, x1, xm, xmo, ymo, yo, yi, yil, xi;
2130          int xil = 0;
2131          int rxm = 0, rxmo = 0;
2132 <        int bytes_per_row = VideoMonitor.mode.bytes_per_row;
2133 <        int bytes_per_pixel = VideoMonitor.mode.bytes_per_row / VideoMonitor.mode.x;
2134 <        int rx = VideoMonitor.mode.bytes_per_row / 16;
2135 <        int ry = VideoMonitor.mode.y / 16;
2132 >        const video_mode &mode = drv->monitor.get_current_mode();
2133 >        int bytes_per_row = mode.bytes_per_row;
2134 >        int bytes_per_pixel = mode.bytes_per_row / mode.x;
2135 >        int rx = mode.bytes_per_row / 16;
2136 >        int ry = mode.y / 16;
2137          int max_box;
2138  
2139          y2s = sm_uptd[ticker % 8];
# Line 2158 | Line 2187 | static void update_display_dynamic(int t
2187                                          i = (yi * bytes_per_row) + xi;
2188                                          for (y2=0; y2 < yil; y2++, i += bytes_per_row)
2189                                                  memcpy(&the_buffer_copy[i], &the_buffer[i], xil);
2190 <                                        if (VideoMonitor.mode.depth == VDEPTH_1BIT) {
2190 >                                        if (mode.depth == VDEPTH_1BIT) {
2191                                                  if (drv->have_shm)
2192                                                          XShmPutImage(x_display, drv->w, drv->gc, drv->img, xi * 8, yi, xi * 8, yi, xil * 8, yil, 0);
2193                                                  else
# Line 2190 | Line 2219 | static void update_display_static(driver
2219   {
2220          // Incremental update code
2221          unsigned wide = 0, high = 0, x1, x2, y1, y2, i, j;
2222 <        int bytes_per_row = VideoMonitor.mode.bytes_per_row;
2223 <        int bytes_per_pixel = VideoMonitor.mode.bytes_per_row / VideoMonitor.mode.x;
2222 >        const video_mode &mode = drv->monitor.get_current_mode();
2223 >        int bytes_per_row = mode.bytes_per_row;
2224 >        int bytes_per_pixel = mode.bytes_per_row / mode.x;
2225          uint8 *p, *p2;
2226  
2227          // Check for first line from top and first line from bottom that have changed
2228          y1 = 0;
2229 <        for (j=0; j<VideoMonitor.mode.y; j++) {
2229 >        for (j=0; j<mode.y; j++) {
2230                  if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
2231                          y1 = j;
2232                          break;
2233                  }
2234          }
2235          y2 = y1 - 1;
2236 <        for (j=VideoMonitor.mode.y-1; j>=y1; j--) {
2236 >        for (j=mode.y-1; j>=y1; j--) {
2237                  if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
2238                          y2 = j;
2239                          break;
# Line 2213 | Line 2243 | static void update_display_static(driver
2243  
2244          // Check for first column from left and first column from right that have changed
2245          if (high) {
2246 <                if (VideoMonitor.mode.depth == VDEPTH_1BIT) {
2247 <                        x1 = VideoMonitor.mode.x - 1;
2246 >                if (mode.depth == VDEPTH_1BIT) {
2247 >                        x1 = mode.x - 1;
2248                          for (j=y1; j<=y2; j++) {
2249                                  p = &the_buffer[j * bytes_per_row];
2250                                  p2 = &the_buffer_copy[j * bytes_per_row];
# Line 2232 | Line 2262 | static void update_display_static(driver
2262                                  p2 = &the_buffer_copy[j * bytes_per_row];
2263                                  p += bytes_per_row;
2264                                  p2 += bytes_per_row;
2265 <                                for (i=(VideoMonitor.mode.x>>3); i>(x2>>3); i--) {
2265 >                                for (i=(mode.x>>3); i>(x2>>3); i--) {
2266                                          p--; p2--;
2267                                          if (*p != *p2) {
2268                                                  x2 = (i << 3) + 7;
# Line 2251 | Line 2281 | static void update_display_static(driver
2281                          }
2282  
2283                  } else {
2284 <                        x1 = VideoMonitor.mode.x;
2284 >                        x1 = mode.x;
2285                          for (j=y1; j<=y2; j++) {
2286                                  p = &the_buffer[j * bytes_per_row];
2287                                  p2 = &the_buffer_copy[j * bytes_per_row];
# Line 2269 | Line 2299 | static void update_display_static(driver
2299                                  p2 = &the_buffer_copy[j * bytes_per_row];
2300                                  p += bytes_per_row;
2301                                  p2 += bytes_per_row;
2302 <                                for (i=VideoMonitor.mode.x*bytes_per_pixel; i>x2*bytes_per_pixel; i--) {
2302 >                                for (i=mode.x*bytes_per_pixel; i>x2*bytes_per_pixel; i--) {
2303                                          p--;
2304                                          p2--;
2305                                          if (*p != *p2) {
# Line 2336 | Line 2366 | static inline void handle_palette_change
2366   {
2367          LOCK_PALETTE;
2368  
2369 <        if (palette_changed) {
2370 <                palette_changed = false;
2369 >        if (x_palette_changed) {
2370 >                x_palette_changed = false;
2371                  drv->update_palette();
2372          }
2373  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines