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