* started to cleanup name clashes for onetime compilation
[ffmpeg.git] / libavcodec / imgconvert.c
1 /*
2  * Misc image convertion routines
3  * Copyright (c) 2001, 2002 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19 #include "avcodec.h"
20 #include "dsputil.h"
21
22 #ifdef USE_FASTMEMCPY
23 #include "fastmemcpy.h"
24 #endif
25 /* XXX: totally non optimized */
26
27 static void yuv422_to_yuv420p(UINT8 *lum, UINT8 *cb, UINT8 *cr,
28                               UINT8 *src, int width, int height)
29 {
30     int x, y;
31     UINT8 *p = src;
32
33     for(y=0;y<height;y+=2) {
34         for(x=0;x<width;x+=2) {
35             lum[0] = p[0];
36             cb[0] = p[1];
37             lum[1] = p[2];
38             cr[0] = p[3];
39             p += 4;
40             lum += 2;
41             cb++;
42             cr++;
43         }
44         for(x=0;x<width;x+=2) {
45             lum[0] = p[0];
46             lum[1] = p[2];
47             p += 4;
48             lum += 2;
49         }
50     }
51 }
52
53 #define SCALEBITS 8
54 #define ONE_HALF  (1 << (SCALEBITS - 1))
55 #define FIX(x)          ((int) ((x) * (1L<<SCALEBITS) + 0.5))
56
57 static void rgb24_to_yuv420p(UINT8 *lum, UINT8 *cb, UINT8 *cr,
58                               UINT8 *src, int width, int height)
59 {
60     int wrap, wrap3, x, y;
61     int r, g, b, r1, g1, b1;
62     UINT8 *p;
63
64     wrap = width;
65     wrap3 = width * 3;
66     p = src;
67     for(y=0;y<height;y+=2) {
68         for(x=0;x<width;x+=2) {
69             r = p[0];
70             g = p[1];
71             b = p[2];
72             r1 = r;
73             g1 = g;
74             b1 = b;
75             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 
76                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
77             r = p[3];
78             g = p[4];
79             b = p[5];
80             r1 += r;
81             g1 += g;
82             b1 += b;
83             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 
84                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
85             p += wrap3;
86             lum += wrap;
87
88             r = p[0];
89             g = p[1];
90             b = p[2];
91             r1 += r;
92             g1 += g;
93             b1 += b;
94             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 
95                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
96             r = p[3];
97             g = p[4];
98             b = p[5];
99             r1 += r;
100             g1 += g;
101             b1 += b;
102             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 
103                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
104             
105             cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + 
106                       FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
107             cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 - 
108                      FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
109
110             cb++;
111             cr++;
112             p += -wrap3 + 2 * 3;
113             lum += -wrap + 2;
114         }
115         p += wrap3;
116         lum += wrap;
117     }
118 }
119
120 static void bgr24_to_yuv420p(UINT8 *lum, UINT8 *cb, UINT8 *cr,
121                               UINT8 *src, int width, int height)
122 {
123     int wrap, wrap3, x, y;
124     int r, g, b, r1, g1, b1;
125     UINT8 *p;
126
127     wrap = width;
128     wrap3 = width * 3;
129     p = src;
130     for(y=0;y<height;y+=2) {
131         for(x=0;x<width;x+=2) {
132             b = p[0];
133             g = p[1];
134             r = p[2];
135             r1 = r;
136             g1 = g;
137             b1 = b;
138             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 
139                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
140             b = p[3];
141             g = p[4];
142             r = p[5];
143             r1 += r;
144             g1 += g;
145             b1 += b;
146             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 
147                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
148             p += wrap3;
149             lum += wrap;
150
151             b = p[0];
152             g = p[1];
153             r = p[2];
154             r1 += r;
155             g1 += g;
156             b1 += b;
157             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 
158                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
159             b = p[3];
160             g = p[4];
161             r = p[5];
162             r1 += r;
163             g1 += g;
164             b1 += b;
165             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 
166                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
167             
168             cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + 
169                       FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
170             cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 - 
171                      FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
172
173             cb++;
174             cr++;
175             p += -wrap3 + 2 * 3;
176             lum += -wrap + 2;
177         }
178         p += wrap3;
179         lum += wrap;
180     }
181 }
182
183 /* XXX: use generic filter ? */
184 /* 1x2 -> 1x1 */
185 static void shrink2(UINT8 *dst, int dst_wrap, 
186                     UINT8 *src, int src_wrap,
187                     int width, int height)
188 {
189     int w;
190     UINT8 *s1, *s2, *d;
191
192     for(;height > 0; height--) {
193         s1 = src;
194         s2 = s1 + src_wrap;
195         d = dst;
196         for(w = width;w >= 4; w-=4) {
197             d[0] = (s1[0] + s2[0]) >> 1;
198             d[1] = (s1[1] + s2[1]) >> 1;
199             d[2] = (s1[2] + s2[2]) >> 1;
200             d[3] = (s1[3] + s2[3]) >> 1;
201             s1 += 4;
202             s2 += 4;
203             d += 4;
204         }
205         for(;w > 0; w--) {
206             d[0] = (s1[0] + s2[0]) >> 1;
207             s1++;
208             s2++;
209             d++;
210         }
211         src += 2 * src_wrap;
212         dst += dst_wrap;
213     }
214 }
215
216 /* 2x2 -> 1x1 */
217 static void shrink22(UINT8 *dst, int dst_wrap, 
218                      UINT8 *src, int src_wrap,
219                      int width, int height)
220 {
221     int w;
222     UINT8 *s1, *s2, *d;
223
224     for(;height > 0; height--) {
225         s1 = src;
226         s2 = s1 + src_wrap;
227         d = dst;
228         for(w = width;w >= 4; w-=4) {
229             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 1;
230             d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 1;
231             d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 1;
232             d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 1;
233             s1 += 8;
234             s2 += 8;
235             d += 4;
236         }
237         for(;w > 0; w--) {
238             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 1;
239             s1 += 2;
240             s2 += 2;
241             d++;
242         }
243         src += 2 * src_wrap;
244         dst += dst_wrap;
245     }
246 }
247
248 static void img_copy(UINT8 *dst, int dst_wrap, 
249                      UINT8 *src, int src_wrap,
250                      int width, int height)
251 {
252     for(;height > 0; height--) {
253         memcpy(dst, src, width);
254         dst += dst_wrap;
255         src += src_wrap;
256     }
257 }
258
259 #define SCALE_BITS 10
260
261 #define C_Y  (76309 >> (16 - SCALE_BITS))
262 #define C_RV (117504 >> (16 - SCALE_BITS))
263 #define C_BU (138453 >> (16 - SCALE_BITS))
264 #define C_GU (13954 >> (16 - SCALE_BITS))
265 #define C_GV (34903 >> (16 - SCALE_BITS))
266
267 #define RGBOUT(r, g, b, y1)\
268 {\
269     y = (y1 - 16) * C_Y;\
270     r = cm[(y + r_add) >> SCALE_BITS];\
271     g = cm[(y + g_add) >> SCALE_BITS];\
272     b = cm[(y + b_add) >> SCALE_BITS];\
273 }
274
275 /* XXX: no chroma interpolating is done */
276 static void yuv420p_to_rgb24(AVPicture *dst, AVPicture *src, 
277                              int width, int height)
278 {
279     UINT8 *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr, *d, *d1, *d2;
280     int w, y, cb, cr, r_add, g_add, b_add, width2;
281     UINT8 *cm = cropTbl + MAX_NEG_CROP;
282
283     d = dst->data[0];
284     y1_ptr = src->data[0];
285     cb_ptr = src->data[1];
286     cr_ptr = src->data[2];
287     width2 = width >> 1;
288     for(;height > 0; height -= 2) {
289         d1 = d;
290         d2 = d + dst->linesize[0];
291         y2_ptr = y1_ptr + src->linesize[0];
292         for(w = width2; w > 0; w --) {
293             cb = cb_ptr[0] - 128;
294             cr = cr_ptr[0] - 128;
295             r_add = C_RV * cr + (1 << (SCALE_BITS - 1));
296             g_add = - C_GU * cb - C_GV * cr + (1 << (SCALE_BITS - 1));
297             b_add = C_BU * cb + (1 << (SCALE_BITS - 1));
298             
299             /* output 4 pixels */
300             RGBOUT(d1[0], d1[1], d1[2], y1_ptr[0]);
301             RGBOUT(d1[3], d1[4], d1[5], y1_ptr[1]);
302             RGBOUT(d2[0], d2[1], d2[2], y2_ptr[0]);
303             RGBOUT(d2[3], d2[4], d2[5], y2_ptr[1]);
304
305             d1 += 6;
306             d2 += 6;
307             y1_ptr += 2;
308             y2_ptr += 2;
309             cb_ptr++;
310             cr_ptr++;
311         }
312         d += 2 * dst->linesize[0];
313         y1_ptr += 2 * src->linesize[0] - width;
314         cb_ptr += src->linesize[1] - width2;
315         cr_ptr += src->linesize[2] - width2;
316     }
317 }
318
319 /* XXX: no chroma interpolating is done */
320 static void yuv422p_to_rgb24(AVPicture *dst, AVPicture *src, 
321                              int width, int height)
322 {
323     UINT8 *y1_ptr, *cb_ptr, *cr_ptr, *d, *d1;
324     int w, y, cb, cr, r_add, g_add, b_add, width2;
325     UINT8 *cm = cropTbl + MAX_NEG_CROP;
326
327     d = dst->data[0];
328     y1_ptr = src->data[0];
329     cb_ptr = src->data[1];
330     cr_ptr = src->data[2];
331     width2 = width >> 1;
332     for(;height > 0; height --) {
333         d1 = d;
334         for(w = width2; w > 0; w --) {
335             cb = cb_ptr[0] - 128;
336             cr = cr_ptr[0] - 128;
337             r_add = C_RV * cr + (1 << (SCALE_BITS - 1));
338             g_add = - C_GU * cb - C_GV * cr + (1 << (SCALE_BITS - 1));
339             b_add = C_BU * cb + (1 << (SCALE_BITS - 1));
340             
341             /* output 2 pixels */
342             RGBOUT(d1[0], d1[1], d1[2], y1_ptr[0]);
343             RGBOUT(d1[3], d1[4], d1[5], y1_ptr[1]);
344
345             d1 += 6;
346             y1_ptr += 2;
347             cb_ptr++;
348             cr_ptr++;
349         }
350         d += dst->linesize[0];
351         y1_ptr += src->linesize[0] - width;
352         cb_ptr += src->linesize[1] - width2;
353         cr_ptr += src->linesize[2] - width2;
354     }
355 }
356
357 /* XXX: always use linesize. Return -1 if not supported */
358 int img_convert(AVPicture *dst, int dst_pix_fmt,
359                 AVPicture *src, int pix_fmt, 
360                 int width, int height)
361 {
362     int i;
363
364     assert(pix_fmt != PIX_FMT_ANY && dst_pix_fmt != PIX_FMT_ANY);
365
366     if (dst_pix_fmt == pix_fmt) {
367         switch(pix_fmt) {
368         case PIX_FMT_YUV420P:
369             for(i=0;i<3;i++) {
370                 if (i == 1) {
371                     width >>= 1;
372                     height >>= 1;
373                 }
374                 img_copy(dst->data[i], dst->linesize[i],
375                          src->data[i], src->linesize[i],
376                          width, height);
377             }
378             break;
379         default:
380             return -1;
381         }
382     } else if (dst_pix_fmt == PIX_FMT_YUV420P) {
383         
384         switch(pix_fmt) {
385         case PIX_FMT_YUV420P:
386             for(i=0;i<3;i++) {
387                 img_copy(dst->data[i], dst->linesize[i],
388                          src->data[i], src->linesize[i],
389                          width, height);
390             }
391             break;
392         case PIX_FMT_YUV422P:
393             img_copy(dst->data[0], dst->linesize[0],
394                      src->data[0], src->linesize[0],
395                      width, height);
396             width >>= 1;
397             height >>= 1;
398             for(i=1;i<3;i++) {
399                 shrink2(dst->data[i], dst->linesize[i],
400                         src->data[i], src->linesize[i],
401                         width, height);
402             }
403             break;
404         case PIX_FMT_YUV444P:
405             img_copy(dst->data[0], dst->linesize[0],
406                      src->data[0], src->linesize[0],
407                      width, height);
408             width >>= 1;
409             height >>= 1;
410             for(i=1;i<3;i++) {
411                 shrink22(dst->data[i], dst->linesize[i],
412                          src->data[i], src->linesize[i],
413                          width, height);
414             }
415             break;
416         case PIX_FMT_YUV422:
417             yuv422_to_yuv420p(dst->data[0], dst->data[1], dst->data[2], 
418                               src->data[0], width, height);
419             break;
420         case PIX_FMT_RGB24:
421             rgb24_to_yuv420p(dst->data[0], dst->data[1], dst->data[2], 
422                              src->data[0], width, height);
423             break;
424         case PIX_FMT_BGR24:
425             bgr24_to_yuv420p(dst->data[0], dst->data[1], dst->data[2], 
426                              src->data[0], width, height);
427             break;
428         default:
429             return -1;
430         }
431     } else if (dst_pix_fmt == PIX_FMT_RGB24) {
432         switch(pix_fmt) {
433         case PIX_FMT_YUV420P:
434             yuv420p_to_rgb24(dst, src, width, height);
435             break;
436         case PIX_FMT_YUV422P:
437             yuv422p_to_rgb24(dst, src, width, height);
438             break;
439         default:
440             return -1;
441         }
442     } else {
443         return -1;
444     }
445     return 0;
446 }
447
448 /* filter parameters: [-1 4 2 4 -1] // 8 */
449 static void deinterlace_line(UINT8 *dst, UINT8 *src, int src_wrap,
450                              int size)
451 {
452     UINT8 *cm = cropTbl + MAX_NEG_CROP;
453     int sum;
454     UINT8 *s;
455
456     for(;size > 0;size--) {
457         s = src;
458         sum = -s[0];
459         s += src_wrap;
460         sum += s[0] << 2;
461         s += src_wrap;
462         sum += s[0] << 1;
463         s += src_wrap;
464         sum += s[0] << 2;
465         s += src_wrap;
466         sum += -s[0];
467         dst[0] = cm[(sum + 4) >> 3];
468         dst++;
469         src++;
470     }
471 }
472
473 /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
474    top field is copied as is, but the bottom field is deinterlaced
475    against the top field. */
476 static void deinterlace_bottom_field(UINT8 *dst, int dst_wrap,
477                                      UINT8 *src1, int src_wrap,
478                                      int width, int height)
479 {
480     UINT8 *src, *ptr;
481     int y, y1, i;
482     UINT8 *buf;
483
484     buf = (UINT8*)av_malloc(5 * width);
485
486     src = src1;
487     for(y=0;y<height;y+=2) {
488         /* copy top field line */
489         memcpy(dst, src, width);
490         dst += dst_wrap;
491         src += (1 - 2) * src_wrap;
492         y1 = y - 2;
493         if (y1 >= 0 && (y1 + 4) < height) {
494             /* fast case : no edges */
495             deinterlace_line(dst, src, src_wrap, width);
496         } else {
497             /* in order to use the same function, we use an intermediate buffer */
498             ptr = buf;
499             for(i=0;i<5;i++) {
500                 if (y1 < 0)
501                     memcpy(ptr, src1, width);
502                 else if (y1 >= height) 
503                     memcpy(ptr, src1 + (height - 1) * src_wrap, width);
504                 else
505                     memcpy(ptr, src1 + y1 * src_wrap, width);
506                 y1++;
507                 ptr += width;
508             }
509             deinterlace_line(dst, buf, width, width);
510         }
511         dst += dst_wrap;
512         src += (2 + 1) * src_wrap;
513     }
514     av_free(buf);
515 }
516
517
518 /* deinterlace, return -1 if format not handled */
519 int avpicture_deinterlace(AVPicture *dst, AVPicture *src,
520                           int pix_fmt, int width, int height)
521 {
522     int i;
523
524     if (pix_fmt != PIX_FMT_YUV420P &&
525         pix_fmt != PIX_FMT_YUV422P &&
526         pix_fmt != PIX_FMT_YUV444P)
527         return -1;
528     if ((width & 1) != 0 || (height & 3) != 0)
529         return -1;
530     
531     for(i=0;i<3;i++) {
532         if (i == 1) {
533             switch(pix_fmt) {
534             case PIX_FMT_YUV420P:
535                 width >>= 1;
536                 height >>= 1;
537                 break;
538             case PIX_FMT_YUV422P:
539                 width >>= 1;
540                 break;
541             default:
542                 break;
543             }
544         }
545         deinterlace_bottom_field(dst->data[i], dst->linesize[i],
546                                  src->data[i], src->linesize[i],
547                                  width, height);
548     }
549     return 0;
550 }
551
552 #undef FIX