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.4 by cebix, 2001-07-01T14:38:03Z

# Line 19 | Line 19
19   */
20  
21   #include "sysdeps.h"
22 + #include "video.h"
23  
24   #include <stdio.h>
25   #include <stdlib.h>
# Line 67 | Line 68 | static void Blit_Copy_Raw(uint8 * dest,
68   /* --- BGR 555                                                            --- */
69   /* -------------------------------------------------------------------------- */
70  
71 < // TODO: BGR 555 (SGI/Irix)
72 < // R/G/B mask values: 0x001f, 0x03e0, 0x7c00
71 > #ifdef WORDS_BIGENDIAN
72 >
73 > // Native byte order
74 >
75 > #define FB_BLIT_1(dst, src) \
76 >        (dst = (((src) >> 10) & 0x001f) | ((src) & 0x03e0) | (((src) << 10) & 0x7c00))
77 >
78 > #define FB_BLIT_2(dst, src) \
79 >        (dst = (((src) >> 10) & 0x001f001f) | ((src) & 0x03e003e0) | (((src) << 10) & 0x7c007c00))
80 >
81 > #define FB_DEPTH 15
82 > #define FB_FUNC_NAME Blit_BGR555_NBO
83 > #include "video_blit.h"
84 >
85 > // Opposite byte order (untested)
86 >
87 > #define FB_BLIT_1(dst, src) \
88 >        (dst = (((src) >> 2) & 0x1f00) | (((src) >> 8) & 3) | (((src) << 8) & 0xe000) | (((src) << 2) & 0x7c))
89 >
90 > #define FB_BLIT_2(dst, src) \
91 >        (dst = (((src) >> 2) & 0x1f001f00) | (((src) >> 8) & 0x30003) | (((src) << 8) & 0xe000e000) | (((src) << 2) & 0x7c007c))
92 >
93 > #define FB_DEPTH 15
94 > #define FB_FUNC_NAME Blit_BGR555_OBO
95 > #include "video_blit.h"
96 >
97 > #else
98 >
99 > // Native byte order (untested)
100 >
101 > #define FB_BLIT_1(dst, src) \
102 >        (dst = (((src) >> 2) & 0x1f) | (((src) >> 8) & 0xe0) | (((src) << 8) & 0x0300) | (((src) << 2) & 0x7c00))
103 >
104 > #define FB_BLIT_2(dst, src) \
105 >        (dst = (((src) >> 2) & 0x1f001f) | (((src) >> 8) & 0xe000e0) | (((src) << 8) & 0x03000300) | (((src) << 2) & 0x7c007c00))
106 >
107 > #define FB_DEPTH 15
108 > #define FB_FUNC_NAME Blit_BGR555_NBO
109 > #include "video_blit.h"
110 >
111 > // Opposite byte order (untested)
112 >
113 > #define FB_BLIT_1(dst, src) \
114 >        (dst = (((src) << 6) & 0x1f00) | ((src) & 0xe003) | (((src) >> 6) & 0x7c))
115 >
116 > #define FB_BLIT_2(dst, src) \
117 >        (dst = (((src) << 6) & 0x1f001f00) | ((src) & 0xe003e003) | (((src) >> 6) & 0x7c007c))
118 >
119 > #define FB_DEPTH 15
120 > #define FB_FUNC_NAME Blit_BGR555_OBO
121 > #include "video_blit.h"
122 >
123 > #endif
124  
125   /* -------------------------------------------------------------------------- */
126   /* --- RGB 565                                                            --- */
# Line 168 | Line 220 | static void Blit_Copy_Raw(uint8 * dest,
220   /* --- BGR 888                                                            --- */
221   /* -------------------------------------------------------------------------- */
222  
223 < // Native byte order (untested)
223 > // Native byte order [BE] (untested)
224  
225   #ifdef WORDS_BIGENDIAN
226  
# Line 181 | Line 233 | static void Blit_Copy_Raw(uint8 * dest,
233  
234   #else
235  
236 + // Opposite byte order [LE] (untested)
237 +
238   #define FB_BLIT_2(dst, src) \
239          (dst = (((src) >> 16) & 0xff) | ((src) & 0xff0000) | (((src) & 0xff) << 16))
240  
# Line 190 | Line 244 | static void Blit_Copy_Raw(uint8 * dest,
244  
245   #endif
246  
247 < // Opposite byte order (untested)
247 > // Opposite byte order [BE] (untested) / Native byte order [LE] (untested)
248  
249   #ifdef WORDS_BIGENDIAN
250   # define FB_FUNC_NAME Blit_BGR888_OBO
# Line 229 | Line 283 | static Screen_blit_func_info Screen_blit
283          {  1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // NT
284          {  8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // OK (NBO)
285          { 15, 0x007c00, 0x0003e0, 0x00001f, Blit_Copy_Raw       , Blit_RGB555_OBO       },      // OK (OBO)
286 +        { 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO     , Blit_BGR555_OBO       },      // NT
287          { 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO     , Blit_RGB565_OBO       },      // OK (OBO)
288          { 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK (OBO)
289          { 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       },      // NT
290 <        { 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK (OBO)
291 <        { 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       }       // NT
290 >        { 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK
291 >        { 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       }       // OK
292   #else
293          {  1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // NT
294          {  8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // OK (NBO)
295          { 15, 0x007c00, 0x0003e0, 0x00001f, Blit_RGB555_NBO     , Blit_Copy_Raw         },      // OK (NBO)
296 +        { 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO     , Blit_BGR555_OBO       },      // NT
297          { 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO     , Blit_RGB565_OBO       },      // OK (NBO)
298          { 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_RGB888_NBO     , Blit_Copy_Raw         },      // OK (NBO)
299          { 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       },      // NT
# Line 249 | Line 305 | static Screen_blit_func_info Screen_blit
305   // Initialize the framebuffer update function
306   // Returns FALSE, if the function was to be reduced to a simple memcpy()
307   // --> In that case, VOSF is not necessary
308 < bool Screen_blitter_init(XVisualInfo * visual_info, bool native_byte_order)
308 > bool Screen_blitter_init(XVisualInfo * visual_info, bool native_byte_order, video_depth mac_depth)
309   {
310 <        visualFormat.depth = visual_info->depth;
311 <        visualFormat.Rmask = visual_info->red_mask;
312 <        visualFormat.Gmask = visual_info->green_mask;
313 <        visualFormat.Bmask = visual_info->blue_mask;
310 > #if REAL_ADDRESSING || DIRECT_ADDRESSING
311 >        if (mac_depth == VDEPTH_1BIT) {
312 >
313 >                // 1-bit mode uses a 1-bit X image, so there's no need for special blitting routines
314 >                Screen_blit = Blit_Copy_Raw;
315 >
316 >        } else {
317 >
318 >                visualFormat.depth = visual_info->depth;
319 >                visualFormat.Rmask = visual_info->red_mask;
320 >                visualFormat.Gmask = visual_info->green_mask;
321 >                visualFormat.Bmask = visual_info->blue_mask;
322          
323 <        // Compute RGB shift values
324 <        visualFormat.Rshift = 0;
325 <        for (uint32 Rmask = visualFormat.Rmask; Rmask && ((Rmask & 1) != 1); Rmask >>= 1)
326 <                ++visualFormat.Rshift;
327 <        visualFormat.Gshift = 0;
328 <        for (uint32 Gmask = visualFormat.Gmask; Gmask && ((Gmask & 1) != 1); Gmask >>= 1)
329 <                ++visualFormat.Gshift;
330 <        visualFormat.Bshift = 0;
331 <        for (uint32 Bmask = visualFormat.Bmask; Bmask && ((Bmask & 1) != 1); Bmask >>= 1)
332 <                ++visualFormat.Bshift;
323 >                // Compute RGB shift values
324 >                visualFormat.Rshift = 0;
325 >                for (uint32 Rmask = visualFormat.Rmask; Rmask && ((Rmask & 1) != 1); Rmask >>= 1)
326 >                        ++visualFormat.Rshift;
327 >                visualFormat.Gshift = 0;
328 >                for (uint32 Gmask = visualFormat.Gmask; Gmask && ((Gmask & 1) != 1); Gmask >>= 1)
329 >                        ++visualFormat.Gshift;
330 >                visualFormat.Bshift = 0;
331 >                for (uint32 Bmask = visualFormat.Bmask; Bmask && ((Bmask & 1) != 1); Bmask >>= 1)
332 >                        ++visualFormat.Bshift;
333          
334 <        // Search for an adequate blit function
335 <        bool blitter_found = false;
336 <        const int blitters_count = sizeof(Screen_blitters)/sizeof(Screen_blitters[0]);
337 <        for (int i = 0; !blitter_found && (i < blitters_count); i++) {
338 <                if      (       (visualFormat.depth == Screen_blitters[i].depth)
339 <                        &&      (visualFormat.Rmask == Screen_blitters[i].Rmask)
340 <                        &&      (visualFormat.Gmask == Screen_blitters[i].Gmask)
341 <                        &&      (visualFormat.Bmask == Screen_blitters[i].Bmask)
342 <                        )
343 <                {
344 <                        blitter_found = true;
345 <                        Screen_blit = native_byte_order
346 <                                                ? Screen_blitters[i].handler_nbo
347 <                                                : Screen_blitters[i].handler_obo
348 <                                                ;
334 >                // Search for an adequate blit function
335 >                bool blitter_found = false;
336 >                const int blitters_count = sizeof(Screen_blitters)/sizeof(Screen_blitters[0]);
337 >                for (int i = 0; !blitter_found && (i < blitters_count); i++) {
338 >                        if      (       (visualFormat.depth == Screen_blitters[i].depth)
339 >                                &&      (visualFormat.Rmask == Screen_blitters[i].Rmask)
340 >                                &&      (visualFormat.Gmask == Screen_blitters[i].Gmask)
341 >                                &&      (visualFormat.Bmask == Screen_blitters[i].Bmask)
342 >                                )
343 >                        {
344 >                                blitter_found = true;
345 >                                Screen_blit = native_byte_order
346 >                                                        ? Screen_blitters[i].handler_nbo
347 >                                                        : Screen_blitters[i].handler_obo
348 >                                                        ;
349 >                        }
350                  }
286        }
351          
352 <        // No appropriate blitter found, dump RGB mask values and abort()
353 <        if (!blitter_found) {
354 <                fprintf(stderr, "### No appropriate blitter found\n");
355 <                fprintf(stderr, "\tR/G/B mask values  : 0x%06x, 0x%06x, 0x%06x (depth = %d)\n",
356 <                        visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask, visualFormat.depth);
357 <                fprintf(stderr, "\tR/G/B shift values : %d/%d/%d\n",
358 <                        visualFormat.Rshift, visualFormat.Gshift, visualFormat.Bshift);
359 <                abort();
352 >                // No appropriate blitter found, dump RGB mask values and abort()
353 >                if (!blitter_found) {
354 >                        fprintf(stderr, "### No appropriate blitter found\n");
355 >                        fprintf(stderr, "\tR/G/B mask values  : 0x%06x, 0x%06x, 0x%06x (depth = %d)\n",
356 >                                visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask, visualFormat.depth);
357 >                        fprintf(stderr, "\tR/G/B shift values : %d/%d/%d\n",
358 >                                visualFormat.Rshift, visualFormat.Gshift, visualFormat.Bshift);
359 >                        abort();
360 >                }
361          }
362 + #else
363 +        // The UAE memory handlers will blit correctly
364 +        // --> no need for specialised blitters here
365 +        Screen_blit = Blit_Copy_Raw;
366 + #endif
367          
368          // If the blitter simply reduces to a copy, we don't need VOSF in DGA mode
369          // --> In that case, we return FALSE

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines