libavcodec/huffyuvdec.c

   1 /*
   2  * huffyuv decoder
   3  *
   4  * Copyright (c) 2002-2014 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * see https://multimedia.cx/huffyuv.txt for a description of
   7  * the algorithm used
   8  *
   9  * This file is part of FFmpeg.
  10  *
  11  * FFmpeg is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * FFmpeg is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with FFmpeg; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24  *
  25  * yuva, gray, 4:4:4, 4:1:1, 4:1:0 and >8 bit per sample support sponsored by NOA
  26  */
  27
  28 /**
  29  * @file
  30  * huffyuv decoder
  31  */
  32
  33 #define UNCHECKED_BITSTREAM_READER 1
  34
  35 #include "config_components.h"
  36
  37 #include "avcodec.h"
  38 #include "bswapdsp.h"
  39 #include "codec_internal.h"
  40 #include "get_bits.h"
  41 #include "huffyuv.h"
  42 #include "huffyuvdsp.h"
  43 #include "lossless_videodsp.h"
  44 #include "thread.h"
  45 #include "libavutil/emms.h"
  46 #include "libavutil/imgutils.h"
  47 #include "libavutil/pixdesc.h"
  48
  49 #define VLC_BITS 12
  50
  51 typedef struct HYuvDecContext {
  52     GetBitContext gb;
  53     Predictor predictor;
  54     int interlaced;
  55     int decorrelate;
  56     int bitstream_bpp;
  57     int version;
  58     int yuy2;                               //use yuy2 instead of 422P
  59     int bgr32;                              //use bgr32 instead of bgr24
  60     int bps;
  61     int n;                                  // 1<<bps
  62     int vlc_n;                              // number of vlc codes (FFMIN(1<<bps, MAX_VLC_N))
  63     int alpha;
  64     int chroma;
  65     int yuv;
  66     int chroma_h_shift;
  67     int chroma_v_shift;
  68     int flags;
  69     int context;
  70     int last_slice_end;
  71
  72     uint8_t *temp[3];
  73     uint16_t *temp16[3];                    ///< identical to temp but 16bit type
  74     uint8_t len[4][MAX_VLC_N];
  75     uint32_t bits[4][MAX_VLC_N];
  76     uint32_t pix_bgr_map[1<<VLC_BITS];
  77     VLC vlc[8];                             //Y,U,V,A,YY,YU,YV,AA
  78     uint8_t *bitstream_buffer;
  79     unsigned int bitstream_buffer_size;
  80     BswapDSPContext bdsp;
  81     HuffYUVDSPContext hdsp;
  82     LLVidDSPContext llviddsp;
  83 } HYuvDecContext;
  84
  85
  86 #define classic_shift_luma_table_size 42
  87 static const unsigned char classic_shift_luma[classic_shift_luma_table_size + AV_INPUT_BUFFER_PADDING_SIZE] = {
  88     34, 36, 35, 69, 135, 232,   9, 16, 10, 24,  11,  23,  12,  16, 13, 10,
  89     14,  8, 15,  8,  16,   8,  17, 20, 16, 10, 207, 206, 205, 236, 11,  8,
  90     10, 21,  9, 23,   8,   8, 199, 70, 69, 68,   0,
  91   0,0,0,0,0,0,0,0,
  92 };
  93
  94 #define classic_shift_chroma_table_size 59
  95 static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + AV_INPUT_BUFFER_PADDING_SIZE] = {
  96     66, 36,  37,  38, 39, 40,  41,  75,  76,  77, 110, 239, 144, 81, 82,  83,
  97     84, 85, 118, 183, 56, 57,  88,  89,  56,  89, 154,  57,  58, 57, 26, 141,
  98     57, 56,  58,  57, 58, 57, 184, 119, 214, 245, 116,  83,  82, 49, 80,  79,
  99     78, 77,  44,  75, 41, 40,  39,  38,  37,  36,  34,  0,
 100   0,0,0,0,0,0,0,0,
 101 };
 102
 103 static const unsigned char classic_add_luma[256] = {
 104      3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
 105     73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
 106     68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
 107     35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
 108     37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
 109     35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
 110     27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
 111     15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
 112     12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
 113     12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
 114     18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
 115     28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
 116     28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
 117     62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
 118     54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
 119     46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
 120 };
 121
 122 static const unsigned char classic_add_chroma[256] = {
 123      3,    1,   2,   2,   2,   2,   3,   3,   7,   5,   7,   5,   8,   6,  11,   9,
 124      7,   13,  11,  10,   9,   8,   7,   5,   9,   7,   6,   4,   7,   5,   8,   7,
 125      11,   8,  13,  11,  19,  15,  22,  23,  20,  33,  32,  28,  27,  29,  51,  77,
 126      43,  45,  76,  81,  46,  82,  75,  55,  56, 144,  58,  80,  60,  74, 147,  63,
 127     143,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
 128      80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  27,  30,  21,  22,
 129      17,  14,   5,   6, 100,  54,  47,  50,  51,  53, 106, 107, 108, 109, 110, 111,
 130     112, 113, 114, 115,   4, 117, 118,  92,  94, 121, 122,   3, 124, 103,   2,   1,
 131       0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134,
 132     135, 132, 133, 104,  64, 101,  62,  57, 102,  95,  93,  59,  61,  28,  97,  96,
 133      52,  49,  48,  29,  32,  25,  24,  46,  23,  98,  45,  44,  43,  20,  42,  41,
 134      19,  18,  99,  40,  15,  39,  38,  16,  13,  12,  11,  37,  10,   9,   8,  36,
 135       7, 128, 127, 105, 123, 116,  35,  34,  33, 145,  31,  79,  42, 146,  78,  26,
 136      83,  48,  49,  50,  44,  47,  26,  31,  30,  18,  17,  19,  21,  24,  25,  13,
 137      14,  16,  17,  18,  20,  21,  12,  14,  15,   9,  10,   6,   9,   6,   5,   8,
 138       6,  12,   8,  10,   7,   9,   6,   4,   6,   2,   2,   3,   3,   3,   3,   2,
 139 };
 140
 141 static int read_len_table(uint8_t *dst, GetBitContext *gb, int n)
 142 {
 143     int i, val, repeat;
 144
 145     for (i = 0; i < n;) {
 146         repeat = get_bits(gb, 3);
 147         val    = get_bits(gb, 5);
 148         if (repeat == 0)
 149             repeat = get_bits(gb, 8);
 150         if (i + repeat > n || get_bits_left(gb) < 0) {
 151             av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
 152             return AVERROR_INVALIDDATA;
 153         }
 154         while (repeat--)
 155             dst[i++] = val;
 156     }
 157     return 0;
 158 }
 159
 160 static int generate_joint_tables(HYuvDecContext *s)
 161 {
 162     int ret;
 163     uint16_t *symbols = av_mallocz(5 << VLC_BITS);
 164     uint16_t *bits;
 165     uint8_t *len;
 166     if (!symbols)
 167         return AVERROR(ENOMEM);
 168     bits = symbols + (1 << VLC_BITS);
 169     len = (uint8_t *)(bits + (1 << VLC_BITS));
 170
 171     if (s->bitstream_bpp < 24 || s->version > 2) {
 172         int count = 1 + s->alpha + 2 * s->chroma;
 173         int p, i, y, u;
 174         for (p = 0; p < count; p++) {
 175             int p0 = s->version > 2 ? p : 0;
 176             for (i = y = 0; y < s->vlc_n; y++) {
 177                 int len0  = s->len[p0][y];
 178                 int limit = VLC_BITS - len0;
 179                 if (limit <= 0 || !len0)
 180                     continue;
 181                 if ((sign_extend(y, 8) & (s->vlc_n-1)) != y)
 182                     continue;
 183                 for (u = 0; u < s->vlc_n; u++) {
 184                     int len1 = s->len[p][u];
 185                     if (len1 > limit || !len1)
 186                         continue;
 187                     if ((sign_extend(u, 8) & (s->vlc_n-1)) != u)
 188                         continue;
 189                     av_assert0(i < (1 << VLC_BITS));
 190                     len[i]     = len0 + len1;
 191                     bits[i]    = (s->bits[p0][y] << len1) + s->bits[p][u];
 192                     symbols[i] = (y << 8) + (u & 0xFF);
 193                         i++;
 194                 }
 195             }
 196             ff_vlc_free(&s->vlc[4 + p]);
 197             if ((ret = ff_vlc_init_sparse(&s->vlc[4 + p], VLC_BITS, i, len, 1, 1,
 198                                           bits, 2, 2, symbols, 2, 2, 0)) < 0)
 199                 goto out;
 200         }
 201     } else {
 202         uint8_t (*map)[4] = (uint8_t(*)[4]) s->pix_bgr_map;
 203         int i, b, g, r, code;
 204         int p0 = s->decorrelate;
 205         int p1 = !s->decorrelate;
 206         /* Restrict the range to +/-16 because that's pretty much guaranteed
 207          * to cover all the combinations that fit in 11 bits total, and it
 208          *  does not matter if we miss a few rare codes. */
 209         for (i = 0, g = -16; g < 16; g++) {
 210             int len0   = s->len[p0][g & 255];
 211             int limit0 = VLC_BITS - len0;
 212             if (limit0 < 2 || !len0)
 213                 continue;
 214             for (b = -16; b < 16; b++) {
 215                 int len1   = s->len[p1][b & 255];
 216                 int limit1 = limit0 - len1;
 217                 if (limit1 < 1 || !len1)
 218                     continue;
 219                 code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];
 220                 for (r = -16; r < 16; r++) {
 221                     int len2 = s->len[2][r & 255];
 222                     if (len2 > limit1 || !len2)
 223                         continue;
 224                     av_assert0(i < (1 << VLC_BITS));
 225                     len[i]  = len0 + len1 + len2;
 226                     bits[i] = (code << len2) + s->bits[2][r & 255];
 227                     if (s->decorrelate) {
 228                         map[i][G] = g;
 229                         map[i][B] = g + b;
 230                         map[i][R] = g + r;
 231                     } else {
 232                         map[i][B] = g;
 233                         map[i][G] = b;
 234                         map[i][R] = r;
 235                     }
 236                     i++;
 237                 }
 238             }
 239         }
 240         ff_vlc_free(&s->vlc[4]);
 241         if ((ret = vlc_init(&s->vlc[4], VLC_BITS, i, len, 1, 1,
 242                             bits, 2, 2, 0)) < 0)
 243             goto out;
 244     }
 245     ret = 0;
 246 out:
 247     av_freep(&symbols);
 248     return ret;
 249 }
 250
 251 static int read_huffman_tables(HYuvDecContext *s, const uint8_t *src, int length)
 252 {
 253     GetBitContext gb;
 254     int i, ret;
 255     int count = 3;
 256
 257     if ((ret = init_get_bits(&gb, src, length * 8)) < 0)
 258         return ret;
 259
 260     if (s->version > 2)
 261         count = 1 + s->alpha + 2*s->chroma;
 262
 263     for (i = 0; i < count; i++) {
 264         if ((ret = read_len_table(s->len[i], &gb, s->vlc_n)) < 0)
 265             return ret;
 266         if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n)) < 0)
 267             return ret;
 268         ff_vlc_free(&s->vlc[i]);
 269         if ((ret = vlc_init(&s->vlc[i], VLC_BITS, s->vlc_n, s->len[i], 1, 1,
 270                            s->bits[i], 4, 4, 0)) < 0)
 271             return ret;
 272     }
 273
 274     if ((ret = generate_joint_tables(s)) < 0)
 275         return ret;
 276
 277     return (get_bits_count(&gb) + 7) / 8;
 278 }
 279
 280 static int read_old_huffman_tables(HYuvDecContext *s)
 281 {
 282     GetBitContext gb;
 283     int i, ret;
 284
 285     init_get_bits(&gb, classic_shift_luma,
 286                   classic_shift_luma_table_size * 8);
 287     if ((ret = read_len_table(s->len[0], &gb, 256)) < 0)
 288         return ret;
 289
 290     init_get_bits(&gb, classic_shift_chroma,
 291                   classic_shift_chroma_table_size * 8);
 292     if ((ret = read_len_table(s->len[1], &gb, 256)) < 0)
 293         return ret;
 294
 295     for (i = 0; i < 256; i++)
 296         s->bits[0][i] = classic_add_luma[i];
 297     for (i = 0; i < 256; i++)
 298         s->bits[1][i] = classic_add_chroma[i];
 299
 300     if (s->bitstream_bpp >= 24) {
 301         memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));
 302         memcpy(s->len[1], s->len[0], 256 * sizeof(uint8_t));
 303     }
 304     memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));
 305     memcpy(s->len[2], s->len[1], 256 * sizeof(uint8_t));
 306
 307     for (i = 0; i < 4; i++) {
 308         ff_vlc_free(&s->vlc[i]);
 309         if ((ret = vlc_init(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
 310                             s->bits[i], 4, 4, 0)) < 0)
 311             return ret;
 312     }
 313
 314     if ((ret = generate_joint_tables(s)) < 0)
 315         return ret;
 316
 317     return 0;
 318 }
 319
 320 static av_cold int decode_end(AVCodecContext *avctx)
 321 {
 322     HYuvDecContext *s = avctx->priv_data;
 323     int i;
 324
 325     ff_huffyuv_common_end(s->temp, s->temp16);
 326     av_freep(&s->bitstream_buffer);
 327
 328     for (i = 0; i < 8; i++)
 329         ff_vlc_free(&s->vlc[i]);
 330
 331     return 0;
 332 }
 333
 334 static av_cold int decode_init(AVCodecContext *avctx)
 335 {
 336     HYuvDecContext *s = avctx->priv_data;
 337     int ret;
 338
 339     ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
 340     if (ret < 0)
 341         return ret;
 342
 343     s->flags = avctx->flags;
 344
 345     ff_bswapdsp_init(&s->bdsp);
 346     ff_huffyuvdsp_init(&s->hdsp, avctx->pix_fmt);
 347     ff_llviddsp_init(&s->llviddsp);
 348     memset(s->vlc, 0, 4 * sizeof(VLC));
 349
 350     s->interlaced = avctx->height > 288;
 351     s->bgr32      = 1;
 352
 353     if (avctx->extradata_size) {
 354         if ((avctx->bits_per_coded_sample & 7) &&
 355             avctx->bits_per_coded_sample != 12)
 356             s->version = 1; // do such files exist at all?
 357         else if (avctx->extradata_size > 3 && avctx->extradata[3] == 0)
 358             s->version = 2;
 359         else
 360             s->version = 3;
 361     } else
 362         s->version = 0;
 363
 364     s->bps = 8;
 365     s->n = 1<<s->bps;
 366     s->vlc_n = FFMIN(s->n, MAX_VLC_N);
 367     s->chroma = 1;
 368     if (s->version >= 2) {
 369         int method, interlace;
 370
 371         if (avctx->extradata_size < 4)
 372             return AVERROR_INVALIDDATA;
 373
 374         method           = avctx->extradata[0];
 375         s->decorrelate   = method & 64 ? 1 : 0;
 376         s->predictor     = method & 63;
 377         if (s->version == 2) {
 378             s->bitstream_bpp = avctx->extradata[1];
 379             if (s->bitstream_bpp == 0)
 380                 s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
 381         } else {
 382             s->bps = (avctx->extradata[1] >> 4) + 1;
 383             s->n = 1<<s->bps;
 384             s->vlc_n = FFMIN(s->n, MAX_VLC_N);
 385             s->chroma_h_shift = avctx->extradata[1] & 3;
 386             s->chroma_v_shift = (avctx->extradata[1] >> 2) & 3;
 387             s->yuv   = !!(avctx->extradata[2] & 1);
 388             s->chroma= !!(avctx->extradata[2] & 3);
 389             s->alpha = !!(avctx->extradata[2] & 4);
 390         }
 391         interlace     = (avctx->extradata[2] & 0x30) >> 4;
 392         s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
 393         s->context    = avctx->extradata[2] & 0x40 ? 1 : 0;
 394
 395         if ((ret = read_huffman_tables(s, avctx->extradata + 4,
 396                                        avctx->extradata_size - 4)) < 0)
 397             return ret;
 398     } else {
 399         switch (avctx->bits_per_coded_sample & 7) {
 400         case 1:
 401             s->predictor   = LEFT;
 402             s->decorrelate = 0;
 403             break;
 404         case 2:
 405             s->predictor   = LEFT;
 406             s->decorrelate = 1;
 407             break;
 408         case 3:
 409             s->predictor   = PLANE;
 410             s->decorrelate = avctx->bits_per_coded_sample >= 24;
 411             break;
 412         case 4:
 413             s->predictor   = MEDIAN;
 414             s->decorrelate = 0;
 415             break;
 416         default:
 417             s->predictor   = LEFT; // OLD
 418             s->decorrelate = 0;
 419             break;
 420         }
 421         s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
 422         s->context       = 0;
 423
 424         if ((ret = read_old_huffman_tables(s)) < 0)
 425             return ret;
 426     }
 427
 428     if (s->version <= 2) {
 429         switch (s->bitstream_bpp) {
 430         case 12:
 431             avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 432             s->yuv = 1;
 433             break;
 434         case 16:
 435             if (s->yuy2)
 436                 avctx->pix_fmt = AV_PIX_FMT_YUYV422;
 437             else
 438                 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 439             s->yuv = 1;
 440             break;
 441         case 24:
 442             if (s->bgr32)
 443                 avctx->pix_fmt = AV_PIX_FMT_0RGB32;
 444             else
 445                 avctx->pix_fmt = AV_PIX_FMT_BGR24;
 446             break;
 447         case 32:
 448             av_assert0(s->bgr32);
 449             avctx->pix_fmt = AV_PIX_FMT_RGB32;
 450             s->alpha = 1;
 451             break;
 452         default:
 453             return AVERROR_INVALIDDATA;
 454         }
 455         av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
 456                                          &s->chroma_h_shift,
 457                                          &s->chroma_v_shift);
 458     } else {
 459         switch ( (s->chroma<<10) | (s->yuv<<9) | (s->alpha<<8) | ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2)) {
 460         case 0x070:
 461             avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 462             break;
 463         case 0x0F0:
 464             avctx->pix_fmt = AV_PIX_FMT_GRAY16;
 465             break;
 466         case 0x470:
 467             avctx->pix_fmt = AV_PIX_FMT_GBRP;
 468             break;
 469         case 0x480:
 470             avctx->pix_fmt = AV_PIX_FMT_GBRP9;
 471             break;
 472         case 0x490:
 473             avctx->pix_fmt = AV_PIX_FMT_GBRP10;
 474             break;
 475         case 0x4B0:
 476             avctx->pix_fmt = AV_PIX_FMT_GBRP12;
 477             break;
 478         case 0x4D0:
 479             avctx->pix_fmt = AV_PIX_FMT_GBRP14;
 480             break;
 481         case 0x4F0:
 482             avctx->pix_fmt = AV_PIX_FMT_GBRP16;
 483             break;
 484         case 0x570:
 485             avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 486             break;
 487         case 0x670:
 488             avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 489             break;
 490         case 0x680:
 491             avctx->pix_fmt = AV_PIX_FMT_YUV444P9;
 492             break;
 493         case 0x690:
 494             avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
 495             break;
 496         case 0x6B0:
 497             avctx->pix_fmt = AV_PIX_FMT_YUV444P12;
 498             break;
 499         case 0x6D0:
 500             avctx->pix_fmt = AV_PIX_FMT_YUV444P14;
 501             break;
 502         case 0x6F0:
 503             avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
 504             break;
 505         case 0x671:
 506             avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 507             break;
 508         case 0x681:
 509             avctx->pix_fmt = AV_PIX_FMT_YUV422P9;
 510             break;
 511         case 0x691:
 512             avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
 513             break;
 514         case 0x6B1:
 515             avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
 516             break;
 517         case 0x6D1:
 518             avctx->pix_fmt = AV_PIX_FMT_YUV422P14;
 519             break;
 520         case 0x6F1:
 521             avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
 522             break;
 523         case 0x672:
 524             avctx->pix_fmt = AV_PIX_FMT_YUV411P;
 525             break;
 526         case 0x674:
 527             avctx->pix_fmt = AV_PIX_FMT_YUV440P;
 528             break;
 529         case 0x675:
 530             avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 531             break;
 532         case 0x685:
 533             avctx->pix_fmt = AV_PIX_FMT_YUV420P9;
 534             break;
 535         case 0x695:
 536             avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
 537             break;
 538         case 0x6B5:
 539             avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
 540             break;
 541         case 0x6D5:
 542             avctx->pix_fmt = AV_PIX_FMT_YUV420P14;
 543             break;
 544         case 0x6F5:
 545             avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
 546             break;
 547         case 0x67A:
 548             avctx->pix_fmt = AV_PIX_FMT_YUV410P;
 549             break;
 550         case 0x770:
 551             avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 552             break;
 553         case 0x780:
 554             avctx->pix_fmt = AV_PIX_FMT_YUVA444P9;
 555             break;
 556         case 0x790:
 557             avctx->pix_fmt = AV_PIX_FMT_YUVA444P10;
 558             break;
 559         case 0x7F0:
 560             avctx->pix_fmt = AV_PIX_FMT_YUVA444P16;
 561             break;
 562         case 0x771:
 563             avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
 564             break;
 565         case 0x781:
 566             avctx->pix_fmt = AV_PIX_FMT_YUVA422P9;
 567             break;
 568         case 0x791:
 569             avctx->pix_fmt = AV_PIX_FMT_YUVA422P10;
 570             break;
 571         case 0x7F1:
 572             avctx->pix_fmt = AV_PIX_FMT_YUVA422P16;
 573             break;
 574         case 0x775:
 575             avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
 576             break;
 577         case 0x785:
 578             avctx->pix_fmt = AV_PIX_FMT_YUVA420P9;
 579             break;
 580         case 0x795:
 581             avctx->pix_fmt = AV_PIX_FMT_YUVA420P10;
 582             break;
 583         case 0x7F5:
 584             avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
 585             break;
 586         default:
 587             return AVERROR_INVALIDDATA;
 588         }
 589     }
 590
 591     if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) {
 592         av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
 593         return AVERROR_INVALIDDATA;
 594     }
 595     if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P &&
 596         avctx->width % 4) {
 597         av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 "
 598                "for this combination of colorspace and predictor type.\n");
 599         return AVERROR_INVALIDDATA;
 600     }
 601
 602     if ((ret = ff_huffyuv_alloc_temp(s->temp, s->temp16, avctx->width)) < 0)
 603         return ret;
 604
 605     return 0;
 606 }
 607
 608 /** Subset of GET_VLC for use in hand-roller VLC code */
 609 #define VLC_INTERN(dst, table, gb, name, bits, max_depth)   \
 610     code = table[index].sym;                                \
 611     n    = table[index].len;                                \
 612     if (max_depth > 1 && n < 0) {                           \
 613         LAST_SKIP_BITS(name, gb, bits);                     \
 614         UPDATE_CACHE(name, gb);                             \
 615                                                             \
 616         nb_bits = -n;                                       \
 617         index   = SHOW_UBITS(name, gb, nb_bits) + code;     \
 618         code    = table[index].sym;                         \
 619         n       = table[index].len;                         \
 620         if (max_depth > 2 && n < 0) {                       \
 621             LAST_SKIP_BITS(name, gb, nb_bits);              \
 622             UPDATE_CACHE(name, gb);                         \
 623                                                             \
 624             nb_bits = -n;                                   \
 625             index   = SHOW_UBITS(name, gb, nb_bits) + code; \
 626             code    = table[index].sym;                     \
 627             n       = table[index].len;                     \
 628         }                                                   \
 629     }                                                       \
 630     dst = code;                                             \
 631     LAST_SKIP_BITS(name, gb, n)
 632
 633
 634 #define GET_VLC_DUAL(dst0, dst1, name, gb, dtable, table1, table2,  \
 635                      bits, max_depth, OP)                           \
 636     do {                                                            \
 637         unsigned int index = SHOW_UBITS(name, gb, bits);            \
 638         int          code, n = dtable[index].len;                   \
 639                                                                     \
 640         if (n<=0) {                                                 \
 641             int nb_bits;                                            \
 642             VLC_INTERN(dst0, table1, gb, name, bits, max_depth);    \
 643                                                                     \
 644             UPDATE_CACHE(re, gb);                                   \
 645             index = SHOW_UBITS(name, gb, bits);                     \
 646             VLC_INTERN(dst1, table2, gb, name, bits, max_depth);    \
 647         } else {                                                    \
 648             code = dtable[index].sym;                               \
 649             OP(dst0, dst1, code);                                   \
 650             LAST_SKIP_BITS(name, gb, n);                            \
 651         }                                                           \
 652     } while (0)
 653
 654 #define OP8bits(dst0, dst1, code) dst0 = code>>8; dst1 = code
 655
 656 #define READ_2PIX(dst0, dst1, plane1)                                   \
 657     UPDATE_CACHE(re, &s->gb);                                           \
 658     GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane1].table,        \
 659                  s->vlc[0].table, s->vlc[plane1].table, VLC_BITS, 3, OP8bits)
 660
 661 static void decode_422_bitstream(HYuvDecContext *s, int count)
 662 {
 663     int i, icount;
 664     OPEN_READER(re, &s->gb);
 665     count /= 2;
 666
 667     icount = get_bits_left(&s->gb) / (32 * 4);
 668     if (count >= icount) {
 669         for (i = 0; i < icount; i++) {
 670             READ_2PIX(s->temp[0][2 * i],     s->temp[1][i], 1);
 671             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
 672         }
 673         for (; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
 674             READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);
 675             if (BITS_LEFT(re, &s->gb) <= 0) break;
 676             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
 677         }
 678         for (; i < count; i++)
 679             s->temp[0][2 * i    ] = s->temp[1][i] =
 680             s->temp[0][2 * i + 1] = s->temp[2][i] = 0;
 681     } else {
 682         for (i = 0; i < count; i++) {
 683             READ_2PIX(s->temp[0][2 * i],     s->temp[1][i], 1);
 684             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
 685         }
 686     }
 687     CLOSE_READER(re, &s->gb);
 688 }
 689
 690 #define READ_2PIX_PLANE(dst0, dst1, plane, OP) \
 691     UPDATE_CACHE(re, &s->gb); \
 692     GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane].table, \
 693                  s->vlc[plane].table, s->vlc[plane].table, VLC_BITS, 3, OP)
 694
 695 #define OP14bits(dst0, dst1, code) dst0 = code>>8; dst1 = sign_extend(code, 8)
 696
 697 /* TODO instead of restarting the read when the code isn't in the first level
 698  * of the joint table, jump into the 2nd level of the individual table. */
 699 #define READ_2PIX_PLANE16(dst0, dst1, plane){\
 700     dst0 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
 701     dst0 += get_bits(&s->gb, 2);\
 702     dst1 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
 703     dst1 += get_bits(&s->gb, 2);\
 704 }
 705 static void decode_plane_bitstream(HYuvDecContext *s, int width, int plane)
 706 {
 707     int i, count = width/2;
 708
 709     if (s->bps <= 8) {
 710         OPEN_READER(re, &s->gb);
 711         if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
 712             for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
 713                 READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
 714             }
 715         } else {
 716             for(i=0; i<count; i++){
 717                 READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
 718             }
 719         }
 720         if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
 721             unsigned int index;
 722             int nb_bits, code, n;
 723             UPDATE_CACHE(re, &s->gb);
 724             index = SHOW_UBITS(re, &s->gb, VLC_BITS);
 725             VLC_INTERN(s->temp[0][width-1], s->vlc[plane].table,
 726                        &s->gb, re, VLC_BITS, 3);
 727         }
 728         CLOSE_READER(re, &s->gb);
 729     } else if (s->bps <= 14) {
 730         OPEN_READER(re, &s->gb);
 731         if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
 732             for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
 733                 READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
 734             }
 735         } else {
 736             for(i=0; i<count; i++){
 737                 READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
 738             }
 739         }
 740         if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
 741             unsigned int index;
 742             int nb_bits, code, n;
 743             UPDATE_CACHE(re, &s->gb);
 744             index = SHOW_UBITS(re, &s->gb, VLC_BITS);
 745             VLC_INTERN(s->temp16[0][width-1], s->vlc[plane].table,
 746                        &s->gb, re, VLC_BITS, 3);
 747         }
 748         CLOSE_READER(re, &s->gb);
 749     } else {
 750         if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
 751             for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
 752                 READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
 753             }
 754         } else {
 755             for(i=0; i<count; i++){
 756                 READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
 757             }
 758         }
 759         if( width&1 && get_bits_left(&s->gb)>0 ) {
 760             int dst = (unsigned)get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)<<2;
 761             s->temp16[0][width-1] = dst + get_bits(&s->gb, 2);
 762         }
 763     }
 764 }
 765
 766 static void decode_gray_bitstream(HYuvDecContext *s, int count)
 767 {
 768     int i;
 769     OPEN_READER(re, &s->gb);
 770     count /= 2;
 771
 772     if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
 773         for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
 774             READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
 775         }
 776     } else {
 777         for (i = 0; i < count; i++) {
 778             READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
 779         }
 780     }
 781     CLOSE_READER(re, &s->gb);
 782 }
 783
 784 static av_always_inline void decode_bgr_1(HYuvDecContext *s, int count,
 785                                           int decorrelate, int alpha)
 786 {
 787     int i;
 788     OPEN_READER(re, &s->gb);
 789
 790     for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
 791         unsigned int index;
 792         int code, n, nb_bits;
 793
 794         UPDATE_CACHE(re, &s->gb);
 795         index = SHOW_UBITS(re, &s->gb, VLC_BITS);
 796         n     = s->vlc[4].table[index].len;
 797
 798         if (n>0) {
 799             code  = s->vlc[4].table[index].sym;
 800             *(uint32_t *) &s->temp[0][4 * i] = s->pix_bgr_map[code];
 801             LAST_SKIP_BITS(re, &s->gb, n);
 802         } else {
 803             if (decorrelate) {
 804                 VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
 805                            &s->gb, re, VLC_BITS, 3);
 806
 807                 UPDATE_CACHE(re, &s->gb);
 808                 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
 809                 VLC_INTERN(code, s->vlc[0].table, &s->gb, re, VLC_BITS, 3);
 810                 s->temp[0][4 * i + B] = code + s->temp[0][4 * i + G];
 811
 812                 UPDATE_CACHE(re, &s->gb);
 813                 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
 814                 VLC_INTERN(code, s->vlc[2].table, &s->gb, re, VLC_BITS, 3);
 815                 s->temp[0][4 * i + R] = code + s->temp[0][4 * i + G];
 816             } else {
 817                 VLC_INTERN(s->temp[0][4 * i + B], s->vlc[0].table,
 818                            &s->gb, re, VLC_BITS, 3);
 819
 820                 UPDATE_CACHE(re, &s->gb);
 821                 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
 822                 VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
 823                            &s->gb, re, VLC_BITS, 3);
 824
 825                 UPDATE_CACHE(re, &s->gb);
 826                 index = SHOW_UBITS(re, &s->gb, VLC_BITS);
 827                 VLC_INTERN(s->temp[0][4 * i + R], s->vlc[2].table,
 828                            &s->gb, re, VLC_BITS, 3);
 829             }
 830         }
 831         if (alpha) {
 832             UPDATE_CACHE(re, &s->gb);
 833             index = SHOW_UBITS(re, &s->gb, VLC_BITS);
 834             VLC_INTERN(s->temp[0][4 * i + A], s->vlc[2].table,
 835                        &s->gb, re, VLC_BITS, 3);
 836         } else
 837             s->temp[0][4 * i + A] = 0;
 838     }
 839     CLOSE_READER(re, &s->gb);
 840 }
 841
 842 static void decode_bgr_bitstream(HYuvDecContext *s, int count)
 843 {
 844     if (s->decorrelate) {
 845         if (s->bitstream_bpp == 24)
 846             decode_bgr_1(s, count, 1, 0);
 847         else
 848             decode_bgr_1(s, count, 1, 1);
 849     } else {
 850         if (s->bitstream_bpp == 24)
 851             decode_bgr_1(s, count, 0, 0);
 852         else
 853             decode_bgr_1(s, count, 0, 1);
 854     }
 855 }
 856
 857 static void draw_slice(HYuvDecContext *s, AVCodecContext *avctx, AVFrame *frame, int y)
 858 {
 859     int h, cy, i;
 860     int offset[AV_NUM_DATA_POINTERS];
 861
 862     if (!avctx->draw_horiz_band)
 863         return;
 864
 865     h  = y - s->last_slice_end;
 866     y -= h;
 867
 868     if (s->bitstream_bpp == 12)
 869         cy = y >> 1;
 870     else
 871         cy = y;
 872
 873     offset[0] = frame->linesize[0] * y;
 874     offset[1] = frame->linesize[1] * cy;
 875     offset[2] = frame->linesize[2] * cy;
 876     for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
 877         offset[i] = 0;
 878     emms_c();
 879
 880     avctx->draw_horiz_band(avctx, frame, offset, y, 3, h);
 881
 882     s->last_slice_end = y + h;
 883 }
 884
 885 static int left_prediction(HYuvDecContext *s, uint8_t *dst, const uint8_t *src, int w, int acc)
 886 {
 887     if (s->bps <= 8) {
 888         return s->llviddsp.add_left_pred(dst, src, w, acc);
 889     } else {
 890         return s->llviddsp.add_left_pred_int16((      uint16_t *)dst, (const uint16_t *)src, s->n-1, w, acc);
 891     }
 892 }
 893
 894 static void add_bytes(HYuvDecContext *s, uint8_t *dst, uint8_t *src, int w)
 895 {
 896     if (s->bps <= 8) {
 897         s->llviddsp.add_bytes(dst, src, w);
 898     } else {
 899         s->hdsp.add_int16((uint16_t*)dst, (const uint16_t*)src, s->n - 1, w);
 900     }
 901 }
 902
 903 static void add_median_prediction(HYuvDecContext *s, uint8_t *dst, const uint8_t *src, const uint8_t *diff, int w, int *left, int *left_top)
 904 {
 905     if (s->bps <= 8) {
 906         s->llviddsp.add_median_pred(dst, src, diff, w, left, left_top);
 907     } else {
 908         s->hdsp.add_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src, (const uint16_t *)diff, s->n-1, w, left, left_top);
 909     }
 910 }
 911
 912 static int decode_slice(AVCodecContext *avctx, AVFrame *p, int height,
 913                         int buf_size, int y_offset, int table_size)
 914 {
 915     HYuvDecContext *s = avctx->priv_data;
 916     int fake_ystride, fake_ustride, fake_vstride;
 917     const int width  = avctx->width;
 918     const int width2 = avctx->width >> 1;
 919     int ret;
 920
 921     if ((ret = init_get_bits8(&s->gb, s->bitstream_buffer + table_size, buf_size - table_size)) < 0)
 922         return ret;
 923
 924     fake_ystride = s->interlaced ? p->linesize[0] * 2 : p->linesize[0];
 925     fake_ustride = s->interlaced ? p->linesize[1] * 2 : p->linesize[1];
 926     fake_vstride = s->interlaced ? p->linesize[2] * 2 : p->linesize[2];
 927
 928     if (s->version > 2) {
 929         int plane;
 930         for(plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
 931             int left, lefttop, y;
 932             int w = width;
 933             int h = height;
 934             int fake_stride = fake_ystride;
 935
 936             if (s->chroma && (plane == 1 || plane == 2)) {
 937                 w >>= s->chroma_h_shift;
 938                 h >>= s->chroma_v_shift;
 939                 fake_stride = plane == 1 ? fake_ustride : fake_vstride;
 940             }
 941
 942             switch (s->predictor) {
 943             case LEFT:
 944             case PLANE:
 945                 decode_plane_bitstream(s, w, plane);
 946                 left = left_prediction(s, p->data[plane], s->temp[0], w, 0);
 947
 948                 for (y = 1; y < h; y++) {
 949                     uint8_t *dst = p->data[plane] + p->linesize[plane]*y;
 950
 951                     decode_plane_bitstream(s, w, plane);
 952                     left = left_prediction(s, dst, s->temp[0], w, left);
 953                     if (s->predictor == PLANE) {
 954                         if (y > s->interlaced) {
 955                             add_bytes(s, dst, dst - fake_stride, w);
 956                         }
 957                     }
 958                 }
 959
 960                 break;
 961             case MEDIAN:
 962                 decode_plane_bitstream(s, w, plane);
 963                 left= left_prediction(s, p->data[plane], s->temp[0], w, 0);
 964
 965                 y = 1;
 966                 if (y >= h)
 967                     break;
 968
 969                 /* second line is left predicted for interlaced case */
 970                 if (s->interlaced) {
 971                     decode_plane_bitstream(s, w, plane);
 972                     left = left_prediction(s, p->data[plane] + p->linesize[plane], s->temp[0], w, left);
 973                     y++;
 974                     if (y >= h)
 975                         break;
 976                 }
 977
 978                 lefttop = p->data[plane][0];
 979                 decode_plane_bitstream(s, w, plane);
 980                 add_median_prediction(s, p->data[plane] + fake_stride, p->data[plane], s->temp[0], w, &left, &lefttop);
 981                 y++;
 982
 983                 for (; y<h; y++) {
 984                     uint8_t *dst;
 985
 986                     decode_plane_bitstream(s, w, plane);
 987
 988                     dst = p->data[plane] + p->linesize[plane] * y;
 989
 990                     add_median_prediction(s, dst, dst - fake_stride, s->temp[0], w, &left, &lefttop);
 991                 }
 992
 993                 break;
 994             }
 995         }
 996         draw_slice(s, avctx, p, height);
 997     } else if (s->bitstream_bpp < 24) {
 998         int y, cy;
 999         int lefty, leftu, leftv;
1000         int lefttopy, lefttopu, lefttopv;
1001
1002         if (s->yuy2) {
1003             p->data[0][3] = get_bits(&s->gb, 8);
1004             p->data[0][2] = get_bits(&s->gb, 8);
1005             p->data[0][1] = get_bits(&s->gb, 8);
1006             p->data[0][0] = get_bits(&s->gb, 8);
1007
1008             av_log(avctx, AV_LOG_ERROR,
1009                    "YUY2 output is not implemented yet\n");
1010             return AVERROR_PATCHWELCOME;
1011         } else {
1012             leftv         =
1013             p->data[2][0 + y_offset * p->linesize[2]] = get_bits(&s->gb, 8);
1014             lefty         =
1015             p->data[0][1 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8);
1016             leftu         =
1017             p->data[1][0 + y_offset * p->linesize[1]] = get_bits(&s->gb, 8);
1018             p->data[0][0 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8);
1019
1020             switch (s->predictor) {
1021             case LEFT:
1022             case PLANE:
1023                 decode_422_bitstream(s, width - 2);
1024                 lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0] * y_offset + 2, s->temp[0],
1025                                                    width - 2, lefty);
1026                 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1027                     leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[1] * y_offset + 1, s->temp[1], width2 - 1, leftu);
1028                     leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[2] * y_offset + 1, s->temp[2], width2 - 1, leftv);
1029                 }
1030
1031                 for (cy = y = 1; y < height; y++, cy++) {
1032                     uint8_t *ydst, *udst, *vdst;
1033
1034                     if (s->bitstream_bpp == 12) {
1035                         decode_gray_bitstream(s, width);
1036
1037                         ydst = p->data[0] + p->linesize[0] * (y + y_offset);
1038
1039                         lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
1040                                                            width, lefty);
1041                         if (s->predictor == PLANE) {
1042                             if (y > s->interlaced)
1043                                 s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
1044                         }
1045                         y++;
1046                         if (y >= height)
1047                             break;
1048                     }
1049
1050                     draw_slice(s, avctx, p, y);
1051
1052                     ydst = p->data[0] + p->linesize[0] * (y  + y_offset);
1053                     udst = p->data[1] + p->linesize[1] * (cy + y_offset);
1054                     vdst = p->data[2] + p->linesize[2] * (cy + y_offset);
1055
1056                     decode_422_bitstream(s, width);
1057                     lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
1058                                                        width, lefty);
1059                     if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1060                         leftu = s->llviddsp.add_left_pred(udst, s->temp[1], width2, leftu);
1061                         leftv = s->llviddsp.add_left_pred(vdst, s->temp[2], width2, leftv);
1062                     }
1063                     if (s->predictor == PLANE) {
1064                         if (cy > s->interlaced) {
1065                             s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
1066                             if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1067                                 s->llviddsp.add_bytes(udst, udst - fake_ustride, width2);
1068                                 s->llviddsp.add_bytes(vdst, vdst - fake_vstride, width2);
1069                             }
1070                         }
1071                     }
1072                 }
1073                 draw_slice(s, avctx, p, height);
1074
1075                 break;
1076             case MEDIAN:
1077                 /* first line except first 2 pixels is left predicted */
1078                 decode_422_bitstream(s, width - 2);
1079                 lefty = s->llviddsp.add_left_pred(p->data[0] + 2, s->temp[0],
1080                                                    width - 2, lefty);
1081                 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1082                     leftu = s->llviddsp.add_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1083                     leftv = s->llviddsp.add_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1084                 }
1085
1086                 cy = y = 1;
1087                 if (y >= height)
1088                     break;
1089
1090                 /* second line is left predicted for interlaced case */
1091                 if (s->interlaced) {
1092                     decode_422_bitstream(s, width);
1093                     lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0],
1094                                                        s->temp[0], width, lefty);
1095                     if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1096                         leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1097                         leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1098                     }
1099                     y++;
1100                     cy++;
1101                     if (y >= height)
1102                         break;
1103                 }
1104
1105                 /* next 4 pixels are left predicted too */
1106                 decode_422_bitstream(s, 4);
1107                 lefty = s->llviddsp.add_left_pred(p->data[0] + fake_ystride,
1108                                                    s->temp[0], 4, lefty);
1109                 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1110                     leftu = s->llviddsp.add_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1111                     leftv = s->llviddsp.add_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1112                 }
1113
1114                 /* next line except the first 4 pixels is median predicted */
1115                 lefttopy = p->data[0][3];
1116                 decode_422_bitstream(s, width - 4);
1117                 s->llviddsp.add_median_pred(p->data[0] + fake_ystride + 4,
1118                                              p->data[0] + 4, s->temp[0],
1119                                              width - 4, &lefty, &lefttopy);
1120                 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1121                     lefttopu = p->data[1][1];
1122                     lefttopv = p->data[2][1];
1123                     s->llviddsp.add_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
1124                     s->llviddsp.add_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
1125                 }
1126                 y++;
1127                 cy++;
1128
1129                 for (; y < height; y++, cy++) {
1130                     uint8_t *ydst, *udst, *vdst;
1131
1132                     if (s->bitstream_bpp == 12) {
1133                         while (2 * cy > y) {
1134                             decode_gray_bitstream(s, width);
1135                             ydst = p->data[0] + p->linesize[0] * y;
1136                             s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1137                                                          s->temp[0], width,
1138                                                          &lefty, &lefttopy);
1139                             y++;
1140                         }
1141                         if (y >= height)
1142                             break;
1143                     }
1144                     draw_slice(s, avctx, p, y);
1145
1146                     decode_422_bitstream(s, width);
1147
1148                     ydst = p->data[0] + p->linesize[0] * y;
1149                     udst = p->data[1] + p->linesize[1] * cy;
1150                     vdst = p->data[2] + p->linesize[2] * cy;
1151
1152                     s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1153                                                  s->temp[0], width,
1154                                                  &lefty, &lefttopy);
1155                     if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1156                         s->llviddsp.add_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1157                         s->llviddsp.add_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1158                     }
1159                 }
1160
1161                 draw_slice(s, avctx, p, height);
1162                 break;
1163             }
1164         }
1165     } else {
1166         int y;
1167         uint8_t left[4];
1168         const int last_line = (y_offset + height - 1) * p->linesize[0];
1169
1170         if (s->bitstream_bpp == 32) {
1171             left[A] = p->data[0][last_line + A] = get_bits(&s->gb, 8);
1172             left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1173             left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1174             left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1175         } else {
1176             left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1177             left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1178             left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1179             left[A] = p->data[0][last_line + A] = 255;
1180             skip_bits(&s->gb, 8);
1181         }
1182
1183         if (s->bgr32) {
1184             switch (s->predictor) {
1185             case LEFT:
1186             case PLANE:
1187                 decode_bgr_bitstream(s, width - 1);
1188                 s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + last_line + 4,
1189                                                  s->temp[0], width - 1, left);
1190
1191                 for (y = height - 2; y >= 0; y--) { // Yes it is stored upside down.
1192                     decode_bgr_bitstream(s, width);
1193
1194                     s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + p->linesize[0] * (y + y_offset),
1195                                                      s->temp[0], width, left);
1196                     if (s->predictor == PLANE) {
1197                         if (s->bitstream_bpp != 32)
1198                             left[A] = 0;
1199                         if (y < height - 1 - s->interlaced) {
1200                             s->llviddsp.add_bytes(p->data[0] + p->linesize[0] * (y + y_offset),
1201                                               p->data[0] + p->linesize[0] * (y + y_offset) +
1202                                               fake_ystride, 4 * width);
1203                         }
1204                     }
1205                 }
1206                 // just 1 large slice as this is not possible in reverse order
1207                 draw_slice(s, avctx, p, height);
1208                 break;
1209             default:
1210                 av_log(avctx, AV_LOG_ERROR,
1211                        "prediction type not supported!\n");
1212             }
1213         } else {
1214             av_log(avctx, AV_LOG_ERROR,
1215                    "BGR24 output is not implemented yet\n");
1216             return AVERROR_PATCHWELCOME;
1217         }
1218     }
1219
1220     return 0;
1221 }
1222
1223 static int decode_frame(AVCodecContext *avctx, AVFrame *p,
1224                         int *got_frame, AVPacket *avpkt)
1225 {
1226     const uint8_t *buf = avpkt->data;
1227     int buf_size       = avpkt->size;
1228     HYuvDecContext *s = avctx->priv_data;
1229     const int width  = avctx->width;
1230     const int height = avctx->height;
1231     int slice, table_size = 0, ret, nb_slices;
1232     unsigned slices_info_offset;
1233     int slice_height;
1234
1235     if (buf_size < (width * height + 7)/8)
1236         return AVERROR_INVALIDDATA;
1237
1238     av_fast_padded_malloc(&s->bitstream_buffer,
1239                    &s->bitstream_buffer_size,
1240                    buf_size);
1241     if (!s->bitstream_buffer)
1242         return AVERROR(ENOMEM);
1243
1244     s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer,
1245                       (const uint32_t *) buf, buf_size / 4);
1246
1247     if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
1248         return ret;
1249
1250     if (s->context) {
1251         table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
1252         if (table_size < 0)
1253             return table_size;
1254     }
1255
1256     if ((unsigned) (buf_size - table_size) >= INT_MAX / 8)
1257         return AVERROR_INVALIDDATA;
1258
1259     s->last_slice_end = 0;
1260
1261     if (avctx->codec_id == AV_CODEC_ID_HYMT &&
1262         (buf_size > 32 && AV_RL32(avpkt->data + buf_size - 16) == 0)) {
1263         slices_info_offset = AV_RL32(avpkt->data + buf_size - 4);
1264         slice_height = AV_RL32(avpkt->data + buf_size - 8);
1265         nb_slices = AV_RL32(avpkt->data + buf_size - 12);
1266         if (nb_slices * 8LL + slices_info_offset > buf_size - 16 ||
1267             s->chroma_v_shift ||
1268             slice_height <= 0 || nb_slices * (uint64_t)slice_height > height)
1269             return AVERROR_INVALIDDATA;
1270     } else {
1271         slice_height = height;
1272         nb_slices = 1;
1273     }
1274
1275     for (slice = 0; slice < nb_slices; slice++) {
1276         int y_offset, slice_offset, slice_size;
1277
1278         if (nb_slices > 1) {
1279             slice_offset = AV_RL32(avpkt->data + slices_info_offset + slice * 8);
1280             slice_size = AV_RL32(avpkt->data + slices_info_offset + slice * 8 + 4);
1281
1282             if (slice_offset < 0 || slice_size <= 0 || (slice_offset&3) ||
1283                 slice_offset + (int64_t)slice_size > buf_size)
1284                 return AVERROR_INVALIDDATA;
1285
1286             y_offset = height - (slice + 1) * slice_height;
1287             s->bdsp.bswap_buf((uint32_t *)s->bitstream_buffer,
1288                               (const uint32_t *)(buf + slice_offset), slice_size / 4);
1289         } else {
1290             y_offset = 0;
1291             slice_offset = 0;
1292             slice_size = buf_size;
1293         }
1294
1295         ret = decode_slice(avctx, p, slice_height, slice_size, y_offset, table_size);
1296         emms_c();
1297         if (ret < 0)
1298             return ret;
1299     }
1300
1301     *got_frame = 1;
1302
1303     return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
1304 }
1305
1306 const FFCodec ff_huffyuv_decoder = {
1307     .p.name           = "huffyuv",
1308     CODEC_LONG_NAME("Huffyuv / HuffYUV"),
1309     .p.type           = AVMEDIA_TYPE_VIDEO,
1310     .p.id             = AV_CODEC_ID_HUFFYUV,
1311     .priv_data_size   = sizeof(HYuvDecContext),
1312     .init             = decode_init,
1313     .close            = decode_end,
1314     FF_CODEC_DECODE_CB(decode_frame),
1315     .p.capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1316                         AV_CODEC_CAP_FRAME_THREADS,
1317     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
1318 };
1319
1320 #if CONFIG_FFVHUFF_DECODER
1321 const FFCodec ff_ffvhuff_decoder = {
1322     .p.name           = "ffvhuff",
1323     CODEC_LONG_NAME("Huffyuv FFmpeg variant"),
1324     .p.type           = AVMEDIA_TYPE_VIDEO,
1325     .p.id             = AV_CODEC_ID_FFVHUFF,
1326     .priv_data_size   = sizeof(HYuvDecContext),
1327     .init             = decode_init,
1328     .close            = decode_end,
1329     FF_CODEC_DECODE_CB(decode_frame),
1330     .p.capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1331                         AV_CODEC_CAP_FRAME_THREADS,
1332     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
1333 };
1334 #endif /* CONFIG_FFVHUFF_DECODER */
1335
1336 #if CONFIG_HYMT_DECODER
1337 const FFCodec ff_hymt_decoder = {
1338     .p.name           = "hymt",
1339     CODEC_LONG_NAME("HuffYUV MT"),
1340     .p.type           = AVMEDIA_TYPE_VIDEO,
1341     .p.id             = AV_CODEC_ID_HYMT,
1342     .priv_data_size   = sizeof(HYuvDecContext),
1343     .init             = decode_init,
1344     .close            = decode_end,
1345     FF_CODEC_DECODE_CB(decode_frame),
1346     .p.capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1347                         AV_CODEC_CAP_FRAME_THREADS,
1348     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
1349 };
1350 #endif /* CONFIG_HYMT_DECODER */