more #ifdef CONFIG_ENCODERS by (Wolfgang Hesseler <qv at multimediaware dot com>)
[libav.git] / libavcodec / huffyuv.c
CommitLineData
11f18faf
MN
1/*
2 * huffyuv codec for libavcodec
3 *
aaa1e4cd 4 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
11f18faf
MN
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 */
983e3246
MN
23
24/**
25 * @file huffyuv.c
26 * huffyuv codec for libavcodec.
27 */
11f18faf
MN
28
29#include "common.h"
30#include "avcodec.h"
31#include "dsputil.h"
32
0626afe9
MN
33#ifndef INT64_MAX
34#define INT64_MAX 9223372036854775807LL
11f18faf
MN
35#endif
36
37#define VLC_BITS 11
1e491e29 38
11f18faf
MN
39typedef enum Predictor{
40 LEFT= 0,
41 PLANE,
42 MEDIAN,
43} Predictor;
44
45typedef 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;
7c5ab7b8 59 int last_slice_end;
11f18faf
MN
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];
492cd3a9 65 AVFrame picture;
11f18faf
MN
66 uint8_t __align8 bitstream_buffer[1024*1024*3]; //FIXME dynamic alloc or some other solution
67 DSPContext dsp;
68}HYuvContext;
69
24def10e 70static const unsigned char classic_shift_luma[] = {
676b385c
MN
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
24def10e 76static const unsigned char classic_shift_chroma[] = {
676b385c
MN
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
24def10e 82static const unsigned char classic_add_luma[256] = {
676b385c
MN
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
24def10e 101static const unsigned char classic_add_chroma[256] = {
676b385c
MN
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
11f18faf
MN
120static 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
138static 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
157static 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}
5fd74135
MN
173
174#ifdef CONFIG_ENCODERS
11f18faf
MN
175//FIXME optimize
176static 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
5fd74135 194#endif //CONFIG_ENCODERS
11f18faf
MN
195
196static 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
5fd74135 218#ifdef CONFIG_ENCODERS
7c5ab7b8 219static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
11f18faf 220 int i;
7c5ab7b8
MN
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];
11f18faf 236 }
11f18faf 237}
5fd74135 238#endif //CONFIG_ENCODERS
11f18faf
MN
239static 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
253static 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
5fd74135
MN
273#ifdef CONFIG_ENCODERS
274
11f18faf
MN
275static 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]=
0626afe9 310 counts[min2_i]= INT64_MAX;
11f18faf
MN
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
5fd74135
MN
331#endif //CONFIG_ENCODERS
332
11f18faf
MN
333static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
334 GetBitContext gb;
335 int i;
336
68f593b4 337 init_get_bits(&gb, src, length*8);
11f18faf
MN
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
346for(j=0; j<256; j++){
347printf("%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
356static int read_old_huffman_tables(HYuvContext *s){
676b385c 357#if 1
11f18faf
MN
358 GetBitContext gb;
359 int i;
360
68f593b4 361 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
11f18faf 362 read_len_table(s->len[0], &gb);
68f593b4 363 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
11f18faf
MN
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
386static int decode_init(AVCodecContext *avctx)
387{
388 HYuvContext *s = avctx->priv_data;
1e491e29 389 int width, height;
11f18faf
MN
390
391 s->avctx= avctx;
392 s->flags= avctx->flags;
393
1d98dca3 394 dsputil_init(&s->dsp, avctx);
11f18faf
MN
395
396 width= s->width= avctx->width;
397 height= s->height= avctx->height;
492cd3a9 398 avctx->coded_frame= &s->picture;
1e491e29 399
11f18faf
MN
400s->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){
152ba68c 405 if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
11f18faf
MN
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
11f18faf
MN
455 switch(s->bitstream_bpp){
456 case 12:
457 avctx->pix_fmt = PIX_FMT_YUV420P;
11f18faf
MN
458 break;
459 case 16:
460 if(s->yuy2){
461 avctx->pix_fmt = PIX_FMT_YUV422;
11f18faf
MN
462 }else{
463 avctx->pix_fmt = PIX_FMT_YUV422P;
11f18faf
MN
464 }
465 break;
466 case 24:
467 case 32:
468 if(s->bgr32){
0b2612b1 469 avctx->pix_fmt = PIX_FMT_RGBA32;
11f18faf
MN
470 }else{
471 avctx->pix_fmt = PIX_FMT_BGR24;
11f18faf
MN
472 }
473 break;
474 default:
475 assert(0);
11f18faf
MN
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
5fd74135
MN
483#ifdef CONFIG_ENCODERS
484
11f18faf
MN
485static 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
509static 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
1d98dca3 517 dsputil_init(&s->dsp, avctx);
11f18faf
MN
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
492cd3a9 528 avctx->coded_frame= &s->picture;
1e491e29 529
11f18faf 530 switch(avctx->pix_fmt){
152ba68c
MN
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;
11f18faf
MN
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;
5fd74135 598
11f18faf 599// printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
5fd74135 600
11f18faf 601 s->picture_number=0;
5fd74135 602
11f18faf
MN
603 return 0;
604}
605
5fd74135
MN
606#endif //CONFIG_ENCODERS
607
11f18faf
MN
608static void decode_422_bitstream(HYuvContext *s, int count){
609 int i;
5fd74135 610
11f18faf
MN
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
152ba68c
MN
621static 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
5fd74135
MN
632#ifdef CONFIG_ENCODERS
633
11f18faf
MN
634static 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
152ba68c
MN
655static 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
5fd74135
MN
672#endif //CONFIG_ENCODERS
673
11f18faf
MN
674static void decode_bgr_bitstream(HYuvContext *s, int count){
675 int i;
5fd74135 676
11f18faf
MN
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
7c5ab7b8
MN
710static void draw_slice(HYuvContext *s, int y){
711 int h, cy;
0c1a9eda 712 uint8_t *src_ptr[3];
7c5ab7b8
MN
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
1e491e29
MN
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;
7c5ab7b8
MN
729 emms_c();
730
1e491e29 731 s->avctx->draw_horiz_band(s->avctx, src_ptr, s->picture.linesize[0], y, s->width, h);
7c5ab7b8
MN
732
733 s->last_slice_end= y + h;
734}
735
11f18faf
MN
736static 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;
22f3e8be 741 int fake_ystride, fake_ustride, fake_vstride;
492cd3a9 742 AVFrame * const p= &s->picture;
11f18faf 743
492cd3a9 744 AVFrame *picture = data;
11f18faf
MN
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
68f593b4 754 init_get_bits(&s->gb, s->bitstream_buffer, buf_size*8);
22f3e8be 755
e20c4069
MN
756 if(p->data[0])
757 avctx->release_buffer(avctx, p);
758
1e491e29
MN
759 p->reference= 0;
760 if(avctx->get_buffer(avctx, p) < 0){
761 fprintf(stderr, "get_buffer() failed\n");
762 return -1;
22f3e8be 763 }
1e491e29
MN
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];
7c5ab7b8
MN
768
769 s->last_slice_end= 0;
22f3e8be 770
11f18faf 771 if(s->bitstream_bpp<24){
152ba68c 772 int y, cy;
11f18faf
MN
773 int lefty, leftu, leftv;
774 int lefttopy, lefttopu, lefttopv;
775
776 if(s->yuy2){
1e491e29
MN
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);
11f18faf
MN
781
782 fprintf(stderr, "YUY2 output isnt implemenetd yet\n");
783 return -1;
784 }else{
785
1e491e29
MN
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);
11f18faf
MN
790
791 switch(s->predictor){
792 case LEFT:
793 case PLANE:
794 decode_422_bitstream(s, width-2);
1e491e29 795 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
11f18faf 796 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
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);
11f18faf
MN
799 }
800
152ba68c 801 for(cy=y=1; y<s->height; y++,cy++){
11f18faf 802 uint8_t *ydst, *udst, *vdst;
152ba68c
MN
803
804 if(s->bitstream_bpp==12){
805 decode_gray_bitstream(s, width);
806
1e491e29 807 ydst= p->data[0] + p->linesize[0]*y;
152ba68c
MN
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 }
11f18faf 817
7c5ab7b8
MN
818 draw_slice(s, y);
819
1e491e29
MN
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;
152ba68c
MN
823
824 decode_422_bitstream(s, width);
11f18faf
MN
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){
152ba68c 831 if(cy>s->interlaced){
11f18faf
MN
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 }
7c5ab7b8
MN
840 draw_slice(s, height);
841
11f18faf
MN
842 break;
843 case MEDIAN:
844 /* first line except first 2 pixels is left predicted */
845 decode_422_bitstream(s, width-2);
1e491e29 846 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
11f18faf 847 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
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);
11f18faf
MN
850 }
851
152ba68c 852 cy=y=1;
11f18faf
MN
853
854 /* second line is left predicted for interlaced case */
855 if(s->interlaced){
856 decode_422_bitstream(s, width);
1e491e29 857 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
11f18faf 858 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
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);
11f18faf 861 }
152ba68c 862 y++; cy++;
11f18faf
MN
863 }
864
865 /* next 4 pixels are left predicted too */
866 decode_422_bitstream(s, 4);
1e491e29 867 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
11f18faf 868 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
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);
11f18faf
MN
871 }
872
873 /* next line except the first 4 pixels is median predicted */
1e491e29 874 lefttopy= p->data[0][3];
11f18faf 875 decode_422_bitstream(s, width-4);
1e491e29 876 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
11f18faf 877 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
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);
11f18faf 882 }
152ba68c
MN
883 y++; cy++;
884
885 for(; y<height; y++,cy++){
11f18faf 886 uint8_t *ydst, *udst, *vdst;
152ba68c
MN
887
888 if(s->bitstream_bpp==12){
889 while(2*cy > y){
890 decode_gray_bitstream(s, width);
1e491e29 891 ydst= p->data[0] + p->linesize[0]*y;
152ba68c
MN
892 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
893 y++;
894 }
895 if(y>=height) break;
896 }
7c5ab7b8 897 draw_slice(s, y);
152ba68c 898
11f18faf 899 decode_422_bitstream(s, width);
152ba68c 900
1e491e29
MN
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;
11f18faf
MN
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 }
7c5ab7b8
MN
911
912 draw_slice(s, height);
11f18faf
MN
913 break;
914 }
915 }
916 }else{
917 int y;
918 int leftr, leftg, leftb;
1e491e29 919 const int last_line= (height-1)*p->linesize[0];
11f18faf
MN
920
921 if(s->bitstream_bpp==32){
1e491e29
MN
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);
11f18faf 926 }else{
1e491e29
MN
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);
11f18faf
MN
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);
1e491e29 938 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
11f18faf
MN
939
940 for(y=s->height-2; y>=0; y--){ //yes its stored upside down
941 decode_bgr_bitstream(s, width);
942
1e491e29 943 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
11f18faf
MN
944 if(s->predictor == PLANE){
945 if((y&s->interlaced)==0){
1e491e29
MN
946 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
947 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
11f18faf
MN
948 }
949 }
950 }
7c5ab7b8 951 draw_slice(s, height); // just 1 large slice as this isnt possible in reverse order
11f18faf
MN
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
1e491e29 964 *picture= *p;
492cd3a9 965 *data_size = sizeof(AVFrame);
11f18faf 966
8c031d1c 967 return (get_bits_count(&s->gb)+31)/32*4;
11f18faf
MN
968}
969
970static int decode_end(AVCodecContext *avctx)
971{
972 HYuvContext *s = avctx->priv_data;
973 int i;
974
975 for(i=0; i<3; i++){
11f18faf
MN
976 free_vlc(&s->vlc[i]);
977 }
d90cf87b
MN
978
979 avcodec_default_free_buffers(avctx);
1e491e29 980
11f18faf
MN
981 return 0;
982}
983
5fd74135
MN
984#ifdef CONFIG_ENCODERS
985
11f18faf
MN
986static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
987 HYuvContext *s = avctx->priv_data;
492cd3a9 988 AVFrame *pict = data;
11f18faf
MN
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];
492cd3a9 995 AVFrame * const p= &s->picture;
11f18faf
MN
996 int i, size;
997
998 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
999
1e491e29 1000 *p = *pict;
aaa1e4cd
MN
1001 p->pict_type= FF_I_TYPE;
1002 p->key_frame= 1;
11f18faf 1003
152ba68c
MN
1004 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1005 int lefty, leftu, leftv, y, cy;
11f18faf 1006
1e491e29
MN
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]);
11f18faf 1011
1e491e29
MN
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);
11f18faf
MN
1015
1016 encode_422_bitstream(s, width-2);
1017
1018 if(s->predictor==MEDIAN){
1019 int lefttopy, lefttopu, lefttopv;
152ba68c 1020 cy=y=1;
11f18faf 1021 if(s->interlaced){
1e491e29
MN
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);
11f18faf
MN
1025
1026 encode_422_bitstream(s, width);
152ba68c 1027 y++; cy++;
11f18faf
MN
1028 }
1029
1e491e29
MN
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);
11f18faf
MN
1033
1034 encode_422_bitstream(s, 4);
152ba68c 1035
1e491e29
MN
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);
11f18faf 1042 encode_422_bitstream(s, width-4);
152ba68c 1043 y++; cy++;
11f18faf 1044
152ba68c 1045 for(; y<height; y++,cy++){
11f18faf
MN
1046 uint8_t *ydst, *udst, *vdst;
1047
152ba68c
MN
1048 if(s->bitstream_bpp==12){
1049 while(2*cy > y){
1e491e29 1050 ydst= p->data[0] + p->linesize[0]*y;
152ba68c
MN
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 }
1e491e29
MN
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;
11f18faf
MN
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{
152ba68c 1068 for(cy=y=1; y<height; y++,cy++){
11f18faf 1069 uint8_t *ydst, *udst, *vdst;
152ba68c
MN
1070
1071 /* encode a luma only line & y++ */
1072 if(s->bitstream_bpp==12){
1e491e29 1073 ydst= p->data[0] + p->linesize[0]*y;
152ba68c
MN
1074
1075 if(s->predictor == PLANE && s->interlaced < y){
7c5ab7b8 1076 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
152ba68c 1077
7c5ab7b8 1078 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
152ba68c 1079 }else{
7c5ab7b8 1080 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
152ba68c
MN
1081 }
1082 encode_gray_bitstream(s, width);
1083 y++;
1084 if(y>=height) break;
1085 }
1086
1e491e29
MN
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;
11f18faf 1090
152ba68c 1091 if(s->predictor == PLANE && s->interlaced < cy){
7c5ab7b8
MN
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);
11f18faf 1095
7c5ab7b8
MN
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);
11f18faf 1099 }else{
7c5ab7b8
MN
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);
11f18faf
MN
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{
152ba68c 1128 flush_put_bits(&s->pb);
11f18faf
MN
1129 bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1130 }
1131
11f18faf 1132 s->picture_number++;
1e491e29 1133
11f18faf
MN
1134 return size*4;
1135}
1136
1137static 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
5fd74135
MN
1147#endif //CONFIG_ENCODERS
1148
5d4ce457
ZK
1149static const AVOption huffyuv_options[] =
1150{
1151 AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1152 AVOPTION_END()
1153};
1154
11f18faf
MN
1155AVCodec 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,
7c5ab7b8 1164 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
11f18faf
MN
1165 NULL
1166};
1167
5fd74135
MN
1168#ifdef CONFIG_ENCODERS
1169
11f18faf
MN
1170AVCodec huffyuv_encoder = {
1171 "huffyuv",
1172 CODEC_TYPE_VIDEO,
1173 CODEC_ID_HUFFYUV,
1174 sizeof(HYuvContext),
1175 encode_init,
1176 encode_frame,
1177 encode_end,
5d4ce457 1178 .options = huffyuv_options,
11f18faf 1179};
5fd74135
MN
1180
1181#endif //CONFIG_ENCODERS