2 * 11/19/04 1.0 moved to LGPL.
\r
4 * 04/01/00 Fixes for running under build 23xx Microsoft JVM. mdm.
\r
6 * 19/12/99 Performance improvements to compute_pcm_samples().
\r
7 * Mat McGowan. mdm@techie.com.
\r
9 * 16/02/99 Java Conversion by E.B , javalayer@javazoom.net
\r
11 * @(#) synthesis_filter.h 1.8, last edit: 6/15/94 16:52:00
\r
12 * @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
\r
13 * @(#) Berlin University of Technology
\r
15 *-----------------------------------------------------------------------
\r
16 * This program is free software; you can redistribute it and/or modify
\r
17 * it under the terms of the GNU Library General Public License as published
\r
18 * by the Free Software Foundation; either version 2 of the License, or
\r
19 * (at your option) any later version.
\r
21 * This program is distributed in the hope that it will be useful,
\r
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
24 * GNU Library General Public License for more details.
\r
26 * You should have received a copy of the GNU Library General Public
\r
27 * License along with this program; if not, write to the Free Software
\r
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
\r
29 *----------------------------------------------------------------------
\r
33 * A class for the synthesis filter bank. This class does a fast downsampling
\r
34 * from 32, 44.1 or 48 kHz to 8 kHz, if ULAW is defined. Frequencies above 4 kHz
\r
35 * are removed by ignoring higher subbands.
\r
37 @LATTICE("OUT<V1,V1<V,V<NEWV,NEWV<SAMPLE,SAMPLE<EQ,EQ<IDX,NEWV*,IDX*")
\r
38 @METHODDEFAULT("OUT<THIS,THIS<C,C<IN,C*,THISLOC=THIS,GLOBALLOC=THIS")
\r
39 final class SynthesisFilter {
\r
42 private int vidx = 1;
\r
47 // private float[] actual_v; // v1 or v2
\r
49 private int actual_write_pos; // 0-15
\r
51 private float[] samples; // 32 new subband samples
\r
53 private int channel;
\r
55 private float scalefactor;
\r
60 * Quality value for controlling CPU usage/quality tradeoff.
\r
63 * private int quality;
\r
65 * private int v_inc;
\r
69 * public static final int HIGH_QUALITY = 1; public static final int
\r
70 * MEDIUM_QUALITY = 2; public static final int LOW_QUALITY = 4;
\r
74 * Contructor. The scalefactor scales the calculated float pcm samples to
\r
75 * short values (raw pcm samples are in [-1.0, 1.0], if no violations occur).
\r
77 public SynthesisFilter(int channelnumber, float factor, float[] eq0) {
\r
79 d16 = splitArray(d, 16);
\r
81 v1 = new float[512];
\r
82 v2 = new float[512];
\r
83 samples = new float[32];
\r
84 channel = channelnumber;
\r
85 scalefactor = factor;
\r
87 // setQuality(HIGH_QUALITY);
\r
91 for (int i = 0; i < 32; i++)
\r
94 if (eq.length < 32) {
\r
95 throw new IllegalArgumentException("eq0");
\r
100 for (int p = 0; p < 512; p++)
\r
101 v1[p] = v2[p] = 0.0f;
\r
103 for (int p2 = 0; p2 < 32; p2++)
\r
104 samples[p2] = 0.0f;
\r
107 actual_write_pos = 15;
\r
112 * private void setQuality(int quality0) { switch (quality0) { case
\r
113 * HIGH_QUALITY: case MEDIUM_QUALITY: case LOW_QUALITY: v_inc = 16 * quality0;
\r
114 * quality = quality0; break; default : throw new
\r
115 * IllegalArgumentException("Unknown quality value"); } }
\r
117 * public int getQuality() { return quality; }
\r
123 public void input_sample(@LOC("IN") float sample, @LOC("IN") int subbandnumber) {
\r
124 samples[subbandnumber] = eq[subbandnumber] * sample;
\r
127 public void input_samples(@LOC("IN") float[] s) {
\r
128 for (@LOC("C") int i = 31; i >= 0; i--) {
\r
129 samples[i] = s[i] * eq[i];
\r
133 private void compute_new_v2_v1() {
\r
135 @LOC("THIS,SynthesisFilter.NEWV") float new_v0 = 0.0f;
\r
136 @LOC("THIS,SynthesisFilter.NEWV") float new_v1 = 0.0f;
\r
137 @LOC("THIS,SynthesisFilter.NEWV") float new_v2 = 0.0f;
\r
138 @LOC("THIS,SynthesisFilter.NEWV") float new_v3 = 0.0f;
\r
139 @LOC("THIS,SynthesisFilter.NEWV") float new_v4 = 0.0f;
\r
140 @LOC("THIS,SynthesisFilter.NEWV") float new_v5 = 0.0f;
\r
141 @LOC("THIS,SynthesisFilter.NEWV") float new_v6 = 0.0f;
\r
142 @LOC("THIS,SynthesisFilter.NEWV") float new_v7 = 0.0f;
\r
143 @LOC("THIS,SynthesisFilter.NEWV") float new_v8 = 0.0f;
\r
144 @LOC("THIS,SynthesisFilter.NEWV") float new_v9 = 0.0f;
\r
145 @LOC("THIS,SynthesisFilter.NEWV") float new_v10 = 0.0f;
\r
146 @LOC("THIS,SynthesisFilter.NEWV") float new_v11 = 0.0f;
\r
147 @LOC("THIS,SynthesisFilter.NEWV") float new_v12 = 0.0f;
\r
148 @LOC("THIS,SynthesisFilter.NEWV") float new_v13 = 0.0f;
\r
149 @LOC("THIS,SynthesisFilter.NEWV") float new_v14 = 0.0f;
\r
150 @LOC("THIS,SynthesisFilter.NEWV") float new_v15 = 0.0f;
\r
151 @LOC("THIS,SynthesisFilter.NEWV") float new_v16 = 0.0f;
\r
152 @LOC("THIS,SynthesisFilter.NEWV") float new_v17 = 0.0f;
\r
153 @LOC("THIS,SynthesisFilter.NEWV") float new_v18 = 0.0f;
\r
154 @LOC("THIS,SynthesisFilter.NEWV") float new_v19 = 0.0f;
\r
155 @LOC("THIS,SynthesisFilter.NEWV") float new_v20 = 0.0f;
\r
156 @LOC("THIS,SynthesisFilter.NEWV") float new_v21 = 0.0f;
\r
157 @LOC("THIS,SynthesisFilter.NEWV") float new_v22 = 0.0f;
\r
158 @LOC("THIS,SynthesisFilter.NEWV") float new_v23 = 0.0f;
\r
159 @LOC("THIS,SynthesisFilter.NEWV") float new_v24 = 0.0f;
\r
160 @LOC("THIS,SynthesisFilter.NEWV") float new_v25 = 0.0f;
\r
161 @LOC("THIS,SynthesisFilter.NEWV") float new_v26 = 0.0f;
\r
162 @LOC("THIS,SynthesisFilter.NEWV") float new_v27 = 0.0f;
\r
163 @LOC("THIS,SynthesisFilter.NEWV") float new_v28 = 0.0f;
\r
164 @LOC("THIS,SynthesisFilter.NEWV") float new_v29 = 0.0f;
\r
165 @LOC("THIS,SynthesisFilter.NEWV") float new_v30 = 0.0f;
\r
166 @LOC("THIS,SynthesisFilter.NEWV") float new_v31 = 0.0f;
\r
168 // float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure
\r
169 // 3-A.2 in ISO DIS 11172-3
\r
170 // float[] p = new float[16];
\r
171 // float[] pp = new float[16];
\r
173 // float[] s = samples;
\r
175 @LOC("THIS,SynthesisFilter.NEWV") float s0 = samples[0];
\r
176 @LOC("THIS,SynthesisFilter.NEWV") float s1 = samples[1];
\r
177 @LOC("THIS,SynthesisFilter.NEWV") float s2 = samples[2];
\r
178 @LOC("THIS,SynthesisFilter.NEWV") float s3 = samples[3];
\r
179 @LOC("THIS,SynthesisFilter.NEWV") float s4 = samples[4];
\r
180 @LOC("THIS,SynthesisFilter.NEWV") float s5 = samples[5];
\r
181 @LOC("THIS,SynthesisFilter.NEWV") float s6 = samples[6];
\r
182 @LOC("THIS,SynthesisFilter.NEWV") float s7 = samples[7];
\r
183 @LOC("THIS,SynthesisFilter.NEWV") float s8 = samples[8];
\r
184 @LOC("THIS,SynthesisFilter.NEWV") float s9 = samples[9];
\r
185 @LOC("THIS,SynthesisFilter.NEWV") float s10 = samples[10];
\r
186 @LOC("THIS,SynthesisFilter.NEWV") float s11 = samples[11];
\r
187 @LOC("THIS,SynthesisFilter.NEWV") float s12 = samples[12];
\r
188 @LOC("THIS,SynthesisFilter.NEWV") float s13 = samples[13];
\r
189 @LOC("THIS,SynthesisFilter.NEWV") float s14 = samples[14];
\r
190 @LOC("THIS,SynthesisFilter.NEWV") float s15 = samples[15];
\r
191 @LOC("THIS,SynthesisFilter.NEWV") float s16 = samples[16];
\r
192 @LOC("THIS,SynthesisFilter.NEWV") float s17 = samples[17];
\r
193 @LOC("THIS,SynthesisFilter.NEWV") float s18 = samples[18];
\r
194 @LOC("THIS,SynthesisFilter.NEWV") float s19 = samples[19];
\r
195 @LOC("THIS,SynthesisFilter.NEWV") float s20 = samples[20];
\r
196 @LOC("THIS,SynthesisFilter.NEWV") float s21 = samples[21];
\r
197 @LOC("THIS,SynthesisFilter.NEWV") float s22 = samples[22];
\r
198 @LOC("THIS,SynthesisFilter.NEWV") float s23 = samples[23];
\r
199 @LOC("THIS,SynthesisFilter.NEWV") float s24 = samples[24];
\r
200 @LOC("THIS,SynthesisFilter.NEWV") float s25 = samples[25];
\r
201 @LOC("THIS,SynthesisFilter.NEWV") float s26 = samples[26];
\r
202 @LOC("THIS,SynthesisFilter.NEWV") float s27 = samples[27];
\r
203 @LOC("THIS,SynthesisFilter.NEWV") float s28 = samples[28];
\r
204 @LOC("THIS,SynthesisFilter.NEWV") float s29 = samples[29];
\r
205 @LOC("THIS,SynthesisFilter.NEWV") float s30 = samples[30];
\r
206 @LOC("THIS,SynthesisFilter.NEWV") float s31 = samples[31];
\r
208 @LOC("THIS,SynthesisFilter.NEWV") float p0 = s0 + s31;
\r
209 @LOC("THIS,SynthesisFilter.NEWV") float p1 = s1 + s30;
\r
210 @LOC("THIS,SynthesisFilter.NEWV") float p2 = s2 + s29;
\r
211 @LOC("THIS,SynthesisFilter.NEWV") float p3 = s3 + s28;
\r
212 @LOC("THIS,SynthesisFilter.NEWV") float p4 = s4 + s27;
\r
213 @LOC("THIS,SynthesisFilter.NEWV") float p5 = s5 + s26;
\r
214 @LOC("THIS,SynthesisFilter.NEWV") float p6 = s6 + s25;
\r
215 @LOC("THIS,SynthesisFilter.NEWV") float p7 = s7 + s24;
\r
216 @LOC("THIS,SynthesisFilter.NEWV") float p8 = s8 + s23;
\r
217 @LOC("THIS,SynthesisFilter.NEWV") float p9 = s9 + s22;
\r
218 @LOC("THIS,SynthesisFilter.NEWV") float p10 = s10 + s21;
\r
219 @LOC("THIS,SynthesisFilter.NEWV") float p11 = s11 + s20;
\r
220 @LOC("THIS,SynthesisFilter.NEWV") float p12 = s12 + s19;
\r
221 @LOC("THIS,SynthesisFilter.NEWV") float p13 = s13 + s18;
\r
222 @LOC("THIS,SynthesisFilter.NEWV") float p14 = s14 + s17;
\r
223 @LOC("THIS,SynthesisFilter.NEWV") float p15 = s15 + s16;
\r
225 @LOC("THIS,SynthesisFilter.NEWV") float pp0 = p0 + p15;
\r
226 @LOC("THIS,SynthesisFilter.NEWV") float pp1 = p1 + p14;
\r
227 @LOC("THIS,SynthesisFilter.NEWV") float pp2 = p2 + p13;
\r
228 @LOC("THIS,SynthesisFilter.NEWV") float pp3 = p3 + p12;
\r
229 @LOC("THIS,SynthesisFilter.NEWV") float pp4 = p4 + p11;
\r
230 @LOC("THIS,SynthesisFilter.NEWV") float pp5 = p5 + p10;
\r
231 @LOC("THIS,SynthesisFilter.NEWV") float pp6 = p6 + p9;
\r
232 @LOC("THIS,SynthesisFilter.NEWV") float pp7 = p7 + p8;
\r
233 @LOC("THIS,SynthesisFilter.NEWV") float pp8 = (p0 - p15) * cos1_32;
\r
234 @LOC("THIS,SynthesisFilter.NEWV") float pp9 = (p1 - p14) * cos3_32;
\r
235 @LOC("THIS,SynthesisFilter.NEWV") float pp10 = (p2 - p13) * cos5_32;
\r
236 @LOC("THIS,SynthesisFilter.NEWV") float pp11 = (p3 - p12) * cos7_32;
\r
237 @LOC("THIS,SynthesisFilter.NEWV") float pp12 = (p4 - p11) * cos9_32;
\r
238 @LOC("THIS,SynthesisFilter.NEWV") float pp13 = (p5 - p10) * cos11_32;
\r
239 @LOC("THIS,SynthesisFilter.NEWV") float pp14 = (p6 - p9) * cos13_32;
\r
240 @LOC("THIS,SynthesisFilter.NEWV") float pp15 = (p7 - p8) * cos15_32;
\r
246 p4 = (pp0 - pp7) * cos1_16;
\r
247 p5 = (pp1 - pp6) * cos3_16;
\r
248 p6 = (pp2 - pp5) * cos5_16;
\r
249 p7 = (pp3 - pp4) * cos7_16;
\r
254 p12 = (pp8 - pp15) * cos1_16;
\r
255 p13 = (pp9 - pp14) * cos3_16;
\r
256 p14 = (pp10 - pp13) * cos5_16;
\r
257 p15 = (pp11 - pp12) * cos7_16;
\r
261 pp2 = (p0 - p3) * cos1_8;
\r
262 pp3 = (p1 - p2) * cos3_8;
\r
265 pp6 = (p4 - p7) * cos1_8;
\r
266 pp7 = (p5 - p6) * cos3_8;
\r
269 pp10 = (p8 - p11) * cos1_8;
\r
270 pp11 = (p9 - p10) * cos3_8;
\r
273 pp14 = (p12 - p15) * cos1_8;
\r
274 pp15 = (p13 - p14) * cos3_8;
\r
277 p1 = (pp0 - pp1) * cos1_4;
\r
279 p3 = (pp2 - pp3) * cos1_4;
\r
281 p5 = (pp4 - pp5) * cos1_4;
\r
283 p7 = (pp6 - pp7) * cos1_4;
\r
285 p9 = (pp8 - pp9) * cos1_4;
\r
287 p11 = (pp10 - pp11) * cos1_4;
\r
289 p13 = (pp12 - pp13) * cos1_4;
\r
291 p15 = (pp14 - pp15) * cos1_4;
\r
293 // this is pretty insane coding
\r
294 @LOC("THIS,SynthesisFilter.NEWV") float tmp1;
\r
295 new_v19/* 36-17 */= -(new_v4 = (new_v12 = p7) + p5) - p6;
\r
296 new_v27/* 44-17 */= -p6 - p7 - p4;
\r
297 new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13;
\r
298 new_v17/* 34-17 */= -(new_v2 = p15 + p13 + p9) - p14;
\r
299 new_v21/* 38-17 */= (tmp1 = -p14 - p15 - p10 - p11) - p13;
\r
300 new_v29/* 46-17 */= -p14 - p15 - p12 - p8;
\r
301 new_v25/* 42-17 */= tmp1 - p12;
\r
302 new_v31/* 48-17 */= -p0;
\r
304 new_v23/* 40-17 */= -(new_v8 = p3) - p2;
\r
306 p0 = (s0 - s31) * cos1_64;
\r
307 p1 = (s1 - s30) * cos3_64;
\r
308 p2 = (s2 - s29) * cos5_64;
\r
309 p3 = (s3 - s28) * cos7_64;
\r
310 p4 = (s4 - s27) * cos9_64;
\r
311 p5 = (s5 - s26) * cos11_64;
\r
312 p6 = (s6 - s25) * cos13_64;
\r
313 p7 = (s7 - s24) * cos15_64;
\r
314 p8 = (s8 - s23) * cos17_64;
\r
315 p9 = (s9 - s22) * cos19_64;
\r
316 p10 = (s10 - s21) * cos21_64;
\r
317 p11 = (s11 - s20) * cos23_64;
\r
318 p12 = (s12 - s19) * cos25_64;
\r
319 p13 = (s13 - s18) * cos27_64;
\r
320 p14 = (s14 - s17) * cos29_64;
\r
321 p15 = (s15 - s16) * cos31_64;
\r
331 pp8 = (p0 - p15) * cos1_32;
\r
332 pp9 = (p1 - p14) * cos3_32;
\r
333 pp10 = (p2 - p13) * cos5_32;
\r
334 pp11 = (p3 - p12) * cos7_32;
\r
335 pp12 = (p4 - p11) * cos9_32;
\r
336 pp13 = (p5 - p10) * cos11_32;
\r
337 pp14 = (p6 - p9) * cos13_32;
\r
338 pp15 = (p7 - p8) * cos15_32;
\r
344 p4 = (pp0 - pp7) * cos1_16;
\r
345 p5 = (pp1 - pp6) * cos3_16;
\r
346 p6 = (pp2 - pp5) * cos5_16;
\r
347 p7 = (pp3 - pp4) * cos7_16;
\r
352 p12 = (pp8 - pp15) * cos1_16;
\r
353 p13 = (pp9 - pp14) * cos3_16;
\r
354 p14 = (pp10 - pp13) * cos5_16;
\r
355 p15 = (pp11 - pp12) * cos7_16;
\r
359 pp2 = (p0 - p3) * cos1_8;
\r
360 pp3 = (p1 - p2) * cos3_8;
\r
363 pp6 = (p4 - p7) * cos1_8;
\r
364 pp7 = (p5 - p6) * cos3_8;
\r
367 pp10 = (p8 - p11) * cos1_8;
\r
368 pp11 = (p9 - p10) * cos3_8;
\r
371 pp14 = (p12 - p15) * cos1_8;
\r
372 pp15 = (p13 - p14) * cos3_8;
\r
375 p1 = (pp0 - pp1) * cos1_4;
\r
377 p3 = (pp2 - pp3) * cos1_4;
\r
379 p5 = (pp4 - pp5) * cos1_4;
\r
381 p7 = (pp6 - pp7) * cos1_4;
\r
383 p9 = (pp8 - pp9) * cos1_4;
\r
385 p11 = (pp10 - pp11) * cos1_4;
\r
387 p13 = (pp12 - pp13) * cos1_4;
\r
389 p15 = (pp14 - pp15) * cos1_4;
\r
391 // manually doing something that a compiler should handle sucks
\r
392 // coding like this is hard to read
\r
393 @LOC("THIS,SynthesisFilter.NEWV") float tmp2;
\r
394 new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11) + p5 + p13;
\r
395 new_v7 = (new_v9 = p15 + p11 + p3) + p13;
\r
396 new_v16/* 33-17 */= -(new_v1 = (tmp1 = p13 + p15 + p9) + p1) - p14;
\r
397 new_v18/* 35-17 */= -(new_v3 = tmp1 + p5 + p7) - p6 - p14;
\r
399 new_v22/* 39-17 */= (tmp1 = -p10 - p11 - p14 - p15) - p13 - p2 - p3;
\r
400 new_v20/* 37-17 */= tmp1 - p13 - p5 - p6 - p7;
\r
401 new_v24/* 41-17 */= tmp1 - p12 - p2 - p3;
\r
402 new_v26/* 43-17 */= tmp1 - p12 - (tmp2 = p4 + p6 + p7);
\r
403 new_v30/* 47-17 */= (tmp1 = -p8 - p12 - p14 - p15) - p0;
\r
404 new_v28/* 45-17 */= tmp1 - tmp2;
\r
406 // insert V[0-15] (== new_v[0-15]) into actual v:
\r
407 // float[] x2 = actual_v + actual_write_pos;
\r
408 // float dest[] = actual_v; v2
\r
410 @LOC("THIS,SynthesisFilter.NEWV") int pos = actual_write_pos;
\r
412 v2[0 + pos] = new_v0;
\r
413 v2[16 + pos] = new_v1;
\r
414 v2[32 + pos] = new_v2;
\r
415 v2[48 + pos] = new_v3;
\r
416 v2[64 + pos] = new_v4;
\r
417 v2[80 + pos] = new_v5;
\r
418 v2[96 + pos] = new_v6;
\r
419 v2[112 + pos] = new_v7;
\r
420 v2[128 + pos] = new_v8;
\r
421 v2[144 + pos] = new_v9;
\r
422 v2[160 + pos] = new_v10;
\r
423 v2[176 + pos] = new_v11;
\r
424 v2[192 + pos] = new_v12;
\r
425 v2[208 + pos] = new_v13;
\r
426 v2[224 + pos] = new_v14;
\r
427 v2[240 + pos] = new_v15;
\r
429 // V[16] is always 0.0:
\r
430 v2[256 + pos] = 0.0f;
\r
432 // insert V[17-31] (== -new_v[15-1]) into actual v:
\r
433 v2[272 + pos] = -new_v15;
\r
434 v2[288 + pos] = -new_v14;
\r
435 v2[304 + pos] = -new_v13;
\r
436 v2[320 + pos] = -new_v12;
\r
437 v2[336 + pos] = -new_v11;
\r
438 v2[352 + pos] = -new_v10;
\r
439 v2[368 + pos] = -new_v9;
\r
440 v2[384 + pos] = -new_v8;
\r
441 v2[400 + pos] = -new_v7;
\r
442 v2[416 + pos] = -new_v6;
\r
443 v2[432 + pos] = -new_v5;
\r
444 v2[448 + pos] = -new_v4;
\r
445 v2[464 + pos] = -new_v3;
\r
446 v2[480 + pos] = -new_v2;
\r
447 v2[496 + pos] = -new_v1;
\r
449 // insert V[32] (== -new_v[0]) into other v:
\r
450 // dest = (actual_v == v1) ? v2 : v1;
\r
452 v1[0 + pos] = -new_v0;
\r
453 // insert V[33-48] (== new_v[16-31]) into other v:
\r
454 v1[16 + pos] = new_v16;
\r
455 v1[32 + pos] = new_v17;
\r
456 v1[48 + pos] = new_v18;
\r
457 v1[64 + pos] = new_v19;
\r
458 v1[80 + pos] = new_v20;
\r
459 v1[96 + pos] = new_v21;
\r
460 v1[112 + pos] = new_v22;
\r
461 v1[128 + pos] = new_v23;
\r
462 v1[144 + pos] = new_v24;
\r
463 v1[160 + pos] = new_v25;
\r
464 v1[176 + pos] = new_v26;
\r
465 v1[192 + pos] = new_v27;
\r
466 v1[208 + pos] = new_v28;
\r
467 v1[224 + pos] = new_v29;
\r
468 v1[240 + pos] = new_v30;
\r
469 v1[256 + pos] = new_v31;
\r
471 // insert V[49-63] (== new_v[30-16]) into other v:
\r
472 v1[272 + pos] = new_v30;
\r
473 v1[288 + pos] = new_v29;
\r
474 v1[304 + pos] = new_v28;
\r
475 v1[320 + pos] = new_v27;
\r
476 v1[336 + pos] = new_v26;
\r
477 v1[352 + pos] = new_v25;
\r
478 v1[368 + pos] = new_v24;
\r
479 v1[384 + pos] = new_v23;
\r
480 v1[400 + pos] = new_v22;
\r
481 v1[416 + pos] = new_v21;
\r
482 v1[432 + pos] = new_v20;
\r
483 v1[448 + pos] = new_v19;
\r
484 v1[464 + pos] = new_v18;
\r
485 v1[480 + pos] = new_v17;
\r
486 v1[496 + pos] = new_v16;
\r
489 private void compute_new_v1_v2() {
\r
491 @LOC("THIS,SynthesisFilter.NEWV") float new_v0 = 0.0f;
\r
492 @LOC("THIS,SynthesisFilter.NEWV") float new_v1 = 0.0f;
\r
493 @LOC("THIS,SynthesisFilter.NEWV") float new_v2 = 0.0f;
\r
494 @LOC("THIS,SynthesisFilter.NEWV") float new_v3 = 0.0f;
\r
495 @LOC("THIS,SynthesisFilter.NEWV") float new_v4 = 0.0f;
\r
496 @LOC("THIS,SynthesisFilter.NEWV") float new_v5 = 0.0f;
\r
497 @LOC("THIS,SynthesisFilter.NEWV") float new_v6 = 0.0f;
\r
498 @LOC("THIS,SynthesisFilter.NEWV") float new_v7 = 0.0f;
\r
499 @LOC("THIS,SynthesisFilter.NEWV") float new_v8 = 0.0f;
\r
500 @LOC("THIS,SynthesisFilter.NEWV") float new_v9 = 0.0f;
\r
501 @LOC("THIS,SynthesisFilter.NEWV") float new_v10 = 0.0f;
\r
502 @LOC("THIS,SynthesisFilter.NEWV") float new_v11 = 0.0f;
\r
503 @LOC("THIS,SynthesisFilter.NEWV") float new_v12 = 0.0f;
\r
504 @LOC("THIS,SynthesisFilter.NEWV") float new_v13 = 0.0f;
\r
505 @LOC("THIS,SynthesisFilter.NEWV") float new_v14 = 0.0f;
\r
506 @LOC("THIS,SynthesisFilter.NEWV") float new_v15 = 0.0f;
\r
507 @LOC("THIS,SynthesisFilter.NEWV") float new_v16 = 0.0f;
\r
508 @LOC("THIS,SynthesisFilter.NEWV") float new_v17 = 0.0f;
\r
509 @LOC("THIS,SynthesisFilter.NEWV") float new_v18 = 0.0f;
\r
510 @LOC("THIS,SynthesisFilter.NEWV") float new_v19 = 0.0f;
\r
511 @LOC("THIS,SynthesisFilter.NEWV") float new_v20 = 0.0f;
\r
512 @LOC("THIS,SynthesisFilter.NEWV") float new_v21 = 0.0f;
\r
513 @LOC("THIS,SynthesisFilter.NEWV") float new_v22 = 0.0f;
\r
514 @LOC("THIS,SynthesisFilter.NEWV") float new_v23 = 0.0f;
\r
515 @LOC("THIS,SynthesisFilter.NEWV") float new_v24 = 0.0f;
\r
516 @LOC("THIS,SynthesisFilter.NEWV") float new_v25 = 0.0f;
\r
517 @LOC("THIS,SynthesisFilter.NEWV") float new_v26 = 0.0f;
\r
518 @LOC("THIS,SynthesisFilter.NEWV") float new_v27 = 0.0f;
\r
519 @LOC("THIS,SynthesisFilter.NEWV") float new_v28 = 0.0f;
\r
520 @LOC("THIS,SynthesisFilter.NEWV") float new_v29 = 0.0f;
\r
521 @LOC("THIS,SynthesisFilter.NEWV") float new_v30 = 0.0f;
\r
522 @LOC("THIS,SynthesisFilter.NEWV") float new_v31 = 0.0f;
\r
524 // float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure
\r
525 // 3-A.2 in ISO DIS 11172-3
\r
526 // float[] p = new float[16];
\r
527 // float[] pp = new float[16];
\r
529 // float[] s = samples;
\r
531 @LOC("THIS,SynthesisFilter.NEWV") float s0 = samples[0];
\r
532 @LOC("THIS,SynthesisFilter.NEWV") float s1 = samples[1];
\r
533 @LOC("THIS,SynthesisFilter.NEWV") float s2 = samples[2];
\r
534 @LOC("THIS,SynthesisFilter.NEWV") float s3 = samples[3];
\r
535 @LOC("THIS,SynthesisFilter.NEWV") float s4 = samples[4];
\r
536 @LOC("THIS,SynthesisFilter.NEWV") float s5 = samples[5];
\r
537 @LOC("THIS,SynthesisFilter.NEWV") float s6 = samples[6];
\r
538 @LOC("THIS,SynthesisFilter.NEWV") float s7 = samples[7];
\r
539 @LOC("THIS,SynthesisFilter.NEWV") float s8 = samples[8];
\r
540 @LOC("THIS,SynthesisFilter.NEWV") float s9 = samples[9];
\r
541 @LOC("THIS,SynthesisFilter.NEWV") float s10 = samples[10];
\r
542 @LOC("THIS,SynthesisFilter.NEWV") float s11 = samples[11];
\r
543 @LOC("THIS,SynthesisFilter.NEWV") float s12 = samples[12];
\r
544 @LOC("THIS,SynthesisFilter.NEWV") float s13 = samples[13];
\r
545 @LOC("THIS,SynthesisFilter.NEWV") float s14 = samples[14];
\r
546 @LOC("THIS,SynthesisFilter.NEWV") float s15 = samples[15];
\r
547 @LOC("THIS,SynthesisFilter.NEWV") float s16 = samples[16];
\r
548 @LOC("THIS,SynthesisFilter.NEWV") float s17 = samples[17];
\r
549 @LOC("THIS,SynthesisFilter.NEWV") float s18 = samples[18];
\r
550 @LOC("THIS,SynthesisFilter.NEWV") float s19 = samples[19];
\r
551 @LOC("THIS,SynthesisFilter.NEWV") float s20 = samples[20];
\r
552 @LOC("THIS,SynthesisFilter.NEWV") float s21 = samples[21];
\r
553 @LOC("THIS,SynthesisFilter.NEWV") float s22 = samples[22];
\r
554 @LOC("THIS,SynthesisFilter.NEWV") float s23 = samples[23];
\r
555 @LOC("THIS,SynthesisFilter.NEWV") float s24 = samples[24];
\r
556 @LOC("THIS,SynthesisFilter.NEWV") float s25 = samples[25];
\r
557 @LOC("THIS,SynthesisFilter.NEWV") float s26 = samples[26];
\r
558 @LOC("THIS,SynthesisFilter.NEWV") float s27 = samples[27];
\r
559 @LOC("THIS,SynthesisFilter.NEWV") float s28 = samples[28];
\r
560 @LOC("THIS,SynthesisFilter.NEWV") float s29 = samples[29];
\r
561 @LOC("THIS,SynthesisFilter.NEWV") float s30 = samples[30];
\r
562 @LOC("THIS,SynthesisFilter.NEWV") float s31 = samples[31];
\r
564 @LOC("THIS,SynthesisFilter.NEWV") float p0 = s0 + s31;
\r
565 @LOC("THIS,SynthesisFilter.NEWV") float p1 = s1 + s30;
\r
566 @LOC("THIS,SynthesisFilter.NEWV") float p2 = s2 + s29;
\r
567 @LOC("THIS,SynthesisFilter.NEWV") float p3 = s3 + s28;
\r
568 @LOC("THIS,SynthesisFilter.NEWV") float p4 = s4 + s27;
\r
569 @LOC("THIS,SynthesisFilter.NEWV") float p5 = s5 + s26;
\r
570 @LOC("THIS,SynthesisFilter.NEWV") float p6 = s6 + s25;
\r
571 @LOC("THIS,SynthesisFilter.NEWV") float p7 = s7 + s24;
\r
572 @LOC("THIS,SynthesisFilter.NEWV") float p8 = s8 + s23;
\r
573 @LOC("THIS,SynthesisFilter.NEWV") float p9 = s9 + s22;
\r
574 @LOC("THIS,SynthesisFilter.NEWV") float p10 = s10 + s21;
\r
575 @LOC("THIS,SynthesisFilter.NEWV") float p11 = s11 + s20;
\r
576 @LOC("THIS,SynthesisFilter.NEWV") float p12 = s12 + s19;
\r
577 @LOC("THIS,SynthesisFilter.NEWV") float p13 = s13 + s18;
\r
578 @LOC("THIS,SynthesisFilter.NEWV") float p14 = s14 + s17;
\r
579 @LOC("THIS,SynthesisFilter.NEWV") float p15 = s15 + s16;
\r
581 @LOC("THIS,SynthesisFilter.NEWV") float pp0 = p0 + p15;
\r
582 @LOC("THIS,SynthesisFilter.NEWV") float pp1 = p1 + p14;
\r
583 @LOC("THIS,SynthesisFilter.NEWV") float pp2 = p2 + p13;
\r
584 @LOC("THIS,SynthesisFilter.NEWV") float pp3 = p3 + p12;
\r
585 @LOC("THIS,SynthesisFilter.NEWV") float pp4 = p4 + p11;
\r
586 @LOC("THIS,SynthesisFilter.NEWV") float pp5 = p5 + p10;
\r
587 @LOC("THIS,SynthesisFilter.NEWV") float pp6 = p6 + p9;
\r
588 @LOC("THIS,SynthesisFilter.NEWV") float pp7 = p7 + p8;
\r
589 @LOC("THIS,SynthesisFilter.NEWV") float pp8 = (p0 - p15) * cos1_32;
\r
590 @LOC("THIS,SynthesisFilter.NEWV") float pp9 = (p1 - p14) * cos3_32;
\r
591 @LOC("THIS,SynthesisFilter.NEWV") float pp10 = (p2 - p13) * cos5_32;
\r
592 @LOC("THIS,SynthesisFilter.NEWV") float pp11 = (p3 - p12) * cos7_32;
\r
593 @LOC("THIS,SynthesisFilter.NEWV") float pp12 = (p4 - p11) * cos9_32;
\r
594 @LOC("THIS,SynthesisFilter.NEWV") float pp13 = (p5 - p10) * cos11_32;
\r
595 @LOC("THIS,SynthesisFilter.NEWV") float pp14 = (p6 - p9) * cos13_32;
\r
596 @LOC("THIS,SynthesisFilter.NEWV") float pp15 = (p7 - p8) * cos15_32;
\r
602 p4 = (pp0 - pp7) * cos1_16;
\r
603 p5 = (pp1 - pp6) * cos3_16;
\r
604 p6 = (pp2 - pp5) * cos5_16;
\r
605 p7 = (pp3 - pp4) * cos7_16;
\r
610 p12 = (pp8 - pp15) * cos1_16;
\r
611 p13 = (pp9 - pp14) * cos3_16;
\r
612 p14 = (pp10 - pp13) * cos5_16;
\r
613 p15 = (pp11 - pp12) * cos7_16;
\r
617 pp2 = (p0 - p3) * cos1_8;
\r
618 pp3 = (p1 - p2) * cos3_8;
\r
621 pp6 = (p4 - p7) * cos1_8;
\r
622 pp7 = (p5 - p6) * cos3_8;
\r
625 pp10 = (p8 - p11) * cos1_8;
\r
626 pp11 = (p9 - p10) * cos3_8;
\r
629 pp14 = (p12 - p15) * cos1_8;
\r
630 pp15 = (p13 - p14) * cos3_8;
\r
633 p1 = (pp0 - pp1) * cos1_4;
\r
635 p3 = (pp2 - pp3) * cos1_4;
\r
637 p5 = (pp4 - pp5) * cos1_4;
\r
639 p7 = (pp6 - pp7) * cos1_4;
\r
641 p9 = (pp8 - pp9) * cos1_4;
\r
643 p11 = (pp10 - pp11) * cos1_4;
\r
645 p13 = (pp12 - pp13) * cos1_4;
\r
647 p15 = (pp14 - pp15) * cos1_4;
\r
649 // this is pretty insane coding
\r
650 @LOC("THIS,SynthesisFilter.NEWV") float tmp1;
\r
651 new_v19/* 36-17 */= -(new_v4 = (new_v12 = p7) + p5) - p6;
\r
652 new_v27/* 44-17 */= -p6 - p7 - p4;
\r
653 new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13;
\r
654 new_v17/* 34-17 */= -(new_v2 = p15 + p13 + p9) - p14;
\r
655 new_v21/* 38-17 */= (tmp1 = -p14 - p15 - p10 - p11) - p13;
\r
656 new_v29/* 46-17 */= -p14 - p15 - p12 - p8;
\r
657 new_v25/* 42-17 */= tmp1 - p12;
\r
658 new_v31/* 48-17 */= -p0;
\r
660 new_v23/* 40-17 */= -(new_v8 = p3) - p2;
\r
662 p0 = (s0 - s31) * cos1_64;
\r
663 p1 = (s1 - s30) * cos3_64;
\r
664 p2 = (s2 - s29) * cos5_64;
\r
665 p3 = (s3 - s28) * cos7_64;
\r
666 p4 = (s4 - s27) * cos9_64;
\r
667 p5 = (s5 - s26) * cos11_64;
\r
668 p6 = (s6 - s25) * cos13_64;
\r
669 p7 = (s7 - s24) * cos15_64;
\r
670 p8 = (s8 - s23) * cos17_64;
\r
671 p9 = (s9 - s22) * cos19_64;
\r
672 p10 = (s10 - s21) * cos21_64;
\r
673 p11 = (s11 - s20) * cos23_64;
\r
674 p12 = (s12 - s19) * cos25_64;
\r
675 p13 = (s13 - s18) * cos27_64;
\r
676 p14 = (s14 - s17) * cos29_64;
\r
677 p15 = (s15 - s16) * cos31_64;
\r
687 pp8 = (p0 - p15) * cos1_32;
\r
688 pp9 = (p1 - p14) * cos3_32;
\r
689 pp10 = (p2 - p13) * cos5_32;
\r
690 pp11 = (p3 - p12) * cos7_32;
\r
691 pp12 = (p4 - p11) * cos9_32;
\r
692 pp13 = (p5 - p10) * cos11_32;
\r
693 pp14 = (p6 - p9) * cos13_32;
\r
694 pp15 = (p7 - p8) * cos15_32;
\r
700 p4 = (pp0 - pp7) * cos1_16;
\r
701 p5 = (pp1 - pp6) * cos3_16;
\r
702 p6 = (pp2 - pp5) * cos5_16;
\r
703 p7 = (pp3 - pp4) * cos7_16;
\r
708 p12 = (pp8 - pp15) * cos1_16;
\r
709 p13 = (pp9 - pp14) * cos3_16;
\r
710 p14 = (pp10 - pp13) * cos5_16;
\r
711 p15 = (pp11 - pp12) * cos7_16;
\r
715 pp2 = (p0 - p3) * cos1_8;
\r
716 pp3 = (p1 - p2) * cos3_8;
\r
719 pp6 = (p4 - p7) * cos1_8;
\r
720 pp7 = (p5 - p6) * cos3_8;
\r
723 pp10 = (p8 - p11) * cos1_8;
\r
724 pp11 = (p9 - p10) * cos3_8;
\r
727 pp14 = (p12 - p15) * cos1_8;
\r
728 pp15 = (p13 - p14) * cos3_8;
\r
731 p1 = (pp0 - pp1) * cos1_4;
\r
733 p3 = (pp2 - pp3) * cos1_4;
\r
735 p5 = (pp4 - pp5) * cos1_4;
\r
737 p7 = (pp6 - pp7) * cos1_4;
\r
739 p9 = (pp8 - pp9) * cos1_4;
\r
741 p11 = (pp10 - pp11) * cos1_4;
\r
743 p13 = (pp12 - pp13) * cos1_4;
\r
745 p15 = (pp14 - pp15) * cos1_4;
\r
747 // manually doing something that a compiler should handle sucks
\r
748 // coding like this is hard to read
\r
749 @LOC("THIS,SynthesisFilter.NEWV") float tmp2;
\r
750 new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11) + p5 + p13;
\r
751 new_v7 = (new_v9 = p15 + p11 + p3) + p13;
\r
752 new_v16/* 33-17 */= -(new_v1 = (tmp1 = p13 + p15 + p9) + p1) - p14;
\r
753 new_v18/* 35-17 */= -(new_v3 = tmp1 + p5 + p7) - p6 - p14;
\r
755 new_v22/* 39-17 */= (tmp1 = -p10 - p11 - p14 - p15) - p13 - p2 - p3;
\r
756 new_v20/* 37-17 */= tmp1 - p13 - p5 - p6 - p7;
\r
757 new_v24/* 41-17 */= tmp1 - p12 - p2 - p3;
\r
758 new_v26/* 43-17 */= tmp1 - p12 - (tmp2 = p4 + p6 + p7);
\r
759 new_v30/* 47-17 */= (tmp1 = -p8 - p12 - p14 - p15) - p0;
\r
760 new_v28/* 45-17 */= tmp1 - tmp2;
\r
762 // insert V[0-15] (== new_v[0-15]) into actual v:
\r
763 // float[] x2 = actual_v + actual_write_pos;
\r
764 // float dest[] = actual_v; actual_v=v1;
\r
766 @LOC("THIS,SynthesisFilter.NEWV") int pos = actual_write_pos;
\r
768 v1[0 + pos] = new_v0;
\r
769 v1[16 + pos] = new_v1;
\r
770 v1[32 + pos] = new_v2;
\r
771 v1[48 + pos] = new_v3;
\r
772 v1[64 + pos] = new_v4;
\r
773 v1[80 + pos] = new_v5;
\r
774 v1[96 + pos] = new_v6;
\r
775 v1[112 + pos] = new_v7;
\r
776 v1[128 + pos] = new_v8;
\r
777 v1[144 + pos] = new_v9;
\r
778 v1[160 + pos] = new_v10;
\r
779 v1[176 + pos] = new_v11;
\r
780 v1[192 + pos] = new_v12;
\r
781 v1[208 + pos] = new_v13;
\r
782 v1[224 + pos] = new_v14;
\r
783 v1[240 + pos] = new_v15;
\r
785 // V[16] is always 0.0:
\r
786 v1[256 + pos] = 0.0f;
\r
788 // insert V[17-31] (== -new_v[15-1]) into actual v:
\r
789 v1[272 + pos] = -new_v15;
\r
790 v1[288 + pos] = -new_v14;
\r
791 v1[304 + pos] = -new_v13;
\r
792 v1[320 + pos] = -new_v12;
\r
793 v1[336 + pos] = -new_v11;
\r
794 v1[352 + pos] = -new_v10;
\r
795 v1[368 + pos] = -new_v9;
\r
796 v1[384 + pos] = -new_v8;
\r
797 v1[400 + pos] = -new_v7;
\r
798 v1[416 + pos] = -new_v6;
\r
799 v1[432 + pos] = -new_v5;
\r
800 v1[448 + pos] = -new_v4;
\r
801 v1[464 + pos] = -new_v3;
\r
802 v1[480 + pos] = -new_v2;
\r
803 v1[496 + pos] = -new_v1;
\r
805 // insert V[32] (== -new_v[0]) into other v:
\r
806 // dest = (actual_v == v1) ? v2 : v1;
\r
808 v2[0 + pos] = -new_v0;
\r
809 // insert V[33-48] (== new_v[16-31]) into other v:
\r
810 v2[16 + pos] = new_v16;
\r
811 v2[32 + pos] = new_v17;
\r
812 v2[48 + pos] = new_v18;
\r
813 v2[64 + pos] = new_v19;
\r
814 v2[80 + pos] = new_v20;
\r
815 v2[96 + pos] = new_v21;
\r
816 v2[112 + pos] = new_v22;
\r
817 v2[128 + pos] = new_v23;
\r
818 v2[144 + pos] = new_v24;
\r
819 v2[160 + pos] = new_v25;
\r
820 v2[176 + pos] = new_v26;
\r
821 v2[192 + pos] = new_v27;
\r
822 v2[208 + pos] = new_v28;
\r
823 v2[224 + pos] = new_v29;
\r
824 v2[240 + pos] = new_v30;
\r
825 v2[256 + pos] = new_v31;
\r
827 // insert V[49-63] (== new_v[30-16]) into other v:
\r
828 v2[272 + pos] = new_v30;
\r
829 v2[288 + pos] = new_v29;
\r
830 v2[304 + pos] = new_v28;
\r
831 v2[320 + pos] = new_v27;
\r
832 v2[336 + pos] = new_v26;
\r
833 v2[352 + pos] = new_v25;
\r
834 v2[368 + pos] = new_v24;
\r
835 v2[384 + pos] = new_v23;
\r
836 v2[400 + pos] = new_v22;
\r
837 v2[416 + pos] = new_v21;
\r
838 v2[432 + pos] = new_v20;
\r
839 v2[448 + pos] = new_v19;
\r
840 v2[464 + pos] = new_v18;
\r
841 v2[480 + pos] = new_v17;
\r
842 v2[496 + pos] = new_v16;
\r
846 * Compute PCM Samples.
\r
850 private float[] _tmpOut = new float[32];
\r
852 private void compute_pcm_samples0() {
\r
855 // final float[] vp = actual_v;
\r
856 // int inc = v_inc;
\r
857 // final float[] tmpOut = _tmpOut;
\r
858 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
860 // fat chance of having this loop unroll
\r
861 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
862 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
863 // final float[] dp = d16[i];
\r
865 (float) (((v1[0 + dvp] * d16[i][0]) + (v1[15 + dvp] * d16[i][1])
\r
866 + (v1[14 + dvp] * d16[i][2]) + (v1[13 + dvp] * d16[i][3])
\r
867 + (v1[12 + dvp] * d16[i][4]) + (v1[11 + dvp] * d16[i][5])
\r
868 + (v1[10 + dvp] * d16[i][6]) + (v1[9 + dvp] * d16[i][7])
\r
869 + (v1[8 + dvp] * d16[i][8]) + (v1[7 + dvp] * d16[i][9])
\r
870 + (v1[6 + dvp] * d16[i][10]) + (v1[5 + dvp] * d16[i][11])
\r
871 + (v1[4 + dvp] * d16[i][12]) + (v1[3 + dvp] * d16[i][13])
\r
872 + (v1[2 + dvp] * d16[i][14]) + (v1[1 + dvp] * d16[i][15])) * scalefactor);
\r
874 _tmpOut[i] = pcm_sample;
\r
879 // final float[] vp = actual_v;
\r
880 // int inc = v_inc;
\r
881 // final float[] tmpOut = _tmpOut;
\r
882 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
884 // fat chance of having this loop unroll
\r
885 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
886 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
887 // final float[] dp = d16[i];
\r
889 (float) (((v2[0 + dvp] * d16[i][0]) + (v2[15 + dvp] * d16[i][1])
\r
890 + (v2[14 + dvp] * d16[i][2]) + (v2[13 + dvp] * d16[i][3])
\r
891 + (v2[12 + dvp] * d16[i][4]) + (v2[11 + dvp] * d16[i][5])
\r
892 + (v2[10 + dvp] * d16[i][6]) + (v2[9 + dvp] * d16[i][7])
\r
893 + (v2[8 + dvp] * d16[i][8]) + (v2[7 + dvp] * d16[i][9])
\r
894 + (v2[6 + dvp] * d16[i][10]) + (v2[5 + dvp] * d16[i][11])
\r
895 + (v2[4 + dvp] * d16[i][12]) + (v2[3 + dvp] * d16[i][13])
\r
896 + (v2[2 + dvp] * d16[i][14]) + (v2[1 + dvp] * d16[i][15])) * scalefactor);
\r
898 _tmpOut[i] = pcm_sample;
\r
906 private void compute_pcm_samples1() {
\r
909 // final float[] vp = actual_v;
\r
910 // int inc = v_inc;
\r
911 // final float[] tmpOut = _tmpOut;
\r
912 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
914 // fat chance of having this loop unroll
\r
915 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
916 // final float[] dp = d16[i];
\r
917 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
920 (float) (((v1[1 + dvp] * d16[i][0]) + (v1[0 + dvp] * d16[i][1])
\r
921 + (v1[15 + dvp] * d16[i][2]) + (v1[14 + dvp] * d16[i][3])
\r
922 + (v1[13 + dvp] * d16[i][4]) + (v1[12 + dvp] * d16[i][5])
\r
923 + (v1[11 + dvp] * d16[i][6]) + (v1[10 + dvp] * d16[i][7])
\r
924 + (v1[9 + dvp] * d16[i][8]) + (v1[8 + dvp] * d16[i][9])
\r
925 + (v1[7 + dvp] * d16[i][10]) + (v1[6 + dvp] * d16[i][11])
\r
926 + (v1[5 + dvp] * d16[i][12]) + (v1[4 + dvp] * d16[i][13])
\r
927 + (v1[3 + dvp] * d16[i][14]) + (v1[2 + dvp] * d16[i][15])) * scalefactor);
\r
929 _tmpOut[i] = pcm_sample;
\r
934 // final float[] vp = actual_v;
\r
935 // int inc = v_inc;
\r
936 // final float[] tmpOut = _tmpOut;
\r
937 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
939 // fat chance of having this loop unroll
\r
940 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
941 // final float[] dp = d16[i];
\r
942 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
945 (float) (((v2[1 + dvp] * d16[i][0]) + (v2[0 + dvp] * d16[i][1])
\r
946 + (v2[15 + dvp] * d16[i][2]) + (v2[14 + dvp] * d16[i][3])
\r
947 + (v2[13 + dvp] * d16[i][4]) + (v2[12 + dvp] * d16[i][5])
\r
948 + (v2[11 + dvp] * d16[i][6]) + (v2[10 + dvp] * d16[i][7])
\r
949 + (v2[9 + dvp] * d16[i][8]) + (v2[8 + dvp] * d16[i][9])
\r
950 + (v2[7 + dvp] * d16[i][10]) + (v2[6 + dvp] * d16[i][11])
\r
951 + (v2[5 + dvp] * d16[i][12]) + (v2[4 + dvp] * d16[i][13])
\r
952 + (v2[3 + dvp] * d16[i][14]) + (v2[2 + dvp] * d16[i][15])) * scalefactor);
\r
954 _tmpOut[i] = pcm_sample;
\r
962 private void compute_pcm_samples2() {
\r
965 // final float[] vp = actual_v;
\r
966 // int inc = v_inc;
\r
967 // final float[] tmpOut = _tmpOut;
\r
968 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
970 // fat chance of having this loop unroll
\r
971 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
972 // final float[] dp = d16[i];
\r
973 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
976 (float) (((v1[2 + dvp] * d16[i][0]) + (v1[1 + dvp] * d16[i][1])
\r
977 + (v1[0 + dvp] * d16[i][2]) + (v1[15 + dvp] * d16[i][3])
\r
978 + (v1[14 + dvp] * d16[i][4]) + (v1[13 + dvp] * d16[i][5])
\r
979 + (v1[12 + dvp] * d16[i][6]) + (v1[11 + dvp] * d16[i][7])
\r
980 + (v1[10 + dvp] * d16[i][8]) + (v1[9 + dvp] * d16[i][9])
\r
981 + (v1[8 + dvp] * d16[i][10]) + (v1[7 + dvp] * d16[i][11])
\r
982 + (v1[6 + dvp] * d16[i][12]) + (v1[5 + dvp] * d16[i][13])
\r
983 + (v1[4 + dvp] * d16[i][14]) + (v1[3 + dvp] * d16[i][15])) * scalefactor);
\r
985 _tmpOut[i] = pcm_sample;
\r
990 // final float[] vp = actual_v;
\r
991 // int inc = v_inc;
\r
992 // final float[] tmpOut = _tmpOut;
\r
993 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
995 // fat chance of having this loop unroll
\r
996 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
997 // final float[] dp = d16[i];
\r
998 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1001 (float) (((v2[2 + dvp] * d16[i][0]) + (v2[1 + dvp] * d16[i][1])
\r
1002 + (v2[0 + dvp] * d16[i][2]) + (v2[15 + dvp] * d16[i][3])
\r
1003 + (v2[14 + dvp] * d16[i][4]) + (v2[13 + dvp] * d16[i][5])
\r
1004 + (v2[12 + dvp] * d16[i][6]) + (v2[11 + dvp] * d16[i][7])
\r
1005 + (v2[10 + dvp] * d16[i][8]) + (v2[9 + dvp] * d16[i][9])
\r
1006 + (v2[8 + dvp] * d16[i][10]) + (v2[7 + dvp] * d16[i][11])
\r
1007 + (v2[6 + dvp] * d16[i][12]) + (v2[5 + dvp] * d16[i][13])
\r
1008 + (v2[4 + dvp] * d16[i][14]) + (v2[3 + dvp] * d16[i][15])) * scalefactor);
\r
1010 _tmpOut[i] = pcm_sample;
\r
1018 private void compute_pcm_samples3() {
\r
1021 // final float[] vp = actual_v;
\r
1023 // int inc = v_inc;
\r
1024 // final float[] tmpOut = _tmpOut;
\r
1025 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1027 // fat chance of having this loop unroll
\r
1028 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1029 // final float[] dp = d16[i];
\r
1030 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1033 (float) (((v1[3 + dvp] * d16[i][0]) + (v1[2 + dvp] * d16[i][1])
\r
1034 + (v1[1 + dvp] * d16[i][2]) + (v1[0 + dvp] * d16[i][3])
\r
1035 + (v1[15 + dvp] * d16[i][4]) + (v1[14 + dvp] * d16[i][5])
\r
1036 + (v1[13 + dvp] * d16[i][6]) + (v1[12 + dvp] * d16[i][7])
\r
1037 + (v1[11 + dvp] * d16[i][8]) + (v1[10 + dvp] * d16[i][9])
\r
1038 + (v1[9 + dvp] * d16[i][10]) + (v1[8 + dvp] * d16[i][11])
\r
1039 + (v1[7 + dvp] * d16[i][12]) + (v1[6 + dvp] * d16[i][13])
\r
1040 + (v1[5 + dvp] * d16[i][14]) + (v1[4 + dvp] * d16[i][15])) * scalefactor);
\r
1042 _tmpOut[i] = pcm_sample;
\r
1047 // final float[] vp = actual_v;
\r
1049 // int inc = v_inc;
\r
1050 // final float[] tmpOut = _tmpOut;
\r
1051 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1053 // fat chance of having this loop unroll
\r
1054 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1055 // final float[] dp = d16[i];
\r
1056 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1059 (float) (((v2[3 + dvp] * d16[i][0]) + (v2[2 + dvp] * d16[i][1])
\r
1060 + (v2[1 + dvp] * d16[i][2]) + (v2[0 + dvp] * d16[i][3])
\r
1061 + (v2[15 + dvp] * d16[i][4]) + (v2[14 + dvp] * d16[i][5])
\r
1062 + (v2[13 + dvp] * d16[i][6]) + (v2[12 + dvp] * d16[i][7])
\r
1063 + (v2[11 + dvp] * d16[i][8]) + (v2[10 + dvp] * d16[i][9])
\r
1064 + (v2[9 + dvp] * d16[i][10]) + (v2[8 + dvp] * d16[i][11])
\r
1065 + (v2[7 + dvp] * d16[i][12]) + (v2[6 + dvp] * d16[i][13])
\r
1066 + (v2[5 + dvp] * d16[i][14]) + (v2[4 + dvp] * d16[i][15])) * scalefactor);
\r
1068 _tmpOut[i] = pcm_sample;
\r
1076 private void compute_pcm_samples4() {
\r
1079 // final float[] vp = actual_v;
\r
1081 // int inc = v_inc;
\r
1082 // final float[] tmpOut = _tmpOut;
\r
1083 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1085 // fat chance of having this loop unroll
\r
1086 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1087 // final float[] dp = d16[i];
\r
1088 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1091 (float) (((v1[4 + dvp] * d16[i][0]) + (v1[3 + dvp] * d16[i][1])
\r
1092 + (v1[2 + dvp] * d16[i][2]) + (v1[1 + dvp] * d16[i][3]) + (v1[0 + dvp] * d16[i][4])
\r
1093 + (v1[15 + dvp] * d16[i][5]) + (v1[14 + dvp] * d16[i][6])
\r
1094 + (v1[13 + dvp] * d16[i][7]) + (v1[12 + dvp] * d16[i][8])
\r
1095 + (v1[11 + dvp] * d16[i][9]) + (v1[10 + dvp] * d16[i][10])
\r
1096 + (v1[9 + dvp] * d16[i][11]) + (v1[8 + dvp] * d16[i][12])
\r
1097 + (v1[7 + dvp] * d16[i][13]) + (v1[6 + dvp] * d16[i][14]) + (v1[5 + dvp] * d16[i][15])) * scalefactor);
\r
1099 _tmpOut[i] = pcm_sample;
\r
1104 // final float[] vp = actual_v;
\r
1106 // int inc = v_inc;
\r
1107 // final float[] tmpOut = _tmpOut;
\r
1108 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1110 // fat chance of having this loop unroll
\r
1111 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1112 // final float[] dp = d16[i];
\r
1113 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1116 (float) (((v2[4 + dvp] * d16[i][0]) + (v2[3 + dvp] * d16[i][1])
\r
1117 + (v2[2 + dvp] * d16[i][2]) + (v2[1 + dvp] * d16[i][3]) + (v2[0 + dvp] * d16[i][4])
\r
1118 + (v2[15 + dvp] * d16[i][5]) + (v2[14 + dvp] * d16[i][6])
\r
1119 + (v2[13 + dvp] * d16[i][7]) + (v2[12 + dvp] * d16[i][8])
\r
1120 + (v2[11 + dvp] * d16[i][9]) + (v2[10 + dvp] * d16[i][10])
\r
1121 + (v2[9 + dvp] * d16[i][11]) + (v2[8 + dvp] * d16[i][12])
\r
1122 + (v2[7 + dvp] * d16[i][13]) + (v2[6 + dvp] * d16[i][14]) + (v2[5 + dvp] * d16[i][15])) * scalefactor);
\r
1124 _tmpOut[i] = pcm_sample;
\r
1132 private void compute_pcm_samples5() {
\r
1135 // final float[] vp = actual_v;
\r
1137 // int inc = v_inc;
\r
1138 // final float[] tmpOut = _tmpOut;
\r
1139 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1141 // fat chance of having this loop unroll
\r
1142 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1143 // final float[] dp = d16[i];
\r
1144 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1147 (float) (((v1[5 + dvp] * d16[i][0]) + (v1[4 + dvp] * d16[i][1])
\r
1148 + (v1[3 + dvp] * d16[i][2]) + (v1[2 + dvp] * d16[i][3]) + (v1[1 + dvp] * d16[i][4])
\r
1149 + (v1[0 + dvp] * d16[i][5]) + (v1[15 + dvp] * d16[i][6])
\r
1150 + (v1[14 + dvp] * d16[i][7]) + (v1[13 + dvp] * d16[i][8])
\r
1151 + (v1[12 + dvp] * d16[i][9]) + (v1[11 + dvp] * d16[i][10])
\r
1152 + (v1[10 + dvp] * d16[i][11]) + (v1[9 + dvp] * d16[i][12])
\r
1153 + (v1[8 + dvp] * d16[i][13]) + (v1[7 + dvp] * d16[i][14]) + (v1[6 + dvp] * d16[i][15])) * scalefactor);
\r
1155 _tmpOut[i] = pcm_sample;
\r
1160 // final float[] vp = actual_v;
\r
1162 // int inc = v_inc;
\r
1163 // final float[] tmpOut = _tmpOut;
\r
1164 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1166 // fat chance of having this loop unroll
\r
1167 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1168 // final float[] dp = d16[i];
\r
1169 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1172 (float) (((v2[5 + dvp] * d16[i][0]) + (v2[4 + dvp] * d16[i][1])
\r
1173 + (v2[3 + dvp] * d16[i][2]) + (v2[2 + dvp] * d16[i][3]) + (v2[1 + dvp] * d16[i][4])
\r
1174 + (v2[0 + dvp] * d16[i][5]) + (v2[15 + dvp] * d16[i][6])
\r
1175 + (v2[14 + dvp] * d16[i][7]) + (v2[13 + dvp] * d16[i][8])
\r
1176 + (v2[12 + dvp] * d16[i][9]) + (v2[11 + dvp] * d16[i][10])
\r
1177 + (v2[10 + dvp] * d16[i][11]) + (v2[9 + dvp] * d16[i][12])
\r
1178 + (v2[8 + dvp] * d16[i][13]) + (v2[7 + dvp] * d16[i][14]) + (v2[6 + dvp] * d16[i][15])) * scalefactor);
\r
1180 _tmpOut[i] = pcm_sample;
\r
1188 private void compute_pcm_samples6() {
\r
1192 // final float[] vp = actual_v;
\r
1193 // int inc = v_inc;
\r
1194 // final float[] tmpOut = _tmpOut;
\r
1195 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1197 // fat chance of having this loop unroll
\r
1198 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1199 // final float[] dp = d16[i];
\r
1200 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1203 (float) (((v1[6 + dvp] * d16[i][0]) + (v1[5 + dvp] * d16[i][1])
\r
1204 + (v1[4 + dvp] * d16[i][2]) + (v1[3 + dvp] * d16[i][3]) + (v1[2 + dvp] * d16[i][4])
\r
1205 + (v1[1 + dvp] * d16[i][5]) + (v1[0 + dvp] * d16[i][6])
\r
1206 + (v1[15 + dvp] * d16[i][7]) + (v1[14 + dvp] * d16[i][8])
\r
1207 + (v1[13 + dvp] * d16[i][9]) + (v1[12 + dvp] * d16[i][10])
\r
1208 + (v1[11 + dvp] * d16[i][11]) + (v1[10 + dvp] * d16[i][12])
\r
1209 + (v1[9 + dvp] * d16[i][13]) + (v1[8 + dvp] * d16[i][14]) + (v1[7 + dvp] * d16[i][15])) * scalefactor);
\r
1211 _tmpOut[i] = pcm_sample;
\r
1217 // final float[] vp = actual_v;
\r
1218 // int inc = v_inc;
\r
1219 // final float[] tmpOut = _tmpOut;
\r
1220 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1222 // fat chance of having this loop unroll
\r
1223 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1224 // final float[] dp = d16[i];
\r
1225 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1228 (float) (((v2[6 + dvp] * d16[i][0]) + (v2[5 + dvp] * d16[i][1])
\r
1229 + (v2[4 + dvp] * d16[i][2]) + (v2[3 + dvp] * d16[i][3]) + (v2[2 + dvp] * d16[i][4])
\r
1230 + (v2[1 + dvp] * d16[i][5]) + (v2[0 + dvp] * d16[i][6])
\r
1231 + (v2[15 + dvp] * d16[i][7]) + (v2[14 + dvp] * d16[i][8])
\r
1232 + (v2[13 + dvp] * d16[i][9]) + (v2[12 + dvp] * d16[i][10])
\r
1233 + (v2[11 + dvp] * d16[i][11]) + (v2[10 + dvp] * d16[i][12])
\r
1234 + (v2[9 + dvp] * d16[i][13]) + (v2[8 + dvp] * d16[i][14]) + (v2[7 + dvp] * d16[i][15])) * scalefactor);
\r
1236 _tmpOut[i] = pcm_sample;
\r
1244 private void compute_pcm_samples7() {
\r
1247 // final float[] vp = actual_v;
\r
1249 // int inc = v_inc;
\r
1250 // final float[] tmpOut = _tmpOut;
\r
1251 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1253 // fat chance of having this loop unroll
\r
1254 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1255 // final float[] dp = d16[i];
\r
1256 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1259 (float) (((v1[7 + dvp] * d16[i][0]) + (v1[6 + dvp] * d16[i][1])
\r
1260 + (v1[5 + dvp] * d16[i][2]) + (v1[4 + dvp] * d16[i][3]) + (v1[3 + dvp] * d16[i][4])
\r
1261 + (v1[2 + dvp] * d16[i][5]) + (v1[1 + dvp] * d16[i][6]) + (v1[0 + dvp] * d16[i][7])
\r
1262 + (v1[15 + dvp] * d16[i][8]) + (v1[14 + dvp] * d16[i][9])
\r
1263 + (v1[13 + dvp] * d16[i][10]) + (v1[12 + dvp] * d16[i][11])
\r
1264 + (v1[11 + dvp] * d16[i][12]) + (v1[10 + dvp] * d16[i][13])
\r
1265 + (v1[9 + dvp] * d16[i][14]) + (v1[8 + dvp] * d16[i][15])) * scalefactor);
\r
1267 _tmpOut[i] = pcm_sample;
\r
1272 // final float[] vp = actual_v;
\r
1274 // int inc = v_inc;
\r
1275 // final float[] tmpOut = _tmpOut;
\r
1276 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1278 // fat chance of having this loop unroll
\r
1279 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1280 // final float[] dp = d16[i];
\r
1281 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1284 (float) (((v2[7 + dvp] * d16[i][0]) + (v2[6 + dvp] * d16[i][1])
\r
1285 + (v2[5 + dvp] * d16[i][2]) + (v2[4 + dvp] * d16[i][3]) + (v2[3 + dvp] * d16[i][4])
\r
1286 + (v2[2 + dvp] * d16[i][5]) + (v2[1 + dvp] * d16[i][6]) + (v2[0 + dvp] * d16[i][7])
\r
1287 + (v2[15 + dvp] * d16[i][8]) + (v2[14 + dvp] * d16[i][9])
\r
1288 + (v2[13 + dvp] * d16[i][10]) + (v2[12 + dvp] * d16[i][11])
\r
1289 + (v2[11 + dvp] * d16[i][12]) + (v2[10 + dvp] * d16[i][13])
\r
1290 + (v2[9 + dvp] * d16[i][14]) + (v2[8 + dvp] * d16[i][15])) * scalefactor);
\r
1292 _tmpOut[i] = pcm_sample;
\r
1300 private void compute_pcm_samples8() {
\r
1304 // final float[] vp = actual_v;
\r
1306 // int inc = v_inc;
\r
1307 // final float[] tmpOut = _tmpOut;
\r
1308 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1310 // fat chance of having this loop unroll
\r
1311 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1312 // final float[] dp = d16[i];
\r
1313 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1316 (float) (((v1[8 + dvp] * d16[i][0]) + (v1[7 + dvp] * d16[i][1])
\r
1317 + (v1[6 + dvp] * d16[i][2]) + (v1[5 + dvp] * d16[i][3]) + (v1[4 + dvp] * d16[i][4])
\r
1318 + (v1[3 + dvp] * d16[i][5]) + (v1[2 + dvp] * d16[i][6]) + (v1[1 + dvp] * d16[i][7])
\r
1319 + (v1[0 + dvp] * d16[i][8]) + (v1[15 + dvp] * d16[i][9])
\r
1320 + (v1[14 + dvp] * d16[i][10]) + (v1[13 + dvp] * d16[i][11])
\r
1321 + (v1[12 + dvp] * d16[i][12]) + (v1[11 + dvp] * d16[i][13])
\r
1322 + (v1[10 + dvp] * d16[i][14]) + (v1[9 + dvp] * d16[i][15])) * scalefactor);
\r
1324 _tmpOut[i] = pcm_sample;
\r
1330 // final float[] vp = actual_v;
\r
1332 // int inc = v_inc;
\r
1333 // final float[] tmpOut = _tmpOut;
\r
1334 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1336 // fat chance of having this loop unroll
\r
1337 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1338 // final float[] dp = d16[i];
\r
1339 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1342 (float) (((v2[8 + dvp] * d16[i][0]) + (v2[7 + dvp] * d16[i][1])
\r
1343 + (v2[6 + dvp] * d16[i][2]) + (v2[5 + dvp] * d16[i][3]) + (v2[4 + dvp] * d16[i][4])
\r
1344 + (v2[3 + dvp] * d16[i][5]) + (v2[2 + dvp] * d16[i][6]) + (v2[1 + dvp] * d16[i][7])
\r
1345 + (v2[0 + dvp] * d16[i][8]) + (v2[15 + dvp] * d16[i][9])
\r
1346 + (v2[14 + dvp] * d16[i][10]) + (v2[13 + dvp] * d16[i][11])
\r
1347 + (v2[12 + dvp] * d16[i][12]) + (v2[11 + dvp] * d16[i][13])
\r
1348 + (v2[10 + dvp] * d16[i][14]) + (v2[9 + dvp] * d16[i][15])) * scalefactor);
\r
1350 _tmpOut[i] = pcm_sample;
\r
1358 private void compute_pcm_samples9() {
\r
1361 // final float[] vp = actual_v;
\r
1363 // int inc = v_inc;
\r
1364 // final float[] tmpOut = _tmpOut;
\r
1365 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1367 // fat chance of having this loop unroll
\r
1368 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1369 // final float[] dp = d16[i];
\r
1370 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1373 (float) (((v1[9 + dvp] * d16[i][0]) + (v1[8 + dvp] * d16[i][1])
\r
1374 + (v1[7 + dvp] * d16[i][2]) + (v1[6 + dvp] * d16[i][3]) + (v1[5 + dvp] * d16[i][4])
\r
1375 + (v1[4 + dvp] * d16[i][5]) + (v1[3 + dvp] * d16[i][6]) + (v1[2 + dvp] * d16[i][7])
\r
1376 + (v1[1 + dvp] * d16[i][8]) + (v1[0 + dvp] * d16[i][9])
\r
1377 + (v1[15 + dvp] * d16[i][10]) + (v1[14 + dvp] * d16[i][11])
\r
1378 + (v1[13 + dvp] * d16[i][12]) + (v1[12 + dvp] * d16[i][13])
\r
1379 + (v1[11 + dvp] * d16[i][14]) + (v1[10 + dvp] * d16[i][15])) * scalefactor);
\r
1381 _tmpOut[i] = pcm_sample;
\r
1386 // final float[] vp = actual_v;
\r
1388 // int inc = v_inc;
\r
1389 // final float[] tmpOut = _tmpOut;
\r
1390 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1392 // fat chance of having this loop unroll
\r
1393 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1394 // final float[] dp = d16[i];
\r
1395 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1398 (float) (((v2[9 + dvp] * d16[i][0]) + (v2[8 + dvp] * d16[i][1])
\r
1399 + (v2[7 + dvp] * d16[i][2]) + (v2[6 + dvp] * d16[i][3]) + (v2[5 + dvp] * d16[i][4])
\r
1400 + (v2[4 + dvp] * d16[i][5]) + (v2[3 + dvp] * d16[i][6]) + (v2[2 + dvp] * d16[i][7])
\r
1401 + (v2[1 + dvp] * d16[i][8]) + (v2[0 + dvp] * d16[i][9])
\r
1402 + (v2[15 + dvp] * d16[i][10]) + (v2[14 + dvp] * d16[i][11])
\r
1403 + (v2[13 + dvp] * d16[i][12]) + (v2[12 + dvp] * d16[i][13])
\r
1404 + (v2[11 + dvp] * d16[i][14]) + (v2[10 + dvp] * d16[i][15])) * scalefactor);
\r
1406 _tmpOut[i] = pcm_sample;
\r
1414 private void compute_pcm_samples10() {
\r
1416 // final float[] vp = actual_v;
\r
1417 // int inc = v_inc;
\r
1418 // final float[] tmpOut = _tmpOut;
\r
1419 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1421 // fat chance of having this loop unroll
\r
1422 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1423 // final float[] dp = d16[i];
\r
1424 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1427 (float) (((v1[10 + dvp] * d16[i][0]) + (v1[9 + dvp] * d16[i][1])
\r
1428 + (v1[8 + dvp] * d16[i][2]) + (v1[7 + dvp] * d16[i][3]) + (v1[6 + dvp] * d16[i][4])
\r
1429 + (v1[5 + dvp] * d16[i][5]) + (v1[4 + dvp] * d16[i][6]) + (v1[3 + dvp] * d16[i][7])
\r
1430 + (v1[2 + dvp] * d16[i][8]) + (v1[1 + dvp] * d16[i][9])
\r
1431 + (v1[0 + dvp] * d16[i][10]) + (v1[15 + dvp] * d16[i][11])
\r
1432 + (v1[14 + dvp] * d16[i][12]) + (v1[13 + dvp] * d16[i][13])
\r
1433 + (v1[12 + dvp] * d16[i][14]) + (v1[11 + dvp] * d16[i][15])) * scalefactor);
\r
1435 _tmpOut[i] = pcm_sample;
\r
1440 // final float[] vp = actual_v;
\r
1441 // int inc = v_inc;
\r
1442 // final float[] tmpOut = _tmpOut;
\r
1443 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1445 // fat chance of having this loop unroll
\r
1446 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1447 // final float[] dp = d16[i];
\r
1448 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1451 (float) (((v2[10 + dvp] * d16[i][0]) + (v2[9 + dvp] * d16[i][1])
\r
1452 + (v2[8 + dvp] * d16[i][2]) + (v2[7 + dvp] * d16[i][3]) + (v2[6 + dvp] * d16[i][4])
\r
1453 + (v2[5 + dvp] * d16[i][5]) + (v2[4 + dvp] * d16[i][6]) + (v2[3 + dvp] * d16[i][7])
\r
1454 + (v2[2 + dvp] * d16[i][8]) + (v2[1 + dvp] * d16[i][9])
\r
1455 + (v2[0 + dvp] * d16[i][10]) + (v2[15 + dvp] * d16[i][11])
\r
1456 + (v2[14 + dvp] * d16[i][12]) + (v2[13 + dvp] * d16[i][13])
\r
1457 + (v2[12 + dvp] * d16[i][14]) + (v2[11 + dvp] * d16[i][15])) * scalefactor);
\r
1459 _tmpOut[i] = pcm_sample;
\r
1467 private void compute_pcm_samples11() {
\r
1470 // final float[] vp = actual_v;
\r
1472 // int inc = v_inc;
\r
1473 // final float[] tmpOut = _tmpOut;
\r
1474 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1476 // fat chance of having this loop unroll
\r
1477 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1478 // final float[] dp = d16[i];
\r
1479 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1482 (float) (((v1[11 + dvp] * d16[i][0]) + (v1[10 + dvp] * d16[i][1])
\r
1483 + (v1[9 + dvp] * d16[i][2]) + (v1[8 + dvp] * d16[i][3]) + (v1[7 + dvp] * d16[i][4])
\r
1484 + (v1[6 + dvp] * d16[i][5]) + (v1[5 + dvp] * d16[i][6]) + (v1[4 + dvp] * d16[i][7])
\r
1485 + (v1[3 + dvp] * d16[i][8]) + (v1[2 + dvp] * d16[i][9])
\r
1486 + (v1[1 + dvp] * d16[i][10]) + (v1[0 + dvp] * d16[i][11])
\r
1487 + (v1[15 + dvp] * d16[i][12]) + (v1[14 + dvp] * d16[i][13])
\r
1488 + (v1[13 + dvp] * d16[i][14]) + (v1[12 + dvp] * d16[i][15])) * scalefactor);
\r
1490 _tmpOut[i] = pcm_sample;
\r
1495 // final float[] vp = actual_v;
\r
1497 // int inc = v_inc;
\r
1498 // final float[] tmpOut = _tmpOut;
\r
1499 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1501 // fat chance of having this loop unroll
\r
1502 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1503 // final float[] dp = d16[i];
\r
1504 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1507 (float) (((v2[11 + dvp] * d16[i][0]) + (v2[10 + dvp] * d16[i][1])
\r
1508 + (v2[9 + dvp] * d16[i][2]) + (v2[8 + dvp] * d16[i][3]) + (v2[7 + dvp] * d16[i][4])
\r
1509 + (v2[6 + dvp] * d16[i][5]) + (v2[5 + dvp] * d16[i][6]) + (v2[4 + dvp] * d16[i][7])
\r
1510 + (v2[3 + dvp] * d16[i][8]) + (v2[2 + dvp] * d16[i][9])
\r
1511 + (v2[1 + dvp] * d16[i][10]) + (v2[0 + dvp] * d16[i][11])
\r
1512 + (v2[15 + dvp] * d16[i][12]) + (v2[14 + dvp] * d16[i][13])
\r
1513 + (v2[13 + dvp] * d16[i][14]) + (v2[12 + dvp] * d16[i][15])) * scalefactor);
\r
1515 _tmpOut[i] = pcm_sample;
\r
1523 private void compute_pcm_samples12() {
\r
1526 // final float[] vp = actual_v;
\r
1527 // int inc = v_inc;
\r
1528 // final float[] tmpOut = _tmpOut;
\r
1529 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1531 // fat chance of having this loop unroll
\r
1532 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1533 // final float[] dp = d16[i];
\r
1534 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1537 (float) (((v1[12 + dvp] * d16[i][0]) + (v1[11 + dvp] * d16[i][1])
\r
1538 + (v1[10 + dvp] * d16[i][2]) + (v1[9 + dvp] * d16[i][3])
\r
1539 + (v1[8 + dvp] * d16[i][4]) + (v1[7 + dvp] * d16[i][5]) + (v1[6 + dvp] * d16[i][6])
\r
1540 + (v1[5 + dvp] * d16[i][7]) + (v1[4 + dvp] * d16[i][8]) + (v1[3 + dvp] * d16[i][9])
\r
1541 + (v1[2 + dvp] * d16[i][10]) + (v1[1 + dvp] * d16[i][11])
\r
1542 + (v1[0 + dvp] * d16[i][12]) + (v1[15 + dvp] * d16[i][13])
\r
1543 + (v1[14 + dvp] * d16[i][14]) + (v1[13 + dvp] * d16[i][15])) * scalefactor);
\r
1545 _tmpOut[i] = pcm_sample;
\r
1550 // final float[] vp = actual_v;
\r
1551 // int inc = v_inc;
\r
1552 // final float[] tmpOut = _tmpOut;
\r
1553 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1555 // fat chance of having this loop unroll
\r
1556 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1557 // final float[] dp = d16[i];
\r
1558 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1561 (float) (((v2[12 + dvp] * d16[i][0]) + (v2[11 + dvp] * d16[i][1])
\r
1562 + (v2[10 + dvp] * d16[i][2]) + (v2[9 + dvp] * d16[i][3])
\r
1563 + (v2[8 + dvp] * d16[i][4]) + (v2[7 + dvp] * d16[i][5]) + (v2[6 + dvp] * d16[i][6])
\r
1564 + (v2[5 + dvp] * d16[i][7]) + (v2[4 + dvp] * d16[i][8]) + (v2[3 + dvp] * d16[i][9])
\r
1565 + (v2[2 + dvp] * d16[i][10]) + (v2[1 + dvp] * d16[i][11])
\r
1566 + (v2[0 + dvp] * d16[i][12]) + (v2[15 + dvp] * d16[i][13])
\r
1567 + (v2[14 + dvp] * d16[i][14]) + (v2[13 + dvp] * d16[i][15])) * scalefactor);
\r
1569 _tmpOut[i] = pcm_sample;
\r
1577 private void compute_pcm_samples13() {
\r
1580 // final float[] vp = actual_v;
\r
1582 // int inc = v_inc;
\r
1583 // final float[] tmpOut = _tmpOut;
\r
1584 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1586 // fat chance of having this loop unroll
\r
1587 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1588 // final float[] dp = d16[i];
\r
1589 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1592 (float) (((v1[13 + dvp] * d16[i][0]) + (v1[12 + dvp] * d16[i][1])
\r
1593 + (v1[11 + dvp] * d16[i][2]) + (v1[10 + dvp] * d16[i][3])
\r
1594 + (v1[9 + dvp] * d16[i][4]) + (v1[8 + dvp] * d16[i][5]) + (v1[7 + dvp] * d16[i][6])
\r
1595 + (v1[6 + dvp] * d16[i][7]) + (v1[5 + dvp] * d16[i][8]) + (v1[4 + dvp] * d16[i][9])
\r
1596 + (v1[3 + dvp] * d16[i][10]) + (v1[2 + dvp] * d16[i][11])
\r
1597 + (v1[1 + dvp] * d16[i][12]) + (v1[0 + dvp] * d16[i][13])
\r
1598 + (v1[15 + dvp] * d16[i][14]) + (v1[14 + dvp] * d16[i][15])) * scalefactor);
\r
1600 _tmpOut[i] = pcm_sample;
\r
1605 // final float[] vp = actual_v;
\r
1607 // int inc = v_inc;
\r
1608 // final float[] tmpOut = _tmpOut;
\r
1609 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1611 // fat chance of having this loop unroll
\r
1612 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1613 // final float[] dp = d16[i];
\r
1614 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1617 (float) (((v2[13 + dvp] * d16[i][0]) + (v2[12 + dvp] * d16[i][1])
\r
1618 + (v2[11 + dvp] * d16[i][2]) + (v2[10 + dvp] * d16[i][3])
\r
1619 + (v2[9 + dvp] * d16[i][4]) + (v2[8 + dvp] * d16[i][5]) + (v2[7 + dvp] * d16[i][6])
\r
1620 + (v2[6 + dvp] * d16[i][7]) + (v2[5 + dvp] * d16[i][8]) + (v2[4 + dvp] * d16[i][9])
\r
1621 + (v2[3 + dvp] * d16[i][10]) + (v2[2 + dvp] * d16[i][11])
\r
1622 + (v2[1 + dvp] * d16[i][12]) + (v2[0 + dvp] * d16[i][13])
\r
1623 + (v2[15 + dvp] * d16[i][14]) + (v2[14 + dvp] * d16[i][15])) * scalefactor);
\r
1625 _tmpOut[i] = pcm_sample;
\r
1633 private void compute_pcm_samples14() {
\r
1636 // final float[] vp = actual_v;
\r
1638 // int inc = v_inc;
\r
1639 // final float[] tmpOut = _tmpOut;
\r
1640 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1642 // fat chance of having this loop unroll
\r
1643 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1644 // final float[] dp = d16[i];
\r
1645 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1648 (float) (((v1[14 + dvp] * d16[i][0]) + (v1[13 + dvp] * d16[i][1])
\r
1649 + (v1[12 + dvp] * d16[i][2]) + (v1[11 + dvp] * d16[i][3])
\r
1650 + (v1[10 + dvp] * d16[i][4]) + (v1[9 + dvp] * d16[i][5])
\r
1651 + (v1[8 + dvp] * d16[i][6]) + (v1[7 + dvp] * d16[i][7]) + (v1[6 + dvp] * d16[i][8])
\r
1652 + (v1[5 + dvp] * d16[i][9]) + (v1[4 + dvp] * d16[i][10])
\r
1653 + (v1[3 + dvp] * d16[i][11]) + (v1[2 + dvp] * d16[i][12])
\r
1654 + (v1[1 + dvp] * d16[i][13]) + (v1[0 + dvp] * d16[i][14]) + (v1[15 + dvp] * d16[i][15])) * scalefactor);
\r
1656 _tmpOut[i] = pcm_sample;
\r
1661 // final float[] vp = actual_v;
\r
1663 // int inc = v_inc;
\r
1664 // final float[] tmpOut = _tmpOut;
\r
1665 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1667 // fat chance of having this loop unroll
\r
1668 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1669 // final float[] dp = d16[i];
\r
1670 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1673 (float) (((v2[14 + dvp] * d16[i][0]) + (v2[13 + dvp] * d16[i][1])
\r
1674 + (v2[12 + dvp] * d16[i][2]) + (v2[11 + dvp] * d16[i][3])
\r
1675 + (v2[10 + dvp] * d16[i][4]) + (v2[9 + dvp] * d16[i][5])
\r
1676 + (v2[8 + dvp] * d16[i][6]) + (v2[7 + dvp] * d16[i][7]) + (v2[6 + dvp] * d16[i][8])
\r
1677 + (v2[5 + dvp] * d16[i][9]) + (v2[4 + dvp] * d16[i][10])
\r
1678 + (v2[3 + dvp] * d16[i][11]) + (v2[2 + dvp] * d16[i][12])
\r
1679 + (v2[1 + dvp] * d16[i][13]) + (v2[0 + dvp] * d16[i][14]) + (v2[15 + dvp] * d16[i][15])) * scalefactor);
\r
1681 _tmpOut[i] = pcm_sample;
\r
1689 private void compute_pcm_samples15() {
\r
1691 // final float[] vp = actual_v;
\r
1693 // int inc = v_inc;
\r
1694 // final float[] tmpOut = _tmpOut;
\r
1695 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1697 // fat chance of having this loop unroll
\r
1698 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1699 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1700 // final float d16[i][] = d16[i];
\r
1702 (float) (((v1[15 + dvp] * d16[i][0]) + (v1[14 + dvp] * d16[i][1])
\r
1703 + (v1[13 + dvp] * d16[i][2]) + (v1[12 + dvp] * d16[i][3])
\r
1704 + (v1[11 + dvp] * d16[i][4]) + (v1[10 + dvp] * d16[i][5])
\r
1705 + (v1[9 + dvp] * d16[i][6]) + (v1[8 + dvp] * d16[i][7]) + (v1[7 + dvp] * d16[i][8])
\r
1706 + (v1[6 + dvp] * d16[i][9]) + (v1[5 + dvp] * d16[i][10])
\r
1707 + (v1[4 + dvp] * d16[i][11]) + (v1[3 + dvp] * d16[i][12])
\r
1708 + (v1[2 + dvp] * d16[i][13]) + (v1[1 + dvp] * d16[i][14]) + (v1[0 + dvp] * d16[i][15])) * scalefactor);
\r
1710 _tmpOut[i] = pcm_sample;
\r
1714 // final float[] vp = actual_v;
\r
1716 // int inc = v_inc;
\r
1717 // final float[] tmpOut = _tmpOut;
\r
1718 @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;
\r
1720 // fat chance of having this loop unroll
\r
1721 for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {
\r
1722 @LOC("THIS,SynthesisFilter.V1") float pcm_sample;
\r
1723 // final float d16[i][] = d16[i];
\r
1725 (float) (((v2[15 + dvp] * d16[i][0]) + (v2[14 + dvp] * d16[i][1])
\r
1726 + (v2[13 + dvp] * d16[i][2]) + (v2[12 + dvp] * d16[i][3])
\r
1727 + (v2[11 + dvp] * d16[i][4]) + (v2[10 + dvp] * d16[i][5])
\r
1728 + (v2[9 + dvp] * d16[i][6]) + (v2[8 + dvp] * d16[i][7]) + (v2[7 + dvp] * d16[i][8])
\r
1729 + (v2[6 + dvp] * d16[i][9]) + (v2[5 + dvp] * d16[i][10])
\r
1730 + (v2[4 + dvp] * d16[i][11]) + (v2[3 + dvp] * d16[i][12])
\r
1731 + (v2[2 + dvp] * d16[i][13]) + (v2[1 + dvp] * d16[i][14]) + (v2[0 + dvp] * d16[i][15])) * scalefactor);
\r
1733 _tmpOut[i] = pcm_sample;
\r
1740 private void compute_pcm_samples() {
\r
1742 switch (actual_write_pos) {
\r
1744 compute_pcm_samples0();
\r
1747 compute_pcm_samples1();
\r
1750 compute_pcm_samples2();
\r
1753 compute_pcm_samples3();
\r
1756 compute_pcm_samples4();
\r
1759 compute_pcm_samples5();
\r
1762 compute_pcm_samples6();
\r
1765 compute_pcm_samples7();
\r
1768 compute_pcm_samples8();
\r
1771 compute_pcm_samples9();
\r
1774 compute_pcm_samples10();
\r
1777 compute_pcm_samples11();
\r
1780 compute_pcm_samples12();
\r
1783 compute_pcm_samples13();
\r
1786 compute_pcm_samples14();
\r
1789 compute_pcm_samples15();
\r
1793 // if (buffer != null) {
\r
1794 // buffer.appendSamples(channel, _tmpOut);
\r
1796 SampleBufferWrapper.appendSamples(channel, _tmpOut);
\r
1799 * // MDM: I was considering putting in quality control for // low-spec
\r
1800 * CPUs, but the performance gain (about 10-15%) // did not justify the
\r
1801 * considerable drop in audio quality. switch (inc) { case 16:
\r
1802 * buffer.appendSamples(channel, tmpOut); break; case 32: for (int i=0;
\r
1803 * i<16; i++) { buffer.append(channel, (short)tmpOut[i]);
\r
1804 * buffer.append(channel, (short)tmpOut[i]); } break; case 64: for (int i=0;
\r
1805 * i<8; i++) { buffer.append(channel, (short)tmpOut[i]);
\r
1806 * buffer.append(channel, (short)tmpOut[i]); buffer.append(channel,
\r
1807 * (short)tmpOut[i]); buffer.append(channel, (short)tmpOut[i]); } break;
\r
1814 * Calculate 32 PCM samples and put the into the Obuffer-object.
\r
1817 public void calculate_pcm_samples() {
\r
1820 compute_new_v1_v2();
\r
1822 compute_new_v2_v1();
\r
1825 // System.out.println("1.actual_v=" + (actual_v == v1) + " vidx=" + vidx);
\r
1826 // compute_new_v();
\r
1827 // System.out.println("2.actual_v=" + (actual_v == v1) + " vidx=" + vidx);
\r
1828 compute_pcm_samples();
\r
1829 // System.out.println("3.actual_v=" + (actual_v == v1) + " vidx=" + vidx);
\r
1831 actual_write_pos = (actual_write_pos + 1) & 0xf;
\r
1832 // actual_v = (actual_v == v1) ? v2 : v1;
\r
1840 // initialize samples[]:
\r
1841 // for (register float *floatp = samples + 32; floatp > samples; )
\r
1842 // *--floatp = 0.0f;
\r
1844 // MDM: this may not be necessary. The Layer III decoder always
\r
1845 // outputs 32 subband samples, but I haven't checked layer I & II.
\r
1846 for (@LOC("C") int p = 0; p < 32; p++)
\r
1847 samples[p] = 0.0f;
\r
1850 private static final double MY_PI = 3.14159265358979323846;
\r
1851 private static final float cos1_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 64.0)));
\r
1852 private static final float cos3_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 64.0)));
\r
1853 private static final float cos5_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 64.0)));
\r
1854 private static final float cos7_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 64.0)));
\r
1855 private static final float cos9_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 64.0)));
\r
1856 private static final float cos11_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 64.0)));
\r
1857 private static final float cos13_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 64.0)));
\r
1858 private static final float cos15_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 64.0)));
\r
1859 private static final float cos17_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 17.0 / 64.0)));
\r
1860 private static final float cos19_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 19.0 / 64.0)));
\r
1861 private static final float cos21_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 21.0 / 64.0)));
\r
1862 private static final float cos23_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 23.0 / 64.0)));
\r
1863 private static final float cos25_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 25.0 / 64.0)));
\r
1864 private static final float cos27_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 27.0 / 64.0)));
\r
1865 private static final float cos29_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 29.0 / 64.0)));
\r
1866 private static final float cos31_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 31.0 / 64.0)));
\r
1867 private static final float cos1_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 32.0)));
\r
1868 private static final float cos3_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 32.0)));
\r
1869 private static final float cos5_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 32.0)));
\r
1870 private static final float cos7_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 32.0)));
\r
1871 private static final float cos9_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 32.0)));
\r
1872 private static final float cos11_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 32.0)));
\r
1873 private static final float cos13_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 32.0)));
\r
1874 private static final float cos15_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 32.0)));
\r
1875 private static final float cos1_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 16.0)));
\r
1876 private static final float cos3_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 16.0)));
\r
1877 private static final float cos5_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 16.0)));
\r
1878 private static final float cos7_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 16.0)));
\r
1879 private static final float cos1_8 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 8.0)));
\r
1880 private static final float cos3_8 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 8.0)));
\r
1881 private static final float cos1_4 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 4.0)));
\r
1883 // Note: These values are not in the same order
\r
1884 // as in Annex 3-B.3 of the ISO/IEC DIS 11172-3
\r
1885 // private float d[] = {0.000000000, -4.000442505};
\r
1888 * d[] split into subarrays of length 16. This provides for more faster access
\r
1889 * by allowing a block of 16 to be addressed with constant offset.
\r
1892 private static float d16[][] = null;
\r
1895 * Converts a 1D array into a number of smaller arrays. This is used to
\r
1896 * achieve offset + constant indexing into an array. Each sub-array represents
\r
1897 * a block of values of the original array.
\r
1900 * The array to split up into blocks.
\r
1901 * @param blockSize
\r
1902 * The size of the blocks to split the array into. This must be an
\r
1903 * exact divisor of the length of the array, or some data will be
\r
1904 * lost from the main array.
\r
1906 * @return An array of arrays in which each element in the returned array will
\r
1907 * be of length <code>blockSize</code>.
\r
1909 static private float[][] splitArray(final float[] array, final int blockSize) {
\r
1910 int size = array.length / blockSize;
\r
1911 float[][] split = new float[size][];
\r
1912 for (int i = 0; i < size; i++) {
\r
1913 split[i] = subArray(array, i * blockSize, blockSize);
\r
1919 * Returns a subarray of an existing array.
\r
1922 * The array to retrieve a subarra from.
\r
1924 * The offset in the array that corresponds to the first index of the
\r
1927 * The number of indeces in the subarray.
\r
1928 * @return The subarray, which may be of length 0.
\r
1930 static private float[] subArray(final float[] array, final int offs, int len) {
\r
1931 if (offs + len > array.length) {
\r
1932 len = array.length - offs;
\r
1938 float[] subarray = new float[len];
\r
1939 for (int i = 0; i < len; i++) {
\r
1940 subarray[i] = array[offs + i];
\r
1946 // The original data for d[]. This data is loaded from a file
\r
1947 // to reduce the overall package size and to improve performance.
\r
1949 static final float d[] = { 0.000000000f, -0.000442505f, 0.003250122f, -0.007003784f,
\r
1950 0.031082153f, -0.078628540f, 0.100311279f, -0.572036743f, 1.144989014f, 0.572036743f,
\r
1951 0.100311279f, 0.078628540f, 0.031082153f, 0.007003784f, 0.003250122f, 0.000442505f,
\r
1952 -0.000015259f, -0.000473022f, 0.003326416f, -0.007919312f, 0.030517578f, -0.084182739f,
\r
1953 0.090927124f, -0.600219727f, 1.144287109f, 0.543823242f, 0.108856201f, 0.073059082f,
\r
1954 0.031478882f, 0.006118774f, 0.003173828f, 0.000396729f, -0.000015259f, -0.000534058f,
\r
1955 0.003387451f, -0.008865356f, 0.029785156f, -0.089706421f, 0.080688477f, -0.628295898f,
\r
1956 1.142211914f, 0.515609741f, 0.116577148f, 0.067520142f, 0.031738281f, 0.005294800f,
\r
1957 0.003082275f, 0.000366211f, -0.000015259f, -0.000579834f, 0.003433228f, -0.009841919f,
\r
1958 0.028884888f, -0.095169067f, 0.069595337f, -0.656219482f, 1.138763428f, 0.487472534f,
\r
1959 0.123474121f, 0.061996460f, 0.031845093f, 0.004486084f, 0.002990723f, 0.000320435f,
\r
1960 -0.000015259f, -0.000625610f, 0.003463745f, -0.010848999f, 0.027801514f, -0.100540161f,
\r
1961 0.057617188f, -0.683914185f, 1.133926392f, 0.459472656f, 0.129577637f, 0.056533813f,
\r
1962 0.031814575f, 0.003723145f, 0.002899170f, 0.000289917f, -0.000015259f, -0.000686646f,
\r
1963 0.003479004f, -0.011886597f, 0.026535034f, -0.105819702f, 0.044784546f, -0.711318970f,
\r
1964 1.127746582f, 0.431655884f, 0.134887695f, 0.051132202f, 0.031661987f, 0.003005981f,
\r
1965 0.002792358f, 0.000259399f, -0.000015259f, -0.000747681f, 0.003479004f, -0.012939453f,
\r
1966 0.025085449f, -0.110946655f, 0.031082153f, -0.738372803f, 1.120223999f, 0.404083252f,
\r
1967 0.139450073f, 0.045837402f, 0.031387329f, 0.002334595f, 0.002685547f, 0.000244141f,
\r
1968 -0.000030518f, -0.000808716f, 0.003463745f, -0.014022827f, 0.023422241f, -0.115921021f,
\r
1969 0.016510010f, -0.765029907f, 1.111373901f, 0.376800537f, 0.143264771f, 0.040634155f,
\r
1970 0.031005859f, 0.001693726f, 0.002578735f, 0.000213623f, -0.000030518f, -0.000885010f,
\r
1971 0.003417969f, -0.015121460f, 0.021575928f, -0.120697021f, 0.001068115f, -0.791213989f,
\r
1972 1.101211548f, 0.349868774f, 0.146362305f, 0.035552979f, 0.030532837f, 0.001098633f,
\r
1973 0.002456665f, 0.000198364f, -0.000030518f, -0.000961304f, 0.003372192f, -0.016235352f,
\r
1974 0.019531250f, -0.125259399f, -0.015228271f, -0.816864014f, 1.089782715f, 0.323318481f,
\r
1975 0.148773193f, 0.030609131f, 0.029937744f, 0.000549316f, 0.002349854f, 0.000167847f,
\r
1976 -0.000030518f, -0.001037598f, 0.003280640f, -0.017349243f, 0.017257690f, -0.129562378f,
\r
1977 -0.032379150f, -0.841949463f, 1.077117920f, 0.297210693f, 0.150497437f, 0.025817871f,
\r
1978 0.029281616f, 0.000030518f, 0.002243042f, 0.000152588f, -0.000045776f, -0.001113892f,
\r
1979 0.003173828f, -0.018463135f, 0.014801025f, -0.133590698f, -0.050354004f, -0.866363525f,
\r
1980 1.063217163f, 0.271591187f, 0.151596069f, 0.021179199f, 0.028533936f, -0.000442505f,
\r
1981 0.002120972f, 0.000137329f, -0.000045776f, -0.001205444f, 0.003051758f, -0.019577026f,
\r
1982 0.012115479f, -0.137298584f, -0.069168091f, -0.890090942f, 1.048156738f, 0.246505737f,
\r
1983 0.152069092f, 0.016708374f, 0.027725220f, -0.000869751f, 0.002014160f, 0.000122070f,
\r
1984 -0.000061035f, -0.001296997f, 0.002883911f, -0.020690918f, 0.009231567f, -0.140670776f,
\r
1985 -0.088775635f, -0.913055420f, 1.031936646f, 0.221984863f, 0.151962280f, 0.012420654f,
\r
1986 0.026840210f, -0.001266479f, 0.001907349f, 0.000106812f, -0.000061035f, -0.001388550f,
\r
1987 0.002700806f, -0.021789551f, 0.006134033f, -0.143676758f, -0.109161377f, -0.935195923f,
\r
1988 1.014617920f, 0.198059082f, 0.151306152f, 0.008316040f, 0.025909424f, -0.001617432f,
\r
1989 0.001785278f, 0.000106812f, -0.000076294f, -0.001480103f, 0.002487183f, -0.022857666f,
\r
1990 0.002822876f, -0.146255493f, -0.130310059f, -0.956481934f, 0.996246338f, 0.174789429f,
\r
1991 0.150115967f, 0.004394531f, 0.024932861f, -0.001937866f, 0.001693726f, 0.000091553f,
\r
1992 -0.000076294f, -0.001586914f, 0.002227783f, -0.023910522f, -0.000686646f, -0.148422241f,
\r
1993 -0.152206421f, -0.976852417f, 0.976852417f, 0.152206421f, 0.148422241f, 0.000686646f,
\r
1994 0.023910522f, -0.002227783f, 0.001586914f, 0.000076294f, -0.000091553f, -0.001693726f,
\r
1995 0.001937866f, -0.024932861f, -0.004394531f, -0.150115967f, -0.174789429f, -0.996246338f,
\r
1996 0.956481934f, 0.130310059f, 0.146255493f, -0.002822876f, 0.022857666f, -0.002487183f,
\r
1997 0.001480103f, 0.000076294f, -0.000106812f, -0.001785278f, 0.001617432f, -0.025909424f,
\r
1998 -0.008316040f, -0.151306152f, -0.198059082f, -1.014617920f, 0.935195923f, 0.109161377f,
\r
1999 0.143676758f, -0.006134033f, 0.021789551f, -0.002700806f, 0.001388550f, 0.000061035f,
\r
2000 -0.000106812f, -0.001907349f, 0.001266479f, -0.026840210f, -0.012420654f, -0.151962280f,
\r
2001 -0.221984863f, -1.031936646f, 0.913055420f, 0.088775635f, 0.140670776f, -0.009231567f,
\r
2002 0.020690918f, -0.002883911f, 0.001296997f, 0.000061035f, -0.000122070f, -0.002014160f,
\r
2003 0.000869751f, -0.027725220f, -0.016708374f, -0.152069092f, -0.246505737f, -1.048156738f,
\r
2004 0.890090942f, 0.069168091f, 0.137298584f, -0.012115479f, 0.019577026f, -0.003051758f,
\r
2005 0.001205444f, 0.000045776f, -0.000137329f, -0.002120972f, 0.000442505f, -0.028533936f,
\r
2006 -0.021179199f, -0.151596069f, -0.271591187f, -1.063217163f, 0.866363525f, 0.050354004f,
\r
2007 0.133590698f, -0.014801025f, 0.018463135f, -0.003173828f, 0.001113892f, 0.000045776f,
\r
2008 -0.000152588f, -0.002243042f, -0.000030518f, -0.029281616f, -0.025817871f, -0.150497437f,
\r
2009 -0.297210693f, -1.077117920f, 0.841949463f, 0.032379150f, 0.129562378f, -0.017257690f,
\r
2010 0.017349243f, -0.003280640f, 0.001037598f, 0.000030518f, -0.000167847f, -0.002349854f,
\r
2011 -0.000549316f, -0.029937744f, -0.030609131f, -0.148773193f, -0.323318481f, -1.089782715f,
\r
2012 0.816864014f, 0.015228271f, 0.125259399f, -0.019531250f, 0.016235352f, -0.003372192f,
\r
2013 0.000961304f, 0.000030518f, -0.000198364f, -0.002456665f, -0.001098633f, -0.030532837f,
\r
2014 -0.035552979f, -0.146362305f, -0.349868774f, -1.101211548f, 0.791213989f, -0.001068115f,
\r
2015 0.120697021f, -0.021575928f, 0.015121460f, -0.003417969f, 0.000885010f, 0.000030518f,
\r
2016 -0.000213623f, -0.002578735f, -0.001693726f, -0.031005859f, -0.040634155f, -0.143264771f,
\r
2017 -0.376800537f, -1.111373901f, 0.765029907f, -0.016510010f, 0.115921021f, -0.023422241f,
\r
2018 0.014022827f, -0.003463745f, 0.000808716f, 0.000030518f, -0.000244141f, -0.002685547f,
\r
2019 -0.002334595f, -0.031387329f, -0.045837402f, -0.139450073f, -0.404083252f, -1.120223999f,
\r
2020 0.738372803f, -0.031082153f, 0.110946655f, -0.025085449f, 0.012939453f, -0.003479004f,
\r
2021 0.000747681f, 0.000015259f, -0.000259399f, -0.002792358f, -0.003005981f, -0.031661987f,
\r
2022 -0.051132202f, -0.134887695f, -0.431655884f, -1.127746582f, 0.711318970f, -0.044784546f,
\r
2023 0.105819702f, -0.026535034f, 0.011886597f, -0.003479004f, 0.000686646f, 0.000015259f,
\r
2024 -0.000289917f, -0.002899170f, -0.003723145f, -0.031814575f, -0.056533813f, -0.129577637f,
\r
2025 -0.459472656f, -1.133926392f, 0.683914185f, -0.057617188f, 0.100540161f, -0.027801514f,
\r
2026 0.010848999f, -0.003463745f, 0.000625610f, 0.000015259f, -0.000320435f, -0.002990723f,
\r
2027 -0.004486084f, -0.031845093f, -0.061996460f, -0.123474121f, -0.487472534f, -1.138763428f,
\r
2028 0.656219482f, -0.069595337f, 0.095169067f, -0.028884888f, 0.009841919f, -0.003433228f,
\r
2029 0.000579834f, 0.000015259f, -0.000366211f, -0.003082275f, -0.005294800f, -0.031738281f,
\r
2030 -0.067520142f, -0.116577148f, -0.515609741f, -1.142211914f, 0.628295898f, -0.080688477f,
\r
2031 0.089706421f, -0.029785156f, 0.008865356f, -0.003387451f, 0.000534058f, 0.000015259f,
\r
2032 -0.000396729f, -0.003173828f, -0.006118774f, -0.031478882f, -0.073059082f, -0.108856201f,
\r
2033 -0.543823242f, -1.144287109f, 0.600219727f, -0.090927124f, 0.084182739f, -0.030517578f,
\r
2034 0.007919312f, -0.003326416f, 0.000473022f, 0.000015259f };
\r