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