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