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