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