git.sesse.net Git - ffmpeg/blob - 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