summaryrefslogtreecommitdiff
path: root/audio_codec/libfaad/lt_predict.c (plain)
blob: ed9d5eac7e6a6286c1b6a8b5e44251853bdbbbbf
1/*
2** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
4**
5** This program is free software; you can redistribute it and/or modify
6** it under the terms of the GNU General Public License as published by
7** the Free Software Foundation; either version 2 of the License, or
8** (at your option) any later version.
9**
10** This program is distributed in the hope that it will be useful,
11** but WITHOUT ANY WARRANTY; without even the implied warranty of
12** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13** GNU General Public License for more details.
14**
15** You should have received a copy of the GNU General Public License
16** along with this program; if not, write to the Free Software
17** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18**
19** Any non-GPL usage of this software or parts of this software is strictly
20** forbidden.
21**
22** The "appropriate copyright message" mentioned in section 2c of the GPLv2
23** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
24**
25** Commercial non-GPL licensing of this software is possible.
26** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
27**
28** $Id: lt_predict.c,v 1.27 2007/11/01 12:33:31 menno Exp $
29**/
30
31
32#include "common.h"
33#include "structs.h"
34
35#ifdef LTP_DEC
36
37#include "syntax.h"
38#include "lt_predict.h"
39#include "filtbank.h"
40#include "tns.h"
41
42
43/* static function declarations */
44static int16_t real_to_int16(real_t sig_in);
45
46
47/* check if the object type is an object type that can have LTP */
48uint8_t is_ltp_ot(uint8_t object_type)
49{
50#ifdef LTP_DEC
51 if ((object_type == LTP)
52#ifdef ERROR_RESILIENCE
53 || (object_type == ER_LTP)
54#endif
55#ifdef LD_DEC
56 || (object_type == LD)
57#endif
58 ) {
59 return 1;
60 }
61#endif
62
63 return 0;
64}
65
66ALIGN static const real_t codebook[8] = {
67 REAL_CONST(0.570829),
68 REAL_CONST(0.696616),
69 REAL_CONST(0.813004),
70 REAL_CONST(0.911304),
71 REAL_CONST(0.984900),
72 REAL_CONST(1.067894),
73 REAL_CONST(1.194601),
74 REAL_CONST(1.369533)
75};
76
77void lt_prediction(ic_stream *ics, ltp_info *ltp, real_t *spec,
78 int16_t *lt_pred_stat, fb_info *fb, uint8_t win_shape,
79 uint8_t win_shape_prev, uint8_t sr_index,
80 uint8_t object_type, uint16_t frame_len)
81{
82 uint8_t sfb;
83 uint16_t bin, i, num_samples;
84 ALIGN real_t x_est[2048];
85 ALIGN real_t X_est[2048];
86
87 if (ics->window_sequence != EIGHT_SHORT_SEQUENCE) {
88 if (ltp->data_present) {
89 num_samples = frame_len << 1;
90
91 for (i = 0; i < num_samples; i++) {
92 /* The extra lookback M (N/2 for LD, 0 for LTP) is handled
93 in the buffer updating */
94
95#if 0
96 x_est[i] = MUL_R_C(lt_pred_stat[num_samples + i - ltp->lag],
97 codebook[ltp->coef]);
98#else
99 /* lt_pred_stat is a 16 bit int, multiplied with the fixed point real
100 this gives a real for x_est
101 */
102 x_est[i] = (real_t)lt_pred_stat[num_samples + i - ltp->lag] * codebook[ltp->coef];
103#endif
104 }
105
106 filter_bank_ltp(fb, ics->window_sequence, win_shape, win_shape_prev,
107 x_est, X_est, object_type, frame_len);
108
109 tns_encode_frame(ics, &(ics->tns), sr_index, object_type, X_est,
110 frame_len);
111
112 for (sfb = 0; sfb < ltp->last_band; sfb++) {
113 if (ltp->long_used[sfb]) {
114 uint16_t low = ics->swb_offset[sfb];
115 uint16_t high = min(ics->swb_offset[sfb + 1], ics->swb_offset_max);
116
117 for (bin = low; bin < high; bin++) {
118 spec[bin] += X_est[bin];
119 }
120 }
121 }
122 }
123 }
124}
125
126#ifdef FIXED_POINT
127static INLINE int16_t real_to_int16(real_t sig_in)
128{
129 if (sig_in >= 0) {
130 sig_in += (1 << (REAL_BITS - 1));
131 if (sig_in >= REAL_CONST(32768)) {
132 return 32767;
133 }
134 } else {
135 sig_in += -(1 << (REAL_BITS - 1));
136 if (sig_in <= REAL_CONST(-32768)) {
137 return -32768;
138 }
139 }
140
141 return (sig_in >> REAL_BITS);
142}
143#else
144static INLINE int16_t real_to_int16(real_t sig_in)
145{
146 if (sig_in >= 0) {
147#ifndef HAS_LRINTF
148 sig_in += 0.5f;
149#endif
150 if (sig_in >= 32768.0f) {
151 return 32767;
152 }
153 } else {
154#ifndef HAS_LRINTF
155 sig_in += -0.5f;
156#endif
157 if (sig_in <= -32768.0f) {
158 return -32768;
159 }
160 }
161
162 return lrintf(sig_in);
163}
164#endif
165
166void lt_update_state(int16_t *lt_pred_stat, real_t *time, real_t *overlap,
167 uint16_t frame_len, uint8_t object_type)
168{
169 uint16_t i;
170
171 /*
172 * The reference point for index i and the content of the buffer
173 * lt_pred_stat are arranged so that lt_pred_stat(0 ... N/2 - 1) contains the
174 * last aliased half window from the IMDCT, and lt_pred_stat(N/2 ... N-1)
175 * is always all zeros. The rest of lt_pred_stat (i<0) contains the previous
176 * fully reconstructed time domain samples, i.e., output of the decoder.
177 *
178 * These values are shifted up by N*2 to avoid (i<0)
179 *
180 * For the LD object type an extra 512 samples lookback is accomodated here.
181 */
182#ifdef LD_DEC
183 if (object_type == LD) {
184 for (i = 0; i < frame_len; i++) {
185 lt_pred_stat[i] /* extra 512 */ = lt_pred_stat[i + frame_len];
186 lt_pred_stat[frame_len + i] = lt_pred_stat[i + (frame_len * 2)];
187 lt_pred_stat[(frame_len * 2) + i] = real_to_int16(time[i]);
188 lt_pred_stat[(frame_len * 3) + i] = real_to_int16(overlap[i]);
189 }
190 } else {
191#endif
192 for (i = 0; i < frame_len; i++) {
193 lt_pred_stat[i] = lt_pred_stat[i + frame_len];
194 lt_pred_stat[frame_len + i] = real_to_int16(time[i]);
195 lt_pred_stat[(frame_len * 2) + i] = real_to_int16(overlap[i]);
196#if 0 /* set to zero once upon initialisation */
197 lt_pred_stat[(frame_len * 3) + i] = 0;
198#endif
199 }
200#ifdef LD_DEC
201 }
202#endif
203}
204
205#endif
206
generated by cgit at 2024-05-18 19:14:52 (GMT)