1 /*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2009 Sam Lantinga
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
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
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19 Sam Lantinga
20 slouken@libsdl.org
21 */
22 #include "SDL_config.h"
23
24 /* This a stretch blit implementation based on ideas given to me by
25 Tomasz Cejner - thanks! :)
26
27 April 27, 2000 - Sam Lantinga
28 */
29
30 #include "SDL_video.h"
31 #include "SDL_blit.h"
32
33 /* This isn't ready for general consumption yet - it should be folded
34 into the general blitting mechanism.
35 */
36
37 #if ((defined(_MFC_VER) && defined(_M_IX86)/* && !defined(_WIN32_WCE) still needed? */) || \
38 defined(__WATCOMC__) || \
39 (defined(__GNUC__) && defined(__i386__))) && SDL_ASSEMBLY_ROUTINES
40 /* There's a bug with gcc 4.4.1 and -O2 where srcp doesn't get the correct
41 * value after the first scanline. FIXME? */
42 /*#define USE_ASM_STRETCH*/
43 #endif
44
45 #ifdef USE_ASM_STRETCH
46
47 #ifdef HAVE_MPROTECT
48 #include <sys/types.h>
49 #include <sys/mman.h>
50 #endif
51 #ifdef __GNUC__
52 #define PAGE_ALIGNED __attribute__((__aligned__(4096)))
53 #else
54 #define PAGE_ALIGNED
55 #endif
56
57 #if defined(_M_IX86) || defined(i386)
58 #define PREFIX16 0x66
59 #define STORE_BYTE 0xAA
60 #define STORE_WORD 0xAB
61 #define LOAD_BYTE 0xAC
62 #define LOAD_WORD 0xAD
63 #define RETURN 0xC3
64 #else
65 #error Need assembly opcodes for this architecture
66 #endif
67
68 static unsigned char copy_row[4096] PAGE_ALIGNED;
69
generate_rowbytes(int src_w,int dst_w,int bpp)70 static int generate_rowbytes(int src_w, int dst_w, int bpp)
71 {
72 static struct {
73 int bpp;
74 int src_w;
75 int dst_w;
76 int status;
77 } last;
78
79 int i;
80 int pos, inc;
81 unsigned char *eip, *fence;
82 unsigned char load, store;
83
84 /* See if we need to regenerate the copy buffer */
85 if ( (src_w == last.src_w) &&
86 (dst_w == last.dst_w) && (bpp == last.bpp) ) {
87 return(last.status);
88 }
89 last.bpp = bpp;
90 last.src_w = src_w;
91 last.dst_w = dst_w;
92 last.status = -1;
93
94 switch (bpp) {
95 case 1:
96 load = LOAD_BYTE;
97 store = STORE_BYTE;
98 break;
99 case 2:
100 case 4:
101 load = LOAD_WORD;
102 store = STORE_WORD;
103 break;
104 default:
105 SDL_SetError("ASM stretch of %d bytes isn't supported\n", bpp);
106 return(-1);
107 }
108 #ifdef HAVE_MPROTECT
109 /* Make the code writeable */
110 if ( mprotect(copy_row, sizeof(copy_row), PROT_READ|PROT_WRITE) < 0 ) {
111 SDL_SetError("Couldn't make copy buffer writeable");
112 return(-1);
113 }
114 #endif
115 pos = 0x10000;
116 inc = (src_w << 16) / dst_w;
117 eip = copy_row;
118 fence = copy_row+sizeof(copy_row)-2;
119 for ( i=0; i<dst_w && eip < end; ++i ) {
120 while ( pos >= 0x10000L ) {
121 if ( eip == fence ) {
122 return -1;
123 }
124 if ( bpp == 2 ) {
125 *eip++ = PREFIX16;
126 }
127 *eip++ = load;
128 pos -= 0x10000L;
129 }
130 if ( eip == fence ) {
131 return -1;
132 }
133 if ( bpp == 2 ) {
134 *eip++ = PREFIX16;
135 }
136 *eip++ = store;
137 pos += inc;
138 }
139 *eip++ = RETURN;
140
141 #ifdef HAVE_MPROTECT
142 /* Make the code executable but not writeable */
143 if ( mprotect(copy_row, sizeof(copy_row), PROT_READ|PROT_EXEC) < 0 ) {
144 SDL_SetError("Couldn't make copy buffer executable");
145 return(-1);
146 }
147 #endif
148 last.status = 0;
149 return(0);
150 }
151
152 #endif /* USE_ASM_STRETCH */
153
154 #define DEFINE_COPY_ROW(name, type) \
155 void name(type *src, int src_w, type *dst, int dst_w) \
156 { \
157 int i; \
158 int pos, inc; \
159 type pixel = 0; \
160 \
161 pos = 0x10000; \
162 inc = (src_w << 16) / dst_w; \
163 for ( i=dst_w; i>0; --i ) { \
164 while ( pos >= 0x10000L ) { \
165 pixel = *src++; \
166 pos -= 0x10000L; \
167 } \
168 *dst++ = pixel; \
169 pos += inc; \
170 } \
171 }
DEFINE_COPY_ROW(copy_row1,Uint8)172 DEFINE_COPY_ROW(copy_row1, Uint8)
173 DEFINE_COPY_ROW(copy_row2, Uint16)
174 DEFINE_COPY_ROW(copy_row4, Uint32)
175
176 /* The ASM code doesn't handle 24-bpp stretch blits */
177 void copy_row3(Uint8 *src, int src_w, Uint8 *dst, int dst_w)
178 {
179 int i;
180 int pos, inc;
181 Uint8 pixel[3] = { 0, 0, 0 };
182
183 pos = 0x10000;
184 inc = (src_w << 16) / dst_w;
185 for ( i=dst_w; i>0; --i ) {
186 while ( pos >= 0x10000L ) {
187 pixel[0] = *src++;
188 pixel[1] = *src++;
189 pixel[2] = *src++;
190 pos -= 0x10000L;
191 }
192 *dst++ = pixel[0];
193 *dst++ = pixel[1];
194 *dst++ = pixel[2];
195 pos += inc;
196 }
197 }
198
199 /* Perform a stretch blit between two surfaces of the same format.
200 NOTE: This function is not safe to call from multiple threads!
201 */
SDL_SoftStretch(SDL_Surface * src,SDL_Rect * srcrect,SDL_Surface * dst,SDL_Rect * dstrect)202 int SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect,
203 SDL_Surface *dst, SDL_Rect *dstrect)
204 {
205 int src_locked;
206 int dst_locked;
207 int pos, inc;
208 int dst_width;
209 int dst_maxrow;
210 int src_row, dst_row;
211 Uint8 *srcp = NULL;
212 Uint8 *dstp;
213 SDL_Rect full_src;
214 SDL_Rect full_dst;
215 #ifdef USE_ASM_STRETCH
216 SDL_bool use_asm = SDL_TRUE;
217 #ifdef __GNUC__
218 int u1, u2;
219 #endif
220 #endif /* USE_ASM_STRETCH */
221 const int bpp = dst->format->BytesPerPixel;
222
223 if ( src->format->BitsPerPixel != dst->format->BitsPerPixel ) {
224 SDL_SetError("Only works with same format surfaces");
225 return(-1);
226 }
227
228 /* Verify the blit rectangles */
229 if ( srcrect ) {
230 if ( (srcrect->x < 0) || (srcrect->y < 0) ||
231 ((srcrect->x+srcrect->w) > src->w) ||
232 ((srcrect->y+srcrect->h) > src->h) ) {
233 SDL_SetError("Invalid source blit rectangle");
234 return(-1);
235 }
236 } else {
237 full_src.x = 0;
238 full_src.y = 0;
239 full_src.w = src->w;
240 full_src.h = src->h;
241 srcrect = &full_src;
242 }
243 if ( dstrect ) {
244 if ( (dstrect->x < 0) || (dstrect->y < 0) ||
245 ((dstrect->x+dstrect->w) > dst->w) ||
246 ((dstrect->y+dstrect->h) > dst->h) ) {
247 SDL_SetError("Invalid destination blit rectangle");
248 return(-1);
249 }
250 } else {
251 full_dst.x = 0;
252 full_dst.y = 0;
253 full_dst.w = dst->w;
254 full_dst.h = dst->h;
255 dstrect = &full_dst;
256 }
257
258 /* Lock the destination if it's in hardware */
259 dst_locked = 0;
260 if ( SDL_MUSTLOCK(dst) ) {
261 if ( SDL_LockSurface(dst) < 0 ) {
262 SDL_SetError("Unable to lock destination surface");
263 return(-1);
264 }
265 dst_locked = 1;
266 }
267 /* Lock the source if it's in hardware */
268 src_locked = 0;
269 if ( SDL_MUSTLOCK(src) ) {
270 if ( SDL_LockSurface(src) < 0 ) {
271 if ( dst_locked ) {
272 SDL_UnlockSurface(dst);
273 }
274 SDL_SetError("Unable to lock source surface");
275 return(-1);
276 }
277 src_locked = 1;
278 }
279
280 /* Set up the data... */
281 pos = 0x10000;
282 inc = (srcrect->h << 16) / dstrect->h;
283 src_row = srcrect->y;
284 dst_row = dstrect->y;
285 dst_width = dstrect->w*bpp;
286
287 #ifdef USE_ASM_STRETCH
288 /* Write the opcodes for this stretch */
289 if ( (bpp == 3) ||
290 (generate_rowbytes(srcrect->w, dstrect->w, bpp) < 0) ) {
291 use_asm = SDL_FALSE;
292 }
293 #endif
294
295 /* Perform the stretch blit */
296 for ( dst_maxrow = dst_row+dstrect->h; dst_row<dst_maxrow; ++dst_row ) {
297 dstp = (Uint8 *)dst->pixels + (dst_row*dst->pitch)
298 + (dstrect->x*bpp);
299 while ( pos >= 0x10000L ) {
300 srcp = (Uint8 *)src->pixels + (src_row*src->pitch)
301 + (srcrect->x*bpp);
302 ++src_row;
303 pos -= 0x10000L;
304 }
305 #ifdef USE_ASM_STRETCH
306 if (use_asm) {
307 #ifdef __GNUC__
308 __asm__ __volatile__ (
309 "call *%4"
310 : "=&D" (u1), "=&S" (u2)
311 : "0" (dstp), "1" (srcp), "r" (copy_row)
312 : "memory" );
313 #elif defined(_MSC_VER) || defined(__WATCOMC__)
314 { void *code = copy_row;
315 __asm {
316 push edi
317 push esi
318
319 mov edi, dstp
320 mov esi, srcp
321 call dword ptr code
322
323 pop esi
324 pop edi
325 }
326 }
327 #else
328 #error Need inline assembly for this compiler
329 #endif
330 } else
331 #endif
332 switch (bpp) {
333 case 1:
334 copy_row1(srcp, srcrect->w, dstp, dstrect->w);
335 break;
336 case 2:
337 copy_row2((Uint16 *)srcp, srcrect->w,
338 (Uint16 *)dstp, dstrect->w);
339 break;
340 case 3:
341 copy_row3(srcp, srcrect->w, dstp, dstrect->w);
342 break;
343 case 4:
344 copy_row4((Uint32 *)srcp, srcrect->w,
345 (Uint32 *)dstp, dstrect->w);
346 break;
347 }
348 pos += inc;
349 }
350
351 /* We need to unlock the surfaces if they're locked */
352 if ( dst_locked ) {
353 SDL_UnlockSurface(dst);
354 }
355 if ( src_locked ) {
356 SDL_UnlockSurface(src);
357 }
358 return(0);
359 }
360
361