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