?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use svn.ffmpeg.org for the externals which is both more correct and more reliable.
[mplayer/glamo.git] / libswscale / yuv2rgb_altivec.c
blob0223fdd54dee1a075f0edde9656bbbbf3ef90c46
1 /*
2 * AltiVec acceleration for colorspace conversion
3 *
4 * copyright (C) 2004 Marc Hoffman <marc.hoffman@analog.com>
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 /*
24 Convert I420 YV12 to RGB in various formats,
25 it rejects images that are not in 420 formats,
26 it rejects images that don't have widths of multiples of 16,
27 it rejects images that don't have heights of multiples of 2.
28 Reject defers to C simulation code.
29
30 Lots of optimizations to be done here.
31
32 1. Need to fix saturation code. I just couldn't get it to fly with packs
33 and adds, so we currently use max/min to clip.
34
35 2. The inefficient use of chroma loading needs a bit of brushing up.
36
37 3. Analysis of pipeline stalls needs to be done. Use shark to identify
38 pipeline stalls.
39
40
41 MODIFIED to calculate coeffs from currently selected color space.
42 MODIFIED core to be a macro where you specify the output format.
43 ADDED UYVY conversion which is never called due to some thing in swscale.
44 CORRECTED algorithim selection to be strict on input formats.
45 ADDED runtime detection of AltiVec.
46
47 ADDED altivec_yuv2packedX vertical scl + RGB converter
48
49 March 27,2004
50 PERFORMANCE ANALYSIS
51
52 The C version uses 25% of the processor or ~250Mips for D1 video rawvideo
53 used as test.
54 The AltiVec version uses 10% of the processor or ~100Mips for D1 video
55 same sequence.
56
57 720 * 480 * 30 ~10MPS
58
59 so we have roughly 10 clocks per pixel. This is too high, something has
60 to be wrong.
61
62 OPTIMIZED clip codes to utilize vec_max and vec_packs removing the
63 need for vec_min.
64
65 OPTIMIZED DST OUTPUT cache/DMA controls. We are pretty much guaranteed to have
66 the input video frame, it was just decompressed so it probably resides in L1
67 caches. However, we are creating the output video stream. This needs to use the
68 DSTST instruction to optimize for the cache. We couple this with the fact that
69 we are not going to be visiting the input buffer again so we mark it Least
70 Recently Used. This shaves 25% of the processor cycles off.
71
72 Now memcpy is the largest mips consumer in the system, probably due
73 to the inefficient X11 stuff.
74
75 GL libraries seem to be very slow on this machine 1.33Ghz PB running
76 Jaguar, this is not the case for my 1Ghz PB. I thought it might be
77 a versioning issue, however I have libGL.1.2.dylib for both
78 machines. (We need to figure this out now.)
79
80 GL2 libraries work now with patch for RGB32.
81
82 NOTE: quartz vo driver ARGB32_to_RGB24 consumes 30% of the processor.
83
84 Integrated luma prescaling adjustment for saturation/contrast/brightness
85 adjustment.
86 */
87
88 #include <stdio.h>
89 #include <stdlib.h>
90 #include <string.h>
91 #include <inttypes.h>
92 #include <assert.h>
93 #include "config.h"
94 #ifdef HAVE_MALLOC_H
95 #include <malloc.h>
96 #endif
97 #include "rgb2rgb.h"
98 #include "swscale.h"
99 #include "swscale_internal.h"
100
101 #undef PROFILE_THE_BEAST
102 #undef INC_SCALING
103
104 typedef unsigned char ubyte;
105 typedef signed char sbyte;
106
107
108 /* RGB interleaver, 16 planar pels 8-bit samples per channel in
109 homogeneous vector registers x0,x1,x2 are interleaved with the
110 following technique:
111
112 o0 = vec_mergeh (x0,x1);
113 o1 = vec_perm (o0, x2, perm_rgb_0);
114 o2 = vec_perm (o0, x2, perm_rgb_1);
115 o3 = vec_mergel (x0,x1);
116 o4 = vec_perm (o3,o2,perm_rgb_2);
117 o5 = vec_perm (o3,o2,perm_rgb_3);
118
119 perm_rgb_0: o0(RG).h v1(B) --> o1*
120 0 1 2 3 4
121 rgbr|gbrg|brgb|rgbr
122 0010 0100 1001 0010
123 0102 3145 2673 894A
124
125 perm_rgb_1: o0(RG).h v1(B) --> o2
126 0 1 2 3 4
127 gbrg|brgb|bbbb|bbbb
128 0100 1001 1111 1111
129 B5CD 6EF7 89AB CDEF
130
131 perm_rgb_2: o3(RG).l o2(rgbB.l) --> o4*
132 0 1 2 3 4
133 gbrg|brgb|rgbr|gbrg
134 1111 1111 0010 0100
135 89AB CDEF 0182 3945
136
137 perm_rgb_2: o3(RG).l o2(rgbB.l) ---> o5*
138 0 1 2 3 4
139 brgb|rgbr|gbrg|brgb
140 1001 0010 0100 1001
141 a67b 89cA BdCD eEFf
142
143 */
144 static
145 const vector unsigned char
146 perm_rgb_0 = {0x00,0x01,0x10,0x02,0x03,0x11,0x04,0x05,
147 0x12,0x06,0x07,0x13,0x08,0x09,0x14,0x0a},
148 perm_rgb_1 = {0x0b,0x15,0x0c,0x0d,0x16,0x0e,0x0f,0x17,
149 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f},
150 perm_rgb_2 = {0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
151 0x00,0x01,0x18,0x02,0x03,0x19,0x04,0x05},
152 perm_rgb_3 = {0x1a,0x06,0x07,0x1b,0x08,0x09,0x1c,0x0a,
153 0x0b,0x1d,0x0c,0x0d,0x1e,0x0e,0x0f,0x1f};
154
155 #define vec_merge3(x2,x1,x0,y0,y1,y2) \
156 do { \
157 __typeof__(x0) o0,o2,o3; \
158 o0 = vec_mergeh (x0,x1); \
159 y0 = vec_perm (o0, x2, perm_rgb_0); \
160 o2 = vec_perm (o0, x2, perm_rgb_1); \
161 o3 = vec_mergel (x0,x1); \
162 y1 = vec_perm (o3,o2,perm_rgb_2); \
163 y2 = vec_perm (o3,o2,perm_rgb_3); \
164 } while(0)
165
166 #define vec_mstbgr24(x0,x1,x2,ptr) \
167 do { \
168 __typeof__(x0) _0,_1,_2; \
169 vec_merge3 (x0,x1,x2,_0,_1,_2); \
170 vec_st (_0, 0, ptr++); \
171 vec_st (_1, 0, ptr++); \
172 vec_st (_2, 0, ptr++); \
173 } while (0);
174
175 #define vec_mstrgb24(x0,x1,x2,ptr) \
176 do { \
177 __typeof__(x0) _0,_1,_2; \
178 vec_merge3 (x2,x1,x0,_0,_1,_2); \
179 vec_st (_0, 0, ptr++); \
180 vec_st (_1, 0, ptr++); \
181 vec_st (_2, 0, ptr++); \
182 } while (0);
183
184 /* pack the pixels in rgb0 format
185 msb R
186 lsb 0
187 */
188 #define vec_mstrgb32(T,x0,x1,x2,x3,ptr) \
189 do { \
190 T _0,_1,_2,_3; \
191 _0 = vec_mergeh (x0,x1); \
192 _1 = vec_mergeh (x2,x3); \
193 _2 = (T)vec_mergeh ((vector unsigned short)_0,(vector unsigned short)_1); \
194 _3 = (T)vec_mergel ((vector unsigned short)_0,(vector unsigned short)_1); \
195 vec_st (_2, 0*16, (T *)ptr); \
196 vec_st (_3, 1*16, (T *)ptr); \
197 _0 = vec_mergel (x0,x1); \
198 _1 = vec_mergel (x2,x3); \
199 _2 = (T)vec_mergeh ((vector unsigned short)_0,(vector unsigned short)_1); \
200 _3 = (T)vec_mergel ((vector unsigned short)_0,(vector unsigned short)_1); \
201 vec_st (_2, 2*16, (T *)ptr); \
202 vec_st (_3, 3*16, (T *)ptr); \
203 ptr += 4; \
204 } while (0);
205
206 /*
207
208 | 1 0 1.4021 | | Y |
209 | 1 -0.3441 -0.7142 |x| Cb|
210 | 1 1.7718 0 | | Cr|
211
212
213 Y: [-128 127]
214 Cb/Cr : [-128 127]
215
216 typical yuv conversion work on Y: 0-255 this version has been optimized for jpeg decode.
217
218 */
219
220
221
222
223 #define vec_unh(x) \
224 (vector signed short) \
225 vec_perm(x,(__typeof__(x)){0}, \
226 ((vector unsigned char){0x10,0x00,0x10,0x01,0x10,0x02,0x10,0x03,\
227 0x10,0x04,0x10,0x05,0x10,0x06,0x10,0x07}))
228 #define vec_unl(x) \
229 (vector signed short) \
230 vec_perm(x,(__typeof__(x)){0}, \
231 ((vector unsigned char){0x10,0x08,0x10,0x09,0x10,0x0A,0x10,0x0B,\
232 0x10,0x0C,0x10,0x0D,0x10,0x0E,0x10,0x0F}))
233
234 #define vec_clip_s16(x) \
235 vec_max (vec_min (x, ((vector signed short){235,235,235,235,235,235,235,235})), \
236 ((vector signed short){ 16, 16, 16, 16, 16, 16, 16, 16}))
237
238 #define vec_packclp(x,y) \
239 (vector unsigned char)vec_packs \
240 ((vector unsigned short)vec_max (x,((vector signed short) {0})), \
241 (vector unsigned short)vec_max (y,((vector signed short) {0})))
242
243 //#define out_pixels(a,b,c,ptr) vec_mstrgb32(__typeof__(a),((__typeof__ (a)){0}),a,a,a,ptr)
244
245
246 static inline void cvtyuvtoRGB (SwsContext *c,
247 vector signed short Y, vector signed short U, vector signed short V,
248 vector signed short *R, vector signed short *G, vector signed short *B)
249 {
250 vector signed short vx,ux,uvx;
251
252 Y = vec_mradds (Y, c->CY, c->OY);
253 U = vec_sub (U,(vector signed short)
254 vec_splat((vector signed short){128},0));
255 V = vec_sub (V,(vector signed short)
256 vec_splat((vector signed short){128},0));
257
258 // ux = (CBU*(u<<c->CSHIFT)+0x4000)>>15;
259 ux = vec_sl (U, c->CSHIFT);
260 *B = vec_mradds (ux, c->CBU, Y);
261
262 // vx = (CRV*(v<<c->CSHIFT)+0x4000)>>15;
263 vx = vec_sl (V, c->CSHIFT);
264 *R = vec_mradds (vx, c->CRV, Y);
265
266 // uvx = ((CGU*u) + (CGV*v))>>15;
267 uvx = vec_mradds (U, c->CGU, Y);
268 *G = vec_mradds (V, c->CGV, uvx);
269 }
270
271
272 /*
273 ------------------------------------------------------------------------------
274 CS converters
275 ------------------------------------------------------------------------------
276 */
277
278
279 #define DEFCSP420_CVT(name,out_pixels) \
280 static int altivec_##name (SwsContext *c, \
281 unsigned char **in, int *instrides, \
282 int srcSliceY, int srcSliceH, \
283 unsigned char **oplanes, int *outstrides) \
284 { \
285 int w = c->srcW; \
286 int h = srcSliceH; \
287 int i,j; \
288 int instrides_scl[3]; \
289 vector unsigned char y0,y1; \
290 \
291 vector signed char u,v; \
292 \
293 vector signed short Y0,Y1,Y2,Y3; \
294 vector signed short U,V; \
295 vector signed short vx,ux,uvx; \
296 vector signed short vx0,ux0,uvx0; \
297 vector signed short vx1,ux1,uvx1; \
298 vector signed short R0,G0,B0; \
299 vector signed short R1,G1,B1; \
300 vector unsigned char R,G,B; \
301 \
302 vector unsigned char *y1ivP, *y2ivP, *uivP, *vivP; \
303 vector unsigned char align_perm; \
304 \
305 vector signed short \
306 lCY = c->CY, \
307 lOY = c->OY, \
308 lCRV = c->CRV, \
309 lCBU = c->CBU, \
310 lCGU = c->CGU, \
311 lCGV = c->CGV; \
312 \
313 vector unsigned short lCSHIFT = c->CSHIFT; \
314 \
315 ubyte *y1i = in[0]; \
316 ubyte *y2i = in[0]+instrides[0]; \
317 ubyte *ui = in[1]; \
318 ubyte *vi = in[2]; \
319 \
320 vector unsigned char *oute \
321 = (vector unsigned char *) \
322 (oplanes[0]+srcSliceY*outstrides[0]); \
323 vector unsigned char *outo \
324 = (vector unsigned char *) \
325 (oplanes[0]+srcSliceY*outstrides[0]+outstrides[0]); \
326 \
327 \
328 instrides_scl[0] = instrides[0]*2-w; /* the loop moves y{1,2}i by w */ \
329 instrides_scl[1] = instrides[1]-w/2; /* the loop moves ui by w/2 */ \
330 instrides_scl[2] = instrides[2]-w/2; /* the loop moves vi by w/2 */ \
331 \
332 \
333 for (i=0;i<h/2;i++) { \
334 vec_dstst (outo, (0x02000002|(((w*3+32)/32)<<16)), 0); \
335 vec_dstst (oute, (0x02000002|(((w*3+32)/32)<<16)), 1); \
336 \
337 for (j=0;j<w/16;j++) { \
338 \
339 y1ivP = (vector unsigned char *)y1i; \
340 y2ivP = (vector unsigned char *)y2i; \
341 uivP = (vector unsigned char *)ui; \
342 vivP = (vector unsigned char *)vi; \
343 \
344 align_perm = vec_lvsl (0, y1i); \
345 y0 = (vector unsigned char) \
346 vec_perm (y1ivP[0], y1ivP[1], align_perm); \
347 \
348 align_perm = vec_lvsl (0, y2i); \
349 y1 = (vector unsigned char) \
350 vec_perm (y2ivP[0], y2ivP[1], align_perm); \
351 \
352 align_perm = vec_lvsl (0, ui); \
353 u = (vector signed char) \
354 vec_perm (uivP[0], uivP[1], align_perm); \
355 \
356 align_perm = vec_lvsl (0, vi); \
357 v = (vector signed char) \
358 vec_perm (vivP[0], vivP[1], align_perm); \
359 \
360 u = (vector signed char) \
361 vec_sub (u,(vector signed char) \
362 vec_splat((vector signed char){128},0)); \
363 v = (vector signed char) \
364 vec_sub (v,(vector signed char) \
365 vec_splat((vector signed char){128},0)); \
366 \
367 U = vec_unpackh (u); \
368 V = vec_unpackh (v); \
369 \
370 \
371 Y0 = vec_unh (y0); \
372 Y1 = vec_unl (y0); \
373 Y2 = vec_unh (y1); \
374 Y3 = vec_unl (y1); \
375 \
376 Y0 = vec_mradds (Y0, lCY, lOY); \
377 Y1 = vec_mradds (Y1, lCY, lOY); \
378 Y2 = vec_mradds (Y2, lCY, lOY); \
379 Y3 = vec_mradds (Y3, lCY, lOY); \
380 \
381 /* ux = (CBU*(u<<CSHIFT)+0x4000)>>15 */ \
382 ux = vec_sl (U, lCSHIFT); \
383 ux = vec_mradds (ux, lCBU, (vector signed short){0}); \
384 ux0 = vec_mergeh (ux,ux); \
385 ux1 = vec_mergel (ux,ux); \
386 \
387 /* vx = (CRV*(v<<CSHIFT)+0x4000)>>15; */ \
388 vx = vec_sl (V, lCSHIFT); \
389 vx = vec_mradds (vx, lCRV, (vector signed short){0}); \
390 vx0 = vec_mergeh (vx,vx); \
391 vx1 = vec_mergel (vx,vx); \
392 \
393 /* uvx = ((CGU*u) + (CGV*v))>>15 */ \
394 uvx = vec_mradds (U, lCGU, (vector signed short){0}); \
395 uvx = vec_mradds (V, lCGV, uvx); \
396 uvx0 = vec_mergeh (uvx,uvx); \
397 uvx1 = vec_mergel (uvx,uvx); \
398 \
399 R0 = vec_add (Y0,vx0); \
400 G0 = vec_add (Y0,uvx0); \
401 B0 = vec_add (Y0,ux0); \
402 R1 = vec_add (Y1,vx1); \
403 G1 = vec_add (Y1,uvx1); \
404 B1 = vec_add (Y1,ux1); \
405 \
406 R = vec_packclp (R0,R1); \
407 G = vec_packclp (G0,G1); \
408 B = vec_packclp (B0,B1); \
409 \
410 out_pixels(R,G,B,oute); \
411 \
412 R0 = vec_add (Y2,vx0); \
413 G0 = vec_add (Y2,uvx0); \
414 B0 = vec_add (Y2,ux0); \
415 R1 = vec_add (Y3,vx1); \
416 G1 = vec_add (Y3,uvx1); \
417 B1 = vec_add (Y3,ux1); \
418 R = vec_packclp (R0,R1); \
419 G = vec_packclp (G0,G1); \
420 B = vec_packclp (B0,B1); \
421 \
422 \
423 out_pixels(R,G,B,outo); \
424 \
425 y1i += 16; \
426 y2i += 16; \
427 ui += 8; \
428 vi += 8; \
429 \
430 } \
431 \
432 outo += (outstrides[0])>>4; \
433 oute += (outstrides[0])>>4; \
434 \
435 ui += instrides_scl[1]; \
436 vi += instrides_scl[2]; \
437 y1i += instrides_scl[0]; \
438 y2i += instrides_scl[0]; \
439 } \
440 return srcSliceH; \
441 }
442
443
444 #define out_abgr(a,b,c,ptr) vec_mstrgb32(__typeof__(a),((__typeof__ (a)){0}),c,b,a,ptr)
445 #define out_bgra(a,b,c,ptr) vec_mstrgb32(__typeof__(a),c,b,a,((__typeof__ (a)){0}),ptr)
446 #define out_rgba(a,b,c,ptr) vec_mstrgb32(__typeof__(a),a,b,c,((__typeof__ (a)){0}),ptr)
447 #define out_argb(a,b,c,ptr) vec_mstrgb32(__typeof__(a),((__typeof__ (a)){0}),a,b,c,ptr)
448 #define out_rgb24(a,b,c,ptr) vec_mstrgb24(a,b,c,ptr)
449 #define out_bgr24(a,b,c,ptr) vec_mstbgr24(a,b,c,ptr)
450
451 DEFCSP420_CVT (yuv2_abgr, out_abgr)
452 #if 1
453 DEFCSP420_CVT (yuv2_bgra, out_bgra)
454 #else
455 static int altivec_yuv2_bgra32 (SwsContext *c,
456 unsigned char **in, int *instrides,
457 int srcSliceY, int srcSliceH,
458 unsigned char **oplanes, int *outstrides)
459 {
460 int w = c->srcW;
461 int h = srcSliceH;
462 int i,j;
463 int instrides_scl[3];
464 vector unsigned char y0,y1;
465
466 vector signed char u,v;
467
468 vector signed short Y0,Y1,Y2,Y3;
469 vector signed short U,V;
470 vector signed short vx,ux,uvx;
471 vector signed short vx0,ux0,uvx0;
472 vector signed short vx1,ux1,uvx1;
473 vector signed short R0,G0,B0;
474 vector signed short R1,G1,B1;
475 vector unsigned char R,G,B;
476
477 vector unsigned char *uivP, *vivP;
478 vector unsigned char align_perm;
479
480 vector signed short
481 lCY = c->CY,
482 lOY = c->OY,
483 lCRV = c->CRV,
484 lCBU = c->CBU,
485 lCGU = c->CGU,
486 lCGV = c->CGV;
487
488 vector unsigned short lCSHIFT = c->CSHIFT;
489
490 ubyte *y1i = in[0];
491 ubyte *y2i = in[0]+w;
492 ubyte *ui = in[1];
493 ubyte *vi = in[2];
494
495 vector unsigned char *oute
496 = (vector unsigned char *)
497 (oplanes[0]+srcSliceY*outstrides[0]);
498 vector unsigned char *outo
499 = (vector unsigned char *)
500 (oplanes[0]+srcSliceY*outstrides[0]+outstrides[0]);
501
502
503 instrides_scl[0] = instrides[0];
504 instrides_scl[1] = instrides[1]-w/2; /* the loop moves ui by w/2 */
505 instrides_scl[2] = instrides[2]-w/2; /* the loop moves vi by w/2 */
506
507
508 for (i=0;i<h/2;i++) {
509 vec_dstst (outo, (0x02000002|(((w*3+32)/32)<<16)), 0);
510 vec_dstst (oute, (0x02000002|(((w*3+32)/32)<<16)), 1);
511
512 for (j=0;j<w/16;j++) {
513
514 y0 = vec_ldl (0,y1i);
515 y1 = vec_ldl (0,y2i);
516 uivP = (vector unsigned char *)ui;
517 vivP = (vector unsigned char *)vi;
518
519 align_perm = vec_lvsl (0, ui);
520 u = (vector signed char)vec_perm (uivP[0], uivP[1], align_perm);
521
522 align_perm = vec_lvsl (0, vi);
523 v = (vector signed char)vec_perm (vivP[0], vivP[1], align_perm);
524 u = (vector signed char)
525 vec_sub (u,(vector signed char)
526 vec_splat((vector signed char){128},0));
527
528 v = (vector signed char)
529 vec_sub (v, (vector signed char)
530 vec_splat((vector signed char){128},0));
531
532 U = vec_unpackh (u);
533 V = vec_unpackh (v);
534
535
536 Y0 = vec_unh (y0);
537 Y1 = vec_unl (y0);
538 Y2 = vec_unh (y1);
539 Y3 = vec_unl (y1);
540
541 Y0 = vec_mradds (Y0, lCY, lOY);
542 Y1 = vec_mradds (Y1, lCY, lOY);
543 Y2 = vec_mradds (Y2, lCY, lOY);
544 Y3 = vec_mradds (Y3, lCY, lOY);
545
546 /* ux = (CBU*(u<<CSHIFT)+0x4000)>>15 */
547 ux = vec_sl (U, lCSHIFT);
548 ux = vec_mradds (ux, lCBU, (vector signed short){0});
549 ux0 = vec_mergeh (ux,ux);
550 ux1 = vec_mergel (ux,ux);
551
552 /* vx = (CRV*(v<<CSHIFT)+0x4000)>>15; */
553 vx = vec_sl (V, lCSHIFT);
554 vx = vec_mradds (vx, lCRV, (vector signed short){0});
555 vx0 = vec_mergeh (vx,vx);
556 vx1 = vec_mergel (vx,vx);
557 /* uvx = ((CGU*u) + (CGV*v))>>15 */
558 uvx = vec_mradds (U, lCGU, (vector signed short){0});
559 uvx = vec_mradds (V, lCGV, uvx);
560 uvx0 = vec_mergeh (uvx,uvx);
561 uvx1 = vec_mergel (uvx,uvx);
562 R0 = vec_add (Y0,vx0);
563 G0 = vec_add (Y0,uvx0);
564 B0 = vec_add (Y0,ux0);
565 R1 = vec_add (Y1,vx1);
566 G1 = vec_add (Y1,uvx1);
567 B1 = vec_add (Y1,ux1);
568 R = vec_packclp (R0,R1);
569 G = vec_packclp (G0,G1);
570 B = vec_packclp (B0,B1);
571
572 out_argb(R,G,B,oute);
573 R0 = vec_add (Y2,vx0);
574 G0 = vec_add (Y2,uvx0);
575 B0 = vec_add (Y2,ux0);
576 R1 = vec_add (Y3,vx1);
577 G1 = vec_add (Y3,uvx1);
578 B1 = vec_add (Y3,ux1);
579 R = vec_packclp (R0,R1);
580 G = vec_packclp (G0,G1);
581 B = vec_packclp (B0,B1);
582
583 out_argb(R,G,B,outo);
584 y1i += 16;
585 y2i += 16;
586 ui += 8;
587 vi += 8;
588
589 }
590
591 outo += (outstrides[0])>>4;
592 oute += (outstrides[0])>>4;
593
594 ui += instrides_scl[1];
595 vi += instrides_scl[2];
596 y1i += instrides_scl[0];
597 y2i += instrides_scl[0];
598 }
599 return srcSliceH;
600 }
601
602 #endif
603
604
605 DEFCSP420_CVT (yuv2_rgba, out_rgba)
606 DEFCSP420_CVT (yuv2_argb, out_argb)
607 DEFCSP420_CVT (yuv2_rgb24, out_rgb24)
608 DEFCSP420_CVT (yuv2_bgr24, out_bgr24)
609
610
611 // uyvy|uyvy|uyvy|uyvy
612 // 0123 4567 89ab cdef
613 static
614 const vector unsigned char
615 demux_u = {0x10,0x00,0x10,0x00,
616 0x10,0x04,0x10,0x04,
617 0x10,0x08,0x10,0x08,
618 0x10,0x0c,0x10,0x0c},
619 demux_v = {0x10,0x02,0x10,0x02,
620 0x10,0x06,0x10,0x06,
621 0x10,0x0A,0x10,0x0A,
622 0x10,0x0E,0x10,0x0E},
623 demux_y = {0x10,0x01,0x10,0x03,
624 0x10,0x05,0x10,0x07,
625 0x10,0x09,0x10,0x0B,
626 0x10,0x0D,0x10,0x0F};
627
628 /*
629 this is so I can play live CCIR raw video
630 */
631 static int altivec_uyvy_rgb32 (SwsContext *c,
632 unsigned char **in, int *instrides,
633 int srcSliceY, int srcSliceH,
634 unsigned char **oplanes, int *outstrides)
635 {
636 int w = c->srcW;
637 int h = srcSliceH;
638 int i,j;
639 vector unsigned char uyvy;
640 vector signed short Y,U,V;
641 vector signed short R0,G0,B0,R1,G1,B1;
642 vector unsigned char R,G,B;
643 vector unsigned char *out;
644 ubyte *img;
645
646 img = in[0];
647 out = (vector unsigned char *)(oplanes[0]+srcSliceY*outstrides[0]);
648
649 for (i=0;i<h;i++) {
650 for (j=0;j<w/16;j++) {
651 uyvy = vec_ld (0, img);
652 U = (vector signed short)
653 vec_perm (uyvy, (vector unsigned char){0}, demux_u);
654
655 V = (vector signed short)
656 vec_perm (uyvy, (vector unsigned char){0}, demux_v);
657
658 Y = (vector signed short)
659 vec_perm (uyvy, (vector unsigned char){0}, demux_y);
660
661 cvtyuvtoRGB (c, Y,U,V,&R0,&G0,&B0);
662
663 uyvy = vec_ld (16, img);
664 U = (vector signed short)
665 vec_perm (uyvy, (vector unsigned char){0}, demux_u);
666
667 V = (vector signed short)
668 vec_perm (uyvy, (vector unsigned char){0}, demux_v);
669
670 Y = (vector signed short)
671 vec_perm (uyvy, (vector unsigned char){0}, demux_y);
672
673 cvtyuvtoRGB (c, Y,U,V,&R1,&G1,&B1);
674
675 R = vec_packclp (R0,R1);
676 G = vec_packclp (G0,G1);
677 B = vec_packclp (B0,B1);
678
679 // vec_mstbgr24 (R,G,B, out);
680 out_rgba (R,G,B,out);
681
682 img += 32;
683 }
684 }
685 return srcSliceH;
686 }
687
688
689
690 /* Ok currently the acceleration routine only supports
691 inputs of widths a multiple of 16
692 and heights a multiple 2
693
694 So we just fall back to the C codes for this.
695 */
696 SwsFunc yuv2rgb_init_altivec (SwsContext *c)
697 {
698 if (!(c->flags & SWS_CPU_CAPS_ALTIVEC))
699 return NULL;
700
701 /*
702 and this seems not to matter too much I tried a bunch of
703 videos with abnormal widths and MPlayer crashes elsewhere.
704 mplayer -vo x11 -rawvideo on:w=350:h=240 raw-350x240.eyuv
705 boom with X11 bad match.
706
707 */
708 if ((c->srcW & 0xf) != 0) return NULL;
709
710 switch (c->srcFormat) {
711 case PIX_FMT_YUV410P:
712 case PIX_FMT_YUV420P:
713 /*case IMGFMT_CLPL: ??? */
714 case PIX_FMT_GRAY8:
715 case PIX_FMT_NV12:
716 case PIX_FMT_NV21:
717 if ((c->srcH & 0x1) != 0)
718 return NULL;
719
720 switch(c->dstFormat){
721 case PIX_FMT_RGB24:
722 av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space RGB24\n");
723 return altivec_yuv2_rgb24;
724 case PIX_FMT_BGR24:
725 av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space BGR24\n");
726 return altivec_yuv2_bgr24;
727 case PIX_FMT_ARGB:
728 av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space ARGB\n");
729 return altivec_yuv2_argb;
730 case PIX_FMT_ABGR:
731 av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space ABGR\n");
732 return altivec_yuv2_abgr;
733 case PIX_FMT_RGBA:
734 av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space RGBA\n");
735 return altivec_yuv2_rgba;
736 case PIX_FMT_BGRA:
737 av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space BGRA\n");
738 return altivec_yuv2_bgra;
739 default: return NULL;
740 }
741 break;
742
743 case PIX_FMT_UYVY422:
744 switch(c->dstFormat){
745 case PIX_FMT_BGR32:
746 av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space UYVY -> RGB32\n");
747 return altivec_uyvy_rgb32;
748 default: return NULL;
749 }
750 break;
751
752 }
753 return NULL;
754 }
755
756 void yuv2rgb_altivec_init_tables (SwsContext *c, const int inv_table[4],int brightness,int contrast, int saturation)
757 {
758 union {
759 signed short tmp[8] __attribute__ ((aligned(16)));
760 vector signed short vec;
761 } buf;
762
763 buf.tmp[0] = ((0xffffLL) * contrast>>8)>>9; //cy
764 buf.tmp[1] = -256*brightness; //oy
765 buf.tmp[2] = (inv_table[0]>>3) *(contrast>>16)*(saturation>>16); //crv
766 buf.tmp[3] = (inv_table[1]>>3) *(contrast>>16)*(saturation>>16); //cbu
767 buf.tmp[4] = -((inv_table[2]>>1)*(contrast>>16)*(saturation>>16)); //cgu
768 buf.tmp[5] = -((inv_table[3]>>1)*(contrast>>16)*(saturation>>16)); //cgv
769
770
771 c->CSHIFT = (vector unsigned short)vec_splat_u16(2);
772 c->CY = vec_splat ((vector signed short)buf.vec, 0);
773 c->OY = vec_splat ((vector signed short)buf.vec, 1);
774 c->CRV = vec_splat ((vector signed short)buf.vec, 2);
775 c->CBU = vec_splat ((vector signed short)buf.vec, 3);
776 c->CGU = vec_splat ((vector signed short)buf.vec, 4);
777 c->CGV = vec_splat ((vector signed short)buf.vec, 5);
778 #if 0
779 {
780 int i;
781 char *v[6]={"cy","oy","crv","cbu","cgu","cgv"};
782 for (i=0; i<6; i++)
783 printf("%s %d ", v[i],buf.tmp[i] );
784 printf("\n");
785 }
786 #endif
787 return;
788 }
789
790
791 void
792 altivec_yuv2packedX (SwsContext *c,
793 int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
794 int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
795 uint8_t *dest, int dstW, int dstY)
796 {
797 int i,j;
798 vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V;
799 vector signed short R0,G0,B0,R1,G1,B1;
800
801 vector unsigned char R,G,B;
802 vector unsigned char *out,*nout;
803
804 vector signed short RND = vec_splat_s16(1<<3);
805 vector unsigned short SCL = vec_splat_u16(4);
806 unsigned long scratch[16] __attribute__ ((aligned (16)));
807
808 vector signed short *YCoeffs, *CCoeffs;
809
810 YCoeffs = c->vYCoeffsBank+dstY*lumFilterSize;
811 CCoeffs = c->vCCoeffsBank+dstY*chrFilterSize;
812
813 out = (vector unsigned char *)dest;
814
815 for (i=0; i<dstW; i+=16){
816 Y0 = RND;
817 Y1 = RND;
818 /* extract 16 coeffs from lumSrc */
819 for (j=0; j<lumFilterSize; j++) {
820 X0 = vec_ld (0, &lumSrc[j][i]);
821 X1 = vec_ld (16, &lumSrc[j][i]);
822 Y0 = vec_mradds (X0, YCoeffs[j], Y0);
823 Y1 = vec_mradds (X1, YCoeffs[j], Y1);
824 }
825
826 U = RND;
827 V = RND;
828 /* extract 8 coeffs from U,V */
829 for (j=0; j<chrFilterSize; j++) {
830 X = vec_ld (0, &chrSrc[j][i/2]);
831 U = vec_mradds (X, CCoeffs[j], U);
832 X = vec_ld (0, &chrSrc[j][i/2+2048]);
833 V = vec_mradds (X, CCoeffs[j], V);
834 }
835
836 /* scale and clip signals */
837 Y0 = vec_sra (Y0, SCL);
838 Y1 = vec_sra (Y1, SCL);
839 U = vec_sra (U, SCL);
840 V = vec_sra (V, SCL);
841
842 Y0 = vec_clip_s16 (Y0);
843 Y1 = vec_clip_s16 (Y1);
844 U = vec_clip_s16 (U);
845 V = vec_clip_s16 (V);
846
847 /* now we have
848 Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15
849 U= u0 u1 u2 u3 u4 u5 u6 u7 V= v0 v1 v2 v3 v4 v5 v6 v7
850
851 Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15
852 U0= u0 u0 u1 u1 u2 u2 u3 u3 U1= u4 u4 u5 u5 u6 u6 u7 u7
853 V0= v0 v0 v1 v1 v2 v2 v3 v3 V1= v4 v4 v5 v5 v6 v6 v7 v7
854 */
855
856 U0 = vec_mergeh (U,U);
857 V0 = vec_mergeh (V,V);
858
859 U1 = vec_mergel (U,U);
860 V1 = vec_mergel (V,V);
861
862 cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
863 cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
864
865 R = vec_packclp (R0,R1);
866 G = vec_packclp (G0,G1);
867 B = vec_packclp (B0,B1);
868
869 switch(c->dstFormat) {
870 case PIX_FMT_ABGR: out_abgr (R,G,B,out); break;
871 case PIX_FMT_BGRA: out_bgra (R,G,B,out); break;
872 case PIX_FMT_RGBA: out_rgba (R,G,B,out); break;
873 case PIX_FMT_ARGB: out_argb (R,G,B,out); break;
874 case PIX_FMT_RGB24: out_rgb24 (R,G,B,out); break;
875 case PIX_FMT_BGR24: out_bgr24 (R,G,B,out); break;
876 default:
877 {
878 /* If this is reached, the caller should have called yuv2packedXinC
879 instead. */
880 static int printed_error_message;
881 if (!printed_error_message) {
882 av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
883 sws_format_name(c->dstFormat));
884 printed_error_message=1;
885 }
886 return;
887 }
888 }
889 }
890
891 if (i < dstW) {
892 i -= 16;
893
894 Y0 = RND;
895 Y1 = RND;
896 /* extract 16 coeffs from lumSrc */
897 for (j=0; j<lumFilterSize; j++) {
898 X0 = vec_ld (0, &lumSrc[j][i]);
899 X1 = vec_ld (16, &lumSrc[j][i]);
900 Y0 = vec_mradds (X0, YCoeffs[j], Y0);
901 Y1 = vec_mradds (X1, YCoeffs[j], Y1);
902 }
903
904 U = RND;
905 V = RND;
906 /* extract 8 coeffs from U,V */
907 for (j=0; j<chrFilterSize; j++) {
908 X = vec_ld (0, &chrSrc[j][i/2]);
909 U = vec_mradds (X, CCoeffs[j], U);
910 X = vec_ld (0, &chrSrc[j][i/2+2048]);
911 V = vec_mradds (X, CCoeffs[j], V);
912 }
913
914 /* scale and clip signals */
915 Y0 = vec_sra (Y0, SCL);
916 Y1 = vec_sra (Y1, SCL);
917 U = vec_sra (U, SCL);
918 V = vec_sra (V, SCL);
919
920 Y0 = vec_clip_s16 (Y0);
921 Y1 = vec_clip_s16 (Y1);
922 U = vec_clip_s16 (U);
923 V = vec_clip_s16 (V);
924
925 /* now we have
926 Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15
927 U = u0 u1 u2 u3 u4 u5 u6 u7 V = v0 v1 v2 v3 v4 v5 v6 v7
928
929 Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15
930 U0= u0 u0 u1 u1 u2 u2 u3 u3 U1= u4 u4 u5 u5 u6 u6 u7 u7
931 V0= v0 v0 v1 v1 v2 v2 v3 v3 V1= v4 v4 v5 v5 v6 v6 v7 v7
932 */
933
934 U0 = vec_mergeh (U,U);
935 V0 = vec_mergeh (V,V);
936
937 U1 = vec_mergel (U,U);
938 V1 = vec_mergel (V,V);
939
940 cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
941 cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
942
943 R = vec_packclp (R0,R1);
944 G = vec_packclp (G0,G1);
945 B = vec_packclp (B0,B1);
946
947 nout = (vector unsigned char *)scratch;
948 switch(c->dstFormat) {
949 case PIX_FMT_ABGR: out_abgr (R,G,B,nout); break;
950 case PIX_FMT_BGRA: out_bgra (R,G,B,nout); break;
951 case PIX_FMT_RGBA: out_rgba (R,G,B,nout); break;
952 case PIX_FMT_ARGB: out_argb (R,G,B,nout); break;
953 case PIX_FMT_RGB24: out_rgb24 (R,G,B,nout); break;
954 case PIX_FMT_BGR24: out_bgr24 (R,G,B,nout); break;
955 default:
956 /* Unreachable, I think. */
957 av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
958 sws_format_name(c->dstFormat));
959 return;
960 }
961
962 memcpy (&((uint32_t*)dest)[i], scratch, (dstW-i)/4);
963 }
964
965 }
mplayer with SMedia Glamo drivers