static int8_t rvlc_huffman_esc(bitfile *ld,
int8_t direction)
{
uint8_t i, j;
uint32_t cw;
rvlc_huff_table *h = book_escape;
i = h->len;
if (direction > 0)
cw = faad_getbits(ld, i DEBUGVAR(1,0,""));
else
cw = faad_getbits_rev(ld, i DEBUGVAR(1,0,""));
while ((cw != h->cw)
&& (i < 21))
{
h++;
j = h->len-i;
i += j;
cw <<= j;
if (direction > 0)
cw |= faad_getbits(ld, j DEBUGVAR(1,0,""));
else
cw |= faad_getbits_rev(ld, j DEBUGVAR(1,0,""));
}
return h->index;
}
static int getescape(faacDecHandle hDecoder, int q)
{
int i, off, neg;
if(q < 0){
if(q != -16)
return q;
neg = 1;
} else{
if(q != +16)
return q;
neg = 0;
}
for(i=4;; i++){
if(faad_get1bit(&hDecoder->ld) == 0)
break;
}
if(i > 16){
off = faad_getbits(&hDecoder->ld, i-16) << 16;
off |= faad_getbits(&hDecoder->ld, 16);
} else
off = faad_getbits(&hDecoder->ld, i);
i = off + (1<<i);
if(neg)
i = -i;
return i;
}
/*
* read the codebook and boundaries
*/
static int huffcb(faacDecHandle hDecoder, byte *sect, int *sectbits,
int tot_sfb, int sfb_per_sbk, byte max_sfb)
{
int nsect, n, base, bits, len;
bits = sectbits[0];
len = (1 << bits) - 1;
nsect = 0;
for(base = 0; base < tot_sfb && nsect < tot_sfb; ) {
*sect++ = (byte)faad_getbits(&hDecoder->ld, LEN_CB);
n = faad_getbits(&hDecoder->ld, bits);
while(n == len && base < tot_sfb) {
base += len;
n = faad_getbits(&hDecoder->ld, bits);
}
base += n;
*sect++ = base;
nsect++;
/* insert a zero section for regions above max_sfb for each group */
if ((sect[-1] % sfb_per_sbk) == max_sfb) {
base += (sfb_per_sbk - max_sfb);
*sect++ = 0;
*sect++ = base;
nsect++;
}
}
if(base != tot_sfb || nsect > tot_sfb)
return 0;
return nsect;
}
void getfill(faacDecHandle hDecoder, byte *data)
{
int cnt;
if ((cnt = faad_getbits(&hDecoder->ld, LEN_F_CNT)) == (1<<LEN_F_CNT)-1)
cnt += faad_getbits(&hDecoder->ld, LEN_F_ESC) - 1;
while (cnt > 0)
cnt -= extension_payload(hDecoder, cnt, data);
}
/*
* program configuration element
*/
static void get_ele_list(faacDecHandle hDecoder, EleList *p, int enable_cpe)
{
int i, j;
for (i=0, j=p->num_ele; i<j; i++) {
if (enable_cpe)
p->ele_is_cpe[i] = faad_getbits(&hDecoder->ld, LEN_ELE_IS_CPE);
else
p->ele_is_cpe[i] = 0; /* sdb */
p->ele_tag[i] = faad_getbits(&hDecoder->ld, LEN_TAG);
}
}
static void get_pulse_nc(faacDecHandle hDecoder, struct Pulse_Info *pulse_info)
{
int i;
pulse_info->number_pulse = faad_getbits(&hDecoder->ld, LEN_NPULSE);
pulse_info->pulse_start_sfb = faad_getbits(&hDecoder->ld, LEN_PULSE_ST_SFB);
for(i = 0; i < pulse_info->number_pulse + 1; i++) {
pulse_info->pulse_offset[i] = faad_getbits(&hDecoder->ld, LEN_POFF);
pulse_info->pulse_amp[i] = faad_getbits(&hDecoder->ld, LEN_PAMP);
}
}
static int8_t rvlc_huffman_sf(bitfile *ld_sf, bitfile *ld_esc,
int8_t direction)
{
uint8_t i, j;
int8_t index;
uint32_t cw;
rvlc_huff_table *h = book_rvlc;
i = h->len;
if (direction > 0)
cw = faad_getbits(ld_sf, i DEBUGVAR(1,0,""));
else
cw = faad_getbits_rev(ld_sf, i DEBUGVAR(1,0,""));
while ((cw != h->cw)
&& (i < 10))
{
h++;
j = h->len-i;
i += j;
cw <<= j;
if (direction > 0)
cw |= faad_getbits(ld_sf, j DEBUGVAR(1,0,""));
else
cw |= faad_getbits_rev(ld_sf, j DEBUGVAR(1,0,""));
}
index = h->index;
if (index == +ESC_VAL)
{
int8_t esc = rvlc_huffman_esc(ld_esc, direction);
if (esc == 99)
return 99;
index += esc;
#ifdef PRINT_RVLC
printf("esc: %d - ", esc);
#endif
}
if (index == -ESC_VAL)
{
int8_t esc = rvlc_huffman_esc(ld_esc, direction);
if (esc == 99)
return 99;
index -= esc;
#ifdef PRINT_RVLC
printf("esc: %d - ", esc);
#endif
}
return index;
}
static int get_tns(faacDecHandle hDecoder, Info *info, TNS_frame_info *tns_frame_info)
{
int f, t, top, res, res2, compress;
int short_flag, s;
int *sp, tmp, s_mask, n_mask;
TNSfilt *tns_filt;
TNSinfo *tns_info;
static int sgn_mask[] = { 0x2, 0x4, 0x8 };
static int neg_mask[] = { 0xfffc, 0xfff8, 0xfff0 };
short_flag = (!info->islong);
tns_frame_info->n_subblocks = info->nsbk;
for (s=0; s<tns_frame_info->n_subblocks; s++) {
tns_info = &tns_frame_info->info[s];
if (!(tns_info->n_filt = faad_getbits(&hDecoder->ld, short_flag ? 1 : 2)))
continue;
tns_info -> coef_res = res = faad_get1bit(&hDecoder->ld) + 3;
top = info->sfb_per_sbk[s];
tns_filt = &tns_info->filt[ 0 ];
for (f=tns_info->n_filt; f>0; f--) {
tns_filt->stop_band = top;
top = tns_filt->start_band = top - faad_getbits(&hDecoder->ld, short_flag ? 4 : 6);
tns_filt->order = faad_getbits(&hDecoder->ld, short_flag ? 3 : 5);
if (tns_filt->order) {
tns_filt->direction = faad_get1bit(&hDecoder->ld);
compress = faad_get1bit(&hDecoder->ld);
res2 = res - compress;
s_mask = sgn_mask[ res2 - 2 ];
n_mask = neg_mask[ res2 - 2 ];
sp = tns_filt->coef;
for (t=tns_filt->order; t>0; t--) {
tmp = (short)faad_getbits(&hDecoder->ld, res2);
*sp++ = (tmp & s_mask) ? (short)(tmp | n_mask) : (short)tmp;
}
}
tns_filt++;
}
} /* subblock loop */
return 1;
}
static INLINE int16_t huffman_getescape(bitfile *ld, int16_t sp)
{
uint8_t neg, i;
int16_t j;
int16_t off;
if (sp < 0)
{
if (sp != -16)
return sp;
neg = 1;
} else {
if (sp != 16)
return sp;
neg = 0;
}
for (i = 4; ; i++)
{
if (faad_get1bit(ld
DEBUGVAR(1,6,"huffman_getescape(): escape size")) == 0)
{
break;
}
}
off = (int16_t)faad_getbits(ld, i
DEBUGVAR(1,9,"huffman_getescape(): escape"));
j = off | (1<<i);
if (neg)
j = -j;
return j;
}
/*
* read a synthesis mask
* uses EXTENDED_MS_MASK
* and grouped mask
*/
static int getmask(faacDecHandle hDecoder, Info *info, byte *group, byte max_sfb, byte *mask)
{
int b, i, mp;
mp = faad_getbits(&hDecoder->ld, LEN_MASK_PRES);
/* special EXTENDED_MS_MASK cases */
if(mp == 0) { /* no ms at all */
return 0;
}
if(mp == 2) {/* MS for whole spectrum on, mask bits set to 1 */
for(b = 0; b < info->nsbk; b = *group++)
for(i = 0; i < info->sfb_per_sbk[b]; i ++)
*mask++ = 1;
return 2;
}
/* otherwise get mask */
for(b = 0; b < info->nsbk; b = *group++){
for(i = 0; i < max_sfb; i ++) {
*mask = (byte)faad_get1bit(&hDecoder->ld);
mask++;
}
for( ; i < info->sfb_per_sbk[b]; i++){
*mask = 0;
mask++;
}
}
return 1;
}
static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
uint8_t bs_extension_id, uint16_t num_bits_left)
{
switch (bs_extension_id)
{
#ifdef PS_DEC
case EXTENSION_ID_PS:
sbr->ps_used = 1;
if (!sbr->ps)
{
sbr->ps = ps_init(get_sr_index(sbr->sample_rate));
}
return ps_data(sbr->ps, ld);
#endif
#ifdef DRM_PS
case DRM_PARAMETRIC_STEREO:
sbr->ps_used = 1;
if (!sbr->drm_ps)
{
sbr->drm_ps = drm_ps_init();
}
return drm_ps_data(sbr->drm_ps, ld);
#endif
default:
sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6
DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
return 6;
}
}
/* table 9 */
static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch)
{
uint8_t n;
for (n = 0; n < sbr->N_Q; n++)
{
sbr->bs_invf_mode[ch][n] = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,271,"invf_mode(): bs_invf_mode"));
}
}
/* table 11 */
void sbr_noise(bitfile *ld, sbr_info *sbr, uint8_t ch)
{
uint8_t noise, band;
int8_t delta = 0;
sbr_huff_tab t_huff, f_huff;
if ((sbr->bs_coupling == 1) && (ch == 1))
{
delta = 1;
t_huff = t_huffman_noise_bal_3_0dB;
f_huff = f_huffman_env_bal_3_0dB;
} else {
delta = 0;
t_huff = t_huffman_noise_3_0dB;
f_huff = f_huffman_env_3_0dB;
}
for (noise = 0; noise < sbr->L_Q[ch]; noise++)
{
if(sbr->bs_df_noise[ch][noise] == 0)
{
if ((sbr->bs_coupling == 1) && (ch == 1))
{
sbr->Q[ch][0][noise] = (faad_getbits(ld, 5
DEBUGVAR(1,276,"sbr_noise(): bs_data_noise")) << delta);
} else {
sbr->Q[ch][0][noise] = (faad_getbits(ld, 5
DEBUGVAR(1,277,"sbr_noise(): bs_data_noise")) << delta);
}
for (band = 1; band < sbr->N_Q; band++)
{
sbr->Q[ch][band][noise] = (sbr_huff_dec(ld, f_huff) << delta);
}
} else {
for (band = 0; band < sbr->N_Q; band++)
{
sbr->Q[ch][band][noise] = (sbr_huff_dec(ld, t_huff) << delta);
}
}
}
extract_noise_floor_data(sbr, ch);
}
int getdata(faacDecHandle hDecoder, int *tag, int *dt_cnt, byte *data_bytes)
{
int i, align_flag, cnt;
*tag = faad_getbits(&hDecoder->ld, LEN_TAG);
align_flag = faad_getbits(&hDecoder->ld, LEN_D_ALIGN);
if ((cnt = faad_getbits(&hDecoder->ld, LEN_D_CNT)) == (1<<LEN_D_CNT)-1)
cnt += faad_getbits(&hDecoder->ld, LEN_D_ESC);
*dt_cnt = cnt;
if (align_flag)
faad_byte_align(&hDecoder->ld);
for (i=0; i<cnt; i++)
data_bytes[i] = faad_getbits(&hDecoder->ld, LEN_BYTE);
return 0;
}
static int extension_payload(faacDecHandle hDecoder, int cnt, byte *data)
{
int type, i;
/* fill bytes should not emulate any EX types below! */
type = faad_getbits(&hDecoder->ld, LEN_EX_TYPE);
switch(type) {
case EX_FILL_DATA:
faad_getbits(&hDecoder->ld, LEN_NIBBLE);
for (i=0; i<cnt-1; i++)
data[i] = faad_getbits(&hDecoder->ld, LEN_BYTE);
return cnt;
default:
faad_getbits(&hDecoder->ld, LEN_NIBBLE);
for (i=0; i<cnt-1; i++)
faad_getbits(&hDecoder->ld, LEN_BYTE);
return cnt;
}
}
uint8_t rvlc_scale_factor_data(ic_stream *ics, bitfile *ld)
{
uint8_t bits = 9;
ics->sf_concealment = faad_get1bit(ld
DEBUGVAR(1,149,"rvlc_scale_factor_data(): sf_concealment"));
ics->rev_global_gain = (uint8_t)faad_getbits(ld, 8
DEBUGVAR(1,150,"rvlc_scale_factor_data(): rev_global_gain"));
if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
bits = 11;
/* the number of bits used for the huffman codewords */
ics->length_of_rvlc_sf = (uint16_t)faad_getbits(ld, bits
DEBUGVAR(1,151,"rvlc_scale_factor_data(): length_of_rvlc_sf"));
if (ics->noise_used)
{
ics->dpcm_noise_nrg = (uint16_t)faad_getbits(ld, 9
DEBUGVAR(1,152,"rvlc_scale_factor_data(): dpcm_noise_nrg"));
ics->length_of_rvlc_sf -= 9;
}
ics->sf_escapes_present = faad_get1bit(ld
DEBUGVAR(1,153,"rvlc_scale_factor_data(): sf_escapes_present"));
if (ics->sf_escapes_present)
{
ics->length_of_rvlc_escapes = (uint8_t)faad_getbits(ld, 8
DEBUGVAR(1,154,"rvlc_scale_factor_data(): length_of_rvlc_escapes"));
}
if (ics->noise_used)
{
ics->dpcm_noise_last_position = (uint16_t)faad_getbits(ld, 9
DEBUGVAR(1,155,"rvlc_scale_factor_data(): dpcm_noise_last_position"));
}
return 0;
}
static INLINE int16_t sbr_huff_dec(bitfile *ld, sbr_huff_tab t_huff)
{
uint8_t bit;
int16_t index = 0;
while (index >= 0)
{
bit = (uint8_t)faad_getbits(ld, 1);
index = t_huff[index][bit];
}
return index + 64;
}
static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
uint8_t bs_extension_id, uint16_t num_bits_left)
{
#ifdef PS_DEC
uint8_t header;
uint16_t ret;
#endif
switch (bs_extension_id)
{
#ifdef PS_DEC
case EXTENSION_ID_PS:
if (!sbr->ps)
{
sbr->ps = ps_init(get_sr_index(sbr->sample_rate));
}
if (sbr->psResetFlag)
{
sbr->ps->header_read = 0;
}
ret = ps_data(sbr->ps, ld, &header);
/* enable PS if and only if: a header has been decoded */
if (sbr->ps_used == 0 && header == 1)
{
sbr->ps_used = 1;
}
if (header == 1)
{
sbr->psResetFlag = 0;
}
return ret;
#endif
#ifdef DRM_PS
case DRM_PARAMETRIC_STEREO:
sbr->ps_used = 1;
if (!sbr->drm_ps)
{
sbr->drm_ps = drm_ps_init();
}
return drm_ps_data(sbr->drm_ps, ld);
#endif
default:
sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6
DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
return 6;
}
}
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;
}
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;
}
/*
* adif_header
*/
int get_adif_header(faacDecHandle hDecoder)
{
int i, n, tag, select_status;
ProgConfig tmp_config;
ADIF_Header *p = &hDecoder->adif_header;
/* adif header */
for (i=0; i<LEN_ADIF_ID; i++)
p->adif_id[i] = (char)faad_getbits(&hDecoder->ld, LEN_BYTE);
p->adif_id[i] = 0; /* null terminated string */
/* copyright string */
if ((p->copy_id_present = faad_getbits(&hDecoder->ld, LEN_COPYRT_PRES)) == 1) {
for (i=0; i<LEN_COPYRT_ID; i++)
p->copy_id[i] = (char)faad_getbits(&hDecoder->ld, LEN_BYTE);
p->copy_id[i] = 0; /* null terminated string */
}
p->original_copy = faad_getbits(&hDecoder->ld, LEN_ORIG);
p->home = faad_getbits(&hDecoder->ld, LEN_HOME);
p->bitstream_type = faad_getbits(&hDecoder->ld, LEN_BS_TYPE);
p->bitrate = faad_getbits(&hDecoder->ld, LEN_BIT_RATE);
/* program config elements */
select_status = -1;
n = faad_getbits(&hDecoder->ld, LEN_NUM_PCE) + 1;
for (i=0; i<n; i++) {
tmp_config.buffer_fullness =
(p->bitstream_type == 0) ? faad_getbits(&hDecoder->ld, LEN_ADIF_BF) : 0;
tag = get_prog_config(hDecoder, &tmp_config);
if (hDecoder->current_program < 0)
hDecoder->current_program = tag; /* default is first prog */
if (hDecoder->current_program == tag) {
CopyMemory(&hDecoder->prog_config, &tmp_config, sizeof(hDecoder->prog_config));
select_status = 1;
}
}
return select_status;
}
/*
* get scale factors
*/
static int hufffac(faacDecHandle hDecoder, Info *info, byte *group, int nsect, byte *sect,
int global_gain, int *factors)
{
Huffscl *hcw;
int i, b, bb, t, n, sfb, top, fac, is_pos;
int factor_transmitted[MAXBANDS], *fac_trans;
int noise_pcm_flag = 1;
int noise_nrg;
/* clear array for the case of max_sfb == 0 */
SetMemory(factor_transmitted, 0, MAXBANDS*sizeof(int));
SetMemory(factors, 0, MAXBANDS*sizeof(int));
sfb = 0;
fac_trans = factor_transmitted;
for(i = 0; i < nsect; i++){
top = sect[1]; /* top of section in sfb */
t = sect[0]; /* codebook for this section */
sect += 2;
for(; sfb < top; sfb++) {
fac_trans[sfb] = t;
}
}
/* scale factors are dpcm relative to global gain
* intensity positions are dpcm relative to zero
*/
fac = global_gain;
is_pos = 0;
noise_nrg = global_gain - NOISE_OFFSET;
/* get scale factors */
hcw = bookscl;
bb = 0;
for(b = 0; b < info->nsbk; ){
n = info->sfb_per_sbk[b];
b = *group++;
for(i = 0; i < n; i++){
switch (fac_trans[i]) {
case ZERO_HCB: /* zero book */
break;
default: /* spectral books */
/* decode scale factor */
t = decode_huff_cw_scl(hDecoder, hcw);
fac += t - MIDFAC; /* 1.5 dB */
if(fac >= 2*TEXP || fac < 0)
return 0;
factors[i] = fac;
break;
case BOOKSCL: /* invalid books */
return 0;
case INTENSITY_HCB: /* intensity books */
case INTENSITY_HCB2:
/* decode intensity position */
t = decode_huff_cw_scl(hDecoder, hcw);
is_pos += t - MIDFAC;
factors[i] = is_pos;
break;
case NOISE_HCB: /* noise books */
/* decode noise energy */
if (noise_pcm_flag) {
noise_pcm_flag = 0;
t = faad_getbits(&hDecoder->ld, NOISE_PCM_BITS) - NOISE_PCM_OFFSET;
} else
t = decode_huff_cw_scl(hDecoder, hcw) - MIDFAC;
noise_nrg += t;
factors[i] = noise_nrg;
break;
}
}
/* expand short block grouping */
if (!(info->islong)) {
for(bb++; bb < b; bb++) {
for (i=0; i<n; i++) {
factors[i+n] = factors[i];
}
factors += n;
}
}
fac_trans += n;
factors += n;
}
return 1;
}
static int getics(faacDecHandle hDecoder, Info *info, int common_window, byte *win, byte *wshape,
byte *group, byte *max_sfb, int *lpflag, int *prstflag,
byte *cb_map, Float *coef, int *global_gain,
int *factors,
NOK_LT_PRED_STATUS *nok_ltp_status,
TNS_frame_info *tns)
{
int nsect, i, cb, top, bot, tot_sfb;
byte sect[ 2*(MAXBANDS+1) ];
memset(sect, 0, sizeof(sect));
/*
* global gain
*/
*global_gain = (short)faad_getbits(&hDecoder->ld, LEN_SCL_PCM);
if (!common_window) {
if (!get_ics_info(hDecoder, win, wshape, group, max_sfb, lpflag, prstflag,
nok_ltp_status, NULL, 0))
return 0;
}
CopyMemory(info, hDecoder->winmap[*win], sizeof(Info));
/* calculate total number of sfb for this grouping */
if (*max_sfb == 0) {
tot_sfb = 0;
}
else {
i=0;
tot_sfb = info->sfb_per_sbk[0];
while (group[i++] < info->nsbk) {
tot_sfb += info->sfb_per_sbk[0];
}
}
/*
* section data
*/
nsect = huffcb(hDecoder, sect, info->sectbits, tot_sfb, info->sfb_per_sbk[0], *max_sfb);
if(nsect==0 && *max_sfb>0)
return 0;
/* generate "linear" description from section info
* stored as codebook for each scalefactor band and group
*/
if (nsect) {
bot = 0;
for (i=0; i<nsect; i++) {
cb = sect[2*i];
top = sect[2*i + 1];
for (; bot<top; bot++)
*cb_map++ = cb;
bot = top;
}
} else {
for (i=0; i<MAXBANDS; i++)
cb_map[i] = 0;
}
/* calculate band offsets
* (because of grouping and interleaving this cannot be
* a constant: store it in info.bk_sfb_top)
*/
calc_gsfb_table(info, group);
/*
* scale factor data
*/
if(!hufffac(hDecoder, info, group, nsect, sect, *global_gain, factors))
return 0;
/*
* Pulse coding
*/
if ((hDecoder->pulse_info.pulse_data_present = faad_get1bit(&hDecoder->ld))) { /* pulse data present */
if (info->islong) {
get_pulse_nc(hDecoder, &hDecoder->pulse_info);
} else {
/* CommonExit(1,"Pulse data not allowed for short blocks"); */
return 0;
}
}
/*
* tns data
*/
if (faad_get1bit(&hDecoder->ld)) { /* tns present */
get_tns(hDecoder, info, tns);
}
else {
clr_tns(info, tns);
}
if (faad_get1bit(&hDecoder->ld)) { /* gain control present */
/* CommonExit(1, "Gain control not implemented"); */
return 0;
}
return huffspec(hDecoder, info, nsect, sect, factors, coef);
}
/* table 5 */
static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr)
{
uint8_t result;
if (faad_get1bit(ld
DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra")))
{
faad_getbits(ld, 4
DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data"));
}
#ifdef DRM
/* bs_coupling, from sbr_channel_pair_base_element(bs_amp_res) */
if (sbr->Is_DRM_SBR)
faad_get1bit(ld);
#endif
if ((result = sbr_grid(ld, sbr, 0)) > 0)
return result;
sbr_dtdf(ld, sbr, 0);
invf_mode(ld, sbr, 0);
sbr_envelope(ld, sbr, 0);
sbr_noise(ld, sbr, 0);
envelope_noise_dequantisation(sbr, 0);
memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]"));
if (sbr->bs_add_harmonic_flag[0])
sinusoidal_coding(ld, sbr, 0);
sbr->bs_extended_data = faad_get1bit(ld
DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]"));
if (sbr->bs_extended_data)
{
uint16_t nr_bits_left;
uint16_t cnt = (uint16_t)faad_getbits(ld, 4
DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size"));
if (cnt == 15)
{
cnt += (uint16_t)faad_getbits(ld, 8
DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count"));
}
nr_bits_left = 8 * cnt;
while (nr_bits_left > 7)
{
sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id"));
nr_bits_left -= 2;
nr_bits_left -= sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
}
/* Corrigendum */
if (nr_bits_left > 0)
{
faad_getbits(ld, nr_bits_left
DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left"));
}
}
return 0;
}
/* table 6 */
static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr)
{
uint8_t n, result;
if (faad_get1bit(ld
DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra")))
{
faad_getbits(ld, 4
DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
faad_getbits(ld, 4
DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
}
sbr->bs_coupling = faad_get1bit(ld
DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling"));
if (sbr->bs_coupling)
{
if ((result = sbr_grid(ld, sbr, 0)) > 0)
return result;
/* need to copy some data from left to right */
sbr->bs_frame_class[1] = sbr->bs_frame_class[0];
sbr->L_E[1] = sbr->L_E[0];
sbr->L_Q[1] = sbr->L_Q[0];
sbr->bs_pointer[1] = sbr->bs_pointer[0];
for (n = 0; n <= sbr->L_E[0]; n++)
{
sbr->t_E[1][n] = sbr->t_E[0][n];
sbr->f[1][n] = sbr->f[0][n];
}
for (n = 0; n <= sbr->L_Q[0]; n++)
sbr->t_Q[1][n] = sbr->t_Q[0][n];
sbr_dtdf(ld, sbr, 0);
sbr_dtdf(ld, sbr, 1);
invf_mode(ld, sbr, 0);
/* more copying */
for (n = 0; n < sbr->N_Q; n++)
sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n];
sbr_envelope(ld, sbr, 0);
sbr_noise(ld, sbr, 0);
sbr_envelope(ld, sbr, 1);
sbr_noise(ld, sbr, 1);
memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
if (sbr->bs_add_harmonic_flag[0])
sinusoidal_coding(ld, sbr, 0);
sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
if (sbr->bs_add_harmonic_flag[1])
sinusoidal_coding(ld, sbr, 1);
} else {
if ((result = sbr_grid(ld, sbr, 0)) > 0)
return result;
if ((result = sbr_grid(ld, sbr, 1)) > 0)
return result;
sbr_dtdf(ld, sbr, 0);
sbr_dtdf(ld, sbr, 1);
invf_mode(ld, sbr, 0);
invf_mode(ld, sbr, 1);
sbr_envelope(ld, sbr, 0);
sbr_envelope(ld, sbr, 1);
sbr_noise(ld, sbr, 0);
sbr_noise(ld, sbr, 1);
memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
if (sbr->bs_add_harmonic_flag[0])
sinusoidal_coding(ld, sbr, 0);
sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
if (sbr->bs_add_harmonic_flag[1])
sinusoidal_coding(ld, sbr, 1);
}
envelope_noise_dequantisation(sbr, 0);
envelope_noise_dequantisation(sbr, 1);
if (sbr->bs_coupling)
unmap_envelope_noise(sbr);
sbr->bs_extended_data = faad_get1bit(ld
DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]"));
if (sbr->bs_extended_data)
{
uint16_t nr_bits_left;
uint16_t cnt = (uint16_t)faad_getbits(ld, 4
DEBUGVAR(1,234,"sbr_channel_pair_element(): bs_extension_size"));
if (cnt == 15)
{
cnt += (uint16_t)faad_getbits(ld, 8
DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count"));
}
nr_bits_left = 8 * cnt;
while (nr_bits_left > 7)
{
sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id"));
nr_bits_left -= 2;
sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
}
/* Corrigendum */
if (nr_bits_left > 0)
{
faad_getbits(ld, nr_bits_left
DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left"));
}
}
return 0;
}
static int get_ics_info(faacDecHandle hDecoder, byte *win, byte *wshape, byte *group, byte *max_sfb,
int *lpflag, int *prstflag, NOK_LT_PRED_STATUS *nok_ltp_status,
NOK_LT_PRED_STATUS *nok_ltp_status_right, int stereo_flag)
{
Info *info;
int i, j;
int max_pred_sfb = pred_max_bands(hDecoder);
faad_get1bit(&hDecoder->ld); /* reserved bit */
*win = (unsigned char)faad_getbits(&hDecoder->ld, LEN_WIN_SEQ);
*wshape = (unsigned char)faad_get1bit(&hDecoder->ld); /* window shape */
if ((info = hDecoder->winmap[*win]) == NULL)
/* CommonExit(1, "bad window code"); */
return 0;
/*
* max scale factor, scale factor grouping and prediction flags
*/
prstflag[0] = 0;
if (info->islong) {
*max_sfb = (unsigned char)faad_getbits(&hDecoder->ld, LEN_MAX_SFBL);
group[0] = 1;
if (hDecoder->mc_info.object_type != AACLTP) {
if ((lpflag[0] = faad_getbits(&hDecoder->ld, LEN_PRED_PRES))) {
if ((prstflag[0] = faad_getbits(&hDecoder->ld, LEN_PRED_RST))) {
for(i=1; i<LEN_PRED_RSTGRP+1; i++)
prstflag[i] = faad_getbits(&hDecoder->ld, LEN_PRED_RST);
}
j = ( (*max_sfb < max_pred_sfb) ?
*max_sfb : max_pred_sfb ) + 1;
for (i = 1; i < j; i++)
lpflag[i] = faad_getbits(&hDecoder->ld, LEN_PRED_ENAB);
for ( ; i < max_pred_sfb+1; i++)
lpflag[i] = 0;
}
} else { /* AAC LTP */
if(faad_get1bit(&hDecoder->ld))
{
nok_lt_decode(hDecoder, *max_sfb, nok_ltp_status->sbk_prediction_used,
nok_ltp_status->sfb_prediction_used,
&nok_ltp_status->weight,
nok_ltp_status->delay);
if(stereo_flag)
nok_lt_decode(hDecoder, *max_sfb, nok_ltp_status_right->sbk_prediction_used,
nok_ltp_status_right->sfb_prediction_used,
&nok_ltp_status_right->weight,
nok_ltp_status_right->delay);
} else {
nok_ltp_status->sbk_prediction_used[0] = 0;
if(stereo_flag)
nok_ltp_status_right->sbk_prediction_used[0] = 0;
}
}
} else {
*max_sfb = (unsigned char)faad_getbits(&hDecoder->ld, LEN_MAX_SFBS);
getgroup(hDecoder, info, group);
lpflag[0] = 0;
nok_ltp_status->sbk_prediction_used[0] = 0;
if(stereo_flag)
nok_ltp_status_right->sbk_prediction_used[0] = 0;
}
return 1;
}
/*
* read and decode the data for the next 1024 output samples
* return -1 if there was an error
*/
int huffdecode(faacDecHandle hDecoder, int id, MC_Info *mip, byte *win,
Wnd_Shape *wshape,
byte **cb_map, int **factors,
byte **group, byte *hasmask, byte **mask, byte *max_sfb,
int **lpflag, int **prstflag,
NOK_LT_PRED_STATUS **nok_ltp_status,
TNS_frame_info **tns, Float **coef)
{
int i, tag, common_window, ch, widx, first=0, last=0;
int global_gain; /* not used in this routine */
Info info;
tag = faad_getbits(&hDecoder->ld, LEN_TAG);
switch(id) {
case ID_SCE:
common_window = 0;
break;
case ID_CPE:
common_window = faad_get1bit(&hDecoder->ld); /* common_window */
break;
default:
/* CommonWarning("Unknown id"); */
return(-1);
}
if ((ch = chn_config(hDecoder, id, tag, common_window, mip)) < 0)
return -1;
switch(id) {
case ID_SCE:
widx = mip->ch_info[ch].widx;
first = ch;
last = ch;
hasmask[widx] = 0;
break;
case ID_CPE:
first = ch;
last = mip->ch_info[ch].paired_ch;
if (common_window) {
widx = mip->ch_info[ch].widx;
if (!get_ics_info(hDecoder, &win[widx], &wshape[widx].this_bk, group[widx],
&max_sfb[widx], lpflag[widx], prstflag[widx],
nok_ltp_status[widx],nok_ltp_status[mip->ch_info[ch].paired_ch], common_window))
return -1;
hasmask[widx] = getmask(hDecoder, hDecoder->winmap[win[widx]], group[widx],
max_sfb[widx], mask[widx]);
}
else {
hasmask[mip->ch_info[first].widx] = 0;
hasmask[mip->ch_info[last].widx] = 0;
}
break;
}
for (i=first; i<=last; i++) {
widx = mip->ch_info[i].widx;
SetMemory(coef[i], 0, LN2*sizeof(Float));
if(!getics(hDecoder, &info, common_window, &win[widx], &wshape[widx].this_bk,
group[widx], &max_sfb[widx], lpflag[widx], prstflag[widx],
cb_map[i], coef[i], &global_gain, factors[i], nok_ltp_status[widx],
tns[i]))
return -1;
}
return 0;
}
/* table 7 */
static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch)
{
uint8_t i, env, rel, result;
uint8_t bs_abs_bord, bs_abs_bord_1;
uint8_t bs_num_env = 0;
sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,248,"sbr_grid(): bs_frame_class"));
switch (sbr->bs_frame_class[ch])
{
case FIXFIX:
i = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw"));
bs_num_env = min(1 << i, 5);
i = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag"));
for (env = 0; env < bs_num_env; env++)
sbr->f[ch][env] = i;
sbr->abs_bord_lead[ch] = 0;
sbr->abs_bord_trail[ch] = sbr->numTimeSlots;
sbr->n_rel_lead[ch] = bs_num_env - 1;
sbr->n_rel_trail[ch] = 0;
break;
case FIXVAR:
bs_abs_bord = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots;
bs_num_env = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1;
for (rel = 0; rel < bs_num_env-1; rel++)
{
sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2;
}
i = sbr_log2(bs_num_env + 1);
sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
DEBUGVAR(1,254,"sbr_grid(): bs_pointer"));
for (env = 0; env < bs_num_env; env++)
{
sbr->f[ch][bs_num_env - env - 1] = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,255,"sbr_grid(): bs_freq_res"));
}
sbr->abs_bord_lead[ch] = 0;
sbr->abs_bord_trail[ch] = bs_abs_bord;
sbr->n_rel_lead[ch] = 0;
sbr->n_rel_trail[ch] = bs_num_env - 1;
break;
case VARFIX:
bs_abs_bord = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord"));
bs_num_env = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1;
for (rel = 0; rel < bs_num_env-1; rel++)
{
sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2;
}
i = sbr_log2(bs_num_env + 1);
sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
DEBUGVAR(1,259,"sbr_grid(): bs_pointer"));
for (env = 0; env < bs_num_env; env++)
{
sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,260,"sbr_grid(): bs_freq_res"));
}
sbr->abs_bord_lead[ch] = bs_abs_bord;
sbr->abs_bord_trail[ch] = sbr->numTimeSlots;
sbr->n_rel_lead[ch] = bs_num_env - 1;
sbr->n_rel_trail[ch] = 0;
break;
case VARVAR:
bs_abs_bord = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0"));
bs_abs_bord_1 = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots;
sbr->bs_num_rel_0[ch] = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0"));
sbr->bs_num_rel_1[ch] = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1"));
bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1);
for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++)
{
sbr->bs_rel_bord_0[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,265,"sbr_grid(): bs_rel_bord")) + 2;
}
for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++)
{
sbr->bs_rel_bord_1[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,266,"sbr_grid(): bs_rel_bord")) + 2;
}
i = sbr_log2(sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 2);
sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
DEBUGVAR(1,267,"sbr_grid(): bs_pointer"));
for (env = 0; env < bs_num_env; env++)
{
sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,268,"sbr_grid(): bs_freq_res"));
}
sbr->abs_bord_lead[ch] = bs_abs_bord;
sbr->abs_bord_trail[ch] = bs_abs_bord_1;
sbr->n_rel_lead[ch] = sbr->bs_num_rel_0[ch];
sbr->n_rel_trail[ch] = sbr->bs_num_rel_1[ch];
break;
}
if (sbr->bs_frame_class[ch] == VARVAR)
sbr->L_E[ch] = min(bs_num_env, 5);
else
sbr->L_E[ch] = min(bs_num_env, 4);
if (sbr->L_E[ch] <= 0)
return 1;
if (sbr->L_E[ch] > 1)
sbr->L_Q[ch] = 2;
else
sbr->L_Q[ch] = 1;
/* TODO: this code can probably be integrated into the code above! */
if ((result = envelope_time_border_vector(sbr, ch)) > 0)
return result;
noise_floor_time_border_vector(sbr, ch);
return 0;
}
uint16_t ps_data(ps_info *ps, bitfile *ld)
{
uint8_t tmp, n;
uint16_t bits = (uint16_t)faad_get_processed_bits(ld);
/* check for new PS header */
if (faad_get1bit(ld
DEBUGVAR(1,1000,"ps_data(): enable_ps_header")))
{
ps->use34hybrid_bands = 0;
/* Inter-channel Intensity Difference (IID) parameters enabled */
ps->enable_iid = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,1001,"ps_data(): enable_iid"));
if (ps->enable_iid)
{
ps->iid_mode = (uint8_t)faad_getbits(ld, 3
DEBUGVAR(1,1002,"ps_data(): iid_mode"));
ps->nr_iid_par = nr_iid_par_tab[ps->iid_mode];
ps->nr_ipdopd_par = nr_ipdopd_par_tab[ps->iid_mode];
if (ps->iid_mode == 2 || ps->iid_mode == 5)
ps->use34hybrid_bands = 1;
/* IPD freq res equal to IID freq res */
ps->ipd_mode = ps->iid_mode;
}
/* Inter-channel Coherence (ICC) parameters enabled */
ps->enable_icc = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,1003,"ps_data(): enable_icc"));
if (ps->enable_icc)
{
ps->icc_mode = (uint8_t)faad_getbits(ld, 3
DEBUGVAR(1,1004,"ps_data(): icc_mode"));
ps->nr_icc_par = nr_icc_par_tab[ps->icc_mode];
if (ps->icc_mode == 2 || ps->icc_mode == 5)
ps->use34hybrid_bands = 1;
}
/* PS extension layer enabled */
ps->enable_ext = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,1005,"ps_data(): enable_ext"));
}
ps->frame_class = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,1006,"ps_data(): frame_class"));
tmp = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,1007,"ps_data(): num_env_idx"));
ps->num_env = num_env_tab[ps->frame_class][tmp];
if (ps->frame_class)
{
for (n = 1; n < ps->num_env+1; n++)
{
ps->border_position[n] = (uint8_t)faad_getbits(ld, 5
DEBUGVAR(1,1008,"ps_data(): border_position"));
}
}
if (ps->enable_iid)
{
for (n = 0; n < ps->num_env; n++)
{
ps->iid_dt[n] = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,1009,"ps_data(): iid_dt"));
/* iid_data */
if (ps->iid_mode < 3)
{
huff_data(ld, ps->iid_dt[n], ps->nr_iid_par, t_huff_iid_def,
f_huff_iid_def, ps->iid_index[n]);
} else {
huff_data(ld, ps->iid_dt[n], ps->nr_iid_par, t_huff_iid_fine,
f_huff_iid_fine, ps->iid_index[n]);
}
}
}
if (ps->enable_icc)
{
for (n = 0; n < ps->num_env; n++)
{
ps->icc_dt[n] = (uint8_t)faad_get1bit(ld
DEBUGVAR(1,1010,"ps_data(): icc_dt"));
/* icc_data */
huff_data(ld, ps->icc_dt[n], ps->nr_icc_par, t_huff_icc,
f_huff_icc, ps->icc_index[n]);
}
}
if (ps->enable_ext)
{
uint16_t num_bits_left;
uint16_t cnt = (uint16_t)faad_getbits(ld, 4
DEBUGVAR(1,1011,"ps_data(): ps_extension_size"));
if (cnt == 15)
{
cnt += (uint16_t)faad_getbits(ld, 8
DEBUGVAR(1,1012,"ps_data(): esc_count"));
}
num_bits_left = 8 * cnt;
while (num_bits_left > 7)
{
uint8_t ps_extension_id = (uint8_t)faad_getbits(ld, 2
DEBUGVAR(1,1013,"ps_data(): ps_extension_size"));
num_bits_left -= 2;
num_bits_left -= ps_extension(ps, ld, ps_extension_id, num_bits_left);
}
faad_getbits(ld, num_bits_left
DEBUGVAR(1,1014,"ps_data(): fill_bits"));
}
bits = (uint16_t)faad_get_processed_bits(ld) - bits;
ps->ps_data_available = 1;
return bits;
}
/* table 10 */
void sbr_envelope(bitfile *ld, sbr_info *sbr, uint8_t ch)
{
uint8_t env, band;
int8_t delta = 0;
sbr_huff_tab t_huff, f_huff;
if ((sbr->L_E[ch] == 1) && (sbr->bs_frame_class[ch] == FIXFIX))
sbr->amp_res[ch] = 0;
else
sbr->amp_res[ch] = sbr->bs_amp_res;
if ((sbr->bs_coupling) && (ch == 1))
{
delta = 1;
if (sbr->amp_res[ch])
{
t_huff = t_huffman_env_bal_3_0dB;
f_huff = f_huffman_env_bal_3_0dB;
} else {
t_huff = t_huffman_env_bal_1_5dB;
f_huff = f_huffman_env_bal_1_5dB;
}
} else {
delta = 0;
if (sbr->amp_res[ch])
{
t_huff = t_huffman_env_3_0dB;
f_huff = f_huffman_env_3_0dB;
} else {
t_huff = t_huffman_env_1_5dB;
f_huff = f_huffman_env_1_5dB;
}
}
for (env = 0; env < sbr->L_E[ch]; env++)
{
if (sbr->bs_df_env[ch][env] == 0)
{
if ((sbr->bs_coupling == 1) && (ch == 1))
{
if (sbr->amp_res[ch])
{
sbr->E[ch][0][env] = (uint16_t)(faad_getbits(ld, 5
DEBUGVAR(1,272,"sbr_envelope(): bs_data_env")) << delta);
} else {
sbr->E[ch][0][env] = (uint16_t)(faad_getbits(ld, 6
DEBUGVAR(1,273,"sbr_envelope(): bs_data_env")) << delta);
}
} else {
if (sbr->amp_res[ch])
{
sbr->E[ch][0][env] = (uint16_t)(faad_getbits(ld, 6
DEBUGVAR(1,274,"sbr_envelope(): bs_data_env")) << delta);
} else {
sbr->E[ch][0][env] = (uint16_t)(faad_getbits(ld, 7
DEBUGVAR(1,275,"sbr_envelope(): bs_data_env")) << delta);
}
}
for (band = 1; band < sbr->n[sbr->f[ch][env]]; band++)
{
sbr->E[ch][band][env] = (sbr_huff_dec(ld, f_huff) << delta);
}
} else {
for (band = 0; band < sbr->n[sbr->f[ch][env]]; band++)
{
sbr->E[ch][band][env] = (sbr_huff_dec(ld, t_huff) << delta);
}
}
}
extract_envelope_data(sbr, ch);
}
