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