diff options
| -rw-r--r-- | Changelog | 1 | ||||
| -rw-r--r-- | doc/ffmpeg-doc.texi | 4 | ||||
| -rw-r--r-- | libavcodec/dv.c | 378 | ||||
| -rw-r--r-- | libavformat/dv.c | 1 |
4 files changed, 373 insertions, 11 deletions
@@ -1,4 +1,5 @@ version <next>: +- DV encoder, DV muxer - Microsoft RLE video decoder - Microsoft Video-1 decoder - Apple Video (RPZA) decoder diff --git a/doc/ffmpeg-doc.texi b/doc/ffmpeg-doc.texi index 1cdd2f6fa4..b0248b02fa 100644 --- a/doc/ffmpeg-doc.texi +++ b/doc/ffmpeg-doc.texi @@ -618,7 +618,7 @@ library: @item MPEG4 @tab X @tab X @tab MPEG4 is a variant of Quicktime @item Raw MPEG4 video @tab X @tab X -@item DV @tab @tab X +@item DV @tab X @tab X @item 4xm @tab @tab X @tab 4X Technologies format, used in some games @item Playstation STR @tab @tab X @@ -668,7 +668,7 @@ following image formats are supported: @item WMV8 @tab X @tab X @tab Not completely working @item H263(+) @tab X @tab X @tab Also known as Real Video 1.0 @item MJPEG @tab X @tab X -@item DV @tab @tab X +@item DV @tab X @tab X @item Huff YUV @tab X @tab X @item Asus v1 @tab X @tab X @tab fourcc: ASV1 @item Asus v2 @tab X @tab X @tab fourcc: ASV2 diff --git a/libavcodec/dv.c b/libavcodec/dv.c index 4281267f60..b9a39965c4 100644 --- a/libavcodec/dv.c +++ b/libavcodec/dv.c @@ -2,6 +2,12 @@ * DV decoder * Copyright (c) 2002 Fabrice Bellard. * + * DV encoder + * Copyright (c) 2003 Roman Shaposhnik. + * + * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth + * of DV technical info. + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either @@ -19,7 +25,7 @@ /** * @file dv.c - * DV decoder. + * DV codec. */ #include "avcodec.h" #include "dsputil.h" @@ -72,7 +78,7 @@ static void dv_build_unquantize_tables(DVVideoDecodeContext *s) } } -static int dvvideo_decode_init(AVCodecContext *avctx) +static int dvvideo_init(AVCodecContext *avctx) { DVVideoDecodeContext *s = avctx->priv_data; MpegEncContext s2; @@ -140,6 +146,10 @@ static int dvvideo_decode_init(AVCodecContext *avctx) /* XXX: do it only for constant case */ dv_build_unquantize_tables(s); + /* FIXME: I really don't think this should be here */ + if (dv_codec_profile(avctx)) + avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt; + return 0; } @@ -368,6 +378,9 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s, mb->pos = 0; mb->partial_bit_count = 0; +#ifdef VLC_DEBUG + printf("MB block: %d, %d ", mb_index, j); +#endif dv_decode_ac(s, mb, block, last_index); /* write the remaining bits in a new buffer only if the @@ -391,7 +404,7 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s, /* pass 2 : we can do it just after */ #ifdef VLC_DEBUG - printf("***pass 2 size=%d\n", mb_bit_count); + printf("***pass 2 size=%d MB#=%d\n", mb_bit_count, mb_index); #endif block = block1; mb = mb1; @@ -501,6 +514,317 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s, } } +/* Converts run and level (where level != 0) pair into vlc, returning bit size */ +static inline int dv_rl2vlc(int run, int l, uint32_t* vlc) +{ + int sign = l >> 8; + int level = (l ^ sign) - sign; + int size; + + sign = (sign & 1); + + if (run < 15 && level < 23 && dv_vlc_codes[run][level] != -1) { + *vlc = (dv_vlc_bits[dv_vlc_codes[run][level]] << 1) | sign; + size = dv_vlc_len[dv_vlc_codes[run][level]] + 1; + } + else { + if (level < 23) { + *vlc = (dv_vlc_bits[dv_vlc_codes[0][level]] << 1) | sign; + size = dv_vlc_len[dv_vlc_codes[0][level]] + 1; + } else { + *vlc = 0xfe00 | (level << 1) | sign; + size = 16; + } + + switch(run) { + case 0: + break; + case 1: + case 2: + *vlc |= ((0x7ce | (run - 1)) << size); + size += 11; + break; + case 3: + case 4: + case 5: + case 6: + *vlc |= ((0xfac | (run - 3)) << size); + size += 12; + break; + default: + *vlc |= ((0x1f80 | (run - 1)) << size); + size += 13; + break; + } + } + + return size; +} + +typedef struct EncBlockInfo { + int qno; + int cno; + int dct_mode; + int block_size; + DCTELEM *mb; + PutBitContext pb; +} EncBlockInfo; + +static inline int dv_bits_left(EncBlockInfo* bi) +{ + return (bi->block_size - get_bit_count(&bi->pb)); +} + +static inline void dv_encode_ac(EncBlockInfo* bi, PutBitContext* heap) +{ + int i, level, size, run = 0; + uint32_t vlc; + PutBitContext* cpb = &bi->pb; + + for (i=1; i<64; i++) { + level = bi->mb[ff_zigzag_direct[i]] / + (1<<(dv_quant_shifts[bi->qno + dv_quant_offset[bi->cno]] + [dv_88_areas[ff_zigzag_direct[i]]] + 4 + (bi->cno == 3))); + if (level != 0) { + size = dv_rl2vlc(run, level, &vlc); +put_vlc: + +#ifdef VLC_DEBUG + printf(" %3d:%3d", run, level); +#endif + if (cpb == &bi->pb && size > dv_bits_left(bi)) { + size -= dv_bits_left(bi); + put_bits(cpb, dv_bits_left(bi), vlc >> size); + vlc = vlc & ((1<<size)-1); + cpb = heap; + } + put_bits(cpb, size, vlc); + run = 0; + } else + run++; + } + + if (i == 64) { + size = 4; vlc = 6; /* End Of Block stamp */ + goto put_vlc; + } +} + +static inline void dv_redistr_bits(EncBlockInfo* bi, int count, uint8_t* extra_data, int extra_bits, PutBitContext* heap) +{ + int i; + GetBitContext gb; + + init_get_bits(&gb, extra_data, extra_bits); + + for (i=0; i<count; i++) { + int bits_left = dv_bits_left(bi); +#ifdef VLC_DEBUG + if (bits_left) + printf("------------> inserting %d bytes in %d:%d\n", bits_left, i/6, i%6); +#endif + if (bits_left > extra_bits) { + bit_copy(&bi->pb, &gb, extra_bits); + extra_bits = 0; + break; + } else + bit_copy(&bi->pb, &gb, bits_left); + + extra_bits -= bits_left; + bi++; + } + + if (extra_bits > 0 && heap) + bit_copy(heap, &gb, extra_bits); +} + +static inline void dv_set_class_number(EncBlockInfo* bi, int j) +{ + int i, max_ac = 0; + + for (i=1; i<64; i++) { + int ac = abs(bi->mb[ff_zigzag_direct[i]]) / 4; + if (max_ac < ac) + max_ac = ac; + } + if (max_ac < 12) + bi->cno = j; + else if (max_ac < 24) + bi->cno = j + 1; + else if (max_ac < 36) + bi->cno = j + 2; + else + bi->cno = j + 3; + + if (bi->cno > 3) + bi->cno = 3; +} + +/* + * This is a very rough initial implementaion. The performance is + * horrible and some features are missing, mainly 2-4-8 DCT encoding. + * The weighting is missing as well, but it's missing from the decoding + * step also -- so at least we're on the same page with decoder ;-) + */ +static inline void dv_encode_video_segment(DVVideoDecodeContext *s, + uint8_t *dif, + const uint16_t *mb_pos_ptr) +{ + int mb_index, i, j, v; + int mb_x, mb_y, c_offset, linesize; + uint8_t* y_ptr; + uint8_t* data; + int do_edge_wrap; + DCTELEM *block; + EncBlockInfo enc_blks[5*6]; + EncBlockInfo* enc_blk; + int free_vs_bits; + int extra_bits; + PutBitContext extra_vs; + uint8_t extra_vs_data[5*6*128]; + uint8_t extra_mb_data[6*128]; + + int QNO = 15; + + /* Stage 1 -- doing DCT on 5 MBs */ + block = &s->block[0][0]; + for(mb_index = 0; mb_index < 5; mb_index++) { + v = *mb_pos_ptr++; + mb_x = v & 0xff; + mb_y = v >> 8; + y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8); + c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ? + ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) : + (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8)); + do_edge_wrap = 0; + for(j = 0;j < 6; j++) { + if (j < 4) { /* Four Y blocks */ + /* NOTE: at end of line, the macroblock is handled as 420 */ + if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { + data = y_ptr + (j * 8); + } else { + data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]); + } + linesize = s->picture.linesize[0]; + } else { /* Cr and Cb blocks */ + /* don't ask Fabrice why they inverted Cb and Cr ! */ + data = s->picture.data[6 - j] + c_offset; + linesize = s->picture.linesize[6 - j]; + if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) + do_edge_wrap = 1; + } + + /* Everything is set up -- now just copy data -> DCT block */ + if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */ + uint8_t* d; + DCTELEM *b = block; + for (i=0;i<8;i++) { + d = data + 8 * linesize; + b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3]; + b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; + data += linesize; + b += 8; + } + } else { /* Simple copy: 8x8 -> 8x8 */ + s->get_pixels(block, data, linesize); + } + + s->fdct(block); + + block += 64; + } + } + + /* Stage 2 -- setup for encoding phase */ + enc_blk = &enc_blks[0]; + block = &s->block[0][0]; + for (i=0; i<5; i++) { + for (j=0; j<6; j++) { + enc_blk->mb = block; + enc_blk->dct_mode = 0; + enc_blk->block_size = block_sizes[j]; + + dv_set_class_number(enc_blk, j/4*(j%2)); + + block += 64; + enc_blk++; + } + } + + /* Stage 3 -- encoding by trial-and-error */ +encode_vs: + enc_blk = &enc_blks[0]; + for (i=0; i<5; i++) { + uint8_t* p = dif + i*80 + 4; + for (j=0; j<6; j++) { + enc_blk->qno = QNO; + init_put_bits(&enc_blk->pb, p, block_sizes[j]/8, NULL, NULL); + enc_blk++; + p += block_sizes[j]/8; + } + } + + init_put_bits(&extra_vs, extra_vs_data, sizeof(extra_vs_data), NULL, NULL); + free_vs_bits = 0; + enc_blk = &enc_blks[0]; + for (i=0; i<5; i++) { + PutBitContext extra_mb; + EncBlockInfo* enc_blk2 = enc_blk; + int free_mb_bits = 0; + + init_put_bits(&extra_mb, extra_mb_data, sizeof(extra_mb_data), NULL, NULL); + dif[i*80 + 3] = enc_blk->qno; + + for (j=0; j<6; j++) { + uint16_t dc = ((enc_blk->mb[0] >> 3) - 1024) >> 2; + + put_bits(&enc_blk->pb, 9, dc); + put_bits(&enc_blk->pb, 1, enc_blk->dct_mode); + put_bits(&enc_blk->pb, 2, enc_blk->cno); + +#ifdef VLC_DEBUG + printf("[%d, %d]: ", i, j); +#endif + dv_encode_ac(enc_blk, &extra_mb); +#ifdef VLC_DEBUG + printf("\n"); +#endif + + free_mb_bits += dv_bits_left(enc_blk); + enc_blk++; + } + + /* We can't flush extra_mb just yet -- since it'll round up bit number */ + extra_bits = get_bit_count(&extra_mb); + if (free_mb_bits > extra_bits) + free_vs_bits += free_mb_bits - extra_bits; + + if (extra_bits) { /* FIXME: speed up things when free_mb_bits == 0 */ + flush_put_bits(&extra_mb); + dv_redistr_bits(enc_blk2, 6, extra_mb_data, extra_bits, &extra_vs); + } + } + + /* We can't flush extra_mb just yet -- since it'll round up bit number */ + extra_bits = get_bit_count(&extra_vs); + if (extra_bits > free_vs_bits && QNO) { /* FIXME: very crude trial-and-error */ + QNO--; + goto encode_vs; + } + + if (extra_bits) { + flush_put_bits(&extra_vs); + dv_redistr_bits(&enc_blks[0], 5*6, extra_vs_data, extra_bits, NULL); + } + + for (i=0; i<6*5; i++) { + flush_put_bits(&enc_blks[i].pb); +#ifdef VLC_DEBUG + printf("[%d:%d] qno=%d cno=%d\n", i/6, i%6, enc_blks[i].qno, enc_blks[i].cno); +#endif + } +} + /* NOTE: exactly one frame must be given (120000 bytes for NTSC, 144000 bytes for PAL) */ static int dvvideo_decode_frame(AVCodecContext *avctx, @@ -535,6 +859,9 @@ static int dvvideo_decode_frame(AVCodecContext *avctx, if ((vs % 3) == 0) buf += 80; /* skip audio block */ +#ifdef VLC_DEBUG + printf("********************* %d, %d **********************\n", ds, vs); +#endif dv_decode_video_segment(s, buf, mb_pos_ptr); buf += 5 * 80; mb_pos_ptr += 5; @@ -550,10 +877,45 @@ static int dvvideo_decode_frame(AVCodecContext *avctx, return s->sys->frame_size; } -static int dvvideo_decode_end(AVCodecContext *avctx) +static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, + void *data) { - avcodec_default_free_buffers(avctx); + DVVideoDecodeContext *s = c->priv_data; + const uint16_t *mb_pos_ptr; + int ds, vs; + + s->sys = dv_codec_profile(c); + if (!s->sys) + return -1; + + c->pix_fmt = s->sys->pix_fmt; + s->picture = *((AVFrame *)data); + + /* for each DIF segment */ + mb_pos_ptr = s->sys->video_place; + for (ds = 0; ds < s->sys->difseg_size; ds++) { + buf += 6 * 80; /* skip DIF segment header */ + + for(vs = 0; vs < 27; vs++) { + if ((vs % 3) == 0) + buf += 80; /* skip audio block */ + +#ifdef VLC_DEBUG + printf("********************* %d, %d **********************\n", ds, vs); +#endif + dv_encode_video_segment(s, buf, mb_pos_ptr); + buf += 5 * 80; + mb_pos_ptr += 5; + } + } + emms_c(); + return s->sys->frame_size; +} + +static int dvvideo_end(AVCodecContext *avctx) +{ + avcodec_default_free_buffers(avctx); return 0; } @@ -562,9 +924,9 @@ AVCodec dvvideo_decoder = { CODEC_TYPE_VIDEO, CODEC_ID_DVVIDEO, sizeof(DVVideoDecodeContext), - dvvideo_decode_init, - NULL, - dvvideo_decode_end, + dvvideo_init, + dvvideo_encode_frame, + dvvideo_end, dvvideo_decode_frame, CODEC_CAP_DR1, NULL diff --git a/libavformat/dv.c b/libavformat/dv.c index b8e41be400..a132f97dde 100644 --- a/libavformat/dv.c +++ b/libavformat/dv.c @@ -678,7 +678,6 @@ bail_out: void dv_delete_mux(DVMuxContext *c) { fifo_free(&c->audio_data); - av_free(c); } DVDemuxContext* dv_init_demux(AVFormatContext *s, int vid, int aid) |