*----------------------------------------------------------------------\r
*/\r
\r
-import java.io.IOException;\r
+//import java.io.IOException; //Compiler does not support imports\r
\r
/**\r
* A class for the synthesis filter bank.\r
* This class does a fast downsampling from 32, 44.1 or 48 kHz to 8 kHz, if ULAW is defined.\r
* Frequencies above 4 kHz are removed by ignoring higher subbands.\r
*/\r
+@LATTICE("TMP<PCM,PCM<AV,AV<V2,V2<V1,V1<L1,L1<L2,L2<L3,L3<L4,L4<LSH,LSH<S,S<SA,SA<EQ,EQ<SH,SH*,LSH*,V1*")\r
+@METHODDEFAULT("OUT<V,V<SH,SH<IN,IN<GLOBAL,SH*,THISLOC=IN,GLOBALLOC=GLOBAL")\r
final class SynthesisFilter\r
{\r
- private float[] v1;\r
- private float[] v2;\r
- private float[] actual_v; // v1 or v2\r
- private int actual_write_pos; // 0-15\r
- private float[] samples; // 32 new subband samples\r
- private int channel;\r
- private float scalefactor;\r
- private float[] eq;\r
+ @LOC("V1") private float[] v1;\r
+ @LOC("V2") private float[] v2;\r
+ @LOC("AV") private float[] actual_v; // v1 or v2\r
+ @LOC("SH") private int actual_write_pos; // 0-15\r
+ @LOC("SA") private float[] samples; // 32 new subband samples\r
+ @LOC("V2") private int channel;\r
+ @LOC("V2") private float scalefactor;\r
+ @LOC("EQ") private float[] eq;\r
\r
/**\r
* Quality value for controlling CPU usage/quality tradeoff. \r
/**\r
* Inject Sample.\r
*/\r
- public void input_sample(float sample, int subbandnumber)\r
+ public void input_sample(@LOC("V") float sample, @LOC("V") int subbandnumber)\r
{ \r
samples[subbandnumber] = eq[subbandnumber]*sample;\r
}\r
\r
- public void input_samples(float[] s)\r
+ public void input_samples(@LOC("V") float[] s)\r
{\r
for (int i=31; i>=0; i--)\r
{ \r
}\r
*/\r
\r
- float new_v0, new_v1, new_v2, new_v3, new_v4, new_v5, new_v6, new_v7, new_v8, new_v9;\r
- float new_v10, new_v11, new_v12, new_v13, new_v14, new_v15, new_v16, new_v17, new_v18, new_v19;\r
- float new_v20, new_v21, new_v22, new_v23, new_v24, new_v25, new_v26, new_v27, new_v28, new_v29;\r
- float new_v30, new_v31;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v0;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v1;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v2;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v3;\r
+ @LOC("IN,SynthesisFilter.L3") float new_v4;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v5;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v6;\r
+ @LOC("IN,SynthesisFilter.L3") float new_v7;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v8;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v9;\r
+ @LOC("IN,SynthesisFilter.L3") float new_v10;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v11;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v12;\r
+ @LOC("IN,SynthesisFilter.L3") float new_v13;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v14;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v15;\r
+ @LOC("IN,SynthesisFilter.L1") float new_v16;\r
+ @LOC("IN,SynthesisFilter.L3") float new_v17;\r
+ @LOC("IN,SynthesisFilter.L1") float new_v18;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v19;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v20;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v21;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v22;\r
+ @LOC("IN,SynthesisFilter.L3") float new_v23;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v24;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v25;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v26;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v27;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v28;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v29;\r
+ @LOC("IN,SynthesisFilter.L2") float new_v30;\r
+ @LOC("IN,SynthesisFilter.L4") float new_v31;\r
\r
new_v0 = new_v1 = new_v2 = new_v3 = new_v4 = new_v5 = new_v6 = new_v7 = new_v8 = new_v9 = \r
new_v10 = new_v11 = new_v12 = new_v13 = new_v14 = new_v15 = new_v16 = new_v17 = new_v18 = new_v19 = \r
// float[] p = new float[16];\r
// float[] pp = new float[16];\r
\r
- float[] s = samples;\r
- \r
- float s0 = s[0];\r
- float s1 = s[1];\r
- float s2 = s[2];\r
- float s3 = s[3];\r
- float s4 = s[4];\r
- float s5 = s[5];\r
- float s6 = s[6];\r
- float s7 = s[7];\r
- float s8 = s[8];\r
- float s9 = s[9];\r
- float s10 = s[10]; \r
- float s11 = s[11];\r
- float s12 = s[12];\r
- float s13 = s[13];\r
- float s14 = s[14];\r
- float s15 = s[15];\r
- float s16 = s[16];\r
- float s17 = s[17];\r
- float s18 = s[18];\r
- float s19 = s[19];\r
- float s20 = s[20]; \r
- float s21 = s[21];\r
- float s22 = s[22];\r
- float s23 = s[23];\r
- float s24 = s[24];\r
- float s25 = s[25];\r
- float s26 = s[26];\r
- float s27 = s[27];\r
- float s28 = s[28];\r
- float s29 = s[29];\r
- float s30 = s[30]; \r
- float s31 = s[31];\r
+ //float[] s = samples; // subbed in samples directly below to reduce uneccesary areas\r
+ \r
+ @LOC("IN,SynthesisFilter.S") float s0 = samples[0];\r
+ @LOC("IN,SynthesisFilter.S") float s1 = samples[1];\r
+ @LOC("IN,SynthesisFilter.S") float s2 = samples[2];\r
+ @LOC("IN,SynthesisFilter.S") float s3 = samples[3];\r
+ @LOC("IN,SynthesisFilter.S") float s4 = samples[4];\r
+ @LOC("IN,SynthesisFilter.S") float s5 = samples[5];\r
+ @LOC("IN,SynthesisFilter.S") float s6 = samples[6];\r
+ @LOC("IN,SynthesisFilter.S") float s7 = samples[7];\r
+ @LOC("IN,SynthesisFilter.S") float s8 = samples[8];\r
+ @LOC("IN,SynthesisFilter.S") float s9 = samples[9];\r
+ @LOC("IN,SynthesisFilter.S") float s10 = samples[10]; \r
+ @LOC("IN,SynthesisFilter.S") float s11 = samples[11];\r
+ @LOC("IN,SynthesisFilter.S") float s12 = samples[12];\r
+ @LOC("IN,SynthesisFilter.S") float s13 = samples[13];\r
+ @LOC("IN,SynthesisFilter.S") float s14 = samples[14];\r
+ @LOC("IN,SynthesisFilter.S") float s15 = samples[15];\r
+ @LOC("IN,SynthesisFilter.S") float s16 = samples[16];\r
+ @LOC("IN,SynthesisFilter.S") float s17 = samples[17];\r
+ @LOC("IN,SynthesisFilter.S") float s18 = samples[18];\r
+ @LOC("IN,SynthesisFilter.S") float s19 = samples[19];\r
+ @LOC("IN,SynthesisFilter.S") float s20 = samples[20]; \r
+ @LOC("IN,SynthesisFilter.S") float s21 = samples[21];\r
+ @LOC("IN,SynthesisFilter.S") float s22 = samples[22];\r
+ @LOC("IN,SynthesisFilter.S") float s23 = samples[23];\r
+ @LOC("IN,SynthesisFilter.S") float s24 = samples[24];\r
+ @LOC("IN,SynthesisFilter.S") float s25 = samples[25];\r
+ @LOC("IN,SynthesisFilter.S") float s26 = samples[26];\r
+ @LOC("IN,SynthesisFilter.S") float s27 = samples[27];\r
+ @LOC("IN,SynthesisFilter.S") float s28 = samples[28];\r
+ @LOC("IN,SynthesisFilter.S") float s29 = samples[29];\r
+ @LOC("IN,SynthesisFilter.S") float s30 = samples[30]; \r
+ @LOC("IN,SynthesisFilter.S") float s31 = samples[31];\r
\r
- float p0 = s0 + s31;\r
- float p1 = s1 + s30;\r
- float p2 = s2 + s29;\r
- float p3 = s3 + s28;\r
- float p4 = s4 + s27;\r
- float p5 = s5 + s26;\r
- float p6 = s6 + s25;\r
- float p7 = s7 + s24;\r
- float p8 = s8 + s23;\r
- float p9 = s9 + s22;\r
- float p10 = s10 + s21;\r
- float p11 = s11 + s20;\r
- float p12 = s12 + s19;\r
- float p13 = s13 + s18;\r
- float p14 = s14 + s17;\r
- float p15 = s15 + s16;\r
- \r
- float pp0 = p0 + p15;\r
- float pp1 = p1 + p14;\r
- float pp2 = p2 + p13;\r
- float pp3 = p3 + p12;\r
- float pp4 = p4 + p11;\r
- float pp5 = p5 + p10;\r
- float pp6 = p6 + p9;\r
- float pp7 = p7 + p8;\r
- float pp8 = (p0 - p15) * cos1_32;\r
- float pp9 = (p1 - p14) * cos3_32;\r
- float pp10 = (p2 - p13) * cos5_32;\r
- float pp11 = (p3 - p12) * cos7_32;\r
- float pp12 = (p4 - p11) * cos9_32;\r
- float pp13 = (p5 - p10) * cos11_32;\r
- float pp14 = (p6 - p9) * cos13_32;\r
- float pp15 = (p7 - p8) * cos15_32;\r
+ @LOC("IN,SynthesisFilter.LSH") float p0 = s0 + s31;\r
+ @LOC("IN,SynthesisFilter.LSH") float p1 = s1 + s30;\r
+ @LOC("IN,SynthesisFilter.LSH") float p2 = s2 + s29;\r
+ @LOC("IN,SynthesisFilter.LSH") float p3 = s3 + s28;\r
+ @LOC("IN,SynthesisFilter.LSH") float p4 = s4 + s27;\r
+ @LOC("IN,SynthesisFilter.LSH") float p5 = s5 + s26;\r
+ @LOC("IN,SynthesisFilter.LSH") float p6 = s6 + s25;\r
+ @LOC("IN,SynthesisFilter.LSH") float p7 = s7 + s24;\r
+ @LOC("IN,SynthesisFilter.LSH") float p8 = s8 + s23;\r
+ @LOC("IN,SynthesisFilter.LSH") float p9 = s9 + s22;\r
+ @LOC("IN,SynthesisFilter.LSH") float p10 = s10 + s21;\r
+ @LOC("IN,SynthesisFilter.LSH") float p11 = s11 + s20;\r
+ @LOC("IN,SynthesisFilter.LSH") float p12 = s12 + s19;\r
+ @LOC("IN,SynthesisFilter.LSH") float p13 = s13 + s18;\r
+ @LOC("IN,SynthesisFilter.LSH") float p14 = s14 + s17;\r
+ @LOC("IN,SynthesisFilter.LSH") float p15 = s15 + s16;\r
+ \r
+ @LOC("IN,SynthesisFilter.LSH") float pp0 = p0 + p15;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp1 = p1 + p14;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp2 = p2 + p13;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp3 = p3 + p12;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp4 = p4 + p11;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp5 = p5 + p10;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp6 = p6 + p9;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp7 = p7 + p8;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp8 = (p0 - p15) * cos1_32;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp9 = (p1 - p14) * cos3_32;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp10 = (p2 - p13) * cos5_32;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp11 = (p3 - p12) * cos7_32;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp12 = (p4 - p11) * cos9_32;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp13 = (p5 - p10) * cos11_32;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp14 = (p6 - p9) * cos13_32;\r
+ @LOC("IN,SynthesisFilter.LSH") float pp15 = (p7 - p8) * cos15_32;\r
\r
p0 = pp0 + pp7;\r
p1 = pp1 + pp6;\r
p15 = (pp14 - pp15) * cos1_4;\r
\r
// this is pretty insane coding\r
- float tmp1;\r
+ @LOC("IN,SynthesisFilter.L3") float tmp1;\r
new_v19/*36-17*/ = -(new_v4 = (new_v12 = p7) + p5) - p6;\r
new_v27/*44-17*/ = -p6 - p7 - p4;\r
new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13;\r
\r
// manually doing something that a compiler should handle sucks\r
// coding like this is hard to read\r
- float tmp2;\r
+ @LOC("IN,SynthesisFilter.L4") float tmp2;\r
new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11)\r
+ p5 + p13;\r
new_v7 = (new_v9 = p15 + p11 + p3) + p13;\r
\r
// insert V[0-15] (== new_v[0-15]) into actual v: \r
// float[] x2 = actual_v + actual_write_pos;\r
- float dest[] = actual_v;\r
- \r
- int pos = actual_write_pos;\r
- \r
- dest[0 + pos] = new_v0;\r
- dest[16 + pos] = new_v1;\r
- dest[32 + pos] = new_v2;\r
- dest[48 + pos] = new_v3;\r
- dest[64 + pos] = new_v4;\r
- dest[80 + pos] = new_v5;\r
- dest[96 + pos] = new_v6;\r
- dest[112 + pos] = new_v7;\r
- dest[128 + pos] = new_v8;\r
- dest[144 + pos] = new_v9;\r
- dest[160 + pos] = new_v10;\r
- dest[176 + pos] = new_v11;\r
- dest[192 + pos] = new_v12;\r
- dest[208 + pos] = new_v13;\r
- dest[224 + pos] = new_v14;\r
- dest[240 + pos] = new_v15;\r
+ //float dest[] = actual_v; //actual_v subbed in so as not to create a new area\r
+ \r
+ //int pos = actual_write_pos; //substituted to simplify location relations\r
+ \r
+ actual_v[0 + actual_write_pos] = new_v0;\r
+ actual_v[16 + actual_write_pos] = new_v1;\r
+ actual_v[32 + actual_write_pos] = new_v2;\r
+ actual_v[48 + actual_write_pos] = new_v3;\r
+ actual_v[64 + actual_write_pos] = new_v4;\r
+ actual_v[80 + actual_write_pos] = new_v5;\r
+ actual_v[96 + actual_write_pos] = new_v6;\r
+ actual_v[112 + actual_write_pos] = new_v7;\r
+ actual_v[128 + actual_write_pos] = new_v8;\r
+ actual_v[144 + actual_write_pos] = new_v9;\r
+ actual_v[160 + actual_write_pos] = new_v10;\r
+ actual_v[176 + actual_write_pos] = new_v11;\r
+ actual_v[192 + actual_write_pos] = new_v12;\r
+ actual_v[208 + actual_write_pos] = new_v13;\r
+ actual_v[224 + actual_write_pos] = new_v14;\r
+ actual_v[240 + actual_write_pos] = new_v15;\r
\r
// V[16] is always 0.0:\r
- dest[256 + pos] = 0.0f;\r
+ actual_v[256 + actual_write_pos] = 0.0f;\r
\r
// insert V[17-31] (== -new_v[15-1]) into actual v:\r
- dest[272 + pos] = -new_v15;\r
- dest[288 + pos] = -new_v14;\r
- dest[304 + pos] = -new_v13;\r
- dest[320 + pos] = -new_v12;\r
- dest[336 + pos] = -new_v11;\r
- dest[352 + pos] = -new_v10;\r
- dest[368 + pos] = -new_v9;\r
- dest[384 + pos] = -new_v8;\r
- dest[400 + pos] = -new_v7;\r
- dest[416 + pos] = -new_v6;\r
- dest[432 + pos] = -new_v5;\r
- dest[448 + pos] = -new_v4;\r
- dest[464 + pos] = -new_v3;\r
- dest[480 + pos] = -new_v2;\r
- dest[496 + pos] = -new_v1;\r
+ actual_v[272 + actual_write_pos] = -new_v15;\r
+ actual_v[288 + actual_write_pos] = -new_v14;\r
+ actual_v[304 + actual_write_pos] = -new_v13;\r
+ actual_v[320 + actual_write_pos] = -new_v12;\r
+ actual_v[336 + actual_write_pos] = -new_v11;\r
+ actual_v[352 + actual_write_pos] = -new_v10;\r
+ actual_v[368 + actual_write_pos] = -new_v9;\r
+ actual_v[384 + actual_write_pos] = -new_v8;\r
+ actual_v[400 + actual_write_pos] = -new_v7;\r
+ actual_v[416 + actual_write_pos] = -new_v6;\r
+ actual_v[432 + actual_write_pos] = -new_v5;\r
+ actual_v[448 + actual_write_pos] = -new_v4;\r
+ actual_v[464 + actual_write_pos] = -new_v3;\r
+ actual_v[480 + actual_write_pos] = -new_v2;\r
+ actual_v[496 + actual_write_pos] = -new_v1;\r
\r
// insert V[32] (== -new_v[0]) into other v:\r
- dest = (actual_v==v1) ? v2 : v1;\r
- \r
- dest[0 + pos] = -new_v0;\r
+ //dest = (actual_v==v1) ? v2 : v1; //assignment replaced with if statement so that new areas are not created\r
+ if(actual_v == v1){\r
+ v2[0 + actual_write_pos] = -new_v0;\r
// insert V[33-48] (== new_v[16-31]) into other v:\r
- dest[16 + pos] = new_v16;\r
- dest[32 + pos] = new_v17;\r
- dest[48 + pos] = new_v18;\r
- dest[64 + pos] = new_v19;\r
- dest[80 + pos] = new_v20;\r
- dest[96 + pos] = new_v21;\r
- dest[112 + pos] = new_v22;\r
- dest[128 + pos] = new_v23;\r
- dest[144 + pos] = new_v24;\r
- dest[160 + pos] = new_v25;\r
- dest[176 + pos] = new_v26;\r
- dest[192 + pos] = new_v27;\r
- dest[208 + pos] = new_v28;\r
- dest[224 + pos] = new_v29;\r
- dest[240 + pos] = new_v30;\r
- dest[256 + pos] = new_v31;\r
+ v2[16 + actual_write_pos] = new_v16;\r
+ v2[32 + actual_write_pos] = new_v17;\r
+ v2[48 + actual_write_pos] = new_v18;\r
+ v2[64 + actual_write_pos] = new_v19;\r
+ v2[80 + actual_write_pos] = new_v20;\r
+ v2[96 + actual_write_pos] = new_v21;\r
+ v2[112 + actual_write_pos] = new_v22;\r
+ v2[128 + actual_write_pos] = new_v23;\r
+ v2[144 + actual_write_pos] = new_v24;\r
+ v2[160 + actual_write_pos] = new_v25;\r
+ v2[176 + actual_write_pos] = new_v26;\r
+ v2[192 + actual_write_pos] = new_v27;\r
+ v2[208 + actual_write_pos] = new_v28;\r
+ v2[224 + actual_write_pos] = new_v29;\r
+ v2[240 + actual_write_pos] = new_v30;\r
+ v2[256 + actual_write_pos] = new_v31;\r
\r
// insert V[49-63] (== new_v[30-16]) into other v:\r
- dest[272 + pos] = new_v30;\r
- dest[288 + pos] = new_v29;\r
- dest[304 + pos] = new_v28;\r
- dest[320 + pos] = new_v27;\r
- dest[336 + pos] = new_v26;\r
- dest[352 + pos] = new_v25;\r
- dest[368 + pos] = new_v24;\r
- dest[384 + pos] = new_v23;\r
- dest[400 + pos] = new_v22;\r
- dest[416 + pos] = new_v21;\r
- dest[432 + pos] = new_v20;\r
- dest[448 + pos] = new_v19;\r
- dest[464 + pos] = new_v18;\r
- dest[480 + pos] = new_v17;\r
- dest[496 + pos] = new_v16; \r
+ v2[272 + actual_write_pos] = new_v30;\r
+ v2[288 + actual_write_pos] = new_v29;\r
+ v2[304 + actual_write_pos] = new_v28;\r
+ v2[320 + actual_write_pos] = new_v27;\r
+ v2[336 + actual_write_pos] = new_v26;\r
+ v2[352 + actual_write_pos] = new_v25;\r
+ v2[368 + actual_write_pos] = new_v24;\r
+ v2[384 + actual_write_pos] = new_v23;\r
+ v2[400 + actual_write_pos] = new_v22;\r
+ v2[416 + actual_write_pos] = new_v21;\r
+ v2[432 + actual_write_pos] = new_v20;\r
+ v2[448 + actual_write_pos] = new_v19;\r
+ v2[464 + actual_write_pos] = new_v18;\r
+ v2[480 + actual_write_pos] = new_v17;\r
+ v2[496 + actual_write_pos] = new_v16;\r
+ } \r
+ else{\r
+ v1[0 + actual_write_pos] = -new_v0;\r
+ v1[16 + actual_write_pos] = new_v16;\r
+ v1[32 + actual_write_pos] = new_v17;\r
+ v1[48 + actual_write_pos] = new_v18;\r
+ v1[64 + actual_write_pos] = new_v19;\r
+ v1[80 + actual_write_pos] = new_v20;\r
+ v1[96 + actual_write_pos] = new_v21;\r
+ v1[112 + actual_write_pos] = new_v22;\r
+ v1[128 + actual_write_pos] = new_v23;\r
+ v1[144 + actual_write_pos] = new_v24;\r
+ v1[160 + actual_write_pos] = new_v25;\r
+ v1[176 + actual_write_pos] = new_v26;\r
+ v1[192 + actual_write_pos] = new_v27;\r
+ v1[208 + actual_write_pos] = new_v28;\r
+ v1[224 + actual_write_pos] = new_v29;\r
+ v1[240 + actual_write_pos] = new_v30;\r
+ v1[256 + actual_write_pos] = new_v31;\r
+ \r
+ // insert V[49-63] (== new_v[30-16]) into other v:\r
+ v1[272 + actual_write_pos] = new_v30;\r
+ v1[288 + actual_write_pos] = new_v29;\r
+ v1[304 + actual_write_pos] = new_v28;\r
+ v1[320 + actual_write_pos] = new_v27;\r
+ v1[336 + actual_write_pos] = new_v26;\r
+ v1[352 + actual_write_pos] = new_v25;\r
+ v1[368 + actual_write_pos] = new_v24;\r
+ v1[384 + actual_write_pos] = new_v23;\r
+ v1[400 + actual_write_pos] = new_v22;\r
+ v1[416 + actual_write_pos] = new_v21;\r
+ v1[432 + actual_write_pos] = new_v20;\r
+ v1[448 + actual_write_pos] = new_v19;\r
+ v1[464 + actual_write_pos] = new_v18;\r
+ v1[480 + actual_write_pos] = new_v17;\r
+ v1[496 + actual_write_pos] = new_v16;\r
+ }\r
/*\r
}\r
else\r
* Compute PCM Samples.\r
*/\r
\r
- private float[] _tmpOut = new float[32];\r
- \r
+ @LOC("TMP") private float[] _tmpOut = new float[32];\r
\r
- private void compute_pcm_samples0(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples0(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v; \r
+ //final float[] vp = actual_v; //subbed in variable name instead to reduce areas \r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut; //subbed in variable name instread to reduce areas\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
- {\r
- float pcm_sample;\r
- final float[] dp = d16[i];\r
- pcm_sample = (float)(((vp[0 + dvp] * dp[0]) +\r
- (vp[15 + dvp] * dp[1]) +\r
- (vp[14 + dvp] * dp[2]) +\r
- (vp[13 + dvp] * dp[3]) +\r
- (vp[12 + dvp] * dp[4]) +\r
- (vp[11 + dvp] * dp[5]) +\r
- (vp[10 + dvp] * dp[6]) +\r
- (vp[9 + dvp] * dp[7]) +\r
- (vp[8 + dvp] * dp[8]) +\r
- (vp[7 + dvp] * dp[9]) +\r
- (vp[6 + dvp] * dp[10]) +\r
- (vp[5 + dvp] * dp[11]) +\r
- (vp[4 + dvp] * dp[12]) +\r
- (vp[3 + dvp] * dp[13]) +\r
- (vp[2 + dvp] * dp[14]) +\r
- (vp[1 + dvp] * dp[15])\r
+ for(@LOC("I") int i=0; i<32; i++)\r
+ {\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+ //final float[] dp = d16[i]; //subbed in variable name instead to reduce areas\r
+ pcm_sample = (float)(((actual_v[0 + dvp] * d16[i][0]) +\r
+ (actual_v[15 + dvp] * d16[i][1]) +\r
+ (actual_v[14 + dvp] * d16[i][2]) +\r
+ (actual_v[13 + dvp] * d16[i][3]) +\r
+ (actual_v[12 + dvp] * d16[i][4]) +\r
+ (actual_v[11 + dvp] * d16[i][5]) +\r
+ (actual_v[10 + dvp] * d16[i][6]) +\r
+ (actual_v[9 + dvp] * d16[i][7]) +\r
+ (actual_v[8 + dvp] * d16[i][8]) +\r
+ (actual_v[7 + dvp] * d16[i][9]) +\r
+ (actual_v[6 + dvp] * d16[i][10]) +\r
+ (actual_v[5 + dvp] * d16[i][11]) +\r
+ (actual_v[4 + dvp] * d16[i][12]) +\r
+ (actual_v[3 + dvp] * d16[i][13]) +\r
+ (actual_v[2 + dvp] * d16[i][14]) +\r
+ (actual_v[1 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- \r
- private void compute_pcm_samples1(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples1(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v; \r
+ //final float[] vp = actual_v; \r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[1 + dvp] * dp[0]) +\r
- (vp[0 + dvp] * dp[1]) +\r
- (vp[15 + dvp] * dp[2]) +\r
- (vp[14 + dvp] * dp[3]) +\r
- (vp[13 + dvp] * dp[4]) +\r
- (vp[12 + dvp] * dp[5]) +\r
- (vp[11 + dvp] * dp[6]) +\r
- (vp[10 + dvp] * dp[7]) +\r
- (vp[9 + dvp] * dp[8]) +\r
- (vp[8 + dvp] * dp[9]) +\r
- (vp[7 + dvp] * dp[10]) +\r
- (vp[6 + dvp] * dp[11]) +\r
- (vp[5 + dvp] * dp[12]) +\r
- (vp[4 + dvp] * dp[13]) +\r
- (vp[3 + dvp] * dp[14]) +\r
- (vp[2 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[1 + dvp] * d16[i][0]) +\r
+ (actual_v[0 + dvp] * d16[i][1]) +\r
+ (actual_v[15 + dvp] * d16[i][2]) +\r
+ (actual_v[14 + dvp] * d16[i][3]) +\r
+ (actual_v[13 + dvp] * d16[i][4]) +\r
+ (actual_v[12 + dvp] * d16[i][5]) +\r
+ (actual_v[11 + dvp] * d16[i][6]) +\r
+ (actual_v[10 + dvp] * d16[i][7]) +\r
+ (actual_v[9 + dvp] * d16[i][8]) +\r
+ (actual_v[8 + dvp] * d16[i][9]) +\r
+ (actual_v[7 + dvp] * d16[i][10]) +\r
+ (actual_v[6 + dvp] * d16[i][11]) +\r
+ (actual_v[5 + dvp] * d16[i][12]) +\r
+ (actual_v[4 + dvp] * d16[i][13]) +\r
+ (actual_v[3 + dvp] * d16[i][14]) +\r
+ (actual_v[2 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
- \r
+ _tmpOut[i] = pcm_sample;\r
+// actual_v\r
dvp += 16;\r
} // for\r
}\r
- private void compute_pcm_samples2(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples2(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[2 + dvp] * dp[0]) +\r
- (vp[1 + dvp] * dp[1]) +\r
- (vp[0 + dvp] * dp[2]) +\r
- (vp[15 + dvp] * dp[3]) +\r
- (vp[14 + dvp] * dp[4]) +\r
- (vp[13 + dvp] * dp[5]) +\r
- (vp[12 + dvp] * dp[6]) +\r
- (vp[11 + dvp] * dp[7]) +\r
- (vp[10 + dvp] * dp[8]) +\r
- (vp[9 + dvp] * dp[9]) +\r
- (vp[8 + dvp] * dp[10]) +\r
- (vp[7 + dvp] * dp[11]) +\r
- (vp[6 + dvp] * dp[12]) +\r
- (vp[5 + dvp] * dp[13]) +\r
- (vp[4 + dvp] * dp[14]) +\r
- (vp[3 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[2 + dvp] * d16[i][0]) +\r
+ (actual_v[1 + dvp] * d16[i][1]) +\r
+ (actual_v[0 + dvp] * d16[i][2]) +\r
+ (actual_v[15 + dvp] * d16[i][3]) +\r
+ (actual_v[14 + dvp] * d16[i][4]) +\r
+ (actual_v[13 + dvp] * d16[i][5]) +\r
+ (actual_v[12 + dvp] * d16[i][6]) +\r
+ (actual_v[11 + dvp] * d16[i][7]) +\r
+ (actual_v[10 + dvp] * d16[i][8]) +\r
+ (actual_v[9 + dvp] * d16[i][9]) +\r
+ (actual_v[8 + dvp] * d16[i][10]) +\r
+ (actual_v[7 + dvp] * d16[i][11]) +\r
+ (actual_v[6 + dvp] * d16[i][12]) +\r
+ (actual_v[5 + dvp] * d16[i][13]) +\r
+ (actual_v[4 + dvp] * d16[i][14]) +\r
+ (actual_v[3 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
- }\r
- \r
- private void compute_pcm_samples3(Obuffer buffer)\r
+ }\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS") \r
+ private void compute_pcm_samples3(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
int idx = 0;\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[3 + dvp] * dp[0]) +\r
- (vp[2 + dvp] * dp[1]) +\r
- (vp[1 + dvp] * dp[2]) +\r
- (vp[0 + dvp] * dp[3]) +\r
- (vp[15 + dvp] * dp[4]) +\r
- (vp[14 + dvp] * dp[5]) +\r
- (vp[13 + dvp] * dp[6]) +\r
- (vp[12 + dvp] * dp[7]) +\r
- (vp[11 + dvp] * dp[8]) +\r
- (vp[10 + dvp] * dp[9]) +\r
- (vp[9 + dvp] * dp[10]) +\r
- (vp[8 + dvp] * dp[11]) +\r
- (vp[7 + dvp] * dp[12]) +\r
- (vp[6 + dvp] * dp[13]) +\r
- (vp[5 + dvp] * dp[14]) +\r
- (vp[4 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float) ( ( (actual_v[3 + dvp] * d16[i][0]) +\r
+ (actual_v[2 + dvp] * d16[i][1]) +\r
+ (actual_v[1 + dvp] * d16[i][2]) +\r
+ (actual_v[0 + dvp] * d16[i][3]) +\r
+ (actual_v[15 + dvp] * d16[i][4]) +\r
+ (actual_v[14 + dvp] * d16[i][5]) +\r
+ (actual_v[13 + dvp] * d16[i][6]) +\r
+ (actual_v[12 + dvp] * d16[i][7]) +\r
+ (actual_v[11 + dvp] * d16[i][8]) +\r
+ (actual_v[10 + dvp] * d16[i][9]) +\r
+ (actual_v[9 + dvp] * d16[i][10]) +\r
+ (actual_v[8 + dvp] * d16[i][11]) +\r
+ (actual_v[7 + dvp] * d16[i][12]) +\r
+ (actual_v[6 + dvp] * d16[i][13]) +\r
+ (actual_v[5 + dvp] * d16[i][14]) +\r
+ (actual_v[4 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
- }\r
- \r
- private void compute_pcm_samples4(Obuffer buffer)\r
+ }\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS") \r
+ private void compute_pcm_samples4(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[4 + dvp] * dp[0]) +\r
- (vp[3 + dvp] * dp[1]) +\r
- (vp[2 + dvp] * dp[2]) +\r
- (vp[1 + dvp] * dp[3]) +\r
- (vp[0 + dvp] * dp[4]) +\r
- (vp[15 + dvp] * dp[5]) +\r
- (vp[14 + dvp] * dp[6]) +\r
- (vp[13 + dvp] * dp[7]) +\r
- (vp[12 + dvp] * dp[8]) +\r
- (vp[11 + dvp] * dp[9]) +\r
- (vp[10 + dvp] * dp[10]) +\r
- (vp[9 + dvp] * dp[11]) +\r
- (vp[8 + dvp] * dp[12]) +\r
- (vp[7 + dvp] * dp[13]) +\r
- (vp[6 + dvp] * dp[14]) +\r
- (vp[5 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[4 + dvp] * d16[i][0]) +\r
+ (actual_v[3 + dvp] * d16[i][1]) +\r
+ (actual_v[2 + dvp] * d16[i][2]) +\r
+ (actual_v[1 + dvp] * d16[i][3]) +\r
+ (actual_v[0 + dvp] * d16[i][4]) +\r
+ (actual_v[15 + dvp] * d16[i][5]) +\r
+ (actual_v[14 + dvp] * d16[i][6]) +\r
+ (actual_v[13 + dvp] * d16[i][7]) +\r
+ (actual_v[12 + dvp] * d16[i][8]) +\r
+ (actual_v[11 + dvp] * d16[i][9]) +\r
+ (actual_v[10 + dvp] * d16[i][10]) +\r
+ (actual_v[9 + dvp] * d16[i][11]) +\r
+ (actual_v[8 + dvp] * d16[i][12]) +\r
+ (actual_v[7 + dvp] * d16[i][13]) +\r
+ (actual_v[6 + dvp] * d16[i][14]) +\r
+ (actual_v[5 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- \r
- private void compute_pcm_samples5(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples5(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[5 + dvp] * dp[0]) +\r
- (vp[4 + dvp] * dp[1]) +\r
- (vp[3 + dvp] * dp[2]) +\r
- (vp[2 + dvp] * dp[3]) +\r
- (vp[1 + dvp] * dp[4]) +\r
- (vp[0 + dvp] * dp[5]) +\r
- (vp[15 + dvp] * dp[6]) +\r
- (vp[14 + dvp] * dp[7]) +\r
- (vp[13 + dvp] * dp[8]) +\r
- (vp[12 + dvp] * dp[9]) +\r
- (vp[11 + dvp] * dp[10]) +\r
- (vp[10 + dvp] * dp[11]) +\r
- (vp[9 + dvp] * dp[12]) +\r
- (vp[8 + dvp] * dp[13]) +\r
- (vp[7 + dvp] * dp[14]) +\r
- (vp[6 + dvp] * dp[15])\r
+ // final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[5 + dvp] * d16[i][0]) +\r
+ (actual_v[4 + dvp] * d16[i][1]) +\r
+ (actual_v[3 + dvp] * d16[i][2]) +\r
+ (actual_v[2 + dvp] * d16[i][3]) +\r
+ (actual_v[1 + dvp] * d16[i][4]) +\r
+ (actual_v[0 + dvp] * d16[i][5]) +\r
+ (actual_v[15 + dvp] * d16[i][6]) +\r
+ (actual_v[14 + dvp] * d16[i][7]) +\r
+ (actual_v[13 + dvp] * d16[i][8]) +\r
+ (actual_v[12 + dvp] * d16[i][9]) +\r
+ (actual_v[11 + dvp] * d16[i][10]) +\r
+ (actual_v[10 + dvp] * d16[i][11]) +\r
+ (actual_v[9 + dvp] * d16[i][12]) +\r
+ (actual_v[8 + dvp] * d16[i][13]) +\r
+ (actual_v[7 + dvp] * d16[i][14]) +\r
+ (actual_v[6 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- \r
- private void compute_pcm_samples6(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples6(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v; \r
+ //final float[] vp = actual_v; \r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[6 + dvp] * dp[0]) +\r
- (vp[5 + dvp] * dp[1]) +\r
- (vp[4 + dvp] * dp[2]) +\r
- (vp[3 + dvp] * dp[3]) +\r
- (vp[2 + dvp] * dp[4]) +\r
- (vp[1 + dvp] * dp[5]) +\r
- (vp[0 + dvp] * dp[6]) +\r
- (vp[15 + dvp] * dp[7]) +\r
- (vp[14 + dvp] * dp[8]) +\r
- (vp[13 + dvp] * dp[9]) +\r
- (vp[12 + dvp] * dp[10]) +\r
- (vp[11 + dvp] * dp[11]) +\r
- (vp[10 + dvp] * dp[12]) +\r
- (vp[9 + dvp] * dp[13]) +\r
- (vp[8 + dvp] * dp[14]) +\r
- (vp[7 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[6 + dvp] * d16[i][0]) +\r
+ (actual_v[5 + dvp] * d16[i][1]) +\r
+ (actual_v[4 + dvp] * d16[i][2]) +\r
+ (actual_v[3 + dvp] * d16[i][3]) +\r
+ (actual_v[2 + dvp] * d16[i][4]) +\r
+ (actual_v[1 + dvp] * d16[i][5]) +\r
+ (actual_v[0 + dvp] * d16[i][6]) +\r
+ (actual_v[15 + dvp] * d16[i][7]) +\r
+ (actual_v[14 + dvp] * d16[i][8]) +\r
+ (actual_v[13 + dvp] * d16[i][9]) +\r
+ (actual_v[12 + dvp] * d16[i][10]) +\r
+ (actual_v[11 + dvp] * d16[i][11]) +\r
+ (actual_v[10 + dvp] * d16[i][12]) +\r
+ (actual_v[9 + dvp] * d16[i][13]) +\r
+ (actual_v[8 + dvp] * d16[i][14]) +\r
+ (actual_v[7 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- \r
- private void compute_pcm_samples7(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples7(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[7 + dvp] * dp[0]) +\r
- (vp[6 + dvp] * dp[1]) +\r
- (vp[5 + dvp] * dp[2]) +\r
- (vp[4 + dvp] * dp[3]) +\r
- (vp[3 + dvp] * dp[4]) +\r
- (vp[2 + dvp] * dp[5]) +\r
- (vp[1 + dvp] * dp[6]) +\r
- (vp[0 + dvp] * dp[7]) +\r
- (vp[15 + dvp] * dp[8]) +\r
- (vp[14 + dvp] * dp[9]) +\r
- (vp[13 + dvp] * dp[10]) +\r
- (vp[12 + dvp] * dp[11]) +\r
- (vp[11 + dvp] * dp[12]) +\r
- (vp[10 + dvp] * dp[13]) +\r
- (vp[9 + dvp] * dp[14]) +\r
- (vp[8 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[7 + dvp] * d16[i][0]) +\r
+ (actual_v[6 + dvp] * d16[i][1]) +\r
+ (actual_v[5 + dvp] * d16[i][2]) +\r
+ (actual_v[4 + dvp] * d16[i][3]) +\r
+ (actual_v[3 + dvp] * d16[i][4]) +\r
+ (actual_v[2 + dvp] * d16[i][5]) +\r
+ (actual_v[1 + dvp] * d16[i][6]) +\r
+ (actual_v[0 + dvp] * d16[i][7]) +\r
+ (actual_v[15 + dvp] * d16[i][8]) +\r
+ (actual_v[14 + dvp] * d16[i][9]) +\r
+ (actual_v[13 + dvp] * d16[i][10]) +\r
+ (actual_v[12 + dvp] * d16[i][11]) +\r
+ (actual_v[11 + dvp] * d16[i][12]) +\r
+ (actual_v[10 + dvp] * d16[i][13]) +\r
+ (actual_v[9 + dvp] * d16[i][14]) +\r
+ (actual_v[8 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
- }\r
- private void compute_pcm_samples8(Obuffer buffer)\r
+ }\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples8(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[8 + dvp] * dp[0]) +\r
- (vp[7 + dvp] * dp[1]) +\r
- (vp[6 + dvp] * dp[2]) +\r
- (vp[5 + dvp] * dp[3]) +\r
- (vp[4 + dvp] * dp[4]) +\r
- (vp[3 + dvp] * dp[5]) +\r
- (vp[2 + dvp] * dp[6]) +\r
- (vp[1 + dvp] * dp[7]) +\r
- (vp[0 + dvp] * dp[8]) +\r
- (vp[15 + dvp] * dp[9]) +\r
- (vp[14 + dvp] * dp[10]) +\r
- (vp[13 + dvp] * dp[11]) +\r
- (vp[12 + dvp] * dp[12]) +\r
- (vp[11 + dvp] * dp[13]) +\r
- (vp[10 + dvp] * dp[14]) +\r
- (vp[9 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[8 + dvp] * d16[i][0]) +\r
+ (actual_v[7 + dvp] * d16[i][1]) +\r
+ (actual_v[6 + dvp] * d16[i][2]) +\r
+ (actual_v[5 + dvp] * d16[i][3]) +\r
+ (actual_v[4 + dvp] * d16[i][4]) +\r
+ (actual_v[3 + dvp] * d16[i][5]) +\r
+ (actual_v[2 + dvp] * d16[i][6]) +\r
+ (actual_v[1 + dvp] * d16[i][7]) +\r
+ (actual_v[0 + dvp] * d16[i][8]) +\r
+ (actual_v[15 + dvp] * d16[i][9]) +\r
+ (actual_v[14 + dvp] * d16[i][10]) +\r
+ (actual_v[13 + dvp] * d16[i][11]) +\r
+ (actual_v[12 + dvp] * d16[i][12]) +\r
+ (actual_v[11 + dvp] * d16[i][13]) +\r
+ (actual_v[10 + dvp] * d16[i][14]) +\r
+ (actual_v[9 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- \r
- private void compute_pcm_samples9(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples9(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[9 + dvp] * dp[0]) +\r
- (vp[8 + dvp] * dp[1]) +\r
- (vp[7 + dvp] * dp[2]) +\r
- (vp[6 + dvp] * dp[3]) +\r
- (vp[5 + dvp] * dp[4]) +\r
- (vp[4 + dvp] * dp[5]) +\r
- (vp[3 + dvp] * dp[6]) +\r
- (vp[2 + dvp] * dp[7]) +\r
- (vp[1 + dvp] * dp[8]) +\r
- (vp[0 + dvp] * dp[9]) +\r
- (vp[15 + dvp] * dp[10]) +\r
- (vp[14 + dvp] * dp[11]) +\r
- (vp[13 + dvp] * dp[12]) +\r
- (vp[12 + dvp] * dp[13]) +\r
- (vp[11 + dvp] * dp[14]) +\r
- (vp[10 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[9 + dvp] * d16[i][0]) +\r
+ (actual_v[8 + dvp] * d16[i][1]) +\r
+ (actual_v[7 + dvp] * d16[i][2]) +\r
+ (actual_v[6 + dvp] * d16[i][3]) +\r
+ (actual_v[5 + dvp] * d16[i][4]) +\r
+ (actual_v[4 + dvp] * d16[i][5]) +\r
+ (actual_v[3 + dvp] * d16[i][6]) +\r
+ (actual_v[2 + dvp] * d16[i][7]) +\r
+ (actual_v[1 + dvp] * d16[i][8]) +\r
+ (actual_v[0 + dvp] * d16[i][9]) +\r
+ (actual_v[15 + dvp] * d16[i][10]) +\r
+ (actual_v[14 + dvp] * d16[i][11]) +\r
+ (actual_v[13 + dvp] * d16[i][12]) +\r
+ (actual_v[12 + dvp] * d16[i][13]) +\r
+ (actual_v[11 + dvp] * d16[i][14]) +\r
+ (actual_v[10 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- \r
- private void compute_pcm_samples10(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples10(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v; \r
+ //final float[] vp = actual_v; \r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[10 + dvp] * dp[0]) +\r
- (vp[9 + dvp] * dp[1]) +\r
- (vp[8 + dvp] * dp[2]) +\r
- (vp[7 + dvp] * dp[3]) +\r
- (vp[6 + dvp] * dp[4]) +\r
- (vp[5 + dvp] * dp[5]) +\r
- (vp[4 + dvp] * dp[6]) +\r
- (vp[3 + dvp] * dp[7]) +\r
- (vp[2 + dvp] * dp[8]) +\r
- (vp[1 + dvp] * dp[9]) +\r
- (vp[0 + dvp] * dp[10]) +\r
- (vp[15 + dvp] * dp[11]) +\r
- (vp[14 + dvp] * dp[12]) +\r
- (vp[13 + dvp] * dp[13]) +\r
- (vp[12 + dvp] * dp[14]) +\r
- (vp[11 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[10 + dvp] * d16[i][0]) +\r
+ (actual_v[9 + dvp] * d16[i][1]) +\r
+ (actual_v[8 + dvp] * d16[i][2]) +\r
+ (actual_v[7 + dvp] * d16[i][3]) +\r
+ (actual_v[6 + dvp] * d16[i][4]) +\r
+ (actual_v[5 + dvp] * d16[i][5]) +\r
+ (actual_v[4 + dvp] * d16[i][6]) +\r
+ (actual_v[3 + dvp] * d16[i][7]) +\r
+ (actual_v[2 + dvp] * d16[i][8]) +\r
+ (actual_v[1 + dvp] * d16[i][9]) +\r
+ (actual_v[0 + dvp] * d16[i][10]) +\r
+ (actual_v[15 + dvp] * d16[i][11]) +\r
+ (actual_v[14 + dvp] * d16[i][12]) +\r
+ (actual_v[13 + dvp] * d16[i][13]) +\r
+ (actual_v[12 + dvp] * d16[i][14]) +\r
+ (actual_v[11 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- private void compute_pcm_samples11(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples11(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[11 + dvp] * dp[0]) +\r
- (vp[10 + dvp] * dp[1]) +\r
- (vp[9 + dvp] * dp[2]) +\r
- (vp[8 + dvp] * dp[3]) +\r
- (vp[7 + dvp] * dp[4]) +\r
- (vp[6 + dvp] * dp[5]) +\r
- (vp[5 + dvp] * dp[6]) +\r
- (vp[4 + dvp] * dp[7]) +\r
- (vp[3 + dvp] * dp[8]) +\r
- (vp[2 + dvp] * dp[9]) +\r
- (vp[1 + dvp] * dp[10]) +\r
- (vp[0 + dvp] * dp[11]) +\r
- (vp[15 + dvp] * dp[12]) +\r
- (vp[14 + dvp] * dp[13]) +\r
- (vp[13 + dvp] * dp[14]) +\r
- (vp[12 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[11 + dvp] * d16[i][0]) +\r
+ (actual_v[10 + dvp] * d16[i][1]) +\r
+ (actual_v[9 + dvp] * d16[i][2]) +\r
+ (actual_v[8 + dvp] * d16[i][3]) +\r
+ (actual_v[7 + dvp] * d16[i][4]) +\r
+ (actual_v[6 + dvp] * d16[i][5]) +\r
+ (actual_v[5 + dvp] * d16[i][6]) +\r
+ (actual_v[4 + dvp] * d16[i][7]) +\r
+ (actual_v[3 + dvp] * d16[i][8]) +\r
+ (actual_v[2 + dvp] * d16[i][9]) +\r
+ (actual_v[1 + dvp] * d16[i][10]) +\r
+ (actual_v[0 + dvp] * d16[i][11]) +\r
+ (actual_v[15 + dvp] * d16[i][12]) +\r
+ (actual_v[14 + dvp] * d16[i][13]) +\r
+ (actual_v[13 + dvp] * d16[i][14]) +\r
+ (actual_v[12 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- private void compute_pcm_samples12(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples12(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v; \r
+ //final float[] vp = actual_v; \r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[12 + dvp] * dp[0]) +\r
- (vp[11 + dvp] * dp[1]) +\r
- (vp[10 + dvp] * dp[2]) +\r
- (vp[9 + dvp] * dp[3]) +\r
- (vp[8 + dvp] * dp[4]) +\r
- (vp[7 + dvp] * dp[5]) +\r
- (vp[6 + dvp] * dp[6]) +\r
- (vp[5 + dvp] * dp[7]) +\r
- (vp[4 + dvp] * dp[8]) +\r
- (vp[3 + dvp] * dp[9]) +\r
- (vp[2 + dvp] * dp[10]) +\r
- (vp[1 + dvp] * dp[11]) +\r
- (vp[0 + dvp] * dp[12]) +\r
- (vp[15 + dvp] * dp[13]) +\r
- (vp[14 + dvp] * dp[14]) +\r
- (vp[13 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[12 + dvp] * d16[i][0]) +\r
+ (actual_v[11 + dvp] * d16[i][1]) +\r
+ (actual_v[10 + dvp] * d16[i][2]) +\r
+ (actual_v[9 + dvp] * d16[i][3]) +\r
+ (actual_v[8 + dvp] * d16[i][4]) +\r
+ (actual_v[7 + dvp] * d16[i][5]) +\r
+ (actual_v[6 + dvp] * d16[i][6]) +\r
+ (actual_v[5 + dvp] * d16[i][7]) +\r
+ (actual_v[4 + dvp] * d16[i][8]) +\r
+ (actual_v[3 + dvp] * d16[i][9]) +\r
+ (actual_v[2 + dvp] * d16[i][10]) +\r
+ (actual_v[1 + dvp] * d16[i][11]) +\r
+ (actual_v[0 + dvp] * d16[i][12]) +\r
+ (actual_v[15 + dvp] * d16[i][13]) +\r
+ (actual_v[14 + dvp] * d16[i][14]) +\r
+ (actual_v[13 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
- }\r
- private void compute_pcm_samples13(Obuffer buffer)\r
+ }\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples13(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[13 + dvp] * dp[0]) +\r
- (vp[12 + dvp] * dp[1]) +\r
- (vp[11 + dvp] * dp[2]) +\r
- (vp[10 + dvp] * dp[3]) +\r
- (vp[9 + dvp] * dp[4]) +\r
- (vp[8 + dvp] * dp[5]) +\r
- (vp[7 + dvp] * dp[6]) +\r
- (vp[6 + dvp] * dp[7]) +\r
- (vp[5 + dvp] * dp[8]) +\r
- (vp[4 + dvp] * dp[9]) +\r
- (vp[3 + dvp] * dp[10]) +\r
- (vp[2 + dvp] * dp[11]) +\r
- (vp[1 + dvp] * dp[12]) +\r
- (vp[0 + dvp] * dp[13]) +\r
- (vp[15 + dvp] * dp[14]) +\r
- (vp[14 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[13 + dvp] * d16[i][0]) +\r
+ (actual_v[12 + dvp] * d16[i][1]) +\r
+ (actual_v[11 + dvp] * d16[i][2]) +\r
+ (actual_v[10 + dvp] * d16[i][3]) +\r
+ (actual_v[9 + dvp] * d16[i][4]) +\r
+ (actual_v[8 + dvp] * d16[i][5]) +\r
+ (actual_v[7 + dvp] * d16[i][6]) +\r
+ (actual_v[6 + dvp] * d16[i][7]) +\r
+ (actual_v[5 + dvp] * d16[i][8]) +\r
+ (actual_v[4 + dvp] * d16[i][9]) +\r
+ (actual_v[3 + dvp] * d16[i][10]) +\r
+ (actual_v[2 + dvp] * d16[i][11]) +\r
+ (actual_v[1 + dvp] * d16[i][12]) +\r
+ (actual_v[0 + dvp] * d16[i][13]) +\r
+ (actual_v[15 + dvp] * d16[i][14]) +\r
+ (actual_v[14 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- private void compute_pcm_samples14(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples14(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- final float[] dp = d16[i];\r
- float pcm_sample;\r
-\r
- pcm_sample = (float)(((vp[14 + dvp] * dp[0]) +\r
- (vp[13 + dvp] * dp[1]) +\r
- (vp[12 + dvp] * dp[2]) +\r
- (vp[11 + dvp] * dp[3]) +\r
- (vp[10 + dvp] * dp[4]) +\r
- (vp[9 + dvp] * dp[5]) +\r
- (vp[8 + dvp] * dp[6]) +\r
- (vp[7 + dvp] * dp[7]) +\r
- (vp[6 + dvp] * dp[8]) +\r
- (vp[5 + dvp] * dp[9]) +\r
- (vp[4 + dvp] * dp[10]) +\r
- (vp[3 + dvp] * dp[11]) +\r
- (vp[2 + dvp] * dp[12]) +\r
- (vp[1 + dvp] * dp[13]) +\r
- (vp[0 + dvp] * dp[14]) +\r
- (vp[15 + dvp] * dp[15])\r
+ //final float[] dp = d16[i];\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+\r
+ pcm_sample = (float)(((actual_v[14 + dvp] * d16[i][0]) +\r
+ (actual_v[13 + dvp] * d16[i][1]) +\r
+ (actual_v[12 + dvp] * d16[i][2]) +\r
+ (actual_v[11 + dvp] * d16[i][3]) +\r
+ (actual_v[10 + dvp] * d16[i][4]) +\r
+ (actual_v[9 + dvp] * d16[i][5]) +\r
+ (actual_v[8 + dvp] * d16[i][6]) +\r
+ (actual_v[7 + dvp] * d16[i][7]) +\r
+ (actual_v[6 + dvp] * d16[i][8]) +\r
+ (actual_v[5 + dvp] * d16[i][9]) +\r
+ (actual_v[4 + dvp] * d16[i][10]) +\r
+ (actual_v[3 + dvp] * d16[i][11]) +\r
+ (actual_v[2 + dvp] * d16[i][12]) +\r
+ (actual_v[1 + dvp] * d16[i][13]) +\r
+ (actual_v[0 + dvp] * d16[i][14]) +\r
+ (actual_v[15 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample;\r
+ _tmpOut[i] = pcm_sample;\r
\r
dvp += 16;\r
} // for\r
}\r
- private void compute_pcm_samples15(Obuffer buffer)\r
+ @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS")\r
+ private void compute_pcm_samples15(@LOC("THIS") Obuffer buffer)\r
{\r
- final float[] vp = actual_v;\r
+ //final float[] vp = actual_v;\r
\r
//int inc = v_inc;\r
- final float[] tmpOut = _tmpOut;\r
- int dvp =0;\r
+ //final float[] tmpOut = _tmpOut;\r
+ @LOC("DVP") int dvp =0;\r
\r
// fat chance of having this loop unroll\r
- for( int i=0; i<32; i++)\r
+ for(@LOC("I") int i=0; i<32; i++)\r
{\r
- float pcm_sample;\r
- final float dp[] = d16[i];\r
- pcm_sample = (float)(((vp[15 + dvp] * dp[0]) +\r
- (vp[14 + dvp] * dp[1]) +\r
- (vp[13 + dvp] * dp[2]) +\r
- (vp[12 + dvp] * dp[3]) +\r
- (vp[11 + dvp] * dp[4]) +\r
- (vp[10 + dvp] * dp[5]) +\r
- (vp[9 + dvp] * dp[6]) +\r
- (vp[8 + dvp] * dp[7]) +\r
- (vp[7 + dvp] * dp[8]) +\r
- (vp[6 + dvp] * dp[9]) +\r
- (vp[5 + dvp] * dp[10]) +\r
- (vp[4 + dvp] * dp[11]) +\r
- (vp[3 + dvp] * dp[12]) +\r
- (vp[2 + dvp] * dp[13]) +\r
- (vp[1 + dvp] * dp[14]) +\r
- (vp[0 + dvp] * dp[15])\r
+ @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
+ //final float dp[] = d16[i];\r
+ pcm_sample = (float)(((actual_v[15 + dvp] * d16[i][0]) +\r
+ (actual_v[14 + dvp] * d16[i][1]) +\r
+ (actual_v[13 + dvp] * d16[i][2]) +\r
+ (actual_v[12 + dvp] * d16[i][3]) +\r
+ (actual_v[11 + dvp] * d16[i][4]) +\r
+ (actual_v[10 + dvp] * d16[i][5]) +\r
+ (actual_v[9 + dvp] * d16[i][6]) +\r
+ (actual_v[8 + dvp] * d16[i][7]) +\r
+ (actual_v[7 + dvp] * d16[i][8]) +\r
+ (actual_v[6 + dvp] * d16[i][9]) +\r
+ (actual_v[5 + dvp] * d16[i][10]) +\r
+ (actual_v[4 + dvp] * d16[i][11]) +\r
+ (actual_v[3 + dvp] * d16[i][12]) +\r
+ (actual_v[2 + dvp] * d16[i][13]) +\r
+ (actual_v[1 + dvp] * d16[i][14]) +\r
+ (actual_v[0 + dvp] * d16[i][15])\r
) * scalefactor);\r
\r
- tmpOut[i] = pcm_sample; \r
+ _tmpOut[i] = pcm_sample; \r
dvp += 16;\r
} // for\r
}\r
\r
-private void compute_pcm_samples(Obuffer buffer)\r
+private void compute_pcm_samples(@LOC("GLOBAL") Obuffer buffer)\r
{\r
\r
switch (actual_write_pos)\r
/**\r
* Calculate 32 PCM samples and put the into the Obuffer-object.\r
*/\r
- \r
- public void calculate_pcm_samples(Obuffer buffer)\r
+ \r
+ @LATTICE("V<THIS,THIS<SH,SH*,THISLOC=THIS") \r
+ public void calculate_pcm_samples(@LOC("V") Obuffer buffer)\r
{\r
compute_new_v(); \r
compute_pcm_samples(buffer);\r
\r
// MDM: this may not be necessary. The Layer III decoder always\r
// outputs 32 subband samples, but I haven't checked layer I & II.\r
- for (int p=0;p<32;p++) \r
+ for (@LOC("SH") int p=0;p<32;p++) \r
samples[p] = 0.0f;\r
}\r
\r
\r
- private static final double MY_PI = 3.14159265358979323846;\r
- private static final float cos1_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 64.0)));\r
- private static final float cos3_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 64.0)));\r
- private static final float cos5_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 64.0)));\r
- private static final float cos7_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 64.0)));\r
- private static final float cos9_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 64.0)));\r
- private static final float cos11_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 64.0)));\r
- private static final float cos13_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 64.0)));\r
- private static final float cos15_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 64.0)));\r
- private static final float cos17_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 17.0 / 64.0)));\r
- private static final float cos19_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 19.0 / 64.0)));\r
- private static final float cos21_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 21.0 / 64.0)));\r
- private static final float cos23_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 23.0 / 64.0)));\r
- private static final float cos25_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 25.0 / 64.0)));\r
- private static final float cos27_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 27.0 / 64.0)));\r
- private static final float cos29_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 29.0 / 64.0)));\r
- private static final float cos31_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 31.0 / 64.0)));\r
- private static final float cos1_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 32.0)));\r
- private static final float cos3_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 32.0)));\r
- private static final float cos5_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 32.0)));\r
- private static final float cos7_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 32.0)));\r
- private static final float cos9_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 32.0)));\r
- private static final float cos11_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 32.0)));\r
- private static final float cos13_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 32.0)));\r
- private static final float cos15_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 32.0)));\r
- private static final float cos1_16 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 16.0)));\r
- private static final float cos3_16 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 16.0)));\r
- private static final float cos5_16 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 16.0)));\r
- private static final float cos7_16 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 16.0)));\r
- private static final float cos1_8 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 8.0)));\r
- private static final float cos3_8 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 8.0)));\r
- private static final float cos1_4 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 4.0)));\r
+ @LOC("EQ") private static final double MY_PI = 3.14159265358979323846;\r
+ @LOC("SA") private static final float cos1_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 64.0)));\r
+ @LOC("SA") private static final float cos3_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 64.0)));\r
+ @LOC("SA") private static final float cos5_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 64.0)));\r
+ @LOC("SA") private static final float cos7_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 64.0)));\r
+ @LOC("SA") private static final float cos9_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 64.0)));\r
+ @LOC("SA") private static final float cos11_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 64.0)));\r
+ @LOC("SA") private static final float cos13_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 64.0)));\r
+ @LOC("SA") private static final float cos15_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 64.0)));\r
+ @LOC("SA") private static final float cos17_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 17.0 / 64.0)));\r
+ @LOC("SA") private static final float cos19_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 19.0 / 64.0)));\r
+ @LOC("SA") private static final float cos21_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 21.0 / 64.0)));\r
+ @LOC("SA") private static final float cos23_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 23.0 / 64.0)));\r
+ @LOC("SA") private static final float cos25_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 25.0 / 64.0)));\r
+ @LOC("SA") private static final float cos27_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 27.0 / 64.0)));\r
+ @LOC("SA") private static final float cos29_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 29.0 / 64.0)));\r
+ @LOC("SA") private static final float cos31_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 31.0 / 64.0)));\r
+ @LOC("SA") private static final float cos1_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 32.0)));\r
+ @LOC("SA") private static final float cos3_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 32.0)));\r
+ @LOC("SA") private static final float cos5_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 32.0)));\r
+ @LOC("SA") private static final float cos7_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 32.0)));\r
+ @LOC("SA") private static final float cos9_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 32.0)));\r
+ @LOC("SA") private static final float cos11_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 32.0)));\r
+ @LOC("SA") private static final float cos13_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 32.0)));\r
+ @LOC("SA") private static final float cos15_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 32.0)));\r
+ @LOC("SA") private static final float cos1_16 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 16.0)));\r
+ @LOC("SA") private static final float cos3_16 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 16.0)));\r
+ @LOC("SA") private static final float cos5_16 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 16.0)));\r
+ @LOC("SA") private static final float cos7_16 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 16.0)));\r
+ @LOC("SA") private static final float cos1_8 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 8.0)));\r
+ @LOC("SA") private static final float cos3_8 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 8.0)));\r
+ @LOC("SA") private static final float cos1_4 =(float) (1.0 / (2.0 * Math.cos(MY_PI / 4.0)));\r
\r
// Note: These values are not in the same order\r
// as in Annex 3-B.3 of the ISO/IEC DIS 11172-3 \r
// private float d[] = {0.000000000, -4.000442505};\r
\r
- private static float d[] = null;\r
+ @LOC("V2") private static float d[] = null;\r
\r
/** \r
* d[] split into subarrays of length 16. This provides for\r
* more faster access by allowing a block of 16 to be addressed\r
* with constant offset. \r
**/\r
- private static float d16[][] = null; \r
+ @LOC("V2") private static float d16[][] = null; \r
\r
/**\r
* Loads the data for the d[] from the resource SFd.ser. \r
{\r
try\r
{\r
- Class elemType = Float.TYPE;\r
- Object o = JavaLayerUtils.deserializeArrayResource("sfd.ser", elemType, 512);\r
- return (float[])o;\r
+// Class elemType = Float.TYPE;\r
+// Object o = JavaLayerUtils.deserializeArrayResource("sfd.ser", elemType, 512);\r
+// Object o = JavaLayerUtils.deserializeArrayResource("sfd.ser", 512);\r
+ \r
+ float[] sfd =\r
+ { 0.0f, -4.42505E-4f, 0.003250122f, -0.007003784f, 0.031082153f, -0.07862854f,\r
+ 0.10031128f, -0.57203674f, 1.144989f, 0.57203674f, 0.10031128f, 0.07862854f,\r
+ 0.031082153f, 0.007003784f, 0.003250122f, 4.42505E-4f, -1.5259E-5f, -4.73022E-4f,\r
+ 0.003326416f, -0.007919312f, 0.030517578f, -0.08418274f, 0.090927124f, -0.6002197f,\r
+ 1.1442871f, 0.54382324f, 0.1088562f, 0.07305908f, 0.03147888f, 0.006118774f,\r
+ 0.003173828f, 3.96729E-4f, -1.5259E-5f, -5.34058E-4f, 0.003387451f, -0.008865356f,\r
+ 0.029785156f, -0.08970642f, 0.08068848f, -0.6282959f, 1.1422119f, 0.51560974f,\r
+ 0.11657715f, 0.06752014f, 0.03173828f, 0.0052948f, 0.003082275f, 3.66211E-4f,\r
+ -1.5259E-5f, -5.79834E-4f, 0.003433228f, -0.009841919f, 0.028884888f, -0.09516907f,\r
+ 0.06959534f, -0.6562195f, 1.1387634f, 0.48747253f, 0.12347412f, 0.06199646f,\r
+ 0.031845093f, 0.004486084f, 0.002990723f, 3.20435E-4f, -1.5259E-5f, -6.2561E-4f,\r
+ 0.003463745f, -0.010848999f, 0.027801514f, -0.10054016f, 0.057617188f, -0.6839142f,\r
+ 1.1339264f, 0.45947266f, 0.12957764f, 0.056533813f, 0.031814575f, 0.003723145f,\r
+ 0.00289917f, 2.89917E-4f, -1.5259E-5f, -6.86646E-4f, 0.003479004f, -0.011886597f,\r
+ 0.026535034f, -0.1058197f, 0.044784546f, -0.71131897f, 1.1277466f, 0.43165588f,\r
+ 0.1348877f, 0.051132202f, 0.031661987f, 0.003005981f, 0.002792358f, 2.59399E-4f,\r
+ -1.5259E-5f, -7.47681E-4f, 0.003479004f, -0.012939453f, 0.02508545f, -0.110946655f,\r
+ 0.031082153f, -0.7383728f, 1.120224f, 0.40408325f, 0.13945007f, 0.045837402f,\r
+ 0.03138733f, 0.002334595f, 0.002685547f, 2.44141E-4f, -3.0518E-5f, -8.08716E-4f,\r
+ 0.003463745f, -0.014022827f, 0.023422241f, -0.11592102f, 0.01651001f, -0.7650299f,\r
+ 1.1113739f, 0.37680054f, 0.14326477f, 0.040634155f, 0.03100586f, 0.001693726f,\r
+ 0.002578735f, 2.13623E-4f, -3.0518E-5f, -8.8501E-4f, 0.003417969f, -0.01512146f,\r
+ 0.021575928f, -0.12069702f, 0.001068115f, -0.791214f, 1.1012115f, 0.34986877f,\r
+ 0.1463623f, 0.03555298f, 0.030532837f, 0.001098633f, 0.002456665f, 1.98364E-4f,\r
+ -3.0518E-5f, -9.61304E-4f, 0.003372192f, -0.016235352f, 0.01953125f, -0.1252594f,\r
+ -0.015228271f, -0.816864f, 1.0897827f, 0.32331848f, 0.1487732f, 0.03060913f,\r
+ 0.029937744f, 5.49316E-4f, 0.002349854f, 1.67847E-4f, -3.0518E-5f, -0.001037598f,\r
+ 0.00328064f, -0.017349243f, 0.01725769f, -0.12956238f, -0.03237915f, -0.84194946f,\r
+ 1.0771179f, 0.2972107f, 0.15049744f, 0.025817871f, 0.029281616f, 3.0518E-5f,\r
+ 0.002243042f, 1.52588E-4f, -4.5776E-5f, -0.001113892f, 0.003173828f, -0.018463135f,\r
+ 0.014801025f, -0.1335907f, -0.050354004f, -0.8663635f, 1.0632172f, 0.2715912f,\r
+ 0.15159607f, 0.0211792f, 0.028533936f, -4.42505E-4f, 0.002120972f, 1.37329E-4f,\r
+ -4.5776E-5f, -0.001205444f, 0.003051758f, -0.019577026f, 0.012115479f, -0.13729858f,\r
+ -0.06916809f, -0.89009094f, 1.0481567f, 0.24650574f, 0.15206909f, 0.016708374f,\r
+ 0.02772522f, -8.69751E-4f, 0.00201416f, 1.2207E-4f, -6.1035E-5f, -0.001296997f,\r
+ 0.002883911f, -0.020690918f, 0.009231567f, -0.14067078f, -0.088775635f, -0.9130554f,\r
+ 1.0319366f, 0.22198486f, 0.15196228f, 0.012420654f, 0.02684021f, -0.001266479f,\r
+ 0.001907349f, 1.06812E-4f, -6.1035E-5f, -0.00138855f, 0.002700806f, -0.02178955f,\r
+ 0.006134033f, -0.14367676f, -0.10916138f, -0.9351959f, 1.0146179f, 0.19805908f,\r
+ 0.15130615f, 0.00831604f, 0.025909424f, -0.001617432f, 0.001785278f, 1.06812E-4f,\r
+ -7.6294E-5f, -0.001480103f, 0.002487183f, -0.022857666f, 0.002822876f, -0.1462555f,\r
+ -0.13031006f, -0.95648193f, 0.99624634f, 0.17478943f, 0.15011597f, 0.004394531f,\r
+ 0.024932861f, -0.001937866f, 0.001693726f, 9.1553E-5f, -7.6294E-5f, -0.001586914f,\r
+ 0.002227783f, -0.023910522f, -6.86646E-4f, -0.14842224f, -0.15220642f, -0.9768524f,\r
+ 0.9768524f, 0.15220642f, 0.14842224f, 6.86646E-4f, 0.023910522f, -0.002227783f,\r
+ 0.001586914f, 7.6294E-5f, -9.1553E-5f, -0.001693726f, 0.001937866f, -0.024932861f,\r
+ -0.004394531f, -0.15011597f, -0.17478943f, -0.99624634f, 0.95648193f, 0.13031006f,\r
+ 0.1462555f, -0.002822876f, 0.022857666f, -0.002487183f, 0.001480103f, 7.6294E-5f,\r
+ -1.06812E-4f, -0.001785278f, 0.001617432f, -0.025909424f, -0.00831604f, -0.15130615f,\r
+ -0.19805908f, -1.0146179f, 0.9351959f, 0.10916138f, 0.14367676f, -0.006134033f,\r
+ 0.02178955f, -0.002700806f, 0.00138855f, 6.1035E-5f, -1.06812E-4f, -0.001907349f,\r
+ 0.001266479f, -0.02684021f, -0.012420654f, -0.15196228f, -0.22198486f, -1.0319366f,\r
+ 0.9130554f, 0.088775635f, 0.14067078f, -0.009231567f, 0.020690918f, -0.002883911f,\r
+ 0.001296997f, 6.1035E-5f, -1.2207E-4f, -0.00201416f, 8.69751E-4f, -0.02772522f,\r
+ -0.016708374f, -0.15206909f, -0.24650574f, -1.0481567f, 0.89009094f, 0.06916809f,\r
+ 0.13729858f, -0.012115479f, 0.019577026f, -0.003051758f, 0.001205444f, 4.5776E-5f,\r
+ -1.37329E-4f, -0.002120972f, 4.42505E-4f, -0.028533936f, -0.0211792f, -0.15159607f,\r
+ -0.2715912f, -1.0632172f, 0.8663635f, 0.050354004f, 0.1335907f, -0.014801025f,\r
+ 0.018463135f, -0.003173828f, 0.001113892f, 4.5776E-5f, -1.52588E-4f, -0.002243042f,\r
+ -3.0518E-5f, -0.029281616f, -0.025817871f, -0.15049744f, -0.2972107f, -1.0771179f,\r
+ 0.84194946f, 0.03237915f, 0.12956238f, -0.01725769f, 0.017349243f, -0.00328064f,\r
+ 0.001037598f, 3.0518E-5f, -1.67847E-4f, -0.002349854f, -5.49316E-4f, -0.029937744f,\r
+ -0.03060913f, -0.1487732f, -0.32331848f, -1.0897827f, 0.816864f, 0.015228271f,\r
+ 0.1252594f, -0.01953125f, 0.016235352f, -0.003372192f, 9.61304E-4f, 3.0518E-5f,\r
+ -1.98364E-4f, -0.002456665f, -0.001098633f, -0.030532837f, -0.03555298f, -0.1463623f,\r
+ -0.34986877f, -1.1012115f, 0.791214f, -0.001068115f, 0.12069702f, -0.021575928f,\r
+ 0.01512146f, -0.003417969f, 8.8501E-4f, 3.0518E-5f, -2.13623E-4f, -0.002578735f,\r
+ -0.001693726f, -0.03100586f, -0.040634155f, -0.14326477f, -0.37680054f, -1.1113739f,\r
+ 0.7650299f, -0.01651001f, 0.11592102f, -0.023422241f, 0.014022827f, -0.003463745f,\r
+ 8.08716E-4f, 3.0518E-5f, -2.44141E-4f, -0.002685547f, -0.002334595f, -0.03138733f,\r
+ -0.045837402f, -0.13945007f, -0.40408325f, -1.120224f, 0.7383728f, -0.031082153f,\r
+ 0.110946655f, -0.02508545f, 0.012939453f, -0.003479004f, 7.47681E-4f, 1.5259E-5f,\r
+ -2.59399E-4f, -0.002792358f, -0.003005981f, -0.031661987f, -0.051132202f,\r
+ -0.1348877f, -0.43165588f, -1.1277466f, 0.71131897f, -0.044784546f, 0.1058197f,\r
+ -0.026535034f, 0.011886597f, -0.003479004f, 6.86646E-4f, 1.5259E-5f, -2.89917E-4f,\r
+ -0.00289917f, -0.003723145f, -0.031814575f, -0.056533813f, -0.12957764f,\r
+ -0.45947266f, -1.1339264f, 0.6839142f, -0.057617188f, 0.10054016f, -0.027801514f,\r
+ 0.010848999f, -0.003463745f, 6.2561E-4f, 1.5259E-5f, -3.20435E-4f, -0.002990723f,\r
+ -0.004486084f, -0.031845093f, -0.06199646f, -0.12347412f, -0.48747253f, -1.1387634f,\r
+ 0.6562195f, -0.06959534f, 0.09516907f, -0.028884888f, 0.009841919f, -0.003433228f,\r
+ 5.79834E-4f, 1.5259E-5f, -3.66211E-4f, -0.003082275f, -0.0052948f, -0.03173828f,\r
+ -0.06752014f, -0.11657715f, -0.51560974f, -1.1422119f, 0.6282959f, -0.08068848f,\r
+ 0.08970642f, -0.029785156f, 0.008865356f, -0.003387451f, 5.34058E-4f, 1.5259E-5f,\r
+ -3.96729E-4f, -0.003173828f, -0.006118774f, -0.03147888f, -0.07305908f, -0.1088562f,\r
+ -0.54382324f, -1.1442871f, 0.6002197f, -0.090927124f, 0.08418274f, -0.030517578f,\r
+ 0.007919312f, -0.003326416f, 4.73022E-4f, 1.5259E-5f };\r
+ \r
+ return sfd;\r
}\r
- catch (IOException ex)\r
+// catch (IOException ex)\r
+ catch (Exception ex)\r
{\r
throw new ExceptionInInitializerError(ex);\r
} \r
projects / IRC.git / blobdiff