git.sesse.net Git - ffmpeg/blob - libavcodec/huffyuv.c

   1 /*
   2  * huffyuv codec for libavcodec
   3  *
   4  * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * see http://www.pcisys.net/~melanson/codecs/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
  26 /**
  27  * @file
  28  * huffyuv codec for libavcodec.
  29  */
  30
  31 #include "avcodec.h"
  32 #include "internal.h"
  33 #include "get_bits.h"
  34 #include "put_bits.h"
  35 #include "dsputil.h"
  36 #include "thread.h"
  37 #include "huffman.h"
  38
  39 #define VLC_BITS 11
  40
  41 #if HAVE_BIGENDIAN
  42 #define B 3
  43 #define G 2
  44 #define R 1
  45 #define A 0
  46 #else
  47 #define B 0
  48 #define G 1
  49 #define R 2
  50 #define A 3
  51 #endif
  52
  53 typedef enum Predictor {
  54     LEFT= 0,
  55     PLANE,
  56     MEDIAN,
  57 } Predictor;
  58
  59 typedef struct HYuvContext {
  60     AVCodecContext *avctx;
  61     Predictor predictor;
  62     GetBitContext gb;
  63     PutBitContext pb;
  64     int interlaced;
  65     int decorrelate;
  66     int bitstream_bpp;
  67     int version;
  68     int yuy2;                               //use yuy2 instead of 422P
  69     int bgr32;                              //use bgr32 instead of bgr24
  70     int width, height;
  71     int flags;
  72     int context;
  73     int picture_number;
  74     int last_slice_end;
  75     uint8_t *temp[3];
  76     uint64_t stats[3][256];
  77     uint8_t len[3][256];
  78     uint32_t bits[3][256];
  79     uint32_t pix_bgr_map[1<<VLC_BITS];
  80     VLC vlc[6];                             //Y,U,V,YY,YU,YV
  81     AVFrame picture;
  82     uint8_t *bitstream_buffer;
  83     unsigned int bitstream_buffer_size;
  84     DSPContext dsp;
  85 } HYuvContext;
  86
  87 #define classic_shift_luma_table_size 42
  88 static const unsigned char classic_shift_luma[classic_shift_luma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {
  89   34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
  90   16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
  91   69,68, 0,
  92   0,0,0,0,0,0,0,0,
  93 };
  94
  95 #define classic_shift_chroma_table_size 59
  96 static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {
  97   66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
  98   56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
  99   214,245,116,83,82,49,80,79,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 inline int sub_left_prediction(HYuvContext *s, uint8_t *dst,
 142                                       const uint8_t *src, int w, int left)
 143 {
 144     int i;
 145     if (w < 32) {
 146         for (i = 0; i < w; i++) {
 147             const int temp = src[i];
 148             dst[i] = temp - left;
 149             left   = temp;
 150         }
 151         return left;
 152     } else {
 153         for (i = 0; i < 16; i++) {
 154             const int temp = src[i];
 155             dst[i] = temp - left;
 156             left   = temp;
 157         }
 158         s->dsp.diff_bytes(dst + 16, src + 16, src + 15, w - 16);
 159         return src[w-1];
 160     }
 161 }
 162
 163 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst,
 164                                              const uint8_t *src, int w,
 165                                              int *red, int *green, int *blue, int *alpha)
 166 {
 167     int i;
 168     int r,g,b,a;
 169     r = *red;
 170     g = *green;
 171     b = *blue;
 172     a = *alpha;
 173     for (i = 0; i < FFMIN(w, 4); i++) {
 174         const int rt = src[i * 4 + R];
 175         const int gt = src[i * 4 + G];
 176         const int bt = src[i * 4 + B];
 177         const int at = src[i * 4 + A];
 178         dst[i * 4 + R] = rt - r;
 179         dst[i * 4 + G] = gt - g;
 180         dst[i * 4 + B] = bt - b;
 181         dst[i * 4 + A] = at - a;
 182         r = rt;
 183         g = gt;
 184         b = bt;
 185         a = at;
 186     }
 187
 188     s->dsp.diff_bytes(dst + 16, src + 16, src + 12, w * 4 - 16);
 189
 190     *red   = src[(w - 1) * 4 + R];
 191     *green = src[(w - 1) * 4 + G];
 192     *blue  = src[(w - 1) * 4 + B];
 193     *alpha = src[(w - 1) * 4 + A];
 194 }
 195
 196 static inline void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue){
 197     int i;
 198     int r,g,b;
 199     r = *red;
 200     g = *green;
 201     b = *blue;
 202     for (i = 0; i < FFMIN(w,16); i++) {
 203         const int rt = src[i*3 + 0];
 204         const int gt = src[i*3 + 1];
 205         const int bt = src[i*3 + 2];
 206         dst[i*3 + 0] = rt - r;
 207         dst[i*3 + 1] = gt - g;
 208         dst[i*3 + 2] = bt - b;
 209         r = rt;
 210         g = gt;
 211         b = bt;
 212     }
 213
 214     s->dsp.diff_bytes(dst + 48, src + 48, src + 48 - 3, w*3 - 48);
 215
 216     *red   = src[(w - 1)*3 + 0];
 217     *green = src[(w - 1)*3 + 1];
 218     *blue  = src[(w - 1)*3 + 2];
 219 }
 220
 221 static int read_len_table(uint8_t *dst, GetBitContext *gb)
 222 {
 223     int i, val, repeat;
 224
 225     for (i = 0; i < 256;) {
 226         repeat = get_bits(gb, 3);
 227         val    = get_bits(gb, 5);
 228         if (repeat == 0)
 229             repeat = get_bits(gb, 8);
 230         if (i + repeat > 256 || get_bits_left(gb) < 0) {
 231             av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
 232             return -1;
 233         }
 234         while (repeat--)
 235             dst[i++] = val;
 236     }
 237     return 0;
 238 }
 239
 240 static int generate_bits_table(uint32_t *dst, const uint8_t *len_table)
 241 {
 242     int len, index;
 243     uint32_t bits = 0;
 244
 245     for (len = 32; len > 0; len--) {
 246         for (index = 0; index < 256; index++) {
 247             if (len_table[index] == len)
 248                 dst[index] = bits++;
 249         }
 250         if (bits & 1) {
 251             av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
 252             return -1;
 253         }
 254         bits >>= 1;
 255     }
 256     return 0;
 257 }
 258
 259 static void generate_joint_tables(HYuvContext *s)
 260 {
 261     uint16_t symbols[1 << VLC_BITS];
 262     uint16_t bits[1 << VLC_BITS];
 263     uint8_t len[1 << VLC_BITS];
 264     if (s->bitstream_bpp < 24) {
 265         int p, i, y, u;
 266         for (p = 0; p < 3; p++) {
 267             for (i = y = 0; y < 256; y++) {
 268                 int len0 = s->len[0][y];
 269                 int limit = VLC_BITS - len0;
 270                 if(limit <= 0)
 271                     continue;
 272                 for (u = 0; u < 256; u++) {
 273                     int len1 = s->len[p][u];
 274                     if (len1 > limit)
 275                         continue;
 276                     len[i] = len0 + len1;
 277                     bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
 278                     symbols[i] = (y << 8) + u;
 279                     if(symbols[i] != 0xffff) // reserved to mean "invalid"
 280                         i++;
 281                 }
 282             }
 283             ff_free_vlc(&s->vlc[3 + p]);
 284             ff_init_vlc_sparse(&s->vlc[3 + p], VLC_BITS, i, len, 1, 1,
 285                                bits, 2, 2, symbols, 2, 2, 0);
 286         }
 287     } else {
 288         uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
 289         int i, b, g, r, code;
 290         int p0 = s->decorrelate;
 291         int p1 = !s->decorrelate;
 292         // restrict the range to +/-16 because that's pretty much guaranteed to
 293         // cover all the combinations that fit in 11 bits total, and it doesn't
 294         // matter if we miss a few rare codes.
 295         for (i = 0, g = -16; g < 16; g++) {
 296             int len0 = s->len[p0][g & 255];
 297             int limit0 = VLC_BITS - len0;
 298             if (limit0 < 2)
 299                 continue;
 300             for (b = -16; b < 16; b++) {
 301                 int len1 = s->len[p1][b & 255];
 302                 int limit1 = limit0 - len1;
 303                 if (limit1 < 1)
 304                     continue;
 305                 code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];
 306                 for (r = -16; r < 16; r++) {
 307                     int len2 = s->len[2][r & 255];
 308                     if (len2 > limit1)
 309                         continue;
 310                     len[i] = len0 + len1 + len2;
 311                     bits[i] = (code << len2) + s->bits[2][r & 255];
 312                     if (s->decorrelate) {
 313                         map[i][G] = g;
 314                         map[i][B] = g + b;
 315                         map[i][R] = g + r;
 316                     } else {
 317                         map[i][B] = g;
 318                         map[i][G] = b;
 319                         map[i][R] = r;
 320                     }
 321                     i++;
 322                 }
 323             }
 324         }
 325         ff_free_vlc(&s->vlc[3]);
 326         init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
 327     }
 328 }
 329
 330 static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)
 331 {
 332     GetBitContext gb;
 333     int i;
 334
 335     init_get_bits(&gb, src, length * 8);
 336
 337     for (i = 0; i < 3; i++) {
 338         if (read_len_table(s->len[i], &gb) < 0)
 339             return -1;
 340         if (generate_bits_table(s->bits[i], s->len[i]) < 0) {
 341             return -1;
 342         }
 343         ff_free_vlc(&s->vlc[i]);
 344         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
 345                  s->bits[i], 4, 4, 0);
 346     }
 347
 348     generate_joint_tables(s);
 349
 350     return (get_bits_count(&gb) + 7) / 8;
 351 }
 352
 353 static int read_old_huffman_tables(HYuvContext *s)
 354 {
 355     GetBitContext gb;
 356     int i;
 357
 358     init_get_bits(&gb, classic_shift_luma,
 359                   classic_shift_luma_table_size * 8);
 360     if (read_len_table(s->len[0], &gb) < 0)
 361         return -1;
 362
 363     init_get_bits(&gb, classic_shift_chroma,
 364                   classic_shift_chroma_table_size * 8);
 365     if (read_len_table(s->len[1], &gb) < 0)
 366         return -1;
 367
 368     for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
 369     for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
 370
 371     if (s->bitstream_bpp >= 24) {
 372         memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));
 373         memcpy(s->len[1] , s->len [0], 256 * sizeof(uint8_t));
 374     }
 375     memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));
 376     memcpy(s->len[2] , s->len [1], 256 * sizeof(uint8_t));
 377
 378     for (i = 0; i < 3; i++) {
 379         ff_free_vlc(&s->vlc[i]);
 380         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
 381                  s->bits[i], 4, 4, 0);
 382     }
 383
 384     generate_joint_tables(s);
 385
 386     return 0;
 387 }
 388
 389 static av_cold void alloc_temp(HYuvContext *s)
 390 {
 391     int i;
 392
 393     if (s->bitstream_bpp<24) {
 394         for (i=0; i<3; i++) {
 395             s->temp[i]= av_malloc(s->width + 16);
 396         }
 397     } else {
 398         s->temp[0]= av_mallocz(4*s->width + 16);
 399     }
 400 }
 401
 402 static av_cold int common_init(AVCodecContext *avctx)
 403 {
 404     HYuvContext *s = avctx->priv_data;
 405
 406     s->avctx = avctx;
 407     s->flags = avctx->flags;
 408
 409     ff_dsputil_init(&s->dsp, avctx);
 410
 411     s->width = avctx->width;
 412     s->height = avctx->height;
 413     av_assert1(s->width > 0 && s->height > 0);
 414
 415     return 0;
 416 }
 417
 418 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
 419 static av_cold int decode_init(AVCodecContext *avctx)
 420 {
 421     HYuvContext *s = avctx->priv_data;
 422
 423     common_init(avctx);
 424     memset(s->vlc, 0, 3 * sizeof(VLC));
 425
 426     avctx->coded_frame = &s->picture;
 427     avcodec_get_frame_defaults(&s->picture);
 428     s->interlaced = s->height > 288;
 429
 430     s->bgr32 = 1;
 431
 432     if (avctx->extradata_size) {
 433         if ((avctx->bits_per_coded_sample & 7) &&
 434             avctx->bits_per_coded_sample != 12)
 435             s->version = 1; // do such files exist at all?
 436         else
 437             s->version = 2;
 438     } else
 439         s->version = 0;
 440
 441     if (s->version == 2) {
 442         int method, interlace;
 443
 444         if (avctx->extradata_size < 4)
 445             return -1;
 446
 447         method = ((uint8_t*)avctx->extradata)[0];
 448         s->decorrelate = method & 64 ? 1 : 0;
 449         s->predictor = method & 63;
 450         s->bitstream_bpp = ((uint8_t*)avctx->extradata)[1];
 451         if (s->bitstream_bpp == 0)
 452             s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
 453         interlace = (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
 454         s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
 455         s->context = ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
 456
 457         if ( read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
 458                                  avctx->extradata_size - 4) < 0)
 459             return -1;
 460     }else{
 461         switch (avctx->bits_per_coded_sample & 7) {
 462         case 1:
 463             s->predictor = LEFT;
 464             s->decorrelate = 0;
 465             break;
 466         case 2:
 467             s->predictor = LEFT;
 468             s->decorrelate = 1;
 469             break;
 470         case 3:
 471             s->predictor = PLANE;
 472             s->decorrelate = avctx->bits_per_coded_sample >= 24;
 473             break;
 474         case 4:
 475             s->predictor = MEDIAN;
 476             s->decorrelate = 0;
 477             break;
 478         default:
 479             s->predictor = LEFT; //OLD
 480             s->decorrelate = 0;
 481             break;
 482         }
 483         s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
 484         s->context = 0;
 485
 486         if (read_old_huffman_tables(s) < 0)
 487             return -1;
 488     }
 489
 490     switch (s->bitstream_bpp) {
 491     case 12:
 492         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 493         break;
 494     case 16:
 495         if (s->yuy2) {
 496             avctx->pix_fmt = AV_PIX_FMT_YUYV422;
 497         } else {
 498             avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 499         }
 500         break;
 501     case 24:
 502     case 32:
 503         if (s->bgr32) {
 504             avctx->pix_fmt = AV_PIX_FMT_RGB32;
 505         } else {
 506             avctx->pix_fmt = AV_PIX_FMT_BGR24;
 507         }
 508         break;
 509     default:
 510         return AVERROR_INVALIDDATA;
 511     }
 512
 513     if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) {
 514         av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
 515         return AVERROR_INVALIDDATA;
 516     }
 517
 518     alloc_temp(s);
 519
 520     return 0;
 521 }
 522
 523 static av_cold int decode_init_thread_copy(AVCodecContext *avctx)
 524 {
 525     HYuvContext *s = avctx->priv_data;
 526     int i;
 527
 528     avctx->coded_frame= &s->picture;
 529     alloc_temp(s);
 530
 531     for (i = 0; i < 6; i++)
 532         s->vlc[i].table = NULL;
 533
 534     if (s->version == 2) {
 535         if (read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
 536                                 avctx->extradata_size) < 0)
 537             return -1;
 538     } else {
 539         if (read_old_huffman_tables(s) < 0)
 540             return -1;
 541     }
 542
 543     return 0;
 544 }
 545 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
 546
 547 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
 548 static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)
 549 {
 550     int i;
 551     int index = 0;
 552
 553     for (i = 0; i < 256;) {
 554         int val = len[i];
 555         int repeat = 0;
 556
 557         for (; i < 256 && len[i] == val && repeat < 255; i++)
 558             repeat++;
 559
 560         av_assert0(val < 32 && val >0 && repeat<256 && repeat>0);
 561         if (repeat > 7) {
 562             buf[index++] = val;
 563             buf[index++] = repeat;
 564         } else {
 565             buf[index++] = val | (repeat << 5);
 566         }
 567     }
 568
 569     return index;
 570 }
 571
 572 static av_cold int encode_init(AVCodecContext *avctx)
 573 {
 574     HYuvContext *s = avctx->priv_data;
 575     int i, j;
 576
 577     common_init(avctx);
 578
 579     avctx->extradata = av_mallocz(1024*30); // 256*3+4 == 772
 580     avctx->stats_out = av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
 581     s->version = 2;
 582
 583     avctx->coded_frame = &s->picture;
 584
 585     switch (avctx->pix_fmt) {
 586     case AV_PIX_FMT_YUV420P:
 587     case AV_PIX_FMT_YUV422P:
 588         if (s->width & 1) {
 589             av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
 590             return AVERROR(EINVAL);
 591         }
 592         s->bitstream_bpp = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? 12 : 16;
 593         break;
 594     case AV_PIX_FMT_RGB32:
 595         s->bitstream_bpp = 32;
 596         break;
 597     case AV_PIX_FMT_RGB24:
 598         s->bitstream_bpp = 24;
 599         break;
 600     default:
 601         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 602         return -1;
 603     }
 604     avctx->bits_per_coded_sample = s->bitstream_bpp;
 605     s->decorrelate = s->bitstream_bpp >= 24;
 606     s->predictor = avctx->prediction_method;
 607     s->interlaced = avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
 608     if (avctx->context_model == 1) {
 609         s->context = avctx->context_model;
 610         if (s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) {
 611             av_log(avctx, AV_LOG_ERROR,
 612                    "context=1 is not compatible with "
 613                    "2 pass huffyuv encoding\n");
 614             return -1;
 615         }
 616     }else s->context= 0;
 617
 618     if (avctx->codec->id == AV_CODEC_ID_HUFFYUV) {
 619         if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
 620             av_log(avctx, AV_LOG_ERROR,
 621                    "Error: YV12 is not supported by huffyuv; use "
 622                    "vcodec=ffvhuff or format=422p\n");
 623             return -1;
 624         }
 625         if (avctx->context_model) {
 626             av_log(avctx, AV_LOG_ERROR,
 627                    "Error: per-frame huffman tables are not supported "
 628                    "by huffyuv; use vcodec=ffvhuff\n");
 629             return -1;
 630         }
 631         if (s->interlaced != ( s->height > 288 ))
 632             av_log(avctx, AV_LOG_INFO,
 633                    "using huffyuv 2.2.0 or newer interlacing flag\n");
 634     }
 635
 636     if (s->bitstream_bpp >= 24 && s->predictor == MEDIAN) {
 637         av_log(avctx, AV_LOG_ERROR,
 638                "Error: RGB is incompatible with median predictor\n");
 639         return -1;
 640     }
 641
 642     ((uint8_t*)avctx->extradata)[0] = s->predictor | (s->decorrelate << 6);
 643     ((uint8_t*)avctx->extradata)[1] = s->bitstream_bpp;
 644     ((uint8_t*)avctx->extradata)[2] = s->interlaced ? 0x10 : 0x20;
 645     if (s->context)
 646         ((uint8_t*)avctx->extradata)[2] |= 0x40;
 647     ((uint8_t*)avctx->extradata)[3] = 0;
 648     s->avctx->extradata_size = 4;
 649
 650     if (avctx->stats_in) {
 651         char *p = avctx->stats_in;
 652
 653         for (i = 0; i < 3; i++)
 654             for (j = 0; j < 256; j++)
 655                 s->stats[i][j] = 1;
 656
 657         for (;;) {
 658             for (i = 0; i < 3; i++) {
 659                 char *next;
 660
 661                 for (j = 0; j < 256; j++) {
 662                     s->stats[i][j] += strtol(p, &next, 0);
 663                     if (next == p) return -1;
 664                     p = next;
 665                 }
 666             }
 667             if (p[0] == 0 || p[1] == 0 || p[2] == 0) break;
 668         }
 669     } else {
 670         for (i = 0; i < 3; i++)
 671             for (j = 0; j < 256; j++) {
 672                 int d = FFMIN(j, 256 - j);
 673
 674                 s->stats[i][j] = 100000000 / (d + 1);
 675             }
 676     }
 677
 678     for (i = 0; i < 3; i++) {
 679         ff_huff_gen_len_table(s->len[i], s->stats[i]);
 680
 681         if (generate_bits_table(s->bits[i], s->len[i]) < 0) {
 682             return -1;
 683         }
 684
 685         s->avctx->extradata_size +=
 686             store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
 687     }
 688
 689     if (s->context) {
 690         for (i = 0; i < 3; i++) {
 691             int pels = s->width * s->height / (i ? 40 : 10);
 692             for (j = 0; j < 256; j++) {
 693                 int d = FFMIN(j, 256 - j);
 694                 s->stats[i][j] = pels/(d + 1);
 695             }
 696         }
 697     } else {
 698         for (i = 0; i < 3; i++)
 699             for (j = 0; j < 256; j++)
 700                 s->stats[i][j]= 0;
 701     }
 702
 703     alloc_temp(s);
 704
 705     s->picture_number=0;
 706
 707     return 0;
 708 }
 709 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
 710
 711 /* TODO instead of restarting the read when the code isn't in the first level
 712  * of the joint table, jump into the 2nd level of the individual table. */
 713 #define READ_2PIX(dst0, dst1, plane1){\
 714     uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
 715     if(code != 0xffff){\
 716         dst0 = code>>8;\
 717         dst1 = code;\
 718     }else{\
 719         dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
 720         dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
 721     }\
 722 }
 723
 724 static void decode_422_bitstream(HYuvContext *s, int count)
 725 {
 726     int i;
 727
 728     count /= 2;
 729
 730     if (count >= (get_bits_left(&s->gb)) / (31 * 4)) {
 731         for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
 732             READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);
 733             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
 734         }
 735     } else {
 736         for (i = 0; i < count; i++) {
 737             READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);
 738             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
 739         }
 740     }
 741 }
 742
 743 static void decode_gray_bitstream(HYuvContext *s, int count)
 744 {
 745     int i;
 746
 747     count/=2;
 748
 749     if (count >= (get_bits_left(&s->gb)) / (31 * 2)) {
 750         for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
 751             READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
 752         }
 753     } else {
 754         for(i=0; i<count; i++){
 755             READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
 756         }
 757     }
 758 }
 759
 760 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
 761 static int encode_422_bitstream(HYuvContext *s, int offset, int count)
 762 {
 763     int i;
 764     const uint8_t *y = s->temp[0] + offset;
 765     const uint8_t *u = s->temp[1] + offset / 2;
 766     const uint8_t *v = s->temp[2] + offset / 2;
 767
 768     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 2 * 4 * count) {
 769         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 770         return -1;
 771     }
 772
 773 #define LOAD4\
 774             int y0 = y[2 * i];\
 775             int y1 = y[2 * i + 1];\
 776             int u0 = u[i];\
 777             int v0 = v[i];
 778
 779     count /= 2;
 780
 781     if (s->flags & CODEC_FLAG_PASS1) {
 782         for(i = 0; i < count; i++) {
 783             LOAD4;
 784             s->stats[0][y0]++;
 785             s->stats[1][u0]++;
 786             s->stats[0][y1]++;
 787             s->stats[2][v0]++;
 788         }
 789     }
 790     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)
 791         return 0;
 792     if (s->context) {
 793         for (i = 0; i < count; i++) {
 794             LOAD4;
 795             s->stats[0][y0]++;
 796             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
 797             s->stats[1][u0]++;
 798             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
 799             s->stats[0][y1]++;
 800             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
 801             s->stats[2][v0]++;
 802             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
 803         }
 804     } else {
 805         for(i = 0; i < count; i++) {
 806             LOAD4;
 807             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
 808             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
 809             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
 810             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
 811         }
 812     }
 813     return 0;
 814 }
 815
 816 static int encode_gray_bitstream(HYuvContext *s, int count)
 817 {
 818     int i;
 819
 820     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 4 * count) {
 821         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 822         return -1;
 823     }
 824
 825 #define LOAD2\
 826             int y0 = s->temp[0][2 * i];\
 827             int y1 = s->temp[0][2 * i + 1];
 828 #define STAT2\
 829             s->stats[0][y0]++;\
 830             s->stats[0][y1]++;
 831 #define WRITE2\
 832             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
 833             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
 834
 835     count /= 2;
 836
 837     if (s->flags & CODEC_FLAG_PASS1) {
 838         for (i = 0; i < count; i++) {
 839             LOAD2;
 840             STAT2;
 841         }
 842     }
 843     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)
 844         return 0;
 845
 846     if (s->context) {
 847         for (i = 0; i < count; i++) {
 848             LOAD2;
 849             STAT2;
 850             WRITE2;
 851         }
 852     } else {
 853         for (i = 0; i < count; i++) {
 854             LOAD2;
 855             WRITE2;
 856         }
 857     }
 858     return 0;
 859 }
 860 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
 861
 862 static av_always_inline void decode_bgr_1(HYuvContext *s, int count,
 863                                           int decorrelate, int alpha)
 864 {
 865     int i;
 866     for (i = 0; i < count; i++) {
 867         int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
 868         if (code != -1) {
 869             *(uint32_t*)&s->temp[0][4 * i] = s->pix_bgr_map[code];
 870         } else if(decorrelate) {
 871             s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 872             s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) +
 873                                     s->temp[0][4 * i + G];
 874             s->temp[0][4 * i + R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) +
 875                                     s->temp[0][4 * i + G];
 876         } else {
 877             s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 878             s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 879             s->temp[0][4 * i + R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 880         }
 881         if (alpha)
 882             s->temp[0][4 * i + A] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 883     }
 884 }
 885
 886 static void decode_bgr_bitstream(HYuvContext *s, int count)
 887 {
 888     if (s->decorrelate) {
 889         if (s->bitstream_bpp==24)
 890             decode_bgr_1(s, count, 1, 0);
 891         else
 892             decode_bgr_1(s, count, 1, 1);
 893     } else {
 894         if (s->bitstream_bpp==24)
 895             decode_bgr_1(s, count, 0, 0);
 896         else
 897             decode_bgr_1(s, count, 0, 1);
 898     }
 899 }
 900
 901 static inline int encode_bgra_bitstream(HYuvContext *s, int count, int planes)
 902 {
 903     int i;
 904
 905     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*planes*count) {
 906         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 907         return -1;
 908     }
 909
 910 #define LOAD3\
 911             int g =  s->temp[0][planes==3 ? 3*i + 1 : 4*i + G];\
 912             int b = (s->temp[0][planes==3 ? 3*i + 2 : 4*i + B] - g) & 0xff;\
 913             int r = (s->temp[0][planes==3 ? 3*i + 0 : 4*i + R] - g) & 0xff;\
 914             int a =  s->temp[0][planes*i + A];
 915 #define STAT3\
 916             s->stats[0][b]++;\
 917             s->stats[1][g]++;\
 918             s->stats[2][r]++;\
 919             if(planes==4) s->stats[2][a]++;
 920 #define WRITE3\
 921             put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
 922             put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
 923             put_bits(&s->pb, s->len[2][r], s->bits[2][r]);\
 924             if(planes==4) put_bits(&s->pb, s->len[2][a], s->bits[2][a]);
 925
 926     if ((s->flags & CODEC_FLAG_PASS1) &&
 927         (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)) {
 928         for (i = 0; i < count; i++) {
 929             LOAD3;
 930             STAT3;
 931         }
 932     } else if (s->context || (s->flags & CODEC_FLAG_PASS1)) {
 933         for (i = 0; i < count; i++) {
 934             LOAD3;
 935             STAT3;
 936             WRITE3;
 937         }
 938     } else {
 939         for (i = 0; i < count; i++) {
 940             LOAD3;
 941             WRITE3;
 942         }
 943     }
 944     return 0;
 945 }
 946
 947 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
 948 static void draw_slice(HYuvContext *s, int y)
 949 {
 950     int h, cy, i;
 951     int offset[AV_NUM_DATA_POINTERS];
 952
 953     if (s->avctx->draw_horiz_band==NULL)
 954         return;
 955
 956     h = y - s->last_slice_end;
 957     y -= h;
 958
 959     if (s->bitstream_bpp == 12) {
 960         cy = y>>1;
 961     } else {
 962         cy = y;
 963     }
 964
 965     offset[0] = s->picture.linesize[0]*y;
 966     offset[1] = s->picture.linesize[1]*cy;
 967     offset[2] = s->picture.linesize[2]*cy;
 968     for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
 969         offset[i] = 0;
 970     emms_c();
 971
 972     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
 973
 974     s->last_slice_end = y + h;
 975 }
 976
 977 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 978                         AVPacket *avpkt)
 979 {
 980     const uint8_t *buf = avpkt->data;
 981     int buf_size = avpkt->size;
 982     HYuvContext *s = avctx->priv_data;
 983     const int width = s->width;
 984     const int width2 = s->width>>1;
 985     const int height = s->height;
 986     int fake_ystride, fake_ustride, fake_vstride;
 987     AVFrame * const p = &s->picture;
 988     int table_size = 0;
 989
 990     AVFrame *picture = data;
 991
 992     av_fast_malloc(&s->bitstream_buffer,
 993                    &s->bitstream_buffer_size,
 994                    buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 995     if (!s->bitstream_buffer)
 996         return AVERROR(ENOMEM);
 997
 998     memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 999     s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer,
1000                      (const uint32_t*)buf, buf_size / 4);
1001
1002     if (p->data[0])
1003         ff_thread_release_buffer(avctx, p);
1004
1005     p->reference = 0;
1006     if (ff_thread_get_buffer(avctx, p) < 0) {
1007         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1008         return -1;
1009     }
1010
1011     if (s->context) {
1012         table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
1013         if (table_size < 0)
1014             return -1;
1015     }
1016
1017     if ((unsigned)(buf_size-table_size) >= INT_MAX / 8)
1018         return -1;
1019
1020     init_get_bits(&s->gb, s->bitstream_buffer+table_size,
1021                   (buf_size-table_size) * 8);
1022
1023     fake_ystride = s->interlaced ? p->linesize[0] * 2  : p->linesize[0];
1024     fake_ustride = s->interlaced ? p->linesize[1] * 2  : p->linesize[1];
1025     fake_vstride = s->interlaced ? p->linesize[2] * 2  : p->linesize[2];
1026
1027     s->last_slice_end = 0;
1028
1029     if (s->bitstream_bpp < 24) {
1030         int y, cy;
1031         int lefty, leftu, leftv;
1032         int lefttopy, lefttopu, lefttopv;
1033
1034         if (s->yuy2) {
1035             p->data[0][3] = get_bits(&s->gb, 8);
1036             p->data[0][2] = get_bits(&s->gb, 8);
1037             p->data[0][1] = get_bits(&s->gb, 8);
1038             p->data[0][0] = get_bits(&s->gb, 8);
1039
1040             av_log(avctx, AV_LOG_ERROR,
1041                    "YUY2 output is not implemented yet\n");
1042             return -1;
1043         } else {
1044
1045             leftv = p->data[2][0] = get_bits(&s->gb, 8);
1046             lefty = p->data[0][1] = get_bits(&s->gb, 8);
1047             leftu = p->data[1][0] = get_bits(&s->gb, 8);
1048                     p->data[0][0] = get_bits(&s->gb, 8);
1049
1050             switch (s->predictor) {
1051             case LEFT:
1052             case PLANE:
1053                 decode_422_bitstream(s, width-2);
1054                 lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1055                 if (!(s->flags&CODEC_FLAG_GRAY)) {
1056                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1057                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1058                 }
1059
1060                 for (cy = y = 1; y < s->height; y++, cy++) {
1061                     uint8_t *ydst, *udst, *vdst;
1062
1063                     if (s->bitstream_bpp == 12) {
1064                         decode_gray_bitstream(s, width);
1065
1066                         ydst = p->data[0] + p->linesize[0] * y;
1067
1068                         lefty = s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
1069                         if (s->predictor == PLANE) {
1070                             if (y > s->interlaced)
1071                                 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1072                         }
1073                         y++;
1074                         if (y >= s->height) break;
1075                     }
1076
1077                     draw_slice(s, y);
1078
1079                     ydst = p->data[0] + p->linesize[0]*y;
1080                     udst = p->data[1] + p->linesize[1]*cy;
1081                     vdst = p->data[2] + p->linesize[2]*cy;
1082
1083                     decode_422_bitstream(s, width);
1084                     lefty = s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
1085                     if (!(s->flags & CODEC_FLAG_GRAY)) {
1086                         leftu= s->dsp.add_hfyu_left_prediction(udst, s->temp[1], width2, leftu);
1087                         leftv= s->dsp.add_hfyu_left_prediction(vdst, s->temp[2], width2, leftv);
1088                     }
1089                     if (s->predictor == PLANE) {
1090                         if (cy > s->interlaced) {
1091                             s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1092                             if (!(s->flags & CODEC_FLAG_GRAY)) {
1093                                 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1094                                 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1095                             }
1096                         }
1097                     }
1098                 }
1099                 draw_slice(s, height);
1100
1101                 break;
1102             case MEDIAN:
1103                 /* first line except first 2 pixels is left predicted */
1104                 decode_422_bitstream(s, width - 2);
1105                 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width - 2, lefty);
1106                 if (!(s->flags & CODEC_FLAG_GRAY)) {
1107                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1108                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1109                 }
1110
1111                 cy = y = 1;
1112
1113                 /* second line is left predicted for interlaced case */
1114                 if (s->interlaced) {
1115                     decode_422_bitstream(s, width);
1116                     lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1117                     if (!(s->flags & CODEC_FLAG_GRAY)) {
1118                         leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1119                         leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1120                     }
1121                     y++; cy++;
1122                 }
1123
1124                 /* next 4 pixels are left predicted too */
1125                 decode_422_bitstream(s, 4);
1126                 lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1127                 if (!(s->flags&CODEC_FLAG_GRAY)) {
1128                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1129                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1130                 }
1131
1132                 /* next line except the first 4 pixels is median predicted */
1133                 lefttopy = p->data[0][3];
1134                 decode_422_bitstream(s, width - 4);
1135                 s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1136                 if (!(s->flags&CODEC_FLAG_GRAY)) {
1137                     lefttopu = p->data[1][1];
1138                     lefttopv = p->data[2][1];
1139                     s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
1140                     s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
1141                 }
1142                 y++; cy++;
1143
1144                 for (; y<height; y++, cy++) {
1145                     uint8_t *ydst, *udst, *vdst;
1146
1147                     if (s->bitstream_bpp == 12) {
1148                         while (2 * cy > y) {
1149                             decode_gray_bitstream(s, width);
1150                             ydst = p->data[0] + p->linesize[0] * y;
1151                             s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1152                             y++;
1153                         }
1154                         if (y >= height) break;
1155                     }
1156                     draw_slice(s, y);
1157
1158                     decode_422_bitstream(s, width);
1159
1160                     ydst = p->data[0] + p->linesize[0] * y;
1161                     udst = p->data[1] + p->linesize[1] * cy;
1162                     vdst = p->data[2] + p->linesize[2] * cy;
1163
1164                     s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1165                     if (!(s->flags & CODEC_FLAG_GRAY)) {
1166                         s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1167                         s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1168                     }
1169                 }
1170
1171                 draw_slice(s, height);
1172                 break;
1173             }
1174         }
1175     } else {
1176         int y;
1177         int leftr, leftg, leftb, lefta;
1178         const int last_line = (height - 1) * p->linesize[0];
1179
1180         if (s->bitstream_bpp == 32) {
1181             lefta = p->data[0][last_line+A] = get_bits(&s->gb, 8);
1182             leftr = p->data[0][last_line+R] = get_bits(&s->gb, 8);
1183             leftg = p->data[0][last_line+G] = get_bits(&s->gb, 8);
1184             leftb = p->data[0][last_line+B] = get_bits(&s->gb, 8);
1185         } else {
1186             leftr = p->data[0][last_line+R] = get_bits(&s->gb, 8);
1187             leftg = p->data[0][last_line+G] = get_bits(&s->gb, 8);
1188             leftb = p->data[0][last_line+B] = get_bits(&s->gb, 8);
1189             lefta = p->data[0][last_line+A] = 255;
1190             skip_bits(&s->gb, 8);
1191         }
1192
1193         if (s->bgr32) {
1194             switch (s->predictor) {
1195             case LEFT:
1196             case PLANE:
1197                 decode_bgr_bitstream(s, width - 1);
1198                 s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width - 1, &leftr, &leftg, &leftb, &lefta);
1199
1200                 for (y = s->height - 2; y >= 0; y--) { //Yes it is stored upside down.
1201                     decode_bgr_bitstream(s, width);
1202
1203                     s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb, &lefta);
1204                     if (s->predictor == PLANE) {
1205                         if (s->bitstream_bpp != 32) lefta = 0;
1206                         if ((y & s->interlaced) == 0 &&
1207                             y < s->height - 1 - s->interlaced) {
1208                             s->dsp.add_bytes(p->data[0] + p->linesize[0] * y,
1209                                              p->data[0] + p->linesize[0] * y +
1210                                              fake_ystride, fake_ystride);
1211                         }
1212                     }
1213                 }
1214                 // just 1 large slice as this is not possible in reverse order
1215                 draw_slice(s, height);
1216                 break;
1217             default:
1218                 av_log(avctx, AV_LOG_ERROR,
1219                        "prediction type not supported!\n");
1220             }
1221         }else{
1222             av_log(avctx, AV_LOG_ERROR,
1223                    "BGR24 output is not implemented yet\n");
1224             return -1;
1225         }
1226     }
1227     emms_c();
1228
1229     *picture = *p;
1230     *data_size = sizeof(AVFrame);
1231
1232     return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
1233 }
1234 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1235
1236 static int common_end(HYuvContext *s)
1237 {
1238     int i;
1239
1240     for(i = 0; i < 3; i++) {
1241         av_freep(&s->temp[i]);
1242     }
1243     return 0;
1244 }
1245
1246 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
1247 static av_cold int decode_end(AVCodecContext *avctx)
1248 {
1249     HYuvContext *s = avctx->priv_data;
1250     int i;
1251
1252     if (s->picture.data[0])
1253         avctx->release_buffer(avctx, &s->picture);
1254
1255     common_end(s);
1256     av_freep(&s->bitstream_buffer);
1257
1258     for (i = 0; i < 6; i++) {
1259         ff_free_vlc(&s->vlc[i]);
1260     }
1261
1262     return 0;
1263 }
1264 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1265
1266 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
1267 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1268                         const AVFrame *pict, int *got_packet)
1269 {
1270     HYuvContext *s = avctx->priv_data;
1271     const int width = s->width;
1272     const int width2 = s->width>>1;
1273     const int height = s->height;
1274     const int fake_ystride = s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
1275     const int fake_ustride = s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
1276     const int fake_vstride = s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
1277     AVFrame * const p = &s->picture;
1278     int i, j, size = 0, ret;
1279
1280     if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + FF_MIN_BUFFER_SIZE)) < 0)
1281         return ret;
1282
1283     *p = *pict;
1284     p->pict_type = AV_PICTURE_TYPE_I;
1285     p->key_frame = 1;
1286
1287     if (s->context) {
1288         for (i = 0; i < 3; i++) {
1289             ff_huff_gen_len_table(s->len[i], s->stats[i]);
1290             if (generate_bits_table(s->bits[i], s->len[i]) < 0)
1291                 return -1;
1292             size += store_table(s, s->len[i], &pkt->data[size]);
1293         }
1294
1295         for (i = 0; i < 3; i++)
1296             for (j = 0; j < 256; j++)
1297                 s->stats[i][j] >>= 1;
1298     }
1299
1300     init_put_bits(&s->pb, pkt->data + size, pkt->size - size);
1301
1302     if (avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
1303         avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
1304         int lefty, leftu, leftv, y, cy;
1305
1306         put_bits(&s->pb, 8, leftv = p->data[2][0]);
1307         put_bits(&s->pb, 8, lefty = p->data[0][1]);
1308         put_bits(&s->pb, 8, leftu = p->data[1][0]);
1309         put_bits(&s->pb, 8,         p->data[0][0]);
1310
1311         lefty = sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
1312         leftu = sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
1313         leftv = sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
1314
1315         encode_422_bitstream(s, 2, width-2);
1316
1317         if (s->predictor==MEDIAN) {
1318             int lefttopy, lefttopu, lefttopv;
1319             cy = y = 1;
1320             if (s->interlaced) {
1321                 lefty = sub_left_prediction(s, s->temp[0], p->data[0] + p->linesize[0], width , lefty);
1322                 leftu = sub_left_prediction(s, s->temp[1], p->data[1] + p->linesize[1], width2, leftu);
1323                 leftv = sub_left_prediction(s, s->temp[2], p->data[2] + p->linesize[2], width2, leftv);
1324
1325                 encode_422_bitstream(s, 0, width);
1326                 y++; cy++;
1327             }
1328
1329             lefty = sub_left_prediction(s, s->temp[0], p->data[0] + fake_ystride, 4, lefty);
1330             leftu = sub_left_prediction(s, s->temp[1], p->data[1] + fake_ustride, 2, leftu);
1331             leftv = sub_left_prediction(s, s->temp[2], p->data[2] + fake_vstride, 2, leftv);
1332
1333             encode_422_bitstream(s, 0, 4);
1334
1335             lefttopy = p->data[0][3];
1336             lefttopu = p->data[1][1];
1337             lefttopv = p->data[2][1];
1338             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride + 4, width - 4 , &lefty, &lefttopy);
1339             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);
1340             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);
1341             encode_422_bitstream(s, 0, width - 4);
1342             y++; cy++;
1343
1344             for (; y < height; y++,cy++) {
1345                 uint8_t *ydst, *udst, *vdst;
1346
1347                 if (s->bitstream_bpp == 12) {
1348                     while (2 * cy > y) {
1349                         ydst = p->data[0] + p->linesize[0] * y;
1350                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1351                         encode_gray_bitstream(s, width);
1352                         y++;
1353                     }
1354                     if (y >= height) break;
1355                 }
1356                 ydst = p->data[0] + p->linesize[0] * y;
1357                 udst = p->data[1] + p->linesize[1] * cy;
1358                 vdst = p->data[2] + p->linesize[2] * cy;
1359
1360                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1361                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1362                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1363
1364                 encode_422_bitstream(s, 0, width);
1365             }
1366         } else {
1367             for (cy = y = 1; y < height; y++, cy++) {
1368                 uint8_t *ydst, *udst, *vdst;
1369
1370                 /* encode a luma only line & y++ */
1371                 if (s->bitstream_bpp == 12) {
1372                     ydst = p->data[0] + p->linesize[0] * y;
1373
1374                     if (s->predictor == PLANE && s->interlaced < y) {
1375                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1376
1377                         lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1378                     } else {
1379                         lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1380                     }
1381                     encode_gray_bitstream(s, width);
1382                     y++;
1383                     if (y >= height) break;
1384                 }
1385
1386                 ydst = p->data[0] + p->linesize[0] * y;
1387                 udst = p->data[1] + p->linesize[1] * cy;
1388                 vdst = p->data[2] + p->linesize[2] * cy;
1389
1390                 if (s->predictor == PLANE && s->interlaced < cy) {
1391                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1392                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1393                     s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1394
1395                     lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1396                     leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1397                     leftv = sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1398                 } else {
1399                     lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1400                     leftu = sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1401                     leftv = sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1402                 }
1403
1404                 encode_422_bitstream(s, 0, width);
1405             }
1406         }
1407     } else if(avctx->pix_fmt == AV_PIX_FMT_RGB32) {
1408         uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
1409         const int stride = -p->linesize[0];
1410         const int fake_stride = -fake_ystride;
1411         int y;
1412         int leftr, leftg, leftb, lefta;
1413
1414         put_bits(&s->pb, 8, lefta = data[A]);
1415         put_bits(&s->pb, 8, leftr = data[R]);
1416         put_bits(&s->pb, 8, leftg = data[G]);
1417         put_bits(&s->pb, 8, leftb = data[B]);
1418
1419         sub_left_prediction_bgr32(s, s->temp[0], data + 4, width - 1, &leftr, &leftg, &leftb, &lefta);
1420         encode_bgra_bitstream(s, width - 1, 4);
1421
1422         for (y = 1; y < s->height; y++) {
1423             uint8_t *dst = data + y*stride;
1424             if (s->predictor == PLANE && s->interlaced < y) {
1425                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);
1426                 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb, &lefta);
1427             } else {
1428                 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb, &lefta);
1429             }
1430             encode_bgra_bitstream(s, width, 4);
1431         }
1432     }else if(avctx->pix_fmt == AV_PIX_FMT_RGB24){
1433         uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1434         const int stride = -p->linesize[0];
1435         const int fake_stride = -fake_ystride;
1436         int y;
1437         int leftr, leftg, leftb;
1438
1439         put_bits(&s->pb, 8, leftr= data[0]);
1440         put_bits(&s->pb, 8, leftg= data[1]);
1441         put_bits(&s->pb, 8, leftb= data[2]);
1442         put_bits(&s->pb, 8, 0);
1443
1444         sub_left_prediction_rgb24(s, s->temp[0], data+3, width-1, &leftr, &leftg, &leftb);
1445         encode_bgra_bitstream(s, width-1, 3);
1446
1447         for(y=1; y<s->height; y++){
1448             uint8_t *dst = data + y*stride;
1449             if(s->predictor == PLANE && s->interlaced < y){
1450                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*3);
1451                 sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1452             }else{
1453                 sub_left_prediction_rgb24(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1454             }
1455             encode_bgra_bitstream(s, width, 3);
1456         }
1457     } else {
1458         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1459     }
1460     emms_c();
1461
1462     size += (put_bits_count(&s->pb) + 31) / 8;
1463     put_bits(&s->pb, 16, 0);
1464     put_bits(&s->pb, 15, 0);
1465     size /= 4;
1466
1467     if ((s->flags&CODEC_FLAG_PASS1) && (s->picture_number & 31) == 0) {
1468         int j;
1469         char *p = avctx->stats_out;
1470         char *end = p + 1024*30;
1471         for (i = 0; i < 3; i++) {
1472             for (j = 0; j < 256; j++) {
1473                 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1474                 p += strlen(p);
1475                 s->stats[i][j]= 0;
1476             }
1477             snprintf(p, end-p, "\n");
1478             p++;
1479         }
1480     } else
1481         avctx->stats_out[0] = '\0';
1482     if (!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)) {
1483         flush_put_bits(&s->pb);
1484         s->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size);
1485     }
1486
1487     s->picture_number++;
1488
1489     pkt->size   = size * 4;
1490     pkt->flags |= AV_PKT_FLAG_KEY;
1491     *got_packet = 1;
1492
1493     return 0;
1494 }
1495
1496 static av_cold int encode_end(AVCodecContext *avctx)
1497 {
1498     HYuvContext *s = avctx->priv_data;
1499
1500     common_end(s);
1501
1502     av_freep(&avctx->extradata);
1503     av_freep(&avctx->stats_out);
1504
1505     return 0;
1506 }
1507 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
1508
1509 #if CONFIG_HUFFYUV_DECODER
1510 AVCodec ff_huffyuv_decoder = {
1511     .name             = "huffyuv",
1512     .type             = AVMEDIA_TYPE_VIDEO,
1513     .id               = AV_CODEC_ID_HUFFYUV,
1514     .priv_data_size   = sizeof(HYuvContext),
1515     .init             = decode_init,
1516     .close            = decode_end,
1517     .decode           = decode_frame,
1518     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
1519                         CODEC_CAP_FRAME_THREADS,
1520     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1521     .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1522 };
1523 #endif
1524
1525 #if CONFIG_FFVHUFF_DECODER
1526 AVCodec ff_ffvhuff_decoder = {
1527     .name             = "ffvhuff",
1528     .type             = AVMEDIA_TYPE_VIDEO,
1529     .id               = AV_CODEC_ID_FFVHUFF,
1530     .priv_data_size   = sizeof(HYuvContext),
1531     .init             = decode_init,
1532     .close            = decode_end,
1533     .decode           = decode_frame,
1534     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
1535                         CODEC_CAP_FRAME_THREADS,
1536     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1537     .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1538 };
1539 #endif
1540
1541 #if CONFIG_HUFFYUV_ENCODER
1542 AVCodec ff_huffyuv_encoder = {
1543     .name           = "huffyuv",
1544     .type           = AVMEDIA_TYPE_VIDEO,
1545     .id             = AV_CODEC_ID_HUFFYUV,
1546     .priv_data_size = sizeof(HYuvContext),
1547     .init           = encode_init,
1548     .encode2        = encode_frame,
1549     .close          = encode_end,
1550     .pix_fmts       = (const enum AVPixelFormat[]){
1551         AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
1552     },
1553     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1554 };
1555 #endif
1556
1557 #if CONFIG_FFVHUFF_ENCODER
1558 AVCodec ff_ffvhuff_encoder = {
1559     .name           = "ffvhuff",
1560     .type           = AVMEDIA_TYPE_VIDEO,
1561     .id             = AV_CODEC_ID_FFVHUFF,
1562     .priv_data_size = sizeof(HYuvContext),
1563     .init           = encode_init,
1564     .encode2        = encode_frame,
1565     .close          = encode_end,
1566     .pix_fmts       = (const enum AVPixelFormat[]){
1567         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
1568     },
1569     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1570 };
1571 #endif