Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

SDLFrameBuffer.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:    SDLFrameBuffer.cpp                                         *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi 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.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *  $Id: SDLFrameBuffer.cpp,v 1.9 2005/01/20 20:04:22 mkropfbe Exp $
 *                                                                      *
 ***********************************************************************/

#include "global.hpp"
#include "IO.hpp"
#include "Frame.hpp"
#include "SDLFrameBuffer.hpp"
#include "VideoFrameBuffer.hpp"



/*------------ SDLFrameBuffer methods --------------------------------------- */

SDLFrameBuffer::SDLFrameBuffer(SDL_Surface *surface, int depth, bool gray, int width, int height)
  : VideoFrameBuffer(gray)
{
        this->surface = surface;
        this->width = width;
        this->height = height;
        assert(depth % 8 == 0);

        /*
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    rmask = 0xff000000;
    gmask = 0x00ff0000;
    bmask = 0x0000ff00;
    amask = 0x000000ff;
#else
    rmask = 0x000000ff;
    gmask = 0x0000ff00;
    bmask = 0x00ff0000;
    amask = 0xff000000;
#endif
        
        rmask = 0x00000020;
        gmask = 0x000007E0;
        bmask = 0x0000F800;

        rmask = 0x0000000F;
        gmask = 0x000000F0;
        bmask = 0x00000F00;

        //rmask = 0xFFFFFFFF;
  //gmask = 0xFFFFFFFF;
  //bmask = 0xFFFFFFFF;
*/

        /*
        Uint32 rmask, gmask, bmask, amask;
        amask=rmask=gmask=bmask=0;
        image = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, depth, rmask, gmask, bmask, amask);

        if (image == NULL) {
                dprintf_err("Couldn't initialize blitbuffer with dimension %ix%i depth %i\n",width,height, depth);
                ::exit(1);
        }
        SDL_SetAlpha(image,0,0xff);
        dprintf_full("SDLFrameBuffer: initialize blitbuffer with dimension %ix%i depth %i, bpp %i, no aplpha blending\n",
                                                         width,height, image->format->BitsPerPixel, image->format->BytesPerPixel);
        */
}


SDLFrameBuffer::~SDLFrameBuffer() {
        if(image)
                SDL_FreeSurface(image);
        image = NULL;
}


inline void SDLFrameBuffer::setPixel(int x, int y, uint value) {
        
        int bpp = surface->format->BytesPerPixel;
        Uint8 *p = (Uint8 *)(surface->pixels) + y * surface->pitch + x * bpp;

        //      dprintf_full("SDLFrameBuffer::setPixel  image   pitch %i bpp %i %x %x\n",image->pitch,image->format->BytesPerPixel,p,value);
        //      printf("%x\t",value);
        
        switch(bpp) {
        case 1:
                *p = (Uint8)value;
                break;
                
        case 2:
                *(Uint16 *)p = value;
                break;
                
        case 3:
                if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                        p[0] = (value >> 16) & 0xff;
                        p[1] = (value >> 8) & 0xff;
                        p[2] = value & 0xff;
                } else {
                        p[0] = value & 0xff;
                        p[1] = (value >> 8) & 0xff;
                        p[2] = (value >> 16) & 0xff;
                }
                break;
                
        case 4:
                if (gray)
                        value = value << 16 | value << 8 | value;
                *(Uint32 *)p = value;
                break;
        }
}


void SDLFrameBuffer::bitBlt(AU *au) {
        //dprintf_full("SDLFrameBuffer::bitBlt  surface pitch %i bpp %i AU->size %i\n",surface->pitch,surface->format->BytesPerPixel, au->size);
        //      dprintf_full("SDLFrameBuffer::bitBlt  image   pitch %i bpp %i AU->size %i\n",image->pitch,image->format->BytesPerPixel, au->size);
        memcpy(surface->pixels, au->payload, au->size);
}


void SDLFrameBuffer::postPaintEvent() {
        /*
        if (SDL_MUSTLOCK(surface)) {
                if (SDL_LockSurface(surface) < 0) {
                        ::exit(2);
                }
        }
        
        if(SDL_BlitSurface(image, NULL, surface, NULL) < 0)
                fprintf(stderr, "BlitSurface error: %s\n", SDL_GetError());
        
        if (SDL_MUSTLOCK(surface)) {
                SDL_UnlockSurface(surface);
        }
        */
        SDL_UpdateRect(surface, 0, 0, 0, 0);
}

© ViTooKi 2003 :: [Lite version] Created with Doxygen