fdce574bd2340fb23bf56c2d459ba874fdaf73dd
[ffmpeg.git] / libavcodec / imgconvert.c
1 /*
2  * Misc image convertion routines
3  * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
4  *
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.
9  *
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.
14  *
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
18  */
19
20 /**
21  * @file imgconvert.c
22  * Misc image convertion routines.
23  */
24
25 /* TODO:
26  * - write 'ffimg' program to test all the image related stuff
27  * - move all api to slice based system
28  * - integrate deinterlacing, postprocessing and scaling in the conversion process
29  */
30
31 #include "avcodec.h"
32 #include "dsputil.h"
33
34 #ifdef USE_FASTMEMCPY
35 #include "fastmemcpy.h"
36 #endif
37
38 #ifdef HAVE_MMX
39 #include "i386/mmx.h"
40 #endif
41
42 #define xglue(x, y) x ## y
43 #define glue(x, y) xglue(x, y)
44
45 #define FF_COLOR_RGB      0 /* RGB color space */
46 #define FF_COLOR_GRAY     1 /* gray color space */
47 #define FF_COLOR_YUV      2 /* YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
48 #define FF_COLOR_YUV_JPEG 3 /* YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
49
50 #define FF_PIXEL_PLANAR   0 /* each channel has one component in AVPicture */
51 #define FF_PIXEL_PACKED   1 /* only one components containing all the channels */
52 #define FF_PIXEL_PALETTE  2  /* one components containing indexes for a palette */
53
54 typedef struct PixFmtInfo {
55     const char *name;
56     uint8_t nb_channels;     /* number of channels (including alpha) */
57     uint8_t color_type;      /* color type (see FF_COLOR_xxx constants) */
58     uint8_t pixel_type;      /* pixel storage type (see FF_PIXEL_xxx constants) */
59     uint8_t is_alpha : 1;    /* true if alpha can be specified */
60     uint8_t x_chroma_shift;  /* X chroma subsampling factor is 2 ^ shift */
61     uint8_t y_chroma_shift;  /* Y chroma subsampling factor is 2 ^ shift */
62     uint8_t depth;           /* bit depth of the color components */
63 } PixFmtInfo;
64
65 /* this table gives more information about formats */
66 static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = {
67     /* YUV formats */
68     [PIX_FMT_YUV420P] = {
69         .name = "yuv420p",
70         .nb_channels = 3,
71         .color_type = FF_COLOR_YUV,
72         .pixel_type = FF_PIXEL_PLANAR,
73         .depth = 8,
74         .x_chroma_shift = 1, .y_chroma_shift = 1, 
75     },
76     [PIX_FMT_YUV422P] = {
77         .name = "yuv422p",
78         .nb_channels = 3,
79         .color_type = FF_COLOR_YUV,
80         .pixel_type = FF_PIXEL_PLANAR,
81         .depth = 8,
82         .x_chroma_shift = 1, .y_chroma_shift = 0, 
83     },
84     [PIX_FMT_YUV444P] = {
85         .name = "yuv444p",
86         .nb_channels = 3,
87         .color_type = FF_COLOR_YUV,
88         .pixel_type = FF_PIXEL_PLANAR,
89         .depth = 8,
90         .x_chroma_shift = 0, .y_chroma_shift = 0, 
91     },
92     [PIX_FMT_YUV422] = {
93         .name = "yuv422",
94         .nb_channels = 1,
95         .color_type = FF_COLOR_YUV,
96         .pixel_type = FF_PIXEL_PACKED,
97         .depth = 8,
98         .x_chroma_shift = 1, .y_chroma_shift = 0,
99     },
100     [PIX_FMT_UYVY422] = {
101         .name = "uyvy422",
102         .nb_channels = 1,
103         .color_type = FF_COLOR_YUV,
104         .pixel_type = FF_PIXEL_PACKED,
105         .depth = 8,
106         .x_chroma_shift = 1, .y_chroma_shift = 0,
107     },
108     [PIX_FMT_YUV410P] = {
109         .name = "yuv410p",
110         .nb_channels = 3,
111         .color_type = FF_COLOR_YUV,
112         .pixel_type = FF_PIXEL_PLANAR,
113         .depth = 8,
114         .x_chroma_shift = 2, .y_chroma_shift = 2,
115     },
116     [PIX_FMT_YUV411P] = {
117         .name = "yuv411p",
118         .nb_channels = 3,
119         .color_type = FF_COLOR_YUV,
120         .pixel_type = FF_PIXEL_PLANAR,
121         .depth = 8,
122         .x_chroma_shift = 2, .y_chroma_shift = 0,
123     },
124
125     /* JPEG YUV */
126     [PIX_FMT_YUVJ420P] = {
127         .name = "yuvj420p",
128         .nb_channels = 3,
129         .color_type = FF_COLOR_YUV_JPEG,
130         .pixel_type = FF_PIXEL_PLANAR,
131         .depth = 8,
132         .x_chroma_shift = 1, .y_chroma_shift = 1, 
133     },
134     [PIX_FMT_YUVJ422P] = {
135         .name = "yuvj422p",
136         .nb_channels = 3,
137         .color_type = FF_COLOR_YUV_JPEG,
138         .pixel_type = FF_PIXEL_PLANAR,
139         .depth = 8,
140         .x_chroma_shift = 1, .y_chroma_shift = 0, 
141     },
142     [PIX_FMT_YUVJ444P] = {
143         .name = "yuvj444p",
144         .nb_channels = 3,
145         .color_type = FF_COLOR_YUV_JPEG,
146         .pixel_type = FF_PIXEL_PLANAR,
147         .depth = 8,
148         .x_chroma_shift = 0, .y_chroma_shift = 0, 
149     },
150
151     /* RGB formats */
152     [PIX_FMT_RGB24] = {
153         .name = "rgb24",
154         .nb_channels = 3,
155         .color_type = FF_COLOR_RGB,
156         .pixel_type = FF_PIXEL_PACKED,
157         .depth = 8,
158         .x_chroma_shift = 0, .y_chroma_shift = 0,
159     },
160     [PIX_FMT_BGR24] = {
161         .name = "bgr24",
162         .nb_channels = 3,
163         .color_type = FF_COLOR_RGB,
164         .pixel_type = FF_PIXEL_PACKED,
165         .depth = 8,
166         .x_chroma_shift = 0, .y_chroma_shift = 0,
167     },
168     [PIX_FMT_RGBA32] = {
169         .name = "rgba32",
170         .nb_channels = 4, .is_alpha = 1,
171         .color_type = FF_COLOR_RGB,
172         .pixel_type = FF_PIXEL_PACKED,
173         .depth = 8,
174         .x_chroma_shift = 0, .y_chroma_shift = 0,
175     },
176     [PIX_FMT_RGB565] = {
177         .name = "rgb565",
178         .nb_channels = 3,
179         .color_type = FF_COLOR_RGB,
180         .pixel_type = FF_PIXEL_PACKED,
181         .depth = 5,
182         .x_chroma_shift = 0, .y_chroma_shift = 0,
183     },
184     [PIX_FMT_RGB555] = {
185         .name = "rgb555",
186         .nb_channels = 4, .is_alpha = 1,
187         .color_type = FF_COLOR_RGB,
188         .pixel_type = FF_PIXEL_PACKED,
189         .depth = 5,
190         .x_chroma_shift = 0, .y_chroma_shift = 0,
191     },
192
193     /* gray / mono formats */
194     [PIX_FMT_GRAY8] = {
195         .name = "gray",
196         .nb_channels = 1,
197         .color_type = FF_COLOR_GRAY,
198         .pixel_type = FF_PIXEL_PLANAR,
199         .depth = 8,
200     },
201     [PIX_FMT_MONOWHITE] = {
202         .name = "monow",
203         .nb_channels = 1,
204         .color_type = FF_COLOR_GRAY,
205         .pixel_type = FF_PIXEL_PLANAR,
206         .depth = 1,
207     },
208     [PIX_FMT_MONOBLACK] = {
209         .name = "monob",
210         .nb_channels = 1,
211         .color_type = FF_COLOR_GRAY,
212         .pixel_type = FF_PIXEL_PLANAR,
213         .depth = 1,
214     },
215
216     /* paletted formats */
217     [PIX_FMT_PAL8] = {
218         .name = "pal8",
219         .nb_channels = 4, .is_alpha = 1,
220         .color_type = FF_COLOR_RGB,
221         .pixel_type = FF_PIXEL_PALETTE,
222         .depth = 8,
223     },
224 };
225
226 void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift)
227 {
228     *h_shift = pix_fmt_info[pix_fmt].x_chroma_shift;
229     *v_shift = pix_fmt_info[pix_fmt].y_chroma_shift;
230 }
231
232 const char *avcodec_get_pix_fmt_name(int pix_fmt)
233 {
234     if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB)
235         return "???";
236     else
237         return pix_fmt_info[pix_fmt].name;
238 }
239
240 enum PixelFormat avcodec_get_pix_fmt(const char* name)
241 {
242     int i; 
243     
244     for (i=0; i < PIX_FMT_NB; i++)
245          if (!strcmp(pix_fmt_info[i].name, name))
246              break;
247     return i;
248 }
249
250 /* Picture field are filled with 'ptr' addresses. Also return size */
251 int avpicture_fill(AVPicture *picture, uint8_t *ptr,
252                    int pix_fmt, int width, int height)
253 {
254     int size, w2, h2, size2;
255     PixFmtInfo *pinfo;
256     
257     pinfo = &pix_fmt_info[pix_fmt];
258     size = width * height;
259     switch(pix_fmt) {
260     case PIX_FMT_YUV420P:
261     case PIX_FMT_YUV422P:
262     case PIX_FMT_YUV444P:
263     case PIX_FMT_YUV410P:
264     case PIX_FMT_YUV411P:
265     case PIX_FMT_YUVJ420P:
266     case PIX_FMT_YUVJ422P:
267     case PIX_FMT_YUVJ444P:
268         w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
269         h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
270         size2 = w2 * h2;
271         picture->data[0] = ptr;
272         picture->data[1] = picture->data[0] + size;
273         picture->data[2] = picture->data[1] + size2;
274         picture->linesize[0] = width;
275         picture->linesize[1] = w2;
276         picture->linesize[2] = w2;
277         return size + 2 * size2;
278     case PIX_FMT_RGB24:
279     case PIX_FMT_BGR24:
280         picture->data[0] = ptr;
281         picture->data[1] = NULL;
282         picture->data[2] = NULL;
283         picture->linesize[0] = width * 3;
284         return size * 3;
285     case PIX_FMT_RGBA32:
286         picture->data[0] = ptr;
287         picture->data[1] = NULL;
288         picture->data[2] = NULL;
289         picture->linesize[0] = width * 4;
290         return size * 4;
291     case PIX_FMT_RGB555:
292     case PIX_FMT_RGB565:
293     case PIX_FMT_YUV422:
294         picture->data[0] = ptr;
295         picture->data[1] = NULL;
296         picture->data[2] = NULL;
297         picture->linesize[0] = width * 2;
298         return size * 2;
299     case PIX_FMT_UYVY422:
300         picture->data[0] = ptr;
301         picture->data[1] = NULL;
302         picture->data[2] = NULL;
303         picture->linesize[0] = width * 2;
304         return size * 2;
305     case PIX_FMT_GRAY8:
306         picture->data[0] = ptr;
307         picture->data[1] = NULL;
308         picture->data[2] = NULL;
309         picture->linesize[0] = width;
310         return size;
311     case PIX_FMT_MONOWHITE:
312     case PIX_FMT_MONOBLACK:
313         picture->data[0] = ptr;
314         picture->data[1] = NULL;
315         picture->data[2] = NULL;
316         picture->linesize[0] = (width + 7) >> 3;
317         return picture->linesize[0] * height;
318     case PIX_FMT_PAL8:
319         size2 = (size + 3) & ~3;
320         picture->data[0] = ptr;
321         picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */
322         picture->data[2] = NULL;
323         picture->linesize[0] = width;
324         picture->linesize[1] = 4;
325         return size2 + 256 * 4;
326     default:
327         picture->data[0] = NULL;
328         picture->data[1] = NULL;
329         picture->data[2] = NULL;
330         picture->data[3] = NULL;
331         return -1;
332     }
333 }
334
335 int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height,
336                      unsigned char *dest, int dest_size)
337 {
338     PixFmtInfo* pf = &pix_fmt_info[pix_fmt];
339     int i, j, w, h, data_planes;
340     const unsigned char* s; 
341     int size = avpicture_get_size(pix_fmt, width, height);
342
343     if (size > dest_size)
344         return -1;
345
346     if (pf->pixel_type == FF_PIXEL_PACKED || pf->pixel_type == FF_PIXEL_PALETTE) {
347         if (pix_fmt == PIX_FMT_YUV422 || 
348             pix_fmt == PIX_FMT_UYVY422 || 
349             pix_fmt == PIX_FMT_RGB565 ||
350             pix_fmt == PIX_FMT_RGB555)
351             w = width * 2;
352         else if (pix_fmt == PIX_FMT_PAL8)
353           w = width;
354         else
355           w = width * (pf->depth * pf->nb_channels / 8);
356           
357         data_planes = 1;
358         h = height;
359     } else {
360         data_planes = pf->nb_channels;
361         w = width;
362         h = height;
363     }
364     
365     for (i=0; i<data_planes; i++) {
366          if (i == 1) {
367              w = width >> pf->x_chroma_shift;
368              h = height >> pf->y_chroma_shift;
369          }
370          s = src->data[i];
371          for(j=0; j<h; j++) {
372              memcpy(dest, s, w);
373              dest += w;
374              s += src->linesize[i];
375          }
376     }
377     
378     if (pf->pixel_type == FF_PIXEL_PALETTE)
379         memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4);
380     
381     return size;
382 }
383
384 int avpicture_get_size(int pix_fmt, int width, int height)
385 {
386     AVPicture dummy_pict;
387     return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);
388 }
389
390 /**
391  * compute the loss when converting from a pixel format to another 
392  */
393 int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt,
394                              int has_alpha)
395 {
396     const PixFmtInfo *pf, *ps;
397     int loss;
398
399     ps = &pix_fmt_info[src_pix_fmt];
400     pf = &pix_fmt_info[dst_pix_fmt];
401
402     /* compute loss */
403     loss = 0;
404     pf = &pix_fmt_info[dst_pix_fmt];
405     if (pf->depth < ps->depth ||
406         (dst_pix_fmt == PIX_FMT_RGB555 && src_pix_fmt == PIX_FMT_RGB565))
407         loss |= FF_LOSS_DEPTH;
408     if (pf->x_chroma_shift > ps->x_chroma_shift ||
409         pf->y_chroma_shift > ps->y_chroma_shift)
410         loss |= FF_LOSS_RESOLUTION;
411     switch(pf->color_type) {
412     case FF_COLOR_RGB:
413         if (ps->color_type != FF_COLOR_RGB &&
414             ps->color_type != FF_COLOR_GRAY)
415             loss |= FF_LOSS_COLORSPACE;
416         break;
417     case FF_COLOR_GRAY:
418         if (ps->color_type != FF_COLOR_GRAY)
419             loss |= FF_LOSS_COLORSPACE;
420         break;
421     case FF_COLOR_YUV:
422         if (ps->color_type != FF_COLOR_YUV)
423             loss |= FF_LOSS_COLORSPACE;
424         break;
425     case FF_COLOR_YUV_JPEG:
426         if (ps->color_type != FF_COLOR_YUV_JPEG &&
427             ps->color_type != FF_COLOR_YUV && 
428             ps->color_type != FF_COLOR_GRAY)
429             loss |= FF_LOSS_COLORSPACE;
430         break;
431     default:
432         /* fail safe test */
433         if (ps->color_type != pf->color_type)
434             loss |= FF_LOSS_COLORSPACE;
435         break;
436     }
437     if (pf->color_type == FF_COLOR_GRAY &&
438         ps->color_type != FF_COLOR_GRAY)
439         loss |= FF_LOSS_CHROMA;
440     if (!pf->is_alpha && (ps->is_alpha && has_alpha))
441         loss |= FF_LOSS_ALPHA;
442     if (pf->pixel_type == FF_PIXEL_PALETTE && 
443         (ps->pixel_type != FF_PIXEL_PALETTE && ps->color_type != FF_COLOR_GRAY))
444         loss |= FF_LOSS_COLORQUANT;
445     return loss;
446 }
447
448 static int avg_bits_per_pixel(int pix_fmt)
449 {
450     int bits;
451     const PixFmtInfo *pf;
452
453     pf = &pix_fmt_info[pix_fmt];
454     switch(pf->pixel_type) {
455     case FF_PIXEL_PACKED:
456         switch(pix_fmt) {
457         case PIX_FMT_YUV422:
458         case PIX_FMT_UYVY422:
459         case PIX_FMT_RGB565:
460         case PIX_FMT_RGB555:
461             bits = 16;
462             break;
463         default:
464             bits = pf->depth * pf->nb_channels;
465             break;
466         }
467         break;
468     case FF_PIXEL_PLANAR:
469         if (pf->x_chroma_shift == 0 && pf->y_chroma_shift == 0) {
470             bits = pf->depth * pf->nb_channels;
471         } else {
472             bits = pf->depth + ((2 * pf->depth) >> 
473                                 (pf->x_chroma_shift + pf->y_chroma_shift));
474         }
475         break;
476     case FF_PIXEL_PALETTE:
477         bits = 8;
478         break;
479     default:
480         bits = -1;
481         break;
482     }
483     return bits;
484 }
485
486 static int avcodec_find_best_pix_fmt1(int pix_fmt_mask, 
487                                       int src_pix_fmt,
488                                       int has_alpha,
489                                       int loss_mask)
490 {
491     int dist, i, loss, min_dist, dst_pix_fmt;
492
493     /* find exact color match with smallest size */
494     dst_pix_fmt = -1;
495     min_dist = 0x7fffffff;
496     for(i = 0;i < PIX_FMT_NB; i++) {
497         if (pix_fmt_mask & (1 << i)) {
498             loss = avcodec_get_pix_fmt_loss(i, src_pix_fmt, has_alpha) & loss_mask;
499             if (loss == 0) {
500                 dist = avg_bits_per_pixel(i);
501                 if (dist < min_dist) {
502                     min_dist = dist;
503                     dst_pix_fmt = i;
504                 }
505             }
506         }
507     }
508     return dst_pix_fmt;
509 }
510
511 /** 
512  * find best pixel format to convert to. Return -1 if none found 
513  */
514 int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt,
515                               int has_alpha, int *loss_ptr)
516 {
517     int dst_pix_fmt, loss_mask, i;
518     static const int loss_mask_order[] = {
519         ~0, /* no loss first */
520         ~FF_LOSS_ALPHA,
521         ~FF_LOSS_RESOLUTION,
522         ~(FF_LOSS_COLORSPACE | FF_LOSS_RESOLUTION),
523         ~FF_LOSS_COLORQUANT,
524         ~FF_LOSS_DEPTH,
525         0,
526     };
527
528     /* try with successive loss */
529     i = 0;
530     for(;;) {
531         loss_mask = loss_mask_order[i++];
532         dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_mask, src_pix_fmt, 
533                                                  has_alpha, loss_mask);
534         if (dst_pix_fmt >= 0)
535             goto found;
536         if (loss_mask == 0)
537             break;
538     }
539     return -1;
540  found:
541     if (loss_ptr)
542         *loss_ptr = avcodec_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
543     return dst_pix_fmt;
544 }
545
546 static void img_copy_plane(uint8_t *dst, int dst_wrap, 
547                            const uint8_t *src, int src_wrap,
548                            int width, int height)
549 {
550     for(;height > 0; height--) {
551         memcpy(dst, src, width);
552         dst += dst_wrap;
553         src += src_wrap;
554     }
555 }
556
557 /**
558  * Copy image 'src' to 'dst'.
559  */
560 void img_copy(AVPicture *dst, const AVPicture *src,
561               int pix_fmt, int width, int height)
562 {
563     int bwidth, bits, i;
564     PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
565     
566     pf = &pix_fmt_info[pix_fmt];
567     switch(pf->pixel_type) {
568     case FF_PIXEL_PACKED:
569         switch(pix_fmt) {
570         case PIX_FMT_YUV422:
571         case PIX_FMT_UYVY422:
572         case PIX_FMT_RGB565:
573         case PIX_FMT_RGB555:
574             bits = 16;
575             break;
576         default:
577             bits = pf->depth * pf->nb_channels;
578             break;
579         }
580         bwidth = (width * bits + 7) >> 3;
581         img_copy_plane(dst->data[0], dst->linesize[0],
582                        src->data[0], src->linesize[0],
583                        bwidth, height);
584         break;
585     case FF_PIXEL_PLANAR:
586         for(i = 0; i < pf->nb_channels; i++) {
587             int w, h;
588             w = width;
589             h = height;
590             if (i == 1 || i == 2) {
591                 w >>= pf->x_chroma_shift;
592                 h >>= pf->y_chroma_shift;
593             }
594             bwidth = (w * pf->depth + 7) >> 3;
595             img_copy_plane(dst->data[i], dst->linesize[i],
596                            src->data[i], src->linesize[i],
597                            bwidth, h);
598         }
599         break;
600     case FF_PIXEL_PALETTE:
601         img_copy_plane(dst->data[0], dst->linesize[0],
602                        src->data[0], src->linesize[0],
603                        width, height);
604         /* copy the palette */
605         img_copy_plane(dst->data[1], dst->linesize[1],
606                        src->data[1], src->linesize[1],
607                        4, 256);
608         break;
609     }
610 }
611
612 /* XXX: totally non optimized */
613
614 static void yuv422_to_yuv420p(AVPicture *dst, const AVPicture *src,
615                               int width, int height)
616 {
617     const uint8_t *p, *p1;
618     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
619     int w;
620  
621     p1 = src->data[0];
622     lum1 = dst->data[0];
623     cb1 = dst->data[1];
624     cr1 = dst->data[2];
625
626     for(;height >= 1; height -= 2) {
627         p = p1;
628         lum = lum1;
629         cb = cb1;
630         cr = cr1;
631         for(w = width; w >= 2; w -= 2) {
632             lum[0] = p[0];
633             cb[0] = p[1];
634             lum[1] = p[2];
635             cr[0] = p[3];
636             p += 4;
637             lum += 2;
638             cb++;
639             cr++;
640         }
641         if (w) {
642             lum[0] = p[0];
643             cb[0] = p[1];
644             cr[0] = p[3];
645             cb++;
646             cr++;
647         }
648         p1 += src->linesize[0];
649         lum1 += dst->linesize[0];
650         if (height>1) {
651             p = p1;
652             lum = lum1;
653             for(w = width; w >= 2; w -= 2) {
654                 lum[0] = p[0];
655                 lum[1] = p[2];
656                 p += 4;
657                 lum += 2;
658             }
659             if (w) {
660                 lum[0] = p[0];
661             }
662             p1 += src->linesize[0];
663             lum1 += dst->linesize[0];
664         }
665         cb1 += dst->linesize[1];
666         cr1 += dst->linesize[2];
667     }
668 }
669
670 static void uyvy422_to_yuv420p(AVPicture *dst, const AVPicture *src,
671                               int width, int height)
672 {
673     const uint8_t *p, *p1;
674     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
675     int w;
676  
677     p1 = src->data[0];
678     
679     lum1 = dst->data[0];
680     cb1 = dst->data[1];
681     cr1 = dst->data[2];
682
683     for(;height >= 1; height -= 2) {
684         p = p1;
685         lum = lum1;
686         cb = cb1;
687         cr = cr1;
688         for(w = width; w >= 2; w -= 2) {
689             lum[0] = p[1];
690             cb[0] = p[0];
691             lum[1] = p[3];
692             cr[0] = p[2];
693             p += 4;
694             lum += 2;
695             cb++;
696             cr++;
697         }
698         if (w) {
699             lum[0] = p[1];
700             cb[0] = p[0];
701             cr[0] = p[2];
702             cb++;
703             cr++;
704         }
705         p1 += src->linesize[0];
706         lum1 += dst->linesize[0];
707         if (height>1) {
708             p = p1;
709             lum = lum1;
710             for(w = width; w >= 2; w -= 2) {
711                 lum[0] = p[1];
712                 lum[1] = p[3];
713                 p += 4;
714                 lum += 2;
715             }
716             if (w) {
717                 lum[0] = p[1];
718             }
719             p1 += src->linesize[0];
720             lum1 += dst->linesize[0];
721         }
722         cb1 += dst->linesize[1];
723         cr1 += dst->linesize[2];
724     }
725 }
726
727
728 static void uyvy422_to_yuv422p(AVPicture *dst, const AVPicture *src,
729                               int width, int height)
730 {
731     const uint8_t *p, *p1;
732     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
733     int w;
734
735     p1 = src->data[0];
736     lum1 = dst->data[0];
737     cb1 = dst->data[1];
738     cr1 = dst->data[2];
739     for(;height > 0; height--) {
740         p = p1;
741         lum = lum1;
742         cb = cb1;
743         cr = cr1;
744         for(w = width; w >= 2; w -= 2) {
745             lum[0] = p[1];
746             cb[0] = p[0];
747             lum[1] = p[3];
748             cr[0] = p[2];
749             p += 4;
750             lum += 2;
751             cb++;
752             cr++;
753         }
754         p1 += src->linesize[0];
755         lum1 += dst->linesize[0];
756         cb1 += dst->linesize[1];
757         cr1 += dst->linesize[2];
758     }
759 }
760
761
762 static void yuv422_to_yuv422p(AVPicture *dst, const AVPicture *src,
763                               int width, int height)
764 {
765     const uint8_t *p, *p1;
766     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
767     int w;
768
769     p1 = src->data[0];
770     lum1 = dst->data[0];
771     cb1 = dst->data[1];
772     cr1 = dst->data[2];
773     for(;height > 0; height--) {
774         p = p1;
775         lum = lum1;
776         cb = cb1;
777         cr = cr1;
778         for(w = width; w >= 2; w -= 2) {
779             lum[0] = p[0];
780             cb[0] = p[1];
781             lum[1] = p[2];
782             cr[0] = p[3];
783             p += 4;
784             lum += 2;
785             cb++;
786             cr++;
787         }
788         p1 += src->linesize[0];
789         lum1 += dst->linesize[0];
790         cb1 += dst->linesize[1];
791         cr1 += dst->linesize[2];
792     }
793 }
794
795 static void yuv422p_to_yuv422(AVPicture *dst, const AVPicture *src,
796                               int width, int height)
797 {
798     uint8_t *p, *p1;
799     const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
800     int w;
801
802     p1 = dst->data[0];
803     lum1 = src->data[0];
804     cb1 = src->data[1];
805     cr1 = src->data[2];
806     for(;height > 0; height--) {
807         p = p1;
808         lum = lum1;
809         cb = cb1;
810         cr = cr1;
811         for(w = width; w >= 2; w -= 2) {
812             p[0] = lum[0];
813             p[1] = cb[0];
814             p[2] = lum[1];
815             p[3] = cr[0];
816             p += 4;
817             lum += 2;
818             cb++;
819             cr++;
820         }
821         p1 += dst->linesize[0];
822         lum1 += src->linesize[0];
823         cb1 += src->linesize[1];
824         cr1 += src->linesize[2];
825     }
826 }
827
828 static void yuv422p_to_uyvy422(AVPicture *dst, const AVPicture *src,
829                               int width, int height)
830 {
831     uint8_t *p, *p1;
832     const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
833     int w;
834
835     p1 = dst->data[0];
836     lum1 = src->data[0];
837     cb1 = src->data[1];
838     cr1 = src->data[2];
839     for(;height > 0; height--) {
840         p = p1;
841         lum = lum1;
842         cb = cb1;
843         cr = cr1;
844         for(w = width; w >= 2; w -= 2) {
845             p[1] = lum[0];
846             p[0] = cb[0];
847             p[3] = lum[1];
848             p[2] = cr[0];
849             p += 4;
850             lum += 2;
851             cb++;
852             cr++;
853         }
854         p1 += dst->linesize[0];
855         lum1 += src->linesize[0];
856         cb1 += src->linesize[1];
857         cr1 += src->linesize[2];
858     }
859 }
860
861
862
863 #define SCALEBITS 10
864 #define ONE_HALF  (1 << (SCALEBITS - 1))
865 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
866
867 #define YUV_TO_RGB1_CCIR(cb1, cr1)\
868 {\
869     cb = (cb1) - 128;\
870     cr = (cr1) - 128;\
871     r_add = FIX(1.40200*255.0/224.0) * cr + ONE_HALF;\
872     g_add = - FIX(0.34414*255.0/224.0) * cb - FIX(0.71414*255.0/224.0) * cr + \
873             ONE_HALF;\
874     b_add = FIX(1.77200*255.0/224.0) * cb + ONE_HALF;\
875 }
876
877 #define YUV_TO_RGB2_CCIR(r, g, b, y1)\
878 {\
879     y = ((y1) - 16) * FIX(255.0/219.0);\
880     r = cm[(y + r_add) >> SCALEBITS];\
881     g = cm[(y + g_add) >> SCALEBITS];\
882     b = cm[(y + b_add) >> SCALEBITS];\
883 }
884
885 #define YUV_TO_RGB1(cb1, cr1)\
886 {\
887     cb = (cb1) - 128;\
888     cr = (cr1) - 128;\
889     r_add = FIX(1.40200) * cr + ONE_HALF;\
890     g_add = - FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;\
891     b_add = FIX(1.77200) * cb + ONE_HALF;\
892 }
893
894 #define YUV_TO_RGB2(r, g, b, y1)\
895 {\
896     y = (y1) << SCALEBITS;\
897     r = cm[(y + r_add) >> SCALEBITS];\
898     g = cm[(y + g_add) >> SCALEBITS];\
899     b = cm[(y + b_add) >> SCALEBITS];\
900 }
901
902 #define Y_CCIR_TO_JPEG(y)\
903  cm[((y) * FIX(255.0/219.0) + (ONE_HALF - 16 * FIX(255.0/219.0))) >> SCALEBITS]
904
905 #define Y_JPEG_TO_CCIR(y)\
906  (((y) * FIX(219.0/255.0) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
907
908 #define C_CCIR_TO_JPEG(y)\
909  cm[(((y) - 128) * FIX(127.0/112.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS]
910
911 /* NOTE: the clamp is really necessary! */
912 static inline int C_JPEG_TO_CCIR(int y) {
913     y = (((y - 128) * FIX(112.0/127.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS);
914     if (y < 16)
915         y = 16;
916     return y;
917 }
918
919
920 #define RGB_TO_Y(r, g, b) \
921 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
922   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
923
924 #define RGB_TO_U(r1, g1, b1, shift)\
925 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
926      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
927
928 #define RGB_TO_V(r1, g1, b1, shift)\
929 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
930    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
931
932 #define RGB_TO_Y_CCIR(r, g, b) \
933 ((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + \
934   FIX(0.11400*219.0/255.0) * (b) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
935
936 #define RGB_TO_U_CCIR(r1, g1, b1, shift)\
937 (((- FIX(0.16874*224.0/255.0) * r1 - FIX(0.33126*224.0/255.0) * g1 +         \
938      FIX(0.50000*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
939
940 #define RGB_TO_V_CCIR(r1, g1, b1, shift)\
941 (((FIX(0.50000*224.0/255.0) * r1 - FIX(0.41869*224.0/255.0) * g1 -           \
942    FIX(0.08131*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
943
944 static uint8_t y_ccir_to_jpeg[256];
945 static uint8_t y_jpeg_to_ccir[256];
946 static uint8_t c_ccir_to_jpeg[256];
947 static uint8_t c_jpeg_to_ccir[256];
948
949 /* init various conversion tables */
950 static void img_convert_init(void)
951 {
952     int i;
953     uint8_t *cm = cropTbl + MAX_NEG_CROP;
954
955     for(i = 0;i < 256; i++) {
956         y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i);
957         y_jpeg_to_ccir[i] = Y_JPEG_TO_CCIR(i);
958         c_ccir_to_jpeg[i] = C_CCIR_TO_JPEG(i);
959         c_jpeg_to_ccir[i] = C_JPEG_TO_CCIR(i);
960     }
961 }
962
963 /* apply to each pixel the given table */
964 static void img_apply_table(uint8_t *dst, int dst_wrap, 
965                             const uint8_t *src, int src_wrap,
966                             int width, int height, const uint8_t *table1)
967 {
968     int n;
969     const uint8_t *s;
970     uint8_t *d;
971     const uint8_t *table;
972
973     table = table1;
974     for(;height > 0; height--) {
975         s = src;
976         d = dst;
977         n = width;
978         while (n >= 4) {
979             d[0] = table[s[0]];
980             d[1] = table[s[1]];
981             d[2] = table[s[2]];
982             d[3] = table[s[3]];
983             d += 4;
984             s += 4;
985             n -= 4;
986         }
987         while (n > 0) {
988             d[0] = table[s[0]];
989             d++;
990             s++;
991             n--;
992         }
993         dst += dst_wrap;
994         src += src_wrap;
995     }
996 }
997
998 /* XXX: use generic filter ? */
999 /* XXX: in most cases, the sampling position is incorrect */
1000
1001 /* 4x1 -> 1x1 */
1002 static void shrink41(uint8_t *dst, int dst_wrap, 
1003                      const uint8_t *src, int src_wrap,
1004                      int width, int height)
1005 {
1006     int w;
1007     const uint8_t *s;
1008     uint8_t *d;
1009
1010     for(;height > 0; height--) {
1011         s = src;
1012         d = dst;
1013         for(w = width;w > 0; w--) {
1014             d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2;
1015             s += 4;
1016             d++;
1017         }
1018         src += src_wrap;
1019         dst += dst_wrap;
1020     }
1021 }
1022
1023 /* 2x1 -> 1x1 */
1024 static void shrink21(uint8_t *dst, int dst_wrap, 
1025                      const uint8_t *src, int src_wrap,
1026                      int width, int height)
1027 {
1028     int w;
1029     const uint8_t *s;
1030     uint8_t *d;
1031
1032     for(;height > 0; height--) {
1033         s = src;
1034         d = dst;
1035         for(w = width;w > 0; w--) {
1036             d[0] = (s[0] + s[1]) >> 1;
1037             s += 2;
1038             d++;
1039         }
1040         src += src_wrap;
1041         dst += dst_wrap;
1042     }
1043 }
1044
1045 /* 1x2 -> 1x1 */
1046 static void shrink12(uint8_t *dst, int dst_wrap, 
1047                      const uint8_t *src, int src_wrap,
1048                      int width, int height)
1049 {
1050     int w;
1051     uint8_t *d;
1052     const uint8_t *s1, *s2;
1053
1054     for(;height > 0; height--) {
1055         s1 = src;
1056         s2 = s1 + src_wrap;
1057         d = dst;
1058         for(w = width;w >= 4; w-=4) {
1059             d[0] = (s1[0] + s2[0]) >> 1;
1060             d[1] = (s1[1] + s2[1]) >> 1;
1061             d[2] = (s1[2] + s2[2]) >> 1;
1062             d[3] = (s1[3] + s2[3]) >> 1;
1063             s1 += 4;
1064             s2 += 4;
1065             d += 4;
1066         }
1067         for(;w > 0; w--) {
1068             d[0] = (s1[0] + s2[0]) >> 1;
1069             s1++;
1070             s2++;
1071             d++;
1072         }
1073         src += 2 * src_wrap;
1074         dst += dst_wrap;
1075     }
1076 }
1077
1078 /* 2x2 -> 1x1 */
1079 static void shrink22(uint8_t *dst, int dst_wrap, 
1080                      const uint8_t *src, int src_wrap,
1081                      int width, int height)
1082 {
1083     int w;
1084     const uint8_t *s1, *s2;
1085     uint8_t *d;
1086
1087     for(;height > 0; height--) {
1088         s1 = src;
1089         s2 = s1 + src_wrap;
1090         d = dst;
1091         for(w = width;w >= 4; w-=4) {
1092             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
1093             d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;
1094             d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;
1095             d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;
1096             s1 += 8;
1097             s2 += 8;
1098             d += 4;
1099         }
1100         for(;w > 0; w--) {
1101             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
1102             s1 += 2;
1103             s2 += 2;
1104             d++;
1105         }
1106         src += 2 * src_wrap;
1107         dst += dst_wrap;
1108     }
1109 }
1110
1111 /* 4x4 -> 1x1 */
1112 static void shrink44(uint8_t *dst, int dst_wrap, 
1113                      const uint8_t *src, int src_wrap,
1114                      int width, int height)
1115 {
1116     int w;
1117     const uint8_t *s1, *s2, *s3, *s4;
1118     uint8_t *d;
1119
1120     for(;height > 0; height--) {
1121         s1 = src;
1122         s2 = s1 + src_wrap;
1123         s3 = s2 + src_wrap;
1124         s4 = s3 + src_wrap;
1125         d = dst;
1126         for(w = width;w > 0; w--) {
1127             d[0] = (s1[0] + s1[1] + s1[2] + s1[3] +
1128                     s2[0] + s2[1] + s2[2] + s2[3] +
1129                     s3[0] + s3[1] + s3[2] + s3[3] +
1130                     s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4;
1131             s1 += 4;
1132             s2 += 4;
1133             s3 += 4;
1134             s4 += 4;
1135             d++;
1136         }
1137         src += 4 * src_wrap;
1138         dst += dst_wrap;
1139     }
1140 }
1141
1142 static void grow21_line(uint8_t *dst, const uint8_t *src,
1143                         int width)
1144 {
1145     int w;
1146     const uint8_t *s1;
1147     uint8_t *d;
1148
1149     s1 = src;
1150     d = dst;
1151     for(w = width;w >= 4; w-=4) {
1152         d[1] = d[0] = s1[0];
1153         d[3] = d[2] = s1[1];
1154         s1 += 2;
1155         d += 4;
1156     }
1157     for(;w >= 2; w -= 2) {
1158         d[1] = d[0] = s1[0];
1159         s1 ++;
1160         d += 2;
1161     }
1162     /* only needed if width is not a multiple of two */
1163     /* XXX: veryfy that */
1164     if (w) {
1165         d[0] = s1[0];
1166     }
1167 }
1168
1169 static void grow41_line(uint8_t *dst, const uint8_t *src,
1170                         int width)
1171 {
1172     int w, v;
1173     const uint8_t *s1;
1174     uint8_t *d;
1175
1176     s1 = src;
1177     d = dst;
1178     for(w = width;w >= 4; w-=4) {
1179         v = s1[0];
1180         d[0] = v;
1181         d[1] = v;
1182         d[2] = v;
1183         d[3] = v;
1184         s1 ++;
1185         d += 4;
1186     }
1187 }
1188
1189 /* 1x1 -> 2x1 */
1190 static void grow21(uint8_t *dst, int dst_wrap,
1191                    const uint8_t *src, int src_wrap,
1192                    int width, int height)
1193 {
1194     for(;height > 0; height--) {
1195         grow21_line(dst, src, width);
1196         src += src_wrap;
1197         dst += dst_wrap;
1198     }
1199 }
1200
1201 /* 1x1 -> 2x2 */
1202 static void grow22(uint8_t *dst, int dst_wrap,
1203                    const uint8_t *src, int src_wrap,
1204                    int width, int height)
1205 {
1206     for(;height > 0; height--) {
1207         grow21_line(dst, src, width);
1208         if (height%2)
1209             src += src_wrap;
1210         dst += dst_wrap;
1211     }
1212 }
1213
1214 /* 1x1 -> 4x1 */
1215 static void grow41(uint8_t *dst, int dst_wrap,
1216                    const uint8_t *src, int src_wrap,
1217                    int width, int height)
1218 {
1219     for(;height > 0; height--) {
1220         grow41_line(dst, src, width);
1221         src += src_wrap;
1222         dst += dst_wrap;
1223     }
1224 }
1225
1226 /* 1x1 -> 4x4 */
1227 static void grow44(uint8_t *dst, int dst_wrap,
1228                    const uint8_t *src, int src_wrap,
1229                    int width, int height)
1230 {
1231     for(;height > 0; height--) {
1232         grow41_line(dst, src, width);
1233         if ((height & 3) == 1)
1234             src += src_wrap;
1235         dst += dst_wrap;
1236     }
1237 }
1238
1239 /* 1x2 -> 2x1 */
1240 static void conv411(uint8_t *dst, int dst_wrap, 
1241                     const uint8_t *src, int src_wrap,
1242                     int width, int height)
1243 {
1244     int w, c;
1245     const uint8_t *s1, *s2;
1246     uint8_t *d;
1247
1248     width>>=1;
1249
1250     for(;height > 0; height--) {
1251         s1 = src;
1252         s2 = src + src_wrap;
1253         d = dst;
1254         for(w = width;w > 0; w--) {
1255             c = (s1[0] + s2[0]) >> 1;
1256             d[0] = c;
1257             d[1] = c;
1258             s1++;
1259             s2++;
1260             d += 2;
1261         }
1262         src += src_wrap * 2;
1263         dst += dst_wrap;
1264     }
1265 }
1266
1267 /* XXX: add jpeg quantize code */
1268
1269 #define TRANSP_INDEX (6*6*6)
1270
1271 /* this is maybe slow, but allows for extensions */
1272 static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
1273 {
1274     return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));
1275 }
1276
1277 static void build_rgb_palette(uint8_t *palette, int has_alpha)
1278 {
1279     uint32_t *pal;
1280     static const uint8_t pal_value[6] = { 0x00, 0x33, 0x66, 0x99, 0xcc, 0xff };
1281     int i, r, g, b;
1282
1283     pal = (uint32_t *)palette;
1284     i = 0;
1285     for(r = 0; r < 6; r++) {
1286         for(g = 0; g < 6; g++) {
1287             for(b = 0; b < 6; b++) {
1288                 pal[i++] = (0xff << 24) | (pal_value[r] << 16) | 
1289                     (pal_value[g] << 8) | pal_value[b];
1290             }
1291         }
1292     }
1293     if (has_alpha)
1294         pal[i++] = 0;
1295     while (i < 256)
1296         pal[i++] = 0xff000000;
1297 }
1298
1299 /* copy bit n to bits 0 ... n - 1 */
1300 static inline unsigned int bitcopy_n(unsigned int a, int n)
1301 {
1302     int mask;
1303     mask = (1 << n) - 1;
1304     return (a & (0xff & ~mask)) | ((-((a >> n) & 1)) & mask);
1305 }
1306
1307 /* rgb555 handling */
1308
1309 #define RGB_NAME rgb555
1310
1311 #define RGB_IN(r, g, b, s)\
1312 {\
1313     unsigned int v = ((const uint16_t *)(s))[0];\
1314     r = bitcopy_n(v >> (10 - 3), 3);\
1315     g = bitcopy_n(v >> (5 - 3), 3);\
1316     b = bitcopy_n(v << 3, 3);\
1317 }
1318
1319 #define RGBA_IN(r, g, b, a, s)\
1320 {\
1321     unsigned int v = ((const uint16_t *)(s))[0];\
1322     r = bitcopy_n(v >> (10 - 3), 3);\
1323     g = bitcopy_n(v >> (5 - 3), 3);\
1324     b = bitcopy_n(v << 3, 3);\
1325     a = (-(v >> 15)) & 0xff;\
1326 }
1327
1328 #define RGBA_OUT(d, r, g, b, a)\
1329 {\
1330     ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3) | \
1331                            ((a << 8) & 0x8000);\
1332 }
1333
1334 #define BPP 2
1335
1336 #include "imgconvert_template.h"
1337
1338 /* rgb565 handling */
1339
1340 #define RGB_NAME rgb565
1341
1342 #define RGB_IN(r, g, b, s)\
1343 {\
1344     unsigned int v = ((const uint16_t *)(s))[0];\
1345     r = bitcopy_n(v >> (11 - 3), 3);\
1346     g = bitcopy_n(v >> (5 - 2), 2);\
1347     b = bitcopy_n(v << 3, 3);\
1348 }
1349
1350 #define RGB_OUT(d, r, g, b)\
1351 {\
1352     ((uint16_t *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);\
1353 }
1354
1355 #define BPP 2
1356
1357 #include "imgconvert_template.h"
1358
1359 /* bgr24 handling */
1360
1361 #define RGB_NAME bgr24
1362
1363 #define RGB_IN(r, g, b, s)\
1364 {\
1365     b = (s)[0];\
1366     g = (s)[1];\
1367     r = (s)[2];\
1368 }
1369
1370 #define RGB_OUT(d, r, g, b)\
1371 {\
1372     (d)[0] = b;\
1373     (d)[1] = g;\
1374     (d)[2] = r;\
1375 }
1376
1377 #define BPP 3
1378
1379 #include "imgconvert_template.h"
1380
1381 #undef RGB_IN
1382 #undef RGB_OUT
1383 #undef BPP
1384
1385 /* rgb24 handling */
1386
1387 #define RGB_NAME rgb24
1388 #define FMT_RGB24
1389
1390 #define RGB_IN(r, g, b, s)\
1391 {\
1392     r = (s)[0];\
1393     g = (s)[1];\
1394     b = (s)[2];\
1395 }
1396
1397 #define RGB_OUT(d, r, g, b)\
1398 {\
1399     (d)[0] = r;\
1400     (d)[1] = g;\
1401     (d)[2] = b;\
1402 }
1403
1404 #define BPP 3
1405
1406 #include "imgconvert_template.h"
1407
1408 /* rgba32 handling */
1409
1410 #define RGB_NAME rgba32
1411 #define FMT_RGBA32
1412
1413 #define RGB_IN(r, g, b, s)\
1414 {\
1415     unsigned int v = ((const uint32_t *)(s))[0];\
1416     r = (v >> 16) & 0xff;\
1417     g = (v >> 8) & 0xff;\
1418     b = v & 0xff;\
1419 }
1420
1421 #define RGBA_IN(r, g, b, a, s)\
1422 {\
1423     unsigned int v = ((const uint32_t *)(s))[0];\
1424     a = (v >> 24) & 0xff;\
1425     r = (v >> 16) & 0xff;\
1426     g = (v >> 8) & 0xff;\
1427     b = v & 0xff;\
1428 }
1429
1430 #define RGBA_OUT(d, r, g, b, a)\
1431 {\
1432     ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;\
1433 }
1434
1435 #define BPP 4
1436
1437 #include "imgconvert_template.h"
1438
1439 static void mono_to_gray(AVPicture *dst, const AVPicture *src,
1440                          int width, int height, int xor_mask)
1441 {
1442     const unsigned char *p;
1443     unsigned char *q;
1444     int v, dst_wrap, src_wrap;
1445     int y, w;
1446
1447     p = src->data[0];
1448     src_wrap = src->linesize[0] - ((width + 7) >> 3);
1449
1450     q = dst->data[0];
1451     dst_wrap = dst->linesize[0] - width;
1452     for(y=0;y<height;y++) {
1453         w = width; 
1454         while (w >= 8) {
1455             v = *p++ ^ xor_mask;
1456             q[0] = -(v >> 7);
1457             q[1] = -((v >> 6) & 1);
1458             q[2] = -((v >> 5) & 1);
1459             q[3] = -((v >> 4) & 1);
1460             q[4] = -((v >> 3) & 1);
1461             q[5] = -((v >> 2) & 1);
1462             q[6] = -((v >> 1) & 1);
1463             q[7] = -((v >> 0) & 1);
1464             w -= 8;
1465             q += 8;
1466         }
1467         if (w > 0) {
1468             v = *p++ ^ xor_mask;
1469             do {
1470                 q[0] = -((v >> 7) & 1);
1471                 q++;
1472                 v <<= 1;
1473             } while (--w);
1474         }
1475         p += src_wrap;
1476         q += dst_wrap;
1477     }
1478 }
1479
1480 static void monowhite_to_gray(AVPicture *dst, const AVPicture *src,
1481                                int width, int height)
1482 {
1483     mono_to_gray(dst, src, width, height, 0xff);
1484 }
1485
1486 static void monoblack_to_gray(AVPicture *dst, const AVPicture *src,
1487                                int width, int height)
1488 {
1489     mono_to_gray(dst, src, width, height, 0x00);
1490 }
1491
1492 static void gray_to_mono(AVPicture *dst, const AVPicture *src,
1493                          int width, int height, int xor_mask)
1494 {
1495     int n;
1496     const uint8_t *s;
1497     uint8_t *d;
1498     int j, b, v, n1, src_wrap, dst_wrap, y;
1499
1500     s = src->data[0];
1501     src_wrap = src->linesize[0] - width;
1502
1503     d = dst->data[0];
1504     dst_wrap = dst->linesize[0] - ((width + 7) >> 3);
1505
1506     for(y=0;y<height;y++) {
1507         n = width;
1508         while (n >= 8) {
1509             v = 0;
1510             for(j=0;j<8;j++) {
1511                 b = s[0];
1512                 s++;
1513                 v = (v << 1) | (b >> 7);
1514             }
1515             d[0] = v ^ xor_mask;
1516             d++;
1517             n -= 8;
1518         }
1519         if (n > 0) {
1520             n1 = n;
1521             v = 0;
1522             while (n > 0) {
1523                 b = s[0];
1524                 s++;
1525                 v = (v << 1) | (b >> 7);
1526                 n--;
1527             }
1528             d[0] = (v << (8 - (n1 & 7))) ^ xor_mask;
1529             d++;
1530         }
1531         s += src_wrap;
1532         d += dst_wrap;
1533     }
1534 }
1535
1536 static void gray_to_monowhite(AVPicture *dst, const AVPicture *src,
1537                               int width, int height)
1538 {
1539     gray_to_mono(dst, src, width, height, 0xff);
1540 }
1541
1542 static void gray_to_monoblack(AVPicture *dst, const AVPicture *src,
1543                               int width, int height)
1544 {
1545     gray_to_mono(dst, src, width, height, 0x00);
1546 }
1547
1548 typedef struct ConvertEntry {
1549     void (*convert)(AVPicture *dst,
1550                     const AVPicture *src, int width, int height);
1551 } ConvertEntry;
1552
1553 /* Add each new convertion function in this table. In order to be able
1554    to convert from any format to any format, the following constraints
1555    must be satisfied:
1556
1557    - all FF_COLOR_RGB formats must convert to and from PIX_FMT_RGB24 
1558
1559    - all FF_COLOR_GRAY formats must convert to and from PIX_FMT_GRAY8
1560
1561    - all FF_COLOR_RGB formats with alpha must convert to and from PIX_FMT_RGBA32
1562
1563    - PIX_FMT_YUV444P and PIX_FMT_YUVJ444P must convert to and from
1564      PIX_FMT_RGB24.
1565
1566    - PIX_FMT_422 must convert to and from PIX_FMT_422P.
1567
1568    The other conversion functions are just optimisations for common cases.
1569 */
1570 static ConvertEntry convert_table[PIX_FMT_NB][PIX_FMT_NB] = {
1571     [PIX_FMT_YUV420P] = {
1572         [PIX_FMT_RGB555] = { 
1573             .convert = yuv420p_to_rgb555
1574         },
1575         [PIX_FMT_RGB565] = { 
1576             .convert = yuv420p_to_rgb565
1577         },
1578         [PIX_FMT_BGR24] = { 
1579             .convert = yuv420p_to_bgr24
1580         },
1581         [PIX_FMT_RGB24] = { 
1582             .convert = yuv420p_to_rgb24
1583         },
1584         [PIX_FMT_RGBA32] = { 
1585             .convert = yuv420p_to_rgba32
1586         },
1587     },
1588     [PIX_FMT_YUV422P] = { 
1589         [PIX_FMT_YUV422] = { 
1590             .convert = yuv422p_to_yuv422,
1591         },
1592         [PIX_FMT_UYVY422] = { 
1593             .convert = yuv422p_to_uyvy422,
1594         },
1595     },
1596     [PIX_FMT_YUV444P] = { 
1597         [PIX_FMT_RGB24] = { 
1598             .convert = yuv444p_to_rgb24
1599         },
1600     },
1601     [PIX_FMT_YUVJ420P] = {
1602         [PIX_FMT_RGB555] = { 
1603             .convert = yuvj420p_to_rgb555
1604         },
1605         [PIX_FMT_RGB565] = { 
1606             .convert = yuvj420p_to_rgb565
1607         },
1608         [PIX_FMT_BGR24] = { 
1609             .convert = yuvj420p_to_bgr24
1610         },
1611         [PIX_FMT_RGB24] = { 
1612             .convert = yuvj420p_to_rgb24
1613         },
1614         [PIX_FMT_RGBA32] = { 
1615             .convert = yuvj420p_to_rgba32
1616         },
1617     },
1618     [PIX_FMT_YUVJ444P] = { 
1619         [PIX_FMT_RGB24] = { 
1620             .convert = yuvj444p_to_rgb24
1621         },
1622     },
1623     [PIX_FMT_YUV422] = { 
1624         [PIX_FMT_YUV420P] = { 
1625             .convert = yuv422_to_yuv420p,
1626         },
1627         [PIX_FMT_YUV422P] = { 
1628             .convert = yuv422_to_yuv422p,
1629         },
1630     },
1631     [PIX_FMT_UYVY422] = { 
1632         [PIX_FMT_YUV420P] = { 
1633             .convert = uyvy422_to_yuv420p,
1634         },
1635         [PIX_FMT_YUV422P] = { 
1636             .convert = uyvy422_to_yuv422p,
1637         },
1638     },
1639     [PIX_FMT_RGB24] = {
1640         [PIX_FMT_YUV420P] = { 
1641             .convert = rgb24_to_yuv420p
1642         },
1643         [PIX_FMT_RGB565] = { 
1644             .convert = rgb24_to_rgb565
1645         },
1646         [PIX_FMT_RGB555] = { 
1647             .convert = rgb24_to_rgb555
1648         },
1649         [PIX_FMT_RGBA32] = { 
1650             .convert = rgb24_to_rgba32
1651         },
1652         [PIX_FMT_BGR24] = { 
1653             .convert = rgb24_to_bgr24
1654         },
1655         [PIX_FMT_GRAY8] = { 
1656             .convert = rgb24_to_gray
1657         },
1658         [PIX_FMT_PAL8] = {
1659             .convert = rgb24_to_pal8
1660         },
1661         [PIX_FMT_YUV444P] = { 
1662             .convert = rgb24_to_yuv444p
1663         },
1664         [PIX_FMT_YUVJ420P] = { 
1665             .convert = rgb24_to_yuvj420p
1666         },
1667         [PIX_FMT_YUVJ444P] = { 
1668             .convert = rgb24_to_yuvj444p
1669         },
1670     },
1671     [PIX_FMT_RGBA32] = {
1672         [PIX_FMT_RGB24] = { 
1673             .convert = rgba32_to_rgb24
1674         },
1675         [PIX_FMT_RGB555] = { 
1676             .convert = rgba32_to_rgb555
1677         },
1678         [PIX_FMT_PAL8] = { 
1679             .convert = rgba32_to_pal8
1680         },
1681         [PIX_FMT_YUV420P] = { 
1682             .convert = rgba32_to_yuv420p
1683         },
1684         [PIX_FMT_GRAY8] = { 
1685             .convert = rgba32_to_gray
1686         },
1687     },
1688     [PIX_FMT_BGR24] = {
1689         [PIX_FMT_RGB24] = { 
1690             .convert = bgr24_to_rgb24
1691         },
1692         [PIX_FMT_YUV420P] = { 
1693             .convert = bgr24_to_yuv420p
1694         },
1695         [PIX_FMT_GRAY8] = { 
1696             .convert = bgr24_to_gray
1697         },
1698     },
1699     [PIX_FMT_RGB555] = {
1700         [PIX_FMT_RGB24] = { 
1701             .convert = rgb555_to_rgb24
1702         },
1703         [PIX_FMT_RGBA32] = { 
1704             .convert = rgb555_to_rgba32
1705         },
1706         [PIX_FMT_YUV420P] = { 
1707             .convert = rgb555_to_yuv420p
1708         },
1709         [PIX_FMT_GRAY8] = { 
1710             .convert = rgb555_to_gray
1711         },
1712     },
1713     [PIX_FMT_RGB565] = {
1714         [PIX_FMT_RGB24] = { 
1715             .convert = rgb565_to_rgb24
1716         },
1717         [PIX_FMT_YUV420P] = { 
1718             .convert = rgb565_to_yuv420p
1719         },
1720         [PIX_FMT_GRAY8] = { 
1721             .convert = rgb565_to_gray
1722         },
1723     },
1724     [PIX_FMT_GRAY8] = {
1725         [PIX_FMT_RGB555] = { 
1726             .convert = gray_to_rgb555
1727         },
1728         [PIX_FMT_RGB565] = { 
1729             .convert = gray_to_rgb565
1730         },
1731         [PIX_FMT_RGB24] = { 
1732             .convert = gray_to_rgb24
1733         },
1734         [PIX_FMT_BGR24] = { 
1735             .convert = gray_to_bgr24
1736         },
1737         [PIX_FMT_RGBA32] = { 
1738             .convert = gray_to_rgba32
1739         },
1740         [PIX_FMT_MONOWHITE] = { 
1741             .convert = gray_to_monowhite
1742         },
1743         [PIX_FMT_MONOBLACK] = { 
1744             .convert = gray_to_monoblack
1745         },
1746     },
1747     [PIX_FMT_MONOWHITE] = {
1748         [PIX_FMT_GRAY8] = { 
1749             .convert = monowhite_to_gray
1750         },
1751     },
1752     [PIX_FMT_MONOBLACK] = {
1753         [PIX_FMT_GRAY8] = { 
1754             .convert = monoblack_to_gray
1755         },
1756     },
1757     [PIX_FMT_PAL8] = {
1758         [PIX_FMT_RGB555] = { 
1759             .convert = pal8_to_rgb555
1760         },
1761         [PIX_FMT_RGB565] = { 
1762             .convert = pal8_to_rgb565
1763         },
1764         [PIX_FMT_BGR24] = { 
1765             .convert = pal8_to_bgr24
1766         },
1767         [PIX_FMT_RGB24] = { 
1768             .convert = pal8_to_rgb24
1769         },
1770         [PIX_FMT_RGBA32] = { 
1771             .convert = pal8_to_rgba32
1772         },
1773     },
1774 };
1775
1776 int avpicture_alloc(AVPicture *picture,
1777                            int pix_fmt, int width, int height)
1778 {
1779     unsigned int size;
1780     void *ptr;
1781
1782     size = avpicture_get_size(pix_fmt, width, height);
1783     ptr = av_malloc(size);
1784     if (!ptr)
1785         goto fail;
1786     avpicture_fill(picture, ptr, pix_fmt, width, height);
1787     return 0;
1788  fail:
1789     memset(picture, 0, sizeof(AVPicture));
1790     return -1;
1791 }
1792
1793 void avpicture_free(AVPicture *picture)
1794 {
1795     av_free(picture->data[0]);
1796 }
1797
1798 /* return true if yuv planar */
1799 static inline int is_yuv_planar(PixFmtInfo *ps)
1800 {
1801     return (ps->color_type == FF_COLOR_YUV ||
1802             ps->color_type == FF_COLOR_YUV_JPEG) && 
1803         ps->pixel_type == FF_PIXEL_PLANAR;
1804 }
1805
1806 /* XXX: always use linesize. Return -1 if not supported */
1807 int img_convert(AVPicture *dst, int dst_pix_fmt,
1808                 const AVPicture *src, int src_pix_fmt, 
1809                 int src_width, int src_height)
1810 {
1811     static int inited;
1812     int i, ret, dst_width, dst_height, int_pix_fmt;
1813     PixFmtInfo *src_pix, *dst_pix;
1814     ConvertEntry *ce;
1815     AVPicture tmp1, *tmp = &tmp1;
1816
1817     if (src_pix_fmt < 0 || src_pix_fmt >= PIX_FMT_NB ||
1818         dst_pix_fmt < 0 || dst_pix_fmt >= PIX_FMT_NB)
1819         return -1;
1820     if (src_width <= 0 || src_height <= 0)
1821         return 0;
1822
1823     if (!inited) {
1824         inited = 1;
1825         img_convert_init();
1826     }
1827
1828     dst_width = src_width;
1829     dst_height = src_height;
1830
1831     dst_pix = &pix_fmt_info[dst_pix_fmt];
1832     src_pix = &pix_fmt_info[src_pix_fmt];
1833     if (src_pix_fmt == dst_pix_fmt) {
1834         /* no conversion needed: just copy */
1835         img_copy(dst, src, dst_pix_fmt, dst_width, dst_height);
1836         return 0;
1837     }
1838
1839     ce = &convert_table[src_pix_fmt][dst_pix_fmt];
1840     if (ce->convert) {
1841         /* specific conversion routine */
1842         ce->convert(dst, src, dst_width, dst_height);
1843         return 0;
1844     }
1845
1846     /* gray to YUV */
1847     if (is_yuv_planar(dst_pix) &&
1848         src_pix_fmt == PIX_FMT_GRAY8) {
1849         int w, h, y;
1850         uint8_t *d;
1851
1852         if (dst_pix->color_type == FF_COLOR_YUV_JPEG) {
1853             img_copy_plane(dst->data[0], dst->linesize[0],
1854                      src->data[0], src->linesize[0],
1855                      dst_width, dst_height);
1856         } else {
1857             img_apply_table(dst->data[0], dst->linesize[0],
1858                             src->data[0], src->linesize[0],
1859                             dst_width, dst_height,
1860                             y_jpeg_to_ccir);
1861         }
1862         /* fill U and V with 128 */
1863         w = dst_width;
1864         h = dst_height;
1865         w >>= dst_pix->x_chroma_shift;
1866         h >>= dst_pix->y_chroma_shift;
1867         for(i = 1; i <= 2; i++) {
1868             d = dst->data[i];
1869             for(y = 0; y< h; y++) {
1870                 memset(d, 128, w);
1871                 d += dst->linesize[i];
1872             }
1873         }
1874         return 0;
1875     }
1876
1877     /* YUV to gray */
1878     if (is_yuv_planar(src_pix) && 
1879         dst_pix_fmt == PIX_FMT_GRAY8) {
1880         if (src_pix->color_type == FF_COLOR_YUV_JPEG) {
1881             img_copy_plane(dst->data[0], dst->linesize[0],
1882                      src->data[0], src->linesize[0],
1883                      dst_width, dst_height);
1884         } else {
1885             img_apply_table(dst->data[0], dst->linesize[0],
1886                             src->data[0], src->linesize[0],
1887                             dst_width, dst_height,
1888                             y_ccir_to_jpeg);
1889         }
1890         return 0;
1891     }
1892
1893     /* YUV to YUV planar */
1894     if (is_yuv_planar(dst_pix) && is_yuv_planar(src_pix)) {
1895         int x_shift, y_shift, w, h, xy_shift;
1896         void (*resize_func)(uint8_t *dst, int dst_wrap, 
1897                             const uint8_t *src, int src_wrap,
1898                             int width, int height);
1899
1900         /* compute chroma size of the smallest dimensions */
1901         w = dst_width;
1902         h = dst_height;
1903         if (dst_pix->x_chroma_shift >= src_pix->x_chroma_shift)
1904             w >>= dst_pix->x_chroma_shift;
1905         else
1906             w >>= src_pix->x_chroma_shift;
1907         if (dst_pix->y_chroma_shift >= src_pix->y_chroma_shift)
1908             h >>= dst_pix->y_chroma_shift;
1909         else
1910             h >>= src_pix->y_chroma_shift;
1911
1912         x_shift = (dst_pix->x_chroma_shift - src_pix->x_chroma_shift);
1913         y_shift = (dst_pix->y_chroma_shift - src_pix->y_chroma_shift);
1914         xy_shift = ((x_shift & 0xf) << 4) | (y_shift & 0xf);
1915         /* there must be filters for conversion at least from and to
1916            YUV444 format */
1917         switch(xy_shift) {
1918         case 0x00:
1919             resize_func = img_copy_plane;
1920             break;
1921         case 0x10:
1922             resize_func = shrink21;
1923             break;
1924         case 0x20:
1925             resize_func = shrink41;
1926             break;
1927         case 0x01:
1928             resize_func = shrink12;
1929             break;
1930         case 0x11:
1931             resize_func = shrink22;
1932             break;
1933         case 0x22:
1934             resize_func = shrink44;
1935             break;
1936         case 0xf0:
1937             resize_func = grow21;
1938             break;
1939         case 0xe0:
1940             resize_func = grow41;
1941             break;
1942         case 0xff:
1943             resize_func = grow22;
1944             break;
1945         case 0xee:
1946             resize_func = grow44;
1947             break;
1948         case 0xf1:
1949             resize_func = conv411;
1950             break;
1951         default:
1952             /* currently not handled */
1953             goto no_chroma_filter;
1954         }
1955
1956         img_copy_plane(dst->data[0], dst->linesize[0],
1957                        src->data[0], src->linesize[0],
1958                        dst_width, dst_height);
1959
1960         for(i = 1;i <= 2; i++)
1961             resize_func(dst->data[i], dst->linesize[i],
1962                         src->data[i], src->linesize[i],
1963                         dst_width>>dst_pix->x_chroma_shift, dst_height>>dst_pix->y_chroma_shift);
1964         /* if yuv color space conversion is needed, we do it here on
1965            the destination image */
1966         if (dst_pix->color_type != src_pix->color_type) {
1967             const uint8_t *y_table, *c_table;
1968             if (dst_pix->color_type == FF_COLOR_YUV) {
1969                 y_table = y_jpeg_to_ccir;
1970                 c_table = c_jpeg_to_ccir;
1971             } else {
1972                 y_table = y_ccir_to_jpeg;
1973                 c_table = c_ccir_to_jpeg;
1974             }
1975             img_apply_table(dst->data[0], dst->linesize[0],
1976                             dst->data[0], dst->linesize[0],
1977                             dst_width, dst_height,
1978                             y_table);
1979
1980             for(i = 1;i <= 2; i++)
1981                 img_apply_table(dst->data[i], dst->linesize[i],
1982                                 dst->data[i], dst->linesize[i],
1983                                 dst_width>>dst_pix->x_chroma_shift, 
1984                                 dst_height>>dst_pix->y_chroma_shift,
1985                                 c_table);
1986         }
1987         return 0;
1988     }
1989  no_chroma_filter:
1990
1991     /* try to use an intermediate format */
1992     if (src_pix_fmt == PIX_FMT_YUV422 ||
1993         dst_pix_fmt == PIX_FMT_YUV422) {
1994         /* specific case: convert to YUV422P first */
1995         int_pix_fmt = PIX_FMT_YUV422P;
1996     } else if (src_pix_fmt == PIX_FMT_UYVY422 ||
1997         dst_pix_fmt == PIX_FMT_UYVY422) {
1998         /* specific case: convert to YUV422P first */
1999         int_pix_fmt = PIX_FMT_YUV422P;
2000     } else if ((src_pix->color_type == FF_COLOR_GRAY &&
2001                 src_pix_fmt != PIX_FMT_GRAY8) || 
2002                (dst_pix->color_type == FF_COLOR_GRAY &&
2003                 dst_pix_fmt != PIX_FMT_GRAY8)) {
2004         /* gray8 is the normalized format */
2005         int_pix_fmt = PIX_FMT_GRAY8;
2006     } else if ((is_yuv_planar(src_pix) && 
2007                 src_pix_fmt != PIX_FMT_YUV444P &&
2008                 src_pix_fmt != PIX_FMT_YUVJ444P)) {
2009         /* yuv444 is the normalized format */
2010         if (src_pix->color_type == FF_COLOR_YUV_JPEG)
2011             int_pix_fmt = PIX_FMT_YUVJ444P;
2012         else
2013             int_pix_fmt = PIX_FMT_YUV444P;
2014     } else if ((is_yuv_planar(dst_pix) && 
2015                 dst_pix_fmt != PIX_FMT_YUV444P &&
2016                 dst_pix_fmt != PIX_FMT_YUVJ444P)) {
2017         /* yuv444 is the normalized format */
2018         if (dst_pix->color_type == FF_COLOR_YUV_JPEG)
2019             int_pix_fmt = PIX_FMT_YUVJ444P;
2020         else
2021             int_pix_fmt = PIX_FMT_YUV444P;
2022     } else {
2023         /* the two formats are rgb or gray8 or yuv[j]444p */
2024         if (src_pix->is_alpha && dst_pix->is_alpha)
2025             int_pix_fmt = PIX_FMT_RGBA32;
2026         else
2027             int_pix_fmt = PIX_FMT_RGB24;
2028     }
2029     if (avpicture_alloc(tmp, int_pix_fmt, dst_width, dst_height) < 0)
2030         return -1;
2031     ret = -1;
2032     if (img_convert(tmp, int_pix_fmt,
2033                     src, src_pix_fmt, src_width, src_height) < 0)
2034         goto fail1;
2035     if (img_convert(dst, dst_pix_fmt,
2036                     tmp, int_pix_fmt, dst_width, dst_height) < 0)
2037         goto fail1;
2038     ret = 0;
2039  fail1:
2040     avpicture_free(tmp);
2041     return ret;
2042 }
2043
2044 /* NOTE: we scan all the pixels to have an exact information */
2045 static int get_alpha_info_pal8(const AVPicture *src, int width, int height)
2046 {
2047     const unsigned char *p;
2048     int src_wrap, ret, x, y;
2049     unsigned int a;
2050     uint32_t *palette = (uint32_t *)src->data[1];
2051     
2052     p = src->data[0];
2053     src_wrap = src->linesize[0] - width;
2054     ret = 0;
2055     for(y=0;y<height;y++) {
2056         for(x=0;x<width;x++) {
2057             a = palette[p[0]] >> 24;
2058             if (a == 0x00) {
2059                 ret |= FF_ALPHA_TRANSP;
2060             } else if (a != 0xff) {
2061                 ret |= FF_ALPHA_SEMI_TRANSP;
2062             }
2063             p++;
2064         }
2065         p += src_wrap;
2066     }
2067     return ret;
2068 }
2069
2070 /**
2071  * Tell if an image really has transparent alpha values.
2072  * @return ored mask of FF_ALPHA_xxx constants
2073  */
2074 int img_get_alpha_info(const AVPicture *src,
2075                        int pix_fmt, int width, int height)
2076 {
2077     PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
2078     int ret;
2079
2080     pf = &pix_fmt_info[pix_fmt];
2081     /* no alpha can be represented in format */
2082     if (!pf->is_alpha)
2083         return 0;
2084     switch(pix_fmt) {
2085     case PIX_FMT_RGBA32:
2086         ret = get_alpha_info_rgba32(src, width, height);
2087         break;
2088     case PIX_FMT_RGB555:
2089         ret = get_alpha_info_rgb555(src, width, height);
2090         break;
2091     case PIX_FMT_PAL8:
2092         ret = get_alpha_info_pal8(src, width, height);
2093         break;
2094     default:
2095         /* we do not know, so everything is indicated */
2096         ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP;
2097         break;
2098     }
2099     return ret;
2100 }
2101
2102 #ifdef HAVE_MMX
2103 #define DEINT_INPLACE_LINE_LUM \
2104                     movd_m2r(lum_m4[0],mm0);\
2105                     movd_m2r(lum_m3[0],mm1);\
2106                     movd_m2r(lum_m2[0],mm2);\
2107                     movd_m2r(lum_m1[0],mm3);\
2108                     movd_m2r(lum[0],mm4);\
2109                     punpcklbw_r2r(mm7,mm0);\
2110                     movd_r2m(mm2,lum_m4[0]);\
2111                     punpcklbw_r2r(mm7,mm1);\
2112                     punpcklbw_r2r(mm7,mm2);\
2113                     punpcklbw_r2r(mm7,mm3);\
2114                     punpcklbw_r2r(mm7,mm4);\
2115                     paddw_r2r(mm3,mm1);\
2116                     psllw_i2r(1,mm2);\
2117                     paddw_r2r(mm4,mm0);\
2118                     psllw_i2r(2,mm1);\
2119                     paddw_r2r(mm6,mm2);\
2120                     paddw_r2r(mm2,mm1);\
2121                     psubusw_r2r(mm0,mm1);\
2122                     psrlw_i2r(3,mm1);\
2123                     packuswb_r2r(mm7,mm1);\
2124                     movd_r2m(mm1,lum_m2[0]);
2125
2126 #define DEINT_LINE_LUM \
2127                     movd_m2r(lum_m4[0],mm0);\
2128                     movd_m2r(lum_m3[0],mm1);\
2129                     movd_m2r(lum_m2[0],mm2);\
2130                     movd_m2r(lum_m1[0],mm3);\
2131                     movd_m2r(lum[0],mm4);\
2132                     punpcklbw_r2r(mm7,mm0);\
2133                     punpcklbw_r2r(mm7,mm1);\
2134                     punpcklbw_r2r(mm7,mm2);\
2135                     punpcklbw_r2r(mm7,mm3);\
2136                     punpcklbw_r2r(mm7,mm4);\
2137                     paddw_r2r(mm3,mm1);\
2138                     psllw_i2r(1,mm2);\
2139                     paddw_r2r(mm4,mm0);\
2140                     psllw_i2r(2,mm1);\
2141                     paddw_r2r(mm6,mm2);\
2142                     paddw_r2r(mm2,mm1);\
2143                     psubusw_r2r(mm0,mm1);\
2144                     psrlw_i2r(3,mm1);\
2145                     packuswb_r2r(mm7,mm1);\
2146                     movd_r2m(mm1,dst[0]);
2147 #endif
2148
2149 /* filter parameters: [-1 4 2 4 -1] // 8 */
2150 static void deinterlace_line(uint8_t *dst, 
2151                              const uint8_t *lum_m4, const uint8_t *lum_m3, 
2152                              const uint8_t *lum_m2, const uint8_t *lum_m1, 
2153                              const uint8_t *lum,
2154                              int size)
2155 {
2156 #ifndef HAVE_MMX
2157     uint8_t *cm = cropTbl + MAX_NEG_CROP;
2158     int sum;
2159
2160     for(;size > 0;size--) {
2161         sum = -lum_m4[0];
2162         sum += lum_m3[0] << 2;
2163         sum += lum_m2[0] << 1;
2164         sum += lum_m1[0] << 2;
2165         sum += -lum[0];
2166         dst[0] = cm[(sum + 4) >> 3];
2167         lum_m4++;
2168         lum_m3++;
2169         lum_m2++;
2170         lum_m1++;
2171         lum++;
2172         dst++;
2173     }
2174 #else
2175
2176     {
2177         mmx_t rounder;
2178         rounder.uw[0]=4;
2179         rounder.uw[1]=4;
2180         rounder.uw[2]=4;
2181         rounder.uw[3]=4;
2182         pxor_r2r(mm7,mm7);
2183         movq_m2r(rounder,mm6);
2184     }
2185     for (;size > 3; size-=4) {
2186         DEINT_LINE_LUM
2187         lum_m4+=4;
2188         lum_m3+=4;
2189         lum_m2+=4;
2190         lum_m1+=4;
2191         lum+=4;
2192         dst+=4;
2193     }
2194 #endif
2195 }
2196 static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum,
2197                              int size)
2198 {
2199 #ifndef HAVE_MMX
2200     uint8_t *cm = cropTbl + MAX_NEG_CROP;
2201     int sum;
2202
2203     for(;size > 0;size--) {
2204         sum = -lum_m4[0];
2205         sum += lum_m3[0] << 2;
2206         sum += lum_m2[0] << 1;
2207         lum_m4[0]=lum_m2[0];
2208         sum += lum_m1[0] << 2;
2209         sum += -lum[0];
2210         lum_m2[0] = cm[(sum + 4) >> 3];
2211         lum_m4++;
2212         lum_m3++;
2213         lum_m2++;
2214         lum_m1++;
2215         lum++;
2216     }
2217 #else
2218
2219     {
2220         mmx_t rounder;
2221         rounder.uw[0]=4;
2222         rounder.uw[1]=4;
2223         rounder.uw[2]=4;
2224         rounder.uw[3]=4;
2225         pxor_r2r(mm7,mm7);
2226         movq_m2r(rounder,mm6);
2227     }
2228     for (;size > 3; size-=4) {
2229         DEINT_INPLACE_LINE_LUM
2230         lum_m4+=4;
2231         lum_m3+=4;
2232         lum_m2+=4;
2233         lum_m1+=4;
2234         lum+=4;
2235     }
2236 #endif
2237 }
2238
2239 /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
2240    top field is copied as is, but the bottom field is deinterlaced
2241    against the top field. */
2242 static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap,
2243                                     const uint8_t *src1, int src_wrap,
2244                                     int width, int height)
2245 {
2246     const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
2247     int y;
2248
2249     src_m2 = src1;
2250     src_m1 = src1;
2251     src_0=&src_m1[src_wrap];
2252     src_p1=&src_0[src_wrap];
2253     src_p2=&src_p1[src_wrap];
2254     for(y=0;y<(height-2);y+=2) {
2255         memcpy(dst,src_m1,width);
2256         dst += dst_wrap;
2257         deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width);
2258         src_m2 = src_0;
2259         src_m1 = src_p1;
2260         src_0 = src_p2;
2261         src_p1 += 2*src_wrap;
2262         src_p2 += 2*src_wrap;
2263         dst += dst_wrap;
2264     }
2265     memcpy(dst,src_m1,width);
2266     dst += dst_wrap;
2267     /* do last line */
2268     deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);
2269 }
2270
2271 static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap,
2272                                              int width, int height)
2273 {
2274     uint8_t *src_m1, *src_0, *src_p1, *src_p2;
2275     int y;
2276     uint8_t *buf;
2277     buf = (uint8_t*)av_malloc(width);
2278
2279     src_m1 = src1;
2280     memcpy(buf,src_m1,width);
2281     src_0=&src_m1[src_wrap];
2282     src_p1=&src_0[src_wrap];
2283     src_p2=&src_p1[src_wrap];
2284     for(y=0;y<(height-2);y+=2) {
2285         deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width);
2286         src_m1 = src_p1;
2287         src_0 = src_p2;
2288         src_p1 += 2*src_wrap;
2289         src_p2 += 2*src_wrap;
2290     }
2291     /* do last line */
2292     deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width);
2293     av_free(buf);
2294 }
2295
2296
2297 /* deinterlace - if not supported return -1 */
2298 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
2299                           int pix_fmt, int width, int height)
2300 {
2301     int i;
2302
2303     if (pix_fmt != PIX_FMT_YUV420P &&
2304         pix_fmt != PIX_FMT_YUV422P &&
2305         pix_fmt != PIX_FMT_YUV444P &&
2306         pix_fmt != PIX_FMT_YUV411P)
2307         return -1;
2308     if ((width & 3) != 0 || (height & 3) != 0)
2309         return -1;
2310
2311     for(i=0;i<3;i++) {
2312         if (i == 1) {
2313             switch(pix_fmt) {
2314             case PIX_FMT_YUV420P:
2315                 width >>= 1;
2316                 height >>= 1;
2317                 break;
2318             case PIX_FMT_YUV422P:
2319                 width >>= 1;
2320                 break;
2321             case PIX_FMT_YUV411P:
2322                 width >>= 2;
2323                 break;
2324             default:
2325                 break;
2326             }
2327         }
2328         if (src == dst) {
2329             deinterlace_bottom_field_inplace(dst->data[i], dst->linesize[i],
2330                                  width, height);
2331         } else {
2332             deinterlace_bottom_field(dst->data[i],dst->linesize[i],
2333                                         src->data[i], src->linesize[i],
2334                                         width, height);
2335         }
2336     }
2337 #ifdef HAVE_MMX
2338     emms();
2339 #endif
2340     return 0;
2341 }
2342
2343 #undef FIX