int32_t lfe_peak_cb;
const int8_t *channel_order_tab; ///< channel reordering table, lfe and non lfe
- int32_t history[512][MAX_CHANNELS]; /* This is a circular buffer */
- int32_t subband[SUBBAND_SAMPLES][DCAENC_SUBBANDS][MAX_CHANNELS];
- int32_t quantized[SUBBAND_SAMPLES][DCAENC_SUBBANDS][MAX_CHANNELS];
- int32_t peak_cb[DCAENC_SUBBANDS][MAX_CHANNELS];
+ int32_t history[MAX_CHANNELS][512]; /* This is a circular buffer */
+ int32_t subband[MAX_CHANNELS][DCAENC_SUBBANDS][SUBBAND_SAMPLES];
+ int32_t quantized[MAX_CHANNELS][DCAENC_SUBBANDS][SUBBAND_SAMPLES];
+ int32_t peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS];
int32_t downsampled_lfe[DCA_LFE_SAMPLES];
int32_t masking_curve_cb[SUBSUBFRAMES][256];
- int abits[DCAENC_SUBBANDS][MAX_CHANNELS];
- int scale_factor[DCAENC_SUBBANDS][MAX_CHANNELS];
- softfloat quant[DCAENC_SUBBANDS][MAX_CHANNELS];
+ int32_t bit_allocation_sel[MAX_CHANNELS];
+ int abits[MAX_CHANNELS][DCAENC_SUBBANDS];
+ int scale_factor[MAX_CHANNELS][DCAENC_SUBBANDS];
+ softfloat quant[MAX_CHANNELS][DCAENC_SUBBANDS];
+ int32_t quant_index_sel[MAX_CHANNELS][DCA_CODE_BOOKS];
int32_t eff_masking_curve_cb[256];
int32_t band_masking_cb[32];
int32_t worst_quantization_noise;
{
DCAEncContext *c = avctx->priv_data;
uint64_t layout = avctx->channel_layout;
- int i, min_frame_bits;
+ int i, j, min_frame_bits;
c->fullband_channels = c->channels = avctx->channels;
c->lfe_channel = (avctx->channels == 3 || avctx->channels == 6);
c->channel_order_tab = channel_reorder_nolfe[c->channel_config];
}
+ for (i = 0; i < MAX_CHANNELS; i++) {
+ for (j = 0; j < DCA_CODE_BOOKS; j++) {
+ c->quant_index_sel[i][j] = ff_dca_quant_index_group_size[j];
+ }
+ /* 6 - no Huffman */
+ c->bit_allocation_sel[i] = 6;
+ }
+
for (i = 0; i < 9; i++) {
if (sample_rates[i] == avctx->sample_rate)
break;
int hist_start = 0;
const int chi = c->channel_order_tab[ch];
- for (i = 0; i < 512; i++)
- hist[i] = c->history[i][ch];
+ memcpy(hist, &c->history[ch][0], 512 * sizeof(int32_t));
for (subs = 0; subs < SUBBAND_SAMPLES; subs++) {
int32_t accum[64];
int band;
/* Calculate the convolutions at once */
- for (i = 0; i < 64; i++)
- accum[i] = 0;
+ memset(accum, 0, 64 * sizeof(int32_t));
for (k = 0, i = hist_start, j = 0;
i < 512; k = (k + 1) & 63, i++, j++)
resp += mul32(accum[i], cos_t(s << 3)) >> 3;
}
- c->subband[subs][band][ch] = ((band + 1) & 2) ? -resp : resp;
+ c->subband[ch][band][subs] = ((band + 1) & 2) ? -resp : resp;
}
/* Copy in 32 new samples from input */
for (i = 0; i < 32; i++)
hist[i + hist_start] = input[(subs * 32 + i) * c->channels + chi];
+
hist_start = (hist_start + 32) & 511;
}
}
int32_t accum;
int hist_start = 0;
- for (i = 0; i < 512; i++)
- hist[i] = c->history[i][c->channels - 1];
+ memcpy(hist, &c->history[c->channels - 1][0], 512 * sizeof(int32_t));
for (lfes = 0; lfes < DCA_LFE_SAMPLES; lfes++) {
/* Calculate the convolution */
const int chi = c->channel_order_tab[ch];
for (i = 0, k = 128 + 256 * ssf; k < 512; i++, k++)
- data[i] = c->history[k][ch];
+ data[i] = c->history[ch][k];
for (k -= 512; i < 512; i++, k++)
data[i] = input[k * c->channels + chi];
adjust_jnd(c->samplerate_index, data, c->masking_curve_cb[ssf]);
{
int band, ch;
- for (band = 0; band < 32; band++)
- for (ch = 0; ch < c->fullband_channels; ch++) {
+ for (ch = 0; ch < c->fullband_channels; ch++)
+ for (band = 0; band < 32; band++) {
int sample;
int32_t m = 0;
for (sample = 0; sample < SUBBAND_SAMPLES; sample++) {
- int32_t s = abs(c->subband[sample][band][ch]);
+ int32_t s = abs(c->subband[ch][band][sample]);
if (m < s)
m = s;
}
- c->peak_cb[band][ch] = get_cb(m);
+ c->peak_cb[ch][band] = get_cb(m);
}
if (c->lfe_channel) {
#define USED_NABITS 2
#define USED_26ABITS 4
+static int32_t quantize_value(int32_t value, softfloat quant)
+{
+ int32_t offset = 1 << (quant.e - 1);
+
+ value = mul32(value, quant.m) + offset;
+ value = value >> quant.e;
+ return value;
+}
+
+static int calc_one_scale(int32_t peak_cb, int abits, softfloat *quant)
+{
+ int32_t peak;
+ int our_nscale, try_remove;
+ softfloat our_quant;
+
+ av_assert0(peak_cb <= 0);
+ av_assert0(peak_cb >= -2047);
+
+ our_nscale = 127;
+ peak = cb_to_level[-peak_cb];
+
+ for (try_remove = 64; try_remove > 0; try_remove >>= 1) {
+ if (scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e <= 17)
+ continue;
+ our_quant.m = mul32(scalefactor_inv[our_nscale - try_remove].m, stepsize_inv[abits].m);
+ our_quant.e = scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e - 17;
+ if ((ff_dca_quant_levels[abits] - 1) / 2 < quantize_value(peak, our_quant))
+ continue;
+ our_nscale -= try_remove;
+ }
+
+ if (our_nscale >= 125)
+ our_nscale = 124;
+
+ quant->m = mul32(scalefactor_inv[our_nscale].m, stepsize_inv[abits].m);
+ quant->e = scalefactor_inv[our_nscale].e + stepsize_inv[abits].e - 17;
+ av_assert0((ff_dca_quant_levels[abits] - 1) / 2 >= quantize_value(peak, *quant));
+
+ return our_nscale;
+}
+
+static void quantize_all(DCAEncContext *c)
+{
+ int sample, band, ch;
+
+ for (ch = 0; ch < c->fullband_channels; ch++)
+ for (band = 0; band < 32; band++)
+ for (sample = 0; sample < SUBBAND_SAMPLES; sample++)
+ c->quantized[ch][band][sample] = quantize_value(c->subband[ch][band][sample], c->quant[ch][band]);
+}
+
+static void accumulate_huff_bit_consumption(int abits, int32_t *quantized, uint32_t *result)
+{
+ uint8_t sel, id = abits - 1;
+ for (sel = 0; sel < ff_dca_quant_index_group_size[id]; sel++)
+ result[sel] += ff_dca_vlc_calc_quant_bits(quantized, SUBBAND_SAMPLES, sel, id);
+}
+
+static uint32_t set_best_code(uint32_t vlc_bits[DCA_CODE_BOOKS][7], uint32_t clc_bits[DCA_CODE_BOOKS], int32_t res[DCA_CODE_BOOKS])
+{
+ uint8_t i, sel;
+ uint32_t best_sel_bits[DCA_CODE_BOOKS];
+ int32_t best_sel_id[DCA_CODE_BOOKS];
+ uint32_t t, bits = 0;
+
+ for (i = 0; i < DCA_CODE_BOOKS; i++) {
+
+ av_assert0(!((!!vlc_bits[i][0]) ^ (!!clc_bits[i])));
+ if (vlc_bits[i][0] == 0) {
+ /* do not transmit adjustment index for empty codebooks */
+ res[i] = ff_dca_quant_index_group_size[i];
+ /* and skip it */
+ continue;
+ }
+
+ best_sel_bits[i] = vlc_bits[i][0];
+ best_sel_id[i] = 0;
+ for (sel = 0; sel < ff_dca_quant_index_group_size[i]; sel++) {
+ if (best_sel_bits[i] > vlc_bits[i][sel] && vlc_bits[i][sel]) {
+ best_sel_bits[i] = vlc_bits[i][sel];
+ best_sel_id[i] = sel;
+ }
+ }
+
+ /* 2 bits to transmit scale factor adjustment index */
+ t = best_sel_bits[i] + 2;
+ if (t < clc_bits[i]) {
+ res[i] = best_sel_id[i];
+ bits += t;
+ } else {
+ res[i] = ff_dca_quant_index_group_size[i];
+ bits += clc_bits[i];
+ }
+ }
+ return bits;
+}
+
+static uint32_t set_best_abits_code(int abits[DCAENC_SUBBANDS], int bands, int32_t *res)
+{
+ uint8_t i;
+ uint32_t t;
+ int32_t best_sel = 6;
+ int32_t best_bits = bands * 5;
+
+ /* Check do we have subband which cannot be encoded by Huffman tables */
+ for (i = 0; i < bands; i++) {
+ if (abits[i] > 12) {
+ *res = best_sel;
+ return best_bits;
+ }
+ }
+
+ for (i = 0; i < DCA_BITALLOC_12_COUNT; i++) {
+ t = ff_dca_vlc_calc_alloc_bits(abits, bands, i);
+ if (t < best_bits) {
+ best_bits = t;
+ best_sel = i;
+ }
+ }
+
+ *res = best_sel;
+ return best_bits;
+}
+
static int init_quantization_noise(DCAEncContext *c, int noise)
{
int ch, band, ret = 0;
+ uint32_t huff_bit_count_accum[MAX_CHANNELS][DCA_CODE_BOOKS][7];
+ uint32_t clc_bit_count_accum[MAX_CHANNELS][DCA_CODE_BOOKS];
+ uint32_t bits_counter = 0;
- c->consumed_bits = 132 + 493 * c->fullband_channels;
+ c->consumed_bits = 132 + 333 * c->fullband_channels;
if (c->lfe_channel)
c->consumed_bits += 72;
/* attempt to guess the bit distribution based on the prevoius frame */
for (ch = 0; ch < c->fullband_channels; ch++) {
for (band = 0; band < 32; band++) {
- int snr_cb = c->peak_cb[band][ch] - c->band_masking_cb[band] - noise;
+ int snr_cb = c->peak_cb[ch][band] - c->band_masking_cb[band] - noise;
if (snr_cb >= 1312) {
- c->abits[band][ch] = 26;
+ c->abits[ch][band] = 26;
ret |= USED_26ABITS;
} else if (snr_cb >= 222) {
- c->abits[band][ch] = 8 + mul32(snr_cb - 222, 69000000);
+ c->abits[ch][band] = 8 + mul32(snr_cb - 222, 69000000);
ret |= USED_NABITS;
} else if (snr_cb >= 0) {
- c->abits[band][ch] = 2 + mul32(snr_cb, 106000000);
+ c->abits[ch][band] = 2 + mul32(snr_cb, 106000000);
ret |= USED_NABITS;
} else {
- c->abits[band][ch] = 1;
+ c->abits[ch][band] = 1;
ret |= USED_1ABITS;
}
}
+ c->consumed_bits += set_best_abits_code(c->abits[ch], 32, &c->bit_allocation_sel[ch]);
}
- for (band = 0; band < 32; band++)
- for (ch = 0; ch < c->fullband_channels; ch++) {
- c->consumed_bits += bit_consumption[c->abits[band][ch]];
+ /* Recalc scale_factor each time to get bits consumption in case of Huffman coding.
+ It is suboptimal solution */
+ /* TODO: May be cache scaled values */
+ for (ch = 0; ch < c->fullband_channels; ch++) {
+ for (band = 0; band < 32; band++) {
+ c->scale_factor[ch][band] = calc_one_scale(c->peak_cb[ch][band],
+ c->abits[ch][band],
+ &c->quant[ch][band]);
}
+ }
+ quantize_all(c);
+
+ memset(huff_bit_count_accum, 0, MAX_CHANNELS * DCA_CODE_BOOKS * 7 * sizeof(uint32_t));
+ memset(clc_bit_count_accum, 0, MAX_CHANNELS * DCA_CODE_BOOKS * sizeof(uint32_t));
+ for (ch = 0; ch < c->fullband_channels; ch++) {
+ for (band = 0; band < 32; band++) {
+ if (c->abits[ch][band] && c->abits[ch][band] <= DCA_CODE_BOOKS) {
+ accumulate_huff_bit_consumption(c->abits[ch][band], c->quantized[ch][band], huff_bit_count_accum[ch][c->abits[ch][band] - 1]);
+ clc_bit_count_accum[ch][c->abits[ch][band] - 1] += bit_consumption[c->abits[ch][band]];
+ } else {
+ bits_counter += bit_consumption[c->abits[ch][band]];
+ }
+ }
+ }
+
+ for (ch = 0; ch < c->fullband_channels; ch++) {
+ bits_counter += set_best_code(huff_bit_count_accum[ch], clc_bit_count_accum[ch], c->quant_index_sel[ch]);
+ }
+
+ c->consumed_bits += bits_counter;
return ret;
}
for (ch = 0; ch < c->channels; ch++) {
const int chi = c->channel_order_tab[ch];
- c->history[k][ch] = input[k * c->channels + chi];
+ c->history[ch][k] = input[k * c->channels + chi];
}
}
-static int32_t quantize_value(int32_t value, softfloat quant)
-{
- int32_t offset = 1 << (quant.e - 1);
-
- value = mul32(value, quant.m) + offset;
- value = value >> quant.e;
- return value;
-}
-
-static int calc_one_scale(int32_t peak_cb, int abits, softfloat *quant)
-{
- int32_t peak;
- int our_nscale, try_remove;
- softfloat our_quant;
-
- av_assert0(peak_cb <= 0);
- av_assert0(peak_cb >= -2047);
-
- our_nscale = 127;
- peak = cb_to_level[-peak_cb];
-
- for (try_remove = 64; try_remove > 0; try_remove >>= 1) {
- if (scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e <= 17)
- continue;
- our_quant.m = mul32(scalefactor_inv[our_nscale - try_remove].m, stepsize_inv[abits].m);
- our_quant.e = scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e - 17;
- if ((ff_dca_quant_levels[abits] - 1) / 2 < quantize_value(peak, our_quant))
- continue;
- our_nscale -= try_remove;
- }
-
- if (our_nscale >= 125)
- our_nscale = 124;
-
- quant->m = mul32(scalefactor_inv[our_nscale].m, stepsize_inv[abits].m);
- quant->e = scalefactor_inv[our_nscale].e + stepsize_inv[abits].e - 17;
- av_assert0((ff_dca_quant_levels[abits] - 1) / 2 >= quantize_value(peak, *quant));
-
- return our_nscale;
-}
-
-static void calc_scales(DCAEncContext *c)
+static void calc_lfe_scales(DCAEncContext *c)
{
- int band, ch;
-
- for (band = 0; band < 32; band++)
- for (ch = 0; ch < c->fullband_channels; ch++)
- c->scale_factor[band][ch] = calc_one_scale(c->peak_cb[band][ch],
- c->abits[band][ch],
- &c->quant[band][ch]);
-
if (c->lfe_channel)
c->lfe_scale_factor = calc_one_scale(c->lfe_peak_cb, 11, &c->lfe_quant);
}
-static void quantize_all(DCAEncContext *c)
-{
- int sample, band, ch;
-
- for (sample = 0; sample < SUBBAND_SAMPLES; sample++)
- for (band = 0; band < 32; band++)
- for (ch = 0; ch < c->fullband_channels; ch++)
- c->quantized[sample][band][ch] = quantize_value(c->subband[sample][band][ch], c->quant[band][ch]);
-}
-
static void put_frame_header(DCAEncContext *c)
{
/* SYNC */
static void put_primary_audio_header(DCAEncContext *c)
{
- static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
- static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
-
int ch, i;
/* Number of subframes */
put_bits(&c->pb, 4, SUBFRAMES - 1);
/* Bit allocation quantizer select: linear 5-bit */
for (ch = 0; ch < c->fullband_channels; ch++)
- put_bits(&c->pb, 3, 6);
+ put_bits(&c->pb, 3, c->bit_allocation_sel[ch]);
+
+ /* Quantization index codebook select */
+ for (i = 0; i < DCA_CODE_BOOKS; i++)
+ for (ch = 0; ch < c->fullband_channels; ch++)
+ put_bits(&c->pb, ff_dca_quant_index_sel_nbits[i], c->quant_index_sel[ch][i]);
- /* Quantization index codebook select: dummy data
- to avoid transmission of scale factor adjustment */
- for (i = 1; i < 11; i++)
+ /* Scale factor adjustment index: transmitted in case of Huffman coding */
+ for (i = 0; i < DCA_CODE_BOOKS; i++)
for (ch = 0; ch < c->fullband_channels; ch++)
- put_bits(&c->pb, bitlen[i], thr[i]);
+ if (c->quant_index_sel[ch][i] < ff_dca_quant_index_group_size[i])
+ put_bits(&c->pb, 2, 0);
- /* Scale factor adjustment index: not transmitted */
/* Audio header CRC check word: not transmitted */
}
static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
{
- if (c->abits[band][ch] <= 7) {
- int sum, i, j;
- for (i = 0; i < 8; i += 4) {
- sum = 0;
- for (j = 3; j >= 0; j--) {
- sum *= ff_dca_quant_levels[c->abits[band][ch]];
- sum += c->quantized[ss * 8 + i + j][band][ch];
- sum += (ff_dca_quant_levels[c->abits[band][ch]] - 1) / 2;
- }
- put_bits(&c->pb, bit_consumption[c->abits[band][ch]] / 4, sum);
+ int i, j, sum, bits, sel;
+ if (c->abits[ch][band] <= DCA_CODE_BOOKS) {
+ av_assert0(c->abits[ch][band] > 0);
+ sel = c->quant_index_sel[ch][c->abits[ch][band] - 1];
+ // Huffman codes
+ if (sel < ff_dca_quant_index_group_size[c->abits[ch][band] - 1]) {
+ ff_dca_vlc_enc_quant(&c->pb, &c->quantized[ch][band][ss * 8], 8, sel, c->abits[ch][band] - 1);
+ return;
}
- } else {
- int i;
- for (i = 0; i < 8; i++) {
- int bits = bit_consumption[c->abits[band][ch]] / 16;
- put_sbits(&c->pb, bits, c->quantized[ss * 8 + i][band][ch]);
+
+ // Block codes
+ if (c->abits[ch][band] <= 7) {
+ for (i = 0; i < 8; i += 4) {
+ sum = 0;
+ for (j = 3; j >= 0; j--) {
+ sum *= ff_dca_quant_levels[c->abits[ch][band]];
+ sum += c->quantized[ch][band][ss * 8 + i + j];
+ sum += (ff_dca_quant_levels[c->abits[ch][band]] - 1) / 2;
+ }
+ put_bits(&c->pb, bit_consumption[c->abits[ch][band]] / 4, sum);
+ }
+ return;
}
}
+
+ for (i = 0; i < 8; i++) {
+ bits = bit_consumption[c->abits[ch][band]] / 16;
+ put_sbits(&c->pb, bits, c->quantized[ch][band][ss * 8 + i]);
+ }
}
static void put_subframe(DCAEncContext *c, int subframe)
/* Prediction VQ address: not transmitted */
/* Bit allocation index */
- for (ch = 0; ch < c->fullband_channels; ch++)
- for (band = 0; band < DCAENC_SUBBANDS; band++)
- put_bits(&c->pb, 5, c->abits[band][ch]);
+ for (ch = 0; ch < c->fullband_channels; ch++) {
+ if (c->bit_allocation_sel[ch] == 6) {
+ for (band = 0; band < DCAENC_SUBBANDS; band++) {
+ put_bits(&c->pb, 5, c->abits[ch][band]);
+ }
+ } else {
+ ff_dca_vlc_enc_alloc(&c->pb, c->abits[ch], DCAENC_SUBBANDS, c->bit_allocation_sel[ch]);
+ }
+ }
if (SUBSUBFRAMES > 1) {
/* Transition mode: none for each channel and subband */
/* Scale factors */
for (ch = 0; ch < c->fullband_channels; ch++)
for (band = 0; band < DCAENC_SUBBANDS; band++)
- put_bits(&c->pb, 7, c->scale_factor[band][ch]);
+ put_bits(&c->pb, 7, c->scale_factor[ch][band]);
/* Joint subband scale factor codebook select: not transmitted */
/* Scale factors for joint subband coding: not transmitted */
calc_masking(c, samples);
find_peaks(c);
assign_bits(c);
- calc_scales(c);
- quantize_all(c);
+ calc_lfe_scales(c);
shift_history(c, samples);
init_put_bits(&c->pb, avpkt->data, avpkt->size);
projects / ffmpeg / blobdiff