2 * huffyuv codec for libavcodec
4 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
26 * huffyuv codec for libavcodec.
30 #include "bitstream.h"
36 #ifdef WORDS_BIGENDIAN
46 typedef enum Predictor{
52 typedef struct HYuvContext{
53 AVCodecContext *avctx;
61 int yuy2; //use yuy2 instead of 422P
62 int bgr32; //use bgr32 instead of bgr24
69 uint64_t stats[3][256];
71 uint32_t bits[3][256];
74 uint8_t *bitstream_buffer;
75 unsigned int bitstream_buffer_size;
79 static const unsigned char classic_shift_luma[] = {
80 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
81 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
85 static const unsigned char classic_shift_chroma[] = {
86 66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
87 56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
88 214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
91 static const unsigned char classic_add_luma[256] = {
92 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
93 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
94 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
95 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
96 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
97 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
98 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
99 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
100 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
101 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
102 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
103 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
104 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
105 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
106 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
107 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
110 static const unsigned char classic_add_chroma[256] = {
111 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
112 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
113 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
114 43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
115 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
116 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
117 17, 14, 5, 6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
118 112,113,114,115, 4,117,118, 92, 94,121,122, 3,124,103, 2, 1,
119 0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
120 135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
121 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
122 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
123 7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
124 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
125 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
126 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
129 static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
132 for(i=0; i<w-1; i++){
148 static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
156 l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
165 static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
187 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
191 const int temp= src[i];
198 const int temp= src[i];
202 s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
207 static void read_len_table(uint8_t *dst, GetBitContext *gb){
211 repeat= get_bits(gb, 3);
212 val = get_bits(gb, 5);
214 repeat= get_bits(gb, 8);
215 //printf("%d %d\n", val, repeat);
221 static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
225 for(len=32; len>0; len--){
226 for(index=0; index<256; index++){
227 if(len_table[index]==len)
231 av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
239 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
240 uint64_t counts[2*size];
244 for(offset=1; ; offset<<=1){
245 for(i=0; i<size; i++){
246 counts[i]= stats[i] + offset - 1;
249 for(next=size; next<size*2; next++){
253 min1=min2= INT64_MAX;
256 for(i=0; i<next; i++){
257 if(min2 > counts[i]){
258 if(min1 > counts[i]){
270 if(min2==INT64_MAX) break;
272 counts[next]= min1 + min2;
274 counts[min2_i]= INT64_MAX;
280 for(i=0; i<size; i++){
284 for(len=0; up[index] != -1; len++)
295 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
299 init_get_bits(&gb, src, length*8);
302 read_len_table(s->len[i], &gb);
304 if(generate_bits_table(s->bits[i], s->len[i])<0){
308 for(j=0; j<256; j++){
309 printf("%6X, %2d, %3d\n", s->bits[i][j], s->len[i][j], j);
312 free_vlc(&s->vlc[i]);
313 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
316 return (get_bits_count(&gb)+7)/8;
319 static int read_old_huffman_tables(HYuvContext *s){
324 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
325 read_len_table(s->len[0], &gb);
326 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
327 read_len_table(s->len[1], &gb);
329 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i];
330 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
332 if(s->bitstream_bpp >= 24){
333 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
334 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
336 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
337 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
340 free_vlc(&s->vlc[i]);
341 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
346 av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
351 static void alloc_temp(HYuvContext *s){
354 if(s->bitstream_bpp<24){
356 s->temp[i]= av_malloc(s->width + 16);
359 s->temp[0]= av_malloc(4*s->width + 16);
363 static int common_init(AVCodecContext *avctx){
364 HYuvContext *s = avctx->priv_data;
367 s->flags= avctx->flags;
369 dsputil_init(&s->dsp, avctx);
371 s->width= avctx->width;
372 s->height= avctx->height;
373 assert(s->width>0 && s->height>0);
378 static int decode_init(AVCodecContext *avctx)
380 HYuvContext *s = avctx->priv_data;
383 memset(s->vlc, 0, 3*sizeof(VLC));
385 avctx->coded_frame= &s->picture;
386 s->interlaced= s->height > 288;
389 //if(avctx->extradata)
390 // printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
391 if(avctx->extradata_size){
392 if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
393 s->version=1; // do such files exist at all?
400 int method, interlace;
402 method= ((uint8_t*)avctx->extradata)[0];
403 s->decorrelate= method&64 ? 1 : 0;
404 s->predictor= method&63;
405 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
406 if(s->bitstream_bpp==0)
407 s->bitstream_bpp= avctx->bits_per_sample&~7;
408 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
409 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
410 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
412 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
415 switch(avctx->bits_per_sample&7){
426 s->decorrelate= avctx->bits_per_sample >= 24;
429 s->predictor= MEDIAN;
433 s->predictor= LEFT; //OLD
437 s->bitstream_bpp= avctx->bits_per_sample & ~7;
440 if(read_old_huffman_tables(s) < 0)
444 switch(s->bitstream_bpp){
446 avctx->pix_fmt = PIX_FMT_YUV420P;
450 avctx->pix_fmt = PIX_FMT_YUV422;
452 avctx->pix_fmt = PIX_FMT_YUV422P;
458 avctx->pix_fmt = PIX_FMT_RGBA32;
460 avctx->pix_fmt = PIX_FMT_BGR24;
469 // av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
474 static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
482 for(; i<256 && len[i]==val && repeat<255; i++)
485 assert(val < 32 && val >0 && repeat<256 && repeat>0);
488 buf[index++]= repeat;
490 buf[index++]= val | (repeat<<5);
497 static int encode_init(AVCodecContext *avctx)
499 HYuvContext *s = avctx->priv_data;
504 avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
505 avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
508 avctx->coded_frame= &s->picture;
510 switch(avctx->pix_fmt){
511 case PIX_FMT_YUV420P:
512 s->bitstream_bpp= 12;
514 case PIX_FMT_YUV422P:
515 s->bitstream_bpp= 16;
518 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
521 avctx->bits_per_sample= s->bitstream_bpp;
522 s->decorrelate= s->bitstream_bpp >= 24;
523 s->predictor= avctx->prediction_method;
524 s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
525 if(avctx->context_model==1){
526 s->context= avctx->context_model;
527 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
528 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
533 if(avctx->codec->id==CODEC_ID_HUFFYUV){
534 if(avctx->pix_fmt==PIX_FMT_YUV420P){
535 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
538 if(avctx->context_model){
539 av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
542 if(s->interlaced != ( s->height > 288 ))
543 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
544 }else if(avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
545 av_log(avctx, AV_LOG_ERROR, "This codec is under development; files encoded with it may not be decodable with future versions!!! Set vstrict=-2 / -strict -2 to use it anyway.\n");
549 ((uint8_t*)avctx->extradata)[0]= s->predictor;
550 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
551 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
553 ((uint8_t*)avctx->extradata)[2]|= 0x40;
554 ((uint8_t*)avctx->extradata)[3]= 0;
555 s->avctx->extradata_size= 4;
558 char *p= avctx->stats_in;
568 for(j=0; j<256; j++){
569 s->stats[i][j]+= strtol(p, &next, 0);
570 if(next==p) return -1;
574 if(p[0]==0 || p[1]==0 || p[2]==0) break;
578 for(j=0; j<256; j++){
579 int d= FFMIN(j, 256-j);
581 s->stats[i][j]= 100000000/(d+1);
586 generate_len_table(s->len[i], s->stats[i], 256);
588 if(generate_bits_table(s->bits[i], s->len[i])<0){
592 s->avctx->extradata_size+=
593 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
598 int pels = s->width*s->height / (i?40:10);
599 for(j=0; j<256; j++){
600 int d= FFMIN(j, 256-j);
601 s->stats[i][j]= pels/(d+1);
610 // printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
619 static void decode_422_bitstream(HYuvContext *s, int count){
624 for(i=0; i<count; i++){
625 s->temp[0][2*i ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
626 s->temp[1][ i ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
627 s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
628 s->temp[2][ i ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
632 static void decode_gray_bitstream(HYuvContext *s, int count){
637 for(i=0; i<count; i++){
638 s->temp[0][2*i ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
639 s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
643 static int encode_422_bitstream(HYuvContext *s, int count){
646 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
647 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
652 if(s->flags&CODEC_FLAG_PASS1){
653 for(i=0; i<count; i++){
654 s->stats[0][ s->temp[0][2*i ] ]++;
655 s->stats[1][ s->temp[1][ i ] ]++;
656 s->stats[0][ s->temp[0][2*i+1] ]++;
657 s->stats[2][ s->temp[2][ i ] ]++;
660 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
663 for(i=0; i<count; i++){
664 s->stats[0][ s->temp[0][2*i ] ]++;
665 put_bits(&s->pb, s->len[0][ s->temp[0][2*i ] ], s->bits[0][ s->temp[0][2*i ] ]);
666 s->stats[1][ s->temp[1][ i ] ]++;
667 put_bits(&s->pb, s->len[1][ s->temp[1][ i ] ], s->bits[1][ s->temp[1][ i ] ]);
668 s->stats[0][ s->temp[0][2*i+1] ]++;
669 put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
670 s->stats[2][ s->temp[2][ i ] ]++;
671 put_bits(&s->pb, s->len[2][ s->temp[2][ i ] ], s->bits[2][ s->temp[2][ i ] ]);
674 for(i=0; i<count; i++){
675 put_bits(&s->pb, s->len[0][ s->temp[0][2*i ] ], s->bits[0][ s->temp[0][2*i ] ]);
676 put_bits(&s->pb, s->len[1][ s->temp[1][ i ] ], s->bits[1][ s->temp[1][ i ] ]);
677 put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
678 put_bits(&s->pb, s->len[2][ s->temp[2][ i ] ], s->bits[2][ s->temp[2][ i ] ]);
684 static int encode_gray_bitstream(HYuvContext *s, int count){
687 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
688 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
693 if(s->flags&CODEC_FLAG_PASS1){
694 for(i=0; i<count; i++){
695 s->stats[0][ s->temp[0][2*i ] ]++;
696 s->stats[0][ s->temp[0][2*i+1] ]++;
699 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
703 for(i=0; i<count; i++){
704 s->stats[0][ s->temp[0][2*i ] ]++;
705 put_bits(&s->pb, s->len[0][ s->temp[0][2*i ] ], s->bits[0][ s->temp[0][2*i ] ]);
706 s->stats[0][ s->temp[0][2*i+1] ]++;
707 put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
710 for(i=0; i<count; i++){
711 put_bits(&s->pb, s->len[0][ s->temp[0][2*i ] ], s->bits[0][ s->temp[0][2*i ] ]);
712 put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
718 static void decode_bgr_bitstream(HYuvContext *s, int count){
722 if(s->bitstream_bpp==24){
723 for(i=0; i<count; i++){
724 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
725 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
726 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
729 for(i=0; i<count; i++){
730 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
731 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
732 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
733 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
737 if(s->bitstream_bpp==24){
738 for(i=0; i<count; i++){
739 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
740 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
741 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
744 for(i=0; i<count; i++){
745 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
746 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
747 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
748 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
754 static void draw_slice(HYuvContext *s, int y){
758 if(s->avctx->draw_horiz_band==NULL)
761 h= y - s->last_slice_end;
764 if(s->bitstream_bpp==12){
770 offset[0] = s->picture.linesize[0]*y;
771 offset[1] = s->picture.linesize[1]*cy;
772 offset[2] = s->picture.linesize[2]*cy;
776 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
778 s->last_slice_end= y + h;
781 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
782 HYuvContext *s = avctx->priv_data;
783 const int width= s->width;
784 const int width2= s->width>>1;
785 const int height= s->height;
786 int fake_ystride, fake_ustride, fake_vstride;
787 AVFrame * const p= &s->picture;
790 AVFrame *picture = data;
792 s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
794 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
797 avctx->release_buffer(avctx, p);
800 if(avctx->get_buffer(avctx, p) < 0){
801 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
806 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
811 if((unsigned)(buf_size-table_size) >= INT_MAX/8)
814 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
816 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0];
817 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1];
818 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2];
820 s->last_slice_end= 0;
822 if(s->bitstream_bpp<24){
824 int lefty, leftu, leftv;
825 int lefttopy, lefttopu, lefttopv;
828 p->data[0][3]= get_bits(&s->gb, 8);
829 p->data[0][2]= get_bits(&s->gb, 8);
830 p->data[0][1]= get_bits(&s->gb, 8);
831 p->data[0][0]= get_bits(&s->gb, 8);
833 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
837 leftv= p->data[2][0]= get_bits(&s->gb, 8);
838 lefty= p->data[0][1]= get_bits(&s->gb, 8);
839 leftu= p->data[1][0]= get_bits(&s->gb, 8);
840 p->data[0][0]= get_bits(&s->gb, 8);
842 switch(s->predictor){
845 decode_422_bitstream(s, width-2);
846 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
847 if(!(s->flags&CODEC_FLAG_GRAY)){
848 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
849 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
852 for(cy=y=1; y<s->height; y++,cy++){
853 uint8_t *ydst, *udst, *vdst;
855 if(s->bitstream_bpp==12){
856 decode_gray_bitstream(s, width);
858 ydst= p->data[0] + p->linesize[0]*y;
860 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
861 if(s->predictor == PLANE){
863 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
866 if(y>=s->height) break;
871 ydst= p->data[0] + p->linesize[0]*y;
872 udst= p->data[1] + p->linesize[1]*cy;
873 vdst= p->data[2] + p->linesize[2]*cy;
875 decode_422_bitstream(s, width);
876 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
877 if(!(s->flags&CODEC_FLAG_GRAY)){
878 leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
879 leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
881 if(s->predictor == PLANE){
882 if(cy>s->interlaced){
883 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
884 if(!(s->flags&CODEC_FLAG_GRAY)){
885 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
886 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
891 draw_slice(s, height);
895 /* first line except first 2 pixels is left predicted */
896 decode_422_bitstream(s, width-2);
897 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
898 if(!(s->flags&CODEC_FLAG_GRAY)){
899 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
900 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
905 /* second line is left predicted for interlaced case */
907 decode_422_bitstream(s, width);
908 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
909 if(!(s->flags&CODEC_FLAG_GRAY)){
910 leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
911 leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
916 /* next 4 pixels are left predicted too */
917 decode_422_bitstream(s, 4);
918 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
919 if(!(s->flags&CODEC_FLAG_GRAY)){
920 leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
921 leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
924 /* next line except the first 4 pixels is median predicted */
925 lefttopy= p->data[0][3];
926 decode_422_bitstream(s, width-4);
927 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
928 if(!(s->flags&CODEC_FLAG_GRAY)){
929 lefttopu= p->data[1][1];
930 lefttopv= p->data[2][1];
931 add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
932 add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
936 for(; y<height; y++,cy++){
937 uint8_t *ydst, *udst, *vdst;
939 if(s->bitstream_bpp==12){
941 decode_gray_bitstream(s, width);
942 ydst= p->data[0] + p->linesize[0]*y;
943 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
950 decode_422_bitstream(s, width);
952 ydst= p->data[0] + p->linesize[0]*y;
953 udst= p->data[1] + p->linesize[1]*cy;
954 vdst= p->data[2] + p->linesize[2]*cy;
956 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
957 if(!(s->flags&CODEC_FLAG_GRAY)){
958 add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
959 add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
963 draw_slice(s, height);
969 int leftr, leftg, leftb;
970 const int last_line= (height-1)*p->linesize[0];
972 if(s->bitstream_bpp==32){
973 skip_bits(&s->gb, 8);
974 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
975 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
976 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
978 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
979 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
980 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
981 skip_bits(&s->gb, 8);
985 switch(s->predictor){
988 decode_bgr_bitstream(s, width-1);
989 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
991 for(y=s->height-2; y>=0; y--){ //yes its stored upside down
992 decode_bgr_bitstream(s, width);
994 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
995 if(s->predictor == PLANE){
996 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
997 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
998 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
1002 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1005 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1009 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1016 *data_size = sizeof(AVFrame);
1018 return (get_bits_count(&s->gb)+31)/32*4;
1021 static int common_end(HYuvContext *s){
1025 av_freep(&s->temp[i]);
1030 static int decode_end(AVCodecContext *avctx)
1032 HYuvContext *s = avctx->priv_data;
1036 av_freep(&s->bitstream_buffer);
1039 free_vlc(&s->vlc[i]);
1045 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1046 HYuvContext *s = avctx->priv_data;
1047 AVFrame *pict = data;
1048 const int width= s->width;
1049 const int width2= s->width>>1;
1050 const int height= s->height;
1051 const int fake_ystride= s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
1052 const int fake_ustride= s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
1053 const int fake_vstride= s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
1054 AVFrame * const p= &s->picture;
1058 p->pict_type= FF_I_TYPE;
1063 generate_len_table(s->len[i], s->stats[i], 256);
1064 if(generate_bits_table(s->bits[i], s->len[i])<0)
1066 size+= store_table(s, s->len[i], &buf[size]);
1070 for(j=0; j<256; j++)
1071 s->stats[i][j] >>= 1;
1074 init_put_bits(&s->pb, buf+size, buf_size-size);
1076 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1077 int lefty, leftu, leftv, y, cy;
1079 put_bits(&s->pb, 8, leftv= p->data[2][0]);
1080 put_bits(&s->pb, 8, lefty= p->data[0][1]);
1081 put_bits(&s->pb, 8, leftu= p->data[1][0]);
1082 put_bits(&s->pb, 8, p->data[0][0]);
1084 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1085 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1086 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
1088 encode_422_bitstream(s, width-2);
1090 if(s->predictor==MEDIAN){
1091 int lefttopy, lefttopu, lefttopv;
1094 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1095 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1096 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1098 encode_422_bitstream(s, width);
1102 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1103 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1104 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1106 encode_422_bitstream(s, 4);
1108 lefttopy= p->data[0][3];
1109 lefttopu= p->data[1][1];
1110 lefttopv= p->data[2][1];
1111 s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1112 s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1113 s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1114 encode_422_bitstream(s, width-4);
1117 for(; y<height; y++,cy++){
1118 uint8_t *ydst, *udst, *vdst;
1120 if(s->bitstream_bpp==12){
1122 ydst= p->data[0] + p->linesize[0]*y;
1123 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1124 encode_gray_bitstream(s, width);
1127 if(y>=height) break;
1129 ydst= p->data[0] + p->linesize[0]*y;
1130 udst= p->data[1] + p->linesize[1]*cy;
1131 vdst= p->data[2] + p->linesize[2]*cy;
1133 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1134 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1135 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1137 encode_422_bitstream(s, width);
1140 for(cy=y=1; y<height; y++,cy++){
1141 uint8_t *ydst, *udst, *vdst;
1143 /* encode a luma only line & y++ */
1144 if(s->bitstream_bpp==12){
1145 ydst= p->data[0] + p->linesize[0]*y;
1147 if(s->predictor == PLANE && s->interlaced < y){
1148 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1150 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1152 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1154 encode_gray_bitstream(s, width);
1156 if(y>=height) break;
1159 ydst= p->data[0] + p->linesize[0]*y;
1160 udst= p->data[1] + p->linesize[1]*cy;
1161 vdst= p->data[2] + p->linesize[2]*cy;
1163 if(s->predictor == PLANE && s->interlaced < cy){
1164 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1165 s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1166 s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1168 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1169 leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1170 leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1172 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1173 leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1174 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1177 encode_422_bitstream(s, width);
1181 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1185 size+= (put_bits_count(&s->pb)+31)/8;
1188 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1190 char *p= avctx->stats_out;
1191 char *end= p + 1024*30;
1193 for(j=0; j<256; j++){
1194 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1198 snprintf(p, end-p, "\n");
1202 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1203 flush_put_bits(&s->pb);
1204 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1205 avctx->stats_out[0] = '\0';
1208 s->picture_number++;
1213 static int encode_end(AVCodecContext *avctx)
1215 HYuvContext *s = avctx->priv_data;
1219 av_freep(&avctx->extradata);
1220 av_freep(&avctx->stats_out);
1225 AVCodec huffyuv_decoder = {
1229 sizeof(HYuvContext),
1234 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1238 AVCodec ffvhuff_decoder = {
1242 sizeof(HYuvContext),
1247 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1251 #ifdef CONFIG_ENCODERS
1253 AVCodec huffyuv_encoder = {
1257 sizeof(HYuvContext),
1263 AVCodec ffvhuff_encoder = {
1267 sizeof(HYuvContext),
1273 #endif //CONFIG_ENCODERS