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