2 * huffyuv codec for libavcodec
4 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
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 VLC vlc[6]; //Y,U,V,YY,YU,YV
75 uint8_t *bitstream_buffer;
76 unsigned int bitstream_buffer_size;
80 static const unsigned char classic_shift_luma[] = {
81 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
82 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
86 static const unsigned char classic_shift_chroma[] = {
87 66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
88 56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
89 214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
92 static const unsigned char classic_add_luma[256] = {
93 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
94 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
95 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
96 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
97 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
98 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
99 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
100 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
101 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
102 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
103 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
104 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
105 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
106 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
107 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
108 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
111 static const unsigned char classic_add_chroma[256] = {
112 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
113 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
114 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
115 43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
116 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
117 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
118 17, 14, 5, 6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
119 112,113,114,115, 4,117,118, 92, 94,121,122, 3,124,103, 2, 1,
120 0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
121 135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
122 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
123 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
124 7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
125 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
126 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
127 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
130 static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
133 for(i=0; i<w-1; i++){
149 static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
157 l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
166 static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
188 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
192 const int temp= src[i];
199 const int temp= src[i];
203 s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
208 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
214 for(i=0; i<FFMIN(w,4); i++){
215 const int rt= src[i*4+R];
216 const int gt= src[i*4+G];
217 const int bt= src[i*4+B];
225 s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
226 *red= src[(w-1)*4+R];
227 *green= src[(w-1)*4+G];
228 *blue= src[(w-1)*4+B];
231 static void read_len_table(uint8_t *dst, GetBitContext *gb){
235 repeat= get_bits(gb, 3);
236 val = get_bits(gb, 5);
238 repeat= get_bits(gb, 8);
239 //printf("%d %d\n", val, repeat);
245 static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
249 for(len=32; len>0; len--){
250 for(index=0; index<256; index++){
251 if(len_table[index]==len)
255 av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
263 #ifdef CONFIG_ENCODERS
269 static void heap_sift(heap_elem_t *h, int root, int size)
271 while(root*2+1 < size) {
272 int child = root*2+1;
273 if(child < size-1 && h[child].val > h[child+1].val)
275 if(h[root].val > h[child].val) {
276 FFSWAP(heap_elem_t, h[root], h[child]);
283 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
289 for(offset=1; ; offset<<=1){
290 for(i=0; i<size; i++){
292 h[i].val = (stats[i] << 8) + offset;
294 for(i=size/2-1; i>=0; i--)
295 heap_sift(h, i, size);
297 for(next=size; next<size*2-1; next++){
298 // merge the two smallest entries, and put it back in the heap
299 uint64_t min1v = h[0].val;
300 up[h[0].name] = next;
301 h[0].val = INT64_MAX;
302 heap_sift(h, 0, size);
303 up[h[0].name] = next;
306 heap_sift(h, 0, size);
310 for(i=2*size-3; i>=size; i--)
311 len[i] = len[up[i]] + 1;
312 for(i=0; i<size; i++) {
313 dst[i] = len[up[i]] + 1;
314 if(dst[i] > 32) break;
319 #endif /* CONFIG_ENCODERS */
321 static void generate_joint_tables(HYuvContext *s){
323 if(s->bitstream_bpp < 24){
324 uint16_t symbols[1<<VLC_BITS];
325 uint16_t bits[1<<VLC_BITS];
326 uint8_t len[1<<VLC_BITS];
329 for(i=y=0; y<256; y++){
330 int len0 = s->len[0][y];
331 int limit = VLC_BITS - len0;
334 for(u=0; u<256; u++){
335 int len1 = s->len[p][u];
338 len[i] = len0 + len1;
339 bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
340 symbols[i] = (y<<8) + u;
341 if(symbols[i] != 0xffff) // reserved to mean "invalid"
345 free_vlc(&s->vlc[3+p]);
346 init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
351 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
355 init_get_bits(&gb, src, length*8);
358 read_len_table(s->len[i], &gb);
360 if(generate_bits_table(s->bits[i], s->len[i])<0){
364 for(j=0; j<256; j++){
365 printf("%6X, %2d, %3d\n", s->bits[i][j], s->len[i][j], j);
368 free_vlc(&s->vlc[i]);
369 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
372 generate_joint_tables(s);
374 return (get_bits_count(&gb)+7)/8;
377 static int read_old_huffman_tables(HYuvContext *s){
382 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
383 read_len_table(s->len[0], &gb);
384 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
385 read_len_table(s->len[1], &gb);
387 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i];
388 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
390 if(s->bitstream_bpp >= 24){
391 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
392 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
394 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
395 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
398 free_vlc(&s->vlc[i]);
399 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
402 generate_joint_tables(s);
406 av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
411 static void alloc_temp(HYuvContext *s){
414 if(s->bitstream_bpp<24){
416 s->temp[i]= av_malloc(s->width + 16);
420 s->temp[i]= av_malloc(4*s->width + 16);
425 static int common_init(AVCodecContext *avctx){
426 HYuvContext *s = avctx->priv_data;
429 s->flags= avctx->flags;
431 dsputil_init(&s->dsp, avctx);
433 s->width= avctx->width;
434 s->height= avctx->height;
435 assert(s->width>0 && s->height>0);
440 #ifdef CONFIG_DECODERS
441 static int decode_init(AVCodecContext *avctx)
443 HYuvContext *s = avctx->priv_data;
446 memset(s->vlc, 0, 3*sizeof(VLC));
448 avctx->coded_frame= &s->picture;
449 s->interlaced= s->height > 288;
452 //if(avctx->extradata)
453 // printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
454 if(avctx->extradata_size){
455 if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
456 s->version=1; // do such files exist at all?
463 int method, interlace;
465 method= ((uint8_t*)avctx->extradata)[0];
466 s->decorrelate= method&64 ? 1 : 0;
467 s->predictor= method&63;
468 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
469 if(s->bitstream_bpp==0)
470 s->bitstream_bpp= avctx->bits_per_sample&~7;
471 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
472 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
473 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
475 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
478 switch(avctx->bits_per_sample&7){
489 s->decorrelate= avctx->bits_per_sample >= 24;
492 s->predictor= MEDIAN;
496 s->predictor= LEFT; //OLD
500 s->bitstream_bpp= avctx->bits_per_sample & ~7;
503 if(read_old_huffman_tables(s) < 0)
507 switch(s->bitstream_bpp){
509 avctx->pix_fmt = PIX_FMT_YUV420P;
513 avctx->pix_fmt = PIX_FMT_YUYV422;
515 avctx->pix_fmt = PIX_FMT_YUV422P;
521 avctx->pix_fmt = PIX_FMT_RGB32;
523 avctx->pix_fmt = PIX_FMT_BGR24;
532 // av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
538 #ifdef CONFIG_ENCODERS
539 static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
547 for(; i<256 && len[i]==val && repeat<255; i++)
550 assert(val < 32 && val >0 && repeat<256 && repeat>0);
553 buf[index++]= repeat;
555 buf[index++]= val | (repeat<<5);
562 static int encode_init(AVCodecContext *avctx)
564 HYuvContext *s = avctx->priv_data;
569 avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
570 avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
573 avctx->coded_frame= &s->picture;
575 switch(avctx->pix_fmt){
576 case PIX_FMT_YUV420P:
577 s->bitstream_bpp= 12;
579 case PIX_FMT_YUV422P:
580 s->bitstream_bpp= 16;
583 s->bitstream_bpp= 24;
586 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
589 avctx->bits_per_sample= s->bitstream_bpp;
590 s->decorrelate= s->bitstream_bpp >= 24;
591 s->predictor= avctx->prediction_method;
592 s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
593 if(avctx->context_model==1){
594 s->context= avctx->context_model;
595 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
596 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
601 if(avctx->codec->id==CODEC_ID_HUFFYUV){
602 if(avctx->pix_fmt==PIX_FMT_YUV420P){
603 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
606 if(avctx->context_model){
607 av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
610 if(s->interlaced != ( s->height > 288 ))
611 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
614 if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
615 av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
619 ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
620 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
621 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
623 ((uint8_t*)avctx->extradata)[2]|= 0x40;
624 ((uint8_t*)avctx->extradata)[3]= 0;
625 s->avctx->extradata_size= 4;
628 char *p= avctx->stats_in;
638 for(j=0; j<256; j++){
639 s->stats[i][j]+= strtol(p, &next, 0);
640 if(next==p) return -1;
644 if(p[0]==0 || p[1]==0 || p[2]==0) break;
648 for(j=0; j<256; j++){
649 int d= FFMIN(j, 256-j);
651 s->stats[i][j]= 100000000/(d+1);
656 generate_len_table(s->len[i], s->stats[i], 256);
658 if(generate_bits_table(s->bits[i], s->len[i])<0){
662 s->avctx->extradata_size+=
663 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
668 int pels = s->width*s->height / (i?40:10);
669 for(j=0; j<256; j++){
670 int d= FFMIN(j, 256-j);
671 s->stats[i][j]= pels/(d+1);
680 // printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
688 #endif /* CONFIG_ENCODERS */
690 /* TODO instead of restarting the read when the code isn't in the first level
691 * of the joint table, jump into the 2nd level of the individual table. */
692 #define READ_2PIX(dst0, dst1, plane1){\
693 uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
698 dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
699 dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
703 static void decode_422_bitstream(HYuvContext *s, int count){
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);
714 static void decode_gray_bitstream(HYuvContext *s, int count){
719 for(i=0; i<count; i++){
720 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
724 #ifdef CONFIG_ENCODERS
725 static int encode_422_bitstream(HYuvContext *s, int count){
728 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
729 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
734 int y0 = s->temp[0][2*i];\
735 int y1 = s->temp[0][2*i+1];\
736 int u0 = s->temp[1][i];\
737 int v0 = s->temp[2][i];
740 if(s->flags&CODEC_FLAG_PASS1){
741 for(i=0; i<count; i++){
749 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
752 for(i=0; i<count; i++){
755 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
757 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
759 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
761 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
764 for(i=0; i<count; i++){
766 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]);
768 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
769 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
775 static int encode_gray_bitstream(HYuvContext *s, int count){
778 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
779 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
784 int y0 = s->temp[0][2*i];\
785 int y1 = s->temp[0][2*i+1];
790 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
791 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
794 if(s->flags&CODEC_FLAG_PASS1){
795 for(i=0; i<count; i++){
800 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
804 for(i=0; i<count; i++){
810 for(i=0; i<count; i++){
817 #endif /* CONFIG_ENCODERS */
819 static void decode_bgr_bitstream(HYuvContext *s, int count){
823 if(s->bitstream_bpp==24){
824 for(i=0; i<count; i++){
825 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
826 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
827 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
830 for(i=0; i<count; i++){
831 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
832 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
833 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
834 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
838 if(s->bitstream_bpp==24){
839 for(i=0; i<count; i++){
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 for(i=0; i<count; i++){
846 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
847 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
848 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
849 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
855 static int encode_bgr_bitstream(HYuvContext *s, int count){
858 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
859 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
864 int g= s->temp[0][4*i+G];\
865 int b= (s->temp[0][4*i+B] - g) & 0xff;\
866 int r= (s->temp[0][4*i+R] - g) & 0xff;
872 put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
873 put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
874 put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
876 if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
877 for(i=0; i<count; i++){
881 }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
882 for(i=0; i<count; i++){
888 for(i=0; i<count; i++){
896 #ifdef CONFIG_DECODERS
897 static void draw_slice(HYuvContext *s, int y){
901 if(s->avctx->draw_horiz_band==NULL)
904 h= y - s->last_slice_end;
907 if(s->bitstream_bpp==12){
913 offset[0] = s->picture.linesize[0]*y;
914 offset[1] = s->picture.linesize[1]*cy;
915 offset[2] = s->picture.linesize[2]*cy;
919 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
921 s->last_slice_end= y + h;
924 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
925 HYuvContext *s = avctx->priv_data;
926 const int width= s->width;
927 const int width2= s->width>>1;
928 const int height= s->height;
929 int fake_ystride, fake_ustride, fake_vstride;
930 AVFrame * const p= &s->picture;
933 AVFrame *picture = data;
935 s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
937 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
940 avctx->release_buffer(avctx, p);
943 if(avctx->get_buffer(avctx, p) < 0){
944 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
949 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
954 if((unsigned)(buf_size-table_size) >= INT_MAX/8)
957 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
959 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0];
960 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1];
961 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2];
963 s->last_slice_end= 0;
965 if(s->bitstream_bpp<24){
967 int lefty, leftu, leftv;
968 int lefttopy, lefttopu, lefttopv;
971 p->data[0][3]= get_bits(&s->gb, 8);
972 p->data[0][2]= get_bits(&s->gb, 8);
973 p->data[0][1]= get_bits(&s->gb, 8);
974 p->data[0][0]= get_bits(&s->gb, 8);
976 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
980 leftv= p->data[2][0]= get_bits(&s->gb, 8);
981 lefty= p->data[0][1]= get_bits(&s->gb, 8);
982 leftu= p->data[1][0]= get_bits(&s->gb, 8);
983 p->data[0][0]= get_bits(&s->gb, 8);
985 switch(s->predictor){
988 decode_422_bitstream(s, width-2);
989 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
990 if(!(s->flags&CODEC_FLAG_GRAY)){
991 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
992 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
995 for(cy=y=1; y<s->height; y++,cy++){
996 uint8_t *ydst, *udst, *vdst;
998 if(s->bitstream_bpp==12){
999 decode_gray_bitstream(s, width);
1001 ydst= p->data[0] + p->linesize[0]*y;
1003 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1004 if(s->predictor == PLANE){
1006 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1009 if(y>=s->height) break;
1014 ydst= p->data[0] + p->linesize[0]*y;
1015 udst= p->data[1] + p->linesize[1]*cy;
1016 vdst= p->data[2] + p->linesize[2]*cy;
1018 decode_422_bitstream(s, width);
1019 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1020 if(!(s->flags&CODEC_FLAG_GRAY)){
1021 leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
1022 leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
1024 if(s->predictor == PLANE){
1025 if(cy>s->interlaced){
1026 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1027 if(!(s->flags&CODEC_FLAG_GRAY)){
1028 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1029 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1034 draw_slice(s, height);
1038 /* first line except first 2 pixels is left predicted */
1039 decode_422_bitstream(s, width-2);
1040 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1041 if(!(s->flags&CODEC_FLAG_GRAY)){
1042 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1043 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1048 /* second line is left predicted for interlaced case */
1050 decode_422_bitstream(s, width);
1051 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1052 if(!(s->flags&CODEC_FLAG_GRAY)){
1053 leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1054 leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1059 /* next 4 pixels are left predicted too */
1060 decode_422_bitstream(s, 4);
1061 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1062 if(!(s->flags&CODEC_FLAG_GRAY)){
1063 leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1064 leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1067 /* next line except the first 4 pixels is median predicted */
1068 lefttopy= p->data[0][3];
1069 decode_422_bitstream(s, width-4);
1070 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1071 if(!(s->flags&CODEC_FLAG_GRAY)){
1072 lefttopu= p->data[1][1];
1073 lefttopv= p->data[2][1];
1074 add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
1075 add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
1079 for(; y<height; y++,cy++){
1080 uint8_t *ydst, *udst, *vdst;
1082 if(s->bitstream_bpp==12){
1084 decode_gray_bitstream(s, width);
1085 ydst= p->data[0] + p->linesize[0]*y;
1086 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1089 if(y>=height) break;
1093 decode_422_bitstream(s, width);
1095 ydst= p->data[0] + p->linesize[0]*y;
1096 udst= p->data[1] + p->linesize[1]*cy;
1097 vdst= p->data[2] + p->linesize[2]*cy;
1099 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1100 if(!(s->flags&CODEC_FLAG_GRAY)){
1101 add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1102 add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1106 draw_slice(s, height);
1112 int leftr, leftg, leftb;
1113 const int last_line= (height-1)*p->linesize[0];
1115 if(s->bitstream_bpp==32){
1116 skip_bits(&s->gb, 8);
1117 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1118 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1119 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1121 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1122 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1123 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1124 skip_bits(&s->gb, 8);
1128 switch(s->predictor){
1131 decode_bgr_bitstream(s, width-1);
1132 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
1134 for(y=s->height-2; y>=0; y--){ //yes its stored upside down
1135 decode_bgr_bitstream(s, width);
1137 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
1138 if(s->predictor == PLANE){
1139 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
1140 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
1141 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
1145 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1148 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1152 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1159 *data_size = sizeof(AVFrame);
1161 return (get_bits_count(&s->gb)+31)/32*4 + table_size;
1165 static int common_end(HYuvContext *s){
1169 av_freep(&s->temp[i]);
1174 #ifdef CONFIG_DECODERS
1175 static int decode_end(AVCodecContext *avctx)
1177 HYuvContext *s = avctx->priv_data;
1181 av_freep(&s->bitstream_buffer);
1184 free_vlc(&s->vlc[i]);
1191 #ifdef CONFIG_ENCODERS
1192 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1193 HYuvContext *s = avctx->priv_data;
1194 AVFrame *pict = data;
1195 const int width= s->width;
1196 const int width2= s->width>>1;
1197 const int height= s->height;
1198 const int fake_ystride= s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
1199 const int fake_ustride= s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
1200 const int fake_vstride= s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
1201 AVFrame * const p= &s->picture;
1205 p->pict_type= FF_I_TYPE;
1210 generate_len_table(s->len[i], s->stats[i], 256);
1211 if(generate_bits_table(s->bits[i], s->len[i])<0)
1213 size+= store_table(s, s->len[i], &buf[size]);
1217 for(j=0; j<256; j++)
1218 s->stats[i][j] >>= 1;
1221 init_put_bits(&s->pb, buf+size, buf_size-size);
1223 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1224 int lefty, leftu, leftv, y, cy;
1226 put_bits(&s->pb, 8, leftv= p->data[2][0]);
1227 put_bits(&s->pb, 8, lefty= p->data[0][1]);
1228 put_bits(&s->pb, 8, leftu= p->data[1][0]);
1229 put_bits(&s->pb, 8, p->data[0][0]);
1231 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1232 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1233 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
1235 encode_422_bitstream(s, width-2);
1237 if(s->predictor==MEDIAN){
1238 int lefttopy, lefttopu, lefttopv;
1241 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1242 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1243 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1245 encode_422_bitstream(s, width);
1249 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1250 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1251 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1253 encode_422_bitstream(s, 4);
1255 lefttopy= p->data[0][3];
1256 lefttopu= p->data[1][1];
1257 lefttopv= p->data[2][1];
1258 s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1259 s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1260 s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1261 encode_422_bitstream(s, width-4);
1264 for(; y<height; y++,cy++){
1265 uint8_t *ydst, *udst, *vdst;
1267 if(s->bitstream_bpp==12){
1269 ydst= p->data[0] + p->linesize[0]*y;
1270 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1271 encode_gray_bitstream(s, width);
1274 if(y>=height) break;
1276 ydst= p->data[0] + p->linesize[0]*y;
1277 udst= p->data[1] + p->linesize[1]*cy;
1278 vdst= p->data[2] + p->linesize[2]*cy;
1280 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1281 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1282 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1284 encode_422_bitstream(s, width);
1287 for(cy=y=1; y<height; y++,cy++){
1288 uint8_t *ydst, *udst, *vdst;
1290 /* encode a luma only line & y++ */
1291 if(s->bitstream_bpp==12){
1292 ydst= p->data[0] + p->linesize[0]*y;
1294 if(s->predictor == PLANE && s->interlaced < y){
1295 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1297 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1299 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1301 encode_gray_bitstream(s, width);
1303 if(y>=height) break;
1306 ydst= p->data[0] + p->linesize[0]*y;
1307 udst= p->data[1] + p->linesize[1]*cy;
1308 vdst= p->data[2] + p->linesize[2]*cy;
1310 if(s->predictor == PLANE && s->interlaced < cy){
1311 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1312 s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1313 s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1315 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1316 leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1317 leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1319 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1320 leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1321 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1324 encode_422_bitstream(s, width);
1327 }else if(avctx->pix_fmt == PIX_FMT_RGB32){
1328 uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1329 const int stride = -p->linesize[0];
1330 const int fake_stride = -fake_ystride;
1332 int leftr, leftg, leftb;
1334 put_bits(&s->pb, 8, leftr= data[R]);
1335 put_bits(&s->pb, 8, leftg= data[G]);
1336 put_bits(&s->pb, 8, leftb= data[B]);
1337 put_bits(&s->pb, 8, 0);
1339 sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
1340 encode_bgr_bitstream(s, width-1);
1342 for(y=1; y<s->height; y++){
1343 uint8_t *dst = data + y*stride;
1344 if(s->predictor == PLANE && s->interlaced < y){
1345 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
1346 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1348 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1350 encode_bgr_bitstream(s, width);
1353 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1357 size+= (put_bits_count(&s->pb)+31)/8;
1360 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1362 char *p= avctx->stats_out;
1363 char *end= p + 1024*30;
1365 for(j=0; j<256; j++){
1366 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1370 snprintf(p, end-p, "\n");
1374 avctx->stats_out[0] = '\0';
1375 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1376 flush_put_bits(&s->pb);
1377 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1380 s->picture_number++;
1385 static int encode_end(AVCodecContext *avctx)
1387 HYuvContext *s = avctx->priv_data;
1391 av_freep(&avctx->extradata);
1392 av_freep(&avctx->stats_out);
1396 #endif /* CONFIG_ENCODERS */
1398 #ifdef CONFIG_DECODERS
1399 AVCodec huffyuv_decoder = {
1403 sizeof(HYuvContext),
1408 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1412 AVCodec ffvhuff_decoder = {
1416 sizeof(HYuvContext),
1421 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1426 #ifdef CONFIG_ENCODERS
1428 AVCodec huffyuv_encoder = {
1432 sizeof(HYuvContext),
1436 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
1439 AVCodec ffvhuff_encoder = {
1443 sizeof(HYuvContext),
1447 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
1450 #endif //CONFIG_ENCODERS