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.17 by gbeauche, 2005-03-19T05:34:15Z

# 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 37 | Line 37
37   *    Besides, there can't seem to be a way to call SetVideoMode() from a child thread.
38   *  - Refresh performance is still slow. Use SDL_CreateRGBSurface()?
39   *  - Backport hw cursor acceleration to Basilisk II?
40 *  - Move generic Native QuickDraw acceleration routines to gfxaccel.cpp
40   */
41  
42   #include "sysdeps.h"
# Line 57 | Line 56
56   #include "video.h"
57   #include "video_defs.h"
58   #include "video_blit.h"
59 + #include "vm_alloc.h"
60  
61   #define DEBUG 0
62   #include "debug.h"
# Line 82 | Line 82 | static int display_type = DISPLAY_WINDOW
82   #endif
83  
84   // Constants
85 + #ifdef WIN32
86 + const char KEYCODE_FILE_NAME[] = "BasiliskII_keycodes";
87 + #else
88   const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
89 + #endif
90  
91  
92   // Global variables
# Line 97 | Line 101 | static uint32 the_buffer_size;                                         // S
101   static bool redraw_thread_active = false;                       // Flag: Redraw thread installed
102   static volatile bool redraw_thread_cancel;                      // Flag: Cancel Redraw thread
103   static SDL_Thread *redraw_thread = NULL;                        // Redraw thread
104 + static volatile bool thread_stop_req = false;
105 + static volatile bool thread_stop_ack = false;           // Acknowledge for thread_stop_req
106  
107   #ifdef ENABLE_VOSF
108   static bool use_vosf = false;                                           // Flag: VOSF enabled
# Line 146 | Line 152 | extern void SysMountFirstFloppy(void);
152  
153  
154   /*
155 + *  Framebuffer allocation routines
156 + */
157 +
158 + static void *vm_acquire_framebuffer(uint32 size)
159 + {
160 + #ifdef SHEEPSHAVER
161 + #ifdef DIRECT_ADDRESSING_HACK
162 +        const uint32 FRAME_BUFFER_BASE = 0x61000000;
163 +        uint8 *fb = Mac2HostAddr(FRAME_BUFFER_BASE);
164 +        if (vm_acquire_fixed(fb, size) < 0)
165 +                fb = VM_MAP_FAILED;
166 +        return fb;
167 + #endif
168 + #endif
169 +        return vm_acquire(size);
170 + }
171 +
172 + static inline void vm_release_framebuffer(void *fb, uint32 size)
173 + {
174 +        vm_release(fb, size);
175 + }
176 +
177 +
178 + /*
179   *  SheepShaver glue
180   */
181  
# Line 325 | Line 355 | static inline int bytes_per_pixel(int de
355   }
356  
357   // Map video_mode depth ID to numerical depth value
358 < static int sdl_depth_of_video_depth(int video_depth)
358 > static int mac_depth_of_video_depth(int video_depth)
359   {
360          int depth = -1;
361          switch (video_depth) {
# Line 353 | Line 383 | static int sdl_depth_of_video_depth(int
383          return depth;
384   }
385  
386 + // Map video_mode depth ID to SDL screen depth
387 + static int sdl_depth_of_video_depth(int video_depth)
388 + {
389 +        return (video_depth <= VIDEO_DEPTH_8BIT) ? 8 : mac_depth_of_video_depth(video_depth);
390 + }
391 +
392   // Check wether specified mode is available
393   static bool has_mode(int type, int width, int height)
394   {
# Line 413 | Line 449 | static void add_mode(int type, int width
449          VIDEO_MODE_Y = height;
450          VIDEO_MODE_RESOLUTION = resolution_id;
451          VIDEO_MODE_ROW_BYTES = bytes_per_row;
452 <        VIDEO_MODE_DEPTH = depth;
452 >        VIDEO_MODE_DEPTH = (video_depth)depth;
453          VideoModes.push_back(mode);
454   }
455  
# Line 549 | Line 585 | driver_base::~driver_base()
585          if (s)
586                  SDL_FreeSurface(s);
587  
588 +        // the_buffer shall always be mapped through vm_acquire_framebuffer()
589 +        if (the_buffer != VM_MAP_FAILED) {
590 +                D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
591 +                vm_release_framebuffer(the_buffer, the_buffer_size);
592 +                the_buffer = NULL;
593 +        }
594 +
595          // Free frame buffer(s)
596          if (!use_vosf) {
554                if (the_buffer) {
555                        free(the_buffer);
556                        the_buffer = NULL;
557                }
597                  if (the_buffer_copy) {
598                          free(the_buffer_copy);
599                          the_buffer_copy = NULL;
# Line 562 | Line 601 | driver_base::~driver_base()
601          }
602   #ifdef ENABLE_VOSF
603          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                }
604                  if (the_host_buffer) {
605                          D(bug(" freeing the_host_buffer at %p\n", the_host_buffer));
606                          free(the_host_buffer);
# Line 578 | Line 611 | driver_base::~driver_base()
611                          free(the_buffer_copy);
612                          the_buffer_copy = NULL;
613                  }
614 +
615 +                // Deinitialize VOSF
616 +                video_vosf_exit();
617          }
618   #endif
619   }
# Line 587 | Line 623 | void driver_base::update_palette(void)
623   {
624          const VIDEO_MODE &mode = monitor.get_current_mode();
625  
626 <        if (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
626 >        if ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
627                  SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
628   }
629  
# Line 618 | Line 654 | driver_window::driver_window(SDL_monitor
654          ADBSetRelMouseMode(mouse_grabbed);
655  
656          // Create surface
657 <        int depth = (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
657 >        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
658          if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
659                  return;
660  
# Line 627 | Line 663 | driver_window::driver_window(SDL_monitor
663          // Allocate memory for frame buffer (SIZE is extended to page-boundary)
664          the_host_buffer = (uint8 *)s->pixels;
665          the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
666 <        the_buffer = (uint8 *)vm_acquire(the_buffer_size);
666 >        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
667          the_buffer_copy = (uint8 *)malloc(the_buffer_size);
668          D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
669  
# Line 651 | Line 687 | driver_window::driver_window(SDL_monitor
687                  // Allocate memory for frame buffer
688                  the_buffer_size = (aligned_height + 2) * s->pitch;
689                  the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
690 <                the_buffer = (uint8 *)calloc(1, the_buffer_size);
690 >                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
691                  D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
692          }
693          
# Line 676 | Line 712 | driver_window::driver_window(SDL_monitor
712          visualFormat.Rmask = f->Rmask;
713          visualFormat.Gmask = f->Gmask;
714          visualFormat.Bmask = f->Bmask;
715 <        Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(VIDEO_MODE_DEPTH));
715 >        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
716  
717          // Load gray ramp to 8->16/32 expand map
718          if (!IsDirectMode(mode))
# Line 774 | Line 810 | static void keycode_init(void)
810                  SDL_VideoDriverName(video_driver, sizeof(video_driver));
811                  bool video_driver_found = false;
812                  char line[256];
813 +                int n_keys = 0;
814                  while (fgets(line, sizeof(line) - 1, f)) {
815                          // Read line
816                          int len = strlen(line);
# Line 786 | Line 823 | static void keycode_init(void)
823                                  continue;
824  
825                          if (video_driver_found) {
826 <                                // Skip aliases
826 >                                // Skip aliases as long as we have read keycodes yet
827 >                                // Otherwise, it's another mapping and we have to stop
828                                  static const char sdl_str[] = "sdl";
829 <                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0)
829 >                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0 && n_keys == 0)
830                                          continue;
831  
832                                  // Read keycode
833                                  int x_code, mac_code;
834                                  if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
835 <                                        keycode_table[x_code & 0xff] = mac_code;
835 >                                        keycode_table[x_code & 0xff] = mac_code, n_keys++;
836                                  else
837                                          break;
838                          } else {
# Line 819 | Line 857 | static void keycode_init(void)
857                          WarningAlert(str);
858                          return;
859                  }
860 +
861 +                D(bug("Using SDL/%s keycodes table, %d key mappings\n", video_driver, n_keys));
862          }
863   }
864  
# Line 919 | Line 959 | bool VideoInit(bool classic)
959          int max_width = 640, max_height = 480;
960          SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
961          if (modes && modes != (SDL_Rect **)-1) {
962 <                max_width = modes[0]->w;
963 <                max_height = modes[0]->h;
962 >                // It turns out that on some implementations, and contrary to the documentation,
963 >                // the returned list is not sorted from largest to smallest (e.g. Windows)
964 >                for (int i = 0; modes[i] != NULL; i++) {
965 >                        const int w = modes[i]->w;
966 >                        const int h = modes[i]->h;
967 >                        if (w > max_width && h > max_height) {
968 >                                max_width = w;
969 >                                max_height = h;
970 >                        }
971 >                }
972                  if (default_width > max_width)
973                          default_width = max_width;
974                  if (default_height > max_height)
# Line 955 | Line 1003 | bool VideoInit(bool classic)
1003                          add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
1004                  else {
1005                          for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++) {
1006 <                                int bpp = (d <= VIDEO_DEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
1006 >                                int bpp = sdl_depth_of_video_depth(d);
1007                                  if (SDL_VideoModeOK(max_width, max_height, bpp, SDL_HWSURFACE))
1008                                          add_window_modes(video_depth(d));
1009                          }
# Line 1043 | Line 1091 | void SDL_monitor_desc::video_close(void)
1091          UNLOCK_FRAME_BUFFER;
1092          D(bug(" frame buffer unlocked\n"));
1093  
1046 #ifdef ENABLE_VOSF
1047        if (use_vosf) {
1048                // Deinitialize VOSF
1049                video_vosf_exit();
1050        }
1051 #endif
1052
1094          // Close display
1095          delete drv;
1096          drv = NULL;
# Line 1147 | Line 1188 | void SDL_monitor_desc::set_palette(uint8
1188          const VIDEO_MODE &mode = get_current_mode();
1189  
1190          // FIXME: how can we handle the gamma ramp?
1191 <        if (VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1191 >        if ((int)VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1192                  return;
1193  
1194          LOCK_PALETTE;
# Line 1208 | Line 1249 | int16 video_mode_change(VidLocals *csSav
1249                          csSave->saveData = ReadMacInt32(ParamPtr + csData);
1250                          csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1251  
1252 <                        // Disable interrupts
1252 >                        // Disable interrupts and pause redraw thread
1253                          DisableInterrupt();
1254 +                        thread_stop_ack = false;
1255 +                        thread_stop_req = true;
1256 +                        while (!thread_stop_ack) ;
1257  
1258                          cur_mode = i;
1259                          monitor_desc *monitor = VideoMonitors[0];
# Line 1220 | Line 1264 | int16 video_mode_change(VidLocals *csSav
1264                          csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1265                          csSave->saveMode=VModes[cur_mode].viAppleMode;
1266  
1267 <                        // Enable interrupts
1267 >                        // Enable interrupts and resume redraw thread
1268 >                        thread_stop_req = false;
1269                          EnableInterrupt();
1270                          return noErr;
1271                  }
# Line 1267 | Line 1312 | void video_set_cursor(void)
1312  
1313  
1314   /*
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 /*
1315   *  Keyboard-related utilify functions
1316   */
1317  
# Line 1962 | Line 1645 | static void update_display_static(driver
1645  
1646          // Check for first column from left and first column from right that have changed
1647          if (high) {
1648 <                if (VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1648 >                if ((int)VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1649                          const int src_bytes_per_row = bytes_per_row;
1650                          const int dst_bytes_per_row = drv->s->pitch;
1651                          const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;
# Line 2223 | Line 1906 | static int redraw_func(void *arg)
1906                          next = GetTicks_usec();
1907                  ticks++;
1908  
1909 + #ifdef SHEEPSHAVER
1910 +                // Pause if requested (during video mode switches)
1911 +                if (thread_stop_req) {
1912 +                        thread_stop_ack = true;
1913 +                        continue;
1914 +                }
1915 + #endif
1916 +
1917                  // Handle SDL events
1918                  handle_events();
1919  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines