|
|
|
@ -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) |
|
|
|
|
{ |
|
|
|
@ -80,19 +82,19 @@ static av_cold int dvvideo_encode_init(AVCodecContext *avctx) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* bit budget for AC only in 5 MBs */ |
|
|
|
|
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; |
|
|
|
|
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; |
|
|
|
@ -101,9 +103,9 @@ static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vl |
|
|
|
|
size = 16; |
|
|
|
|
} |
|
|
|
|
if (run) { |
|
|
|
|
*vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : |
|
|
|
|
*vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc : |
|
|
|
|
(0x1f80 | (run - 1))) << size; |
|
|
|
|
size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; |
|
|
|
|
size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
@ -116,17 +118,15 @@ 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) { |
|
|
|
|
size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; |
|
|
|
|
} |
|
|
|
|
if (run) |
|
|
|
|
size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13; |
|
|
|
|
} |
|
|
|
|
return size; |
|
|
|
|
} |
|
|
|
|
#else |
|
|
|
|
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) |
|
|
|
|
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc) |
|
|
|
|
{ |
|
|
|
|
*vlc = dv_vlc_map[run][l].vlc | sign; |
|
|
|
|
return dv_vlc_map[run][l].size; |
|
|
|
@ -152,17 +152,18 @@ typedef struct EncBlockInfo { |
|
|
|
|
uint32_t partial_bit_buffer; /* we can't use uint16_t here */ |
|
|
|
|
} EncBlockInfo; |
|
|
|
|
|
|
|
|
|
static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, |
|
|
|
|
PutBitContext* pb_pool, |
|
|
|
|
PutBitContext* pb_end) |
|
|
|
|
static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi, |
|
|
|
|
PutBitContext *pb_pool, |
|
|
|
|
PutBitContext *pb_end) |
|
|
|
|
{ |
|
|
|
|
int prev, bits_left; |
|
|
|
|
PutBitContext* pb = pb_pool; |
|
|
|
|
PutBitContext *pb = pb_pool; |
|
|
|
|
int size = bi->partial_bit_count; |
|
|
|
|
uint32_t vlc = bi->partial_bit_buffer; |
|
|
|
|
|
|
|
|
|
bi->partial_bit_count = bi->partial_bit_buffer = 0; |
|
|
|
|
for (;;){ |
|
|
|
|
bi->partial_bit_count = |
|
|
|
|
bi->partial_bit_buffer = 0; |
|
|
|
|
for (;;) { |
|
|
|
|
/* Find suitable storage space */ |
|
|
|
|
for (; size > (bits_left = put_bits_left(pb)); pb++) { |
|
|
|
|
if (bits_left) { |
|
|
|
@ -186,21 +187,25 @@ static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, |
|
|
|
|
/* Construct the next VLC */ |
|
|
|
|
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); |
|
|
|
|
if (bi->cur_ac < 64) { |
|
|
|
|
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) { |
|
|
|
|
int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) + |
|
|
|
|
s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4); |
|
|
|
|
int is = s->ildct_cmp(NULL, data, NULL, linesize << 1, 4) + |
|
|
|
|
s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4); |
|
|
|
|
return ps > is; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
@ -230,33 +235,38 @@ 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; |
|
|
|
|
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}; |
|
|
|
|
static const int classes[] = { 12, 24, 36, 0xffff }; |
|
|
|
|
#else /* improved Libav method */ |
|
|
|
|
static const int classes[] = {-1, -1, 255, 0xffff}; |
|
|
|
|
static const int classes[] = { -1, -1, 255, 0xffff }; |
|
|
|
|
#endif |
|
|
|
|
int max = classes[0]; |
|
|
|
|
int prev = 0; |
|
|
|
|
|
|
|
|
|
assert((((int)blk) & 15) == 0); |
|
|
|
|
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,9 +275,10 @@ 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. */ |
|
|
|
|
memset(blk, 0, 64*sizeof(*blk)); |
|
|
|
|
/* 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; |
|
|
|
|
} |
|
|
|
|
bi->mb[0] = blk[0]; |
|
|
|
@ -278,26 +289,28 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, i |
|
|
|
|
for (area = 0; area < 4; area++) { |
|
|
|
|
bi->prev[area] = prev; |
|
|
|
|
bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
|
|
|
|
|
for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) { |
|
|
|
|
for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) { |
|
|
|
|
int level = blk[zigzag_scan[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; |
|
|
|
|
bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); |
|
|
|
|
bi->next[prev]= i; |
|
|
|
|
bi->next[prev] = i; |
|
|
|
|
prev = i; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
bi->next[prev]= i; |
|
|
|
|
for (bi->cno = 0; max > classes[bi->cno]; bi->cno++); |
|
|
|
|
bi->next[prev] = i; |
|
|
|
|
for (bi->cno = 0; max > classes[bi->cno]; bi->cno++) |
|
|
|
|
; |
|
|
|
|
|
|
|
|
|
bi->cno += bias; |
|
|
|
|
|
|
|
|
@ -308,29 +321,34 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, i |
|
|
|
|
for (area = 0; area < 4; area++) { |
|
|
|
|
bi->prev[area] = prev; |
|
|
|
|
bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
|
|
|
|
|
for (; i < mb_area_start[area+1]; i = bi->next[i]) { |
|
|
|
|
for (; i < mb_area_start[area + 1]; i = bi->next[i]) { |
|
|
|
|
bi->mb[i] >>= 1; |
|
|
|
|
|
|
|
|
|
if (bi->mb[i]) { |
|
|
|
|
bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); |
|
|
|
|
bi->next[prev]= i; |
|
|
|
|
bi->next[prev] = i; |
|
|
|
|
prev = i; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
bi->next[prev]= 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) |
|
|
|
|
static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos) |
|
|
|
|
{ |
|
|
|
|
int size[5]; |
|
|
|
|
int i, j, k, a, prev, a2; |
|
|
|
|
EncBlockInfo* b; |
|
|
|
|
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++) { |
|
|
|
@ -345,27 +363,27 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) |
|
|
|
|
b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
|
|
|
|
|
b->area_q[a]++; |
|
|
|
|
prev = b->prev[a]; |
|
|
|
|
assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); |
|
|
|
|
for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) { |
|
|
|
|
assert(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]); |
|
|
|
|
for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) { |
|
|
|
|
b->mb[k] >>= 1; |
|
|
|
|
if (b->mb[k]) { |
|
|
|
|
b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); |
|
|
|
|
prev = k; |
|
|
|
|
} else { |
|
|
|
|
if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){ |
|
|
|
|
for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++) |
|
|
|
|
if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) { |
|
|
|
|
for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++) |
|
|
|
|
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]]); |
|
|
|
|
assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != 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; |
|
|
|
|
} |
|
|
|
|
b->next[prev] = b->next[k]; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
b->prev[a+1]= prev; |
|
|
|
|
b->prev[a + 1] = prev; |
|
|
|
|
} |
|
|
|
|
size[i] += b->bit_size[a]; |
|
|
|
|
} |
|
|
|
@ -373,18 +391,17 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) |
|
|
|
|
if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
} while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); |
|
|
|
|
} while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){ |
|
|
|
|
for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) { |
|
|
|
|
b = blks; |
|
|
|
|
size[0] = 5 * 6 * 4; //EOB
|
|
|
|
|
for (j = 0; j < 6 *5; j++, b++) { |
|
|
|
|
size[0] = 5 * 6 * 4; // EOB
|
|
|
|
|
for (j = 0; j < 6 * 5; j++, b++) { |
|
|
|
|
prev = b->prev[0]; |
|
|
|
|
for (k = b->next[prev]; k < 64; k = b->next[k]) { |
|
|
|
|
if (b->mb[k] < a && b->mb[k] > -a){ |
|
|
|
|
if (b->mb[k] < a && b->mb[k] > -a) { |
|
|
|
|
b->next[prev] = b->next[k]; |
|
|
|
|
}else{ |
|
|
|
|
} else { |
|
|
|
|
size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); |
|
|
|
|
prev = k; |
|
|
|
|
} |
|
|
|
@ -399,18 +416,18 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
DVwork_chunk *work_chunk = arg; |
|
|
|
|
int mb_index, i, j; |
|
|
|
|
int mb_x, mb_y, c_offset, linesize, y_stride; |
|
|
|
|
uint8_t* y_ptr; |
|
|
|
|
uint8_t* dif; |
|
|
|
|
uint8_t *y_ptr; |
|
|
|
|
uint8_t *dif; |
|
|
|
|
LOCAL_ALIGNED_8(uint8_t, scratch, [128]); |
|
|
|
|
EncBlockInfo enc_blks[5*DV_MAX_BPM]; |
|
|
|
|
PutBitContext pbs[5*DV_MAX_BPM]; |
|
|
|
|
PutBitContext* pb; |
|
|
|
|
EncBlockInfo* enc_blk; |
|
|
|
|
EncBlockInfo enc_blks[5 * DV_MAX_BPM]; |
|
|
|
|
PutBitContext pbs[5 * DV_MAX_BPM]; |
|
|
|
|
PutBitContext *pb; |
|
|
|
|
EncBlockInfo *enc_blk; |
|
|
|
|
int vs_bit_size = 0; |
|
|
|
|
int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */ |
|
|
|
|
int* qnosp = &qnos[0]; |
|
|
|
|
int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */ |
|
|
|
|
int *qnosp = &qnos[0]; |
|
|
|
|
|
|
|
|
|
dif = &s->buf[work_chunk->buf_offset*80]; |
|
|
|
|
dif = &s->buf[work_chunk->buf_offset * 80]; |
|
|
|
|
enc_blk = &enc_blks[0]; |
|
|
|
|
for (mb_index = 0; mb_index < 5; mb_index++) { |
|
|
|
|
dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); |
|
|
|
@ -423,21 +440,22 @@ 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 */ |
|
|
|
|
vs_bit_size += |
|
|
|
|
dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0); |
|
|
|
|
dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0); |
|
|
|
|
} else { |
|
|
|
|
vs_bit_size += |
|
|
|
|
dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0); |
|
|
|
|
dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) + |
|
|
|
|
dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0); |
|
|
|
|
} |
|
|
|
|
enc_blk += 4; |
|
|
|
|
|
|
|
|
@ -449,12 +467,18 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
linesize = s->frame->linesize[j]; |
|
|
|
|
y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3); |
|
|
|
|
if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
|
|
|
|
uint8_t* d; |
|
|
|
|
uint8_t* b = scratch; |
|
|
|
|
uint8_t *d; |
|
|
|
|
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; |
|
|
|
|
} |
|
|
|
@ -462,10 +486,10 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
linesize = 16; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
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); |
|
|
|
|
} |
|
|
|
|
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); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
@ -473,49 +497,50 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
dv_guess_qnos(&enc_blks[0], qnosp); |
|
|
|
|
|
|
|
|
|
/* DIF encoding process */ |
|
|
|
|
for (j=0; j<5*s->sys->bpm;) { |
|
|
|
|
for (j = 0; j < 5 * s->sys->bpm;) { |
|
|
|
|
int start_mb = j; |
|
|
|
|
|
|
|
|
|
dif[3] = *qnosp++; |
|
|
|
|
dif += 4; |
|
|
|
|
|
|
|
|
|
/* First pass over individual cells only */ |
|
|
|
|
for (i=0; i<s->sys->bpm; i++, j++) { |
|
|
|
|
int sz = s->sys->block_sizes[i]>>3; |
|
|
|
|
for (i = 0; i < s->sys->bpm; i++, j++) { |
|
|
|
|
int sz = s->sys->block_sizes[i] >> 3; |
|
|
|
|
|
|
|
|
|
init_put_bits(&pbs[j], dif, sz); |
|
|
|
|
put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2); |
|
|
|
|
put_bits(&pbs[j], 1, enc_blks[j].dct_mode); |
|
|
|
|
put_bits(&pbs[j], 2, enc_blks[j].cno); |
|
|
|
|
|
|
|
|
|
dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); |
|
|
|
|
dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]); |
|
|
|
|
dif += sz; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* Second pass over each MB space */ |
|
|
|
|
pb = &pbs[start_mb]; |
|
|
|
|
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]); |
|
|
|
|
} |
|
|
|
|
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]); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* Third and final pass over the whole video segment space */ |
|
|
|
|
pb = &pbs[0]; |
|
|
|
|
for (j=0; j<5*s->sys->bpm; j++) { |
|
|
|
|
for (j = 0; j < 5 * s->sys->bpm; j++) { |
|
|
|
|
if (enc_blks[j].partial_bit_count) |
|
|
|
|
pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]); |
|
|
|
|
pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]); |
|
|
|
|
if (enc_blks[j].partial_bit_count) |
|
|
|
|
av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n"); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
for (j=0; j<5*s->sys->bpm; j++) { |
|
|
|
|
for (j = 0; j < 5 * s->sys->bpm; j++) { |
|
|
|
|
int pos; |
|
|
|
|
int size = pbs[j].size_in_bits >> 3; |
|
|
|
|
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); |
|
|
|
@ -525,7 +550,7 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, |
|
|
|
|
uint8_t* buf) |
|
|
|
|
uint8_t *buf) |
|
|
|
|
{ |
|
|
|
|
/*
|
|
|
|
|
* Here's what SMPTE314M says about these two: |
|
|
|
@ -548,10 +573,11 @@ 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; |
|
|
|
|
buf[0] = (uint8_t) pack_id; |
|
|
|
|
switch (pack_id) { |
|
|
|
|
case dv_header525: /* I can't imagine why these two weren't defined as real */ |
|
|
|
|
case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */ |
|
|
|
@ -591,16 +617,19 @@ 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; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, |
|
|
|
|
uint8_t seq_num, uint8_t dif_num, |
|
|
|
|
uint8_t* buf) |
|
|
|
|
uint8_t *buf) |
|
|
|
|
{ |
|
|
|
|
buf[0] = (uint8_t)t; /* Section type */ |
|
|
|
|
buf[0] = (uint8_t) t; /* Section type */ |
|
|
|
|
buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */ |
|
|
|
|
(chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */ |
|
|
|
|
7; /* reserved -- always 1 */ |
|
|
|
@ -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) |
|
|
|
|
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 */ |
|
|
|
@ -631,7 +657,7 @@ static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf) |
|
|
|
|
return 3; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void dv_format_frame(DVVideoContext* c, uint8_t* buf) |
|
|
|
|
static void dv_format_frame(DVVideoContext *c, uint8_t *buf) |
|
|
|
|
{ |
|
|
|
|
int chan, i, j, k; |
|
|
|
|
|
|
|
|
@ -641,14 +667,15 @@ 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 */ |
|
|
|
|
for (j = 0; j < 2; j++) { |
|
|
|
|
buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf); |
|
|
|
|
for (k = 0; k < 6; k++) |
|
|
|
|
buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5; |
|
|
|
|
buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5; |
|
|
|
|
buf += 29; /* unused bytes */ |
|
|
|
|
} |
|
|
|
|
|
|
|
|
@ -657,30 +684,29 @@ static void dv_format_frame(DVVideoContext* c, uint8_t* buf) |
|
|
|
|
buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf); |
|
|
|
|
buf += dv_write_pack(dv_video_source, c, buf); |
|
|
|
|
buf += dv_write_pack(dv_video_control, c, buf); |
|
|
|
|
buf += 7*5; |
|
|
|
|
buf += 7 * 5; |
|
|
|
|
buf += dv_write_pack(dv_video_source, c, buf); |
|
|
|
|
buf += dv_write_pack(dv_video_control, c, buf); |
|
|
|
|
buf += 4*5 + 2; /* unused bytes */ |
|
|
|
|
buf += 4 * 5 + 2; /* unused bytes */ |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */ |
|
|
|
|
for (j = 0; j < 135; j++) { |
|
|
|
|
if (j%15 == 0) { |
|
|
|
|
if (j % 15 == 0) { |
|
|
|
|
memset(buf, 0xff, 80); |
|
|
|
|
buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf); |
|
|
|
|
buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf); |
|
|
|
|
buf += 77; /* audio control & shuffled PCM audio */ |
|
|
|
|
} |
|
|
|
|
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 |
|
|
|
|
}, |
|
|
|
|
}; |
|
|
|
|