Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

aacdec_usac, aacsbr: implement SBR support for USAC

Browse Source 
Currently, no eSBR features are supported.
Thankfully, no encoders exist for it yet.
release/7.1
Lynne 7 months ago
parent 0c0e7ec81e
commit 0b67c83b2e
No known key found for this signature in database
GPG Key ID: A2FEA5F03F034464
4 changed files with 351 additions and 43 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 119
      libavcodec/aac/aacdec_usac.c
  2. 11
      libavcodec/aacsbr.h
  3. 232
      libavcodec/aacsbr_template.c
  4. 32
      libavcodec/sbr.h

119
libavcodec/aac/aacdec_usac.c
Unescape View File

@ -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;
}

11
libavcodec/aacsbr.h
Unescape View File

@ -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);

232
libavcodec/aacsbr_template.c
Unescape View File

@ -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)
*

32
libavcodec/sbr.h
Unescape View File

@ -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;

Write Preview
Loading…
Cancel
Save