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     if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P && avctx->width%4) {
 518         av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 this colorspace and predictor\n");
 519         return AVERROR_INVALIDDATA;
 520     }
 521     alloc_temp(s);
 522
 523     return 0;
 524 }
 525
 526 static av_cold int decode_init_thread_copy(AVCodecContext *avctx)
 527 {
 528     HYuvContext *s = avctx->priv_data;
 529     int i;
 530
 531     avctx->coded_frame= &s->picture;
 532     alloc_temp(s);
 533
 534     for (i = 0; i < 6; i++)
 535         s->vlc[i].table = NULL;
 536
 537     if (s->version == 2) {
 538         if (read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
 539                                 avctx->extradata_size) < 0)
 540             return -1;
 541     } else {
 542         if (read_old_huffman_tables(s) < 0)
 543             return -1;
 544     }
 545
 546     return 0;
 547 }
 548 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
 549
 550 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
 551 static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)
 552 {
 553     int i;
 554     int index = 0;
 555
 556     for (i = 0; i < 256;) {
 557         int val = len[i];
 558         int repeat = 0;
 559
 560         for (; i < 256 && len[i] == val && repeat < 255; i++)
 561             repeat++;
 562
 563         av_assert0(val < 32 && val >0 && repeat<256 && repeat>0);
 564         if (repeat > 7) {
 565             buf[index++] = val;
 566             buf[index++] = repeat;
 567         } else {
 568             buf[index++] = val | (repeat << 5);
 569         }
 570     }
 571
 572     return index;
 573 }
 574
 575 static av_cold int encode_init(AVCodecContext *avctx)
 576 {
 577     HYuvContext *s = avctx->priv_data;
 578     int i, j;
 579
 580     common_init(avctx);
 581
 582     avctx->extradata = av_mallocz(1024*30); // 256*3+4 == 772
 583     avctx->stats_out = av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
 584     s->version = 2;
 585
 586     avctx->coded_frame = &s->picture;
 587
 588     switch (avctx->pix_fmt) {
 589     case AV_PIX_FMT_YUV420P:
 590     case AV_PIX_FMT_YUV422P:
 591         if (s->width & 1) {
 592             av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
 593             return AVERROR(EINVAL);
 594         }
 595         s->bitstream_bpp = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? 12 : 16;
 596         break;
 597     case AV_PIX_FMT_RGB32:
 598         s->bitstream_bpp = 32;
 599         break;
 600     case AV_PIX_FMT_RGB24:
 601         s->bitstream_bpp = 24;
 602         break;
 603     default:
 604         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 605         return -1;
 606     }
 607     avctx->bits_per_coded_sample = s->bitstream_bpp;
 608     s->decorrelate = s->bitstream_bpp >= 24;
 609     s->predictor = avctx->prediction_method;
 610     s->interlaced = avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
 611     if (avctx->context_model == 1) {
 612         s->context = avctx->context_model;
 613         if (s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) {
 614             av_log(avctx, AV_LOG_ERROR,
 615                    "context=1 is not compatible with "
 616                    "2 pass huffyuv encoding\n");
 617             return -1;
 618         }
 619     }else s->context= 0;
 620
 621     if (avctx->codec->id == AV_CODEC_ID_HUFFYUV) {
 622         if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
 623             av_log(avctx, AV_LOG_ERROR,
 624                    "Error: YV12 is not supported by huffyuv; use "
 625                    "vcodec=ffvhuff or format=422p\n");
 626             return -1;
 627         }
 628         if (avctx->context_model) {
 629             av_log(avctx, AV_LOG_ERROR,
 630                    "Error: per-frame huffman tables are not supported "
 631                    "by huffyuv; use vcodec=ffvhuff\n");
 632             return -1;
 633         }
 634         if (s->interlaced != ( s->height > 288 ))
 635             av_log(avctx, AV_LOG_INFO,
 636                    "using huffyuv 2.2.0 or newer interlacing flag\n");
 637     }
 638
 639     if (s->bitstream_bpp >= 24 && s->predictor == MEDIAN) {
 640         av_log(avctx, AV_LOG_ERROR,
 641                "Error: RGB is incompatible with median predictor\n");
 642         return -1;
 643     }
 644
 645     ((uint8_t*)avctx->extradata)[0] = s->predictor | (s->decorrelate << 6);
 646     ((uint8_t*)avctx->extradata)[1] = s->bitstream_bpp;
 647     ((uint8_t*)avctx->extradata)[2] = s->interlaced ? 0x10 : 0x20;
 648     if (s->context)
 649         ((uint8_t*)avctx->extradata)[2] |= 0x40;
 650     ((uint8_t*)avctx->extradata)[3] = 0;
 651     s->avctx->extradata_size = 4;
 652
 653     if (avctx->stats_in) {
 654         char *p = avctx->stats_in;
 655
 656         for (i = 0; i < 3; i++)
 657             for (j = 0; j < 256; j++)
 658                 s->stats[i][j] = 1;
 659
 660         for (;;) {
 661             for (i = 0; i < 3; i++) {
 662                 char *next;
 663
 664                 for (j = 0; j < 256; j++) {
 665                     s->stats[i][j] += strtol(p, &next, 0);
 666                     if (next == p) return -1;
 667                     p = next;
 668                 }
 669             }
 670             if (p[0] == 0 || p[1] == 0 || p[2] == 0) break;
 671         }
 672     } else {
 673         for (i = 0; i < 3; i++)
 674             for (j = 0; j < 256; j++) {
 675                 int d = FFMIN(j, 256 - j);
 676
 677                 s->stats[i][j] = 100000000 / (d + 1);
 678             }
 679     }
 680
 681     for (i = 0; i < 3; i++) {
 682         ff_huff_gen_len_table(s->len[i], s->stats[i]);
 683
 684         if (generate_bits_table(s->bits[i], s->len[i]) < 0) {
 685             return -1;
 686         }
 687
 688         s->avctx->extradata_size +=
 689             store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
 690     }
 691
 692     if (s->context) {
 693         for (i = 0; i < 3; i++) {
 694             int pels = s->width * s->height / (i ? 40 : 10);
 695             for (j = 0; j < 256; j++) {
 696                 int d = FFMIN(j, 256 - j);
 697                 s->stats[i][j] = pels/(d + 1);
 698             }
 699         }
 700     } else {
 701         for (i = 0; i < 3; i++)
 702             for (j = 0; j < 256; j++)
 703                 s->stats[i][j]= 0;
 704     }
 705
 706     alloc_temp(s);
 707
 708     s->picture_number=0;
 709
 710     return 0;
 711 }
 712 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
 713
 714 /* TODO instead of restarting the read when the code isn't in the first level
 715  * of the joint table, jump into the 2nd level of the individual table. */
 716 #define READ_2PIX(dst0, dst1, plane1){\
 717     uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
 718     if(code != 0xffff){\
 719         dst0 = code>>8;\
 720         dst1 = code;\
 721     }else{\
 722         dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
 723         dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
 724     }\
 725 }
 726
 727 static void decode_422_bitstream(HYuvContext *s, int count)
 728 {
 729     int i;
 730
 731     count /= 2;
 732
 733     if (count >= (get_bits_left(&s->gb)) / (31 * 4)) {
 734         for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
 735             READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);
 736             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
 737         }
 738     } else {
 739         for (i = 0; i < count; i++) {
 740             READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);
 741             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
 742         }
 743     }
 744 }
 745
 746 static void decode_gray_bitstream(HYuvContext *s, int count)
 747 {
 748     int i;
 749
 750     count/=2;
 751
 752     if (count >= (get_bits_left(&s->gb)) / (31 * 2)) {
 753         for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
 754             READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
 755         }
 756     } else {
 757         for(i=0; i<count; i++){
 758             READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
 759         }
 760     }
 761 }
 762
 763 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
 764 static int encode_422_bitstream(HYuvContext *s, int offset, int count)
 765 {
 766     int i;
 767     const uint8_t *y = s->temp[0] + offset;
 768     const uint8_t *u = s->temp[1] + offset / 2;
 769     const uint8_t *v = s->temp[2] + offset / 2;
 770
 771     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 2 * 4 * count) {
 772         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 773         return -1;
 774     }
 775
 776 #define LOAD4\
 777             int y0 = y[2 * i];\
 778             int y1 = y[2 * i + 1];\
 779             int u0 = u[i];\
 780             int v0 = v[i];
 781
 782     count /= 2;
 783
 784     if (s->flags & CODEC_FLAG_PASS1) {
 785         for(i = 0; i < count; i++) {
 786             LOAD4;
 787             s->stats[0][y0]++;
 788             s->stats[1][u0]++;
 789             s->stats[0][y1]++;
 790             s->stats[2][v0]++;
 791         }
 792     }
 793     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)
 794         return 0;
 795     if (s->context) {
 796         for (i = 0; i < count; i++) {
 797             LOAD4;
 798             s->stats[0][y0]++;
 799             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
 800             s->stats[1][u0]++;
 801             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
 802             s->stats[0][y1]++;
 803             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
 804             s->stats[2][v0]++;
 805             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
 806         }
 807     } else {
 808         for(i = 0; i < count; i++) {
 809             LOAD4;
 810             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
 811             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
 812             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
 813             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
 814         }
 815     }
 816     return 0;
 817 }
 818
 819 static int encode_gray_bitstream(HYuvContext *s, int count)
 820 {
 821     int i;
 822
 823     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 4 * count) {
 824         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 825         return -1;
 826     }
 827
 828 #define LOAD2\
 829             int y0 = s->temp[0][2 * i];\
 830             int y1 = s->temp[0][2 * i + 1];
 831 #define STAT2\
 832             s->stats[0][y0]++;\
 833             s->stats[0][y1]++;
 834 #define WRITE2\
 835             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
 836             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
 837
 838     count /= 2;
 839
 840     if (s->flags & CODEC_FLAG_PASS1) {
 841         for (i = 0; i < count; i++) {
 842             LOAD2;
 843             STAT2;
 844         }
 845     }
 846     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)
 847         return 0;
 848
 849     if (s->context) {
 850         for (i = 0; i < count; i++) {
 851             LOAD2;
 852             STAT2;
 853             WRITE2;
 854         }
 855     } else {
 856         for (i = 0; i < count; i++) {
 857             LOAD2;
 858             WRITE2;
 859         }
 860     }
 861     return 0;
 862 }
 863 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
 864
 865 static av_always_inline void decode_bgr_1(HYuvContext *s, int count,
 866                                           int decorrelate, int alpha)
 867 {
 868     int i;
 869     for (i = 0; i < count; i++) {
 870         int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
 871         if (code != -1) {
 872             *(uint32_t*)&s->temp[0][4 * i] = s->pix_bgr_map[code];
 873         } else if(decorrelate) {
 874             s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 875             s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) +
 876                                     s->temp[0][4 * i + G];
 877             s->temp[0][4 * i + R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) +
 878                                     s->temp[0][4 * i + G];
 879         } else {
 880             s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 881             s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 882             s->temp[0][4 * i + R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 883         }
 884         if (alpha)
 885             s->temp[0][4 * i + A] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 886     }
 887 }
 888
 889 static void decode_bgr_bitstream(HYuvContext *s, int count)
 890 {
 891     if (s->decorrelate) {
 892         if (s->bitstream_bpp==24)
 893             decode_bgr_1(s, count, 1, 0);
 894         else
 895             decode_bgr_1(s, count, 1, 1);
 896     } else {
 897         if (s->bitstream_bpp==24)
 898             decode_bgr_1(s, count, 0, 0);
 899         else
 900             decode_bgr_1(s, count, 0, 1);
 901     }
 902 }
 903
 904 static inline int encode_bgra_bitstream(HYuvContext *s, int count, int planes)
 905 {
 906     int i;
 907
 908     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*planes*count) {
 909         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 910         return -1;
 911     }
 912
 913 #define LOAD3\
 914             int g =  s->temp[0][planes==3 ? 3*i + 1 : 4*i + G];\
 915             int b = (s->temp[0][planes==3 ? 3*i + 2 : 4*i + B] - g) & 0xff;\
 916             int r = (s->temp[0][planes==3 ? 3*i + 0 : 4*i + R] - g) & 0xff;\
 917             int a =  s->temp[0][planes*i + A];
 918 #define STAT3\
 919             s->stats[0][b]++;\
 920             s->stats[1][g]++;\
 921             s->stats[2][r]++;\
 922             if(planes==4) s->stats[2][a]++;
 923 #define WRITE3\
 924             put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
 925             put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
 926             put_bits(&s->pb, s->len[2][r], s->bits[2][r]);\
 927             if(planes==4) put_bits(&s->pb, s->len[2][a], s->bits[2][a]);
 928
 929     if ((s->flags & CODEC_FLAG_PASS1) &&
 930         (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)) {
 931         for (i = 0; i < count; i++) {
 932             LOAD3;
 933             STAT3;
 934         }
 935     } else if (s->context || (s->flags & CODEC_FLAG_PASS1)) {
 936         for (i = 0; i < count; i++) {
 937             LOAD3;
 938             STAT3;
 939             WRITE3;
 940         }
 941     } else {
 942         for (i = 0; i < count; i++) {
 943             LOAD3;
 944             WRITE3;
 945         }
 946     }
 947     return 0;
 948 }
 949
 950 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
 951 static void draw_slice(HYuvContext *s, int y)
 952 {
 953     int h, cy, i;
 954     int offset[AV_NUM_DATA_POINTERS];
 955
 956     if (s->avctx->draw_horiz_band==NULL)
 957         return;
 958
 959     h = y - s->last_slice_end;
 960     y -= h;
 961
 962     if (s->bitstream_bpp == 12) {
 963         cy = y>>1;
 964     } else {
 965         cy = y;
 966     }
 967
 968     offset[0] = s->picture.linesize[0]*y;
 969     offset[1] = s->picture.linesize[1]*cy;
 970     offset[2] = s->picture.linesize[2]*cy;
 971     for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
 972         offset[i] = 0;
 973     emms_c();
 974
 975     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
 976
 977     s->last_slice_end = y + h;
 978 }
 979
 980 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 981                         AVPacket *avpkt)
 982 {
 983     const uint8_t *buf = avpkt->data;
 984     int buf_size = avpkt->size;
 985     HYuvContext *s = avctx->priv_data;
 986     const int width = s->width;
 987     const int width2 = s->width>>1;
 988     const int height = s->height;
 989     int fake_ystride, fake_ustride, fake_vstride;
 990     AVFrame * const p = &s->picture;
 991     int table_size = 0;
 992
 993     AVFrame *picture = data;
 994
 995     av_fast_malloc(&s->bitstream_buffer,
 996                    &s->bitstream_buffer_size,
 997                    buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 998     if (!s->bitstream_buffer)
 999         return AVERROR(ENOMEM);
1000
1001     memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1002     s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer,
1003                      (const uint32_t*)buf, buf_size / 4);
1004
1005     if (p->data[0])
1006         ff_thread_release_buffer(avctx, p);
1007
1008     p->reference = 0;
1009     if (ff_thread_get_buffer(avctx, p) < 0) {
1010         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1011         return -1;
1012     }
1013
1014     if (s->context) {
1015         table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
1016         if (table_size < 0)
1017             return -1;
1018     }
1019
1020     if ((unsigned)(buf_size-table_size) >= INT_MAX / 8)
1021         return -1;
1022
1023     init_get_bits(&s->gb, s->bitstream_buffer+table_size,
1024                   (buf_size-table_size) * 8);
1025
1026     fake_ystride = s->interlaced ? p->linesize[0] * 2  : p->linesize[0];
1027     fake_ustride = s->interlaced ? p->linesize[1] * 2  : p->linesize[1];
1028     fake_vstride = s->interlaced ? p->linesize[2] * 2  : p->linesize[2];
1029
1030     s->last_slice_end = 0;
1031
1032     if (s->bitstream_bpp < 24) {
1033         int y, cy;
1034         int lefty, leftu, leftv;
1035         int lefttopy, lefttopu, lefttopv;
1036
1037         if (s->yuy2) {
1038             p->data[0][3] = get_bits(&s->gb, 8);
1039             p->data[0][2] = get_bits(&s->gb, 8);
1040             p->data[0][1] = get_bits(&s->gb, 8);
1041             p->data[0][0] = get_bits(&s->gb, 8);
1042
1043             av_log(avctx, AV_LOG_ERROR,
1044                    "YUY2 output is not implemented yet\n");
1045             return -1;
1046         } else {
1047
1048             leftv = p->data[2][0] = get_bits(&s->gb, 8);
1049             lefty = p->data[0][1] = get_bits(&s->gb, 8);
1050             leftu = p->data[1][0] = get_bits(&s->gb, 8);
1051                     p->data[0][0] = get_bits(&s->gb, 8);
1052
1053             switch (s->predictor) {
1054             case LEFT:
1055             case PLANE:
1056                 decode_422_bitstream(s, width-2);
1057                 lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1058                 if (!(s->flags&CODEC_FLAG_GRAY)) {
1059                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1060                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1061                 }
1062
1063                 for (cy = y = 1; y < s->height; y++, cy++) {
1064                     uint8_t *ydst, *udst, *vdst;
1065
1066                     if (s->bitstream_bpp == 12) {
1067                         decode_gray_bitstream(s, width);
1068
1069                         ydst = p->data[0] + p->linesize[0] * y;
1070
1071                         lefty = s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
1072                         if (s->predictor == PLANE) {
1073                             if (y > s->interlaced)
1074                                 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1075                         }
1076                         y++;
1077                         if (y >= s->height) break;
1078                     }
1079
1080                     draw_slice(s, y);
1081
1082                     ydst = p->data[0] + p->linesize[0]*y;
1083                     udst = p->data[1] + p->linesize[1]*cy;
1084                     vdst = p->data[2] + p->linesize[2]*cy;
1085
1086                     decode_422_bitstream(s, width);
1087                     lefty = s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
1088                     if (!(s->flags & CODEC_FLAG_GRAY)) {
1089                         leftu= s->dsp.add_hfyu_left_prediction(udst, s->temp[1], width2, leftu);
1090                         leftv= s->dsp.add_hfyu_left_prediction(vdst, s->temp[2], width2, leftv);
1091                     }
1092                     if (s->predictor == PLANE) {
1093                         if (cy > s->interlaced) {
1094                             s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1095                             if (!(s->flags & CODEC_FLAG_GRAY)) {
1096                                 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1097                                 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1098                             }
1099                         }
1100                     }
1101                 }
1102                 draw_slice(s, height);
1103
1104                 break;
1105             case MEDIAN:
1106                 /* first line except first 2 pixels is left predicted */
1107                 decode_422_bitstream(s, width - 2);
1108                 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width - 2, lefty);
1109                 if (!(s->flags & CODEC_FLAG_GRAY)) {
1110                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1111                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1112                 }
1113
1114                 cy = y = 1;
1115
1116                 /* second line is left predicted for interlaced case */
1117                 if (s->interlaced) {
1118                     decode_422_bitstream(s, width);
1119                     lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1120                     if (!(s->flags & CODEC_FLAG_GRAY)) {
1121                         leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1122                         leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1123                     }
1124                     y++; cy++;
1125                 }
1126
1127                 /* next 4 pixels are left predicted too */
1128                 decode_422_bitstream(s, 4);
1129                 lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1130                 if (!(s->flags&CODEC_FLAG_GRAY)) {
1131                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1132                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1133                 }
1134
1135                 /* next line except the first 4 pixels is median predicted */
1136                 lefttopy = p->data[0][3];
1137                 decode_422_bitstream(s, width - 4);
1138                 s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1139                 if (!(s->flags&CODEC_FLAG_GRAY)) {
1140                     lefttopu = p->data[1][1];
1141                     lefttopv = p->data[2][1];
1142                     s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
1143                     s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
1144                 }
1145                 y++; cy++;
1146
1147                 for (; y<height; y++, cy++) {
1148                     uint8_t *ydst, *udst, *vdst;
1149
1150                     if (s->bitstream_bpp == 12) {
1151                         while (2 * cy > y) {
1152                             decode_gray_bitstream(s, width);
1153                             ydst = p->data[0] + p->linesize[0] * y;
1154                             s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1155                             y++;
1156                         }
1157                         if (y >= height) break;
1158                     }
1159                     draw_slice(s, y);
1160
1161                     decode_422_bitstream(s, width);
1162
1163                     ydst = p->data[0] + p->linesize[0] * y;
1164                     udst = p->data[1] + p->linesize[1] * cy;
1165                     vdst = p->data[2] + p->linesize[2] * cy;
1166
1167                     s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1168                     if (!(s->flags & CODEC_FLAG_GRAY)) {
1169                         s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1170                         s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1171                     }
1172                 }
1173
1174                 draw_slice(s, height);
1175                 break;
1176             }
1177         }
1178     } else {
1179         int y;
1180         int leftr, leftg, leftb, lefta;
1181         const int last_line = (height - 1) * p->linesize[0];
1182
1183         if (s->bitstream_bpp == 32) {
1184             lefta = p->data[0][last_line+A] = get_bits(&s->gb, 8);
1185             leftr = p->data[0][last_line+R] = get_bits(&s->gb, 8);
1186             leftg = p->data[0][last_line+G] = get_bits(&s->gb, 8);
1187             leftb = p->data[0][last_line+B] = get_bits(&s->gb, 8);
1188         } else {
1189             leftr = p->data[0][last_line+R] = get_bits(&s->gb, 8);
1190             leftg = p->data[0][last_line+G] = get_bits(&s->gb, 8);
1191             leftb = p->data[0][last_line+B] = get_bits(&s->gb, 8);
1192             lefta = p->data[0][last_line+A] = 255;
1193             skip_bits(&s->gb, 8);
1194         }
1195
1196         if (s->bgr32) {
1197             switch (s->predictor) {
1198             case LEFT:
1199             case PLANE:
1200                 decode_bgr_bitstream(s, width - 1);
1201                 s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width - 1, &leftr, &leftg, &leftb, &lefta);
1202
1203                 for (y = s->height - 2; y >= 0; y--) { //Yes it is stored upside down.
1204                     decode_bgr_bitstream(s, width);
1205
1206                     s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb, &lefta);
1207                     if (s->predictor == PLANE) {
1208                         if (s->bitstream_bpp != 32) lefta = 0;
1209                         if ((y & s->interlaced) == 0 &&
1210                             y < s->height - 1 - s->interlaced) {
1211                             s->dsp.add_bytes(p->data[0] + p->linesize[0] * y,
1212                                              p->data[0] + p->linesize[0] * y +
1213                                              fake_ystride, fake_ystride);
1214                         }
1215                     }
1216                 }
1217                 // just 1 large slice as this is not possible in reverse order
1218                 draw_slice(s, height);
1219                 break;
1220             default:
1221                 av_log(avctx, AV_LOG_ERROR,
1222                        "prediction type not supported!\n");
1223             }
1224         }else{
1225             av_log(avctx, AV_LOG_ERROR,
1226                    "BGR24 output is not implemented yet\n");
1227             return -1;
1228         }
1229     }
1230     emms_c();
1231
1232     *picture = *p;
1233     *got_frame = 1;
1234
1235     return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
1236 }
1237 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1238
1239 static int common_end(HYuvContext *s)
1240 {
1241     int i;
1242
1243     for(i = 0; i < 3; i++) {
1244         av_freep(&s->temp[i]);
1245     }
1246     return 0;
1247 }
1248
1249 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
1250 static av_cold int decode_end(AVCodecContext *avctx)
1251 {
1252     HYuvContext *s = avctx->priv_data;
1253     int i;
1254
1255     if (s->picture.data[0])
1256         avctx->release_buffer(avctx, &s->picture);
1257
1258     common_end(s);
1259     av_freep(&s->bitstream_buffer);
1260
1261     for (i = 0; i < 6; i++) {
1262         ff_free_vlc(&s->vlc[i]);
1263     }
1264
1265     return 0;
1266 }
1267 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1268
1269 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
1270 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1271                         const AVFrame *pict, int *got_packet)
1272 {
1273     HYuvContext *s = avctx->priv_data;
1274     const int width = s->width;
1275     const int width2 = s->width>>1;
1276     const int height = s->height;
1277     const int fake_ystride = s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
1278     const int fake_ustride = s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
1279     const int fake_vstride = s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
1280     AVFrame * const p = &s->picture;
1281     int i, j, size = 0, ret;
1282
1283     if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + FF_MIN_BUFFER_SIZE)) < 0)
1284         return ret;
1285
1286     *p = *pict;
1287     p->pict_type = AV_PICTURE_TYPE_I;
1288     p->key_frame = 1;
1289
1290     if (s->context) {
1291         for (i = 0; i < 3; i++) {
1292             ff_huff_gen_len_table(s->len[i], s->stats[i]);
1293             if (generate_bits_table(s->bits[i], s->len[i]) < 0)
1294                 return -1;
1295             size += store_table(s, s->len[i], &pkt->data[size]);
1296         }
1297
1298         for (i = 0; i < 3; i++)
1299             for (j = 0; j < 256; j++)
1300                 s->stats[i][j] >>= 1;
1301     }
1302
1303     init_put_bits(&s->pb, pkt->data + size, pkt->size - size);
1304
1305     if (avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
1306         avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
1307         int lefty, leftu, leftv, y, cy;
1308
1309         put_bits(&s->pb, 8, leftv = p->data[2][0]);
1310         put_bits(&s->pb, 8, lefty = p->data[0][1]);
1311         put_bits(&s->pb, 8, leftu = p->data[1][0]);
1312         put_bits(&s->pb, 8,         p->data[0][0]);
1313
1314         lefty = sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
1315         leftu = sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
1316         leftv = sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
1317
1318         encode_422_bitstream(s, 2, width-2);
1319
1320         if (s->predictor==MEDIAN) {
1321             int lefttopy, lefttopu, lefttopv;
1322             cy = y = 1;
1323             if (s->interlaced) {
1324                 lefty = sub_left_prediction(s, s->temp[0], p->data[0] + p->linesize[0], width , lefty);
1325                 leftu = sub_left_prediction(s, s->temp[1], p->data[1] + p->linesize[1], width2, leftu);
1326                 leftv = sub_left_prediction(s, s->temp[2], p->data[2] + p->linesize[2], width2, leftv);
1327
1328                 encode_422_bitstream(s, 0, width);
1329                 y++; cy++;
1330             }
1331
1332             lefty = sub_left_prediction(s, s->temp[0], p->data[0] + fake_ystride, 4, lefty);
1333             leftu = sub_left_prediction(s, s->temp[1], p->data[1] + fake_ustride, 2, leftu);
1334             leftv = sub_left_prediction(s, s->temp[2], p->data[2] + fake_vstride, 2, leftv);
1335
1336             encode_422_bitstream(s, 0, 4);
1337
1338             lefttopy = p->data[0][3];
1339             lefttopu = p->data[1][1];
1340             lefttopv = p->data[2][1];
1341             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride + 4, width - 4 , &lefty, &lefttopy);
1342             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);
1343             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);
1344             encode_422_bitstream(s, 0, width - 4);
1345             y++; cy++;
1346
1347             for (; y < height; y++,cy++) {
1348                 uint8_t *ydst, *udst, *vdst;
1349
1350                 if (s->bitstream_bpp == 12) {
1351                     while (2 * cy > y) {
1352                         ydst = p->data[0] + p->linesize[0] * y;
1353                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1354                         encode_gray_bitstream(s, width);
1355                         y++;
1356                     }
1357                     if (y >= height) break;
1358                 }
1359                 ydst = p->data[0] + p->linesize[0] * y;
1360                 udst = p->data[1] + p->linesize[1] * cy;
1361                 vdst = p->data[2] + p->linesize[2] * cy;
1362
1363                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1364                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1365                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1366
1367                 encode_422_bitstream(s, 0, width);
1368             }
1369         } else {
1370             for (cy = y = 1; y < height; y++, cy++) {
1371                 uint8_t *ydst, *udst, *vdst;
1372
1373                 /* encode a luma only line & y++ */
1374                 if (s->bitstream_bpp == 12) {
1375                     ydst = p->data[0] + p->linesize[0] * y;
1376
1377                     if (s->predictor == PLANE && s->interlaced < y) {
1378                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1379
1380                         lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1381                     } else {
1382                         lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1383                     }
1384                     encode_gray_bitstream(s, width);
1385                     y++;
1386                     if (y >= height) break;
1387                 }
1388
1389                 ydst = p->data[0] + p->linesize[0] * y;
1390                 udst = p->data[1] + p->linesize[1] * cy;
1391                 vdst = p->data[2] + p->linesize[2] * cy;
1392
1393                 if (s->predictor == PLANE && s->interlaced < cy) {
1394                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1395                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1396                     s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1397
1398                     lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1399                     leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1400                     leftv = sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1401                 } else {
1402                     lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1403                     leftu = sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1404                     leftv = sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1405                 }
1406
1407                 encode_422_bitstream(s, 0, width);
1408             }
1409         }
1410     } else if(avctx->pix_fmt == AV_PIX_FMT_RGB32) {
1411         uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
1412         const int stride = -p->linesize[0];
1413         const int fake_stride = -fake_ystride;
1414         int y;
1415         int leftr, leftg, leftb, lefta;
1416
1417         put_bits(&s->pb, 8, lefta = data[A]);
1418         put_bits(&s->pb, 8, leftr = data[R]);
1419         put_bits(&s->pb, 8, leftg = data[G]);
1420         put_bits(&s->pb, 8, leftb = data[B]);
1421
1422         sub_left_prediction_bgr32(s, s->temp[0], data + 4, width - 1, &leftr, &leftg, &leftb, &lefta);
1423         encode_bgra_bitstream(s, width - 1, 4);
1424
1425         for (y = 1; y < s->height; y++) {
1426             uint8_t *dst = data + y*stride;
1427             if (s->predictor == PLANE && s->interlaced < y) {
1428                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);
1429                 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb, &lefta);
1430             } else {
1431                 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb, &lefta);
1432             }
1433             encode_bgra_bitstream(s, width, 4);
1434         }
1435     }else if(avctx->pix_fmt == AV_PIX_FMT_RGB24){
1436         uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1437         const int stride = -p->linesize[0];
1438         const int fake_stride = -fake_ystride;
1439         int y;
1440         int leftr, leftg, leftb;
1441
1442         put_bits(&s->pb, 8, leftr= data[0]);
1443         put_bits(&s->pb, 8, leftg= data[1]);
1444         put_bits(&s->pb, 8, leftb= data[2]);
1445         put_bits(&s->pb, 8, 0);
1446
1447         sub_left_prediction_rgb24(s, s->temp[0], data+3, width-1, &leftr, &leftg, &leftb);
1448         encode_bgra_bitstream(s, width-1, 3);
1449
1450         for(y=1; y<s->height; y++){
1451             uint8_t *dst = data + y*stride;
1452             if(s->predictor == PLANE && s->interlaced < y){
1453                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*3);
1454                 sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1455             }else{
1456                 sub_left_prediction_rgb24(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1457             }
1458             encode_bgra_bitstream(s, width, 3);
1459         }
1460     } else {
1461         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1462     }
1463     emms_c();
1464
1465     size += (put_bits_count(&s->pb) + 31) / 8;
1466     put_bits(&s->pb, 16, 0);
1467     put_bits(&s->pb, 15, 0);
1468     size /= 4;
1469
1470     if ((s->flags&CODEC_FLAG_PASS1) && (s->picture_number & 31) == 0) {
1471         int j;
1472         char *p = avctx->stats_out;
1473         char *end = p + 1024*30;
1474         for (i = 0; i < 3; i++) {
1475             for (j = 0; j < 256; j++) {
1476                 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1477                 p += strlen(p);
1478                 s->stats[i][j]= 0;
1479             }
1480             snprintf(p, end-p, "\n");
1481             p++;
1482         }
1483     } else
1484         avctx->stats_out[0] = '\0';
1485     if (!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)) {
1486         flush_put_bits(&s->pb);
1487         s->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size);
1488     }
1489
1490     s->picture_number++;
1491
1492     pkt->size   = size * 4;
1493     pkt->flags |= AV_PKT_FLAG_KEY;
1494     *got_packet = 1;
1495
1496     return 0;
1497 }
1498
1499 static av_cold int encode_end(AVCodecContext *avctx)
1500 {
1501     HYuvContext *s = avctx->priv_data;
1502
1503     common_end(s);
1504
1505     av_freep(&avctx->extradata);
1506     av_freep(&avctx->stats_out);
1507
1508     return 0;
1509 }
1510 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
1511
1512 #if CONFIG_HUFFYUV_DECODER
1513 AVCodec ff_huffyuv_decoder = {
1514     .name             = "huffyuv",
1515     .type             = AVMEDIA_TYPE_VIDEO,
1516     .id               = AV_CODEC_ID_HUFFYUV,
1517     .priv_data_size   = sizeof(HYuvContext),
1518     .init             = decode_init,
1519     .close            = decode_end,
1520     .decode           = decode_frame,
1521     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
1522                         CODEC_CAP_FRAME_THREADS,
1523     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1524     .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1525 };
1526 #endif
1527
1528 #if CONFIG_FFVHUFF_DECODER
1529 AVCodec ff_ffvhuff_decoder = {
1530     .name             = "ffvhuff",
1531     .type             = AVMEDIA_TYPE_VIDEO,
1532     .id               = AV_CODEC_ID_FFVHUFF,
1533     .priv_data_size   = sizeof(HYuvContext),
1534     .init             = decode_init,
1535     .close            = decode_end,
1536     .decode           = decode_frame,
1537     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
1538                         CODEC_CAP_FRAME_THREADS,
1539     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1540     .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1541 };
1542 #endif
1543
1544 #if CONFIG_HUFFYUV_ENCODER
1545 AVCodec ff_huffyuv_encoder = {
1546     .name           = "huffyuv",
1547     .type           = AVMEDIA_TYPE_VIDEO,
1548     .id             = AV_CODEC_ID_HUFFYUV,
1549     .priv_data_size = sizeof(HYuvContext),
1550     .init           = encode_init,
1551     .encode2        = encode_frame,
1552     .close          = encode_end,
1553     .pix_fmts       = (const enum AVPixelFormat[]){
1554         AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
1555     },
1556     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1557 };
1558 #endif
1559
1560 #if CONFIG_FFVHUFF_ENCODER
1561 AVCodec ff_ffvhuff_encoder = {
1562     .name           = "ffvhuff",
1563     .type           = AVMEDIA_TYPE_VIDEO,
1564     .id             = AV_CODEC_ID_FFVHUFF,
1565     .priv_data_size = sizeof(HYuvContext),
1566     .init           = encode_init,
1567     .encode2        = encode_frame,
1568     .close          = encode_end,
1569     .pix_fmts       = (const enum AVPixelFormat[]){
1570         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
1571     },
1572     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1573 };
1574 #endif