From 228ca70d485e2660c2e381d7112cbcca65c156a0 Mon Sep 17 00:00:00 2001 From: diego Date: Wed, 2 Jun 2004 22:59:04 +0000 Subject: update to the 2.0 release of faad, patch by adland git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@12528 b3059339-0415-0410-9bf9-f77b7e298cf2 --- libfaad2/sbr_dec.c | 492 +++++++++++++++++++++++++++++++---------------------- 1 file changed, 288 insertions(+), 204 deletions(-) (limited to 'libfaad2/sbr_dec.c') diff --git a/libfaad2/sbr_dec.c b/libfaad2/sbr_dec.c index ed1e28dd5b..af1edb20d1 100644 --- a/libfaad2/sbr_dec.c +++ b/libfaad2/sbr_dec.c @@ -1,6 +1,6 @@ /* ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding -** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com +** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com ** ** This program is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by @@ -22,7 +22,7 @@ ** Commercial non-GPL licensing of this software is possible. ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. ** -** $Id: sbr_dec.c,v 1.12 2003/09/25 12:04:31 menno Exp $ +** $Id: sbr_dec.c,v 1.2 2003/10/03 22:22:27 alex Exp $ **/ @@ -31,6 +31,7 @@ #ifdef SBR_DEC +#include #include #include "syntax.h" @@ -40,16 +41,23 @@ #include "sbr_hfgen.h" #include "sbr_hfadj.h" +/* static function declarations */ +static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch); -sbr_info *sbrDecodeInit(uint16_t framelength +sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac, + uint32_t sample_rate #ifdef DRM , uint8_t IsDRM #endif ) { - sbr_info *sbr = malloc(sizeof(sbr_info)); + 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; @@ -65,22 +73,11 @@ sbr_info *sbrDecodeInit(uint16_t framelength sbr->header_count = 0; #ifdef DRM - sbr->Is_DRM_SBR = 0; - if (IsDRM) - { - sbr->Is_DRM_SBR = 1; - sbr->tHFGen = T_HFGEN_DRM; - sbr->tHFAdj = T_HFADJ_DRM; - - /* "offset" is different in DRM */ - sbr->bs_samplerate_mode = 0; - } else + sbr->Is_DRM_SBR = IsDRM; #endif - { - sbr->bs_samplerate_mode = 1; - sbr->tHFGen = T_HFGEN; - sbr->tHFAdj = T_HFADJ; - } + sbr->bs_samplerate_mode = 1; + sbr->tHFGen = T_HFGEN; + sbr->tHFAdj = T_HFADJ; /* force sbr reset */ sbr->bs_start_freq_prev = -1; @@ -105,30 +102,25 @@ void sbrDecodeEnd(sbr_info *sbr) { qmfa_end(sbr->qmfa[0]); qmfs_end(sbr->qmfs[0]); - if (sbr->id_aac == ID_CPE) + if (sbr->qmfs[1] != NULL) { qmfa_end(sbr->qmfa[1]); qmfs_end(sbr->qmfs[1]); } - if (sbr->Xcodec[0]) free(sbr->Xcodec[0]); - if (sbr->Xsbr[0]) free(sbr->Xsbr[0]); - if (sbr->Xcodec[1]) free(sbr->Xcodec[1]); - if (sbr->Xsbr[1]) free(sbr->Xsbr[1]); - for (j = 0; j < 5; j++) { - if (sbr->G_temp_prev[0][j]) free(sbr->G_temp_prev[0][j]); - if (sbr->Q_temp_prev[0][j]) free(sbr->Q_temp_prev[0][j]); - if (sbr->G_temp_prev[1][j]) free(sbr->G_temp_prev[1][j]); - if (sbr->Q_temp_prev[1][j]) free(sbr->Q_temp_prev[1][j]); + if (sbr->G_temp_prev[0][j]) faad_free(sbr->G_temp_prev[0][j]); + if (sbr->Q_temp_prev[0][j]) faad_free(sbr->Q_temp_prev[0][j]); + if (sbr->G_temp_prev[1][j]) faad_free(sbr->G_temp_prev[1][j]); + if (sbr->Q_temp_prev[1][j]) faad_free(sbr->Q_temp_prev[1][j]); } - free(sbr); + faad_free(sbr); } } -void sbr_save_prev_data(sbr_info *sbr, uint8_t ch) +static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch) { uint8_t i; @@ -137,6 +129,10 @@ void sbr_save_prev_data(sbr_info *sbr, uint8_t ch) sbr->L_E_prev[ch] = sbr->L_E[ch]; + /* sbr->L_E[ch] can become 0 on files with bit errors */ + if (sbr->L_E[ch] <= 0) + return 19; + sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1]; for (i = 0; i < 64; i++) { @@ -154,55 +150,150 @@ void sbr_save_prev_data(sbr_info *sbr, uint8_t ch) sbr->prevEnvIsShort[ch] = 0; else sbr->prevEnvIsShort[ch] = -1; + + return 0; } -void sbrDecodeFrame(sbr_info *sbr, real_t *left_channel, - real_t *right_channel, uint8_t id_aac, - uint8_t just_seeked, uint8_t upsample_only) +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; - uint8_t dont_process = 0; - uint8_t ch, channels, ret; - real_t *ch_buf; +#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); - qmf_t X[32*64]; + 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 - real_t deg[64]; + ,deg +#endif + ,ch); #endif - bitfile *ld = NULL; +#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 - sbr->id_aac = id_aac; - channels = (id_aac == ID_SCE) ? 1 : 2; +#if 1 + /* hf adjustment */ + hf_adjustment(sbr, sbr->Xsbr[ch] +#ifdef SBR_LOW_POWER + ,deg +#endif + ,ch); +#endif + } - if (sbr->data == NULL || sbr->data_size == 0) + if ((sbr->just_seeked != 0) || dont_process) { - ret = 1; + 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 { - ld = (bitfile*)malloc(sizeof(bitfile)); + for (l = 0; l < sbr->numTimeSlotsRate; l++) + { + uint8_t xover_band; - /* initialise and read the bitstream */ - faad_initbits(ld, sbr->data, sbr->data_size); + if (l < sbr->t_E[ch][0]) + xover_band = sbr->kx_prev; + else + xover_band = sbr->kx; - ret = sbr_extension_data(ld, sbr, id_aac); + 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 + } + } - ret = ld->error ? ld->error : ret; - faad_endbits(ld); - if (ld) free(ld); - ld = NULL; + 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)); } +} - if (sbr->data) free(sbr->data); - sbr->data = NULL; +uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan, + 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; - if (ret || (sbr->header_count == 0)) + /* 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 (ret && sbr->Reset) + if (sbr->ret && sbr->Reset) sbr->bs_start_freq_prev = -1; } @@ -213,183 +304,176 @@ void sbrDecodeFrame(sbr_info *sbr, real_t *left_channel, sbr->just_seeked = 0; } - for (ch = 0; ch < channels; ch++) + sbr_process_channel(sbr, left_chan, X, 0, dont_process); + /* subband synthesis */ +#ifndef USE_SSE + sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan); +#else + sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[0], X, left_chan); +#endif + + sbr_process_channel(sbr, right_chan, X, 1, dont_process); + /* subband synthesis */ +#ifndef USE_SSE + sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan); +#else + sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[1], X, right_chan); +#endif + + if (sbr->bs_header_flag) + sbr->just_seeked = 0; + + if (sbr->header_count != 0 && sbr->ret == 0) { - 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] = malloc(64*sizeof(real_t)); - sbr->Q_temp_prev[ch][j] = malloc(64*sizeof(real_t)); - } + ret = sbr_save_prev_data(sbr, 0); + if (ret) return ret; + ret = sbr_save_prev_data(sbr, 1); + if (ret) return ret; + } - sbr->Xsbr[ch] = malloc((sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t)); - sbr->Xcodec[ch] = malloc((sbr->numTimeSlotsRate+sbr->tHFGen)*32 * sizeof(qmf_t)); + sbr->frame++; - 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)); - } + return 0; +} - if (ch == 0) - ch_buf = left_channel; - else - ch_buf = right_channel; +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 0 - for (i = 0; i < sbr->tHFAdj; i++) - { - int8_t j; - for (j = sbr->kx_prev; j < sbr->kx; j++) - { - QMF_RE(sbr->Xcodec[ch][i*32 + j]) = 0; -#ifndef SBR_LOW_POWER - QMF_IM(sbr->Xcodec[ch][i*32 + j]) = 0; -#endif - } - } -#endif + if (sbr == NULL) + return 20; - /* subband analysis */ - if (dont_process) - sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], ch_buf, sbr->Xcodec[ch], sbr->tHFGen, 32); - else - sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], ch_buf, sbr->Xcodec[ch], sbr->tHFGen, sbr->kx); + /* case can occur due to bit errors */ + if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) + return 21; - if (!dont_process) - { - /* insert high frequencies here */ - /* hf generation using patching */ - hf_generation(sbr, sbr->Xcodec[ch], sbr->Xsbr[ch] -#ifdef SBR_LOW_POWER - ,deg -#endif - ,ch); + if (sbr->ret || (sbr->header_count == 0)) + { + /* don't process just upsample */ + dont_process = 1; -#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)*64 + k]) = 0; - } - } -#endif + /* Re-activate reset for next frame */ + if (sbr->ret && sbr->Reset) + sbr->bs_start_freq_prev = -1; + } -#if 1 - /* hf adjustment */ - hf_adjustment(sbr, sbr->Xsbr[ch] -#ifdef SBR_LOW_POWER - ,deg -#endif - ,ch); -#endif - } + if (just_seeked) + { + sbr->just_seeked = 1; + } else { + sbr->just_seeked = 0; + } - if ((sbr->just_seeked != 0) || dont_process) - { - for (l = 0; l < sbr->numTimeSlotsRate; l++) - { - for (k = 0; k < 32; k++) - { - QMF_RE(X[l * 64 + k]) = QMF_RE(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]); -#ifndef SBR_LOW_POWER - QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]); -#endif - } - for (k = 32; k < 64; k++) - { - QMF_RE(X[l * 64 + k]) = 0; -#ifndef SBR_LOW_POWER - QMF_IM(X[l * 64 + k]) = 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 - } - } - } 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; + if (sbr->bs_header_flag) + sbr->just_seeked = 0; -#ifdef DRM - if (sbr->Is_DRM_SBR) - xover_band = sbr->kx; -#endif + if (sbr->header_count != 0 && sbr->ret == 0) + { + ret = sbr_save_prev_data(sbr, 0); + if (ret) return ret; + } - for (k = 0; k < xover_band; k++) - { - QMF_RE(X[l * 64 + k]) = QMF_RE(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]); -#ifndef SBR_LOW_POWER - QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]); -#endif - } - for (k = xover_band; k < 64; k++) - { - QMF_RE(X[l * 64 + k]) = QMF_RE(sbr->Xsbr[ch][(l + sbr->tHFAdj)*64 + k]); -#ifndef SBR_LOW_POWER - QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xsbr[ch][(l + sbr->tHFAdj)*64 + k]); -#endif - } -#ifdef SBR_LOW_POWER - QMF_RE(X[l * 64 + xover_band - 1]) += QMF_RE(sbr->Xsbr[ch][(l + sbr->tHFAdj)*64 + xover_band - 1]); -#endif -#ifdef DRM - if (sbr->Is_DRM_SBR) - { - for (k = xover_band; k < xover_band + 4; k++) - { - QMF_RE(X[l * 64 + k]) += QMF_RE(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]); - QMF_IM(X[l * 64 + k]) += QMF_IM(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]); - } - } -#endif - } - } + sbr->frame++; - /* subband synthesis */ - sbr_qmf_synthesis_64(sbr, sbr->qmfs[ch], (const complex_t*)X, ch_buf); + return 0; +} - for (i = 0; i < 32; i++) - { - int8_t j; - for (j = 0; j < sbr->tHFGen; j++) - { - QMF_RE(sbr->Xcodec[ch][j*32 + i]) = QMF_RE(sbr->Xcodec[ch][(j+sbr->numTimeSlotsRate)*32 + i]); -#ifndef SBR_LOW_POWER - QMF_IM(sbr->Xcodec[ch][j*32 + i]) = QMF_IM(sbr->Xcodec[ch][(j+sbr->numTimeSlotsRate)*32 + i]); -#endif - } - } - for (i = 0; i < 64; i++) +static void ps_dummy_function(qmf_t X_mono[MAX_NTSR][64], + qmf_t X_left[MAX_NTSR][64], qmf_t X_right[MAX_NTSR][64]) +{ + uint8_t i, j; + + for (i = 0; i < MAX_NTSR; i++) + { + for (j = 0; j < 64; j++) { - int8_t j; - for (j = 0; j < sbr->tHFGen; j++) - { - QMF_RE(sbr->Xsbr[ch][j*64 + i]) = QMF_RE(sbr->Xsbr[ch][(j+sbr->numTimeSlotsRate)*64 + i]); + QMF_RE(X_left[i][j]) = QMF_RE(X_mono[i][j]); + QMF_RE(X_right[i][j]) = QMF_RE(X_mono[i][j]); #ifndef SBR_LOW_POWER - QMF_IM(sbr->Xsbr[ch][j*64 + i]) = QMF_IM(sbr->Xsbr[ch][(j+sbr->numTimeSlotsRate)*64 + i]); + QMF_IM(X_left[i][j]) = QMF_IM(X_mono[i][j]); + QMF_IM(X_right[i][j]) = QMF_IM(X_mono[i][j]); #endif - } } } +} + +#if (defined(PS_DEC) || defined(DRM_PS)) +uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel, + const uint8_t just_seeked, const uint8_t upsample_only) +{ + uint8_t dont_process = 0; + uint8_t ret = 0; + ALIGN qmf_t X_mono[MAX_NTSR][64]; + ALIGN qmf_t X_left[MAX_NTSR][64]; + ALIGN qmf_t X_right[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; + } + + if (sbr->frame == 0) + { + sbr->qmfs[1] = qmfs_init(64); + } + + sbr_process_channel(sbr, left_channel, X_mono, 0, dont_process); + + /* perform parametric stereo */ + ps_dummy_function(X_mono, X_left, X_right); + + /* subband synthesis */ +#ifndef USE_SSE + sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel); + sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel); +#else + sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[0], X_left, left_channel); + sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[1], X_right, right_channel); +#endif if (sbr->bs_header_flag) sbr->just_seeked = 0; - if (sbr->header_count != 0) + if (sbr->header_count != 0 && sbr->ret == 0) { - for (ch = 0; ch < channels; ch++) - sbr_save_prev_data(sbr, ch); + ret = sbr_save_prev_data(sbr, 0); + if (ret) return ret; } sbr->frame++; + + return 0; } +#endif #endif -- cgit v1.2.3