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