2 * Templates for image conversion routines
3 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #define RGB_OUT(d, r, g, b) RGBA_OUT(d, r, g, b, 0xffU)
24 static void glue (uyvy422_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
25 int width, int height)
27 uint8_t *s, *d, *d1, *s1;
28 int w, y, cb, cr, r_add, g_add, b_add;
29 uint8_t *cm = cropTbl + MAX_NEG_CROP;
34 for(;height > 0; height --) {
37 for(w = width; w >= 2; w -= 2) {
38 YUV_TO_RGB1_CCIR(s1[0], s1[2]);
40 YUV_TO_RGB2_CCIR(r, g, b, s1[1]);
44 YUV_TO_RGB2_CCIR(r, g, b, s1[3]);
52 YUV_TO_RGB1_CCIR(s1[0], s1[2]);
54 YUV_TO_RGB2_CCIR(r, g, b, s1[1]);
58 d += dst->linesize[0];
59 s += src->linesize[0];
63 static void glue (yuv422_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
64 int width, int height)
66 uint8_t *s, *d, *d1, *s1;
67 int w, y, cb, cr, r_add, g_add, b_add;
68 uint8_t *cm = cropTbl + MAX_NEG_CROP;
73 for(;height > 0; height --) {
76 for(w = width; w >= 2; w -= 2) {
77 YUV_TO_RGB1_CCIR(s1[1], s1[3]);
79 YUV_TO_RGB2_CCIR(r, g, b, s1[0]);
83 YUV_TO_RGB2_CCIR(r, g, b, s1[2]);
91 YUV_TO_RGB1_CCIR(s1[1], s1[3]);
93 YUV_TO_RGB2_CCIR(r, g, b, s1[0]);
97 d += dst->linesize[0];
98 s += src->linesize[0];
102 static void glue (yvyu422_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
103 int width, int height)
105 uint8_t *s, *d, *d1, *s1;
106 int w, y, cb, cr, r_add, g_add, b_add;
107 uint8_t *cm = cropTbl + MAX_NEG_CROP;
108 unsigned int r, g, b;
112 for(;height > 0; height --) {
115 for(w = width; w >= 2; w -= 2) {
116 YUV_TO_RGB1_CCIR(s1[3], s1[1]);
118 YUV_TO_RGB2_CCIR(r, g, b, s1[0]);
119 RGB_OUT(d1, r, g, b);
122 YUV_TO_RGB2_CCIR(r, g, b, s1[2]);
123 RGB_OUT(d1, r, g, b);
130 YUV_TO_RGB1_CCIR(s1[3], s1[1]);
132 YUV_TO_RGB2_CCIR(r, g, b, s1[0]);
133 RGB_OUT(d1, r, g, b);
136 d += dst->linesize[0];
137 s += src->linesize[0];
141 static void glue (yuv420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
142 int width, int height)
144 const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
145 uint8_t *d, *d1, *d2;
146 int w, y, cb, cr, r_add, g_add, b_add, width2;
147 uint8_t *cm = cropTbl + MAX_NEG_CROP;
148 unsigned int r, g, b;
151 y1_ptr = src->data[0];
152 cb_ptr = src->data[1];
153 cr_ptr = src->data[2];
154 width2 = (width + 1) >> 1;
155 for (; height >= 2; height -= 2) {
157 d2 = d + dst->linesize[0];
158 y2_ptr = y1_ptr + src->linesize[0];
159 for (w = width; w >= 2; w -= 2) {
160 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
161 /* output 4 pixels */
162 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
163 RGB_OUT (d1, r, g, b);
165 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
166 RGB_OUT (d1 + BPP, r, g, b);
168 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
169 RGB_OUT (d2, r, g, b);
171 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[1]);
172 RGB_OUT (d2 + BPP, r, g, b);
182 /* handle odd width */
184 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
185 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
186 RGB_OUT (d1, r, g, b);
188 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
189 RGB_OUT (d2, r, g, b);
197 d += 2 * dst->linesize[0];
198 y1_ptr += 2 * src->linesize[0] - width;
199 cb_ptr += src->linesize[1] - width2;
200 cr_ptr += src->linesize[2] - width2;
202 /* handle odd height */
205 for (w = width; w >= 2; w -= 2) {
206 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
207 /* output 2 pixels */
208 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
209 RGB_OUT (d1, r, g, b);
211 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
212 RGB_OUT (d1 + BPP, r, g, b);
222 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
224 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
225 RGB_OUT (d1, r, g, b);
236 #define RGBA_OUT_(d, r, g, b, a) RGB_OUT(d, r, g, b)
237 #define YUVA_TO_A(d, a)
239 #define RGBA_OUT_(d, r, g, b, a) RGBA_OUT(d, r, g, b, a)
240 #define YUVA_TO_A(d, a) do { d = a; } while (0);
243 static void glue (yuva420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
244 int width, int height)
246 const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr, *a1_ptr, *a2_ptr;
247 uint8_t *d, *d1, *d2;
248 int w, y, cb, cr, r_add, g_add, b_add, width2;
249 uint8_t *cm = cropTbl + MAX_NEG_CROP;
250 unsigned int r, g, b;
256 y1_ptr = src->data[0];
257 cb_ptr = src->data[1];
258 cr_ptr = src->data[2];
259 a1_ptr = src->data[3];
260 width2 = (width + 1) >> 1;
261 for (; height >= 2; height -= 2) {
263 d2 = d + dst->linesize[0];
264 y2_ptr = y1_ptr + src->linesize[0];
265 a2_ptr = a1_ptr + src->linesize[3];
266 for (w = width; w >= 2; w -= 2) {
267 YUVA_TO_A (a, a1_ptr[0]);
268 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
269 /* output 4 pixels */
270 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
271 RGBA_OUT_ (d1, r, g, b, a);
273 YUVA_TO_A (a, a1_ptr[1]);
274 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
275 RGBA_OUT_ (d1 + BPP, r, g, b, a);
277 YUVA_TO_A (a, a2_ptr[0]);
278 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
279 RGBA_OUT_ (d2, r, g, b, a);
281 YUVA_TO_A (a, a2_ptr[1]);
282 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[1]);
283 RGBA_OUT_ (d2 + BPP, r, g, b, a);
295 /* handle odd width */
297 YUVA_TO_A (a, a1_ptr[0]);
298 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
299 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
300 RGBA_OUT_ (d1, r, g, b, a);
302 YUVA_TO_A (a, a2_ptr[0]);
303 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
304 RGBA_OUT_ (d2, r, g, b, a);
314 d += 2 * dst->linesize[0];
315 y1_ptr += 2 * src->linesize[0] - width;
316 cb_ptr += src->linesize[1] - width2;
317 cr_ptr += src->linesize[2] - width2;
318 a1_ptr += 2 * src->linesize[3] - width;
320 /* handle odd height */
323 for (w = width; w >= 2; w -= 2) {
324 YUVA_TO_A (a, a1_ptr[0]);
325 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
326 /* output 2 pixels */
327 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
328 RGBA_OUT_ (d1, r, g, b, a);
330 YUVA_TO_A (a, a1_ptr[1]);
331 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
332 RGBA_OUT_ (d1 + BPP, r, g, b, a);
343 YUVA_TO_A (a, a1_ptr[0]);
344 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
346 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
347 RGBA_OUT_ (d1, r, g, b, a);
358 static void glue (nv12_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
359 int width, int height)
361 const uint8_t *y1_ptr, *y2_ptr, *c_ptr;
362 uint8_t *d, *d1, *d2;
363 int w, y, cb, cr, r_add, g_add, b_add;
364 uint8_t *cm = cropTbl + MAX_NEG_CROP;
365 unsigned int r, g, b;
366 int c_wrap = src->linesize[1] - ((width + 1) & ~0x01);
369 y1_ptr = src->data[0];
370 c_ptr = src->data[1];
371 for (; height >= 2; height -= 2) {
373 d2 = d + dst->linesize[0];
374 y2_ptr = y1_ptr + src->linesize[0];
375 for (w = width; w >= 2; w -= 2) {
376 YUV_TO_RGB1_CCIR (c_ptr[0], c_ptr[1]);
377 /* output 4 pixels */
378 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
379 RGB_OUT (d1, r, g, b);
381 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
382 RGB_OUT (d1 + BPP, r, g, b);
384 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
385 RGB_OUT (d2, r, g, b);
387 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[1]);
388 RGB_OUT (d2 + BPP, r, g, b);
397 /* handle odd width */
399 YUV_TO_RGB1_CCIR (c_ptr[0], c_ptr[1]);
400 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
401 RGB_OUT (d1, r, g, b);
403 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
404 RGB_OUT (d2, r, g, b);
411 d += 2 * dst->linesize[0];
412 y1_ptr += 2 * src->linesize[0] - width;
415 /* handle odd height */
418 for (w = width; w >= 2; w -= 2) {
419 YUV_TO_RGB1_CCIR (c_ptr[0], c_ptr[1]);
420 /* output 2 pixels */
421 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
422 RGB_OUT (d1, r, g, b);
424 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
425 RGB_OUT (d1 + BPP, r, g, b);
432 /* handle odd width */
434 YUV_TO_RGB1_CCIR (c_ptr[0], c_ptr[1]);
436 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
437 RGB_OUT (d1, r, g, b);
446 static void glue (nv21_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
447 int width, int height)
449 const uint8_t *y1_ptr, *y2_ptr, *c_ptr;
450 uint8_t *d, *d1, *d2;
451 int w, y, cb, cr, r_add, g_add, b_add;
452 uint8_t *cm = cropTbl + MAX_NEG_CROP;
453 unsigned int r, g, b;
454 int c_wrap = src->linesize[1] - ((width + 1) & ~0x01);
457 y1_ptr = src->data[0];
458 c_ptr = src->data[1];
459 for (; height >= 2; height -= 2) {
461 d2 = d + dst->linesize[0];
462 y2_ptr = y1_ptr + src->linesize[0];
463 for (w = width; w >= 2; w -= 2) {
464 YUV_TO_RGB1_CCIR (c_ptr[1], c_ptr[0]);
465 /* output 4 pixels */
466 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
467 RGB_OUT (d1, r, g, b);
469 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
470 RGB_OUT (d1 + BPP, r, g, b);
472 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
473 RGB_OUT (d2, r, g, b);
475 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[1]);
476 RGB_OUT (d2 + BPP, r, g, b);
485 /* handle odd width */
487 YUV_TO_RGB1_CCIR (c_ptr[1], c_ptr[0]);
488 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
489 RGB_OUT (d1, r, g, b);
491 YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
492 RGB_OUT (d2, r, g, b);
499 d += 2 * dst->linesize[0];
500 y1_ptr += 2 * src->linesize[0] - width;
503 /* handle odd height */
506 for (w = width; w >= 2; w -= 2) {
507 YUV_TO_RGB1_CCIR (c_ptr[1], c_ptr[0]);
508 /* output 2 pixels */
509 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
510 RGB_OUT (d1, r, g, b);
512 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
513 RGB_OUT (d1 + BPP, r, g, b);
520 /* handle odd width */
522 YUV_TO_RGB1_CCIR (c_ptr[1], c_ptr[0]);
524 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
525 RGB_OUT (d1, r, g, b);
534 static void glue (yuvj420p_to_, RGB_NAME) (AVPicture * dst,
535 const AVPicture * src, int width, int height)
537 const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
538 uint8_t *d, *d1, *d2;
539 int w, y, cb, cr, r_add, g_add, b_add, width2;
540 uint8_t *cm = cropTbl + MAX_NEG_CROP;
541 unsigned int r, g, b;
544 y1_ptr = src->data[0];
545 cb_ptr = src->data[1];
546 cr_ptr = src->data[2];
547 width2 = (width + 1) >> 1;
548 for (; height >= 2; height -= 2) {
550 d2 = d + dst->linesize[0];
551 y2_ptr = y1_ptr + src->linesize[0];
552 for (w = width; w >= 2; w -= 2) {
553 YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
554 /* output 4 pixels */
555 YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
556 RGB_OUT (d1, r, g, b);
558 YUV_TO_RGB2 (r, g, b, y1_ptr[1]);
559 RGB_OUT (d1 + BPP, r, g, b);
561 YUV_TO_RGB2 (r, g, b, y2_ptr[0]);
562 RGB_OUT (d2, r, g, b);
564 YUV_TO_RGB2 (r, g, b, y2_ptr[1]);
565 RGB_OUT (d2 + BPP, r, g, b);
575 /* handle odd width */
577 YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
578 YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
579 RGB_OUT (d1, r, g, b);
581 YUV_TO_RGB2 (r, g, b, y2_ptr[0]);
582 RGB_OUT (d2, r, g, b);
590 d += 2 * dst->linesize[0];
591 y1_ptr += 2 * src->linesize[0] - width;
592 cb_ptr += src->linesize[1] - width2;
593 cr_ptr += src->linesize[2] - width2;
595 /* handle odd height */
598 for (w = width; w >= 2; w -= 2) {
599 YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
600 /* output 2 pixels */
601 YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
602 RGB_OUT (d1, r, g, b);
604 YUV_TO_RGB2 (r, g, b, y1_ptr[1]);
605 RGB_OUT (d1 + BPP, r, g, b);
615 YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
616 /* output 2 pixels */
617 YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
618 RGB_OUT (d1, r, g, b);
628 static void glue (y800_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
629 int width, int height)
631 const unsigned char *p;
633 uint8_t *cm = cropTbl + MAX_NEG_CROP;
634 int r, dst_wrap, src_wrap;
638 src_wrap = src->linesize[0] - width;
641 dst_wrap = dst->linesize[0] - BPP * width;
643 for (y = 0; y < height; y++) {
644 for (x = 0; x < width; x++) {
645 r = Y_CCIR_TO_JPEG (p[0]);
646 RGB_OUT (q, r, r, r);
655 static void glue (y16_to_, RGB_NAME) (AVPicture * dst,
656 const AVPicture * src, int width, int height)
658 const unsigned char *p;
660 uint8_t *cm = cropTbl + MAX_NEG_CROP;
661 int r, dst_wrap, src_wrap;
665 src_wrap = src->linesize[0] - 2 * width;
668 dst_wrap = dst->linesize[0] - BPP * width;
670 for (y = 0; y < height; y++) {
671 for (x = 0; x < width; x++) {
672 r = Y_CCIR_TO_JPEG (GST_READ_UINT16_LE (p) >> 8);
673 RGB_OUT (q, r, r, r);
682 static void glue (RGB_NAME, _to_yuv420p) (AVPicture * dst,
683 const AVPicture * src, int width, int height)
685 int wrap, wrap3, width2;
686 int r, g, b, r1, g1, b1, w;
687 uint8_t *lum, *cb, *cr;
694 width2 = (width + 1) >> 1;
695 wrap = dst->linesize[0];
696 wrap3 = src->linesize[0];
698 for (; height >= 2; height -= 2) {
699 for (w = width; w >= 2; w -= 2) {
704 lum[0] = RGB_TO_Y_CCIR (r, g, b);
706 RGB_IN (r, g, b, p + BPP);
710 lum[1] = RGB_TO_Y_CCIR (r, g, b);
718 lum[0] = RGB_TO_Y_CCIR (r, g, b);
720 RGB_IN (r, g, b, p + BPP);
724 lum[1] = RGB_TO_Y_CCIR (r, g, b);
726 cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 2);
727 cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 2);
732 p += -wrap3 + 2 * BPP;
740 lum[0] = RGB_TO_Y_CCIR (r, g, b);
747 lum[0] = RGB_TO_Y_CCIR (r, g, b);
748 cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
749 cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
755 p += wrap3 + (wrap3 - width * BPP);
756 lum += wrap + (wrap - width);
757 cb += dst->linesize[1] - width2;
758 cr += dst->linesize[2] - width2;
760 /* handle odd height */
762 for (w = width; w >= 2; w -= 2) {
767 lum[0] = RGB_TO_Y_CCIR (r, g, b);
769 RGB_IN (r, g, b, p + BPP);
773 lum[1] = RGB_TO_Y_CCIR (r, g, b);
774 cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
775 cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
783 lum[0] = RGB_TO_Y_CCIR (r, g, b);
784 cb[0] = RGB_TO_U_CCIR (r, g, b, 0);
785 cr[0] = RGB_TO_V_CCIR (r, g, b, 0);
791 #define RGBA_IN_(r, g, b, a, p) RGB_IN(r, g, b, p)
793 #define RGBA_IN_(r, g, b, a, p) RGBA_IN(r, g, b, a, p)
796 static void glue (RGB_NAME, _to_yuva420p) (AVPicture * dst,
797 const AVPicture * src, int width, int height)
799 int wrap, wrap3, width2;
800 int r, g, b, r1, g1, b1, w, ra = 255;
801 uint8_t *lum, *cb, *cr, *a;
809 width2 = (width + 1) >> 1;
810 wrap = dst->linesize[0];
811 wrap3 = src->linesize[0];
813 for (; height >= 2; height -= 2) {
814 for (w = width; w >= 2; w -= 2) {
815 RGBA_IN_ (r, g, b, ra, p);
819 lum[0] = RGB_TO_Y_CCIR (r, g, b);
822 RGBA_IN_ (r, g, b, ra, p + BPP);
826 lum[1] = RGB_TO_Y_CCIR (r, g, b);
832 RGBA_IN_ (r, g, b, ra, p);
836 lum[0] = RGB_TO_Y_CCIR (r, g, b);
839 RGBA_IN_ (r, g, b, ra, p + BPP);
843 lum[1] = RGB_TO_Y_CCIR (r, g, b);
846 cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 2);
847 cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 2);
851 p += -wrap3 + 2 * BPP;
856 RGBA_IN_ (r, g, b, ra, p);
860 lum[0] = RGB_TO_Y_CCIR (r, g, b);
865 RGBA_IN_ (r, g, b, ra, p);
869 lum[0] = RGB_TO_Y_CCIR (r, g, b);
871 cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
872 cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
879 p += wrap3 + (wrap3 - width * BPP);
880 lum += wrap + (wrap - width);
881 a += wrap + (wrap - width);
882 cb += dst->linesize[1] - width2;
883 cr += dst->linesize[2] - width2;
885 /* handle odd height */
887 for (w = width; w >= 2; w -= 2) {
888 RGBA_IN_ (r, g, b, ra, p);
892 lum[0] = RGB_TO_Y_CCIR (r, g, b);
895 RGBA_IN_ (r, g, b, ra, p + BPP);
899 lum[1] = RGB_TO_Y_CCIR (r, g, b);
901 cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
902 cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
910 RGBA_IN_ (r, g, b, ra, p);
911 lum[0] = RGB_TO_Y_CCIR (r, g, b);
913 cb[0] = RGB_TO_U_CCIR (r, g, b, 0);
914 cr[0] = RGB_TO_V_CCIR (r, g, b, 0);
919 static void glue (RGB_NAME, _to_nv12) (AVPicture * dst, const AVPicture * src,
920 int width, int height)
923 int r, g, b, r1, g1, b1, w;
930 wrap = dst->linesize[0];
931 wrap3 = src->linesize[0];
933 for (; height >= 2; height -= 2) {
934 for (w = width; w >= 2; w -= 2) {
939 lum[0] = RGB_TO_Y_CCIR (r, g, b);
941 RGB_IN (r, g, b, p + BPP);
945 lum[1] = RGB_TO_Y_CCIR (r, g, b);
953 lum[0] = RGB_TO_Y_CCIR (r, g, b);
955 RGB_IN (r, g, b, p + BPP);
959 lum[1] = RGB_TO_Y_CCIR (r, g, b);
961 c[0] = RGB_TO_U_CCIR (r1, g1, b1, 2);
962 c[1] = RGB_TO_V_CCIR (r1, g1, b1, 2);
966 p += -wrap3 + 2 * BPP;
969 /* handle odd width */
975 lum[0] = RGB_TO_Y_CCIR (r, g, b);
982 lum[0] = RGB_TO_Y_CCIR (r, g, b);
983 c[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
984 c[1] = RGB_TO_V_CCIR (r1, g1, b1, 1);
988 p += wrap3 + (wrap3 - width * BPP);
989 lum += wrap + (wrap - width);
990 c += dst->linesize[1] - (width & ~1);
992 /* handle odd height */
994 for (w = width; w >= 2; w -= 2) {
999 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1001 RGB_IN (r, g, b, p + BPP);
1005 lum[1] = RGB_TO_Y_CCIR (r, g, b);
1006 c[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
1007 c[1] = RGB_TO_V_CCIR (r1, g1, b1, 1);
1012 /* handle odd width */
1014 RGB_IN (r, g, b, p);
1015 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1016 c[0] = RGB_TO_U_CCIR (r, g, b, 0);
1017 c[1] = RGB_TO_V_CCIR (r, g, b, 0);
1022 static void glue (RGB_NAME, _to_nv21) (AVPicture * dst, const AVPicture * src,
1023 int width, int height)
1026 int r, g, b, r1, g1, b1, w;
1033 wrap = dst->linesize[0];
1034 wrap3 = src->linesize[0];
1036 for (; height >= 2; height -= 2) {
1037 for (w = width; w >= 2; w -= 2) {
1038 RGB_IN (r, g, b, p);
1042 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1044 RGB_IN (r, g, b, p + BPP);
1048 lum[1] = RGB_TO_Y_CCIR (r, g, b);
1052 RGB_IN (r, g, b, p);
1056 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1058 RGB_IN (r, g, b, p + BPP);
1062 lum[1] = RGB_TO_Y_CCIR (r, g, b);
1064 c[1] = RGB_TO_U_CCIR (r1, g1, b1, 2);
1065 c[0] = RGB_TO_V_CCIR (r1, g1, b1, 2);
1069 p += -wrap3 + 2 * BPP;
1072 /* handle odd width */
1074 RGB_IN (r, g, b, p);
1078 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1081 RGB_IN (r, g, b, p);
1085 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1086 c[1] = RGB_TO_U_CCIR (r1, g1, b1, 1);
1087 c[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
1091 p += wrap3 + (wrap3 - width * BPP);
1092 lum += wrap + (wrap - width);
1093 c += dst->linesize[1] - (width & ~1);
1095 /* handle odd height */
1097 for (w = width; w >= 2; w -= 2) {
1098 RGB_IN (r, g, b, p);
1102 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1104 RGB_IN (r, g, b, p + BPP);
1108 lum[1] = RGB_TO_Y_CCIR (r, g, b);
1109 c[1] = RGB_TO_U_CCIR (r1, g1, b1, 1);
1110 c[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
1115 /* handle odd width */
1117 RGB_IN (r, g, b, p);
1118 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1119 c[1] = RGB_TO_U_CCIR (r, g, b, 0);
1120 c[0] = RGB_TO_V_CCIR (r, g, b, 0);
1125 static void glue (RGB_NAME, _to_gray) (AVPicture * dst, const AVPicture * src,
1126 int width, int height)
1128 const unsigned char *p;
1130 int r, g, b, dst_wrap, src_wrap;
1134 src_wrap = src->linesize[0] - BPP * width;
1137 dst_wrap = dst->linesize[0] - width;
1139 for (y = 0; y < height; y++) {
1140 for (x = 0; x < width; x++) {
1141 RGB_IN (r, g, b, p);
1142 q[0] = RGB_TO_Y (r, g, b);
1151 static void glue (RGB_NAME, _to_y800) (AVPicture * dst, const AVPicture * src,
1152 int width, int height)
1154 const unsigned char *p;
1156 int r, g, b, dst_wrap, src_wrap;
1160 src_wrap = src->linesize[0] - BPP * width;
1163 dst_wrap = dst->linesize[0] - width;
1165 for (y = 0; y < height; y++) {
1166 for (x = 0; x < width; x++) {
1167 RGB_IN (r, g, b, p);
1168 q[0] = RGB_TO_Y_CCIR (r, g, b);
1177 static void glue (RGB_NAME, _to_y16) (AVPicture * dst,
1178 const AVPicture * src, int width, int height)
1180 const unsigned char *p;
1182 int r, g, b, dst_wrap, src_wrap;
1186 src_wrap = src->linesize[0] - BPP * width;
1189 dst_wrap = dst->linesize[0] - 2 * width;
1191 for (y = 0; y < height; y++) {
1192 for (x = 0; x < width; x++) {
1193 RGB_IN (r, g, b, p);
1194 GST_WRITE_UINT16_LE (q, RGB_TO_Y_CCIR (r, g, b) << 8);
1203 static void glue (gray_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
1204 int width, int height)
1206 const unsigned char *p;
1208 int r, dst_wrap, src_wrap;
1212 src_wrap = src->linesize[0] - width;
1215 dst_wrap = dst->linesize[0] - BPP * width;
1217 for (y = 0; y < height; y++) {
1218 for (x = 0; x < width; x++) {
1220 RGB_OUT (q, r, r, r);
1229 static void glue (RGB_NAME, _to_gray16_l) (AVPicture * dst,
1230 const AVPicture * src, int width, int height)
1232 const unsigned char *p;
1234 int r, g, b, dst_wrap, src_wrap;
1238 src_wrap = src->linesize[0] - BPP * width;
1241 dst_wrap = dst->linesize[0] - 2 * width;
1243 for (y = 0; y < height; y++) {
1244 for (x = 0; x < width; x++) {
1245 RGB_IN (r, g, b, p);
1246 GST_WRITE_UINT16_LE (q, RGB_TO_Y (r, g, b) << 8);
1255 static void glue (gray16_l_to_, RGB_NAME) (AVPicture * dst,
1256 const AVPicture * src, int width, int height)
1258 const unsigned char *p;
1260 int r, dst_wrap, src_wrap;
1264 src_wrap = src->linesize[0] - 2 * width;
1267 dst_wrap = dst->linesize[0] - BPP * width;
1269 for (y = 0; y < height; y++) {
1270 for (x = 0; x < width; x++) {
1271 r = GST_READ_UINT16_LE (p) >> 8;
1272 RGB_OUT (q, r, r, r);
1281 static void glue (RGB_NAME, _to_gray16_b) (AVPicture * dst,
1282 const AVPicture * src, int width, int height)
1284 const unsigned char *p;
1286 int r, g, b, dst_wrap, src_wrap;
1290 src_wrap = src->linesize[0] - BPP * width;
1293 dst_wrap = dst->linesize[0] - 2 * width;
1295 for (y = 0; y < height; y++) {
1296 for (x = 0; x < width; x++) {
1297 RGB_IN (r, g, b, p);
1298 GST_WRITE_UINT16_BE (q, RGB_TO_Y (r, g, b) << 8);
1307 static void glue (gray16_b_to_, RGB_NAME) (AVPicture * dst,
1308 const AVPicture * src, int width, int height)
1310 const unsigned char *p;
1312 int r, dst_wrap, src_wrap;
1316 src_wrap = src->linesize[0] - 2 * width;
1319 dst_wrap = dst->linesize[0] - BPP * width;
1321 for (y = 0; y < height; y++) {
1322 for (x = 0; x < width; x++) {
1323 r = GST_READ_UINT16_BE (p) >> 8;
1324 RGB_OUT (q, r, r, r);
1333 static void glue (pal8_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
1334 int width, int height)
1336 const unsigned char *p;
1338 int r, g, b, dst_wrap, src_wrap;
1341 const uint32_t *palette;
1344 src_wrap = src->linesize[0] - width;
1345 palette = (uint32_t *) src->data[1];
1348 dst_wrap = dst->linesize[0] - BPP * width;
1350 for (y = 0; y < height; y++) {
1351 for (x = 0; x < width; x++) {
1353 r = (v >> 16) & 0xff;
1354 g = (v >> 8) & 0xff;
1359 a = (v >> 24) & 0xff;
1360 RGBA_OUT (q, r, g, b, a);
1363 RGB_OUT (q, r, g, b);
1373 #if !defined(FMT_RGBA32) && defined(RGBA_OUT)
1376 static void glue (rgba32_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
1377 int width, int height)
1381 int src_wrap, dst_wrap, j, y;
1382 unsigned int v, r, g, b, a;
1385 src_wrap = src->linesize[0] - width * 4;
1388 dst_wrap = dst->linesize[0] - width * BPP;
1390 for (y = 0; y < height; y++) {
1391 for (j = 0; j < width; j++) {
1392 v = ((const uint32_t *) (s))[0];
1393 a = (v >> 24) & 0xff;
1394 r = (v >> 16) & 0xff;
1395 g = (v >> 8) & 0xff;
1397 RGBA_OUT (d, r, g, b, a);
1406 static void glue (RGB_NAME, _to_rgba32) (AVPicture * dst, const AVPicture * src,
1407 int width, int height)
1411 int src_wrap, dst_wrap, j, y;
1412 unsigned int r, g, b, a;
1415 src_wrap = src->linesize[0] - width * BPP;
1418 dst_wrap = dst->linesize[0] - width * 4;
1420 for (y = 0; y < height; y++) {
1421 for (j = 0; j < width; j++) {
1422 RGBA_IN (r, g, b, a, s);
1423 ((uint32_t *) (d))[0] = (a << 24) | (r << 16) | (g << 8) | b;
1431 #endif /* !defined(FMT_RGBA32) && defined(RGBA_OUT) */
1433 #if defined(FMT_RGBA32)
1435 #if !defined(rgba32_fcts_done)
1436 #define rgba32_fcts_done
1439 ayuv4444_to_rgba32 (AVPicture * dst, const AVPicture * src,
1440 int width, int height)
1442 uint8_t *s, *d, *d1, *s1;
1443 int w, y, cb, cr, r_add, g_add, b_add;
1444 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1445 unsigned int r, g, b, a;
1449 for (; height > 0; height--) {
1452 for (w = width; w > 0; w--) {
1454 YUV_TO_RGB1_CCIR (s1[2], s1[3]);
1456 YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
1457 RGBA_OUT (d1, r, g, b, a);
1461 d += dst->linesize[0];
1462 s += src->linesize[0];
1467 rgba32_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
1468 int width, int height)
1470 int src_wrap, dst_wrap, x, y;
1475 src_wrap = src->linesize[0] - width * BPP;
1476 dst_wrap = dst->linesize[0] - width * 4;
1479 for (y = 0; y < height; y++) {
1480 for (x = 0; x < width; x++) {
1481 RGBA_IN (r, g, b, a, p);
1483 d[1] = RGB_TO_Y_CCIR (r, g, b);
1484 d[2] = RGB_TO_U_CCIR (r, g, b, 0);
1485 d[3] = RGB_TO_V_CCIR (r, g, b, 0);
1494 #endif /* !defined(rgba32_fcts_done) */
1496 #endif /* defined(FMT_RGBA32) */
1498 #if defined(FMT_BGRA32)
1499 #if !defined(bgra32_fcts_done)
1500 #define bgra32_fcts_done
1503 bgra32_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
1504 int width, int height)
1506 int src_wrap, dst_wrap, x, y;
1511 src_wrap = src->linesize[0] - width * BPP;
1512 dst_wrap = dst->linesize[0] - width * 4;
1515 for (y = 0; y < height; y++) {
1516 for (x = 0; x < width; x++) {
1517 RGBA_IN (r, g, b, a, p);
1519 d[1] = RGB_TO_Y_CCIR (r, g, b);
1520 d[2] = RGB_TO_U_CCIR (r, g, b, 0);
1521 d[3] = RGB_TO_V_CCIR (r, g, b, 0);
1531 ayuv4444_to_bgra32 (AVPicture * dst, const AVPicture * src,
1532 int width, int height)
1534 uint8_t *s, *d, *d1, *s1;
1535 int w, y, cb, cr, r_add, g_add, b_add;
1536 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1537 unsigned int r, g, b, a;
1541 for (; height > 0; height--) {
1544 for (w = width; w > 0; w--) {
1546 YUV_TO_RGB1_CCIR (s1[2], s1[3]);
1548 YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
1549 RGBA_OUT (d1, r, g, b, a);
1553 d += dst->linesize[0];
1554 s += src->linesize[0];
1558 #endif /* !defined(bgra32_fcts_done) */
1560 #endif /* defined(FMT_BGRA32) */
1562 #if defined(FMT_ARGB32)
1564 #if !defined(argb32_fcts_done)
1565 #define argb32_fcts_done
1568 ayuv4444_to_argb32 (AVPicture * dst, const AVPicture * src,
1569 int width, int height)
1571 uint8_t *s, *d, *d1, *s1;
1572 int w, y, cb, cr, r_add, g_add, b_add;
1573 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1574 unsigned int r, g, b, a;
1578 for (; height > 0; height--) {
1581 for (w = width; w > 0; w--) {
1583 YUV_TO_RGB1_CCIR (s1[2], s1[3]);
1585 YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
1586 RGBA_OUT (d1, r, g, b, a);
1590 d += dst->linesize[0];
1591 s += src->linesize[0];
1596 argb32_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
1597 int width, int height)
1599 int src_wrap, dst_wrap, x, y;
1604 src_wrap = src->linesize[0] - width * BPP;
1605 dst_wrap = dst->linesize[0] - width * 4;
1608 for (y = 0; y < height; y++) {
1609 for (x = 0; x < width; x++) {
1610 RGBA_IN (r, g, b, a, p);
1612 d[1] = RGB_TO_Y_CCIR (r, g, b);
1613 d[2] = RGB_TO_U_CCIR (r, g, b, 0);
1614 d[3] = RGB_TO_V_CCIR (r, g, b, 0);
1623 #endif /* !defined(argb32_fcts_done) */
1625 #endif /* defined(FMT_ARGB32) */
1627 #if defined(FMT_ABGR32)
1628 #if !defined(abgr32_fcts_done)
1629 #define abgr32_fcts_done
1632 abgr32_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
1633 int width, int height)
1635 int src_wrap, dst_wrap, x, y;
1640 src_wrap = src->linesize[0] - width * BPP;
1641 dst_wrap = dst->linesize[0] - width * 4;
1644 for (y = 0; y < height; y++) {
1645 for (x = 0; x < width; x++) {
1646 RGBA_IN (r, g, b, a, p);
1648 d[1] = RGB_TO_Y_CCIR (r, g, b);
1649 d[2] = RGB_TO_U_CCIR (r, g, b, 0);
1650 d[3] = RGB_TO_V_CCIR (r, g, b, 0);
1660 ayuv4444_to_abgr32 (AVPicture * dst, const AVPicture * src,
1661 int width, int height)
1663 uint8_t *s, *d, *d1, *s1;
1664 int w, y, cb, cr, r_add, g_add, b_add;
1665 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1666 unsigned int r, g, b, a;
1670 for (; height > 0; height--) {
1673 for (w = width; w > 0; w--) {
1675 YUV_TO_RGB1_CCIR (s1[2], s1[3]);
1677 YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
1678 RGBA_OUT (d1, r, g, b, a);
1682 d += dst->linesize[0];
1683 s += src->linesize[0];
1687 #endif /* !defined(abgr32_fcts_done) */
1689 #endif /* defined(FMT_ABGR32) */
1693 static void glue (rgb24_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
1694 int width, int height)
1698 int src_wrap, dst_wrap, j, y;
1699 unsigned int r, g, b;
1702 src_wrap = src->linesize[0] - width * 3;
1705 dst_wrap = dst->linesize[0] - width * BPP;
1707 for (y = 0; y < height; y++) {
1708 for (j = 0; j < width; j++) {
1712 RGB_OUT (d, r, g, b);
1721 static void glue (RGB_NAME, _to_rgb24) (AVPicture * dst, const AVPicture * src,
1722 int width, int height)
1726 int src_wrap, dst_wrap, j, y;
1727 unsigned int r, g, b;
1730 src_wrap = src->linesize[0] - width * BPP;
1733 dst_wrap = dst->linesize[0] - width * 3;
1735 for (y = 0; y < height; y++) {
1736 for (j = 0; j < width; j++) {
1749 #endif /* !FMT_RGB24 */
1754 yuv444p_to_rgb24 (AVPicture * dst, const AVPicture * src, int width, int height)
1756 const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
1758 int w, y, cb, cr, r_add, g_add, b_add;
1759 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1760 unsigned int r, g, b;
1763 y1_ptr = src->data[0];
1764 cb_ptr = src->data[1];
1765 cr_ptr = src->data[2];
1766 for (; height > 0; height--) {
1768 for (w = width; w > 0; w--) {
1769 YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
1771 YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
1772 RGB_OUT (d1, r, g, b);
1779 d += dst->linesize[0];
1780 y1_ptr += src->linesize[0] - width;
1781 cb_ptr += src->linesize[1] - width;
1782 cr_ptr += src->linesize[2] - width;
1787 yuvj444p_to_rgb24 (AVPicture * dst, const AVPicture * src,
1788 int width, int height)
1790 const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
1792 int w, y, cb, cr, r_add, g_add, b_add;
1793 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1794 unsigned int r, g, b;
1797 y1_ptr = src->data[0];
1798 cb_ptr = src->data[1];
1799 cr_ptr = src->data[2];
1800 for (; height > 0; height--) {
1802 for (w = width; w > 0; w--) {
1803 YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
1805 YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
1806 RGB_OUT (d1, r, g, b);
1813 d += dst->linesize[0];
1814 y1_ptr += src->linesize[0] - width;
1815 cb_ptr += src->linesize[1] - width;
1816 cr_ptr += src->linesize[2] - width;
1821 rgb24_to_yuv444p (AVPicture * dst, const AVPicture * src, int width, int height)
1825 uint8_t *lum, *cb, *cr;
1832 src_wrap = src->linesize[0] - width * BPP;
1834 for (y = 0; y < height; y++) {
1835 for (x = 0; x < width; x++) {
1836 RGB_IN (r, g, b, p);
1837 lum[0] = RGB_TO_Y_CCIR (r, g, b);
1838 cb[0] = RGB_TO_U_CCIR (r, g, b, 0);
1839 cr[0] = RGB_TO_V_CCIR (r, g, b, 0);
1846 lum += dst->linesize[0] - width;
1847 cb += dst->linesize[1] - width;
1848 cr += dst->linesize[2] - width;
1853 rgb24_to_yuvj420p (AVPicture * dst, const AVPicture * src,
1854 int width, int height)
1856 int wrap, wrap3, width2;
1857 int r, g, b, r1, g1, b1, w;
1858 uint8_t *lum, *cb, *cr;
1865 width2 = (width + 1) >> 1;
1866 wrap = dst->linesize[0];
1867 wrap3 = src->linesize[0];
1869 for (; height >= 2; height -= 2) {
1870 for (w = width; w >= 2; w -= 2) {
1871 RGB_IN (r, g, b, p);
1875 lum[0] = RGB_TO_Y (r, g, b);
1877 RGB_IN (r, g, b, p + BPP);
1881 lum[1] = RGB_TO_Y (r, g, b);
1885 RGB_IN (r, g, b, p);
1889 lum[0] = RGB_TO_Y (r, g, b);
1891 RGB_IN (r, g, b, p + BPP);
1895 lum[1] = RGB_TO_Y (r, g, b);
1897 cb[0] = RGB_TO_U (r1, g1, b1, 2);
1898 cr[0] = RGB_TO_V (r1, g1, b1, 2);
1902 p += -wrap3 + 2 * BPP;
1906 RGB_IN (r, g, b, p);
1910 lum[0] = RGB_TO_Y (r, g, b);
1913 RGB_IN (r, g, b, p);
1917 lum[0] = RGB_TO_Y (r, g, b);
1918 cb[0] = RGB_TO_U (r1, g1, b1, 1);
1919 cr[0] = RGB_TO_V (r1, g1, b1, 1);
1925 p += wrap3 + (wrap3 - width * BPP);
1926 lum += wrap + (wrap - width);
1927 cb += dst->linesize[1] - width2;
1928 cr += dst->linesize[2] - width2;
1930 /* handle odd height */
1932 for (w = width; w >= 2; w -= 2) {
1933 RGB_IN (r, g, b, p);
1937 lum[0] = RGB_TO_Y (r, g, b);
1939 RGB_IN (r, g, b, p + BPP);
1943 lum[1] = RGB_TO_Y (r, g, b);
1944 cb[0] = RGB_TO_U (r1, g1, b1, 1);
1945 cr[0] = RGB_TO_V (r1, g1, b1, 1);
1952 RGB_IN (r, g, b, p);
1953 lum[0] = RGB_TO_Y (r, g, b);
1954 cb[0] = RGB_TO_U (r, g, b, 0);
1955 cr[0] = RGB_TO_V (r, g, b, 0);
1961 rgb24_to_yuvj444p (AVPicture * dst, const AVPicture * src,
1962 int width, int height)
1966 uint8_t *lum, *cb, *cr;
1973 src_wrap = src->linesize[0] - width * BPP;
1975 for (y = 0; y < height; y++) {
1976 for (x = 0; x < width; x++) {
1977 RGB_IN (r, g, b, p);
1978 lum[0] = RGB_TO_Y (r, g, b);
1979 cb[0] = RGB_TO_U (r, g, b, 0);
1980 cr[0] = RGB_TO_V (r, g, b, 0);
1987 lum += dst->linesize[0] - width;
1988 cb += dst->linesize[1] - width;
1989 cr += dst->linesize[2] - width;
1994 ayuv4444_to_rgb24 (AVPicture * dst, const AVPicture * src,
1995 int width, int height)
1997 uint8_t *s, *d, *d1, *s1;
1998 int w, y, cb, cr, r_add, g_add, b_add;
1999 uint8_t *cm = cropTbl + MAX_NEG_CROP;
2000 unsigned int r, g, b;
2004 for (; height > 0; height--) {
2007 for (w = width; w > 0; w--) {
2008 YUV_TO_RGB1_CCIR (s1[2], s1[3]);
2010 YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
2011 RGB_OUT (d1, r, g, b);
2015 d += dst->linesize[0];
2016 s += src->linesize[0];
2021 rgb24_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
2022 int width, int height)
2024 int src_wrap, dst_wrap, x, y;
2029 src_wrap = src->linesize[0] - width * BPP;
2030 dst_wrap = dst->linesize[0] - width * 4;
2033 for (y = 0; y < height; y++) {
2034 for (x = 0; x < width; x++) {
2035 RGB_IN (r, g, b, p);
2037 d[1] = RGB_TO_Y_CCIR (r, g, b);
2038 d[2] = RGB_TO_U_CCIR (r, g, b, 0);
2039 d[3] = RGB_TO_V_CCIR (r, g, b, 0);
2049 v308_to_rgb24 (AVPicture * dst, const AVPicture * src, int width, int height)
2051 uint8_t *s, *d, *d1, *s1;
2052 int w, y, cb, cr, r_add, g_add, b_add;
2053 uint8_t *cm = cropTbl + MAX_NEG_CROP;
2054 unsigned int r, g, b;
2058 for (; height > 0; height--) {
2061 for (w = width; w > 0; w--) {
2062 YUV_TO_RGB1_CCIR (s1[1], s1[2]);
2064 YUV_TO_RGB2_CCIR (r, g, b, s1[0]);
2065 RGB_OUT (d1, r, g, b);
2069 d += dst->linesize[0];
2070 s += src->linesize[0];
2075 rgb24_to_v308 (AVPicture * dst, const AVPicture * src, int width, int height)
2077 int src_wrap, dst_wrap, x, y;
2082 src_wrap = src->linesize[0] - width * BPP;
2083 dst_wrap = dst->linesize[0] - width * 3;
2086 for (y = 0; y < height; y++) {
2087 for (x = 0; x < width; x++) {
2088 RGB_IN (r, g, b, p);
2089 d[0] = RGB_TO_Y_CCIR (r, g, b);
2090 d[1] = RGB_TO_U_CCIR (r, g, b, 0);
2091 d[2] = RGB_TO_V_CCIR (r, g, b, 0);
2099 #endif /* FMT_RGB24 */
2101 #if defined(FMT_RGB24) || defined(FMT_RGBA32)
2103 static void glue (RGB_NAME, _to_pal8) (AVPicture * dst, const AVPicture * src,
2104 int width, int height)
2106 const unsigned char *p;
2108 int dst_wrap, src_wrap;
2109 int x, y, has_alpha;
2110 unsigned int r, g, b;
2113 src_wrap = src->linesize[0] - BPP * width;
2116 dst_wrap = dst->linesize[0] - width;
2119 for (y = 0; y < height; y++) {
2120 for (x = 0; x < width; x++) {
2124 RGBA_IN (r, g, b, a, p);
2125 /* crude approximation for alpha ! */
2128 q[0] = TRANSP_INDEX;
2130 q[0] = gif_clut_index (r, g, b);
2134 RGB_IN (r, g, b, p);
2135 q[0] = gif_clut_index (r, g, b);
2144 build_rgb_palette (dst->data[1], has_alpha);
2147 #endif /* defined(FMT_RGB24) || defined(FMT_RGBA32) */
2151 static int glue (get_alpha_info_, RGB_NAME) (const AVPicture * src,
2152 int width, int height)
2154 const unsigned char *p;
2155 int src_wrap, ret, x, y;
2156 unsigned int G_GNUC_UNUSED r, G_GNUC_UNUSED g, G_GNUC_UNUSED b, a;
2159 src_wrap = src->linesize[0] - BPP * width;
2161 for (y = 0; y < height; y++) {
2162 for (x = 0; x < width; x++) {
2163 RGBA_IN (r, g, b, a, p);
2165 ret |= FF_ALPHA_TRANSP;
2166 } else if (a != 0xff) {
2167 ret |= FF_ALPHA_SEMI_TRANSP;
2176 #endif /* RGBA_IN */