/*

    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

*/

#ifdef SAVE_RCSID

static char rcsid =

 "@(#) $Id$";

#endif

#ifndef _SDL_blit_h

#define _SDL_blit_h

#include "SDL_endian.h"

/* The structure passed to the low level blit functions */

typedef struct {

	Uint8 *s_pixels;

	int s_width;

	int s_height;

	int s_skip;

	Uint8 *d_pixels;

	int d_width;

	int d_height;

	int d_skip;

	void *aux_data;

	SDL_PixelFormat *src;

	Uint8 *table;

	SDL_PixelFormat *dst;

} SDL_BlitInfo;

/* The type definition for the low level blit functions */

typedef void (*SDL_loblit)(SDL_BlitInfo *info);

/* This is the private info structure for software accelerated blits */

struct private_swaccel {

	SDL_loblit blit;

	void *aux_data;

};

/* Blit mapping definition */

typedef struct SDL_BlitMap {

	SDL_Surface *dst;

	int identity;

	Uint8 *table;

	SDL_blit hw_blit;

	SDL_blit sw_blit;

	struct private_hwaccel *hw_data;

	struct private_swaccel *sw_data;

	/* the version count matches the destination; mismatch indicates

	   an invalid mapping */

        unsigned int format_version;

} SDL_BlitMap;

/* Functions found in SDL_blit.c */

extern int SDL_CalculateBlit(SDL_Surface *surface);

/* Functions found in SDL_blit_{0,1,N,A}.c */

extern SDL_loblit SDL_CalculateBlit0(SDL_Surface *surface, int complex);

extern SDL_loblit SDL_CalculateBlit1(SDL_Surface *surface, int complex);

extern SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int complex);

extern SDL_loblit SDL_CalculateAlphaBlit(SDL_Surface *surface, int complex);

/*

 * Useful macros for blitting routines

 */

#define FORMAT_EQUAL(A, B)						\

    ((A)->BitsPerPixel == (B)->BitsPerPixel				\

     && ((A)->Rmask == (B)->Rmask) && ((A)->Amask == (B)->Amask))

/* Load pixel of the specified format from a buffer and get its R-G-B values */

/* FIXME: rescale values to 0..255 here? */

{									\

}

{									\

}

{									\

}

{									\

}

do {									   \

	switch (bpp) {							   \

		case 2:							   \

		break;							   \

									   \

		case 3: {						   \

		        Uint8 *B = (Uint8 *)(buf);			   \

			if(SDL_BYTEORDER == SDL_LIL_ENDIAN) {		   \

			} else {					   \

			}						   \

		}							   \

		break;							   \

									   \

		case 4:							   \

		break;							   \

									   \

		default:						   \

		break;							   \

	}								   \

} while(0)

do {									   \

	switch (bpp) {							   \

		case 2:							   \

		break;							   \

									   \

		case 3: {						   \

		        Uint8 *B = (Uint8 *)buf;			   \

			if(SDL_BYTEORDER == SDL_LIL_ENDIAN) {		   \

			} else {					   \

			}						   \

		}							   \

		break;							   \

									   \

		case 4:							   \

		break;							   \

									   \

	        default:						   \

		break;							   \

	}								   \

} while(0)

/* Assemble R-G-B values into a specified pixel format and store them */

{									\

		((g>>fmt->Gloss)<<fmt->Gshift)|				\

		((b>>fmt->Bloss)<<fmt->Bshift);				\

}

{									\

}

{									\

}

{									\

}

#define ASSEMBLE_RGB(buf, bpp, fmt, r, g, b) 				\

{									\

	switch (bpp) {							\

		case 2: {						\

									\

		}							\

		break;							\

									\

		case 3: {						\

                        if(SDL_BYTEORDER == SDL_LIL_ENDIAN) {		\

			        *((buf)+fmt->Rshift/8) = r;		\

				*((buf)+fmt->Gshift/8) = g;		\

				*((buf)+fmt->Bshift/8) = b;		\

			} else {					\

			        *((buf)+2-fmt->Rshift/8) = r;		\

				*((buf)+2-fmt->Gshift/8) = g;		\

				*((buf)+2-fmt->Bshift/8) = b;		\

			}						\

		}							\

		break;							\

									\

		case 4: {						\

									\

		}							\

		break;							\

	}								\

}

#define ASSEMBLE_RGB_AMASK(buf, bpp, fmt, r, g, b, Amask)		\

{									\

	switch (bpp) {							\

		case 2: {						\

			Uint16 *bufp;					\

									\

			bufp = (Uint16 *)buf;				\

		}							\

		break;							\

									\

		case 3: {						\

                        if(SDL_BYTEORDER == SDL_LIL_ENDIAN) {		\

			        *((buf)+fmt->Rshift/8) = r;		\

				*((buf)+fmt->Gshift/8) = g;		\

				*((buf)+fmt->Bshift/8) = b;		\

			} else {					\

			        *((buf)+2-fmt->Rshift/8) = r;		\

				*((buf)+2-fmt->Gshift/8) = g;		\

				*((buf)+2-fmt->Bshift/8) = b;		\

			}						\

		}							\

		break;							\

									\

		case 4: {						\

			Uint32 *bufp;					\

									\

			bufp = (Uint32 *)buf;				\

		}							\

		break;							\

	}								\

}

/* FIXME: Should we rescale alpha into 0..255 here? */

{									\

}

{						\

}

{									\

}

{									\

}

{									\

}

do {									   \

	switch (bpp) {							   \

		case 2:							   \

		break;							   \

									   \

		case 3:	{/* FIXME: broken code (no alpha) */		   \

		        Uint8 *b = (Uint8 *)buf;			   \

			if(SDL_BYTEORDER == SDL_LIL_ENDIAN) {		   \

			} else {					   \

			}						   \

		}							   \

		break;							   \

									   \

		case 4:							   \

		break;							   \

									   \

		default:						   \

		break;							   \

	}								   \

} while(0)

/* FIXME: this isn't correct, especially for Alpha (maximum != 255) */

{									\

		((g>>fmt->Gloss)<<fmt->Gshift)|				\

		((b>>fmt->Bloss)<<fmt->Bshift)|				\

		((a>>fmt->Aloss)<<fmt->Ashift);				\

}

#define ASSEMBLE_RGBA(buf, bpp, fmt, r, g, b, a)			\

{									\

	switch (bpp) {							\

		case 2: {						\

									\

		}							\

		break;							\

									\

		case 3: { /* FIXME: broken code (no alpha) */		\

                        if(SDL_BYTEORDER == SDL_LIL_ENDIAN) {		\

			        *((buf)+fmt->Rshift/8) = r;		\

				*((buf)+fmt->Gshift/8) = g;		\

				*((buf)+fmt->Bshift/8) = b;		\

			} else {					\

			        *((buf)+2-fmt->Rshift/8) = r;		\

				*((buf)+2-fmt->Gshift/8) = g;		\

				*((buf)+2-fmt->Bshift/8) = b;		\

			}						\

		}							\

		break;							\

									\

		case 4: {						\

									\

		}							\

		break;							\

	}								\

}

#define ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB)	\

do {						\

	dR = (((sR-dR)*(A))>>8)+dR;		\

	dG = (((sG-dG)*(A))>>8)+dG;		\

	dB = (((sB-dB)*(A))>>8)+dB;		\

} while(0)

#define ACCURATE_ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB)	\

do {						\

    unsigned tR, tG, tB, tA; \

    tA = 255 - sA; \

    tR = 1 + (sR * sA) + (dR * tA); \

    dR = (tR + (tR >> 8)) >> 8; \

    tG = 1 + (sG * sA) + (dG * tA); \

    dG = (tG + (tG >> 8)) >> 8; \

    tB = 1 + (sB * sA) + (dB * tA); \

    dB = (tB + (tB >> 8)) >> 8; \

} while(0)

/* This is a very useful loop for optimizing blitters */

#if defined(_MSC_VER) && (_MSC_VER == 1300)

/* There's a bug in the Visual C++ 7 optimizer when compiling this code */

#else

#define USE_DUFFS_LOOP

#endif

#ifdef USE_DUFFS_LOOP

/* 8-times unrolled loop */

#define DUFFS_LOOP8(pixel_copy_increment, width)			\

{ int n = (width+7)/8;							\

	switch (width & 7) {						\

	case 0: do {	pixel_copy_increment;				\

	case 7:		pixel_copy_increment;				\

	case 6:		pixel_copy_increment;				\

	case 5:		pixel_copy_increment;				\

	case 4:		pixel_copy_increment;				\

	case 3:		pixel_copy_increment;				\

	case 2:		pixel_copy_increment;				\

	case 1:		pixel_copy_increment;				\

		} while ( --n > 0 );					\

	}								\

}

/* 4-times unrolled loop */

#define DUFFS_LOOP4(pixel_copy_increment, width)			\

{ int n = (width+3)/4;							\

	switch (width & 3) {						\

	case 0: do {	pixel_copy_increment;				\

	case 3:		pixel_copy_increment;				\

	case 2:		pixel_copy_increment;				\

	case 1:		pixel_copy_increment;				\

		} while ( --n > 0 );					\

	}								\

}

/* 2 - times unrolled loop */

#define DUFFS_LOOP_DOUBLE2(pixel_copy_increment,			\

				double_pixel_copy_increment, width)	\

{ int n, w = width;							\

	if( w & 1 ) {							\

	    pixel_copy_increment;					\

	    w--;							\

	}								\

	if ( w > 0 )	{						\

	    n = ( w + 2) / 4;						\

	    switch( w & 2 ) {						\

	    case 0: do {	double_pixel_copy_increment;		\

	    case 2:		double_pixel_copy_increment;		\

		    } while ( --n > 0 );					\

	    }								\

	}								\

}

/* 2 - times unrolled loop 4 pixels */

#define DUFFS_LOOP_QUATRO2(pixel_copy_increment,			\

				double_pixel_copy_increment,		\

				quatro_pixel_copy_increment, width)	\

{ int n, w = width;								\

        if(w & 1) {							\

	  pixel_copy_increment;						\

	  w--;								\

	}								\

	if(w & 2) {							\

	  double_pixel_copy_increment;					\

	  w -= 2;							\

	}								\

	if ( w > 0 ) {							\

	    n = ( w + 7 ) / 8;						\

	    switch( w & 4 ) {						\

	    case 0: do {	quatro_pixel_copy_increment;		\

	    case 4:		quatro_pixel_copy_increment;		\

		    } while ( --n > 0 );					\

	    }								\

	}								\

}

/* Use the 8-times version of the loop by default */

#define DUFFS_LOOP(pixel_copy_increment, width)				\

	DUFFS_LOOP8(pixel_copy_increment, width)

#else

/* Don't use Duff's device to unroll loops */

#define DUFFS_LOOP_DOUBLE2(pixel_copy_increment,			\

			 double_pixel_copy_increment, width)		\

{ int n = width;								\

    if( n & 1 ) {							\

	pixel_copy_increment;						\

	n--;								\

    }									\

    n=n>>1;								\

    for(; n > 0; --n) {   						\

	double_pixel_copy_increment;					\

    }									\

}

/* Don't use Duff's device to unroll loops */

#define DUFFS_LOOP_QUATRO2(pixel_copy_increment,			\

				double_pixel_copy_increment,		\

				quatro_pixel_copy_increment, width)	\

{ int n = width;								\

        if(n & 1) {							\

	  pixel_copy_increment;						\

	  n--;								\

	}								\

	if(n & 2) {							\

	  double_pixel_copy_increment;					\

	  n -= 2;							\

	}								\

	n=n>>2;								\

	for(; n > 0; --n) {   						\

	  quatro_pixel_copy_increment;					\

        }								\

}