|
|
@@ -45,6 +45,12 @@
|
|
|
/** Maximum number of exponent groups. +1 for separate DC exponent. */
|
|
|
#define AC3_MAX_EXP_GROUPS 85
|
|
|
|
|
|
+/* stereo rematrixing algorithms */
|
|
|
+#define AC3_REMATRIXING_IS_STATIC 0x1
|
|
|
+#define AC3_REMATRIXING_SUMS 0
|
|
|
+#define AC3_REMATRIXING_NONE 1
|
|
|
+#define AC3_REMATRIXING_ALWAYS 3
|
|
|
+
|
|
|
/** Scale a float value by 2^bits and convert to an integer. */
|
|
|
#define SCALE_FLOAT(a, bits) lrintf((a) * (float)(1 << (bits)))
|
|
|
|
|
|
@@ -71,6 +77,8 @@ typedef struct AC3Block {
|
|
|
uint16_t **qmant; ///< quantized mantissas
|
|
|
uint8_t exp_strategy[AC3_MAX_CHANNELS]; ///< exponent strategies
|
|
|
int8_t exp_shift[AC3_MAX_CHANNELS]; ///< exponent shift values
|
|
|
+ uint8_t new_rematrixing_strategy; ///< send new rematrixing flags in this block
|
|
|
+ uint8_t rematrixing_flags[4]; ///< rematrixing flags
|
|
|
} AC3Block;
|
|
|
|
|
|
/**
|
|
|
@@ -107,6 +115,8 @@ typedef struct AC3EncodeContext {
|
|
|
int bandwidth_code[AC3_MAX_CHANNELS]; ///< bandwidth code (0 to 60) (chbwcod)
|
|
|
int nb_coefs[AC3_MAX_CHANNELS];
|
|
|
|
|
|
+ int rematrixing; ///< determines how rematrixing strategy is calculated
|
|
|
+
|
|
|
/* bitrate allocation control */
|
|
|
int slow_gain_code; ///< slow gain code (sgaincod)
|
|
|
int slow_decay_code; ///< slow decay code (sdcycod)
|
|
|
@@ -261,6 +271,114 @@ static void apply_mdct(AC3EncodeContext *s)
|
|
|
}
|
|
|
|
|
|
|
|
|
+/**
|
|
|
+ * Initialize stereo rematrixing.
|
|
|
+ * If the strategy does not change for each frame, set the rematrixing flags.
|
|
|
+ */
|
|
|
+static void rematrixing_init(AC3EncodeContext *s)
|
|
|
+{
|
|
|
+ if (s->channel_mode == AC3_CHMODE_STEREO)
|
|
|
+ s->rematrixing = AC3_REMATRIXING_SUMS;
|
|
|
+ else
|
|
|
+ s->rematrixing = AC3_REMATRIXING_NONE;
|
|
|
+ /* NOTE: AC3_REMATRIXING_ALWAYS might be used in
|
|
|
+ the future in conjunction with channel coupling. */
|
|
|
+
|
|
|
+ if (s->rematrixing & AC3_REMATRIXING_IS_STATIC) {
|
|
|
+ int flag = (s->rematrixing == AC3_REMATRIXING_ALWAYS);
|
|
|
+ s->blocks[0].new_rematrixing_strategy = 1;
|
|
|
+ memset(s->blocks[0].rematrixing_flags, flag,
|
|
|
+ sizeof(s->blocks[0].rematrixing_flags));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ * Determine rematrixing flags for each block and band.
|
|
|
+ */
|
|
|
+static void compute_rematrixing_strategy(AC3EncodeContext *s)
|
|
|
+{
|
|
|
+ int nb_coefs;
|
|
|
+ int blk, bnd, i;
|
|
|
+ AC3Block *block, *block0;
|
|
|
+
|
|
|
+ if (s->rematrixing & AC3_REMATRIXING_IS_STATIC)
|
|
|
+ return;
|
|
|
+
|
|
|
+ nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);
|
|
|
+
|
|
|
+ s->blocks[0].new_rematrixing_strategy = 1;
|
|
|
+ for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
|
|
|
+ block = &s->blocks[blk];
|
|
|
+ for (bnd = 0; bnd < 4; bnd++) {
|
|
|
+ /* calculate calculate sum of squared coeffs for one band in one block */
|
|
|
+ int start = ff_ac3_rematrix_band_tab[bnd];
|
|
|
+ int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
|
|
|
+ CoefSumType sum[4] = {0,};
|
|
|
+ for (i = start; i < end; i++) {
|
|
|
+ CoefType lt = block->mdct_coef[0][i];
|
|
|
+ CoefType rt = block->mdct_coef[1][i];
|
|
|
+ CoefType md = lt + rt;
|
|
|
+ CoefType sd = lt - rt;
|
|
|
+ sum[0] += lt * lt;
|
|
|
+ sum[1] += rt * rt;
|
|
|
+ sum[2] += md * md;
|
|
|
+ sum[3] += sd * sd;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* compare sums to determine if rematrixing will be used for this band */
|
|
|
+ if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1]))
|
|
|
+ block->rematrixing_flags[bnd] = 1;
|
|
|
+ else
|
|
|
+ block->rematrixing_flags[bnd] = 0;
|
|
|
+
|
|
|
+ /* determine if new rematrixing flags will be sent */
|
|
|
+ if (blk &&
|
|
|
+ !block->new_rematrixing_strategy &&
|
|
|
+ block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) {
|
|
|
+ block->new_rematrixing_strategy = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ block0 = block;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ * Apply stereo rematrixing to coefficients based on rematrixing flags.
|
|
|
+ */
|
|
|
+static void apply_rematrixing(AC3EncodeContext *s)
|
|
|
+{
|
|
|
+ int nb_coefs;
|
|
|
+ int blk, bnd, i;
|
|
|
+ int start, end;
|
|
|
+ uint8_t *flags;
|
|
|
+
|
|
|
+ if (s->rematrixing == AC3_REMATRIXING_NONE)
|
|
|
+ return;
|
|
|
+
|
|
|
+ nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);
|
|
|
+
|
|
|
+ for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
|
|
|
+ AC3Block *block = &s->blocks[blk];
|
|
|
+ if (block->new_rematrixing_strategy)
|
|
|
+ flags = block->rematrixing_flags;
|
|
|
+ for (bnd = 0; bnd < 4; bnd++) {
|
|
|
+ if (flags[bnd]) {
|
|
|
+ start = ff_ac3_rematrix_band_tab[bnd];
|
|
|
+ end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
|
|
|
+ for (i = start; i < end; i++) {
|
|
|
+ int32_t lt = block->fixed_coef[0][i];
|
|
|
+ int32_t rt = block->fixed_coef[1][i];
|
|
|
+ block->fixed_coef[0][i] = (lt + rt) >> 1;
|
|
|
+ block->fixed_coef[1][i] = (lt - rt) >> 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
/**
|
|
|
* Initialize exponent tables.
|
|
|
*/
|
|
|
@@ -592,7 +710,6 @@ static void count_frame_bits_fixed(AC3EncodeContext *s)
|
|
|
/* assumptions:
|
|
|
* no dynamic range codes
|
|
|
* no channel coupling
|
|
|
- * no rematrixing
|
|
|
* bit allocation parameters do not change between blocks
|
|
|
* SNR offsets do not change between blocks
|
|
|
* no delta bit allocation
|
|
|
@@ -609,8 +726,6 @@ static void count_frame_bits_fixed(AC3EncodeContext *s)
|
|
|
frame_bits += s->fbw_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */
|
|
|
if (s->channel_mode == AC3_CHMODE_STEREO) {
|
|
|
frame_bits++; /* rematstr */
|
|
|
- if (!blk)
|
|
|
- frame_bits += 4;
|
|
|
}
|
|
|
frame_bits += 2 * s->fbw_channels; /* chexpstr[2] * c */
|
|
|
if (s->lfe_on)
|
|
|
@@ -681,6 +796,13 @@ static void count_frame_bits(AC3EncodeContext *s)
|
|
|
|
|
|
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
|
|
|
uint8_t *exp_strategy = s->blocks[blk].exp_strategy;
|
|
|
+
|
|
|
+ /* stereo rematrixing */
|
|
|
+ if (s->channel_mode == AC3_CHMODE_STEREO &&
|
|
|
+ s->blocks[blk].new_rematrixing_strategy) {
|
|
|
+ frame_bits += 4;
|
|
|
+ }
|
|
|
+
|
|
|
for (ch = 0; ch < s->fbw_channels; ch++) {
|
|
|
if (exp_strategy[ch] != EXP_REUSE)
|
|
|
frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */
|
|
|
@@ -1194,16 +1316,11 @@ static void output_audio_block(AC3EncodeContext *s, int block_num)
|
|
|
|
|
|
/* stereo rematrixing */
|
|
|
if (s->channel_mode == AC3_CHMODE_STEREO) {
|
|
|
- if (!block_num) {
|
|
|
- /* first block must define rematrixing (rematstr) */
|
|
|
- put_bits(&s->pb, 1, 1);
|
|
|
-
|
|
|
- /* dummy rematrixing rematflg(1:4)=0 */
|
|
|
+ put_bits(&s->pb, 1, block->new_rematrixing_strategy);
|
|
|
+ if (block->new_rematrixing_strategy) {
|
|
|
+ /* rematrixing flags */
|
|
|
for (rbnd = 0; rbnd < 4; rbnd++)
|
|
|
- put_bits(&s->pb, 1, 0);
|
|
|
- } else {
|
|
|
- /* no matrixing (but should be used in the future) */
|
|
|
- put_bits(&s->pb, 1, 0);
|
|
|
+ put_bits(&s->pb, 1, block->rematrixing_flags[rbnd]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -1394,8 +1511,12 @@ static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame,
|
|
|
|
|
|
apply_mdct(s);
|
|
|
|
|
|
+ compute_rematrixing_strategy(s);
|
|
|
+
|
|
|
scale_coefficients(s);
|
|
|
|
|
|
+ apply_rematrixing(s);
|
|
|
+
|
|
|
process_exponents(s);
|
|
|
|
|
|
ret = compute_bit_allocation(s);
|
|
|
@@ -1707,6 +1828,8 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx)
|
|
|
|
|
|
set_bandwidth(s);
|
|
|
|
|
|
+ rematrixing_init(s);
|
|
|
+
|
|
|
exponent_init(s);
|
|
|
|
|
|
bit_alloc_init(s);
|
Justin Ruggles