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 library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
  21  * the algorithm used
  22  */
  23
  24 /**
  25  * @file huffyuv.c
  26  * huffyuv codec for libavcodec.
  27  */
  28
  29 #include "common.h"
  30 #include "avcodec.h"
  31 #include "dsputil.h"
  32
  33 #define VLC_BITS 11
  34
  35 typedef enum Predictor{
  36     LEFT= 0,
  37     PLANE,
  38     MEDIAN,
  39 } Predictor;
  40
  41 typedef struct HYuvContext{
  42     AVCodecContext *avctx;
  43     Predictor predictor;
  44     GetBitContext gb;
  45     PutBitContext pb;
  46     int interlaced;
  47     int decorrelate;
  48     int bitstream_bpp;
  49     int version;
  50     int yuy2;                               //use yuy2 instead of 422P
  51     int bgr32;                              //use bgr32 instead of bgr24
  52     int width, height;
  53     int flags;
  54     int picture_number;
  55     int last_slice_end;
  56     uint8_t __align8 temp[3][2560];
  57     uint64_t stats[3][256];
  58     uint8_t len[3][256];
  59     uint32_t bits[3][256];
  60     VLC vlc[3];
  61     AVFrame picture;
  62     uint8_t __align8 bitstream_buffer[1024*1024*3]; //FIXME dynamic alloc or some other solution
  63     DSPContext dsp;
  64 }HYuvContext;
  65
  66 static const unsigned char classic_shift_luma[] = {
  67   34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
  68   16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
  69   69,68, 0
  70 };
  71
  72 static const unsigned char classic_shift_chroma[] = {
  73   66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
  74   56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
  75   214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
  76 };
  77
  78 static const unsigned char classic_add_luma[256] = {
  79     3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
  80    73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
  81    68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
  82    35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
  83    37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
  84    35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
  85    27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
  86    15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
  87    12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
  88    12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
  89    18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
  90    28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
  91    28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
  92    62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
  93    54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
  94    46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
  95 };
  96
  97 static const unsigned char classic_add_chroma[256] = {
  98     3,  1,  2,  2,  2,  2,  3,  3,  7,  5,  7,  5,  8,  6, 11,  9,
  99     7, 13, 11, 10,  9,  8,  7,  5,  9,  7,  6,  4,  7,  5,  8,  7,
 100    11,  8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
 101    43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
 102   143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 103    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
 104    17, 14,  5,  6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
 105   112,113,114,115,  4,117,118, 92, 94,121,122,  3,124,103,  2,  1,
 106     0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
 107   135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
 108    52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
 109    19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10,  9,  8, 36,
 110     7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
 111    83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
 112    14, 16, 17, 18, 20, 21, 12, 14, 15,  9, 10,  6,  9,  6,  5,  8,
 113     6, 12,  8, 10,  7,  9,  6,  4,  6,  2,  2,  3,  3,  3,  3,  2,
 114 };
 115
 116 static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
 117     int i;
 118
 119     for(i=0; i<w-1; i++){
 120         acc+= src[i];
 121         dst[i]= acc;
 122         i++;
 123         acc+= src[i];
 124         dst[i]= acc;
 125     }
 126
 127     for(; i<w; i++){
 128         acc+= src[i];
 129         dst[i]= acc;
 130     }
 131
 132     return acc;
 133 }
 134
 135 static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
 136     int i;
 137     uint8_t l, lt;
 138
 139     l= *left;
 140     lt= *left_top;
 141
 142     for(i=0; i<w; i++){
 143         l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
 144         lt= src1[i];
 145         dst[i]= l;
 146     }
 147
 148     *left= l;
 149     *left_top= lt;
 150 }
 151
 152 static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
 153     int i;
 154     int r,g,b;
 155     r= *red;
 156     g= *green;
 157     b= *blue;
 158
 159     for(i=0; i<w; i++){
 160         b+= src[4*i+0];
 161         g+= src[4*i+1];
 162         r+= src[4*i+2];
 163
 164         dst[4*i+0]= b;
 165         dst[4*i+1]= g;
 166         dst[4*i+2]= r;
 167     }
 168
 169     *red= r;
 170     *green= g;
 171     *blue= b;
 172 }
 173
 174 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
 175     int i;
 176     if(w<32){
 177         for(i=0; i<w; i++){
 178             const int temp= src[i];
 179             dst[i]= temp - left;
 180             left= temp;
 181         }
 182         return left;
 183     }else{
 184         for(i=0; i<16; i++){
 185             const int temp= src[i];
 186             dst[i]= temp - left;
 187             left= temp;
 188         }
 189         s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
 190         return src[w-1];
 191     }
 192 }
 193
 194 static void read_len_table(uint8_t *dst, GetBitContext *gb){
 195     int i, val, repeat;
 196
 197     for(i=0; i<256;){
 198         repeat= get_bits(gb, 3);
 199         val   = get_bits(gb, 5);
 200         if(repeat==0)
 201             repeat= get_bits(gb, 8);
 202 //printf("%d %d\n", val, repeat);
 203         while (repeat--)
 204             dst[i++] = val;
 205     }
 206 }
 207
 208 static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
 209     int len, index;
 210     uint32_t bits=0;
 211
 212     for(len=32; len>0; len--){
 213         for(index=0; index<256; index++){
 214             if(len_table[index]==len)
 215                 dst[index]= bits++;
 216         }
 217         if(bits & 1){
 218             av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
 219             return -1;
 220         }
 221         bits >>= 1;
 222     }
 223     return 0;
 224 }
 225
 226 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
 227     uint64_t counts[2*size];
 228     int up[2*size];
 229     int offset, i, next;
 230
 231     for(offset=1; ; offset<<=1){
 232         for(i=0; i<size; i++){
 233             counts[i]= stats[i] + offset - 1;
 234         }
 235
 236         for(next=size; next<size*2; next++){
 237             uint64_t min1, min2;
 238             int min1_i, min2_i;
 239
 240             min1=min2= INT64_MAX;
 241             min1_i= min2_i=-1;
 242
 243             for(i=0; i<next; i++){
 244                 if(min2 > counts[i]){
 245                     if(min1 > counts[i]){
 246                         min2= min1;
 247                         min2_i= min1_i;
 248                         min1= counts[i];
 249                         min1_i= i;
 250                     }else{
 251                         min2= counts[i];
 252                         min2_i= i;
 253                     }
 254                 }
 255             }
 256
 257             if(min2==INT64_MAX) break;
 258
 259             counts[next]= min1 + min2;
 260             counts[min1_i]=
 261             counts[min2_i]= INT64_MAX;
 262             up[min1_i]=
 263             up[min2_i]= next;
 264             up[next]= -1;
 265         }
 266
 267         for(i=0; i<size; i++){
 268             int len;
 269             int index=i;
 270
 271             for(len=0; up[index] != -1; len++)
 272                 index= up[index];
 273
 274             if(len > 32) break;
 275
 276             dst[i]= len;
 277         }
 278         if(i==size) break;
 279     }
 280 }
 281
 282 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
 283     GetBitContext gb;
 284     int i;
 285
 286     init_get_bits(&gb, src, length*8);
 287
 288     for(i=0; i<3; i++){
 289         read_len_table(s->len[i], &gb);
 290
 291         if(generate_bits_table(s->bits[i], s->len[i])<0){
 292             return -1;
 293         }
 294 #if 0
 295 for(j=0; j<256; j++){
 296 printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
 297 }
 298 #endif
 299         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4);
 300     }
 301
 302     return 0;
 303 }
 304
 305 static int read_old_huffman_tables(HYuvContext *s){
 306 #if 1
 307     GetBitContext gb;
 308     int i;
 309
 310     init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
 311     read_len_table(s->len[0], &gb);
 312     init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
 313     read_len_table(s->len[1], &gb);
 314
 315     for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
 316     for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
 317
 318     if(s->bitstream_bpp >= 24){
 319         memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
 320         memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
 321     }
 322     memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
 323     memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
 324
 325     for(i=0; i<3; i++)
 326         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4);
 327
 328     return 0;
 329 #else
 330     fprintf(stderr, "v1 huffyuv is not supported \n");
 331     return -1;
 332 #endif
 333 }
 334
 335 static int decode_init(AVCodecContext *avctx)
 336 {
 337     HYuvContext *s = avctx->priv_data;
 338     int width, height;
 339
 340     s->avctx= avctx;
 341     s->flags= avctx->flags;
 342
 343     dsputil_init(&s->dsp, avctx);
 344
 345     width= s->width= avctx->width;
 346     height= s->height= avctx->height;
 347     avctx->coded_frame= &s->picture;
 348
 349 s->bgr32=1;
 350     assert(width && height);
 351 //if(avctx->extradata)
 352 //  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
 353     if(avctx->extradata_size){
 354         if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
 355             s->version=1; // do such files exist at all?
 356         else
 357             s->version=2;
 358     }else
 359         s->version=0;
 360
 361     if(s->version==2){
 362         int method;
 363
 364         method= ((uint8_t*)avctx->extradata)[0];
 365         s->decorrelate= method&64 ? 1 : 0;
 366         s->predictor= method&63;
 367         s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
 368         if(s->bitstream_bpp==0)
 369             s->bitstream_bpp= avctx->bits_per_sample&~7;
 370
 371         if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
 372             return -1;
 373     }else{
 374         switch(avctx->bits_per_sample&7){
 375         case 1:
 376             s->predictor= LEFT;
 377             s->decorrelate= 0;
 378             break;
 379         case 2:
 380             s->predictor= LEFT;
 381             s->decorrelate= 1;
 382             break;
 383         case 3:
 384             s->predictor= PLANE;
 385             s->decorrelate= avctx->bits_per_sample >= 24;
 386             break;
 387         case 4:
 388             s->predictor= MEDIAN;
 389             s->decorrelate= 0;
 390             break;
 391         default:
 392             s->predictor= LEFT; //OLD
 393             s->decorrelate= 0;
 394             break;
 395         }
 396         s->bitstream_bpp= avctx->bits_per_sample & ~7;
 397
 398         if(read_old_huffman_tables(s) < 0)
 399             return -1;
 400     }
 401
 402     s->interlaced= height > 288;
 403
 404     switch(s->bitstream_bpp){
 405     case 12:
 406         avctx->pix_fmt = PIX_FMT_YUV420P;
 407         break;
 408     case 16:
 409         if(s->yuy2){
 410             avctx->pix_fmt = PIX_FMT_YUV422;
 411         }else{
 412             avctx->pix_fmt = PIX_FMT_YUV422P;
 413         }
 414         break;
 415     case 24:
 416     case 32:
 417         if(s->bgr32){
 418             avctx->pix_fmt = PIX_FMT_RGBA32;
 419         }else{
 420             avctx->pix_fmt = PIX_FMT_BGR24;
 421         }
 422         break;
 423     default:
 424         assert(0);
 425     }
 426
 427 //    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
 428
 429     return 0;
 430 }
 431
 432 static void store_table(HYuvContext *s, uint8_t *len){
 433     int i;
 434     int index= s->avctx->extradata_size;
 435
 436     for(i=0; i<256;){
 437         int val= len[i];
 438         int repeat=0;
 439
 440         for(; i<256 && len[i]==val && repeat<255; i++)
 441             repeat++;
 442
 443         assert(val < 32 && val >0 && repeat<256 && repeat>0);
 444         if(repeat>7){
 445             ((uint8_t*)s->avctx->extradata)[index++]= val;
 446             ((uint8_t*)s->avctx->extradata)[index++]= repeat;
 447         }else{
 448             ((uint8_t*)s->avctx->extradata)[index++]= val | (repeat<<5);
 449         }
 450     }
 451
 452     s->avctx->extradata_size= index;
 453 }
 454
 455 static int encode_init(AVCodecContext *avctx)
 456 {
 457     HYuvContext *s = avctx->priv_data;
 458     int i, j, width, height;
 459
 460     s->avctx= avctx;
 461     s->flags= avctx->flags;
 462
 463     dsputil_init(&s->dsp, avctx);
 464
 465     width= s->width= avctx->width;
 466     height= s->height= avctx->height;
 467
 468     assert(width && height);
 469
 470     avctx->extradata= av_mallocz(1024*30);
 471     avctx->stats_out= av_mallocz(1024*30);
 472     s->version=2;
 473
 474     avctx->coded_frame= &s->picture;
 475
 476     switch(avctx->pix_fmt){
 477     case PIX_FMT_YUV420P:
 478         if(avctx->strict_std_compliance>=0){
 479             av_log(avctx, AV_LOG_ERROR, "YV12-huffyuv is experimental, there WILL be no compatbility! (use (v)strict=-1)\n");
 480             return -1;
 481         }
 482         s->bitstream_bpp= 12;
 483         break;
 484     case PIX_FMT_YUV422P:
 485         s->bitstream_bpp= 16;
 486         break;
 487     default:
 488         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 489         return -1;
 490     }
 491     avctx->bits_per_sample= s->bitstream_bpp;
 492     s->decorrelate= s->bitstream_bpp >= 24;
 493     s->predictor= avctx->prediction_method;
 494
 495     ((uint8_t*)avctx->extradata)[0]= s->predictor;
 496     ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
 497     ((uint8_t*)avctx->extradata)[2]=
 498     ((uint8_t*)avctx->extradata)[3]= 0;
 499     s->avctx->extradata_size= 4;
 500
 501     if(avctx->stats_in){
 502         char *p= avctx->stats_in;
 503
 504         for(i=0; i<3; i++)
 505             for(j=0; j<256; j++)
 506                 s->stats[i][j]= 1;
 507
 508         for(;;){
 509             for(i=0; i<3; i++){
 510                 char *next;
 511
 512                 for(j=0; j<256; j++){
 513                     s->stats[i][j]+= strtol(p, &next, 0);
 514                     if(next==p) return -1;
 515                     p=next;
 516                 }
 517             }
 518             if(p[0]==0 || p[1]==0 || p[2]==0) break;
 519         }
 520     }else{
 521         for(i=0; i<3; i++)
 522             for(j=0; j<256; j++){
 523                 int d= FFMIN(j, 256-j);
 524
 525                 s->stats[i][j]= 100000000/(d+1);
 526             }
 527     }
 528
 529     for(i=0; i<3; i++){
 530         generate_len_table(s->len[i], s->stats[i], 256);
 531
 532         if(generate_bits_table(s->bits[i], s->len[i])<0){
 533             return -1;
 534         }
 535
 536         store_table(s, s->len[i]);
 537     }
 538
 539     for(i=0; i<3; i++)
 540         for(j=0; j<256; j++)
 541             s->stats[i][j]= 0;
 542
 543     s->interlaced= height > 288;
 544
 545 //    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
 546
 547     s->picture_number=0;
 548
 549     return 0;
 550 }
 551
 552 static void decode_422_bitstream(HYuvContext *s, int count){
 553     int i;
 554
 555     count/=2;
 556
 557     for(i=0; i<count; i++){
 558         s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 559         s->temp[1][  i  ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 560         s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 561         s->temp[2][  i  ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 562     }
 563 }
 564
 565 static void decode_gray_bitstream(HYuvContext *s, int count){
 566     int i;
 567
 568     count/=2;
 569
 570     for(i=0; i<count; i++){
 571         s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 572         s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 573     }
 574 }
 575
 576 static void encode_422_bitstream(HYuvContext *s, int count){
 577     int i;
 578
 579     count/=2;
 580     if(s->flags&CODEC_FLAG_PASS1){
 581         for(i=0; i<count; i++){
 582             s->stats[0][ s->temp[0][2*i  ] ]++;
 583             s->stats[1][ s->temp[1][  i  ] ]++;
 584             s->stats[0][ s->temp[0][2*i+1] ]++;
 585             s->stats[2][ s->temp[2][  i  ] ]++;
 586         }
 587     }else{
 588         for(i=0; i<count; i++){
 589             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
 590             put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
 591             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
 592             put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
 593         }
 594     }
 595 }
 596
 597 static void encode_gray_bitstream(HYuvContext *s, int count){
 598     int i;
 599
 600     count/=2;
 601     if(s->flags&CODEC_FLAG_PASS1){
 602         for(i=0; i<count; i++){
 603             s->stats[0][ s->temp[0][2*i  ] ]++;
 604             s->stats[0][ s->temp[0][2*i+1] ]++;
 605         }
 606     }else{
 607         for(i=0; i<count; i++){
 608             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
 609             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
 610         }
 611     }
 612 }
 613
 614 static void decode_bgr_bitstream(HYuvContext *s, int count){
 615     int i;
 616
 617     if(s->decorrelate){
 618         if(s->bitstream_bpp==24){
 619             for(i=0; i<count; i++){
 620                 s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 621                 s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+1];
 622                 s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+1];
 623             }
 624         }else{
 625             for(i=0; i<count; i++){
 626                 s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 627                 s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+1];
 628                 s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+1];
 629                                    get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
 630             }
 631         }
 632     }else{
 633         if(s->bitstream_bpp==24){
 634             for(i=0; i<count; i++){
 635                 s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 636                 s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 637                 s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 638             }
 639         }else{
 640             for(i=0; i<count; i++){
 641                 s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 642                 s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 643                 s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 644                                    get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
 645             }
 646         }
 647     }
 648 }
 649
 650 static void draw_slice(HYuvContext *s, int y){
 651     int h, cy;
 652     int offset[4];
 653
 654     if(s->avctx->draw_horiz_band==NULL)
 655         return;
 656
 657     h= y - s->last_slice_end;
 658     y -= h;
 659
 660     if(s->bitstream_bpp==12){
 661         cy= y>>1;
 662     }else{
 663         cy= y;
 664     }
 665
 666     offset[0] = s->picture.linesize[0]*y;
 667     offset[1] = s->picture.linesize[1]*cy;
 668     offset[2] = s->picture.linesize[2]*cy;
 669     offset[3] = 0;
 670     emms_c();
 671
 672     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
 673
 674     s->last_slice_end= y + h;
 675 }
 676
 677 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
 678     HYuvContext *s = avctx->priv_data;
 679     const int width= s->width;
 680     const int width2= s->width>>1;
 681     const int height= s->height;
 682     int fake_ystride, fake_ustride, fake_vstride;
 683     AVFrame * const p= &s->picture;
 684
 685     AVFrame *picture = data;
 686
 687     *data_size = 0;
 688
 689     /* no supplementary picture */
 690     if (buf_size == 0)
 691         return 0;
 692
 693     s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
 694
 695     init_get_bits(&s->gb, s->bitstream_buffer, buf_size*8);
 696
 697     if(p->data[0])
 698         avctx->release_buffer(avctx, p);
 699
 700     p->reference= 0;
 701     if(avctx->get_buffer(avctx, p) < 0){
 702         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 703         return -1;
 704     }
 705
 706     fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
 707     fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
 708     fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
 709
 710     s->last_slice_end= 0;
 711
 712     if(s->bitstream_bpp<24){
 713         int y, cy;
 714         int lefty, leftu, leftv;
 715         int lefttopy, lefttopu, lefttopv;
 716
 717         if(s->yuy2){
 718             p->data[0][3]= get_bits(&s->gb, 8);
 719             p->data[0][2]= get_bits(&s->gb, 8);
 720             p->data[0][1]= get_bits(&s->gb, 8);
 721             p->data[0][0]= get_bits(&s->gb, 8);
 722
 723             av_log(avctx, AV_LOG_ERROR, "YUY2 output isnt implemenetd yet\n");
 724             return -1;
 725         }else{
 726
 727             leftv= p->data[2][0]= get_bits(&s->gb, 8);
 728             lefty= p->data[0][1]= get_bits(&s->gb, 8);
 729             leftu= p->data[1][0]= get_bits(&s->gb, 8);
 730                    p->data[0][0]= get_bits(&s->gb, 8);
 731
 732             switch(s->predictor){
 733             case LEFT:
 734             case PLANE:
 735                 decode_422_bitstream(s, width-2);
 736                 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
 737                 if(!(s->flags&CODEC_FLAG_GRAY)){
 738                     leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
 739                     leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
 740                 }
 741
 742                 for(cy=y=1; y<s->height; y++,cy++){
 743                     uint8_t *ydst, *udst, *vdst;
 744
 745                     if(s->bitstream_bpp==12){
 746                         decode_gray_bitstream(s, width);
 747
 748                         ydst= p->data[0] + p->linesize[0]*y;
 749
 750                         lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
 751                         if(s->predictor == PLANE){
 752                             if(y>s->interlaced)
 753                                 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
 754                         }
 755                         y++;
 756                         if(y>=s->height) break;
 757                     }
 758
 759                     draw_slice(s, y);
 760
 761                     ydst= p->data[0] + p->linesize[0]*y;
 762                     udst= p->data[1] + p->linesize[1]*cy;
 763                     vdst= p->data[2] + p->linesize[2]*cy;
 764
 765                     decode_422_bitstream(s, width);
 766                     lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
 767                     if(!(s->flags&CODEC_FLAG_GRAY)){
 768                         leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
 769                         leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
 770                     }
 771                     if(s->predictor == PLANE){
 772                         if(cy>s->interlaced){
 773                             s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
 774                             if(!(s->flags&CODEC_FLAG_GRAY)){
 775                                 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
 776                                 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
 777                             }
 778                         }
 779                     }
 780                 }
 781                 draw_slice(s, height);
 782
 783                 break;
 784             case MEDIAN:
 785                 /* first line except first 2 pixels is left predicted */
 786                 decode_422_bitstream(s, width-2);
 787                 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
 788                 if(!(s->flags&CODEC_FLAG_GRAY)){
 789                     leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
 790                     leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
 791                 }
 792
 793                 cy=y=1;
 794
 795                 /* second line is left predicted for interlaced case */
 796                 if(s->interlaced){
 797                     decode_422_bitstream(s, width);
 798                     lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
 799                     if(!(s->flags&CODEC_FLAG_GRAY)){
 800                         leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
 801                         leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
 802                     }
 803                     y++; cy++;
 804                 }
 805
 806                 /* next 4 pixels are left predicted too */
 807                 decode_422_bitstream(s, 4);
 808                 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
 809                 if(!(s->flags&CODEC_FLAG_GRAY)){
 810                     leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
 811                     leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
 812                 }
 813
 814                 /* next line except the first 4 pixels is median predicted */
 815                 lefttopy= p->data[0][3];
 816                 decode_422_bitstream(s, width-4);
 817                 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
 818                 if(!(s->flags&CODEC_FLAG_GRAY)){
 819                     lefttopu= p->data[1][1];
 820                     lefttopv= p->data[2][1];
 821                     add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
 822                     add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
 823                 }
 824                 y++; cy++;
 825
 826                 for(; y<height; y++,cy++){
 827                     uint8_t *ydst, *udst, *vdst;
 828
 829                     if(s->bitstream_bpp==12){
 830                         while(2*cy > y){
 831                             decode_gray_bitstream(s, width);
 832                             ydst= p->data[0] + p->linesize[0]*y;
 833                             add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
 834                             y++;
 835                         }
 836                         if(y>=height) break;
 837                     }
 838                     draw_slice(s, y);
 839
 840                     decode_422_bitstream(s, width);
 841
 842                     ydst= p->data[0] + p->linesize[0]*y;
 843                     udst= p->data[1] + p->linesize[1]*cy;
 844                     vdst= p->data[2] + p->linesize[2]*cy;
 845
 846                     add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
 847                     if(!(s->flags&CODEC_FLAG_GRAY)){
 848                         add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
 849                         add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
 850                     }
 851                 }
 852
 853                 draw_slice(s, height);
 854                 break;
 855             }
 856         }
 857     }else{
 858         int y;
 859         int leftr, leftg, leftb;
 860         const int last_line= (height-1)*p->linesize[0];
 861
 862         if(s->bitstream_bpp==32){
 863                    p->data[0][last_line+3]= get_bits(&s->gb, 8);
 864             leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
 865             leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
 866             leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
 867         }else{
 868             leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
 869             leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
 870             leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
 871             skip_bits(&s->gb, 8);
 872         }
 873
 874         if(s->bgr32){
 875             switch(s->predictor){
 876             case LEFT:
 877             case PLANE:
 878                 decode_bgr_bitstream(s, width-1);
 879                 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
 880
 881                 for(y=s->height-2; y>=0; y--){ //yes its stored upside down
 882                     decode_bgr_bitstream(s, width);
 883
 884                     add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
 885                     if(s->predictor == PLANE){
 886                         if((y&s->interlaced)==0){
 887                             s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
 888                                              p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
 889                         }
 890                     }
 891                 }
 892                 draw_slice(s, height); // just 1 large slice as this isnt possible in reverse order
 893                 break;
 894             default:
 895                 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
 896             }
 897         }else{
 898
 899             av_log(avctx, AV_LOG_ERROR, "BGR24 output isnt implemenetd yet\n");
 900             return -1;
 901         }
 902     }
 903     emms_c();
 904
 905     *picture= *p;
 906     *data_size = sizeof(AVFrame);
 907
 908     return (get_bits_count(&s->gb)+31)/32*4;
 909 }
 910
 911 static int decode_end(AVCodecContext *avctx)
 912 {
 913     HYuvContext *s = avctx->priv_data;
 914     int i;
 915
 916     for(i=0; i<3; i++){
 917         free_vlc(&s->vlc[i]);
 918     }
 919
 920     return 0;
 921 }
 922
 923 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 924     HYuvContext *s = avctx->priv_data;
 925     AVFrame *pict = data;
 926     const int width= s->width;
 927     const int width2= s->width>>1;
 928     const int height= s->height;
 929     const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
 930     const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
 931     const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
 932     AVFrame * const p= &s->picture;
 933     int i, size;
 934
 935     init_put_bits(&s->pb, buf, buf_size);
 936
 937     *p = *pict;
 938     p->pict_type= FF_I_TYPE;
 939     p->key_frame= 1;
 940
 941     if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
 942         int lefty, leftu, leftv, y, cy;
 943
 944         put_bits(&s->pb, 8, leftv= p->data[2][0]);
 945         put_bits(&s->pb, 8, lefty= p->data[0][1]);
 946         put_bits(&s->pb, 8, leftu= p->data[1][0]);
 947         put_bits(&s->pb, 8,        p->data[0][0]);
 948
 949         lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
 950         leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
 951         leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
 952
 953         encode_422_bitstream(s, width-2);
 954
 955         if(s->predictor==MEDIAN){
 956             int lefttopy, lefttopu, lefttopv;
 957             cy=y=1;
 958             if(s->interlaced){
 959                 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
 960                 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
 961                 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
 962
 963                 encode_422_bitstream(s, width);
 964                 y++; cy++;
 965             }
 966
 967             lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
 968             leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ystride, 2, leftu);
 969             leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_ystride, 2, leftv);
 970
 971             encode_422_bitstream(s, 4);
 972
 973             lefttopy= p->data[0][3];
 974             lefttopu= p->data[1][1];
 975             lefttopv= p->data[2][1];
 976             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
 977             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
 978             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
 979             encode_422_bitstream(s, width-4);
 980             y++; cy++;
 981
 982             for(; y<height; y++,cy++){
 983                 uint8_t *ydst, *udst, *vdst;
 984
 985                 if(s->bitstream_bpp==12){
 986                     while(2*cy > y){
 987                         ydst= p->data[0] + p->linesize[0]*y;
 988                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
 989                         encode_gray_bitstream(s, width);
 990                         y++;
 991                     }
 992                     if(y>=height) break;
 993                 }
 994                 ydst= p->data[0] + p->linesize[0]*y;
 995                 udst= p->data[1] + p->linesize[1]*cy;
 996                 vdst= p->data[2] + p->linesize[2]*cy;
 997
 998                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
 999                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1000                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1001
1002                 encode_422_bitstream(s, width);
1003             }
1004         }else{
1005             for(cy=y=1; y<height; y++,cy++){
1006                 uint8_t *ydst, *udst, *vdst;
1007
1008                 /* encode a luma only line & y++ */
1009                 if(s->bitstream_bpp==12){
1010                     ydst= p->data[0] + p->linesize[0]*y;
1011
1012                     if(s->predictor == PLANE && s->interlaced < y){
1013                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1014
1015                         lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1016                     }else{
1017                         lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1018                     }
1019                     encode_gray_bitstream(s, width);
1020                     y++;
1021                     if(y>=height) break;
1022                 }
1023
1024                 ydst= p->data[0] + p->linesize[0]*y;
1025                 udst= p->data[1] + p->linesize[1]*cy;
1026                 vdst= p->data[2] + p->linesize[2]*cy;
1027
1028                 if(s->predictor == PLANE && s->interlaced < cy){
1029                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1030                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1031                     s->dsp.diff_bytes(s->temp[2] + 1250, vdst, vdst - fake_vstride, width2);
1032
1033                     lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1034                     leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1035                     leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + 1250, width2, leftv);
1036                 }else{
1037                     lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1038                     leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1039                     leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1040                 }
1041
1042                 encode_422_bitstream(s, width);
1043             }
1044         }
1045     }else{
1046         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1047     }
1048     emms_c();
1049
1050     size= (put_bits_count(&s->pb)+31)/32;
1051
1052     if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1053         int j;
1054         char *p= avctx->stats_out;
1055         for(i=0; i<3; i++){
1056             for(j=0; j<256; j++){
1057                 sprintf(p, "%llu ", s->stats[i][j]);
1058                 p+= strlen(p);
1059                 s->stats[i][j]= 0;
1060             }
1061             sprintf(p, "\n");
1062             p++;
1063         }
1064     }else{
1065         flush_put_bits(&s->pb);
1066         s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1067     }
1068
1069     s->picture_number++;
1070
1071     return size*4;
1072 }
1073
1074 static int encode_end(AVCodecContext *avctx)
1075 {
1076 //    HYuvContext *s = avctx->priv_data;
1077
1078     av_freep(&avctx->extradata);
1079     av_freep(&avctx->stats_out);
1080
1081     return 0;
1082 }
1083
1084 static const AVOption huffyuv_options[] =
1085 {
1086     AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1087     AVOPTION_END()
1088 };
1089
1090 AVCodec huffyuv_decoder = {
1091     "huffyuv",
1092     CODEC_TYPE_VIDEO,
1093     CODEC_ID_HUFFYUV,
1094     sizeof(HYuvContext),
1095     decode_init,
1096     NULL,
1097     decode_end,
1098     decode_frame,
1099     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1100     NULL
1101 };
1102
1103 #ifdef CONFIG_ENCODERS
1104
1105 AVCodec huffyuv_encoder = {
1106     "huffyuv",
1107     CODEC_TYPE_VIDEO,
1108     CODEC_ID_HUFFYUV,
1109     sizeof(HYuvContext),
1110     encode_init,
1111     encode_frame,
1112     encode_end,
1113     .options = huffyuv_options,
1114 };
1115
1116 #endif //CONFIG_ENCODERS