src/Unix/video_blit.cpp

/*
 *  video_blit.cpp - Video/graphics emulation, blitters
 *
 *  Basilisk II (C) 1997-2005 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"
#include "video.h"
#include "video_blit.h"

#include <stdio.h>
#include <stdlib.h>

// Format of the target visual
static VisualFormat visualFormat;

// This holds the pixels values of the palette colors for 8->16/32-bit expansion
uint32 ExpandMap[256];

// Mark video_blit.h for specialization
#define DEFINE_VIDEO_BLITTERS 1

/* -------------------------------------------------------------------------- */
/* --- Raw Copy / No conversion required                                  --- */
/* -------------------------------------------------------------------------- */

static void Blit_Copy_Raw(uint8 * dest, const uint8 * source, uint32 length)
{
        // This function is likely to be inlined and/or highly optimized
        memcpy(dest, source, length);
}

/* -------------------------------------------------------------------------- */
/* --- RGB 555                                                            --- */
/* -------------------------------------------------------------------------- */

#ifdef WORDS_BIGENDIAN
# define FB_FUNC_NAME Blit_RGB555_OBO
#else
# define FB_FUNC_NAME Blit_RGB555_NBO
#endif

#define FB_BLIT_1(dst, src) \
        (dst = (((src) >> 8) & 0xff) | (((src) & 0xff) << 8))
        
#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 8) & 0x00ff00ff) | (((src) & 0x00ff00ff) << 8))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 8) & UVAL64(0x00ff00ff00ff00ff)) | \
                        (((src) & UVAL64(0x00ff00ff00ff00ff)) << 8))

#define FB_DEPTH 15
#include "video_blit.h"

/* -------------------------------------------------------------------------- */
/* --- BGR 555                                                            --- */
/* -------------------------------------------------------------------------- */

#ifdef WORDS_BIGENDIAN

// Native byte order

#define FB_BLIT_1(dst, src) \
        (dst = (((src) >> 10) & 0x001f) | ((src) & 0x03e0) | (((src) << 10) & 0x7c00))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 10) & 0x001f001f) | ((src) & 0x03e003e0) | (((src) << 10) & 0x7c007c00))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 10) & UVAL64(0x001f001f001f001f)) | \
                        ( (src)        & UVAL64(0x03e003e003e003e0)) | \
                        (((src) << 10) & UVAL64(0x7c007c007c007c00)))

#define FB_DEPTH 15
#define FB_FUNC_NAME Blit_BGR555_NBO
#include "video_blit.h"

// Opposite byte order (untested)

#define FB_BLIT_1(dst, src) \
        (dst = (((src) >> 2) & 0x1f00) | (((src) >> 8) & 3) | (((src) << 8) & 0xe000) | (((src) << 2) & 0x7c))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 2) & 0x1f001f00) | (((src) >> 8) & 0x30003) | (((src) << 8) & 0xe000e000) | (((src) << 2) & 0x7c007c))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 2) & UVAL64(0x1f001f001f001f00)) | \
                        (((src) >> 8) & UVAL64(0x0003000300030003)) | \
                        (((src) << 8) & UVAL64(0xe000e000e000e000)) | \
                        (((src) << 2) & UVAL64(0x007c007c007c007c)))

#define FB_DEPTH 15
#define FB_FUNC_NAME Blit_BGR555_OBO
#include "video_blit.h"

#else

// Native byte order (untested)

#define FB_BLIT_1(dst, src) \
        (dst = (((src) >> 2) & 0x1f) | (((src) >> 8) & 0xe0) | (((src) << 8) & 0x0300) | (((src) << 2) & 0x7c00))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 2) & 0x1f001f) | (((src) >> 8) & 0xe000e0) | (((src) << 8) & 0x03000300) | (((src) << 2) & 0x7c007c00))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 2) & UVAL64(0x001f001f001f001f)) | \
                        (((src) >> 8) & UVAL64(0x00e000e000e000e0)) | \
                        (((src) << 8) & UVAL64(0x0300030003000300)) | \
                        (((src) << 2) & UVAL64(0x7c007c007c007c00)))

#define FB_DEPTH 15
#define FB_FUNC_NAME Blit_BGR555_NBO
#include "video_blit.h"

// Opposite byte order (untested)

#define FB_BLIT_1(dst, src) \
        (dst = (((src) << 6) & 0x1f00) | ((src) & 0xe003) | (((src) >> 6) & 0x7c))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) << 6) & 0x1f001f00) | ((src) & 0xe003e003) | (((src) >> 6) & 0x7c007c))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) << 6) & UVAL64(0x1f001f001f001f00)) | \
                        ( (src)       & UVAL64(0xe003e003e003e003)) | \
                        (((src) >> 6) & UVAL64(0x007c007c007c007c)))

#define FB_DEPTH 15
#define FB_FUNC_NAME Blit_BGR555_OBO
#include "video_blit.h"

#endif

/* -------------------------------------------------------------------------- */
/* --- RGB 565                                                            --- */
/* -------------------------------------------------------------------------- */

#ifdef WORDS_BIGENDIAN

// Native byte order

#define FB_BLIT_1(dst, src) \
        (dst = (((src) & 0x1f) | (((src) << 1) & 0xffc0)))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) & 0x001f001f) | (((src) << 1) & 0xffc0ffc0)))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src)       & UVAL64(0x001f001f001f001f)) | \
                        (((src) << 1) & UVAL64(0xffc0ffc0ffc0ffc0))))

#define FB_DEPTH 16
#define FB_FUNC_NAME Blit_RGB565_NBO
#include "video_blit.h"

// Opposite byte order

#define FB_BLIT_1(dst, src) \
        (dst = ((((src) >> 7) & 0xff) | (((src) << 9) & 0xc000) | (((src) << 8) & 0x1f00)))

#define FB_BLIT_2(dst, src) \
        (dst = ((((src) >> 7) & 0x00ff00ff) | (((src) << 9) & 0xc000c000) | (((src) << 8) & 0x1f001f00)))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 7) & UVAL64(0x00ff00ff00ff00ff)) | \
                        (((src) << 9) & UVAL64(0xc000c000c000c000)) | \
                        (((src) << 8) & UVAL64(0x1f001f001f001f00)))

#define FB_DEPTH 16
#define FB_FUNC_NAME Blit_RGB565_OBO
#include "video_blit.h"

#else

// Native byte order

#define FB_BLIT_1(dst, src) \
        (dst = (((src) >> 8) & 0x001f) | (((src) << 9) & 0xfe00) | (((src) >> 7) & 0x01c0))
        
#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 8) & 0x001f001f) | (((src) << 9) & 0xfe00fe00) | (((src) >> 7) & 0x01c001c0))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 8) & UVAL64(0x001f001f001f001f)) | \
                        (((src) << 9) & UVAL64(0xfe00fe00fe00fe00)) | \
                        (((src) >> 7) & UVAL64(0x01c001c001c001c0)))

#define FB_DEPTH 16
#define FB_FUNC_NAME Blit_RGB565_NBO
#include "video_blit.h"

// Opposite byte order (untested)

#define FB_BLIT_1(dst, src) \
        (dst = (((src) & 0x1f00) | (((src) << 1) & 0xe0fe) | (((src) >> 15) & 1)))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) & 0x1f001f00) | (((src) << 1) & 0xe0fee0fe) | (((src) >> 15) & 0x10001)))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src)        & UVAL64(0x1f001f001f001f00)) | \
                        (((src) <<  1) & UVAL64(0xe0fee0fee0fee0fe)) | \
                        (((src) >> 15) & UVAL64(0x0001000100010001))))

#define FB_DEPTH 16
#define FB_FUNC_NAME Blit_RGB565_OBO
#include "video_blit.h"

#endif

/* -------------------------------------------------------------------------- */
/* --- RGB 888                                                            --- */
/* -------------------------------------------------------------------------- */

#ifdef WORDS_BIGENDIAN
# define FB_FUNC_NAME Blit_RGB888_OBO
#else
# define FB_FUNC_NAME Blit_RGB888_NBO
#endif

#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 24) & 0xff) | (((src) >> 8) & 0xff00) | (((src) & 0xff00) << 8) | (((src) & 0xff) << 24))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 24) & UVAL64(0x000000ff000000ff)) | \
                        (((src) >>  8) & UVAL64(0x0000ff000000ff00)) | \
                        (((src) & UVAL64(0x0000ff000000ff00)) <<  8) | \
                        (((src) & UVAL64(0x000000ff000000ff)) << 24))

#define FB_DEPTH 24
#include "video_blit.h"

/* -------------------------------------------------------------------------- */
/* --- BGR 888                                                            --- */
/* -------------------------------------------------------------------------- */

// Native byte order [BE] (untested)

#ifdef WORDS_BIGENDIAN

#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 16) & 0xff) | ((src) & 0xff00) | (((src) & 0xff) << 16))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 16) & UVAL64(0x000000ff000000ff)) | \
                        ( (src)        & UVAL64(0x0000ff000000ff00)) | \
                        (((src) & UVAL64(0x000000ff000000ff)) << 16))

#define FB_FUNC_NAME Blit_BGR888_NBO
#define FB_DEPTH 24
#include "video_blit.h"

#else

// Opposite byte order [LE] (untested)

#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 16) & 0xff) | ((src) & 0xff0000) | (((src) & 0xff) << 16))

#define FB_BLIT_4(dst, src) \
        (dst =  (((src) >> 16) & UVAL64(0x000000ff000000ff)) | \
                        ( (src)        & UVAL64(0x00ff000000ff0000)) | \
                        (((src) & UVAL64(0x000000ff000000ff)) << 16))

#define FB_FUNC_NAME Blit_BGR888_OBO
#define FB_DEPTH 24
#include "video_blit.h"

#endif

// Opposite byte order [BE] (untested) / Native byte order [LE] (untested)

#ifdef WORDS_BIGENDIAN
# define FB_FUNC_NAME Blit_BGR888_OBO
#else
# define FB_FUNC_NAME Blit_BGR888_NBO
#endif

#define FB_BLIT_2(dst, src) \
        (dst = ((src) & 0xff00ff) | (((src) & 0xff00) << 16))

#define FB_BLIT_4(dst, src) \
        (dst = ((src) & UVAL64(0x00ff00ff00ff00ff)) | (((src) & UVAL64(0x0000ff000000ff00)) << 16))

#define FB_DEPTH 24
#include "video_blit.h"

/* -------------------------------------------------------------------------- */
/* --- 1/2/4-bit indexed to 8-bit mode conversion                           --- */
/* -------------------------------------------------------------------------- */

static void Blit_Expand_1_To_8(uint8 * dest, const uint8 * p, uint32 length)
{
        uint8 *q = (uint8 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = c >> 7;
                *q++ = (c >> 6) & 1;
                *q++ = (c >> 5) & 1;
                *q++ = (c >> 4) & 1;
                *q++ = (c >> 3) & 1;
                *q++ = (c >> 2) & 1;
                *q++ = (c >> 1) & 1;
                *q++ = c & 1;
        }
}

static void Blit_Expand_2_To_8(uint8 * dest, const uint8 * p, uint32 length)
{
        uint8 *q = (uint8 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = c >> 6;
                *q++ = (c >> 4) & 3;
                *q++ = (c >> 2) & 3;
                *q++ = c & 3;
        }
}

static void Blit_Expand_4_To_8(uint8 * dest, const uint8 * p, uint32 length)
{
        uint8 *q = (uint8 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = c >> 4;
                *q++ = c & 0x0f;
        }
}

/* -------------------------------------------------------------------------- */
/* --- 1/2/4/8-bit indexed to 16-bit mode color expansion                 --- */
/* -------------------------------------------------------------------------- */

static void Blit_Expand_1_To_16(uint8 * dest, const uint8 * p, uint32 length)
{
        uint16 *q = (uint16 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = -(c >> 7);
                *q++ = -((c >> 6) & 1);
                *q++ = -((c >> 5) & 1);
                *q++ = -((c >> 4) & 1);
                *q++ = -((c >> 3) & 1);
                *q++ = -((c >> 2) & 1);
                *q++ = -((c >> 1) & 1);
                *q++ = -(c & 1);
        }
}

static void Blit_Expand_2_To_16(uint8 * dest, const uint8 * p, uint32 length)
{
        uint16 *q = (uint16 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = ExpandMap[c >> 6];
                *q++ = ExpandMap[c >> 4];
                *q++ = ExpandMap[c >> 2];
                *q++ = ExpandMap[c];
        }
}

static void Blit_Expand_4_To_16(uint8 * dest, const uint8 * p, uint32 length)
{
        uint16 *q = (uint16 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = ExpandMap[c >> 4];
                *q++ = ExpandMap[c];
        }
}

static void Blit_Expand_8_To_16(uint8 * dest, const uint8 * p, uint32 length)
{
        uint16 *q = (uint16 *)dest;
        for (uint32 i=0; i<length; i++)
                *q++ = ExpandMap[*p++];
}

/* -------------------------------------------------------------------------- */
/* --- 1/2/4/8-bit indexed to 32-bit mode color expansion                 --- */
/* -------------------------------------------------------------------------- */

static void Blit_Expand_1_To_32(uint8 * dest, const uint8 * p, uint32 length)
{
        uint32 *q = (uint32 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = -(c >> 7);
                *q++ = -((c >> 6) & 1);
                *q++ = -((c >> 5) & 1);
                *q++ = -((c >> 4) & 1);
                *q++ = -((c >> 3) & 1);
                *q++ = -((c >> 2) & 1);
                *q++ = -((c >> 1) & 1);
                *q++ = -(c & 1);
        }
}

static void Blit_Expand_2_To_32(uint8 * dest, const uint8 * p, uint32 length)
{
        uint32 *q = (uint32 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = ExpandMap[c >> 6];
                *q++ = ExpandMap[c >> 4];
                *q++ = ExpandMap[c >> 2];
                *q++ = ExpandMap[c];
        }
}

static void Blit_Expand_4_To_32(uint8 * dest, const uint8 * p, uint32 length)
{
        uint32 *q = (uint32 *)dest;
        for (uint32 i=0; i<length; i++) {
                uint8 c = *p++;
                *q++ = ExpandMap[c >> 4];
                *q++ = ExpandMap[c];
        }
}

static void Blit_Expand_8_To_32(uint8 * dest, const uint8 * p, uint32 length)
{
        uint32 *q = (uint32 *)dest;
        for (uint32 i=0; i<length; i++)
                *q++ = ExpandMap[*p++];
}

/* -------------------------------------------------------------------------- */
/* --- Blitters to the host frame buffer, or XImage buffer                --- */
/* -------------------------------------------------------------------------- */

// Function used to update the hosst frame buffer (DGA), or an XImage buffer (WIN)
// --> Shall be initialized only through the Screen_blitter_init() function
typedef void (*Screen_blit_func)(uint8 * dest, const uint8 * source, uint32 length);
Screen_blit_func Screen_blit = 0;

// Structure used to match the adequate framebuffer update function
struct Screen_blit_func_info {
        int                                     depth;                  // Screen depth
        uint32                          Rmask;                  // Red mask
        uint32                          Gmask;                  // Green mask
        uint32                          Bmask;                  // Blue mask
        Screen_blit_func        handler_nbo;    // Update function (native byte order)
        Screen_blit_func        handler_obo;    // Update function (opposite byte order)
};

// Table of visual formats supported and their respective handler
static Screen_blit_func_info Screen_blitters[] = {
#ifdef WORDS_BIGENDIAN
        {  1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // NT
        {  8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // OK (NBO)
        { 15, 0x007c00, 0x0003e0, 0x00001f, Blit_Copy_Raw       , Blit_RGB555_OBO       },      // OK (OBO)
        { 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO     , Blit_BGR555_OBO       },      // NT
        { 16, 0x007c00, 0x0003e0, 0x00001f, Blit_Copy_Raw       , Blit_RGB555_OBO       },      // OK (OBO)
        { 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO     , Blit_RGB565_OBO       },      // OK (OBO)
        { 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK (OBO)
        { 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       },      // NT
        { 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw       , Blit_RGB888_OBO       },      // OK
        { 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       }       // OK
#else
        {  1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // NT
        {  8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw       , Blit_Copy_Raw         },      // OK (NBO)
        { 15, 0x007c00, 0x0003e0, 0x00001f, Blit_RGB555_NBO     , Blit_Copy_Raw         },      // OK (NBO)
        { 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO     , Blit_BGR555_OBO       },      // NT
        { 16, 0x007c00, 0x0003e0, 0x00001f, Blit_RGB555_NBO     , Blit_Copy_Raw         },      // OK (NBO)
        { 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO     , Blit_RGB565_OBO       },      // OK (NBO)
        { 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_RGB888_NBO     , Blit_Copy_Raw         },      // OK (NBO)
        { 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       },      // NT
        { 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_RGB888_NBO     , Blit_Copy_Raw         },      // OK (NBO)
        { 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO     , Blit_BGR888_OBO       }       // NT
#endif
};

// Initialize the framebuffer update function
// Returns FALSE, if the function was to be reduced to a simple memcpy()
// --> In that case, VOSF is not necessary
bool Screen_blitter_init(VisualFormat const & visual_format, bool native_byte_order, int mac_depth)
{
#if USE_SDL_VIDEO
        const bool use_sdl_video = true;
#else
        const bool use_sdl_video = false;
#endif
#if REAL_ADDRESSING || DIRECT_ADDRESSING
        if (mac_depth == 1 && !use_sdl_video && !visual_format.fullscreen) {

                // Windowed 1-bit mode uses a 1-bit X image, so there's no need for special blitting routines
                Screen_blit = Blit_Copy_Raw;

        } else {

                // Compute RGB shift values
                visualFormat = visual_format;
                visualFormat.Rshift = 0;
                for (uint32 Rmask = visualFormat.Rmask; Rmask && ((Rmask & 1) != 1); Rmask >>= 1)
                        ++visualFormat.Rshift;
                visualFormat.Gshift = 0;
                for (uint32 Gmask = visualFormat.Gmask; Gmask && ((Gmask & 1) != 1); Gmask >>= 1)
                        ++visualFormat.Gshift;
                visualFormat.Bshift = 0;
                for (uint32 Bmask = visualFormat.Bmask; Bmask && ((Bmask & 1) != 1); Bmask >>= 1)
                        ++visualFormat.Bshift;

                // 1/2/4/8-bit mode on 8/16/32-bit screen?
                Screen_blit = NULL;
                switch (visualFormat.depth) {
                case 8:
                        switch (mac_depth) {
                        case 1: Screen_blit = Blit_Expand_1_To_8; break;
                        case 2: Screen_blit = Blit_Expand_2_To_8; break;
                        case 4: Screen_blit = Blit_Expand_4_To_8; break;
                        }
                        break;
                case 15:
                case 16:
                        switch (mac_depth) {
                        case 1: Screen_blit = Blit_Expand_1_To_16; break;
                        case 2: Screen_blit = Blit_Expand_2_To_16; break;
                        case 4: Screen_blit = Blit_Expand_4_To_16; break;
                        case 8: Screen_blit = Blit_Expand_8_To_16; break;
                        }
                        break;
                case 24:
                case 32:
                        switch (mac_depth) {
                        case 1: Screen_blit = Blit_Expand_1_To_32; break;
                        case 2: Screen_blit = Blit_Expand_2_To_32; break;
                        case 4: Screen_blit = Blit_Expand_4_To_32; break;
                        case 8: Screen_blit = Blit_Expand_8_To_32; break;
                        }
                        break;
                }
                bool blitter_found = (Screen_blit != NULL);
        
                // Search for an adequate blit function
                const int blitters_count = sizeof(Screen_blitters)/sizeof(Screen_blitters[0]);
                for (int i = 0; !blitter_found && (i < blitters_count); i++) {
                        if      (       (visualFormat.depth == Screen_blitters[i].depth)
                                &&      (visualFormat.Rmask == Screen_blitters[i].Rmask)
                                &&      (visualFormat.Gmask == Screen_blitters[i].Gmask)
                                &&      (visualFormat.Bmask == Screen_blitters[i].Bmask)
                                )
                        {
                                blitter_found = true;
                                Screen_blit = native_byte_order
                                                        ? Screen_blitters[i].handler_nbo
                                                        : Screen_blitters[i].handler_obo
                                                        ;
                        }
                }
        
                // No appropriate blitter found, dump RGB mask values and abort()
                if (!blitter_found) {
                        fprintf(stderr, "### No appropriate blitter found\n");
                        fprintf(stderr, "\tR/G/B mask values  : 0x%06x, 0x%06x, 0x%06x (depth = %d)\n",
                                visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask, visualFormat.depth);
                        fprintf(stderr, "\tR/G/B shift values : %d/%d/%d\n",
                                visualFormat.Rshift, visualFormat.Gshift, visualFormat.Bshift);
                        abort();
                }
        }
#else
        // The UAE memory handlers will blit correctly
        // --> no need for specialised blitters here
        Screen_blit = Blit_Copy_Raw;
#endif
        
        // If the blitter simply reduces to a copy, we don't need VOSF in DGA mode
        // --> In that case, we return FALSE
        return (Screen_blit != Blit_Copy_Raw);
}
Revision:	1.17
Committed:	2005-03-28T16:14:25Z (19 years, 1 month ago) by gbeauche
Branch:	MAIN
Changes since 1.16:	+38 -4 lines
Log Message:	Enable multiple depths in fullscreen DGA modes, i.e. add 1-bit to 16/32-bit blitters, rewrite update_display_dga_vosf() to actually work with sub byte pixels. Factor out update_display_window_vosf() since it's long time that it is no longer checking for first column and last column that have changed.
#	Content
1	/*
2	* video_blit.cpp - Video/graphics emulation, blitters
3	*
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
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#include "sysdeps.h"
22	#include "video.h"
23	#include "video_blit.h"
24
25	#include <stdio.h>
26	#include <stdlib.h>
27
28	// Format of the target visual
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	/* -------------------------------------------------------------------------- */
40
41	static void Blit_Copy_Raw(uint8 * dest, const uint8 * source, uint32 length)
42	{
43	// This function is likely to be inlined and/or highly optimized
44	memcpy(dest, source, length);
45	}
46
47	/* -------------------------------------------------------------------------- */
48	/* --- RGB 555 --- */
49	/* -------------------------------------------------------------------------- */
50
51	#ifdef WORDS_BIGENDIAN
52	# define FB_FUNC_NAME Blit_RGB555_OBO
53	#else
54	# define FB_FUNC_NAME Blit_RGB555_NBO
55	#endif
56
57	#define FB_BLIT_1(dst, src) \
58	(dst = (((src) >> 8) & 0xff) \| (((src) & 0xff) << 8))
59
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
70	/* -------------------------------------------------------------------------- */
71	/* --- BGR 555 --- */
72	/* -------------------------------------------------------------------------- */
73
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 --- */
152	/* -------------------------------------------------------------------------- */
153
154	#ifdef WORDS_BIGENDIAN
155
156	// Native byte order
157
158	#define FB_BLIT_1(dst, src) \
159	(dst = (((src) & 0x1f) \| (((src) << 1) & 0xffc0)))
160
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"
171
172	// Opposite byte order
173
174	#define FB_BLIT_1(dst, src) \
175	(dst = ((((src) >> 7) & 0xff) \| (((src) << 9) & 0xc000) \| (((src) << 8) & 0x1f00)))
176
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"
188
189	#else
190
191	// Native byte order
192
193	#define FB_BLIT_1(dst, src) \
194	(dst = (((src) >> 8) & 0x001f) \| (((src) << 9) & 0xfe00) \| (((src) >> 7) & 0x01c0))
195
196	#define FB_BLIT_2(dst, src) \
197	(dst = (((src) >> 8) & 0x001f001f) \| (((src) << 9) & 0xfe00fe00) \| (((src) >> 7) & 0x01c001c0))
198
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
206	#include "video_blit.h"
207
208	// Opposite byte order (untested)
209
210	#define FB_BLIT_1(dst, src) \
211	(dst = (((src) & 0x1f00) \| (((src) << 1) & 0xe0fe) \| (((src) >> 15) & 1)))
212
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"
224
225	#endif
226
227	/* -------------------------------------------------------------------------- */
228	/* --- RGB 888 --- */
229	/* -------------------------------------------------------------------------- */
230
231	#ifdef WORDS_BIGENDIAN
232	# define FB_FUNC_NAME Blit_RGB888_OBO
233	#else
234	# define FB_FUNC_NAME Blit_RGB888_NBO
235	#endif
236
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
249	/* -------------------------------------------------------------------------- */
250	/* --- BGR 888 --- */
251	/* -------------------------------------------------------------------------- */
252
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 [BE] (untested) / Native byte order [LE] (untested)
288
289	#ifdef WORDS_BIGENDIAN
290	# define FB_FUNC_NAME Blit_BGR888_OBO
291	#else
292	# define FB_FUNC_NAME Blit_BGR888_NBO
293	#endif
294
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	/* --- 1/2/4/8-bit indexed to 16-bit mode color expansion --- */
348	/* -------------------------------------------------------------------------- */
349
350	static void Blit_Expand_1_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++ = -(c >> 7);
356	*q++ = -((c >> 6) & 1);
357	*q++ = -((c >> 5) & 1);
358	*q++ = -((c >> 4) & 1);
359	*q++ = -((c >> 3) & 1);
360	*q++ = -((c >> 2) & 1);
361	*q++ = -((c >> 1) & 1);
362	*q++ = -(c & 1);
363	}
364	}
365
366	static void Blit_Expand_2_To_16(uint8 * dest, const uint8 * p, uint32 length)
367	{
368	uint16 q = (uint16 )dest;
369	for (uint32 i=0; i<length; i++) {
370	uint8 c = *p++;
371	*q++ = ExpandMap[c >> 6];
372	*q++ = ExpandMap[c >> 4];
373	*q++ = ExpandMap[c >> 2];
374	*q++ = ExpandMap[c];
375	}
376	}
377
378	static void Blit_Expand_4_To_16(uint8 * dest, const uint8 * p, uint32 length)
379	{
380	uint16 q = (uint16 )dest;
381	for (uint32 i=0; i<length; i++) {
382	uint8 c = *p++;
383	*q++ = ExpandMap[c >> 4];
384	*q++ = ExpandMap[c];
385	}
386	}
387
388	static void Blit_Expand_8_To_16(uint8 * dest, const uint8 * p, uint32 length)
389	{
390	uint16 q = (uint16 )dest;
391	for (uint32 i=0; i<length; i++)
392	q++ = ExpandMap[p++];
393	}
394
395	/* -------------------------------------------------------------------------- */
396	/* --- 1/2/4/8-bit indexed to 32-bit mode color expansion --- */
397	/* -------------------------------------------------------------------------- */
398
399	static void Blit_Expand_1_To_32(uint8 * dest, const uint8 * p, uint32 length)
400	{
401	uint32 q = (uint32 )dest;
402	for (uint32 i=0; i<length; i++) {
403	uint8 c = *p++;
404	*q++ = -(c >> 7);
405	*q++ = -((c >> 6) & 1);
406	*q++ = -((c >> 5) & 1);
407	*q++ = -((c >> 4) & 1);
408	*q++ = -((c >> 3) & 1);
409	*q++ = -((c >> 2) & 1);
410	*q++ = -((c >> 1) & 1);
411	*q++ = -(c & 1);
412	}
413	}
414
415	static void Blit_Expand_2_To_32(uint8 * dest, const uint8 * p, uint32 length)
416	{
417	uint32 q = (uint32 )dest;
418	for (uint32 i=0; i<length; i++) {
419	uint8 c = *p++;
420	*q++ = ExpandMap[c >> 6];
421	*q++ = ExpandMap[c >> 4];
422	*q++ = ExpandMap[c >> 2];
423	*q++ = ExpandMap[c];
424	}
425	}
426
427	static void Blit_Expand_4_To_32(uint8 * dest, const uint8 * p, uint32 length)
428	{
429	uint32 q = (uint32 )dest;
430	for (uint32 i=0; i<length; i++) {
431	uint8 c = *p++;
432	*q++ = ExpandMap[c >> 4];
433	*q++ = ExpandMap[c];
434	}
435	}
436
437	static void Blit_Expand_8_To_32(uint8 * dest, const uint8 * p, uint32 length)
438	{
439	uint32 q = (uint32 )dest;
440	for (uint32 i=0; i<length; i++)
441	q++ = ExpandMap[p++];
442	}
443
444	/* -------------------------------------------------------------------------- */
445	/* --- Blitters to the host frame buffer, or XImage buffer --- */
446	/* -------------------------------------------------------------------------- */
447
448	// Function used to update the hosst frame buffer (DGA), or an XImage buffer (WIN)
449	// --> Shall be initialized only through the Screen_blitter_init() function
450	typedef void (Screen_blit_func)(uint8 dest, const uint8 * source, uint32 length);
451	Screen_blit_func Screen_blit = 0;
452
453	// Structure used to match the adequate framebuffer update function
454	struct Screen_blit_func_info {
455	int depth; // Screen depth
456	uint32 Rmask; // Red mask
457	uint32 Gmask; // Green mask
458	uint32 Bmask; // Blue mask
459	Screen_blit_func handler_nbo; // Update function (native byte order)
460	Screen_blit_func handler_obo; // Update function (opposite byte order)
461	};
462
463	// Table of visual formats supported and their respective handler
464	static Screen_blit_func_info Screen_blitters[] = {
465	#ifdef WORDS_BIGENDIAN
466	{ 1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw , Blit_Copy_Raw }, // NT
467	{ 8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw , Blit_Copy_Raw }, // OK (NBO)
468	{ 15, 0x007c00, 0x0003e0, 0x00001f, Blit_Copy_Raw , Blit_RGB555_OBO }, // OK (OBO)
469	{ 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO , Blit_BGR555_OBO }, // NT
470	{ 16, 0x007c00, 0x0003e0, 0x00001f, Blit_Copy_Raw , Blit_RGB555_OBO }, // OK (OBO)
471	{ 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO , Blit_RGB565_OBO }, // OK (OBO)
472	{ 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw , Blit_RGB888_OBO }, // OK (OBO)
473	{ 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO , Blit_BGR888_OBO }, // NT
474	{ 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_Copy_Raw , Blit_RGB888_OBO }, // OK
475	{ 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO , Blit_BGR888_OBO } // OK
476	#else
477	{ 1, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw , Blit_Copy_Raw }, // NT
478	{ 8, 0x000000, 0x000000, 0x000000, Blit_Copy_Raw , Blit_Copy_Raw }, // OK (NBO)
479	{ 15, 0x007c00, 0x0003e0, 0x00001f, Blit_RGB555_NBO , Blit_Copy_Raw }, // OK (NBO)
480	{ 15, 0x00001f, 0x0003e0, 0x007c00, Blit_BGR555_NBO , Blit_BGR555_OBO }, // NT
481	{ 16, 0x007c00, 0x0003e0, 0x00001f, Blit_RGB555_NBO , Blit_Copy_Raw }, // OK (NBO)
482	{ 16, 0x00f800, 0x0007e0, 0x00001f, Blit_RGB565_NBO , Blit_RGB565_OBO }, // OK (NBO)
483	{ 24, 0xff0000, 0x00ff00, 0x0000ff, Blit_RGB888_NBO , Blit_Copy_Raw }, // OK (NBO)
484	{ 24, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO , Blit_BGR888_OBO }, // NT
485	{ 32, 0xff0000, 0x00ff00, 0x0000ff, Blit_RGB888_NBO , Blit_Copy_Raw }, // OK (NBO)
486	{ 32, 0x0000ff, 0x00ff00, 0xff0000, Blit_BGR888_NBO , Blit_BGR888_OBO } // NT
487	#endif
488	};
489
490	// Initialize the framebuffer update function
491	// Returns FALSE, if the function was to be reduced to a simple memcpy()
492	// --> In that case, VOSF is not necessary
493	bool Screen_blitter_init(VisualFormat const & visual_format, bool native_byte_order, int mac_depth)
494	{
495	#if USE_SDL_VIDEO
496	const bool use_sdl_video = true;
497	#else
498	const bool use_sdl_video = false;
499	#endif
500	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
501	if (mac_depth == 1 && !use_sdl_video && !visual_format.fullscreen) {
502
503	// Windowed 1-bit mode uses a 1-bit X image, so there's no need for special blitting routines
504	Screen_blit = Blit_Copy_Raw;
505
506	} else {
507
508	// Compute RGB shift values
509	visualFormat = visual_format;
510	visualFormat.Rshift = 0;
511	for (uint32 Rmask = visualFormat.Rmask; Rmask && ((Rmask & 1) != 1); Rmask >>= 1)
512	++visualFormat.Rshift;
513	visualFormat.Gshift = 0;
514	for (uint32 Gmask = visualFormat.Gmask; Gmask && ((Gmask & 1) != 1); Gmask >>= 1)
515	++visualFormat.Gshift;
516	visualFormat.Bshift = 0;
517	for (uint32 Bmask = visualFormat.Bmask; Bmask && ((Bmask & 1) != 1); Bmask >>= 1)
518	++visualFormat.Bshift;
519
520	// 1/2/4/8-bit mode on 8/16/32-bit screen?
521	Screen_blit = NULL;
522	switch (visualFormat.depth) {
523	case 8:
524	switch (mac_depth) {
525	case 1: Screen_blit = Blit_Expand_1_To_8; break;
526	case 2: Screen_blit = Blit_Expand_2_To_8; break;
527	case 4: Screen_blit = Blit_Expand_4_To_8; break;
528	}
529	break;
530	case 15:
531	case 16:
532	switch (mac_depth) {
533	case 1: Screen_blit = Blit_Expand_1_To_16; break;
534	case 2: Screen_blit = Blit_Expand_2_To_16; break;
535	case 4: Screen_blit = Blit_Expand_4_To_16; break;
536	case 8: Screen_blit = Blit_Expand_8_To_16; break;
537	}
538	break;
539	case 24:
540	case 32:
541	switch (mac_depth) {
542	case 1: Screen_blit = Blit_Expand_1_To_32; break;
543	case 2: Screen_blit = Blit_Expand_2_To_32; break;
544	case 4: Screen_blit = Blit_Expand_4_To_32; break;
545	case 8: Screen_blit = Blit_Expand_8_To_32; break;
546	}
547	break;
548	}
549	bool blitter_found = (Screen_blit != NULL);
550
551	// Search for an adequate blit function
552	const int blitters_count = sizeof(Screen_blitters)/sizeof(Screen_blitters[0]);
553	for (int i = 0; !blitter_found && (i < blitters_count); i++) {
554	if ( (visualFormat.depth == Screen_blitters[i].depth)
555	&& (visualFormat.Rmask == Screen_blitters[i].Rmask)
556	&& (visualFormat.Gmask == Screen_blitters[i].Gmask)
557	&& (visualFormat.Bmask == Screen_blitters[i].Bmask)
558	)
559	{
560	blitter_found = true;
561	Screen_blit = native_byte_order
562	? Screen_blitters[i].handler_nbo
563	: Screen_blitters[i].handler_obo
564	;
565	}
566	}
567
568	// No appropriate blitter found, dump RGB mask values and abort()
569	if (!blitter_found) {
570	fprintf(stderr, "### No appropriate blitter found\n");
571	fprintf(stderr, "\tR/G/B mask values : 0x%06x, 0x%06x, 0x%06x (depth = %d)\n",
572	visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask, visualFormat.depth);
573	fprintf(stderr, "\tR/G/B shift values : %d/%d/%d\n",
574	visualFormat.Rshift, visualFormat.Gshift, visualFormat.Bshift);
575	abort();
576	}
577	}
578	#else
579	// The UAE memory handlers will blit correctly
580	// --> no need for specialised blitters here
581	Screen_blit = Blit_Copy_Raw;
582	#endif
583
584	// If the blitter simply reduces to a copy, we don't need VOSF in DGA mode
585	// --> In that case, we return FALSE
586	return (Screen_blit != Blit_Copy_Raw);
587	}