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.
50 typedef enum Predictor{
56 typedef struct HYuvContext{
57 AVCodecContext *avctx;
65 int yuy2; //use yuy2 instead of 422P
66 int bgr32; //use bgr32 instead of bgr24
73 uint64_t stats[3][256];
75 uint32_t bits[3][256];
76 uint32_t pix_bgr_map[1<<VLC_BITS];
77 VLC vlc[6]; //Y,U,V,YY,YU,YV
79 uint8_t *bitstream_buffer;
80 unsigned int bitstream_buffer_size;
84 static const unsigned char classic_shift_luma[] = {
85 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
86 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
90 static const unsigned char classic_shift_chroma[] = {
91 66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
92 56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
93 214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
96 static const unsigned char classic_add_luma[256] = {
97 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
98 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
99 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
100 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
101 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
102 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
103 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
104 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
105 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
106 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
107 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
108 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
109 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
110 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
111 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
112 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
115 static const unsigned char classic_add_chroma[256] = {
116 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
117 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
118 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
119 43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
120 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
121 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
122 17, 14, 5, 6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
123 112,113,114,115, 4,117,118, 92, 94,121,122, 3,124,103, 2, 1,
124 0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
125 135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
126 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
127 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
128 7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
129 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
130 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
131 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
134 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
138 const int temp= src[i];
145 const int temp= src[i];
149 s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
154 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
160 for(i=0; i<FFMIN(w,4); i++){
161 const int rt= src[i*4+R];
162 const int gt= src[i*4+G];
163 const int bt= src[i*4+B];
171 s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
172 *red= src[(w-1)*4+R];
173 *green= src[(w-1)*4+G];
174 *blue= src[(w-1)*4+B];
177 static int read_len_table(uint8_t *dst, GetBitContext *gb){
181 repeat= get_bits(gb, 3);
182 val = get_bits(gb, 5);
184 repeat= get_bits(gb, 8);
185 //printf("%d %d\n", val, repeat);
187 av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
196 static int generate_bits_table(uint32_t *dst, const uint8_t *len_table){
200 for(len=32; len>0; len--){
201 for(index=0; index<256; index++){
202 if(len_table[index]==len)
206 av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
214 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
220 static void heap_sift(HeapElem *h, int root, int size)
222 while(root*2+1 < size) {
223 int child = root*2+1;
224 if(child < size-1 && h[child].val > h[child+1].val)
226 if(h[root].val > h[child].val) {
227 FFSWAP(HeapElem, h[root], h[child]);
234 static void generate_len_table(uint8_t *dst, const uint64_t *stats){
241 for(offset=1; ; offset<<=1){
242 for(i=0; i<size; i++){
244 h[i].val = (stats[i] << 8) + offset;
246 for(i=size/2-1; i>=0; i--)
247 heap_sift(h, i, size);
249 for(next=size; next<size*2-1; next++){
250 // merge the two smallest entries, and put it back in the heap
251 uint64_t min1v = h[0].val;
252 up[h[0].name] = next;
253 h[0].val = INT64_MAX;
254 heap_sift(h, 0, size);
255 up[h[0].name] = next;
258 heap_sift(h, 0, size);
262 for(i=2*size-3; i>=size; i--)
263 len[i] = len[up[i]] + 1;
264 for(i=0; i<size; i++) {
265 dst[i] = len[up[i]] + 1;
266 if(dst[i] >= 32) break;
271 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
273 static void generate_joint_tables(HYuvContext *s){
274 uint16_t symbols[1<<VLC_BITS];
275 uint16_t bits[1<<VLC_BITS];
276 uint8_t len[1<<VLC_BITS];
277 if(s->bitstream_bpp < 24){
280 for(i=y=0; y<256; y++){
281 int len0 = s->len[0][y];
282 int limit = VLC_BITS - len0;
285 for(u=0; u<256; u++){
286 int len1 = s->len[p][u];
289 len[i] = len0 + len1;
290 bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
291 symbols[i] = (y<<8) + u;
292 if(symbols[i] != 0xffff) // reserved to mean "invalid"
296 free_vlc(&s->vlc[3+p]);
297 init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
300 uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
301 int i, b, g, r, code;
302 int p0 = s->decorrelate;
303 int p1 = !s->decorrelate;
304 // restrict the range to +/-16 becaues that's pretty much guaranteed to
305 // cover all the combinations that fit in 11 bits total, and it doesn't
306 // matter if we miss a few rare codes.
307 for(i=0, g=-16; g<16; g++){
308 int len0 = s->len[p0][g&255];
309 int limit0 = VLC_BITS - len0;
312 for(b=-16; b<16; b++){
313 int len1 = s->len[p1][b&255];
314 int limit1 = limit0 - len1;
317 code = (s->bits[p0][g&255] << len1) + s->bits[p1][b&255];
318 for(r=-16; r<16; r++){
319 int len2 = s->len[2][r&255];
322 len[i] = len0 + len1 + len2;
323 bits[i] = (code << len2) + s->bits[2][r&255];
337 free_vlc(&s->vlc[3]);
338 init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
342 static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length){
346 init_get_bits(&gb, src, length*8);
349 if(read_len_table(s->len[i], &gb)<0)
351 if(generate_bits_table(s->bits[i], s->len[i])<0){
355 for(j=0; j<256; j++){
356 printf("%6X, %2d, %3d\n", s->bits[i][j], s->len[i][j], j);
359 free_vlc(&s->vlc[i]);
360 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
363 generate_joint_tables(s);
365 return (get_bits_count(&gb)+7)/8;
368 static int read_old_huffman_tables(HYuvContext *s){
373 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
374 if(read_len_table(s->len[0], &gb)<0)
376 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
377 if(read_len_table(s->len[1], &gb)<0)
380 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i];
381 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
383 if(s->bitstream_bpp >= 24){
384 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
385 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
387 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
388 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
391 free_vlc(&s->vlc[i]);
392 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
395 generate_joint_tables(s);
399 av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
404 static av_cold void alloc_temp(HYuvContext *s){
407 if(s->bitstream_bpp<24){
409 s->temp[i]= av_malloc(s->width + 16);
412 s->temp[0]= av_mallocz(4*s->width + 16);
416 static av_cold int common_init(AVCodecContext *avctx){
417 HYuvContext *s = avctx->priv_data;
420 s->flags= avctx->flags;
422 dsputil_init(&s->dsp, avctx);
424 s->width= avctx->width;
425 s->height= avctx->height;
426 assert(s->width>0 && s->height>0);
431 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
432 static av_cold int decode_init(AVCodecContext *avctx)
434 HYuvContext *s = avctx->priv_data;
437 memset(s->vlc, 0, 3*sizeof(VLC));
439 avctx->coded_frame= &s->picture;
440 s->interlaced= s->height > 288;
443 //if(avctx->extradata)
444 // printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
445 if(avctx->extradata_size){
446 if((avctx->bits_per_coded_sample&7) && avctx->bits_per_coded_sample != 12)
447 s->version=1; // do such files exist at all?
454 int method, interlace;
456 if (avctx->extradata_size < 4)
459 method= ((uint8_t*)avctx->extradata)[0];
460 s->decorrelate= method&64 ? 1 : 0;
461 s->predictor= method&63;
462 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
463 if(s->bitstream_bpp==0)
464 s->bitstream_bpp= avctx->bits_per_coded_sample&~7;
465 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
466 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
467 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
469 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size-4) < 0)
472 switch(avctx->bits_per_coded_sample&7){
483 s->decorrelate= avctx->bits_per_coded_sample >= 24;
486 s->predictor= MEDIAN;
490 s->predictor= LEFT; //OLD
494 s->bitstream_bpp= avctx->bits_per_coded_sample & ~7;
497 if(read_old_huffman_tables(s) < 0)
501 switch(s->bitstream_bpp){
503 avctx->pix_fmt = PIX_FMT_YUV420P;
507 avctx->pix_fmt = PIX_FMT_YUYV422;
509 avctx->pix_fmt = PIX_FMT_YUV422P;
515 avctx->pix_fmt = PIX_FMT_RGB32;
517 avctx->pix_fmt = PIX_FMT_BGR24;
526 // 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);
530 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
532 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
533 static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf){
541 for(; i<256 && len[i]==val && repeat<255; i++)
544 assert(val < 32 && val >0 && repeat<256 && repeat>0);
547 buf[index++]= repeat;
549 buf[index++]= val | (repeat<<5);
556 static av_cold int encode_init(AVCodecContext *avctx)
558 HYuvContext *s = avctx->priv_data;
563 avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
564 avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
567 avctx->coded_frame= &s->picture;
569 switch(avctx->pix_fmt){
570 case PIX_FMT_YUV420P:
571 s->bitstream_bpp= 12;
573 case PIX_FMT_YUV422P:
574 s->bitstream_bpp= 16;
577 s->bitstream_bpp= 24;
580 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
583 avctx->bits_per_coded_sample= s->bitstream_bpp;
584 s->decorrelate= s->bitstream_bpp >= 24;
585 s->predictor= avctx->prediction_method;
586 s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
587 if(avctx->context_model==1){
588 s->context= avctx->context_model;
589 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
590 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
595 if(avctx->codec->id==CODEC_ID_HUFFYUV){
596 if(avctx->pix_fmt==PIX_FMT_YUV420P){
597 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
600 if(avctx->context_model){
601 av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
604 if(s->interlaced != ( s->height > 288 ))
605 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
608 if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
609 av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
613 ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
614 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
615 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
617 ((uint8_t*)avctx->extradata)[2]|= 0x40;
618 ((uint8_t*)avctx->extradata)[3]= 0;
619 s->avctx->extradata_size= 4;
622 char *p= avctx->stats_in;
632 for(j=0; j<256; j++){
633 s->stats[i][j]+= strtol(p, &next, 0);
634 if(next==p) return -1;
638 if(p[0]==0 || p[1]==0 || p[2]==0) break;
642 for(j=0; j<256; j++){
643 int d= FFMIN(j, 256-j);
645 s->stats[i][j]= 100000000/(d+1);
650 generate_len_table(s->len[i], s->stats[i]);
652 if(generate_bits_table(s->bits[i], s->len[i])<0){
656 s->avctx->extradata_size+=
657 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
662 int pels = s->width*s->height / (i?40:10);
663 for(j=0; j<256; j++){
664 int d= FFMIN(j, 256-j);
665 s->stats[i][j]= pels/(d+1);
674 // printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
682 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
684 /* TODO instead of restarting the read when the code isn't in the first level
685 * of the joint table, jump into the 2nd level of the individual table. */
686 #define READ_2PIX(dst0, dst1, plane1){\
687 uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
692 dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
693 dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
697 static void decode_422_bitstream(HYuvContext *s, int count){
702 if(count >= (get_bits_left(&s->gb))/(31*4)){
703 for(i=0; i<count && get_bits_count(&s->gb) < s->gb.size_in_bits; i++){
704 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
705 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
708 for(i=0; i<count; i++){
709 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
710 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
715 static void decode_gray_bitstream(HYuvContext *s, int count){
720 if(count >= (get_bits_left(&s->gb))/(31*2)){
721 for(i=0; i<count && get_bits_count(&s->gb) < s->gb.size_in_bits; i++){
722 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
725 for(i=0; i<count; i++){
726 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
731 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
732 static int encode_422_bitstream(HYuvContext *s, int offset, int count){
734 const uint8_t *y = s->temp[0] + offset;
735 const uint8_t *u = s->temp[1] + offset/2;
736 const uint8_t *v = s->temp[2] + offset/2;
738 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
739 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
750 if(s->flags&CODEC_FLAG_PASS1){
751 for(i=0; i<count; i++){
759 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
762 for(i=0; i<count; i++){
765 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
767 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
769 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
771 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
774 for(i=0; i<count; i++){
776 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
777 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
778 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
779 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
785 static int encode_gray_bitstream(HYuvContext *s, int count){
788 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
789 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
794 int y0 = s->temp[0][2*i];\
795 int y1 = s->temp[0][2*i+1];
800 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
801 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
804 if(s->flags&CODEC_FLAG_PASS1){
805 for(i=0; i<count; i++){
810 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
814 for(i=0; i<count; i++){
820 for(i=0; i<count; i++){
827 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
829 static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
831 for(i=0; i<count; i++){
832 int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
834 *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
835 }else if(decorrelate){
836 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
837 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
838 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
840 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
841 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
842 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
845 s->temp[0][4*i+A] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
849 static void decode_bgr_bitstream(HYuvContext *s, int count){
851 if(s->bitstream_bpp==24)
852 decode_bgr_1(s, count, 1, 0);
854 decode_bgr_1(s, count, 1, 1);
856 if(s->bitstream_bpp==24)
857 decode_bgr_1(s, count, 0, 0);
859 decode_bgr_1(s, count, 0, 1);
863 static int encode_bgr_bitstream(HYuvContext *s, int count){
866 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
867 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
872 int g= s->temp[0][4*i+G];\
873 int b= (s->temp[0][4*i+B] - g) & 0xff;\
874 int r= (s->temp[0][4*i+R] - g) & 0xff;
880 put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
881 put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
882 put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
884 if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
885 for(i=0; i<count; i++){
889 }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
890 for(i=0; i<count; i++){
896 for(i=0; i<count; i++){
904 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
905 static void draw_slice(HYuvContext *s, int y){
909 if(s->avctx->draw_horiz_band==NULL)
912 h= y - s->last_slice_end;
915 if(s->bitstream_bpp==12){
921 offset[0] = s->picture.linesize[0]*y;
922 offset[1] = s->picture.linesize[1]*cy;
923 offset[2] = s->picture.linesize[2]*cy;
927 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
929 s->last_slice_end= y + h;
932 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
933 const uint8_t *buf = avpkt->data;
934 int buf_size = avpkt->size;
935 HYuvContext *s = avctx->priv_data;
936 const int width= s->width;
937 const int width2= s->width>>1;
938 const int height= s->height;
939 int fake_ystride, fake_ustride, fake_vstride;
940 AVFrame * const p= &s->picture;
943 AVFrame *picture = data;
945 av_fast_malloc(&s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
946 if (!s->bitstream_buffer)
947 return AVERROR(ENOMEM);
949 memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
950 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
953 avctx->release_buffer(avctx, p);
956 if(avctx->get_buffer(avctx, p) < 0){
957 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
962 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
967 if((unsigned)(buf_size-table_size) >= INT_MAX/8)
970 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
972 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0];
973 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1];
974 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2];
976 s->last_slice_end= 0;
978 if(s->bitstream_bpp<24){
980 int lefty, leftu, leftv;
981 int lefttopy, lefttopu, lefttopv;
984 p->data[0][3]= get_bits(&s->gb, 8);
985 p->data[0][2]= get_bits(&s->gb, 8);
986 p->data[0][1]= get_bits(&s->gb, 8);
987 p->data[0][0]= get_bits(&s->gb, 8);
989 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
993 leftv= p->data[2][0]= get_bits(&s->gb, 8);
994 lefty= p->data[0][1]= get_bits(&s->gb, 8);
995 leftu= p->data[1][0]= get_bits(&s->gb, 8);
996 p->data[0][0]= get_bits(&s->gb, 8);
998 switch(s->predictor){
1001 decode_422_bitstream(s, width-2);
1002 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1003 if(!(s->flags&CODEC_FLAG_GRAY)){
1004 leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1005 leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1008 for(cy=y=1; y<s->height; y++,cy++){
1009 uint8_t *ydst, *udst, *vdst;
1011 if(s->bitstream_bpp==12){
1012 decode_gray_bitstream(s, width);
1014 ydst= p->data[0] + p->linesize[0]*y;
1016 lefty= s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
1017 if(s->predictor == PLANE){
1019 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1022 if(y>=s->height) break;
1027 ydst= p->data[0] + p->linesize[0]*y;
1028 udst= p->data[1] + p->linesize[1]*cy;
1029 vdst= p->data[2] + p->linesize[2]*cy;
1031 decode_422_bitstream(s, width);
1032 lefty= s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
1033 if(!(s->flags&CODEC_FLAG_GRAY)){
1034 leftu= s->dsp.add_hfyu_left_prediction(udst, s->temp[1], width2, leftu);
1035 leftv= s->dsp.add_hfyu_left_prediction(vdst, s->temp[2], width2, leftv);
1037 if(s->predictor == PLANE){
1038 if(cy>s->interlaced){
1039 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1040 if(!(s->flags&CODEC_FLAG_GRAY)){
1041 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1042 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1047 draw_slice(s, height);
1051 /* first line except first 2 pixels is left predicted */
1052 decode_422_bitstream(s, width-2);
1053 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1054 if(!(s->flags&CODEC_FLAG_GRAY)){
1055 leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1056 leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1061 /* second line is left predicted for interlaced case */
1063 decode_422_bitstream(s, width);
1064 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1065 if(!(s->flags&CODEC_FLAG_GRAY)){
1066 leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1067 leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1072 /* next 4 pixels are left predicted too */
1073 decode_422_bitstream(s, 4);
1074 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1075 if(!(s->flags&CODEC_FLAG_GRAY)){
1076 leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1077 leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1080 /* next line except the first 4 pixels is median predicted */
1081 lefttopy= p->data[0][3];
1082 decode_422_bitstream(s, width-4);
1083 s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1084 if(!(s->flags&CODEC_FLAG_GRAY)){
1085 lefttopu= p->data[1][1];
1086 lefttopv= p->data[2][1];
1087 s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
1088 s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
1092 for(; y<height; y++,cy++){
1093 uint8_t *ydst, *udst, *vdst;
1095 if(s->bitstream_bpp==12){
1097 decode_gray_bitstream(s, width);
1098 ydst= p->data[0] + p->linesize[0]*y;
1099 s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1102 if(y>=height) break;
1106 decode_422_bitstream(s, width);
1108 ydst= p->data[0] + p->linesize[0]*y;
1109 udst= p->data[1] + p->linesize[1]*cy;
1110 vdst= p->data[2] + p->linesize[2]*cy;
1112 s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1113 if(!(s->flags&CODEC_FLAG_GRAY)){
1114 s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1115 s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1119 draw_slice(s, height);
1125 int leftr, leftg, leftb, lefta;
1126 const int last_line= (height-1)*p->linesize[0];
1128 if(s->bitstream_bpp==32){
1129 lefta= p->data[0][last_line+A]= get_bits(&s->gb, 8);
1130 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1131 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1132 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1134 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1135 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1136 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1137 lefta= p->data[0][last_line+A]= 255;
1138 skip_bits(&s->gb, 8);
1142 switch(s->predictor){
1145 decode_bgr_bitstream(s, width-1);
1146 s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb, &lefta);
1148 for(y=s->height-2; y>=0; y--){ //Yes it is stored upside down.
1149 decode_bgr_bitstream(s, width);
1151 s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb, &lefta);
1152 if(s->predictor == PLANE){
1153 if(s->bitstream_bpp!=32) lefta=0;
1154 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
1155 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
1156 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
1160 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1163 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1167 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1174 *data_size = sizeof(AVFrame);
1176 return (get_bits_count(&s->gb)+31)/32*4 + table_size;
1178 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1180 static int common_end(HYuvContext *s){
1184 av_freep(&s->temp[i]);
1189 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
1190 static av_cold int decode_end(AVCodecContext *avctx)
1192 HYuvContext *s = avctx->priv_data;
1195 if (s->picture.data[0])
1196 avctx->release_buffer(avctx, &s->picture);
1199 av_freep(&s->bitstream_buffer);
1202 free_vlc(&s->vlc[i]);
1207 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1209 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
1210 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1211 HYuvContext *s = avctx->priv_data;
1212 AVFrame *pict = data;
1213 const int width= s->width;
1214 const int width2= s->width>>1;
1215 const int height= s->height;
1216 const int fake_ystride= s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
1217 const int fake_ustride= s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
1218 const int fake_vstride= s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
1219 AVFrame * const p= &s->picture;
1223 p->pict_type= FF_I_TYPE;
1228 generate_len_table(s->len[i], s->stats[i]);
1229 if(generate_bits_table(s->bits[i], s->len[i])<0)
1231 size+= store_table(s, s->len[i], &buf[size]);
1235 for(j=0; j<256; j++)
1236 s->stats[i][j] >>= 1;
1239 init_put_bits(&s->pb, buf+size, buf_size-size);
1241 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1242 int lefty, leftu, leftv, y, cy;
1244 put_bits(&s->pb, 8, leftv= p->data[2][0]);
1245 put_bits(&s->pb, 8, lefty= p->data[0][1]);
1246 put_bits(&s->pb, 8, leftu= p->data[1][0]);
1247 put_bits(&s->pb, 8, p->data[0][0]);
1249 lefty= sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
1250 leftu= sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
1251 leftv= sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
1253 encode_422_bitstream(s, 2, width-2);
1255 if(s->predictor==MEDIAN){
1256 int lefttopy, lefttopu, lefttopv;
1259 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1260 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1261 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1263 encode_422_bitstream(s, 0, width);
1267 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1268 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1269 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1271 encode_422_bitstream(s, 0, 4);
1273 lefttopy= p->data[0][3];
1274 lefttopu= p->data[1][1];
1275 lefttopv= p->data[2][1];
1276 s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1277 s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1278 s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1279 encode_422_bitstream(s, 0, width-4);
1282 for(; y<height; y++,cy++){
1283 uint8_t *ydst, *udst, *vdst;
1285 if(s->bitstream_bpp==12){
1287 ydst= p->data[0] + p->linesize[0]*y;
1288 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1289 encode_gray_bitstream(s, width);
1292 if(y>=height) break;
1294 ydst= p->data[0] + p->linesize[0]*y;
1295 udst= p->data[1] + p->linesize[1]*cy;
1296 vdst= p->data[2] + p->linesize[2]*cy;
1298 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1299 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1300 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1302 encode_422_bitstream(s, 0, width);
1305 for(cy=y=1; y<height; y++,cy++){
1306 uint8_t *ydst, *udst, *vdst;
1308 /* encode a luma only line & y++ */
1309 if(s->bitstream_bpp==12){
1310 ydst= p->data[0] + p->linesize[0]*y;
1312 if(s->predictor == PLANE && s->interlaced < y){
1313 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1315 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1317 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1319 encode_gray_bitstream(s, width);
1321 if(y>=height) break;
1324 ydst= p->data[0] + p->linesize[0]*y;
1325 udst= p->data[1] + p->linesize[1]*cy;
1326 vdst= p->data[2] + p->linesize[2]*cy;
1328 if(s->predictor == PLANE && s->interlaced < cy){
1329 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1330 s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1331 s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1333 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1334 leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1335 leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1337 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1338 leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1339 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1342 encode_422_bitstream(s, 0, width);
1345 }else if(avctx->pix_fmt == PIX_FMT_RGB32){
1346 uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1347 const int stride = -p->linesize[0];
1348 const int fake_stride = -fake_ystride;
1350 int leftr, leftg, leftb;
1352 put_bits(&s->pb, 8, leftr= data[R]);
1353 put_bits(&s->pb, 8, leftg= data[G]);
1354 put_bits(&s->pb, 8, leftb= data[B]);
1355 put_bits(&s->pb, 8, 0);
1357 sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
1358 encode_bgr_bitstream(s, width-1);
1360 for(y=1; y<s->height; y++){
1361 uint8_t *dst = data + y*stride;
1362 if(s->predictor == PLANE && s->interlaced < y){
1363 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
1364 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1366 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1368 encode_bgr_bitstream(s, width);
1371 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1375 size+= (put_bits_count(&s->pb)+31)/8;
1376 put_bits(&s->pb, 16, 0);
1377 put_bits(&s->pb, 15, 0);
1380 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1382 char *p= avctx->stats_out;
1383 char *end= p + 1024*30;
1385 for(j=0; j<256; j++){
1386 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1390 snprintf(p, end-p, "\n");
1394 avctx->stats_out[0] = '\0';
1395 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1396 flush_put_bits(&s->pb);
1397 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1400 s->picture_number++;
1405 static av_cold int encode_end(AVCodecContext *avctx)
1407 HYuvContext *s = avctx->priv_data;
1411 av_freep(&avctx->extradata);
1412 av_freep(&avctx->stats_out);
1416 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
1418 #if CONFIG_HUFFYUV_DECODER
1419 AVCodec huffyuv_decoder = {
1423 sizeof(HYuvContext),
1428 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1430 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1434 #if CONFIG_FFVHUFF_DECODER
1435 AVCodec ffvhuff_decoder = {
1439 sizeof(HYuvContext),
1444 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1446 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1450 #if CONFIG_HUFFYUV_ENCODER
1451 AVCodec huffyuv_encoder = {
1455 sizeof(HYuvContext),
1459 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
1460 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1464 #if CONFIG_FFVHUFF_ENCODER
1465 AVCodec ffvhuff_encoder = {
1469 sizeof(HYuvContext),
1473 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
1474 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),