| /* |
| 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); |
| } |
| |
| } |