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
27 * @file libavcodec/huffyuv.c
28 * huffyuv codec for libavcodec.
32 #include "bitstream.h"
37 #ifdef WORDS_BIGENDIAN
47 typedef enum Predictor{
53 typedef struct HYuvContext{
54 AVCodecContext *avctx;
62 int yuy2; //use yuy2 instead of 422P
63 int bgr32; //use bgr32 instead of bgr24
70 uint64_t stats[3][256];
72 uint32_t bits[3][256];
73 uint32_t pix_bgr_map[1<<VLC_BITS];
74 VLC vlc[6]; //Y,U,V,YY,YU,YV
76 uint8_t *bitstream_buffer;
77 unsigned int bitstream_buffer_size;
81 static const unsigned char classic_shift_luma[] = {
82 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
83 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
87 static const unsigned char classic_shift_chroma[] = {
88 66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
89 56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
90 214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
93 static const unsigned char classic_add_luma[256] = {
94 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
95 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
96 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
97 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
98 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
99 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
100 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
101 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
102 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
103 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
104 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
105 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
106 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
107 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
108 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
109 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
112 static const unsigned char classic_add_chroma[256] = {
113 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
114 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
115 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
116 43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
117 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
118 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
119 17, 14, 5, 6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
120 112,113,114,115, 4,117,118, 92, 94,121,122, 3,124,103, 2, 1,
121 0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
122 135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
123 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
124 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
125 7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
126 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
127 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
128 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
131 static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
134 for(i=0; i<w-1; i++){
150 static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
172 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
176 const int temp= src[i];
183 const int temp= src[i];
187 s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
192 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
198 for(i=0; i<FFMIN(w,4); i++){
199 const int rt= src[i*4+R];
200 const int gt= src[i*4+G];
201 const int bt= src[i*4+B];
209 s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
210 *red= src[(w-1)*4+R];
211 *green= src[(w-1)*4+G];
212 *blue= src[(w-1)*4+B];
215 static void read_len_table(uint8_t *dst, GetBitContext *gb){
219 repeat= get_bits(gb, 3);
220 val = get_bits(gb, 5);
222 repeat= get_bits(gb, 8);
223 //printf("%d %d\n", val, repeat);
229 static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
233 for(len=32; len>0; len--){
234 for(index=0; index<256; index++){
235 if(len_table[index]==len)
239 av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
247 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
253 static void heap_sift(HeapElem *h, int root, int size)
255 while(root*2+1 < size) {
256 int child = root*2+1;
257 if(child < size-1 && h[child].val > h[child+1].val)
259 if(h[root].val > h[child].val) {
260 FFSWAP(HeapElem, h[root], h[child]);
267 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
273 for(offset=1; ; offset<<=1){
274 for(i=0; i<size; i++){
276 h[i].val = (stats[i] << 8) + offset;
278 for(i=size/2-1; i>=0; i--)
279 heap_sift(h, i, size);
281 for(next=size; next<size*2-1; next++){
282 // merge the two smallest entries, and put it back in the heap
283 uint64_t min1v = h[0].val;
284 up[h[0].name] = next;
285 h[0].val = INT64_MAX;
286 heap_sift(h, 0, size);
287 up[h[0].name] = next;
290 heap_sift(h, 0, size);
294 for(i=2*size-3; i>=size; i--)
295 len[i] = len[up[i]] + 1;
296 for(i=0; i<size; i++) {
297 dst[i] = len[up[i]] + 1;
298 if(dst[i] >= 32) break;
303 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
305 static void generate_joint_tables(HYuvContext *s){
306 uint16_t symbols[1<<VLC_BITS];
307 uint16_t bits[1<<VLC_BITS];
308 uint8_t len[1<<VLC_BITS];
309 if(s->bitstream_bpp < 24){
312 for(i=y=0; y<256; y++){
313 int len0 = s->len[0][y];
314 int limit = VLC_BITS - len0;
317 for(u=0; u<256; u++){
318 int len1 = s->len[p][u];
321 len[i] = len0 + len1;
322 bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
323 symbols[i] = (y<<8) + u;
324 if(symbols[i] != 0xffff) // reserved to mean "invalid"
328 free_vlc(&s->vlc[3+p]);
329 init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
332 uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
333 int i, b, g, r, code;
334 int p0 = s->decorrelate;
335 int p1 = !s->decorrelate;
336 // restrict the range to +/-16 becaues that's pretty much guaranteed to
337 // cover all the combinations that fit in 11 bits total, and it doesn't
338 // matter if we miss a few rare codes.
339 for(i=0, g=-16; g<16; g++){
340 int len0 = s->len[p0][g&255];
341 int limit0 = VLC_BITS - len0;
344 for(b=-16; b<16; b++){
345 int len1 = s->len[p1][b&255];
346 int limit1 = limit0 - len1;
349 code = (s->bits[p0][g&255] << len1) + s->bits[p1][b&255];
350 for(r=-16; r<16; r++){
351 int len2 = s->len[2][r&255];
354 len[i] = len0 + len1 + len2;
355 bits[i] = (code << len2) + s->bits[2][r&255];
369 free_vlc(&s->vlc[3]);
370 init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
374 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
378 init_get_bits(&gb, src, length*8);
381 read_len_table(s->len[i], &gb);
383 if(generate_bits_table(s->bits[i], s->len[i])<0){
387 for(j=0; j<256; j++){
388 printf("%6X, %2d, %3d\n", s->bits[i][j], s->len[i][j], j);
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);
397 return (get_bits_count(&gb)+7)/8;
400 static int read_old_huffman_tables(HYuvContext *s){
405 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
406 read_len_table(s->len[0], &gb);
407 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
408 read_len_table(s->len[1], &gb);
410 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i];
411 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
413 if(s->bitstream_bpp >= 24){
414 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
415 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
417 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
418 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
421 free_vlc(&s->vlc[i]);
422 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
425 generate_joint_tables(s);
429 av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
434 static av_cold void alloc_temp(HYuvContext *s){
437 if(s->bitstream_bpp<24){
439 s->temp[i]= av_malloc(s->width + 16);
443 s->temp[i]= av_malloc(4*s->width + 16);
448 static av_cold int common_init(AVCodecContext *avctx){
449 HYuvContext *s = avctx->priv_data;
452 s->flags= avctx->flags;
454 dsputil_init(&s->dsp, avctx);
456 s->width= avctx->width;
457 s->height= avctx->height;
458 assert(s->width>0 && s->height>0);
463 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
464 static av_cold int decode_init(AVCodecContext *avctx)
466 HYuvContext *s = avctx->priv_data;
469 memset(s->vlc, 0, 3*sizeof(VLC));
471 avctx->coded_frame= &s->picture;
472 s->interlaced= s->height > 288;
475 //if(avctx->extradata)
476 // printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
477 if(avctx->extradata_size){
478 if((avctx->bits_per_coded_sample&7) && avctx->bits_per_coded_sample != 12)
479 s->version=1; // do such files exist at all?
486 int method, interlace;
488 method= ((uint8_t*)avctx->extradata)[0];
489 s->decorrelate= method&64 ? 1 : 0;
490 s->predictor= method&63;
491 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
492 if(s->bitstream_bpp==0)
493 s->bitstream_bpp= avctx->bits_per_coded_sample&~7;
494 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
495 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
496 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
498 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
501 switch(avctx->bits_per_coded_sample&7){
512 s->decorrelate= avctx->bits_per_coded_sample >= 24;
515 s->predictor= MEDIAN;
519 s->predictor= LEFT; //OLD
523 s->bitstream_bpp= avctx->bits_per_coded_sample & ~7;
526 if(read_old_huffman_tables(s) < 0)
530 switch(s->bitstream_bpp){
532 avctx->pix_fmt = PIX_FMT_YUV420P;
536 avctx->pix_fmt = PIX_FMT_YUYV422;
538 avctx->pix_fmt = PIX_FMT_YUV422P;
544 avctx->pix_fmt = PIX_FMT_RGB32;
546 avctx->pix_fmt = PIX_FMT_BGR24;
555 // 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);
559 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
561 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
562 static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
570 for(; i<256 && len[i]==val && repeat<255; i++)
573 assert(val < 32 && val >0 && repeat<256 && repeat>0);
576 buf[index++]= repeat;
578 buf[index++]= val | (repeat<<5);
585 static av_cold int encode_init(AVCodecContext *avctx)
587 HYuvContext *s = avctx->priv_data;
592 avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
593 avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
596 avctx->coded_frame= &s->picture;
598 switch(avctx->pix_fmt){
599 case PIX_FMT_YUV420P:
600 s->bitstream_bpp= 12;
602 case PIX_FMT_YUV422P:
603 s->bitstream_bpp= 16;
606 s->bitstream_bpp= 24;
609 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
612 avctx->bits_per_coded_sample= s->bitstream_bpp;
613 s->decorrelate= s->bitstream_bpp >= 24;
614 s->predictor= avctx->prediction_method;
615 s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
616 if(avctx->context_model==1){
617 s->context= avctx->context_model;
618 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
619 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
624 if(avctx->codec->id==CODEC_ID_HUFFYUV){
625 if(avctx->pix_fmt==PIX_FMT_YUV420P){
626 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
629 if(avctx->context_model){
630 av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
633 if(s->interlaced != ( s->height > 288 ))
634 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
637 if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
638 av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
642 ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
643 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
644 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
646 ((uint8_t*)avctx->extradata)[2]|= 0x40;
647 ((uint8_t*)avctx->extradata)[3]= 0;
648 s->avctx->extradata_size= 4;
651 char *p= avctx->stats_in;
661 for(j=0; j<256; j++){
662 s->stats[i][j]+= strtol(p, &next, 0);
663 if(next==p) return -1;
667 if(p[0]==0 || p[1]==0 || p[2]==0) break;
671 for(j=0; j<256; j++){
672 int d= FFMIN(j, 256-j);
674 s->stats[i][j]= 100000000/(d+1);
679 generate_len_table(s->len[i], s->stats[i], 256);
681 if(generate_bits_table(s->bits[i], s->len[i])<0){
685 s->avctx->extradata_size+=
686 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
691 int pels = s->width*s->height / (i?40:10);
692 for(j=0; j<256; j++){
693 int d= FFMIN(j, 256-j);
694 s->stats[i][j]= pels/(d+1);
703 // printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
711 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
713 /* TODO instead of restarting the read when the code isn't in the first level
714 * of the joint table, jump into the 2nd level of the individual table. */
715 #define READ_2PIX(dst0, dst1, plane1){\
716 uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
721 dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
722 dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
726 static void decode_422_bitstream(HYuvContext *s, int count){
731 for(i=0; i<count; i++){
732 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
733 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
737 static void decode_gray_bitstream(HYuvContext *s, int count){
742 for(i=0; i<count; i++){
743 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
747 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
748 static int encode_422_bitstream(HYuvContext *s, int count){
751 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
752 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
757 int y0 = s->temp[0][2*i];\
758 int y1 = s->temp[0][2*i+1];\
759 int u0 = s->temp[1][i];\
760 int v0 = s->temp[2][i];
763 if(s->flags&CODEC_FLAG_PASS1){
764 for(i=0; i<count; i++){
772 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
775 for(i=0; i<count; i++){
778 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
780 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
782 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
784 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
787 for(i=0; i<count; i++){
789 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
790 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
791 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
792 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
798 static int encode_gray_bitstream(HYuvContext *s, int count){
801 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
802 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
807 int y0 = s->temp[0][2*i];\
808 int y1 = s->temp[0][2*i+1];
813 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
814 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
817 if(s->flags&CODEC_FLAG_PASS1){
818 for(i=0; i<count; i++){
823 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
827 for(i=0; i<count; i++){
833 for(i=0; i<count; i++){
840 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
842 static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
844 for(i=0; i<count; i++){
845 int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
847 *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
848 }else if(decorrelate){
849 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
850 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
851 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
853 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
854 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
855 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
858 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
862 static void decode_bgr_bitstream(HYuvContext *s, int count){
864 if(s->bitstream_bpp==24)
865 decode_bgr_1(s, count, 1, 0);
867 decode_bgr_1(s, count, 1, 1);
869 if(s->bitstream_bpp==24)
870 decode_bgr_1(s, count, 0, 0);
872 decode_bgr_1(s, count, 0, 1);
876 static int encode_bgr_bitstream(HYuvContext *s, int count){
879 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
880 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
885 int g= s->temp[0][4*i+G];\
886 int b= (s->temp[0][4*i+B] - g) & 0xff;\
887 int r= (s->temp[0][4*i+R] - g) & 0xff;
893 put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
894 put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
895 put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
897 if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
898 for(i=0; i<count; i++){
902 }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
903 for(i=0; i<count; i++){
909 for(i=0; i<count; i++){
917 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
918 static void draw_slice(HYuvContext *s, int y){
922 if(s->avctx->draw_horiz_band==NULL)
925 h= y - s->last_slice_end;
928 if(s->bitstream_bpp==12){
934 offset[0] = s->picture.linesize[0]*y;
935 offset[1] = s->picture.linesize[1]*cy;
936 offset[2] = s->picture.linesize[2]*cy;
940 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
942 s->last_slice_end= y + h;
945 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
946 const uint8_t *buf = avpkt->data;
947 int buf_size = avpkt->size;
948 HYuvContext *s = avctx->priv_data;
949 const int width= s->width;
950 const int width2= s->width>>1;
951 const int height= s->height;
952 int fake_ystride, fake_ustride, fake_vstride;
953 AVFrame * const p= &s->picture;
956 AVFrame *picture = data;
958 s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
960 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
963 avctx->release_buffer(avctx, p);
966 if(avctx->get_buffer(avctx, p) < 0){
967 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
972 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
977 if((unsigned)(buf_size-table_size) >= INT_MAX/8)
980 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
982 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0];
983 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1];
984 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2];
986 s->last_slice_end= 0;
988 if(s->bitstream_bpp<24){
990 int lefty, leftu, leftv;
991 int lefttopy, lefttopu, lefttopv;
994 p->data[0][3]= get_bits(&s->gb, 8);
995 p->data[0][2]= get_bits(&s->gb, 8);
996 p->data[0][1]= get_bits(&s->gb, 8);
997 p->data[0][0]= get_bits(&s->gb, 8);
999 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
1003 leftv= p->data[2][0]= get_bits(&s->gb, 8);
1004 lefty= p->data[0][1]= get_bits(&s->gb, 8);
1005 leftu= p->data[1][0]= get_bits(&s->gb, 8);
1006 p->data[0][0]= get_bits(&s->gb, 8);
1008 switch(s->predictor){
1011 decode_422_bitstream(s, width-2);
1012 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1013 if(!(s->flags&CODEC_FLAG_GRAY)){
1014 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1015 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1018 for(cy=y=1; y<s->height; y++,cy++){
1019 uint8_t *ydst, *udst, *vdst;
1021 if(s->bitstream_bpp==12){
1022 decode_gray_bitstream(s, width);
1024 ydst= p->data[0] + p->linesize[0]*y;
1026 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1027 if(s->predictor == PLANE){
1029 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1032 if(y>=s->height) break;
1037 ydst= p->data[0] + p->linesize[0]*y;
1038 udst= p->data[1] + p->linesize[1]*cy;
1039 vdst= p->data[2] + p->linesize[2]*cy;
1041 decode_422_bitstream(s, width);
1042 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1043 if(!(s->flags&CODEC_FLAG_GRAY)){
1044 leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
1045 leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
1047 if(s->predictor == PLANE){
1048 if(cy>s->interlaced){
1049 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1050 if(!(s->flags&CODEC_FLAG_GRAY)){
1051 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1052 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1057 draw_slice(s, height);
1061 /* first line except first 2 pixels is left predicted */
1062 decode_422_bitstream(s, width-2);
1063 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1064 if(!(s->flags&CODEC_FLAG_GRAY)){
1065 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1066 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1071 /* second line is left predicted for interlaced case */
1073 decode_422_bitstream(s, width);
1074 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1075 if(!(s->flags&CODEC_FLAG_GRAY)){
1076 leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1077 leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1082 /* next 4 pixels are left predicted too */
1083 decode_422_bitstream(s, 4);
1084 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1085 if(!(s->flags&CODEC_FLAG_GRAY)){
1086 leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1087 leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1090 /* next line except the first 4 pixels is median predicted */
1091 lefttopy= p->data[0][3];
1092 decode_422_bitstream(s, width-4);
1093 s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1094 if(!(s->flags&CODEC_FLAG_GRAY)){
1095 lefttopu= p->data[1][1];
1096 lefttopv= p->data[2][1];
1097 s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
1098 s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
1102 for(; y<height; y++,cy++){
1103 uint8_t *ydst, *udst, *vdst;
1105 if(s->bitstream_bpp==12){
1107 decode_gray_bitstream(s, width);
1108 ydst= p->data[0] + p->linesize[0]*y;
1109 s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1112 if(y>=height) break;
1116 decode_422_bitstream(s, width);
1118 ydst= p->data[0] + p->linesize[0]*y;
1119 udst= p->data[1] + p->linesize[1]*cy;
1120 vdst= p->data[2] + p->linesize[2]*cy;
1122 s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1123 if(!(s->flags&CODEC_FLAG_GRAY)){
1124 s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1125 s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1129 draw_slice(s, height);
1135 int leftr, leftg, leftb;
1136 const int last_line= (height-1)*p->linesize[0];
1138 if(s->bitstream_bpp==32){
1139 skip_bits(&s->gb, 8);
1140 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1141 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1142 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1144 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1145 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1146 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1147 skip_bits(&s->gb, 8);
1151 switch(s->predictor){
1154 decode_bgr_bitstream(s, width-1);
1155 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
1157 for(y=s->height-2; y>=0; y--){ //Yes it is stored upside down.
1158 decode_bgr_bitstream(s, width);
1160 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
1161 if(s->predictor == PLANE){
1162 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
1163 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
1164 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
1168 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1171 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1175 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1182 *data_size = sizeof(AVFrame);
1184 return (get_bits_count(&s->gb)+31)/32*4 + table_size;
1186 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1188 static int common_end(HYuvContext *s){
1192 av_freep(&s->temp[i]);
1197 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
1198 static av_cold int decode_end(AVCodecContext *avctx)
1200 HYuvContext *s = avctx->priv_data;
1204 av_freep(&s->bitstream_buffer);
1207 free_vlc(&s->vlc[i]);
1212 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1214 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
1215 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1216 HYuvContext *s = avctx->priv_data;
1217 AVFrame *pict = data;
1218 const int width= s->width;
1219 const int width2= s->width>>1;
1220 const int height= s->height;
1221 const int fake_ystride= s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
1222 const int fake_ustride= s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
1223 const int fake_vstride= s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
1224 AVFrame * const p= &s->picture;
1228 p->pict_type= FF_I_TYPE;
1233 generate_len_table(s->len[i], s->stats[i], 256);
1234 if(generate_bits_table(s->bits[i], s->len[i])<0)
1236 size+= store_table(s, s->len[i], &buf[size]);
1240 for(j=0; j<256; j++)
1241 s->stats[i][j] >>= 1;
1244 init_put_bits(&s->pb, buf+size, buf_size-size);
1246 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1247 int lefty, leftu, leftv, y, cy;
1249 put_bits(&s->pb, 8, leftv= p->data[2][0]);
1250 put_bits(&s->pb, 8, lefty= p->data[0][1]);
1251 put_bits(&s->pb, 8, leftu= p->data[1][0]);
1252 put_bits(&s->pb, 8, p->data[0][0]);
1254 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1255 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1256 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
1258 encode_422_bitstream(s, width-2);
1260 if(s->predictor==MEDIAN){
1261 int lefttopy, lefttopu, lefttopv;
1264 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1265 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1266 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1268 encode_422_bitstream(s, width);
1272 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1273 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1274 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1276 encode_422_bitstream(s, 4);
1278 lefttopy= p->data[0][3];
1279 lefttopu= p->data[1][1];
1280 lefttopv= p->data[2][1];
1281 s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1282 s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1283 s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1284 encode_422_bitstream(s, width-4);
1287 for(; y<height; y++,cy++){
1288 uint8_t *ydst, *udst, *vdst;
1290 if(s->bitstream_bpp==12){
1292 ydst= p->data[0] + p->linesize[0]*y;
1293 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1294 encode_gray_bitstream(s, width);
1297 if(y>=height) break;
1299 ydst= p->data[0] + p->linesize[0]*y;
1300 udst= p->data[1] + p->linesize[1]*cy;
1301 vdst= p->data[2] + p->linesize[2]*cy;
1303 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1304 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1305 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1307 encode_422_bitstream(s, width);
1310 for(cy=y=1; y<height; y++,cy++){
1311 uint8_t *ydst, *udst, *vdst;
1313 /* encode a luma only line & y++ */
1314 if(s->bitstream_bpp==12){
1315 ydst= p->data[0] + p->linesize[0]*y;
1317 if(s->predictor == PLANE && s->interlaced < y){
1318 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1320 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1322 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1324 encode_gray_bitstream(s, width);
1326 if(y>=height) break;
1329 ydst= p->data[0] + p->linesize[0]*y;
1330 udst= p->data[1] + p->linesize[1]*cy;
1331 vdst= p->data[2] + p->linesize[2]*cy;
1333 if(s->predictor == PLANE && s->interlaced < cy){
1334 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1335 s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1336 s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1338 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1339 leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1340 leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1342 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1343 leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1344 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1347 encode_422_bitstream(s, width);
1350 }else if(avctx->pix_fmt == PIX_FMT_RGB32){
1351 uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1352 const int stride = -p->linesize[0];
1353 const int fake_stride = -fake_ystride;
1355 int leftr, leftg, leftb;
1357 put_bits(&s->pb, 8, leftr= data[R]);
1358 put_bits(&s->pb, 8, leftg= data[G]);
1359 put_bits(&s->pb, 8, leftb= data[B]);
1360 put_bits(&s->pb, 8, 0);
1362 sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
1363 encode_bgr_bitstream(s, width-1);
1365 for(y=1; y<s->height; y++){
1366 uint8_t *dst = data + y*stride;
1367 if(s->predictor == PLANE && s->interlaced < y){
1368 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
1369 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1371 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1373 encode_bgr_bitstream(s, width);
1376 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1380 size+= (put_bits_count(&s->pb)+31)/8;
1381 put_bits(&s->pb, 16, 0);
1382 put_bits(&s->pb, 15, 0);
1385 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1387 char *p= avctx->stats_out;
1388 char *end= p + 1024*30;
1390 for(j=0; j<256; j++){
1391 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1395 snprintf(p, end-p, "\n");
1399 avctx->stats_out[0] = '\0';
1400 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1401 flush_put_bits(&s->pb);
1402 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1405 s->picture_number++;
1410 static av_cold int encode_end(AVCodecContext *avctx)
1412 HYuvContext *s = avctx->priv_data;
1416 av_freep(&avctx->extradata);
1417 av_freep(&avctx->stats_out);
1421 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
1423 #if CONFIG_HUFFYUV_DECODER
1424 AVCodec huffyuv_decoder = {
1428 sizeof(HYuvContext),
1433 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1435 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1439 #if CONFIG_FFVHUFF_DECODER
1440 AVCodec ffvhuff_decoder = {
1444 sizeof(HYuvContext),
1449 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1451 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1455 #if CONFIG_HUFFYUV_ENCODER
1456 AVCodec huffyuv_encoder = {
1460 sizeof(HYuvContext),
1464 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
1465 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1469 #if CONFIG_FFVHUFF_ENCODER
1470 AVCodec ffvhuff_encoder = {
1474 sizeof(HYuvContext),
1478 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
1479 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),