git.sesse.net Git - ffmpeg/blob - libavcodec/huffyuv.c

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