sdlsurface.cpp

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#include <SDL/SDL_image.h>
#include <SDL/SDL_rotozoom.h>

#include <boost/assign/list_of.hpp> // for 'map_list_of()'

#include <wt/trace.h>
#include "sdlsurface.h"
#include "sdldisplay.h"   // for default depth

namespace Wt {

const FlagMap SDLSurface::flagMap = boost::assign::map_list_of
                                    (W::SWSurface, SDL_SWSURFACE)
                                    (W::HWSurface, SDL_HWSURFACE)
                                    (W::AsyncBlit, SDL_ASYNCBLIT)
                                    (W::HWPalette, SDL_HWPALETTE)
                                    (W::HWAccel, SDL_HWACCEL)
                                    (W::AnyFormat, SDL_ANYFORMAT)
                                    (W::DoubleBuffer, SDL_DOUBLEBUF)
                                    (W::FullScreen, SDL_FULLSCREEN)
                                    (W::OpenGL, SDL_OPENGL)
                                    (W::OpenGLBlit, SDL_OPENGLBLIT)
                                    (W::Resizable, SDL_RESIZABLE)
                                    (W::NoFrame, SDL_NOFRAME);

void SDLSurface::Deleter::operator()(SDL_Surface* s) {
    //trace("sdlsurface", "Deleting SDL_Surface %p\n", s);
    SDL_FreeSurface(s);
}

void SDLSurface::detach() {
    //avoid detaching if we are the only client for this surface
    if (!sdl_surface.unique()) {
        /// \bug GCC bug. does not enfoce constness
        SDLPixelFormat f = pixelFormat();
        sdl_surface.reset(SDL_ConvertSurface(*this, f, flags()), Deleter());
    }
}

static SDL_Surface *deconst(const SDLSurface src) {
    //SDL breakage
    return const_cast<SDL_Surface *>
           (static_cast<const SDL_Surface *>(src));
}

SDLSurface::SDLSurface(int w, int h, int depth, int flags)
        : sdl_surface(
            SDL_CreateRGBSurface(flagMap.state(flags ? flags : static_cast<int>(W::DefaultPixmapFlags)),
                                 w, h, (depth > 0) ? depth : defaultDepth(),
                         0, 0, 0, 0), Deleter()) {
    trace("sdlsurface",
          "Creating new SDL_Surface %p [%d x %d]\n",
          static_cast<SDL_Surface *>(*this), width(), height());
    onDepthChange();
}

SDLSurface::SDLSurface(SDL_Surface* surface)
: sdl_surface(surface, Deleter()) {
    if (surface) {
        trace("sdlsurface",
              "Creating from existing SDL_Surface %p [%d x %d]\n",
              static_cast<SDL_Surface *>(*this), width(), height());
    } else {
        trace("sdlsurface", "Creating NULL SDL_Surface %p\n", 0);
    }
    onDepthChange();
}

SDLSurface::SDLSurface(const std::string& filename)
        : sdl_surface(IMG_Load_RW(SDL_RWFromFile(
                              filename.c_str(), "rb"), 1), Deleter()) {

    if(!*this) {
        Error("IMG_Load_RW: %s (%s)\n", IMG_GetError(), filename.c_str());
    }

    onDepthChange();
}

int SDLSurface::lock() {
    detach()
    ;
    return SDL_LockSurface(*this);
}

int SDLSurface::unlock() {
    detach();
    SDL_UnlockSurface(*this);
    return 0;
}

SDLRect SDLSurface::clipRect() const {
    SDLRect r;
    SDL_GetClipRect(deconst(*this), r);
    assert(r == sdl_surface->clip_rect);
    return r;
}

SDLRect SDLSurface::setClipRect(const SDLRect& rect) {
    SDLRect r = rect;
    detach();
    SDL_SetClipRect(*this, r);
    return r;
}

void SDLSurface::setPalette(const std::vector<SDLColor>& ca,
                            int offset, int flags) {
    //SDL breakage
    SDL_Color *colors = const_cast<SDL_Color *>(
                            reinterpret_cast<const SDL_Color *>(&ca[0]));
    detach();
    SDL_SetPalette(*this, flags, colors, offset, ca.size());
}

void SDLSurface::setColor(int i, const SDLColor& c) {
    std::vector<SDLColor> ca(1, c);
    setPalette(ca, i);
}

int SDLSurface::numColors() const {
    SDLPalette pal = pixelFormat().palette();
    return (pal) ? pal.size() :  0;
}

void SDLSurface::setNumColors(int ncolors) {
    int old = numColors();

    if (ncolors < old) {
        SDLPalette pal = pixelFormat().palette();
        std::vector<SDLColor> ca;
        ca.reserve(ncolors);
        for (int i = 0; i < ncolors; i++)
            ca[i] = pal[i];
        setPalette(ca, 0);
    } else if (ncolors > old) {
        std::vector<SDLColor> ca(ncolors - old, SDLColor());
        setPalette(ca, old);
    }
}

bool SDLSurface::isGrayscale() const {
    SDLPalette pal = pixelFormat().palette();
    if (pal) {
        int n = numColors();
        for (int i = 0; i < n; i++) {
            SDLColor c = pal[i];
            if (c.red() != c.green() || c.green() != c.blue())
                return false;
        }
        return true;
    } else {}

    return false;
}

void SDLSurface::setTransparentColor(const SDLColor& color) {
    detach();
    SDL_SetColorKey(*this, SDL_SRCCOLORKEY | SDL_RLEACCEL,
                    pixelFormat().mapToPixelValue(color));
}

void SDLSurface::clearTransparentColor() {
    detach();
    SDL_SetColorKey(*this, 0, 0);
}

void SDLSurface::setAlpha(int alpha) {
    detach();
    SDL_SetAlpha(*this, SDL_SRCALPHA, alpha);
}

void SDLSurface::clearAlpha() {
    detach();
    SDL_SetAlpha(*this, 0, SDLColor::Opaque);
}

int SDLSurface::fill(int v) {
    detach();
    return SDL_FillRect(*this, 0, v);
}

int SDLSurface::fill(const SDLRect& dst, int v) {
    SDLRect r = dst;
    detach();
    return SDL_FillRect(*this, r, v);
}

static int safe_blit(SDL_Surface *src, SDL_Rect *srcrect,
                     SDL_Surface *dst, SDL_Rect *dstrect) {
    int err;
    while ((err = SDL_BlitSurface(src, srcrect, dst, dstrect)) == -2) {
        while (SDL_LockSurface(src) < 0)
            //SDL_Delay(10);
            /// \todo Write image pixels to image->pixels
            SDL_UnlockSurface(src);
    }
    assert(!err);
    return err;
}

/*!
    if (source surface has SDL_SRCALPHA set) {
       if (source surface has alpha channel (that is, format->Amask != 0))
          blit using per-pixel alpha, ignoring any colour key
       else {
          if (source surface has SDL_SRCCOLORKEY set)
             blit using the colour key AND the per-surface alpha value
          else
             blit using the per-surface alpha value
          }
    } else {
         if (source surface has SDL_SRCCOLORKEY set)
             blit using the colour key
         else
             ordinary opaque rectangular blit
    }
 
    Note: The per-surface alpha value of 128 is considered a special case
    and is optimised, so it's much faster than other per-surface values.
    
    Alpha effects surface blitting in the following ways:
    
    RGBA->RGB with SDL_SRCALPHA 
    The source is alpha-blended with the destination, using the alpha
    channel. SDL_SRCCOLORKEY and the per-surface alpha are ignored.
 
    RGBA->RGB without SDL_SRCALPHA  
    The RGB data is copied from the source. The source alpha channel and the
    per-surface alpha value are ignored.
 
    RGB->RGBA with SDL_SRCALPHA 
    The source is alpha-blended with the destination using the per-surface
    alpha value. If SDL_SRCCOLORKEY is set, only the pixels not matching the
    colorkey value are copied. The alpha channel of the copied pixels is set
    to opaque.
 
    RGB->RGBA without SDL_SRCALPHA  
    The RGB data is copied from the source and the alpha value of the copied
    pixels is set to opaque. If SDL_SRCCOLORKEY is set, only the pixels not
    matching the colorkey value are copied.
 
    RGBA->RGBA with SDL_SRCALPHA    
    The source is alpha-blended with the destination using the source alpha
    channel. The alpha channel in the destination surface is left untouched.
    SDL_SRCCOLORKEY is ignored.
 
    RGBA->RGBA without SDL_SRCALPHA 
    The RGBA data is copied to the destination surface. If SDL_SRCCOLORKEY
    is set, only the pixels not matching the colorkey value are copied.
 
    RGB->RGB with SDL_SRCALPHA  
    The source is alpha-blended with the destination using the per-surface
    alpha value. If SDL_SRCCOLORKEY is set, only the pixels not matching the
    colorkey value are copied.
 
    RGB->RGB without SDL_SRCALPHA   
    The RGB data is copied from the source. If SDL_SRCCOLORKEY is set, only
    the pixels not matching the colorkey value are copied.
    
    Note: Note that RGBA->RGBA blits (with SDL_SRCALPHA set) keep the alpha
    of the destination surface. This means that you cannot compose two
    arbitrary RGBA surfaces this way and get the result you would expect
    from "overlaying" them; the destination alpha will work as a mask.
        
    Also note that per-pixel and per-surface alpha cannot be combined; the
    per-pixel alpha is always used if available
 */

int SDLSurface::blit(const SDLSurface& src) {
    detach();
    return safe_blit(deconst(src), 0, *this, 0);
}

int SDLSurface::blit(int x, int y, const SDLSurface& src) {
    SDLRect dst(x, y, 0, 0);
    detach();
    return safe_blit(deconst(src), 0, *this, dst);
}

int SDLSurface::blit(int x, int y,
                     const SDLSurface& src, const SDLRect& src_rect) {
    ///SDL breakage
    SDLRect s = src_rect;
    SDLRect dst(x, y, 0, 0);
    detach();
    return safe_blit(deconst(src), s, *this, dst);
}

bool SDLSurface::load(const std::string& filename) {
    SDLSurface dst = IMG_Load_RW(SDL_RWFromFile(filename.c_str(), "rb"), 1);

    if (dst) {
        sdl_surface = dst;
        return true;
    }
    return false;
}

bool SDLSurface::load(const void *p, size_t size) {
    SDLSurface dst = IMG_Load_RW(SDL_RWFromConstMem(p, size), 1);

    if (dst) {
        sdl_surface = dst;
        return true;
    }
    return false;
}

int SDLSurface::convertTo(const SDLSurface src) {
    if (*this == src)
        return 0;
    /// \bug GCC bug. does not enfoce constness
    SDLPixelFormat f = src.pixelFormat();
    SDLSurface dst = SDL_ConvertSurface(*this, f, src.flags());

    if (dst) {
        sdl_surface = dst;
        return 0;
    }

    return -1;
}

int SDLSurface::convertToDisplay() {
    SDLSurface dst = SDL_DisplayFormatAlpha(*this);
    if (dst) {
        sdl_surface = dst;
        return 0;
    }

    return -1;
}

int SDLSurface::convertDepth(int new_depth) {
    SDLSurface dst = SDLSurface(width(), height(), new_depth);
    if (dst) {
        dst.blit(*this);
        sdl_surface = dst;
        return 0;
    }
    return -1;
}

void SDLSurface::resize(int x, int y) {
    SDLPixelFormat f = pixelFormat();
    SDLSurface dst = SDL_CreateRGBSurface(flags(), x, y, f.bitsPerPixel(),
                                          f.redMask(), f.greenMask(),
                                          f.blueMask(), f.alphaMask());
    if (dst)
        sdl_surface = dst;
}

int SDLSurface::defaultDepth() {
    return SDLDisplay::instance()->depth();
}

int SDLSurface::blitAlphaCopy(int x, int y, const SDLSurface& src,
                              const SDLRect& src_rect) {
    assert(depth() == src.depth());

    bool has_alpha = src.hasAlpha();
    bool has_colorkey = src.hasTransparentColor();
    int alpha = 0, pv = 0;

    // note: we can't use set/clearAlpha beacuse of detach
    if (has_alpha) {
        alpha = src.alpha();
        SDL_SetAlpha(deconst(src), 0, SDLColor::Opaque);
    }

    if (has_colorkey) {
        pv = src.pixelFormat().transparentPixelValue();
        SDL_SetColorKey(deconst(src), 0, 0);
    }

    int status = blit(x, y, src, src_rect);

    if (has_alpha) {
        SDL_SetAlpha(deconst(src), SDL_SRCALPHA, alpha);
    }

    if (has_colorkey) {
        SDL_SetColorKey(deconst(src), SDL_SRCCOLORKEY | SDL_RLEACCEL, pv);
    }
    return status;
}

int SDLSurface::blitAlphaCopy(const SDLSurface& src) {
    return blitAlphaCopy(0, 0, src, SDLRect(0, 0, src.width(), src.height()));
}

int SDLSurface::blitAlphaCopy(int x, int y, const SDLSurface& src) {
    return blitAlphaCopy(x, y, src, SDLRect(0, 0, src.width(), src.height()));
}

int SDLSurface::readPixel8bpp(int pixel_offset) const {
    return * (Uint8 *) pixelAddress(pixel_offset);
}

void SDLSurface::writePixel8bpp(int pixel_offset, int pixel_value) {
    * (Uint8 *) pixelAddress(pixel_offset) = pixel_value;
}

int SDLSurface::readPixel16bpp(int pixel_offset) const {
    return * (Uint16 *) pixelAddress(pixel_offset);
}

void SDLSurface::writePixel16bpp(int pixel_offset, int pixel_value) {
    * (Uint16 *) pixelAddress(pixel_offset) = pixel_value;
}

int SDLSurface::readPixel24bpp(int pixel_offset) const {
    Uint8* screen_loc = (Uint8 *) pixelAddress(pixel_offset);
    const SDLPixelFormat f = pixelFormat();
    Uint32 pixel = 0;
    int shift;

    // I´m not sure on this, Karsten 01/1999
    shift = f.redShift();
    pixel = *(screen_loc + shift / 8) << shift;
    shift = f.greenShift();
    pixel |= *(screen_loc + shift / 8) << shift;
    shift = f.blueShift();
    pixel |= *(screen_loc + shift / 8) << shift;
    return pixel;
}

void SDLSurface::writePixel24bpp(int pixel_offset, int pixel_value) {
    Uint8* screen_loc = (Uint8 *) pixelAddress(pixel_offset);
    int shift;
    const SDLPixelFormat f = pixelFormat();

    shift = f.redShift();
    *(screen_loc + shift / 8) =  pixel_value >> shift;
    shift = f.greenShift();
    *(screen_loc + shift / 8) =  pixel_value >> shift;
    shift = f.blueShift();
    *(screen_loc + shift / 8) =  pixel_value >> shift;
}

int SDLSurface::readPixel32bpp(int pixel_offset) const {
    return * (Uint32 *) pixelAddress(pixel_offset);
}

void SDLSurface::writePixel32bpp(int pixel_offset, int pixel_value) {
    * (Uint32 *) pixelAddress(pixel_offset) = pixel_value;
}

void SDLSurface::onDepthChange() {
    // don't crash on NULL surfaces
    if (!*this)
        return;
    switch (depth()) {
    case 0:
        read_pixel = 0;
        write_pixel = 0;
        assert(0);
        break;
    case 8:
        read_pixel = &SDLSurface::readPixel8bpp;
        write_pixel = &SDLSurface::writePixel8bpp;
        break;
    case 16:
        read_pixel = &SDLSurface::readPixel16bpp;
        write_pixel = &SDLSurface::writePixel16bpp;
        break;
    case 24:
        read_pixel = &SDLSurface::readPixel24bpp;
        write_pixel = &SDLSurface::writePixel24bpp;
        break;
    case 32:
        read_pixel = &SDLSurface::readPixel32bpp;
        write_pixel = &SDLSurface::writePixel32bpp;
        break;
    default:
        assert(0);
        break;
    }
}

SDLSurface SDLSurface::scale_surface(int w, int h,
                                     bool smooth, ScaleMode mode) const {
    if (mode != ScaleFree && (width() * h != height() * w)) {
        double r1 = static_cast<double>(width()) /
                    static_cast<double>(height());
        double r2 = static_cast<double>(w) /
                    static_cast<double>(h);
        if ( (mode == ScaleMin & (r2 > r1)) || (mode == ScaleMax & (r2 < r1)) )
            w = static_cast<int>(h * r1);
        if ( (mode == ScaleMin & (r2 < r1)) || (mode == ScaleMax & (r2 > r1)) )
            h = static_cast<int>(w / r1);
    }
    double zx =  static_cast<double>(w) / static_cast<double>(width());
    double zy =  static_cast<double>(h) / static_cast<double>(height());

    return SDLSurface(zoomSurface(deconst(*this), zx, zy, smooth));
}

SDLSurface SDLSurface::scale(int w, int h, ScaleMode mode) const {
    return scale_surface(w, h, false, mode);
}

SDLSurface SDLSurface::smoothScale(int w, int h, ScaleMode mode) const {
    return scale_surface(w, h, true, mode);
}

SDLSurface SDLSurface::scaleWidth(int w) const {
    return scale_surface(w, height(), false, ScaleFree);
}

SDLSurface SDLSurface::scaleHeight(int h) const {
    return scale_surface(width(), h, false, ScaleFree);
}

} // namespace

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.