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