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.10 by cebix, 2002-01-15T14:58:37Z

# 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-2002 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  
24   #include <stdio.h>
25   #include <stdlib.h>
# Line 34 | Line 35 | struct VisualFormat {
35   };
36   static VisualFormat visualFormat;
37  
38 + // This holds the pixels values of the palette colors for 8->16/32-bit expansion
39 + uint32 ExpandMap[256];
40 +
41   /* -------------------------------------------------------------------------- */
42   /* --- Raw Copy / No conversion required                                  --- */
43   /* -------------------------------------------------------------------------- */
# Line 60 | Line 64 | static void Blit_Copy_Raw(uint8 * dest,
64   #define FB_BLIT_2(dst, src) \
65          (dst = (((src) >> 8) & 0x00ff00ff) | (((src) & 0x00ff00ff) << 8))
66  
67 + #define FB_BLIT_4(dst, src) \
68 +        (dst =  (((src) >> 8) & UVAL64(0x00ff00ff00ff00ff)) | \
69 +                        (((src) & UVAL64(0x00ff00ff00ff00ff)) << 8))
70 +
71   #define FB_DEPTH 15
72   #include "video_blit.h"
73  
# Line 67 | Line 75 | static void Blit_Copy_Raw(uint8 * dest,
75   /* --- BGR 555                                                            --- */
76   /* -------------------------------------------------------------------------- */
77  
78 < // TODO: BGR 555 (SGI/Irix)
79 < // R/G/B mask values: 0x001f, 0x03e0, 0x7c00
78 > #ifdef WORDS_BIGENDIAN
79 >
80 > // Native byte order
81 >
82 > #define FB_BLIT_1(dst, src) \
83 >        (dst = (((src) >> 10) & 0x001f) | ((src) & 0x03e0) | (((src) << 10) & 0x7c00))
84 >
85 > #define FB_BLIT_2(dst, src) \
86 >        (dst = (((src) >> 10) & 0x001f001f) | ((src) & 0x03e003e0) | (((src) << 10) & 0x7c007c00))
87 >
88 > #define FB_BLIT_4(dst, src) \
89 >        (dst =  (((src) >> 10) & UVAL64(0x001f001f001f001f)) | \
90 >                        ( (src)        & UVAL64(0x03e003e003e003e0)) | \
91 >                        (((src) << 10) & UVAL64(0x7c007c007c007c00)))
92 >
93 > #define FB_DEPTH 15
94 > #define FB_FUNC_NAME Blit_BGR555_NBO
95 > #include "video_blit.h"
96 >
97 > // Opposite byte order (untested)
98 >
99 > #define FB_BLIT_1(dst, src) \
100 >        (dst = (((src) >> 2) & 0x1f00) | (((src) >> 8) & 3) | (((src) << 8) & 0xe000) | (((src) << 2) & 0x7c))
101 >
102 > #define FB_BLIT_2(dst, src) \
103 >        (dst = (((src) >> 2) & 0x1f001f00) | (((src) >> 8) & 0x30003) | (((src) << 8) & 0xe000e000) | (((src) << 2) & 0x7c007c))
104 >
105 > #define FB_BLIT_4(dst, src) \
106 >        (dst =  (((src) >> 2) & UVAL64(0x1f001f001f001f00)) | \
107 >                        (((src) >> 8) & UVAL64(0x0003000300030003)) | \
108 >                        (((src) << 8) & UVAL64(0xe000e000e000e000)) | \
109 >                        (((src) << 2) & UVAL64(0x007c007c007c007c)))
110 >
111 > #define FB_DEPTH 15
112 > #define FB_FUNC_NAME Blit_BGR555_OBO
113 > #include "video_blit.h"
114 >
115 > #else
116 >
117 > // Native byte order (untested)
118 >
119 > #define FB_BLIT_1(dst, src) \
120 >        (dst = (((src) >> 2) & 0x1f) | (((src) >> 8) & 0xe0) | (((src) << 8) & 0x0300) | (((src) << 2) & 0x7c00))
121 >
122 > #define FB_BLIT_2(dst, src) \
123 >        (dst = (((src) >> 2) & 0x1f001f) | (((src) >> 8) & 0xe000e0) | (((src) << 8) & 0x03000300) | (((src) << 2) & 0x7c007c00))
124 >
125 > #define FB_BLIT_4(dst, src) \
126 >        (dst =  (((src) >> 2) & UVAL64(0x001f001f001f001f)) | \
127 >                        (((src) >> 8) & UVAL64(0x00e000e000e000e0)) | \
128 >                        (((src) << 8) & UVAL64(0x0300030003000300)) | \
129 >                        (((src) << 2) & UVAL64(0x7c007c007c007c00)))
130 >
131 > #define FB_DEPTH 15
132 > #define FB_FUNC_NAME Blit_BGR555_NBO
133 > #include "video_blit.h"
134 >
135 > // Opposite byte order (untested)
136 >
137 > #define FB_BLIT_1(dst, src) \
138 >        (dst = (((src) << 6) & 0x1f00) | ((src) & 0xe003) | (((src) >> 6) & 0x7c))
139 >
140 > #define FB_BLIT_2(dst, src) \
141 >        (dst = (((src) << 6) & 0x1f001f00) | ((src) & 0xe003e003) | (((src) >> 6) & 0x7c007c))
142 >
143 > #define FB_BLIT_4(dst, src) \
144 >        (dst =  (((src) << 6) & UVAL64(0x1f001f001f001f00)) | \
145 >                        ( (src)       & UVAL64(0xe003e003e003e003)) | \
146 >                        (((src) >> 6) & UVAL64(0x007c007c007c007c)))
147 >
148 > #define FB_DEPTH 15
149 > #define FB_FUNC_NAME Blit_BGR555_OBO
150 > #include "video_blit.h"
151 >
152 > #endif
153  
154   /* -------------------------------------------------------------------------- */
155   /* --- RGB 565                                                            --- */
# Line 84 | Line 165 | static void Blit_Copy_Raw(uint8 * dest,
165   #define FB_BLIT_2(dst, src) \
166          (dst = (((src) & 0x001f001f) | (((src) << 1) & 0xffc0ffc0)))
167  
168 + #define FB_BLIT_4(dst, src) \
169 +        (dst =  (((src)       & UVAL64(0x001f001f001f001f)) | \
170 +                        (((src) << 1) & UVAL64(0xffc0ffc0ffc0ffc0))))
171 +
172   #define FB_DEPTH 16
173   #define FB_FUNC_NAME Blit_RGB565_NBO
174   #include "video_blit.h"
# Line 96 | Line 181 | static void Blit_Copy_Raw(uint8 * dest,
181   #define FB_BLIT_2(dst, src) \
182          (dst = ((((src) >> 7) & 0x00ff00ff) | (((src) << 9) & 0xc000c000) | (((src) << 8) & 0x1f001f00)))
183  
184 + #define FB_BLIT_4(dst, src) \
185 +        (dst =  (((src) >> 7) & UVAL64(0x00ff00ff00ff00ff)) | \
186 +                        (((src) << 9) & UVAL64(0xc000c000c000c000)) | \
187 +                        (((src) << 8) & UVAL64(0x1f001f001f001f00)))
188 +
189   #define FB_DEPTH 16
190   #define FB_FUNC_NAME Blit_RGB565_OBO
191   #include "video_blit.h"
# Line 107 | Line 197 | static void Blit_Copy_Raw(uint8 * dest,
197   #define FB_BLIT_1(dst, src) \
198          (dst = (((src) >> 8) & 0x001f) | (((src) << 9) & 0xfe00) | (((src) >> 7) & 0x01c0))
199          
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
200   #define FB_BLIT_2(dst, src) \
201          (dst = (((src) >> 8) & 0x001f001f) | (((src) << 9) & 0xfe00fe00) | (((src) >> 7) & 0x01c001c0))
202  
203 < #endif
203 > #define FB_BLIT_4(dst, src) \
204 >        (dst =  (((src) >> 8) & UVAL64(0x001f001f001f001f)) | \
205 >                        (((src) << 9) & UVAL64(0xfe00fe00fe00fe00)) | \
206 >                        (((src) >> 7) & UVAL64(0x01c001c001c001c0)))
207  
208   #define FB_DEPTH 16
209   #define FB_FUNC_NAME Blit_RGB565_NBO
# Line 142 | Line 217 | static void Blit_Copy_Raw(uint8 * dest,
217   #define FB_BLIT_2(dst, src) \
218          (dst = (((src) & 0x1f001f00) | (((src) << 1) & 0xe0fee0fe) | (((src) >> 15) & 0x10001)))
219  
220 + #define FB_BLIT_4(dst, src) \
221 +        (dst =  (((src)        & UVAL64(0x1f001f001f001f00)) | \
222 +                        (((src) <<  1) & UVAL64(0xe0fee0fee0fee0fe)) | \
223 +                        (((src) >> 15) & UVAL64(0x0001000100010001))))
224 +
225   #define FB_DEPTH 16
226   #define FB_FUNC_NAME Blit_RGB565_OBO
227   #include "video_blit.h"
# Line 161 | Line 241 | static void Blit_Copy_Raw(uint8 * dest,
241   #define FB_BLIT_2(dst, src) \
242          (dst = (((src) >> 24) & 0xff) | (((src) >> 8) & 0xff00) | (((src) & 0xff00) << 8) | (((src) & 0xff) << 24))
243  
244 + #define FB_BLIT_4(dst, src) \
245 +        (dst =  (((src) >> 24) & UVAL64(0x000000ff000000ff)) | \
246 +                        (((src) >>  8) & UVAL64(0x0000ff000000ff00)) | \
247 +                        (((src) & UVAL64(0x0000ff000000ff00)) <<  8) | \
248 +                        (((src) & UVAL64(0x000000ff000000ff)) << 24))
249 +
250   #define FB_DEPTH 24
251   #include "video_blit.h"
252  
# Line 168 | Line 254 | static void Blit_Copy_Raw(uint8 * dest,
254   /* --- BGR 888                                                            --- */
255   /* -------------------------------------------------------------------------- */
256  
257 < // Native byte order (untested)
257 > // Native byte order [BE] (untested)
258  
259   #ifdef WORDS_BIGENDIAN
260  
261   #define FB_BLIT_2(dst, src) \
262          (dst = (((src) >> 16) & 0xff) | ((src) & 0xff00) | (((src) & 0xff) << 16))
263  
264 + #define FB_BLIT_4(dst, src) \
265 +        (dst =  (((src) >> 16) & UVAL64(0x000000ff000000ff)) | \
266 +                        ( (src)        & UVAL64(0x0000ff000000ff00)) | \
267 +                        (((src) & UVAL64(0x000000ff000000ff)) << 16))
268 +
269   #define FB_FUNC_NAME Blit_BGR888_NBO
270   #define FB_DEPTH 24
271   #include "video_blit.h"
272  
273   #else
274  
275 + // Opposite byte order [LE] (untested)
276 +
277   #define FB_BLIT_2(dst, src) \
278          (dst = (((src) >> 16) & 0xff) | ((src) & 0xff0000) | (((src) & 0xff) << 16))
279  
280 + #define FB_BLIT_4(dst, src) \
281 +        (dst =  (((src) >> 16) & UVAL64(0x000000ff000000ff)) | \
282 +                        ( (src)        & UVAL64(0x00ff000000ff0000)) | \
283 +                        (((src) & UVAL64(0x000000ff000000ff)) << 16))
284 +
285   #define FB_FUNC_NAME Blit_BGR888_OBO
286   #define FB_DEPTH 24
287   #include "video_blit.h"
288  
289   #endif
290  
291 < // Opposite byte order (untested)
291 > // Opposite byte order [BE] (untested) / Native byte order [LE] (untested)
292  
293   #ifdef WORDS_BIGENDIAN
294   # define FB_FUNC_NAME Blit_BGR888_OBO
# Line 201 | Line 299 | static void Blit_Copy_Raw(uint8 * dest,
299   #define FB_BLIT_2(dst, src) \
300          (dst = ((src) & 0xff00ff) | (((src) & 0xff00) << 16))
301  
302 + #define FB_BLIT_4(dst, src) \
303 +        (dst = ((src) & UVAL64(0x00ff00ff00ff00ff)) | (((src) & UVAL64(0x0000ff000000ff00)) << 16))
304 +
305   #define FB_DEPTH 24
306   #include "video_blit.h"
307  
308   /* -------------------------------------------------------------------------- */
309 + /* --- 2/4-bit indexed to 8-bit mode conversion                           --- */
310 + /* -------------------------------------------------------------------------- */
311 +
312 + static void Blit_Expand_2_To_8(uint8 * dest, const uint8 * p, uint32 length)
313 + {
314 +        uint8 *q = (uint8 *)dest;
315 +        for (uint32 i=0; i<length; i++) {
316 +                uint8 c = *p++;
317 +                *q++ = c >> 6;
318 +                *q++ = (c >> 4) & 3;
319 +                *q++ = (c >> 2) & 3;
320 +                *q++ = c & 3;
321 +        }
322 + }
323 +
324 + static void Blit_Expand_4_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 >> 4;
330 +                *q++ = c & 0x0f;
331 +        }
332 + }
333 +
334 + /* -------------------------------------------------------------------------- */
335 + /* --- 2/4/8-bit indexed to 16-bit mode color expansion                   --- */
336 + /* -------------------------------------------------------------------------- */
337 +
338 + static void Blit_Expand_2_To_16(uint8 * dest, const uint8 * p, uint32 length)
339 + {
340 +        uint16 *q = (uint16 *)dest;
341 +        for (uint32 i=0; i<length; i++) {
342 +                uint8 c = *p++;
343 +                *q++ = ExpandMap[c >> 6];
344 +                *q++ = ExpandMap[c >> 4];
345 +                *q++ = ExpandMap[c >> 2];
346 +                *q++ = ExpandMap[c];
347 +        }
348 + }
349 +
350 + static void Blit_Expand_4_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 >> 4];
356 +                *q++ = ExpandMap[c];
357 +        }
358 + }
359 +
360 + static void Blit_Expand_8_To_16(uint8 * dest, const uint8 * p, uint32 length)
361 + {
362 +        uint16 *q = (uint16 *)dest;
363 +        for (uint32 i=0; i<length; i++)
364 +                *q++ = ExpandMap[*p++];
365 + }
366 +
367 + /* -------------------------------------------------------------------------- */
368 + /* --- 2/4/8-bit indexed to 32-bit mode color expansion                   --- */
369 + /* -------------------------------------------------------------------------- */
370 +
371 + static void Blit_Expand_2_To_32(uint8 * dest, const uint8 * p, uint32 length)
372 + {
373 +        uint32 *q = (uint32 *)dest;
374 +        for (uint32 i=0; i<length; i++) {
375 +                uint8 c = *p++;
376 +                *q++ = ExpandMap[c >> 6];
377 +                *q++ = ExpandMap[c >> 4];
378 +                *q++ = ExpandMap[c >> 2];
379 +                *q++ = ExpandMap[c];
380 +        }
381 + }
382 +
383 + static void Blit_Expand_4_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 >> 4];
389 +                *q++ = ExpandMap[c];
390 +        }
391 + }
392 +
393 + static void Blit_Expand_8_To_32(uint8 * dest, const uint8 * p, uint32 length)
394 + {
395 +        uint32 *q = (uint32 *)dest;
396 +        for (uint32 i=0; i<length; i++)
397 +                *q++ = ExpandMap[*p++];
398 + }
399 +
400 + /* -------------------------------------------------------------------------- */
401   /* --- Blitters to the host frame buffer, or XImage buffer                --- */
402   /* -------------------------------------------------------------------------- */
403  
# Line 229 | Line 422 | static Screen_blit_func_info Screen_blit
422          {  1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // NT
423          {  8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // OK (NBO)
424          { 15, 0x007c00, 0x0003e0, 0x00001f, Blit_Copy_Raw       , Blit_RGB555_OBO       },      // OK (OBO)
425 +        { 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO     , Blit_BGR555_OBO       },      // NT
426          { 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO     , Blit_RGB565_OBO       },      // OK (OBO)
427          { 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK (OBO)
428          { 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       },      // NT
429 <        { 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK (OBO)
430 <        { 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       }       // NT
429 >        { 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK
430 >        { 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       }       // OK
431   #else
432          {  1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // NT
433          {  8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // OK (NBO)
434          { 15, 0x007c00, 0x0003e0, 0x00001f, Blit_RGB555_NBO     , Blit_Copy_Raw         },      // OK (NBO)
435 +        { 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO     , Blit_BGR555_OBO       },      // NT
436          { 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO     , Blit_RGB565_OBO       },      // OK (NBO)
437          { 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_RGB888_NBO     , Blit_Copy_Raw         },      // OK (NBO)
438          { 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       },      // NT
# Line 249 | Line 444 | static Screen_blit_func_info Screen_blit
444   // Initialize the framebuffer update function
445   // Returns FALSE, if the function was to be reduced to a simple memcpy()
446   // --> In that case, VOSF is not necessary
447 < bool Screen_blitter_init(XVisualInfo * visual_info, bool native_byte_order)
447 > bool Screen_blitter_init(XVisualInfo * visual_info, bool native_byte_order, video_depth mac_depth)
448   {
449 <        visualFormat.depth = visual_info->depth;
450 <        visualFormat.Rmask = visual_info->red_mask;
451 <        visualFormat.Gmask = visual_info->green_mask;
452 <        visualFormat.Bmask = visual_info->blue_mask;
449 > #if REAL_ADDRESSING || DIRECT_ADDRESSING
450 >        if (mac_depth == VDEPTH_1BIT) {
451 >
452 >                // 1-bit mode uses a 1-bit X image, so there's no need for special blitting routines
453 >                Screen_blit = Blit_Copy_Raw;
454 >
455 >        } else {
456 >
457 >                visualFormat.depth = visual_info->depth;
458 >                visualFormat.Rmask = visual_info->red_mask;
459 >                visualFormat.Gmask = visual_info->green_mask;
460 >                visualFormat.Bmask = visual_info->blue_mask;
461 >
462 >                // Compute RGB shift values
463 >                visualFormat.Rshift = 0;
464 >                for (uint32 Rmask = visualFormat.Rmask; Rmask && ((Rmask & 1) != 1); Rmask >>= 1)
465 >                        ++visualFormat.Rshift;
466 >                visualFormat.Gshift = 0;
467 >                for (uint32 Gmask = visualFormat.Gmask; Gmask && ((Gmask & 1) != 1); Gmask >>= 1)
468 >                        ++visualFormat.Gshift;
469 >                visualFormat.Bshift = 0;
470 >                for (uint32 Bmask = visualFormat.Bmask; Bmask && ((Bmask & 1) != 1); Bmask >>= 1)
471 >                        ++visualFormat.Bshift;
472 >
473 >                bool blitter_found = false;
474          
475 <        // Compute RGB shift values
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;
475 >                // 2/4/8-bit mode on 8/16/32-bit screen?
476 >                if (visualFormat.depth == 8) {
477 >                        if (mac_depth == VDEPTH_2BIT) {
478 >                                Screen_blit = Blit_Expand_2_To_8;
479 >                                blitter_found = true;
480 >                        } else if (mac_depth == VDEPTH_4BIT) {
481 >                                Screen_blit = Blit_Expand_4_To_8;
482 >                                blitter_found = true;
483 >                        }
484 >                } else if (visualFormat.depth == 15 || visualFormat.depth == 16) {
485 >                        if (mac_depth == VDEPTH_2BIT) {
486 >                                Screen_blit = Blit_Expand_2_To_16;
487 >                                blitter_found = true;
488 >                        } else if (mac_depth == VDEPTH_4BIT) {
489 >                                Screen_blit = Blit_Expand_4_To_16;
490 >                                blitter_found = true;
491 >                        } else if (mac_depth == VDEPTH_8BIT) {
492 >                                Screen_blit = Blit_Expand_8_To_16;
493 >                                blitter_found = true;
494 >                        }
495 >                } else if (visualFormat.depth == 24 || visualFormat.depth == 32) {
496 >                        if (mac_depth == VDEPTH_2BIT) {
497 >                                Screen_blit = Blit_Expand_2_To_32;
498 >                                blitter_found = true;
499 >                        } else if (mac_depth == VDEPTH_4BIT) {
500 >                                Screen_blit = Blit_Expand_4_To_32;
501 >                                blitter_found = true;
502 >                        } else if (mac_depth == VDEPTH_8BIT) {
503 >                                Screen_blit = Blit_Expand_8_To_32;
504 >                                blitter_found = true;
505 >                        }
506 >                }
507          
508 <        // Search for an adequate blit function
509 <        bool blitter_found = false;
510 <        const int blitters_count = sizeof(Screen_blitters)/sizeof(Screen_blitters[0]);
511 <        for (int i = 0; !blitter_found && (i < blitters_count); i++) {
512 <                if      (       (visualFormat.depth == Screen_blitters[i].depth)
513 <                        &&      (visualFormat.Rmask == Screen_blitters[i].Rmask)
514 <                        &&      (visualFormat.Gmask == Screen_blitters[i].Gmask)
515 <                        &&      (visualFormat.Bmask == Screen_blitters[i].Bmask)
516 <                        )
517 <                {
518 <                        blitter_found = true;
519 <                        Screen_blit = native_byte_order
520 <                                                ? Screen_blitters[i].handler_nbo
521 <                                                : Screen_blitters[i].handler_obo
522 <                                                ;
508 >                // Search for an adequate blit function
509 >                const int blitters_count = sizeof(Screen_blitters)/sizeof(Screen_blitters[0]);
510 >                for (int i = 0; !blitter_found && (i < blitters_count); i++) {
511 >                        if      (       (visualFormat.depth == Screen_blitters[i].depth)
512 >                                &&      (visualFormat.Rmask == Screen_blitters[i].Rmask)
513 >                                &&      (visualFormat.Gmask == Screen_blitters[i].Gmask)
514 >                                &&      (visualFormat.Bmask == Screen_blitters[i].Bmask)
515 >                                )
516 >                        {
517 >                                blitter_found = true;
518 >                                Screen_blit = native_byte_order
519 >                                                        ? Screen_blitters[i].handler_nbo
520 >                                                        : Screen_blitters[i].handler_obo
521 >                                                        ;
522 >                        }
523                  }
286        }
524          
525 <        // No appropriate blitter found, dump RGB mask values and abort()
526 <        if (!blitter_found) {
527 <                fprintf(stderr, "### No appropriate blitter found\n");
528 <                fprintf(stderr, "\tR/G/B mask values  : 0x%06x, 0x%06x, 0x%06x (depth = %d)\n",
529 <                        visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask, visualFormat.depth);
530 <                fprintf(stderr, "\tR/G/B shift values : %d/%d/%d\n",
531 <                        visualFormat.Rshift, visualFormat.Gshift, visualFormat.Bshift);
532 <                abort();
525 >                // No appropriate blitter found, dump RGB mask values and abort()
526 >                if (!blitter_found) {
527 >                        fprintf(stderr, "### No appropriate blitter found\n");
528 >                        fprintf(stderr, "\tR/G/B mask values  : 0x%06x, 0x%06x, 0x%06x (depth = %d)\n",
529 >                                visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask, visualFormat.depth);
530 >                        fprintf(stderr, "\tR/G/B shift values : %d/%d/%d\n",
531 >                                visualFormat.Rshift, visualFormat.Gshift, visualFormat.Bshift);
532 >                        abort();
533 >                }
534          }
535 + #else
536 +        // The UAE memory handlers will blit correctly
537 +        // --> no need for specialised blitters here
538 +        Screen_blit = Blit_Copy_Raw;
539 + #endif
540          
541          // If the blitter simply reduces to a copy, we don't need VOSF in DGA mode
542          // --> In that case, we return FALSE

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines