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     avcodec_default_free_buffers(avctx);
 921
 922     return 0;
 923 }
 924
 925 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 926     HYuvContext *s = avctx->priv_data;
 927     AVFrame *pict = data;
 928     const int width= s->width;
 929     const int width2= s->width>>1;
 930     const int height= s->height;
 931     const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
 932     const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
 933     const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
 934     AVFrame * const p= &s->picture;
 935     int i, size;
 936
 937     init_put_bits(&s->pb, buf, buf_size);
 938
 939     *p = *pict;
 940     p->pict_type= FF_I_TYPE;
 941     p->key_frame= 1;
 942
 943     if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
 944         int lefty, leftu, leftv, y, cy;
 945
 946         put_bits(&s->pb, 8, leftv= p->data[2][0]);
 947         put_bits(&s->pb, 8, lefty= p->data[0][1]);
 948         put_bits(&s->pb, 8, leftu= p->data[1][0]);
 949         put_bits(&s->pb, 8,        p->data[0][0]);
 950
 951         lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
 952         leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
 953         leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
 954
 955         encode_422_bitstream(s, width-2);
 956
 957         if(s->predictor==MEDIAN){
 958             int lefttopy, lefttopu, lefttopv;
 959             cy=y=1;
 960             if(s->interlaced){
 961                 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
 962                 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
 963                 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
 964
 965                 encode_422_bitstream(s, width);
 966                 y++; cy++;
 967             }
 968
 969             lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
 970             leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ystride, 2, leftu);
 971             leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_ystride, 2, leftv);
 972
 973             encode_422_bitstream(s, 4);
 974
 975             lefttopy= p->data[0][3];
 976             lefttopu= p->data[1][1];
 977             lefttopv= p->data[2][1];
 978             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
 979             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
 980             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
 981             encode_422_bitstream(s, width-4);
 982             y++; cy++;
 983
 984             for(; y<height; y++,cy++){
 985                 uint8_t *ydst, *udst, *vdst;
 986
 987                 if(s->bitstream_bpp==12){
 988                     while(2*cy > y){
 989                         ydst= p->data[0] + p->linesize[0]*y;
 990                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
 991                         encode_gray_bitstream(s, width);
 992                         y++;
 993                     }
 994                     if(y>=height) break;
 995                 }
 996                 ydst= p->data[0] + p->linesize[0]*y;
 997                 udst= p->data[1] + p->linesize[1]*cy;
 998                 vdst= p->data[2] + p->linesize[2]*cy;
 999
1000                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1001                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1002                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1003
1004                 encode_422_bitstream(s, width);
1005             }
1006         }else{
1007             for(cy=y=1; y<height; y++,cy++){
1008                 uint8_t *ydst, *udst, *vdst;
1009
1010                 /* encode a luma only line & y++ */
1011                 if(s->bitstream_bpp==12){
1012                     ydst= p->data[0] + p->linesize[0]*y;
1013
1014                     if(s->predictor == PLANE && s->interlaced < y){
1015                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1016
1017                         lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1018                     }else{
1019                         lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1020                     }
1021                     encode_gray_bitstream(s, width);
1022                     y++;
1023                     if(y>=height) break;
1024                 }
1025
1026                 ydst= p->data[0] + p->linesize[0]*y;
1027                 udst= p->data[1] + p->linesize[1]*cy;
1028                 vdst= p->data[2] + p->linesize[2]*cy;
1029
1030                 if(s->predictor == PLANE && s->interlaced < cy){
1031                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1032                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1033                     s->dsp.diff_bytes(s->temp[2] + 1250, vdst, vdst - fake_vstride, width2);
1034
1035                     lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1036                     leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1037                     leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + 1250, width2, leftv);
1038                 }else{
1039                     lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1040                     leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1041                     leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1042                 }
1043
1044                 encode_422_bitstream(s, width);
1045             }
1046         }
1047     }else{
1048         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1049     }
1050     emms_c();
1051
1052     size= (get_bit_count(&s->pb)+31)/32;
1053
1054     if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1055         int j;
1056         char *p= avctx->stats_out;
1057         for(i=0; i<3; i++){
1058             for(j=0; j<256; j++){
1059                 sprintf(p, "%llu ", s->stats[i][j]);
1060                 p+= strlen(p);
1061                 s->stats[i][j]= 0;
1062             }
1063             sprintf(p, "\n");
1064             p++;
1065         }
1066     }else{
1067         flush_put_bits(&s->pb);
1068         s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1069     }
1070
1071     s->picture_number++;
1072
1073     return size*4;
1074 }
1075
1076 static int encode_end(AVCodecContext *avctx)
1077 {
1078 //    HYuvContext *s = avctx->priv_data;
1079
1080     av_freep(&avctx->extradata);
1081     av_freep(&avctx->stats_out);
1082
1083     return 0;
1084 }
1085
1086 static const AVOption huffyuv_options[] =
1087 {
1088     AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1089     AVOPTION_END()
1090 };
1091
1092 AVCodec huffyuv_decoder = {
1093     "huffyuv",
1094     CODEC_TYPE_VIDEO,
1095     CODEC_ID_HUFFYUV,
1096     sizeof(HYuvContext),
1097     decode_init,
1098     NULL,
1099     decode_end,
1100     decode_frame,
1101     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1102     NULL
1103 };
1104
1105 #ifdef CONFIG_ENCODERS
1106
1107 AVCodec huffyuv_encoder = {
1108     "huffyuv",
1109     CODEC_TYPE_VIDEO,
1110     CODEC_ID_HUFFYUV,
1111     sizeof(HYuvContext),
1112     encode_init,
1113     encode_frame,
1114     encode_end,
1115     .options = huffyuv_options,
1116 };
1117
1118 #endif //CONFIG_ENCODERS