Add missing const qualifiers to AltiVec function parameters where appropriate.
[mplayer/glamo.git] / libfaad2 / tns.c
blobe3bb729e837c74a21ad693684330b9fb23cbd450
1 /*
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2004 M. Bakker, Ahead Software 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.
19 ** Any non-GPL usage of this software or parts of this software is strictly
20 ** forbidden.
22 ** Commercial non-GPL licensing of this software is possible.
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
25 ** $Id: tns.c,v 1.35 2004/09/04 14:56:29 menno Exp $
26 **/
28 #include "common.h"
29 #include "structs.h"
31 #include "syntax.h"
32 #include "tns.h"
35 /* static function declarations */
36 static void tns_decode_coef(uint8_t order, uint8_t coef_res_bits, uint8_t coef_compress,
37 uint8_t *coef, real_t *a);
38 static void tns_ar_filter(real_t *spectrum, uint16_t size, int8_t inc, real_t *lpc,
39 uint8_t order);
40 static void tns_ma_filter(real_t *spectrum, uint16_t size, int8_t inc, real_t *lpc,
41 uint8_t order);
44 #ifdef _MSC_VER
45 #pragma warning(disable:4305)
46 #pragma warning(disable:4244)
47 #endif
48 static real_t tns_coef_0_3[] =
50 COEF_CONST(0.0), COEF_CONST(0.4338837391), COEF_CONST(0.7818314825), COEF_CONST(0.9749279122),
51 COEF_CONST(-0.9848077530), COEF_CONST(-0.8660254038), COEF_CONST(-0.6427876097), COEF_CONST(-0.3420201433),
52 COEF_CONST(-0.4338837391), COEF_CONST(-0.7818314825), COEF_CONST(-0.9749279122), COEF_CONST(-0.9749279122),
53 COEF_CONST(-0.9848077530), COEF_CONST(-0.8660254038), COEF_CONST(-0.6427876097), COEF_CONST(-0.3420201433)
55 static real_t tns_coef_0_4[] =
57 COEF_CONST(0.0), COEF_CONST(0.2079116908), COEF_CONST(0.4067366431), COEF_CONST(0.5877852523),
58 COEF_CONST(0.7431448255), COEF_CONST(0.8660254038), COEF_CONST(0.9510565163), COEF_CONST(0.9945218954),
59 COEF_CONST(-0.9957341763), COEF_CONST(-0.9618256432), COEF_CONST(-0.8951632914), COEF_CONST(-0.7980172273),
60 COEF_CONST(-0.6736956436), COEF_CONST(-0.5264321629), COEF_CONST(-0.3612416662), COEF_CONST(-0.1837495178)
62 static real_t tns_coef_1_3[] =
64 COEF_CONST(0.0), COEF_CONST(0.4338837391), COEF_CONST(-0.6427876097), COEF_CONST(-0.3420201433),
65 COEF_CONST(0.9749279122), COEF_CONST(0.7818314825), COEF_CONST(-0.6427876097), COEF_CONST(-0.3420201433),
66 COEF_CONST(-0.4338837391), COEF_CONST(-0.7818314825), COEF_CONST(-0.6427876097), COEF_CONST(-0.3420201433),
67 COEF_CONST(-0.7818314825), COEF_CONST(-0.4338837391), COEF_CONST(-0.6427876097), COEF_CONST(-0.3420201433)
69 static real_t tns_coef_1_4[] =
71 COEF_CONST(0.0), COEF_CONST(0.2079116908), COEF_CONST(0.4067366431), COEF_CONST(0.5877852523),
72 COEF_CONST(-0.6736956436), COEF_CONST(-0.5264321629), COEF_CONST(-0.3612416662), COEF_CONST(-0.1837495178),
73 COEF_CONST(0.9945218954), COEF_CONST(0.9510565163), COEF_CONST(0.8660254038), COEF_CONST(0.7431448255),
74 COEF_CONST(-0.6736956436), COEF_CONST(-0.5264321629), COEF_CONST(-0.3612416662), COEF_CONST(-0.1837495178)
78 /* TNS decoding for one channel and frame */
79 void tns_decode_frame(ic_stream *ics, tns_info *tns, uint8_t sr_index,
80 uint8_t object_type, real_t *spec, uint16_t frame_len)
82 uint8_t w, f, tns_order;
83 int8_t inc;
84 int16_t size;
85 uint16_t bottom, top, start, end;
86 uint16_t nshort = frame_len/8;
87 real_t lpc[TNS_MAX_ORDER+1];
89 if (!ics->tns_data_present)
90 return;
92 for (w = 0; w < ics->num_windows; w++)
94 bottom = ics->num_swb;
96 for (f = 0; f < tns->n_filt[w]; f++)
98 top = bottom;
99 bottom = max(top - tns->length[w][f], 0);
100 tns_order = min(tns->order[w][f], TNS_MAX_ORDER);
101 if (!tns_order)
102 continue;
104 tns_decode_coef(tns_order, tns->coef_res[w]+3,
105 tns->coef_compress[w][f], tns->coef[w][f], lpc);
107 start = min(bottom, max_tns_sfb(sr_index, object_type, (ics->window_sequence == EIGHT_SHORT_SEQUENCE)));
108 start = min(start, ics->max_sfb);
109 start = ics->swb_offset[start];
111 end = min(top, max_tns_sfb(sr_index, object_type, (ics->window_sequence == EIGHT_SHORT_SEQUENCE)));
112 end = min(end, ics->max_sfb);
113 end = ics->swb_offset[end];
115 size = end - start;
116 if (size <= 0)
117 continue;
119 if (tns->direction[w][f])
121 inc = -1;
122 start = end - 1;
123 } else {
124 inc = 1;
127 tns_ar_filter(&spec[(w*nshort)+start], size, inc, lpc, tns_order);
132 /* TNS encoding for one channel and frame */
133 void tns_encode_frame(ic_stream *ics, tns_info *tns, uint8_t sr_index,
134 uint8_t object_type, real_t *spec, uint16_t frame_len)
136 uint8_t w, f, tns_order;
137 int8_t inc;
138 int16_t size;
139 uint16_t bottom, top, start, end;
140 uint16_t nshort = frame_len/8;
141 real_t lpc[TNS_MAX_ORDER+1];
143 if (!ics->tns_data_present)
144 return;
146 for (w = 0; w < ics->num_windows; w++)
148 bottom = ics->num_swb;
150 for (f = 0; f < tns->n_filt[w]; f++)
152 top = bottom;
153 bottom = max(top - tns->length[w][f], 0);
154 tns_order = min(tns->order[w][f], TNS_MAX_ORDER);
155 if (!tns_order)
156 continue;
158 tns_decode_coef(tns_order, tns->coef_res[w]+3,
159 tns->coef_compress[w][f], tns->coef[w][f], lpc);
161 start = min(bottom, max_tns_sfb(sr_index, object_type, (ics->window_sequence == EIGHT_SHORT_SEQUENCE)));
162 start = min(start, ics->max_sfb);
163 start = ics->swb_offset[start];
165 end = min(top, max_tns_sfb(sr_index, object_type, (ics->window_sequence == EIGHT_SHORT_SEQUENCE)));
166 end = min(end, ics->max_sfb);
167 end = ics->swb_offset[end];
169 size = end - start;
170 if (size <= 0)
171 continue;
173 if (tns->direction[w][f])
175 inc = -1;
176 start = end - 1;
177 } else {
178 inc = 1;
181 tns_ma_filter(&spec[(w*nshort)+start], size, inc, lpc, tns_order);
186 /* Decoder transmitted coefficients for one TNS filter */
187 static void tns_decode_coef(uint8_t order, uint8_t coef_res_bits, uint8_t coef_compress,
188 uint8_t *coef, real_t *a)
190 uint8_t i, m;
191 real_t tmp2[TNS_MAX_ORDER+1], b[TNS_MAX_ORDER+1];
193 /* Conversion to signed integer */
194 for (i = 0; i < order; i++)
196 if (coef_compress == 0)
198 if (coef_res_bits == 3)
200 tmp2[i] = tns_coef_0_3[coef[i]];
201 } else {
202 tmp2[i] = tns_coef_0_4[coef[i]];
204 } else {
205 if (coef_res_bits == 3)
207 tmp2[i] = tns_coef_1_3[coef[i]];
208 } else {
209 tmp2[i] = tns_coef_1_4[coef[i]];
214 /* Conversion to LPC coefficients */
215 a[0] = COEF_CONST(1.0);
216 for (m = 1; m <= order; m++)
218 for (i = 1; i < m; i++) /* loop only while i<m */
219 b[i] = a[i] + MUL_C(tmp2[m-1], a[m-i]);
221 for (i = 1; i < m; i++) /* loop only while i<m */
222 a[i] = b[i];
224 a[m] = tmp2[m-1]; /* changed */
228 static void tns_ar_filter(real_t *spectrum, uint16_t size, int8_t inc, real_t *lpc,
229 uint8_t order)
232 - Simple all-pole filter of order "order" defined by
233 y(n) = x(n) - lpc[1]*y(n-1) - ... - lpc[order]*y(n-order)
234 - The state variables of the filter are initialized to zero every time
235 - The output data is written over the input data ("in-place operation")
236 - An input vector of "size" samples is processed and the index increment
237 to the next data sample is given by "inc"
240 uint8_t j;
241 uint16_t i;
242 real_t y;
243 /* state is stored as a double ringbuffer */
244 real_t state[2*TNS_MAX_ORDER] = {0};
245 int8_t state_index = 0;
247 for (i = 0; i < size; i++)
249 y = *spectrum;
251 for (j = 0; j < order; j++)
252 y -= MUL_C(state[state_index+j], lpc[j+1]);
254 /* double ringbuffer state */
255 state_index--;
256 if (state_index < 0)
257 state_index = order-1;
258 state[state_index] = state[state_index + order] = y;
260 *spectrum = y;
261 spectrum += inc;
263 //#define TNS_PRINT
264 #ifdef TNS_PRINT
265 //printf("%d\n", y);
266 printf("0x%.8X\n", y);
267 #endif
271 static void tns_ma_filter(real_t *spectrum, uint16_t size, int8_t inc, real_t *lpc,
272 uint8_t order)
275 - Simple all-zero filter of order "order" defined by
276 y(n) = x(n) + a(2)*x(n-1) + ... + a(order+1)*x(n-order)
277 - The state variables of the filter are initialized to zero every time
278 - The output data is written over the input data ("in-place operation")
279 - An input vector of "size" samples is processed and the index increment
280 to the next data sample is given by "inc"
283 uint8_t j;
284 uint16_t i;
285 real_t y;
286 /* state is stored as a double ringbuffer */
287 real_t state[2*TNS_MAX_ORDER] = {0};
288 int8_t state_index = 0;
290 for (i = 0; i < size; i++)
292 y = *spectrum;
294 for (j = 0; j < order; j++)
295 y += MUL_C(state[j], lpc[j+1]);
297 /* double ringbuffer state */
298 state_index--;
299 if (state_index < 0)
300 state_index = order-1;
301 state[state_index] = state[state_index + order] = *spectrum;
303 *spectrum = y;
304 spectrum += inc;