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