Mercurial > sdl-ios-xcode

view src/video/ataricommon/SDL_atarigl.c @ 3846:66fb40445587 SDL-ryan-multiple-audio-device

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Removed distinction between "available" and "init" in audio backends, since both had to be checked for success as a pair at the higher level and several of the Available methods were just always-succeed placeholders anyhow. Now the availability check is done in the init code, and the higher level tries all possible drivers until one manages to initialize successfully.
author Ryan C. Gordon <icculus@icculus.org>
date Tue, 17 Oct 2006 09:09:21 +0000
parents adf732f1f016
children e1da92da346c
line wrap: on
line source

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2004 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/* Atari OSMesa.ldg implementation of SDL OpenGL support */

/*--- Includes ---*/

#if SDL_VIDEO_OPENGL
#include <GL/osmesa.h>
#endif

#include <mint/osbind.h>

#include "SDL_endian.h"
#include "SDL_video.h"
#include "SDL_atarigl_c.h"
#if SDL_VIDEO_OPENGL_OSMESA_DYNAMIC
#include "SDL_loadso.h"
#endif

/*--- Defines ---*/

#define PATH_OSMESA_LDG	"osmesa.ldg"
#define PATH_MESAGL_LDG	"mesa_gl.ldg"
#define PATH_TINYGL_LDG	"tiny_gl.ldg"

#define VDI_RGB	0xf

/*--- Functions prototypes ---*/

static void SDL_AtariGL_UnloadLibrary(_THIS);

#if SDL_VIDEO_OPENGL
static void CopyShadowNull(_THIS, SDL_Surface * surface);
static void CopyShadowDirect(_THIS, SDL_Surface * surface);
static void CopyShadowRGBTo555(_THIS, SDL_Surface * surface);
static void CopyShadowRGBTo565(_THIS, SDL_Surface * surface);
static void CopyShadowRGBSwap(_THIS, SDL_Surface * surface);
static void CopyShadowRGBToARGB(_THIS, SDL_Surface * surface);
static void CopyShadowRGBToABGR(_THIS, SDL_Surface * surface);
static void CopyShadowRGBToBGRA(_THIS, SDL_Surface * surface);
static void CopyShadowRGBToRGBA(_THIS, SDL_Surface * surface);
static void CopyShadow8888To555(_THIS, SDL_Surface * surface);
static void CopyShadow8888To565(_THIS, SDL_Surface * surface);

static void ConvertNull(_THIS, SDL_Surface * surface);
static void Convert565To555be(_THIS, SDL_Surface * surface);
static void Convert565To555le(_THIS, SDL_Surface * surface);
static void Convert565le(_THIS, SDL_Surface * surface);
static void ConvertBGRAToABGR(_THIS, SDL_Surface * surface);

static int InitNew(_THIS, SDL_Surface * current);
static int InitOld(_THIS, SDL_Surface * current);
#endif

/*--- Public functions ---*/

int
SDL_AtariGL_Init(_THIS, SDL_Surface * current)
{
#if SDL_VIDEO_OPENGL
    if (gl_oldmesa) {
        gl_active = InitOld(_this, current);
    } else {
        gl_active = InitNew(_this, current);
    }
#endif

    return (gl_active);
}

void
SDL_AtariGL_Quit(_THIS, SDL_bool unload)
{
#if SDL_VIDEO_OPENGL
    if (gl_oldmesa) {
        /* Old mesa implementations */
        if (_this->gl_data->OSMesaDestroyLDG) {
            _this->gl_data->OSMesaDestroyLDG();
        }
        if (gl_shadow) {
            Mfree(gl_shadow);
            gl_shadow = NULL;
        }
    } else {
        /* New mesa implementation */
        if (gl_ctx) {
            if (_this->gl_data->OSMesaDestroyContext) {
                _this->gl_data->OSMesaDestroyContext(gl_ctx);
            }
            gl_ctx = NULL;
        }
    }

    if (unload) {
        SDL_AtariGL_UnloadLibrary(_this);
    }
#endif /* SDL_VIDEO_OPENGL */
    gl_active = 0;
}

int
SDL_AtariGL_LoadLibrary(_THIS, const char *path)
{
#if SDL_VIDEO_OPENGL

#if SDL_VIDEO_OPENGL_OSMESA_DYNAMIC
    void *handle;
    SDL_bool cancel_load;

    if (gl_active) {
        SDL_SetError("OpenGL context already created");
        return -1;
    }

    /* Unload previous driver */
    SDL_AtariGL_UnloadLibrary(_this);

    /* Load library given by path */
    handle = SDL_LoadObject(path);
    if (handle == NULL) {
        /* Try to load another one */
        path = SDL_getenv("SDL_VIDEO_GL_DRIVER");
        if (path != NULL) {
            handle = SDL_LoadObject(path);
        }

        /* If it does not work, try some other */
        if (handle == NULL) {
            path = PATH_OSMESA_LDG;
            handle = SDL_LoadObject(path);
        }

        if (handle == NULL) {
            path = PATH_MESAGL_LDG;
            handle = SDL_LoadObject(path);
        }

        if (handle == NULL) {
            path = PATH_TINYGL_LDG;
            handle = SDL_LoadObject(path);
        }
    }

    if (handle == NULL) {
        SDL_SetError("Could not load OpenGL library");
        return -1;
    }

    _this->gl_data->glGetIntegerv = SDL_LoadFunction(handle, "glGetIntegerv");
    _this->gl_data->glFinish = SDL_LoadFunction(handle, "glFinish");
    _this->gl_data->glFlush = SDL_LoadFunction(handle, "glFlush");

    cancel_load = SDL_FALSE;
    if (_this->gl_data->glGetIntegerv == NULL) {
        cancel_load = SDL_TRUE;
    } else {
        /* We need either glFinish (OSMesa) or glFlush (TinyGL) */
        if ((_this->gl_data->glFinish == NULL) &&
            (_this->gl_data->glFlush == NULL)) {
            cancel_load = SDL_TRUE;
        }
    }
    if (cancel_load) {
        SDL_SetError("Could not retrieve OpenGL functions");
        SDL_UnloadObject(handle);
        /* Restore pointers to static library */
        SDL_AtariGL_InitPointers(this);
        return -1;
    }

    /* Load functions pointers (osmesa.ldg) */
    _this->gl_data->OSMesaCreateContextExt =
        SDL_LoadFunction(handle, "OSMesaCreateContextExt");
    _this->gl_data->OSMesaDestroyContext =
        SDL_LoadFunction(handle, "OSMesaDestroyContext");
    _this->gl_data->OSMesaMakeCurrent =
        SDL_LoadFunction(handle, "OSMesaMakeCurrent");
    _this->gl_data->OSMesaPixelStore =
        SDL_LoadFunction(handle, "OSMesaPixelStore");
    _this->gl_data->OSMesaGetProcAddress =
        SDL_LoadFunction(handle, "OSMesaGetProcAddress");

    /* Load old functions pointers (mesa_gl.ldg, tiny_gl.ldg) */
    _this->gl_data->OSMesaCreateLDG =
        SDL_LoadFunction(handle, "OSMesaCreateLDG");
    _this->gl_data->OSMesaDestroyLDG =
        SDL_LoadFunction(handle, "OSMesaDestroyLDG");

    gl_oldmesa = 0;

    if ((_this->gl_data->OSMesaCreateContextExt == NULL) ||
        (_this->gl_data->OSMesaDestroyContext == NULL) ||
        (_this->gl_data->OSMesaMakeCurrent == NULL) ||
        (_this->gl_data->OSMesaPixelStore == NULL) ||
        (_this->gl_data->OSMesaGetProcAddress == NULL)) {
        /* Hum, maybe old library ? */
        if ((_this->gl_data->OSMesaCreateLDG == NULL) ||
            (_this->gl_data->OSMesaDestroyLDG == NULL)) {
            SDL_SetError("Could not retrieve OSMesa functions");
            SDL_UnloadObject(handle);
            /* Restore pointers to static library */
            SDL_AtariGL_InitPointers(_this);
            return -1;
        } else {
            gl_oldmesa = 1;
        }
    }

    _this->gl_config.dll_handle = handle;
    if (path) {
        SDL_strlcpy(_this->gl_config.driver_path, path,
                    SDL_arraysize(_this->gl_config.driver_path));
    } else {
        *this->gl_config.driver_path = '\0';
    }

#endif
    _this->gl_config.driver_loaded = 1;

    return 0;
#else
    return -1;
#endif
}

void *
SDL_AtariGL_GetProcAddress(_THIS, const char *proc)
{
    void *func = NULL;
#if SDL_VIDEO_OPENGL

    if (_this->gl_config.dll_handle) {
        func = SDL_LoadFunction(this->gl_config.dll_handle, (void *) proc);
    } else if (_this->gl_data->OSMesaGetProcAddress) {
        func = _this->gl_data->OSMesaGetProcAddress(proc);
    }
#endif
    return func;
}

int
SDL_AtariGL_GetAttribute(_THIS, SDL_GLattr attrib, int *value)
{
#if SDL_VIDEO_OPENGL
    GLenum mesa_attrib;
    SDL_Surface *surface;

    if (!gl_active) {
        return -1;
    }

    switch (attrib) {
    case SDL_GL_RED_SIZE:
        mesa_attrib = GL_RED_BITS;
        break;
    case SDL_GL_GREEN_SIZE:
        mesa_attrib = GL_GREEN_BITS;
        break;
    case SDL_GL_BLUE_SIZE:
        mesa_attrib = GL_BLUE_BITS;
        break;
    case SDL_GL_ALPHA_SIZE:
        mesa_attrib = GL_ALPHA_BITS;
        break;
    case SDL_GL_DOUBLEBUFFER:
        surface = _this->screen;
        *value = ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF);
        return 0;
    case SDL_GL_DEPTH_SIZE:
        mesa_attrib = GL_DEPTH_BITS;
        break;
    case SDL_GL_STENCIL_SIZE:
        mesa_attrib = GL_STENCIL_BITS;
        break;
    case SDL_GL_ACCUM_RED_SIZE:
        mesa_attrib = GL_ACCUM_RED_BITS;
        break;
    case SDL_GL_ACCUM_GREEN_SIZE:
        mesa_attrib = GL_ACCUM_GREEN_BITS;
        break;
    case SDL_GL_ACCUM_BLUE_SIZE:
        mesa_attrib = GL_ACCUM_BLUE_BITS;
        break;
    case SDL_GL_ACCUM_ALPHA_SIZE:
        mesa_attrib = GL_ACCUM_ALPHA_BITS;
        break;
    default:
        return -1;
    }

    _this->gl_data->glGetIntegerv(mesa_attrib, value);
    return 0;
#else
    return -1;
#endif
}

int
SDL_AtariGL_MakeCurrent(_THIS)
{
#if SDL_VIDEO_OPENGL
    SDL_Surface *surface;
    GLenum type;

    if (gl_oldmesa && gl_active) {
        return 0;
    }

    if (_this->gl_config.dll_handle) {
        if ((_this->gl_data->OSMesaMakeCurrent == NULL) ||
            (_this->gl_data->OSMesaPixelStore == NULL)) {
            return -1;
        }
    }

    if (!gl_active) {
        SDL_SetError("Invalid OpenGL context");
        return -1;
    }

    surface = _this->screen;

    if ((surface->format->BitsPerPixel == 15)
        || (surface->format->BitsPerPixel == 16)) {
        type = GL_UNSIGNED_SHORT_5_6_5;
    } else {
        type = GL_UNSIGNED_BYTE;
    }

    if (!
        (_this->gl_data->
         OSMesaMakeCurrent(gl_ctx, surface->pixels, type, surface->w,
                           surface->h))) {
        SDL_SetError("Can not make OpenGL context current");
        return -1;
    }

    /* OSMesa draws upside down */
    _this->gl_data->OSMesaPixelStore(OSMESA_Y_UP, 0);

    return 0;
#else
    return -1;
#endif
}

void
SDL_AtariGL_SwapBuffers(_THIS)
{
#if SDL_VIDEO_OPENGL
    if (gl_active) {
        if (_this->gl_config.dll_handle) {
            if (_this->gl_data->glFinish) {
                _this->gl_data->glFinish();
            } else if (_this->gl_data->glFlush) {
                _this->gl_data->glFlush();
            }
        } else {
            _this->gl_data->glFinish();
        }
        gl_copyshadow(_this, _this->screen);
        gl_convert(_this, _this->screen);
    }
#endif
}

void
SDL_AtariGL_InitPointers(_THIS)
{
#if SDL_VIDEO_OPENGL
    _this->gl_data->OSMesaCreateContextExt = OSMesaCreateContextExt;
    _this->gl_data->OSMesaDestroyContext = OSMesaDestroyContext;
    _this->gl_data->OSMesaMakeCurrent = OSMesaMakeCurrent;
    _this->gl_data->OSMesaPixelStore = OSMesaPixelStore;
    _this->gl_data->OSMesaGetProcAddress = OSMesaGetProcAddress;

    _this->gl_data->glGetIntegerv = glGetIntegerv;
    _this->gl_data->glFinish = glFinish;
    _this->gl_data->glFlush = glFlush;

    _this->gl_data->OSMesaCreateLDG = NULL;
    _this->gl_data->OSMesaDestroyLDG = NULL;
#endif
}

/*--- Private functions ---*/

static void
SDL_AtariGL_UnloadLibrary(_THIS)
{
#if SDL_VIDEO_OPENGL
    if (_this->gl_config.dll_handle) {
        SDL_UnloadObject(_this->gl_config.dll_handle);
        _this->gl_config.dll_handle = NULL;

        /* Restore pointers to static library */
        SDL_AtariGL_InitPointers(_this);
    }
#endif
}

/*--- Creation of an OpenGL context using new/old functions ---*/

#if SDL_VIDEO_OPENGL
static int
InitNew(_THIS, SDL_Surface * current)
{
    GLenum osmesa_format;
    SDL_PixelFormat *pixel_format;
    Uint32 redmask;
    int recreatecontext;
    GLint newaccumsize;

    if (_this->gl_config.dll_handle) {
        if (_this->gl_data->OSMesaCreateContextExt == NULL) {
            return 0;
        }
    }

    /* Init OpenGL context using OSMesa */
    gl_convert = ConvertNull;
    gl_copyshadow = CopyShadowNull;
    gl_upsidedown = SDL_FALSE;

    pixel_format = current->format;
    redmask = pixel_format->Rmask;
    switch (pixel_format->BitsPerPixel) {
    case 15:
        /* 1555, big and little endian, unsupported */
        gl_pixelsize = 2;
        osmesa_format = OSMESA_RGB_565;
        if (redmask == 31 << 10) {
            gl_convert = Convert565To555be;
        } else {
            gl_convert = Convert565To555le;
        }
        break;
    case 16:
        gl_pixelsize = 2;
        if (redmask == 31 << 11) {
            osmesa_format = OSMESA_RGB_565;
        } else {
            /* 565, little endian, unsupported */
            osmesa_format = OSMESA_RGB_565;
            gl_convert = Convert565le;
        }
        break;
    case 24:
        gl_pixelsize = 3;
        if (redmask == 255 << 16) {
            osmesa_format = OSMESA_RGB;
        } else {
            osmesa_format = OSMESA_BGR;
        }
        break;
    case 32:
        gl_pixelsize = 4;
        if (redmask == 255 << 16) {
            osmesa_format = OSMESA_ARGB;
        } else if (redmask == 255 << 8) {
            osmesa_format = OSMESA_BGRA;
        } else if (redmask == 255 << 24) {
            osmesa_format = OSMESA_RGBA;
        } else {
            /* ABGR format unsupported */
            osmesa_format = OSMESA_BGRA;
            gl_convert = ConvertBGRAToABGR;
        }
        break;
    default:
        gl_pixelsize = 1;
        osmesa_format = OSMESA_COLOR_INDEX;
        break;
    }

    /* Try to keep current context if possible */
    newaccumsize =
        _this->gl_config.accum_red_size +
        _this->gl_config.accum_green_size +
        _this->gl_config.accum_blue_size + _this->gl_config.accum_alpha_size;
    recreatecontext = 1;
    if (gl_ctx &&
        (gl_curformat == osmesa_format) &&
        (gl_curdepth == _this->gl_config.depth_size) &&
        (gl_curstencil == _this->gl_config.stencil_size) &&
        (gl_curaccum == newaccumsize)) {
        recreatecontext = 0;
    }
    if (recreatecontext) {
        SDL_AtariGL_Quit(this, SDL_FALSE);

        gl_ctx =
            _this->gl_data->OSMesaCreateContextExt(osmesa_format,
                                                   _this->gl_config.
                                                   depth_size,
                                                   _this->gl_config.
                                                   stencil_size,
                                                   newaccumsize, NULL);

        if (gl_ctx) {
            gl_curformat = osmesa_format;
            gl_curdepth = _this->gl_config.depth_size;
            gl_curstencil = _this->gl_config.stencil_size;
            gl_curaccum = newaccumsize;
        } else {
            gl_curformat = 0;
            gl_curdepth = 0;
            gl_curstencil = 0;
            gl_curaccum = 0;
        }
    }

    return (gl_ctx != NULL);
}


static int
InitOld(_THIS, SDL_Surface * current)
{
    GLenum osmesa_format;
    SDL_PixelFormat *pixel_format;
    Uint32 redmask;
    int recreatecontext, tinygl_present;

    if (_this->gl_config.dll_handle) {
        if (_this->gl_data->OSMesaCreateLDG == NULL) {
            return 0;
        }
    }

    /* TinyGL only supports VDI_RGB (OSMESA_RGB) */
    tinygl_present = 0;
    if (_this->gl_config.dll_handle) {
        if (_this->gl_data->glFinish == NULL) {
            tinygl_present = 1;
        }
    }

    /* Init OpenGL context using OSMesa */
    gl_convert = ConvertNull;
    gl_copyshadow = CopyShadowNull;
    gl_upsidedown = SDL_FALSE;

    pixel_format = current->format;
    redmask = pixel_format->Rmask;
    switch (pixel_format->BitsPerPixel) {
    case 15:
        /* 15 bits unsupported */
        if (tinygl_present) {
            gl_pixelsize = 3;
            osmesa_format = VDI_RGB;
            if (redmask == 31 << 10) {
                gl_copyshadow = CopyShadowRGBTo555;
            } else {
                gl_copyshadow = CopyShadowRGBTo565;
                gl_convert = Convert565To555le;
            }
        } else {
            gl_pixelsize = 4;
            gl_upsidedown = SDL_TRUE;
            osmesa_format = OSMESA_ARGB;
            if (redmask == 31 << 10) {
                gl_copyshadow = CopyShadow8888To555;
            } else {
                gl_copyshadow = CopyShadow8888To565;
                gl_convert = Convert565To555le;
            }
        }
        break;
    case 16:
        /* 16 bits unsupported */
        if (tinygl_present) {
            gl_pixelsize = 3;
            osmesa_format = VDI_RGB;
            gl_copyshadow = CopyShadowRGBTo565;
            if (redmask != 31 << 11) {
                /* 565, little endian, unsupported */
                gl_convert = Convert565le;
            }
        } else {
            gl_pixelsize = 4;
            gl_upsidedown = SDL_TRUE;
            osmesa_format = OSMESA_ARGB;
            gl_copyshadow = CopyShadow8888To565;
            if (redmask != 31 << 11) {
                /* 565, little endian, unsupported */
                gl_convert = Convert565le;
            }
        }
        break;
    case 24:
        gl_pixelsize = 3;
        if (tinygl_present) {
            osmesa_format = VDI_RGB;
            gl_copyshadow = CopyShadowDirect;
            if (redmask != 255 << 16) {
                gl_copyshadow = CopyShadowRGBSwap;
            }
        } else {
            gl_copyshadow = CopyShadowDirect;
            gl_upsidedown = SDL_TRUE;
            if (redmask == 255 << 16) {
                osmesa_format = OSMESA_RGB;
            } else {
                osmesa_format = OSMESA_BGR;
            }
        }
        break;
    case 32:
        if (tinygl_present) {
            gl_pixelsize = 3;
            osmesa_format = VDI_RGB;
            gl_copyshadow = CopyShadowRGBToARGB;
            if (redmask == 255) {
                gl_convert = CopyShadowRGBToABGR;
            } else if (redmask == 255 << 8) {
                gl_convert = CopyShadowRGBToBGRA;
            } else if (redmask == 255 << 24) {
                gl_convert = CopyShadowRGBToRGBA;
            }
        } else {
            gl_pixelsize = 4;
            gl_upsidedown = SDL_TRUE;
            gl_copyshadow = CopyShadowDirect;
            if (redmask == 255 << 16) {
                osmesa_format = OSMESA_ARGB;
            } else if (redmask == 255 << 8) {
                osmesa_format = OSMESA_BGRA;
            } else if (redmask == 255 << 24) {
                osmesa_format = OSMESA_RGBA;
            } else {
                /* ABGR format unsupported */
                osmesa_format = OSMESA_BGRA;
                gl_convert = ConvertBGRAToABGR;
            }
        }
        break;
    default:
        if (tinygl_present) {
            SDL_AtariGL_Quit(_this, SDL_FALSE);
            return 0;
        }
        gl_pixelsize = 1;
        gl_copyshadow = CopyShadowDirect;
        osmesa_format = OSMESA_COLOR_INDEX;
        break;
    }

    /* Try to keep current context if possible */
    recreatecontext = 1;
    if (gl_shadow &&
        (gl_curformat == osmesa_format) &&
        (gl_curwidth == current->w) && (gl_curheight == current->h)) {
        recreatecontext = 0;
    }
    if (recreatecontext) {
        SDL_AtariGL_Quit(_this, SDL_FALSE);

        gl_shadow =
            _this->gl_data->OSMesaCreateLDG(osmesa_format, GL_UNSIGNED_BYTE,
                                            current->w, current->h);

        if (gl_shadow) {
            gl_curformat = osmesa_format;
            gl_curwidth = current->w;
            gl_curheight = current->h;
        } else {
            gl_curformat = 0;
            gl_curwidth = 0;
            gl_curheight = 0;
        }
    }

    return (gl_shadow != NULL);
}

/*--- Conversions routines from shadow buffer to the screen ---*/

static void
CopyShadowNull(_THIS, SDL_Surface * surface)
{
}

static void
CopyShadowDirect(_THIS, SDL_Surface * surface)
{
    int y, srcpitch, dstpitch;
    Uint8 *srcline, *dstline;

    srcline = gl_shadow;
    srcpitch = surface->w * gl_pixelsize;
    dstline = surface->pixels;
    dstpitch = surface->pitch;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        SDL_memcpy(dstline, srcline, srcpitch);

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadowRGBTo555(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint16 *dstline, *dstcol;
    Uint8 *srcline, *srccol;

    srcline = (Uint8 *) gl_shadow;
    srcpitch = surface->w * gl_pixelsize;
    dstline = surface->pixels;
    dstpitch = surface->pitch >> 1;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;
        for (x = 0; x < surface->w; x++) {
            Uint16 dstcolor;

            dstcolor = ((*srccol++) << 7) & (31 << 10);
            dstcolor |= ((*srccol++) << 2) & (31 << 5);
            dstcolor |= ((*srccol++) >> 3) & 31;
            *dstcol++ = dstcolor;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadowRGBTo565(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint16 *dstline, *dstcol;
    Uint8 *srcline, *srccol;

    srcline = (Uint8 *) gl_shadow;
    srcpitch = surface->w * gl_pixelsize;
    dstline = surface->pixels;
    dstpitch = surface->pitch >> 1;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;

        for (x = 0; x < surface->w; x++) {
            Uint16 dstcolor;

            dstcolor = ((*srccol++) << 8) & (31 << 11);
            dstcolor |= ((*srccol++) << 3) & (63 << 5);
            dstcolor |= ((*srccol++) >> 3) & 31;
            *dstcol++ = dstcolor;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadowRGBSwap(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint8 *dstline, *dstcol;
    Uint8 *srcline, *srccol;

    srcline = (Uint8 *) gl_shadow;
    srcpitch = surface->w * gl_pixelsize;
    dstline = surface->pixels;
    dstpitch = surface->pitch;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;

        for (x = 0; x < surface->w; x++) {
            *dstcol++ = srccol[2];
            *dstcol++ = srccol[1];
            *dstcol++ = srccol[0];
            srccol += 3;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadowRGBToARGB(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint32 *dstline, *dstcol;
    Uint8 *srcline, *srccol;

    srcline = (Uint8 *) gl_shadow;
    srcpitch = surface->w * gl_pixelsize;
    dstline = surface->pixels;
    dstpitch = surface->pitch >> 2;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;

        for (x = 0; x < surface->w; x++) {
            Uint32 dstcolor;

            dstcolor = (*srccol++) << 16;
            dstcolor |= (*srccol++) << 8;
            dstcolor |= *srccol++;

            *dstcol++ = dstcolor;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadowRGBToABGR(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint32 *dstline, *dstcol;
    Uint8 *srcline, *srccol;

    srcline = (Uint8 *) gl_shadow;
    srcpitch = surface->w * gl_pixelsize;
    dstline = surface->pixels;
    dstpitch = surface->pitch >> 2;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;

        for (x = 0; x < surface->w; x++) {
            Uint32 dstcolor;

            dstcolor = *srccol++;
            dstcolor |= (*srccol++) << 8;
            dstcolor |= (*srccol++) << 16;

            *dstcol++ = dstcolor;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadowRGBToBGRA(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint32 *dstline, *dstcol;
    Uint8 *srcline, *srccol;

    srcline = (Uint8 *) gl_shadow;
    srcpitch = surface->w * gl_pixelsize;
    dstline = surface->pixels;
    dstpitch = surface->pitch >> 2;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;

        for (x = 0; x < surface->w; x++) {
            Uint32 dstcolor;

            dstcolor = (*srccol++) << 8;
            dstcolor |= (*srccol++) << 16;
            dstcolor |= (*srccol++) << 24;

            *dstcol++ = dstcolor;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadowRGBToRGBA(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint32 *dstline, *dstcol;
    Uint8 *srcline, *srccol;

    srcline = (Uint8 *) gl_shadow;
    srcpitch = surface->w * gl_pixelsize;
    dstline = surface->pixels;
    dstpitch = surface->pitch >> 2;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;

        for (x = 0; x < surface->w; x++) {
            Uint32 dstcolor;

            dstcolor = (*srccol++) << 24;
            dstcolor |= (*srccol++) << 16;
            dstcolor |= (*srccol++) << 8;

            *dstcol++ = dstcolor;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadow8888To555(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint16 *dstline, *dstcol;
    Uint32 *srcline, *srccol;

    srcline = (Uint32 *) gl_shadow;
    srcpitch = (surface->w * gl_pixelsize) >> 2;
    dstline = surface->pixels;
    dstpitch = surface->pitch >> 1;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;
        for (x = 0; x < surface->w; x++) {
            Uint32 srccolor;
            Uint16 dstcolor;

            srccolor = *srccol++;
            dstcolor = (srccolor >> 9) & (31 << 10);
            dstcolor |= (srccolor >> 6) & (31 << 5);
            dstcolor |= (srccolor >> 3) & 31;
            *dstcol++ = dstcolor;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

static void
CopyShadow8888To565(_THIS, SDL_Surface * surface)
{
    int x, y, srcpitch, dstpitch;
    Uint16 *dstline, *dstcol;
    Uint32 *srcline, *srccol;

    srcline = (Uint32 *) gl_shadow;
    srcpitch = (surface->w * gl_pixelsize) >> 2;
    dstline = surface->pixels;
    dstpitch = surface->pitch >> 1;
    if (gl_upsidedown) {
        srcline += (surface->h - 1) * srcpitch;
        srcpitch = -srcpitch;
    }

    for (y = 0; y < surface->h; y++) {
        srccol = srcline;
        dstcol = dstline;

        for (x = 0; x < surface->w; x++) {
            Uint32 srccolor;
            Uint16 dstcolor;

            srccolor = *srccol++;
            dstcolor = (srccolor >> 8) & (31 << 11);
            dstcolor |= (srccolor >> 5) & (63 << 5);
            dstcolor |= (srccolor >> 3) & 31;
            *dstcol++ = dstcolor;
        }

        srcline += srcpitch;
        dstline += dstpitch;
    }
}

/*--- Conversions routines in the screen ---*/

static void
ConvertNull(_THIS, SDL_Surface * surface)
{
}

static void
Convert565To555be(_THIS, SDL_Surface * surface)
{
    int x, y, pitch;
    unsigned short *line, *pixel;

    line = surface->pixels;
    pitch = surface->pitch >> 1;
    for (y = 0; y < surface->h; y++) {
        pixel = line;
        for (x = 0; x < surface->w; x++) {
            unsigned short color = *pixel;

            *pixel++ = (color & 0x1f) | ((color >> 1) & 0xffe0);
        }

        line += pitch;
    }
}

static void
Convert565To555le(_THIS, SDL_Surface * surface)
{
    int x, y, pitch;
    unsigned short *line, *pixel;

    line = surface->pixels;
    pitch = surface->pitch >> 1;
    for (y = 0; y < surface->h; y++) {
        pixel = line;
        for (x = 0; x < surface->w; x++) {
            unsigned short color = *pixel;

            color = (color & 0x1f) | ((color >> 1) & 0xffe0);
            *pixel++ = SDL_Swap16(color);
        }

        line += pitch;
    }
}

static void
Convert565le(_THIS, SDL_Surface * surface)
{
    int x, y, pitch;
    unsigned short *line, *pixel;

    line = surface->pixels;
    pitch = surface->pitch >> 1;
    for (y = 0; y < surface->h; y++) {
        pixel = line;
        for (x = 0; x < surface->w; x++) {
            unsigned short color = *pixel;

            *pixel++ = SDL_Swap16(color);
        }

        line += pitch;
    }
}

static void
ConvertBGRAToABGR(_THIS, SDL_Surface * surface)
{
    int x, y, pitch;
    unsigned long *line, *pixel;

    line = surface->pixels;
    pitch = surface->pitch >> 2;
    for (y = 0; y < surface->h; y++) {
        pixel = line;
        for (x = 0; x < surface->w; x++) {
            unsigned long color = *pixel;

            *pixel++ = (color << 24) | (color >> 8);
        }

        line += pitch;
    }
}

#endif /* SDL_VIDEO_OPENGL */
/* vi: set ts=4 sw=4 expandtab: */