Mercurial > sdl-ios-xcode
annotate src/video/cybergfx/SDL_cgximage.c @ 1554:0ca607a5d173
Fixed bug #84
Date: Sun, 23 Oct 2005 16:39:03 +0200
From: "A. Schmid" <sahib@phreaker.net>
Subject: [SDL] no software surfaces with svgalib driver?
Hi,
I noticed that the SDL (1.2.9) svgalib driver only makes use of linear
addressable (framebuffer) video modes. On older systems (like one of
mine), linear addressable modes are often not available.
Especially for cards with VESA VBE < 2.0 the svgalib vesa driver is
unusable, since VESA only supports framebuffering for VBE 2.0 and later.
The changes necessary to add support for software surfaces seem to be
relatively small. I only had to hack src/video/svga/SDL_svgavideo.c (see
attached patch). The code worked fine for me, but it is no more than a
proof of concept and should be reviewed (probably has a memory leak when
switching modes). It also uses the vgagl library (included in the
svgalib package) and needs to be linked against it.
-Alex
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Sun, 19 Mar 2006 12:04:40 +0000 |
| parents | d910939febfa |
| children | e49147870aac c121d94672cb |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
3 Copyright (C) 1997-2006 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
6 modify it under the terms of the GNU Lesser General Public |
| 0 | 7 License as published by the Free Software Foundation; either |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
8 version 2.1 of the License, or (at your option) any later version. |
| 0 | 9 |
| 10 This library is distributed in the hope that it will be useful, | |
| 11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
13 Lesser General Public License for more details. |
| 0 | 14 |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
15 You should have received a copy of the GNU Lesser General Public |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
16 License along with this library; if not, write to the Free Software |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 0 | 18 |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
21
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
22 #include "SDL_config.h" |
| 0 | 23 |
| 24 #include "SDL_endian.h" | |
| 25 #include "SDL_cgximage_c.h" | |
| 26 | |
| 27 #ifdef HAVE_KSTAT | |
| 28 #include <kstat.h> | |
| 29 #endif | |
| 30 | |
| 31 #ifdef USE_CGX_WRITELUTPIXEL | |
| 32 #if defined(__SASC) || defined(__PPC__) | |
| 33 #define WLUT WriteLUTPixelArray | |
| 34 #else | |
| 35 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) | |
| 36 { WriteLUTPixelArray(a,b,c,d,e,f,g,h,i,l,m); } | |
| 37 #endif | |
| 38 | |
| 39 #endif | |
| 40 | |
| 41 /* Various screen update functions available */ | |
| 42 static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects); | |
| 43 static void CGX_FakeUpdate(_THIS, int numrects, SDL_Rect *rects); | |
| 44 | |
| 45 BOOL SafeDisp=TRUE,SafeChange=TRUE; | |
| 46 struct MsgPort *safeport=NULL,*dispport=NULL; | |
| 47 ULONG safe_sigbit,disp_sigbit; | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
48 int use_picasso96=1; |
| 0 | 49 |
| 50 int CGX_SetupImage(_THIS, SDL_Surface *screen) | |
| 51 { | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
52 SDL_Ximage=NULL; |
|
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
53 |
|
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
54 if(screen->flags&SDL_HWSURFACE) { |
|
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
55 ULONG pitch; |
| 0 | 56 |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
57 if(!screen->hwdata) { |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
58 if(!(screen->hwdata=SDL_malloc(sizeof(struct private_hwdata)))) |
| 0 | 59 return -1; |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
60 |
| 0 | 61 D(bug("Creating system accel struct\n")); |
| 62 } | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
63 screen->hwdata->lock=NULL; |
|
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
64 screen->hwdata->allocated=0; |
|
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
65 screen->hwdata->mask=NULL; |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
66 screen->hwdata->bmap=SDL_RastPort->BitMap; |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
67 screen->hwdata->videodata=this; |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
68 |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
69 if(!(screen->hwdata->lock=LockBitMapTags(screen->hwdata->bmap, |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
70 LBMI_BASEADDRESS,(ULONG)&screen->pixels, |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
71 LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE))) { |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
72 SDL_free(screen->hwdata); |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
73 screen->hwdata=NULL; |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
74 return -1; |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
75 } |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
76 else { |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
77 UnLockBitMap(screen->hwdata->lock); |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
78 screen->hwdata->lock=NULL; |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
79 } |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
80 |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
81 screen->pitch=pitch; |
| 0 | 82 |
| 83 this->UpdateRects = CGX_FakeUpdate; | |
| 84 | |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
85 D(bug("Accel video image configured (%lx, pitch %ld).\n",screen->pixels,screen->pitch)); |
| 0 | 86 return 0; |
| 87 } | |
| 88 | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
89 screen->pixels = SDL_malloc(screen->h*screen->pitch); |
| 0 | 90 |
| 91 if ( screen->pixels == NULL ) { | |
| 92 SDL_OutOfMemory(); | |
| 93 return(-1); | |
| 94 } | |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
95 |
| 0 | 96 SDL_Ximage=screen->pixels; |
| 97 | |
| 98 if ( SDL_Ximage == NULL ) { | |
| 99 SDL_SetError("Couldn't create XImage"); | |
| 100 return(-1); | |
| 101 } | |
| 102 | |
| 103 this->UpdateRects = CGX_NormalUpdate; | |
| 104 | |
| 105 return(0); | |
| 106 } | |
| 107 | |
| 108 void CGX_DestroyImage(_THIS, SDL_Surface *screen) | |
| 109 { | |
| 110 if ( SDL_Ximage ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
111 SDL_free(SDL_Ximage); |
| 0 | 112 SDL_Ximage = NULL; |
| 113 } | |
| 114 if ( screen ) { | |
| 115 screen->pixels = NULL; | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
116 |
|
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
117 if(screen->hwdata) { |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
118 SDL_free(screen->hwdata); |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
119 screen->hwdata=NULL; |
|
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
120 } |
| 0 | 121 } |
| 122 } | |
| 123 | |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
124 /* This is a hack to see whether this system has more than 1 CPU */ |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
125 static int num_CPU(void) |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
126 { |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
127 return 1; |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
128 } |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
129 |
| 0 | 130 int CGX_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags) |
| 131 { | |
| 132 int retval; | |
| 133 | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
134 D(bug("Calling ResizeImage()\n")); |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
135 |
| 0 | 136 CGX_DestroyImage(this, screen); |
| 137 | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
138 if ( flags & SDL_OPENGL ) { /* No image when using GL */ |
| 0 | 139 retval = 0; |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
140 } else { |
| 0 | 141 retval = CGX_SetupImage(this, screen); |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
142 /* We support asynchronous blitting on the display */ |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
143 if ( flags & SDL_ASYNCBLIT ) { |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
144 if ( num_CPU() > 1 ) { |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
145 screen->flags |= SDL_ASYNCBLIT; |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
146 } |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
147 } |
| 0 | 148 } |
| 149 return(retval); | |
| 150 } | |
| 151 | |
| 152 int CGX_AllocHWSurface(_THIS, SDL_Surface *surface) | |
| 153 { | |
| 154 D(bug("Alloc HW surface...%ld x %ld x %ld!\n",surface->w,surface->h,this->hidden->depth)); | |
| 155 | |
| 156 if(surface==SDL_VideoSurface) | |
| 157 { | |
| 158 D(bug("Allocation skipped, it's system one!\n")); | |
| 159 return 0; | |
| 160 } | |
| 161 | |
| 162 if(!surface->hwdata) | |
| 163 { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
164 if(!(surface->hwdata=SDL_malloc(sizeof(struct private_hwdata)))) |
| 0 | 165 return -1; |
| 166 } | |
| 167 | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
168 surface->hwdata->mask=NULL; |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
169 surface->hwdata->lock=NULL; |
|
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
170 surface->hwdata->videodata=this; |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
171 surface->hwdata->allocated=0; |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
172 |
| 0 | 173 if(surface->hwdata->bmap=AllocBitMap(surface->w,surface->h,this->hidden->depth,BMF_MINPLANES,SDL_Display->RastPort.BitMap)) |
| 174 { | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
175 surface->hwdata->allocated=1; |
| 0 | 176 surface->flags|=SDL_HWSURFACE; |
| 177 D(bug("...OK\n")); | |
| 178 return 0; | |
| 179 } | |
| 180 else | |
| 181 { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
182 SDL_free(surface->hwdata); |
| 0 | 183 surface->hwdata=NULL; |
| 184 } | |
| 185 | |
| 186 return(-1); | |
| 187 } | |
| 188 void CGX_FreeHWSurface(_THIS, SDL_Surface *surface) | |
| 189 { | |
| 190 if(surface && surface!=SDL_VideoSurface && surface->hwdata) | |
| 191 { | |
| 192 D(bug("Free hw surface.\n")); | |
| 193 | |
| 194 if(surface->hwdata->mask) | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
195 SDL_free(surface->hwdata->mask); |
| 0 | 196 |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
197 if(surface->hwdata->bmap&&surface->hwdata->allocated) |
| 0 | 198 FreeBitMap(surface->hwdata->bmap); |
| 199 | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
200 SDL_free(surface->hwdata); |
| 0 | 201 surface->hwdata=NULL; |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
202 surface->pixels=NULL; |
|
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
203 D(bug("end of free hw surface\n")); |
| 0 | 204 } |
| 205 return; | |
| 206 } | |
| 207 | |
| 208 int CGX_LockHWSurface(_THIS, SDL_Surface *surface) | |
| 209 { | |
| 210 if (surface->hwdata) | |
| 211 { | |
| 212 // D(bug("Locking a bitmap...\n")); | |
| 213 if(!surface->hwdata->lock) | |
| 214 { | |
| 215 Uint32 pitch; | |
| 216 | |
| 217 if(!(surface->hwdata->lock=LockBitMapTags(surface->hwdata->bmap, | |
| 218 LBMI_BASEADDRESS,(ULONG)&surface->pixels, | |
| 219 LBMI_BYTESPERROW,(ULONG)&pitch,TAG_DONE))) | |
| 220 return -1; | |
| 221 | |
| 222 // surface->pitch e' a 16bit! | |
| 223 | |
| 224 surface->pitch=pitch; | |
| 225 | |
| 226 if(!currently_fullscreen&&surface==SDL_VideoSurface) | |
| 227 surface->pixels=((char *)surface->pixels)+(surface->pitch*(SDL_Window->BorderTop+SDL_Window->TopEdge)+ | |
| 228 surface->format->BytesPerPixel*(SDL_Window->BorderLeft+SDL_Window->LeftEdge)); | |
| 229 } | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
230 D(else bug("Already locked!!!\n")); |
| 0 | 231 } |
| 232 return(0); | |
| 233 } | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
234 |
| 0 | 235 void CGX_UnlockHWSurface(_THIS, SDL_Surface *surface) |
| 236 { | |
| 237 if(surface->hwdata && surface->hwdata->lock) | |
| 238 { | |
| 239 UnLockBitMap(surface->hwdata->lock); | |
| 240 surface->hwdata->lock=NULL; | |
|
21
75a95f82bc1f
Updated the Amiga OS port of SDL (thanks Gabriele)
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
241 // surface->pixels=NULL; |
| 0 | 242 } |
| 243 } | |
| 244 | |
| 245 int CGX_FlipHWSurface(_THIS, SDL_Surface *surface) | |
| 246 { | |
| 247 static int current=0; | |
| 248 | |
| 249 if(this->hidden->dbuffer) | |
| 250 { | |
| 251 if(!SafeChange) | |
| 252 { | |
| 253 Wait(disp_sigbit); | |
| 254 // Non faccio nulla, vuoto solo la porta | |
| 255 while(GetMsg(dispport)!=NULL) | |
| 256 ; | |
| 257 SafeChange=TRUE; | |
| 258 } | |
| 259 | |
| 260 if(ChangeScreenBuffer(SDL_Display,this->hidden->SB[current^1])) | |
| 261 { | |
| 262 surface->hwdata->bmap=SDL_RastPort->BitMap=this->hidden->SB[current]->sb_BitMap; | |
| 263 SafeChange=FALSE; | |
| 264 SafeDisp=FALSE; | |
| 265 current^=1; | |
| 266 } | |
| 267 | |
| 268 if(!SafeDisp) | |
| 269 { | |
| 270 Wait(safe_sigbit); | |
| 271 while(GetMsg(safeport)!=NULL) | |
| 272 ; | |
| 273 SafeDisp=TRUE; | |
| 274 } | |
| 275 | |
| 276 } | |
| 277 return(0); | |
| 278 } | |
| 279 | |
| 280 /* Byte-swap the pixels in the display image */ | |
| 281 static void CGX_SwapAllPixels(SDL_Surface *screen) | |
| 282 { | |
| 283 int x, y; | |
| 284 | |
| 285 switch (screen->format->BytesPerPixel) { | |
| 286 case 2: { | |
| 287 Uint16 *spot; | |
| 288 for ( y=0; y<screen->h; ++y ) { | |
| 289 spot = (Uint16 *) ((Uint8 *)screen->pixels + | |
| 290 y * screen->pitch); | |
| 291 for ( x=0; x<screen->w; ++x, ++spot ) { | |
| 292 *spot = SDL_Swap16(*spot); | |
| 293 } | |
| 294 } | |
| 295 } | |
| 296 break; | |
| 297 | |
| 298 case 4: { | |
| 299 Uint32 *spot; | |
| 300 for ( y=0; y<screen->h; ++y ) { | |
| 301 spot = (Uint32 *) ((Uint8 *)screen->pixels + | |
| 302 y * screen->pitch); | |
| 303 for ( x=0; x<screen->w; ++x, ++spot ) { | |
| 304 *spot = SDL_Swap32(*spot); | |
| 305 } | |
| 306 } | |
| 307 } | |
| 308 break; | |
| 309 | |
| 310 default: | |
| 311 /* should never get here */ | |
| 312 break; | |
| 313 } | |
| 314 } | |
| 315 static void CGX_SwapPixels(SDL_Surface *screen, int numrects, SDL_Rect *rects) | |
| 316 { | |
| 317 int i; | |
| 318 int x, minx, maxx; | |
| 319 int y, miny, maxy; | |
| 320 | |
| 321 switch (screen->format->BytesPerPixel) { | |
| 322 case 2: { | |
| 323 Uint16 *spot; | |
| 324 for ( i=0; i<numrects; ++i ) { | |
| 325 minx = rects[i].x; | |
| 326 maxx = rects[i].x+rects[i].w; | |
| 327 miny = rects[i].y; | |
| 328 maxy = rects[i].y+rects[i].h; | |
| 329 for ( y=miny; y<maxy; ++y ) { | |
| 330 spot = (Uint16 *) ((Uint8 *)screen->pixels + | |
| 331 y * screen->pitch + minx * 2); | |
| 332 for ( x=minx; x<maxx; ++x, ++spot ) { | |
| 333 *spot = SDL_Swap16(*spot); | |
| 334 } | |
| 335 } | |
| 336 } | |
| 337 } | |
| 338 break; | |
| 339 | |
| 340 case 4: { | |
| 341 Uint32 *spot; | |
| 342 for ( i=0; i<numrects; ++i ) { | |
| 343 minx = rects[i].x; | |
| 344 maxx = rects[i].x+rects[i].w; | |
| 345 miny = rects[i].y; | |
| 346 maxy = rects[i].y+rects[i].h; | |
| 347 for ( y=miny; y<maxy; ++y ) { | |
| 348 spot = (Uint32 *) ((Uint8 *)screen->pixels + | |
| 349 y * screen->pitch + minx * 4); | |
| 350 for ( x=minx; x<maxx; ++x, ++spot ) { | |
| 351 *spot = SDL_Swap32(*spot); | |
| 352 } | |
| 353 } | |
| 354 } | |
| 355 } | |
| 356 break; | |
| 357 | |
| 358 default: | |
| 359 /* should never get here */ | |
| 360 break; | |
| 361 } | |
| 362 } | |
| 363 | |
| 364 #ifdef __SASC | |
| 365 | |
| 366 #define USE_WPA WritePixelArray | |
| 367 #else | |
| 368 | |
| 369 void USE_WPA(char *a,int b,int c,int d, struct RastPort *e,int f,int g, int h, int i, Uint32 l) | |
| 370 { | |
| 371 WritePixelArray(a,b,c,d,e,f,g,h,i,l); | |
| 372 } | |
| 373 | |
| 374 #endif | |
| 375 | |
| 376 static void CGX_FakeUpdate(_THIS, int numrects, SDL_Rect *rects) | |
| 377 { | |
| 378 } | |
| 379 | |
| 380 static void CGX_NormalUpdate(_THIS, int numrects, SDL_Rect *rects) | |
| 381 { | |
| 382 int i,format,customroutine=0; | |
| 383 #ifndef USE_CGX_WRITELUTPIXEL | |
| 384 int bpp; | |
| 385 #endif | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
386 if(this->hidden->same_format && !use_picasso96) |
| 0 | 387 { |
| 388 format=RECTFMT_RAW; | |
| 389 } | |
| 390 else switch(this->screen->format->BytesPerPixel) | |
| 391 { | |
| 392 case 4: | |
| 393 format=RECTFMT_RGBA; | |
| 394 break; | |
| 395 case 3: | |
| 396 format=RECTFMT_RGB; | |
| 397 break; | |
| 398 case 2: | |
| 399 customroutine=1; | |
| 400 break; | |
| 401 case 1: | |
| 402 // D(bug("soft depth: 8 hardbpp: %ld\n",this->hidden->depth)); | |
| 403 if(this->hidden->depth>8) | |
| 404 { | |
| 405 #ifndef USE_CGX_WRITELUTPIXEL | |
| 406 if(this->hidden->depth>32) | |
| 407 customroutine=4; | |
| 408 else if(this->hidden->depth>16) | |
| 409 { | |
| 410 bpp=this->hidden->BytesPerPixel; // That one is the only one that needs bpp | |
| 411 customroutine=2; // The slow one! | |
| 412 } | |
| 413 else | |
| 414 customroutine=3; | |
| 415 #else | |
| 416 | |
| 417 customroutine=2; | |
| 418 #endif | |
| 419 | |
| 420 // format=RECTFMT_LUT8; Vecchia funzione x usare la WritePixelArray. | |
| 421 } | |
| 422 else | |
| 423 customroutine=1; | |
| 424 break; | |
| 425 default: | |
| 426 D(bug("Unable to blit this surface!\n")); | |
| 427 return; | |
| 428 } | |
| 429 | |
| 430 /* Check for endian-swapped X server, swap if necessary (VERY slow!) */ | |
| 431 if ( swap_pixels && | |
| 432 ((this->screen->format->BytesPerPixel%2) == 0) ) { | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
433 D(bug("Software Swapping! SLOOOW!\n")); |
| 0 | 434 CGX_SwapPixels(this->screen, numrects, rects); |
| 435 for ( i=0; i<numrects; ++i ) { | |
| 436 if ( ! rects[i].w ) { /* Clipped? */ | |
| 437 continue; | |
| 438 } | |
| 439 USE_WPA(this->screen->pixels,rects[i].x, rects[i].y,this->screen->pitch, | |
| 440 SDL_RastPort,SDL_Window->BorderLeft+rects[i].x,SDL_Window->BorderTop+rects[i].y, | |
| 441 rects[i].w,rects[i].h,format); | |
| 442 } | |
| 443 CGX_SwapPixels(this->screen, numrects, rects); | |
| 444 } | |
| 445 else if (customroutine==2) | |
| 446 { | |
| 447 #ifdef USE_CGX_WRITELUTPIXEL | |
| 448 for ( i=0; i<numrects; ++i ) { | |
| 449 if ( ! rects[i].w ) { /* Clipped? */ | |
| 450 continue; | |
| 451 } | |
| 452 | |
| 453 WLUT(this->screen->pixels,rects[i].x, rects[i].y,this->screen->pitch, | |
| 454 SDL_RastPort,SDL_XPixels,SDL_Window->BorderLeft+rects[i].x,SDL_Window->BorderTop+rects[i].y, | |
| 455 rects[i].w,rects[i].h,CTABFMT_XRGB8); | |
| 456 } | |
| 457 #else | |
| 458 unsigned char *bm_address; | |
| 459 Uint32 destpitch; | |
| 460 APTR handle; | |
| 461 | |
| 462 if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,&bm_address, | |
| 463 LBMI_BYTESPERROW,&destpitch,TAG_DONE)) | |
| 464 { | |
| 465 int srcwidth; | |
| 466 unsigned char *destbase; | |
| 467 register int j,k,t; | |
| 468 register unsigned char *mask,*dst; | |
| 469 register unsigned char *src,*dest; | |
| 470 | |
| 471 // Aggiungo il bordo della finestra se sono fullscreen. | |
| 472 if(currently_fullscreen) | |
| 473 destbase=bm_address; | |
| 474 else | |
| 475 destbase=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel; | |
| 476 | |
| 477 for ( i=0; i<numrects; ++i ) | |
| 478 { | |
| 479 srcwidth=rects[i].w; | |
| 480 | |
| 481 if ( !srcwidth ) { /* Clipped? */ | |
| 482 continue; | |
| 483 } | |
| 484 | |
| 485 dest=destbase+rects[i].x*this->hidden->BytesPerPixel; | |
| 486 dest+=(rects[i].y*destpitch); | |
| 487 src=((char *)(this->screen->pixels))+rects[i].x; | |
| 488 src+=(rects[i].y*this->screen->pitch); | |
| 489 | |
| 490 for(j=rects[i].h;j;--j) | |
| 491 { | |
| 492 dst=dest; | |
| 493 // SLOW routine, used for 8->24 bit mapping | |
| 494 for(k=0;k<srcwidth;k++) | |
| 495 { | |
| 496 mask=(unsigned char *)(&SDL_XPixels[src[k]]); | |
| 497 for(t=0;t<bpp;t++) | |
| 498 { | |
| 499 dst[t]=mask[t]; | |
| 500 } | |
| 501 dst+=bpp; | |
| 502 } | |
| 503 src+=this->screen->pitch; | |
| 504 dest+=destpitch; | |
| 505 } | |
| 506 } | |
| 507 UnLockBitMap(handle); | |
| 508 } | |
| 509 } | |
| 510 else if (customroutine==3) | |
| 511 { | |
| 512 unsigned char *bm_address; | |
| 513 Uint32 destpitch; | |
| 514 APTR handle; | |
| 515 | |
| 516 if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,&bm_address, | |
| 517 LBMI_BYTESPERROW,&destpitch,TAG_DONE)) | |
| 518 { | |
| 519 int srcwidth; | |
| 520 unsigned char *destbase; | |
| 521 register int j,k; | |
| 522 register unsigned char *src,*dest; | |
| 523 register Uint16 *destl,*srcl; | |
| 524 | |
| 525 if(currently_fullscreen) | |
| 526 destbase=bm_address; | |
| 527 else | |
| 528 destbase=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel; | |
| 529 | |
| 530 for ( i=0; i<numrects; ++i ) | |
| 531 { | |
| 532 srcwidth=rects[i].w; | |
| 533 | |
| 534 if ( !srcwidth ) { /* Clipped? */ | |
| 535 continue; | |
| 536 } | |
| 537 | |
| 538 dest=destbase+rects[i].x*this->hidden->BytesPerPixel; | |
| 539 dest+=(rects[i].y*destpitch); | |
| 540 src=((char *)(this->screen->pixels))+rects[i].x; | |
| 541 src+=(rects[i].y*this->screen->pitch); | |
| 542 | |
| 543 // This is the fast, well not too slow, remapping code for 16bit displays | |
| 544 | |
| 545 for(j=rects[i].h;j;--j) | |
| 546 { | |
| 547 destl=(Uint16 *)dest; | |
| 548 | |
| 549 for(k=0;k<srcwidth;k++) | |
| 550 { | |
| 551 srcl=(Uint16 *)&SDL_XPixels[src[k]]; | |
| 552 *destl=*srcl; | |
| 553 destl++; | |
| 554 } | |
| 555 src+=this->screen->pitch; | |
| 556 dest+=destpitch; | |
| 557 } | |
| 558 } | |
| 559 UnLockBitMap(handle); | |
| 560 } | |
| 561 } | |
| 562 else if (customroutine==4) | |
| 563 { | |
| 564 unsigned char *bm_address; | |
| 565 Uint32 destpitch; | |
| 566 APTR handle; | |
| 567 | |
| 568 if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,&bm_address, | |
| 569 LBMI_BYTESPERROW,&destpitch,TAG_DONE)) | |
| 570 { | |
| 571 int srcwidth; | |
| 572 unsigned char *destbase; | |
| 573 register int j,k; | |
| 574 register unsigned char *src,*dest; | |
| 575 register Uint32 *destl,*srcl; | |
| 576 | |
| 577 if(currently_fullscreen) | |
| 578 destbase=bm_address; | |
| 579 else | |
| 580 destbase=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel; | |
| 581 | |
| 582 for ( i=0; i<numrects; ++i ) | |
| 583 { | |
| 584 srcwidth=rects[i].w; | |
| 585 | |
| 586 if ( !srcwidth ) { /* Clipped? */ | |
| 587 continue; | |
| 588 } | |
| 589 | |
| 590 dest=destbase+rects[i].x*this->hidden->BytesPerPixel; | |
| 591 dest+=(rects[i].y*destpitch); | |
| 592 src=((char *)(this->screen->pixels))+rects[i].x; | |
| 593 src+=(rects[i].y*this->screen->pitch); | |
| 594 | |
| 595 // This is the fast, well not too slow, remapping code for 32bit displays | |
| 596 | |
| 597 for(j=rects[i].h;j;--j) | |
| 598 { | |
| 599 destl=(Uint32 *)dest; | |
| 600 | |
| 601 for(k=0;k<srcwidth;k++) | |
| 602 { | |
| 603 srcl=(Uint32 *)&SDL_XPixels[src[k]]; | |
| 604 *destl=*srcl; | |
| 605 destl++; | |
| 606 } | |
| 607 src+=this->screen->pitch; | |
| 608 dest+=destpitch; | |
| 609 } | |
| 610 } | |
| 611 UnLockBitMap(handle); | |
| 612 } | |
| 613 #endif | |
| 614 } | |
| 615 else if(customroutine) | |
| 616 { | |
| 617 unsigned char *bm_address; | |
| 618 Uint32 destpitch; | |
| 619 APTR handle; | |
| 620 | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
621 // D(bug("Using customroutine!\n")); |
| 0 | 622 |
| 623 if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address, | |
| 624 LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE)) | |
| 625 { | |
| 626 unsigned char *destbase; | |
| 627 register int j,srcwidth; | |
| 628 register unsigned char *src,*dest; | |
| 629 | |
| 630 // Aggiungo il bordo della finestra se sono fullscreen. | |
| 631 if(currently_fullscreen) | |
| 632 destbase=bm_address; | |
| 633 else | |
| 634 destbase=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->screen->format->BytesPerPixel; | |
| 635 | |
| 636 for ( i=0; i<numrects; ++i ) | |
| 637 { | |
| 638 srcwidth=rects[i].w; | |
| 639 | |
| 640 if ( !srcwidth ) { /* Clipped? */ | |
| 641 continue; | |
| 642 } | |
| 643 | |
| 644 dest=destbase+rects[i].x*this->screen->format->BytesPerPixel; | |
| 645 dest+=(rects[i].y*destpitch); | |
| 646 src=((char *)(this->screen->pixels))+rects[i].x*this->screen->format->BytesPerPixel; | |
| 647 src+=(rects[i].y*this->screen->pitch); | |
| 648 | |
| 649 srcwidth*=this->screen->format->BytesPerPixel; | |
| 650 | |
| 651 // 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)); | |
| 652 | |
| 653 for(j=rects[i].h;j;--j) | |
| 654 { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
655 SDL_memcpy(dest,src,srcwidth); |
| 0 | 656 src+=this->screen->pitch; |
| 657 dest+=destpitch; | |
| 658 } | |
| 659 } | |
| 660 UnLockBitMap(handle); | |
| 661 // D(bug("Rectblit addr: %lx pitch: %ld rects:%ld srcptr: %lx srcpitch: %ld\n",bm_address,destpitch,numrects,this->screen->pixels,this->screen->pitch)); | |
| 662 } | |
| 663 } | |
| 664 else | |
| 665 { | |
| 666 for ( i=0; i<numrects; ++i ) { | |
| 667 if ( ! rects[i].w ) { /* Clipped? */ | |
| 668 continue; | |
| 669 } | |
| 670 USE_WPA(this->screen->pixels,rects[i].x, rects[i].y,this->screen->pitch, | |
| 671 SDL_RastPort,SDL_Window->BorderLeft+rects[i].x,SDL_Window->BorderTop+rects[i].y, | |
| 672 rects[i].w,rects[i].h,format); | |
| 673 } | |
| 674 } | |
| 675 } | |
| 676 | |
| 677 void CGX_RefreshDisplay(_THIS) | |
| 678 { | |
| 679 int format,customroutine=0; | |
| 680 #ifndef USE_CGX_WRITELUTPIXEL | |
| 681 int bpp; | |
| 682 #endif | |
| 683 /* Don't refresh a display that doesn't have an image (like GL) */ | |
| 684 if ( ! SDL_Ximage ) { | |
| 685 return; | |
| 686 } | |
| 687 | |
|
255
dcb5e869f8b5
Updated Amiga port by Gabriele Greco
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
688 if(this->hidden->same_format && !use_picasso96) |
| 0 | 689 { |
| 690 format=RECTFMT_RAW; | |
| 691 } | |
| 692 else switch(this->screen->format->BytesPerPixel) | |
| 693 { | |
| 694 case 4: | |
| 695 format=RECTFMT_RGBA; | |
| 696 break; | |
| 697 case 3: | |
| 698 format=RECTFMT_RGB; | |
| 699 break; | |
| 700 case 2: | |
| 701 customroutine=1; | |
| 702 break; | |
| 703 case 1: | |
| 704 // D(bug("soft depth: 8 hardbpp: %ld\n",this->hidden->depth)); | |
| 705 if(this->hidden->depth>8) | |
| 706 { | |
| 707 #ifndef USE_CGX_WRITELUTPIXEL | |
| 708 if(this->hidden->depth>32) | |
| 709 customroutine=4; | |
| 710 else if(this->hidden->depth>16) | |
| 711 { | |
| 712 bpp=this->hidden->BytesPerPixel; // That one is the only one that needs bpp | |
| 713 customroutine=2; // The slow one! | |
| 714 } | |
| 715 else | |
| 716 customroutine=3; | |
| 717 #else | |
| 718 | |
| 719 customroutine=2; | |
| 720 #endif | |
| 721 // format=RECTFMT_LUT8; | |
| 722 } | |
| 723 else | |
| 724 customroutine=1; | |
| 725 break; | |
| 726 | |
| 727 } | |
| 728 | |
| 729 /* Check for endian-swapped X server, swap if necessary */ | |
| 730 if ( swap_pixels && | |
| 731 ((this->screen->format->BytesPerPixel%2) == 0) ) { | |
| 732 CGX_SwapAllPixels(this->screen); | |
| 733 USE_WPA(this->screen->pixels,0,0,this->screen->pitch, | |
| 734 SDL_RastPort,SDL_Window->BorderLeft,SDL_Window->BorderTop, | |
| 735 this->screen->w,this->screen->h,format); | |
| 736 CGX_SwapAllPixels(this->screen); | |
| 737 } | |
| 738 else if (customroutine==2) | |
| 739 { | |
| 740 #ifdef USE_CGX_WRITELUTPIXEL | |
| 741 WLUT(this->screen->pixels,0,0,this->screen->pitch, | |
| 742 SDL_RastPort,SDL_XPixels,SDL_Window->BorderLeft,SDL_Window->BorderTop, | |
| 743 this->screen->w,this->screen->h,CTABFMT_XRGB8); | |
| 744 #else | |
| 745 unsigned char *bm_address; | |
| 746 Uint32 destpitch; | |
| 747 APTR handle; | |
| 748 | |
| 749 if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address, | |
| 750 LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE)) | |
| 751 { | |
| 752 register int j,k,t; | |
| 753 register unsigned char *mask,*dst; | |
| 754 register unsigned char *src,*dest; | |
| 755 | |
| 756 // Aggiungo il bordo della finestra se sono fullscreen. | |
| 757 if(!currently_fullscreen) | |
| 758 dest=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel; | |
| 759 else | |
| 760 dest=bm_address; | |
| 761 | |
| 762 src=this->screen->pixels; | |
| 763 | |
| 764 for(j=this->screen->h;j;--j) | |
| 765 { | |
| 766 dst=dest; | |
| 767 // SLOW routine, used for 8->24 bit mapping | |
| 768 for(k=0;k<this->screen->w;k++) | |
| 769 { | |
| 770 mask=(unsigned char *)(&SDL_XPixels[src[k]]); | |
| 771 for(t=0;t<bpp;t++) | |
| 772 { | |
| 773 dst[t]=mask[t]; | |
| 774 } | |
| 775 dst+=bpp; | |
| 776 } | |
| 777 src+=this->screen->pitch; | |
| 778 dest+=destpitch; | |
| 779 } | |
| 780 UnLockBitMap(handle); | |
| 781 } | |
| 782 } | |
| 783 else if (customroutine==3) | |
| 784 { | |
| 785 unsigned char *bm_address; | |
| 786 Uint32 destpitch; | |
| 787 APTR handle; | |
| 788 | |
| 789 if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address, | |
| 790 LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE)) | |
| 791 { | |
| 792 register int j,k; | |
| 793 register unsigned char *src,*dest; | |
| 794 register Uint16 *destl,*srcl; | |
| 795 | |
| 796 if(!currently_fullscreen) | |
| 797 dest=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel; | |
| 798 else | |
| 799 dest=bm_address; | |
| 800 | |
| 801 src=this->screen->pixels; | |
| 802 | |
| 803 // This is the fast, well not too slow, remapping code for 16bit displays | |
| 804 | |
| 805 for(j=this->screen->h;j;--j) | |
| 806 { | |
| 807 destl=(Uint16 *)dest; | |
| 808 | |
| 809 for(k=0;k<this->screen->w;k++) | |
| 810 { | |
| 811 srcl=(Uint16 *)&SDL_XPixels[src[k]]; | |
| 812 *destl=*srcl; | |
| 813 destl++; | |
| 814 } | |
| 815 src+=this->screen->pitch; | |
| 816 dest+=destpitch; | |
| 817 } | |
| 818 UnLockBitMap(handle); | |
| 819 } | |
| 820 } | |
| 821 else if (customroutine==4) | |
| 822 { | |
| 823 unsigned char *bm_address; | |
| 824 Uint32 destpitch; | |
| 825 APTR handle; | |
| 826 | |
| 827 if(handle=LockBitMapTags(SDL_RastPort->BitMap,LBMI_BASEADDRESS,(ULONG)&bm_address, | |
| 828 LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE)) | |
| 829 { | |
| 830 register int j,k; | |
| 831 register unsigned char *src,*dest; | |
| 832 register Uint32 *destl,*srcl; | |
| 833 | |
| 834 if(!currently_fullscreen) | |
| 835 dest=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->hidden->BytesPerPixel; | |
| 836 else | |
| 837 dest=bm_address; | |
| 838 | |
| 839 src=this->screen->pixels; | |
| 840 | |
| 841 // This is the fast, well not too slow, remapping code for 32bit displays | |
| 842 | |
| 843 for(j=this->screen->h;j;--j) | |
| 844 { | |
| 845 destl=(Uint32 *)dest; | |
| 846 | |
| 847 for(k=0;k<this->screen->w;k++) | |
| 848 { | |
| 849 srcl=(Uint32 *)&SDL_XPixels[src[k]]; | |
| 850 *destl=*srcl; | |
| 851 destl++; | |
| 852 } | |
| 853 src+=this->screen->pitch; | |
| 854 dest+=destpitch; | |
| 855 } | |
| 856 UnLockBitMap(handle); | |
| 857 } | |
| 858 #endif | |
| 859 } | |
| 860 else if(customroutine) | |
| 861 { | |
| 862 unsigned char *bm_address; | |
| 863 Uint32 destpitch; | |
| 864 APTR handle; | |
| 865 | |
| 866 if(handle=LockBitMapTags(SDL_RastPort->BitMap, | |
| 867 LBMI_BASEADDRESS,(ULONG)&bm_address, | |
| 868 LBMI_BYTESPERROW,(ULONG)&destpitch,TAG_DONE)) | |
| 869 { | |
| 870 register int j; | |
| 871 register unsigned char *src,*dest; | |
| 872 | |
| 873 if(!currently_fullscreen) | |
| 874 dest=bm_address+(SDL_Window->TopEdge+SDL_Window->BorderTop)*destpitch+(SDL_Window->BorderLeft+SDL_Window->LeftEdge)*this->screen->format->BytesPerPixel; | |
| 875 else | |
| 876 dest=bm_address; | |
| 877 | |
| 878 src=this->screen->pixels; | |
| 879 | |
| 880 // D(bug("addr: %lx pitch: %ld src:%lx srcpitch: %ld\n",dest,destpitch,this->screen->pixels,this->screen->pitch)); | |
| 881 | |
| 882 if(this->screen->pitch==destpitch) | |
| 883 { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
884 SDL_memcpy(dest,src,this->screen->pitch*this->screen->h); |
| 0 | 885 } |
| 886 else | |
| 887 { | |
| 888 for(j=this->screen->h;j;--j) | |
| 889 { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
890 SDL_memcpy(dest,src,this->screen->pitch); |
| 0 | 891 src+=this->screen->pitch; |
| 892 dest+=destpitch; | |
| 893 } | |
| 894 } | |
| 895 | |
| 896 UnLockBitMap(handle); | |
| 897 } | |
| 898 } | |
| 899 else | |
| 900 { | |
| 901 USE_WPA(this->screen->pixels,0,0,this->screen->pitch, | |
| 902 SDL_RastPort,SDL_Window->BorderLeft,SDL_Window->BorderTop, | |
| 903 this->screen->w,this->screen->h,format); | |
| 904 } | |
| 905 | |
| 906 } |