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