2 * huffyuv codec for libavcodec
4 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
6 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
9 * This file is part of FFmpeg.
11 * FFmpeg is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * FFmpeg is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with FFmpeg; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 * huffyuv codec for libavcodec.
53 typedef enum Predictor{
59 typedef struct HYuvContext{
60 AVCodecContext *avctx;
68 int yuy2; //use yuy2 instead of 422P
69 int bgr32; //use bgr32 instead of bgr24
76 uint64_t stats[3][256];
78 uint32_t bits[3][256];
79 uint32_t pix_bgr_map[1<<VLC_BITS];
80 VLC vlc[6]; //Y,U,V,YY,YU,YV
82 uint8_t *bitstream_buffer;
83 unsigned int bitstream_buffer_size;
87 #define classic_shift_luma_table_size 42
88 static const unsigned char classic_shift_luma[classic_shift_luma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {
89 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
90 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
95 #define classic_shift_chroma_table_size 59
96 static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {
97 66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
98 56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
99 214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0,
103 static const unsigned char classic_add_luma[256] = {
104 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
105 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
106 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
107 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
108 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
109 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
110 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
111 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
112 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
113 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
114 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
115 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
116 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
117 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
118 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
119 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
122 static const unsigned char classic_add_chroma[256] = {
123 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
124 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
125 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
126 43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
127 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
128 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
129 17, 14, 5, 6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
130 112,113,114,115, 4,117,118, 92, 94,121,122, 3,124,103, 2, 1,
131 0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
132 135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
133 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
134 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
135 7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
136 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
137 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
138 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
141 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int left){
145 const int temp= src[i];
152 const int temp= src[i];
156 s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
161 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha){
168 for(i=0; i<FFMIN(w,4); i++){
169 const int rt= src[i*4+R];
170 const int gt= src[i*4+G];
171 const int bt= src[i*4+B];
172 const int at= src[i*4+A];
182 s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
183 *red= src[(w-1)*4+R];
184 *green= src[(w-1)*4+G];
185 *blue= src[(w-1)*4+B];
186 *alpha= src[(w-1)*4+A];
189 static inline void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue){
195 for(i=0; i<FFMIN(w,16); i++){
196 const int rt= src[i*3+0];
197 const int gt= src[i*3+1];
198 const int bt= src[i*3+2];
206 s->dsp.diff_bytes(dst+48, src+48, src+48-3, w*3-48);
207 *red= src[(w-1)*3+0];
208 *green= src[(w-1)*3+1];
209 *blue= src[(w-1)*3+2];
212 static int read_len_table(uint8_t *dst, GetBitContext *gb){
216 repeat= get_bits(gb, 3);
217 val = get_bits(gb, 5);
219 repeat= get_bits(gb, 8);
220 //printf("%d %d\n", val, repeat);
221 if(i+repeat > 256 || get_bits_left(gb) < 0) {
222 av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
231 static int generate_bits_table(uint32_t *dst, const uint8_t *len_table){
235 for(len=32; len>0; len--){
236 for(index=0; index<256; index++){
237 if(len_table[index]==len)
241 av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
249 static void generate_joint_tables(HYuvContext *s){
250 uint16_t symbols[1<<VLC_BITS];
251 uint16_t bits[1<<VLC_BITS];
252 uint8_t len[1<<VLC_BITS];
253 if(s->bitstream_bpp < 24){
256 for(i=y=0; y<256; y++){
257 int len0 = s->len[0][y];
258 int limit = VLC_BITS - len0;
261 for(u=0; u<256; u++){
262 int len1 = s->len[p][u];
265 len[i] = len0 + len1;
266 bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
267 symbols[i] = (y<<8) + u;
268 if(symbols[i] != 0xffff) // reserved to mean "invalid"
272 ff_free_vlc(&s->vlc[3+p]);
273 ff_init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
276 uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
277 int i, b, g, r, code;
278 int p0 = s->decorrelate;
279 int p1 = !s->decorrelate;
280 // restrict the range to +/-16 becaues that's pretty much guaranteed to
281 // cover all the combinations that fit in 11 bits total, and it doesn't
282 // matter if we miss a few rare codes.
283 for(i=0, g=-16; g<16; g++){
284 int len0 = s->len[p0][g&255];
285 int limit0 = VLC_BITS - len0;
288 for(b=-16; b<16; b++){
289 int len1 = s->len[p1][b&255];
290 int limit1 = limit0 - len1;
293 code = (s->bits[p0][g&255] << len1) + s->bits[p1][b&255];
294 for(r=-16; r<16; r++){
295 int len2 = s->len[2][r&255];
298 len[i] = len0 + len1 + len2;
299 bits[i] = (code << len2) + s->bits[2][r&255];
313 ff_free_vlc(&s->vlc[3]);
314 init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
318 static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length){
322 init_get_bits(&gb, src, length*8);
325 if(read_len_table(s->len[i], &gb)<0)
327 if(generate_bits_table(s->bits[i], s->len[i])<0){
330 ff_free_vlc(&s->vlc[i]);
331 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
334 generate_joint_tables(s);
336 return (get_bits_count(&gb)+7)/8;
339 static int read_old_huffman_tables(HYuvContext *s){
343 init_get_bits(&gb, classic_shift_luma, classic_shift_luma_table_size*8);
344 if(read_len_table(s->len[0], &gb)<0)
346 init_get_bits(&gb, classic_shift_chroma, classic_shift_chroma_table_size*8);
347 if(read_len_table(s->len[1], &gb)<0)
350 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i];
351 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
353 if(s->bitstream_bpp >= 24){
354 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
355 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
357 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
358 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
361 ff_free_vlc(&s->vlc[i]);
362 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
365 generate_joint_tables(s);
370 static av_cold void alloc_temp(HYuvContext *s){
373 if(s->bitstream_bpp<24){
375 s->temp[i]= av_malloc(s->width + 16);
378 s->temp[0]= av_mallocz(4*s->width + 16);
382 static av_cold int common_init(AVCodecContext *avctx){
383 HYuvContext *s = avctx->priv_data;
386 s->flags= avctx->flags;
388 ff_dsputil_init(&s->dsp, avctx);
390 s->width= avctx->width;
391 s->height= avctx->height;
392 av_assert1(s->width>0 && s->height>0);
397 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
398 static av_cold int decode_init(AVCodecContext *avctx)
400 HYuvContext *s = avctx->priv_data;
403 memset(s->vlc, 0, 3*sizeof(VLC));
405 avctx->coded_frame= &s->picture;
406 avcodec_get_frame_defaults(&s->picture);
407 s->interlaced= s->height > 288;
410 //if(avctx->extradata)
411 // printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
412 if(avctx->extradata_size){
413 if((avctx->bits_per_coded_sample&7) && avctx->bits_per_coded_sample != 12)
414 s->version=1; // do such files exist at all?
421 int method, interlace;
423 if (avctx->extradata_size < 4)
426 method= ((uint8_t*)avctx->extradata)[0];
427 s->decorrelate= method&64 ? 1 : 0;
428 s->predictor= method&63;
429 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
430 if(s->bitstream_bpp==0)
431 s->bitstream_bpp= avctx->bits_per_coded_sample&~7;
432 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
433 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
434 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
436 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size-4) < 0)
439 switch(avctx->bits_per_coded_sample&7){
450 s->decorrelate= avctx->bits_per_coded_sample >= 24;
453 s->predictor= MEDIAN;
457 s->predictor= LEFT; //OLD
461 s->bitstream_bpp= avctx->bits_per_coded_sample & ~7;
464 if(read_old_huffman_tables(s) < 0)
468 switch(s->bitstream_bpp){
470 avctx->pix_fmt = PIX_FMT_YUV420P;
474 avctx->pix_fmt = PIX_FMT_YUYV422;
476 avctx->pix_fmt = PIX_FMT_YUV422P;
482 avctx->pix_fmt = PIX_FMT_RGB32;
484 avctx->pix_fmt = PIX_FMT_BGR24;
488 return AVERROR_INVALIDDATA;
491 if ((avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P) && avctx->width & 1) {
492 av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
493 return AVERROR_INVALIDDATA;
498 // av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
503 static av_cold int decode_init_thread_copy(AVCodecContext *avctx)
505 HYuvContext *s = avctx->priv_data;
508 avctx->coded_frame= &s->picture;
511 for (i = 0; i < 6; i++)
512 s->vlc[i].table = NULL;
515 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
518 if(read_old_huffman_tables(s) < 0)
524 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
526 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
527 static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf){
535 for(; i<256 && len[i]==val && repeat<255; i++)
538 av_assert0(val < 32 && val >0 && repeat<256 && repeat>0);
541 buf[index++]= repeat;
543 buf[index++]= val | (repeat<<5);
550 static av_cold int encode_init(AVCodecContext *avctx)
552 HYuvContext *s = avctx->priv_data;
557 avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
558 avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
561 avctx->coded_frame= &s->picture;
563 switch(avctx->pix_fmt){
564 case PIX_FMT_YUV420P:
565 case PIX_FMT_YUV422P:
567 av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
568 return AVERROR(EINVAL);
570 s->bitstream_bpp = avctx->pix_fmt == PIX_FMT_YUV420P ? 12 : 16;
573 s->bitstream_bpp= 32;
576 s->bitstream_bpp= 24;
579 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
582 avctx->bits_per_coded_sample= s->bitstream_bpp;
583 s->decorrelate= s->bitstream_bpp >= 24;
584 s->predictor= avctx->prediction_method;
585 s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
586 if(avctx->context_model==1){
587 s->context= avctx->context_model;
588 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
589 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
594 if(avctx->codec->id==AV_CODEC_ID_HUFFYUV){
595 if(avctx->pix_fmt==PIX_FMT_YUV420P){
596 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
599 if(avctx->context_model){
600 av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
603 if(s->interlaced != ( s->height > 288 ))
604 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
607 if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
608 av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
612 ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
613 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
614 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
616 ((uint8_t*)avctx->extradata)[2]|= 0x40;
617 ((uint8_t*)avctx->extradata)[3]= 0;
618 s->avctx->extradata_size= 4;
621 char *p= avctx->stats_in;
631 for(j=0; j<256; j++){
632 s->stats[i][j]+= strtol(p, &next, 0);
633 if(next==p) return -1;
637 if(p[0]==0 || p[1]==0 || p[2]==0) break;
641 for(j=0; j<256; j++){
642 int d= FFMIN(j, 256-j);
644 s->stats[i][j]= 100000000/(d+1);
649 ff_generate_len_table(s->len[i], s->stats[i]);
651 if(generate_bits_table(s->bits[i], s->len[i])<0){
655 s->avctx->extradata_size+=
656 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
661 int pels = s->width*s->height / (i?40:10);
662 for(j=0; j<256; j++){
663 int d= FFMIN(j, 256-j);
664 s->stats[i][j]= pels/(d+1);
673 // printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
681 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
683 /* TODO instead of restarting the read when the code isn't in the first level
684 * of the joint table, jump into the 2nd level of the individual table. */
685 #define READ_2PIX(dst0, dst1, plane1){\
686 uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
691 dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
692 dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
696 static void decode_422_bitstream(HYuvContext *s, int count){
701 if(count >= (get_bits_left(&s->gb))/(31*4)){
702 for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
703 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
704 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
707 for(i=0; i<count; i++){
708 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
709 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
714 static void decode_gray_bitstream(HYuvContext *s, int count){
719 if(count >= (get_bits_left(&s->gb))/(31*2)){
720 for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
721 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
724 for(i=0; i<count; i++){
725 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
730 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
731 static int encode_422_bitstream(HYuvContext *s, int offset, int count){
733 const uint8_t *y = s->temp[0] + offset;
734 const uint8_t *u = s->temp[1] + offset/2;
735 const uint8_t *v = s->temp[2] + offset/2;
737 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
738 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
749 if(s->flags&CODEC_FLAG_PASS1){
750 for(i=0; i<count; i++){
758 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
761 for(i=0; i<count; i++){
764 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
766 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
768 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
770 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
773 for(i=0; i<count; i++){
775 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
776 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
777 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
778 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
784 static int encode_gray_bitstream(HYuvContext *s, int count){
787 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
788 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
793 int y0 = s->temp[0][2*i];\
794 int y1 = s->temp[0][2*i+1];
799 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
800 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
803 if(s->flags&CODEC_FLAG_PASS1){
804 for(i=0; i<count; i++){
809 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
813 for(i=0; i<count; i++){
819 for(i=0; i<count; i++){
826 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
828 static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
830 for(i=0; i<count; i++){
831 int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
833 *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
834 }else if(decorrelate){
835 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
836 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
837 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
839 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
840 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
841 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
844 s->temp[0][4*i+A] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
848 static void decode_bgr_bitstream(HYuvContext *s, int count){
850 if(s->bitstream_bpp==24)
851 decode_bgr_1(s, count, 1, 0);
853 decode_bgr_1(s, count, 1, 1);
855 if(s->bitstream_bpp==24)
856 decode_bgr_1(s, count, 0, 0);
858 decode_bgr_1(s, count, 0, 1);
862 static inline int encode_bgra_bitstream(HYuvContext *s, int count, int planes){
865 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*planes*count){
866 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
871 int g= s->temp[0][planes==3 ? 3*i+1 : 4*i+G];\
872 int b= (s->temp[0][planes==3 ? 3*i+2 : 4*i+B] - g) & 0xff;\
873 int r= (s->temp[0][planes==3 ? 3*i+0 : 4*i+R] - g) & 0xff;\
874 int a= s->temp[0][planes*i+A];
879 if(planes==4) s->stats[2][a]++;
881 put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
882 put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
883 put_bits(&s->pb, s->len[2][r], s->bits[2][r]);\
884 if(planes==4) put_bits(&s->pb, s->len[2][a], s->bits[2][a]);
886 if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
887 for(i=0; i<count; i++){
891 }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
892 for(i=0; i<count; i++){
898 for(i=0; i<count; i++){
906 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
907 static void draw_slice(HYuvContext *s, int y){
909 int offset[AV_NUM_DATA_POINTERS];
911 if(s->avctx->draw_horiz_band==NULL)
914 h= y - s->last_slice_end;
917 if(s->bitstream_bpp==12){
923 offset[0] = s->picture.linesize[0]*y;
924 offset[1] = s->picture.linesize[1]*cy;
925 offset[2] = s->picture.linesize[2]*cy;
926 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
930 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
932 s->last_slice_end= y + h;
935 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
936 const uint8_t *buf = avpkt->data;
937 int buf_size = avpkt->size;
938 HYuvContext *s = avctx->priv_data;
939 const int width= s->width;
940 const int width2= s->width>>1;
941 const int height= s->height;
942 int fake_ystride, fake_ustride, fake_vstride;
943 AVFrame * const p= &s->picture;
946 AVFrame *picture = data;
948 av_fast_malloc(&s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
949 if (!s->bitstream_buffer)
950 return AVERROR(ENOMEM);
952 memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
953 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
956 ff_thread_release_buffer(avctx, p);
959 if(ff_thread_get_buffer(avctx, p) < 0){
960 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
965 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
970 if((unsigned)(buf_size-table_size) >= INT_MAX/8)
973 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
975 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0];
976 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1];
977 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2];
979 s->last_slice_end= 0;
981 if(s->bitstream_bpp<24){
983 int lefty, leftu, leftv;
984 int lefttopy, lefttopu, lefttopv;
987 p->data[0][3]= get_bits(&s->gb, 8);
988 p->data[0][2]= get_bits(&s->gb, 8);
989 p->data[0][1]= get_bits(&s->gb, 8);
990 p->data[0][0]= get_bits(&s->gb, 8);
992 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
996 leftv= p->data[2][0]= get_bits(&s->gb, 8);
997 lefty= p->data[0][1]= get_bits(&s->gb, 8);
998 leftu= p->data[1][0]= get_bits(&s->gb, 8);
999 p->data[0][0]= get_bits(&s->gb, 8);
1001 switch(s->predictor){
1004 decode_422_bitstream(s, width-2);
1005 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1006 if(!(s->flags&CODEC_FLAG_GRAY)){
1007 leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1008 leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1011 for(cy=y=1; y<s->height; y++,cy++){
1012 uint8_t *ydst, *udst, *vdst;
1014 if(s->bitstream_bpp==12){
1015 decode_gray_bitstream(s, width);
1017 ydst= p->data[0] + p->linesize[0]*y;
1019 lefty= s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
1020 if(s->predictor == PLANE){
1022 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1025 if(y>=s->height) break;
1030 ydst= p->data[0] + p->linesize[0]*y;
1031 udst= p->data[1] + p->linesize[1]*cy;
1032 vdst= p->data[2] + p->linesize[2]*cy;
1034 decode_422_bitstream(s, width);
1035 lefty= s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
1036 if(!(s->flags&CODEC_FLAG_GRAY)){
1037 leftu= s->dsp.add_hfyu_left_prediction(udst, s->temp[1], width2, leftu);
1038 leftv= s->dsp.add_hfyu_left_prediction(vdst, s->temp[2], width2, leftv);
1040 if(s->predictor == PLANE){
1041 if(cy>s->interlaced){
1042 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1043 if(!(s->flags&CODEC_FLAG_GRAY)){
1044 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1045 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1050 draw_slice(s, height);
1054 /* first line except first 2 pixels is left predicted */
1055 decode_422_bitstream(s, width-2);
1056 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1057 if(!(s->flags&CODEC_FLAG_GRAY)){
1058 leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1059 leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1064 /* second line is left predicted for interlaced case */
1066 decode_422_bitstream(s, width);
1067 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1068 if(!(s->flags&CODEC_FLAG_GRAY)){
1069 leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1070 leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1075 /* next 4 pixels are left predicted too */
1076 decode_422_bitstream(s, 4);
1077 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1078 if(!(s->flags&CODEC_FLAG_GRAY)){
1079 leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1080 leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1083 /* next line except the first 4 pixels is median predicted */
1084 lefttopy= p->data[0][3];
1085 decode_422_bitstream(s, width-4);
1086 s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1087 if(!(s->flags&CODEC_FLAG_GRAY)){
1088 lefttopu= p->data[1][1];
1089 lefttopv= p->data[2][1];
1090 s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
1091 s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
1095 for(; y<height; y++,cy++){
1096 uint8_t *ydst, *udst, *vdst;
1098 if(s->bitstream_bpp==12){
1100 decode_gray_bitstream(s, width);
1101 ydst= p->data[0] + p->linesize[0]*y;
1102 s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1105 if(y>=height) break;
1109 decode_422_bitstream(s, width);
1111 ydst= p->data[0] + p->linesize[0]*y;
1112 udst= p->data[1] + p->linesize[1]*cy;
1113 vdst= p->data[2] + p->linesize[2]*cy;
1115 s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1116 if(!(s->flags&CODEC_FLAG_GRAY)){
1117 s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1118 s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1122 draw_slice(s, height);
1128 int leftr, leftg, leftb, lefta;
1129 const int last_line= (height-1)*p->linesize[0];
1131 if(s->bitstream_bpp==32){
1132 lefta= p->data[0][last_line+A]= get_bits(&s->gb, 8);
1133 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1134 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1135 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1137 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1138 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1139 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1140 lefta= p->data[0][last_line+A]= 255;
1141 skip_bits(&s->gb, 8);
1145 switch(s->predictor){
1148 decode_bgr_bitstream(s, width-1);
1149 s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb, &lefta);
1151 for(y=s->height-2; y>=0; y--){ //Yes it is stored upside down.
1152 decode_bgr_bitstream(s, width);
1154 s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb, &lefta);
1155 if(s->predictor == PLANE){
1156 if(s->bitstream_bpp!=32) lefta=0;
1157 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
1158 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
1159 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
1163 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1166 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1170 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1177 *data_size = sizeof(AVFrame);
1179 return (get_bits_count(&s->gb)+31)/32*4 + table_size;
1181 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1183 static int common_end(HYuvContext *s){
1187 av_freep(&s->temp[i]);
1192 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
1193 static av_cold int decode_end(AVCodecContext *avctx)
1195 HYuvContext *s = avctx->priv_data;
1198 if (s->picture.data[0])
1199 avctx->release_buffer(avctx, &s->picture);
1202 av_freep(&s->bitstream_buffer);
1205 ff_free_vlc(&s->vlc[i]);
1210 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1212 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
1213 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1214 const AVFrame *pict, int *got_packet)
1216 HYuvContext *s = avctx->priv_data;
1217 const int width= s->width;
1218 const int width2= s->width>>1;
1219 const int height= s->height;
1220 const int fake_ystride= s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
1221 const int fake_ustride= s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
1222 const int fake_vstride= s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
1223 AVFrame * const p= &s->picture;
1224 int i, j, size = 0, ret;
1226 if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + FF_MIN_BUFFER_SIZE)) < 0)
1230 p->pict_type= AV_PICTURE_TYPE_I;
1235 ff_generate_len_table(s->len[i], s->stats[i]);
1236 if(generate_bits_table(s->bits[i], s->len[i])<0)
1238 size += store_table(s, s->len[i], &pkt->data[size]);
1242 for(j=0; j<256; j++)
1243 s->stats[i][j] >>= 1;
1246 init_put_bits(&s->pb, pkt->data + size, pkt->size - size);
1248 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1249 int lefty, leftu, leftv, y, cy;
1251 put_bits(&s->pb, 8, leftv= p->data[2][0]);
1252 put_bits(&s->pb, 8, lefty= p->data[0][1]);
1253 put_bits(&s->pb, 8, leftu= p->data[1][0]);
1254 put_bits(&s->pb, 8, p->data[0][0]);
1256 lefty= sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
1257 leftu= sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
1258 leftv= sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
1260 encode_422_bitstream(s, 2, width-2);
1262 if(s->predictor==MEDIAN){
1263 int lefttopy, lefttopu, lefttopv;
1266 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1267 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1268 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1270 encode_422_bitstream(s, 0, width);
1274 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1275 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1276 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1278 encode_422_bitstream(s, 0, 4);
1280 lefttopy= p->data[0][3];
1281 lefttopu= p->data[1][1];
1282 lefttopv= p->data[2][1];
1283 s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1284 s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1285 s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1286 encode_422_bitstream(s, 0, width-4);
1289 for(; y<height; y++,cy++){
1290 uint8_t *ydst, *udst, *vdst;
1292 if(s->bitstream_bpp==12){
1294 ydst= p->data[0] + p->linesize[0]*y;
1295 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1296 encode_gray_bitstream(s, width);
1299 if(y>=height) break;
1301 ydst= p->data[0] + p->linesize[0]*y;
1302 udst= p->data[1] + p->linesize[1]*cy;
1303 vdst= p->data[2] + p->linesize[2]*cy;
1305 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1306 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1307 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1309 encode_422_bitstream(s, 0, width);
1312 for(cy=y=1; y<height; y++,cy++){
1313 uint8_t *ydst, *udst, *vdst;
1315 /* encode a luma only line & y++ */
1316 if(s->bitstream_bpp==12){
1317 ydst= p->data[0] + p->linesize[0]*y;
1319 if(s->predictor == PLANE && s->interlaced < y){
1320 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1322 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1324 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1326 encode_gray_bitstream(s, width);
1328 if(y>=height) break;
1331 ydst= p->data[0] + p->linesize[0]*y;
1332 udst= p->data[1] + p->linesize[1]*cy;
1333 vdst= p->data[2] + p->linesize[2]*cy;
1335 if(s->predictor == PLANE && s->interlaced < cy){
1336 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1337 s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1338 s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1340 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1341 leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1342 leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1344 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1345 leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1346 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1349 encode_422_bitstream(s, 0, width);
1352 }else if(avctx->pix_fmt == PIX_FMT_RGB32){
1353 uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1354 const int stride = -p->linesize[0];
1355 const int fake_stride = -fake_ystride;
1357 int leftr, leftg, leftb, lefta;
1359 put_bits(&s->pb, 8, lefta= data[A]);
1360 put_bits(&s->pb, 8, leftr= data[R]);
1361 put_bits(&s->pb, 8, leftg= data[G]);
1362 put_bits(&s->pb, 8, leftb= data[B]);
1364 sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb, &lefta);
1365 encode_bgra_bitstream(s, width-1, 4);
1367 for(y=1; y<s->height; y++){
1368 uint8_t *dst = data + y*stride;
1369 if(s->predictor == PLANE && s->interlaced < y){
1370 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
1371 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb, &lefta);
1373 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb, &lefta);
1375 encode_bgra_bitstream(s, width, 4);
1377 }else if(avctx->pix_fmt == PIX_FMT_RGB24){
1378 uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1379 const int stride = -p->linesize[0];
1380 const int fake_stride = -fake_ystride;
1382 int leftr, leftg, leftb;
1384 put_bits(&s->pb, 8, leftr= data[0]);
1385 put_bits(&s->pb, 8, leftg= data[1]);
1386 put_bits(&s->pb, 8, leftb= data[2]);
1387 put_bits(&s->pb, 8, 0);
1389 sub_left_prediction_rgb24(s, s->temp[0], data+3, width-1, &leftr, &leftg, &leftb);
1390 encode_bgra_bitstream(s, width-1, 3);
1392 for(y=1; y<s->height; y++){
1393 uint8_t *dst = data + y*stride;
1394 if(s->predictor == PLANE && s->interlaced < y){
1395 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*3);
1396 sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1398 sub_left_prediction_rgb24(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1400 encode_bgra_bitstream(s, width, 3);
1403 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1407 size+= (put_bits_count(&s->pb)+31)/8;
1408 put_bits(&s->pb, 16, 0);
1409 put_bits(&s->pb, 15, 0);
1412 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1414 char *p= avctx->stats_out;
1415 char *end= p + 1024*30;
1417 for(j=0; j<256; j++){
1418 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1422 snprintf(p, end-p, "\n");
1426 avctx->stats_out[0] = '\0';
1427 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1428 flush_put_bits(&s->pb);
1429 s->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size);
1432 s->picture_number++;
1435 pkt->flags |= AV_PKT_FLAG_KEY;
1441 static av_cold int encode_end(AVCodecContext *avctx)
1443 HYuvContext *s = avctx->priv_data;
1447 av_freep(&avctx->extradata);
1448 av_freep(&avctx->stats_out);
1452 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
1454 #if CONFIG_HUFFYUV_DECODER
1455 AVCodec ff_huffyuv_decoder = {
1457 .type = AVMEDIA_TYPE_VIDEO,
1458 .id = AV_CODEC_ID_HUFFYUV,
1459 .priv_data_size = sizeof(HYuvContext),
1460 .init = decode_init,
1461 .close = decode_end,
1462 .decode = decode_frame,
1463 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
1464 CODEC_CAP_FRAME_THREADS,
1465 .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1466 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1470 #if CONFIG_FFVHUFF_DECODER
1471 AVCodec ff_ffvhuff_decoder = {
1473 .type = AVMEDIA_TYPE_VIDEO,
1474 .id = AV_CODEC_ID_FFVHUFF,
1475 .priv_data_size = sizeof(HYuvContext),
1476 .init = decode_init,
1477 .close = decode_end,
1478 .decode = decode_frame,
1479 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
1480 CODEC_CAP_FRAME_THREADS,
1481 .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1482 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1486 #if CONFIG_HUFFYUV_ENCODER
1487 AVCodec ff_huffyuv_encoder = {
1489 .type = AVMEDIA_TYPE_VIDEO,
1490 .id = AV_CODEC_ID_HUFFYUV,
1491 .priv_data_size = sizeof(HYuvContext),
1492 .init = encode_init,
1493 .encode2 = encode_frame,
1494 .close = encode_end,
1495 .pix_fmts = (const enum PixelFormat[]){
1496 PIX_FMT_YUV422P, PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_NONE
1498 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1502 #if CONFIG_FFVHUFF_ENCODER
1503 AVCodec ff_ffvhuff_encoder = {
1505 .type = AVMEDIA_TYPE_VIDEO,
1506 .id = AV_CODEC_ID_FFVHUFF,
1507 .priv_data_size = sizeof(HYuvContext),
1508 .init = encode_init,
1509 .encode2 = encode_frame,
1510 .close = encode_end,
1511 .pix_fmts = (const enum PixelFormat[]){
1512 PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_NONE
1514 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),