libavcodec/huffyuv.c

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