2 * Misc image convertion routines
3 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
5 * This file is part of FFmpeg.
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.
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.
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
24 * Misc image convertion routines.
28 * - write 'ffimg' program to test all the image related stuff
29 * - move all api to slice based system
30 * - integrate deinterlacing, postprocessing and scaling in the conversion process
37 #include "libvo/fastmemcpy.h"
44 #define xglue(x, y) x ## y
45 #define glue(x, y) xglue(x, y)
47 #define FF_COLOR_RGB 0 /* RGB color space */
48 #define FF_COLOR_GRAY 1 /* gray color space */
49 #define FF_COLOR_YUV 2 /* YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
50 #define FF_COLOR_YUV_JPEG 3 /* YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
52 #define FF_PIXEL_PLANAR 0 /* each channel has one component in AVPicture */
53 #define FF_PIXEL_PACKED 1 /* only one components containing all the channels */
54 #define FF_PIXEL_PALETTE 2 /* one components containing indexes for a palette */
56 typedef struct PixFmtInfo {
58 uint8_t nb_channels; /* number of channels (including alpha) */
59 uint8_t color_type; /* color type (see FF_COLOR_xxx constants) */
60 uint8_t pixel_type; /* pixel storage type (see FF_PIXEL_xxx constants) */
61 uint8_t is_alpha : 1; /* true if alpha can be specified */
62 uint8_t x_chroma_shift; /* X chroma subsampling factor is 2 ^ shift */
63 uint8_t y_chroma_shift; /* Y chroma subsampling factor is 2 ^ shift */
64 uint8_t depth; /* bit depth of the color components */
67 /* this table gives more information about formats */
68 static const PixFmtInfo pix_fmt_info[PIX_FMT_NB] = {
73 .color_type = FF_COLOR_YUV,
74 .pixel_type = FF_PIXEL_PLANAR,
76 .x_chroma_shift = 1, .y_chroma_shift = 1,
81 .color_type = FF_COLOR_YUV,
82 .pixel_type = FF_PIXEL_PLANAR,
84 .x_chroma_shift = 1, .y_chroma_shift = 0,
89 .color_type = FF_COLOR_YUV,
90 .pixel_type = FF_PIXEL_PLANAR,
92 .x_chroma_shift = 0, .y_chroma_shift = 0,
97 .color_type = FF_COLOR_YUV,
98 .pixel_type = FF_PIXEL_PACKED,
100 .x_chroma_shift = 1, .y_chroma_shift = 0,
102 [PIX_FMT_UYVY422] = {
105 .color_type = FF_COLOR_YUV,
106 .pixel_type = FF_PIXEL_PACKED,
108 .x_chroma_shift = 1, .y_chroma_shift = 0,
110 [PIX_FMT_YUV410P] = {
113 .color_type = FF_COLOR_YUV,
114 .pixel_type = FF_PIXEL_PLANAR,
116 .x_chroma_shift = 2, .y_chroma_shift = 2,
118 [PIX_FMT_YUV411P] = {
121 .color_type = FF_COLOR_YUV,
122 .pixel_type = FF_PIXEL_PLANAR,
124 .x_chroma_shift = 2, .y_chroma_shift = 0,
128 [PIX_FMT_YUVJ420P] = {
131 .color_type = FF_COLOR_YUV_JPEG,
132 .pixel_type = FF_PIXEL_PLANAR,
134 .x_chroma_shift = 1, .y_chroma_shift = 1,
136 [PIX_FMT_YUVJ422P] = {
139 .color_type = FF_COLOR_YUV_JPEG,
140 .pixel_type = FF_PIXEL_PLANAR,
142 .x_chroma_shift = 1, .y_chroma_shift = 0,
144 [PIX_FMT_YUVJ444P] = {
147 .color_type = FF_COLOR_YUV_JPEG,
148 .pixel_type = FF_PIXEL_PLANAR,
150 .x_chroma_shift = 0, .y_chroma_shift = 0,
157 .color_type = FF_COLOR_RGB,
158 .pixel_type = FF_PIXEL_PACKED,
160 .x_chroma_shift = 0, .y_chroma_shift = 0,
165 .color_type = FF_COLOR_RGB,
166 .pixel_type = FF_PIXEL_PACKED,
168 .x_chroma_shift = 0, .y_chroma_shift = 0,
172 .nb_channels = 4, .is_alpha = 1,
173 .color_type = FF_COLOR_RGB,
174 .pixel_type = FF_PIXEL_PACKED,
176 .x_chroma_shift = 0, .y_chroma_shift = 0,
181 .color_type = FF_COLOR_RGB,
182 .pixel_type = FF_PIXEL_PACKED,
184 .x_chroma_shift = 0, .y_chroma_shift = 0,
188 .nb_channels = 4, .is_alpha = 1,
189 .color_type = FF_COLOR_RGB,
190 .pixel_type = FF_PIXEL_PACKED,
192 .x_chroma_shift = 0, .y_chroma_shift = 0,
195 /* gray / mono formats */
199 .color_type = FF_COLOR_GRAY,
200 .pixel_type = FF_PIXEL_PLANAR,
203 [PIX_FMT_MONOWHITE] = {
206 .color_type = FF_COLOR_GRAY,
207 .pixel_type = FF_PIXEL_PLANAR,
210 [PIX_FMT_MONOBLACK] = {
213 .color_type = FF_COLOR_GRAY,
214 .pixel_type = FF_PIXEL_PLANAR,
218 /* paletted formats */
221 .nb_channels = 4, .is_alpha = 1,
222 .color_type = FF_COLOR_RGB,
223 .pixel_type = FF_PIXEL_PALETTE,
226 [PIX_FMT_XVMC_MPEG2_MC] = {
229 [PIX_FMT_XVMC_MPEG2_IDCT] = {
232 [PIX_FMT_UYVY411] = {
235 .color_type = FF_COLOR_YUV,
236 .pixel_type = FF_PIXEL_PACKED,
238 .x_chroma_shift = 2, .y_chroma_shift = 0,
242 .nb_channels = 4, .is_alpha = 1,
243 .color_type = FF_COLOR_RGB,
244 .pixel_type = FF_PIXEL_PACKED,
246 .x_chroma_shift = 0, .y_chroma_shift = 0,
251 .color_type = FF_COLOR_RGB,
252 .pixel_type = FF_PIXEL_PACKED,
254 .x_chroma_shift = 0, .y_chroma_shift = 0,
258 .nb_channels = 4, .is_alpha = 1,
259 .color_type = FF_COLOR_RGB,
260 .pixel_type = FF_PIXEL_PACKED,
262 .x_chroma_shift = 0, .y_chroma_shift = 0,
267 .color_type = FF_COLOR_RGB,
268 .pixel_type = FF_PIXEL_PACKED,
270 .x_chroma_shift = 0, .y_chroma_shift = 0,
275 .color_type = FF_COLOR_RGB,
276 .pixel_type = FF_PIXEL_PACKED,
278 .x_chroma_shift = 0, .y_chroma_shift = 0,
280 [PIX_FMT_RGB4_BYTE] = {
283 .color_type = FF_COLOR_RGB,
284 .pixel_type = FF_PIXEL_PACKED,
286 .x_chroma_shift = 0, .y_chroma_shift = 0,
291 .color_type = FF_COLOR_RGB,
292 .pixel_type = FF_PIXEL_PACKED,
294 .x_chroma_shift = 0, .y_chroma_shift = 0,
299 .color_type = FF_COLOR_RGB,
300 .pixel_type = FF_PIXEL_PACKED,
302 .x_chroma_shift = 0, .y_chroma_shift = 0,
304 [PIX_FMT_BGR4_BYTE] = {
307 .color_type = FF_COLOR_RGB,
308 .pixel_type = FF_PIXEL_PACKED,
310 .x_chroma_shift = 0, .y_chroma_shift = 0,
315 .color_type = FF_COLOR_YUV,
316 .pixel_type = FF_PIXEL_PLANAR,
318 .x_chroma_shift = 1, .y_chroma_shift = 1,
323 .color_type = FF_COLOR_YUV,
324 .pixel_type = FF_PIXEL_PLANAR,
326 .x_chroma_shift = 1, .y_chroma_shift = 1,
329 [PIX_FMT_BGR32_1] = {
331 .nb_channels = 4, .is_alpha = 1,
332 .color_type = FF_COLOR_RGB,
333 .pixel_type = FF_PIXEL_PACKED,
335 .x_chroma_shift = 0, .y_chroma_shift = 0,
337 [PIX_FMT_RGB32_1] = {
339 .nb_channels = 4, .is_alpha = 1,
340 .color_type = FF_COLOR_RGB,
341 .pixel_type = FF_PIXEL_PACKED,
343 .x_chroma_shift = 0, .y_chroma_shift = 0,
347 void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift)
349 *h_shift = pix_fmt_info[pix_fmt].x_chroma_shift;
350 *v_shift = pix_fmt_info[pix_fmt].y_chroma_shift;
353 const char *avcodec_get_pix_fmt_name(int pix_fmt)
355 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB)
358 return pix_fmt_info[pix_fmt].name;
361 enum PixelFormat avcodec_get_pix_fmt(const char* name)
365 for (i=0; i < PIX_FMT_NB; i++)
366 if (!strcmp(pix_fmt_info[i].name, name))
371 /* Picture field are filled with 'ptr' addresses. Also return size */
372 int avpicture_fill(AVPicture *picture, uint8_t *ptr,
373 int pix_fmt, int width, int height)
375 int size, w2, h2, size2;
376 const PixFmtInfo *pinfo;
378 if(avcodec_check_dimensions(NULL, width, height))
381 pinfo = &pix_fmt_info[pix_fmt];
382 size = width * height;
384 case PIX_FMT_YUV420P:
385 case PIX_FMT_YUV422P:
386 case PIX_FMT_YUV444P:
387 case PIX_FMT_YUV410P:
388 case PIX_FMT_YUV411P:
389 case PIX_FMT_YUVJ420P:
390 case PIX_FMT_YUVJ422P:
391 case PIX_FMT_YUVJ444P:
392 w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
393 h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
395 picture->data[0] = ptr;
396 picture->data[1] = picture->data[0] + size;
397 picture->data[2] = picture->data[1] + size2;
398 picture->linesize[0] = width;
399 picture->linesize[1] = w2;
400 picture->linesize[2] = w2;
401 return size + 2 * size2;
404 w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
405 h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
407 picture->data[0] = ptr;
408 picture->data[1] = picture->data[0] + size;
409 picture->data[2] = NULL;
410 picture->linesize[0] = width;
411 picture->linesize[1] = w2;
412 picture->linesize[2] = 0;
413 return size + 2 * size2;
416 picture->data[0] = ptr;
417 picture->data[1] = NULL;
418 picture->data[2] = NULL;
419 picture->linesize[0] = width * 3;
423 case PIX_FMT_RGB32_1:
424 case PIX_FMT_BGR32_1:
425 picture->data[0] = ptr;
426 picture->data[1] = NULL;
427 picture->data[2] = NULL;
428 picture->linesize[0] = width * 4;
435 picture->data[0] = ptr;
436 picture->data[1] = NULL;
437 picture->data[2] = NULL;
438 picture->linesize[0] = width * 2;
440 case PIX_FMT_UYVY422:
441 picture->data[0] = ptr;
442 picture->data[1] = NULL;
443 picture->data[2] = NULL;
444 picture->linesize[0] = width * 2;
446 case PIX_FMT_UYVY411:
447 picture->data[0] = ptr;
448 picture->data[1] = NULL;
449 picture->data[2] = NULL;
450 picture->linesize[0] = width + width/2;
451 return size + size/2;
454 case PIX_FMT_RGB4_BYTE:
455 case PIX_FMT_BGR4_BYTE:
457 picture->data[0] = ptr;
458 picture->data[1] = NULL;
459 picture->data[2] = NULL;
460 picture->linesize[0] = width;
464 picture->data[0] = ptr;
465 picture->data[1] = NULL;
466 picture->data[2] = NULL;
467 picture->linesize[0] = width / 2;
469 case PIX_FMT_MONOWHITE:
470 case PIX_FMT_MONOBLACK:
471 picture->data[0] = ptr;
472 picture->data[1] = NULL;
473 picture->data[2] = NULL;
474 picture->linesize[0] = (width + 7) >> 3;
475 return picture->linesize[0] * height;
477 size2 = (size + 3) & ~3;
478 picture->data[0] = ptr;
479 picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */
480 picture->data[2] = NULL;
481 picture->linesize[0] = width;
482 picture->linesize[1] = 4;
483 return size2 + 256 * 4;
486 picture->data[0] = NULL;
487 picture->data[1] = NULL;
488 picture->data[2] = NULL;
489 picture->data[3] = NULL;
494 int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height,
495 unsigned char *dest, int dest_size)
497 const PixFmtInfo* pf = &pix_fmt_info[pix_fmt];
498 int i, j, w, h, data_planes;
499 const unsigned char* s;
500 int size = avpicture_get_size(pix_fmt, width, height);
502 if (size > dest_size || size < 0)
505 if (pf->pixel_type == FF_PIXEL_PACKED || pf->pixel_type == FF_PIXEL_PALETTE) {
506 if (pix_fmt == PIX_FMT_YUV422 ||
507 pix_fmt == PIX_FMT_UYVY422 ||
508 pix_fmt == PIX_FMT_BGR565 ||
509 pix_fmt == PIX_FMT_BGR565 ||
510 pix_fmt == PIX_FMT_RGB565 ||
511 pix_fmt == PIX_FMT_RGB555)
513 else if (pix_fmt == PIX_FMT_UYVY411)
515 else if (pix_fmt == PIX_FMT_PAL8)
518 w = width * (pf->depth * pf->nb_channels / 8);
523 data_planes = pf->nb_channels;
524 w = (width*pf->depth + 7)/8;
528 for (i=0; i<data_planes; i++) {
530 w = width >> pf->x_chroma_shift;
531 h = height >> pf->y_chroma_shift;
537 s += src->linesize[i];
541 if (pf->pixel_type == FF_PIXEL_PALETTE)
542 memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4);
547 int avpicture_get_size(int pix_fmt, int width, int height)
549 AVPicture dummy_pict;
550 return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);
554 * compute the loss when converting from a pixel format to another
556 int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt,
559 const PixFmtInfo *pf, *ps;
562 ps = &pix_fmt_info[src_pix_fmt];
563 pf = &pix_fmt_info[dst_pix_fmt];
567 pf = &pix_fmt_info[dst_pix_fmt];
568 if (pf->depth < ps->depth ||
569 (dst_pix_fmt == PIX_FMT_RGB555 && src_pix_fmt == PIX_FMT_RGB565))
570 loss |= FF_LOSS_DEPTH;
571 if (pf->x_chroma_shift > ps->x_chroma_shift ||
572 pf->y_chroma_shift > ps->y_chroma_shift)
573 loss |= FF_LOSS_RESOLUTION;
574 switch(pf->color_type) {
576 if (ps->color_type != FF_COLOR_RGB &&
577 ps->color_type != FF_COLOR_GRAY)
578 loss |= FF_LOSS_COLORSPACE;
581 if (ps->color_type != FF_COLOR_GRAY)
582 loss |= FF_LOSS_COLORSPACE;
585 if (ps->color_type != FF_COLOR_YUV)
586 loss |= FF_LOSS_COLORSPACE;
588 case FF_COLOR_YUV_JPEG:
589 if (ps->color_type != FF_COLOR_YUV_JPEG &&
590 ps->color_type != FF_COLOR_YUV &&
591 ps->color_type != FF_COLOR_GRAY)
592 loss |= FF_LOSS_COLORSPACE;
596 if (ps->color_type != pf->color_type)
597 loss |= FF_LOSS_COLORSPACE;
600 if (pf->color_type == FF_COLOR_GRAY &&
601 ps->color_type != FF_COLOR_GRAY)
602 loss |= FF_LOSS_CHROMA;
603 if (!pf->is_alpha && (ps->is_alpha && has_alpha))
604 loss |= FF_LOSS_ALPHA;
605 if (pf->pixel_type == FF_PIXEL_PALETTE &&
606 (ps->pixel_type != FF_PIXEL_PALETTE && ps->color_type != FF_COLOR_GRAY))
607 loss |= FF_LOSS_COLORQUANT;
611 static int avg_bits_per_pixel(int pix_fmt)
614 const PixFmtInfo *pf;
616 pf = &pix_fmt_info[pix_fmt];
617 switch(pf->pixel_type) {
618 case FF_PIXEL_PACKED:
621 case PIX_FMT_UYVY422:
628 case PIX_FMT_UYVY411:
632 bits = pf->depth * pf->nb_channels;
636 case FF_PIXEL_PLANAR:
637 if (pf->x_chroma_shift == 0 && pf->y_chroma_shift == 0) {
638 bits = pf->depth * pf->nb_channels;
640 bits = pf->depth + ((2 * pf->depth) >>
641 (pf->x_chroma_shift + pf->y_chroma_shift));
644 case FF_PIXEL_PALETTE:
654 static int avcodec_find_best_pix_fmt1(int pix_fmt_mask,
659 int dist, i, loss, min_dist, dst_pix_fmt;
661 /* find exact color match with smallest size */
663 min_dist = 0x7fffffff;
664 for(i = 0;i < PIX_FMT_NB; i++) {
665 if (pix_fmt_mask & (1 << i)) {
666 loss = avcodec_get_pix_fmt_loss(i, src_pix_fmt, has_alpha) & loss_mask;
668 dist = avg_bits_per_pixel(i);
669 if (dist < min_dist) {
680 * find best pixel format to convert to. Return -1 if none found
682 int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt,
683 int has_alpha, int *loss_ptr)
685 int dst_pix_fmt, loss_mask, i;
686 static const int loss_mask_order[] = {
687 ~0, /* no loss first */
690 ~(FF_LOSS_COLORSPACE | FF_LOSS_RESOLUTION),
696 /* try with successive loss */
699 loss_mask = loss_mask_order[i++];
700 dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_mask, src_pix_fmt,
701 has_alpha, loss_mask);
702 if (dst_pix_fmt >= 0)
710 *loss_ptr = avcodec_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
714 void ff_img_copy_plane(uint8_t *dst, int dst_wrap,
715 const uint8_t *src, int src_wrap,
716 int width, int height)
720 for(;height > 0; height--) {
721 memcpy(dst, src, width);
728 * Copy image 'src' to 'dst'.
730 void img_copy(AVPicture *dst, const AVPicture *src,
731 int pix_fmt, int width, int height)
734 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
736 pf = &pix_fmt_info[pix_fmt];
737 switch(pf->pixel_type) {
738 case FF_PIXEL_PACKED:
741 case PIX_FMT_UYVY422:
748 case PIX_FMT_UYVY411:
752 bits = pf->depth * pf->nb_channels;
755 bwidth = (width * bits + 7) >> 3;
756 ff_img_copy_plane(dst->data[0], dst->linesize[0],
757 src->data[0], src->linesize[0],
760 case FF_PIXEL_PLANAR:
761 for(i = 0; i < pf->nb_channels; i++) {
765 if (i == 1 || i == 2) {
766 w >>= pf->x_chroma_shift;
767 h >>= pf->y_chroma_shift;
769 bwidth = (w * pf->depth + 7) >> 3;
770 ff_img_copy_plane(dst->data[i], dst->linesize[i],
771 src->data[i], src->linesize[i],
775 case FF_PIXEL_PALETTE:
776 ff_img_copy_plane(dst->data[0], dst->linesize[0],
777 src->data[0], src->linesize[0],
779 /* copy the palette */
780 ff_img_copy_plane(dst->data[1], dst->linesize[1],
781 src->data[1], src->linesize[1],
787 /* XXX: totally non optimized */
789 static void yuv422_to_yuv420p(AVPicture *dst, const AVPicture *src,
790 int width, int height)
792 const uint8_t *p, *p1;
793 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
801 for(;height >= 1; height -= 2) {
806 for(w = width; w >= 2; w -= 2) {
823 p1 += src->linesize[0];
824 lum1 += dst->linesize[0];
828 for(w = width; w >= 2; w -= 2) {
837 p1 += src->linesize[0];
838 lum1 += dst->linesize[0];
840 cb1 += dst->linesize[1];
841 cr1 += dst->linesize[2];
845 static void uyvy422_to_yuv420p(AVPicture *dst, const AVPicture *src,
846 int width, int height)
848 const uint8_t *p, *p1;
849 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
858 for(;height >= 1; height -= 2) {
863 for(w = width; w >= 2; w -= 2) {
880 p1 += src->linesize[0];
881 lum1 += dst->linesize[0];
885 for(w = width; w >= 2; w -= 2) {
894 p1 += src->linesize[0];
895 lum1 += dst->linesize[0];
897 cb1 += dst->linesize[1];
898 cr1 += dst->linesize[2];
903 static void uyvy422_to_yuv422p(AVPicture *dst, const AVPicture *src,
904 int width, int height)
906 const uint8_t *p, *p1;
907 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
914 for(;height > 0; height--) {
919 for(w = width; w >= 2; w -= 2) {
929 p1 += src->linesize[0];
930 lum1 += dst->linesize[0];
931 cb1 += dst->linesize[1];
932 cr1 += dst->linesize[2];
937 static void yuv422_to_yuv422p(AVPicture *dst, const AVPicture *src,
938 int width, int height)
940 const uint8_t *p, *p1;
941 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
948 for(;height > 0; height--) {
953 for(w = width; w >= 2; w -= 2) {
963 p1 += src->linesize[0];
964 lum1 += dst->linesize[0];
965 cb1 += dst->linesize[1];
966 cr1 += dst->linesize[2];
970 static void yuv422p_to_yuv422(AVPicture *dst, const AVPicture *src,
971 int width, int height)
974 const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
981 for(;height > 0; height--) {
986 for(w = width; w >= 2; w -= 2) {
996 p1 += dst->linesize[0];
997 lum1 += src->linesize[0];
998 cb1 += src->linesize[1];
999 cr1 += src->linesize[2];
1003 static void yuv422p_to_uyvy422(AVPicture *dst, const AVPicture *src,
1004 int width, int height)
1007 const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
1011 lum1 = src->data[0];
1014 for(;height > 0; height--) {
1019 for(w = width; w >= 2; w -= 2) {
1029 p1 += dst->linesize[0];
1030 lum1 += src->linesize[0];
1031 cb1 += src->linesize[1];
1032 cr1 += src->linesize[2];
1036 static void uyvy411_to_yuv411p(AVPicture *dst, const AVPicture *src,
1037 int width, int height)
1039 const uint8_t *p, *p1;
1040 uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
1044 lum1 = dst->data[0];
1047 for(;height > 0; height--) {
1052 for(w = width; w >= 4; w -= 4) {
1064 p1 += src->linesize[0];
1065 lum1 += dst->linesize[0];
1066 cb1 += dst->linesize[1];
1067 cr1 += dst->linesize[2];
1072 static void yuv420p_to_yuv422(AVPicture *dst, const AVPicture *src,
1073 int width, int height)
1076 uint8_t *line1, *line2, *linesrc = dst->data[0];
1077 uint8_t *lum1, *lum2, *lumsrc = src->data[0];
1078 uint8_t *cb1, *cb2 = src->data[1];
1079 uint8_t *cr1, *cr2 = src->data[2];
1081 for(h = height / 2; h--;) {
1083 line2 = linesrc + dst->linesize[0];
1086 lum2 = lumsrc + src->linesize[0];
1091 for(w = width / 2; w--;) {
1092 *line1++ = *lum1++; *line2++ = *lum2++;
1093 *line1++ = *line2++ = *cb1++;
1094 *line1++ = *lum1++; *line2++ = *lum2++;
1095 *line1++ = *line2++ = *cr1++;
1098 linesrc += dst->linesize[0] * 2;
1099 lumsrc += src->linesize[0] * 2;
1100 cb2 += src->linesize[1];
1101 cr2 += src->linesize[2];
1105 static void yuv420p_to_uyvy422(AVPicture *dst, const AVPicture *src,
1106 int width, int height)
1109 uint8_t *line1, *line2, *linesrc = dst->data[0];
1110 uint8_t *lum1, *lum2, *lumsrc = src->data[0];
1111 uint8_t *cb1, *cb2 = src->data[1];
1112 uint8_t *cr1, *cr2 = src->data[2];
1114 for(h = height / 2; h--;) {
1116 line2 = linesrc + dst->linesize[0];
1119 lum2 = lumsrc + src->linesize[0];
1124 for(w = width / 2; w--;) {
1125 *line1++ = *line2++ = *cb1++;
1126 *line1++ = *lum1++; *line2++ = *lum2++;
1127 *line1++ = *line2++ = *cr1++;
1128 *line1++ = *lum1++; *line2++ = *lum2++;
1131 linesrc += dst->linesize[0] * 2;
1132 lumsrc += src->linesize[0] * 2;
1133 cb2 += src->linesize[1];
1134 cr2 += src->linesize[2];
1138 #define SCALEBITS 10
1139 #define ONE_HALF (1 << (SCALEBITS - 1))
1140 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
1142 #define YUV_TO_RGB1_CCIR(cb1, cr1)\
1146 r_add = FIX(1.40200*255.0/224.0) * cr + ONE_HALF;\
1147 g_add = - FIX(0.34414*255.0/224.0) * cb - FIX(0.71414*255.0/224.0) * cr + \
1149 b_add = FIX(1.77200*255.0/224.0) * cb + ONE_HALF;\
1152 #define YUV_TO_RGB2_CCIR(r, g, b, y1)\
1154 y = ((y1) - 16) * FIX(255.0/219.0);\
1155 r = cm[(y + r_add) >> SCALEBITS];\
1156 g = cm[(y + g_add) >> SCALEBITS];\
1157 b = cm[(y + b_add) >> SCALEBITS];\
1160 #define YUV_TO_RGB1(cb1, cr1)\
1164 r_add = FIX(1.40200) * cr + ONE_HALF;\
1165 g_add = - FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;\
1166 b_add = FIX(1.77200) * cb + ONE_HALF;\
1169 #define YUV_TO_RGB2(r, g, b, y1)\
1171 y = (y1) << SCALEBITS;\
1172 r = cm[(y + r_add) >> SCALEBITS];\
1173 g = cm[(y + g_add) >> SCALEBITS];\
1174 b = cm[(y + b_add) >> SCALEBITS];\
1177 #define Y_CCIR_TO_JPEG(y)\
1178 cm[((y) * FIX(255.0/219.0) + (ONE_HALF - 16 * FIX(255.0/219.0))) >> SCALEBITS]
1180 #define Y_JPEG_TO_CCIR(y)\
1181 (((y) * FIX(219.0/255.0) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
1183 #define C_CCIR_TO_JPEG(y)\
1184 cm[(((y) - 128) * FIX(127.0/112.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS]
1186 /* NOTE: the clamp is really necessary! */
1187 static inline int C_JPEG_TO_CCIR(int y) {
1188 y = (((y - 128) * FIX(112.0/127.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS);
1195 #define RGB_TO_Y(r, g, b) \
1196 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
1197 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
1199 #define RGB_TO_U(r1, g1, b1, shift)\
1200 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
1201 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
1203 #define RGB_TO_V(r1, g1, b1, shift)\
1204 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
1205 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
1207 #define RGB_TO_Y_CCIR(r, g, b) \
1208 ((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + \
1209 FIX(0.11400*219.0/255.0) * (b) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
1211 #define RGB_TO_U_CCIR(r1, g1, b1, shift)\
1212 (((- FIX(0.16874*224.0/255.0) * r1 - FIX(0.33126*224.0/255.0) * g1 + \
1213 FIX(0.50000*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
1215 #define RGB_TO_V_CCIR(r1, g1, b1, shift)\
1216 (((FIX(0.50000*224.0/255.0) * r1 - FIX(0.41869*224.0/255.0) * g1 - \
1217 FIX(0.08131*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
1219 static uint8_t y_ccir_to_jpeg[256];
1220 static uint8_t y_jpeg_to_ccir[256];
1221 static uint8_t c_ccir_to_jpeg[256];
1222 static uint8_t c_jpeg_to_ccir[256];
1224 /* init various conversion tables */
1225 static void img_convert_init(void)
1228 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1230 for(i = 0;i < 256; i++) {
1231 y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i);
1232 y_jpeg_to_ccir[i] = Y_JPEG_TO_CCIR(i);
1233 c_ccir_to_jpeg[i] = C_CCIR_TO_JPEG(i);
1234 c_jpeg_to_ccir[i] = C_JPEG_TO_CCIR(i);
1238 /* apply to each pixel the given table */
1239 static void img_apply_table(uint8_t *dst, int dst_wrap,
1240 const uint8_t *src, int src_wrap,
1241 int width, int height, const uint8_t *table1)
1246 const uint8_t *table;
1249 for(;height > 0; height--) {
1273 /* XXX: use generic filter ? */
1274 /* XXX: in most cases, the sampling position is incorrect */
1277 static void shrink41(uint8_t *dst, int dst_wrap,
1278 const uint8_t *src, int src_wrap,
1279 int width, int height)
1285 for(;height > 0; height--) {
1288 for(w = width;w > 0; w--) {
1289 d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2;
1299 static void shrink21(uint8_t *dst, int dst_wrap,
1300 const uint8_t *src, int src_wrap,
1301 int width, int height)
1307 for(;height > 0; height--) {
1310 for(w = width;w > 0; w--) {
1311 d[0] = (s[0] + s[1]) >> 1;
1321 static void shrink12(uint8_t *dst, int dst_wrap,
1322 const uint8_t *src, int src_wrap,
1323 int width, int height)
1327 const uint8_t *s1, *s2;
1329 for(;height > 0; height--) {
1333 for(w = width;w >= 4; w-=4) {
1334 d[0] = (s1[0] + s2[0]) >> 1;
1335 d[1] = (s1[1] + s2[1]) >> 1;
1336 d[2] = (s1[2] + s2[2]) >> 1;
1337 d[3] = (s1[3] + s2[3]) >> 1;
1343 d[0] = (s1[0] + s2[0]) >> 1;
1348 src += 2 * src_wrap;
1354 void ff_shrink22(uint8_t *dst, int dst_wrap,
1355 const uint8_t *src, int src_wrap,
1356 int width, int height)
1359 const uint8_t *s1, *s2;
1362 for(;height > 0; height--) {
1366 for(w = width;w >= 4; w-=4) {
1367 d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
1368 d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;
1369 d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;
1370 d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;
1376 d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
1381 src += 2 * src_wrap;
1387 void ff_shrink44(uint8_t *dst, int dst_wrap,
1388 const uint8_t *src, int src_wrap,
1389 int width, int height)
1392 const uint8_t *s1, *s2, *s3, *s4;
1395 for(;height > 0; height--) {
1401 for(w = width;w > 0; w--) {
1402 d[0] = (s1[0] + s1[1] + s1[2] + s1[3] +
1403 s2[0] + s2[1] + s2[2] + s2[3] +
1404 s3[0] + s3[1] + s3[2] + s3[3] +
1405 s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4;
1412 src += 4 * src_wrap;
1418 void ff_shrink88(uint8_t *dst, int dst_wrap,
1419 const uint8_t *src, int src_wrap,
1420 int width, int height)
1424 for(;height > 0; height--) {
1425 for(w = width;w > 0; w--) {
1428 tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7];
1431 *(dst++) = (tmp + 32)>>6;
1432 src += 8 - 8*src_wrap;
1434 src += 8*src_wrap - 8*width;
1435 dst += dst_wrap - width;
1439 static void grow21_line(uint8_t *dst, const uint8_t *src,
1448 for(w = width;w >= 4; w-=4) {
1449 d[1] = d[0] = s1[0];
1450 d[3] = d[2] = s1[1];
1454 for(;w >= 2; w -= 2) {
1455 d[1] = d[0] = s1[0];
1459 /* only needed if width is not a multiple of two */
1460 /* XXX: veryfy that */
1466 static void grow41_line(uint8_t *dst, const uint8_t *src,
1475 for(w = width;w >= 4; w-=4) {
1487 static void grow21(uint8_t *dst, int dst_wrap,
1488 const uint8_t *src, int src_wrap,
1489 int width, int height)
1491 for(;height > 0; height--) {
1492 grow21_line(dst, src, width);
1499 static void grow22(uint8_t *dst, int dst_wrap,
1500 const uint8_t *src, int src_wrap,
1501 int width, int height)
1503 for(;height > 0; height--) {
1504 grow21_line(dst, src, width);
1512 static void grow41(uint8_t *dst, int dst_wrap,
1513 const uint8_t *src, int src_wrap,
1514 int width, int height)
1516 for(;height > 0; height--) {
1517 grow41_line(dst, src, width);
1524 static void grow44(uint8_t *dst, int dst_wrap,
1525 const uint8_t *src, int src_wrap,
1526 int width, int height)
1528 for(;height > 0; height--) {
1529 grow41_line(dst, src, width);
1530 if ((height & 3) == 1)
1537 static void conv411(uint8_t *dst, int dst_wrap,
1538 const uint8_t *src, int src_wrap,
1539 int width, int height)
1542 const uint8_t *s1, *s2;
1547 for(;height > 0; height--) {
1549 s2 = src + src_wrap;
1551 for(w = width;w > 0; w--) {
1552 c = (s1[0] + s2[0]) >> 1;
1559 src += src_wrap * 2;
1564 /* XXX: add jpeg quantize code */
1566 #define TRANSP_INDEX (6*6*6)
1568 /* this is maybe slow, but allows for extensions */
1569 static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
1571 return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));
1574 static void build_rgb_palette(uint8_t *palette, int has_alpha)
1577 static const uint8_t pal_value[6] = { 0x00, 0x33, 0x66, 0x99, 0xcc, 0xff };
1580 pal = (uint32_t *)palette;
1582 for(r = 0; r < 6; r++) {
1583 for(g = 0; g < 6; g++) {
1584 for(b = 0; b < 6; b++) {
1585 pal[i++] = (0xff << 24) | (pal_value[r] << 16) |
1586 (pal_value[g] << 8) | pal_value[b];
1593 pal[i++] = 0xff000000;
1596 /* copy bit n to bits 0 ... n - 1 */
1597 static inline unsigned int bitcopy_n(unsigned int a, int n)
1600 mask = (1 << n) - 1;
1601 return (a & (0xff & ~mask)) | ((-((a >> n) & 1)) & mask);
1604 /* rgb555 handling */
1606 #define RGB_NAME rgb555
1608 #define RGB_IN(r, g, b, s)\
1610 unsigned int v = ((const uint16_t *)(s))[0];\
1611 r = bitcopy_n(v >> (10 - 3), 3);\
1612 g = bitcopy_n(v >> (5 - 3), 3);\
1613 b = bitcopy_n(v << 3, 3);\
1616 #define RGBA_IN(r, g, b, a, s)\
1618 unsigned int v = ((const uint16_t *)(s))[0];\
1619 r = bitcopy_n(v >> (10 - 3), 3);\
1620 g = bitcopy_n(v >> (5 - 3), 3);\
1621 b = bitcopy_n(v << 3, 3);\
1622 a = (-(v >> 15)) & 0xff;\
1625 #define RGBA_OUT(d, r, g, b, a)\
1627 ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3) | \
1628 ((a << 8) & 0x8000);\
1633 #include "imgconvert_template.h"
1635 /* rgb565 handling */
1637 #define RGB_NAME rgb565
1639 #define RGB_IN(r, g, b, s)\
1641 unsigned int v = ((const uint16_t *)(s))[0];\
1642 r = bitcopy_n(v >> (11 - 3), 3);\
1643 g = bitcopy_n(v >> (5 - 2), 2);\
1644 b = bitcopy_n(v << 3, 3);\
1647 #define RGB_OUT(d, r, g, b)\
1649 ((uint16_t *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);\
1654 #include "imgconvert_template.h"
1656 /* bgr24 handling */
1658 #define RGB_NAME bgr24
1660 #define RGB_IN(r, g, b, s)\
1667 #define RGB_OUT(d, r, g, b)\
1676 #include "imgconvert_template.h"
1682 /* rgb24 handling */
1684 #define RGB_NAME rgb24
1687 #define RGB_IN(r, g, b, s)\
1694 #define RGB_OUT(d, r, g, b)\
1703 #include "imgconvert_template.h"
1705 /* rgba32 handling */
1707 #define RGB_NAME rgba32
1710 #define RGB_IN(r, g, b, s)\
1712 unsigned int v = ((const uint32_t *)(s))[0];\
1713 r = (v >> 16) & 0xff;\
1714 g = (v >> 8) & 0xff;\
1718 #define RGBA_IN(r, g, b, a, s)\
1720 unsigned int v = ((const uint32_t *)(s))[0];\
1721 a = (v >> 24) & 0xff;\
1722 r = (v >> 16) & 0xff;\
1723 g = (v >> 8) & 0xff;\
1727 #define RGBA_OUT(d, r, g, b, a)\
1729 ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;\
1734 #include "imgconvert_template.h"
1736 static void mono_to_gray(AVPicture *dst, const AVPicture *src,
1737 int width, int height, int xor_mask)
1739 const unsigned char *p;
1741 int v, dst_wrap, src_wrap;
1745 src_wrap = src->linesize[0] - ((width + 7) >> 3);
1748 dst_wrap = dst->linesize[0] - width;
1749 for(y=0;y<height;y++) {
1752 v = *p++ ^ xor_mask;
1754 q[1] = -((v >> 6) & 1);
1755 q[2] = -((v >> 5) & 1);
1756 q[3] = -((v >> 4) & 1);
1757 q[4] = -((v >> 3) & 1);
1758 q[5] = -((v >> 2) & 1);
1759 q[6] = -((v >> 1) & 1);
1760 q[7] = -((v >> 0) & 1);
1765 v = *p++ ^ xor_mask;
1767 q[0] = -((v >> 7) & 1);
1777 static void monowhite_to_gray(AVPicture *dst, const AVPicture *src,
1778 int width, int height)
1780 mono_to_gray(dst, src, width, height, 0xff);
1783 static void monoblack_to_gray(AVPicture *dst, const AVPicture *src,
1784 int width, int height)
1786 mono_to_gray(dst, src, width, height, 0x00);
1789 static void gray_to_mono(AVPicture *dst, const AVPicture *src,
1790 int width, int height, int xor_mask)
1795 int j, b, v, n1, src_wrap, dst_wrap, y;
1798 src_wrap = src->linesize[0] - width;
1801 dst_wrap = dst->linesize[0] - ((width + 7) >> 3);
1803 for(y=0;y<height;y++) {
1810 v = (v << 1) | (b >> 7);
1812 d[0] = v ^ xor_mask;
1822 v = (v << 1) | (b >> 7);
1825 d[0] = (v << (8 - (n1 & 7))) ^ xor_mask;
1833 static void gray_to_monowhite(AVPicture *dst, const AVPicture *src,
1834 int width, int height)
1836 gray_to_mono(dst, src, width, height, 0xff);
1839 static void gray_to_monoblack(AVPicture *dst, const AVPicture *src,
1840 int width, int height)
1842 gray_to_mono(dst, src, width, height, 0x00);
1845 typedef struct ConvertEntry {
1846 void (*convert)(AVPicture *dst,
1847 const AVPicture *src, int width, int height);
1850 /* Add each new convertion function in this table. In order to be able
1851 to convert from any format to any format, the following constraints
1854 - all FF_COLOR_RGB formats must convert to and from PIX_FMT_RGB24
1856 - all FF_COLOR_GRAY formats must convert to and from PIX_FMT_GRAY8
1858 - all FF_COLOR_RGB formats with alpha must convert to and from PIX_FMT_RGBA32
1860 - PIX_FMT_YUV444P and PIX_FMT_YUVJ444P must convert to and from
1863 - PIX_FMT_422 must convert to and from PIX_FMT_422P.
1865 The other conversion functions are just optimisations for common cases.
1867 static const ConvertEntry convert_table[PIX_FMT_NB][PIX_FMT_NB] = {
1868 [PIX_FMT_YUV420P] = {
1869 [PIX_FMT_YUV422] = {
1870 .convert = yuv420p_to_yuv422,
1872 [PIX_FMT_RGB555] = {
1873 .convert = yuv420p_to_rgb555
1875 [PIX_FMT_RGB565] = {
1876 .convert = yuv420p_to_rgb565
1879 .convert = yuv420p_to_bgr24
1882 .convert = yuv420p_to_rgb24
1884 [PIX_FMT_RGBA32] = {
1885 .convert = yuv420p_to_rgba32
1887 [PIX_FMT_UYVY422] = {
1888 .convert = yuv420p_to_uyvy422,
1891 [PIX_FMT_YUV422P] = {
1892 [PIX_FMT_YUV422] = {
1893 .convert = yuv422p_to_yuv422,
1895 [PIX_FMT_UYVY422] = {
1896 .convert = yuv422p_to_uyvy422,
1899 [PIX_FMT_YUV444P] = {
1901 .convert = yuv444p_to_rgb24
1904 [PIX_FMT_YUVJ420P] = {
1905 [PIX_FMT_RGB555] = {
1906 .convert = yuvj420p_to_rgb555
1908 [PIX_FMT_RGB565] = {
1909 .convert = yuvj420p_to_rgb565
1912 .convert = yuvj420p_to_bgr24
1915 .convert = yuvj420p_to_rgb24
1917 [PIX_FMT_RGBA32] = {
1918 .convert = yuvj420p_to_rgba32
1921 [PIX_FMT_YUVJ444P] = {
1923 .convert = yuvj444p_to_rgb24
1926 [PIX_FMT_YUV422] = {
1927 [PIX_FMT_YUV420P] = {
1928 .convert = yuv422_to_yuv420p,
1930 [PIX_FMT_YUV422P] = {
1931 .convert = yuv422_to_yuv422p,
1934 [PIX_FMT_UYVY422] = {
1935 [PIX_FMT_YUV420P] = {
1936 .convert = uyvy422_to_yuv420p,
1938 [PIX_FMT_YUV422P] = {
1939 .convert = uyvy422_to_yuv422p,
1943 [PIX_FMT_YUV420P] = {
1944 .convert = rgb24_to_yuv420p
1946 [PIX_FMT_RGB565] = {
1947 .convert = rgb24_to_rgb565
1949 [PIX_FMT_RGB555] = {
1950 .convert = rgb24_to_rgb555
1952 [PIX_FMT_RGBA32] = {
1953 .convert = rgb24_to_rgba32
1956 .convert = rgb24_to_bgr24
1959 .convert = rgb24_to_gray
1962 .convert = rgb24_to_pal8
1964 [PIX_FMT_YUV444P] = {
1965 .convert = rgb24_to_yuv444p
1967 [PIX_FMT_YUVJ420P] = {
1968 .convert = rgb24_to_yuvj420p
1970 [PIX_FMT_YUVJ444P] = {
1971 .convert = rgb24_to_yuvj444p
1974 [PIX_FMT_RGBA32] = {
1976 .convert = rgba32_to_rgb24
1978 [PIX_FMT_RGB555] = {
1979 .convert = rgba32_to_rgb555
1982 .convert = rgba32_to_pal8
1984 [PIX_FMT_YUV420P] = {
1985 .convert = rgba32_to_yuv420p
1988 .convert = rgba32_to_gray
1993 .convert = bgr24_to_rgb24
1995 [PIX_FMT_YUV420P] = {
1996 .convert = bgr24_to_yuv420p
1999 .convert = bgr24_to_gray
2002 [PIX_FMT_RGB555] = {
2004 .convert = rgb555_to_rgb24
2006 [PIX_FMT_RGBA32] = {
2007 .convert = rgb555_to_rgba32
2009 [PIX_FMT_YUV420P] = {
2010 .convert = rgb555_to_yuv420p
2013 .convert = rgb555_to_gray
2016 [PIX_FMT_RGB565] = {
2018 .convert = rgb565_to_rgb24
2020 [PIX_FMT_YUV420P] = {
2021 .convert = rgb565_to_yuv420p
2024 .convert = rgb565_to_gray
2028 [PIX_FMT_RGB555] = {
2029 .convert = gray_to_rgb555
2031 [PIX_FMT_RGB565] = {
2032 .convert = gray_to_rgb565
2035 .convert = gray_to_rgb24
2038 .convert = gray_to_bgr24
2040 [PIX_FMT_RGBA32] = {
2041 .convert = gray_to_rgba32
2043 [PIX_FMT_MONOWHITE] = {
2044 .convert = gray_to_monowhite
2046 [PIX_FMT_MONOBLACK] = {
2047 .convert = gray_to_monoblack
2050 [PIX_FMT_MONOWHITE] = {
2052 .convert = monowhite_to_gray
2055 [PIX_FMT_MONOBLACK] = {
2057 .convert = monoblack_to_gray
2061 [PIX_FMT_RGB555] = {
2062 .convert = pal8_to_rgb555
2064 [PIX_FMT_RGB565] = {
2065 .convert = pal8_to_rgb565
2068 .convert = pal8_to_bgr24
2071 .convert = pal8_to_rgb24
2073 [PIX_FMT_RGBA32] = {
2074 .convert = pal8_to_rgba32
2077 [PIX_FMT_UYVY411] = {
2078 [PIX_FMT_YUV411P] = {
2079 .convert = uyvy411_to_yuv411p,
2085 int avpicture_alloc(AVPicture *picture,
2086 int pix_fmt, int width, int height)
2091 size = avpicture_get_size(pix_fmt, width, height);
2094 ptr = av_malloc(size);
2097 avpicture_fill(picture, ptr, pix_fmt, width, height);
2100 memset(picture, 0, sizeof(AVPicture));
2104 void avpicture_free(AVPicture *picture)
2106 av_free(picture->data[0]);
2109 /* return true if yuv planar */
2110 static inline int is_yuv_planar(const PixFmtInfo *ps)
2112 return (ps->color_type == FF_COLOR_YUV ||
2113 ps->color_type == FF_COLOR_YUV_JPEG) &&
2114 ps->pixel_type == FF_PIXEL_PLANAR;
2118 * Crop image top and left side
2120 int img_crop(AVPicture *dst, const AVPicture *src,
2121 int pix_fmt, int top_band, int left_band)
2126 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt]))
2129 y_shift = pix_fmt_info[pix_fmt].y_chroma_shift;
2130 x_shift = pix_fmt_info[pix_fmt].x_chroma_shift;
2132 dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band;
2133 dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift);
2134 dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift);
2136 dst->linesize[0] = src->linesize[0];
2137 dst->linesize[1] = src->linesize[1];
2138 dst->linesize[2] = src->linesize[2];
2145 int img_pad(AVPicture *dst, const AVPicture *src, int height, int width, int pix_fmt,
2146 int padtop, int padbottom, int padleft, int padright, int *color)
2148 uint8_t *optr, *iptr;
2154 if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt]))
2157 for (i = 0; i < 3; i++) {
2158 x_shift = i ? pix_fmt_info[pix_fmt].x_chroma_shift : 0;
2159 y_shift = i ? pix_fmt_info[pix_fmt].y_chroma_shift : 0;
2161 if (padtop || padleft) {
2162 memset(dst->data[i], color[i], dst->linesize[i] * (padtop >> y_shift) + (padleft >> x_shift));
2165 if (padleft || padright || src) {
2166 if (src) { /* first line */
2167 iptr = src->data[i];
2168 optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) + (padleft >> x_shift);
2169 memcpy(optr, iptr, src->linesize[i]);
2170 iptr += src->linesize[i];
2172 optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) + (dst->linesize[i] - (padright >> x_shift));
2173 yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
2174 for (y = 0; y < yheight; y++) {
2175 memset(optr, color[i], (padleft + padright) >> x_shift);
2177 memcpy(optr + ((padleft + padright) >> x_shift), iptr, src->linesize[i]);
2178 iptr += src->linesize[i];
2180 optr += dst->linesize[i];
2184 if (padbottom || padright) {
2185 optr = dst->data[i] + dst->linesize[i] * ((height - padbottom) >> y_shift) - (padright >> x_shift);
2186 memset(optr, color[i], dst->linesize[i] * (padbottom >> y_shift) + (padright >> x_shift));
2192 #ifndef CONFIG_SWSCALER
2193 /* XXX: always use linesize. Return -1 if not supported */
2194 int img_convert(AVPicture *dst, int dst_pix_fmt,
2195 const AVPicture *src, int src_pix_fmt,
2196 int src_width, int src_height)
2199 int i, ret, dst_width, dst_height, int_pix_fmt;
2200 const PixFmtInfo *src_pix, *dst_pix;
2201 const ConvertEntry *ce;
2202 AVPicture tmp1, *tmp = &tmp1;
2204 if (src_pix_fmt < 0 || src_pix_fmt >= PIX_FMT_NB ||
2205 dst_pix_fmt < 0 || dst_pix_fmt >= PIX_FMT_NB)
2207 if (src_width <= 0 || src_height <= 0)
2215 dst_width = src_width;
2216 dst_height = src_height;
2218 dst_pix = &pix_fmt_info[dst_pix_fmt];
2219 src_pix = &pix_fmt_info[src_pix_fmt];
2220 if (src_pix_fmt == dst_pix_fmt) {
2221 /* no conversion needed: just copy */
2222 img_copy(dst, src, dst_pix_fmt, dst_width, dst_height);
2226 ce = &convert_table[src_pix_fmt][dst_pix_fmt];
2228 /* specific conversion routine */
2229 ce->convert(dst, src, dst_width, dst_height);
2234 if (is_yuv_planar(dst_pix) &&
2235 src_pix_fmt == PIX_FMT_GRAY8) {
2239 if (dst_pix->color_type == FF_COLOR_YUV_JPEG) {
2240 ff_img_copy_plane(dst->data[0], dst->linesize[0],
2241 src->data[0], src->linesize[0],
2242 dst_width, dst_height);
2244 img_apply_table(dst->data[0], dst->linesize[0],
2245 src->data[0], src->linesize[0],
2246 dst_width, dst_height,
2249 /* fill U and V with 128 */
2252 w >>= dst_pix->x_chroma_shift;
2253 h >>= dst_pix->y_chroma_shift;
2254 for(i = 1; i <= 2; i++) {
2256 for(y = 0; y< h; y++) {
2258 d += dst->linesize[i];
2265 if (is_yuv_planar(src_pix) &&
2266 dst_pix_fmt == PIX_FMT_GRAY8) {
2267 if (src_pix->color_type == FF_COLOR_YUV_JPEG) {
2268 ff_img_copy_plane(dst->data[0], dst->linesize[0],
2269 src->data[0], src->linesize[0],
2270 dst_width, dst_height);
2272 img_apply_table(dst->data[0], dst->linesize[0],
2273 src->data[0], src->linesize[0],
2274 dst_width, dst_height,
2280 /* YUV to YUV planar */
2281 if (is_yuv_planar(dst_pix) && is_yuv_planar(src_pix)) {
2282 int x_shift, y_shift, w, h, xy_shift;
2283 void (*resize_func)(uint8_t *dst, int dst_wrap,
2284 const uint8_t *src, int src_wrap,
2285 int width, int height);
2287 /* compute chroma size of the smallest dimensions */
2290 if (dst_pix->x_chroma_shift >= src_pix->x_chroma_shift)
2291 w >>= dst_pix->x_chroma_shift;
2293 w >>= src_pix->x_chroma_shift;
2294 if (dst_pix->y_chroma_shift >= src_pix->y_chroma_shift)
2295 h >>= dst_pix->y_chroma_shift;
2297 h >>= src_pix->y_chroma_shift;
2299 x_shift = (dst_pix->x_chroma_shift - src_pix->x_chroma_shift);
2300 y_shift = (dst_pix->y_chroma_shift - src_pix->y_chroma_shift);
2301 xy_shift = ((x_shift & 0xf) << 4) | (y_shift & 0xf);
2302 /* there must be filters for conversion at least from and to
2306 resize_func = ff_img_copy_plane;
2309 resize_func = shrink21;
2312 resize_func = shrink41;
2315 resize_func = shrink12;
2318 resize_func = ff_shrink22;
2321 resize_func = ff_shrink44;
2324 resize_func = grow21;
2327 resize_func = grow41;
2330 resize_func = grow22;
2333 resize_func = grow44;
2336 resize_func = conv411;
2339 /* currently not handled */
2340 goto no_chroma_filter;
2343 ff_img_copy_plane(dst->data[0], dst->linesize[0],
2344 src->data[0], src->linesize[0],
2345 dst_width, dst_height);
2347 for(i = 1;i <= 2; i++)
2348 resize_func(dst->data[i], dst->linesize[i],
2349 src->data[i], src->linesize[i],
2350 dst_width>>dst_pix->x_chroma_shift, dst_height>>dst_pix->y_chroma_shift);
2351 /* if yuv color space conversion is needed, we do it here on
2352 the destination image */
2353 if (dst_pix->color_type != src_pix->color_type) {
2354 const uint8_t *y_table, *c_table;
2355 if (dst_pix->color_type == FF_COLOR_YUV) {
2356 y_table = y_jpeg_to_ccir;
2357 c_table = c_jpeg_to_ccir;
2359 y_table = y_ccir_to_jpeg;
2360 c_table = c_ccir_to_jpeg;
2362 img_apply_table(dst->data[0], dst->linesize[0],
2363 dst->data[0], dst->linesize[0],
2364 dst_width, dst_height,
2367 for(i = 1;i <= 2; i++)
2368 img_apply_table(dst->data[i], dst->linesize[i],
2369 dst->data[i], dst->linesize[i],
2370 dst_width>>dst_pix->x_chroma_shift,
2371 dst_height>>dst_pix->y_chroma_shift,
2378 /* try to use an intermediate format */
2379 if (src_pix_fmt == PIX_FMT_YUV422 ||
2380 dst_pix_fmt == PIX_FMT_YUV422) {
2381 /* specific case: convert to YUV422P first */
2382 int_pix_fmt = PIX_FMT_YUV422P;
2383 } else if (src_pix_fmt == PIX_FMT_UYVY422 ||
2384 dst_pix_fmt == PIX_FMT_UYVY422) {
2385 /* specific case: convert to YUV422P first */
2386 int_pix_fmt = PIX_FMT_YUV422P;
2387 } else if (src_pix_fmt == PIX_FMT_UYVY411 ||
2388 dst_pix_fmt == PIX_FMT_UYVY411) {
2389 /* specific case: convert to YUV411P first */
2390 int_pix_fmt = PIX_FMT_YUV411P;
2391 } else if ((src_pix->color_type == FF_COLOR_GRAY &&
2392 src_pix_fmt != PIX_FMT_GRAY8) ||
2393 (dst_pix->color_type == FF_COLOR_GRAY &&
2394 dst_pix_fmt != PIX_FMT_GRAY8)) {
2395 /* gray8 is the normalized format */
2396 int_pix_fmt = PIX_FMT_GRAY8;
2397 } else if ((is_yuv_planar(src_pix) &&
2398 src_pix_fmt != PIX_FMT_YUV444P &&
2399 src_pix_fmt != PIX_FMT_YUVJ444P)) {
2400 /* yuv444 is the normalized format */
2401 if (src_pix->color_type == FF_COLOR_YUV_JPEG)
2402 int_pix_fmt = PIX_FMT_YUVJ444P;
2404 int_pix_fmt = PIX_FMT_YUV444P;
2405 } else if ((is_yuv_planar(dst_pix) &&
2406 dst_pix_fmt != PIX_FMT_YUV444P &&
2407 dst_pix_fmt != PIX_FMT_YUVJ444P)) {
2408 /* yuv444 is the normalized format */
2409 if (dst_pix->color_type == FF_COLOR_YUV_JPEG)
2410 int_pix_fmt = PIX_FMT_YUVJ444P;
2412 int_pix_fmt = PIX_FMT_YUV444P;
2414 /* the two formats are rgb or gray8 or yuv[j]444p */
2415 if (src_pix->is_alpha && dst_pix->is_alpha)
2416 int_pix_fmt = PIX_FMT_RGBA32;
2418 int_pix_fmt = PIX_FMT_RGB24;
2420 if (avpicture_alloc(tmp, int_pix_fmt, dst_width, dst_height) < 0)
2423 if (img_convert(tmp, int_pix_fmt,
2424 src, src_pix_fmt, src_width, src_height) < 0)
2426 if (img_convert(dst, dst_pix_fmt,
2427 tmp, int_pix_fmt, dst_width, dst_height) < 0)
2431 avpicture_free(tmp);
2436 /* NOTE: we scan all the pixels to have an exact information */
2437 static int get_alpha_info_pal8(const AVPicture *src, int width, int height)
2439 const unsigned char *p;
2440 int src_wrap, ret, x, y;
2442 uint32_t *palette = (uint32_t *)src->data[1];
2445 src_wrap = src->linesize[0] - width;
2447 for(y=0;y<height;y++) {
2448 for(x=0;x<width;x++) {
2449 a = palette[p[0]] >> 24;
2451 ret |= FF_ALPHA_TRANSP;
2452 } else if (a != 0xff) {
2453 ret |= FF_ALPHA_SEMI_TRANSP;
2463 * Tell if an image really has transparent alpha values.
2464 * @return ored mask of FF_ALPHA_xxx constants
2466 int img_get_alpha_info(const AVPicture *src,
2467 int pix_fmt, int width, int height)
2469 const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
2472 pf = &pix_fmt_info[pix_fmt];
2473 /* no alpha can be represented in format */
2477 case PIX_FMT_RGBA32:
2478 ret = get_alpha_info_rgba32(src, width, height);
2480 case PIX_FMT_RGB555:
2481 ret = get_alpha_info_rgb555(src, width, height);
2484 ret = get_alpha_info_pal8(src, width, height);
2487 /* we do not know, so everything is indicated */
2488 ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP;
2495 #define DEINT_INPLACE_LINE_LUM \
2496 movd_m2r(lum_m4[0],mm0);\
2497 movd_m2r(lum_m3[0],mm1);\
2498 movd_m2r(lum_m2[0],mm2);\
2499 movd_m2r(lum_m1[0],mm3);\
2500 movd_m2r(lum[0],mm4);\
2501 punpcklbw_r2r(mm7,mm0);\
2502 movd_r2m(mm2,lum_m4[0]);\
2503 punpcklbw_r2r(mm7,mm1);\
2504 punpcklbw_r2r(mm7,mm2);\
2505 punpcklbw_r2r(mm7,mm3);\
2506 punpcklbw_r2r(mm7,mm4);\
2507 paddw_r2r(mm3,mm1);\
2509 paddw_r2r(mm4,mm0);\
2511 paddw_r2r(mm6,mm2);\
2512 paddw_r2r(mm2,mm1);\
2513 psubusw_r2r(mm0,mm1);\
2515 packuswb_r2r(mm7,mm1);\
2516 movd_r2m(mm1,lum_m2[0]);
2518 #define DEINT_LINE_LUM \
2519 movd_m2r(lum_m4[0],mm0);\
2520 movd_m2r(lum_m3[0],mm1);\
2521 movd_m2r(lum_m2[0],mm2);\
2522 movd_m2r(lum_m1[0],mm3);\
2523 movd_m2r(lum[0],mm4);\
2524 punpcklbw_r2r(mm7,mm0);\
2525 punpcklbw_r2r(mm7,mm1);\
2526 punpcklbw_r2r(mm7,mm2);\
2527 punpcklbw_r2r(mm7,mm3);\
2528 punpcklbw_r2r(mm7,mm4);\
2529 paddw_r2r(mm3,mm1);\
2531 paddw_r2r(mm4,mm0);\
2533 paddw_r2r(mm6,mm2);\
2534 paddw_r2r(mm2,mm1);\
2535 psubusw_r2r(mm0,mm1);\
2537 packuswb_r2r(mm7,mm1);\
2538 movd_r2m(mm1,dst[0]);
2541 /* filter parameters: [-1 4 2 4 -1] // 8 */
2542 static void deinterlace_line(uint8_t *dst,
2543 const uint8_t *lum_m4, const uint8_t *lum_m3,
2544 const uint8_t *lum_m2, const uint8_t *lum_m1,
2549 uint8_t *cm = cropTbl + MAX_NEG_CROP;
2552 for(;size > 0;size--) {
2554 sum += lum_m3[0] << 2;
2555 sum += lum_m2[0] << 1;
2556 sum += lum_m1[0] << 2;
2558 dst[0] = cm[(sum + 4) >> 3];
2575 movq_m2r(rounder,mm6);
2577 for (;size > 3; size-=4) {
2588 static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum,
2592 uint8_t *cm = cropTbl + MAX_NEG_CROP;
2595 for(;size > 0;size--) {
2597 sum += lum_m3[0] << 2;
2598 sum += lum_m2[0] << 1;
2599 lum_m4[0]=lum_m2[0];
2600 sum += lum_m1[0] << 2;
2602 lum_m2[0] = cm[(sum + 4) >> 3];
2618 movq_m2r(rounder,mm6);
2620 for (;size > 3; size-=4) {
2621 DEINT_INPLACE_LINE_LUM
2631 /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
2632 top field is copied as is, but the bottom field is deinterlaced
2633 against the top field. */
2634 static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap,
2635 const uint8_t *src1, int src_wrap,
2636 int width, int height)
2638 const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
2643 src_0=&src_m1[src_wrap];
2644 src_p1=&src_0[src_wrap];
2645 src_p2=&src_p1[src_wrap];
2646 for(y=0;y<(height-2);y+=2) {
2647 memcpy(dst,src_m1,width);
2649 deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width);
2653 src_p1 += 2*src_wrap;
2654 src_p2 += 2*src_wrap;
2657 memcpy(dst,src_m1,width);
2660 deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);
2663 static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap,
2664 int width, int height)
2666 uint8_t *src_m1, *src_0, *src_p1, *src_p2;
2669 buf = (uint8_t*)av_malloc(width);
2672 memcpy(buf,src_m1,width);
2673 src_0=&src_m1[src_wrap];
2674 src_p1=&src_0[src_wrap];
2675 src_p2=&src_p1[src_wrap];
2676 for(y=0;y<(height-2);y+=2) {
2677 deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width);
2680 src_p1 += 2*src_wrap;
2681 src_p2 += 2*src_wrap;
2684 deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width);
2689 /* deinterlace - if not supported return -1 */
2690 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
2691 int pix_fmt, int width, int height)
2695 if (pix_fmt != PIX_FMT_YUV420P &&
2696 pix_fmt != PIX_FMT_YUV422P &&
2697 pix_fmt != PIX_FMT_YUV444P &&
2698 pix_fmt != PIX_FMT_YUV411P)
2700 if ((width & 3) != 0 || (height & 3) != 0)
2706 case PIX_FMT_YUV420P:
2710 case PIX_FMT_YUV422P:
2713 case PIX_FMT_YUV411P:
2721 deinterlace_bottom_field_inplace(dst->data[i], dst->linesize[i],
2724 deinterlace_bottom_field(dst->data[i],dst->linesize[i],
2725 src->data[i], src->linesize[i],