uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
const uint8_t just_seeked, const uint8_t upsample_only)
{
uint8_t dont_process = 0;
uint8_t ret = 0;
ALIGN qmf_t X[MAX_NTSR][64];
if (sbr == NULL)
return 20;
/* case can occur due to bit errors */
if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
return 21;
if (sbr->ret || (sbr->header_count == 0))
{
/* don't process just upsample */
dont_process = 1;
/* Re-activate reset for next frame */
if (sbr->ret && sbr->Reset)
sbr->bs_start_freq_prev = -1;
}
if (just_seeked)
{
sbr->just_seeked = 1;
} else {
sbr->just_seeked = 0;
}
sbr_process_channel(sbr, channel, X, 0, dont_process);
/* subband synthesis */
#ifndef USE_SSE
sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel);
#else
sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[0], X, channel);
#endif
if (sbr->bs_header_flag)
sbr->just_seeked = 0;
if (sbr->header_count != 0 && sbr->ret == 0)
{
ret = sbr_save_prev_data(sbr, 0);
if (ret) return ret;
}
sbr->frame++;
return 0;
}
uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
const uint8_t just_seeked, const uint8_t downSampledSBR)
{
uint8_t l, k;
uint8_t dont_process = 0;
uint8_t ret = 0;
memset(p_XLR->X_L, 0, sizeof(*p_XLR->X_L));
memset(p_XLR->X_R, 0, sizeof(*p_XLR->X_R));
if (sbr == NULL)
return 20;
/* case can occur due to bit errors */
if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
return 21;
if (sbr->ret || (sbr->header_count == 0))
{
/* don't process just upsample */
dont_process = 1;
/* Re-activate reset for next frame */
if (sbr->ret && sbr->Reset)
sbr->bs_start_freq_prev = -1;
}
if (just_seeked)
{
sbr->just_seeked = 1;
} else {
sbr->just_seeked = 0;
}
sbr_process_channel(sbr, left_channel, p_XLR->X_L, 0, dont_process, downSampledSBR);
/* copy some extra data for PS */
for (l = 32; l < 38; l++)
{
for (k = 0; k < 5; k++)
{
QMF_RE(p_XLR->X_L[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
QMF_IM(p_XLR->X_L[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
}
}
/* perform parametric stereo */
#ifdef DRM_PS
if (sbr->Is_DRM_SBR)
{
drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), sbr->sample_rate, p_XLR->X_L, p_XLR->X_R);
} else {
#endif
#ifdef PS_DEC
ps_decode(&sbr->ps, p_XLR->X_L, p_XLR->X_R);
#endif
#ifdef DRM_PS
}
#endif
/* subband synthesis */
if (downSampledSBR)
{
sbr_qmf_synthesis_32(sbr, &sbr->qmfs[0], p_XLR->X_L, left_channel);
sbr_qmf_synthesis_32(sbr, &sbr->qmfs[1], p_XLR->X_R, right_channel);
} else {
sbr_qmf_synthesis_64(sbr, &sbr->qmfs[0], p_XLR->X_L, left_channel);
sbr_qmf_synthesis_64(sbr, &sbr->qmfs[1], p_XLR->X_R, right_channel);
}
if (sbr->bs_header_flag)
sbr->just_seeked = 0;
if (sbr->header_count != 0 && sbr->ret == 0)
{
ret = sbr_save_prev_data(sbr, 0);
if (ret) return ret;
}
sbr_save_matrix(sbr, 0);
sbr->frame++;
return 0;
}
uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
const uint8_t just_seeked, const uint8_t downSampledSBR)
{
uint8_t dont_process = 0;
uint8_t ret = 0;
if (sbr == NULL)
return 20;
/* case can occur due to bit errors */
if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
return 21;
if (sbr->ret || (sbr->header_count == 0))
{
/* don't process just upsample */
dont_process = 1;
/* Re-activate reset for next frame */
if (sbr->ret && sbr->Reset)
sbr->bs_start_freq_prev = -1;
}
if (just_seeked)
{
sbr->just_seeked = 1;
} else {
sbr->just_seeked = 0;
}
sbr_process_channel(sbr, channel, p_XLR->X_L, 0, dont_process, downSampledSBR);
/* subband synthesis */
if (downSampledSBR)
{
sbr_qmf_synthesis_32(sbr, &sbr->qmfs[0], p_XLR->X_L, channel);
} else {
sbr_qmf_synthesis_64(sbr, &sbr->qmfs[0], p_XLR->X_L, channel);
}
if (sbr->bs_header_flag)
sbr->just_seeked = 0;
if (sbr->header_count != 0 && sbr->ret == 0)
{
ret = sbr_save_prev_data(sbr, 0);
if (ret) return ret;
}
sbr_save_matrix(sbr, 0);
sbr->frame++;
//#define POST_QMF_PRINT
#ifdef POST_QMF_PRINT
{
int i;
for (i = 0; i < 2048; i++)
{
printf("%d\n", channel[i]);
}
}
#endif
return 0;
}
uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
const uint8_t just_seeked, const uint8_t downSampledSBR)
{
uint8_t dont_process = 0;
uint8_t ret = 0;
ALIGN qmf_t X[MAX_NTSR][64];
if (sbr == NULL)
return 20;
/* case can occur due to bit errors */
if (sbr->id_aac != ID_CPE)
return 21;
if (sbr->ret || (sbr->header_count == 0))
{
/* don't process just upsample */
dont_process = 1;
/* Re-activate reset for next frame */
if (sbr->ret && sbr->Reset)
sbr->bs_start_freq_prev = -1;
}
if (just_seeked)
{
sbr->just_seeked = 1;
} else {
sbr->just_seeked = 0;
}
sbr->ret += sbr_process_channel(sbr, left_chan, X, 0, dont_process, downSampledSBR);
/* subband synthesis */
if (downSampledSBR)
{
sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, left_chan);
} else {
sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan);
}
sbr->ret += sbr_process_channel(sbr, right_chan, X, 1, dont_process, downSampledSBR);
/* subband synthesis */
if (downSampledSBR)
{
sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X, right_chan);
} else {
sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan);
}
if (sbr->bs_header_flag)
sbr->just_seeked = 0;
if (sbr->header_count != 0 && sbr->ret == 0)
{
ret = sbr_save_prev_data(sbr, 0);
if (ret) return ret;
ret = sbr_save_prev_data(sbr, 1);
if (ret) return ret;
}
sbr_save_matrix(sbr, 0);
sbr_save_matrix(sbr, 1);
sbr->frame++;
//#define POST_QMF_PRINT
#ifdef POST_QMF_PRINT
{
int i;
for (i = 0; i < 2048; i++)
{
printf("%d\n", left_chan[i]);
}
for (i = 0; i < 2048; i++)
{
printf("%d\n", right_chan[i]);
}
}
#endif
return 0;
}
void sbrDecodeFrame(sbr_info *sbr, real_t *left_channel,
real_t *right_channel, uint8_t id_aac,
uint8_t just_seeked)
{
int16_t i, k, l;
uint8_t dont_process = 0;
uint8_t ch, channels, ret;
real_t *ch_buf;
sbr->id_aac = id_aac;
channels = (id_aac == ID_SCE) ? 1 : 2;
ret = sbr_extension_data(&sbr->ld, sbr, id_aac);
ret = (sbr->ld.error)? sbr->ld.error : ret;
if(ret || (sbr->header_count == 0))
dont_process = 1;
if(just_seeked)
sbr->just_seeked = 1;
else
sbr->just_seeked = 0;
for (ch = 0; ch < channels; ch++){
if (ch == 0)
ch_buf = left_channel;
else
ch_buf = right_channel;
for (i = 0; i < tHFAdj; i++){
int8_t j;
for (j = sbr->kx_prev; j < sbr->kx; j++){
QMF_RE(sbr->Xcodec[ch][i*32 + j]) = 0;
QMF_IM(sbr->Xcodec[ch][i*32 + j]) = 0;
}
}
sbr_qmf_analysis_32(sbr->qmfa[ch], ch_buf, sbr->Xcodec[ch], tHFGen);
if(!dont_process){
hf_generation(sbr, sbr->Xcodec[ch], sbr->Xsbr[ch],ch);
hf_adjustment(sbr, sbr->Xsbr[ch],ch);
}
if((sbr->just_seeked != 0) || dont_process){
for (l = 0; l < 32; l++){
for (k = 0; k < 32; k++){
QMF_RE(sbr->temp_X[l * 64 + k]) = QMF_RE(sbr->Xcodec[ch][(l + tHFAdj)*32 + k]);
QMF_IM(sbr->temp_X[l * 64 + k]) = QMF_IM(sbr->Xcodec[ch][(l + tHFAdj)*32 + k]);
}
for (k = 32; k < 64; k++){
QMF_RE(sbr->temp_X[l * 64 + k]) = 0;
QMF_IM(sbr->temp_X[l * 64 + k]) = 0;
}
}
}else{
for (l = 0; l < 32; 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(sbr->temp_X[l * 64 + k]) = QMF_RE(sbr->Xcodec[ch][(l + tHFAdj)*32 + k]);
QMF_IM(sbr->temp_X[l * 64 + k]) = QMF_IM(sbr->Xcodec[ch][(l + tHFAdj)*32 + k]);
}
for (k = xover_band; k < 64; k++){
QMF_RE(sbr->temp_X[l * 64 + k]) = QMF_RE(sbr->Xsbr[ch][(l + tHFAdj)*64 + k]);
QMF_IM(sbr->temp_X[l * 64 + k]) = QMF_IM(sbr->Xsbr[ch][(l + tHFAdj)*64 + k]);
}
}
}
sbr_qmf_synthesis_64(sbr->qmfs[ch], (const complex_t*)sbr->temp_X, ch_buf);
for (i = 0; i < 32; i++){
int8_t j;
for (j = 0; j < tHFGen; j++){
QMF_RE(sbr->Xcodec[ch][j*32 + i]) = QMF_RE(sbr->Xcodec[ch][(j+32)*32 + i]);
QMF_IM(sbr->Xcodec[ch][j*32 + i]) = QMF_IM(sbr->Xcodec[ch][(j+32)*32 + i]);
}
}
for (i = 0; i < 64; i++){
int8_t j;
for (j = 0; j < tHFGen; j++){
QMF_RE(sbr->Xsbr[ch][j*64 + i]) = QMF_RE(sbr->Xsbr[ch][(j+32)*64 + i]);
QMF_IM(sbr->Xsbr[ch][j*64 + i]) = QMF_IM(sbr->Xsbr[ch][(j+32)*64 + i]);
}
}
}
if (sbr->bs_header_flag)
sbr->just_seeked = 0;
if (sbr->header_count != 0){
for (ch = 0; ch < channels; ch++)
sbr_save_prev_data(sbr, ch);
}
sbr->frame++;
}
uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
const uint8_t just_seeked, const uint8_t downSampledSBR)
{
uint8_t l, k;
uint8_t dont_process = 0;
uint8_t ret = 0;
ALIGN qmf_t X_left[38][64] = {{0}};
ALIGN qmf_t X_right[38][64] = {{0}}; /* must set this to 0 */
if (sbr == NULL)
return 20;
/* case can occur due to bit errors */
if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
return 21;
if (sbr->ret || (sbr->header_count == 0))
{
/* don't process just upsample */
dont_process = 1;
/* Re-activate reset for next frame */
if (sbr->ret && sbr->Reset)
sbr->bs_start_freq_prev = -1;
}
if (just_seeked)
{
sbr->just_seeked = 1;
} else {
sbr->just_seeked = 0;
}
if (sbr->qmfs[1] == NULL)
{
sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64);
}
sbr->ret += sbr_process_channel(sbr, left_channel, X_left, 0, dont_process, downSampledSBR);
/* copy some extra data for PS */
for (l = sbr->numTimeSlotsRate; l < sbr->numTimeSlotsRate + 6; l++)
{
for (k = 0; k < 5; k++)
{
QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
}
}
/* perform parametric stereo */
#ifdef DRM_PS
if (sbr->Is_DRM_SBR)
{
drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), X_left, X_right);
} else {
#endif
#ifdef PS_DEC
ps_decode(sbr->ps, X_left, X_right);
#endif
#ifdef DRM_PS
}
#endif
/* subband synthesis */
if (downSampledSBR)
{
sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X_left, left_channel);
sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X_right, right_channel);
} else {
sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel);
sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel);
}
if (sbr->bs_header_flag)
sbr->just_seeked = 0;
if (sbr->header_count != 0 && sbr->ret == 0)
{
ret = sbr_save_prev_data(sbr, 0);
if (ret) return ret;
}
sbr_save_matrix(sbr, 0);
sbr->frame++;
return 0;
}
