[FFmpeg-devel] [PATCH 6/6] aacdec_usac, aacsbr: implement SBR support for USAC
Lynne
dev at lynne.ee
Thu Jun 20 05:12:15 EEST 2024
On 16/06/2024 10:54, Lynne wrote:
> Currently, no eSBR features are supported.
> Thankfully, no encoders exist for it yet.
> ---
> 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;
I'll wait 2 more days before merging this patch, but I'll push the other
5 fix/prep patches tomorrow.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: OpenPGP_0xA2FEA5F03F034464.asc
Type: application/pgp-keys
Size: 624 bytes
Desc: OpenPGP public key
URL: <https://ffmpeg.org/pipermail/ffmpeg-devel/attachments/20240620/21a79ba8/attachment.key>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: OpenPGP_signature.asc
Type: application/pgp-signature
Size: 236 bytes
Desc: OpenPGP digital signature
URL: <https://ffmpeg.org/pipermail/ffmpeg-devel/attachments/20240620/21a79ba8/attachment.sig>
More information about the ffmpeg-devel
mailing list