Mercurial > sdl-ios-xcode
comparison src/video/SDL_blit_N.c @ 1668:4da1ee79c9af SDL-1.3
more tweaking indent options
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Mon, 29 May 2006 04:04:35 +0000 |
parents | 782fd950bd46 |
children |
comparison
equal
deleted
inserted
replaced
1667:1fddae038bc8 | 1668:4da1ee79c9af |
---|---|
37 #endif | 37 #endif |
38 #define assert(X) | 38 #define assert(X) |
39 #ifdef __MACOSX__ | 39 #ifdef __MACOSX__ |
40 #include <sys/sysctl.h> | 40 #include <sys/sysctl.h> |
41 static size_t | 41 static size_t |
42 GetL3CacheSize (void) | 42 GetL3CacheSize(void) |
43 { | 43 { |
44 const char key[] = "hw.l3cachesize"; | 44 const char key[] = "hw.l3cachesize"; |
45 u_int64_t result = 0; | 45 u_int64_t result = 0; |
46 size_t typeSize = sizeof (result); | 46 size_t typeSize = sizeof(result); |
47 | 47 |
48 | 48 |
49 int err = sysctlbyname (key, &result, &typeSize, NULL, 0); | 49 int err = sysctlbyname(key, &result, &typeSize, NULL, 0); |
50 if (0 != err) | 50 if (0 != err) |
51 return 0; | 51 return 0; |
52 | 52 |
53 return result; | 53 return result; |
54 } | 54 } |
55 #else | 55 #else |
56 static size_t | 56 static size_t |
57 GetL3CacheSize (void) | 57 GetL3CacheSize(void) |
58 { | 58 { |
59 /* XXX: Just guess G4 */ | 59 /* XXX: Just guess G4 */ |
60 return 2097152; | 60 return 2097152; |
61 } | 61 } |
62 #endif /* __MACOSX__ */ | 62 #endif /* __MACOSX__ */ |
103 ? vec_lvsl(0, src) \ | 103 ? vec_lvsl(0, src) \ |
104 : vec_add(vec_lvsl(8, src), vec_splat_u8(8))) | 104 : vec_add(vec_lvsl(8, src), vec_splat_u8(8))) |
105 | 105 |
106 /* Calculate the permute vector used for 32->32 swizzling */ | 106 /* Calculate the permute vector used for 32->32 swizzling */ |
107 static vector unsigned char | 107 static vector unsigned char |
108 calc_swizzle32 (const SDL_PixelFormat * srcfmt, | 108 calc_swizzle32(const SDL_PixelFormat * srcfmt, const SDL_PixelFormat * dstfmt) |
109 const SDL_PixelFormat * dstfmt) | |
110 { | 109 { |
111 /* | 110 /* |
112 * We have to assume that the bits that aren't used by other | 111 * We have to assume that the bits that aren't used by other |
113 * colors is alpha, and it's one complete byte, since some formats | 112 * colors is alpha, and it's one complete byte, since some formats |
114 * leave alpha with a zero mask, but we should still swizzle the bits. | 113 * leave alpha with a zero mask, but we should still swizzle the bits. |
125 srcfmt = &default_pixel_format; | 124 srcfmt = &default_pixel_format; |
126 } | 125 } |
127 if (!dstfmt) { | 126 if (!dstfmt) { |
128 dstfmt = &default_pixel_format; | 127 dstfmt = &default_pixel_format; |
129 } | 128 } |
130 const vector unsigned char plus = | 129 const vector unsigned char plus = VECUINT8_LITERAL(0x00, 0x00, 0x00, 0x00, |
131 VECUINT8_LITERAL (0x00, 0x00, 0x00, 0x00, | 130 0x04, 0x04, 0x04, 0x04, |
132 0x04, 0x04, 0x04, 0x04, | 131 0x08, 0x08, 0x08, 0x08, |
133 0x08, 0x08, 0x08, 0x08, | 132 0x0C, 0x0C, 0x0C, |
134 0x0C, 0x0C, 0x0C, 0x0C); | 133 0x0C); |
135 vector unsigned char vswiz; | 134 vector unsigned char vswiz; |
136 vector unsigned int srcvec; | 135 vector unsigned int srcvec; |
137 #define RESHIFT(X) (3 - ((X) >> 3)) | 136 #define RESHIFT(X) (3 - ((X) >> 3)) |
138 Uint32 rmask = RESHIFT (srcfmt->Rshift) << (dstfmt->Rshift); | 137 Uint32 rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift); |
139 Uint32 gmask = RESHIFT (srcfmt->Gshift) << (dstfmt->Gshift); | 138 Uint32 gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift); |
140 Uint32 bmask = RESHIFT (srcfmt->Bshift) << (dstfmt->Bshift); | 139 Uint32 bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift); |
141 Uint32 amask; | 140 Uint32 amask; |
142 /* Use zero for alpha if either surface doesn't have alpha */ | 141 /* Use zero for alpha if either surface doesn't have alpha */ |
143 if (dstfmt->Amask) { | 142 if (dstfmt->Amask) { |
144 amask = | 143 amask = |
145 ((srcfmt->Amask) ? RESHIFT (srcfmt->Ashift) : 0x10) << (dstfmt-> | 144 ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt-> |
146 Ashift); | 145 Ashift); |
147 } else { | 146 } else { |
148 amask = | 147 amask = |
149 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ | 148 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ |
150 0xFFFFFFFF); | 149 0xFFFFFFFF); |
151 } | 150 } |
152 #undef RESHIFT | 151 #undef RESHIFT |
153 ((unsigned int *) (char *) &srcvec)[0] = (rmask | gmask | bmask | amask); | 152 ((unsigned int *) (char *) &srcvec)[0] = (rmask | gmask | bmask | amask); |
154 vswiz = vec_add (plus, (vector unsigned char) vec_splat (srcvec, 0)); | 153 vswiz = vec_add(plus, (vector unsigned char) vec_splat(srcvec, 0)); |
155 return (vswiz); | 154 return (vswiz); |
156 } | 155 } |
157 | 156 |
158 static void Blit_RGB888_RGB565 (SDL_BlitInfo * info); | 157 static void Blit_RGB888_RGB565(SDL_BlitInfo * info); |
159 static void | 158 static void |
160 Blit_RGB888_RGB565Altivec (SDL_BlitInfo * info) | 159 Blit_RGB888_RGB565Altivec(SDL_BlitInfo * info) |
161 { | 160 { |
162 int height = info->d_height; | 161 int height = info->d_height; |
163 Uint8 *src = (Uint8 *) info->s_pixels; | 162 Uint8 *src = (Uint8 *) info->s_pixels; |
164 int srcskip = info->s_skip; | 163 int srcskip = info->s_skip; |
165 Uint8 *dst = (Uint8 *) info->d_pixels; | 164 Uint8 *dst = (Uint8 *) info->d_pixels; |
166 int dstskip = info->d_skip; | 165 int dstskip = info->d_skip; |
167 SDL_PixelFormat *srcfmt = info->src; | 166 SDL_PixelFormat *srcfmt = info->src; |
168 vector unsigned char valpha = vec_splat_u8 (0); | 167 vector unsigned char valpha = vec_splat_u8(0); |
169 vector unsigned char vpermute = calc_swizzle32 (srcfmt, NULL); | 168 vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL); |
170 vector unsigned char vgmerge = VECUINT8_LITERAL (0x00, 0x02, 0x00, 0x06, | 169 vector unsigned char vgmerge = VECUINT8_LITERAL(0x00, 0x02, 0x00, 0x06, |
171 0x00, 0x0a, 0x00, 0x0e, | 170 0x00, 0x0a, 0x00, 0x0e, |
172 0x00, 0x12, 0x00, 0x16, | 171 0x00, 0x12, 0x00, 0x16, |
173 0x00, 0x1a, 0x00, 0x1e); | 172 0x00, 0x1a, 0x00, 0x1e); |
174 vector unsigned short v1 = vec_splat_u16 (1); | 173 vector unsigned short v1 = vec_splat_u16(1); |
175 vector unsigned short v3 = vec_splat_u16 (3); | 174 vector unsigned short v3 = vec_splat_u16(3); |
176 vector unsigned short v3f = | 175 vector unsigned short v3f = |
177 VECUINT16_LITERAL (0x003f, 0x003f, 0x003f, 0x003f, | 176 VECUINT16_LITERAL(0x003f, 0x003f, 0x003f, 0x003f, |
178 0x003f, 0x003f, 0x003f, 0x003f); | 177 0x003f, 0x003f, 0x003f, 0x003f); |
179 vector unsigned short vfc = | 178 vector unsigned short vfc = |
180 VECUINT16_LITERAL (0x00fc, 0x00fc, 0x00fc, 0x00fc, | 179 VECUINT16_LITERAL(0x00fc, 0x00fc, 0x00fc, 0x00fc, |
181 0x00fc, 0x00fc, 0x00fc, 0x00fc); | 180 0x00fc, 0x00fc, 0x00fc, 0x00fc); |
182 vector unsigned short vf800 = (vector unsigned short) vec_splat_u8 (-7); | 181 vector unsigned short vf800 = (vector unsigned short) vec_splat_u8(-7); |
183 vf800 = vec_sl (vf800, vec_splat_u16 (8)); | 182 vf800 = vec_sl(vf800, vec_splat_u16(8)); |
184 | 183 |
185 while (height--) { | 184 while (height--) { |
186 vector unsigned char valigner; | 185 vector unsigned char valigner; |
187 vector unsigned char voverflow; | 186 vector unsigned char voverflow; |
188 vector unsigned char vsrc; | 187 vector unsigned char vsrc; |
203 dst += 2; \ | 202 dst += 2; \ |
204 src += 4; \ | 203 src += 4; \ |
205 widthvar--; \ | 204 widthvar--; \ |
206 } | 205 } |
207 | 206 |
208 ONE_PIXEL_BLEND (((UNALIGNED_PTR (dst)) && (width)), width); | 207 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width); |
209 | 208 |
210 /* After all that work, here's the vector part! */ | 209 /* After all that work, here's the vector part! */ |
211 extrawidth = (width % 8); /* trailing unaligned stores */ | 210 extrawidth = (width % 8); /* trailing unaligned stores */ |
212 width -= extrawidth; | 211 width -= extrawidth; |
213 vsrc = vec_ld (0, src); | 212 vsrc = vec_ld(0, src); |
214 valigner = VEC_ALIGNER (src); | 213 valigner = VEC_ALIGNER(src); |
215 | 214 |
216 while (width) { | 215 while (width) { |
217 vector unsigned short vpixel, vrpixel, vgpixel, vbpixel; | 216 vector unsigned short vpixel, vrpixel, vgpixel, vbpixel; |
218 vector unsigned int vsrc1, vsrc2; | 217 vector unsigned int vsrc1, vsrc2; |
219 vector unsigned char vdst; | 218 vector unsigned char vdst; |
220 | 219 |
221 voverflow = vec_ld (15, src); | 220 voverflow = vec_ld(15, src); |
222 vsrc = vec_perm (vsrc, voverflow, valigner); | 221 vsrc = vec_perm(vsrc, voverflow, valigner); |
223 vsrc1 = (vector unsigned int) vec_perm (vsrc, valpha, vpermute); | 222 vsrc1 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute); |
224 src += 16; | 223 src += 16; |
225 vsrc = voverflow; | 224 vsrc = voverflow; |
226 voverflow = vec_ld (15, src); | 225 voverflow = vec_ld(15, src); |
227 vsrc = vec_perm (vsrc, voverflow, valigner); | 226 vsrc = vec_perm(vsrc, voverflow, valigner); |
228 vsrc2 = (vector unsigned int) vec_perm (vsrc, valpha, vpermute); | 227 vsrc2 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute); |
229 /* 1555 */ | 228 /* 1555 */ |
230 vpixel = (vector unsigned short) vec_packpx (vsrc1, vsrc2); | 229 vpixel = (vector unsigned short) vec_packpx(vsrc1, vsrc2); |
231 vgpixel = | 230 vgpixel = (vector unsigned short) vec_perm(vsrc1, vsrc2, vgmerge); |
232 (vector unsigned short) vec_perm (vsrc1, vsrc2, vgmerge); | 231 vgpixel = vec_and(vgpixel, vfc); |
233 vgpixel = vec_and (vgpixel, vfc); | 232 vgpixel = vec_sl(vgpixel, v3); |
234 vgpixel = vec_sl (vgpixel, v3); | 233 vrpixel = vec_sl(vpixel, v1); |
235 vrpixel = vec_sl (vpixel, v1); | 234 vrpixel = vec_and(vrpixel, vf800); |
236 vrpixel = vec_and (vrpixel, vf800); | 235 vbpixel = vec_and(vpixel, v3f); |
237 vbpixel = vec_and (vpixel, v3f); | |
238 vdst = | 236 vdst = |
239 vec_or ((vector unsigned char) vrpixel, | 237 vec_or((vector unsigned char) vrpixel, |
240 (vector unsigned char) vgpixel); | 238 (vector unsigned char) vgpixel); |
241 /* 565 */ | 239 /* 565 */ |
242 vdst = vec_or (vdst, (vector unsigned char) vbpixel); | 240 vdst = vec_or(vdst, (vector unsigned char) vbpixel); |
243 vec_st (vdst, 0, dst); | 241 vec_st(vdst, 0, dst); |
244 | 242 |
245 width -= 8; | 243 width -= 8; |
246 src += 16; | 244 src += 16; |
247 dst += 16; | 245 dst += 16; |
248 vsrc = voverflow; | 246 vsrc = voverflow; |
249 } | 247 } |
250 | 248 |
251 assert (width == 0); | 249 assert(width == 0); |
252 | 250 |
253 /* do scalar until we can align... */ | 251 /* do scalar until we can align... */ |
254 ONE_PIXEL_BLEND ((extrawidth), extrawidth); | 252 ONE_PIXEL_BLEND((extrawidth), extrawidth); |
255 #undef ONE_PIXEL_BLEND | 253 #undef ONE_PIXEL_BLEND |
256 | 254 |
257 src += srcskip; /* move to next row, accounting for pitch. */ | 255 src += srcskip; /* move to next row, accounting for pitch. */ |
258 dst += dstskip; | 256 dst += dstskip; |
259 } | 257 } |
260 | 258 |
261 | 259 |
262 } | 260 } |
263 | 261 |
264 static void | 262 static void |
265 Blit_RGB565_32Altivec (SDL_BlitInfo * info) | 263 Blit_RGB565_32Altivec(SDL_BlitInfo * info) |
266 { | 264 { |
267 int height = info->d_height; | 265 int height = info->d_height; |
268 Uint8 *src = (Uint8 *) info->s_pixels; | 266 Uint8 *src = (Uint8 *) info->s_pixels; |
269 int srcskip = info->s_skip; | 267 int srcskip = info->s_skip; |
270 Uint8 *dst = (Uint8 *) info->d_pixels; | 268 Uint8 *dst = (Uint8 *) info->d_pixels; |
273 SDL_PixelFormat *dstfmt = info->dst; | 271 SDL_PixelFormat *dstfmt = info->dst; |
274 unsigned alpha; | 272 unsigned alpha; |
275 vector unsigned char valpha; | 273 vector unsigned char valpha; |
276 vector unsigned char vpermute; | 274 vector unsigned char vpermute; |
277 vector unsigned short vf800; | 275 vector unsigned short vf800; |
278 vector unsigned int v8 = vec_splat_u32 (8); | 276 vector unsigned int v8 = vec_splat_u32(8); |
279 vector unsigned int v16 = vec_add (v8, v8); | 277 vector unsigned int v16 = vec_add(v8, v8); |
280 vector unsigned short v2 = vec_splat_u16 (2); | 278 vector unsigned short v2 = vec_splat_u16(2); |
281 vector unsigned short v3 = vec_splat_u16 (3); | 279 vector unsigned short v3 = vec_splat_u16(3); |
282 /* | 280 /* |
283 0x10 - 0x1f is the alpha | 281 0x10 - 0x1f is the alpha |
284 0x00 - 0x0e evens are the red | 282 0x00 - 0x0e evens are the red |
285 0x01 - 0x0f odds are zero | 283 0x01 - 0x0f odds are zero |
286 */ | 284 */ |
287 vector unsigned char vredalpha1 = | 285 vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01, |
288 VECUINT8_LITERAL (0x10, 0x00, 0x01, 0x01, | 286 0x10, 0x02, 0x01, 0x01, |
289 0x10, 0x02, 0x01, 0x01, | 287 0x10, 0x04, 0x01, 0x01, |
290 0x10, 0x04, 0x01, 0x01, | 288 0x10, 0x06, 0x01, |
291 0x10, 0x06, 0x01, 0x01); | 289 0x01); |
292 vector unsigned char vredalpha2 = | 290 vector unsigned char vredalpha2 = |
293 (vector unsigned | 291 (vector unsigned |
294 char) (vec_add ((vector unsigned int) vredalpha1, vec_sl (v8, v16)) | 292 char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16)) |
295 ); | 293 ); |
296 /* | 294 /* |
297 0x00 - 0x0f is ARxx ARxx ARxx ARxx | 295 0x00 - 0x0f is ARxx ARxx ARxx ARxx |
298 0x11 - 0x0f odds are blue | 296 0x11 - 0x0f odds are blue |
299 */ | 297 */ |
300 vector unsigned char vblue1 = VECUINT8_LITERAL (0x00, 0x01, 0x02, 0x11, | 298 vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11, |
301 0x04, 0x05, 0x06, 0x13, | 299 0x04, 0x05, 0x06, 0x13, |
302 0x08, 0x09, 0x0a, 0x15, | 300 0x08, 0x09, 0x0a, 0x15, |
303 0x0c, 0x0d, 0x0e, 0x17); | 301 0x0c, 0x0d, 0x0e, 0x17); |
304 vector unsigned char vblue2 = | 302 vector unsigned char vblue2 = |
305 (vector unsigned char) (vec_add ((vector unsigned int) vblue1, v8) | 303 (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8) |
306 ); | 304 ); |
307 /* | 305 /* |
308 0x00 - 0x0f is ARxB ARxB ARxB ARxB | 306 0x00 - 0x0f is ARxB ARxB ARxB ARxB |
309 0x10 - 0x0e evens are green | 307 0x10 - 0x0e evens are green |
310 */ | 308 */ |
311 vector unsigned char vgreen1 = VECUINT8_LITERAL (0x00, 0x01, 0x10, 0x03, | 309 vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03, |
312 0x04, 0x05, 0x12, 0x07, | 310 0x04, 0x05, 0x12, 0x07, |
313 0x08, 0x09, 0x14, 0x0b, | 311 0x08, 0x09, 0x14, 0x0b, |
314 0x0c, 0x0d, 0x16, 0x0f); | 312 0x0c, 0x0d, 0x16, 0x0f); |
315 vector unsigned char vgreen2 = | 313 vector unsigned char vgreen2 = |
316 (vector unsigned | 314 (vector unsigned |
317 char) (vec_add ((vector unsigned int) vgreen1, vec_sl (v8, v8)) | 315 char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8)) |
318 ); | 316 ); |
319 | 317 |
320 | 318 |
321 assert (srcfmt->BytesPerPixel == 2); | 319 assert(srcfmt->BytesPerPixel == 2); |
322 assert (dstfmt->BytesPerPixel == 4); | 320 assert(dstfmt->BytesPerPixel == 4); |
323 | 321 |
324 vf800 = (vector unsigned short) vec_splat_u8 (-7); | 322 vf800 = (vector unsigned short) vec_splat_u8(-7); |
325 vf800 = vec_sl (vf800, vec_splat_u16 (8)); | 323 vf800 = vec_sl(vf800, vec_splat_u16(8)); |
326 | 324 |
327 if (dstfmt->Amask && srcfmt->alpha) { | 325 if (dstfmt->Amask && srcfmt->alpha) { |
328 ((unsigned char *) &valpha)[0] = alpha = srcfmt->alpha; | 326 ((unsigned char *) &valpha)[0] = alpha = srcfmt->alpha; |
329 valpha = vec_splat (valpha, 0); | 327 valpha = vec_splat(valpha, 0); |
330 } else { | 328 } else { |
331 alpha = 0; | 329 alpha = 0; |
332 valpha = vec_splat_u8 (0); | 330 valpha = vec_splat_u8(0); |
333 } | 331 } |
334 | 332 |
335 vpermute = calc_swizzle32 (NULL, dstfmt); | 333 vpermute = calc_swizzle32(NULL, dstfmt); |
336 while (height--) { | 334 while (height--) { |
337 vector unsigned char valigner; | 335 vector unsigned char valigner; |
338 vector unsigned char voverflow; | 336 vector unsigned char voverflow; |
339 vector unsigned char vsrc; | 337 vector unsigned char vsrc; |
340 | 338 |
352 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ | 350 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ |
353 src += 2; \ | 351 src += 2; \ |
354 dst += 4; \ | 352 dst += 4; \ |
355 widthvar--; \ | 353 widthvar--; \ |
356 } | 354 } |
357 ONE_PIXEL_BLEND (((UNALIGNED_PTR (dst)) && (width)), width); | 355 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width); |
358 | 356 |
359 /* After all that work, here's the vector part! */ | 357 /* After all that work, here's the vector part! */ |
360 extrawidth = (width % 8); /* trailing unaligned stores */ | 358 extrawidth = (width % 8); /* trailing unaligned stores */ |
361 width -= extrawidth; | 359 width -= extrawidth; |
362 vsrc = vec_ld (0, src); | 360 vsrc = vec_ld(0, src); |
363 valigner = VEC_ALIGNER (src); | 361 valigner = VEC_ALIGNER(src); |
364 | 362 |
365 while (width) { | 363 while (width) { |
366 vector unsigned short vR, vG, vB; | 364 vector unsigned short vR, vG, vB; |
367 vector unsigned char vdst1, vdst2; | 365 vector unsigned char vdst1, vdst2; |
368 | 366 |
369 voverflow = vec_ld (15, src); | 367 voverflow = vec_ld(15, src); |
370 vsrc = vec_perm (vsrc, voverflow, valigner); | 368 vsrc = vec_perm(vsrc, voverflow, valigner); |
371 | 369 |
372 vR = vec_and ((vector unsigned short) vsrc, vf800); | 370 vR = vec_and((vector unsigned short) vsrc, vf800); |
373 vB = vec_sl ((vector unsigned short) vsrc, v3); | 371 vB = vec_sl((vector unsigned short) vsrc, v3); |
374 vG = vec_sl (vB, v2); | 372 vG = vec_sl(vB, v2); |
375 | 373 |
376 vdst1 = | 374 vdst1 = |
377 (vector unsigned char) vec_perm ((vector unsigned char) vR, | 375 (vector unsigned char) vec_perm((vector unsigned char) vR, |
378 valpha, vredalpha1); | 376 valpha, vredalpha1); |
379 vdst1 = vec_perm (vdst1, (vector unsigned char) vB, vblue1); | 377 vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1); |
380 vdst1 = vec_perm (vdst1, (vector unsigned char) vG, vgreen1); | 378 vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1); |
381 vdst1 = vec_perm (vdst1, valpha, vpermute); | 379 vdst1 = vec_perm(vdst1, valpha, vpermute); |
382 vec_st (vdst1, 0, dst); | 380 vec_st(vdst1, 0, dst); |
383 | 381 |
384 vdst2 = | 382 vdst2 = |
385 (vector unsigned char) vec_perm ((vector unsigned char) vR, | 383 (vector unsigned char) vec_perm((vector unsigned char) vR, |
386 valpha, vredalpha2); | 384 valpha, vredalpha2); |
387 vdst2 = vec_perm (vdst2, (vector unsigned char) vB, vblue2); | 385 vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2); |
388 vdst2 = vec_perm (vdst2, (vector unsigned char) vG, vgreen2); | 386 vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2); |
389 vdst2 = vec_perm (vdst2, valpha, vpermute); | 387 vdst2 = vec_perm(vdst2, valpha, vpermute); |
390 vec_st (vdst2, 16, dst); | 388 vec_st(vdst2, 16, dst); |
391 | 389 |
392 width -= 8; | 390 width -= 8; |
393 dst += 32; | 391 dst += 32; |
394 src += 16; | 392 src += 16; |
395 vsrc = voverflow; | 393 vsrc = voverflow; |
396 } | 394 } |
397 | 395 |
398 assert (width == 0); | 396 assert(width == 0); |
399 | 397 |
400 | 398 |
401 /* do scalar until we can align... */ | 399 /* do scalar until we can align... */ |
402 ONE_PIXEL_BLEND ((extrawidth), extrawidth); | 400 ONE_PIXEL_BLEND((extrawidth), extrawidth); |
403 #undef ONE_PIXEL_BLEND | 401 #undef ONE_PIXEL_BLEND |
404 | 402 |
405 src += srcskip; /* move to next row, accounting for pitch. */ | 403 src += srcskip; /* move to next row, accounting for pitch. */ |
406 dst += dstskip; | 404 dst += dstskip; |
407 } | 405 } |
408 | 406 |
409 } | 407 } |
410 | 408 |
411 | 409 |
412 static void | 410 static void |
413 Blit_RGB555_32Altivec (SDL_BlitInfo * info) | 411 Blit_RGB555_32Altivec(SDL_BlitInfo * info) |
414 { | 412 { |
415 int height = info->d_height; | 413 int height = info->d_height; |
416 Uint8 *src = (Uint8 *) info->s_pixels; | 414 Uint8 *src = (Uint8 *) info->s_pixels; |
417 int srcskip = info->s_skip; | 415 int srcskip = info->s_skip; |
418 Uint8 *dst = (Uint8 *) info->d_pixels; | 416 Uint8 *dst = (Uint8 *) info->d_pixels; |
421 SDL_PixelFormat *dstfmt = info->dst; | 419 SDL_PixelFormat *dstfmt = info->dst; |
422 unsigned alpha; | 420 unsigned alpha; |
423 vector unsigned char valpha; | 421 vector unsigned char valpha; |
424 vector unsigned char vpermute; | 422 vector unsigned char vpermute; |
425 vector unsigned short vf800; | 423 vector unsigned short vf800; |
426 vector unsigned int v8 = vec_splat_u32 (8); | 424 vector unsigned int v8 = vec_splat_u32(8); |
427 vector unsigned int v16 = vec_add (v8, v8); | 425 vector unsigned int v16 = vec_add(v8, v8); |
428 vector unsigned short v1 = vec_splat_u16 (1); | 426 vector unsigned short v1 = vec_splat_u16(1); |
429 vector unsigned short v3 = vec_splat_u16 (3); | 427 vector unsigned short v3 = vec_splat_u16(3); |
430 /* | 428 /* |
431 0x10 - 0x1f is the alpha | 429 0x10 - 0x1f is the alpha |
432 0x00 - 0x0e evens are the red | 430 0x00 - 0x0e evens are the red |
433 0x01 - 0x0f odds are zero | 431 0x01 - 0x0f odds are zero |
434 */ | 432 */ |
435 vector unsigned char vredalpha1 = | 433 vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01, |
436 VECUINT8_LITERAL (0x10, 0x00, 0x01, 0x01, | 434 0x10, 0x02, 0x01, 0x01, |
437 0x10, 0x02, 0x01, 0x01, | 435 0x10, 0x04, 0x01, 0x01, |
438 0x10, 0x04, 0x01, 0x01, | 436 0x10, 0x06, 0x01, |
439 0x10, 0x06, 0x01, 0x01); | 437 0x01); |
440 vector unsigned char vredalpha2 = | 438 vector unsigned char vredalpha2 = |
441 (vector unsigned | 439 (vector unsigned |
442 char) (vec_add ((vector unsigned int) vredalpha1, vec_sl (v8, v16)) | 440 char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16)) |
443 ); | 441 ); |
444 /* | 442 /* |
445 0x00 - 0x0f is ARxx ARxx ARxx ARxx | 443 0x00 - 0x0f is ARxx ARxx ARxx ARxx |
446 0x11 - 0x0f odds are blue | 444 0x11 - 0x0f odds are blue |
447 */ | 445 */ |
448 vector unsigned char vblue1 = VECUINT8_LITERAL (0x00, 0x01, 0x02, 0x11, | 446 vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11, |
449 0x04, 0x05, 0x06, 0x13, | 447 0x04, 0x05, 0x06, 0x13, |
450 0x08, 0x09, 0x0a, 0x15, | 448 0x08, 0x09, 0x0a, 0x15, |
451 0x0c, 0x0d, 0x0e, 0x17); | 449 0x0c, 0x0d, 0x0e, 0x17); |
452 vector unsigned char vblue2 = | 450 vector unsigned char vblue2 = |
453 (vector unsigned char) (vec_add ((vector unsigned int) vblue1, v8) | 451 (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8) |
454 ); | 452 ); |
455 /* | 453 /* |
456 0x00 - 0x0f is ARxB ARxB ARxB ARxB | 454 0x00 - 0x0f is ARxB ARxB ARxB ARxB |
457 0x10 - 0x0e evens are green | 455 0x10 - 0x0e evens are green |
458 */ | 456 */ |
459 vector unsigned char vgreen1 = VECUINT8_LITERAL (0x00, 0x01, 0x10, 0x03, | 457 vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03, |
460 0x04, 0x05, 0x12, 0x07, | 458 0x04, 0x05, 0x12, 0x07, |
461 0x08, 0x09, 0x14, 0x0b, | 459 0x08, 0x09, 0x14, 0x0b, |
462 0x0c, 0x0d, 0x16, 0x0f); | 460 0x0c, 0x0d, 0x16, 0x0f); |
463 vector unsigned char vgreen2 = | 461 vector unsigned char vgreen2 = |
464 (vector unsigned | 462 (vector unsigned |
465 char) (vec_add ((vector unsigned int) vgreen1, vec_sl (v8, v8)) | 463 char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8)) |
466 ); | 464 ); |
467 | 465 |
468 | 466 |
469 assert (srcfmt->BytesPerPixel == 2); | 467 assert(srcfmt->BytesPerPixel == 2); |
470 assert (dstfmt->BytesPerPixel == 4); | 468 assert(dstfmt->BytesPerPixel == 4); |
471 | 469 |
472 vf800 = (vector unsigned short) vec_splat_u8 (-7); | 470 vf800 = (vector unsigned short) vec_splat_u8(-7); |
473 vf800 = vec_sl (vf800, vec_splat_u16 (8)); | 471 vf800 = vec_sl(vf800, vec_splat_u16(8)); |
474 | 472 |
475 if (dstfmt->Amask && srcfmt->alpha) { | 473 if (dstfmt->Amask && srcfmt->alpha) { |
476 ((unsigned char *) &valpha)[0] = alpha = srcfmt->alpha; | 474 ((unsigned char *) &valpha)[0] = alpha = srcfmt->alpha; |
477 valpha = vec_splat (valpha, 0); | 475 valpha = vec_splat(valpha, 0); |
478 } else { | 476 } else { |
479 alpha = 0; | 477 alpha = 0; |
480 valpha = vec_splat_u8 (0); | 478 valpha = vec_splat_u8(0); |
481 } | 479 } |
482 | 480 |
483 vpermute = calc_swizzle32 (NULL, dstfmt); | 481 vpermute = calc_swizzle32(NULL, dstfmt); |
484 while (height--) { | 482 while (height--) { |
485 vector unsigned char valigner; | 483 vector unsigned char valigner; |
486 vector unsigned char voverflow; | 484 vector unsigned char voverflow; |
487 vector unsigned char vsrc; | 485 vector unsigned char vsrc; |
488 | 486 |
500 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ | 498 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ |
501 src += 2; \ | 499 src += 2; \ |
502 dst += 4; \ | 500 dst += 4; \ |
503 widthvar--; \ | 501 widthvar--; \ |
504 } | 502 } |
505 ONE_PIXEL_BLEND (((UNALIGNED_PTR (dst)) && (width)), width); | 503 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width); |
506 | 504 |
507 /* After all that work, here's the vector part! */ | 505 /* After all that work, here's the vector part! */ |
508 extrawidth = (width % 8); /* trailing unaligned stores */ | 506 extrawidth = (width % 8); /* trailing unaligned stores */ |
509 width -= extrawidth; | 507 width -= extrawidth; |
510 vsrc = vec_ld (0, src); | 508 vsrc = vec_ld(0, src); |
511 valigner = VEC_ALIGNER (src); | 509 valigner = VEC_ALIGNER(src); |
512 | 510 |
513 while (width) { | 511 while (width) { |
514 vector unsigned short vR, vG, vB; | 512 vector unsigned short vR, vG, vB; |
515 vector unsigned char vdst1, vdst2; | 513 vector unsigned char vdst1, vdst2; |
516 | 514 |
517 voverflow = vec_ld (15, src); | 515 voverflow = vec_ld(15, src); |
518 vsrc = vec_perm (vsrc, voverflow, valigner); | 516 vsrc = vec_perm(vsrc, voverflow, valigner); |
519 | 517 |
520 vR = vec_and (vec_sl ((vector unsigned short) vsrc, v1), vf800); | 518 vR = vec_and(vec_sl((vector unsigned short) vsrc, v1), vf800); |
521 vB = vec_sl ((vector unsigned short) vsrc, v3); | 519 vB = vec_sl((vector unsigned short) vsrc, v3); |
522 vG = vec_sl (vB, v3); | 520 vG = vec_sl(vB, v3); |
523 | 521 |
524 vdst1 = | 522 vdst1 = |
525 (vector unsigned char) vec_perm ((vector unsigned char) vR, | 523 (vector unsigned char) vec_perm((vector unsigned char) vR, |
526 valpha, vredalpha1); | 524 valpha, vredalpha1); |
527 vdst1 = vec_perm (vdst1, (vector unsigned char) vB, vblue1); | 525 vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1); |
528 vdst1 = vec_perm (vdst1, (vector unsigned char) vG, vgreen1); | 526 vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1); |
529 vdst1 = vec_perm (vdst1, valpha, vpermute); | 527 vdst1 = vec_perm(vdst1, valpha, vpermute); |
530 vec_st (vdst1, 0, dst); | 528 vec_st(vdst1, 0, dst); |
531 | 529 |
532 vdst2 = | 530 vdst2 = |
533 (vector unsigned char) vec_perm ((vector unsigned char) vR, | 531 (vector unsigned char) vec_perm((vector unsigned char) vR, |
534 valpha, vredalpha2); | 532 valpha, vredalpha2); |
535 vdst2 = vec_perm (vdst2, (vector unsigned char) vB, vblue2); | 533 vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2); |
536 vdst2 = vec_perm (vdst2, (vector unsigned char) vG, vgreen2); | 534 vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2); |
537 vdst2 = vec_perm (vdst2, valpha, vpermute); | 535 vdst2 = vec_perm(vdst2, valpha, vpermute); |
538 vec_st (vdst2, 16, dst); | 536 vec_st(vdst2, 16, dst); |
539 | 537 |
540 width -= 8; | 538 width -= 8; |
541 dst += 32; | 539 dst += 32; |
542 src += 16; | 540 src += 16; |
543 vsrc = voverflow; | 541 vsrc = voverflow; |
544 } | 542 } |
545 | 543 |
546 assert (width == 0); | 544 assert(width == 0); |
547 | 545 |
548 | 546 |
549 /* do scalar until we can align... */ | 547 /* do scalar until we can align... */ |
550 ONE_PIXEL_BLEND ((extrawidth), extrawidth); | 548 ONE_PIXEL_BLEND((extrawidth), extrawidth); |
551 #undef ONE_PIXEL_BLEND | 549 #undef ONE_PIXEL_BLEND |
552 | 550 |
553 src += srcskip; /* move to next row, accounting for pitch. */ | 551 src += srcskip; /* move to next row, accounting for pitch. */ |
554 dst += dstskip; | 552 dst += dstskip; |
555 } | 553 } |
556 | 554 |
557 } | 555 } |
558 | 556 |
559 static void BlitNtoNKey (SDL_BlitInfo * info); | 557 static void BlitNtoNKey(SDL_BlitInfo * info); |
560 static void BlitNtoNKeyCopyAlpha (SDL_BlitInfo * info); | 558 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info); |
561 static void | 559 static void |
562 Blit32to32KeyAltivec (SDL_BlitInfo * info) | 560 Blit32to32KeyAltivec(SDL_BlitInfo * info) |
563 { | 561 { |
564 int height = info->d_height; | 562 int height = info->d_height; |
565 Uint32 *srcp = (Uint32 *) info->s_pixels; | 563 Uint32 *srcp = (Uint32 *) info->s_pixels; |
566 int srcskip = info->s_skip; | 564 int srcskip = info->s_skip; |
567 Uint32 *dstp = (Uint32 *) info->d_pixels; | 565 Uint32 *dstp = (Uint32 *) info->d_pixels; |
577 vector unsigned int valpha; | 575 vector unsigned int valpha; |
578 vector unsigned char vpermute; | 576 vector unsigned char vpermute; |
579 vector unsigned char vzero; | 577 vector unsigned char vzero; |
580 vector unsigned int vckey; | 578 vector unsigned int vckey; |
581 vector unsigned int vrgbmask; | 579 vector unsigned int vrgbmask; |
582 vpermute = calc_swizzle32 (srcfmt, dstfmt); | 580 vpermute = calc_swizzle32(srcfmt, dstfmt); |
583 if (info->d_width < 16) { | 581 if (info->d_width < 16) { |
584 if (copy_alpha) { | 582 if (copy_alpha) { |
585 BlitNtoNKeyCopyAlpha (info); | 583 BlitNtoNKeyCopyAlpha(info); |
586 } else { | 584 } else { |
587 BlitNtoNKey (info); | 585 BlitNtoNKey(info); |
588 } | 586 } |
589 return; | 587 return; |
590 } | 588 } |
591 vzero = vec_splat_u8 (0); | 589 vzero = vec_splat_u8(0); |
592 if (alpha) { | 590 if (alpha) { |
593 ((unsigned char *) &valpha)[0] = (unsigned char) alpha; | 591 ((unsigned char *) &valpha)[0] = (unsigned char) alpha; |
594 valpha = | 592 valpha = |
595 (vector unsigned int) vec_splat ((vector unsigned char) valpha, | 593 (vector unsigned int) vec_splat((vector unsigned char) valpha, 0); |
596 0); | |
597 } else { | 594 } else { |
598 valpha = (vector unsigned int) vzero; | 595 valpha = (vector unsigned int) vzero; |
599 } | 596 } |
600 ckey &= rgbmask; | 597 ckey &= rgbmask; |
601 ((unsigned int *) (char *) &vckey)[0] = ckey; | 598 ((unsigned int *) (char *) &vckey)[0] = ckey; |
602 vckey = vec_splat (vckey, 0); | 599 vckey = vec_splat(vckey, 0); |
603 ((unsigned int *) (char *) &vrgbmask)[0] = rgbmask; | 600 ((unsigned int *) (char *) &vrgbmask)[0] = rgbmask; |
604 vrgbmask = vec_splat (vrgbmask, 0); | 601 vrgbmask = vec_splat(vrgbmask, 0); |
605 | 602 |
606 while (height--) { | 603 while (height--) { |
607 #define ONE_PIXEL_BLEND(condition, widthvar) \ | 604 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
608 if (copy_alpha) { \ | 605 if (copy_alpha) { \ |
609 while (condition) { \ | 606 while (condition) { \ |
633 srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \ | 630 srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \ |
634 widthvar--; \ | 631 widthvar--; \ |
635 } \ | 632 } \ |
636 } | 633 } |
637 int width = info->d_width; | 634 int width = info->d_width; |
638 ONE_PIXEL_BLEND ((UNALIGNED_PTR (dstp)) && (width), width); | 635 ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width); |
639 assert (width > 0); | 636 assert(width > 0); |
640 if (width > 0) { | 637 if (width > 0) { |
641 int extrawidth = (width % 4); | 638 int extrawidth = (width % 4); |
642 vector unsigned char valigner = VEC_ALIGNER (srcp); | 639 vector unsigned char valigner = VEC_ALIGNER(srcp); |
643 vector unsigned int vs = vec_ld (0, srcp); | 640 vector unsigned int vs = vec_ld(0, srcp); |
644 width -= extrawidth; | 641 width -= extrawidth; |
645 assert (width >= 4); | 642 assert(width >= 4); |
646 while (width) { | 643 while (width) { |
647 vector unsigned char vsel; | 644 vector unsigned char vsel; |
648 vector unsigned int vd; | 645 vector unsigned int vd; |
649 vector unsigned int voverflow = vec_ld (15, srcp); | 646 vector unsigned int voverflow = vec_ld(15, srcp); |
650 /* load the source vec */ | 647 /* load the source vec */ |
651 vs = vec_perm (vs, voverflow, valigner); | 648 vs = vec_perm(vs, voverflow, valigner); |
652 /* vsel is set for items that match the key */ | 649 /* vsel is set for items that match the key */ |
653 vsel = (vector unsigned char) vec_and (vs, vrgbmask); | 650 vsel = (vector unsigned char) vec_and(vs, vrgbmask); |
654 vsel = (vector unsigned char) vec_cmpeq (vs, vckey); | 651 vsel = (vector unsigned char) vec_cmpeq(vs, vckey); |
655 /* permute the src vec to the dest format */ | 652 /* permute the src vec to the dest format */ |
656 vs = vec_perm (vs, valpha, vpermute); | 653 vs = vec_perm(vs, valpha, vpermute); |
657 /* load the destination vec */ | 654 /* load the destination vec */ |
658 vd = vec_ld (0, dstp); | 655 vd = vec_ld(0, dstp); |
659 /* select the source and dest into vs */ | 656 /* select the source and dest into vs */ |
660 vd = (vector unsigned int) vec_sel ((vector unsigned char) vs, | 657 vd = (vector unsigned int) vec_sel((vector unsigned char) vs, |
661 (vector unsigned char) vd, | 658 (vector unsigned char) vd, |
662 vsel); | 659 vsel); |
663 | 660 |
664 vec_st (vd, 0, dstp); | 661 vec_st(vd, 0, dstp); |
665 srcp += 4; | 662 srcp += 4; |
666 width -= 4; | 663 width -= 4; |
667 dstp += 4; | 664 dstp += 4; |
668 vs = voverflow; | 665 vs = voverflow; |
669 } | 666 } |
670 ONE_PIXEL_BLEND ((extrawidth), extrawidth); | 667 ONE_PIXEL_BLEND((extrawidth), extrawidth); |
671 #undef ONE_PIXEL_BLEND | 668 #undef ONE_PIXEL_BLEND |
672 srcp += srcskip >> 2; | 669 srcp += srcskip >> 2; |
673 dstp += dstskip >> 2; | 670 dstp += dstskip >> 2; |
674 } | 671 } |
675 } | 672 } |
676 } | 673 } |
677 | 674 |
678 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */ | 675 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */ |
679 /* Use this on a G5 */ | 676 /* Use this on a G5 */ |
680 static void | 677 static void |
681 ConvertAltivec32to32_noprefetch (SDL_BlitInfo * info) | 678 ConvertAltivec32to32_noprefetch(SDL_BlitInfo * info) |
682 { | 679 { |
683 int height = info->d_height; | 680 int height = info->d_height; |
684 Uint32 *src = (Uint32 *) info->s_pixels; | 681 Uint32 *src = (Uint32 *) info->s_pixels; |
685 int srcskip = info->s_skip; | 682 int srcskip = info->s_skip; |
686 Uint32 *dst = (Uint32 *) info->d_pixels; | 683 Uint32 *dst = (Uint32 *) info->d_pixels; |
687 int dstskip = info->d_skip; | 684 int dstskip = info->d_skip; |
688 SDL_PixelFormat *srcfmt = info->src; | 685 SDL_PixelFormat *srcfmt = info->src; |
689 SDL_PixelFormat *dstfmt = info->dst; | 686 SDL_PixelFormat *dstfmt = info->dst; |
690 vector unsigned int vzero = vec_splat_u32 (0); | 687 vector unsigned int vzero = vec_splat_u32(0); |
691 vector unsigned char vpermute = calc_swizzle32 (srcfmt, dstfmt); | 688 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt); |
692 if (dstfmt->Amask && !srcfmt->Amask) { | 689 if (dstfmt->Amask && !srcfmt->Amask) { |
693 if (srcfmt->alpha) { | 690 if (srcfmt->alpha) { |
694 vector unsigned char valpha; | 691 vector unsigned char valpha; |
695 ((unsigned char *) &valpha)[0] = srcfmt->alpha; | 692 ((unsigned char *) &valpha)[0] = srcfmt->alpha; |
696 vzero = (vector unsigned int) vec_splat (valpha, 0); | 693 vzero = (vector unsigned int) vec_splat(valpha, 0); |
697 } | 694 } |
698 } | 695 } |
699 | 696 |
700 assert (srcfmt->BytesPerPixel == 4); | 697 assert(srcfmt->BytesPerPixel == 4); |
701 assert (dstfmt->BytesPerPixel == 4); | 698 assert(dstfmt->BytesPerPixel == 4); |
702 | 699 |
703 while (height--) { | 700 while (height--) { |
704 vector unsigned char valigner; | 701 vector unsigned char valigner; |
705 vector unsigned int vbits; | 702 vector unsigned int vbits; |
706 vector unsigned int voverflow; | 703 vector unsigned int voverflow; |
709 | 706 |
710 int width = info->d_width; | 707 int width = info->d_width; |
711 int extrawidth; | 708 int extrawidth; |
712 | 709 |
713 /* do scalar until we can align... */ | 710 /* do scalar until we can align... */ |
714 while ((UNALIGNED_PTR (dst)) && (width)) { | 711 while ((UNALIGNED_PTR(dst)) && (width)) { |
715 bits = *(src++); | 712 bits = *(src++); |
716 RGBA_FROM_8888 (bits, srcfmt, r, g, b, a); | 713 RGBA_FROM_8888(bits, srcfmt, r, g, b, a); |
717 *(dst++) = MAKE8888 (dstfmt, r, g, b, a); | 714 *(dst++) = MAKE8888(dstfmt, r, g, b, a); |
718 width--; | 715 width--; |
719 } | 716 } |
720 | 717 |
721 /* After all that work, here's the vector part! */ | 718 /* After all that work, here's the vector part! */ |
722 extrawidth = (width % 4); | 719 extrawidth = (width % 4); |
723 width -= extrawidth; | 720 width -= extrawidth; |
724 valigner = VEC_ALIGNER (src); | 721 valigner = VEC_ALIGNER(src); |
725 vbits = vec_ld (0, src); | 722 vbits = vec_ld(0, src); |
726 | 723 |
727 while (width) { | 724 while (width) { |
728 voverflow = vec_ld (15, src); | 725 voverflow = vec_ld(15, src); |
729 src += 4; | 726 src += 4; |
730 width -= 4; | 727 width -= 4; |
731 vbits = vec_perm (vbits, voverflow, valigner); /* src is ready. */ | 728 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */ |
732 vbits = vec_perm (vbits, vzero, vpermute); /* swizzle it. */ | 729 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */ |
733 vec_st (vbits, 0, dst); /* store it back out. */ | 730 vec_st(vbits, 0, dst); /* store it back out. */ |
734 dst += 4; | 731 dst += 4; |
735 vbits = voverflow; | 732 vbits = voverflow; |
736 } | 733 } |
737 | 734 |
738 assert (width == 0); | 735 assert(width == 0); |
739 | 736 |
740 /* cover pixels at the end of the row that didn't fit in 16 bytes. */ | 737 /* cover pixels at the end of the row that didn't fit in 16 bytes. */ |
741 while (extrawidth) { | 738 while (extrawidth) { |
742 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */ | 739 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */ |
743 RGBA_FROM_8888 (bits, srcfmt, r, g, b, a); | 740 RGBA_FROM_8888(bits, srcfmt, r, g, b, a); |
744 *(dst++) = MAKE8888 (dstfmt, r, g, b, a); | 741 *(dst++) = MAKE8888(dstfmt, r, g, b, a); |
745 extrawidth--; | 742 extrawidth--; |
746 } | 743 } |
747 | 744 |
748 src += srcskip >> 2; /* move to next row, accounting for pitch. */ | 745 src += srcskip >> 2; /* move to next row, accounting for pitch. */ |
749 dst += dstskip >> 2; | 746 dst += dstskip >> 2; |
752 } | 749 } |
753 | 750 |
754 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */ | 751 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */ |
755 /* Use this on a G4 */ | 752 /* Use this on a G4 */ |
756 static void | 753 static void |
757 ConvertAltivec32to32_prefetch (SDL_BlitInfo * info) | 754 ConvertAltivec32to32_prefetch(SDL_BlitInfo * info) |
758 { | 755 { |
759 const int scalar_dst_lead = sizeof (Uint32) * 4; | 756 const int scalar_dst_lead = sizeof(Uint32) * 4; |
760 const int vector_dst_lead = sizeof (Uint32) * 16; | 757 const int vector_dst_lead = sizeof(Uint32) * 16; |
761 | 758 |
762 int height = info->d_height; | 759 int height = info->d_height; |
763 Uint32 *src = (Uint32 *) info->s_pixels; | 760 Uint32 *src = (Uint32 *) info->s_pixels; |
764 int srcskip = info->s_skip; | 761 int srcskip = info->s_skip; |
765 Uint32 *dst = (Uint32 *) info->d_pixels; | 762 Uint32 *dst = (Uint32 *) info->d_pixels; |
766 int dstskip = info->d_skip; | 763 int dstskip = info->d_skip; |
767 SDL_PixelFormat *srcfmt = info->src; | 764 SDL_PixelFormat *srcfmt = info->src; |
768 SDL_PixelFormat *dstfmt = info->dst; | 765 SDL_PixelFormat *dstfmt = info->dst; |
769 vector unsigned int vzero = vec_splat_u32 (0); | 766 vector unsigned int vzero = vec_splat_u32(0); |
770 vector unsigned char vpermute = calc_swizzle32 (srcfmt, dstfmt); | 767 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt); |
771 if (dstfmt->Amask && !srcfmt->Amask) { | 768 if (dstfmt->Amask && !srcfmt->Amask) { |
772 if (srcfmt->alpha) { | 769 if (srcfmt->alpha) { |
773 vector unsigned char valpha; | 770 vector unsigned char valpha; |
774 ((unsigned char *) &valpha)[0] = srcfmt->alpha; | 771 ((unsigned char *) &valpha)[0] = srcfmt->alpha; |
775 vzero = (vector unsigned int) vec_splat (valpha, 0); | 772 vzero = (vector unsigned int) vec_splat(valpha, 0); |
776 } | 773 } |
777 } | 774 } |
778 | 775 |
779 assert (srcfmt->BytesPerPixel == 4); | 776 assert(srcfmt->BytesPerPixel == 4); |
780 assert (dstfmt->BytesPerPixel == 4); | 777 assert(dstfmt->BytesPerPixel == 4); |
781 | 778 |
782 while (height--) { | 779 while (height--) { |
783 vector unsigned char valigner; | 780 vector unsigned char valigner; |
784 vector unsigned int vbits; | 781 vector unsigned int vbits; |
785 vector unsigned int voverflow; | 782 vector unsigned int voverflow; |
788 | 785 |
789 int width = info->d_width; | 786 int width = info->d_width; |
790 int extrawidth; | 787 int extrawidth; |
791 | 788 |
792 /* do scalar until we can align... */ | 789 /* do scalar until we can align... */ |
793 while ((UNALIGNED_PTR (dst)) && (width)) { | 790 while ((UNALIGNED_PTR(dst)) && (width)) { |
794 vec_dstt (src + scalar_dst_lead, DST_CTRL (2, 32, 1024), | 791 vec_dstt(src + scalar_dst_lead, DST_CTRL(2, 32, 1024), |
795 DST_CHAN_SRC); | 792 DST_CHAN_SRC); |
796 vec_dstst (dst + scalar_dst_lead, DST_CTRL (2, 32, 1024), | 793 vec_dstst(dst + scalar_dst_lead, DST_CTRL(2, 32, 1024), |
797 DST_CHAN_DEST); | 794 DST_CHAN_DEST); |
798 bits = *(src++); | 795 bits = *(src++); |
799 RGBA_FROM_8888 (bits, srcfmt, r, g, b, a); | 796 RGBA_FROM_8888(bits, srcfmt, r, g, b, a); |
800 *(dst++) = MAKE8888 (dstfmt, r, g, b, a); | 797 *(dst++) = MAKE8888(dstfmt, r, g, b, a); |
801 width--; | 798 width--; |
802 } | 799 } |
803 | 800 |
804 /* After all that work, here's the vector part! */ | 801 /* After all that work, here's the vector part! */ |
805 extrawidth = (width % 4); | 802 extrawidth = (width % 4); |
806 width -= extrawidth; | 803 width -= extrawidth; |
807 valigner = VEC_ALIGNER (src); | 804 valigner = VEC_ALIGNER(src); |
808 vbits = vec_ld (0, src); | 805 vbits = vec_ld(0, src); |
809 | 806 |
810 while (width) { | 807 while (width) { |
811 vec_dstt (src + vector_dst_lead, DST_CTRL (2, 32, 1024), | 808 vec_dstt(src + vector_dst_lead, DST_CTRL(2, 32, 1024), |
812 DST_CHAN_SRC); | 809 DST_CHAN_SRC); |
813 vec_dstst (dst + vector_dst_lead, DST_CTRL (2, 32, 1024), | 810 vec_dstst(dst + vector_dst_lead, DST_CTRL(2, 32, 1024), |
814 DST_CHAN_DEST); | 811 DST_CHAN_DEST); |
815 voverflow = vec_ld (15, src); | 812 voverflow = vec_ld(15, src); |
816 src += 4; | 813 src += 4; |
817 width -= 4; | 814 width -= 4; |
818 vbits = vec_perm (vbits, voverflow, valigner); /* src is ready. */ | 815 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */ |
819 vbits = vec_perm (vbits, vzero, vpermute); /* swizzle it. */ | 816 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */ |
820 vec_st (vbits, 0, dst); /* store it back out. */ | 817 vec_st(vbits, 0, dst); /* store it back out. */ |
821 dst += 4; | 818 dst += 4; |
822 vbits = voverflow; | 819 vbits = voverflow; |
823 } | 820 } |
824 | 821 |
825 assert (width == 0); | 822 assert(width == 0); |
826 | 823 |
827 /* cover pixels at the end of the row that didn't fit in 16 bytes. */ | 824 /* cover pixels at the end of the row that didn't fit in 16 bytes. */ |
828 while (extrawidth) { | 825 while (extrawidth) { |
829 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */ | 826 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */ |
830 RGBA_FROM_8888 (bits, srcfmt, r, g, b, a); | 827 RGBA_FROM_8888(bits, srcfmt, r, g, b, a); |
831 *(dst++) = MAKE8888 (dstfmt, r, g, b, a); | 828 *(dst++) = MAKE8888(dstfmt, r, g, b, a); |
832 extrawidth--; | 829 extrawidth--; |
833 } | 830 } |
834 | 831 |
835 src += srcskip >> 2; /* move to next row, accounting for pitch. */ | 832 src += srcskip >> 2; /* move to next row, accounting for pitch. */ |
836 dst += dstskip >> 2; | 833 dst += dstskip >> 2; |
837 } | 834 } |
838 | 835 |
839 vec_dss (DST_CHAN_SRC); | 836 vec_dss(DST_CHAN_SRC); |
840 vec_dss (DST_CHAN_DEST); | 837 vec_dss(DST_CHAN_DEST); |
841 } | 838 } |
842 | 839 |
843 static Uint32 | 840 static Uint32 |
844 GetBlitFeatures (void) | 841 GetBlitFeatures(void) |
845 { | 842 { |
846 static Uint32 features = 0xffffffff; | 843 static Uint32 features = 0xffffffff; |
847 if (features == 0xffffffff) { | 844 if (features == 0xffffffff) { |
848 /* Provide an override for testing .. */ | 845 /* Provide an override for testing .. */ |
849 char *override = SDL_getenv ("SDL_ALTIVEC_BLIT_FEATURES"); | 846 char *override = SDL_getenv("SDL_ALTIVEC_BLIT_FEATURES"); |
850 if (override) { | 847 if (override) { |
851 features = 0; | 848 features = 0; |
852 SDL_sscanf (override, "%u", &features); | 849 SDL_sscanf(override, "%u", &features); |
853 } else { | 850 } else { |
854 features = (0 | 851 features = (0 |
855 /* Feature 1 is has-MMX */ | 852 /* Feature 1 is has-MMX */ |
856 | ((SDL_HasMMX ())? 1 : 0) | 853 | ((SDL_HasMMX())? 1 : 0) |
857 /* Feature 2 is has-AltiVec */ | 854 /* Feature 2 is has-AltiVec */ |
858 | ((SDL_HasAltiVec ())? 2 : 0) | 855 | ((SDL_HasAltiVec())? 2 : 0) |
859 /* Feature 4 is dont-use-prefetch */ | 856 /* Feature 4 is dont-use-prefetch */ |
860 /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */ | 857 /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */ |
861 | ((GetL3CacheSize () == 0) ? 4 : 0) | 858 | ((GetL3CacheSize() == 0) ? 4 : 0) |
862 ); | 859 ); |
863 } | 860 } |
864 } | 861 } |
865 return features; | 862 return features; |
866 } | 863 } |
900 dst = (Uint8)((((src)&0x00E00000)>>16)| \ | 897 dst = (Uint8)((((src)&0x00E00000)>>16)| \ |
901 (((src)&0x0000E000)>>11)| \ | 898 (((src)&0x0000E000)>>11)| \ |
902 (((src)&0x000000C0)>>6)); \ | 899 (((src)&0x000000C0)>>6)); \ |
903 } | 900 } |
904 static void | 901 static void |
905 Blit_RGB888_index8 (SDL_BlitInfo * info) | 902 Blit_RGB888_index8(SDL_BlitInfo * info) |
906 { | 903 { |
907 #ifndef USE_DUFFS_LOOP | 904 #ifndef USE_DUFFS_LOOP |
908 int c; | 905 int c; |
909 #endif | 906 #endif |
910 int width, height; | 907 int width, height; |
932 /* *INDENT-ON* */ | 929 /* *INDENT-ON* */ |
933 #else | 930 #else |
934 for (c = width / 4; c; --c) { | 931 for (c = width / 4; c; --c) { |
935 /* Pack RGB into 8bit pixel */ | 932 /* Pack RGB into 8bit pixel */ |
936 ++src; | 933 ++src; |
937 RGB888_RGB332 (*dst++, *src); | 934 RGB888_RGB332(*dst++, *src); |
938 ++src; | 935 ++src; |
939 RGB888_RGB332 (*dst++, *src); | 936 RGB888_RGB332(*dst++, *src); |
940 ++src; | 937 ++src; |
941 RGB888_RGB332 (*dst++, *src); | 938 RGB888_RGB332(*dst++, *src); |
942 ++src; | 939 ++src; |
943 } | 940 } |
944 switch (width & 3) { | 941 switch (width & 3) { |
945 case 3: | 942 case 3: |
946 RGB888_RGB332 (*dst++, *src); | 943 RGB888_RGB332(*dst++, *src); |
947 ++src; | 944 ++src; |
948 case 2: | 945 case 2: |
949 RGB888_RGB332 (*dst++, *src); | 946 RGB888_RGB332(*dst++, *src); |
950 ++src; | 947 ++src; |
951 case 1: | 948 case 1: |
952 RGB888_RGB332 (*dst++, *src); | 949 RGB888_RGB332(*dst++, *src); |
953 ++src; | 950 ++src; |
954 } | 951 } |
955 #endif /* USE_DUFFS_LOOP */ | 952 #endif /* USE_DUFFS_LOOP */ |
956 src += srcskip; | 953 src += srcskip; |
957 dst += dstskip; | 954 dst += dstskip; |
969 , width); | 966 , width); |
970 /* *INDENT-ON* */ | 967 /* *INDENT-ON* */ |
971 #else | 968 #else |
972 for (c = width / 4; c; --c) { | 969 for (c = width / 4; c; --c) { |
973 /* Pack RGB into 8bit pixel */ | 970 /* Pack RGB into 8bit pixel */ |
974 RGB888_RGB332 (Pixel, *src); | 971 RGB888_RGB332(Pixel, *src); |
975 *dst++ = map[Pixel]; | 972 *dst++ = map[Pixel]; |
976 ++src; | 973 ++src; |
977 RGB888_RGB332 (Pixel, *src); | 974 RGB888_RGB332(Pixel, *src); |
978 *dst++ = map[Pixel]; | 975 *dst++ = map[Pixel]; |
979 ++src; | 976 ++src; |
980 RGB888_RGB332 (Pixel, *src); | 977 RGB888_RGB332(Pixel, *src); |
981 *dst++ = map[Pixel]; | 978 *dst++ = map[Pixel]; |
982 ++src; | 979 ++src; |
983 RGB888_RGB332 (Pixel, *src); | 980 RGB888_RGB332(Pixel, *src); |
984 *dst++ = map[Pixel]; | 981 *dst++ = map[Pixel]; |
985 ++src; | 982 ++src; |
986 } | 983 } |
987 switch (width & 3) { | 984 switch (width & 3) { |
988 case 3: | 985 case 3: |
989 RGB888_RGB332 (Pixel, *src); | 986 RGB888_RGB332(Pixel, *src); |
990 *dst++ = map[Pixel]; | 987 *dst++ = map[Pixel]; |
991 ++src; | 988 ++src; |
992 case 2: | 989 case 2: |
993 RGB888_RGB332 (Pixel, *src); | 990 RGB888_RGB332(Pixel, *src); |
994 *dst++ = map[Pixel]; | 991 *dst++ = map[Pixel]; |
995 ++src; | 992 ++src; |
996 case 1: | 993 case 1: |
997 RGB888_RGB332 (Pixel, *src); | 994 RGB888_RGB332(Pixel, *src); |
998 *dst++ = map[Pixel]; | 995 *dst++ = map[Pixel]; |
999 ++src; | 996 ++src; |
1000 } | 997 } |
1001 #endif /* USE_DUFFS_LOOP */ | 998 #endif /* USE_DUFFS_LOOP */ |
1002 src += srcskip; | 999 src += srcskip; |
1018 (((src[LO])&0x00F80000)>>9)| \ | 1015 (((src[LO])&0x00F80000)>>9)| \ |
1019 (((src[LO])&0x0000F800)>>6)| \ | 1016 (((src[LO])&0x0000F800)>>6)| \ |
1020 (((src[LO])&0x000000F8)>>3); \ | 1017 (((src[LO])&0x000000F8)>>3); \ |
1021 } | 1018 } |
1022 static void | 1019 static void |
1023 Blit_RGB888_RGB555 (SDL_BlitInfo * info) | 1020 Blit_RGB888_RGB555(SDL_BlitInfo * info) |
1024 { | 1021 { |
1025 #ifndef USE_DUFFS_LOOP | 1022 #ifndef USE_DUFFS_LOOP |
1026 int c; | 1023 int c; |
1027 #endif | 1024 #endif |
1028 int width, height; | 1025 int width, height; |
1059 } | 1056 } |
1060 --width; | 1057 --width; |
1061 | 1058 |
1062 while (height--) { | 1059 while (height--) { |
1063 /* Perform copy alignment */ | 1060 /* Perform copy alignment */ |
1064 RGB888_RGB555 (dst, src); | 1061 RGB888_RGB555(dst, src); |
1065 ++src; | 1062 ++src; |
1066 ++dst; | 1063 ++dst; |
1067 | 1064 |
1068 /* Copy in 4 pixel chunks */ | 1065 /* Copy in 4 pixel chunks */ |
1069 for (c = width / 4; c; --c) { | 1066 for (c = width / 4; c; --c) { |
1070 RGB888_RGB555_TWO (dst, src); | 1067 RGB888_RGB555_TWO(dst, src); |
1071 src += 2; | 1068 src += 2; |
1072 dst += 2; | 1069 dst += 2; |
1073 RGB888_RGB555_TWO (dst, src); | 1070 RGB888_RGB555_TWO(dst, src); |
1074 src += 2; | 1071 src += 2; |
1075 dst += 2; | 1072 dst += 2; |
1076 } | 1073 } |
1077 /* Get any leftovers */ | 1074 /* Get any leftovers */ |
1078 switch (width & 3) { | 1075 switch (width & 3) { |
1079 case 3: | 1076 case 3: |
1080 RGB888_RGB555 (dst, src); | 1077 RGB888_RGB555(dst, src); |
1081 ++src; | 1078 ++src; |
1082 ++dst; | 1079 ++dst; |
1083 case 2: | 1080 case 2: |
1084 RGB888_RGB555_TWO (dst, src); | 1081 RGB888_RGB555_TWO(dst, src); |
1085 src += 2; | 1082 src += 2; |
1086 dst += 2; | 1083 dst += 2; |
1087 break; | 1084 break; |
1088 case 1: | 1085 case 1: |
1089 RGB888_RGB555 (dst, src); | 1086 RGB888_RGB555(dst, src); |
1090 ++src; | 1087 ++src; |
1091 ++dst; | 1088 ++dst; |
1092 break; | 1089 break; |
1093 } | 1090 } |
1094 src += srcskip; | 1091 src += srcskip; |
1096 } | 1093 } |
1097 } else { | 1094 } else { |
1098 while (height--) { | 1095 while (height--) { |
1099 /* Copy in 4 pixel chunks */ | 1096 /* Copy in 4 pixel chunks */ |
1100 for (c = width / 4; c; --c) { | 1097 for (c = width / 4; c; --c) { |
1101 RGB888_RGB555_TWO (dst, src); | 1098 RGB888_RGB555_TWO(dst, src); |
1102 src += 2; | 1099 src += 2; |
1103 dst += 2; | 1100 dst += 2; |
1104 RGB888_RGB555_TWO (dst, src); | 1101 RGB888_RGB555_TWO(dst, src); |
1105 src += 2; | 1102 src += 2; |
1106 dst += 2; | 1103 dst += 2; |
1107 } | 1104 } |
1108 /* Get any leftovers */ | 1105 /* Get any leftovers */ |
1109 switch (width & 3) { | 1106 switch (width & 3) { |
1110 case 3: | 1107 case 3: |
1111 RGB888_RGB555 (dst, src); | 1108 RGB888_RGB555(dst, src); |
1112 ++src; | 1109 ++src; |
1113 ++dst; | 1110 ++dst; |
1114 case 2: | 1111 case 2: |
1115 RGB888_RGB555_TWO (dst, src); | 1112 RGB888_RGB555_TWO(dst, src); |
1116 src += 2; | 1113 src += 2; |
1117 dst += 2; | 1114 dst += 2; |
1118 break; | 1115 break; |
1119 case 1: | 1116 case 1: |
1120 RGB888_RGB555 (dst, src); | 1117 RGB888_RGB555(dst, src); |
1121 ++src; | 1118 ++src; |
1122 ++dst; | 1119 ++dst; |
1123 break; | 1120 break; |
1124 } | 1121 } |
1125 src += srcskip; | 1122 src += srcskip; |
1142 (((src[LO])&0x00F80000)>>8)| \ | 1139 (((src[LO])&0x00F80000)>>8)| \ |
1143 (((src[LO])&0x0000FC00)>>5)| \ | 1140 (((src[LO])&0x0000FC00)>>5)| \ |
1144 (((src[LO])&0x000000F8)>>3); \ | 1141 (((src[LO])&0x000000F8)>>3); \ |
1145 } | 1142 } |
1146 static void | 1143 static void |
1147 Blit_RGB888_RGB565 (SDL_BlitInfo * info) | 1144 Blit_RGB888_RGB565(SDL_BlitInfo * info) |
1148 { | 1145 { |
1149 #ifndef USE_DUFFS_LOOP | 1146 #ifndef USE_DUFFS_LOOP |
1150 int c; | 1147 int c; |
1151 #endif | 1148 #endif |
1152 int width, height; | 1149 int width, height; |
1183 } | 1180 } |
1184 --width; | 1181 --width; |
1185 | 1182 |
1186 while (height--) { | 1183 while (height--) { |
1187 /* Perform copy alignment */ | 1184 /* Perform copy alignment */ |
1188 RGB888_RGB565 (dst, src); | 1185 RGB888_RGB565(dst, src); |
1189 ++src; | 1186 ++src; |
1190 ++dst; | 1187 ++dst; |
1191 | 1188 |
1192 /* Copy in 4 pixel chunks */ | 1189 /* Copy in 4 pixel chunks */ |
1193 for (c = width / 4; c; --c) { | 1190 for (c = width / 4; c; --c) { |
1194 RGB888_RGB565_TWO (dst, src); | 1191 RGB888_RGB565_TWO(dst, src); |
1195 src += 2; | 1192 src += 2; |
1196 dst += 2; | 1193 dst += 2; |
1197 RGB888_RGB565_TWO (dst, src); | 1194 RGB888_RGB565_TWO(dst, src); |
1198 src += 2; | 1195 src += 2; |
1199 dst += 2; | 1196 dst += 2; |
1200 } | 1197 } |
1201 /* Get any leftovers */ | 1198 /* Get any leftovers */ |
1202 switch (width & 3) { | 1199 switch (width & 3) { |
1203 case 3: | 1200 case 3: |
1204 RGB888_RGB565 (dst, src); | 1201 RGB888_RGB565(dst, src); |
1205 ++src; | 1202 ++src; |
1206 ++dst; | 1203 ++dst; |
1207 case 2: | 1204 case 2: |
1208 RGB888_RGB565_TWO (dst, src); | 1205 RGB888_RGB565_TWO(dst, src); |
1209 src += 2; | 1206 src += 2; |
1210 dst += 2; | 1207 dst += 2; |
1211 break; | 1208 break; |
1212 case 1: | 1209 case 1: |
1213 RGB888_RGB565 (dst, src); | 1210 RGB888_RGB565(dst, src); |
1214 ++src; | 1211 ++src; |
1215 ++dst; | 1212 ++dst; |
1216 break; | 1213 break; |
1217 } | 1214 } |
1218 src += srcskip; | 1215 src += srcskip; |
1220 } | 1217 } |
1221 } else { | 1218 } else { |
1222 while (height--) { | 1219 while (height--) { |
1223 /* Copy in 4 pixel chunks */ | 1220 /* Copy in 4 pixel chunks */ |
1224 for (c = width / 4; c; --c) { | 1221 for (c = width / 4; c; --c) { |
1225 RGB888_RGB565_TWO (dst, src); | 1222 RGB888_RGB565_TWO(dst, src); |
1226 src += 2; | 1223 src += 2; |
1227 dst += 2; | 1224 dst += 2; |
1228 RGB888_RGB565_TWO (dst, src); | 1225 RGB888_RGB565_TWO(dst, src); |
1229 src += 2; | 1226 src += 2; |
1230 dst += 2; | 1227 dst += 2; |
1231 } | 1228 } |
1232 /* Get any leftovers */ | 1229 /* Get any leftovers */ |
1233 switch (width & 3) { | 1230 switch (width & 3) { |
1234 case 3: | 1231 case 3: |
1235 RGB888_RGB565 (dst, src); | 1232 RGB888_RGB565(dst, src); |
1236 ++src; | 1233 ++src; |
1237 ++dst; | 1234 ++dst; |
1238 case 2: | 1235 case 2: |
1239 RGB888_RGB565_TWO (dst, src); | 1236 RGB888_RGB565_TWO(dst, src); |
1240 src += 2; | 1237 src += 2; |
1241 dst += 2; | 1238 dst += 2; |
1242 break; | 1239 break; |
1243 case 1: | 1240 case 1: |
1244 RGB888_RGB565 (dst, src); | 1241 RGB888_RGB565(dst, src); |
1245 ++src; | 1242 ++src; |
1246 ++dst; | 1243 ++dst; |
1247 break; | 1244 break; |
1248 } | 1245 } |
1249 src += srcskip; | 1246 src += srcskip; |
1257 | 1254 |
1258 | 1255 |
1259 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */ | 1256 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */ |
1260 #define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1]) | 1257 #define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1]) |
1261 static void | 1258 static void |
1262 Blit_RGB565_32 (SDL_BlitInfo * info, const Uint32 * map) | 1259 Blit_RGB565_32(SDL_BlitInfo * info, const Uint32 * map) |
1263 { | 1260 { |
1264 #ifndef USE_DUFFS_LOOP | 1261 #ifndef USE_DUFFS_LOOP |
1265 int c; | 1262 int c; |
1266 #endif | 1263 #endif |
1267 int width, height; | 1264 int width, height; |
1292 } | 1289 } |
1293 #else | 1290 #else |
1294 while (height--) { | 1291 while (height--) { |
1295 /* Copy in 4 pixel chunks */ | 1292 /* Copy in 4 pixel chunks */ |
1296 for (c = width / 4; c; --c) { | 1293 for (c = width / 4; c; --c) { |
1297 *dst++ = RGB565_32 (dst, src, map); | 1294 *dst++ = RGB565_32(dst, src, map); |
1298 src += 2; | 1295 src += 2; |
1299 *dst++ = RGB565_32 (dst, src, map); | 1296 *dst++ = RGB565_32(dst, src, map); |
1300 src += 2; | 1297 src += 2; |
1301 *dst++ = RGB565_32 (dst, src, map); | 1298 *dst++ = RGB565_32(dst, src, map); |
1302 src += 2; | 1299 src += 2; |
1303 *dst++ = RGB565_32 (dst, src, map); | 1300 *dst++ = RGB565_32(dst, src, map); |
1304 src += 2; | 1301 src += 2; |
1305 } | 1302 } |
1306 /* Get any leftovers */ | 1303 /* Get any leftovers */ |
1307 switch (width & 3) { | 1304 switch (width & 3) { |
1308 case 3: | 1305 case 3: |
1309 *dst++ = RGB565_32 (dst, src, map); | 1306 *dst++ = RGB565_32(dst, src, map); |
1310 src += 2; | 1307 src += 2; |
1311 case 2: | 1308 case 2: |
1312 *dst++ = RGB565_32 (dst, src, map); | 1309 *dst++ = RGB565_32(dst, src, map); |
1313 src += 2; | 1310 src += 2; |
1314 case 1: | 1311 case 1: |
1315 *dst++ = RGB565_32 (dst, src, map); | 1312 *dst++ = RGB565_32(dst, src, map); |
1316 src += 2; | 1313 src += 2; |
1317 break; | 1314 break; |
1318 } | 1315 } |
1319 src += srcskip; | 1316 src += srcskip; |
1320 dst += dstskip; | 1317 dst += dstskip; |
1452 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100, | 1449 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100, |
1453 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100, | 1450 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100, |
1454 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200 | 1451 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200 |
1455 }; | 1452 }; |
1456 static void | 1453 static void |
1457 Blit_RGB565_ARGB8888 (SDL_BlitInfo * info) | 1454 Blit_RGB565_ARGB8888(SDL_BlitInfo * info) |
1458 { | 1455 { |
1459 Blit_RGB565_32 (info, RGB565_ARGB8888_LUT); | 1456 Blit_RGB565_32(info, RGB565_ARGB8888_LUT); |
1460 } | 1457 } |
1461 | 1458 |
1462 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */ | 1459 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */ |
1463 static const Uint32 RGB565_ABGR8888_LUT[512] = { | 1460 static const Uint32 RGB565_ABGR8888_LUT[512] = { |
1464 0xff000000, 0x00000000, 0xff080000, 0x00002000, | 1461 0xff000000, 0x00000000, 0xff080000, 0x00002000, |
1589 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff, | 1586 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff, |
1590 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff, | 1587 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff, |
1591 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff | 1588 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff |
1592 }; | 1589 }; |
1593 static void | 1590 static void |
1594 Blit_RGB565_ABGR8888 (SDL_BlitInfo * info) | 1591 Blit_RGB565_ABGR8888(SDL_BlitInfo * info) |
1595 { | 1592 { |
1596 Blit_RGB565_32 (info, RGB565_ABGR8888_LUT); | 1593 Blit_RGB565_32(info, RGB565_ABGR8888_LUT); |
1597 } | 1594 } |
1598 | 1595 |
1599 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */ | 1596 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */ |
1600 static const Uint32 RGB565_RGBA8888_LUT[512] = { | 1597 static const Uint32 RGB565_RGBA8888_LUT[512] = { |
1601 0x000000ff, 0x00000000, 0x000008ff, 0x00200000, | 1598 0x000000ff, 0x00000000, 0x000008ff, 0x00200000, |
1726 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000, | 1723 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000, |
1727 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000, | 1724 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000, |
1728 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000, | 1725 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000, |
1729 }; | 1726 }; |
1730 static void | 1727 static void |
1731 Blit_RGB565_RGBA8888 (SDL_BlitInfo * info) | 1728 Blit_RGB565_RGBA8888(SDL_BlitInfo * info) |
1732 { | 1729 { |
1733 Blit_RGB565_32 (info, RGB565_RGBA8888_LUT); | 1730 Blit_RGB565_32(info, RGB565_RGBA8888_LUT); |
1734 } | 1731 } |
1735 | 1732 |
1736 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */ | 1733 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */ |
1737 static const Uint32 RGB565_BGRA8888_LUT[512] = { | 1734 static const Uint32 RGB565_BGRA8888_LUT[512] = { |
1738 0x00000000, 0x000000ff, 0x08000000, 0x002000ff, | 1735 0x00000000, 0x000000ff, 0x08000000, 0x002000ff, |
1863 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff, | 1860 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff, |
1864 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff, | 1861 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff, |
1865 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff | 1862 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff |
1866 }; | 1863 }; |
1867 static void | 1864 static void |
1868 Blit_RGB565_BGRA8888 (SDL_BlitInfo * info) | 1865 Blit_RGB565_BGRA8888(SDL_BlitInfo * info) |
1869 { | 1866 { |
1870 Blit_RGB565_32 (info, RGB565_BGRA8888_LUT); | 1867 Blit_RGB565_32(info, RGB565_BGRA8888_LUT); |
1871 } | 1868 } |
1872 | 1869 |
1873 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */ | 1870 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */ |
1874 #ifndef RGB888_RGB332 | 1871 #ifndef RGB888_RGB332 |
1875 #define RGB888_RGB332(dst, src) { \ | 1872 #define RGB888_RGB332(dst, src) { \ |
1877 (((src)&0x0000E000)>>11)| \ | 1874 (((src)&0x0000E000)>>11)| \ |
1878 (((src)&0x000000C0)>>6); \ | 1875 (((src)&0x000000C0)>>6); \ |
1879 } | 1876 } |
1880 #endif | 1877 #endif |
1881 static void | 1878 static void |
1882 Blit_RGB888_index8_map (SDL_BlitInfo * info) | 1879 Blit_RGB888_index8_map(SDL_BlitInfo * info) |
1883 { | 1880 { |
1884 #ifndef USE_DUFFS_LOOP | 1881 #ifndef USE_DUFFS_LOOP |
1885 int c; | 1882 int c; |
1886 #endif | 1883 #endif |
1887 int Pixel; | 1884 int Pixel; |
1914 } | 1911 } |
1915 #else | 1912 #else |
1916 while (height--) { | 1913 while (height--) { |
1917 for (c = width / 4; c; --c) { | 1914 for (c = width / 4; c; --c) { |
1918 /* Pack RGB into 8bit pixel */ | 1915 /* Pack RGB into 8bit pixel */ |
1919 RGB888_RGB332 (Pixel, *src); | 1916 RGB888_RGB332(Pixel, *src); |
1920 *dst++ = map[Pixel]; | 1917 *dst++ = map[Pixel]; |
1921 ++src; | 1918 ++src; |
1922 RGB888_RGB332 (Pixel, *src); | 1919 RGB888_RGB332(Pixel, *src); |
1923 *dst++ = map[Pixel]; | 1920 *dst++ = map[Pixel]; |
1924 ++src; | 1921 ++src; |
1925 RGB888_RGB332 (Pixel, *src); | 1922 RGB888_RGB332(Pixel, *src); |
1926 *dst++ = map[Pixel]; | 1923 *dst++ = map[Pixel]; |
1927 ++src; | 1924 ++src; |
1928 RGB888_RGB332 (Pixel, *src); | 1925 RGB888_RGB332(Pixel, *src); |
1929 *dst++ = map[Pixel]; | 1926 *dst++ = map[Pixel]; |
1930 ++src; | 1927 ++src; |
1931 } | 1928 } |
1932 switch (width & 3) { | 1929 switch (width & 3) { |
1933 case 3: | 1930 case 3: |
1934 RGB888_RGB332 (Pixel, *src); | 1931 RGB888_RGB332(Pixel, *src); |
1935 *dst++ = map[Pixel]; | 1932 *dst++ = map[Pixel]; |
1936 ++src; | 1933 ++src; |
1937 case 2: | 1934 case 2: |
1938 RGB888_RGB332 (Pixel, *src); | 1935 RGB888_RGB332(Pixel, *src); |
1939 *dst++ = map[Pixel]; | 1936 *dst++ = map[Pixel]; |
1940 ++src; | 1937 ++src; |
1941 case 1: | 1938 case 1: |
1942 RGB888_RGB332 (Pixel, *src); | 1939 RGB888_RGB332(Pixel, *src); |
1943 *dst++ = map[Pixel]; | 1940 *dst++ = map[Pixel]; |
1944 ++src; | 1941 ++src; |
1945 } | 1942 } |
1946 src += srcskip; | 1943 src += srcskip; |
1947 dst += dstskip; | 1944 dst += dstskip; |
1948 } | 1945 } |
1949 #endif /* USE_DUFFS_LOOP */ | 1946 #endif /* USE_DUFFS_LOOP */ |
1950 } | 1947 } |
1951 static void | 1948 static void |
1952 BlitNto1 (SDL_BlitInfo * info) | 1949 BlitNto1(SDL_BlitInfo * info) |
1953 { | 1950 { |
1954 #ifndef USE_DUFFS_LOOP | 1951 #ifndef USE_DUFFS_LOOP |
1955 int c; | 1952 int c; |
1956 #endif | 1953 #endif |
1957 int width, height; | 1954 int width, height; |
1992 src += srcbpp; | 1989 src += srcbpp; |
1993 , width); | 1990 , width); |
1994 /* *INDENT-ON* */ | 1991 /* *INDENT-ON* */ |
1995 #else | 1992 #else |
1996 for (c = width; c; --c) { | 1993 for (c = width; c; --c) { |
1997 DISEMBLE_RGB (src, srcbpp, srcfmt, Pixel, sR, sG, sB); | 1994 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB); |
1998 if (1) { | 1995 if (1) { |
1999 /* Pack RGB into 8bit pixel */ | 1996 /* Pack RGB into 8bit pixel */ |
2000 *dst = ((sR >> 5) << (3 + 2)) | | 1997 *dst = ((sR >> 5) << (3 + 2)) | |
2001 ((sG >> 5) << (2)) | ((sB >> 6) << (0)); | 1998 ((sG >> 5) << (2)) | ((sB >> 6) << (0)); |
2002 } | 1999 } |
2024 src += srcbpp; | 2021 src += srcbpp; |
2025 , width); | 2022 , width); |
2026 /* *INDENT-ON* */ | 2023 /* *INDENT-ON* */ |
2027 #else | 2024 #else |
2028 for (c = width; c; --c) { | 2025 for (c = width; c; --c) { |
2029 DISEMBLE_RGB (src, srcbpp, srcfmt, Pixel, sR, sG, sB); | 2026 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB); |
2030 if (1) { | 2027 if (1) { |
2031 /* Pack RGB into 8bit pixel */ | 2028 /* Pack RGB into 8bit pixel */ |
2032 *dst = map[((sR >> 5) << (3 + 2)) | | 2029 *dst = map[((sR >> 5) << (3 + 2)) | |
2033 ((sG >> 5) << (2)) | ((sB >> 6) << (0))]; | 2030 ((sG >> 5) << (2)) | ((sB >> 6) << (0))]; |
2034 } | 2031 } |
2042 } | 2039 } |
2043 } | 2040 } |
2044 | 2041 |
2045 /* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */ | 2042 /* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */ |
2046 static void | 2043 static void |
2047 Blit4to4MaskAlpha (SDL_BlitInfo * info) | 2044 Blit4to4MaskAlpha(SDL_BlitInfo * info) |
2048 { | 2045 { |
2049 int width = info->d_width; | 2046 int width = info->d_width; |
2050 int height = info->d_height; | 2047 int height = info->d_height; |
2051 Uint32 *src = (Uint32 *) info->s_pixels; | 2048 Uint32 *src = (Uint32 *) info->s_pixels; |
2052 int srcskip = info->s_skip; | 2049 int srcskip = info->s_skip; |
2091 } | 2088 } |
2092 } | 2089 } |
2093 } | 2090 } |
2094 | 2091 |
2095 static void | 2092 static void |
2096 BlitNtoN (SDL_BlitInfo * info) | 2093 BlitNtoN(SDL_BlitInfo * info) |
2097 { | 2094 { |
2098 int width = info->d_width; | 2095 int width = info->d_width; |
2099 int height = info->d_height; | 2096 int height = info->d_height; |
2100 Uint8 *src = info->s_pixels; | 2097 Uint8 *src = info->s_pixels; |
2101 int srcskip = info->s_skip; | 2098 int srcskip = info->s_skip; |
2126 dst += dstskip; | 2123 dst += dstskip; |
2127 } | 2124 } |
2128 } | 2125 } |
2129 | 2126 |
2130 static void | 2127 static void |
2131 BlitNtoNCopyAlpha (SDL_BlitInfo * info) | 2128 BlitNtoNCopyAlpha(SDL_BlitInfo * info) |
2132 { | 2129 { |
2133 int width = info->d_width; | 2130 int width = info->d_width; |
2134 int height = info->d_height; | 2131 int height = info->d_height; |
2135 Uint8 *src = info->s_pixels; | 2132 Uint8 *src = info->s_pixels; |
2136 int srcskip = info->s_skip; | 2133 int srcskip = info->s_skip; |
2145 /* FIXME: should map alpha to [0..255] correctly! */ | 2142 /* FIXME: should map alpha to [0..255] correctly! */ |
2146 while (height--) { | 2143 while (height--) { |
2147 for (c = width; c; --c) { | 2144 for (c = width; c; --c) { |
2148 Uint32 Pixel; | 2145 Uint32 Pixel; |
2149 unsigned sR, sG, sB, sA; | 2146 unsigned sR, sG, sB, sA; |
2150 DISEMBLE_RGBA (src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA); | 2147 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA); |
2151 ASSEMBLE_RGBA (dst, dstbpp, dstfmt, sR, sG, sB, sA); | 2148 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA); |
2152 dst += dstbpp; | 2149 dst += dstbpp; |
2153 src += srcbpp; | 2150 src += srcbpp; |
2154 } | 2151 } |
2155 src += srcskip; | 2152 src += srcskip; |
2156 dst += dstskip; | 2153 dst += dstskip; |
2157 } | 2154 } |
2158 } | 2155 } |
2159 | 2156 |
2160 static void | 2157 static void |
2161 BlitNto1Key (SDL_BlitInfo * info) | 2158 BlitNto1Key(SDL_BlitInfo * info) |
2162 { | 2159 { |
2163 int width = info->d_width; | 2160 int width = info->d_width; |
2164 int height = info->d_height; | 2161 int height = info->d_height; |
2165 Uint8 *src = info->s_pixels; | 2162 Uint8 *src = info->s_pixels; |
2166 int srcskip = info->s_skip; | 2163 int srcskip = info->s_skip; |
2222 } | 2219 } |
2223 } | 2220 } |
2224 } | 2221 } |
2225 | 2222 |
2226 static void | 2223 static void |
2227 Blit2to2Key (SDL_BlitInfo * info) | 2224 Blit2to2Key(SDL_BlitInfo * info) |
2228 { | 2225 { |
2229 int width = info->d_width; | 2226 int width = info->d_width; |
2230 int height = info->d_height; | 2227 int height = info->d_height; |
2231 Uint16 *srcp = (Uint16 *) info->s_pixels; | 2228 Uint16 *srcp = (Uint16 *) info->s_pixels; |
2232 int srcskip = info->s_skip; | 2229 int srcskip = info->s_skip; |
2256 dstp += dstskip; | 2253 dstp += dstskip; |
2257 } | 2254 } |
2258 } | 2255 } |
2259 | 2256 |
2260 static void | 2257 static void |
2261 BlitNtoNKey (SDL_BlitInfo * info) | 2258 BlitNtoNKey(SDL_BlitInfo * info) |
2262 { | 2259 { |
2263 int width = info->d_width; | 2260 int width = info->d_width; |
2264 int height = info->d_height; | 2261 int height = info->d_height; |
2265 Uint8 *src = info->s_pixels; | 2262 Uint8 *src = info->s_pixels; |
2266 int srcskip = info->s_skip; | 2263 int srcskip = info->s_skip; |
2300 dst += dstskip; | 2297 dst += dstskip; |
2301 } | 2298 } |
2302 } | 2299 } |
2303 | 2300 |
2304 static void | 2301 static void |
2305 BlitNtoNKeyCopyAlpha (SDL_BlitInfo * info) | 2302 BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info) |
2306 { | 2303 { |
2307 int width = info->d_width; | 2304 int width = info->d_width; |
2308 int height = info->d_height; | 2305 int height = info->d_height; |
2309 Uint8 *src = info->s_pixels; | 2306 Uint8 *src = info->s_pixels; |
2310 int srcskip = info->s_skip; | 2307 int srcskip = info->s_skip; |
2476 | 2473 |
2477 /* Mask matches table, or table entry is zero */ | 2474 /* Mask matches table, or table entry is zero */ |
2478 #define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000)) | 2475 #define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000)) |
2479 | 2476 |
2480 SDL_loblit | 2477 SDL_loblit |
2481 SDL_CalculateBlitN (SDL_Surface * surface, int blit_index) | 2478 SDL_CalculateBlitN(SDL_Surface * surface, int blit_index) |
2482 { | 2479 { |
2483 struct private_swaccel *sdata; | 2480 struct private_swaccel *sdata; |
2484 SDL_PixelFormat *srcfmt; | 2481 SDL_PixelFormat *srcfmt; |
2485 SDL_PixelFormat *dstfmt; | 2482 SDL_PixelFormat *dstfmt; |
2486 const struct blit_table *table; | 2483 const struct blit_table *table; |
2492 srcfmt = surface->format; | 2489 srcfmt = surface->format; |
2493 dstfmt = surface->map->dst->format; | 2490 dstfmt = surface->map->dst->format; |
2494 | 2491 |
2495 if (blit_index & 2) { | 2492 if (blit_index & 2) { |
2496 /* alpha or alpha+colorkey */ | 2493 /* alpha or alpha+colorkey */ |
2497 return SDL_CalculateAlphaBlit (surface, blit_index); | 2494 return SDL_CalculateAlphaBlit(surface, blit_index); |
2498 } | 2495 } |
2499 | 2496 |
2500 /* We don't support destinations less than 8-bits */ | 2497 /* We don't support destinations less than 8-bits */ |
2501 if (dstfmt->BitsPerPixel < 8) { | 2498 if (dstfmt->BitsPerPixel < 8) { |
2502 return (NULL); | 2499 return (NULL); |
2512 else if (dstfmt->BytesPerPixel == 1) | 2509 else if (dstfmt->BytesPerPixel == 1) |
2513 return BlitNto1Key; | 2510 return BlitNto1Key; |
2514 else { | 2511 else { |
2515 #if SDL_ALTIVEC_BLITTERS | 2512 #if SDL_ALTIVEC_BLITTERS |
2516 if ((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4) | 2513 if ((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4) |
2517 && SDL_HasAltiVec ()) { | 2514 && SDL_HasAltiVec()) { |
2518 return Blit32to32KeyAltivec; | 2515 return Blit32to32KeyAltivec; |
2519 } else | 2516 } else |
2520 #endif | 2517 #endif |
2521 | 2518 |
2522 if (srcfmt->Amask && dstfmt->Amask) | 2519 if (srcfmt->Amask && dstfmt->Amask) |
2550 int a_need = NO_ALPHA; | 2547 int a_need = NO_ALPHA; |
2551 if (dstfmt->Amask) | 2548 if (dstfmt->Amask) |
2552 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA; | 2549 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA; |
2553 table = normal_blit[srcfmt->BytesPerPixel - 1]; | 2550 table = normal_blit[srcfmt->BytesPerPixel - 1]; |
2554 for (which = 0; table[which].dstbpp; ++which) { | 2551 for (which = 0; table[which].dstbpp; ++which) { |
2555 if (MASKOK (srcfmt->Rmask, table[which].srcR) && | 2552 if (MASKOK(srcfmt->Rmask, table[which].srcR) && |
2556 MASKOK (srcfmt->Gmask, table[which].srcG) && | 2553 MASKOK(srcfmt->Gmask, table[which].srcG) && |
2557 MASKOK (srcfmt->Bmask, table[which].srcB) && | 2554 MASKOK(srcfmt->Bmask, table[which].srcB) && |
2558 MASKOK (dstfmt->Rmask, table[which].dstR) && | 2555 MASKOK(dstfmt->Rmask, table[which].dstR) && |
2559 MASKOK (dstfmt->Gmask, table[which].dstG) && | 2556 MASKOK(dstfmt->Gmask, table[which].dstG) && |
2560 MASKOK (dstfmt->Bmask, table[which].dstB) && | 2557 MASKOK(dstfmt->Bmask, table[which].dstB) && |
2561 dstfmt->BytesPerPixel == table[which].dstbpp && | 2558 dstfmt->BytesPerPixel == table[which].dstbpp && |
2562 (a_need & table[which].alpha) == a_need && | 2559 (a_need & table[which].alpha) == a_need && |
2563 ((table[which].blit_features & GetBlitFeatures ()) == | 2560 ((table[which].blit_features & GetBlitFeatures()) == |
2564 table[which].blit_features)) | 2561 table[which].blit_features)) |
2565 break; | 2562 break; |
2566 } | 2563 } |
2567 sdata->aux_data = table[which].aux_data; | 2564 sdata->aux_data = table[which].aux_data; |
2568 blitfun = table[which].blitfunc; | 2565 blitfun = table[which].blitfunc; |
2581 } | 2578 } |
2582 | 2579 |
2583 #ifdef DEBUG_ASM | 2580 #ifdef DEBUG_ASM |
2584 #if SDL_HERMES_BLITTERS | 2581 #if SDL_HERMES_BLITTERS |
2585 if (blitfun == ConvertMMX) | 2582 if (blitfun == ConvertMMX) |
2586 fprintf (stderr, "Using mmx blit\n"); | 2583 fprintf(stderr, "Using mmx blit\n"); |
2587 else if (blitfun == ConvertX86) | 2584 else if (blitfun == ConvertX86) |
2588 fprintf (stderr, "Using asm blit\n"); | 2585 fprintf(stderr, "Using asm blit\n"); |
2589 else | 2586 else |
2590 #endif | 2587 #endif |
2591 if ((blitfun == BlitNtoN) || (blitfun == BlitNto1)) | 2588 if ((blitfun == BlitNtoN) || (blitfun == BlitNto1)) |
2592 fprintf (stderr, "Using C blit\n"); | 2589 fprintf(stderr, "Using C blit\n"); |
2593 else | 2590 else |
2594 fprintf (stderr, "Using optimized C blit\n"); | 2591 fprintf(stderr, "Using optimized C blit\n"); |
2595 #endif /* DEBUG_ASM */ | 2592 #endif /* DEBUG_ASM */ |
2596 | 2593 |
2597 return (blitfun); | 2594 return (blitfun); |
2598 } | 2595 } |
2599 | 2596 |