|
|
|
|
@ -24,18 +24,20 @@ |
|
|
|
|
* DV encoder |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
#include "config.h" |
|
|
|
|
|
|
|
|
|
#include "libavutil/attributes.h" |
|
|
|
|
#include "libavutil/pixdesc.h" |
|
|
|
|
#include "config.h" |
|
|
|
|
|
|
|
|
|
#include "avcodec.h" |
|
|
|
|
#include "dv.h" |
|
|
|
|
#include "dv_profile_internal.h" |
|
|
|
|
#include "dv_tablegen.h" |
|
|
|
|
#include "fdctdsp.h" |
|
|
|
|
#include "internal.h" |
|
|
|
|
#include "me_cmp.h" |
|
|
|
|
#include "pixblockdsp.h" |
|
|
|
|
#include "put_bits.h" |
|
|
|
|
#include "dv.h" |
|
|
|
|
#include "dv_tablegen.h" |
|
|
|
|
#include "dv_profile_internal.h" |
|
|
|
|
|
|
|
|
|
static av_cold int dvvideo_encode_init(AVCodecContext *avctx) |
|
|
|
|
{ |
|
|
|
|
@ -84,15 +86,15 @@ static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; |
|
|
|
|
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; |
|
|
|
|
|
|
|
|
|
#if CONFIG_SMALL |
|
|
|
|
/* Converts run and level (where level != 0) pair into VLC, returning bit size */ |
|
|
|
|
static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) |
|
|
|
|
/* Convert run and level (where level != 0) pair into VLC, returning bit size */ |
|
|
|
|
static av_always_inline int dv_rl2vlc(int run, int level, int sign, |
|
|
|
|
uint32_t *vlc) |
|
|
|
|
{ |
|
|
|
|
int size; |
|
|
|
|
if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
|
|
|
|
*vlc = dv_vlc_map[run][level].vlc | sign; |
|
|
|
|
size = dv_vlc_map[run][level].size; |
|
|
|
|
} |
|
|
|
|
else { |
|
|
|
|
} else { |
|
|
|
|
if (level < DV_VLC_MAP_LEV_SIZE) { |
|
|
|
|
*vlc = dv_vlc_map[0][level].vlc | sign; |
|
|
|
|
size = dv_vlc_map[0][level].size; |
|
|
|
|
@ -116,13 +118,11 @@ static av_always_inline int dv_rl2vlc_size(int run, int level) |
|
|
|
|
|
|
|
|
|
if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
|
|
|
|
size = dv_vlc_map[run][level].size; |
|
|
|
|
} |
|
|
|
|
else { |
|
|
|
|
} else { |
|
|
|
|
size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; |
|
|
|
|
if (run) { |
|
|
|
|
if (run) |
|
|
|
|
size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
return size; |
|
|
|
|
} |
|
|
|
|
#else |
|
|
|
|
@ -161,7 +161,8 @@ static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, |
|
|
|
|
int size = bi->partial_bit_count; |
|
|
|
|
uint32_t vlc = bi->partial_bit_buffer; |
|
|
|
|
|
|
|
|
|
bi->partial_bit_count = bi->partial_bit_buffer = 0; |
|
|
|
|
bi->partial_bit_count = |
|
|
|
|
bi->partial_bit_buffer = 0; |
|
|
|
|
for (;;) { |
|
|
|
|
/* Find suitable storage space */ |
|
|
|
|
for (; size > (bits_left = put_bits_left(pb)); pb++) { |
|
|
|
|
@ -187,15 +188,19 @@ static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, |
|
|
|
|
prev = bi->cur_ac; |
|
|
|
|
bi->cur_ac = bi->next[prev]; |
|
|
|
|
if (bi->cur_ac < 64) { |
|
|
|
|
size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); |
|
|
|
|
size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], |
|
|
|
|
bi->sign[bi->cur_ac], &vlc); |
|
|
|
|
} else { |
|
|
|
|
size = 4; vlc = 6; /* End Of Block stamp */ |
|
|
|
|
size = 4; |
|
|
|
|
vlc = 6; /* End Of Block stamp */ |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
return pb; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) { |
|
|
|
|
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, |
|
|
|
|
int linesize) |
|
|
|
|
{ |
|
|
|
|
if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) { |
|
|
|
|
int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400; |
|
|
|
|
if (ps > 0) { |
|
|
|
|
@ -230,21 +235,23 @@ static const int dv_weight_248[64] = { |
|
|
|
|
195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651, |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias) |
|
|
|
|
static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data, |
|
|
|
|
int linesize, DVVideoContext *s, |
|
|
|
|
int bias) |
|
|
|
|
{ |
|
|
|
|
const int *weight; |
|
|
|
|
const uint8_t *zigzag_scan; |
|
|
|
|
LOCAL_ALIGNED_16(int16_t, blk, [64]); |
|
|
|
|
int i, area; |
|
|
|
|
/* We offer two different methods for class number assignment: the
|
|
|
|
|
method suggested in SMPTE 314M Table 22, and an improved |
|
|
|
|
method. The SMPTE method is very conservative; it assigns class |
|
|
|
|
3 (i.e. severe quantization) to any block where the largest AC |
|
|
|
|
component is greater than 36. Libav's DV encoder tracks AC bit |
|
|
|
|
consumption precisely, so there is no need to bias most blocks |
|
|
|
|
towards strongly lossy compression. Instead, we assign class 2 |
|
|
|
|
to most blocks, and use class 3 only when strictly necessary |
|
|
|
|
(for blocks whose largest AC component exceeds 255). */ |
|
|
|
|
* method suggested in SMPTE 314M Table 22, and an improved |
|
|
|
|
* method. The SMPTE method is very conservative; it assigns class |
|
|
|
|
* 3 (i.e. severe quantization) to any block where the largest AC |
|
|
|
|
* component is greater than 36. Libav's DV encoder tracks AC bit |
|
|
|
|
* consumption precisely, so there is no need to bias most blocks |
|
|
|
|
* towards strongly lossy compression. Instead, we assign class 2 |
|
|
|
|
* to most blocks, and use class 3 only when strictly necessary |
|
|
|
|
* (for blocks whose largest AC component exceeds 255). */ |
|
|
|
|
|
|
|
|
|
#if 0 /* SMPTE spec method */
|
|
|
|
|
static const int classes[] = { 12, 24, 36, 0xffff }; |
|
|
|
|
@ -256,7 +263,10 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, i |
|
|
|
|
|
|
|
|
|
assert((((int) blk) & 15) == 0); |
|
|
|
|
|
|
|
|
|
bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0; |
|
|
|
|
bi->area_q[0] = |
|
|
|
|
bi->area_q[1] = |
|
|
|
|
bi->area_q[2] = |
|
|
|
|
bi->area_q[3] = 0; |
|
|
|
|
bi->partial_bit_count = 0; |
|
|
|
|
bi->partial_bit_buffer = 0; |
|
|
|
|
bi->cur_ac = 0; |
|
|
|
|
@ -265,8 +275,9 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, i |
|
|
|
|
s->get_pixels(blk, data, linesize); |
|
|
|
|
s->fdct[bi->dct_mode](blk); |
|
|
|
|
} else { |
|
|
|
|
/* We rely on the fact that encoding all zeros leads to an immediate EOB,
|
|
|
|
|
which is precisely what the spec calls for in the "dummy" blocks. */ |
|
|
|
|
/* We rely on the fact that encoding all zeros leads to an immediate
|
|
|
|
|
* EOB, which is precisely what the spec calls for in the "dummy" |
|
|
|
|
* blocks. */ |
|
|
|
|
memset(blk, 0, 64 * sizeof(*blk)); |
|
|
|
|
bi->dct_mode = 0; |
|
|
|
|
} |
|
|
|
|
@ -283,10 +294,11 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, i |
|
|
|
|
|
|
|
|
|
if (level + 15 > 30U) { |
|
|
|
|
bi->sign[i] = (level >> 31) & 1; |
|
|
|
|
/* weight it and and shift down into range, adding for rounding */ |
|
|
|
|
/* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
|
|
|
|
|
AND the 2x doubling of the weights */ |
|
|
|
|
level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4); |
|
|
|
|
/* Weight it and and shift down into range, adding for rounding.
|
|
|
|
|
* The extra division by a factor of 2^4 reverses the 8x |
|
|
|
|
* expansion of the DCT AND the 2x doubling of the weights. */ |
|
|
|
|
level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >> |
|
|
|
|
(dv_weight_bits + 4); |
|
|
|
|
bi->mb[i] = level; |
|
|
|
|
if (level > max) |
|
|
|
|
max = level; |
|
|
|
|
@ -297,7 +309,8 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, i |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
bi->next[prev] = i; |
|
|
|
|
for (bi->cno = 0; max > classes[bi->cno]; bi->cno++); |
|
|
|
|
for (bi->cno = 0; max > classes[bi->cno]; bi->cno++) |
|
|
|
|
; |
|
|
|
|
|
|
|
|
|
bi->cno += bias; |
|
|
|
|
|
|
|
|
|
@ -321,7 +334,8 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, i |
|
|
|
|
bi->next[prev] = i; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3]; |
|
|
|
|
return bi->bit_size[0] + bi->bit_size[1] + |
|
|
|
|
bi->bit_size[2] + bi->bit_size[3]; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos) |
|
|
|
|
@ -330,7 +344,11 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) |
|
|
|
|
int i, j, k, a, prev, a2; |
|
|
|
|
EncBlockInfo *b; |
|
|
|
|
|
|
|
|
|
size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24; |
|
|
|
|
size[0] = |
|
|
|
|
size[1] = |
|
|
|
|
size[2] = |
|
|
|
|
size[3] = |
|
|
|
|
size[4] = 1 << 24; |
|
|
|
|
do { |
|
|
|
|
b = blks; |
|
|
|
|
for (i = 0; i < 5; i++) { |
|
|
|
|
@ -357,8 +375,8 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) |
|
|
|
|
b->prev[a2] = prev; |
|
|
|
|
assert(a2 < 4); |
|
|
|
|
assert(b->mb[b->next[k]]); |
|
|
|
|
b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) |
|
|
|
|
-dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); |
|
|
|
|
b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) - |
|
|
|
|
dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); |
|
|
|
|
assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k)); |
|
|
|
|
b->prev[a2] = prev; |
|
|
|
|
} |
|
|
|
|
@ -375,7 +393,6 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) |
|
|
|
|
} |
|
|
|
|
} while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) { |
|
|
|
|
b = blks; |
|
|
|
|
size[0] = 5 * 6 * 4; // EOB
|
|
|
|
|
@ -423,7 +440,8 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
} else { |
|
|
|
|
y_stride = 16; |
|
|
|
|
} |
|
|
|
|
y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3); |
|
|
|
|
y_ptr = s->frame->data[0] + |
|
|
|
|
((mb_y * s->frame->linesize[0] + mb_x) << 3); |
|
|
|
|
linesize = s->frame->linesize[0]; |
|
|
|
|
|
|
|
|
|
if (s->sys->video_stype == 4) { /* SD 422 */ |
|
|
|
|
@ -453,8 +471,14 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
uint8_t *b = scratch; |
|
|
|
|
for (i = 0; i < 8; i++) { |
|
|
|
|
d = c_ptr + (linesize << 3); |
|
|
|
|
b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3]; |
|
|
|
|
b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; |
|
|
|
|
b[0] = c_ptr[0]; |
|
|
|
|
b[1] = c_ptr[1]; |
|
|
|
|
b[2] = c_ptr[2]; |
|
|
|
|
b[3] = c_ptr[3]; |
|
|
|
|
b[4] = d[0]; |
|
|
|
|
b[5] = d[1]; |
|
|
|
|
b[6] = d[2]; |
|
|
|
|
b[7] = d[3]; |
|
|
|
|
c_ptr += linesize; |
|
|
|
|
b += 16; |
|
|
|
|
} |
|
|
|
|
@ -463,9 +487,9 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1); |
|
|
|
|
if (s->sys->bpm == 8) { |
|
|
|
|
vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1); |
|
|
|
|
} |
|
|
|
|
if (s->sys->bpm == 8) |
|
|
|
|
vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, |
|
|
|
|
linesize, s, 1); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -494,10 +518,10 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
|
|
|
|
|
/* Second pass over each MB space */ |
|
|
|
|
pb = &pbs[start_mb]; |
|
|
|
|
for (i=0; i<s->sys->bpm; i++) { |
|
|
|
|
for (i = 0; i < s->sys->bpm; i++) |
|
|
|
|
if (enc_blks[start_mb + i].partial_bit_count) |
|
|
|
|
pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]); |
|
|
|
|
} |
|
|
|
|
pb = dv_encode_ac(&enc_blks[start_mb + i], pb, |
|
|
|
|
&pbs[start_mb + s->sys->bpm]); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* Third and final pass over the whole video segment space */ |
|
|
|
|
@ -515,7 +539,8 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
flush_put_bits(&pbs[j]); |
|
|
|
|
pos = put_bits_count(&pbs[j]) >> 3; |
|
|
|
|
if (pos > size) { |
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n"); |
|
|
|
|
av_log(avctx, AV_LOG_ERROR, |
|
|
|
|
"bitstream written beyond buffer size\n"); |
|
|
|
|
return -1; |
|
|
|
|
} |
|
|
|
|
memset(pbs[j].buf + pos, 0xff, size - pos); |
|
|
|
|
@ -548,7 +573,8 @@ static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, |
|
|
|
|
int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1); |
|
|
|
|
|
|
|
|
|
uint8_t aspect = 0; |
|
|
|
|
if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */ |
|
|
|
|
if ((int) (av_q2d(c->avctx->sample_aspect_ratio) * |
|
|
|
|
c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */ |
|
|
|
|
aspect = 0x02; |
|
|
|
|
|
|
|
|
|
buf[0] = (uint8_t) pack_id; |
|
|
|
|
@ -591,7 +617,10 @@ static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, |
|
|
|
|
buf[4] = 0xff; /* reserved -- always 1 */ |
|
|
|
|
break; |
|
|
|
|
default: |
|
|
|
|
buf[1] = buf[2] = buf[3] = buf[4] = 0xff; |
|
|
|
|
buf[1] = |
|
|
|
|
buf[2] = |
|
|
|
|
buf[3] = |
|
|
|
|
buf[4] = 0xff; |
|
|
|
|
} |
|
|
|
|
return 5; |
|
|
|
|
} |
|
|
|
|
@ -608,19 +637,16 @@ static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, |
|
|
|
|
return 3; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf) |
|
|
|
|
{ |
|
|
|
|
if (syb_num == 0 || syb_num == 6) { |
|
|
|
|
buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */ |
|
|
|
|
(0 << 4) | /* AP3 (Subcode application ID) */ |
|
|
|
|
0x0f; /* reserved -- always 1 */ |
|
|
|
|
} |
|
|
|
|
else if (syb_num == 11) { |
|
|
|
|
} else if (syb_num == 11) { |
|
|
|
|
buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */ |
|
|
|
|
0x7f; /* reserved -- always 1 */ |
|
|
|
|
} |
|
|
|
|
else { |
|
|
|
|
} else { |
|
|
|
|
buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */ |
|
|
|
|
(0 << 4) | /* APT (Track application ID) */ |
|
|
|
|
0x0f; /* reserved -- always 1 */ |
|
|
|
|
@ -641,7 +667,8 @@ static void dv_format_frame(DVVideoContext* c, uint8_t* buf) |
|
|
|
|
|
|
|
|
|
/* DV header: 1DIF */ |
|
|
|
|
buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf); |
|
|
|
|
buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf); |
|
|
|
|
buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), |
|
|
|
|
c, buf); |
|
|
|
|
buf += 72; /* unused bytes */ |
|
|
|
|
|
|
|
|
|
/* DV subcode: 2DIFs */ |
|
|
|
|
@ -672,15 +699,14 @@ static void dv_format_frame(DVVideoContext* c, uint8_t* buf) |
|
|
|
|
} |
|
|
|
|
buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf); |
|
|
|
|
buf += 77; /* 1 video macroblock: 1 bytes control
|
|
|
|
|
4 * 14 bytes Y 8x8 data |
|
|
|
|
10 bytes Cr 8x8 data |
|
|
|
|
10 bytes Cb 8x8 data */ |
|
|
|
|
* 4 * 14 bytes Y 8x8 data |
|
|
|
|
* 10 bytes Cr 8x8 data |
|
|
|
|
* 10 bytes Cb 8x8 data */ |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt, |
|
|
|
|
const AVFrame *frame, int *got_packet) |
|
|
|
|
{ |
|
|
|
|
@ -728,6 +754,7 @@ AVCodec ff_dvvideo_encoder = { |
|
|
|
|
.close = dvvideo_encode_close, |
|
|
|
|
.capabilities = CODEC_CAP_SLICE_THREADS, |
|
|
|
|
.pix_fmts = (const enum AVPixelFormat[]) { |
|
|
|
|
AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE |
|
|
|
|
AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, |
|
|
|
|
AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE |
|
|
|
|
}, |
|
|
|
|
}; |
|
|
|
|
|
Gabriel Dume
10 years ago
committed by
Diego Biurrun