dissallow sprintf
[ffmpeg.git] / libavcodec / huffyuv.c
1 /*
2  * huffyuv codec for libavcodec
3  *
4  * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
21  * the algorithm used 
22  */
23  
24 /**
25  * @file huffyuv.c
26  * huffyuv codec for libavcodec.
27  */
28
29 #include "common.h"
30 #include "bitstream.h"
31 #include "avcodec.h"
32 #include "dsputil.h"
33
34 #define VLC_BITS 11
35
36 #ifdef WORDS_BIGENDIAN
37 #define B 3
38 #define G 2
39 #define R 1
40 #else
41 #define B 0
42 #define G 1
43 #define R 2
44 #endif
45
46 typedef enum Predictor{
47     LEFT= 0,
48     PLANE,
49     MEDIAN,
50 } Predictor;
51  
52 typedef struct HYuvContext{
53     AVCodecContext *avctx;
54     Predictor predictor;
55     GetBitContext gb;
56     PutBitContext pb;
57     int interlaced;
58     int decorrelate;
59     int bitstream_bpp;
60     int version;
61     int yuy2;                               //use yuy2 instead of 422P
62     int bgr32;                              //use bgr32 instead of bgr24
63     int width, height;
64     int flags;
65     int context;
66     int picture_number;
67     int last_slice_end;
68     uint8_t *temp[3];
69     uint64_t stats[3][256];
70     uint8_t len[3][256];
71     uint32_t bits[3][256];
72     VLC vlc[3];
73     AVFrame picture;
74     uint8_t *bitstream_buffer;
75     int bitstream_buffer_size;
76     DSPContext dsp; 
77 }HYuvContext;
78
79 static const unsigned char classic_shift_luma[] = {
80   34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
81   16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
82   69,68, 0
83 };
84
85 static const unsigned char classic_shift_chroma[] = {
86   66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
87   56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
88   214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
89 };
90
91 static const unsigned char classic_add_luma[256] = {
92     3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
93    73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
94    68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
95    35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
96    37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
97    35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
98    27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
99    15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
100    12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
101    12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
102    18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
103    28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
104    28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
105    62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
106    54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
107    46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
108 };
109
110 static const unsigned char classic_add_chroma[256] = {
111     3,  1,  2,  2,  2,  2,  3,  3,  7,  5,  7,  5,  8,  6, 11,  9,
112     7, 13, 11, 10,  9,  8,  7,  5,  9,  7,  6,  4,  7,  5,  8,  7,
113    11,  8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
114    43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
115   143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
116    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
117    17, 14,  5,  6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
118   112,113,114,115,  4,117,118, 92, 94,121,122,  3,124,103,  2,  1,
119     0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
120   135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
121    52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
122    19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10,  9,  8, 36,
123     7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
124    83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
125    14, 16, 17, 18, 20, 21, 12, 14, 15,  9, 10,  6,  9,  6,  5,  8,
126     6, 12,  8, 10,  7,  9,  6,  4,  6,  2,  2,  3,  3,  3,  3,  2,
127 };
128
129 static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
130     int i;
131
132     for(i=0; i<w-1; i++){
133         acc+= src[i];
134         dst[i]= acc;
135         i++;
136         acc+= src[i];
137         dst[i]= acc;
138     }
139
140     for(; i<w; i++){
141         acc+= src[i];
142         dst[i]= acc;
143     }
144
145     return acc;
146 }
147
148 static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
149     int i;
150     uint8_t l, lt;
151
152     l= *left;
153     lt= *left_top;
154
155     for(i=0; i<w; i++){
156         l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
157         lt= src1[i];
158         dst[i]= l;
159     }    
160
161     *left= l;
162     *left_top= lt;
163 }
164
165 static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
166     int i;
167     int r,g,b;
168     r= *red;
169     g= *green;
170     b= *blue;
171
172     for(i=0; i<w; i++){
173         b+= src[4*i+B];
174         g+= src[4*i+G];
175         r+= src[4*i+R];
176         
177         dst[4*i+B]= b;
178         dst[4*i+G]= g;
179         dst[4*i+R]= r;
180     }
181
182     *red= r;
183     *green= g;
184     *blue= b;
185 }
186
187 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
188     int i;
189     if(w<32){
190         for(i=0; i<w; i++){
191             const int temp= src[i];
192             dst[i]= temp - left;
193             left= temp;
194         }
195         return left;
196     }else{
197         for(i=0; i<16; i++){
198             const int temp= src[i];
199             dst[i]= temp - left;
200             left= temp;
201         }
202         s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
203         return src[w-1];
204     }
205 }
206
207 static void read_len_table(uint8_t *dst, GetBitContext *gb){
208     int i, val, repeat;
209   
210     for(i=0; i<256;){
211         repeat= get_bits(gb, 3);
212         val   = get_bits(gb, 5);
213         if(repeat==0)
214             repeat= get_bits(gb, 8);
215 //printf("%d %d\n", val, repeat);
216         while (repeat--)
217             dst[i++] = val;
218     }
219 }
220
221 static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
222     int len, index;
223     uint32_t bits=0;
224
225     for(len=32; len>0; len--){
226         for(index=0; index<256; index++){
227             if(len_table[index]==len)
228                 dst[index]= bits++;
229         }
230         if(bits & 1){
231             av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
232             return -1;
233         }
234         bits >>= 1;
235     }
236     return 0;
237 }
238
239 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
240     uint64_t counts[2*size];
241     int up[2*size];
242     int offset, i, next;
243     
244     for(offset=1; ; offset<<=1){
245         for(i=0; i<size; i++){
246             counts[i]= stats[i] + offset - 1;
247         }
248         
249         for(next=size; next<size*2; next++){
250             uint64_t min1, min2;
251             int min1_i, min2_i;
252             
253             min1=min2= INT64_MAX;
254             min1_i= min2_i=-1;
255             
256             for(i=0; i<next; i++){
257                 if(min2 > counts[i]){
258                     if(min1 > counts[i]){
259                         min2= min1;
260                         min2_i= min1_i;
261                         min1= counts[i];
262                         min1_i= i;
263                     }else{
264                         min2= counts[i];
265                         min2_i= i;
266                     }
267                 }
268             }
269             
270             if(min2==INT64_MAX) break;
271             
272             counts[next]= min1 + min2;
273             counts[min1_i]=
274             counts[min2_i]= INT64_MAX;
275             up[min1_i]=
276             up[min2_i]= next;
277             up[next]= -1;
278         }
279         
280         for(i=0; i<size; i++){
281             int len;
282             int index=i;
283             
284             for(len=0; up[index] != -1; len++)
285                 index= up[index];
286                 
287             if(len >= 32) break;
288             
289             dst[i]= len;
290         }
291         if(i==size) break;
292     }
293 }
294
295 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
296     GetBitContext gb;
297     int i;
298     
299     init_get_bits(&gb, src, length*8);
300     
301     for(i=0; i<3; i++){
302         read_len_table(s->len[i], &gb);
303         
304         if(generate_bits_table(s->bits[i], s->len[i])<0){
305             return -1;
306         }
307 #if 0
308 for(j=0; j<256; j++){
309 printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
310 }
311 #endif
312         free_vlc(&s->vlc[i]);
313         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
314     }
315     
316     return (get_bits_count(&gb)+7)/8;
317 }
318
319 static int read_old_huffman_tables(HYuvContext *s){
320 #if 1
321     GetBitContext gb;
322     int i;
323
324     init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
325     read_len_table(s->len[0], &gb);
326     init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
327     read_len_table(s->len[1], &gb);
328     
329     for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
330     for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
331
332     if(s->bitstream_bpp >= 24){
333         memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
334         memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
335     }
336     memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
337     memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
338     
339     for(i=0; i<3; i++){
340         free_vlc(&s->vlc[i]);
341         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
342     }
343     
344     return 0;
345 #else
346     fprintf(stderr, "v1 huffyuv is not supported \n");
347     return -1;
348 #endif
349 }
350
351 static int common_init(AVCodecContext *avctx){
352     HYuvContext *s = avctx->priv_data;
353     int i;
354
355     s->avctx= avctx;
356     s->flags= avctx->flags;
357         
358     dsputil_init(&s->dsp, avctx);
359     
360     s->width= avctx->width;
361     s->height= avctx->height;
362     assert(s->width>0 && s->height>0);
363     
364     for(i=0; i<3; i++){
365         s->temp[i]= av_malloc(avctx->width + 16);
366     }
367     return 0;
368 }
369
370 static int decode_init(AVCodecContext *avctx)
371 {
372     HYuvContext *s = avctx->priv_data;
373
374     common_init(avctx);
375     memset(s->vlc, 0, 3*sizeof(VLC));
376     
377     avctx->coded_frame= &s->picture;
378     s->interlaced= s->height > 288;
379
380 s->bgr32=1;
381 //if(avctx->extradata)
382 //  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
383     if(avctx->extradata_size){
384         if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
385             s->version=1; // do such files exist at all?
386         else
387             s->version=2;
388     }else
389         s->version=0;
390     
391     if(s->version==2){
392         int method, interlace;
393
394         method= ((uint8_t*)avctx->extradata)[0];
395         s->decorrelate= method&64 ? 1 : 0;
396         s->predictor= method&63;
397         s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
398         if(s->bitstream_bpp==0) 
399             s->bitstream_bpp= avctx->bits_per_sample&~7;
400         interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
401         s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
402         s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
403             
404         if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
405             return -1;
406     }else{
407         switch(avctx->bits_per_sample&7){
408         case 1:
409             s->predictor= LEFT;
410             s->decorrelate= 0;
411             break;
412         case 2:
413             s->predictor= LEFT;
414             s->decorrelate= 1;
415             break;
416         case 3:
417             s->predictor= PLANE;
418             s->decorrelate= avctx->bits_per_sample >= 24;
419             break;
420         case 4:
421             s->predictor= MEDIAN;
422             s->decorrelate= 0;
423             break;
424         default:
425             s->predictor= LEFT; //OLD
426             s->decorrelate= 0;
427             break;
428         }
429         s->bitstream_bpp= avctx->bits_per_sample & ~7;
430         s->context= 0;
431         
432         if(read_old_huffman_tables(s) < 0)
433             return -1;
434     }
435     
436     switch(s->bitstream_bpp){
437     case 12:
438         avctx->pix_fmt = PIX_FMT_YUV420P;
439         break;
440     case 16:
441         if(s->yuy2){
442             avctx->pix_fmt = PIX_FMT_YUV422;
443         }else{
444             avctx->pix_fmt = PIX_FMT_YUV422P;
445         }
446         break;
447     case 24:
448     case 32:
449         if(s->bgr32){
450             avctx->pix_fmt = PIX_FMT_RGBA32;
451         }else{
452             avctx->pix_fmt = PIX_FMT_BGR24;
453         }
454         break;
455     default:
456         assert(0);
457     }
458     
459 //    av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
460
461     return 0;
462 }
463
464 static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
465     int i;
466     int index= 0;
467
468     for(i=0; i<256;){
469         int val= len[i];
470         int repeat=0;
471         
472         for(; i<256 && len[i]==val && repeat<255; i++)
473             repeat++;
474         
475         assert(val < 32 && val >0 && repeat<256 && repeat>0);
476         if(repeat>7){
477             buf[index++]= val;
478             buf[index++]= repeat;
479         }else{
480             buf[index++]= val | (repeat<<5);
481         }
482     }
483     
484     return index;
485 }
486
487 static int encode_init(AVCodecContext *avctx)
488 {
489     HYuvContext *s = avctx->priv_data;
490     int i, j;
491
492     common_init(avctx);
493     
494     avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
495     avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
496     s->version=2;
497     
498     avctx->coded_frame= &s->picture;
499     
500     switch(avctx->pix_fmt){
501     case PIX_FMT_YUV420P:
502         s->bitstream_bpp= 12;
503         break;
504     case PIX_FMT_YUV422P:
505         s->bitstream_bpp= 16;
506         break;
507     default:
508         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
509         return -1;
510     }
511     avctx->bits_per_sample= s->bitstream_bpp;
512     s->decorrelate= s->bitstream_bpp >= 24;
513     s->predictor= avctx->prediction_method;
514     s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
515     if(avctx->context_model==1){
516         s->context= avctx->context_model;
517         if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
518             av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
519             return -1;
520         }
521     }else s->context= 0;
522     
523     if(avctx->codec->id==CODEC_ID_HUFFYUV){
524         if(avctx->pix_fmt==PIX_FMT_YUV420P){
525             av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
526             return -1;
527         }
528         if(avctx->context_model){
529             av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
530             return -1;
531         }
532         if(s->interlaced != ( s->height > 288 ))
533             av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
534     }else if(avctx->strict_std_compliance>=0){
535         av_log(avctx, AV_LOG_ERROR, "This codec is under development; files encoded with it may not be decodeable with future versions!!! Set vstrict=-1 to use it anyway.\n");
536         return -1;
537     }
538     
539     ((uint8_t*)avctx->extradata)[0]= s->predictor;
540     ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
541     ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
542     if(s->context)
543         ((uint8_t*)avctx->extradata)[2]|= 0x40;
544     ((uint8_t*)avctx->extradata)[3]= 0;
545     s->avctx->extradata_size= 4;
546     
547     if(avctx->stats_in){
548         char *p= avctx->stats_in;
549     
550         for(i=0; i<3; i++)
551             for(j=0; j<256; j++)
552                 s->stats[i][j]= 1;
553
554         for(;;){
555             for(i=0; i<3; i++){
556                 char *next;
557
558                 for(j=0; j<256; j++){
559                     s->stats[i][j]+= strtol(p, &next, 0);
560                     if(next==p) return -1;
561                     p=next;
562                 }        
563             }
564             if(p[0]==0 || p[1]==0 || p[2]==0) break;
565         }
566     }else{
567         for(i=0; i<3; i++)
568             for(j=0; j<256; j++){
569                 int d= FFMIN(j, 256-j);
570                 
571                 s->stats[i][j]= 100000000/(d+1);
572             }
573     }
574     
575     for(i=0; i<3; i++){
576         generate_len_table(s->len[i], s->stats[i], 256);
577
578         if(generate_bits_table(s->bits[i], s->len[i])<0){
579             return -1;
580         }
581         
582         s->avctx->extradata_size+=
583         store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
584     }
585
586     if(s->context){
587         for(i=0; i<3; i++){
588             int pels = s->width*s->height / (i?40:10);
589             for(j=0; j<256; j++){
590                 int d= FFMIN(j, 256-j);
591                 s->stats[i][j]= pels/(d+1);
592             }
593         }
594     }else{
595         for(i=0; i<3; i++)
596             for(j=0; j<256; j++)
597                 s->stats[i][j]= 0;
598     }
599     
600 //    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
601
602     s->picture_number=0;
603
604     return 0;
605 }
606
607 static void decode_422_bitstream(HYuvContext *s, int count){
608     int i;
609
610     count/=2;
611     
612     for(i=0; i<count; i++){
613         s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
614         s->temp[1][  i  ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
615         s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
616         s->temp[2][  i  ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
617     }
618 }
619
620 static void decode_gray_bitstream(HYuvContext *s, int count){
621     int i;
622     
623     count/=2;
624     
625     for(i=0; i<count; i++){
626         s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
627         s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
628     }
629 }
630
631 static int encode_422_bitstream(HYuvContext *s, int count){
632     int i;
633     
634     if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
635         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
636         return -1;
637     }
638     
639     count/=2;
640     if(s->flags&CODEC_FLAG_PASS1){
641         for(i=0; i<count; i++){
642             s->stats[0][ s->temp[0][2*i  ] ]++;
643             s->stats[1][ s->temp[1][  i  ] ]++;
644             s->stats[0][ s->temp[0][2*i+1] ]++;
645             s->stats[2][ s->temp[2][  i  ] ]++;
646         }
647     }else if(s->context){
648         for(i=0; i<count; i++){
649             s->stats[0][ s->temp[0][2*i  ] ]++;
650             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
651             s->stats[1][ s->temp[1][  i  ] ]++;
652             put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
653             s->stats[0][ s->temp[0][2*i+1] ]++;
654             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
655             s->stats[2][ s->temp[2][  i  ] ]++;
656             put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
657         }
658     }else{
659         for(i=0; i<count; i++){
660             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
661             put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
662             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
663             put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
664         }
665     }
666     return 0;
667 }
668
669 static int encode_gray_bitstream(HYuvContext *s, int count){
670     int i;
671     
672     if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
673         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
674         return -1;
675     }
676
677     count/=2;
678     if(s->flags&CODEC_FLAG_PASS1){
679         for(i=0; i<count; i++){
680             s->stats[0][ s->temp[0][2*i  ] ]++;
681             s->stats[0][ s->temp[0][2*i+1] ]++;
682         }
683     }else if(s->context){
684         for(i=0; i<count; i++){
685             s->stats[0][ s->temp[0][2*i  ] ]++;
686             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
687             s->stats[0][ s->temp[0][2*i+1] ]++;
688             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
689         }
690     }else{
691         for(i=0; i<count; i++){
692             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
693             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
694         }
695     }
696     return 0;
697 }
698
699 static void decode_bgr_bitstream(HYuvContext *s, int count){
700     int i;
701
702     if(s->decorrelate){
703         if(s->bitstream_bpp==24){
704             for(i=0; i<count; i++){
705                 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
706                 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
707                 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
708             }
709         }else{
710             for(i=0; i<count; i++){
711                 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
712                 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
713                 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G]; 
714                                    get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
715             }
716         }
717     }else{
718         if(s->bitstream_bpp==24){
719             for(i=0; i<count; i++){
720                 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
721                 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
722                 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
723             }
724         }else{
725             for(i=0; i<count; i++){
726                 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
727                 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
728                 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
729                                    get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
730             }
731         }
732     }
733 }
734
735 static void draw_slice(HYuvContext *s, int y){
736     int h, cy;
737     int offset[4];
738     
739     if(s->avctx->draw_horiz_band==NULL) 
740         return;
741         
742     h= y - s->last_slice_end;
743     y -= h;
744     
745     if(s->bitstream_bpp==12){
746         cy= y>>1;
747     }else{
748         cy= y;
749     }
750
751     offset[0] = s->picture.linesize[0]*y;
752     offset[1] = s->picture.linesize[1]*cy;
753     offset[2] = s->picture.linesize[2]*cy;
754     offset[3] = 0;
755     emms_c();
756
757     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
758     
759     s->last_slice_end= y + h;
760 }
761
762 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
763     HYuvContext *s = avctx->priv_data;
764     const int width= s->width;
765     const int width2= s->width>>1;
766     const int height= s->height;
767     int fake_ystride, fake_ustride, fake_vstride;
768     AVFrame * const p= &s->picture;
769     int table_size= 0;
770
771     AVFrame *picture = data;
772
773     /* no supplementary picture */
774     if (buf_size == 0)
775         return 0;
776         
777     s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
778
779     s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
780     
781     if(p->data[0])
782         avctx->release_buffer(avctx, p);
783
784     p->reference= 0;
785     if(avctx->get_buffer(avctx, p) < 0){
786         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
787         return -1;
788     }
789     
790     if(s->context){
791         table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
792         if(table_size < 0)
793             return -1;
794     }
795
796     init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
797
798     fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
799     fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
800     fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
801     
802     s->last_slice_end= 0;
803         
804     if(s->bitstream_bpp<24){
805         int y, cy;
806         int lefty, leftu, leftv;
807         int lefttopy, lefttopu, lefttopv;
808         
809         if(s->yuy2){
810             p->data[0][3]= get_bits(&s->gb, 8);
811             p->data[0][2]= get_bits(&s->gb, 8);
812             p->data[0][1]= get_bits(&s->gb, 8);
813             p->data[0][0]= get_bits(&s->gb, 8);
814             
815             av_log(avctx, AV_LOG_ERROR, "YUY2 output isnt implemenetd yet\n");
816             return -1;
817         }else{
818         
819             leftv= p->data[2][0]= get_bits(&s->gb, 8);
820             lefty= p->data[0][1]= get_bits(&s->gb, 8);
821             leftu= p->data[1][0]= get_bits(&s->gb, 8);
822                    p->data[0][0]= get_bits(&s->gb, 8);
823         
824             switch(s->predictor){
825             case LEFT:
826             case PLANE:
827                 decode_422_bitstream(s, width-2);
828                 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
829                 if(!(s->flags&CODEC_FLAG_GRAY)){
830                     leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
831                     leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
832                 }
833
834                 for(cy=y=1; y<s->height; y++,cy++){
835                     uint8_t *ydst, *udst, *vdst;
836                     
837                     if(s->bitstream_bpp==12){
838                         decode_gray_bitstream(s, width);
839                     
840                         ydst= p->data[0] + p->linesize[0]*y;
841
842                         lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
843                         if(s->predictor == PLANE){
844                             if(y>s->interlaced)
845                                 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
846                         }
847                         y++;
848                         if(y>=s->height) break;
849                     }
850                     
851                     draw_slice(s, y);
852                     
853                     ydst= p->data[0] + p->linesize[0]*y;
854                     udst= p->data[1] + p->linesize[1]*cy;
855                     vdst= p->data[2] + p->linesize[2]*cy;
856                     
857                     decode_422_bitstream(s, width);
858                     lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
859                     if(!(s->flags&CODEC_FLAG_GRAY)){
860                         leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
861                         leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
862                     }
863                     if(s->predictor == PLANE){
864                         if(cy>s->interlaced){
865                             s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
866                             if(!(s->flags&CODEC_FLAG_GRAY)){
867                                 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
868                                 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
869                             }
870                         }
871                     }
872                 }
873                 draw_slice(s, height);
874                 
875                 break;
876             case MEDIAN:
877                 /* first line except first 2 pixels is left predicted */
878                 decode_422_bitstream(s, width-2);
879                 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
880                 if(!(s->flags&CODEC_FLAG_GRAY)){
881                     leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
882                     leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
883                 }
884                 
885                 cy=y=1;
886                 
887                 /* second line is left predicted for interlaced case */
888                 if(s->interlaced){
889                     decode_422_bitstream(s, width);
890                     lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
891                     if(!(s->flags&CODEC_FLAG_GRAY)){
892                         leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
893                         leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
894                     }
895                     y++; cy++;
896                 }
897
898                 /* next 4 pixels are left predicted too */
899                 decode_422_bitstream(s, 4);
900                 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
901                 if(!(s->flags&CODEC_FLAG_GRAY)){
902                     leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
903                     leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
904                 }
905
906                 /* next line except the first 4 pixels is median predicted */
907                 lefttopy= p->data[0][3];
908                 decode_422_bitstream(s, width-4);
909                 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
910                 if(!(s->flags&CODEC_FLAG_GRAY)){
911                     lefttopu= p->data[1][1];
912                     lefttopv= p->data[2][1];
913                     add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
914                     add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
915                 }
916                 y++; cy++;
917                 
918                 for(; y<height; y++,cy++){
919                     uint8_t *ydst, *udst, *vdst;
920
921                     if(s->bitstream_bpp==12){
922                         while(2*cy > y){
923                             decode_gray_bitstream(s, width);
924                             ydst= p->data[0] + p->linesize[0]*y;
925                             add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
926                             y++;
927                         }
928                         if(y>=height) break;
929                     }
930                     draw_slice(s, y);
931
932                     decode_422_bitstream(s, width);
933
934                     ydst= p->data[0] + p->linesize[0]*y;
935                     udst= p->data[1] + p->linesize[1]*cy;
936                     vdst= p->data[2] + p->linesize[2]*cy;
937
938                     add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
939                     if(!(s->flags&CODEC_FLAG_GRAY)){
940                         add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
941                         add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
942                     }
943                 }
944
945                 draw_slice(s, height);
946                 break;
947             }
948         }
949     }else{
950         int y;
951         int leftr, leftg, leftb;
952         const int last_line= (height-1)*p->linesize[0];
953         
954         if(s->bitstream_bpp==32){
955             skip_bits(&s->gb, 8);
956             leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
957             leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
958             leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
959         }else{
960             leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
961             leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
962             leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
963             skip_bits(&s->gb, 8);
964         }
965         
966         if(s->bgr32){
967             switch(s->predictor){
968             case LEFT:
969             case PLANE:
970                 decode_bgr_bitstream(s, width-1);
971                 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
972
973                 for(y=s->height-2; y>=0; y--){ //yes its stored upside down
974                     decode_bgr_bitstream(s, width);
975                     
976                     add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
977                     if(s->predictor == PLANE){
978                         if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
979                             s->dsp.add_bytes(p->data[0] + p->linesize[0]*y, 
980                                              p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
981                         }
982                     }
983                 }
984                 draw_slice(s, height); // just 1 large slice as this isnt possible in reverse order
985                 break;
986             default:
987                 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
988             }
989         }else{
990
991             av_log(avctx, AV_LOG_ERROR, "BGR24 output isnt implemenetd yet\n");
992             return -1;
993         }
994     }
995     emms_c();
996     
997     *picture= *p;
998     *data_size = sizeof(AVFrame);
999     
1000     return (get_bits_count(&s->gb)+31)/32*4;
1001 }
1002
1003 static int common_end(HYuvContext *s){
1004     int i;
1005     
1006     for(i=0; i<3; i++){
1007         av_freep(&s->temp[i]);
1008     }
1009     return 0;
1010 }
1011
1012 static int decode_end(AVCodecContext *avctx)
1013 {
1014     HYuvContext *s = avctx->priv_data;
1015     int i;
1016     
1017     common_end(s);
1018     av_freep(&s->bitstream_buffer);
1019     
1020     for(i=0; i<3; i++){
1021         free_vlc(&s->vlc[i]);
1022     }
1023
1024     return 0;
1025 }
1026
1027 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1028     HYuvContext *s = avctx->priv_data;
1029     AVFrame *pict = data;
1030     const int width= s->width;
1031     const int width2= s->width>>1;
1032     const int height= s->height;
1033     const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
1034     const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
1035     const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
1036     AVFrame * const p= &s->picture;
1037     int i, j, size=0;
1038
1039     *p = *pict;
1040     p->pict_type= FF_I_TYPE;
1041     p->key_frame= 1;
1042     
1043     if(s->context){
1044         for(i=0; i<3; i++){
1045             generate_len_table(s->len[i], s->stats[i], 256);
1046             if(generate_bits_table(s->bits[i], s->len[i])<0)
1047                 return -1;
1048             size+= store_table(s, s->len[i], &buf[size]);
1049         }
1050
1051         for(i=0; i<3; i++)
1052             for(j=0; j<256; j++)
1053                 s->stats[i][j] >>= 1;
1054     }
1055
1056     init_put_bits(&s->pb, buf+size, buf_size-size);
1057
1058     if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1059         int lefty, leftu, leftv, y, cy;
1060
1061         put_bits(&s->pb, 8, leftv= p->data[2][0]);
1062         put_bits(&s->pb, 8, lefty= p->data[0][1]);
1063         put_bits(&s->pb, 8, leftu= p->data[1][0]);
1064         put_bits(&s->pb, 8,        p->data[0][0]);
1065         
1066         lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1067         leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1068         leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
1069         
1070         encode_422_bitstream(s, width-2);
1071         
1072         if(s->predictor==MEDIAN){
1073             int lefttopy, lefttopu, lefttopv;
1074             cy=y=1;
1075             if(s->interlaced){
1076                 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1077                 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1078                 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1079         
1080                 encode_422_bitstream(s, width);
1081                 y++; cy++;
1082             }
1083             
1084             lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1085             leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1086             leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1087         
1088             encode_422_bitstream(s, 4);
1089
1090             lefttopy= p->data[0][3];
1091             lefttopu= p->data[1][1];
1092             lefttopv= p->data[2][1];
1093             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1094             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1095             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1096             encode_422_bitstream(s, width-4);
1097             y++; cy++;
1098
1099             for(; y<height; y++,cy++){
1100                 uint8_t *ydst, *udst, *vdst;
1101                     
1102                 if(s->bitstream_bpp==12){
1103                     while(2*cy > y){
1104                         ydst= p->data[0] + p->linesize[0]*y;
1105                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1106                         encode_gray_bitstream(s, width);
1107                         y++;
1108                     }
1109                     if(y>=height) break;
1110                 }
1111                 ydst= p->data[0] + p->linesize[0]*y;
1112                 udst= p->data[1] + p->linesize[1]*cy;
1113                 vdst= p->data[2] + p->linesize[2]*cy;
1114
1115                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1116                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1117                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1118
1119                 encode_422_bitstream(s, width);
1120             }
1121         }else{
1122             for(cy=y=1; y<height; y++,cy++){
1123                 uint8_t *ydst, *udst, *vdst;
1124                 
1125                 /* encode a luma only line & y++ */
1126                 if(s->bitstream_bpp==12){
1127                     ydst= p->data[0] + p->linesize[0]*y;
1128
1129                     if(s->predictor == PLANE && s->interlaced < y){
1130                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1131
1132                         lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1133                     }else{
1134                         lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1135                     }
1136                     encode_gray_bitstream(s, width);
1137                     y++;
1138                     if(y>=height) break;
1139                 }
1140                 
1141                 ydst= p->data[0] + p->linesize[0]*y;
1142                 udst= p->data[1] + p->linesize[1]*cy;
1143                 vdst= p->data[2] + p->linesize[2]*cy;
1144
1145                 if(s->predictor == PLANE && s->interlaced < cy){
1146                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1147                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1148                     s->dsp.diff_bytes(s->temp[2] + 1250, vdst, vdst - fake_vstride, width2);
1149
1150                     lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1151                     leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1152                     leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + 1250, width2, leftv);
1153                 }else{
1154                     lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1155                     leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1156                     leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1157                 }
1158
1159                 encode_422_bitstream(s, width);
1160             }
1161         }        
1162     }else{
1163         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1164     }
1165     emms_c();
1166     
1167     size+= (put_bits_count(&s->pb)+31)/8;
1168     size/= 4;
1169     
1170     if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1171         int j;
1172         char *p= avctx->stats_out;
1173         char *end= p + 1024*30;
1174         for(i=0; i<3; i++){
1175             for(j=0; j<256; j++){
1176                 snprintf(p, end-p, "%llu ", s->stats[i][j]);
1177                 p+= strlen(p);
1178                 s->stats[i][j]= 0;
1179             }
1180             snprintf(p, end-p, "\n");
1181             p++;
1182         }
1183     }else{
1184         flush_put_bits(&s->pb);
1185         s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1186         avctx->stats_out[0] = '\0';
1187     }
1188     
1189     s->picture_number++;
1190
1191     return size*4;
1192 }
1193
1194 static int encode_end(AVCodecContext *avctx)
1195 {
1196     HYuvContext *s = avctx->priv_data;
1197     
1198     common_end(s);
1199
1200     av_freep(&avctx->extradata);
1201     av_freep(&avctx->stats_out);
1202     
1203     return 0;
1204 }
1205
1206 static const AVOption huffyuv_options[] =
1207 {
1208     AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1209     AVOPTION_END()
1210 };
1211
1212 static const AVOption ffvhuff_options[] =
1213 {
1214     AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1215     AVOPTION_CODEC_INT("context_model", "context_model", context_model, 0, 2, 0),
1216     AVOPTION_END()
1217 };
1218
1219
1220 AVCodec huffyuv_decoder = {
1221     "huffyuv",
1222     CODEC_TYPE_VIDEO,
1223     CODEC_ID_HUFFYUV,
1224     sizeof(HYuvContext),
1225     decode_init,
1226     NULL,
1227     decode_end,
1228     decode_frame,
1229     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1230     NULL
1231 };
1232
1233 AVCodec ffvhuff_decoder = {
1234     "ffvhuff",
1235     CODEC_TYPE_VIDEO,
1236     CODEC_ID_FFVHUFF,
1237     sizeof(HYuvContext),
1238     decode_init,
1239     NULL,
1240     decode_end,
1241     decode_frame,
1242     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1243     NULL
1244 };
1245
1246 #ifdef CONFIG_ENCODERS
1247
1248 AVCodec huffyuv_encoder = {
1249     "huffyuv",
1250     CODEC_TYPE_VIDEO,
1251     CODEC_ID_HUFFYUV,
1252     sizeof(HYuvContext),
1253     encode_init,
1254     encode_frame,
1255     encode_end,
1256     .options = huffyuv_options,
1257 };
1258
1259 AVCodec ffvhuff_encoder = {
1260     "ffvhuff",
1261     CODEC_TYPE_VIDEO,
1262     CODEC_ID_FFVHUFF,
1263     sizeof(HYuvContext),
1264     encode_init,
1265     encode_frame,
1266     encode_end,
1267     .options = ffvhuff_options,
1268 };
1269
1270 #endif //CONFIG_ENCODERS