Mercurial > mplayer.hg
annotate postproc/rgb2rgb.c @ 4333:c67d50d4a889
Add a parser for the "ASF group stream object" and display the bitrate values
of all the streams.
author | bertrand |
---|---|
date | Thu, 24 Jan 2002 05:30:41 +0000 |
parents | ab67556586fa |
children | e3a9fae516e4 |
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" |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
14 |
3132 | 15 #ifdef ARCH_X86 |
16 #define CAN_COMPILE_X86_ASM | |
17 #endif | |
18 | |
19 #ifdef CAN_COMPILE_X86_ASM | |
2755 | 20 static const uint64_t mask32b __attribute__((aligned(8))) = 0x000000FF000000FFULL; |
21 static const uint64_t mask32g __attribute__((aligned(8))) = 0x0000FF000000FF00ULL; | |
22 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
|
23 static const uint64_t mask32 __attribute__((aligned(8))) = 0x00FFFFFF00FFFFFFULL; |
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
24 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
|
25 static const uint64_t mask24h __attribute__((aligned(8))) = 0x0000FFFFFF000000ULL; |
2746
dece635a28e3
Minor speedup of rgb32to24. (performance is not successful)
nick
parents:
2741
diff
changeset
|
26 static const uint64_t mask24hh __attribute__((aligned(8))) = 0xffff000000000000ULL; |
dece635a28e3
Minor speedup of rgb32to24. (performance is not successful)
nick
parents:
2741
diff
changeset
|
27 static const uint64_t mask24hhh __attribute__((aligned(8))) = 0xffffffff00000000ULL; |
dece635a28e3
Minor speedup of rgb32to24. (performance is not successful)
nick
parents:
2741
diff
changeset
|
28 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
|
29 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
|
30 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
|
31 static const uint64_t mask15s __attribute__((aligned(8))) = 0xFFE0FFE0FFE0FFE0ULL; |
2741 | 32 static const uint64_t red_16mask __attribute__((aligned(8))) = 0x0000f8000000f800ULL; |
33 static const uint64_t green_16mask __attribute__((aligned(8)))= 0x000007e0000007e0ULL; | |
34 static const uint64_t blue_16mask __attribute__((aligned(8))) = 0x0000001f0000001fULL; | |
35 static const uint64_t red_15mask __attribute__((aligned(8))) = 0x00007c000000f800ULL; | |
36 static const uint64_t green_15mask __attribute__((aligned(8)))= 0x000003e0000007e0ULL; | |
37 static const uint64_t blue_15mask __attribute__((aligned(8))) = 0x0000001f0000001fULL; | |
2755 | 38 #if 0 |
39 static volatile uint64_t __attribute__((aligned(8))) b5Dither; | |
40 static volatile uint64_t __attribute__((aligned(8))) g5Dither; | |
41 static volatile uint64_t __attribute__((aligned(8))) g6Dither; | |
42 static volatile uint64_t __attribute__((aligned(8))) r5Dither; | |
43 | |
44 static uint64_t __attribute__((aligned(8))) dither4[2]={ | |
45 0x0103010301030103LL, | |
46 0x0200020002000200LL,}; | |
47 | |
48 static uint64_t __attribute__((aligned(8))) dither8[2]={ | |
49 0x0602060206020602LL, | |
50 0x0004000400040004LL,}; | |
51 #endif | |
2535 | 52 #endif |
2513 | 53 |
3132 | 54 #define RGB2YUV_SHIFT 8 |
55 #define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5)) | |
56 #define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5)) | |
57 #define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5)) | |
58 #define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5)) | |
59 #define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5)) | |
60 #define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5)) | |
61 #define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5)) | |
62 #define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5)) | |
63 #define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5)) | |
64 | |
65 //Note: we have C, MMX, MMX2, 3DNOW version therse no 3DNOW+MMX2 one | |
66 //Plain C versions | |
67 #undef HAVE_MMX | |
68 #undef HAVE_MMX2 | |
69 #undef HAVE_3DNOW | |
70 #undef ARCH_X86 | |
71 #define RENAME(a) a ## _C | |
72 #include "rgb2rgb_template.c" | |
73 | |
74 #ifdef CAN_COMPILE_X86_ASM | |
75 | |
76 //MMX versions | |
77 #undef RENAME | |
78 #define HAVE_MMX | |
79 #undef HAVE_MMX2 | |
80 #undef HAVE_3DNOW | |
81 #define ARCH_X86 | |
82 #define RENAME(a) a ## _MMX | |
83 #include "rgb2rgb_template.c" | |
84 | |
85 //MMX2 versions | |
86 #undef RENAME | |
87 #define HAVE_MMX | |
88 #define HAVE_MMX2 | |
89 #undef HAVE_3DNOW | |
90 #define ARCH_X86 | |
91 #define RENAME(a) a ## _MMX2 | |
92 #include "rgb2rgb_template.c" | |
93 | |
94 //3DNOW versions | |
95 #undef RENAME | |
96 #define HAVE_MMX | |
97 #undef HAVE_MMX2 | |
98 #define HAVE_3DNOW | |
99 #define ARCH_X86 | |
100 #define RENAME(a) a ## _3DNow | |
101 #include "rgb2rgb_template.c" | |
102 | |
103 #endif //CAN_COMPILE_X86_ASM | |
104 | |
2718 | 105 void rgb24to32(const uint8_t *src,uint8_t *dst,unsigned src_size) |
2504 | 106 { |
3132 | 107 #ifdef CAN_COMPILE_X86_ASM |
108 // ordered per speed fasterst first | |
109 if(gCpuCaps.hasMMX2) | |
110 rgb24to32_MMX2(src, dst, src_size); | |
111 else if(gCpuCaps.has3DNow) | |
112 rgb24to32_3DNow(src, dst, src_size); | |
113 else if(gCpuCaps.hasMMX) | |
114 rgb24to32_MMX(src, dst, src_size); | |
115 else | |
116 rgb24to32_C(src, dst, src_size); | |
117 #else | |
118 rgb24to32_C(src, dst, src_size); | |
2510 | 119 #endif |
2504 | 120 } |
2505 | 121 |
2718 | 122 void rgb32to24(const uint8_t *src,uint8_t *dst,unsigned src_size) |
2505 | 123 { |
3132 | 124 #ifdef CAN_COMPILE_X86_ASM |
125 // ordered per speed fasterst first | |
126 if(gCpuCaps.hasMMX2) | |
127 rgb32to24_MMX2(src, dst, src_size); | |
128 else if(gCpuCaps.has3DNow) | |
129 rgb32to24_3DNow(src, dst, src_size); | |
130 else if(gCpuCaps.hasMMX) | |
131 rgb32to24_MMX(src, dst, src_size); | |
132 else | |
133 rgb32to24_C(src, dst, src_size); | |
134 #else | |
135 rgb32to24_C(src, dst, src_size); | |
2517 | 136 #endif |
2505 | 137 } |
2506 | 138 |
2538
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
139 /* |
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
140 Original by Strepto/Astral |
71320898b333
Finish mmx2, 3dnow optimiz. 15to16 should be tested. Better fix of can't compile
nick
parents:
2535
diff
changeset
|
141 ported to gcc & bugfixed : A'rpi |
2564 | 142 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
|
143 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
|
144 */ |
2718 | 145 void rgb15to16(const uint8_t *src,uint8_t *dst,unsigned src_size) |
2506 | 146 { |
3132 | 147 #ifdef CAN_COMPILE_X86_ASM |
148 // ordered per speed fasterst first | |
149 if(gCpuCaps.hasMMX2) | |
150 rgb15to16_MMX2(src, dst, src_size); | |
151 else if(gCpuCaps.has3DNow) | |
152 rgb15to16_3DNow(src, dst, src_size); | |
153 else if(gCpuCaps.hasMMX) | |
154 rgb15to16_MMX(src, dst, src_size); | |
155 else | |
156 rgb15to16_C(src, dst, src_size); | |
2506 | 157 #else |
3132 | 158 rgb15to16_C(src, dst, src_size); |
2506 | 159 #endif |
160 } | |
2694 | 161 |
162 /** | |
163 * Pallete is assumed to contain bgr32 | |
164 */ | |
2718 | 165 void palette8torgb32(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette) |
2694 | 166 { |
2718 | 167 unsigned i; |
2702 | 168 for(i=0; i<num_pixels; i++) |
2718 | 169 ((unsigned *)dst)[i] = ((unsigned *)palette)[ src[i] ]; |
2694 | 170 } |
171 | |
2697 | 172 /** |
173 * Pallete is assumed to contain bgr32 | |
174 */ | |
2718 | 175 void palette8torgb24(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette) |
2697 | 176 { |
2718 | 177 unsigned i; |
2697 | 178 /* |
179 writes 1 byte o much and might cause alignment issues on some architectures? | |
2702 | 180 for(i=0; i<num_pixels; i++) |
2718 | 181 ((unsigned *)(&dst[i*3])) = ((unsigned *)palette)[ src[i] ]; |
2697 | 182 */ |
2702 | 183 for(i=0; i<num_pixels; i++) |
2697 | 184 { |
185 //FIXME slow? | |
186 dst[0]= palette[ src[i]*4+0 ]; | |
187 dst[1]= palette[ src[i]*4+1 ]; | |
188 dst[2]= palette[ src[i]*4+2 ]; | |
189 dst+= 3; | |
190 } | |
191 } | |
192 | |
2718 | 193 void rgb32to16(const uint8_t *src, uint8_t *dst, unsigned src_size) |
2694 | 194 { |
3132 | 195 #ifdef CAN_COMPILE_X86_ASM |
196 // ordered per speed fasterst first | |
197 if(gCpuCaps.hasMMX2) | |
198 rgb32to16_MMX2(src, dst, src_size); | |
199 else if(gCpuCaps.has3DNow) | |
200 rgb32to16_3DNow(src, dst, src_size); | |
201 else if(gCpuCaps.hasMMX) | |
202 rgb32to16_MMX(src, dst, src_size); | |
203 else | |
204 rgb32to16_C(src, dst, src_size); | |
2741 | 205 #else |
3132 | 206 rgb32to16_C(src, dst, src_size); |
2741 | 207 #endif |
2694 | 208 } |
209 | |
2718 | 210 void rgb32to15(const uint8_t *src, uint8_t *dst, unsigned src_size) |
2694 | 211 { |
3132 | 212 #ifdef CAN_COMPILE_X86_ASM |
213 // ordered per speed fasterst first | |
214 if(gCpuCaps.hasMMX2) | |
215 rgb32to15_MMX2(src, dst, src_size); | |
216 else if(gCpuCaps.has3DNow) | |
217 rgb32to15_3DNow(src, dst, src_size); | |
218 else if(gCpuCaps.hasMMX) | |
219 rgb32to15_MMX(src, dst, src_size); | |
220 else | |
221 rgb32to15_C(src, dst, src_size); | |
2741 | 222 #else |
3132 | 223 rgb32to15_C(src, dst, src_size); |
2741 | 224 #endif |
2694 | 225 } |
226 | |
2718 | 227 void rgb24to16(const uint8_t *src, uint8_t *dst, unsigned src_size) |
228 { | |
3132 | 229 #ifdef CAN_COMPILE_X86_ASM |
230 // ordered per speed fasterst first | |
231 if(gCpuCaps.hasMMX2) | |
232 rgb24to16_MMX2(src, dst, src_size); | |
233 else if(gCpuCaps.has3DNow) | |
234 rgb24to16_3DNow(src, dst, src_size); | |
235 else if(gCpuCaps.hasMMX) | |
236 rgb24to16_MMX(src, dst, src_size); | |
237 else | |
238 rgb24to16_C(src, dst, src_size); | |
2740 | 239 #else |
3132 | 240 rgb24to16_C(src, dst, src_size); |
2740 | 241 #endif |
2718 | 242 } |
243 | |
244 void rgb24to15(const uint8_t *src, uint8_t *dst, unsigned src_size) | |
245 { | |
3132 | 246 #ifdef CAN_COMPILE_X86_ASM |
247 // ordered per speed fasterst first | |
248 if(gCpuCaps.hasMMX2) | |
249 rgb24to15_MMX2(src, dst, src_size); | |
250 else if(gCpuCaps.has3DNow) | |
251 rgb24to15_3DNow(src, dst, src_size); | |
252 else if(gCpuCaps.hasMMX) | |
253 rgb24to15_MMX(src, dst, src_size); | |
254 else | |
255 rgb24to15_C(src, dst, src_size); | |
2741 | 256 #else |
3132 | 257 rgb24to15_C(src, dst, src_size); |
2741 | 258 #endif |
2718 | 259 } |
2694 | 260 |
261 /** | |
262 * Palette is assumed to contain bgr16, see rgb32to16 to convert the palette | |
263 */ | |
2718 | 264 void palette8torgb16(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette) |
2694 | 265 { |
2718 | 266 unsigned i; |
2702 | 267 for(i=0; i<num_pixels; i++) |
2694 | 268 ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ]; |
269 } | |
270 | |
271 /** | |
272 * Pallete is assumed to contain bgr15, see rgb32to15 to convert the palette | |
273 */ | |
2718 | 274 void palette8torgb15(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette) |
2694 | 275 { |
2718 | 276 unsigned i; |
2702 | 277 for(i=0; i<num_pixels; i++) |
2694 | 278 ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ]; |
2697 | 279 } |
2755 | 280 |
281 void rgb32tobgr32(const uint8_t *src, uint8_t *dst, unsigned int src_size) | |
282 { | |
3132 | 283 #ifdef CAN_COMPILE_X86_ASM |
284 // ordered per speed fasterst first | |
285 if(gCpuCaps.hasMMX2) | |
286 rgb32tobgr32_MMX2(src, dst, src_size); | |
287 else if(gCpuCaps.has3DNow) | |
288 rgb32tobgr32_3DNow(src, dst, src_size); | |
289 else if(gCpuCaps.hasMMX) | |
290 rgb32tobgr32_MMX(src, dst, src_size); | |
291 else | |
292 rgb32tobgr32_C(src, dst, src_size); | |
2755 | 293 #else |
3132 | 294 rgb32tobgr32_C(src, dst, src_size); |
2755 | 295 #endif |
296 } | |
297 | |
2702 | 298 /** |
299 * | |
2724 | 300 * height should be a multiple of 2 and width should be a multiple of 16 (if this is a |
301 * problem for anyone then tell me, and ill fix it) | |
2702 | 302 */ |
2723 | 303 void yv12toyuy2(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, |
2725 | 304 unsigned int width, unsigned int height, |
305 unsigned int lumStride, unsigned int chromStride, unsigned int dstStride) | |
2701 | 306 { |
3132 | 307 #ifdef CAN_COMPILE_X86_ASM |
308 // ordered per speed fasterst first | |
309 if(gCpuCaps.hasMMX2) | |
310 yv12toyuy2_MMX2(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
311 else if(gCpuCaps.has3DNow) | |
312 yv12toyuy2_3DNow(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
313 else if(gCpuCaps.hasMMX) | |
314 yv12toyuy2_MMX(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
315 else | |
316 yv12toyuy2_C(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); | |
2702 | 317 #else |
3132 | 318 yv12toyuy2_C(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride); |
2702 | 319 #endif |
2701 | 320 } |
321 | |
2724 | 322 /** |
323 * | |
324 * height should be a multiple of 2 and width should be a multiple of 16 (if this is a | |
325 * problem for anyone then tell me, and ill fix it) | |
326 */ | |
327 void yuy2toyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, | |
2725 | 328 unsigned int width, unsigned int height, |
329 unsigned int lumStride, unsigned int chromStride, unsigned int srcStride) | |
2701 | 330 { |
3132 | 331 #ifdef CAN_COMPILE_X86_ASM |
332 // ordered per speed fasterst first | |
333 if(gCpuCaps.hasMMX2) | |
334 yuy2toyv12_MMX2(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
335 else if(gCpuCaps.has3DNow) | |
336 yuy2toyv12_3DNow(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
337 else if(gCpuCaps.hasMMX) | |
338 yuy2toyv12_MMX(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
339 else | |
340 yuy2toyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
2704 | 341 #else |
3132 | 342 yuy2toyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); |
2704 | 343 #endif |
2723 | 344 } |
2801 | 345 |
346 /** | |
347 * | |
348 * height should be a multiple of 2 and width should be a multiple of 16 (if this is a | |
349 * problem for anyone then tell me, and ill fix it) | |
3132 | 350 * chrominance data is only taken from every secound line others are ignored FIXME write HQ version |
2801 | 351 */ |
352 void uyvytoyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, | |
353 unsigned int width, unsigned int height, | |
354 unsigned int lumStride, unsigned int chromStride, unsigned int srcStride) | |
355 { | |
3132 | 356 #ifdef CAN_COMPILE_X86_ASM |
357 // ordered per speed fasterst first | |
358 if(gCpuCaps.hasMMX2) | |
359 uyvytoyv12_MMX2(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
360 else if(gCpuCaps.has3DNow) | |
361 uyvytoyv12_3DNow(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
362 else if(gCpuCaps.hasMMX) | |
363 uyvytoyv12_MMX(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
364 else | |
365 uyvytoyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
2847 | 366 #else |
3132 | 367 uyvytoyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); |
2847 | 368 #endif |
2801 | 369 } |
370 | |
3132 | 371 /** |
372 * | |
373 * height should be a multiple of 2 and width should be a multiple of 2 (if this is a | |
374 * problem for anyone then tell me, and ill fix it) | |
375 * chrominance data is only taken from every secound line others are ignored FIXME write HQ version | |
376 */ | |
377 void rgb24toyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, | |
378 unsigned int width, unsigned int height, | |
379 unsigned int lumStride, unsigned int chromStride, unsigned int srcStride) | |
380 { | |
381 #ifdef CAN_COMPILE_X86_ASM | |
382 // ordered per speed fasterst first | |
383 if(gCpuCaps.hasMMX2) | |
384 rgb24toyv12_MMX2(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
385 else if(gCpuCaps.has3DNow) | |
386 rgb24toyv12_3DNow(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
387 else if(gCpuCaps.hasMMX) | |
388 rgb24toyv12_MMX(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
389 else | |
390 rgb24toyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
391 #else | |
392 rgb24toyv12_C(src, ydst, udst, vdst, width, height, lumStride, chromStride, srcStride); | |
393 #endif | |
394 } |