spelling
[libav.git] / libavcodec / imgconvert_template.h
1 /*
2 * templates for image conversion routines
3 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /* This header intentionally has no multiple inclusion guards. It is meant to
23 * be included multiple times and generates different code depending on the
24 * value of certain #defines. */
25
26 #ifndef RGB_OUT
27 #define RGB_OUT(d, r, g, b) RGBA_OUT(d, r, g, b, 0xff)
28 #endif
29
30 static void glue(yuv420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
31 int width, int height)
32 {
33 const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
34 uint8_t *d, *d1, *d2;
35 int w, y, cb, cr, r_add, g_add, b_add, width2;
36 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
37 unsigned int r, g, b;
38
39 d = dst->data[0];
40 y1_ptr = src->data[0];
41 cb_ptr = src->data[1];
42 cr_ptr = src->data[2];
43 width2 = (width + 1) >> 1;
44 for(;height >= 2; height -= 2) {
45 d1 = d;
46 d2 = d + dst->linesize[0];
47 y2_ptr = y1_ptr + src->linesize[0];
48 for(w = width; w >= 2; w -= 2) {
49 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
50 /* output 4 pixels */
51 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
52 RGB_OUT(d1, r, g, b);
53
54 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]);
55 RGB_OUT(d1 + BPP, r, g, b);
56
57 YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]);
58 RGB_OUT(d2, r, g, b);
59
60 YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[1]);
61 RGB_OUT(d2 + BPP, r, g, b);
62
63 d1 += 2 * BPP;
64 d2 += 2 * BPP;
65
66 y1_ptr += 2;
67 y2_ptr += 2;
68 cb_ptr++;
69 cr_ptr++;
70 }
71 /* handle odd width */
72 if (w) {
73 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
74 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
75 RGB_OUT(d1, r, g, b);
76
77 YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]);
78 RGB_OUT(d2, r, g, b);
79 d1 += BPP;
80 d2 += BPP;
81 y1_ptr++;
82 y2_ptr++;
83 cb_ptr++;
84 cr_ptr++;
85 }
86 d += 2 * dst->linesize[0];
87 y1_ptr += 2 * src->linesize[0] - width;
88 cb_ptr += src->linesize[1] - width2;
89 cr_ptr += src->linesize[2] - width2;
90 }
91 /* handle odd height */
92 if (height) {
93 d1 = d;
94 for(w = width; w >= 2; w -= 2) {
95 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
96 /* output 2 pixels */
97 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
98 RGB_OUT(d1, r, g, b);
99
100 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]);
101 RGB_OUT(d1 + BPP, r, g, b);
102
103 d1 += 2 * BPP;
104
105 y1_ptr += 2;
106 cb_ptr++;
107 cr_ptr++;
108 }
109 /* handle width */
110 if (w) {
111 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
112 /* output 2 pixels */
113 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
114 RGB_OUT(d1, r, g, b);
115 d1 += BPP;
116
117 y1_ptr++;
118 cb_ptr++;
119 cr_ptr++;
120 }
121 }
122 }
123
124 static void glue(yuvj420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
125 int width, int height)
126 {
127 const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
128 uint8_t *d, *d1, *d2;
129 int w, y, cb, cr, r_add, g_add, b_add, width2;
130 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
131 unsigned int r, g, b;
132
133 d = dst->data[0];
134 y1_ptr = src->data[0];
135 cb_ptr = src->data[1];
136 cr_ptr = src->data[2];
137 width2 = (width + 1) >> 1;
138 for(;height >= 2; height -= 2) {
139 d1 = d;
140 d2 = d + dst->linesize[0];
141 y2_ptr = y1_ptr + src->linesize[0];
142 for(w = width; w >= 2; w -= 2) {
143 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
144 /* output 4 pixels */
145 YUV_TO_RGB2(r, g, b, y1_ptr[0]);
146 RGB_OUT(d1, r, g, b);
147
148 YUV_TO_RGB2(r, g, b, y1_ptr[1]);
149 RGB_OUT(d1 + BPP, r, g, b);
150
151 YUV_TO_RGB2(r, g, b, y2_ptr[0]);
152 RGB_OUT(d2, r, g, b);
153
154 YUV_TO_RGB2(r, g, b, y2_ptr[1]);
155 RGB_OUT(d2 + BPP, r, g, b);
156
157 d1 += 2 * BPP;
158 d2 += 2 * BPP;
159
160 y1_ptr += 2;
161 y2_ptr += 2;
162 cb_ptr++;
163 cr_ptr++;
164 }
165 /* handle odd width */
166 if (w) {
167 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
168 YUV_TO_RGB2(r, g, b, y1_ptr[0]);
169 RGB_OUT(d1, r, g, b);
170
171 YUV_TO_RGB2(r, g, b, y2_ptr[0]);
172 RGB_OUT(d2, r, g, b);
173 d1 += BPP;
174 d2 += BPP;
175 y1_ptr++;
176 y2_ptr++;
177 cb_ptr++;
178 cr_ptr++;
179 }
180 d += 2 * dst->linesize[0];
181 y1_ptr += 2 * src->linesize[0] - width;
182 cb_ptr += src->linesize[1] - width2;
183 cr_ptr += src->linesize[2] - width2;
184 }
185 /* handle odd height */
186 if (height) {
187 d1 = d;
188 for(w = width; w >= 2; w -= 2) {
189 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
190 /* output 2 pixels */
191 YUV_TO_RGB2(r, g, b, y1_ptr[0]);
192 RGB_OUT(d1, r, g, b);
193
194 YUV_TO_RGB2(r, g, b, y1_ptr[1]);
195 RGB_OUT(d1 + BPP, r, g, b);
196
197 d1 += 2 * BPP;
198
199 y1_ptr += 2;
200 cb_ptr++;
201 cr_ptr++;
202 }
203 /* handle width */
204 if (w) {
205 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
206 /* output 2 pixels */
207 YUV_TO_RGB2(r, g, b, y1_ptr[0]);
208 RGB_OUT(d1, r, g, b);
209 d1 += BPP;
210
211 y1_ptr++;
212 cb_ptr++;
213 cr_ptr++;
214 }
215 }
216 }
217
218 static void glue(RGB_NAME, _to_yuv420p)(AVPicture *dst, const AVPicture *src,
219 int width, int height)
220 {
221 int wrap, wrap3, width2;
222 int r, g, b, r1, g1, b1, w;
223 uint8_t *lum, *cb, *cr;
224 const uint8_t *p;
225
226 lum = dst->data[0];
227 cb = dst->data[1];
228 cr = dst->data[2];
229
230 width2 = (width + 1) >> 1;
231 wrap = dst->linesize[0];
232 wrap3 = src->linesize[0];
233 p = src->data[0];
234 for(;height>=2;height -= 2) {
235 for(w = width; w >= 2; w -= 2) {
236 RGB_IN(r, g, b, p);
237 r1 = r;
238 g1 = g;
239 b1 = b;
240 lum[0] = RGB_TO_Y_CCIR(r, g, b);
241
242 RGB_IN(r, g, b, p + BPP);
243 r1 += r;
244 g1 += g;
245 b1 += b;
246 lum[1] = RGB_TO_Y_CCIR(r, g, b);
247 p += wrap3;
248 lum += wrap;
249
250 RGB_IN(r, g, b, p);
251 r1 += r;
252 g1 += g;
253 b1 += b;
254 lum[0] = RGB_TO_Y_CCIR(r, g, b);
255
256 RGB_IN(r, g, b, p + BPP);
257 r1 += r;
258 g1 += g;
259 b1 += b;
260 lum[1] = RGB_TO_Y_CCIR(r, g, b);
261
262 cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 2);
263 cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 2);
264
265 cb++;
266 cr++;
267 p += -wrap3 + 2 * BPP;
268 lum += -wrap + 2;
269 }
270 if (w) {
271 RGB_IN(r, g, b, p);
272 r1 = r;
273 g1 = g;
274 b1 = b;
275 lum[0] = RGB_TO_Y_CCIR(r, g, b);
276 p += wrap3;
277 lum += wrap;
278 RGB_IN(r, g, b, p);
279 r1 += r;
280 g1 += g;
281 b1 += b;
282 lum[0] = RGB_TO_Y_CCIR(r, g, b);
283 cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1);
284 cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1);
285 cb++;
286 cr++;
287 p += -wrap3 + BPP;
288 lum += -wrap + 1;
289 }
290 p += wrap3 + (wrap3 - width * BPP);
291 lum += wrap + (wrap - width);
292 cb += dst->linesize[1] - width2;
293 cr += dst->linesize[2] - width2;
294 }
295 /* handle odd height */
296 if (height) {
297 for(w = width; w >= 2; w -= 2) {
298 RGB_IN(r, g, b, p);
299 r1 = r;
300 g1 = g;
301 b1 = b;
302 lum[0] = RGB_TO_Y_CCIR(r, g, b);
303
304 RGB_IN(r, g, b, p + BPP);
305 r1 += r;
306 g1 += g;
307 b1 += b;
308 lum[1] = RGB_TO_Y_CCIR(r, g, b);
309 cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1);
310 cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1);
311 cb++;
312 cr++;
313 p += 2 * BPP;
314 lum += 2;
315 }
316 if (w) {
317 RGB_IN(r, g, b, p);
318 lum[0] = RGB_TO_Y_CCIR(r, g, b);
319 cb[0] = RGB_TO_U_CCIR(r, g, b, 0);
320 cr[0] = RGB_TO_V_CCIR(r, g, b, 0);
321 }
322 }
323 }
324
325 static void glue(RGB_NAME, _to_gray)(AVPicture *dst, const AVPicture *src,
326 int width, int height)
327 {
328 const unsigned char *p;
329 unsigned char *q;
330 int r, g, b, dst_wrap, src_wrap;
331 int x, y;
332
333 p = src->data[0];
334 src_wrap = src->linesize[0] - BPP * width;
335
336 q = dst->data[0];
337 dst_wrap = dst->linesize[0] - width;
338
339 for(y=0;y<height;y++) {
340 for(x=0;x<width;x++) {
341 RGB_IN(r, g, b, p);
342 q[0] = RGB_TO_Y(r, g, b);
343 q++;
344 p += BPP;
345 }
346 p += src_wrap;
347 q += dst_wrap;
348 }
349 }
350
351 static void glue(gray_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
352 int width, int height)
353 {
354 const unsigned char *p;
355 unsigned char *q;
356 int r, dst_wrap, src_wrap;
357 int x, y;
358
359 p = src->data[0];
360 src_wrap = src->linesize[0] - width;
361
362 q = dst->data[0];
363 dst_wrap = dst->linesize[0] - BPP * width;
364
365 for(y=0;y<height;y++) {
366 for(x=0;x<width;x++) {
367 r = p[0];
368 RGB_OUT(q, r, r, r);
369 q += BPP;
370 p ++;
371 }
372 p += src_wrap;
373 q += dst_wrap;
374 }
375 }
376
377 static void glue(pal8_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
378 int width, int height)
379 {
380 const unsigned char *p;
381 unsigned char *q;
382 int r, g, b, dst_wrap, src_wrap;
383 int x, y;
384 uint32_t v;
385 const uint32_t *palette;
386
387 p = src->data[0];
388 src_wrap = src->linesize[0] - width;
389 palette = (uint32_t *)src->data[1];
390
391 q = dst->data[0];
392 dst_wrap = dst->linesize[0] - BPP * width;
393
394 for(y=0;y<height;y++) {
395 for(x=0;x<width;x++) {
396 v = palette[p[0]];
397 r = (v >> 16) & 0xff;
398 g = (v >> 8) & 0xff;
399 b = (v) & 0xff;
400 #ifdef RGBA_OUT
401 {
402 int a;
403 a = (v >> 24) & 0xff;
404 RGBA_OUT(q, r, g, b, a);
405 }
406 #else
407 RGB_OUT(q, r, g, b);
408 #endif
409 q += BPP;
410 p ++;
411 }
412 p += src_wrap;
413 q += dst_wrap;
414 }
415 }
416
417 // RGB24 has optimized routines
418 #if !defined(FMT_RGB32) && !defined(FMT_RGB24)
419 /* alpha support */
420
421 static void glue(rgb32_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
422 int width, int height)
423 {
424 const uint8_t *s;
425 uint8_t *d;
426 int src_wrap, dst_wrap, j, y;
427 unsigned int v, r, g, b;
428 #ifdef RGBA_OUT
429 unsigned int a;
430 #endif
431
432 s = src->data[0];
433 src_wrap = src->linesize[0] - width * 4;
434
435 d = dst->data[0];
436 dst_wrap = dst->linesize[0] - width * BPP;
437
438 for(y=0;y<height;y++) {
439 for(j = 0;j < width; j++) {
440 v = ((const uint32_t *)(s))[0];
441 r = (v >> 16) & 0xff;
442 g = (v >> 8) & 0xff;
443 b = v & 0xff;
444 #ifdef RGBA_OUT
445 a = (v >> 24) & 0xff;
446 RGBA_OUT(d, r, g, b, a);
447 #else
448 RGB_OUT(d, r, g, b);
449 #endif
450 s += 4;
451 d += BPP;
452 }
453 s += src_wrap;
454 d += dst_wrap;
455 }
456 }
457
458 static void glue(RGB_NAME, _to_rgb32)(AVPicture *dst, const AVPicture *src,
459 int width, int height)
460 {
461 const uint8_t *s;
462 uint8_t *d;
463 int src_wrap, dst_wrap, j, y;
464 unsigned int r, g, b;
465 #ifdef RGBA_IN
466 unsigned int a;
467 #endif
468
469 s = src->data[0];
470 src_wrap = src->linesize[0] - width * BPP;
471
472 d = dst->data[0];
473 dst_wrap = dst->linesize[0] - width * 4;
474
475 for(y=0;y<height;y++) {
476 for(j = 0;j < width; j++) {
477 #ifdef RGBA_IN
478 RGBA_IN(r, g, b, a, s);
479 ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;
480 #else
481 RGB_IN(r, g, b, s);
482 ((uint32_t *)(d))[0] = (0xff << 24) | (r << 16) | (g << 8) | b;
483 #endif
484 d += 4;
485 s += BPP;
486 }
487 s += src_wrap;
488 d += dst_wrap;
489 }
490 }
491
492 #endif /* !defined(FMT_RGB32) */
493
494 #ifndef FMT_RGB24
495
496 static void glue(rgb24_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
497 int width, int height)
498 {
499 const uint8_t *s;
500 uint8_t *d;
501 int src_wrap, dst_wrap, j, y;
502 unsigned int r, g, b;
503
504 s = src->data[0];
505 src_wrap = src->linesize[0] - width * 3;
506
507 d = dst->data[0];
508 dst_wrap = dst->linesize[0] - width * BPP;
509
510 for(y=0;y<height;y++) {
511 for(j = 0;j < width; j++) {
512 r = s[0];
513 g = s[1];
514 b = s[2];
515 RGB_OUT(d, r, g, b);
516 s += 3;
517 d += BPP;
518 }
519 s += src_wrap;
520 d += dst_wrap;
521 }
522 }
523
524 static void glue(RGB_NAME, _to_rgb24)(AVPicture *dst, const AVPicture *src,
525 int width, int height)
526 {
527 const uint8_t *s;
528 uint8_t *d;
529 int src_wrap, dst_wrap, j, y;
530 unsigned int r, g , b;
531
532 s = src->data[0];
533 src_wrap = src->linesize[0] - width * BPP;
534
535 d = dst->data[0];
536 dst_wrap = dst->linesize[0] - width * 3;
537
538 for(y=0;y<height;y++) {
539 for(j = 0;j < width; j++) {
540 RGB_IN(r, g, b, s)
541 d[0] = r;
542 d[1] = g;
543 d[2] = b;
544 d += 3;
545 s += BPP;
546 }
547 s += src_wrap;
548 d += dst_wrap;
549 }
550 }
551
552 #endif /* !FMT_RGB24 */
553
554 #ifdef FMT_RGB24
555
556 static void yuv444p_to_rgb24(AVPicture *dst, const AVPicture *src,
557 int width, int height)
558 {
559 const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
560 uint8_t *d, *d1;
561 int w, y, cb, cr, r_add, g_add, b_add;
562 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
563 unsigned int r, g, b;
564
565 d = dst->data[0];
566 y1_ptr = src->data[0];
567 cb_ptr = src->data[1];
568 cr_ptr = src->data[2];
569 for(;height > 0; height --) {
570 d1 = d;
571 for(w = width; w > 0; w--) {
572 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
573
574 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
575 RGB_OUT(d1, r, g, b);
576 d1 += BPP;
577
578 y1_ptr++;
579 cb_ptr++;
580 cr_ptr++;
581 }
582 d += dst->linesize[0];
583 y1_ptr += src->linesize[0] - width;
584 cb_ptr += src->linesize[1] - width;
585 cr_ptr += src->linesize[2] - width;
586 }
587 }
588
589 static void yuvj444p_to_rgb24(AVPicture *dst, const AVPicture *src,
590 int width, int height)
591 {
592 const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
593 uint8_t *d, *d1;
594 int w, y, cb, cr, r_add, g_add, b_add;
595 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
596 unsigned int r, g, b;
597
598 d = dst->data[0];
599 y1_ptr = src->data[0];
600 cb_ptr = src->data[1];
601 cr_ptr = src->data[2];
602 for(;height > 0; height --) {
603 d1 = d;
604 for(w = width; w > 0; w--) {
605 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
606
607 YUV_TO_RGB2(r, g, b, y1_ptr[0]);
608 RGB_OUT(d1, r, g, b);
609 d1 += BPP;
610
611 y1_ptr++;
612 cb_ptr++;
613 cr_ptr++;
614 }
615 d += dst->linesize[0];
616 y1_ptr += src->linesize[0] - width;
617 cb_ptr += src->linesize[1] - width;
618 cr_ptr += src->linesize[2] - width;
619 }
620 }
621
622 static void rgb24_to_yuv444p(AVPicture *dst, const AVPicture *src,
623 int width, int height)
624 {
625 int src_wrap, x, y;
626 int r, g, b;
627 uint8_t *lum, *cb, *cr;
628 const uint8_t *p;
629
630 lum = dst->data[0];
631 cb = dst->data[1];
632 cr = dst->data[2];
633
634 src_wrap = src->linesize[0] - width * BPP;
635 p = src->data[0];
636 for(y=0;y<height;y++) {
637 for(x=0;x<width;x++) {
638 RGB_IN(r, g, b, p);
639 lum[0] = RGB_TO_Y_CCIR(r, g, b);
640 cb[0] = RGB_TO_U_CCIR(r, g, b, 0);
641 cr[0] = RGB_TO_V_CCIR(r, g, b, 0);
642 p += BPP;
643 cb++;
644 cr++;
645 lum++;
646 }
647 p += src_wrap;
648 lum += dst->linesize[0] - width;
649 cb += dst->linesize[1] - width;
650 cr += dst->linesize[2] - width;
651 }
652 }
653
654 static void rgb24_to_yuvj420p(AVPicture *dst, const AVPicture *src,
655 int width, int height)
656 {
657 int wrap, wrap3, width2;
658 int r, g, b, r1, g1, b1, w;
659 uint8_t *lum, *cb, *cr;
660 const uint8_t *p;
661
662 lum = dst->data[0];
663 cb = dst->data[1];
664 cr = dst->data[2];
665
666 width2 = (width + 1) >> 1;
667 wrap = dst->linesize[0];
668 wrap3 = src->linesize[0];
669 p = src->data[0];
670 for(;height>=2;height -= 2) {
671 for(w = width; w >= 2; w -= 2) {
672 RGB_IN(r, g, b, p);
673 r1 = r;
674 g1 = g;
675 b1 = b;
676 lum[0] = RGB_TO_Y(r, g, b);
677
678 RGB_IN(r, g, b, p + BPP);
679 r1 += r;
680 g1 += g;
681 b1 += b;
682 lum[1] = RGB_TO_Y(r, g, b);
683 p += wrap3;
684 lum += wrap;
685
686 RGB_IN(r, g, b, p);
687 r1 += r;
688 g1 += g;
689 b1 += b;
690 lum[0] = RGB_TO_Y(r, g, b);
691
692 RGB_IN(r, g, b, p + BPP);
693 r1 += r;
694 g1 += g;
695 b1 += b;
696 lum[1] = RGB_TO_Y(r, g, b);
697
698 cb[0] = RGB_TO_U(r1, g1, b1, 2);
699 cr[0] = RGB_TO_V(r1, g1, b1, 2);
700
701 cb++;
702 cr++;
703 p += -wrap3 + 2 * BPP;
704 lum += -wrap + 2;
705 }
706 if (w) {
707 RGB_IN(r, g, b, p);
708 r1 = r;
709 g1 = g;
710 b1 = b;
711 lum[0] = RGB_TO_Y(r, g, b);
712 p += wrap3;
713 lum += wrap;
714 RGB_IN(r, g, b, p);
715 r1 += r;
716 g1 += g;
717 b1 += b;
718 lum[0] = RGB_TO_Y(r, g, b);
719 cb[0] = RGB_TO_U(r1, g1, b1, 1);
720 cr[0] = RGB_TO_V(r1, g1, b1, 1);
721 cb++;
722 cr++;
723 p += -wrap3 + BPP;
724 lum += -wrap + 1;
725 }
726 p += wrap3 + (wrap3 - width * BPP);
727 lum += wrap + (wrap - width);
728 cb += dst->linesize[1] - width2;
729 cr += dst->linesize[2] - width2;
730 }
731 /* handle odd height */
732 if (height) {
733 for(w = width; w >= 2; w -= 2) {
734 RGB_IN(r, g, b, p);
735 r1 = r;
736 g1 = g;
737 b1 = b;
738 lum[0] = RGB_TO_Y(r, g, b);
739
740 RGB_IN(r, g, b, p + BPP);
741 r1 += r;
742 g1 += g;
743 b1 += b;
744 lum[1] = RGB_TO_Y(r, g, b);
745 cb[0] = RGB_TO_U(r1, g1, b1, 1);
746 cr[0] = RGB_TO_V(r1, g1, b1, 1);
747 cb++;
748 cr++;
749 p += 2 * BPP;
750 lum += 2;
751 }
752 if (w) {
753 RGB_IN(r, g, b, p);
754 lum[0] = RGB_TO_Y(r, g, b);
755 cb[0] = RGB_TO_U(r, g, b, 0);
756 cr[0] = RGB_TO_V(r, g, b, 0);
757 }
758 }
759 }
760
761 static void rgb24_to_yuvj444p(AVPicture *dst, const AVPicture *src,
762 int width, int height)
763 {
764 int src_wrap, x, y;
765 int r, g, b;
766 uint8_t *lum, *cb, *cr;
767 const uint8_t *p;
768
769 lum = dst->data[0];
770 cb = dst->data[1];
771 cr = dst->data[2];
772
773 src_wrap = src->linesize[0] - width * BPP;
774 p = src->data[0];
775 for(y=0;y<height;y++) {
776 for(x=0;x<width;x++) {
777 RGB_IN(r, g, b, p);
778 lum[0] = RGB_TO_Y(r, g, b);
779 cb[0] = RGB_TO_U(r, g, b, 0);
780 cr[0] = RGB_TO_V(r, g, b, 0);
781 p += BPP;
782 cb++;
783 cr++;
784 lum++;
785 }
786 p += src_wrap;
787 lum += dst->linesize[0] - width;
788 cb += dst->linesize[1] - width;
789 cr += dst->linesize[2] - width;
790 }
791 }
792
793 #endif /* FMT_RGB24 */
794
795 #if defined(FMT_RGB24) || defined(FMT_RGB32)
796
797 static void glue(RGB_NAME, _to_pal8)(AVPicture *dst, const AVPicture *src,
798 int width, int height)
799 {
800 const unsigned char *p;
801 unsigned char *q;
802 int dst_wrap, src_wrap;
803 int x, y, has_alpha;
804 unsigned int r, g, b;
805
806 p = src->data[0];
807 src_wrap = src->linesize[0] - BPP * width;
808
809 q = dst->data[0];
810 dst_wrap = dst->linesize[0] - width;
811 has_alpha = 0;
812
813 for(y=0;y<height;y++) {
814 for(x=0;x<width;x++) {
815 #ifdef RGBA_IN
816 {
817 unsigned int a;
818 RGBA_IN(r, g, b, a, p);
819 /* crude approximation for alpha ! */
820 if (a < 0x80) {
821 has_alpha = 1;
822 q[0] = TRANSP_INDEX;
823 } else {
824 q[0] = gif_clut_index(r, g, b);
825 }
826 }
827 #else
828 RGB_IN(r, g, b, p);
829 q[0] = gif_clut_index(r, g, b);
830 #endif
831 q++;
832 p += BPP;
833 }
834 p += src_wrap;
835 q += dst_wrap;
836 }
837
838 build_rgb_palette(dst->data[1], has_alpha);
839 }
840
841 #endif /* defined(FMT_RGB24) || defined(FMT_RGB32) */
842
843 #ifdef RGBA_IN
844
845 static int glue(get_alpha_info_, RGB_NAME)(const AVPicture *src,
846 int width, int height)
847 {
848 const unsigned char *p;
849 int src_wrap, ret, x, y;
850 unsigned int r, g, b, a;
851
852 p = src->data[0];
853 src_wrap = src->linesize[0] - BPP * width;
854 ret = 0;
855 for(y=0;y<height;y++) {
856 for(x=0;x<width;x++) {
857 RGBA_IN(r, g, b, a, p);
858 if (a == 0x00) {
859 ret |= FF_ALPHA_TRANSP;
860 } else if (a != 0xff) {
861 ret |= FF_ALPHA_SEMI_TRANSP;
862 }
863 p += BPP;
864 }
865 p += src_wrap;
866 }
867 return ret;
868 }
869
870 #endif /* RGBA_IN */
871
872 #undef RGB_IN
873 #undef RGBA_IN
874 #undef RGB_OUT
875 #undef RGBA_OUT
876 #undef BPP
877 #undef RGB_NAME
878 #undef FMT_RGB24
879 #undef FMT_RGB32