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