/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_endian.h"
#include "SDL_cgximage_c.h"
#ifdef HAVE_KSTAT
#include <kstat.h>
#endif
#ifdef USE_CGX_WRITELUTPIXEL
#if defined(__SASC) || defined(__PPC__)
#define WLUT WriteLUTPixelArray
#else
void WLUT(APTR a,UWORD b,UWORD c,UWORD d,struct RastPort *e,APTR f,UWORD g,UWORD h,UWORD i,UWORD l,UBYTE m)
{ WriteLUTPixelArray(a,b,c,d,e,f,g,h,i,l,m); }
#endif
#endif
/* Various screen update functions available */
static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects);
static void CGX_FakeUpdate(_THIS, int numrects, SDL_Rect *rects);
BOOL SafeDisp=TRUE,SafeChange=TRUE;
struct MsgPort *safeport=NULL,*dispport=NULL;
ULONG safe_sigbit,disp_sigbit;
int use_picasso96=1;
int CGX_SetupImage(_THIS, SDL_Surface *screen)
{
SDL_Ximage=NULL;
if(screen->flags&SDL_HWSURFACE) {
ULONG pitch;
if(!screen->hwdata) {
if(!(screen->hwdata=SDL_malloc(sizeof(struct private_hwdata))))
return -1;
D(bug("Creating system accel struct\n"));
}
screen->hwdata->lock=NULL;
screen->hwdata->allocated=0;
screen->hwdata->mask=NULL;
screen->hwdata->bmap=SDL_RastPort->BitMap;
screen->hwdata->videodata=this;
if(!(screen->hwdata->lock=LockBitMapTags(screen->hwdata->bmap,
LBMI_BASEADDRESS,(ULONG)&screen->pixels,
LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE))) {
SDL_free(screen->hwdata);
screen->hwdata=NULL;
return -1;
}
else {
UnLockBitMap(screen->hwdata->lock);
screen->hwdata->lock=NULL;
}
screen->pitch=pitch;
this->UpdateRects = CGX_FakeUpdate;
D(bug("Accel video image configured (%lx, pitch %ld).\n",screen->pixels,screen->pitch));
return 0;
}
screen->pixels = SDL_malloc(screen->h*screen->pitch);
if ( screen->pixels == NULL ) {
SDL_OutOfMemory();
return(-1);
}
SDL_Ximage=screen->pixels;
if ( SDL_Ximage == NULL ) {
SDL_SetError("Couldn't create XImage");
return(-1);
}
this->UpdateRects = CGX_NormalUpdate;
return(0);
}
void CGX_DestroyImage(_THIS, SDL_Surface *screen)
{
if ( SDL_Ximage ) {
SDL_free(SDL_Ximage);
SDL_Ximage = NULL;
}
if ( screen ) {
screen->pixels = NULL;
if(screen->hwdata) {
SDL_free(screen->hwdata);
screen->hwdata=NULL;
}
}
}
/* This is a hack to see whether this system has more than 1 CPU */
static int num_CPU(void)
{
return 1;
}
int CGX_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)
{
int retval;
D(bug("Calling ResizeImage()\n"));
CGX_DestroyImage(this, screen);
if ( flags & SDL_OPENGL ) { /* No image when using GL */
retval = 0;
} else {
retval = CGX_SetupImage(this, screen);
/* We support asynchronous blitting on the display */
if ( flags & SDL_ASYNCBLIT ) {
if ( num_CPU() > 1 ) {
screen->flags |= SDL_ASYNCBLIT;
}
}
}
return(retval);
}
int CGX_AllocHWSurface(_THIS, SDL_Surface *surface)
{
D(bug("Alloc HW surface...%ld x %ld x %ld!\n",surface->w,surface->h,this->hidden->depth));
if(surface==SDL_VideoSurface)
{
D(bug("Allocation skipped, it's system one!\n"));
return 0;
}
if(!surface->hwdata)
{
if(!(surface->hwdata=SDL_malloc(sizeof(struct private_hwdata))))
return -1;
}
surface->hwdata->mask=NULL;
surface->hwdata->lock=NULL;
surface->hwdata->videodata=this;
surface->hwdata->allocated=0;
if(surface->hwdata->bmap=AllocBitMap(surface->w,surface->h,this->hidden->depth,BMF_MINPLANES,SDL_Display->RastPort.BitMap))
{
surface->hwdata->allocated=1;
surface->flags|=SDL_HWSURFACE;
D(bug("...OK\n"));
return 0;
}
else
{
SDL_free(surface->hwdata);
surface->hwdata=NULL;
}
return(-1);
}
void CGX_FreeHWSurface(_THIS, SDL_Surface *surface)
{
if(surface && surface!=SDL_VideoSurface && surface->hwdata)
{
D(bug("Free hw surface.\n"));
if(surface->hwdata->mask)
SDL_free(surface->hwdata->mask);
if(surface->hwdata->bmap&&surface->hwdata->allocated)
FreeBitMap(surface->hwdata->bmap);
SDL_free(surface->hwdata);
surface->hwdata=NULL;
surface->pixels=NULL;
D(bug("end of free hw surface\n"));
}
return;
}
int CGX_LockHWSurface(_THIS, SDL_Surface *surface)
{
if (surface->hwdata)
{
// D(bug("Locking a bitmap...\n"));
if(!surface->hwdata->lock)
{
Uint32 pitch;
if(!(surface->hwdata->lock=LockBitMapTags(surface->hwdata->bmap,
LBMI_BASEADDRESS,(ULONG)&surface->pixels,
LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE)))
return -1;
// surface->pitch e' a 16bit!
surface->pitch=pitch;
if(!currently_fullscreen&&surface==SDL_VideoSurface)
surface->pixels=((char *)surface->pixels)+(surface->pitch*(SDL_Window->BorderTop+SDL_Window->TopEdge)+
surface->format->BytesPerPixel*(SDL_Window->BorderLeft+SDL_Window->LeftEdge));
}
D(else bug("Already locked!!!\n"));
}
return(0);
}
void CGX_UnlockHWSurface(_THIS, SDL_Surface *surface)
{
if(surface->hwdata && surface->hwdata->lock)
{
UnLockBitMap(surface->hwdata->lock);
surface->hwdata->lock=NULL;
// surface->pixels=NULL;
}
}
int CGX_FlipHWSurface(_THIS, SDL_Surface *surface)
{
static int current=0;
if(this->hidden->dbuffer)
{
if(!SafeChange)
{
Wait(disp_sigbit);
// Non faccio nulla, vuoto solo la porta
while(GetMsg(dispport)!=NULL)
;
SafeChange=TRUE;
}
if(ChangeScreenBuffer(SDL_Display,this->hidden->SB[current^1]))
{
surface->hwdata->bmap=SDL_RastPort->BitMap=this->hidden->SB[current]->sb_BitMap;
SafeChange=FALSE;
SafeDisp=FALSE;
current^=1;
}
if(!SafeDisp)
{
Wait(safe_sigbit);
while(GetMsg(safeport)!=NULL)
;
SafeDisp=TRUE;
}
}
return(0);
}
/* Byte-swap the pixels in the display image */
static void CGX_SwapAllPixels(SDL_Surface *screen)
{
int x, y;
switch (screen->format->BytesPerPixel) {
case 2: {
Uint16 *spot;
for ( y=0; y<screen->h; ++y ) {
spot = (Uint16 *) ((Uint8 *)screen->pixels +
y * screen->pitch);
for ( x=0; x<screen->w; ++x, ++spot ) {
*spot = SDL_Swap16(*spot);
}
}
}
break;
case 4: {
Uint32 *spot;
for ( y=0; y<screen->h; ++y ) {
spot = (Uint32 *) ((Uint8 *)screen->pixels +
y * screen->pitch);
for ( x=0; x<screen->w; ++x, ++spot ) {
*spot = SDL_Swap32(*spot);
}
}
}
break;
default:
/* should never get here */
break;
}
}
static void CGX_SwapPixels(SDL_Surface *screen, int numrects, SDL_Rect *rects)
{
int i;
int x, minx, maxx;
int y, miny, maxy;
switch (screen->format->BytesPerPixel) {
case 2: {
Uint16 *spot;
for ( i=0; i<numrects; ++i ) {
minx = rects[i].x;
maxx = rects[i].x+rects[i].w;
miny = rects[i].y;
maxy = rects[i].y+rects[i].h;
for ( y=miny; y<maxy; ++y ) {
spot = (Uint16 *) ((Uint8 *)screen->pixels +
y * screen->pitch + minx * 2);
for ( x=minx; x<maxx; ++x, ++spot ) {
*spot = SDL_Swap16(*spot);
}
}
}
}
break;
case 4: {
Uint32 *spot;
for ( i=0; i<numrects; ++i ) {
minx = rects[i].x;
maxx = rects[i].x+rects[i].w;
miny = rects[i].y;
maxy = rects[i].y+rects[i].h;
for ( y=miny; y<maxy; ++y ) {
spot = (Uint32 *) ((Uint8 *)screen->pixels +
y * screen->pitch + minx * 4);
for ( x=minx; x<maxx; ++x, ++spot ) {
*spot = SDL_Swap32(*spot);
}
}
}
}
break;
default:
/* should never get here */
break;
}
}
#ifdef __SASC
#define USE_WPA WritePixelArray
#else
void USE_WPA(char *a,int b,int c,int d, struct RastPort *e,int f,int g, int h, int i, Uint32 l)
{
WritePixelArray(a,b,c,d,e,f,g,h,i,l);
}
#endif
static void CGX_FakeUpdate(_THIS, int numrects, SDL_Rect *rects)
{
}
static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
{
int i,format,customroutine=0;
#ifndef USE_CGX_WRITELUTPIXEL
int bpp;
#endif
if(this->hidden->same_format && !use_picasso96)
{
format=RECTFMT_RAW;
}
else switch(this->screen->format->BytesPerPixel)
{
case 4:
format=RECTFMT_RGBA;
break;
case 3:
format=RECTFMT_RGB;
break;
case 2:
customroutine=1;
break;
case 1:
// D(bug("soft depth: 8 hardbpp: %ld\n",this->hidden->depth));
if(this->hidden->depth>8)
{
#ifndef USE_CGX_WRITELUTPIXEL
if(this->hidden->depth>32)
customroutine=4;
else if(this->hidden->depth>16)
{
bpp=this->hidden->BytesPerPixel; // That one is the only one that needs bpp
customroutine=2; // The slow one!
}
else
customroutine=3;
#else
customroutine=2;
#endif
// format=RECTFMT_LUT8; Vecchia funzione x usare la WritePixelArray.
}
else
customroutine=1;
break;
default:
D(bug("Unable to blit this surface!\n"));
return;
}
/* Check for endian-swapped X server, swap if necessary (VERY slow!) */
if ( swap_pixels &&
((this->screen->format->BytesPerPixel%2) == 0) ) {
D(bug("Software Swapping! SLOOOW!\n"));
CGX_SwapPixels(this->screen, numrects, rects);
for ( i=0; i<numrects; ++i ) {
if ( ! rects[i].w ) { /* Clipped? */
continue;
}
USE_WPA(this->screen->pixels,rects[i].x, rects[i].y,this->screen->pitch,
SDL_RastPort,SDL_Window->BorderLeft+rects[i].x,SDL_Window->BorderTop+rects[i].y,
rects[i].w,rects[i].h,format);
}
CGX_SwapPixels(this->screen, numrects, rects);
}
else if (customroutine==2)
{
#ifdef USE_CGX_WRITELUTPIXEL
for ( i=0; i<numrects; ++i ) {
if ( ! rects[i].w ) { /* Clipped? */
continue;
}
WLUT(this->screen->pixels,rects[i].x, rects[i].y,this->screen->pitch,
SDL_RastPort,SDL_XPixels,SDL_Window->BorderLeft+rects[i].x,SDL_Window->BorderTop+rects[i].y,
rects[i].w,rects[i].h,CTABFMT_XRGB8);
}
#else
unsigned char *bm_address;
Uint32 destpitch;
APTR handle;
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,&bm_address,
LBMI_BYTESPERROW,&destpitch,TAG_DONE))
{
int srcwidth;
unsigned char *destbase;
register int j,k,t;
register unsigned char *mask,*dst;
register unsigned char *src,*dest;
// Aggiungo il bordo della finestra se sono fullscreen.
if(currently_fullscreen)
destbase=bm_address;
else
destbase=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel;
for ( i=0; i<numrects; ++i )
{
srcwidth=rects[i].w;
if ( !srcwidth ) { /* Clipped? */
continue;
}
dest=destbase+rects[i].x*this->hidden->BytesPerPixel;
dest+=(rects[i].y*destpitch);
src=((char *)(this->screen->pixels))+rects[i].x;
src+=(rects[i].y*this->screen->pitch);
for(j=rects[i].h;j;--j)
{
dst=dest;
// SLOW routine, used for 8->24 bit mapping
for(k=0;k<srcwidth;k++)
{
mask=(unsigned char *)(&SDL_XPixels[src[k]]);
for(t=0;t<bpp;t++)
{
dst[t]=mask[t];
}
dst+=bpp;
}
src+=this->screen->pitch;
dest+=destpitch;
}
}
UnLockBitMap(handle);
}
}
else if (customroutine==3)
{
unsigned char *bm_address;
Uint32 destpitch;
APTR handle;
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,&bm_address,
LBMI_BYTESPERROW,&destpitch,TAG_DONE))
{
int srcwidth;
unsigned char *destbase;
register int j,k;
register unsigned char *src,*dest;
register Uint16 *destl,*srcl;
if(currently_fullscreen)
destbase=bm_address;
else
destbase=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel;
for ( i=0; i<numrects; ++i )
{
srcwidth=rects[i].w;
if ( !srcwidth ) { /* Clipped? */
continue;
}
dest=destbase+rects[i].x*this->hidden->BytesPerPixel;
dest+=(rects[i].y*destpitch);
src=((char *)(this->screen->pixels))+rects[i].x;
src+=(rects[i].y*this->screen->pitch);
// This is the fast, well not too slow, remapping code for 16bit displays
for(j=rects[i].h;j;--j)
{
destl=(Uint16 *)dest;
for(k=0;k<srcwidth;k++)
{
srcl=(Uint16 *)&SDL_XPixels[src[k]];
*destl=*srcl;
destl++;
}
src+=this->screen->pitch;
dest+=destpitch;
}
}
UnLockBitMap(handle);
}
}
else if (customroutine==4)
{
unsigned char *bm_address;
Uint32 destpitch;
APTR handle;
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,&bm_address,
LBMI_BYTESPERROW,&destpitch,TAG_DONE))
{
int srcwidth;
unsigned char *destbase;
register int j,k;
register unsigned char *src,*dest;
register Uint32 *destl,*srcl;
if(currently_fullscreen)
destbase=bm_address;
else
destbase=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel;
for ( i=0; i<numrects; ++i )
{
srcwidth=rects[i].w;
if ( !srcwidth ) { /* Clipped? */
continue;
}
dest=destbase+rects[i].x*this->hidden->BytesPerPixel;
dest+=(rects[i].y*destpitch);
src=((char *)(this->screen->pixels))+rects[i].x;
src+=(rects[i].y*this->screen->pitch);
// This is the fast, well not too slow, remapping code for 32bit displays
for(j=rects[i].h;j;--j)
{
destl=(Uint32 *)dest;
for(k=0;k<srcwidth;k++)
{
srcl=(Uint32 *)&SDL_XPixels[src[k]];
*destl=*srcl;
destl++;
}
src+=this->screen->pitch;
dest+=destpitch;
}
}
UnLockBitMap(handle);
}
#endif
}
else if(customroutine)
{
unsigned char *bm_address;
Uint32 destpitch;
APTR handle;
// D(bug("Using customroutine!\n"));
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address,
LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE))
{
unsigned char *destbase;
register int j,srcwidth;
register unsigned char *src,*dest;
// Aggiungo il bordo della finestra se sono fullscreen.
if(currently_fullscreen)
destbase=bm_address;
else
destbase=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->screen->format->BytesPerPixel;
for ( i=0; i<numrects; ++i )
{
srcwidth=rects[i].w;
if ( !srcwidth ) { /* Clipped? */
continue;
}
dest=destbase+rects[i].x*this->screen->format->BytesPerPixel;
dest+=(rects[i].y*destpitch);
src=((char *)(this->screen->pixels))+rects[i].x*this->screen->format->BytesPerPixel;
src+=(rects[i].y*this->screen->pitch);
srcwidth*=this->screen->format->BytesPerPixel;
// D(bug("Rects: %ld,%ld %ld,%ld Src:%lx Dest:%lx\n",rects[i].x,rects[i].y,rects[i].w,rects[i].h,src,dest));
for(j=rects[i].h;j;--j)
{
SDL_memcpy(dest,src,srcwidth);
src+=this->screen->pitch;
dest+=destpitch;
}
}
UnLockBitMap(handle);
// D(bug("Rectblit addr: %lx pitch: %ld rects:%ld srcptr: %lx srcpitch: %ld\n",bm_address,destpitch,numrects,this->screen->pixels,this->screen->pitch));
}
}
else
{
for ( i=0; i<numrects; ++i ) {
if ( ! rects[i].w ) { /* Clipped? */
continue;
}
USE_WPA(this->screen->pixels,rects[i].x, rects[i].y,this->screen->pitch,
SDL_RastPort,SDL_Window->BorderLeft+rects[i].x,SDL_Window->BorderTop+rects[i].y,
rects[i].w,rects[i].h,format);
}
}
}
void CGX_RefreshDisplay(_THIS)
{
int format,customroutine=0;
#ifndef USE_CGX_WRITELUTPIXEL
int bpp;
#endif
/* Don't refresh a display that doesn't have an image (like GL) */
if ( ! SDL_Ximage ) {
return;
}
if(this->hidden->same_format && !use_picasso96)
{
format=RECTFMT_RAW;
}
else switch(this->screen->format->BytesPerPixel)
{
case 4:
format=RECTFMT_RGBA;
break;
case 3:
format=RECTFMT_RGB;
break;
case 2:
customroutine=1;
break;
case 1:
// D(bug("soft depth: 8 hardbpp: %ld\n",this->hidden->depth));
if(this->hidden->depth>8)
{
#ifndef USE_CGX_WRITELUTPIXEL
if(this->hidden->depth>32)
customroutine=4;
else if(this->hidden->depth>16)
{
bpp=this->hidden->BytesPerPixel; // That one is the only one that needs bpp
customroutine=2; // The slow one!
}
else
customroutine=3;
#else
customroutine=2;
#endif
// format=RECTFMT_LUT8;
}
else
customroutine=1;
break;
}
/* Check for endian-swapped X server, swap if necessary */
if ( swap_pixels &&
((this->screen->format->BytesPerPixel%2) == 0) ) {
CGX_SwapAllPixels(this->screen);
USE_WPA(this->screen->pixels,0,0,this->screen->pitch,
SDL_RastPort,SDL_Window->BorderLeft,SDL_Window->BorderTop,
this->screen->w,this->screen->h,format);
CGX_SwapAllPixels(this->screen);
}
else if (customroutine==2)
{
#ifdef USE_CGX_WRITELUTPIXEL
WLUT(this->screen->pixels,0,0,this->screen->pitch,
SDL_RastPort,SDL_XPixels,SDL_Window->BorderLeft,SDL_Window->BorderTop,
this->screen->w,this->screen->h,CTABFMT_XRGB8);
#else
unsigned char *bm_address;
Uint32 destpitch;
APTR handle;
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address,
LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE))
{
register int j,k,t;
register unsigned char *mask,*dst;
register unsigned char *src,*dest;
// Aggiungo il bordo della finestra se sono fullscreen.
if(!currently_fullscreen)
dest=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel;
else
dest=bm_address;
src=this->screen->pixels;
for(j=this->screen->h;j;--j)
{
dst=dest;
// SLOW routine, used for 8->24 bit mapping
for(k=0;k<this->screen->w;k++)
{
mask=(unsigned char *)(&SDL_XPixels[src[k]]);
for(t=0;t<bpp;t++)
{
dst[t]=mask[t];
}
dst+=bpp;
}
src+=this->screen->pitch;
dest+=destpitch;
}
UnLockBitMap(handle);
}
}
else if (customroutine==3)
{
unsigned char *bm_address;
Uint32 destpitch;
APTR handle;
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address,
LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE))
{
register int j,k;
register unsigned char *src,*dest;
register Uint16 *destl,*srcl;
if(!currently_fullscreen)
dest=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel;
else
dest=bm_address;
src=this->screen->pixels;
// This is the fast, well not too slow, remapping code for 16bit displays
for(j=this->screen->h;j;--j)
{
destl=(Uint16 *)dest;
for(k=0;k<this->screen->w;k++)
{
srcl=(Uint16 *)&SDL_XPixels[src[k]];
*destl=*srcl;
destl++;
}
src+=this->screen->pitch;
dest+=destpitch;
}
UnLockBitMap(handle);
}
}
else if (customroutine==4)
{
unsigned char *bm_address;
Uint32 destpitch;
APTR handle;
if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address,
LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE))
{
register int j,k;
register unsigned char *src,*dest;
register Uint32 *destl,*srcl;
if(!currently_fullscreen)
dest=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel;
else
dest=bm_address;
src=this->screen->pixels;
// This is the fast, well not too slow, remapping code for 32bit displays
for(j=this->screen->h;j;--j)
{
destl=(Uint32 *)dest;
for(k=0;k<this->screen->w;k++)
{
srcl=(Uint32 *)&SDL_XPixels[src[k]];
*destl=*srcl;
destl++;
}
src+=this->screen->pitch;
dest+=destpitch;
}
UnLockBitMap(handle);
}
#endif
}
else if(customroutine)
{
unsigned char *bm_address;
Uint32 destpitch;
APTR handle;
if(handle=LockBitMapTags(SDL_RastPort->BitMap,
LBMI_BASEADDRESS,(ULONG)&bm_address,
LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE))
{
register int j;
register unsigned char *src,*dest;
if(!currently_fullscreen)
dest=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->screen->format->BytesPerPixel;
else
dest=bm_address;
src=this->screen->pixels;
// D(bug("addr: %lx pitch: %ld src:%lx srcpitch: %ld\n",dest,destpitch,this->screen->pixels,this->screen->pitch));
if(this->screen->pitch==destpitch)
{
SDL_memcpy(dest,src,this->screen->pitch*this->screen->h);
}
else
{
for(j=this->screen->h;j;--j)
{
SDL_memcpy(dest,src,this->screen->pitch);
src+=this->screen->pitch;
dest+=destpitch;
}
}
UnLockBitMap(handle);
}
}
else
{
USE_WPA(this->screen->pixels,0,0,this->screen->pitch,
SDL_RastPort,SDL_Window->BorderLeft,SDL_Window->BorderTop,
this->screen->w,this->screen->h,format);
}
}