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