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