This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_blit_N.c
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 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
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
#include "SDL_video.h"
25
#include "SDL_endian.h"
26
#include "SDL_cpuinfo.h"
27
#include "SDL_blit.h"
28
29
30
/* Functions to blit from N-bit surfaces to other surfaces */
31
#if SDL_ALTIVEC_BLITTERS
32
33
34
#if __MWERKS__
#pragma altivec_model on
#endif
35
#ifdef HAVE_ALTIVEC_H
36
#include <altivec.h>
38
#define assert(X)
39
#ifdef __MACOSX__
40
#include <sys/sysctl.h>
41
42
static size_t
GetL3CacheSize (void)
43
44
45
{
const char key[] = "hw.l3cachesize";
u_int64_t result = 0;
46
size_t typeSize = sizeof (result);
49
50
51
int err = sysctlbyname (key, &result, &typeSize, NULL, 0);
if (0 != err)
return 0;
52
53
54
55
return result;
}
#else
56
57
static size_t
GetL3CacheSize (void)
58
59
60
61
{
/* XXX: Just guess G4 */
return 2097152;
}
62
#endif /* __MACOSX__ */
64
#if (defined(__MACOSX__) && (__GNUC__ < 4))
65
#define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
66
(vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p )
67
#define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
68
69
(vector unsigned short) ( a,b,c,d,e,f,g,h )
#else
70
#define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
71
(vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p }
72
#define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
73
74
75
(vector unsigned short) { a,b,c,d,e,f,g,h }
#endif
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F)
#define VSWIZZLE32(a,b,c,d) (vector unsigned char) \
( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \
0x04+a, 0x04+b, 0x04+c, 0x04+d, \
0x08+a, 0x08+b, 0x08+c, 0x08+d, \
0x0C+a, 0x0C+b, 0x0C+c, 0x0C+d )
#define MAKE8888(dstfmt, r, g, b, a) \
( ((r<<dstfmt->Rshift)&dstfmt->Rmask) | \
((g<<dstfmt->Gshift)&dstfmt->Gmask) | \
((b<<dstfmt->Bshift)&dstfmt->Bmask) | \
((a<<dstfmt->Ashift)&dstfmt->Amask) )
/*
* Data Stream Touch...Altivec cache prefetching.
*
* Don't use this on a G5...however, the speed boost is very significant
* on a G4.
*/
#define DST_CHAN_SRC 1
#define DST_CHAN_DEST 2
/* macro to set DST control word value... */
#define DST_CTRL(size, count, stride) \
(((size) << 24) | ((count) << 16) | (stride))
#define VEC_ALIGNER(src) ((UNALIGNED_PTR(src)) \
? vec_lvsl(0, src) \
: vec_add(vec_lvsl(8, src), vec_splat_u8(8)))
/* Calculate the permute vector used for 32->32 swizzling */
107
108
109
static vector unsigned char
calc_swizzle32 (const SDL_PixelFormat * srcfmt,
const SDL_PixelFormat * dstfmt)
110
111
{
/*
112
* We have to assume that the bits that aren't used by other
113
114
115
116
117
118
119
120
121
* colors is alpha, and it's one complete byte, since some formats
* leave alpha with a zero mask, but we should still swizzle the bits.
*/
/* ARGB */
const static struct SDL_PixelFormat default_pixel_format = {
NULL, 0, 0,
0, 0, 0, 0,
16, 8, 0, 24,
0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
124
125
126
127
128
129
if (!srcfmt) {
srcfmt = &default_pixel_format;
}
if (!dstfmt) {
dstfmt = &default_pixel_format;
}
130
131
132
133
134
const vector unsigned char plus =
VECUINT8_LITERAL (0x00, 0x00, 0x00, 0x00,
0x04, 0x04, 0x04, 0x04,
0x08, 0x08, 0x08, 0x08,
0x0C, 0x0C, 0x0C, 0x0C);
135
136
137
vector unsigned char vswiz;
vector unsigned int srcvec;
#define RESHIFT(X) (3 - ((X) >> 3))
138
139
140
Uint32 rmask = RESHIFT (srcfmt->Rshift) << (dstfmt->Rshift);
Uint32 gmask = RESHIFT (srcfmt->Gshift) << (dstfmt->Gshift);
Uint32 bmask = RESHIFT (srcfmt->Bshift) << (dstfmt->Bshift);
141
142
143
Uint32 amask;
/* Use zero for alpha if either surface doesn't have alpha */
if (dstfmt->Amask) {
144
145
146
147
148
149
150
151
152
153
154
155
amask =
((srcfmt->Amask) ? RESHIFT (srcfmt->Ashift) : 0x10) << (dstfmt->
Ashift);
} else {
amask =
0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^
0xFFFFFFFF);
}
#undef RESHIFT
((unsigned int *) (char *) &srcvec)[0] = (rmask | gmask | bmask | amask);
vswiz = vec_add (plus, (vector unsigned char) vec_splat (srcvec, 0));
return (vswiz);
156
157
}
158
159
160
161
static void Blit_RGB888_RGB565 (SDL_BlitInfo * info);
static void
Blit_RGB888_RGB565Altivec (SDL_BlitInfo * info)
{
162
163
164
165
166
167
int height = info->d_height;
Uint8 *src = (Uint8 *) info->s_pixels;
int srcskip = info->s_skip;
Uint8 *dst = (Uint8 *) info->d_pixels;
int dstskip = info->d_skip;
SDL_PixelFormat *srcfmt = info->src;
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
vector unsigned char valpha = vec_splat_u8 (0);
vector unsigned char vpermute = calc_swizzle32 (srcfmt, NULL);
vector unsigned char vgmerge = VECUINT8_LITERAL (0x00, 0x02, 0x00, 0x06,
0x00, 0x0a, 0x00, 0x0e,
0x00, 0x12, 0x00, 0x16,
0x00, 0x1a, 0x00, 0x1e);
vector unsigned short v1 = vec_splat_u16 (1);
vector unsigned short v3 = vec_splat_u16 (3);
vector unsigned short v3f =
VECUINT16_LITERAL (0x003f, 0x003f, 0x003f, 0x003f,
0x003f, 0x003f, 0x003f, 0x003f);
vector unsigned short vfc =
VECUINT16_LITERAL (0x00fc, 0x00fc, 0x00fc, 0x00fc,
0x00fc, 0x00fc, 0x00fc, 0x00fc);
vector unsigned short vf800 = (vector unsigned short) vec_splat_u8 (-7);
vf800 = vec_sl (vf800, vec_splat_u16 (8));
184
185
186
187
188
189
190
191
192
193
194
195
while (height--) {
vector unsigned char valigner;
vector unsigned char voverflow;
vector unsigned char vsrc;
int width = info->d_width;
int extrawidth;
/* do scalar until we can align... */
#define ONE_PIXEL_BLEND(condition, widthvar) \
while (condition) { \
196
Uint32 Pixel; \
197
unsigned sR, sG, sB, sA; \
198
DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \
199
200
201
202
203
204
205
206
207
sR, sG, sB, sA); \
*(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \
((sG << 3) & 0x000007E0) | \
((sB >> 3) & 0x0000001F)); \
dst += 2; \
src += 4; \
widthvar--; \
}
208
ONE_PIXEL_BLEND (((UNALIGNED_PTR (dst)) && (width)), width);
209
210
/* After all that work, here's the vector part! */
211
extrawidth = (width % 8); /* trailing unaligned stores */
212
width -= extrawidth;
213
214
vsrc = vec_ld (0, src);
valigner = VEC_ALIGNER (src);
215
216
217
218
219
220
while (width) {
vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;
vector unsigned int vsrc1, vsrc2;
vector unsigned char vdst;
221
222
223
voverflow = vec_ld (15, src);
vsrc = vec_perm (vsrc, voverflow, valigner);
vsrc1 = (vector unsigned int) vec_perm (vsrc, valpha, vpermute);
224
225
src += 16;
vsrc = voverflow;
226
227
228
voverflow = vec_ld (15, src);
vsrc = vec_perm (vsrc, voverflow, valigner);
vsrc2 = (vector unsigned int) vec_perm (vsrc, valpha, vpermute);
229
/* 1555 */
230
231
232
233
234
235
236
237
238
239
240
vpixel = (vector unsigned short) vec_packpx (vsrc1, vsrc2);
vgpixel =
(vector unsigned short) vec_perm (vsrc1, vsrc2, vgmerge);
vgpixel = vec_and (vgpixel, vfc);
vgpixel = vec_sl (vgpixel, v3);
vrpixel = vec_sl (vpixel, v1);
vrpixel = vec_and (vrpixel, vf800);
vbpixel = vec_and (vpixel, v3f);
vdst =
vec_or ((vector unsigned char) vrpixel,
(vector unsigned char) vgpixel);
241
/* 565 */
242
243
vdst = vec_or (vdst, (vector unsigned char) vbpixel);
vec_st (vdst, 0, dst);
244
245
246
247
248
249
250
width -= 8;
src += 16;
dst += 16;
vsrc = voverflow;
}
251
assert (width == 0);
252
253
/* do scalar until we can align... */
254
ONE_PIXEL_BLEND ((extrawidth), extrawidth);
255
256
#undef ONE_PIXEL_BLEND
257
src += srcskip; /* move to next row, accounting for pitch. */
258
259
260
261
262
263
dst += dstskip;
}
}
264
265
266
static void
Blit_RGB565_32Altivec (SDL_BlitInfo * info)
{
267
268
269
270
271
272
273
274
275
276
277
int height = info->d_height;
Uint8 *src = (Uint8 *) info->s_pixels;
int srcskip = info->s_skip;
Uint8 *dst = (Uint8 *) info->d_pixels;
int dstskip = info->d_skip;
SDL_PixelFormat *srcfmt = info->src;
SDL_PixelFormat *dstfmt = info->dst;
unsigned alpha;
vector unsigned char valpha;
vector unsigned char vpermute;
vector unsigned short vf800;
278
279
280
281
vector unsigned int v8 = vec_splat_u32 (8);
vector unsigned int v16 = vec_add (v8, v8);
vector unsigned short v2 = vec_splat_u16 (2);
vector unsigned short v3 = vec_splat_u16 (3);
283
284
285
286
287
288
289
290
291
292
293
294
295
0x10 - 0x1f is the alpha
0x00 - 0x0e evens are the red
0x01 - 0x0f odds are zero
*/
vector unsigned char vredalpha1 =
VECUINT8_LITERAL (0x10, 0x00, 0x01, 0x01,
0x10, 0x02, 0x01, 0x01,
0x10, 0x04, 0x01, 0x01,
0x10, 0x06, 0x01, 0x01);
vector unsigned char vredalpha2 =
(vector unsigned
char) (vec_add ((vector unsigned int) vredalpha1, vec_sl (v8, v16))
);
297
298
299
300
301
302
303
304
305
306
0x00 - 0x0f is ARxx ARxx ARxx ARxx
0x11 - 0x0f odds are blue
*/
vector unsigned char vblue1 = VECUINT8_LITERAL (0x00, 0x01, 0x02, 0x11,
0x04, 0x05, 0x06, 0x13,
0x08, 0x09, 0x0a, 0x15,
0x0c, 0x0d, 0x0e, 0x17);
vector unsigned char vblue2 =
(vector unsigned char) (vec_add ((vector unsigned int) vblue1, v8)
);
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
0x00 - 0x0f is ARxB ARxB ARxB ARxB
0x10 - 0x0e evens are green
*/
vector unsigned char vgreen1 = VECUINT8_LITERAL (0x00, 0x01, 0x10, 0x03,
0x04, 0x05, 0x12, 0x07,
0x08, 0x09, 0x14, 0x0b,
0x0c, 0x0d, 0x16, 0x0f);
vector unsigned char vgreen2 =
(vector unsigned
char) (vec_add ((vector unsigned int) vgreen1, vec_sl (v8, v8))
);
assert (srcfmt->BytesPerPixel == 2);
assert (dstfmt->BytesPerPixel == 4);
vf800 = (vector unsigned short) vec_splat_u8 (-7);
vf800 = vec_sl (vf800, vec_splat_u16 (8));
326
327
if (dstfmt->Amask && srcfmt->alpha) {
328
329
((unsigned char *) &valpha)[0] = alpha = srcfmt->alpha;
valpha = vec_splat (valpha, 0);
330
331
} else {
alpha = 0;
332
valpha = vec_splat_u8 (0);
333
334
}
335
vpermute = calc_swizzle32 (NULL, dstfmt);
336
337
338
339
340
341
342
343
344
345
346
347
while (height--) {
vector unsigned char valigner;
vector unsigned char voverflow;
vector unsigned char vsrc;
int width = info->d_width;
int extrawidth;
/* do scalar until we can align... */
#define ONE_PIXEL_BLEND(condition, widthvar) \
while (condition) { \
unsigned sR, sG, sB; \
348
349
350
351
unsigned short Pixel = *((unsigned short *)src); \
sR = (Pixel >> 8) & 0xf8; \
sG = (Pixel >> 3) & 0xfc; \
sB = (Pixel << 3) & 0xf8; \
352
353
354
355
356
ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
src += 2; \
dst += 4; \
widthvar--; \
}
357
ONE_PIXEL_BLEND (((UNALIGNED_PTR (dst)) && (width)), width);
358
359
/* After all that work, here's the vector part! */
360
extrawidth = (width % 8); /* trailing unaligned stores */
361
width -= extrawidth;
362
363
vsrc = vec_ld (0, src);
valigner = VEC_ALIGNER (src);
364
365
366
367
368
while (width) {
vector unsigned short vR, vG, vB;
vector unsigned char vdst1, vdst2;
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
voverflow = vec_ld (15, src);
vsrc = vec_perm (vsrc, voverflow, valigner);
vR = vec_and ((vector unsigned short) vsrc, vf800);
vB = vec_sl ((vector unsigned short) vsrc, v3);
vG = vec_sl (vB, v2);
vdst1 =
(vector unsigned char) vec_perm ((vector unsigned char) vR,
valpha, vredalpha1);
vdst1 = vec_perm (vdst1, (vector unsigned char) vB, vblue1);
vdst1 = vec_perm (vdst1, (vector unsigned char) vG, vgreen1);
vdst1 = vec_perm (vdst1, valpha, vpermute);
vec_st (vdst1, 0, dst);
vdst2 =
(vector unsigned char) vec_perm ((vector unsigned char) vR,
valpha, vredalpha2);
vdst2 = vec_perm (vdst2, (vector unsigned char) vB, vblue2);
vdst2 = vec_perm (vdst2, (vector unsigned char) vG, vgreen2);
vdst2 = vec_perm (vdst2, valpha, vpermute);
vec_st (vdst2, 16, dst);
392
393
394
395
396
397
width -= 8;
dst += 32;
src += 16;
vsrc = voverflow;
}
398
assert (width == 0);
399
400
401
/* do scalar until we can align... */
402
ONE_PIXEL_BLEND ((extrawidth), extrawidth);
403
404
#undef ONE_PIXEL_BLEND
405
src += srcskip; /* move to next row, accounting for pitch. */
406
407
408
409
410
dst += dstskip;
}
}
412
413
414
static void
Blit_RGB555_32Altivec (SDL_BlitInfo * info)
{
415
416
417
418
419
420
421
422
423
424
425
int height = info->d_height;
Uint8 *src = (Uint8 *) info->s_pixels;
int srcskip = info->s_skip;
Uint8 *dst = (Uint8 *) info->d_pixels;
int dstskip = info->d_skip;
SDL_PixelFormat *srcfmt = info->src;
SDL_PixelFormat *dstfmt = info->dst;
unsigned alpha;
vector unsigned char valpha;
vector unsigned char vpermute;
vector unsigned short vf800;
426
427
428
429
vector unsigned int v8 = vec_splat_u32 (8);
vector unsigned int v16 = vec_add (v8, v8);
vector unsigned short v1 = vec_splat_u16 (1);
vector unsigned short v3 = vec_splat_u16 (3);
431
432
433
434
435
436
437
438
439
440
441
442
443
0x10 - 0x1f is the alpha
0x00 - 0x0e evens are the red
0x01 - 0x0f odds are zero
*/
vector unsigned char vredalpha1 =
VECUINT8_LITERAL (0x10, 0x00, 0x01, 0x01,
0x10, 0x02, 0x01, 0x01,
0x10, 0x04, 0x01, 0x01,
0x10, 0x06, 0x01, 0x01);
vector unsigned char vredalpha2 =
(vector unsigned
char) (vec_add ((vector unsigned int) vredalpha1, vec_sl (v8, v16))
);
445
446
447
448
449
450
451
452
453
454
0x00 - 0x0f is ARxx ARxx ARxx ARxx
0x11 - 0x0f odds are blue
*/
vector unsigned char vblue1 = VECUINT8_LITERAL (0x00, 0x01, 0x02, 0x11,
0x04, 0x05, 0x06, 0x13,
0x08, 0x09, 0x0a, 0x15,
0x0c, 0x0d, 0x0e, 0x17);
vector unsigned char vblue2 =
(vector unsigned char) (vec_add ((vector unsigned int) vblue1, v8)
);
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
0x00 - 0x0f is ARxB ARxB ARxB ARxB
0x10 - 0x0e evens are green
*/
vector unsigned char vgreen1 = VECUINT8_LITERAL (0x00, 0x01, 0x10, 0x03,
0x04, 0x05, 0x12, 0x07,
0x08, 0x09, 0x14, 0x0b,
0x0c, 0x0d, 0x16, 0x0f);
vector unsigned char vgreen2 =
(vector unsigned
char) (vec_add ((vector unsigned int) vgreen1, vec_sl (v8, v8))
);
assert (srcfmt->BytesPerPixel == 2);
assert (dstfmt->BytesPerPixel == 4);
vf800 = (vector unsigned short) vec_splat_u8 (-7);
vf800 = vec_sl (vf800, vec_splat_u16 (8));
474
475
if (dstfmt->Amask && srcfmt->alpha) {
476
477
((unsigned char *) &valpha)[0] = alpha = srcfmt->alpha;
valpha = vec_splat (valpha, 0);
478
479
} else {
alpha = 0;
480
valpha = vec_splat_u8 (0);
483
vpermute = calc_swizzle32 (NULL, dstfmt);
484
485
486
487
488
489
490
491
492
493
494
495
while (height--) {
vector unsigned char valigner;
vector unsigned char voverflow;
vector unsigned char vsrc;
int width = info->d_width;
int extrawidth;
/* do scalar until we can align... */
#define ONE_PIXEL_BLEND(condition, widthvar) \
while (condition) { \
unsigned sR, sG, sB; \
496
497
498
499
unsigned short Pixel = *((unsigned short *)src); \
sR = (Pixel >> 7) & 0xf8; \
sG = (Pixel >> 2) & 0xf8; \
sB = (Pixel << 3) & 0xf8; \
500
501
502
503
504
ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
src += 2; \
dst += 4; \
widthvar--; \
}
505
ONE_PIXEL_BLEND (((UNALIGNED_PTR (dst)) && (width)), width);
506
507
/* After all that work, here's the vector part! */
508
extrawidth = (width % 8); /* trailing unaligned stores */
509
width -= extrawidth;
510
511
vsrc = vec_ld (0, src);
valigner = VEC_ALIGNER (src);
512
513
514
515
516
while (width) {
vector unsigned short vR, vG, vB;
vector unsigned char vdst1, vdst2;
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
voverflow = vec_ld (15, src);
vsrc = vec_perm (vsrc, voverflow, valigner);
vR = vec_and (vec_sl ((vector unsigned short) vsrc, v1), vf800);
vB = vec_sl ((vector unsigned short) vsrc, v3);
vG = vec_sl (vB, v3);
vdst1 =
(vector unsigned char) vec_perm ((vector unsigned char) vR,
valpha, vredalpha1);
vdst1 = vec_perm (vdst1, (vector unsigned char) vB, vblue1);
vdst1 = vec_perm (vdst1, (vector unsigned char) vG, vgreen1);
vdst1 = vec_perm (vdst1, valpha, vpermute);
vec_st (vdst1, 0, dst);
vdst2 =
(vector unsigned char) vec_perm ((vector unsigned char) vR,
valpha, vredalpha2);
vdst2 = vec_perm (vdst2, (vector unsigned char) vB, vblue2);
vdst2 = vec_perm (vdst2, (vector unsigned char) vG, vgreen2);
vdst2 = vec_perm (vdst2, valpha, vpermute);
vec_st (vdst2, 16, dst);
540
541
542
543
544
545
width -= 8;
dst += 32;
src += 16;
vsrc = voverflow;
}
546
assert (width == 0);
547
548
549
/* do scalar until we can align... */
550
ONE_PIXEL_BLEND ((extrawidth), extrawidth);
551
552
#undef ONE_PIXEL_BLEND
553
src += srcskip; /* move to next row, accounting for pitch. */
554
555
556
557
558
dst += dstskip;
}
}
559
560
561
562
static void BlitNtoNKey (SDL_BlitInfo * info);
static void BlitNtoNKeyCopyAlpha (SDL_BlitInfo * info);
static void
Blit32to32KeyAltivec (SDL_BlitInfo * info)
563
564
565
566
567
568
569
570
571
572
573
{
int height = info->d_height;
Uint32 *srcp = (Uint32 *) info->s_pixels;
int srcskip = info->s_skip;
Uint32 *dstp = (Uint32 *) info->d_pixels;
int dstskip = info->d_skip;
SDL_PixelFormat *srcfmt = info->src;
int srcbpp = srcfmt->BytesPerPixel;
SDL_PixelFormat *dstfmt = info->dst;
int dstbpp = dstfmt->BytesPerPixel;
int copy_alpha = (srcfmt->Amask && dstfmt->Amask);
574
unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
575
Uint32 rgbmask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
576
Uint32 ckey = info->src->colorkey;
577
578
579
580
581
vector unsigned int valpha;
vector unsigned char vpermute;
vector unsigned char vzero;
vector unsigned int vckey;
vector unsigned int vrgbmask;
582
vpermute = calc_swizzle32 (srcfmt, dstfmt);
583
if (info->d_width < 16) {
584
585
if (copy_alpha) {
BlitNtoNKeyCopyAlpha (info);
586
} else {
587
BlitNtoNKey (info);
589
return;
591
vzero = vec_splat_u8 (0);
592
if (alpha) {
593
594
595
596
((unsigned char *) &valpha)[0] = (unsigned char) alpha;
valpha =
(vector unsigned int) vec_splat ((vector unsigned char) valpha,
0);
597
} else {
598
valpha = (vector unsigned int) vzero;
599
600
}
ckey &= rgbmask;
601
602
603
604
((unsigned int *) (char *) &vckey)[0] = ckey;
vckey = vec_splat (vckey, 0);
((unsigned int *) (char *) &vrgbmask)[0] = rgbmask;
vrgbmask = vec_splat (vrgbmask, 0);
605
606
607
608
609
while (height--) {
#define ONE_PIXEL_BLEND(condition, widthvar) \
if (copy_alpha) { \
while (condition) { \
610
Uint32 Pixel; \
611
unsigned sR, sG, sB, sA; \
612
DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \
613
sR, sG, sB, sA); \
614
if ( (Pixel & rgbmask) != ckey ) { \
615
616
617
ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
sR, sG, sB, sA); \
} \
618
619
dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \
srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \
620
621
622
623
widthvar--; \
} \
} else { \
while (condition) { \
624
Uint32 Pixel; \
625
unsigned sR, sG, sB; \
626
627
628
RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \
if ( Pixel != ckey ) { \
RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \
629
630
631
ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
sR, sG, sB, alpha); \
} \
632
633
dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \
srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \
634
635
636
637
widthvar--; \
} \
}
int width = info->d_width;
638
639
ONE_PIXEL_BLEND ((UNALIGNED_PTR (dstp)) && (width), width);
assert (width > 0);
640
641
if (width > 0) {
int extrawidth = (width % 4);
642
643
vector unsigned char valigner = VEC_ALIGNER (srcp);
vector unsigned int vs = vec_ld (0, srcp);
644
width -= extrawidth;
645
assert (width >= 4);
646
647
648
while (width) {
vector unsigned char vsel;
vector unsigned int vd;
649
vector unsigned int voverflow = vec_ld (15, srcp);
650
/* load the source vec */
651
vs = vec_perm (vs, voverflow, valigner);
652
/* vsel is set for items that match the key */
653
654
vsel = (vector unsigned char) vec_and (vs, vrgbmask);
vsel = (vector unsigned char) vec_cmpeq (vs, vckey);
655
/* permute the src vec to the dest format */
656
vs = vec_perm (vs, valpha, vpermute);
657
/* load the destination vec */
658
vd = vec_ld (0, dstp);
659
/* select the source and dest into vs */
660
661
662
663
664
vd = (vector unsigned int) vec_sel ((vector unsigned char) vs,
(vector unsigned char) vd,
vsel);
vec_st (vd, 0, dstp);
665
666
667
668
669
srcp += 4;
width -= 4;
dstp += 4;
vs = voverflow;
}
670
ONE_PIXEL_BLEND ((extrawidth), extrawidth);
671
672
673
674
675
676
677
678
679
#undef ONE_PIXEL_BLEND
srcp += srcskip >> 2;
dstp += dstskip >> 2;
}
}
}
/* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
/* Use this on a G5 */
680
681
static void
ConvertAltivec32to32_noprefetch (SDL_BlitInfo * info)
682
683
684
685
686
687
688
689
{
int height = info->d_height;
Uint32 *src = (Uint32 *) info->s_pixels;
int srcskip = info->s_skip;
Uint32 *dst = (Uint32 *) info->d_pixels;
int dstskip = info->d_skip;
SDL_PixelFormat *srcfmt = info->src;
SDL_PixelFormat *dstfmt = info->dst;
690
691
vector unsigned int vzero = vec_splat_u32 (0);
vector unsigned char vpermute = calc_swizzle32 (srcfmt, dstfmt);
692
693
694
if (dstfmt->Amask && !srcfmt->Amask) {
if (srcfmt->alpha) {
vector unsigned char valpha;
695
696
((unsigned char *) &valpha)[0] = srcfmt->alpha;
vzero = (vector unsigned int) vec_splat (valpha, 0);
697
698
699
}
}
700
701
assert (srcfmt->BytesPerPixel == 4);
assert (dstfmt->BytesPerPixel == 4);
702
703
704
705
706
707
708
709
710
711
712
713
while (height--) {
vector unsigned char valigner;
vector unsigned int vbits;
vector unsigned int voverflow;
Uint32 bits;
Uint8 r, g, b, a;
int width = info->d_width;
int extrawidth;
/* do scalar until we can align... */
714
while ((UNALIGNED_PTR (dst)) && (width)) {
715
bits = *(src++);
716
717
RGBA_FROM_8888 (bits, srcfmt, r, g, b, a);
*(dst++) = MAKE8888 (dstfmt, r, g, b, a);
718
719
720
721
722
723
width--;
}
/* After all that work, here's the vector part! */
extrawidth = (width % 4);
width -= extrawidth;
724
725
valigner = VEC_ALIGNER (src);
vbits = vec_ld (0, src);
727
728
while (width) {
voverflow = vec_ld (15, src);
729
730
src += 4;
width -= 4;
731
732
733
vbits = vec_perm (vbits, voverflow, valigner); /* src is ready. */
vbits = vec_perm (vbits, vzero, vpermute); /* swizzle it. */
vec_st (vbits, 0, dst); /* store it back out. */
734
735
736
737
dst += 4;
vbits = voverflow;
}
738
assert (width == 0);
739
740
741
/* cover pixels at the end of the row that didn't fit in 16 bytes. */
while (extrawidth) {
742
743
744
bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
RGBA_FROM_8888 (bits, srcfmt, r, g, b, a);
*(dst++) = MAKE8888 (dstfmt, r, g, b, a);
745
746
747
extrawidth--;
}
748
src += srcskip >> 2; /* move to next row, accounting for pitch. */
749
750
751
752
753
754
755
dst += dstskip >> 2;
}
}
/* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
/* Use this on a G4 */
756
757
static void
ConvertAltivec32to32_prefetch (SDL_BlitInfo * info)
758
759
760
761
762
763
764
765
766
767
768
{
const int scalar_dst_lead = sizeof (Uint32) * 4;
const int vector_dst_lead = sizeof (Uint32) * 16;
int height = info->d_height;
Uint32 *src = (Uint32 *) info->s_pixels;
int srcskip = info->s_skip;
Uint32 *dst = (Uint32 *) info->d_pixels;
int dstskip = info->d_skip;
SDL_PixelFormat *srcfmt = info->src;
SDL_PixelFormat *dstfmt = info->dst;
769
770
vector unsigned int vzero = vec_splat_u32 (0);
vector unsigned char vpermute = calc_swizzle32 (srcfmt, dstfmt);
771
772
773
if (dstfmt->Amask && !srcfmt->Amask) {
if (srcfmt->alpha) {
vector unsigned char valpha;
774
775
((unsigned char *) &valpha)[0] = srcfmt->alpha;
vzero = (vector unsigned int) vec_splat (valpha, 0);
776
777
778
}
}
779
780
assert (srcfmt->BytesPerPixel == 4);
assert (dstfmt->BytesPerPixel == 4);
781
782
783
784
785
786
787
788
789
790
791
792
while (height--) {
vector unsigned char valigner;
vector unsigned int vbits;
vector unsigned int voverflow;
Uint32 bits;
Uint8 r, g, b, a;
int width = info->d_width;
int extrawidth;
/* do scalar until we can align... */
793
794
795
796
797
while ((UNALIGNED_PTR (dst)) && (width)) {
vec_dstt (src + scalar_dst_lead, DST_CTRL (2, 32, 1024),
DST_CHAN_SRC);
vec_dstst (dst + scalar_dst_lead, DST_CTRL (2, 32, 1024),
DST_CHAN_DEST);
798
bits = *(src++);
799
800
RGBA_FROM_8888 (bits, srcfmt, r, g, b, a);
*(dst++) = MAKE8888 (dstfmt, r, g, b, a);
801
802
803
804
805
806
width--;
}
/* After all that work, here's the vector part! */
extrawidth = (width % 4);
width -= extrawidth;
807
808
valigner = VEC_ALIGNER (src);
vbits = vec_ld (0, src);
809
810
while (width) {
811
812
813
814
815
vec_dstt (src + vector_dst_lead, DST_CTRL (2, 32, 1024),
DST_CHAN_SRC);
vec_dstst (dst + vector_dst_lead, DST_CTRL (2, 32, 1024),
DST_CHAN_DEST);
voverflow = vec_ld (15, src);
816
817
src += 4;
width -= 4;
818
819
820
vbits = vec_perm (vbits, voverflow, valigner); /* src is ready. */
vbits = vec_perm (vbits, vzero, vpermute); /* swizzle it. */
vec_st (vbits, 0, dst); /* store it back out. */
821
822
823
dst += 4;
vbits = voverflow;
}
824
825
assert (width == 0);
826
827
828
/* cover pixels at the end of the row that didn't fit in 16 bytes. */
while (extrawidth) {
829
830
831
bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
RGBA_FROM_8888 (bits, srcfmt, r, g, b, a);
*(dst++) = MAKE8888 (dstfmt, r, g, b, a);
832
833
834
extrawidth--;
}
835
src += srcskip >> 2; /* move to next row, accounting for pitch. */
836
837
838
dst += dstskip >> 2;
}
839
840
vec_dss (DST_CHAN_SRC);
vec_dss (DST_CHAN_DEST);
841
842
}
843
844
static Uint32
GetBlitFeatures (void)
845
846
847
848
{
static Uint32 features = 0xffffffff;
if (features == 0xffffffff) {
/* Provide an override for testing .. */
849
char *override = SDL_getenv ("SDL_ALTIVEC_BLIT_FEATURES");
850
851
if (override) {
features = 0;
852
SDL_sscanf (override, "%u", &features);
853
} else {
854
855
856
857
858
859
860
861
862
features = (0
/* Feature 1 is has-MMX */
| ((SDL_HasMMX ())? 1 : 0)
/* Feature 2 is has-AltiVec */
| ((SDL_HasAltiVec ())? 2 : 0)
/* Feature 4 is dont-use-prefetch */
/* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */
| ((GetL3CacheSize () == 0) ? 4 : 0)
);
863
864
865
866
}
}
return features;
}
868
869
870
#if __MWERKS__
#pragma altivec_model off
#endif
871
872
873
874
875
#else
/* Feature 1 is has-MMX */
#define GetBlitFeatures() ((Uint32)(SDL_HasMMX() ? 1 : 0))
#endif
876
/* This is now endian dependent */
877
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
878
879
#define HI 1
#define LO 0
880
#else /* SDL_BYTEORDER == SDL_BIG_ENDIAN */
881
882
883
884
#define HI 0
#define LO 1
#endif
885
#if SDL_HERMES_BLITTERS
886
887
888
889
890
891
892
/* Heheheh, we coerce Hermes into using SDL blit information */
#define X86_ASSEMBLER
#define HermesConverterInterface SDL_BlitInfo
#define HermesClearInterface void
#define STACKCALL
893
894
#include "../hermes/HeadMMX.h"
#include "../hermes/HeadX86.h"
895
896
897
898
899
#else
/* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
#define RGB888_RGB332(dst, src) { \
900
901
902
dst = (Uint8)((((src)&0x00E00000)>>16)| \
(((src)&0x0000E000)>>11)| \
(((src)&0x000000C0)>>6)); \
903
}
904
905
static void
Blit_RGB888_index8 (SDL_BlitInfo * info)
906
907
{
#ifndef USE_DUFFS_LOOP
909
#endif
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
int width, height;
Uint32 *src;
const Uint8 *map;
Uint8 *dst;
int srcskip, dstskip;
/* Set up some basic variables */
width = info->d_width;
height = info->d_height;
src = (Uint32 *) info->s_pixels;
srcskip = info->s_skip / 4;
dst = info->d_pixels;
dstskip = info->d_skip;
map = info->table;
if (map == NULL) {
while (height--) {
927
#ifdef USE_DUFFS_LOOP
928
/* *INDENT-OFF* */
929
930
931
DUFFS_LOOP(
RGB888_RGB332(*dst++, *src);
, width);
932
/* *INDENT-ON* */
933
#else
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
for (c = width / 4; c; --c) {
/* Pack RGB into 8bit pixel */
++src;
RGB888_RGB332 (*dst++, *src);
++src;
RGB888_RGB332 (*dst++, *src);
++src;
RGB888_RGB332 (*dst++, *src);
++src;
}
switch (width & 3) {
case 3:
RGB888_RGB332 (*dst++, *src);
++src;
case 2:
RGB888_RGB332 (*dst++, *src);
++src;
case 1:
RGB888_RGB332 (*dst++, *src);
++src;
}
955
#endif /* USE_DUFFS_LOOP */
956
957
958
959
960
src += srcskip;
dst += dstskip;
}
} else {
int Pixel;
962
while (height--) {
963
#ifdef USE_DUFFS_LOOP
964
/* *INDENT-OFF* */
965
DUFFS_LOOP(
966
967
RGB888_RGB332(Pixel, *src);
*dst++ = map[Pixel];
968
969
++src;
, width);
970
/* *INDENT-ON* */
971
#else
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
for (c = width / 4; c; --c) {
/* Pack RGB into 8bit pixel */
RGB888_RGB332 (Pixel, *src);
*dst++ = map[Pixel];
++src;
RGB888_RGB332 (Pixel, *src);
*dst++ = map[Pixel];
++src;
RGB888_RGB332 (Pixel, *src);
*dst++ = map[Pixel];
++src;
RGB888_RGB332 (Pixel, *src);
*dst++ = map[Pixel];
++src;
}
switch (width & 3) {
case 3:
RGB888_RGB332 (Pixel, *src);
*dst++ = map[Pixel];
++src;
case 2:
RGB888_RGB332 (Pixel, *src);
*dst++ = map[Pixel];
++src;
case 1:
RGB888_RGB332 (Pixel, *src);
*dst++ = map[Pixel];
++src;
}