* resync without endless loop
[ffmpeg.git] / postproc / rgb2rgb.c
1 /*
2  *
3  *  rgb2rgb.c, Software RGB to RGB convertor
4  *  pluralize by Software PAL8 to RGB convertor
5  *               Software YUV to YUV convertor
6  *               Software YUV to RGB convertor
7  *  Written by Nick Kurshev.
8  *  palette & yuv & runtime cpu stuff by Michael (michaelni@gmx.at) (under GPL)
9  */
10 #include <inttypes.h>
11 #include "../config.h"
12 #include "rgb2rgb.h"
13 #include "../cpudetect.h"
14 #include "../mangle.h"
15
16 #ifdef ARCH_X86
17 #define CAN_COMPILE_X86_ASM
18 #endif
19
20 #define FAST_BGR2YV12 // use 7 bit coeffs instead of 15bit
21
22 #ifdef CAN_COMPILE_X86_ASM
23 static const uint64_t mmx_null  __attribute__((aligned(8))) = 0x0000000000000000ULL;
24 static const uint64_t mmx_one   __attribute__((aligned(8))) = 0xFFFFFFFFFFFFFFFFULL;
25 static const uint64_t mask32b  __attribute__((aligned(8))) = 0x000000FF000000FFULL;
26 static const uint64_t mask32g  __attribute__((aligned(8))) = 0x0000FF000000FF00ULL;
27 static const uint64_t mask32r  __attribute__((aligned(8))) = 0x00FF000000FF0000ULL;
28 static const uint64_t mask32   __attribute__((aligned(8))) = 0x00FFFFFF00FFFFFFULL;
29 static const uint64_t mask24b  __attribute__((aligned(8))) = 0x00FF0000FF0000FFULL;
30 static const uint64_t mask24g  __attribute__((aligned(8))) = 0xFF0000FF0000FF00ULL;
31 static const uint64_t mask24r  __attribute__((aligned(8))) = 0x0000FF0000FF0000ULL;
32 static const uint64_t mask24l  __attribute__((aligned(8))) = 0x0000000000FFFFFFULL;
33 static const uint64_t mask24h  __attribute__((aligned(8))) = 0x0000FFFFFF000000ULL;
34 static const uint64_t mask24hh  __attribute__((aligned(8))) = 0xffff000000000000ULL;
35 static const uint64_t mask24hhh  __attribute__((aligned(8))) = 0xffffffff00000000ULL;
36 static const uint64_t mask24hhhh  __attribute__((aligned(8))) = 0xffffffffffff0000ULL;
37 static const uint64_t mask15b  __attribute__((aligned(8))) = 0x001F001F001F001FULL; /* 00000000 00011111  xxB */
38 static const uint64_t mask15rg __attribute__((aligned(8))) = 0x7FE07FE07FE07FE0ULL; /* 01111111 11100000  RGx */
39 static const uint64_t mask15s  __attribute__((aligned(8))) = 0xFFE0FFE0FFE0FFE0ULL;
40 static const uint64_t mask15g  __attribute__((aligned(8))) = 0x03E003E003E003E0ULL;
41 static const uint64_t mask15r  __attribute__((aligned(8))) = 0x7C007C007C007C00ULL;
42 #define mask16b mask15b
43 static const uint64_t mask16g  __attribute__((aligned(8))) = 0x07E007E007E007E0ULL;
44 static const uint64_t mask16r  __attribute__((aligned(8))) = 0xF800F800F800F800ULL;
45 static const uint64_t red_16mask  __attribute__((aligned(8))) = 0x0000f8000000f800ULL;
46 static const uint64_t green_16mask __attribute__((aligned(8)))= 0x000007e0000007e0ULL;
47 static const uint64_t blue_16mask __attribute__((aligned(8))) = 0x0000001f0000001fULL;
48 static const uint64_t red_15mask  __attribute__((aligned(8))) = 0x00007c000000f800ULL;
49 static const uint64_t green_15mask __attribute__((aligned(8)))= 0x000003e0000007e0ULL;
50 static const uint64_t blue_15mask __attribute__((aligned(8))) = 0x0000001f0000001fULL;
51
52 #ifdef FAST_BGR2YV12
53 static const uint64_t bgr2YCoeff  __attribute__((aligned(8))) = 0x000000210041000DULL;
54 static const uint64_t bgr2UCoeff  __attribute__((aligned(8))) = 0x0000FFEEFFDC0038ULL;
55 static const uint64_t bgr2VCoeff  __attribute__((aligned(8))) = 0x00000038FFD2FFF8ULL;
56 #else
57 static const uint64_t bgr2YCoeff  __attribute__((aligned(8))) = 0x000020E540830C8BULL;
58 static const uint64_t bgr2UCoeff  __attribute__((aligned(8))) = 0x0000ED0FDAC23831ULL;
59 static const uint64_t bgr2VCoeff  __attribute__((aligned(8))) = 0x00003831D0E6F6EAULL;
60 #endif
61 static const uint64_t bgr2YOffset __attribute__((aligned(8))) = 0x1010101010101010ULL;
62 static const uint64_t bgr2UVOffset __attribute__((aligned(8)))= 0x8080808080808080ULL;
63 static const uint64_t w1111       __attribute__((aligned(8))) = 0x0001000100010001ULL;
64
65 #if 0
66 static volatile uint64_t __attribute__((aligned(8))) b5Dither;
67 static volatile uint64_t __attribute__((aligned(8))) g5Dither;
68 static volatile uint64_t __attribute__((aligned(8))) g6Dither;
69 static volatile uint64_t __attribute__((aligned(8))) r5Dither;
70
71 static uint64_t __attribute__((aligned(8))) dither4[2]={
72         0x0103010301030103LL,
73         0x0200020002000200LL,};
74
75 static uint64_t __attribute__((aligned(8))) dither8[2]={
76         0x0602060206020602LL,
77         0x0004000400040004LL,};
78 #endif
79 #endif
80
81 #define RGB2YUV_SHIFT 8
82 #define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5))
83 #define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5))
84 #define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
85 #define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5))
86 #define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5))
87 #define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5))
88 #define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5))
89 #define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
90 #define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5))
91
92 //Note: we have C, MMX, MMX2, 3DNOW version therse no 3DNOW+MMX2 one
93 //Plain C versions
94 #undef HAVE_MMX
95 #undef HAVE_MMX2
96 #undef HAVE_3DNOW
97 #undef ARCH_X86
98 #undef HAVE_SSE2
99 #define RENAME(a) a ## _C
100 #include "rgb2rgb_template.c"
101
102 #ifdef CAN_COMPILE_X86_ASM
103
104 //MMX versions
105 #undef RENAME
106 #define HAVE_MMX
107 #undef HAVE_MMX2
108 #undef HAVE_3DNOW
109 #undef HAVE_SSE2
110 #define ARCH_X86
111 #define RENAME(a) a ## _MMX
112 #include "rgb2rgb_template.c"
113
114 //MMX2 versions
115 #undef RENAME
116 #define HAVE_MMX
117 #define HAVE_MMX2
118 #undef HAVE_3DNOW
119 #undef HAVE_SSE2
120 #define ARCH_X86
121 #define RENAME(a) a ## _MMX2
122 #include "rgb2rgb_template.c"
123
124 //3DNOW versions
125 #undef RENAME
126 #define HAVE_MMX
127 #undef HAVE_MMX2
128 #define HAVE_3DNOW
129 #undef HAVE_SSE2
130 #define ARCH_X86
131 #define RENAME(a) a ## _3DNow
132 #include "rgb2rgb_template.c"
133
134 #endif //CAN_COMPILE_X86_ASM
135
136 void rgb24to32(const uint8_t *src,uint8_t *dst,unsigned src_size)
137 {
138 #ifdef CAN_COMPILE_X86_ASM
139         // ordered per speed fasterst first
140         if(gCpuCaps.hasMMX2)
141                 rgb24to32_MMX2(src, dst, src_size);
142         else if(gCpuCaps.has3DNow)
143                 rgb24to32_3DNow(src, dst, src_size);
144         else if(gCpuCaps.hasMMX)
145                 rgb24to32_MMX(src, dst, src_size);
146         else
147 #endif
148                 rgb24to32_C(src, dst, src_size);
149 }
150
151 void rgb15to24(const uint8_t *src,uint8_t *dst,unsigned src_size)
152 {
153 #ifdef CAN_COMPILE_X86_ASM
154         // ordered per speed fasterst first
155         if(gCpuCaps.hasMMX2)
156                 rgb15to24_MMX2(src, dst, src_size);
157         else if(gCpuCaps.has3DNow)
158                 rgb15to24_3DNow(src, dst, src_size);
159         else if(gCpuCaps.hasMMX)
160                 rgb15to24_MMX(src, dst, src_size);
161         else
162 #endif
163                 rgb15to24_C(src, dst, src_size);
164 }
165
166 void rgb16to24(const uint8_t *src,uint8_t *dst,unsigned src_size)
167 {
168 #ifdef CAN_COMPILE_X86_ASM
169         // ordered per speed fasterst first
170         if(gCpuCaps.hasMMX2)
171                 rgb16to24_MMX2(src, dst, src_size);
172         else if(gCpuCaps.has3DNow)
173                 rgb16to24_3DNow(src, dst, src_size);
174         else if(gCpuCaps.hasMMX)
175                 rgb16to24_MMX(src, dst, src_size);
176         else
177 #endif
178                 rgb16to24_C(src, dst, src_size);
179 }
180
181 void rgb15to32(const uint8_t *src,uint8_t *dst,unsigned src_size)
182 {
183 #ifdef CAN_COMPILE_X86_ASM
184         // ordered per speed fasterst first
185         if(gCpuCaps.hasMMX2)
186                 rgb15to32_MMX2(src, dst, src_size);
187         else if(gCpuCaps.has3DNow)
188                 rgb15to32_3DNow(src, dst, src_size);
189         else if(gCpuCaps.hasMMX)
190                 rgb15to32_MMX(src, dst, src_size);
191         else
192 #endif
193                 rgb15to32_C(src, dst, src_size);
194 }
195
196 void rgb16to32(const uint8_t *src,uint8_t *dst,unsigned src_size)
197 {
198 #ifdef CAN_COMPILE_X86_ASM
199         // ordered per speed fasterst first
200         if(gCpuCaps.hasMMX2)
201                 rgb16to32_MMX2(src, dst, src_size);
202         else if(gCpuCaps.has3DNow)
203                 rgb16to32_3DNow(src, dst, src_size);
204         else if(gCpuCaps.hasMMX)
205                 rgb16to32_MMX(src, dst, src_size);
206         else
207 #endif
208                 rgb16to32_C(src, dst, src_size);
209 }
210
211 void rgb32to24(const uint8_t *src,uint8_t *dst,unsigned src_size)
212 {
213 #ifdef CAN_COMPILE_X86_ASM
214         // ordered per speed fasterst first
215         if(gCpuCaps.hasMMX2)
216                 rgb32to24_MMX2(src, dst, src_size);
217         else if(gCpuCaps.has3DNow)
218                 rgb32to24_3DNow(src, dst, src_size);
219         else if(gCpuCaps.hasMMX)
220                 rgb32to24_MMX(src, dst, src_size);
221         else
222 #endif
223                 rgb32to24_C(src, dst, src_size);
224 }
225
226 /*
227  Original by Strepto/Astral
228  ported to gcc & bugfixed : A'rpi
229  MMX2, 3DNOW optimization by Nick Kurshev
230  32bit c version, and and&add trick by Michael Niedermayer
231 */
232 void rgb15to16(const uint8_t *src,uint8_t *dst,unsigned src_size)
233 {
234 #ifdef CAN_COMPILE_X86_ASM
235         // ordered per speed fasterst first
236         if(gCpuCaps.hasMMX2)
237                 rgb15to16_MMX2(src, dst, src_size);
238         else if(gCpuCaps.has3DNow)
239                 rgb15to16_3DNow(src, dst, src_size);
240         else if(gCpuCaps.hasMMX)
241                 rgb15to16_MMX(src, dst, src_size);
242         else
243 #endif
244                 rgb15to16_C(src, dst, src_size);
245 }
246
247 void rgb16to15(const uint8_t *src,uint8_t *dst,unsigned src_size)
248 {
249 #ifdef CAN_COMPILE_X86_ASM
250         // ordered per speed fasterst first
251         if(gCpuCaps.hasMMX2)
252                 rgb16to15_MMX2(src, dst, src_size);
253         else if(gCpuCaps.has3DNow)
254                 rgb16to15_3DNow(src, dst, src_size);
255         else if(gCpuCaps.hasMMX)
256                 rgb16to15_MMX(src, dst, src_size);
257         else
258 #endif
259                 rgb16to15_C(src, dst, src_size);
260 }
261 /**
262  * Pallete is assumed to contain bgr32
263  */
264 void palette8torgb32(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
265 {
266         unsigned i;
267         for(i=0; i<num_pixels; i++)
268                 ((unsigned *)dst)[i] = ((unsigned *)palette)[ src[i] ];
269 }
270
271 /**
272  * Pallete is assumed to contain bgr32
273  */
274 void palette8torgb24(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
275 {
276         unsigned i;
277 /*
278         writes 1 byte o much and might cause alignment issues on some architectures?
279         for(i=0; i<num_pixels; i++)
280                 ((unsigned *)(&dst[i*3])) = ((unsigned *)palette)[ src[i] ];
281 */
282         for(i=0; i<num_pixels; i++)
283         {
284                 //FIXME slow?
285                 dst[0]= palette[ src[i]*4+0 ];
286                 dst[1]= palette[ src[i]*4+1 ];
287                 dst[2]= palette[ src[i]*4+2 ];
288                 dst+= 3;
289         }
290 }
291
292 void bgr24torgb24(const uint8_t *src, uint8_t *dst, unsigned src_size)
293 {
294 #ifdef CAN_COMPILE_X86_ASM
295         // ordered per speed fasterst first
296         if(gCpuCaps.hasMMX2)
297                 bgr24torgb24_MMX2(src, dst, src_size);
298         else if(gCpuCaps.has3DNow)
299                 bgr24torgb24_3DNow(src, dst, src_size);
300         else if(gCpuCaps.hasMMX)
301                 bgr24torgb24_MMX(src, dst, src_size);
302         else
303                 bgr24torgb24_C(src, dst, src_size);
304 #else
305                 bgr24torgb24_C(src, dst, src_size);
306 #endif
307 }
308
309 void rgb32to16(const uint8_t *src, uint8_t *dst, unsigned src_size)
310 {
311 #ifdef CAN_COMPILE_X86_ASM
312         // ordered per speed fasterst first
313         if(gCpuCaps.hasMMX2)
314                 rgb32to16_MMX2(src, dst, src_size);
315         else if(gCpuCaps.has3DNow)
316                 rgb32to16_3DNow(src, dst, src_size);
317         else if(gCpuCaps.hasMMX)
318                 rgb32to16_MMX(src, dst, src_size);
319         else
320 #endif
321                 rgb32to16_C(src, dst, src_size);
322 }
323
324 void rgb32to15(const uint8_t *src, uint8_t *dst, unsigned src_size)
325 {
326 #ifdef CAN_COMPILE_X86_ASM
327         // ordered per speed fasterst first
328         if(gCpuCaps.hasMMX2)
329                 rgb32to15_MMX2(src, dst, src_size);
330         else if(gCpuCaps.has3DNow)
331                 rgb32to15_3DNow(src, dst, src_size);
332         else if(gCpuCaps.hasMMX)
333                 rgb32to15_MMX(src, dst, src_size);
334         else
335 #endif
336                 rgb32to15_C(src, dst, src_size);
337 }
338
339 void rgb24to16(const uint8_t *src, uint8_t *dst, unsigned src_size)
340 {
341 #ifdef CAN_COMPILE_X86_ASM
342         // ordered per speed fasterst first
343         if(gCpuCaps.hasMMX2)
344                 rgb24to16_MMX2(src, dst, src_size);
345         else if(gCpuCaps.has3DNow)
346                 rgb24to16_3DNow(src, dst, src_size);
347         else if(gCpuCaps.hasMMX)
348                 rgb24to16_MMX(src, dst, src_size);
349         else
350 #endif
351                 rgb24to16_C(src, dst, src_size);
352 }
353
354 void rgb24to15(const uint8_t *src, uint8_t *dst, unsigned src_size)
355 {
356 #ifdef CAN_COMPILE_X86_ASM
357         // ordered per speed fasterst first
358         if(gCpuCaps.hasMMX2)
359                 rgb24to15_MMX2(src, dst, src_size);
360         else if(gCpuCaps.has3DNow)
361                 rgb24to15_3DNow(src, dst, src_size);
362         else if(gCpuCaps.hasMMX)
363                 rgb24to15_MMX(src, dst, src_size);
364         else
365 #endif
366                 rgb24to15_C(src, dst, src_size);
367 }
368
369 /**
370  * Palette is assumed to contain bgr16, see rgb32to16 to convert the palette
371  */
372 void palette8torgb16(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
373 {
374         unsigned i;
375         for(i=0; i<num_pixels; i++)
376                 ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ];
377 }
378
379 /**
380  * Pallete is assumed to contain bgr15, see rgb32to15 to convert the palette
381  */
382 void palette8torgb15(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
383 {
384         unsigned i;
385         for(i=0; i<num_pixels; i++)
386                 ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ];
387 }
388
389 void rgb32tobgr32(const uint8_t *src, uint8_t *dst, unsigned int src_size)
390 {
391 #ifdef CAN_COMPILE_X86_ASM
392         // ordered per speed fasterst first
393         if(gCpuCaps.hasMMX2)
394                 rgb32tobgr32_MMX2(src, dst, src_size);
395         else if(gCpuCaps.has3DNow)
396                 rgb32tobgr32_3DNow(src, dst, src_size);
397         else if(gCpuCaps.hasMMX)
398                 rgb32tobgr32_MMX(src, dst, src_size);
399         else
400 #endif
401                 rgb32tobgr32_C(src, dst, src_size);
402 }
403
404 void rgb32tobgr24(const uint8_t *src, uint8_t *dst, unsigned int src_size)
405 {
406         unsigned i;
407         unsigned num_pixels = src_size >> 2;
408         for(i=0; i<num_pixels; i++)
409         {
410                 dst[3*i + 0] = src[4*i + 2];
411                 dst[3*i + 1] = src[4*i + 1];
412                 dst[3*i + 2] = src[4*i + 0];
413         }
414 }
415
416 void rgb32tobgr16(const uint8_t *src, uint8_t *dst, unsigned int src_size)
417 {
418 #ifdef CAN_COMPILE_X86_ASM
419         // ordered per speed fasterst first
420         if(gCpuCaps.hasMMX2)
421                 rgb32tobgr16_MMX2(src, dst, src_size);
422         else if(gCpuCaps.has3DNow)
423                 rgb32tobgr16_3DNow(src, dst, src_size);
424         else if(gCpuCaps.hasMMX)
425                 rgb32tobgr16_MMX(src, dst, src_size);
426         else
427 #endif
428                 rgb32tobgr16_C(src, dst, src_size);
429 }
430
431 void rgb32tobgr15(const uint8_t *src, uint8_t *dst, unsigned int src_size)
432 {
433 #ifdef CAN_COMPILE_X86_ASM
434         // ordered per speed fasterst first
435         if(gCpuCaps.hasMMX2)
436                 rgb32tobgr15_MMX2(src, dst, src_size);
437         else if(gCpuCaps.has3DNow)
438                 rgb32tobgr15_3DNow(src, dst, src_size);
439         else if(gCpuCaps.hasMMX)
440                 rgb32tobgr15_MMX(src, dst, src_size);
441         else
442 #endif
443                 rgb32tobgr15_C(src, dst, src_size);
444 }
445
446 void rgb24tobgr32(const uint8_t *src, uint8_t *dst, unsigned int src_size)
447 {
448         unsigned i;
449         for(i=0; 3*i<src_size; i++)
450         {
451                 dst[4*i + 0] = src[3*i + 2];
452                 dst[4*i + 1] = src[3*i + 1];
453                 dst[4*i + 2] = src[3*i + 0];
454                 dst[4*i + 3] = 0;
455         }
456 }
457
458 void rgb24tobgr24(const uint8_t *src, uint8_t *dst, unsigned int src_size)
459 {
460 #ifdef CAN_COMPILE_X86_ASM
461         // ordered per speed fasterst first
462         if(gCpuCaps.hasMMX2)
463                 rgb24tobgr24_MMX2(src, dst, src_size);
464         else if(gCpuCaps.has3DNow)
465                 rgb24tobgr24_3DNow(src, dst, src_size);
466         else if(gCpuCaps.hasMMX)
467                 rgb24tobgr24_MMX(src, dst, src_size);
468         else
469 #endif
470                 rgb24tobgr24_C(src, dst, src_size);
471 }
472
473 void rgb24tobgr16(const uint8_t *src, uint8_t *dst, unsigned int src_size)
474 {
475 #ifdef CAN_COMPILE_X86_ASM
476         // ordered per speed fasterst first
477         if(gCpuCaps.hasMMX2)
478                 rgb24tobgr16_MMX2(src, dst, src_size);
479         else if(gCpuCaps.has3DNow)
480                 rgb24tobgr16_3DNow(src, dst, src_size);
481         else if(gCpuCaps.hasMMX)
482                 rgb24tobgr16_MMX(src, dst, src_size);
483         else
484 #endif
485                 rgb24tobgr16_C(src, dst, src_size);
486 }
487
488 void rgb24tobgr15(const uint8_t *src, uint8_t *dst, unsigned int src_size)
489 {
490 #ifdef CAN_COMPILE_X86_ASM
491         // ordered per speed fasterst first
492         if(gCpuCaps.hasMMX2)
493                 rgb24tobgr15_MMX2(src, dst, src_size);
494         else if(gCpuCaps.has3DNow)
495                 rgb24tobgr15_3DNow(src, dst, src_size);
496         else if(gCpuCaps.hasMMX)
497                 rgb24tobgr15_MMX(src, dst, src_size);
498         else
499 #endif
500                 rgb24tobgr15_C(src, dst, src_size);
501 }
502
503 void rgb16tobgr32(const uint8_t *src, uint8_t *dst, unsigned int src_size)
504 {
505         const uint16_t *end;
506         uint8_t *d = (uint8_t *)dst;
507         const uint16_t *s = (uint16_t *)src;
508         end = s + src_size/2;
509         while(s < end)
510         {
511                 register uint16_t bgr;
512                 bgr = *s++;
513                 *d++ = (bgr&0xF800)>>8;
514                 *d++ = (bgr&0x7E0)>>3;
515                 *d++ = (bgr&0x1F)<<3;
516                 *d++ = 0;
517         }
518 }
519
520 void rgb16tobgr24(const uint8_t *src, uint8_t *dst, unsigned int src_size)
521 {
522         const uint16_t *end;
523         uint8_t *d = (uint8_t *)dst;
524         const uint16_t *s = (const uint16_t *)src;
525         end = s + src_size/2;
526         while(s < end)
527         {
528                 register uint16_t bgr;
529                 bgr = *s++;
530                 *d++ = (bgr&0xF800)>>8;
531                 *d++ = (bgr&0x7E0)>>3;
532                 *d++ = (bgr&0x1F)<<3;
533         }
534 }
535
536 void rgb16tobgr16(const uint8_t *src, uint8_t *dst, unsigned int src_size)
537 {
538         unsigned i;
539         unsigned num_pixels = src_size >> 1;
540         
541         for(i=0; i<num_pixels; i++)
542         {
543             unsigned b,g,r;
544             register uint16_t rgb;
545             rgb = src[2*i];
546             r = rgb&0x1F;
547             g = (rgb&0x7E0)>>5;
548             b = (rgb&0xF800)>>11;
549             dst[2*i] = (b&0x1F) | ((g&0x3F)<<5) | ((r&0x1F)<<11);
550         }
551 }
552
553 void rgb16tobgr15(const uint8_t *src, uint8_t *dst, unsigned int src_size)
554 {
555         unsigned i;
556         unsigned num_pixels = src_size >> 1;
557         
558         for(i=0; i<num_pixels; i++)
559         {
560             unsigned b,g,r;
561             register uint16_t rgb;
562             rgb = src[2*i];
563             r = rgb&0x1F;
564             g = (rgb&0x7E0)>>5;
565             b = (rgb&0xF800)>>11;
566             dst[2*i] = (b&0x1F) | ((g&0x1F)<<5) | ((r&0x1F)<<10);
567         }
568 }
569
570 void rgb15tobgr32(const uint8_t *src, uint8_t *dst, unsigned int src_size)
571 {
572         const uint16_t *end;
573         uint8_t *d = (uint8_t *)dst;
574         const uint16_t *s = (const uint16_t *)src;
575         end = s + src_size/2;
576         while(s < end)
577         {
578                 register uint16_t bgr;
579                 bgr = *s++;
580                 *d++ = (bgr&0x7C00)>>7;
581                 *d++ = (bgr&0x3E0)>>2;
582                 *d++ = (bgr&0x1F)<<3;
583                 *d++ = 0;
584         }
585 }
586
587 void rgb15tobgr24(const uint8_t *src, uint8_t *dst, unsigned int src_size)
588 {
589         const uint16_t *end;
590         uint8_t *d = (uint8_t *)dst;
591         const uint16_t *s = (uint16_t *)src;
592         end = s + src_size/2;
593         while(s < end)
594         {
595                 register uint16_t bgr;
596                 bgr = *s++;
597                 *d++ = (bgr&0x7C00)>>7;
598                 *d++ = (bgr&0x3E0)>>2;
599                 *d++ = (bgr&0x1F)<<3;
600         }
601 }
602
603 void rgb15tobgr16(const uint8_t *src, uint8_t *dst, unsigned int src_size)
604 {
605         unsigned i;
606         unsigned num_pixels = src_size >> 1;
607         
608         for(i=0; i<num_pixels; i++)
609         {
610             unsigned b,g,r;
611             register uint16_t rgb;
612             rgb = src[2*i];
613             r = rgb&0x1F;
614             g = (rgb&0x3E0)>>5;
615             b = (rgb&0x7C00)>>10;
616             dst[2*i] = (b&0x1F) | ((g&0x3F)<<5) | ((r&0x1F)<<11);
617         }
618 }
619
620 void rgb15tobgr15(const uint8_t *src, uint8_t *dst, unsigned int src_size)
621 {
622         unsigned i;
623         unsigned num_pixels = src_size >> 1;
624         
625         for(i=0; i<num_pixels; i++)
626         {
627             unsigned b,g,r;
628             register uint16_t rgb;
629             rgb = src[2*i];
630             r = rgb&0x1F;
631             g = (rgb&0x3E0)>>5;
632             b = (rgb&0x7C00)>>10;
633             dst[2*i] = (b&0x1F) | ((g&0x1F)<<5) | ((r&0x1F)<<10);
634         }
635 }
636
637 void rgb8tobgr8(const uint8_t *src, uint8_t *dst, unsigned int src_size)
638 {
639         unsigned i;
640         unsigned num_pixels = src_size;
641         for(i=0; i<num_pixels; i++)
642         {
643             unsigned b,g,r;
644             register uint8_t rgb;
645             rgb = src[i];
646             r = (rgb&0x07);
647             g = (rgb&0x38)>>3;
648             b = (rgb&0xC0)>>6;
649             dst[i] = ((b<<1)&0x07) | ((g&0x07)<<3) | ((r&0x03)<<6);
650         }
651 }
652
653 /**
654  *
655  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
656  * problem for anyone then tell me, and ill fix it)
657  */
658 void yv12toyuy2(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
659         unsigned int width, unsigned int height,
660         unsigned int lumStride, unsigned int chromStride, unsigned int dstStride)
661 {
662 #ifdef CAN_COMPILE_X86_ASM
663         // ordered per speed fasterst first
664         if(gCpuCaps.hasMMX2)
665                 yv12toyuy2_MMX2(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
666         else if(gCpuCaps.has3DNow)
667                 yv12toyuy2_3DNow(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
668         else if(gCpuCaps.hasMMX)
669                 yv12toyuy2_MMX(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
670         else
671 #endif
672                 yv12toyuy2_C(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
673 }
674
675 /**
676  *
677  * width should be a multiple of 16
678  */
679 void yuv422ptoyuy2(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
680         unsigned int width, unsigned int height,
681         unsigned int lumStride, unsigned int chromStride, unsigned int dstStride)
682 {
683 #ifdef CAN_COMPILE_X86_ASM
684         // ordered per speed fasterst first
685         if(gCpuCaps.hasMMX2)
686                 yuv422ptoyuy2_MMX2(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
687         else if(gCpuCaps.has3DNow)
688                 yuv422ptoyuy2_3DNow(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
689         else if(gCpuCaps.hasMMX)
690                 yuv422ptoyuy2_MMX(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
691         else
692 #endif
693                 yuv422ptoyuy2_C(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
694 }
695
696 /**
697  *
698  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
699  * problem for anyone then tell me, and ill fix it)
700  */
701 void yuy2toyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
702         unsigned int width, unsigned int height,
703         unsigned int lumStride, unsigned int chromStride, unsigned int srcStride)
704 {
705 #ifdef CAN_COMPILE_X86_ASM
706         // ordered per speed fasterst first
707         if(gCpuCaps.hasMMX2)
708                 yuy2toyv12_MMX2(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
709         else if(gCpuCaps.has3DNow)
710                 yuy2toyv12_3DNow(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
711         else if(gCpuCaps.hasMMX)
712                 yuy2toyv12_MMX(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
713         else
714 #endif
715                 yuy2toyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
716 }
717
718 /**
719  *
720  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
721  * problem for anyone then tell me, and ill fix it)
722  * chrominance data is only taken from every secound line others are ignored FIXME write HQ version
723  */
724 void uyvytoyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
725         unsigned int width, unsigned int height,
726         unsigned int lumStride, unsigned int chromStride, unsigned int srcStride)
727 {
728 #ifdef CAN_COMPILE_X86_ASM
729         // ordered per speed fasterst first
730         if(gCpuCaps.hasMMX2)
731                 uyvytoyv12_MMX2(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
732         else if(gCpuCaps.has3DNow)
733                 uyvytoyv12_3DNow(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
734         else if(gCpuCaps.hasMMX)
735                 uyvytoyv12_MMX(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
736         else
737                 uyvytoyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
738 #else
739                 uyvytoyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
740 #endif
741 }
742
743 void yvu9toyv12(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc,
744         uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
745         unsigned int width, unsigned int height,
746         unsigned int lumStride, unsigned int chromStride)
747 {
748 #ifdef CAN_COMPILE_X86_ASM
749         // ordered per speed fasterst first
750         if(gCpuCaps.hasMMX2)
751                 yvu9toyv12_MMX2(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride);
752         else if(gCpuCaps.has3DNow)
753                 yvu9toyv12_3DNow(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride);
754         else if(gCpuCaps.hasMMX)
755                 yvu9toyv12_MMX(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride);
756         else
757                 yvu9toyv12_C(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride);
758 #else
759                 yvu9toyv12_C(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride);
760 #endif
761 }
762
763 void planar2x(const uint8_t *src, uint8_t *dst, int width, int height, int srcStride, int dstStride)
764 {
765 #ifdef CAN_COMPILE_X86_ASM
766         // ordered per speed fasterst first
767         if(gCpuCaps.hasMMX2)
768                 planar2x_MMX2(src, dst, width, height, srcStride, dstStride);
769         else if(gCpuCaps.has3DNow)
770                 planar2x_3DNow(src, dst, width, height, srcStride, dstStride);
771         else
772 #endif
773                 planar2x_C(src, dst, width, height, srcStride, dstStride);
774 }
775
776 /**
777  *
778  * height should be a multiple of 2 and width should be a multiple of 2 (if this is a
779  * problem for anyone then tell me, and ill fix it)
780  * chrominance data is only taken from every secound line others are ignored FIXME write HQ version
781  */
782 void rgb24toyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
783         unsigned int width, unsigned int height,
784         unsigned int lumStride, unsigned int chromStride, unsigned int srcStride)
785 {
786 #ifdef CAN_COMPILE_X86_ASM
787         // ordered per speed fasterst first
788         if(gCpuCaps.hasMMX2)
789                 rgb24toyv12_MMX2(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
790         else if(gCpuCaps.has3DNow)
791                 rgb24toyv12_3DNow(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
792         else if(gCpuCaps.hasMMX)
793                 rgb24toyv12_MMX(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
794         else
795 #endif
796                 rgb24toyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
797 }
798
799 void interleaveBytes(uint8_t *src1, uint8_t *src2, uint8_t *dst,
800                      unsigned width, unsigned height, unsigned src1Stride,
801                      unsigned src2Stride, unsigned dstStride)
802 {
803 #ifdef CAN_COMPILE_X86_ASM
804         // ordered per speed fasterst first
805         if(gCpuCaps.hasMMX2)
806                 interleaveBytes_MMX2(src1, src2, dst, width, height, src1Stride, src2Stride, dstStride);
807         else if(gCpuCaps.has3DNow)
808                 interleaveBytes_3DNow(src1, src2, dst, width, height, src1Stride, src2Stride, dstStride);
809         else if(gCpuCaps.hasMMX)
810                 interleaveBytes_MMX(src1, src2, dst, width, height, src1Stride, src2Stride, dstStride);
811         else
812 #endif
813                 interleaveBytes_C(src1, src2, dst, width, height, src1Stride, src2Stride, dstStride);
814 }
815
816 void vu9_to_vu12(const uint8_t *src1, const uint8_t *src2,
817                 uint8_t *dst1, uint8_t *dst2,
818                 unsigned width, unsigned height,
819                 unsigned srcStride1, unsigned srcStride2,
820                 unsigned dstStride1, unsigned dstStride2)
821 {
822 #ifdef CAN_COMPILE_X86_ASM
823         if(gCpuCaps.hasMMX2)
824                 vu9_to_vu12_MMX2(src1, src2, dst1, dst2, width, height, srcStride1, srcStride2, dstStride1, dstStride2);
825         else if(gCpuCaps.has3DNow)
826                 vu9_to_vu12_3DNow(src1, src2, dst1, dst2, width, height, srcStride1, srcStride2, dstStride1, dstStride2);
827         else if(gCpuCaps.hasMMX)
828                 vu9_to_vu12_MMX(src1, src2, dst1, dst2, width, height, srcStride1, srcStride2, dstStride1, dstStride2);
829         else
830 #endif
831                 vu9_to_vu12_C(src1, src2, dst1, dst2, width, height, srcStride1, srcStride2, dstStride1, dstStride2);
832 }
833
834 void yvu9_to_yuy2(const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
835                 uint8_t *dst,
836                 unsigned width, unsigned height,
837                 unsigned srcStride1, unsigned srcStride2,
838                 unsigned srcStride3, unsigned dstStride)
839 {
840 #ifdef CAN_COMPILE_X86_ASM
841         if(gCpuCaps.hasMMX2)
842                 yvu9_to_yuy2_MMX2(src1, src2, src3, dst, width, height, srcStride1, srcStride2, srcStride3, dstStride);
843         else if(gCpuCaps.has3DNow)
844                 yvu9_to_yuy2_3DNow(src1, src2, src3, dst, width, height, srcStride1, srcStride2, srcStride3, dstStride);
845         else if(gCpuCaps.hasMMX)
846                 yvu9_to_yuy2_MMX(src1, src2, src3, dst, width, height, srcStride1, srcStride2, srcStride3, dstStride);
847         else
848 #endif
849                 yvu9_to_yuy2_C(src1, src2, src3, dst, width, height, srcStride1, srcStride2, srcStride3, dstStride);
850 }