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; }
/* table 8 */ static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch) { uint8_t i; for (i = 0; i < sbr->L_E[ch]; i++) { sbr->bs_df_env[ch][i] = faad_get1bit(ld DEBUGVAR(1,269,"sbr_dtdf(): bs_df_env")); } for (i = 0; i < sbr->L_Q[ch]; i++) { sbr->bs_df_noise[ch][i] = faad_get1bit(ld DEBUGVAR(1,270,"sbr_dtdf(): bs_df_noise")); } }
/* * 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 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; }
__inline void decode_huff_cw(faacDecHandle hDecoder, Huffman *h, int *qp, Hcb *hcb) { int i, j; unsigned long cw; i = h->len; cw = faad_getbits_fast(&hDecoder->ld, i); while (cw != h->cw) { h++; j = h->len-i; if (j!=0) { i += j; while (j--) cw = (cw<<1)|faad_get1bit(&hDecoder->ld); } } if(hcb->dim == 4) { qp[0] = h->x; qp[1] = h->y; qp[2] = h->v; qp[3] = h->w; } else { qp[0] = h->x; qp[1] = h->y; } }
static uint8_t huffman_binary_quad(uint8_t cb, bitfile *ld, int16_t *sp) { uint16_t offset = 0; while (!hcb3[offset].is_leaf) { uint8_t b = faad_get1bit(ld DEBUGVAR(1,255,"huffman_spectral_data():3")); offset += hcb3[offset].data[b]; } if (offset > hcb_bin_table_size[cb]) { /* printf("ERROR: offset into hcb_bin_table = %d >%d!\n", offset, hcb_bin_table_size[cb]); */ return 10; } sp[0] = hcb3[offset].data[0]; sp[1] = hcb3[offset].data[1]; sp[2] = hcb3[offset].data[2]; sp[3] = hcb3[offset].data[3]; return 0; }
/* table 12 */ static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch) { uint8_t n; for (n = 0; n < sbr->N_high; n++) { sbr->bs_add_harmonic[ch][n] = faad_get1bit(ld DEBUGVAR(1,278,"sinusoidal_coding(): bs_add_harmonic")); } }
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 uint16_t ps_extension(ps_info *ps, bitfile *ld, const uint8_t ps_extension_id, const uint16_t num_bits_left) { uint8_t n; uint16_t bits = (uint16_t)faad_get_processed_bits(ld); if (ps_extension_id == 0) { ps->enable_ipdopd = (uint8_t)faad_get1bit(ld DEBUGVAR(1,1015,"ps_extension(): enable_ipdopd")); if (ps->enable_ipdopd) { for (n = 0; n < ps->num_env; n++) { ps->ipd_dt[n] = (uint8_t)faad_get1bit(ld DEBUGVAR(1,1016,"ps_extension(): ipd_dt")); /* ipd_data */ huff_data(ld, ps->ipd_dt[n], ps->nr_ipdopd_par, t_huff_ipd, f_huff_ipd, ps->ipd_index[n]); ps->opd_dt[n] = (uint8_t)faad_get1bit(ld DEBUGVAR(1,1017,"ps_extension(): opd_dt")); /* opd_data */ huff_data(ld, ps->opd_dt[n], ps->nr_ipdopd_par, t_huff_opd, f_huff_opd, ps->opd_index[n]); } } faad_get1bit(ld DEBUGVAR(1,1018,"ps_extension(): reserved_ps")); } /* return number of bits read */ bits = (uint16_t)faad_get_processed_bits(ld) - bits; return bits; }
/* * adts_header */ int get_adts_header(faacDecHandle hDecoder) { int sync = 0; ADTS_Header *p = &hDecoder->adts_header; faad_byte_align(&hDecoder->ld); sync = faad_showbits(&hDecoder->ld, 12); while (sync != 4096 - 1) { faad_flushbits(&hDecoder->ld, 8); if (faad_bits_done(&hDecoder->ld) != 0) { return -1; } sync = faad_showbits(&hDecoder->ld, 12); } faad_flushbits(&hDecoder->ld, 12); if (hDecoder->frameNum) { faad_getbits(&hDecoder->ld, 16); #if 0 if (p->fixed.ID == 0) /* MPEG2 AAC doesn't have this */ faad_getbits(&hDecoder->ld, 2); #endif } else { /* Syncword found, proceed to read in the fixed ADTS header */ p->fixed.ID = faad_get1bit(&hDecoder->ld); /* 0 -> MPEG4, 1 -> MPEG2 */ hDecoder->isMpeg4 = !p->fixed.ID; p->fixed.layer = faad_getbits(&hDecoder->ld, 2); p->fixed.protection_absent = faad_get1bit(&hDecoder->ld); hDecoder->mc_info.object_type = p->fixed.object_type = faad_getbits(&hDecoder->ld, 2); hDecoder->mc_info.sampling_rate_idx = p->fixed.sampling_rate_idx = faad_getbits(&hDecoder->ld, 4); p->fixed.private_bit = faad_get1bit(&hDecoder->ld); p->fixed.channel_configuration = faad_getbits(&hDecoder->ld, 3); p->fixed.original_copy = faad_get1bit(&hDecoder->ld); p->fixed.home = faad_get1bit(&hDecoder->ld); #if 0 if (p->fixed.ID == 0) /* MPEG2 AAC doesn't have this */ p->fixed.emphasis = faad_getbits(&hDecoder->ld, 2); #endif } /* ...and the variable ADTS header */ p->variable.copy_id_bit = faad_get1bit(&hDecoder->ld); p->variable.copy_id_start = faad_get1bit(&hDecoder->ld); p->variable.frame_length = faad_getbits(&hDecoder->ld, 13); p->variable.buffer_fullness = faad_getbits(&hDecoder->ld, 11); p->variable.raw_blocks = faad_getbits(&hDecoder->ld, 2); /* ADTS error check (ignored) */ if(!p->fixed.protection_absent) faad_getbits(&hDecoder->ld, 16); return 0; }
/* binary search huffman decoding */ static INLINE int8_t ps_huff_dec(bitfile *ld, ps_huff_tab t_huff) { uint8_t bit; int16_t index = 0; while (index >= 0) { bit = (uint8_t)faad_get1bit(ld); index = t_huff[index][bit]; } return index + 31; }
static INLINE void huffman_sign_bits(bitfile *ld, int16_t *sp, uint8_t len) { uint8_t i; for (i = 0; i < len; i++) { if(sp[i]) { if(faad_get1bit(ld DEBUGVAR(1,5,"huffman_sign_bits(): sign bit")) & 1) { sp[i] = -sp[i]; } } } }
/* get sign bits */ static void get_sign_bits(faacDecHandle hDecoder, int *q, int n) { int i; for(i=0; i < n; i++) { if(q[i]) { if(faad_get1bit(&hDecoder->ld) & 1) { /* 1 signals negative, as in 2's complement */ q[i] = -q[i]; } } } }
int8_t huffman_scale_factor(bitfile *ld) { uint16_t offset = 0; while (hcb_sf[offset][1]) { uint8_t b = faad_get1bit(ld DEBUGVAR(1,255,"huffman_scale_factor()")); offset += hcb_sf[offset][b]; if (offset > 240) { /* printf("ERROR: offset into hcb_sf = %d >240!\n", offset); */ return -1; } } return hcb_sf[offset][0]; }
__inline int decode_huff_cw_scl(faacDecHandle hDecoder, Huffscl *h) { int i, j; long cw; i = h->len; cw = faad_getbits_fast(&hDecoder->ld, i); while ((unsigned long)cw != h->cw) { h++; j = h->len-i; if (j!=0) { i += j; while (j--) cw = (cw<<1)|faad_get1bit(&hDecoder->ld); } } return h->scl; }
static void getgroup(faacDecHandle hDecoder, Info *info, byte *group) { int i, j, first_short; first_short=1; for (i = 0; i < info->nsbk; i++) { if (info->bins_per_sbk[i] > SN2) { /* non-short windows are always their own group */ *group++ = i+1; } else { /* only short-window sequences are grouped! */ if (first_short) { /* first short window is always a new group */ first_short=0; } else { if((j = faad_get1bit(&hDecoder->ld)) == 0) { *group++ = i; } } } } *group = i; }
/* table 4 */ static uint8_t sbr_data(bitfile *ld, sbr_info *sbr) { uint8_t result; #if 0 sbr->bs_samplerate_mode = faad_get1bit(ld DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode")); #endif sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1; switch (sbr->id_aac) { case ID_SCE: if ((result = sbr_single_channel_element(ld, sbr)) > 0) return result; break; case ID_CPE: if ((result = sbr_channel_pair_element(ld, sbr)) > 0) return result; break; } return 0; }
/* 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); #ifndef FIXED_POINT envelope_noise_dequantisation(sbr, 0); #endif 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; #if (defined(PS_DEC) || defined(DRM_PS)) uint8_t ps_ext_read = 0; #endif 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) { uint16_t tmp_nr_bits = 0; sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); tmp_nr_bits += 2; /* allow only 1 PS extension element per extension data */ #if (defined(PS_DEC) || defined(DRM_PS)) #if (defined(PS_DEC) && defined(DRM_PS)) if (sbr->bs_extension_id == EXTENSION_ID_PS || sbr->bs_extension_id == DRM_PARAMETRIC_STEREO) #else #ifdef PS_DEC if (sbr->bs_extension_id == EXTENSION_ID_PS) #else #ifdef DRM_PS if (sbr->bs_extension_id == DRM_PARAMETRIC_STEREO) #endif #endif #endif { if (ps_ext_read == 0) { ps_ext_read = 1; } else { /* to be safe make it 3, will switch to "default" * in sbr_extension() */ #ifdef DRM return 1; #else sbr->bs_extension_id = 3; #endif } } #endif tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); /* check if the data read is bigger than the number of available bits */ if (tmp_nr_bits > nr_bits_left) return 1; nr_bits_left -= tmp_nr_bits; } /* Corrigendum */ if (nr_bits_left > 0) { faad_getbits(ld, nr_bits_left DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left")); } } return 0; }
int8_t AudioSpecificConfig2(uint8_t *pBuffer, uint32_t buffer_size, mp4AudioSpecificConfig *mp4ASC, program_config *pce) { bitfile ld; int8_t result = 0; #ifdef SBR_DEC int8_t bits_to_decode = 0; #endif if (pBuffer == NULL) return -7; if (mp4ASC == NULL) return -8; memset(mp4ASC, 0, sizeof(mp4AudioSpecificConfig)); faad_initbits(&ld, pBuffer, buffer_size); faad_byte_align(&ld); mp4ASC->objectTypeIndex = (uint8_t)faad_getbits(&ld, 5 DEBUGVAR(1,1,"parse_audio_decoder_specific_info(): ObjectTypeIndex")); mp4ASC->samplingFrequencyIndex = (uint8_t)faad_getbits(&ld, 4 DEBUGVAR(1,2,"parse_audio_decoder_specific_info(): SamplingFrequencyIndex")); mp4ASC->channelsConfiguration = (uint8_t)faad_getbits(&ld, 4 DEBUGVAR(1,3,"parse_audio_decoder_specific_info(): ChannelsConfiguration")); mp4ASC->samplingFrequency = get_sample_rate(mp4ASC->samplingFrequencyIndex); if (ObjectTypesTable[mp4ASC->objectTypeIndex] != 1) { faad_endbits(&ld); return -1; } if (mp4ASC->samplingFrequency == 0) { faad_endbits(&ld); return -2; } if (mp4ASC->channelsConfiguration > 7) { faad_endbits(&ld); return -3; } #if (defined(PS_DEC) || defined(DRM_PS)) /* check if we have a mono file */ if (mp4ASC->channelsConfiguration == 1) { /* upMatrix to 2 channels for implicit signalling of PS */ mp4ASC->channelsConfiguration = 2; } #endif #ifdef SBR_DEC mp4ASC->sbr_present_flag = -1; if (mp4ASC->objectTypeIndex == 5) { uint8_t tmp; mp4ASC->sbr_present_flag = 1; tmp = (uint8_t)faad_getbits(&ld, 4 DEBUGVAR(1,5,"parse_audio_decoder_specific_info(): extensionSamplingFrequencyIndex")); /* check for downsampled SBR */ if (tmp == mp4ASC->samplingFrequencyIndex) mp4ASC->downSampledSBR = 1; mp4ASC->samplingFrequencyIndex = tmp; if (mp4ASC->samplingFrequencyIndex == 15) { mp4ASC->samplingFrequency = (uint32_t)faad_getbits(&ld, 24 DEBUGVAR(1,6,"parse_audio_decoder_specific_info(): extensionSamplingFrequencyIndex")); } else { mp4ASC->samplingFrequency = get_sample_rate(mp4ASC->samplingFrequencyIndex); } mp4ASC->objectTypeIndex = (uint8_t)faad_getbits(&ld, 5 DEBUGVAR(1,7,"parse_audio_decoder_specific_info(): ObjectTypeIndex")); } #endif /* get GASpecificConfig */ if (mp4ASC->objectTypeIndex == 1 || mp4ASC->objectTypeIndex == 2 || mp4ASC->objectTypeIndex == 3 || mp4ASC->objectTypeIndex == 4 || mp4ASC->objectTypeIndex == 6 || mp4ASC->objectTypeIndex == 7) { result = GASpecificConfig(&ld, mp4ASC, pce); #ifdef ERROR_RESILIENCE } else if (mp4ASC->objectTypeIndex >= ER_OBJECT_START) { /* ER */ result = GASpecificConfig(&ld, mp4ASC, pce); mp4ASC->epConfig = (uint8_t)faad_getbits(&ld, 2 DEBUGVAR(1,143,"parse_audio_decoder_specific_info(): epConfig")); if (mp4ASC->epConfig != 0) result = -5; #endif } else { result = -4; } #ifdef SSR_DEC /* shorter frames not allowed for SSR */ if ((mp4ASC->objectTypeIndex == 4) && mp4ASC->frameLengthFlag) return -6; #endif #ifdef SBR_DEC bits_to_decode = (int8_t)(buffer_size*8 - faad_get_processed_bits(&ld)); if ((mp4ASC->objectTypeIndex != 5) && (bits_to_decode >= 16)) { int16_t syncExtensionType = (int16_t)faad_getbits(&ld, 11 DEBUGVAR(1,9,"parse_audio_decoder_specific_info(): syncExtensionType")); if (syncExtensionType == 0x2b7) { uint8_t tmp_OTi = (uint8_t)faad_getbits(&ld, 5 DEBUGVAR(1,10,"parse_audio_decoder_specific_info(): extensionAudioObjectType")); if (mp4ASC->objectTypeIndex == 5) { mp4ASC->sbr_present_flag = (uint8_t)faad_get1bit(&ld DEBUGVAR(1,11,"parse_audio_decoder_specific_info(): sbr_present_flag")); if (mp4ASC->sbr_present_flag) { uint8_t tmp; /* Don't set OT to SBR until checked that it is actually there */ mp4ASC->objectTypeIndex = tmp_OTi; tmp = (uint8_t)faad_getbits(&ld, 4 DEBUGVAR(1,12,"parse_audio_decoder_specific_info(): extensionSamplingFrequencyIndex")); /* check for downsampled SBR */ if (tmp == mp4ASC->samplingFrequencyIndex) mp4ASC->downSampledSBR = 1; mp4ASC->samplingFrequencyIndex = tmp; if (mp4ASC->samplingFrequencyIndex == 15) { mp4ASC->samplingFrequency = (uint32_t)faad_getbits(&ld, 24 DEBUGVAR(1,13,"parse_audio_decoder_specific_info(): extensionSamplingFrequencyIndex")); } else { mp4ASC->samplingFrequency = get_sample_rate(mp4ASC->samplingFrequencyIndex); } } } } } /* no SBR signalled, this could mean either implicit signalling or no SBR in this file */ /* MPEG specification states: assume SBR on files with samplerate <= 24000 Hz */ if (mp4ASC->sbr_present_flag == -1) { if (mp4ASC->samplingFrequency <= 24000) { mp4ASC->samplingFrequency *= 2; mp4ASC->forceUpSampling = 1; } else /* > 24000*/ { mp4ASC->downSampledSBR = 1; } } #endif faad_endbits(&ld); return result; }
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 2 */ uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt) { uint8_t result = 0; uint16_t num_align_bits = 0; uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld); #ifdef DRM if (!sbr->Is_DRM_SBR) #endif { uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type")); if (bs_extension_type == EXT_SBR_DATA_CRC) { sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); } } sbr->bs_header_flag = faad_get1bit(ld DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); if (sbr->bs_header_flag) sbr_header(ld, sbr); /* Reset? */ sbr_reset(sbr); /* first frame should have a header */ //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0)) if (sbr->header_count != 0) { if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) { uint8_t k2; /* calculate the Master Frequency Table */ sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode, sbr->sample_rate); k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0); /* check k0 and k2 */ if (sbr->sample_rate >= 48000) { if ((k2 - sbr->k0) > 32) result += 1; } else if (sbr->sample_rate <= 32000) { if ((k2 - sbr->k0) > 48) result += 1; } else { /* (sbr->sample_rate == 44100) */ if ((k2 - sbr->k0) > 45) result += 1; } if (sbr->bs_freq_scale == 0) { result += master_frequency_table_fs0(sbr, sbr->k0, k2, sbr->bs_alter_scale); } else { result += master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale, sbr->bs_alter_scale); } result += derived_frequency_table(sbr, sbr->bs_xover_band, k2); result = (result > 0) ? 1 : 0; } if (result == 0) result = sbr_data(ld, sbr); } else { result = 1; } #ifdef DRM if (!sbr->Is_DRM_SBR) #endif { num_sbr_bits = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits; /* -4 does not apply, bs_extension_type is re-read in this function */ num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits; while (num_align_bits > 7) { faad_getbits(ld, 8 DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits")); num_align_bits -= 8; } faad_getbits(ld, num_align_bits DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits")); } return result; }
/* table 3 */ static void sbr_header(bitfile *ld, sbr_info *sbr) { uint8_t bs_header_extra_1, bs_header_extra_2; sbr->header_count++; sbr->bs_amp_res = faad_get1bit(ld DEBUGVAR(1,203,"sbr_header(): bs_amp_res")); /* bs_start_freq and bs_stop_freq must define a fequency band that does not exceed 48 channels */ sbr->bs_start_freq = (uint8_t)faad_getbits(ld, 4 DEBUGVAR(1,204,"sbr_header(): bs_start_freq")); sbr->bs_stop_freq = (uint8_t)faad_getbits(ld, 4 DEBUGVAR(1,205,"sbr_header(): bs_stop_freq")); sbr->bs_xover_band = (uint8_t)faad_getbits(ld, 3 DEBUGVAR(1,206,"sbr_header(): bs_xover_band")); faad_getbits(ld, 2 DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr")); bs_header_extra_1 = (uint8_t)faad_get1bit(ld DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1")); bs_header_extra_2 = (uint8_t)faad_get1bit(ld DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2")); if (bs_header_extra_1) { sbr->bs_freq_scale = (uint8_t)faad_getbits(ld, 2 DEBUGVAR(1,211,"sbr_header(): bs_freq_scale")); sbr->bs_alter_scale = (uint8_t)faad_get1bit(ld DEBUGVAR(1,212,"sbr_header(): bs_alter_scale")); sbr->bs_noise_bands = (uint8_t)faad_getbits(ld, 2 DEBUGVAR(1,213,"sbr_header(): bs_noise_bands")); } else { /* Default values */ sbr->bs_freq_scale = 2; sbr->bs_alter_scale = 1; sbr->bs_noise_bands = 2; } if (bs_header_extra_2) { sbr->bs_limiter_bands = (uint8_t)faad_getbits(ld, 2 DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands")); sbr->bs_limiter_gains = (uint8_t)faad_getbits(ld, 2 DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains")); sbr->bs_interpol_freq = (uint8_t)faad_get1bit(ld DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq")); sbr->bs_smoothing_mode = (uint8_t)faad_get1bit(ld DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode")); } else { /* Default values */ sbr->bs_limiter_bands = 2; sbr->bs_limiter_gains = 2; sbr->bs_interpol_freq = 1; sbr->bs_smoothing_mode = 1; } #if 0 /* print the header to screen */ printf("bs_amp_res: %d\n", sbr->bs_amp_res); printf("bs_start_freq: %d\n", sbr->bs_start_freq); printf("bs_stop_freq: %d\n", sbr->bs_stop_freq); printf("bs_xover_band: %d\n", sbr->bs_xover_band); if (bs_header_extra_1) { printf("bs_freq_scale: %d\n", sbr->bs_freq_scale); printf("bs_alter_scale: %d\n", sbr->bs_alter_scale); printf("bs_noise_bands: %d\n", sbr->bs_noise_bands); } if (bs_header_extra_2) { printf("bs_limiter_bands: %d\n", sbr->bs_limiter_bands); printf("bs_limiter_gains: %d\n", sbr->bs_limiter_gains); printf("bs_interpol_freq: %d\n", sbr->bs_interpol_freq); printf("bs_smoothing_mode: %d\n", sbr->bs_smoothing_mode); } printf("\n"); #endif }
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; }
/* 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 { uint8_t saved_t_E[6] = {0}, saved_t_Q[3] = {0}; uint8_t saved_L_E = sbr->L_E[0]; uint8_t saved_L_Q = sbr->L_Q[0]; uint8_t saved_frame_class = sbr->bs_frame_class[0]; for (n = 0; n < saved_L_E; n++) saved_t_E[n] = sbr->t_E[0][n]; for (n = 0; n < saved_L_Q; n++) saved_t_Q[n] = sbr->t_Q[0][n]; if ((result = sbr_grid(ld, sbr, 0)) > 0) return result; if ((result = sbr_grid(ld, sbr, 1)) > 0) { /* restore first channel data as well */ sbr->bs_frame_class[0] = saved_frame_class; sbr->L_E[0] = saved_L_E; sbr->L_Q[0] = saved_L_Q; for (n = 0; n < 6; n++) sbr->t_E[0][n] = saved_t_E[n]; for (n = 0; n < 3; n++) sbr->t_Q[0][n] = saved_t_Q[n]; 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); } #ifndef FIXED_POINT envelope_noise_dequantisation(sbr, 0); envelope_noise_dequantisation(sbr, 1); if (sbr->bs_coupling) unmap_envelope_noise(sbr); #endif 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) { uint16_t tmp_nr_bits = 0; sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); tmp_nr_bits += 2; tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); /* check if the data read is bigger than the number of available bits */ if (tmp_nr_bits > nr_bits_left) return 1; nr_bits_left -= tmp_nr_bits; } /* Corrigendum */ if (nr_bits_left > 0) { faad_getbits(ld, nr_bits_left DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left")); } } return 0; }