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

Comparing BasiliskII/src/Unix/video_blit.cpp (file contents):
Revision 1.1 by gbeauche, 2001-01-28T14:05:19Z vs.
Revision 1.13 by gbeauche, 2004-06-23T14:30:48Z

# Line 1 | Line 1
1   /*
2   *  video_blit.cpp - Video/graphics emulation, blitters
3   *
4 < *  Basilisk II (C) 1997-2001 Christian Bauer
4 > *  Basilisk II (C) 1997-2004 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 19 | Line 19
19   */
20  
21   #include "sysdeps.h"
22 + #include "video.h"
23 + #include "video_blit.h"
24  
25   #include <stdio.h>
26   #include <stdlib.h>
25 #include <X11/Xlib.h>
26 #include <X11/Xutil.h>
27  
28 #ifdef ENABLE_VOSF
28   // Format of the target visual
30 struct VisualFormat {
31        int             depth;                                  // Screen depth
32        uint32  Rmask, Gmask, Bmask;    // RGB mask values
33        uint32  Rshift, Gshift, Bshift; // RGB shift values
34 };
29   static VisualFormat visualFormat;
30  
31 + // This holds the pixels values of the palette colors for 8->16/32-bit expansion
32 + uint32 ExpandMap[256];
33 +
34 + // Mark video_blit.h for specialization
35 + #define DEFINE_VIDEO_BLITTERS 1
36 +
37   /* -------------------------------------------------------------------------- */
38   /* --- Raw Copy / No conversion required                                  --- */
39   /* -------------------------------------------------------------------------- */
# Line 60 | Line 60 | static void Blit_Copy_Raw(uint8 * dest,
60   #define FB_BLIT_2(dst, src) \
61          (dst = (((src) >> 8) & 0x00ff00ff) | (((src) & 0x00ff00ff) << 8))
62  
63 + #define FB_BLIT_4(dst, src) \
64 +        (dst =  (((src) >> 8) & UVAL64(0x00ff00ff00ff00ff)) | \
65 +                        (((src) & UVAL64(0x00ff00ff00ff00ff)) << 8))
66 +
67   #define FB_DEPTH 15
68   #include "video_blit.h"
69  
# Line 67 | Line 71 | static void Blit_Copy_Raw(uint8 * dest,
71   /* --- BGR 555                                                            --- */
72   /* -------------------------------------------------------------------------- */
73  
74 < // TODO: BGR 555 (SGI/Irix)
75 < // R/G/B mask values: 0x001f, 0x03e0, 0x7c00
74 > #ifdef WORDS_BIGENDIAN
75 >
76 > // Native byte order
77 >
78 > #define FB_BLIT_1(dst, src) \
79 >        (dst = (((src) >> 10) & 0x001f) | ((src) & 0x03e0) | (((src) << 10) & 0x7c00))
80 >
81 > #define FB_BLIT_2(dst, src) \
82 >        (dst = (((src) >> 10) & 0x001f001f) | ((src) & 0x03e003e0) | (((src) << 10) & 0x7c007c00))
83 >
84 > #define FB_BLIT_4(dst, src) \
85 >        (dst =  (((src) >> 10) & UVAL64(0x001f001f001f001f)) | \
86 >                        ( (src)        & UVAL64(0x03e003e003e003e0)) | \
87 >                        (((src) << 10) & UVAL64(0x7c007c007c007c00)))
88 >
89 > #define FB_DEPTH 15
90 > #define FB_FUNC_NAME Blit_BGR555_NBO
91 > #include "video_blit.h"
92 >
93 > // Opposite byte order (untested)
94 >
95 > #define FB_BLIT_1(dst, src) \
96 >        (dst = (((src) >> 2) & 0x1f00) | (((src) >> 8) & 3) | (((src) << 8) & 0xe000) | (((src) << 2) & 0x7c))
97 >
98 > #define FB_BLIT_2(dst, src) \
99 >        (dst = (((src) >> 2) & 0x1f001f00) | (((src) >> 8) & 0x30003) | (((src) << 8) & 0xe000e000) | (((src) << 2) & 0x7c007c))
100 >
101 > #define FB_BLIT_4(dst, src) \
102 >        (dst =  (((src) >> 2) & UVAL64(0x1f001f001f001f00)) | \
103 >                        (((src) >> 8) & UVAL64(0x0003000300030003)) | \
104 >                        (((src) << 8) & UVAL64(0xe000e000e000e000)) | \
105 >                        (((src) << 2) & UVAL64(0x007c007c007c007c)))
106 >
107 > #define FB_DEPTH 15
108 > #define FB_FUNC_NAME Blit_BGR555_OBO
109 > #include "video_blit.h"
110 >
111 > #else
112 >
113 > // Native byte order (untested)
114 >
115 > #define FB_BLIT_1(dst, src) \
116 >        (dst = (((src) >> 2) & 0x1f) | (((src) >> 8) & 0xe0) | (((src) << 8) & 0x0300) | (((src) << 2) & 0x7c00))
117 >
118 > #define FB_BLIT_2(dst, src) \
119 >        (dst = (((src) >> 2) & 0x1f001f) | (((src) >> 8) & 0xe000e0) | (((src) << 8) & 0x03000300) | (((src) << 2) & 0x7c007c00))
120 >
121 > #define FB_BLIT_4(dst, src) \
122 >        (dst =  (((src) >> 2) & UVAL64(0x001f001f001f001f)) | \
123 >                        (((src) >> 8) & UVAL64(0x00e000e000e000e0)) | \
124 >                        (((src) << 8) & UVAL64(0x0300030003000300)) | \
125 >                        (((src) << 2) & UVAL64(0x7c007c007c007c00)))
126 >
127 > #define FB_DEPTH 15
128 > #define FB_FUNC_NAME Blit_BGR555_NBO
129 > #include "video_blit.h"
130 >
131 > // Opposite byte order (untested)
132 >
133 > #define FB_BLIT_1(dst, src) \
134 >        (dst = (((src) << 6) & 0x1f00) | ((src) & 0xe003) | (((src) >> 6) & 0x7c))
135 >
136 > #define FB_BLIT_2(dst, src) \
137 >        (dst = (((src) << 6) & 0x1f001f00) | ((src) & 0xe003e003) | (((src) >> 6) & 0x7c007c))
138 >
139 > #define FB_BLIT_4(dst, src) \
140 >        (dst =  (((src) << 6) & UVAL64(0x1f001f001f001f00)) | \
141 >                        ( (src)       & UVAL64(0xe003e003e003e003)) | \
142 >                        (((src) >> 6) & UVAL64(0x007c007c007c007c)))
143 >
144 > #define FB_DEPTH 15
145 > #define FB_FUNC_NAME Blit_BGR555_OBO
146 > #include "video_blit.h"
147 >
148 > #endif
149  
150   /* -------------------------------------------------------------------------- */
151   /* --- RGB 565                                                            --- */
# Line 84 | Line 161 | static void Blit_Copy_Raw(uint8 * dest,
161   #define FB_BLIT_2(dst, src) \
162          (dst = (((src) & 0x001f001f) | (((src) << 1) & 0xffc0ffc0)))
163  
164 + #define FB_BLIT_4(dst, src) \
165 +        (dst =  (((src)       & UVAL64(0x001f001f001f001f)) | \
166 +                        (((src) << 1) & UVAL64(0xffc0ffc0ffc0ffc0))))
167 +
168   #define FB_DEPTH 16
169   #define FB_FUNC_NAME Blit_RGB565_NBO
170   #include "video_blit.h"
# Line 96 | Line 177 | static void Blit_Copy_Raw(uint8 * dest,
177   #define FB_BLIT_2(dst, src) \
178          (dst = ((((src) >> 7) & 0x00ff00ff) | (((src) << 9) & 0xc000c000) | (((src) << 8) & 0x1f001f00)))
179  
180 + #define FB_BLIT_4(dst, src) \
181 +        (dst =  (((src) >> 7) & UVAL64(0x00ff00ff00ff00ff)) | \
182 +                        (((src) << 9) & UVAL64(0xc000c000c000c000)) | \
183 +                        (((src) << 8) & UVAL64(0x1f001f001f001f00)))
184 +
185   #define FB_DEPTH 16
186   #define FB_FUNC_NAME Blit_RGB565_OBO
187   #include "video_blit.h"
# Line 107 | Line 193 | static void Blit_Copy_Raw(uint8 * dest,
193   #define FB_BLIT_1(dst, src) \
194          (dst = (((src) >> 8) & 0x001f) | (((src) << 9) & 0xfe00) | (((src) >> 7) & 0x01c0))
195          
110 // gb-- Disabled because I don't see any improvement
111 #if 0 && defined(__i386__) && defined(X86_ASSEMBLY)
112
113 #define FB_BLIT_2(dst, src) \
114        __asm__ (       "movl %0,%%ebx\n\t" \
115                                "movl %0,%%ebp\n\t" \
116                                "andl $0x1f001f00,%%ebx\n\t" \
117                                "andl $0x007f007f,%0\n\t" \
118                                "andl $0xe000e000,%%ebp\n\t" \
119                                "shrl $8,%%ebx\n\t" \
120                                "shrl $7,%%ebp\n\t" \
121                                "shll $9,%0\n\t" \
122                                "orl %%ebx,%%ebp\n\t" \
123                                "orl %%ebp,%0\n\t" \
124                        : "=r" (dst) : "0" (src) : "ebx", "ebp", "cc" )
125
126 #else
127
196   #define FB_BLIT_2(dst, src) \
197          (dst = (((src) >> 8) & 0x001f001f) | (((src) << 9) & 0xfe00fe00) | (((src) >> 7) & 0x01c001c0))
198  
199 < #endif
199 > #define FB_BLIT_4(dst, src) \
200 >        (dst =  (((src) >> 8) & UVAL64(0x001f001f001f001f)) | \
201 >                        (((src) << 9) & UVAL64(0xfe00fe00fe00fe00)) | \
202 >                        (((src) >> 7) & UVAL64(0x01c001c001c001c0)))
203  
204   #define FB_DEPTH 16
205   #define FB_FUNC_NAME Blit_RGB565_NBO
# Line 142 | Line 213 | static void Blit_Copy_Raw(uint8 * dest,
213   #define FB_BLIT_2(dst, src) \
214          (dst = (((src) & 0x1f001f00) | (((src) << 1) & 0xe0fee0fe) | (((src) >> 15) & 0x10001)))
215  
216 + #define FB_BLIT_4(dst, src) \
217 +        (dst =  (((src)        & UVAL64(0x1f001f001f001f00)) | \
218 +                        (((src) <<  1) & UVAL64(0xe0fee0fee0fee0fe)) | \
219 +                        (((src) >> 15) & UVAL64(0x0001000100010001))))
220 +
221   #define FB_DEPTH 16
222   #define FB_FUNC_NAME Blit_RGB565_OBO
223   #include "video_blit.h"
# Line 161 | Line 237 | static void Blit_Copy_Raw(uint8 * dest,
237   #define FB_BLIT_2(dst, src) \
238          (dst = (((src) >> 24) & 0xff) | (((src) >> 8) & 0xff00) | (((src) & 0xff00) << 8) | (((src) & 0xff) << 24))
239  
240 + #define FB_BLIT_4(dst, src) \
241 +        (dst =  (((src) >> 24) & UVAL64(0x000000ff000000ff)) | \
242 +                        (((src) >>  8) & UVAL64(0x0000ff000000ff00)) | \
243 +                        (((src) & UVAL64(0x0000ff000000ff00)) <<  8) | \
244 +                        (((src) & UVAL64(0x000000ff000000ff)) << 24))
245 +
246   #define FB_DEPTH 24
247   #include "video_blit.h"
248  
# Line 168 | Line 250 | static void Blit_Copy_Raw(uint8 * dest,
250   /* --- BGR 888                                                            --- */
251   /* -------------------------------------------------------------------------- */
252  
253 < // Native byte order (untested)
253 > // Native byte order [BE] (untested)
254  
255   #ifdef WORDS_BIGENDIAN
256  
257   #define FB_BLIT_2(dst, src) \
258          (dst = (((src) >> 16) & 0xff) | ((src) & 0xff00) | (((src) & 0xff) << 16))
259  
260 + #define FB_BLIT_4(dst, src) \
261 +        (dst =  (((src) >> 16) & UVAL64(0x000000ff000000ff)) | \
262 +                        ( (src)        & UVAL64(0x0000ff000000ff00)) | \
263 +                        (((src) & UVAL64(0x000000ff000000ff)) << 16))
264 +
265   #define FB_FUNC_NAME Blit_BGR888_NBO
266   #define FB_DEPTH 24
267   #include "video_blit.h"
268  
269   #else
270  
271 + // Opposite byte order [LE] (untested)
272 +
273   #define FB_BLIT_2(dst, src) \
274          (dst = (((src) >> 16) & 0xff) | ((src) & 0xff0000) | (((src) & 0xff) << 16))
275  
276 + #define FB_BLIT_4(dst, src) \
277 +        (dst =  (((src) >> 16) & UVAL64(0x000000ff000000ff)) | \
278 +                        ( (src)        & UVAL64(0x00ff000000ff0000)) | \
279 +                        (((src) & UVAL64(0x000000ff000000ff)) << 16))
280 +
281   #define FB_FUNC_NAME Blit_BGR888_OBO
282   #define FB_DEPTH 24
283   #include "video_blit.h"
284  
285   #endif
286  
287 < // Opposite byte order (untested)
287 > // Opposite byte order [BE] (untested) / Native byte order [LE] (untested)
288  
289   #ifdef WORDS_BIGENDIAN
290   # define FB_FUNC_NAME Blit_BGR888_OBO
# Line 201 | Line 295 | static void Blit_Copy_Raw(uint8 * dest,
295   #define FB_BLIT_2(dst, src) \
296          (dst = ((src) & 0xff00ff) | (((src) & 0xff00) << 16))
297  
298 + #define FB_BLIT_4(dst, src) \
299 +        (dst = ((src) & UVAL64(0x00ff00ff00ff00ff)) | (((src) & UVAL64(0x0000ff000000ff00)) << 16))
300 +
301   #define FB_DEPTH 24
302   #include "video_blit.h"
303  
304   /* -------------------------------------------------------------------------- */
305 + /* --- 1/2/4-bit indexed to 8-bit mode conversion                           --- */
306 + /* -------------------------------------------------------------------------- */
307 +
308 + static void Blit_Expand_1_To_8(uint8 * dest, const uint8 * p, uint32 length)
309 + {
310 +        uint8 *q = (uint8 *)dest;
311 +        for (uint32 i=0; i<length; i++) {
312 +                uint8 c = *p++;
313 +                *q++ = c >> 7;
314 +                *q++ = (c >> 6) & 1;
315 +                *q++ = (c >> 5) & 1;
316 +                *q++ = (c >> 4) & 1;
317 +                *q++ = (c >> 3) & 1;
318 +                *q++ = (c >> 2) & 1;
319 +                *q++ = (c >> 1) & 1;
320 +                *q++ = c & 1;
321 +        }
322 + }
323 +
324 + static void Blit_Expand_2_To_8(uint8 * dest, const uint8 * p, uint32 length)
325 + {
326 +        uint8 *q = (uint8 *)dest;
327 +        for (uint32 i=0; i<length; i++) {
328 +                uint8 c = *p++;
329 +                *q++ = c >> 6;
330 +                *q++ = (c >> 4) & 3;
331 +                *q++ = (c >> 2) & 3;
332 +                *q++ = c & 3;
333 +        }
334 + }
335 +
336 + static void Blit_Expand_4_To_8(uint8 * dest, const uint8 * p, uint32 length)
337 + {
338 +        uint8 *q = (uint8 *)dest;
339 +        for (uint32 i=0; i<length; i++) {
340 +                uint8 c = *p++;
341 +                *q++ = c >> 4;
342 +                *q++ = c & 0x0f;
343 +        }
344 + }
345 +
346 + /* -------------------------------------------------------------------------- */
347 + /* --- 2/4/8-bit indexed to 16-bit mode color expansion                   --- */
348 + /* -------------------------------------------------------------------------- */
349 +
350 + static void Blit_Expand_2_To_16(uint8 * dest, const uint8 * p, uint32 length)
351 + {
352 +        uint16 *q = (uint16 *)dest;
353 +        for (uint32 i=0; i<length; i++) {
354 +                uint8 c = *p++;
355 +                *q++ = ExpandMap[c >> 6];
356 +                *q++ = ExpandMap[c >> 4];
357 +                *q++ = ExpandMap[c >> 2];
358 +                *q++ = ExpandMap[c];
359 +        }
360 + }
361 +
362 + static void Blit_Expand_4_To_16(uint8 * dest, const uint8 * p, uint32 length)
363 + {
364 +        uint16 *q = (uint16 *)dest;
365 +        for (uint32 i=0; i<length; i++) {
366 +                uint8 c = *p++;
367 +                *q++ = ExpandMap[c >> 4];
368 +                *q++ = ExpandMap[c];
369 +        }
370 + }
371 +
372 + static void Blit_Expand_8_To_16(uint8 * dest, const uint8 * p, uint32 length)
373 + {
374 +        uint16 *q = (uint16 *)dest;
375 +        for (uint32 i=0; i<length; i++)
376 +                *q++ = ExpandMap[*p++];
377 + }
378 +
379 + /* -------------------------------------------------------------------------- */
380 + /* --- 2/4/8-bit indexed to 32-bit mode color expansion                   --- */
381 + /* -------------------------------------------------------------------------- */
382 +
383 + static void Blit_Expand_2_To_32(uint8 * dest, const uint8 * p, uint32 length)
384 + {
385 +        uint32 *q = (uint32 *)dest;
386 +        for (uint32 i=0; i<length; i++) {
387 +                uint8 c = *p++;
388 +                *q++ = ExpandMap[c >> 6];
389 +                *q++ = ExpandMap[c >> 4];
390 +                *q++ = ExpandMap[c >> 2];
391 +                *q++ = ExpandMap[c];
392 +        }
393 + }
394 +
395 + static void Blit_Expand_4_To_32(uint8 * dest, const uint8 * p, uint32 length)
396 + {
397 +        uint32 *q = (uint32 *)dest;
398 +        for (uint32 i=0; i<length; i++) {
399 +                uint8 c = *p++;
400 +                *q++ = ExpandMap[c >> 4];
401 +                *q++ = ExpandMap[c];
402 +        }
403 + }
404 +
405 + static void Blit_Expand_8_To_32(uint8 * dest, const uint8 * p, uint32 length)
406 + {
407 +        uint32 *q = (uint32 *)dest;
408 +        for (uint32 i=0; i<length; i++)
409 +                *q++ = ExpandMap[*p++];
410 + }
411 +
412 + /* -------------------------------------------------------------------------- */
413   /* --- Blitters to the host frame buffer, or XImage buffer                --- */
414   /* -------------------------------------------------------------------------- */
415  
# Line 229 | Line 434 | static Screen_blit_func_info Screen_blit
434          {  1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // NT
435          {  8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // OK (NBO)
436          { 15, 0x007c00, 0x0003e0, 0x00001f, Blit_Copy_Raw       , Blit_RGB555_OBO       },      // OK (OBO)
437 +        { 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO     , Blit_BGR555_OBO       },      // NT
438          { 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO     , Blit_RGB565_OBO       },      // OK (OBO)
439          { 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK (OBO)
440          { 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       },      // NT
441 <        { 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK (OBO)
442 <        { 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       }       // NT
441 >        { 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK
442 >        { 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       }       // OK
443   #else
444          {  1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // NT
445          {  8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // OK (NBO)
446          { 15, 0x007c00, 0x0003e0, 0x00001f, Blit_RGB555_NBO     , Blit_Copy_Raw         },      // OK (NBO)
447 +        { 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO     , Blit_BGR555_OBO       },      // NT
448          { 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO     , Blit_RGB565_OBO       },      // OK (NBO)
449          { 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_RGB888_NBO     , Blit_Copy_Raw         },      // OK (NBO)
450          { 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       },      // NT
# Line 249 | Line 456 | static Screen_blit_func_info Screen_blit
456   // Initialize the framebuffer update function
457   // Returns FALSE, if the function was to be reduced to a simple memcpy()
458   // --> In that case, VOSF is not necessary
459 < bool Screen_blitter_init(XVisualInfo * visual_info, bool native_byte_order)
459 > bool Screen_blitter_init(VisualFormat const & visual_format, bool native_byte_order, int mac_depth)
460   {
461 <        visualFormat.depth = visual_info->depth;
462 <        visualFormat.Rmask = visual_info->red_mask;
463 <        visualFormat.Gmask = visual_info->green_mask;
464 <        visualFormat.Bmask = visual_info->blue_mask;
465 <        
466 <        // Compute RGB shift values
467 <        visualFormat.Rshift = 0;
468 <        for (uint32 Rmask = visualFormat.Rmask; Rmask && ((Rmask & 1) != 1); Rmask >>= 1)
469 <                ++visualFormat.Rshift;
470 <        visualFormat.Gshift = 0;
471 <        for (uint32 Gmask = visualFormat.Gmask; Gmask && ((Gmask & 1) != 1); Gmask >>= 1)
472 <                ++visualFormat.Gshift;
473 <        visualFormat.Bshift = 0;
474 <        for (uint32 Bmask = visualFormat.Bmask; Bmask && ((Bmask & 1) != 1); Bmask >>= 1)
475 <                ++visualFormat.Bshift;
461 > #if USE_SDL_VIDEO
462 >        const bool use_sdl_video = true;
463 > #else
464 >        const bool use_sdl_video = false;
465 > #endif
466 > #if REAL_ADDRESSING || DIRECT_ADDRESSING
467 >        if (!use_sdl_video && mac_depth == 1) {
468 >
469 >                // 1-bit mode uses a 1-bit X image, so there's no need for special blitting routines
470 >                Screen_blit = Blit_Copy_Raw;
471 >
472 >        } else {
473 >
474 >                // Compute RGB shift values
475 >                visualFormat = visual_format;
476 >                visualFormat.Rshift = 0;
477 >                for (uint32 Rmask = visualFormat.Rmask; Rmask && ((Rmask & 1) != 1); Rmask >>= 1)
478 >                        ++visualFormat.Rshift;
479 >                visualFormat.Gshift = 0;
480 >                for (uint32 Gmask = visualFormat.Gmask; Gmask && ((Gmask & 1) != 1); Gmask >>= 1)
481 >                        ++visualFormat.Gshift;
482 >                visualFormat.Bshift = 0;
483 >                for (uint32 Bmask = visualFormat.Bmask; Bmask && ((Bmask & 1) != 1); Bmask >>= 1)
484 >                        ++visualFormat.Bshift;
485 >
486 >                // 1/2/4/8-bit mode on 8/16/32-bit screen?
487 >                Screen_blit = NULL;
488 >                switch (visualFormat.depth) {
489 >                case 8:
490 >                        switch (mac_depth) {
491 >                        case 1: Screen_blit = Blit_Expand_1_To_8; break;
492 >                        case 2: Screen_blit = Blit_Expand_2_To_8; break;
493 >                        case 4: Screen_blit = Blit_Expand_4_To_8; break;
494 >                        }
495 >                        break;
496 >                case 15:
497 >                case 16:
498 >                        switch (mac_depth) {
499 >                        case 2: Screen_blit = Blit_Expand_2_To_16; break;
500 >                        case 4: Screen_blit = Blit_Expand_4_To_16; break;
501 >                        case 8: Screen_blit = Blit_Expand_8_To_16; break;
502 >                        }
503 >                        break;
504 >                case 24:
505 >                case 32:
506 >                        switch (mac_depth) {
507 >                        case 2: Screen_blit = Blit_Expand_2_To_32; break;
508 >                        case 4: Screen_blit = Blit_Expand_4_To_32; break;
509 >                        case 8: Screen_blit = Blit_Expand_8_To_32; break;
510 >                        }
511 >                        break;
512 >                }
513 >                bool blitter_found = (Screen_blit != NULL);
514          
515 <        // Search for an adequate blit function
516 <        bool blitter_found = false;
517 <        const int blitters_count = sizeof(Screen_blitters)/sizeof(Screen_blitters[0]);
518 <        for (int i = 0; !blitter_found && (i < blitters_count); i++) {
519 <                if      (       (visualFormat.depth == Screen_blitters[i].depth)
520 <                        &&      (visualFormat.Rmask == Screen_blitters[i].Rmask)
521 <                        &&      (visualFormat.Gmask == Screen_blitters[i].Gmask)
522 <                        &&      (visualFormat.Bmask == Screen_blitters[i].Bmask)
523 <                        )
524 <                {
525 <                        blitter_found = true;
526 <                        Screen_blit = native_byte_order
527 <                                                ? Screen_blitters[i].handler_nbo
528 <                                                : Screen_blitters[i].handler_obo
529 <                                                ;
515 >                // Search for an adequate blit function
516 >                const int blitters_count = sizeof(Screen_blitters)/sizeof(Screen_blitters[0]);
517 >                for (int i = 0; !blitter_found && (i < blitters_count); i++) {
518 >                        if      (       (visualFormat.depth == Screen_blitters[i].depth)
519 >                                &&      (visualFormat.Rmask == Screen_blitters[i].Rmask)
520 >                                &&      (visualFormat.Gmask == Screen_blitters[i].Gmask)
521 >                                &&      (visualFormat.Bmask == Screen_blitters[i].Bmask)
522 >                                )
523 >                        {
524 >                                blitter_found = true;
525 >                                Screen_blit = native_byte_order
526 >                                                        ? Screen_blitters[i].handler_nbo
527 >                                                        : Screen_blitters[i].handler_obo
528 >                                                        ;
529 >                        }
530                  }
286        }
531          
532 <        // No appropriate blitter found, dump RGB mask values and abort()
533 <        if (!blitter_found) {
534 <                fprintf(stderr, "### No appropriate blitter found\n");
535 <                fprintf(stderr, "\tR/G/B mask values  : 0x%06x, 0x%06x, 0x%06x (depth = %d)\n",
536 <                        visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask, visualFormat.depth);
537 <                fprintf(stderr, "\tR/G/B shift values : %d/%d/%d\n",
538 <                        visualFormat.Rshift, visualFormat.Gshift, visualFormat.Bshift);
539 <                abort();
532 >                // No appropriate blitter found, dump RGB mask values and abort()
533 >                if (!blitter_found) {
534 >                        fprintf(stderr, "### No appropriate blitter found\n");
535 >                        fprintf(stderr, "\tR/G/B mask values  : 0x%06x, 0x%06x, 0x%06x (depth = %d)\n",
536 >                                visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask, visualFormat.depth);
537 >                        fprintf(stderr, "\tR/G/B shift values : %d/%d/%d\n",
538 >                                visualFormat.Rshift, visualFormat.Gshift, visualFormat.Bshift);
539 >                        abort();
540 >                }
541          }
542 + #else
543 +        // The UAE memory handlers will blit correctly
544 +        // --> no need for specialised blitters here
545 +        Screen_blit = Blit_Copy_Raw;
546 + #endif
547          
548          // If the blitter simply reduces to a copy, we don't need VOSF in DGA mode
549          // --> In that case, we return FALSE
550          return (Screen_blit != Blit_Copy_Raw);
551   }
302 #endif /* ENABLE_VOSF */

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines