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         s->bitstream_bpp= 12;
 479         break;
 480     case PIX_FMT_YUV422P:
 481         s->bitstream_bpp= 16;
 482         break;
 483     default:
 484         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 485         return -1;
 486     }
 487     avctx->bits_per_sample= s->bitstream_bpp;
 488     s->decorrelate= s->bitstream_bpp >= 24;
 489     s->predictor= avctx->prediction_method;
 490
 491     ((uint8_t*)avctx->extradata)[0]= s->predictor;
 492     ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
 493     ((uint8_t*)avctx->extradata)[2]=
 494     ((uint8_t*)avctx->extradata)[3]= 0;
 495     s->avctx->extradata_size= 4;
 496
 497     if(avctx->stats_in){
 498         char *p= avctx->stats_in;
 499
 500         for(i=0; i<3; i++)
 501             for(j=0; j<256; j++)
 502                 s->stats[i][j]= 1;
 503
 504         for(;;){
 505             for(i=0; i<3; i++){
 506                 char *next;
 507
 508                 for(j=0; j<256; j++){
 509                     s->stats[i][j]+= strtol(p, &next, 0);
 510                     if(next==p) return -1;
 511                     p=next;
 512                 }
 513             }
 514             if(p[0]==0 || p[1]==0 || p[2]==0) break;
 515         }
 516     }else{
 517         for(i=0; i<3; i++)
 518             for(j=0; j<256; j++){
 519                 int d= FFMIN(j, 256-j);
 520
 521                 s->stats[i][j]= 100000000/(d+1);
 522             }
 523     }
 524
 525     for(i=0; i<3; i++){
 526         generate_len_table(s->len[i], s->stats[i], 256);
 527
 528         if(generate_bits_table(s->bits[i], s->len[i])<0){
 529             return -1;
 530         }
 531
 532         store_table(s, s->len[i]);
 533     }
 534
 535     for(i=0; i<3; i++)
 536         for(j=0; j<256; j++)
 537             s->stats[i][j]= 0;
 538
 539     s->interlaced= height > 288;
 540
 541 //    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
 542
 543     s->picture_number=0;
 544
 545     return 0;
 546 }
 547
 548 static void decode_422_bitstream(HYuvContext *s, int count){
 549     int i;
 550
 551     count/=2;
 552
 553     for(i=0; i<count; i++){
 554         s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 555         s->temp[1][  i  ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 556         s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 557         s->temp[2][  i  ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 558     }
 559 }
 560
 561 static void decode_gray_bitstream(HYuvContext *s, int count){
 562     int i;
 563
 564     count/=2;
 565
 566     for(i=0; i<count; i++){
 567         s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 568         s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 569     }
 570 }
 571
 572 static void encode_422_bitstream(HYuvContext *s, int count){
 573     int i;
 574
 575     count/=2;
 576     if(s->flags&CODEC_FLAG_PASS1){
 577         for(i=0; i<count; i++){
 578             s->stats[0][ s->temp[0][2*i  ] ]++;
 579             s->stats[1][ s->temp[1][  i  ] ]++;
 580             s->stats[0][ s->temp[0][2*i+1] ]++;
 581             s->stats[2][ s->temp[2][  i  ] ]++;
 582         }
 583     }else{
 584         for(i=0; i<count; i++){
 585             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
 586             put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
 587             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
 588             put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
 589         }
 590     }
 591 }
 592
 593 static void encode_gray_bitstream(HYuvContext *s, int count){
 594     int i;
 595
 596     count/=2;
 597     if(s->flags&CODEC_FLAG_PASS1){
 598         for(i=0; i<count; i++){
 599             s->stats[0][ s->temp[0][2*i  ] ]++;
 600             s->stats[0][ s->temp[0][2*i+1] ]++;
 601         }
 602     }else{
 603         for(i=0; i<count; i++){
 604             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
 605             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
 606         }
 607     }
 608 }
 609
 610 static void decode_bgr_bitstream(HYuvContext *s, int count){
 611     int i;
 612
 613     if(s->decorrelate){
 614         if(s->bitstream_bpp==24){
 615             for(i=0; i<count; i++){
 616                 s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 617                 s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+1];
 618                 s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+1];
 619             }
 620         }else{
 621             for(i=0; i<count; i++){
 622                 s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 623                 s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+1];
 624                 s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+1];
 625                                    get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
 626             }
 627         }
 628     }else{
 629         if(s->bitstream_bpp==24){
 630             for(i=0; i<count; i++){
 631                 s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 632                 s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 633                 s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 634             }
 635         }else{
 636             for(i=0; i<count; i++){
 637                 s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
 638                 s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
 639                 s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
 640                                    get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
 641             }
 642         }
 643     }
 644 }
 645
 646 static void draw_slice(HYuvContext *s, int y){
 647     int h, cy;
 648     int offset[4];
 649
 650     if(s->avctx->draw_horiz_band==NULL)
 651         return;
 652
 653     h= y - s->last_slice_end;
 654     y -= h;
 655
 656     if(s->bitstream_bpp==12){
 657         cy= y>>1;
 658     }else{
 659         cy= y;
 660     }
 661
 662     offset[0] = s->picture.linesize[0]*y;
 663     offset[1] = s->picture.linesize[1]*cy;
 664     offset[2] = s->picture.linesize[2]*cy;
 665     offset[3] = 0;
 666     emms_c();
 667
 668     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
 669
 670     s->last_slice_end= y + h;
 671 }
 672
 673 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
 674     HYuvContext *s = avctx->priv_data;
 675     const int width= s->width;
 676     const int width2= s->width>>1;
 677     const int height= s->height;
 678     int fake_ystride, fake_ustride, fake_vstride;
 679     AVFrame * const p= &s->picture;
 680
 681     AVFrame *picture = data;
 682
 683     /* no supplementary picture */
 684     if (buf_size == 0)
 685         return 0;
 686
 687     s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
 688
 689     init_get_bits(&s->gb, s->bitstream_buffer, buf_size*8);
 690
 691     if(p->data[0])
 692         avctx->release_buffer(avctx, p);
 693
 694     p->reference= 0;
 695     if(avctx->get_buffer(avctx, p) < 0){
 696         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 697         return -1;
 698     }
 699
 700     fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
 701     fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
 702     fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
 703
 704     s->last_slice_end= 0;
 705
 706     if(s->bitstream_bpp<24){
 707         int y, cy;
 708         int lefty, leftu, leftv;
 709         int lefttopy, lefttopu, lefttopv;
 710
 711         if(s->yuy2){
 712             p->data[0][3]= get_bits(&s->gb, 8);
 713             p->data[0][2]= get_bits(&s->gb, 8);
 714             p->data[0][1]= get_bits(&s->gb, 8);
 715             p->data[0][0]= get_bits(&s->gb, 8);
 716
 717             av_log(avctx, AV_LOG_ERROR, "YUY2 output isnt implemenetd yet\n");
 718             return -1;
 719         }else{
 720
 721             leftv= p->data[2][0]= get_bits(&s->gb, 8);
 722             lefty= p->data[0][1]= get_bits(&s->gb, 8);
 723             leftu= p->data[1][0]= get_bits(&s->gb, 8);
 724                    p->data[0][0]= get_bits(&s->gb, 8);
 725
 726             switch(s->predictor){
 727             case LEFT:
 728             case PLANE:
 729                 decode_422_bitstream(s, width-2);
 730                 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
 731                 if(!(s->flags&CODEC_FLAG_GRAY)){
 732                     leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
 733                     leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
 734                 }
 735
 736                 for(cy=y=1; y<s->height; y++,cy++){
 737                     uint8_t *ydst, *udst, *vdst;
 738
 739                     if(s->bitstream_bpp==12){
 740                         decode_gray_bitstream(s, width);
 741
 742                         ydst= p->data[0] + p->linesize[0]*y;
 743
 744                         lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
 745                         if(s->predictor == PLANE){
 746                             if(y>s->interlaced)
 747                                 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
 748                         }
 749                         y++;
 750                         if(y>=s->height) break;
 751                     }
 752
 753                     draw_slice(s, y);
 754
 755                     ydst= p->data[0] + p->linesize[0]*y;
 756                     udst= p->data[1] + p->linesize[1]*cy;
 757                     vdst= p->data[2] + p->linesize[2]*cy;
 758
 759                     decode_422_bitstream(s, width);
 760                     lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
 761                     if(!(s->flags&CODEC_FLAG_GRAY)){
 762                         leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
 763                         leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
 764                     }
 765                     if(s->predictor == PLANE){
 766                         if(cy>s->interlaced){
 767                             s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
 768                             if(!(s->flags&CODEC_FLAG_GRAY)){
 769                                 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
 770                                 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
 771                             }
 772                         }
 773                     }
 774                 }
 775                 draw_slice(s, height);
 776
 777                 break;
 778             case MEDIAN:
 779                 /* first line except first 2 pixels is left predicted */
 780                 decode_422_bitstream(s, width-2);
 781                 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
 782                 if(!(s->flags&CODEC_FLAG_GRAY)){
 783                     leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
 784                     leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
 785                 }
 786
 787                 cy=y=1;
 788
 789                 /* second line is left predicted for interlaced case */
 790                 if(s->interlaced){
 791                     decode_422_bitstream(s, width);
 792                     lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
 793                     if(!(s->flags&CODEC_FLAG_GRAY)){
 794                         leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
 795                         leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
 796                     }
 797                     y++; cy++;
 798                 }
 799
 800                 /* next 4 pixels are left predicted too */
 801                 decode_422_bitstream(s, 4);
 802                 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
 803                 if(!(s->flags&CODEC_FLAG_GRAY)){
 804                     leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
 805                     leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
 806                 }
 807
 808                 /* next line except the first 4 pixels is median predicted */
 809                 lefttopy= p->data[0][3];
 810                 decode_422_bitstream(s, width-4);
 811                 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
 812                 if(!(s->flags&CODEC_FLAG_GRAY)){
 813                     lefttopu= p->data[1][1];
 814                     lefttopv= p->data[2][1];
 815                     add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
 816                     add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
 817                 }
 818                 y++; cy++;
 819
 820                 for(; y<height; y++,cy++){
 821                     uint8_t *ydst, *udst, *vdst;
 822
 823                     if(s->bitstream_bpp==12){
 824                         while(2*cy > y){
 825                             decode_gray_bitstream(s, width);
 826                             ydst= p->data[0] + p->linesize[0]*y;
 827                             add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
 828                             y++;
 829                         }
 830                         if(y>=height) break;
 831                     }
 832                     draw_slice(s, y);
 833
 834                     decode_422_bitstream(s, width);
 835
 836                     ydst= p->data[0] + p->linesize[0]*y;
 837                     udst= p->data[1] + p->linesize[1]*cy;
 838                     vdst= p->data[2] + p->linesize[2]*cy;
 839
 840                     add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
 841                     if(!(s->flags&CODEC_FLAG_GRAY)){
 842                         add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
 843                         add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
 844                     }
 845                 }
 846
 847                 draw_slice(s, height);
 848                 break;
 849             }
 850         }
 851     }else{
 852         int y;
 853         int leftr, leftg, leftb;
 854         const int last_line= (height-1)*p->linesize[0];
 855
 856         if(s->bitstream_bpp==32){
 857                    p->data[0][last_line+3]= get_bits(&s->gb, 8);
 858             leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
 859             leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
 860             leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
 861         }else{
 862             leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
 863             leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
 864             leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
 865             skip_bits(&s->gb, 8);
 866         }
 867
 868         if(s->bgr32){
 869             switch(s->predictor){
 870             case LEFT:
 871             case PLANE:
 872                 decode_bgr_bitstream(s, width-1);
 873                 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
 874
 875                 for(y=s->height-2; y>=0; y--){ //yes its stored upside down
 876                     decode_bgr_bitstream(s, width);
 877
 878                     add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
 879                     if(s->predictor == PLANE){
 880                         if((y&s->interlaced)==0){
 881                             s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
 882                                              p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
 883                         }
 884                     }
 885                 }
 886                 draw_slice(s, height); // just 1 large slice as this isnt possible in reverse order
 887                 break;
 888             default:
 889                 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
 890             }
 891         }else{
 892
 893             av_log(avctx, AV_LOG_ERROR, "BGR24 output isnt implemenetd yet\n");
 894             return -1;
 895         }
 896     }
 897     emms_c();
 898
 899     *picture= *p;
 900     *data_size = sizeof(AVFrame);
 901
 902     return (get_bits_count(&s->gb)+31)/32*4;
 903 }
 904
 905 static int decode_end(AVCodecContext *avctx)
 906 {
 907     HYuvContext *s = avctx->priv_data;
 908     int i;
 909
 910     for(i=0; i<3; i++){
 911         free_vlc(&s->vlc[i]);
 912     }
 913
 914     return 0;
 915 }
 916
 917 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 918     HYuvContext *s = avctx->priv_data;
 919     AVFrame *pict = data;
 920     const int width= s->width;
 921     const int width2= s->width>>1;
 922     const int height= s->height;
 923     const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
 924     const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
 925     const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
 926     AVFrame * const p= &s->picture;
 927     int i, size;
 928
 929     init_put_bits(&s->pb, buf, buf_size);
 930
 931     *p = *pict;
 932     p->pict_type= FF_I_TYPE;
 933     p->key_frame= 1;
 934
 935     if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
 936         int lefty, leftu, leftv, y, cy;
 937
 938         put_bits(&s->pb, 8, leftv= p->data[2][0]);
 939         put_bits(&s->pb, 8, lefty= p->data[0][1]);
 940         put_bits(&s->pb, 8, leftu= p->data[1][0]);
 941         put_bits(&s->pb, 8,        p->data[0][0]);
 942
 943         lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
 944         leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
 945         leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
 946
 947         encode_422_bitstream(s, width-2);
 948
 949         if(s->predictor==MEDIAN){
 950             int lefttopy, lefttopu, lefttopv;
 951             cy=y=1;
 952             if(s->interlaced){
 953                 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
 954                 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
 955                 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
 956
 957                 encode_422_bitstream(s, width);
 958                 y++; cy++;
 959             }
 960
 961             lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
 962             leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ystride, 2, leftu);
 963             leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_ystride, 2, leftv);
 964
 965             encode_422_bitstream(s, 4);
 966
 967             lefttopy= p->data[0][3];
 968             lefttopu= p->data[1][1];
 969             lefttopv= p->data[2][1];
 970             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
 971             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
 972             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
 973             encode_422_bitstream(s, width-4);
 974             y++; cy++;
 975
 976             for(; y<height; y++,cy++){
 977                 uint8_t *ydst, *udst, *vdst;
 978
 979                 if(s->bitstream_bpp==12){
 980                     while(2*cy > y){
 981                         ydst= p->data[0] + p->linesize[0]*y;
 982                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
 983                         encode_gray_bitstream(s, width);
 984                         y++;
 985                     }
 986                     if(y>=height) break;
 987                 }
 988                 ydst= p->data[0] + p->linesize[0]*y;
 989                 udst= p->data[1] + p->linesize[1]*cy;
 990                 vdst= p->data[2] + p->linesize[2]*cy;
 991
 992                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
 993                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
 994                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
 995
 996                 encode_422_bitstream(s, width);
 997             }
 998         }else{
 999             for(cy=y=1; y<height; y++,cy++){
1000                 uint8_t *ydst, *udst, *vdst;
1001
1002                 /* encode a luma only line & y++ */
1003                 if(s->bitstream_bpp==12){
1004                     ydst= p->data[0] + p->linesize[0]*y;
1005
1006                     if(s->predictor == PLANE && s->interlaced < y){
1007                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1008
1009                         lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1010                     }else{
1011                         lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1012                     }
1013                     encode_gray_bitstream(s, width);
1014                     y++;
1015                     if(y>=height) break;
1016                 }
1017
1018                 ydst= p->data[0] + p->linesize[0]*y;
1019                 udst= p->data[1] + p->linesize[1]*cy;
1020                 vdst= p->data[2] + p->linesize[2]*cy;
1021
1022                 if(s->predictor == PLANE && s->interlaced < cy){
1023                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1024                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1025                     s->dsp.diff_bytes(s->temp[2] + 1250, vdst, vdst - fake_vstride, width2);
1026
1027                     lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1028                     leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1029                     leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + 1250, width2, leftv);
1030                 }else{
1031                     lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1032                     leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1033                     leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1034                 }
1035
1036                 encode_422_bitstream(s, width);
1037             }
1038         }
1039     }else{
1040         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1041     }
1042     emms_c();
1043
1044     size= (put_bits_count(&s->pb)+31)/32;
1045
1046     if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1047         int j;
1048         char *p= avctx->stats_out;
1049         for(i=0; i<3; i++){
1050             for(j=0; j<256; j++){
1051                 sprintf(p, "%llu ", s->stats[i][j]);
1052                 p+= strlen(p);
1053                 s->stats[i][j]= 0;
1054             }
1055             sprintf(p, "\n");
1056             p++;
1057         }
1058     }else{
1059         flush_put_bits(&s->pb);
1060         s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1061     }
1062
1063     s->picture_number++;
1064
1065     return size*4;
1066 }
1067
1068 static int encode_end(AVCodecContext *avctx)
1069 {
1070 //    HYuvContext *s = avctx->priv_data;
1071
1072     av_freep(&avctx->extradata);
1073     av_freep(&avctx->stats_out);
1074
1075     return 0;
1076 }
1077
1078 static const AVOption huffyuv_options[] =
1079 {
1080     AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1081     AVOPTION_END()
1082 };
1083
1084 AVCodec huffyuv_decoder = {
1085     "huffyuv",
1086     CODEC_TYPE_VIDEO,
1087     CODEC_ID_HUFFYUV,
1088     sizeof(HYuvContext),
1089     decode_init,
1090     NULL,
1091     decode_end,
1092     decode_frame,
1093     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1094     NULL
1095 };
1096
1097 #ifdef CONFIG_ENCODERS
1098
1099 AVCodec huffyuv_encoder = {
1100     "huffyuv",
1101     CODEC_TYPE_VIDEO,
1102     CODEC_ID_HUFFYUV,
1103     sizeof(HYuvContext),
1104     encode_init,
1105     encode_frame,
1106     encode_end,
1107     .options = huffyuv_options,
1108 };
1109
1110 #endif //CONFIG_ENCODERS