typo
[ffmpeg.git] / libavcodec / imgconvert.c
1 /*
2  * Misc image conversion routines
3  * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file imgconvert.c
24  * misc image conversion routines
25  */
26
27 /* TODO:
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
31  */
32
33 #include "avcodec.h"
34 #include "dsputil.h"
35 #include "colorspace.h"
36
37 #ifdef HAVE_MMX
38 #include "i386/mmx.h"
39 #endif
40
41 #define xglue(x, y) x ## y
42 #define glue(x, y) xglue(x, y)
43
44 #define FF_COLOR_RGB      0 /**< RGB color space */
45 #define FF_COLOR_GRAY     1 /**< gray color space */
46 #define FF_COLOR_YUV      2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
47 #define FF_COLOR_YUV_JPEG 3 /**< YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
48
49 #define FF_PIXEL_PLANAR   0 /**< each channel has one component in AVPicture */
50 #define FF_PIXEL_PACKED   1 /**< only one components containing all the channels */
51 #define FF_PIXEL_PALETTE  2  /**< one components containing indexes for a palette */
52
53 typedef struct PixFmtInfo {
54     const char *name;
55     uint8_t nb_channels;     /**< number of channels (including alpha) */
56     uint8_t color_type;      /**< color type (see FF_COLOR_xxx constants) */
57     uint8_t pixel_type;      /**< pixel storage type (see FF_PIXEL_xxx constants) */
58     uint8_t is_alpha : 1;    /**< true if alpha can be specified */
59     uint8_t x_chroma_shift;  /**< X chroma subsampling factor is 2 ^ shift */
60     uint8_t y_chroma_shift;  /**< Y chroma subsampling factor is 2 ^ shift */
61     uint8_t depth;           /**< bit depth of the color components */
62 } PixFmtInfo;
63
64 /* this table gives more information about formats */
65 static const PixFmtInfo pix_fmt_info[PIX_FMT_NB] = {
66     /* YUV formats */
67     [PIX_FMT_YUV420P] = {
68         .name = "yuv420p",
69         .nb_channels = 3,
70         .color_type = FF_COLOR_YUV,
71         .pixel_type = FF_PIXEL_PLANAR,
72         .depth = 8,
73         .x_chroma_shift = 1, .y_chroma_shift = 1,
74     },
75     [PIX_FMT_YUV422P] = {
76         .name = "yuv422p",
77         .nb_channels = 3,
78         .color_type = FF_COLOR_YUV,
79         .pixel_type = FF_PIXEL_PLANAR,
80         .depth = 8,
81         .x_chroma_shift = 1, .y_chroma_shift = 0,
82     },
83     [PIX_FMT_YUV444P] = {
84         .name = "yuv444p",
85         .nb_channels = 3,
86         .color_type = FF_COLOR_YUV,
87         .pixel_type = FF_PIXEL_PLANAR,
88         .depth = 8,
89         .x_chroma_shift = 0, .y_chroma_shift = 0,
90     },
91     [PIX_FMT_YUYV422] = {
92         .name = "yuyv422",
93         .nb_channels = 1,
94         .color_type = FF_COLOR_YUV,
95         .pixel_type = FF_PIXEL_PACKED,
96         .depth = 8,
97         .x_chroma_shift = 1, .y_chroma_shift = 0,
98     },
99     [PIX_FMT_UYVY422] = {
100         .name = "uyvy422",
101         .nb_channels = 1,
102         .color_type = FF_COLOR_YUV,
103         .pixel_type = FF_PIXEL_PACKED,
104         .depth = 8,
105         .x_chroma_shift = 1, .y_chroma_shift = 0,
106     },
107     [PIX_FMT_YUV410P] = {
108         .name = "yuv410p",
109         .nb_channels = 3,
110         .color_type = FF_COLOR_YUV,
111         .pixel_type = FF_PIXEL_PLANAR,
112         .depth = 8,
113         .x_chroma_shift = 2, .y_chroma_shift = 2,
114     },
115     [PIX_FMT_YUV411P] = {
116         .name = "yuv411p",
117         .nb_channels = 3,
118         .color_type = FF_COLOR_YUV,
119         .pixel_type = FF_PIXEL_PLANAR,
120         .depth = 8,
121         .x_chroma_shift = 2, .y_chroma_shift = 0,
122     },
123     [PIX_FMT_YUV440P] = {
124         .name = "yuv440p",
125         .nb_channels = 3,
126         .color_type = FF_COLOR_YUV,
127         .pixel_type = FF_PIXEL_PLANAR,
128         .depth = 8,
129         .x_chroma_shift = 0, .y_chroma_shift = 1,
130     },
131
132     /* YUV formats with alpha plane */
133     [PIX_FMT_YUVA420P] = {
134         .name = "yuva420p",
135         .nb_channels = 4,
136         .color_type = FF_COLOR_YUV,
137         .pixel_type = FF_PIXEL_PLANAR,
138         .depth = 8,
139         .x_chroma_shift = 1, .y_chroma_shift = 1,
140     },
141
142     /* JPEG YUV */
143     [PIX_FMT_YUVJ420P] = {
144         .name = "yuvj420p",
145         .nb_channels = 3,
146         .color_type = FF_COLOR_YUV_JPEG,
147         .pixel_type = FF_PIXEL_PLANAR,
148         .depth = 8,
149         .x_chroma_shift = 1, .y_chroma_shift = 1,
150     },
151     [PIX_FMT_YUVJ422P] = {
152         .name = "yuvj422p",
153         .nb_channels = 3,
154         .color_type = FF_COLOR_YUV_JPEG,
155         .pixel_type = FF_PIXEL_PLANAR,
156         .depth = 8,
157         .x_chroma_shift = 1, .y_chroma_shift = 0,
158     },
159     [PIX_FMT_YUVJ444P] = {
160         .name = "yuvj444p",
161         .nb_channels = 3,
162         .color_type = FF_COLOR_YUV_JPEG,
163         .pixel_type = FF_PIXEL_PLANAR,
164         .depth = 8,
165         .x_chroma_shift = 0, .y_chroma_shift = 0,
166     },
167     [PIX_FMT_YUVJ440P] = {
168         .name = "yuvj440p",
169         .nb_channels = 3,
170         .color_type = FF_COLOR_YUV_JPEG,
171         .pixel_type = FF_PIXEL_PLANAR,
172         .depth = 8,
173         .x_chroma_shift = 0, .y_chroma_shift = 1,
174     },
175
176     /* RGB formats */
177     [PIX_FMT_RGB24] = {
178         .name = "rgb24",
179         .nb_channels = 3,
180         .color_type = FF_COLOR_RGB,
181         .pixel_type = FF_PIXEL_PACKED,
182         .depth = 8,
183         .x_chroma_shift = 0, .y_chroma_shift = 0,
184     },
185     [PIX_FMT_BGR24] = {
186         .name = "bgr24",
187         .nb_channels = 3,
188         .color_type = FF_COLOR_RGB,
189         .pixel_type = FF_PIXEL_PACKED,
190         .depth = 8,
191         .x_chroma_shift = 0, .y_chroma_shift = 0,
192     },
193     [PIX_FMT_RGB32] = {
194         .name = "rgb32",
195         .nb_channels = 4, .is_alpha = 1,
196         .color_type = FF_COLOR_RGB,
197         .pixel_type = FF_PIXEL_PACKED,
198         .depth = 8,
199         .x_chroma_shift = 0, .y_chroma_shift = 0,
200     },
201     [PIX_FMT_RGB565] = {
202         .name = "rgb565",
203         .nb_channels = 3,
204         .color_type = FF_COLOR_RGB,
205         .pixel_type = FF_PIXEL_PACKED,
206         .depth = 5,
207         .x_chroma_shift = 0, .y_chroma_shift = 0,
208     },
209     [PIX_FMT_RGB555] = {
210         .name = "rgb555",
211         .nb_channels = 3,
212         .color_type = FF_COLOR_RGB,
213         .pixel_type = FF_PIXEL_PACKED,
214         .depth = 5,
215         .x_chroma_shift = 0, .y_chroma_shift = 0,
216     },
217
218     /* gray / mono formats */
219     [PIX_FMT_GRAY16BE] = {
220         .name = "gray16be",
221         .nb_channels = 1,
222         .color_type = FF_COLOR_GRAY,
223         .pixel_type = FF_PIXEL_PLANAR,
224         .depth = 16,
225     },
226     [PIX_FMT_GRAY16LE] = {
227         .name = "gray16le",
228         .nb_channels = 1,
229         .color_type = FF_COLOR_GRAY,
230         .pixel_type = FF_PIXEL_PLANAR,
231         .depth = 16,
232     },
233     [PIX_FMT_GRAY8] = {
234         .name = "gray",
235         .nb_channels = 1,
236         .color_type = FF_COLOR_GRAY,
237         .pixel_type = FF_PIXEL_PLANAR,
238         .depth = 8,
239     },
240     [PIX_FMT_MONOWHITE] = {
241         .name = "monow",
242         .nb_channels = 1,
243         .color_type = FF_COLOR_GRAY,
244         .pixel_type = FF_PIXEL_PLANAR,
245         .depth = 1,
246     },
247     [PIX_FMT_MONOBLACK] = {
248         .name = "monob",
249         .nb_channels = 1,
250         .color_type = FF_COLOR_GRAY,
251         .pixel_type = FF_PIXEL_PLANAR,
252         .depth = 1,
253     },
254
255     /* paletted formats */
256     [PIX_FMT_PAL8] = {
257         .name = "pal8",
258         .nb_channels = 4, .is_alpha = 1,
259         .color_type = FF_COLOR_RGB,
260         .pixel_type = FF_PIXEL_PALETTE,
261         .depth = 8,
262     },
263     [PIX_FMT_XVMC_MPEG2_MC] = {
264         .name = "xvmcmc",
265     },
266     [PIX_FMT_XVMC_MPEG2_IDCT] = {
267         .name = "xvmcidct",
268     },
269     [PIX_FMT_UYYVYY411] = {
270         .name = "uyyvyy411",
271         .nb_channels = 1,
272         .color_type = FF_COLOR_YUV,
273         .pixel_type = FF_PIXEL_PACKED,
274         .depth = 8,
275         .x_chroma_shift = 2, .y_chroma_shift = 0,
276     },
277     [PIX_FMT_BGR32] = {
278         .name = "bgr32",
279         .nb_channels = 4, .is_alpha = 1,
280         .color_type = FF_COLOR_RGB,
281         .pixel_type = FF_PIXEL_PACKED,
282         .depth = 8,
283         .x_chroma_shift = 0, .y_chroma_shift = 0,
284     },
285     [PIX_FMT_BGR565] = {
286         .name = "bgr565",
287         .nb_channels = 3,
288         .color_type = FF_COLOR_RGB,
289         .pixel_type = FF_PIXEL_PACKED,
290         .depth = 5,
291         .x_chroma_shift = 0, .y_chroma_shift = 0,
292     },
293     [PIX_FMT_BGR555] = {
294         .name = "bgr555",
295         .nb_channels = 3,
296         .color_type = FF_COLOR_RGB,
297         .pixel_type = FF_PIXEL_PACKED,
298         .depth = 5,
299         .x_chroma_shift = 0, .y_chroma_shift = 0,
300     },
301     [PIX_FMT_RGB8] = {
302         .name = "rgb8",
303         .nb_channels = 1,
304         .color_type = FF_COLOR_RGB,
305         .pixel_type = FF_PIXEL_PACKED,
306         .depth = 8,
307         .x_chroma_shift = 0, .y_chroma_shift = 0,
308     },
309     [PIX_FMT_RGB4] = {
310         .name = "rgb4",
311         .nb_channels = 1,
312         .color_type = FF_COLOR_RGB,
313         .pixel_type = FF_PIXEL_PACKED,
314         .depth = 4,
315         .x_chroma_shift = 0, .y_chroma_shift = 0,
316     },
317     [PIX_FMT_RGB4_BYTE] = {
318         .name = "rgb4_byte",
319         .nb_channels = 1,
320         .color_type = FF_COLOR_RGB,
321         .pixel_type = FF_PIXEL_PACKED,
322         .depth = 8,
323         .x_chroma_shift = 0, .y_chroma_shift = 0,
324     },
325     [PIX_FMT_BGR8] = {
326         .name = "bgr8",
327         .nb_channels = 1,
328         .color_type = FF_COLOR_RGB,
329         .pixel_type = FF_PIXEL_PACKED,
330         .depth = 8,
331         .x_chroma_shift = 0, .y_chroma_shift = 0,
332     },
333     [PIX_FMT_BGR4] = {
334         .name = "bgr4",
335         .nb_channels = 1,
336         .color_type = FF_COLOR_RGB,
337         .pixel_type = FF_PIXEL_PACKED,
338         .depth = 4,
339         .x_chroma_shift = 0, .y_chroma_shift = 0,
340     },
341     [PIX_FMT_BGR4_BYTE] = {
342         .name = "bgr4_byte",
343         .nb_channels = 1,
344         .color_type = FF_COLOR_RGB,
345         .pixel_type = FF_PIXEL_PACKED,
346         .depth = 8,
347         .x_chroma_shift = 0, .y_chroma_shift = 0,
348     },
349     [PIX_FMT_NV12] = {
350         .name = "nv12",
351         .nb_channels = 2,
352         .color_type = FF_COLOR_YUV,
353         .pixel_type = FF_PIXEL_PLANAR,
354         .depth = 8,
355         .x_chroma_shift = 1, .y_chroma_shift = 1,
356     },
357     [PIX_FMT_NV21] = {
358         .name = "nv12",
359         .nb_channels = 2,
360         .color_type = FF_COLOR_YUV,
361         .pixel_type = FF_PIXEL_PLANAR,
362         .depth = 8,
363         .x_chroma_shift = 1, .y_chroma_shift = 1,
364     },
365
366     [PIX_FMT_BGR32_1] = {
367         .name = "bgr32_1",
368         .nb_channels = 4, .is_alpha = 1,
369         .color_type = FF_COLOR_RGB,
370         .pixel_type = FF_PIXEL_PACKED,
371         .depth = 8,
372         .x_chroma_shift = 0, .y_chroma_shift = 0,
373     },
374     [PIX_FMT_RGB32_1] = {
375         .name = "rgb32_1",
376         .nb_channels = 4, .is_alpha = 1,
377         .color_type = FF_COLOR_RGB,
378         .pixel_type = FF_PIXEL_PACKED,
379         .depth = 8,
380         .x_chroma_shift = 0, .y_chroma_shift = 0,
381     },
382 };
383
384 void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift)
385 {
386     *h_shift = pix_fmt_info[pix_fmt].x_chroma_shift;
387     *v_shift = pix_fmt_info[pix_fmt].y_chroma_shift;
388 }
389
390 const char *avcodec_get_pix_fmt_name(int pix_fmt)
391 {
392     if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB)
393         return "???";
394     else
395         return pix_fmt_info[pix_fmt].name;
396 }
397
398 enum PixelFormat avcodec_get_pix_fmt(const char* name)
399 {
400     int i;
401
402     for (i=0; i < PIX_FMT_NB; i++)
403          if (!strcmp(pix_fmt_info[i].name, name))
404              break;
405     return i;
406 }
407
408 void avcodec_pix_fmt_string (char *buf, int buf_size, int pix_fmt)
409 {
410     PixFmtInfo info= pix_fmt_info[pix_fmt];
411
412     char is_alpha_char= info.is_alpha ? 'y' : 'n';
413
414     /* print header */
415     if (pix_fmt < 0)
416         snprintf (buf, buf_size,
417                   "name      " " nb_channels" " depth" " is_alpha"
418             );
419     else
420         snprintf (buf, buf_size,
421                   "%-10s" "      %1d     " "   %2d " "     %c   ",
422                   info.name,
423                   info.nb_channels,
424                   info.depth,
425                   is_alpha_char
426             );
427 }
428
429 int avpicture_fill(AVPicture *picture, uint8_t *ptr,
430                    int pix_fmt, int width, int height)
431 {
432     int size, w2, h2, size2;
433     const PixFmtInfo *pinfo;
434
435     if(avcodec_check_dimensions(NULL, width, height))
436         goto fail;
437
438     pinfo = &pix_fmt_info[pix_fmt];
439     size = width * height;
440     switch(pix_fmt) {
441     case PIX_FMT_YUV420P:
442     case PIX_FMT_YUV422P:
443     case PIX_FMT_YUV444P:
444     case PIX_FMT_YUV410P:
445     case PIX_FMT_YUV411P:
446     case PIX_FMT_YUV440P:
447     case PIX_FMT_YUVJ420P:
448     case PIX_FMT_YUVJ422P:
449     case PIX_FMT_YUVJ444P:
450     case PIX_FMT_YUVJ440P:
451         w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
452         h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
453         size2 = w2 * h2;
454         picture->data[0] = ptr;
455         picture->data[1] = picture->data[0] + size;
456         picture->data[2] = picture->data[1] + size2;
457         picture->data[3] = NULL;
458         picture->linesize[0] = width;
459         picture->linesize[1] = w2;
460         picture->linesize[2] = w2;
461         picture->linesize[3] = 0;
462         return size + 2 * size2;
463     case PIX_FMT_YUVA420P:
464         w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
465         h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
466         size2 = w2 * h2;
467         picture->data[0] = ptr;
468         picture->data[1] = picture->data[0] + size;
469         picture->data[2] = picture->data[1] + size2;
470         picture->data[3] = picture->data[1] + size2 + size2;
471         picture->linesize[0] = width;
472         picture->linesize[1] = w2;
473         picture->linesize[2] = w2;
474         picture->linesize[3] = width;
475         return 2 * size + 2 * size2;
476     case PIX_FMT_NV12:
477     case PIX_FMT_NV21:
478         w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
479         h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
480         size2 = w2 * h2 * 2;
481         picture->data[0] = ptr;
482         picture->data[1] = picture->data[0] + size;
483         picture->data[2] = NULL;
484         picture->data[3] = NULL;
485         picture->linesize[0] = width;
486         picture->linesize[1] = w2;
487         picture->linesize[2] = 0;
488         picture->linesize[3] = 0;
489         return size + 2 * size2;
490     case PIX_FMT_RGB24:
491     case PIX_FMT_BGR24:
492         picture->data[0] = ptr;
493         picture->data[1] = NULL;
494         picture->data[2] = NULL;
495         picture->data[3] = NULL;
496         picture->linesize[0] = width * 3;
497         return size * 3;
498     case PIX_FMT_RGB32:
499     case PIX_FMT_BGR32:
500     case PIX_FMT_RGB32_1:
501     case PIX_FMT_BGR32_1:
502         picture->data[0] = ptr;
503         picture->data[1] = NULL;
504         picture->data[2] = NULL;
505         picture->data[3] = NULL;
506         picture->linesize[0] = width * 4;
507         return size * 4;
508     case PIX_FMT_GRAY16BE:
509     case PIX_FMT_GRAY16LE:
510     case PIX_FMT_BGR555:
511     case PIX_FMT_BGR565:
512     case PIX_FMT_RGB555:
513     case PIX_FMT_RGB565:
514     case PIX_FMT_YUYV422:
515         picture->data[0] = ptr;
516         picture->data[1] = NULL;
517         picture->data[2] = NULL;
518         picture->data[3] = NULL;
519         picture->linesize[0] = width * 2;
520         return size * 2;
521     case PIX_FMT_UYVY422:
522         picture->data[0] = ptr;
523         picture->data[1] = NULL;
524         picture->data[2] = NULL;
525         picture->data[3] = NULL;
526         picture->linesize[0] = width * 2;
527         return size * 2;
528     case PIX_FMT_UYYVYY411:
529         picture->data[0] = ptr;
530         picture->data[1] = NULL;
531         picture->data[2] = NULL;
532         picture->data[3] = NULL;
533         picture->linesize[0] = width + width/2;
534         return size + size/2;
535     case PIX_FMT_RGB8:
536     case PIX_FMT_BGR8:
537     case PIX_FMT_RGB4_BYTE:
538     case PIX_FMT_BGR4_BYTE:
539     case PIX_FMT_GRAY8:
540         picture->data[0] = ptr;
541         picture->data[1] = NULL;
542         picture->data[2] = NULL;
543         picture->data[3] = NULL;
544         picture->linesize[0] = width;
545         return size;
546     case PIX_FMT_RGB4:
547     case PIX_FMT_BGR4:
548         picture->data[0] = ptr;
549         picture->data[1] = NULL;
550         picture->data[2] = NULL;
551         picture->data[3] = NULL;
552         picture->linesize[0] = width / 2;
553         return size / 2;
554     case PIX_FMT_MONOWHITE:
555     case PIX_FMT_MONOBLACK:
556         picture->data[0] = ptr;
557         picture->data[1] = NULL;
558         picture->data[2] = NULL;
559         picture->data[3] = NULL;
560         picture->linesize[0] = (width + 7) >> 3;
561         return picture->linesize[0] * height;
562     case PIX_FMT_PAL8:
563         size2 = (size + 3) & ~3;
564         picture->data[0] = ptr;
565         picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */
566         picture->data[2] = NULL;
567         picture->data[3] = NULL;
568         picture->linesize[0] = width;
569         picture->linesize[1] = 4;
570         return size2 + 256 * 4;
571     default:
572 fail:
573         picture->data[0] = NULL;
574         picture->data[1] = NULL;
575         picture->data[2] = NULL;
576         picture->data[3] = NULL;
577         return -1;
578     }
579 }
580
581 int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height,
582                      unsigned char *dest, int dest_size)
583 {
584     const PixFmtInfo* pf = &pix_fmt_info[pix_fmt];
585     int i, j, w, h, data_planes;
586     const unsigned char* s;
587     int size = avpicture_get_size(pix_fmt, width, height);
588
589     if (size > dest_size || size < 0)
590         return -1;
591
592     if (pf->pixel_type == FF_PIXEL_PACKED || pf->pixel_type == FF_PIXEL_PALETTE) {
593         if (pix_fmt == PIX_FMT_YUYV422 ||
594             pix_fmt == PIX_FMT_UYVY422 ||
595             pix_fmt == PIX_FMT_BGR565 ||
596             pix_fmt == PIX_FMT_BGR555 ||
597             pix_fmt == PIX_FMT_RGB565 ||
598             pix_fmt == PIX_FMT_RGB555)
599             w = width * 2;
600         else if (pix_fmt == PIX_FMT_UYYVYY411)
601           w = width + width/2;
602         else if (pix_fmt == PIX_FMT_PAL8)
603           w = width;
604         else
605           w = width * (pf->depth * pf->nb_channels / 8);
606
607         data_planes = 1;
608         h = height;
609     } else {
610         data_planes = pf->nb_channels;
611         w = (width*pf->depth + 7)/8;
612         h = height;
613     }
614
615     for (i=0; i<data_planes; i++) {
616          if (i == 1) {
617              w = width >> pf->x_chroma_shift;
618              h = height >> pf->y_chroma_shift;
619          }
620          s = src->data[i];
621          for(j=0; j<h; j++) {
622              memcpy(dest, s, w);
623              dest += w;
624              s += src->linesize[i];
625          }
626     }
627
628     if (pf->pixel_type == FF_PIXEL_PALETTE)
629         memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4);
630
631     return size;
632 }
633
634 int avpicture_get_size(int pix_fmt, int width, int height)
635 {
636     AVPicture dummy_pict;
637     return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);
638 }
639
640 int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt,
641                              int has_alpha)
642 {
643     const PixFmtInfo *pf, *ps;
644     int loss;
645
646     ps = &pix_fmt_info[src_pix_fmt];
647     pf = &pix_fmt_info[dst_pix_fmt];
648
649     /* compute loss */
650     loss = 0;
651     pf = &pix_fmt_info[dst_pix_fmt];
652     if (pf->depth < ps->depth ||
653         (dst_pix_fmt == PIX_FMT_RGB555 && src_pix_fmt == PIX_FMT_RGB565))
654         loss |= FF_LOSS_DEPTH;
655     if (pf->x_chroma_shift > ps->x_chroma_shift ||
656         pf->y_chroma_shift > ps->y_chroma_shift)
657         loss |= FF_LOSS_RESOLUTION;
658     switch(pf->color_type) {
659     case FF_COLOR_RGB:
660         if (ps->color_type != FF_COLOR_RGB &&
661             ps->color_type != FF_COLOR_GRAY)
662             loss |= FF_LOSS_COLORSPACE;
663         break;
664     case FF_COLOR_GRAY:
665         if (ps->color_type != FF_COLOR_GRAY)
666             loss |= FF_LOSS_COLORSPACE;
667         break;
668     case FF_COLOR_YUV:
669         if (ps->color_type != FF_COLOR_YUV)
670             loss |= FF_LOSS_COLORSPACE;
671         break;
672     case FF_COLOR_YUV_JPEG:
673         if (ps->color_type != FF_COLOR_YUV_JPEG &&
674             ps->color_type != FF_COLOR_YUV &&
675             ps->color_type != FF_COLOR_GRAY)
676             loss |= FF_LOSS_COLORSPACE;
677         break;
678     default:
679         /* fail safe test */
680         if (ps->color_type != pf->color_type)
681             loss |= FF_LOSS_COLORSPACE;
682         break;
683     }
684     if (pf->color_type == FF_COLOR_GRAY &&
685         ps->color_type != FF_COLOR_GRAY)
686         loss |= FF_LOSS_CHROMA;
687     if (!pf->is_alpha && (ps->is_alpha && has_alpha))
688         loss |= FF_LOSS_ALPHA;
689     if (pf->pixel_type == FF_PIXEL_PALETTE &&
690         (ps->pixel_type != FF_PIXEL_PALETTE && ps->color_type != FF_COLOR_GRAY))
691         loss |= FF_LOSS_COLORQUANT;
692     return loss;
693 }
694
695 static int avg_bits_per_pixel(int pix_fmt)
696 {
697     int bits;
698     const PixFmtInfo *pf;
699
700     pf = &pix_fmt_info[pix_fmt];
701     switch(pf->pixel_type) {
702     case FF_PIXEL_PACKED:
703         switch(pix_fmt) {
704         case PIX_FMT_YUYV422:
705         case PIX_FMT_UYVY422:
706         case PIX_FMT_RGB565:
707         case PIX_FMT_RGB555:
708         case PIX_FMT_BGR565:
709         case PIX_FMT_BGR555:
710             bits = 16;
711             break;
712         case PIX_FMT_UYYVYY411:
713             bits = 12;
714             break;
715         default:
716             bits = pf->depth * pf->nb_channels;
717             break;
718         }
719         break;
720     case FF_PIXEL_PLANAR:
721         if (pf->x_chroma_shift == 0 && pf->y_chroma_shift == 0) {
722             bits = pf->depth * pf->nb_channels;
723         } else {
724             bits = pf->depth + ((2 * pf->depth) >>
725                                 (pf->x_chroma_shift + pf->y_chroma_shift));
726         }
727         break;
728     case FF_PIXEL_PALETTE:
729         bits = 8;
730         break;
731     default:
732         bits = -1;
733         break;
734     }
735     return bits;
736 }
737
738 static int avcodec_find_best_pix_fmt1(int pix_fmt_mask,
739                                       int src_pix_fmt,
740                                       int has_alpha,
741                                       int loss_mask)
742 {
743     int dist, i, loss, min_dist, dst_pix_fmt;
744
745     /* find exact color match with smallest size */
746     dst_pix_fmt = -1;
747     min_dist = 0x7fffffff;
748     for(i = 0;i < PIX_FMT_NB; i++) {
749         if (pix_fmt_mask & (1 << i)) {
750             loss = avcodec_get_pix_fmt_loss(i, src_pix_fmt, has_alpha) & loss_mask;
751             if (loss == 0) {
752                 dist = avg_bits_per_pixel(i);
753                 if (dist < min_dist) {
754                     min_dist = dist;
755                     dst_pix_fmt = i;
756                 }
757             }
758         }
759     }
760     return dst_pix_fmt;
761 }
762
763 int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt,
764                               int has_alpha, int *loss_ptr)
765 {
766     int dst_pix_fmt, loss_mask, i;
767     static const int loss_mask_order[] = {
768         ~0, /* no loss first */
769         ~FF_LOSS_ALPHA,
770         ~FF_LOSS_RESOLUTION,
771         ~(FF_LOSS_COLORSPACE | FF_LOSS_RESOLUTION),
772         ~FF_LOSS_COLORQUANT,
773         ~FF_LOSS_DEPTH,
774         0,
775     };
776
777     /* try with successive loss */
778     i = 0;
779     for(;;) {
780         loss_mask = loss_mask_order[i++];
781         dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_mask, src_pix_fmt,
782                                                  has_alpha, loss_mask);
783         if (dst_pix_fmt >= 0)
784             goto found;
785         if (loss_mask == 0)
786             break;
787     }
788     return -1;
789  found:
790     if (loss_ptr)
791         *loss_ptr = avcodec_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
792     return dst_pix_fmt;
793 }
794
795 void ff_img_copy_plane(uint8_t *dst, int dst_wrap,
796                            const uint8_t *src, int src_wrap,
797                            int width, int height)
798 {
799     if((!dst) || (!src))
800         return;
801     for(;height > 0; height--) {
802         memcpy(dst, src, width);
803         dst += dst_wrap;
804         src += src_wrap;
805     }
806 }
807
808 int av_get_plane_bytewidth(enum PixelFormat pix_fmt, int width, int plane)
809 {
810     int bits;
811     const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
812
813     pf = &pix_fmt_info[pix_fmt];
814     switch(pf->pixel_type) {
815     case FF_PIXEL_PACKED:
816         switch(pix_fmt) {
817         case PIX_FMT_YUYV422:
818         case PIX_FMT_UYVY422:
819         case PIX_FMT_RGB565:
820         case PIX_FMT_RGB555:
821         case PIX_FMT_BGR565:
822         case PIX_FMT_BGR555:
823             bits = 16;
824             break;
825         case PIX_FMT_UYYVYY411:
826             bits = 12;
827             break;
828         default:
829             bits = pf->depth * pf->nb_channels;
830             break;
831         }
832         return (width * bits + 7) >> 3;
833         break;
834     case FF_PIXEL_PLANAR:
835             if (plane == 1 || plane == 2)
836                 width >>= pf->x_chroma_shift;
837
838             return (width * pf->depth + 7) >> 3;
839         break;
840     case FF_PIXEL_PALETTE:
841         if (plane == 0)
842             return width;
843         break;
844     }
845
846     return -1;
847 }
848
849 void av_picture_copy(AVPicture *dst, const AVPicture *src,
850               int pix_fmt, int width, int height)
851 {
852     int i;
853     const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
854
855     pf = &pix_fmt_info[pix_fmt];
856     switch(pf->pixel_type) {
857     case FF_PIXEL_PACKED:
858     case FF_PIXEL_PLANAR:
859         for(i = 0; i < pf->nb_channels; i++) {
860             int w, h;
861             int bwidth = av_get_plane_bytewidth(pix_fmt, width, i);
862             w = width;
863             h = height;
864             if (i == 1 || i == 2) {
865                 w >>= pf->x_chroma_shift;
866                 h >>= pf->y_chroma_shift;
867             }
868             ff_img_copy_plane(dst->data[i], dst->linesize[i],
869                            src->data[i], src->linesize[i],
870                            bwidth, h);
871         }
872         break;
873     case FF_PIXEL_PALETTE:
874         ff_img_copy_plane(dst->data[0], dst->linesize[0],
875                        src->data[0], src->linesize[0],
876                        width, height);
877         /* copy the palette */
878         ff_img_copy_plane(dst->data[1], dst->linesize[1],
879                        src->data[1], src->linesize[1],
880                        4, 256);
881         break;
882     }
883 }
884
885 /* XXX: totally non optimized */
886
887 static void yuyv422_to_yuv420p(AVPicture *dst, const AVPicture *src,
888                               int width, int height)
889 {
890     const uint8_t *p, *p1;
891     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
892     int w;
893
894     p1 = src->data[0];
895     lum1 = dst->data[0];
896     cb1 = dst->data[1];
897     cr1 = dst->data[2];
898
899     for(;height >= 1; height -= 2) {
900         p = p1;
901         lum = lum1;
902         cb = cb1;
903         cr = cr1;
904         for(w = width; w >= 2; w -= 2) {
905             lum[0] = p[0];
906             cb[0] = p[1];
907             lum[1] = p[2];
908             cr[0] = p[3];
909             p += 4;
910             lum += 2;
911             cb++;
912             cr++;
913         }
914         if (w) {
915             lum[0] = p[0];
916             cb[0] = p[1];
917             cr[0] = p[3];
918             cb++;
919             cr++;
920         }
921         p1 += src->linesize[0];
922         lum1 += dst->linesize[0];
923         if (height>1) {
924             p = p1;
925             lum = lum1;
926             for(w = width; w >= 2; w -= 2) {
927                 lum[0] = p[0];
928                 lum[1] = p[2];
929                 p += 4;
930                 lum += 2;
931             }
932             if (w) {
933                 lum[0] = p[0];
934             }
935             p1 += src->linesize[0];
936             lum1 += dst->linesize[0];
937         }
938         cb1 += dst->linesize[1];
939         cr1 += dst->linesize[2];
940     }
941 }
942
943 static void uyvy422_to_yuv420p(AVPicture *dst, const AVPicture *src,
944                               int width, int height)
945 {
946     const uint8_t *p, *p1;
947     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
948     int w;
949
950     p1 = src->data[0];
951
952     lum1 = dst->data[0];
953     cb1 = dst->data[1];
954     cr1 = dst->data[2];
955
956     for(;height >= 1; height -= 2) {
957         p = p1;
958         lum = lum1;
959         cb = cb1;
960         cr = cr1;
961         for(w = width; w >= 2; w -= 2) {
962             lum[0] = p[1];
963             cb[0] = p[0];
964             lum[1] = p[3];
965             cr[0] = p[2];
966             p += 4;
967             lum += 2;
968             cb++;
969             cr++;
970         }
971         if (w) {
972             lum[0] = p[1];
973             cb[0] = p[0];
974             cr[0] = p[2];
975             cb++;
976             cr++;
977         }
978         p1 += src->linesize[0];
979         lum1 += dst->linesize[0];
980         if (height>1) {
981             p = p1;
982             lum = lum1;
983             for(w = width; w >= 2; w -= 2) {
984                 lum[0] = p[1];
985                 lum[1] = p[3];
986                 p += 4;
987                 lum += 2;
988             }
989             if (w) {
990                 lum[0] = p[1];
991             }
992             p1 += src->linesize[0];
993             lum1 += dst->linesize[0];
994         }
995         cb1 += dst->linesize[1];
996         cr1 += dst->linesize[2];
997     }
998 }
999
1000
1001 static void uyvy422_to_yuv422p(AVPicture *dst, const AVPicture *src,
1002                               int width, int height)
1003 {
1004     const uint8_t *p, *p1;
1005     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
1006     int w;
1007
1008     p1 = src->data[0];
1009     lum1 = dst->data[0];
1010     cb1 = dst->data[1];
1011     cr1 = dst->data[2];
1012     for(;height > 0; height--) {
1013         p = p1;
1014         lum = lum1;
1015         cb = cb1;
1016         cr = cr1;
1017         for(w = width; w >= 2; w -= 2) {
1018             lum[0] = p[1];
1019             cb[0] = p[0];
1020             lum[1] = p[3];
1021             cr[0] = p[2];
1022             p += 4;
1023             lum += 2;
1024             cb++;
1025             cr++;
1026         }
1027         p1 += src->linesize[0];
1028         lum1 += dst->linesize[0];
1029         cb1 += dst->linesize[1];
1030         cr1 += dst->linesize[2];
1031     }
1032 }
1033
1034
1035 static void yuyv422_to_yuv422p(AVPicture *dst, const AVPicture *src,
1036                               int width, int height)
1037 {
1038     const uint8_t *p, *p1;
1039     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
1040     int w;
1041
1042     p1 = src->data[0];
1043     lum1 = dst->data[0];
1044     cb1 = dst->data[1];
1045     cr1 = dst->data[2];
1046     for(;height > 0; height--) {
1047         p = p1;
1048         lum = lum1;
1049         cb = cb1;
1050         cr = cr1;
1051         for(w = width; w >= 2; w -= 2) {
1052             lum[0] = p[0];
1053             cb[0] = p[1];
1054             lum[1] = p[2];
1055             cr[0] = p[3];
1056             p += 4;
1057             lum += 2;
1058             cb++;
1059             cr++;
1060         }
1061         p1 += src->linesize[0];
1062         lum1 += dst->linesize[0];
1063         cb1 += dst->linesize[1];
1064         cr1 += dst->linesize[2];
1065     }
1066 }
1067
1068 static void yuv422p_to_yuyv422(AVPicture *dst, const AVPicture *src,
1069                               int width, int height)
1070 {
1071     uint8_t *p, *p1;
1072     const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
1073     int w;
1074
1075     p1 = dst->data[0];
1076     lum1 = src->data[0];
1077     cb1 = src->data[1];
1078     cr1 = src->data[2];
1079     for(;height > 0; height--) {
1080         p = p1;
1081         lum = lum1;
1082         cb = cb1;
1083         cr = cr1;
1084         for(w = width; w >= 2; w -= 2) {
1085             p[0] = lum[0];
1086             p[1] = cb[0];
1087             p[2] = lum[1];
1088             p[3] = cr[0];
1089             p += 4;
1090             lum += 2;
1091             cb++;
1092             cr++;
1093         }
1094         p1 += dst->linesize[0];
1095         lum1 += src->linesize[0];
1096         cb1 += src->linesize[1];
1097         cr1 += src->linesize[2];
1098     }
1099 }
1100
1101 static void yuv422p_to_uyvy422(AVPicture *dst, const AVPicture *src,
1102                               int width, int height)
1103 {
1104     uint8_t *p, *p1;
1105     const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
1106     int w;
1107
1108     p1 = dst->data[0];
1109     lum1 = src->data[0];
1110     cb1 = src->data[1];
1111     cr1 = src->data[2];
1112     for(;height > 0; height--) {
1113         p = p1;
1114         lum = lum1;
1115         cb = cb1;
1116         cr = cr1;
1117         for(w = width; w >= 2; w -= 2) {
1118             p[1] = lum[0];
1119             p[0] = cb[0];
1120             p[3] = lum[1];
1121             p[2] = cr[0];
1122             p += 4;
1123             lum += 2;
1124             cb++;
1125             cr++;
1126         }
1127         p1 += dst->linesize[0];
1128         lum1 += src->linesize[0];
1129         cb1 += src->linesize[1];
1130         cr1 += src->linesize[2];
1131     }
1132 }
1133
1134 static void uyyvyy411_to_yuv411p(AVPicture *dst, const AVPicture *src,
1135                               int width, int height)
1136 {
1137     const uint8_t *p, *p1;
1138     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
1139     int w;
1140
1141     p1 = src->data[0];
1142     lum1 = dst->data[0];
1143     cb1 = dst->data[1];
1144     cr1 = dst->data[2];
1145     for(;height > 0; height--) {
1146         p = p1;
1147         lum = lum1;
1148         cb = cb1;
1149         cr = cr1;
1150         for(w = width; w >= 4; w -= 4) {
1151             cb[0] = p[0];
1152             lum[0] = p[1];
1153             lum[1] = p[2];
1154             cr[0] = p[3];
1155             lum[2] = p[4];
1156             lum[3] = p[5];
1157             p += 6;
1158             lum += 4;
1159             cb++;
1160             cr++;
1161         }
1162         p1 += src->linesize[0];
1163         lum1 += dst->linesize[0];
1164         cb1 += dst->linesize[1];
1165         cr1 += dst->linesize[2];
1166     }
1167 }
1168
1169
1170 static void yuv420p_to_yuyv422(AVPicture *dst, const AVPicture *src,
1171                               int width, int height)
1172 {
1173     int w, h;
1174     uint8_t *line1, *line2, *linesrc = dst->data[0];
1175     uint8_t *lum1, *lum2, *lumsrc = src->data[0];
1176     uint8_t *cb1, *cb2 = src->data[1];
1177     uint8_t *cr1, *cr2 = src->data[2];
1178
1179     for(h = height / 2; h--;) {
1180         line1 = linesrc;
1181         line2 = linesrc + dst->linesize[0];
1182
1183         lum1 = lumsrc;
1184         lum2 = lumsrc + src->linesize[0];
1185
1186         cb1 = cb2;
1187         cr1 = cr2;
1188
1189         for(w = width / 2; w--;) {
1190                 *line1++ = *lum1++; *line2++ = *lum2++;
1191                 *line1++ =          *line2++ = *cb1++;
1192                 *line1++ = *lum1++; *line2++ = *lum2++;
1193                 *line1++ =          *line2++ = *cr1++;
1194         }
1195
1196         linesrc += dst->linesize[0] * 2;
1197         lumsrc += src->linesize[0] * 2;
1198         cb2 += src->linesize[1];
1199         cr2 += src->linesize[2];
1200     }
1201 }
1202
1203 static void yuv420p_to_uyvy422(AVPicture *dst, const AVPicture *src,
1204                               int width, int height)
1205 {
1206     int w, h;
1207     uint8_t *line1, *line2, *linesrc = dst->data[0];
1208     uint8_t *lum1, *lum2, *lumsrc = src->data[0];
1209     uint8_t *cb1, *cb2 = src->data[1];
1210     uint8_t *cr1, *cr2 = src->data[2];
1211
1212     for(h = height / 2; h--;) {
1213         line1 = linesrc;
1214         line2 = linesrc + dst->linesize[0];
1215
1216         lum1 = lumsrc;
1217         lum2 = lumsrc + src->linesize[0];
1218
1219         cb1 = cb2;
1220         cr1 = cr2;
1221
1222         for(w = width / 2; w--;) {
1223                 *line1++ =          *line2++ = *cb1++;
1224                 *line1++ = *lum1++; *line2++ = *lum2++;
1225                 *line1++ =          *line2++ = *cr1++;
1226                 *line1++ = *lum1++; *line2++ = *lum2++;
1227         }
1228
1229         linesrc += dst->linesize[0] * 2;
1230         lumsrc += src->linesize[0] * 2;
1231         cb2 += src->linesize[1];
1232         cr2 += src->linesize[2];
1233     }
1234 }
1235
1236 static uint8_t y_ccir_to_jpeg[256];
1237 static uint8_t y_jpeg_to_ccir[256];
1238 static uint8_t c_ccir_to_jpeg[256];
1239 static uint8_t c_jpeg_to_ccir[256];
1240
1241 /* init various conversion tables */
1242 static void img_convert_init(void)
1243 {
1244     int i;
1245     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1246
1247     for(i = 0;i < 256; i++) {
1248         y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i);
1249         y_jpeg_to_ccir[i] = Y_JPEG_TO_CCIR(i);
1250         c_ccir_to_jpeg[i] = C_CCIR_TO_JPEG(i);
1251         c_jpeg_to_ccir[i] = C_JPEG_TO_CCIR(i);
1252     }
1253 }
1254
1255 /* apply to each pixel the given table */
1256 static void img_apply_table(uint8_t *dst, int dst_wrap,
1257                             const uint8_t *src, int src_wrap,
1258                             int width, int height, const uint8_t *table1)
1259 {
1260     int n;
1261     const uint8_t *s;
1262     uint8_t *d;
1263     const uint8_t *table;
1264
1265     table = table1;
1266     for(;height > 0; height--) {
1267         s = src;
1268         d = dst;
1269         n = width;
1270         while (n >= 4) {
1271             d[0] = table[s[0]];
1272             d[1] = table[s[1]];
1273             d[2] = table[s[2]];
1274             d[3] = table[s[3]];
1275             d += 4;
1276             s += 4;
1277             n -= 4;
1278         }
1279         while (n > 0) {
1280             d[0] = table[s[0]];
1281             d++;
1282             s++;
1283             n--;
1284         }
1285         dst += dst_wrap;
1286         src += src_wrap;
1287     }
1288 }
1289
1290 /* XXX: use generic filter ? */
1291 /* XXX: in most cases, the sampling position is incorrect */
1292
1293 /* 4x1 -> 1x1 */
1294 static void shrink41(uint8_t *dst, int dst_wrap,
1295                      const uint8_t *src, int src_wrap,
1296                      int width, int height)
1297 {
1298     int w;
1299     const uint8_t *s;
1300     uint8_t *d;
1301
1302     for(;height > 0; height--) {
1303         s = src;
1304         d = dst;
1305         for(w = width;w > 0; w--) {
1306             d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2;
1307             s += 4;
1308             d++;
1309         }
1310         src += src_wrap;
1311         dst += dst_wrap;
1312     }
1313 }
1314
1315 /* 2x1 -> 1x1 */
1316 static void shrink21(uint8_t *dst, int dst_wrap,
1317                      const uint8_t *src, int src_wrap,
1318                      int width, int height)
1319 {
1320     int w;
1321     const uint8_t *s;
1322     uint8_t *d;
1323
1324     for(;height > 0; height--) {
1325         s = src;
1326         d = dst;
1327         for(w = width;w > 0; w--) {
1328             d[0] = (s[0] + s[1]) >> 1;
1329             s += 2;
1330             d++;
1331         }
1332         src += src_wrap;
1333         dst += dst_wrap;
1334     }
1335 }
1336
1337 /* 1x2 -> 1x1 */
1338 static void shrink12(uint8_t *dst, int dst_wrap,
1339                      const uint8_t *src, int src_wrap,
1340                      int width, int height)
1341 {
1342     int w;
1343     uint8_t *d;
1344     const uint8_t *s1, *s2;
1345
1346     for(;height > 0; height--) {
1347         s1 = src;
1348         s2 = s1 + src_wrap;
1349         d = dst;
1350         for(w = width;w >= 4; w-=4) {
1351             d[0] = (s1[0] + s2[0]) >> 1;
1352             d[1] = (s1[1] + s2[1]) >> 1;
1353             d[2] = (s1[2] + s2[2]) >> 1;
1354             d[3] = (s1[3] + s2[3]) >> 1;
1355             s1 += 4;
1356             s2 += 4;
1357             d += 4;
1358         }
1359         for(;w > 0; w--) {
1360             d[0] = (s1[0] + s2[0]) >> 1;
1361             s1++;
1362             s2++;
1363             d++;
1364         }
1365         src += 2 * src_wrap;
1366         dst += dst_wrap;
1367     }
1368 }
1369
1370 /* 2x2 -> 1x1 */
1371 void ff_shrink22(uint8_t *dst, int dst_wrap,
1372                      const uint8_t *src, int src_wrap,
1373                      int width, int height)
1374 {
1375     int w;
1376     const uint8_t *s1, *s2;
1377     uint8_t *d;
1378
1379     for(;height > 0; height--) {
1380         s1 = src;
1381         s2 = s1 + src_wrap;
1382         d = dst;
1383         for(w = width;w >= 4; w-=4) {
1384             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
1385             d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;
1386             d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;
1387             d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;
1388             s1 += 8;
1389             s2 += 8;
1390             d += 4;
1391         }
1392         for(;w > 0; w--) {
1393             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
1394             s1 += 2;
1395             s2 += 2;
1396             d++;
1397         }
1398         src += 2 * src_wrap;
1399         dst += dst_wrap;
1400     }
1401 }
1402
1403 /* 4x4 -> 1x1 */
1404 void ff_shrink44(uint8_t *dst, int dst_wrap,
1405                      const uint8_t *src, int src_wrap,
1406                      int width, int height)
1407 {
1408     int w;
1409     const uint8_t *s1, *s2, *s3, *s4;
1410     uint8_t *d;
1411
1412     for(;height > 0; height--) {
1413         s1 = src;
1414         s2 = s1 + src_wrap;
1415         s3 = s2 + src_wrap;
1416         s4 = s3 + src_wrap;
1417         d = dst;
1418         for(w = width;w > 0; w--) {
1419             d[0] = (s1[0] + s1[1] + s1[2] + s1[3] +
1420                     s2[0] + s2[1] + s2[2] + s2[3] +
1421                     s3[0] + s3[1] + s3[2] + s3[3] +
1422                     s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4;
1423             s1 += 4;
1424             s2 += 4;
1425             s3 += 4;
1426             s4 += 4;
1427             d++;
1428         }
1429         src += 4 * src_wrap;
1430         dst += dst_wrap;
1431     }
1432 }
1433
1434 /* 8x8 -> 1x1 */
1435 void ff_shrink88(uint8_t *dst, int dst_wrap,
1436                      const uint8_t *src, int src_wrap,
1437                      int width, int height)
1438 {
1439     int w, i;
1440
1441     for(;height > 0; height--) {
1442         for(w = width;w > 0; w--) {
1443             int tmp=0;
1444             for(i=0; i<8; i++){
1445                 tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7];
1446                 src += src_wrap;
1447             }
1448             *(dst++) = (tmp + 32)>>6;
1449             src += 8 - 8*src_wrap;
1450         }
1451         src += 8*src_wrap - 8*width;
1452         dst += dst_wrap - width;
1453     }
1454 }
1455
1456 static void grow21_line(uint8_t *dst, const uint8_t *src,
1457                         int width)
1458 {
1459     int w;
1460     const uint8_t *s1;
1461     uint8_t *d;
1462
1463     s1 = src;
1464     d = dst;
1465     for(w = width;w >= 4; w-=4) {
1466         d[1] = d[0] = s1[0];
1467         d[3] = d[2] = s1[1];
1468         s1 += 2;
1469         d += 4;
1470     }
1471     for(;w >= 2; w -= 2) {
1472         d[1] = d[0] = s1[0];
1473         s1 ++;
1474         d += 2;
1475     }
1476     /* only needed if width is not a multiple of two */
1477     /* XXX: veryfy that */
1478     if (w) {
1479         d[0] = s1[0];
1480     }
1481 }
1482
1483 static void grow41_line(uint8_t *dst, const uint8_t *src,
1484                         int width)
1485 {
1486     int w, v;
1487     const uint8_t *s1;
1488     uint8_t *d;
1489
1490     s1 = src;
1491     d = dst;
1492     for(w = width;w >= 4; w-=4) {
1493         v = s1[0];
1494         d[0] = v;
1495         d[1] = v;
1496         d[2] = v;
1497         d[3] = v;
1498         s1 ++;
1499         d += 4;
1500     }
1501 }
1502
1503 /* 1x1 -> 2x1 */
1504 static void grow21(uint8_t *dst, int dst_wrap,
1505                    const uint8_t *src, int src_wrap,
1506                    int width, int height)
1507 {
1508     for(;height > 0; height--) {
1509         grow21_line(dst, src, width);
1510         src += src_wrap;
1511         dst += dst_wrap;
1512     }
1513 }
1514
1515 /* 1x1 -> 1x2 */
1516 static void grow12(uint8_t *dst, int dst_wrap,
1517                    const uint8_t *src, int src_wrap,
1518                    int width, int height)
1519 {
1520     for(;height > 0; height-=2) {
1521         memcpy(dst, src, width);
1522         dst += dst_wrap;
1523         memcpy(dst, src, width);
1524         dst += dst_wrap;
1525         src += src_wrap;
1526     }
1527 }
1528
1529 /* 1x1 -> 2x2 */
1530 static void grow22(uint8_t *dst, int dst_wrap,
1531                    const uint8_t *src, int src_wrap,
1532                    int width, int height)
1533 {
1534     for(;height > 0; height--) {
1535         grow21_line(dst, src, width);
1536         if (height%2)
1537             src += src_wrap;
1538         dst += dst_wrap;
1539     }
1540 }
1541
1542 /* 1x1 -> 4x1 */
1543 static void grow41(uint8_t *dst, int dst_wrap,
1544                    const uint8_t *src, int src_wrap,
1545                    int width, int height)
1546 {
1547     for(;height > 0; height--) {
1548         grow41_line(dst, src, width);
1549         src += src_wrap;
1550         dst += dst_wrap;
1551     }
1552 }
1553
1554 /* 1x1 -> 4x4 */
1555 static void grow44(uint8_t *dst, int dst_wrap,
1556                    const uint8_t *src, int src_wrap,
1557                    int width, int height)
1558 {
1559     for(;height > 0; height--) {
1560         grow41_line(dst, src, width);
1561         if ((height & 3) == 1)
1562             src += src_wrap;
1563         dst += dst_wrap;
1564     }
1565 }
1566
1567 /* 1x2 -> 2x1 */
1568 static void conv411(uint8_t *dst, int dst_wrap,
1569                     const uint8_t *src, int src_wrap,
1570                     int width, int height)
1571 {
1572     int w, c;
1573     const uint8_t *s1, *s2;
1574     uint8_t *d;
1575
1576     width>>=1;
1577
1578     for(;height > 0; height--) {
1579         s1 = src;
1580         s2 = src + src_wrap;
1581         d = dst;
1582         for(w = width;w > 0; w--) {
1583             c = (s1[0] + s2[0]) >> 1;
1584             d[0] = c;
1585             d[1] = c;
1586             s1++;
1587             s2++;
1588             d += 2;
1589         }
1590         src += src_wrap * 2;
1591         dst += dst_wrap;
1592     }
1593 }
1594
1595 /* XXX: add jpeg quantize code */
1596
1597 #define TRANSP_INDEX (6*6*6)
1598
1599 /* this is maybe slow, but allows for extensions */
1600 static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
1601 {
1602     return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));
1603 }
1604
1605 static void build_rgb_palette(uint8_t *palette, int has_alpha)
1606 {
1607     uint32_t *pal;
1608     static const uint8_t pal_value[6] = { 0x00, 0x33, 0x66, 0x99, 0xcc, 0xff };
1609     int i, r, g, b;
1610
1611     pal = (uint32_t *)palette;
1612     i = 0;
1613     for(r = 0; r < 6; r++) {
1614         for(g = 0; g < 6; g++) {
1615             for(b = 0; b < 6; b++) {
1616                 pal[i++] = (0xff << 24) | (pal_value[r] << 16) |
1617                     (pal_value[g] << 8) | pal_value[b];
1618             }
1619         }
1620     }
1621     if (has_alpha)
1622         pal[i++] = 0;
1623     while (i < 256)
1624         pal[i++] = 0xff000000;
1625 }
1626
1627 /* copy bit n to bits 0 ... n - 1 */
1628 static inline unsigned int bitcopy_n(unsigned int a, int n)
1629 {
1630     int mask;
1631     mask = (1 << n) - 1;
1632     return (a & (0xff & ~mask)) | ((-((a >> n) & 1)) & mask);
1633 }
1634
1635 /* rgb555 handling */
1636
1637 #define RGB_NAME rgb555
1638
1639 #define RGB_IN(r, g, b, s)\
1640 {\
1641     unsigned int v = ((const uint16_t *)(s))[0];\
1642     r = bitcopy_n(v >> (10 - 3), 3);\
1643     g = bitcopy_n(v >> (5 - 3), 3);\
1644     b = bitcopy_n(v << 3, 3);\
1645 }
1646
1647
1648 #define RGB_OUT(d, r, g, b)\
1649 {\
1650     ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);\
1651 }
1652
1653 #define BPP 2
1654
1655 #include "imgconvert_template.h"
1656
1657 /* rgb565 handling */
1658
1659 #define RGB_NAME rgb565
1660
1661 #define RGB_IN(r, g, b, s)\
1662 {\
1663     unsigned int v = ((const uint16_t *)(s))[0];\
1664     r = bitcopy_n(v >> (11 - 3), 3);\
1665     g = bitcopy_n(v >> (5 - 2), 2);\
1666     b = bitcopy_n(v << 3, 3);\
1667 }
1668
1669 #define RGB_OUT(d, r, g, b)\
1670 {\
1671     ((uint16_t *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);\
1672 }
1673
1674 #define BPP 2
1675
1676 #include "imgconvert_template.h"
1677
1678 /* bgr24 handling */
1679
1680 #define RGB_NAME bgr24
1681
1682 #define RGB_IN(r, g, b, s)\
1683 {\
1684     b = (s)[0];\
1685     g = (s)[1];\
1686     r = (s)[2];\
1687 }
1688
1689 #define RGB_OUT(d, r, g, b)\
1690 {\
1691     (d)[0] = b;\
1692     (d)[1] = g;\
1693     (d)[2] = r;\
1694 }
1695
1696 #define BPP 3
1697
1698 #include "imgconvert_template.h"
1699
1700 #undef RGB_IN
1701 #undef RGB_OUT
1702 #undef BPP
1703
1704 /* rgb24 handling */
1705
1706 #define RGB_NAME rgb24
1707 #define FMT_RGB24
1708
1709 #define RGB_IN(r, g, b, s)\
1710 {\
1711     r = (s)[0];\
1712     g = (s)[1];\
1713     b = (s)[2];\
1714 }
1715
1716 #define RGB_OUT(d, r, g, b)\
1717 {\
1718     (d)[0] = r;\
1719     (d)[1] = g;\
1720     (d)[2] = b;\
1721 }
1722
1723 #define BPP 3
1724
1725 #include "imgconvert_template.h"
1726
1727 /* rgb32 handling */
1728
1729 #define RGB_NAME rgb32
1730 #define FMT_RGB32
1731
1732 #define RGB_IN(r, g, b, s)\
1733 {\
1734     unsigned int v = ((const uint32_t *)(s))[0];\
1735     r = (v >> 16) & 0xff;\
1736     g = (v >> 8) & 0xff;\
1737     b = v & 0xff;\
1738 }
1739
1740 #define RGBA_IN(r, g, b, a, s)\
1741 {\
1742     unsigned int v = ((const uint32_t *)(s))[0];\
1743     a = (v >> 24) & 0xff;\
1744     r = (v >> 16) & 0xff;\
1745     g = (v >> 8) & 0xff;\
1746     b = v & 0xff;\
1747 }
1748
1749 #define RGBA_OUT(d, r, g, b, a)\
1750 {\
1751     ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;\
1752 }
1753
1754 #define BPP 4
1755
1756 #include "imgconvert_template.h"
1757
1758 static void mono_to_gray(AVPicture *dst, const AVPicture *src,
1759                          int width, int height, int xor_mask)
1760 {
1761     const unsigned char *p;
1762     unsigned char *q;
1763     int v, dst_wrap, src_wrap;
1764     int y, w;
1765
1766     p = src->data[0];
1767     src_wrap = src->linesize[0] - ((width + 7) >> 3);
1768
1769     q = dst->data[0];
1770     dst_wrap = dst->linesize[0] - width;
1771     for(y=0;y<height;y++) {
1772         w = width;
1773         while (w >= 8) {
1774             v = *p++ ^ xor_mask;
1775             q[0] = -(v >> 7);
1776             q[1] = -((v >> 6) & 1);
1777             q[2] = -((v >> 5) & 1);
1778             q[3] = -((v >> 4) & 1);
1779             q[4] = -((v >> 3) & 1);
1780             q[5] = -((v >> 2) & 1);
1781             q[6] = -((v >> 1) & 1);
1782             q[7] = -((v >> 0) & 1);
1783             w -= 8;
1784             q += 8;
1785         }
1786         if (w > 0) {
1787             v = *p++ ^ xor_mask;
1788             do {
1789                 q[0] = -((v >> 7) & 1);
1790                 q++;
1791                 v <<= 1;
1792             } while (--w);
1793         }
1794         p += src_wrap;
1795         q += dst_wrap;
1796     }
1797 }
1798
1799 static void monowhite_to_gray(AVPicture *dst, const AVPicture *src,
1800                                int width, int height)
1801 {
1802     mono_to_gray(dst, src, width, height, 0xff);
1803 }
1804
1805 static void monoblack_to_gray(AVPicture *dst, const AVPicture *src,
1806                                int width, int height)
1807 {
1808     mono_to_gray(dst, src, width, height, 0x00);
1809 }
1810
1811 static void gray_to_mono(AVPicture *dst, const AVPicture *src,
1812                          int width, int height, int xor_mask)
1813 {
1814     int n;
1815     const uint8_t *s;
1816     uint8_t *d;
1817     int j, b, v, n1, src_wrap, dst_wrap, y;
1818
1819     s = src->data[0];
1820     src_wrap = src->linesize[0] - width;
1821
1822     d = dst->data[0];
1823     dst_wrap = dst->linesize[0] - ((width + 7) >> 3);
1824
1825     for(y=0;y<height;y++) {
1826         n = width;
1827         while (n >= 8) {
1828             v = 0;
1829             for(j=0;j<8;j++) {
1830                 b = s[0];
1831                 s++;
1832                 v = (v << 1) | (b >> 7);
1833             }
1834             d[0] = v ^ xor_mask;
1835             d++;
1836             n -= 8;
1837         }
1838         if (n > 0) {
1839             n1 = n;
1840             v = 0;
1841             while (n > 0) {
1842                 b = s[0];
1843                 s++;
1844                 v = (v << 1) | (b >> 7);
1845                 n--;
1846             }
1847             d[0] = (v << (8 - (n1 & 7))) ^ xor_mask;
1848             d++;
1849         }
1850         s += src_wrap;
1851         d += dst_wrap;
1852     }
1853 }
1854
1855 static void gray_to_monowhite(AVPicture *dst, const AVPicture *src,
1856                               int width, int height)
1857 {
1858     gray_to_mono(dst, src, width, height, 0xff);
1859 }
1860
1861 static void gray_to_monoblack(AVPicture *dst, const AVPicture *src,
1862                               int width, int height)
1863 {
1864     gray_to_mono(dst, src, width, height, 0x00);
1865 }
1866
1867 static void gray_to_gray16(AVPicture *dst, const AVPicture *src,
1868                               int width, int height)
1869 {
1870     int x, y, src_wrap, dst_wrap;
1871     uint8_t *s, *d;
1872     s = src->data[0];
1873     src_wrap = src->linesize[0] - width;
1874     d = dst->data[0];
1875     dst_wrap = dst->linesize[0] - width * 2;
1876     for(y=0; y<height; y++){
1877         for(x=0; x<width; x++){
1878             *d++ = *s;
1879             *d++ = *s++;
1880         }
1881         s += src_wrap;
1882         d += dst_wrap;
1883     }
1884 }
1885
1886 static void gray16_to_gray(AVPicture *dst, const AVPicture *src,
1887                               int width, int height)
1888 {
1889     int x, y, src_wrap, dst_wrap;
1890     uint8_t *s, *d;
1891     s = src->data[0];
1892     src_wrap = src->linesize[0] - width * 2;
1893     d = dst->data[0];
1894     dst_wrap = dst->linesize[0] - width;
1895     for(y=0; y<height; y++){
1896         for(x=0; x<width; x++){
1897             *d++ = *s;
1898             s += 2;
1899         }
1900         s += src_wrap;
1901         d += dst_wrap;
1902     }
1903 }
1904
1905 static void gray16be_to_gray(AVPicture *dst, const AVPicture *src,
1906                               int width, int height)
1907 {
1908     gray16_to_gray(dst, src, width, height);
1909 }
1910
1911 static void gray16le_to_gray(AVPicture *dst, const AVPicture *src,
1912                               int width, int height)
1913 {
1914     AVPicture tmpsrc = *src;
1915     tmpsrc.data[0]++;
1916     gray16_to_gray(dst, &tmpsrc, width, height);
1917 }
1918
1919 static void gray16_to_gray16(AVPicture *dst, const AVPicture *src,
1920                               int width, int height)
1921 {
1922     int x, y, src_wrap, dst_wrap;
1923     uint16_t *s, *d;
1924     s = (uint16_t*)src->data[0];
1925     src_wrap = (src->linesize[0] - width * 2)/2;
1926     d = (uint16_t*)dst->data[0];
1927     dst_wrap = (dst->linesize[0] - width * 2)/2;
1928     for(y=0; y<height; y++){
1929         for(x=0; x<width; x++){
1930             *d++ = bswap_16(*s++);
1931         }
1932         s += src_wrap;
1933         d += dst_wrap;
1934     }
1935 }
1936
1937
1938 typedef struct ConvertEntry {
1939     void (*convert)(AVPicture *dst,
1940                     const AVPicture *src, int width, int height);
1941 } ConvertEntry;
1942
1943 /* Add each new conversion function in this table. In order to be able
1944    to convert from any format to any format, the following constraints
1945    must be satisfied:
1946
1947    - all FF_COLOR_RGB formats must convert to and from PIX_FMT_RGB24
1948
1949    - all FF_COLOR_GRAY formats must convert to and from PIX_FMT_GRAY8
1950
1951    - all FF_COLOR_RGB formats with alpha must convert to and from PIX_FMT_RGB32
1952
1953    - PIX_FMT_YUV444P and PIX_FMT_YUVJ444P must convert to and from
1954      PIX_FMT_RGB24.
1955
1956    - PIX_FMT_422 must convert to and from PIX_FMT_422P.
1957
1958    The other conversion functions are just optimizations for common cases.
1959 */
1960 static const ConvertEntry convert_table[PIX_FMT_NB][PIX_FMT_NB] = {
1961     [PIX_FMT_YUV420P] = {
1962         [PIX_FMT_YUYV422] = {
1963             .convert = yuv420p_to_yuyv422,
1964         },
1965         [PIX_FMT_RGB555] = {
1966             .convert = yuv420p_to_rgb555
1967         },
1968         [PIX_FMT_RGB565] = {
1969             .convert = yuv420p_to_rgb565
1970         },
1971         [PIX_FMT_BGR24] = {
1972             .convert = yuv420p_to_bgr24
1973         },
1974         [PIX_FMT_RGB24] = {
1975             .convert = yuv420p_to_rgb24
1976         },
1977         [PIX_FMT_RGB32] = {
1978             .convert = yuv420p_to_rgb32
1979         },
1980         [PIX_FMT_UYVY422] = {
1981             .convert = yuv420p_to_uyvy422,
1982         },
1983     },
1984     [PIX_FMT_YUV422P] = {
1985         [PIX_FMT_YUYV422] = {
1986             .convert = yuv422p_to_yuyv422,
1987         },
1988         [PIX_FMT_UYVY422] = {
1989             .convert = yuv422p_to_uyvy422,
1990         },
1991     },
1992     [PIX_FMT_YUV444P] = {
1993         [PIX_FMT_RGB24] = {
1994             .convert = yuv444p_to_rgb24
1995         },
1996     },
1997     [PIX_FMT_YUVJ420P] = {
1998         [PIX_FMT_RGB555] = {
1999             .convert = yuvj420p_to_rgb555
2000         },
2001         [PIX_FMT_RGB565] = {
2002             .convert = yuvj420p_to_rgb565
2003         },
2004         [PIX_FMT_BGR24] = {
2005             .convert = yuvj420p_to_bgr24
2006         },
2007         [PIX_FMT_RGB24] = {
2008             .convert = yuvj420p_to_rgb24
2009         },
2010         [PIX_FMT_RGB32] = {
2011             .convert = yuvj420p_to_rgb32
2012         },
2013     },
2014     [PIX_FMT_YUVJ444P] = {
2015         [PIX_FMT_RGB24] = {
2016             .convert = yuvj444p_to_rgb24
2017         },
2018     },
2019     [PIX_FMT_YUYV422] = {
2020         [PIX_FMT_YUV420P] = {
2021             .convert = yuyv422_to_yuv420p,
2022         },
2023         [PIX_FMT_YUV422P] = {
2024             .convert = yuyv422_to_yuv422p,
2025         },
2026     },
2027     [PIX_FMT_UYVY422] = {
2028         [PIX_FMT_YUV420P] = {
2029             .convert = uyvy422_to_yuv420p,
2030         },
2031         [PIX_FMT_YUV422P] = {
2032             .convert = uyvy422_to_yuv422p,
2033         },
2034     },
2035     [PIX_FMT_RGB24] = {
2036         [PIX_FMT_YUV420P] = {
2037             .convert = rgb24_to_yuv420p
2038         },
2039         [PIX_FMT_RGB565] = {
2040             .convert = rgb24_to_rgb565
2041         },
2042         [PIX_FMT_RGB555] = {
2043             .convert = rgb24_to_rgb555
2044         },
2045         [PIX_FMT_RGB32] = {
2046             .convert = rgb24_to_rgb32
2047         },
2048         [PIX_FMT_BGR24] = {
2049             .convert = rgb24_to_bgr24
2050         },
2051         [PIX_FMT_GRAY8] = {
2052             .convert = rgb24_to_gray
2053         },
2054         [PIX_FMT_PAL8] = {
2055             .convert = rgb24_to_pal8
2056         },
2057         [PIX_FMT_YUV444P] = {
2058             .convert = rgb24_to_yuv444p
2059         },
2060         [PIX_FMT_YUVJ420P] = {
2061             .convert = rgb24_to_yuvj420p
2062         },
2063         [PIX_FMT_YUVJ444P] = {
2064             .convert = rgb24_to_yuvj444p
2065         },
2066     },
2067     [PIX_FMT_RGB32] = {
2068         [PIX_FMT_RGB24] = {
2069             .convert = rgb32_to_rgb24
2070         },
2071         [PIX_FMT_BGR24] = {
2072             .convert = rgb32_to_bgr24
2073         },
2074         [PIX_FMT_RGB565] = {
2075             .convert = rgb32_to_rgb565
2076         },
2077         [PIX_FMT_RGB555] = {
2078             .convert = rgb32_to_rgb555
2079         },
2080         [PIX_FMT_PAL8] = {
2081             .convert = rgb32_to_pal8
2082         },
2083         [PIX_FMT_YUV420P] = {
2084             .convert = rgb32_to_yuv420p
2085         },
2086         [PIX_FMT_GRAY8] = {
2087             .convert = rgb32_to_gray
2088         },
2089     },
2090     [PIX_FMT_BGR24] = {
2091         [PIX_FMT_RGB32] = {
2092             .convert = bgr24_to_rgb32
2093         },
2094         [PIX_FMT_RGB24] = {
2095             .convert = bgr24_to_rgb24
2096         },
2097         [PIX_FMT_YUV420P] = {
2098             .convert = bgr24_to_yuv420p
2099         },
2100         [PIX_FMT_GRAY8] = {
2101             .convert = bgr24_to_gray
2102         },
2103     },
2104     [PIX_FMT_RGB555] = {
2105         [PIX_FMT_RGB24] = {
2106             .convert = rgb555_to_rgb24
2107         },
2108         [PIX_FMT_RGB32] = {
2109             .convert = rgb555_to_rgb32
2110         },
2111         [PIX_FMT_YUV420P] = {
2112             .convert = rgb555_to_yuv420p
2113         },
2114         [PIX_FMT_GRAY8] = {
2115             .convert = rgb555_to_gray
2116         },
2117     },
2118     [PIX_FMT_RGB565] = {
2119         [PIX_FMT_RGB32] = {
2120             .convert = rgb565_to_rgb32
2121         },
2122         [PIX_FMT_RGB24] = {
2123             .convert = rgb565_to_rgb24
2124         },
2125         [PIX_FMT_YUV420P] = {
2126             .convert = rgb565_to_yuv420p
2127         },
2128         [PIX_FMT_GRAY8] = {
2129             .convert = rgb565_to_gray
2130         },
2131     },
2132     [PIX_FMT_GRAY16BE] = {
2133         [PIX_FMT_GRAY8] = {
2134             .convert = gray16be_to_gray
2135         },
2136         [PIX_FMT_GRAY16LE] = {
2137             .convert = gray16_to_gray16
2138         },
2139     },
2140     [PIX_FMT_GRAY16LE] = {
2141         [PIX_FMT_GRAY8] = {
2142             .convert = gray16le_to_gray
2143         },
2144         [PIX_FMT_GRAY16BE] = {
2145             .convert = gray16_to_gray16
2146         },
2147     },
2148     [PIX_FMT_GRAY8] = {
2149         [PIX_FMT_RGB555] = {
2150             .convert = gray_to_rgb555
2151         },
2152         [PIX_FMT_RGB565] = {
2153             .convert = gray_to_rgb565
2154         },
2155         [PIX_FMT_RGB24] = {
2156             .convert = gray_to_rgb24
2157         },
2158         [PIX_FMT_BGR24] = {
2159             .convert = gray_to_bgr24
2160         },
2161         [PIX_FMT_RGB32] = {
2162             .convert = gray_to_rgb32
2163         },
2164         [PIX_FMT_MONOWHITE] = {
2165             .convert = gray_to_monowhite
2166         },
2167         [PIX_FMT_MONOBLACK] = {
2168             .convert = gray_to_monoblack
2169         },
2170         [PIX_FMT_GRAY16LE] = {
2171             .convert = gray_to_gray16
2172         },
2173         [PIX_FMT_GRAY16BE] = {
2174             .convert = gray_to_gray16
2175         },
2176     },
2177     [PIX_FMT_MONOWHITE] = {
2178         [PIX_FMT_GRAY8] = {
2179             .convert = monowhite_to_gray
2180         },
2181     },
2182     [PIX_FMT_MONOBLACK] = {
2183         [PIX_FMT_GRAY8] = {
2184             .convert = monoblack_to_gray
2185         },
2186     },
2187     [PIX_FMT_PAL8] = {
2188         [PIX_FMT_RGB555] = {
2189             .convert = pal8_to_rgb555
2190         },
2191         [PIX_FMT_RGB565] = {
2192             .convert = pal8_to_rgb565
2193         },
2194         [PIX_FMT_BGR24] = {
2195             .convert = pal8_to_bgr24
2196         },
2197         [PIX_FMT_RGB24] = {
2198             .convert = pal8_to_rgb24
2199         },
2200         [PIX_FMT_RGB32] = {
2201             .convert = pal8_to_rgb32
2202         },
2203     },
2204     [PIX_FMT_UYYVYY411] = {
2205         [PIX_FMT_YUV411P] = {
2206             .convert = uyyvyy411_to_yuv411p,
2207         },
2208     },
2209
2210 };
2211
2212 int avpicture_alloc(AVPicture *picture,
2213                            int pix_fmt, int width, int height)
2214 {
2215     int size;
2216     void *ptr;
2217
2218     size = avpicture_get_size(pix_fmt, width, height);
2219     if(size<0)
2220         goto fail;
2221     ptr = av_malloc(size);
2222     if (!ptr)
2223         goto fail;
2224     avpicture_fill(picture, ptr, pix_fmt, width, height);
2225     return 0;
2226  fail:
2227     memset(picture, 0, sizeof(AVPicture));
2228     return -1;
2229 }
2230
2231 void avpicture_free(AVPicture *picture)
2232 {
2233     av_free(picture->data[0]);
2234 }
2235
2236 /* return true if yuv planar */
2237 static inline int is_yuv_planar(const PixFmtInfo *ps)
2238 {
2239     return (ps->color_type == FF_COLOR_YUV ||
2240             ps->color_type == FF_COLOR_YUV_JPEG) &&
2241         ps->pixel_type == FF_PIXEL_PLANAR;
2242 }
2243
2244 int av_picture_crop(AVPicture *dst, const AVPicture *src,
2245               int pix_fmt, int top_band, int left_band)
2246 {
2247     int y_shift;
2248     int x_shift;
2249
2250     if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt]))
2251         return -1;
2252
2253     y_shift = pix_fmt_info[pix_fmt].y_chroma_shift;
2254     x_shift = pix_fmt_info[pix_fmt].x_chroma_shift;
2255
2256     dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band;
2257     dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift);
2258     dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift);
2259
2260     dst->linesize[0] = src->linesize[0];
2261     dst->linesize[1] = src->linesize[1];
2262     dst->linesize[2] = src->linesize[2];
2263     return 0;
2264 }
2265
2266 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width,
2267             int pix_fmt, int padtop, int padbottom, int padleft, int padright,
2268             int *color)
2269 {
2270     uint8_t *optr;
2271     int y_shift;
2272     int x_shift;
2273     int yheight;
2274     int i, y;
2275
2276     if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB ||
2277         !is_yuv_planar(&pix_fmt_info[pix_fmt])) return -1;
2278
2279     for (i = 0; i < 3; i++) {
2280         x_shift = i ? pix_fmt_info[pix_fmt].x_chroma_shift : 0;
2281         y_shift = i ? pix_fmt_info[pix_fmt].y_chroma_shift : 0;
2282
2283         if (padtop || padleft) {
2284             memset(dst->data[i], color[i],
2285                 dst->linesize[i] * (padtop >> y_shift) + (padleft >> x_shift));
2286         }
2287
2288         if (padleft || padright) {
2289             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
2290                 (dst->linesize[i] - (padright >> x_shift));
2291             yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
2292             for (y = 0; y < yheight; y++) {
2293                 memset(optr, color[i], (padleft + padright) >> x_shift);
2294                 optr += dst->linesize[i];
2295             }
2296         }
2297
2298         if (src) { /* first line */
2299             uint8_t *iptr = src->data[i];
2300             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
2301                     (padleft >> x_shift);
2302             memcpy(optr, iptr, src->linesize[i]);
2303             iptr += src->linesize[i];
2304             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
2305                 (dst->linesize[i] - (padright >> x_shift));
2306             yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
2307             for (y = 0; y < yheight; y++) {
2308                 memset(optr, color[i], (padleft + padright) >> x_shift);
2309                 memcpy(optr + ((padleft + padright) >> x_shift), iptr,
2310                     src->linesize[i]);
2311                 iptr += src->linesize[i];
2312                 optr += dst->linesize[i];
2313             }
2314         }
2315
2316         if (padbottom || padright) {
2317             optr = dst->data[i] + dst->linesize[i] *
2318                 ((height - padbottom) >> y_shift) - (padright >> x_shift);
2319             memset(optr, color[i],dst->linesize[i] *
2320                 (padbottom >> y_shift) + (padright >> x_shift));
2321         }
2322     }
2323     return 0;
2324 }
2325
2326 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
2327 void img_copy(AVPicture *dst, const AVPicture *src,
2328               int pix_fmt, int width, int height)
2329 {
2330     av_picture_copy(dst, src, pix_fmt, width, height);
2331 }
2332
2333 int img_crop(AVPicture *dst, const AVPicture *src,
2334               int pix_fmt, int top_band, int left_band)
2335 {
2336     return av_picture_crop(dst, src, pix_fmt, top_band, left_band);
2337 }
2338
2339 int img_pad(AVPicture *dst, const AVPicture *src, int height, int width,
2340             int pix_fmt, int padtop, int padbottom, int padleft, int padright,
2341             int *color)
2342 {
2343     return av_picture_pad(dst, src, height, width, pix_fmt, padtop, padbottom, padleft, padright, color);
2344 }
2345 #endif
2346
2347 #ifndef CONFIG_SWSCALER
2348 /* XXX: always use linesize. Return -1 if not supported */
2349 int img_convert(AVPicture *dst, int dst_pix_fmt,
2350                 const AVPicture *src, int src_pix_fmt,
2351                 int src_width, int src_height)
2352 {
2353     static int inited;
2354     int i, ret, dst_width, dst_height, int_pix_fmt;
2355     const PixFmtInfo *src_pix, *dst_pix;
2356     const ConvertEntry *ce;
2357     AVPicture tmp1, *tmp = &tmp1;
2358
2359     if (src_pix_fmt < 0 || src_pix_fmt >= PIX_FMT_NB ||
2360         dst_pix_fmt < 0 || dst_pix_fmt >= PIX_FMT_NB)
2361         return -1;
2362     if (src_width <= 0 || src_height <= 0)
2363         return 0;
2364
2365     if (!inited) {
2366         inited = 1;
2367         img_convert_init();
2368     }
2369
2370     dst_width = src_width;
2371     dst_height = src_height;
2372
2373     dst_pix = &pix_fmt_info[dst_pix_fmt];
2374     src_pix = &pix_fmt_info[src_pix_fmt];
2375     if (src_pix_fmt == dst_pix_fmt) {
2376         /* no conversion needed: just copy */
2377         av_picture_copy(dst, src, dst_pix_fmt, dst_width, dst_height);
2378         return 0;
2379     }
2380
2381     ce = &convert_table[src_pix_fmt][dst_pix_fmt];
2382     if (ce->convert) {
2383         /* specific conversion routine */
2384         ce->convert(dst, src, dst_width, dst_height);
2385         return 0;
2386     }
2387
2388     /* gray to YUV */
2389     if (is_yuv_planar(dst_pix) &&
2390         src_pix_fmt == PIX_FMT_GRAY8) {
2391         int w, h, y;
2392         uint8_t *d;
2393
2394         if (dst_pix->color_type == FF_COLOR_YUV_JPEG) {
2395             ff_img_copy_plane(dst->data[0], dst->linesize[0],
2396                      src->data[0], src->linesize[0],
2397                      dst_width, dst_height);
2398         } else {
2399             img_apply_table(dst->data[0], dst->linesize[0],
2400                             src->data[0], src->linesize[0],
2401                             dst_width, dst_height,
2402                             y_jpeg_to_ccir);
2403         }
2404         /* fill U and V with 128 */
2405         w = dst_width;
2406         h = dst_height;
2407         w >>= dst_pix->x_chroma_shift;
2408         h >>= dst_pix->y_chroma_shift;
2409         for(i = 1; i <= 2; i++) {
2410             d = dst->data[i];
2411             for(y = 0; y< h; y++) {
2412                 memset(d, 128, w);
2413                 d += dst->linesize[i];
2414             }
2415         }
2416         return 0;
2417     }
2418
2419     /* YUV to gray */
2420     if (is_yuv_planar(src_pix) &&
2421         dst_pix_fmt == PIX_FMT_GRAY8) {
2422         if (src_pix->color_type == FF_COLOR_YUV_JPEG) {
2423             ff_img_copy_plane(dst->data[0], dst->linesize[0],
2424                      src->data[0], src->linesize[0],
2425                      dst_width, dst_height);
2426         } else {
2427             img_apply_table(dst->data[0], dst->linesize[0],
2428                             src->data[0], src->linesize[0],
2429                             dst_width, dst_height,
2430                             y_ccir_to_jpeg);
2431         }
2432         return 0;
2433     }
2434
2435     /* YUV to YUV planar */
2436     if (is_yuv_planar(dst_pix) && is_yuv_planar(src_pix)) {
2437         int x_shift, y_shift, w, h, xy_shift;
2438         void (*resize_func)(uint8_t *dst, int dst_wrap,
2439                             const uint8_t *src, int src_wrap,
2440                             int width, int height);
2441
2442         /* compute chroma size of the smallest dimensions */
2443         w = dst_width;
2444         h = dst_height;
2445         if (dst_pix->x_chroma_shift >= src_pix->x_chroma_shift)
2446             w >>= dst_pix->x_chroma_shift;
2447         else
2448             w >>= src_pix->x_chroma_shift;
2449         if (dst_pix->y_chroma_shift >= src_pix->y_chroma_shift)
2450             h >>= dst_pix->y_chroma_shift;
2451         else
2452             h >>= src_pix->y_chroma_shift;
2453
2454         x_shift = (dst_pix->x_chroma_shift - src_pix->x_chroma_shift);
2455         y_shift = (dst_pix->y_chroma_shift - src_pix->y_chroma_shift);
2456         xy_shift = ((x_shift & 0xf) << 4) | (y_shift & 0xf);
2457         /* there must be filters for conversion at least from and to
2458            YUV444 format */
2459         switch(xy_shift) {
2460         case 0x00:
2461             resize_func = ff_img_copy_plane;
2462             break;
2463         case 0x10:
2464             resize_func = shrink21;
2465             break;
2466         case 0x20:
2467             resize_func = shrink41;
2468             break;
2469         case 0x01:
2470             resize_func = shrink12;
2471             break;
2472         case 0x11:
2473             resize_func = ff_shrink22;
2474             break;
2475         case 0x22:
2476             resize_func = ff_shrink44;
2477             break;
2478         case 0xf0:
2479             resize_func = grow21;
2480             break;
2481         case 0x0f:
2482             resize_func = grow12;
2483             break;
2484         case 0xe0:
2485             resize_func = grow41;
2486             break;
2487         case 0xff:
2488             resize_func = grow22;
2489             break;
2490         case 0xee:
2491             resize_func = grow44;
2492             break;
2493         case 0xf1:
2494             resize_func = conv411;
2495             break;
2496         default:
2497             /* currently not handled */
2498             goto no_chroma_filter;
2499         }
2500
2501         ff_img_copy_plane(dst->data[0], dst->linesize[0],
2502                        src->data[0], src->linesize[0],
2503                        dst_width, dst_height);
2504
2505         for(i = 1;i <= 2; i++)
2506             resize_func(dst->data[i], dst->linesize[i],
2507                         src->data[i], src->linesize[i],
2508                         dst_width>>dst_pix->x_chroma_shift, dst_height>>dst_pix->y_chroma_shift);
2509         /* if yuv color space conversion is needed, we do it here on
2510            the destination image */
2511         if (dst_pix->color_type != src_pix->color_type) {
2512             const uint8_t *y_table, *c_table;
2513             if (dst_pix->color_type == FF_COLOR_YUV) {
2514                 y_table = y_jpeg_to_ccir;
2515                 c_table = c_jpeg_to_ccir;
2516             } else {
2517                 y_table = y_ccir_to_jpeg;
2518                 c_table = c_ccir_to_jpeg;
2519             }
2520             img_apply_table(dst->data[0], dst->linesize[0],
2521                             dst->data[0], dst->linesize[0],
2522                             dst_width, dst_height,
2523                             y_table);
2524
2525             for(i = 1;i <= 2; i++)
2526                 img_apply_table(dst->data[i], dst->linesize[i],
2527                                 dst->data[i], dst->linesize[i],
2528                                 dst_width>>dst_pix->x_chroma_shift,
2529                                 dst_height>>dst_pix->y_chroma_shift,
2530                                 c_table);
2531         }
2532         return 0;
2533     }
2534  no_chroma_filter:
2535
2536     /* try to use an intermediate format */
2537     if (src_pix_fmt == PIX_FMT_YUYV422 ||
2538         dst_pix_fmt == PIX_FMT_YUYV422) {
2539         /* specific case: convert to YUV422P first */
2540         int_pix_fmt = PIX_FMT_YUV422P;
2541     } else if (src_pix_fmt == PIX_FMT_UYVY422 ||
2542         dst_pix_fmt == PIX_FMT_UYVY422) {
2543         /* specific case: convert to YUV422P first */
2544         int_pix_fmt = PIX_FMT_YUV422P;
2545     } else if (src_pix_fmt == PIX_FMT_UYYVYY411 ||
2546         dst_pix_fmt == PIX_FMT_UYYVYY411) {
2547         /* specific case: convert to YUV411P first */
2548         int_pix_fmt = PIX_FMT_YUV411P;
2549     } else if ((src_pix->color_type == FF_COLOR_GRAY &&
2550                 src_pix_fmt != PIX_FMT_GRAY8) ||
2551                (dst_pix->color_type == FF_COLOR_GRAY &&
2552                 dst_pix_fmt != PIX_FMT_GRAY8)) {
2553         /* gray8 is the normalized format */
2554         int_pix_fmt = PIX_FMT_GRAY8;
2555     } else if ((is_yuv_planar(src_pix) &&
2556                 src_pix_fmt != PIX_FMT_YUV444P &&
2557                 src_pix_fmt != PIX_FMT_YUVJ444P)) {
2558         /* yuv444 is the normalized format */
2559         if (src_pix->color_type == FF_COLOR_YUV_JPEG)
2560             int_pix_fmt = PIX_FMT_YUVJ444P;
2561         else
2562             int_pix_fmt = PIX_FMT_YUV444P;
2563     } else if ((is_yuv_planar(dst_pix) &&
2564                 dst_pix_fmt != PIX_FMT_YUV444P &&
2565                 dst_pix_fmt != PIX_FMT_YUVJ444P)) {
2566         /* yuv444 is the normalized format */
2567         if (dst_pix->color_type == FF_COLOR_YUV_JPEG)
2568             int_pix_fmt = PIX_FMT_YUVJ444P;
2569         else
2570             int_pix_fmt = PIX_FMT_YUV444P;
2571     } else {
2572         /* the two formats are rgb or gray8 or yuv[j]444p */
2573         if (src_pix->is_alpha && dst_pix->is_alpha)
2574             int_pix_fmt = PIX_FMT_RGB32;
2575         else
2576             int_pix_fmt = PIX_FMT_RGB24;
2577     }
2578     if (src_pix_fmt == int_pix_fmt)
2579         return -1;
2580     if (avpicture_alloc(tmp, int_pix_fmt, dst_width, dst_height) < 0)
2581         return -1;
2582     ret = -1;
2583     if (img_convert(tmp, int_pix_fmt,
2584                     src, src_pix_fmt, src_width, src_height) < 0)
2585         goto fail1;
2586     if (img_convert(dst, dst_pix_fmt,
2587                     tmp, int_pix_fmt, dst_width, dst_height) < 0)
2588         goto fail1;
2589     ret = 0;
2590  fail1:
2591     avpicture_free(tmp);
2592     return ret;
2593 }
2594 #endif
2595
2596 /* NOTE: we scan all the pixels to have an exact information */
2597 static int get_alpha_info_pal8(const AVPicture *src, int width, int height)
2598 {
2599     const unsigned char *p;
2600     int src_wrap, ret, x, y;
2601     unsigned int a;
2602     uint32_t *palette = (uint32_t *)src->data[1];
2603
2604     p = src->data[0];
2605     src_wrap = src->linesize[0] - width;
2606     ret = 0;
2607     for(y=0;y<height;y++) {
2608         for(x=0;x<width;x++) {
2609             a = palette[p[0]] >> 24;
2610             if (a == 0x00) {
2611                 ret |= FF_ALPHA_TRANSP;
2612             } else if (a != 0xff) {
2613                 ret |= FF_ALPHA_SEMI_TRANSP;
2614             }
2615             p++;
2616         }
2617         p += src_wrap;
2618     }
2619     return ret;
2620 }
2621
2622 int img_get_alpha_info(const AVPicture *src,
2623                        int pix_fmt, int width, int height)
2624 {
2625     const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
2626     int ret;
2627
2628     pf = &pix_fmt_info[pix_fmt];
2629     /* no alpha can be represented in format */
2630     if (!pf->is_alpha)
2631         return 0;
2632     switch(pix_fmt) {
2633     case PIX_FMT_RGB32:
2634         ret = get_alpha_info_rgb32(src, width, height);
2635         break;
2636     case PIX_FMT_PAL8:
2637         ret = get_alpha_info_pal8(src, width, height);
2638         break;
2639     default:
2640         /* we do not know, so everything is indicated */
2641         ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP;
2642         break;
2643     }
2644     return ret;
2645 }
2646
2647 #ifdef HAVE_MMX
2648 #define DEINT_INPLACE_LINE_LUM \
2649                     movd_m2r(lum_m4[0],mm0);\
2650                     movd_m2r(lum_m3[0],mm1);\
2651                     movd_m2r(lum_m2[0],mm2);\
2652                     movd_m2r(lum_m1[0],mm3);\
2653                     movd_m2r(lum[0],mm4);\
2654                     punpcklbw_r2r(mm7,mm0);\
2655                     movd_r2m(mm2,lum_m4[0]);\
2656                     punpcklbw_r2r(mm7,mm1);\
2657                     punpcklbw_r2r(mm7,mm2);\
2658                     punpcklbw_r2r(mm7,mm3);\
2659                     punpcklbw_r2r(mm7,mm4);\
2660                     paddw_r2r(mm3,mm1);\
2661                     psllw_i2r(1,mm2);\
2662                     paddw_r2r(mm4,mm0);\
2663                     psllw_i2r(2,mm1);\
2664                     paddw_r2r(mm6,mm2);\
2665                     paddw_r2r(mm2,mm1);\
2666                     psubusw_r2r(mm0,mm1);\
2667                     psrlw_i2r(3,mm1);\
2668                     packuswb_r2r(mm7,mm1);\
2669                     movd_r2m(mm1,lum_m2[0]);
2670
2671 #define DEINT_LINE_LUM \
2672                     movd_m2r(lum_m4[0],mm0);\
2673                     movd_m2r(lum_m3[0],mm1);\
2674                     movd_m2r(lum_m2[0],mm2);\
2675                     movd_m2r(lum_m1[0],mm3);\
2676                     movd_m2r(lum[0],mm4);\
2677                     punpcklbw_r2r(mm7,mm0);\
2678                     punpcklbw_r2r(mm7,mm1);\
2679                     punpcklbw_r2r(mm7,mm2);\
2680                     punpcklbw_r2r(mm7,mm3);\
2681                     punpcklbw_r2r(mm7,mm4);\
2682                     paddw_r2r(mm3,mm1);\
2683                     psllw_i2r(1,mm2);\
2684                     paddw_r2r(mm4,mm0);\
2685                     psllw_i2r(2,mm1);\
2686                     paddw_r2r(mm6,mm2);\
2687                     paddw_r2r(mm2,mm1);\
2688                     psubusw_r2r(mm0,mm1);\
2689                     psrlw_i2r(3,mm1);\
2690                     packuswb_r2r(mm7,mm1);\
2691                     movd_r2m(mm1,dst[0]);
2692 #endif
2693
2694 /* filter parameters: [-1 4 2 4 -1] // 8 */
2695 static void deinterlace_line(uint8_t *dst,
2696                              const uint8_t *lum_m4, const uint8_t *lum_m3,
2697                              const uint8_t *lum_m2, const uint8_t *lum_m1,
2698                              const uint8_t *lum,
2699                              int size)
2700 {
2701 #ifndef HAVE_MMX
2702     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2703     int sum;
2704
2705     for(;size > 0;size--) {
2706         sum = -lum_m4[0];
2707         sum += lum_m3[0] << 2;
2708         sum += lum_m2[0] << 1;
2709         sum += lum_m1[0] << 2;
2710         sum += -lum[0];
2711         dst[0] = cm[(sum + 4) >> 3];
2712         lum_m4++;
2713         lum_m3++;
2714         lum_m2++;
2715         lum_m1++;
2716         lum++;
2717         dst++;
2718     }
2719 #else
2720
2721     {
2722         mmx_t rounder;
2723         rounder.uw[0]=4;
2724         rounder.uw[1]=4;
2725         rounder.uw[2]=4;
2726         rounder.uw[3]=4;
2727         pxor_r2r(mm7,mm7);
2728         movq_m2r(rounder,mm6);
2729     }
2730     for (;size > 3; size-=4) {
2731         DEINT_LINE_LUM
2732         lum_m4+=4;
2733         lum_m3+=4;
2734         lum_m2+=4;
2735         lum_m1+=4;
2736         lum+=4;
2737         dst+=4;
2738     }
2739 #endif
2740 }
2741 static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum,
2742                              int size)
2743 {
2744 #ifndef HAVE_MMX
2745     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2746     int sum;
2747
2748     for(;size > 0;size--) {
2749         sum = -lum_m4[0];
2750         sum += lum_m3[0] << 2;
2751         sum += lum_m2[0] << 1;
2752         lum_m4[0]=lum_m2[0];
2753         sum += lum_m1[0] << 2;
2754         sum += -lum[0];
2755         lum_m2[0] = cm[(sum + 4) >> 3];
2756         lum_m4++;
2757         lum_m3++;
2758         lum_m2++;
2759         lum_m1++;
2760         lum++;
2761     }
2762 #else
2763
2764     {
2765         mmx_t rounder;
2766         rounder.uw[0]=4;
2767         rounder.uw[1]=4;
2768         rounder.uw[2]=4;
2769         rounder.uw[3]=4;
2770         pxor_r2r(mm7,mm7);
2771         movq_m2r(rounder,mm6);
2772     }
2773     for (;size > 3; size-=4) {
2774         DEINT_INPLACE_LINE_LUM
2775         lum_m4+=4;
2776         lum_m3+=4;
2777         lum_m2+=4;
2778         lum_m1+=4;
2779         lum+=4;
2780     }
2781 #endif
2782 }
2783
2784 /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
2785    top field is copied as is, but the bottom field is deinterlaced
2786    against the top field. */
2787 static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap,
2788                                     const uint8_t *src1, int src_wrap,
2789                                     int width, int height)
2790 {
2791     const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
2792     int y;
2793
2794     src_m2 = src1;
2795     src_m1 = src1;
2796     src_0=&src_m1[src_wrap];
2797     src_p1=&src_0[src_wrap];
2798     src_p2=&src_p1[src_wrap];
2799     for(y=0;y<(height-2);y+=2) {
2800         memcpy(dst,src_m1,width);
2801         dst += dst_wrap;
2802         deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width);
2803         src_m2 = src_0;
2804         src_m1 = src_p1;
2805         src_0 = src_p2;
2806         src_p1 += 2*src_wrap;
2807         src_p2 += 2*src_wrap;
2808         dst += dst_wrap;
2809     }
2810     memcpy(dst,src_m1,width);
2811     dst += dst_wrap;
2812     /* do last line */
2813     deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);
2814 }
2815
2816 static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap,
2817                                              int width, int height)
2818 {
2819     uint8_t *src_m1, *src_0, *src_p1, *src_p2;
2820     int y;
2821     uint8_t *buf;
2822     buf = (uint8_t*)av_malloc(width);
2823
2824     src_m1 = src1;
2825     memcpy(buf,src_m1,width);
2826     src_0=&src_m1[src_wrap];
2827     src_p1=&src_0[src_wrap];
2828     src_p2=&src_p1[src_wrap];
2829     for(y=0;y<(height-2);y+=2) {
2830         deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width);
2831         src_m1 = src_p1;
2832         src_0 = src_p2;
2833         src_p1 += 2*src_wrap;
2834         src_p2 += 2*src_wrap;
2835     }
2836     /* do last line */
2837     deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width);
2838     av_free(buf);
2839 }
2840
2841 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
2842                           int pix_fmt, int width, int height)
2843 {
2844     int i;
2845
2846     if (pix_fmt != PIX_FMT_YUV420P &&
2847         pix_fmt != PIX_FMT_YUV422P &&
2848         pix_fmt != PIX_FMT_YUV444P &&
2849         pix_fmt != PIX_FMT_YUV411P &&
2850         pix_fmt != PIX_FMT_GRAY8)
2851         return -1;
2852     if ((width & 3) != 0 || (height & 3) != 0)
2853         return -1;
2854
2855     for(i=0;i<3;i++) {
2856         if (i == 1) {
2857             switch(pix_fmt) {
2858             case PIX_FMT_YUV420P:
2859                 width >>= 1;
2860                 height >>= 1;
2861                 break;
2862             case PIX_FMT_YUV422P:
2863                 width >>= 1;
2864                 break;
2865             case PIX_FMT_YUV411P:
2866                 width >>= 2;
2867                 break;
2868             default:
2869                 break;
2870             }
2871             if (pix_fmt == PIX_FMT_GRAY8) {
2872                 break;
2873             }
2874         }
2875         if (src == dst) {
2876             deinterlace_bottom_field_inplace(dst->data[i], dst->linesize[i],
2877                                  width, height);
2878         } else {
2879             deinterlace_bottom_field(dst->data[i],dst->linesize[i],
2880                                         src->data[i], src->linesize[i],
2881                                         width, height);
2882         }
2883     }
2884     emms_c();
2885     return 0;
2886 }
2887