From 32063c433915b8dddd143a951ad90ae901ac1b38 Mon Sep 17 00:00:00 2001 From: arpi Date: Sat, 30 Aug 2003 22:30:28 +0000 Subject: libfaad2 v2.0rc1 imported git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@10726 b3059339-0415-0410-9bf9-f77b7e298cf2 --- libfaad2/sbr_dec.c | 357 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 357 insertions(+) create mode 100644 libfaad2/sbr_dec.c (limited to 'libfaad2/sbr_dec.c') diff --git a/libfaad2/sbr_dec.c b/libfaad2/sbr_dec.c new file mode 100644 index 0000000000..3bab4a8d01 --- /dev/null +++ b/libfaad2/sbr_dec.c @@ -0,0 +1,357 @@ +/* +** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding +** Copyright (C) 2003 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 +** the Free Software Foundation; either version 2 of the License, or +** (at your option) any later version. +** +** This program is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +** GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License +** along with this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** Any non-GPL usage of this software or parts of this software is strictly +** forbidden. +** +** 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.5 2003/07/29 08:20:13 menno Exp $ +**/ + +/* + SBR Decoder overview: + + To achieve a synchronized output signal, the following steps have to be + acknowledged in the decoder: + - The bitstream parser divides the bitstream into two parts; the AAC + core coder part and the SBR part. + - The SBR bitstream part is fed to the bitstream de-multiplexer followed + by de-quantization The raw data is Huffman decoded. + - The AAC bitstream part is fed to the AAC core decoder, where the + bitstream data of the current frame is decoded, yielding a time domain + audio signal block of 1024 samples. The block length could easily be + adapted to other sizes e.g. 960. + - The core coder audio block is fed to the analysis QMF bank using a + delay of 1312 samples. + - The analysis QMF bank performs the filtering of the delayed core coder + audio signal. The output from the filtering is stored in the matrix + Xlow. The output from the analysis QMF bank is delayed tHFGen subband + samples, before being fed to the synthesis QMF bank. To achieve + synchronization tHFGen = 32, i.e. the value must equal the number of + subband samples corresponding to one frame. + - The HF generator calculates XHigh given the matrix XLow. The process + is guided by the SBR data contained in the current frame. + - The envelope adjuster calculates the matrix Y given the matrix XHigh + and the SBR envelope data, extracted from the SBR bitstream. To + achieve synchronization, tHFAdj has to be set to tHFAdj = 0, i.e. the + envelope adjuster operates on data delayed tHFGen subband samples. + - The synthesis QMF bank operates on the delayed output from the analysis + QMF bank and the output from the envelope adjuster. + */ + +#include "common.h" +#include "structs.h" + +#ifdef SBR_DEC + +#include + +#include "syntax.h" +#include "bits.h" +#include "sbr_syntax.h" +#include "sbr_qmf.h" +#include "sbr_hfgen.h" +#include "sbr_hfadj.h" + + +sbr_info *sbrDecodeInit() +{ + sbr_info *sbr = malloc(sizeof(sbr_info)); + memset(sbr, 0, sizeof(sbr_info)); + + sbr->bs_freq_scale = 2; + sbr->bs_alter_scale = 1; + sbr->bs_noise_bands = 2; + sbr->bs_limiter_bands = 2; + sbr->bs_limiter_gains = 2; + sbr->bs_interpol_freq = 1; + sbr->bs_smoothing_mode = 1; + sbr->bs_start_freq = 5; + sbr->bs_amp_res = 1; + sbr->bs_samplerate_mode = 1; + sbr->prevEnvIsShort[0] = -1; + sbr->prevEnvIsShort[1] = -1; + sbr->header_count = 0; + + return sbr; +} + +void sbrDecodeEnd(sbr_info *sbr) +{ + uint8_t j; + + if (sbr) + { + qmfa_end(sbr->qmfa[0]); + qmfs_end(sbr->qmfs[0]); + if (sbr->id_aac == ID_CPE) + { + 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]); + } + + free(sbr); + } +} + +void sbr_save_prev_data(sbr_info *sbr, uint8_t ch) +{ + uint8_t i; + + /* save data for next frame */ + sbr->kx_prev = sbr->kx; + + sbr->L_E_prev[ch] = sbr->L_E[ch]; + + sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1]; + for (i = 0; i < 64; i++) + { + sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1]; + sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1]; + } + + for (i = 0; i < 64; i++) + { + sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i]; + } + sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch]; + + if (sbr->l_A[ch] == sbr->L_E[ch]) + sbr->prevEnvIsShort[ch] = 0; + else + sbr->prevEnvIsShort[ch] = -1; +} + + +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; + + qmf_t X[32*64]; +#ifdef SBR_LOW_POWER + real_t deg[64]; +#endif + + bitfile *ld = (bitfile*)malloc(sizeof(bitfile)); + + + sbr->id_aac = id_aac; + channels = (id_aac == ID_SCE) ? 1 : 2; + + /* initialise and read the bitstream */ + faad_initbits(ld, sbr->data, sbr->data_size); + + ret = sbr_extension_data(ld, sbr, id_aac); + + if (sbr->data) free(sbr->data); + sbr->data = NULL; + + ret = ld->error ? ld->error : ret; + faad_endbits(ld); + if (ld) free(ld); + ld = NULL; + if (ret || (sbr->header_count == 0)) + { + /* don't process just upsample */ + dont_process = 1; + } + + if (just_seeked) + sbr->just_seeked = 1; + else + sbr->just_seeked = 0; + + for (ch = 0; ch < channels; ch++) + { + 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)); + } + + sbr->Xsbr[ch] = malloc((32+tHFGen)*64 * sizeof(qmf_t)); + sbr->Xcodec[ch] = malloc((32+tHFGen)*32 * sizeof(qmf_t)); + + memset(sbr->Xsbr[ch], 0, (32+tHFGen)*64 * sizeof(qmf_t)); + memset(sbr->Xcodec[ch], 0, (32+tHFGen)*32 * sizeof(qmf_t)); + } + + 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; +#ifndef SBR_LOW_POWER + QMF_IM(sbr->Xcodec[ch][i*32 + j]) = 0; +#endif + } + } + + /* subband analysis */ + sbr_qmf_analysis_32(sbr->qmfa[ch], ch_buf, sbr->Xcodec[ch], tHFGen); + + 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); + +#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][(tHFAdj + l)*64 + k]) = 0; + } + } +#endif + + /* hf adjustment */ + hf_adjustment(sbr, sbr->Xsbr[ch] +#ifdef SBR_LOW_POWER + ,deg +#endif + ,ch); + } + + if ((sbr->just_seeked != 0) || dont_process) + { + for (l = 0; l < 32; l++) + { + for (k = 0; k < 32; k++) + { + QMF_RE(X[l * 64 + k]) = QMF_RE(sbr->Xcodec[ch][(l + tHFAdj)*32 + k]); +#ifndef SBR_LOW_POWER + QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xcodec[ch][(l + 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; +#endif + } + } + } 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(X[l * 64 + k]) = QMF_RE(sbr->Xcodec[ch][(l + tHFAdj)*32 + k]); +#ifndef SBR_LOW_POWER + QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xcodec[ch][(l + tHFAdj)*32 + k]); +#endif + } + for (k = xover_band; k < 64; k++) + { + QMF_RE(X[l * 64 + k]) = QMF_RE(sbr->Xsbr[ch][(l + tHFAdj)*64 + k]); +#ifndef SBR_LOW_POWER + QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xsbr[ch][(l + tHFAdj)*64 + k]); +#endif + } +#ifdef SBR_LOW_POWER + QMF_RE(X[l * 64 + xover_band - 1]) += QMF_RE(sbr->Xsbr[ch][(l + tHFAdj)*64 + xover_band - 1]); +#endif + } + } + + /* subband synthesis */ + sbr_qmf_synthesis_64(sbr->qmfs[ch], (const complex_t*)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]); +#ifndef SBR_LOW_POWER + QMF_IM(sbr->Xcodec[ch][j*32 + i]) = QMF_IM(sbr->Xcodec[ch][(j+32)*32 + i]); +#endif + } + } + 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]); +#ifndef SBR_LOW_POWER + QMF_IM(sbr->Xsbr[ch][j*64 + i]) = QMF_IM(sbr->Xsbr[ch][(j+32)*64 + i]); +#endif + } + } + } + + 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++; +} + +#endif -- cgit v1.2.3