diff options
Diffstat (limited to 'distrib/sdl-1.2.12/src/video/cybergfx/SDL_cgximage.c')
| -rw-r--r-- | distrib/sdl-1.2.12/src/video/cybergfx/SDL_cgximage.c | 906 |
1 files changed, 906 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.12/src/video/cybergfx/SDL_cgximage.c b/distrib/sdl-1.2.12/src/video/cybergfx/SDL_cgximage.c new file mode 100644 index 0000000..3e8938e --- /dev/null +++ b/distrib/sdl-1.2.12/src/video/cybergfx/SDL_cgximage.c @@ -0,0 +1,906 @@ +/* + 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); + } + +} |