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

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