Mercurial > mplayer.hg
annotate postproc/rgb2rgb.c @ 6540:5b3cace64e9d
100l (non mmx versions didnt compile)
some cleanup
author | michael |
---|---|
date | Mon, 24 Jun 2002 00:18:29 +0000 |
parents | e7635c03910f |
children | f98313dcd428 |
rev | line source |
---|---|
2694 | 1 /* |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
2 * |
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
3 * rgb2rgb.c, Software RGB to RGB convertor |
2732 | 4 * pluralize by Software PAL8 to RGB convertor |
5 * Software YUV to YUV convertor | |
6 * Software YUV to RGB convertor | |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
7 * Written by Nick Kurshev. |
3132 | 8 * palette & yuv & runtime cpu stuff by Michael (michaelni@gmx.at) (under GPL) |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
9 */ |
2504 | 10 #include <inttypes.h> |
11 #include "../config.h" | |
12 #include "rgb2rgb.h" | |
3132 | 13 #include "../cpudetect.h" |
4923 | 14 #include "../mangle.h" |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
15 |
3132 | 16 #ifdef ARCH_X86 |
17 #define CAN_COMPILE_X86_ASM | |
18 #endif | |
19 | |
4622 | 20 #define FAST_BGR2YV12 // use 7 bit coeffs instead of 15bit |
21 | |
3132 | 22 #ifdef CAN_COMPILE_X86_ASM |
6492 | 23 static const uint64_t mmx_null __attribute__((aligned(8))) = 0x0000000000000000ULL; |
24 static const uint64_t mmx_one __attribute__((aligned(8))) = 0xFFFFFFFFFFFFFFFFULL; | |
2755 | 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; | |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
28 static const uint64_t mask32 __attribute__((aligned(8))) = 0x00FFFFFF00FFFFFFULL; |
5582 | 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; | |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
32 static const uint64_t mask24l __attribute__((aligned(8))) = 0x0000000000FFFFFFULL; |
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
33 static const uint64_t mask24h __attribute__((aligned(8))) = 0x0000FFFFFF000000ULL; |
2746
dece635a28e3
Minor speedup of rgb32to24. (performance is not successful)
nick
parents:
2741
diff
changeset
|
34 static const uint64_t mask24hh __attribute__((aligned(8))) = 0xffff000000000000ULL; |
dece635a28e3
Minor speedup of rgb32to24. (performance is not successful)
nick
parents:
2741
diff
changeset
|
35 static const uint64_t mask24hhh __attribute__((aligned(8))) = 0xffffffff00000000ULL; |
dece635a28e3
Minor speedup of rgb32to24. (performance is not successful)
nick
parents:
2741
diff
changeset
|
36 static const uint64_t mask24hhhh __attribute__((aligned(8))) = 0xffffffffffff0000ULL; |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
37 static const uint64_t mask15b __attribute__((aligned(8))) = 0x001F001F001F001FULL; /* 00000000 00011111 xxB */ |
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
38 static const uint64_t mask15rg __attribute__((aligned(8))) = 0x7FE07FE07FE07FE0ULL; /* 01111111 11100000 RGx */ |
2698
22652c028692
faster 15to16 bit rgb (the mmx routine is limited by memory speed so there is no difference ): but the c routine is faster
michael
parents:
2697
diff
changeset
|
39 static const uint64_t mask15s __attribute__((aligned(8))) = 0xFFE0FFE0FFE0FFE0ULL; |
6492 | 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; | |
2741 | 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; | |
4622 | 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 | |
2755 | 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 | |
2535 | 79 #endif |
2513 | 80 |
3132 | 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 | |
5338 | 98 #undef HAVE_SSE2 |
3132 | 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 | |
5338 | 109 #undef HAVE_SSE2 |
3132 | 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 | |
5338 | 119 #undef HAVE_SSE2 |
3132 | 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 | |
5338 | 129 #undef HAVE_SSE2 |
3132 | 130 #define ARCH_X86 |
131 #define RENAME(a) a ## _3DNow | |
132 #include "rgb2rgb_template.c" | |
133 | |
134 #endif //CAN_COMPILE_X86_ASM | |
135 | |
2718 | 136 void rgb24to32(const uint8_t *src,uint8_t *dst,unsigned src_size) |
2504 | 137 { |
3132 | 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 | |
6492 | 147 #endif |
3132 | 148 rgb24to32_C(src, dst, src_size); |
6492 | 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 | |
2510 | 177 #endif |
6492 | 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); | |
2504 | 209 } |
2505 | 210 |
2718 | 211 void rgb32to24(const uint8_t *src,uint8_t *dst,unsigned src_size) |
2505 | 212 { |
3132 | 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 | |
6492 | 222 #endif |
3132 | 223 rgb32to24_C(src, dst, src_size); |
2505 | 224 } |
2506 | 225 |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
226 /* |
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
227 Original by Strepto/Astral |
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
228 ported to gcc & bugfixed : A'rpi |
2564 | 229 MMX2, 3DNOW optimization by Nick Kurshev |
2698
22652c028692
faster 15to16 bit rgb (the mmx routine is limited by memory speed so there is no difference ): but the c routine is faster
michael
parents:
2697
diff
changeset
|
230 32bit c version, and and&add trick by Michael Niedermayer |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
231 */ |
2718 | 232 void rgb15to16(const uint8_t *src,uint8_t *dst,unsigned src_size) |
2506 | 233 { |
3132 | 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 | |
6492 | 243 #endif |
3132 | 244 rgb15to16_C(src, dst, src_size); |
2506 | 245 } |
2694 | 246 |
247 /** | |
248 * Pallete is assumed to contain bgr32 | |
249 */ | |
2718 | 250 void palette8torgb32(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette) |
2694 | 251 { |
2718 | 252 unsigned i; |
2702 | 253 for(i=0; i<num_pixels; i++) |
2718 | 254 ((unsigned *)dst)[i] = ((unsigned *)palette)[ src[i] ]; |
2694 | 255 } |
256 | |
2697 | 257 /** |
258 * Pallete is assumed to contain bgr32 | |
259 */ | |
2718 | 260 void palette8torgb24(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette) |
2697 | 261 { |
2718 | 262 unsigned i; |
2697 | 263 /* |
264 writes 1 byte o much and might cause alignment issues on some architectures? | |
2702 | 265 for(i=0; i<num_pixels; i++) |
2718 | 266 ((unsigned *)(&dst[i*3])) = ((unsigned *)palette)[ src[i] ]; |
2697 | 267 */ |
2702 | 268 for(i=0; i<num_pixels; i++) |
2697 | 269 { |
270 //FIXME slow? | |
271 dst[0]= palette[ src[i]*4+0 ]; | |
272 dst[1]= palette[ src[i]*4+1 ]; | |
273 dst[2]= palette[ src[i]*4+2 ]; | |
274 dst+= 3; | |
275 } | |
276 } | |
277 | |
6484
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
278 void bgr24torgb24(const uint8_t *src, uint8_t *dst, unsigned src_size) |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
279 { |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
280 #ifdef CAN_COMPILE_X86_ASM |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
281 // ordered per speed fasterst first |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
282 if(gCpuCaps.hasMMX2) |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
283 bgr24torgb24_MMX2(src, dst, src_size); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
284 else if(gCpuCaps.has3DNow) |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
285 bgr24torgb24_3DNow(src, dst, src_size); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
286 else if(gCpuCaps.hasMMX) |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
287 bgr24torgb24_MMX(src, dst, src_size); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
288 else |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
289 bgr24torgb24_C(src, dst, src_size); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
290 #else |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
291 bgr24torgb24_C(src, dst, src_size); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
292 #endif |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
293 } |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
294 |
2718 | 295 void rgb32to16(const uint8_t *src, uint8_t *dst, unsigned src_size) |
2694 | 296 { |
3132 | 297 #ifdef CAN_COMPILE_X86_ASM |
298 // ordered per speed fasterst first | |
299 if(gCpuCaps.hasMMX2) | |
300 rgb32to16_MMX2(src, dst, src_size); | |
301 else if(gCpuCaps.has3DNow) | |
302 rgb32to16_3DNow(src, dst, src_size); | |
303 else if(gCpuCaps.hasMMX) | |
304 rgb32to16_MMX(src, dst, src_size); | |
305 else | |
6492 | 306 #endif |
3132 | 307 rgb32to16_C(src, dst, src_size); |
2694 | 308 } |
309 | |
2718 | 310 void rgb32to15(const uint8_t *src, uint8_t *dst, unsigned src_size) |
2694 | 311 { |
3132 | 312 #ifdef CAN_COMPILE_X86_ASM |
313 // ordered per speed fasterst first | |
314 if(gCpuCaps.hasMMX2) | |
315 rgb32to15_MMX2(src, dst, src_size); | |
316 else if(gCpuCaps.has3DNow) | |
317 rgb32to15_3DNow(src, dst, src_size); | |
318 else if(gCpuCaps.hasMMX) | |
319 rgb32to15_MMX(src, dst, src_size); | |
320 else | |
6492 | 321 #endif |
3132 | 322 rgb32to15_C(src, dst, src_size); |
2694 | 323 } |
324 | |
2718 | 325 void rgb24to16(const uint8_t *src, uint8_t *dst, unsigned src_size) |
326 { | |
3132 | 327 #ifdef CAN_COMPILE_X86_ASM |
328 // ordered per speed fasterst first | |
329 if(gCpuCaps.hasMMX2) | |
330 rgb24to16_MMX2(src, dst, src_size); | |
331 else if(gCpuCaps.has3DNow) | |
332 rgb24to16_3DNow(src, dst, src_size); | |
333 else if(gCpuCaps.hasMMX) | |
334 rgb24to16_MMX(src, dst, src_size); | |
335 else | |
6492 | 336 #endif |
3132 | 337 rgb24to16_C(src, dst, src_size); |
2718 | 338 } |
339 | |
340 void rgb24to15(const uint8_t *src, uint8_t *dst, unsigned src_size) | |
341 { | |
3132 | 342 #ifdef CAN_COMPILE_X86_ASM |
343 // ordered per speed fasterst first | |
344 if(gCpuCaps.hasMMX2) | |
345 rgb24to15_MMX2(src, dst, src_size); | |
346 else if(gCpuCaps.has3DNow) | |
347 rgb24to15_3DNow(src, dst, src_size); | |
348 else if(gCpuCaps.hasMMX) | |
349 rgb24to15_MMX(src, dst, src_size); | |
350 else | |
6492 | 351 #endif |
3132 | 352 rgb24to15_C(src, dst, src_size); |
2718 | 353 } |
2694 | 354 |
355 /** | |
356 * Palette is assumed to contain bgr16, see rgb32to16 to convert the palette | |
357 */ | |
2718 | 358 void palette8torgb16(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette) |
2694 | 359 { |
2718 | 360 unsigned i; |
2702 | 361 for(i=0; i<num_pixels; i++) |
2694 | 362 ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ]; |
363 } | |
364 | |
365 /** | |
366 * Pallete is assumed to contain bgr15, see rgb32to15 to convert the palette | |
367 */ | |
2718 | 368 void palette8torgb15(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette) |
2694 | 369 { |
2718 | 370 unsigned i; |
2702 | 371 for(i=0; i<num_pixels; i++) |
2694 | 372 ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ]; |
2697 | 373 } |
2755 | 374 |
375 void rgb32tobgr32(const uint8_t *src, uint8_t *dst, unsigned int src_size) | |
376 { | |
3132 | 377 #ifdef CAN_COMPILE_X86_ASM |
378 // ordered per speed fasterst first | |
379 if(gCpuCaps.hasMMX2) | |
380 rgb32tobgr32_MMX2(src, dst, src_size); | |
381 else if(gCpuCaps.has3DNow) | |
382 rgb32tobgr32_3DNow(src, dst, src_size); | |
383 else if(gCpuCaps.hasMMX) | |
384 rgb32tobgr32_MMX(src, dst, src_size); | |
385 else | |
6492 | 386 #endif |
3132 | 387 rgb32tobgr32_C(src, dst, src_size); |
2755 | 388 } |
389 | |
5582 | 390 void rgb24tobgr24(const uint8_t *src, uint8_t *dst, unsigned int src_size) |
391 { | |
392 #ifdef CAN_COMPILE_X86_ASM | |
393 // ordered per speed fasterst first | |
394 if(gCpuCaps.hasMMX2) | |
395 rgb24tobgr24_MMX2(src, dst, src_size); | |
396 else if(gCpuCaps.has3DNow) | |
397 rgb24tobgr24_3DNow(src, dst, src_size); | |
398 else if(gCpuCaps.hasMMX) | |
399 rgb24tobgr24_MMX(src, dst, src_size); | |
400 else | |
6492 | 401 #endif |
5582 | 402 rgb24tobgr24_C(src, dst, src_size); |
403 } | |
404 | |
2702 | 405 /** |
406 * | |
2724 | 407 * height should be a multiple of 2 and width should be a multiple of 16 (if this is a |
408 * problem for anyone then tell me, and ill fix it) | |
2702 | 409 */ |
2723 | 410 void yv12toyuy2(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, |
2725 | 411 unsigned int width, unsigned int height, |
412 unsigned int lumStride, unsigned int chromStride, unsigned int dstStride) | |
2701 | 413 { |
3132 | 414 #ifdef CAN_COMPILE_X86_ASM |
415 // ordered per speed fasterst first | |
416 if(gCpuCaps.hasMMX2) | |
417 yv12toyuy2_MMX2(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
418 else if(gCpuCaps.has3DNow) | |
419 yv12toyuy2_3DNow(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
420 else if(gCpuCaps.hasMMX) | |
421 yv12toyuy2_MMX(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
422 else | |
6492 | 423 #endif |
3132 | 424 yv12toyuy2_C(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); |
2701 | 425 } |
426 | |
2724 | 427 /** |
428 * | |
5588 | 429 * width should be a multiple of 16 |
430 */ | |
431 void yuv422ptoyuy2(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, | |
432 unsigned int width, unsigned int height, | |
433 unsigned int lumStride, unsigned int chromStride, unsigned int dstStride) | |
434 { | |
435 #ifdef CAN_COMPILE_X86_ASM | |
436 // ordered per speed fasterst first | |
437 if(gCpuCaps.hasMMX2) | |
438 yuv422ptoyuy2_MMX2(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
439 else if(gCpuCaps.has3DNow) | |
440 yuv422ptoyuy2_3DNow(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
441 else if(gCpuCaps.hasMMX) | |
442 yuv422ptoyuy2_MMX(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
443 else | |
6492 | 444 #endif |
5588 | 445 yuv422ptoyuy2_C(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); |
446 } | |
447 | |
448 /** | |
449 * | |
2724 | 450 * height should be a multiple of 2 and width should be a multiple of 16 (if this is a |
451 * problem for anyone then tell me, and ill fix it) | |
452 */ | |
453 void yuy2toyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, | |
2725 | 454 unsigned int width, unsigned int height, |
455 unsigned int lumStride, unsigned int chromStride, unsigned int srcStride) | |
2701 | 456 { |
3132 | 457 #ifdef CAN_COMPILE_X86_ASM |
458 // ordered per speed fasterst first | |
459 if(gCpuCaps.hasMMX2) | |
460 yuy2toyv12_MMX2(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
461 else if(gCpuCaps.has3DNow) | |
462 yuy2toyv12_3DNow(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
463 else if(gCpuCaps.hasMMX) | |
464 yuy2toyv12_MMX(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
465 else | |
6492 | 466 #endif |
3132 | 467 yuy2toyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); |
2723 | 468 } |
2801 | 469 |
470 /** | |
471 * | |
472 * height should be a multiple of 2 and width should be a multiple of 16 (if this is a | |
473 * problem for anyone then tell me, and ill fix it) | |
3132 | 474 * chrominance data is only taken from every secound line others are ignored FIXME write HQ version |
2801 | 475 */ |
476 void uyvytoyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, | |
477 unsigned int width, unsigned int height, | |
478 unsigned int lumStride, unsigned int chromStride, unsigned int srcStride) | |
479 { | |
3132 | 480 #ifdef CAN_COMPILE_X86_ASM |
481 // ordered per speed fasterst first | |
482 if(gCpuCaps.hasMMX2) | |
483 uyvytoyv12_MMX2(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
484 else if(gCpuCaps.has3DNow) | |
485 uyvytoyv12_3DNow(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
486 else if(gCpuCaps.hasMMX) | |
487 uyvytoyv12_MMX(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
488 else | |
489 uyvytoyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
2847 | 490 #else |
3132 | 491 uyvytoyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); |
2847 | 492 #endif |
2801 | 493 } |
494 | |
6484
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
495 void yvu9toyv12(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
496 uint8_t *ydst, uint8_t *udst, uint8_t *vdst, |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
497 unsigned int width, unsigned int height, |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
498 unsigned int lumStride, unsigned int chromStride) |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
499 { |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
500 #ifdef CAN_COMPILE_X86_ASM |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
501 // ordered per speed fasterst first |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
502 if(gCpuCaps.hasMMX2) |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
503 yvu9toyv12_MMX2(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
504 else if(gCpuCaps.has3DNow) |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
505 yvu9toyv12_3DNow(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
506 else if(gCpuCaps.hasMMX) |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
507 yvu9toyv12_MMX(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
508 else |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
509 yvu9toyv12_C(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
510 #else |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
511 yvu9toyv12_C(ysrc, usrc, vsrc, ydst, udst, vdst, width, height, lumStride, chromStride); |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
512 #endif |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
513 } |
c5cf988c6d6f
pre-yvu9toyv12 converter, only grayscale Y-plane coping :)
alex
parents:
5588
diff
changeset
|
514 |
3132 | 515 /** |
516 * | |
517 * height should be a multiple of 2 and width should be a multiple of 2 (if this is a | |
518 * problem for anyone then tell me, and ill fix it) | |
519 * chrominance data is only taken from every secound line others are ignored FIXME write HQ version | |
520 */ | |
521 void rgb24toyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, | |
522 unsigned int width, unsigned int height, | |
523 unsigned int lumStride, unsigned int chromStride, unsigned int srcStride) | |
524 { | |
525 #ifdef CAN_COMPILE_X86_ASM | |
526 // ordered per speed fasterst first | |
527 if(gCpuCaps.hasMMX2) | |
528 rgb24toyv12_MMX2(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
529 else if(gCpuCaps.has3DNow) | |
530 rgb24toyv12_3DNow(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
531 else if(gCpuCaps.hasMMX) | |
532 rgb24toyv12_MMX(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
533 else | |
6492 | 534 #endif |
3132 | 535 rgb24toyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); |
536 } | |
5337 | 537 |
538 void interleaveBytes(uint8_t *src1, uint8_t *src2, uint8_t *dst, | |
6492 | 539 unsigned width, unsigned height, unsigned src1Stride, |
540 unsigned src2Stride, unsigned dstStride) | |
5337 | 541 { |
542 #ifdef CAN_COMPILE_X86_ASM | |
543 // ordered per speed fasterst first | |
544 if(gCpuCaps.hasMMX2) | |
545 interleaveBytes_MMX2(src1, src2, dst, width, height, src1Stride, src2Stride, dstStride); | |
546 else if(gCpuCaps.has3DNow) | |
547 interleaveBytes_3DNow(src1, src2, dst, width, height, src1Stride, src2Stride, dstStride); | |
548 else if(gCpuCaps.hasMMX) | |
549 interleaveBytes_MMX(src1, src2, dst, width, height, src1Stride, src2Stride, dstStride); | |
550 else | |
6492 | 551 #endif |
5337 | 552 interleaveBytes_C(src1, src2, dst, width, height, src1Stride, src2Stride, dstStride); |
553 } |