view src/video/nanox/SDL_nximage.c @ 2079:1ed2155b7ee4

From: Torsten Giebl Subject: ALLOCA Patch for SDL-1.2 Newsgroups: gmane.comp.lib.sdl Date: 2006-10-24 00:31:16 GMT Hello ! As alloca.h is not available on CYGWIN and MinGW32 it should not be checked there or it should be checked with -mno-cygwin using. I am a total configure.in newbie, but i found the way that things are handled in configure.in pretty bad for the case CYGWIN with MinGW Mode or not. Maybe this is not possible but i would like to have a way to detect at the start for example CYGWIN and then add. ask if configure was called with --enable-cygwin for example. --enable-cygwin should be optional and disabled by default as we want to have MinGW Mode by default. Only if the user wants it he should be able to use it. Then the whole configure.in would get add. questions okay the system is CYGWIN with or without MinGW Mode. The alloca.h thing for example is only available under CYGWIN ( without MinGW Mode ). CU
author Ryan C. Gordon <icculus@icculus.org>
date Fri, 01 Dec 2006 20:25:03 +0000 (2006-12-01)
parents c121d94672cb
children 99210400e8b9
line wrap: on
line source
/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2004 Sam Lantinga
    Copyright (C) 2001  Hsieh-Fu Tsai
    Copyright (C) 2002  Greg Haerr <greg@censoft.com>

    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
    
    Hsieh-Fu Tsai
    clare@setabox.com
*/
#include "SDL_config.h"

#include "SDL_nximage_c.h"

void
NX_NormalUpdate(_THIS, int numrects, SDL_Rect * rects)
{
    int i, j, xinc, yinc, destinc, rowinc;
    int x, y, w, h;
    unsigned char *src = NULL, *dest = NULL;

    Dprintf("enter NX_NormalUpdate\n");

    /* These are the values for the incoming image */
    xinc = this->screen->format->BytesPerPixel;
    yinc = this->screen->pitch;

    for (i = 0; i < numrects; ++i) {
        x = rects[i].x, y = rects[i].y;
        w = rects[i].w, h = rects[i].h;
        src = SDL_Image + y * yinc + x * xinc;
#ifdef ENABLE_NANOX_DIRECT_FB
        if (Clientfb) {
            if (currently_fullscreen)
                dest =
                    fbinfo.winpixels + (((y + OffsetY) * fbinfo.pitch) +
                                        ((x + OffsetX) * fbinfo.bytespp));
            else
                dest =
                    fbinfo.winpixels + ((y * fbinfo.pitch) +
                                        (x * fbinfo.bytespp));
            destinc = fbinfo.pitch;
        } else
#endif
        {
            dest = Image_buff;
            destinc = w * xinc;
        }
        rowinc = w * xinc;

        // apply GammaRamp table
        if ((pixel_type == MWPF_TRUECOLOR0888
             || pixel_type == MWPF_TRUECOLOR888) && GammaRamp_R
            && GammaRamp_G && GammaRamp_B) {
            Uint8 *ptrsrc;
            Uint8 *ptrdst;
            int k;

            for (j = h; j > 0; --j, src += yinc, dest += destinc) {
                ptrsrc = src;
                ptrdst = dest;
                for (k = w; k > 0; --k) {
                    *ptrdst++ = GammaRamp_B[*ptrsrc++] >> 8;
                    *ptrdst++ = GammaRamp_G[*ptrsrc++] >> 8;
                    *ptrdst++ = GammaRamp_R[*ptrsrc++] >> 8;
                    *ptrdst++ = 0;
                    ++ptrsrc;
                }
            }
        }
#if 1                           /* This is needed for microwindows 0.90 or older */
        else if (pixel_type == MWPF_TRUECOLOR0888
                 || pixel_type == MWPF_TRUECOLOR888) {
            Uint8 *ptrsrc;
            Uint8 *ptrdst;
            int k;

            for (j = h; j > 0; --j, src += yinc, dest += destinc) {
                ptrsrc = src;
                ptrdst = dest;
                for (k = w; k > 0; --k) {
                    *ptrdst++ = *ptrsrc++;
                    *ptrdst++ = *ptrsrc++;
                    *ptrdst++ = *ptrsrc++;
                    *ptrdst++ = 0;
                    ++ptrsrc;
                }
            }
        }
#endif
        else {
            for (j = h; j > 0; --j, src += yinc, dest += destinc)
                SDL_memcpy(dest, src, rowinc);
        }
        if (!Clientfb) {
            if (currently_fullscreen) {
                GrArea(FSwindow, SDL_GC, x + OffsetX, y + OffsetY, w,
                       h, Image_buff, pixel_type);
            } else {
                GrArea(SDL_Window, SDL_GC, x, y, w, h, Image_buff,
                       pixel_type);
            }
        }
    }
    GrFlush();

    Dprintf("leave NX_NormalUpdate\n");
}

int
NX_SetupImage(_THIS, SDL_Surface * screen)
{
    int size = screen->h * screen->pitch;

    Dprintf("enter NX_SetupImage\n");

    screen->pixels = (void *) SDL_malloc(size);

    if (!Clientfb) {
        Image_buff = (unsigned char *) SDL_malloc(size);
        if (screen->pixels == NULL || Image_buff == NULL) {
            SDL_free(screen->pixels);
            SDL_free(Image_buff);
            SDL_OutOfMemory();
            return -1;
        }
    }

    SDL_Image = (unsigned char *) screen->pixels;

    this->UpdateRects = NX_NormalUpdate;

    Dprintf("leave NX_SetupImage\n");
    return 0;
}

void
NX_DestroyImage(_THIS, SDL_Surface * screen)
{
    Dprintf("enter NX_DestroyImage\n");

    if (SDL_Image)
        SDL_free(SDL_Image);
    if (Image_buff)
        SDL_free(Image_buff);
    if (screen)
        screen->pixels = NULL;

    Dprintf("leave NX_DestroyImage\n");
}

int
NX_ResizeImage(_THIS, SDL_Surface * screen, Uint32 flags)
{
    int retval;
    GR_SCREEN_INFO si;

    Dprintf("enter NX_ResizeImage\n");

    NX_DestroyImage(this, screen);
    retval = NX_SetupImage(this, screen);

    GrGetScreenInfo(&si);
    OffsetX = (si.cols - screen->w) / 2;
    OffsetY = (si.rows - screen->h) / 2;

#ifdef ENABLE_NANOX_DIRECT_FB
    if (Clientfb) {
        /* Get current window position and fb pointer */
        if (currently_fullscreen)
            GrGetWindowFBInfo(FSwindow, &fbinfo);
        else
            GrGetWindowFBInfo(SDL_Window, &fbinfo);
    }
#endif
    Dprintf("leave NX_ResizeImage\n");
    return retval;
}

void
NX_RefreshDisplay(_THIS)
{
    Dprintf("enter NX_RefreshDisplay\n");

    // Don't refresh a display that doesn't have an image (like GL)
    if (!SDL_Image) {
        return;
    }
#ifdef ENABLE_NANOX_DIRECT_FB
    if (Clientfb) {
        int j;
        char *src, *dest = NULL;
        int xinc, yinc, rowinc;

        GrGetWindowFBInfo(SDL_Window, &fbinfo);

        xinc = this->screen->format->BytesPerPixel;
        yinc = this->screen->pitch;

        src = SDL_Image;
        if (currently_fullscreen)
            dest = fbinfo.winpixels + ((OffsetY * fbinfo.pitch) +
                                       (OffsetX * fbinfo.bytespp));
        else
            dest = fbinfo.winpixels;
        rowinc = xinc * this->screen->w;

        for (j = this->screen->h; j > 0;
             --j, src += yinc, dest += fbinfo.pitch)
            SDL_memcpy(dest, src, rowinc);
    } else
#endif
    {
        if (currently_fullscreen) {
            GrArea(FSwindow, SDL_GC, OffsetX, OffsetY, this->screen->w,
                   this->screen->h, SDL_Image, pixel_type);
        } else {
            GrArea(SDL_Window, SDL_GC, 0, 0, this->screen->w,
                   this->screen->h, SDL_Image, pixel_type);
        }
    }
    GrFlush();

    Dprintf("leave NX_RefreshDisplay\n");
}

/* vi: set ts=4 sw=4 expandtab: */