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