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