segfault fix
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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     unsigned 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     av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
347     return -1;
348 #endif
349 }
350
351 static void alloc_temp(HYuvContext *s){
352     int i;
353
354     if(s->bitstream_bpp<24){
355         for(i=0; i<3; i++){
356             s->temp[i]= av_malloc(s->width + 16);
357         }
358     }else{
359         s->temp[0]= av_malloc(4*s->width + 16);
360     }
361 }
362
363 static int common_init(AVCodecContext *avctx){
364     HYuvContext *s = avctx->priv_data;
365
366     s->avctx= avctx;
367     s->flags= avctx->flags;
368
369     dsputil_init(&s->dsp, avctx);
370
371     s->width= avctx->width;
372     s->height= avctx->height;
373     assert(s->width>0 && s->height>0);
374
375     return 0;
376 }
377
378 static int decode_init(AVCodecContext *avctx)
379 {
380     HYuvContext *s = avctx->priv_data;
381
382     common_init(avctx);
383     memset(s->vlc, 0, 3*sizeof(VLC));
384
385     avctx->coded_frame= &s->picture;
386     s->interlaced= s->height > 288;
387
388 s->bgr32=1;
389 //if(avctx->extradata)
390 //  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
391     if(avctx->extradata_size){
392         if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
393             s->version=1; // do such files exist at all?
394         else
395             s->version=2;
396     }else
397         s->version=0;
398
399     if(s->version==2){
400         int method, interlace;
401
402         method= ((uint8_t*)avctx->extradata)[0];
403         s->decorrelate= method&64 ? 1 : 0;
404         s->predictor= method&63;
405         s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
406         if(s->bitstream_bpp==0)
407             s->bitstream_bpp= avctx->bits_per_sample&~7;
408         interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
409         s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
410         s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
411
412         if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
413             return -1;
414     }else{
415         switch(avctx->bits_per_sample&7){
416         case 1:
417             s->predictor= LEFT;
418             s->decorrelate= 0;
419             break;
420         case 2:
421             s->predictor= LEFT;
422             s->decorrelate= 1;
423             break;
424         case 3:
425             s->predictor= PLANE;
426             s->decorrelate= avctx->bits_per_sample >= 24;
427             break;
428         case 4:
429             s->predictor= MEDIAN;
430             s->decorrelate= 0;
431             break;
432         default:
433             s->predictor= LEFT; //OLD
434             s->decorrelate= 0;
435             break;
436         }
437         s->bitstream_bpp= avctx->bits_per_sample & ~7;
438         s->context= 0;
439
440         if(read_old_huffman_tables(s) < 0)
441             return -1;
442     }
443
444     switch(s->bitstream_bpp){
445     case 12:
446         avctx->pix_fmt = PIX_FMT_YUV420P;
447         break;
448     case 16:
449         if(s->yuy2){
450             avctx->pix_fmt = PIX_FMT_YUV422;
451         }else{
452             avctx->pix_fmt = PIX_FMT_YUV422P;
453         }
454         break;
455     case 24:
456     case 32:
457         if(s->bgr32){
458             avctx->pix_fmt = PIX_FMT_RGBA32;
459         }else{
460             avctx->pix_fmt = PIX_FMT_BGR24;
461         }
462         break;
463     default:
464         assert(0);
465     }
466
467     alloc_temp(s);
468
469 //    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);
470
471     return 0;
472 }
473
474 static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
475     int i;
476     int index= 0;
477
478     for(i=0; i<256;){
479         int val= len[i];
480         int repeat=0;
481
482         for(; i<256 && len[i]==val && repeat<255; i++)
483             repeat++;
484
485         assert(val < 32 && val >0 && repeat<256 && repeat>0);
486         if(repeat>7){
487             buf[index++]= val;
488             buf[index++]= repeat;
489         }else{
490             buf[index++]= val | (repeat<<5);
491         }
492     }
493
494     return index;
495 }
496
497 static int encode_init(AVCodecContext *avctx)
498 {
499     HYuvContext *s = avctx->priv_data;
500     int i, j;
501
502     common_init(avctx);
503
504     avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
505     avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
506     s->version=2;
507
508     avctx->coded_frame= &s->picture;
509
510     switch(avctx->pix_fmt){
511     case PIX_FMT_YUV420P:
512         s->bitstream_bpp= 12;
513         break;
514     case PIX_FMT_YUV422P:
515         s->bitstream_bpp= 16;
516         break;
517     default:
518         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
519         return -1;
520     }
521     avctx->bits_per_sample= s->bitstream_bpp;
522     s->decorrelate= s->bitstream_bpp >= 24;
523     s->predictor= avctx->prediction_method;
524     s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
525     if(avctx->context_model==1){
526         s->context= avctx->context_model;
527         if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
528             av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
529             return -1;
530         }
531     }else s->context= 0;
532
533     if(avctx->codec->id==CODEC_ID_HUFFYUV){
534         if(avctx->pix_fmt==PIX_FMT_YUV420P){
535             av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
536             return -1;
537         }
538         if(avctx->context_model){
539             av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
540             return -1;
541         }
542         if(s->interlaced != ( s->height > 288 ))
543             av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
544     }else if(avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
545         av_log(avctx, AV_LOG_ERROR, "This codec is under development; files encoded with it may not be decodable with future versions!!! Set vstrict=-2 / -strict -2 to use it anyway.\n");
546         return -1;
547     }
548
549     ((uint8_t*)avctx->extradata)[0]= s->predictor;
550     ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
551     ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
552     if(s->context)
553         ((uint8_t*)avctx->extradata)[2]|= 0x40;
554     ((uint8_t*)avctx->extradata)[3]= 0;
555     s->avctx->extradata_size= 4;
556
557     if(avctx->stats_in){
558         char *p= avctx->stats_in;
559
560         for(i=0; i<3; i++)
561             for(j=0; j<256; j++)
562                 s->stats[i][j]= 1;
563
564         for(;;){
565             for(i=0; i<3; i++){
566                 char *next;
567
568                 for(j=0; j<256; j++){
569                     s->stats[i][j]+= strtol(p, &next, 0);
570                     if(next==p) return -1;
571                     p=next;
572                 }
573             }
574             if(p[0]==0 || p[1]==0 || p[2]==0) break;
575         }
576     }else{
577         for(i=0; i<3; i++)
578             for(j=0; j<256; j++){
579                 int d= FFMIN(j, 256-j);
580
581                 s->stats[i][j]= 100000000/(d+1);
582             }
583     }
584
585     for(i=0; i<3; i++){
586         generate_len_table(s->len[i], s->stats[i], 256);
587
588         if(generate_bits_table(s->bits[i], s->len[i])<0){
589             return -1;
590         }
591
592         s->avctx->extradata_size+=
593         store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
594     }
595
596     if(s->context){
597         for(i=0; i<3; i++){
598             int pels = s->width*s->height / (i?40:10);
599             for(j=0; j<256; j++){
600                 int d= FFMIN(j, 256-j);
601                 s->stats[i][j]= pels/(d+1);
602             }
603         }
604     }else{
605         for(i=0; i<3; i++)
606             for(j=0; j<256; j++)
607                 s->stats[i][j]= 0;
608     }
609
610 //    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
611
612     alloc_temp(s);
613
614     s->picture_number=0;
615
616     return 0;
617 }
618
619 static void decode_422_bitstream(HYuvContext *s, int count){
620     int i;
621
622     count/=2;
623
624     for(i=0; i<count; i++){
625         s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
626         s->temp[1][  i  ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
627         s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
628         s->temp[2][  i  ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
629     }
630 }
631
632 static void decode_gray_bitstream(HYuvContext *s, int count){
633     int i;
634
635     count/=2;
636
637     for(i=0; i<count; i++){
638         s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
639         s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
640     }
641 }
642
643 static int encode_422_bitstream(HYuvContext *s, int count){
644     int i;
645
646     if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
647         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
648         return -1;
649     }
650
651     count/=2;
652     if(s->flags&CODEC_FLAG_PASS1){
653         for(i=0; i<count; i++){
654             s->stats[0][ s->temp[0][2*i  ] ]++;
655             s->stats[1][ s->temp[1][  i  ] ]++;
656             s->stats[0][ s->temp[0][2*i+1] ]++;
657             s->stats[2][ s->temp[2][  i  ] ]++;
658         }
659     }
660     if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
661         return 0;
662     if(s->context){
663         for(i=0; i<count; i++){
664             s->stats[0][ s->temp[0][2*i  ] ]++;
665             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
666             s->stats[1][ s->temp[1][  i  ] ]++;
667             put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
668             s->stats[0][ s->temp[0][2*i+1] ]++;
669             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
670             s->stats[2][ s->temp[2][  i  ] ]++;
671             put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
672         }
673     }else{
674         for(i=0; i<count; i++){
675             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
676             put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
677             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
678             put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
679         }
680     }
681     return 0;
682 }
683
684 static int encode_gray_bitstream(HYuvContext *s, int count){
685     int i;
686
687     if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
688         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
689         return -1;
690     }
691
692     count/=2;
693     if(s->flags&CODEC_FLAG_PASS1){
694         for(i=0; i<count; i++){
695             s->stats[0][ s->temp[0][2*i  ] ]++;
696             s->stats[0][ s->temp[0][2*i+1] ]++;
697         }
698     }
699     if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
700         return 0;
701
702     if(s->context){
703         for(i=0; i<count; i++){
704             s->stats[0][ s->temp[0][2*i  ] ]++;
705             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
706             s->stats[0][ s->temp[0][2*i+1] ]++;
707             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
708         }
709     }else{
710         for(i=0; i<count; i++){
711             put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
712             put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
713         }
714     }
715     return 0;
716 }
717
718 static void decode_bgr_bitstream(HYuvContext *s, int count){
719     int i;
720
721     if(s->decorrelate){
722         if(s->bitstream_bpp==24){
723             for(i=0; i<count; i++){
724                 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
725                 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
726                 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
727             }
728         }else{
729             for(i=0; i<count; i++){
730                 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
731                 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
732                 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
733                                    get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
734             }
735         }
736     }else{
737         if(s->bitstream_bpp==24){
738             for(i=0; i<count; i++){
739                 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
740                 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
741                 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
742             }
743         }else{
744             for(i=0; i<count; i++){
745                 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
746                 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
747                 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
748                                    get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
749             }
750         }
751     }
752 }
753
754 static void draw_slice(HYuvContext *s, int y){
755     int h, cy;
756     int offset[4];
757
758     if(s->avctx->draw_horiz_band==NULL)
759         return;
760
761     h= y - s->last_slice_end;
762     y -= h;
763
764     if(s->bitstream_bpp==12){
765         cy= y>>1;
766     }else{
767         cy= y;
768     }
769
770     offset[0] = s->picture.linesize[0]*y;
771     offset[1] = s->picture.linesize[1]*cy;
772     offset[2] = s->picture.linesize[2]*cy;
773     offset[3] = 0;
774     emms_c();
775
776     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
777
778     s->last_slice_end= y + h;
779 }
780
781 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
782     HYuvContext *s = avctx->priv_data;
783     const int width= s->width;
784     const int width2= s->width>>1;
785     const int height= s->height;
786     int fake_ystride, fake_ustride, fake_vstride;
787     AVFrame * const p= &s->picture;
788     int table_size= 0;
789
790     AVFrame *picture = data;
791
792     s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
793
794     s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
795
796     if(p->data[0])
797         avctx->release_buffer(avctx, p);
798
799     p->reference= 0;
800     if(avctx->get_buffer(avctx, p) < 0){
801         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
802         return -1;
803     }
804
805     if(s->context){
806         table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
807         if(table_size < 0)
808             return -1;
809     }
810
811     if((unsigned)(buf_size-table_size) >= INT_MAX/8)
812         return -1;
813
814     init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
815
816     fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
817     fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
818     fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
819
820     s->last_slice_end= 0;
821
822     if(s->bitstream_bpp<24){
823         int y, cy;
824         int lefty, leftu, leftv;
825         int lefttopy, lefttopu, lefttopv;
826
827         if(s->yuy2){
828             p->data[0][3]= get_bits(&s->gb, 8);
829             p->data[0][2]= get_bits(&s->gb, 8);
830             p->data[0][1]= get_bits(&s->gb, 8);
831             p->data[0][0]= get_bits(&s->gb, 8);
832
833             av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
834             return -1;
835         }else{
836
837             leftv= p->data[2][0]= get_bits(&s->gb, 8);
838             lefty= p->data[0][1]= get_bits(&s->gb, 8);
839             leftu= p->data[1][0]= get_bits(&s->gb, 8);
840                    p->data[0][0]= get_bits(&s->gb, 8);
841
842             switch(s->predictor){
843             case LEFT:
844             case PLANE:
845                 decode_422_bitstream(s, width-2);
846                 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
847                 if(!(s->flags&CODEC_FLAG_GRAY)){
848                     leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
849                     leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
850                 }
851
852                 for(cy=y=1; y<s->height; y++,cy++){
853                     uint8_t *ydst, *udst, *vdst;
854
855                     if(s->bitstream_bpp==12){
856                         decode_gray_bitstream(s, width);
857
858                         ydst= p->data[0] + p->linesize[0]*y;
859
860                         lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
861                         if(s->predictor == PLANE){
862                             if(y>s->interlaced)
863                                 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
864                         }
865                         y++;
866                         if(y>=s->height) break;
867                     }
868
869                     draw_slice(s, y);
870
871                     ydst= p->data[0] + p->linesize[0]*y;
872                     udst= p->data[1] + p->linesize[1]*cy;
873                     vdst= p->data[2] + p->linesize[2]*cy;
874
875                     decode_422_bitstream(s, width);
876                     lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
877                     if(!(s->flags&CODEC_FLAG_GRAY)){
878                         leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
879                         leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
880                     }
881                     if(s->predictor == PLANE){
882                         if(cy>s->interlaced){
883                             s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
884                             if(!(s->flags&CODEC_FLAG_GRAY)){
885                                 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
886                                 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
887                             }
888                         }
889                     }
890                 }
891                 draw_slice(s, height);
892
893                 break;
894             case MEDIAN:
895                 /* first line except first 2 pixels is left predicted */
896                 decode_422_bitstream(s, width-2);
897                 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
898                 if(!(s->flags&CODEC_FLAG_GRAY)){
899                     leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
900                     leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
901                 }
902
903                 cy=y=1;
904
905                 /* second line is left predicted for interlaced case */
906                 if(s->interlaced){
907                     decode_422_bitstream(s, width);
908                     lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
909                     if(!(s->flags&CODEC_FLAG_GRAY)){
910                         leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
911                         leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
912                     }
913                     y++; cy++;
914                 }
915
916                 /* next 4 pixels are left predicted too */
917                 decode_422_bitstream(s, 4);
918                 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
919                 if(!(s->flags&CODEC_FLAG_GRAY)){
920                     leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
921                     leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
922                 }
923
924                 /* next line except the first 4 pixels is median predicted */
925                 lefttopy= p->data[0][3];
926                 decode_422_bitstream(s, width-4);
927                 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
928                 if(!(s->flags&CODEC_FLAG_GRAY)){
929                     lefttopu= p->data[1][1];
930                     lefttopv= p->data[2][1];
931                     add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
932                     add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
933                 }
934                 y++; cy++;
935
936                 for(; y<height; y++,cy++){
937                     uint8_t *ydst, *udst, *vdst;
938
939                     if(s->bitstream_bpp==12){
940                         while(2*cy > y){
941                             decode_gray_bitstream(s, width);
942                             ydst= p->data[0] + p->linesize[0]*y;
943                             add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
944                             y++;
945                         }
946                         if(y>=height) break;
947                     }
948                     draw_slice(s, y);
949
950                     decode_422_bitstream(s, width);
951
952                     ydst= p->data[0] + p->linesize[0]*y;
953                     udst= p->data[1] + p->linesize[1]*cy;
954                     vdst= p->data[2] + p->linesize[2]*cy;
955
956                     add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
957                     if(!(s->flags&CODEC_FLAG_GRAY)){
958                         add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
959                         add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
960                     }
961                 }
962
963                 draw_slice(s, height);
964                 break;
965             }
966         }
967     }else{
968         int y;
969         int leftr, leftg, leftb;
970         const int last_line= (height-1)*p->linesize[0];
971
972         if(s->bitstream_bpp==32){
973             skip_bits(&s->gb, 8);
974             leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
975             leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
976             leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
977         }else{
978             leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
979             leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
980             leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
981             skip_bits(&s->gb, 8);
982         }
983
984         if(s->bgr32){
985             switch(s->predictor){
986             case LEFT:
987             case PLANE:
988                 decode_bgr_bitstream(s, width-1);
989                 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
990
991                 for(y=s->height-2; y>=0; y--){ //yes its stored upside down
992                     decode_bgr_bitstream(s, width);
993
994                     add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
995                     if(s->predictor == PLANE){
996                         if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
997                             s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
998                                              p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
999                         }
1000                     }
1001                 }
1002                 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1003                 break;
1004             default:
1005                 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1006             }
1007         }else{
1008
1009             av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1010             return -1;
1011         }
1012     }
1013     emms_c();
1014
1015     *picture= *p;
1016     *data_size = sizeof(AVFrame);
1017
1018     return (get_bits_count(&s->gb)+31)/32*4;
1019 }
1020
1021 static int common_end(HYuvContext *s){
1022     int i;
1023
1024     for(i=0; i<3; i++){
1025         av_freep(&s->temp[i]);
1026     }
1027     return 0;
1028 }
1029
1030 static int decode_end(AVCodecContext *avctx)
1031 {
1032     HYuvContext *s = avctx->priv_data;
1033     int i;
1034
1035     common_end(s);
1036     av_freep(&s->bitstream_buffer);
1037
1038     for(i=0; i<3; i++){
1039         free_vlc(&s->vlc[i]);
1040     }
1041
1042     return 0;
1043 }
1044
1045 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1046     HYuvContext *s = avctx->priv_data;
1047     AVFrame *pict = data;
1048     const int width= s->width;
1049     const int width2= s->width>>1;
1050     const int height= s->height;
1051     const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
1052     const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
1053     const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
1054     AVFrame * const p= &s->picture;
1055     int i, j, size=0;
1056
1057     *p = *pict;
1058     p->pict_type= FF_I_TYPE;
1059     p->key_frame= 1;
1060
1061     if(s->context){
1062         for(i=0; i<3; i++){
1063             generate_len_table(s->len[i], s->stats[i], 256);
1064             if(generate_bits_table(s->bits[i], s->len[i])<0)
1065                 return -1;
1066             size+= store_table(s, s->len[i], &buf[size]);
1067         }
1068
1069         for(i=0; i<3; i++)
1070             for(j=0; j<256; j++)
1071                 s->stats[i][j] >>= 1;
1072     }
1073
1074     init_put_bits(&s->pb, buf+size, buf_size-size);
1075
1076     if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1077         int lefty, leftu, leftv, y, cy;
1078
1079         put_bits(&s->pb, 8, leftv= p->data[2][0]);
1080         put_bits(&s->pb, 8, lefty= p->data[0][1]);
1081         put_bits(&s->pb, 8, leftu= p->data[1][0]);
1082         put_bits(&s->pb, 8,        p->data[0][0]);
1083
1084         lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1085         leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1086         leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
1087
1088         encode_422_bitstream(s, width-2);
1089
1090         if(s->predictor==MEDIAN){
1091             int lefttopy, lefttopu, lefttopv;
1092             cy=y=1;
1093             if(s->interlaced){
1094                 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1095                 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1096                 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1097
1098                 encode_422_bitstream(s, width);
1099                 y++; cy++;
1100             }
1101
1102             lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1103             leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1104             leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1105
1106             encode_422_bitstream(s, 4);
1107
1108             lefttopy= p->data[0][3];
1109             lefttopu= p->data[1][1];
1110             lefttopv= p->data[2][1];
1111             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1112             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1113             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1114             encode_422_bitstream(s, width-4);
1115             y++; cy++;
1116
1117             for(; y<height; y++,cy++){
1118                 uint8_t *ydst, *udst, *vdst;
1119
1120                 if(s->bitstream_bpp==12){
1121                     while(2*cy > y){
1122                         ydst= p->data[0] + p->linesize[0]*y;
1123                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1124                         encode_gray_bitstream(s, width);
1125                         y++;
1126                     }
1127                     if(y>=height) break;
1128                 }
1129                 ydst= p->data[0] + p->linesize[0]*y;
1130                 udst= p->data[1] + p->linesize[1]*cy;
1131                 vdst= p->data[2] + p->linesize[2]*cy;
1132
1133                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1134                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1135                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1136
1137                 encode_422_bitstream(s, width);
1138             }
1139         }else{
1140             for(cy=y=1; y<height; y++,cy++){
1141                 uint8_t *ydst, *udst, *vdst;
1142
1143                 /* encode a luma only line & y++ */
1144                 if(s->bitstream_bpp==12){
1145                     ydst= p->data[0] + p->linesize[0]*y;
1146
1147                     if(s->predictor == PLANE && s->interlaced < y){
1148                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1149
1150                         lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1151                     }else{
1152                         lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1153                     }
1154                     encode_gray_bitstream(s, width);
1155                     y++;
1156                     if(y>=height) break;
1157                 }
1158
1159                 ydst= p->data[0] + p->linesize[0]*y;
1160                 udst= p->data[1] + p->linesize[1]*cy;
1161                 vdst= p->data[2] + p->linesize[2]*cy;
1162
1163                 if(s->predictor == PLANE && s->interlaced < cy){
1164                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1165                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1166                     s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1167
1168                     lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1169                     leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1170                     leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1171                 }else{
1172                     lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1173                     leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1174                     leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1175                 }
1176
1177                 encode_422_bitstream(s, width);
1178             }
1179         }
1180     }else{
1181         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1182     }
1183     emms_c();
1184
1185     size+= (put_bits_count(&s->pb)+31)/8;
1186     size/= 4;
1187
1188     if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1189         int j;
1190         char *p= avctx->stats_out;
1191         char *end= p + 1024*30;
1192         for(i=0; i<3; i++){
1193             for(j=0; j<256; j++){
1194                 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1195                 p+= strlen(p);
1196                 s->stats[i][j]= 0;
1197             }
1198             snprintf(p, end-p, "\n");
1199             p++;
1200         }
1201     }
1202     if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1203         flush_put_bits(&s->pb);
1204         s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1205         avctx->stats_out[0] = '\0';
1206     }
1207
1208     s->picture_number++;
1209
1210     return size*4;
1211 }
1212
1213 static int encode_end(AVCodecContext *avctx)
1214 {
1215     HYuvContext *s = avctx->priv_data;
1216
1217     common_end(s);
1218
1219     av_freep(&avctx->extradata);
1220     av_freep(&avctx->stats_out);
1221
1222     return 0;
1223 }
1224
1225 AVCodec huffyuv_decoder = {
1226     "huffyuv",
1227     CODEC_TYPE_VIDEO,
1228     CODEC_ID_HUFFYUV,
1229     sizeof(HYuvContext),
1230     decode_init,
1231     NULL,
1232     decode_end,
1233     decode_frame,
1234     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1235     NULL
1236 };
1237
1238 AVCodec ffvhuff_decoder = {
1239     "ffvhuff",
1240     CODEC_TYPE_VIDEO,
1241     CODEC_ID_FFVHUFF,
1242     sizeof(HYuvContext),
1243     decode_init,
1244     NULL,
1245     decode_end,
1246     decode_frame,
1247     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1248     NULL
1249 };
1250
1251 #ifdef CONFIG_ENCODERS
1252
1253 AVCodec huffyuv_encoder = {
1254     "huffyuv",
1255     CODEC_TYPE_VIDEO,
1256     CODEC_ID_HUFFYUV,
1257     sizeof(HYuvContext),
1258     encode_init,
1259     encode_frame,
1260     encode_end,
1261 };
1262
1263 AVCodec ffvhuff_encoder = {
1264     "ffvhuff",
1265     CODEC_TYPE_VIDEO,
1266     CODEC_ID_FFVHUFF,
1267     sizeof(HYuvContext),
1268     encode_init,
1269     encode_frame,
1270     encode_end,
1271 };
1272
1273 #endif //CONFIG_ENCODERS