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