mdct_info *faad_mdct_init(uint16_t N)
{
uint16_t k;
#ifdef FIXED_POINT
uint16_t N_idx;
real_t cangle, sangle, c, s, cold;
#endif
real_t scale;
mdct_info *mdct = (mdct_info*)faad_malloc(sizeof(mdct_info));
assert(N % 8 == 0);
mdct->N = N;
mdct->sincos = (complex_t*)faad_malloc(N/4*sizeof(complex_t));
#ifdef FIXED_POINT
N_idx = map_N_to_idx(N);
scale = const_tab[N_idx][0];
cangle = const_tab[N_idx][1];
sangle = const_tab[N_idx][2];
c = const_tab[N_idx][3];
s = const_tab[N_idx][4];
#else
scale = (real_t)sqrt(2.0 / (real_t)N);
#endif
/* (co)sine table build using recurrence relations */
/* this can also be done using static table lookup or */
/* some form of interpolation */
for (k = 0; k < N/4; k++)
{
#ifdef FIXED_POINT
RE(mdct->sincos[k]) = c; //MUL_C_C(c,scale);
IM(mdct->sincos[k]) = s; //MUL_C_C(s,scale);
cold = c;
c = MUL_F(c,cangle) - MUL_F(s,sangle);
s = MUL_F(s,cangle) + MUL_F(cold,sangle);
#else
/* no recurrence, just sines */
RE(mdct->sincos[k]) = scale*(real_t)(cos(2.0*M_PI*(k+1./8.) / (real_t)N));
IM(mdct->sincos[k]) = scale*(real_t)(sin(2.0*M_PI*(k+1./8.) / (real_t)N));
#endif
}
/* initialise fft */
mdct->cfft = cffti(N/4);
#ifdef PROFILE
mdct->cycles = 0;
mdct->fft_cycles = 0;
#endif
return mdct;
}
mdct_info *faad_mdct_init(uint16_t N)
{
mdct_info *mdct = (mdct_info*)faad_malloc(sizeof(mdct_info));
assert(N % 8 == 0);
mdct->N = N;
/* NOTE: For "small framelengths" in FIXED_POINT the coefficients need to be
* scaled by sqrt("(nearest power of 2) > N" / N) */
/* RE(mdct->sincos[k]) = scale*(real_t)(cos(2.0*M_PI*(k+1./8.) / (real_t)N));
* IM(mdct->sincos[k]) = scale*(real_t)(sin(2.0*M_PI*(k+1./8.) / (real_t)N)); */
/* scale is 1 for fixed point, sqrt(N) for floating point */
switch (N)
{
case 2048:
mdct->sincos = (complex_t*)mdct_tab_2048;
break;
case 256:
mdct->sincos = (complex_t*)mdct_tab_256;
break;
#ifdef LD_DEC
case 1024:
mdct->sincos = (complex_t*)mdct_tab_1024;
break;
#endif
#ifdef ALLOW_SMALL_FRAMELENGTH
case 1920:
mdct->sincos = (complex_t*)mdct_tab_1920;
break;
case 240:
mdct->sincos = (complex_t*)mdct_tab_240;
break;
#ifdef LD_DEC
case 960:
mdct->sincos = (complex_t*)mdct_tab_960;
break;
#endif
#endif
#ifdef SSR_DEC
case 512:
mdct->sincos = (complex_t*)mdct_tab_512;
break;
case 64:
mdct->sincos = (complex_t*)mdct_tab_64;
break;
#endif
}
/* initialise fft */
mdct->cfft = cffti(N/4);
#ifdef PROFILE
mdct->cycles = 0;
mdct->fft_cycles = 0;
#endif
return mdct;
}
fb_info *filter_bank_init(uint16_t frame_len)
{
uint16_t nshort = frame_len/8;
#ifdef LD_DEC
uint16_t frame_len_ld = frame_len/2;
#endif
fb_info *fb = (fb_info*)faad_malloc(sizeof(fb_info));
memset(fb, 0, sizeof(fb_info));
/* normal */
fb->mdct256 = faad_mdct_init(2*nshort);
fb->mdct2048 = faad_mdct_init(2*frame_len);
#ifdef LD_DEC
/* LD */
fb->mdct1024 = faad_mdct_init(2*frame_len_ld);
#endif
#ifdef ALLOW_SMALL_FRAMELENGTH
if (frame_len == 1024)
{
#endif
fb->long_window[0] = sine_long_1024;
fb->short_window[0] = sine_short_128;
fb->long_window[1] = kbd_long_1024;
fb->short_window[1] = kbd_short_128;
#ifdef LD_DEC
fb->ld_window[0] = sine_mid_512;
fb->ld_window[1] = ld_mid_512;
#endif
#ifdef ALLOW_SMALL_FRAMELENGTH
} else /* (frame_len == 960) */ {
fb->long_window[0] = sine_long_960;
fb->short_window[0] = sine_short_120;
fb->long_window[1] = kbd_long_960;
fb->short_window[1] = kbd_short_120;
#ifdef LD_DEC
fb->ld_window[0] = sine_mid_480;
fb->ld_window[1] = ld_mid_480;
#endif
}
#endif
#ifdef USE_SSE
if (cpu_has_sse())
{
fb->if_func = ifilter_bank_sse;
} else {
fb->if_func = ifilter_bank;
}
#endif
return fb;
}
sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac,
uint32_t sample_rate
#ifdef DRM
, uint8_t IsDRM
#endif
)
{
sbr_info *sbr = faad_malloc(sizeof(sbr_info));
memset(sbr, 0, sizeof(sbr_info));
/* save id of the parent element */
sbr->id_aac = id_aac;
sbr->sample_rate = sample_rate;
sbr->bs_freq_scale = 2;
sbr->bs_alter_scale = 1;
sbr->bs_noise_bands = 2;
sbr->bs_limiter_bands = 2;
sbr->bs_limiter_gains = 2;
sbr->bs_interpol_freq = 1;
sbr->bs_smoothing_mode = 1;
sbr->bs_start_freq = 5;
sbr->bs_amp_res = 1;
sbr->bs_samplerate_mode = 1;
sbr->prevEnvIsShort[0] = -1;
sbr->prevEnvIsShort[1] = -1;
sbr->header_count = 0;
#ifdef DRM
sbr->Is_DRM_SBR = IsDRM;
#endif
sbr->bs_samplerate_mode = 1;
sbr->tHFGen = T_HFGEN;
sbr->tHFAdj = T_HFADJ;
/* force sbr reset */
sbr->bs_start_freq_prev = -1;
if (framelength == 960)
{
sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
sbr->numTimeSlots = NO_TIME_SLOTS_960;
} else {
sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
sbr->numTimeSlots = NO_TIME_SLOTS;
}
return sbr;
}
drc_info *drc_init(real_t cut, real_t boost)
{
drc_info *drc = (drc_info*)faad_malloc(sizeof(drc_info));
memset(drc, 0, sizeof(drc_info));
drc->ctrl1 = cut;
drc->ctrl2 = boost;
drc->num_bands = 1;
drc->band_top[0] = 1024/4 - 1;
drc->dyn_rng_sgn[0] = 1;
drc->dyn_rng_ctl[0] = 0;
return drc;
}
fb_info *ssr_filter_bank_init(uint16_t frame_len)
{
uint16_t nshort = frame_len/8;
fb_info *fb = (fb_info*)faad_malloc(sizeof(fb_info));
memset(fb, 0, sizeof(fb_info));
/* normal */
fb->mdct256 = faad_mdct_init(2*nshort);
fb->mdct2048 = faad_mdct_init(2*frame_len);
fb->long_window[0] = sine_long_256;
fb->short_window[0] = sine_short_32;
fb->long_window[1] = kbd_long_256;
fb->short_window[1] = kbd_short_32;
return fb;
}
/* initialize buffer, call once before first getbits or showbits */
void faad_initbits(bitfile *ld, const void *_buffer, const uint32_t buffer_size)
{
uint32_t tmp;
if (ld == NULL)
return;
memset(ld, 0, sizeof(bitfile));
if (buffer_size == 0 || _buffer == NULL)
{
ld->error = 1;
ld->no_more_reading = 1;
return;
}
ld->buffer = faad_malloc((buffer_size+12)*sizeof(uint8_t));
memset(ld->buffer, 0, (buffer_size+12)*sizeof(uint8_t));
memcpy(ld->buffer, _buffer, buffer_size*sizeof(uint8_t));
ld->buffer_size = buffer_size;
tmp = getdword((uint32_t*)ld->buffer);
ld->bufa = tmp;
tmp = getdword((uint32_t*)ld->buffer + 1);
ld->bufb = tmp;
ld->start = (uint32_t*)ld->buffer;
ld->tail = ((uint32_t*)ld->buffer + 2);
ld->bits_left = 32;
ld->bytes_used = 0;
ld->no_more_reading = 0;
ld->error = 0;
}
uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits
DEBUGDEC)
{
int i;
unsigned int temp;
int bytes = bits >> 3;
int remainder = bits & 0x7;
uint8_t *buffer = (uint8_t*)faad_malloc((bytes+1)*sizeof(uint8_t));
for (i = 0; i < bytes; i++)
{
buffer[i] = (uint8_t)faad_getbits(ld, 8 DEBUGVAR(print,var,dbg));
}
if (remainder)
{
temp = faad_getbits(ld, remainder DEBUGVAR(print,var,dbg)) << (8-remainder);
buffer[bytes] = (uint8_t)temp;
}
return buffer;
}
uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits
DEBUGDEC)
{
uint16_t i;
uint8_t temp;
uint16_t bytes = (uint16_t)bits / 8;
uint8_t remainder = (uint8_t)bits % 8;
uint8_t *buffer = (uint8_t*)faad_malloc((bytes+1)*sizeof(uint8_t));
for (i = 0; i < bytes; i++)
{
buffer[i] = (uint8_t)faad_getbits(ld, 8 DEBUGVAR(print,var,dbg));
}
if (remainder)
{
temp = (uint8_t)faad_getbits(ld, remainder DEBUGVAR(print,var,dbg)) << (8-remainder);
buffer[bytes] = temp;
}
return buffer;
}
/* NON-overlapping inverse filterbank for use with SSR */
void ssr_ifilter_bank(fb_info *fb, uint8_t window_sequence, uint8_t window_shape,
uint8_t window_shape_prev, real_t *freq_in,
real_t *time_out, uint16_t frame_len)
{
int16_t i;
real_t *transf_buf;
real_t *window_long;
real_t *window_long_prev;
real_t *window_short;
real_t *window_short_prev;
uint16_t nlong = frame_len;
uint16_t nshort = frame_len/8;
uint16_t trans = nshort/2;
uint16_t nflat_ls = (nlong-nshort)/2;
transf_buf = (real_t*)faad_malloc(2*nlong*sizeof(real_t));
window_long = fb->long_window[window_shape];
window_long_prev = fb->long_window[window_shape_prev];
window_short = fb->short_window[window_shape];
window_short_prev = fb->short_window[window_shape_prev];
switch (window_sequence)
{
case ONLY_LONG_SEQUENCE:
imdct_ssr(fb, freq_in, transf_buf, 2*nlong);
for (i = nlong-1; i >= 0; i--)
{
time_out[i] = MUL_R_C(transf_buf[i],window_long_prev[i]);
time_out[nlong+i] = MUL_R_C(transf_buf[nlong+i],window_long[nlong-1-i]);
}
break;
case LONG_START_SEQUENCE:
imdct_ssr(fb, freq_in, transf_buf, 2*nlong);
for (i = 0; i < nlong; i++)
time_out[i] = MUL_R_C(transf_buf[i],window_long_prev[i]);
for (i = 0; i < nflat_ls; i++)
time_out[nlong+i] = transf_buf[nlong+i];
for (i = 0; i < nshort; i++)
time_out[nlong+nflat_ls+i] = MUL_R_C(transf_buf[nlong+nflat_ls+i],window_short[nshort-i-1]);
for (i = 0; i < nflat_ls; i++)
time_out[nlong+nflat_ls+nshort+i] = 0;
break;
case EIGHT_SHORT_SEQUENCE:
imdct_ssr(fb, freq_in+0*nshort, transf_buf+2*nshort*0, 2*nshort);
imdct_ssr(fb, freq_in+1*nshort, transf_buf+2*nshort*1, 2*nshort);
imdct_ssr(fb, freq_in+2*nshort, transf_buf+2*nshort*2, 2*nshort);
imdct_ssr(fb, freq_in+3*nshort, transf_buf+2*nshort*3, 2*nshort);
imdct_ssr(fb, freq_in+4*nshort, transf_buf+2*nshort*4, 2*nshort);
imdct_ssr(fb, freq_in+5*nshort, transf_buf+2*nshort*5, 2*nshort);
imdct_ssr(fb, freq_in+6*nshort, transf_buf+2*nshort*6, 2*nshort);
imdct_ssr(fb, freq_in+7*nshort, transf_buf+2*nshort*7, 2*nshort);
for(i = nshort-1; i >= 0; i--)
{
time_out[i+0*nshort] = MUL_R_C(transf_buf[nshort*0+i],window_short_prev[i]);
time_out[i+1*nshort] = MUL_R_C(transf_buf[nshort*1+i],window_short[i]);
time_out[i+2*nshort] = MUL_R_C(transf_buf[nshort*2+i],window_short_prev[i]);
time_out[i+3*nshort] = MUL_R_C(transf_buf[nshort*3+i],window_short[i]);
time_out[i+4*nshort] = MUL_R_C(transf_buf[nshort*4+i],window_short_prev[i]);
time_out[i+5*nshort] = MUL_R_C(transf_buf[nshort*5+i],window_short[i]);
time_out[i+6*nshort] = MUL_R_C(transf_buf[nshort*6+i],window_short_prev[i]);
time_out[i+7*nshort] = MUL_R_C(transf_buf[nshort*7+i],window_short[i]);
time_out[i+8*nshort] = MUL_R_C(transf_buf[nshort*8+i],window_short_prev[i]);
time_out[i+9*nshort] = MUL_R_C(transf_buf[nshort*9+i],window_short[i]);
time_out[i+10*nshort] = MUL_R_C(transf_buf[nshort*10+i],window_short_prev[i]);
time_out[i+11*nshort] = MUL_R_C(transf_buf[nshort*11+i],window_short[i]);
time_out[i+12*nshort] = MUL_R_C(transf_buf[nshort*12+i],window_short_prev[i]);
time_out[i+13*nshort] = MUL_R_C(transf_buf[nshort*13+i],window_short[i]);
time_out[i+14*nshort] = MUL_R_C(transf_buf[nshort*14+i],window_short_prev[i]);
time_out[i+15*nshort] = MUL_R_C(transf_buf[nshort*15+i],window_short[i]);
}
break;
case LONG_STOP_SEQUENCE:
imdct_ssr(fb, freq_in, transf_buf, 2*nlong);
for (i = 0; i < nflat_ls; i++)
time_out[i] = 0;
for (i = 0; i < nshort; i++)
time_out[nflat_ls+i] = MUL_R_C(transf_buf[nflat_ls+i],window_short_prev[i]);
for (i = 0; i < nflat_ls; i++)
time_out[nflat_ls+nshort+i] = transf_buf[nflat_ls+nshort+i];
for (i = 0; i < nlong; i++)
time_out[nlong+i] = MUL_R_C(transf_buf[nlong+i],window_long[nlong-1-i]);
break;
}
faad_free(transf_buf);
}
static uint8_t allocate_channel_pair(NeAACDecHandle hDecoder,
uint8_t channel, uint8_t paired_channel)
{
uint8_t mul = 1;
#ifdef MAIN_DEC
/* MAIN object type prediction */
if (hDecoder->object_type == MAIN)
{
/* allocate the state only when needed */
if (hDecoder->pred_stat[channel] == NULL)
{
hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
}
if (hDecoder->pred_stat[paired_channel] == NULL)
{
hDecoder->pred_stat[paired_channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
reset_all_predictors(hDecoder->pred_stat[paired_channel], hDecoder->frameLength);
}
}
#endif
#ifdef LTP_DEC
if (is_ltp_ot(hDecoder->object_type))
{
/* allocate the state only when needed */
if (hDecoder->lt_pred_stat[channel] == NULL)
{
hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
}
if (hDecoder->lt_pred_stat[paired_channel] == NULL)
{
hDecoder->lt_pred_stat[paired_channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
memset(hDecoder->lt_pred_stat[paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
}
}
#endif
if (hDecoder->time_out[channel] == NULL)
{
mul = 1;
#ifdef SBR_DEC
hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
{
/* SBR requires 2 times as much output data */
mul = 2;
hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
}
#endif
hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
}
if (hDecoder->time_out[paired_channel] == NULL)
{
hDecoder->time_out[paired_channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
memset(hDecoder->time_out[paired_channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
}
if (hDecoder->fb_intermed[channel] == NULL)
{
hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
}
if (hDecoder->fb_intermed[paired_channel] == NULL)
{
hDecoder->fb_intermed[paired_channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
memset(hDecoder->fb_intermed[paired_channel], 0, hDecoder->frameLength*sizeof(real_t));
}
#ifdef SSR_DEC
if (hDecoder->object_type == SSR)
{
if (hDecoder->ssr_overlap[cpe->channel] == NULL)
{
hDecoder->ssr_overlap[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
memset(hDecoder->ssr_overlap[cpe->channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
}
if (hDecoder->ssr_overlap[cpe->paired_channel] == NULL)
{
hDecoder->ssr_overlap[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
memset(hDecoder->ssr_overlap[cpe->paired_channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
}
if (hDecoder->prev_fmd[cpe->channel] == NULL)
{
uint16_t k;
hDecoder->prev_fmd[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
for (k = 0; k < 2*hDecoder->frameLength; k++)
hDecoder->prev_fmd[cpe->channel][k] = REAL_CONST(-1);
}
if (hDecoder->prev_fmd[cpe->paired_channel] == NULL)
{
uint16_t k;
hDecoder->prev_fmd[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
for (k = 0; k < 2*hDecoder->frameLength; k++)
hDecoder->prev_fmd[cpe->paired_channel][k] = REAL_CONST(-1);
}
}
#endif
return 0;
}
static void sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
uint8_t ch, uint8_t dont_process)
{
int16_t i, k, l;
#ifdef SBR_LOW_POWER
ALIGN real_t deg[64];
#endif
if (sbr->frame == 0)
{
uint8_t j;
sbr->qmfa[ch] = qmfa_init(32);
sbr->qmfs[ch] = qmfs_init(64);
for (j = 0; j < 5; j++)
{
sbr->G_temp_prev[ch][j] = faad_malloc(64*sizeof(real_t));
sbr->Q_temp_prev[ch][j] = faad_malloc(64*sizeof(real_t));
}
memset(sbr->Xsbr[ch], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
memset(sbr->Xcodec[ch], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*32 * sizeof(qmf_t));
}
/* subband analysis */
if (dont_process)
sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xcodec[ch], sbr->tHFGen, 32);
else
sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xcodec[ch], sbr->tHFGen, sbr->kx);
if (!dont_process)
{
#if 1
/* insert high frequencies here */
/* hf generation using patching */
hf_generation(sbr, sbr->Xcodec[ch], sbr->Xsbr[ch]
#ifdef SBR_LOW_POWER
,deg
#endif
,ch);
#endif
#ifdef SBR_LOW_POWER
for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++)
{
for (k = 0; k < sbr->kx; k++)
{
QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0;
}
}
#endif
#if 1
/* hf adjustment */
hf_adjustment(sbr, sbr->Xsbr[ch]
#ifdef SBR_LOW_POWER
,deg
#endif
,ch);
#endif
}
if ((sbr->just_seeked != 0) || dont_process)
{
for (l = 0; l < sbr->numTimeSlotsRate; l++)
{
for (k = 0; k < 32; k++)
{
QMF_RE(X[l][k]) = QMF_RE(sbr->Xcodec[ch][l + sbr->tHFAdj][k]);
#ifndef SBR_LOW_POWER
QMF_IM(X[l][k]) = QMF_IM(sbr->Xcodec[ch][l + sbr->tHFAdj][k]);
#endif
}
for (k = 32; k < 64; k++)
{
QMF_RE(X[l][k]) = 0;
#ifndef SBR_LOW_POWER
QMF_IM(X[l][k]) = 0;
#endif
}
}
} else {
for (l = 0; l < sbr->numTimeSlotsRate; l++)
{
uint8_t xover_band;
if (l < sbr->t_E[ch][0])
xover_band = sbr->kx_prev;
else
xover_band = sbr->kx;
for (k = 0; k < xover_band; k++)
{
QMF_RE(X[l][k]) = QMF_RE(sbr->Xcodec[ch][l + sbr->tHFAdj][k]);
#ifndef SBR_LOW_POWER
QMF_IM(X[l][k]) = QMF_IM(sbr->Xcodec[ch][l + sbr->tHFAdj][k]);
#endif
}
for (k = xover_band; k < 64; k++)
{
QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
#ifndef SBR_LOW_POWER
QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
#endif
}
#ifdef SBR_LOW_POWER
QMF_RE(X[l][xover_band - 1]) += QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][xover_band - 1]);
#endif
}
}
for (i = 0; i < sbr->tHFGen; i++)
{
memmove(sbr->Xcodec[ch][i], sbr->Xcodec[ch][i+sbr->numTimeSlotsRate], 32 * sizeof(qmf_t));
memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i+sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
}
}
sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac, uint8_t id_ele,
uint32_t sample_rate, uint8_t downSampledSBR,
uint8_t IsDRM)
{
(void)downSampledSBR;
#ifndef DRM
(void)IsDRM;
#endif
/* Allocate sbr_info. */
#if defined(FAAD_STATIC_ALLOC)
sbr_info *sbr = &s_sbr[id_ele];
#else
(void)id_ele;
sbr_info *sbr = (sbr_info*)faad_malloc(sizeof(sbr_info));
if (sbr == NULL)
{
/* could not allocate memory */
return NULL;
}
#endif
memset(sbr, 0, sizeof(sbr_info));
#ifdef PS_DEC
/* initialize PS variables */
ps_init(&sbr->ps);
#endif
/* Allocate XLR temporary variable. Use static allocation if either
* FAAD_STATIC_ALLOC is set or XLR fits to IRAM. */
#if defined(FAAD_STATIC_ALLOC) || defined(HAVE_FAAD_XLR_IN_IRAM)
p_XLR = &s_XLR;
#else
p_XLR = (XLR_t*)faad_malloc(sizeof(XLR_t));
if (p_XLR == NULL)
{
/* could not allocate memory */
return NULL;
}
#endif
memset(p_XLR, 0, sizeof(XLR_t));
/* save id of the parent element */
sbr->id_aac = id_aac;
sbr->sample_rate = sample_rate;
sbr->bs_freq_scale = 2;
sbr->bs_alter_scale = 1;
sbr->bs_noise_bands = 2;
sbr->bs_limiter_bands = 2;
sbr->bs_limiter_gains = 2;
sbr->bs_interpol_freq = 1;
sbr->bs_smoothing_mode = 1;
sbr->bs_start_freq = 5;
sbr->bs_amp_res = 1;
sbr->bs_samplerate_mode = 1;
sbr->prevEnvIsShort[0] = -1;
sbr->prevEnvIsShort[1] = -1;
sbr->header_count = 0;
sbr->Reset = 1;
#ifdef DRM
sbr->Is_DRM_SBR = IsDRM;
#endif
sbr->tHFGen = T_HFGEN;
sbr->tHFAdj = T_HFADJ;
sbr->bsco = 0;
sbr->bsco_prev = 0;
sbr->M_prev = 0;
sbr->frame_len = framelength;
/* force sbr reset */
sbr->bs_start_freq_prev = -1;
if (framelength == 960)
{
sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
sbr->numTimeSlots = NO_TIME_SLOTS_960;
} else {
sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
sbr->numTimeSlots = NO_TIME_SLOTS;
}
sbr->GQ_ringbuf_index[0] = 0;
sbr->GQ_ringbuf_index[1] = 0;
memset(sbr->qmfa, 0, 2*sizeof(qmfa_info));
memset(sbr->qmfs, 0, 2*sizeof(qmfs_info));
memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
return sbr;
}
sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac,
uint32_t sample_rate, uint8_t downSampledSBR
#ifdef DRM
, uint8_t IsDRM
#endif
)
{
sbr_info *sbr = faad_malloc(sizeof(sbr_info));
memset(sbr, 0, sizeof(sbr_info));
/* save id of the parent element */
sbr->id_aac = id_aac;
sbr->sample_rate = sample_rate;
sbr->bs_freq_scale = 2;
sbr->bs_alter_scale = 1;
sbr->bs_noise_bands = 2;
sbr->bs_limiter_bands = 2;
sbr->bs_limiter_gains = 2;
sbr->bs_interpol_freq = 1;
sbr->bs_smoothing_mode = 1;
sbr->bs_start_freq = 5;
sbr->bs_amp_res = 1;
sbr->bs_samplerate_mode = 1;
sbr->prevEnvIsShort[0] = -1;
sbr->prevEnvIsShort[1] = -1;
sbr->header_count = 0;
sbr->Reset = 1;
#ifdef DRM
sbr->Is_DRM_SBR = IsDRM;
#endif
sbr->tHFGen = T_HFGEN;
sbr->tHFAdj = T_HFADJ;
sbr->bsco = 0;
sbr->bsco_prev = 0;
sbr->M_prev = 0;
sbr->frame_len = framelength;
/* force sbr reset */
sbr->bs_start_freq_prev = -1;
if (framelength == 960)
{
sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
sbr->numTimeSlots = NO_TIME_SLOTS_960;
} else {
sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
sbr->numTimeSlots = NO_TIME_SLOTS;
}
sbr->GQ_ringbuf_index[0] = 0;
sbr->GQ_ringbuf_index[1] = 0;
if (id_aac == ID_CPE)
{
/* stereo */
uint8_t j;
sbr->qmfa[0] = qmfa_init(32);
sbr->qmfa[1] = qmfa_init(32);
sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64);
sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64);
for (j = 0; j < 5; j++)
{
sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
sbr->G_temp_prev[1][j] = faad_malloc(64*sizeof(real_t));
sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
sbr->Q_temp_prev[1][j] = faad_malloc(64*sizeof(real_t));
}
memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
} else {
/* mono */
uint8_t j;
sbr->qmfa[0] = qmfa_init(32);
sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64);
sbr->qmfs[1] = NULL;
for (j = 0; j < 5; j++)
{
sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
}
memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
}
return sbr;
}
