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