[FFmpeg-cvslog] aacdec_usac, aacsbr: implement SBR support for USAC
Lynne
git at videolan.org
Sun Jun 23 10:10:30 EEST 2024
ffmpeg | branch: master | Lynne <dev at lynne.ee> | Sun Jun 16 10:52:13 2024 +0200| [0b67c83b2eadf6350587ae7c4a63a8f9bba67cae] | committer: Lynne
aacdec_usac, aacsbr: implement SBR support for USAC
Currently, no eSBR features are supported.
Thankfully, no encoders exist for it yet.
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=0b67c83b2eadf6350587ae7c4a63a8f9bba67cae
---
libavcodec/aac/aacdec_usac.c | 119 +++++++++++++++++++---
libavcodec/aacsbr.h | 11 ++
libavcodec/aacsbr_template.c | 232 ++++++++++++++++++++++++++++++++++++++++---
libavcodec/sbr.h | 32 +++---
4 files changed, 351 insertions(+), 43 deletions(-)
diff --git a/libavcodec/aac/aacdec_usac.c b/libavcodec/aac/aacdec_usac.c
index e5504117d0..132ffee9c2 100644
--- a/libavcodec/aac/aacdec_usac.c
+++ b/libavcodec/aac/aacdec_usac.c
@@ -23,6 +23,8 @@
#include "aacdec_lpd.h"
#include "aacdec_ac.h"
+#include "libavcodec/aacsbr.h"
+
#include "libavcodec/aactab.h"
#include "libavutil/mem.h"
#include "libavcodec/mpeg4audio.h"
@@ -145,7 +147,8 @@ static int decode_loudness_set(AACDecContext *ac, AACUSACConfig *usac,
return 0;
}
-static void decode_usac_sbr_data(AACUsacElemConfig *e, GetBitContext *gb)
+static int decode_usac_sbr_data(AACDecContext *ac,
+ AACUsacElemConfig *e, GetBitContext *gb)
{
uint8_t header_extra1;
uint8_t header_extra2;
@@ -153,6 +156,10 @@ static void decode_usac_sbr_data(AACUsacElemConfig *e, GetBitContext *gb)
e->sbr.harmonic_sbr = get_bits1(gb); /* harmonicSBR */
e->sbr.bs_intertes = get_bits1(gb); /* bs_interTes */
e->sbr.bs_pvc = get_bits1(gb); /* bs_pvc */
+ if (e->sbr.harmonic_sbr || e->sbr.bs_intertes || e->sbr.bs_pvc) {
+ avpriv_report_missing_feature(ac->avctx, "AAC USAC eSBR");
+ return AVERROR_PATCHWELCOME;
+ }
e->sbr.dflt.start_freq = get_bits(gb, 4); /* dflt_start_freq */
e->sbr.dflt.stop_freq = get_bits(gb, 4); /* dflt_stop_freq */
@@ -179,6 +186,8 @@ static void decode_usac_sbr_data(AACUsacElemConfig *e, GetBitContext *gb)
e->sbr.dflt.interpol_freq = get_bits1(gb); /* dflt_interpol_freq */
e->sbr.dflt.smoothing_mode = get_bits1(gb); /* dflt_smoothing_mode */
}
+
+ return 0;
}
static void decode_usac_element_core(AACUsacElemConfig *e,
@@ -190,13 +199,17 @@ static void decode_usac_element_core(AACUsacElemConfig *e,
e->sbr.ratio = sbr_ratio;
}
-static void decode_usac_element_pair(AACUsacElemConfig *e, GetBitContext *gb)
+static int decode_usac_element_pair(AACDecContext *ac,
+ AACUsacElemConfig *e, GetBitContext *gb)
{
e->stereo_config_index = 0;
if (e->sbr.ratio) {
- decode_usac_sbr_data(e, gb);
+ int ret = decode_usac_sbr_data(ac, e, gb);
+ if (ret < 0)
+ return ret;
e->stereo_config_index = get_bits(gb, 2);
}
+
if (e->stereo_config_index) {
e->mps.freq_res = get_bits(gb, 3); /* bsFreqRes */
e->mps.fixed_gain = get_bits(gb, 3); /* bsFixedGainDMX */
@@ -216,6 +229,8 @@ static void decode_usac_element_pair(AACUsacElemConfig *e, GetBitContext *gb)
if (e->mps.temp_shape_config == 2)
e->mps.env_quant_mode = get_bits1(gb); /* bsEnvQuantMode */
}
+
+ return 0;
}
static int decode_usac_extension(AACDecContext *ac, AACUsacElemConfig *e,
@@ -294,6 +309,9 @@ int ff_aac_usac_reset_state(AACDecContext *ac, OutputConfiguration *oc)
AACUsacStereo *us = &che->us;
memset(us, 0, sizeof(*us));
+ if (e->sbr.ratio)
+ ff_aac_sbr_config_usac(ac, che, e);
+
for (int j = 0; j < ch; j++) {
SingleChannelElement *sce = &che->ch[ch];
AACUsacElemData *ue = &sce->ue;
@@ -320,6 +338,7 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
uint8_t freq_idx;
uint8_t channel_config_idx;
int nb_channels = 0;
+ int ratio_mult, ratio_dec;
int samplerate;
int sbr_ratio;
MPEG4AudioConfig *m4ac = &oc->m4ac;
@@ -340,8 +359,6 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
return AVERROR(EINVAL);
}
- m4ac->sample_rate = avctx->sample_rate = samplerate;
-
usac->core_sbr_frame_len_idx = get_bits(gb, 3); /* coreSbrFrameLengthIndex */
m4ac->frame_length_short = usac->core_sbr_frame_len_idx == 0 ||
usac->core_sbr_frame_len_idx == 2;
@@ -354,7 +371,26 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
usac->core_sbr_frame_len_idx == 4 ? 1 :
0;
+ if (sbr_ratio == 2) {
+ ratio_mult = 8;
+ ratio_dec = 3;
+ } else if (sbr_ratio == 3) {
+ ratio_mult = 2;
+ ratio_dec = 1;
+ } else if (sbr_ratio == 4) {
+ ratio_mult = 4;
+ ratio_dec = 1;
+ } else {
+ ratio_mult = 1;
+ ratio_dec = 1;
+ }
+
+ avctx->sample_rate = samplerate;
+ m4ac->ext_sample_rate = samplerate;
+ m4ac->sample_rate = (samplerate * ratio_dec) / ratio_mult;
+
m4ac->sampling_index = ff_aac_sample_rate_idx(m4ac->sample_rate);
+ m4ac->sbr = sbr_ratio > 0;
channel_config_idx = get_bits(gb, 5); /* channelConfigurationIndex */
if (!channel_config_idx) {
@@ -426,8 +462,11 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
case ID_USAC_SCE: /* SCE */
/* UsacCoreConfig */
decode_usac_element_core(e, gb, sbr_ratio);
- if (e->sbr.ratio > 0)
- decode_usac_sbr_data(e, gb);
+ if (e->sbr.ratio > 0) {
+ ret = decode_usac_sbr_data(ac, e, gb);
+ if (ret < 0)
+ return ret;
+ }
layout_map[map_count][0] = TYPE_SCE;
layout_map[map_count][1] = elem_id[0]++;
if (!map_pos_set)
@@ -437,7 +476,9 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
case ID_USAC_CPE: /* UsacChannelPairElementConf */
/* UsacCoreConfig */
decode_usac_element_core(e, gb, sbr_ratio);
- decode_usac_element_pair(e, gb);
+ ret = decode_usac_element_pair(ac, e, gb);
+ if (ret < 0)
+ return ret;
layout_map[map_count][0] = TYPE_CPE;
layout_map[map_count][1] = elem_id[1]++;
if (!map_pos_set)
@@ -1307,13 +1348,14 @@ static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac,
int ret;
int arith_reset_flag;
AACUsacStereo *us = &che->us;
+ int core_nb_channels = nb_channels;
/* Local symbols */
uint8_t global_gain;
us->common_window = 0;
- for (int ch = 0; ch < nb_channels; ch++) {
+ for (int ch = 0; ch < core_nb_channels; ch++) {
SingleChannelElement *sce = &che->ch[ch];
AACUsacElemData *ue = &sce->ue;
@@ -1323,13 +1365,16 @@ static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac,
ue->core_mode = get_bits1(gb);
}
- if (nb_channels == 2) {
+ if (nb_channels > 1 && ec->stereo_config_index == 1)
+ core_nb_channels = 1;
+
+ if (core_nb_channels == 2) {
ret = decode_usac_stereo_info(ac, usac, ec, che, gb, indep_flag);
if (ret)
return ret;
}
- for (int ch = 0; ch < nb_channels; ch++) {
+ for (int ch = 0; ch < core_nb_channels; ch++) {
SingleChannelElement *sce = &che->ch[ch];
IndividualChannelStream *ics = &sce->ics;
AACUsacElemData *ue = &sce->ue;
@@ -1341,7 +1386,7 @@ static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac,
continue;
}
- if ((nb_channels == 1) ||
+ if ((core_nb_channels == 1) ||
(che->ch[0].ue.core_mode != che->ch[1].ue.core_mode))
ue->tns_data_present = get_bits1(gb);
@@ -1424,7 +1469,29 @@ static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac,
}
}
- spectrum_decode(ac, usac, che, nb_channels);
+ if (ec->sbr.ratio) {
+ int sbr_ch = nb_channels;
+ if (nb_channels == 2 &&
+ !(ec->stereo_config_index == 0 || ec->stereo_config_index == 3))
+ sbr_ch = 1;
+
+ ret = ff_aac_sbr_decode_usac_data(ac, che, ec, gb, sbr_ch, indep_flag);
+ if (ret < 0)
+ return ret;
+
+ if (ec->stereo_config_index) {
+ avpriv_report_missing_feature(ac->avctx, "AAC USAC Mps212");
+ return AVERROR_PATCHWELCOME;
+ }
+ }
+
+ spectrum_decode(ac, usac, che, core_nb_channels);
+
+ if (ac->oc[1].m4ac.sbr > 0) {
+ ac->proc.sbr_apply(ac, che, nb_channels == 2 ? TYPE_CPE : TYPE_SCE,
+ che->ch[0].output,
+ che->ch[1].output);
+ }
return 0;
}
@@ -1591,9 +1658,29 @@ int ff_aac_usac_decode_frame(AVCodecContext *avctx, AACDecContext *ac,
int indep_flag, samples = 0;
int audio_found = 0;
int elem_id[3 /* SCE, CPE, LFE */] = { 0, 0, 0 };
-
AVFrame *frame = ac->frame;
+ int ratio_mult, ratio_dec;
+ AACUSACConfig *usac = &ac->oc[1].usac;
+ int sbr_ratio = usac->core_sbr_frame_len_idx == 2 ? 2 :
+ usac->core_sbr_frame_len_idx == 3 ? 3 :
+ usac->core_sbr_frame_len_idx == 4 ? 1 :
+ 0;
+
+ if (sbr_ratio == 2) {
+ ratio_mult = 8;
+ ratio_dec = 3;
+ } else if (sbr_ratio == 3) {
+ ratio_mult = 2;
+ ratio_dec = 1;
+ } else if (sbr_ratio == 4) {
+ ratio_mult = 4;
+ ratio_dec = 1;
+ } else {
+ ratio_mult = 1;
+ ratio_dec = 1;
+ }
+
ff_aac_output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
ac->oc[1].status, 0);
@@ -1660,8 +1747,10 @@ int ff_aac_usac_decode_frame(AVCodecContext *avctx, AACDecContext *ac,
if (audio_found)
samples = ac->oc[1].m4ac.frame_length_short ? 768 : 1024;
+ samples = (samples * ratio_mult) / ratio_dec;
+
if (ac->oc[1].status && audio_found) {
- avctx->sample_rate = ac->oc[1].m4ac.sample_rate;
+ avctx->sample_rate = ac->oc[1].m4ac.ext_sample_rate;
avctx->frame_size = samples;
ac->oc[1].status = OC_LOCKED;
}
diff --git a/libavcodec/aacsbr.h b/libavcodec/aacsbr.h
index d4582d1100..3958b43b91 100644
--- a/libavcodec/aacsbr.h
+++ b/libavcodec/aacsbr.h
@@ -88,6 +88,17 @@ int ff_aac_sbr_decode_extension(AACDecContext *ac, ChannelElement *che,
int ff_aac_sbr_decode_extension_fixed(AACDecContext *ac, ChannelElement *che,
GetBitContext *gb, int crc, int cnt, int id_aac);
+/** Due to channel allocation not being known upon SBR parameter transmission,
+ * supply the parameters separately.
+ * Functionally identical to ff_aac_sbr_decode_extension() */
+int ff_aac_sbr_config_usac(AACDecContext *ac, ChannelElement *che,
+ AACUsacElemConfig *ue);
+
+/** Decode frame SBR data, USAC. */
+int ff_aac_sbr_decode_usac_data(AACDecContext *ac, ChannelElement *che,
+ AACUsacElemConfig *ue, GetBitContext *gb,
+ int sbr_ch, int indep_flag);
+
/** Apply one SBR element to one AAC element. */
void ff_aac_sbr_apply(AACDecContext *ac, ChannelElement *che,
int id_aac, void /* float */ *L, void /* float */ *R);
diff --git a/libavcodec/aacsbr_template.c b/libavcodec/aacsbr_template.c
index 86f4d8c26e..e5bc4d4659 100644
--- a/libavcodec/aacsbr_template.c
+++ b/libavcodec/aacsbr_template.c
@@ -57,6 +57,7 @@ av_cold void AAC_RENAME(ff_aac_sbr_init)(void)
/** Places SBR in pure upsampling mode. */
static void sbr_turnoff(SpectralBandReplication *sbr) {
sbr->start = 0;
+ sbr->usac = 0;
sbr->ready_for_dequant = 0;
// Init defults used in pure upsampling mode
sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
@@ -184,7 +185,8 @@ static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
}
}
-static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
+static unsigned int read_sbr_header(SpectralBandReplication *sbr,
+ GetBitContext *gb, int is_usac)
{
unsigned int cnt = get_bits_count(gb);
uint8_t bs_header_extra_1;
@@ -194,15 +196,20 @@ static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext
sbr->start = 1;
sbr->ready_for_dequant = 0;
+ sbr->usac = is_usac;
// Save last spectrum parameters variables to compare to new ones
memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
- sbr->bs_amp_res_header = get_bits1(gb);
+ if (!is_usac)
+ sbr->bs_amp_res_header = get_bits1(gb);
+
sbr->spectrum_params.bs_start_freq = get_bits(gb, 4);
sbr->spectrum_params.bs_stop_freq = get_bits(gb, 4);
- sbr->spectrum_params.bs_xover_band = get_bits(gb, 3);
- skip_bits(gb, 2); // bs_reserved
+
+ if (!is_usac)
+ sbr->spectrum_params.bs_xover_band = get_bits(gb, 3);
+ skip_bits(gb, 2); // bs_reserved
bs_header_extra_1 = get_bits1(gb);
bs_header_extra_2 = get_bits1(gb);
@@ -645,7 +652,7 @@ static int read_sbr_grid(AACDecContext *ac, SpectralBandReplication *sbr,
switch (bs_frame_class = get_bits(gb, 2)) {
case FIXFIX:
bs_num_env = 1 << get_bits(gb, 2);
- if (bs_num_env > 4) {
+ if (bs_num_env > (sbr->usac ? 8 : 5)) {
av_log(ac->avctx, AV_LOG_ERROR,
"Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
bs_num_env);
@@ -793,10 +800,26 @@ static void copy_sbr_grid(SBRData *dst, const SBRData *src) {
/// Read how the envelope and noise floor data is delta coded
static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb,
- SBRData *ch_data)
+ SBRData *ch_data, int indep_flag)
{
- get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
- get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
+ if (sbr->usac) {
+ if (indep_flag) {
+ ch_data->bs_df_env[0] = 0;
+ get_bits1_vector(gb, &ch_data->bs_df_env[1], ch_data->bs_num_env - 1);
+ } else {
+ get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
+ }
+
+ if (indep_flag) {
+ ch_data->bs_df_noise[0] = 0;
+ get_bits1_vector(gb, &ch_data->bs_df_noise[1], ch_data->bs_num_noise - 1);
+ } else {
+ get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
+ }
+ } else {
+ get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
+ get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
+ }
}
/// Read inverse filtering data
@@ -811,7 +834,7 @@ static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb,
}
static int read_sbr_envelope(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb,
- SBRData *ch_data, int ch)
+ SBRData *ch_data, int ch)
{
int bits;
int i, j, k;
@@ -881,6 +904,13 @@ static int read_sbr_envelope(AACDecContext *ac, SpectralBandReplication *sbr, Ge
}
}
}
+ if (sbr->usac) {
+ if (sbr->inter_tes) {
+ ch_data->temp_shape[i] = get_bits(gb, 1);
+ if (ch_data->temp_shape[i])
+ ch_data->temp_shape_mode[i] = get_bits(gb, 2);
+ }
+ }
}
//assign 0th elements of env_facs_q from last elements
@@ -970,7 +1000,7 @@ static int read_sbr_single_channel_element(AACDecContext *ac,
if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
return -1;
- read_sbr_dtdf(sbr, gb, &sbr->data[0]);
+ read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
read_sbr_invf(sbr, gb, &sbr->data[0]);
if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
return ret;
@@ -996,8 +1026,8 @@ static int read_sbr_channel_pair_element(AACDecContext *ac,
if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
return -1;
copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
- read_sbr_dtdf(sbr, gb, &sbr->data[0]);
- read_sbr_dtdf(sbr, gb, &sbr->data[1]);
+ read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
+ read_sbr_dtdf(sbr, gb, &sbr->data[1], 0);
read_sbr_invf(sbr, gb, &sbr->data[0]);
memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
@@ -1013,8 +1043,8 @@ static int read_sbr_channel_pair_element(AACDecContext *ac,
if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
return -1;
- read_sbr_dtdf(sbr, gb, &sbr->data[0]);
- read_sbr_dtdf(sbr, gb, &sbr->data[1]);
+ read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
+ read_sbr_dtdf(sbr, gb, &sbr->data[1], 0);
read_sbr_invf(sbr, gb, &sbr->data[0]);
read_sbr_invf(sbr, gb, &sbr->data[1]);
if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
@@ -1129,7 +1159,7 @@ int AAC_RENAME(ff_aac_sbr_decode_extension)(AACDecContext *ac, ChannelElement *c
num_sbr_bits++;
if (get_bits1(gb)) // bs_header_flag
- num_sbr_bits += read_sbr_header(sbr, gb);
+ num_sbr_bits += read_sbr_header(sbr, gb, 0);
if (sbr->reset)
sbr_reset(ac, sbr);
@@ -1148,6 +1178,178 @@ int AAC_RENAME(ff_aac_sbr_decode_extension)(AACDecContext *ac, ChannelElement *c
return cnt;
}
+#if !USE_FIXED
+static void copy_usac_default_header(SpectralBandReplication *sbr,
+ AACUsacElemConfig *ue)
+{
+ sbr->inter_tes = ue->sbr.bs_intertes;
+
+ sbr->spectrum_params.bs_start_freq = ue->sbr.dflt.start_freq;
+ sbr->spectrum_params.bs_stop_freq = ue->sbr.dflt.stop_freq;
+
+ sbr->spectrum_params.bs_freq_scale = ue->sbr.dflt.freq_scale;
+ sbr->spectrum_params.bs_alter_scale = ue->sbr.dflt.alter_scale;
+ sbr->spectrum_params.bs_noise_bands = ue->sbr.dflt.noise_bands;
+
+ sbr->bs_limiter_bands = ue->sbr.dflt.limiter_bands;
+ sbr->bs_limiter_gains = ue->sbr.dflt.limiter_gains;
+ sbr->bs_interpol_freq = ue->sbr.dflt.interpol_freq;
+ sbr->bs_smoothing_mode = ue->sbr.dflt.smoothing_mode;
+}
+
+int ff_aac_sbr_config_usac(AACDecContext *ac, ChannelElement *che,
+ AACUsacElemConfig *ue)
+{
+ SpectralBandReplication *sbr = get_sbr(che);
+ sbr_turnoff(sbr);
+ return 0;
+}
+
+int ff_aac_sbr_decode_usac_data(AACDecContext *ac, ChannelElement *che,
+ AACUsacElemConfig *ue, GetBitContext *gb,
+ int sbr_ch, int indep_flag)
+{
+ int ret;
+ SpectralBandReplication *sbr = get_sbr(che);
+ int info_present = 1;
+ int header_present = 1;
+
+ sbr->reset = 0;
+ sbr->usac = 1;
+
+ sbr->sample_rate = ac->oc[1].m4ac.ext_sample_rate;
+ sbr->id_aac = sbr_ch == 2 ? TYPE_CPE : TYPE_SCE;
+
+ if (!indep_flag) {
+ info_present = get_bits1(gb);
+ if (info_present)
+ header_present = get_bits1(gb);
+ else
+ header_present = 0;
+ }
+
+ if (info_present) {
+ /* SbrInfo() */
+ sbr->bs_amp_res_header = get_bits1(gb);
+ sbr->spectrum_params.bs_xover_band = get_bits(gb, 4);
+ sbr->bs_sbr_preprocessing = get_bits1(gb);
+ /* if (bs_pvc) ... */
+ }
+
+ if (header_present) {
+ if (get_bits1(gb)) {
+ int old_bs_limiter_bands = sbr->bs_limiter_bands;
+ SpectrumParameters old_spectrum_params;
+ memcpy(&old_spectrum_params, &sbr->spectrum_params,
+ sizeof(SpectrumParameters));
+
+ copy_usac_default_header(sbr, ue);
+ // Check if spectrum parameters changed
+ if (memcmp(&old_spectrum_params, &sbr->spectrum_params,
+ sizeof(SpectrumParameters)))
+ sbr->reset = 1;
+
+ if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
+ sbr_make_f_tablelim(sbr);
+ } else {
+ read_sbr_header(sbr, gb, 1);
+ }
+
+ sbr->start = 1;
+ }
+
+ //Save some state from the previous frame.
+ sbr->kx[0] = sbr->kx[1];
+ sbr->m[0] = sbr->m[1];
+ sbr->kx_and_m_pushed = 1;
+
+ if (sbr->reset)
+ sbr_reset(ac, sbr);
+
+ sbr->ready_for_dequant = 1;
+
+ int start = get_bits_count(gb);
+
+ if (sbr_ch == 1) { /* sbr_single_channel_element */
+ /* if (harmonicSBR) ... */
+
+ if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
+ return -1;
+
+ read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
+ read_sbr_invf(sbr, gb, &sbr->data[0]);
+
+ if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+ return ret;
+
+ if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+ return ret;
+
+ if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
+ get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
+ } else if (get_bits1(gb)) { /* bs_coupling == 1 */
+ /* if (harmonicSBR) ... */
+
+ if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
+ return -1;
+ copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
+
+ read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
+ read_sbr_dtdf(sbr, gb, &sbr->data[1], indep_flag);
+
+ read_sbr_invf(sbr, gb, &sbr->data[0]);
+ memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0],
+ sizeof(sbr->data[1].bs_invf_mode[0]));
+ memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0],
+ sizeof(sbr->data[1].bs_invf_mode[0]));
+
+ if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+ return ret;
+ if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+ return ret;
+
+ if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
+ return ret;
+ if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
+ return ret;
+
+ if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
+ get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
+ if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
+ get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
+ } else { /* bs_coupling == 0 */
+ /* if (harmonicSBR) ... */
+ if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
+ return -1;
+ if (read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
+ return -1;
+
+ read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
+ read_sbr_dtdf(sbr, gb, &sbr->data[1], indep_flag);
+
+ read_sbr_invf(sbr, gb, &sbr->data[0]);
+ read_sbr_invf(sbr, gb, &sbr->data[1]);
+
+ if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+ return ret;
+ if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
+ return ret;
+
+ if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+ return ret;
+ if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
+ return ret;
+
+ if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
+ get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
+ if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
+ get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
+ }
+
+ return 0;
+}
+#endif
+
/**
* Analysis QMF Bank (14496-3 sp04 p206)
*
diff --git a/libavcodec/sbr.h b/libavcodec/sbr.h
index fe3a39603a..40bb30e04d 100644
--- a/libavcodec/sbr.h
+++ b/libavcodec/sbr.h
@@ -68,9 +68,9 @@ typedef struct SBRData {
unsigned bs_frame_class;
unsigned bs_add_harmonic_flag;
AAC_SIGNE bs_num_env;
- uint8_t bs_freq_res[7];
+ uint8_t bs_freq_res[9];
AAC_SIGNE bs_num_noise;
- uint8_t bs_df_env[5];
+ uint8_t bs_df_env[9];
uint8_t bs_df_noise[2];
uint8_t bs_invf_mode[2][5];
uint8_t bs_add_harmonic[48];
@@ -95,21 +95,24 @@ typedef struct SBRData {
DECLARE_ALIGNED(16, INTFLOAT, Y)[2][38][64][2];
DECLARE_ALIGNED(16, AAC_FLOAT, g_temp)[42][48];
AAC_FLOAT q_temp[42][48];
- uint8_t s_indexmapped[8][48];
+ uint8_t s_indexmapped[9][48];
///Envelope scalefactors
- uint8_t env_facs_q[6][48];
- AAC_FLOAT env_facs[6][48];
+ uint8_t env_facs_q[9][48];
+ AAC_FLOAT env_facs[9][48];
///Noise scalefactors
uint8_t noise_facs_q[3][5];
AAC_FLOAT noise_facs[3][5];
///Envelope time borders
- uint8_t t_env[8];
+ uint8_t t_env[9];
///Envelope time border of the last envelope of the previous frame
uint8_t t_env_num_env_old;
///Noise time borders
uint8_t t_q[3];
unsigned f_indexnoise;
unsigned f_indexsine;
+ //inter_tes (USAC)
+ uint8_t temp_shape[6];
+ uint8_t temp_shape_mode[6];
/** @} */
} SBRData;
@@ -142,9 +145,12 @@ struct SpectralBandReplication {
int start;
int ready_for_dequant;
int id_aac;
+ int usac;
+ int inter_tes; // USAC-only
int reset;
SpectrumParameters spectrum_params;
int bs_amp_res_header;
+ int bs_sbr_preprocessing; // USAC-only
/**
* @name Variables associated with bs_header_extra_2
* @{
@@ -196,18 +202,18 @@ struct SpectralBandReplication {
///First coefficient used to filter the subband signals
DECLARE_ALIGNED(16, INTFLOAT, alpha1)[64][2];
///Dequantized envelope scalefactors, remapped
- AAC_FLOAT e_origmapped[7][48];
+ AAC_FLOAT e_origmapped[8][48];
///Dequantized noise scalefactors, remapped
- AAC_FLOAT q_mapped[7][48];
+ AAC_FLOAT q_mapped[8][48];
///Sinusoidal presence, remapped
- uint8_t s_mapped[7][48];
+ uint8_t s_mapped[8][48];
///Estimated envelope
- AAC_FLOAT e_curr[7][48];
+ AAC_FLOAT e_curr[8][48];
///Amplitude adjusted noise scalefactors
- AAC_FLOAT q_m[7][48];
+ AAC_FLOAT q_m[8][48];
///Sinusoidal levels
- AAC_FLOAT s_m[7][48];
- AAC_FLOAT gain[7][48];
+ AAC_FLOAT s_m[8][48];
+ AAC_FLOAT gain[8][48];
DECLARE_ALIGNED(32, INTFLOAT, qmf_filter_scratch)[5][64];
AVTXContext *mdct_ana;
av_tx_fn mdct_ana_fn;
More information about the ffmpeg-cvslog
mailing list