VirtualBox

source: vbox/trunk/src/libs/ffmpeg-20060710/libavcodec/huffyuv.c@ 9441

Last change on this file since 9441 was 5776, checked in by vboxsync, 17 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette