Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java

   1 /*\r
   2  * 11/19/04 1.0 moved to LGPL.\r
   3  * \r
   4  * 04/01/00 Fixes for running under build 23xx Microsoft JVM. mdm.\r
   5  * \r
   6  * 19/12/99 Performance improvements to compute_pcm_samples().  \r
   7  *                      Mat McGowan. mdm@techie.com. \r
   8  *\r
   9  * 16/02/99 Java Conversion by E.B , javalayer@javazoom.net\r
  10  *\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
  14  *\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
  20  *\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
  25  *\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
  30  */\r
  31 \r
  32 //import java.io.IOException; //Compiler does not support imports\r
  33 \r
  34 /**\r
  35  * A class for the synthesis filter bank. This class does a fast downsampling\r
  36  * from 32, 44.1 or 48 kHz to 8 kHz, if ULAW is defined. Frequencies above 4 kHz\r
  37  * are removed by ignoring higher subbands.\r
  38  */\r
  39 @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
  40 @METHODDEFAULT("OUT<V,V<SH,SH<IN,IN<GLOBAL,SH*,THISLOC=IN,GLOBALLOC=GLOBAL")\r
  41 final class SynthesisFilter {\r
  42   @LOC("V1")\r
  43   private float[] v1;\r
  44   @LOC("V2")\r
  45   private float[] v2;\r
  46   // @LOC("AV") private float[] actual_v; // v1 or v2\r
  47   @LOC("SH")\r
  48   private int actual_write_pos; // 0-15\r
  49   @LOC("SA")\r
  50   private float[] samples; // 32 new subband samples\r
  51   @LOC("V2")\r
  52   private int channel;\r
  53   @LOC("V2")\r
  54   private float scalefactor;\r
  55   @LOC("EQ")\r
  56   private float[] eq;\r
  57 \r
  58   /**\r
  59    * Quality value for controlling CPU usage/quality tradeoff.\r
  60    */\r
  61   /*\r
  62    * private int quality;\r
  63    * \r
  64    * private int v_inc;\r
  65    * \r
  66    * \r
  67    * \r
  68    * public static final int HIGH_QUALITY = 1; public static final int\r
  69    * MEDIUM_QUALITY = 2; public static final int LOW_QUALITY = 4;\r
  70    */\r
  71 \r
  72   /**\r
  73    * Contructor. The scalefactor scales the calculated float pcm samples to\r
  74    * short values (raw pcm samples are in [-1.0, 1.0], if no violations occur).\r
  75    */\r
  76   public SynthesisFilter(int channelnumber, float factor, float[] eq0) {\r
  77     d16 = splitArray(d, 16);\r
  78 \r
  79     v1 = new float[512];\r
  80     v2 = new float[512];\r
  81     samples = new float[32];\r
  82     channel = channelnumber;\r
  83     scalefactor = factor;\r
  84     setEQ(eq);\r
  85     // setQuality(HIGH_QUALITY);\r
  86 \r
  87     reset();\r
  88   }\r
  89 \r
  90   public void setEQ(float[] eq0) {\r
  91     this.eq = eq0;\r
  92     if (eq == null) {\r
  93       eq = new float[32];\r
  94       for (int i = 0; i < 32; i++)\r
  95         eq[i] = 1.0f;\r
  96     }\r
  97     if (eq.length < 32) {\r
  98       throw new IllegalArgumentException("eq0");\r
  99     }\r
 100 \r
 101   }\r
 102 \r
 103   /*\r
 104    * private void setQuality(int quality0) { switch (quality0) { case\r
 105    * HIGH_QUALITY: case MEDIUM_QUALITY: case LOW_QUALITY: v_inc = 16 * quality0;\r
 106    * quality = quality0; break; default : throw new\r
 107    * IllegalArgumentException("Unknown quality value"); } }\r
 108    * \r
 109    * public int getQuality() { return quality; }\r
 110    */\r
 111 \r
 112   /**\r
 113    * Reset the synthesis filter.\r
 114    */\r
 115   public void reset() {\r
 116     // float[] floatp;\r
 117     // float[] floatp2;\r
 118 \r
 119     // initialize v1[] and v2[]:\r
 120     // for (floatp = v1 + 512, floatp2 = v2 + 512; floatp > v1; )\r
 121     // *--floatp = *--floatp2 = 0.0;\r
 122     for (int p = 0; p < 512; p++)\r
 123       v1[p] = v2[p] = 0.0f;\r
 124 \r
 125     // initialize samples[]:\r
 126     // for (floatp = samples + 32; floatp > samples; )\r
 127     // *--floatp = 0.0;\r
 128     for (int p2 = 0; p2 < 32; p2++)\r
 129       samples[p2] = 0.0f;\r
 130 \r
 131     // actual_v = v1;\r
 132     actual_write_pos = 15;\r
 133   }\r
 134 \r
 135   /**\r
 136    * Inject Sample.\r
 137    */\r
 138   @LATTICE("THIS<IN,THISLOC=THIS")\r
 139   public void input_sample(@LOC("IN") float sample, @LOC("IN") int subbandnumber) {\r
 140     samples[subbandnumber] = eq[subbandnumber] * sample;\r
 141   }\r
 142 \r
 143   @LATTICE("TH<IN,IN<C,C*,THISLOC=TH")\r
 144   public void input_samples(@LOC("IN") float[] s) {\r
 145     for (@LOC("C") int i = 31; i >= 0; i--) {\r
 146       samples[i] = s[i] * eq[i];\r
 147     }\r
 148   }\r
 149 \r
 150   /**\r
 151    * Compute new values via a fast cosine transform.\r
 152    */\r
 153   private void compute_new_v() {\r
 154     // p is fully initialized from x1\r
 155     // float[] p = _p;\r
 156     // pp is fully initialized from p\r
 157     // float[] pp = _pp;\r
 158 \r
 159     // float[] new_v = _new_v;\r
 160 \r
 161     // float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure\r
 162     // 3-A.2 in ISO DIS 11172-3\r
 163     // float[] p = new float[16];\r
 164     // float[] pp = new float[16];\r
 165 \r
 166     /*\r
 167      * for (int i=31; i>=0; i--) { new_v[i] = 0.0f; }\r
 168      */\r
 169 \r
 170     @LOC("IN,SynthesisFilter.L4") float new_v0 = 0.0f;\r
 171     @LOC("IN,SynthesisFilter.L2") float new_v1 = 0.0f;\r
 172     @LOC("IN,SynthesisFilter.L4") float new_v2 = 0.0f;\r
 173     @LOC("IN,SynthesisFilter.L2") float new_v3 = 0.0f;\r
 174     @LOC("IN,SynthesisFilter.L3") float new_v4 = 0.0f;\r
 175     @LOC("IN,SynthesisFilter.L4") float new_v5 = 0.0f;\r
 176     @LOC("IN,SynthesisFilter.L2") float new_v6 = 0.0f;\r
 177     @LOC("IN,SynthesisFilter.L3") float new_v7 = 0.0f;\r
 178     @LOC("IN,SynthesisFilter.L4") float new_v8 = 0.0f;\r
 179     @LOC("IN,SynthesisFilter.L4") float new_v9 = 0.0f;\r
 180     @LOC("IN,SynthesisFilter.L3") float new_v10 = 0.0f;\r
 181     @LOC("IN,SynthesisFilter.L2") float new_v11 = 0.0f;\r
 182     @LOC("IN,SynthesisFilter.L4") float new_v12 = 0.0f;\r
 183     @LOC("IN,SynthesisFilter.L3") float new_v13 = 0.0f;\r
 184     @LOC("IN,SynthesisFilter.L4") float new_v14 = 0.0f;\r
 185     @LOC("IN,SynthesisFilter.L4") float new_v15 = 0.0f;\r
 186     @LOC("IN,SynthesisFilter.L1") float new_v16 = 0.0f;\r
 187     @LOC("IN,SynthesisFilter.L3") float new_v17 = 0.0f;\r
 188     @LOC("IN,SynthesisFilter.L1") float new_v18 = 0.0f;\r
 189     @LOC("IN,SynthesisFilter.L2") float new_v19 = 0.0f;\r
 190     @LOC("IN,SynthesisFilter.L2") float new_v20 = 0.0f;\r
 191     @LOC("IN,SynthesisFilter.L2") float new_v21 = 0.0f;\r
 192     @LOC("IN,SynthesisFilter.L2") float new_v22 = 0.0f;\r
 193     @LOC("IN,SynthesisFilter.L3") float new_v23 = 0.0f;\r
 194     @LOC("IN,SynthesisFilter.L2") float new_v24 = 0.0f;\r
 195     @LOC("IN,SynthesisFilter.L2") float new_v25 = 0.0f;\r
 196     @LOC("IN,SynthesisFilter.L2") float new_v26 = 0.0f;\r
 197     @LOC("IN,SynthesisFilter.L4") float new_v27 = 0.0f;\r
 198     @LOC("IN,SynthesisFilter.L2") float new_v28 = 0.0f;\r
 199     @LOC("IN,SynthesisFilter.L4") float new_v29 = 0.0f;\r
 200     @LOC("IN,SynthesisFilter.L2") float new_v30 = 0.0f;\r
 201     @LOC("IN,SynthesisFilter.L4") float new_v31 = 0.0f;\r
 202 \r
 203     // new_v0 = new_v1 = new_v2 = new_v3 = new_v4 = new_v5 = new_v6 = new_v7 =\r
 204     // new_v8 = new_v9 =\r
 205     // new_v10 = new_v11 = new_v12 = new_v13 = new_v14 = new_v15 = new_v16 =\r
 206     // new_v17 = new_v18 = new_v19 =\r
 207     // new_v20 = new_v21 = new_v22 = new_v23 = new_v24 = new_v25 = new_v26 =\r
 208     // new_v27 = new_v28 = new_v29 =\r
 209     // new_v30 = new_v31 = 0.0f;\r
 210 \r
 211     // float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure\r
 212     // 3-A.2 in ISO DIS 11172-3\r
 213     // float[] p = new float[16];\r
 214     // float[] pp = new float[16];\r
 215 \r
 216     // float[] s = samples; // subbed in samples directly below to reduce\r
 217     // uneccesary areas\r
 218 \r
 219     @LOC("IN,SynthesisFilter.S") float s0 = samples[0];\r
 220     @LOC("IN,SynthesisFilter.S") float s1 = samples[1];\r
 221     @LOC("IN,SynthesisFilter.S") float s2 = samples[2];\r
 222     @LOC("IN,SynthesisFilter.S") float s3 = samples[3];\r
 223     @LOC("IN,SynthesisFilter.S") float s4 = samples[4];\r
 224     @LOC("IN,SynthesisFilter.S") float s5 = samples[5];\r
 225     @LOC("IN,SynthesisFilter.S") float s6 = samples[6];\r
 226     @LOC("IN,SynthesisFilter.S") float s7 = samples[7];\r
 227     @LOC("IN,SynthesisFilter.S") float s8 = samples[8];\r
 228     @LOC("IN,SynthesisFilter.S") float s9 = samples[9];\r
 229     @LOC("IN,SynthesisFilter.S") float s10 = samples[10];\r
 230     @LOC("IN,SynthesisFilter.S") float s11 = samples[11];\r
 231     @LOC("IN,SynthesisFilter.S") float s12 = samples[12];\r
 232     @LOC("IN,SynthesisFilter.S") float s13 = samples[13];\r
 233     @LOC("IN,SynthesisFilter.S") float s14 = samples[14];\r
 234     @LOC("IN,SynthesisFilter.S") float s15 = samples[15];\r
 235     @LOC("IN,SynthesisFilter.S") float s16 = samples[16];\r
 236     @LOC("IN,SynthesisFilter.S") float s17 = samples[17];\r
 237     @LOC("IN,SynthesisFilter.S") float s18 = samples[18];\r
 238     @LOC("IN,SynthesisFilter.S") float s19 = samples[19];\r
 239     @LOC("IN,SynthesisFilter.S") float s20 = samples[20];\r
 240     @LOC("IN,SynthesisFilter.S") float s21 = samples[21];\r
 241     @LOC("IN,SynthesisFilter.S") float s22 = samples[22];\r
 242     @LOC("IN,SynthesisFilter.S") float s23 = samples[23];\r
 243     @LOC("IN,SynthesisFilter.S") float s24 = samples[24];\r
 244     @LOC("IN,SynthesisFilter.S") float s25 = samples[25];\r
 245     @LOC("IN,SynthesisFilter.S") float s26 = samples[26];\r
 246     @LOC("IN,SynthesisFilter.S") float s27 = samples[27];\r
 247     @LOC("IN,SynthesisFilter.S") float s28 = samples[28];\r
 248     @LOC("IN,SynthesisFilter.S") float s29 = samples[29];\r
 249     @LOC("IN,SynthesisFilter.S") float s30 = samples[30];\r
 250     @LOC("IN,SynthesisFilter.S") float s31 = samples[31];\r
 251 \r
 252     @LOC("IN,SynthesisFilter.LSH") float p0 = s0 + s31;\r
 253     @LOC("IN,SynthesisFilter.LSH") float p1 = s1 + s30;\r
 254     @LOC("IN,SynthesisFilter.LSH") float p2 = s2 + s29;\r
 255     @LOC("IN,SynthesisFilter.LSH") float p3 = s3 + s28;\r
 256     @LOC("IN,SynthesisFilter.LSH") float p4 = s4 + s27;\r
 257     @LOC("IN,SynthesisFilter.LSH") float p5 = s5 + s26;\r
 258     @LOC("IN,SynthesisFilter.LSH") float p6 = s6 + s25;\r
 259     @LOC("IN,SynthesisFilter.LSH") float p7 = s7 + s24;\r
 260     @LOC("IN,SynthesisFilter.LSH") float p8 = s8 + s23;\r
 261     @LOC("IN,SynthesisFilter.LSH") float p9 = s9 + s22;\r
 262     @LOC("IN,SynthesisFilter.LSH") float p10 = s10 + s21;\r
 263     @LOC("IN,SynthesisFilter.LSH") float p11 = s11 + s20;\r
 264     @LOC("IN,SynthesisFilter.LSH") float p12 = s12 + s19;\r
 265     @LOC("IN,SynthesisFilter.LSH") float p13 = s13 + s18;\r
 266     @LOC("IN,SynthesisFilter.LSH") float p14 = s14 + s17;\r
 267     @LOC("IN,SynthesisFilter.LSH") float p15 = s15 + s16;\r
 268 \r
 269     @LOC("IN,SynthesisFilter.LSH") float pp0 = p0 + p15;\r
 270     @LOC("IN,SynthesisFilter.LSH") float pp1 = p1 + p14;\r
 271     @LOC("IN,SynthesisFilter.LSH") float pp2 = p2 + p13;\r
 272     @LOC("IN,SynthesisFilter.LSH") float pp3 = p3 + p12;\r
 273     @LOC("IN,SynthesisFilter.LSH") float pp4 = p4 + p11;\r
 274     @LOC("IN,SynthesisFilter.LSH") float pp5 = p5 + p10;\r
 275     @LOC("IN,SynthesisFilter.LSH") float pp6 = p6 + p9;\r
 276     @LOC("IN,SynthesisFilter.LSH") float pp7 = p7 + p8;\r
 277     @LOC("IN,SynthesisFilter.LSH") float pp8 = (p0 - p15) * cos1_32;\r
 278     @LOC("IN,SynthesisFilter.LSH") float pp9 = (p1 - p14) * cos3_32;\r
 279     @LOC("IN,SynthesisFilter.LSH") float pp10 = (p2 - p13) * cos5_32;\r
 280     @LOC("IN,SynthesisFilter.LSH") float pp11 = (p3 - p12) * cos7_32;\r
 281     @LOC("IN,SynthesisFilter.LSH") float pp12 = (p4 - p11) * cos9_32;\r
 282     @LOC("IN,SynthesisFilter.LSH") float pp13 = (p5 - p10) * cos11_32;\r
 283     @LOC("IN,SynthesisFilter.LSH") float pp14 = (p6 - p9) * cos13_32;\r
 284     @LOC("IN,SynthesisFilter.LSH") float pp15 = (p7 - p8) * cos15_32;\r
 285 \r
 286     p0 = pp0 + pp7;\r
 287     p1 = pp1 + pp6;\r
 288     p2 = pp2 + pp5;\r
 289     p3 = pp3 + pp4;\r
 290     p4 = (pp0 - pp7) * cos1_16;\r
 291     p5 = (pp1 - pp6) * cos3_16;\r
 292     p6 = (pp2 - pp5) * cos5_16;\r
 293     p7 = (pp3 - pp4) * cos7_16;\r
 294     p8 = pp8 + pp15;\r
 295     p9 = pp9 + pp14;\r
 296     p10 = pp10 + pp13;\r
 297     p11 = pp11 + pp12;\r
 298     p12 = (pp8 - pp15) * cos1_16;\r
 299     p13 = (pp9 - pp14) * cos3_16;\r
 300     p14 = (pp10 - pp13) * cos5_16;\r
 301     p15 = (pp11 - pp12) * cos7_16;\r
 302 \r
 303     pp0 = p0 + p3;\r
 304     pp1 = p1 + p2;\r
 305     pp2 = (p0 - p3) * cos1_8;\r
 306     pp3 = (p1 - p2) * cos3_8;\r
 307     pp4 = p4 + p7;\r
 308     pp5 = p5 + p6;\r
 309     pp6 = (p4 - p7) * cos1_8;\r
 310     pp7 = (p5 - p6) * cos3_8;\r
 311     pp8 = p8 + p11;\r
 312     pp9 = p9 + p10;\r
 313     pp10 = (p8 - p11) * cos1_8;\r
 314     pp11 = (p9 - p10) * cos3_8;\r
 315     pp12 = p12 + p15;\r
 316     pp13 = p13 + p14;\r
 317     pp14 = (p12 - p15) * cos1_8;\r
 318     pp15 = (p13 - p14) * cos3_8;\r
 319 \r
 320     p0 = pp0 + pp1;\r
 321     p1 = (pp0 - pp1) * cos1_4;\r
 322     p2 = pp2 + pp3;\r
 323     p3 = (pp2 - pp3) * cos1_4;\r
 324     p4 = pp4 + pp5;\r
 325     p5 = (pp4 - pp5) * cos1_4;\r
 326     p6 = pp6 + pp7;\r
 327     p7 = (pp6 - pp7) * cos1_4;\r
 328     p8 = pp8 + pp9;\r
 329     p9 = (pp8 - pp9) * cos1_4;\r
 330 \r
 331     p10 = pp10 + pp11;\r
 332     p11 = (pp10 - pp11) * cos1_4;\r
 333     p12 = pp12 + pp13;\r
 334     p13 = (pp12 - pp13) * cos1_4;\r
 335     p14 = pp14 + pp15;\r
 336     p15 = (pp14 - pp15) * cos1_4;\r
 337 \r
 338     // this is pretty insane coding\r
 339     @LOC("IN,SynthesisFilter.L3") float tmp1;\r
 340     new_v19/* 36-17 */= -(new_v4 = (new_v12 = p7) + p5) - p6;\r
 341     new_v27/* 44-17 */= -p6 - p7 - p4;\r
 342     new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13;\r
 343     new_v17/* 34-17 */= -(new_v2 = p15 + p13 + p9) - p14;\r
 344     new_v21/* 38-17 */= (tmp1 = -p14 - p15 - p10 - p11) - p13;\r
 345     new_v29/* 46-17 */= -p14 - p15 - p12 - p8;\r
 346     new_v25/* 42-17 */= tmp1 - p12;\r
 347     new_v31/* 48-17 */= -p0;\r
 348     new_v0 = p1;\r
 349     new_v23/* 40-17 */= -(new_v8 = p3) - p2;\r
 350 \r
 351     p0 = (s0 - s31) * cos1_64;\r
 352     p1 = (s1 - s30) * cos3_64;\r
 353     p2 = (s2 - s29) * cos5_64;\r
 354     p3 = (s3 - s28) * cos7_64;\r
 355     p4 = (s4 - s27) * cos9_64;\r
 356     p5 = (s5 - s26) * cos11_64;\r
 357     p6 = (s6 - s25) * cos13_64;\r
 358     p7 = (s7 - s24) * cos15_64;\r
 359     p8 = (s8 - s23) * cos17_64;\r
 360     p9 = (s9 - s22) * cos19_64;\r
 361     p10 = (s10 - s21) * cos21_64;\r
 362     p11 = (s11 - s20) * cos23_64;\r
 363     p12 = (s12 - s19) * cos25_64;\r
 364     p13 = (s13 - s18) * cos27_64;\r
 365     p14 = (s14 - s17) * cos29_64;\r
 366     p15 = (s15 - s16) * cos31_64;\r
 367 \r
 368     pp0 = p0 + p15;\r
 369     pp1 = p1 + p14;\r
 370     pp2 = p2 + p13;\r
 371     pp3 = p3 + p12;\r
 372     pp4 = p4 + p11;\r
 373     pp5 = p5 + p10;\r
 374     pp6 = p6 + p9;\r
 375     pp7 = p7 + p8;\r
 376     pp8 = (p0 - p15) * cos1_32;\r
 377     pp9 = (p1 - p14) * cos3_32;\r
 378     pp10 = (p2 - p13) * cos5_32;\r
 379     pp11 = (p3 - p12) * cos7_32;\r
 380     pp12 = (p4 - p11) * cos9_32;\r
 381     pp13 = (p5 - p10) * cos11_32;\r
 382     pp14 = (p6 - p9) * cos13_32;\r
 383     pp15 = (p7 - p8) * cos15_32;\r
 384 \r
 385     p0 = pp0 + pp7;\r
 386     p1 = pp1 + pp6;\r
 387     p2 = pp2 + pp5;\r
 388     p3 = pp3 + pp4;\r
 389     p4 = (pp0 - pp7) * cos1_16;\r
 390     p5 = (pp1 - pp6) * cos3_16;\r
 391     p6 = (pp2 - pp5) * cos5_16;\r
 392     p7 = (pp3 - pp4) * cos7_16;\r
 393     p8 = pp8 + pp15;\r
 394     p9 = pp9 + pp14;\r
 395     p10 = pp10 + pp13;\r
 396     p11 = pp11 + pp12;\r
 397     p12 = (pp8 - pp15) * cos1_16;\r
 398     p13 = (pp9 - pp14) * cos3_16;\r
 399     p14 = (pp10 - pp13) * cos5_16;\r
 400     p15 = (pp11 - pp12) * cos7_16;\r
 401 \r
 402     pp0 = p0 + p3;\r
 403     pp1 = p1 + p2;\r
 404     pp2 = (p0 - p3) * cos1_8;\r
 405     pp3 = (p1 - p2) * cos3_8;\r
 406     pp4 = p4 + p7;\r
 407     pp5 = p5 + p6;\r
 408     pp6 = (p4 - p7) * cos1_8;\r
 409     pp7 = (p5 - p6) * cos3_8;\r
 410     pp8 = p8 + p11;\r
 411     pp9 = p9 + p10;\r
 412     pp10 = (p8 - p11) * cos1_8;\r
 413     pp11 = (p9 - p10) * cos3_8;\r
 414     pp12 = p12 + p15;\r
 415     pp13 = p13 + p14;\r
 416     pp14 = (p12 - p15) * cos1_8;\r
 417     pp15 = (p13 - p14) * cos3_8;\r
 418 \r
 419     p0 = pp0 + pp1;\r
 420     p1 = (pp0 - pp1) * cos1_4;\r
 421     p2 = pp2 + pp3;\r
 422     p3 = (pp2 - pp3) * cos1_4;\r
 423     p4 = pp4 + pp5;\r
 424     p5 = (pp4 - pp5) * cos1_4;\r
 425     p6 = pp6 + pp7;\r
 426     p7 = (pp6 - pp7) * cos1_4;\r
 427     p8 = pp8 + pp9;\r
 428     p9 = (pp8 - pp9) * cos1_4;\r
 429     p10 = pp10 + pp11;\r
 430     p11 = (pp10 - pp11) * cos1_4;\r
 431     p12 = pp12 + pp13;\r
 432     p13 = (pp12 - pp13) * cos1_4;\r
 433     p14 = pp14 + pp15;\r
 434     p15 = (pp14 - pp15) * cos1_4;\r
 435 \r
 436     // manually doing something that a compiler should handle sucks\r
 437     // coding like this is hard to read\r
 438     @LOC("IN,SynthesisFilter.L4") float tmp2;\r
 439     // new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11)\r
 440     // + p5 + p13;\r
 441     new_v15 = p15;\r
 442     new_v13 = p15 + p7;\r
 443     new_v11 = p15 + p7 + p11;\r
 444     new_v5 = p15 + p7 + p11 + p5 + p13;\r
 445 \r
 446     // new_v7 = (new_v9 = p15 + p11 + p3) + p13;\r
 447     new_v9 = p15 + p11 + p3;\r
 448     new_v7 = new_v9 + p13;\r
 449 \r
 450     new_v16/* 33-17 */= -(new_v1 = (tmp1 = p13 + p15 + p9) + p1) - p14;\r
 451     new_v18/* 35-17 */= -(new_v3 = tmp1 + p5 + p7) - p6 - p14;\r
 452 \r
 453     new_v22/* 39-17 */= (tmp1 = -p10 - p11 - p14 - p15) - p13 - p2 - p3;\r
 454     new_v20/* 37-17 */= tmp1 - p13 - p5 - p6 - p7;\r
 455     new_v24/* 41-17 */= tmp1 - p12 - p2 - p3;\r
 456     new_v26/* 43-17 */= tmp1 - p12 - (tmp2 = p4 + p6 + p7);\r
 457     new_v30/* 47-17 */= (tmp1 = -p8 - p12 - p14 - p15) - p0;\r
 458     new_v28/* 45-17 */= tmp1 - tmp2;\r
 459 \r
 460     // insert V[0-15] (== new_v[0-15]) into actual v:\r
 461     // float[] x2 = actual_v + actual_write_pos;\r
 462     // float dest[] = actual_v; //actual_v subbed in so as not to create a new\r
 463     // area\r
 464 \r
 465     // int pos = actual_write_pos; //substituted to simplify location relations\r
 466 \r
 467     v1[0 + actual_write_pos] = new_v0;\r
 468     v1[16 + actual_write_pos] = new_v1;\r
 469     v1[32 + actual_write_pos] = new_v2;\r
 470     v1[48 + actual_write_pos] = new_v3;\r
 471     v1[64 + actual_write_pos] = new_v4;\r
 472     v1[80 + actual_write_pos] = new_v5;\r
 473     v1[96 + actual_write_pos] = new_v6;\r
 474     v1[112 + actual_write_pos] = new_v7;\r
 475     v1[128 + actual_write_pos] = new_v8;\r
 476     v1[144 + actual_write_pos] = new_v9;\r
 477     v1[160 + actual_write_pos] = new_v10;\r
 478     v1[176 + actual_write_pos] = new_v11;\r
 479     v1[192 + actual_write_pos] = new_v12;\r
 480     v1[208 + actual_write_pos] = new_v13;\r
 481     v1[224 + actual_write_pos] = new_v14;\r
 482     v1[240 + actual_write_pos] = new_v15;\r
 483 \r
 484     // V[16] is always 0.0:\r
 485     v1[256 + actual_write_pos] = 0.0f;\r
 486 \r
 487     // insert V[17-31] (== -new_v[15-1]) into actual v:\r
 488     v1[272 + actual_write_pos] = -new_v15;\r
 489     v1[288 + actual_write_pos] = -new_v14;\r
 490     v1[304 + actual_write_pos] = -new_v13;\r
 491     v1[320 + actual_write_pos] = -new_v12;\r
 492     v1[336 + actual_write_pos] = -new_v11;\r
 493     v1[352 + actual_write_pos] = -new_v10;\r
 494     v1[368 + actual_write_pos] = -new_v9;\r
 495     v1[384 + actual_write_pos] = -new_v8;\r
 496     v1[400 + actual_write_pos] = -new_v7;\r
 497     v1[416 + actual_write_pos] = -new_v6;\r
 498     v1[432 + actual_write_pos] = -new_v5;\r
 499     v1[448 + actual_write_pos] = -new_v4;\r
 500     v1[464 + actual_write_pos] = -new_v3;\r
 501     v1[480 + actual_write_pos] = -new_v2;\r
 502     v1[496 + actual_write_pos] = -new_v1;\r
 503 \r
 504     // insert V[32] (== -new_v[0]) into other v:\r
 505     // dest = (actual_v==v1) ? v2 : v1; //assignment replaced with if statement\r
 506     // so that new areas are not created\r
 507 \r
 508     v2[0 + actual_write_pos] = -new_v0;\r
 509     // insert V[33-48] (== new_v[16-31]) into other v:\r
 510     v2[16 + actual_write_pos] = new_v16;\r
 511     v2[32 + actual_write_pos] = new_v17;\r
 512     v2[48 + actual_write_pos] = new_v18;\r
 513     v2[64 + actual_write_pos] = new_v19;\r
 514     v2[80 + actual_write_pos] = new_v20;\r
 515     v2[96 + actual_write_pos] = new_v21;\r
 516     v2[112 + actual_write_pos] = new_v22;\r
 517     v2[128 + actual_write_pos] = new_v23;\r
 518     v2[144 + actual_write_pos] = new_v24;\r
 519     v2[160 + actual_write_pos] = new_v25;\r
 520     v2[176 + actual_write_pos] = new_v26;\r
 521     v2[192 + actual_write_pos] = new_v27;\r
 522     v2[208 + actual_write_pos] = new_v28;\r
 523     v2[224 + actual_write_pos] = new_v29;\r
 524     v2[240 + actual_write_pos] = new_v30;\r
 525     v2[256 + actual_write_pos] = new_v31;\r
 526 \r
 527     // insert V[49-63] (== new_v[30-16]) into other v:\r
 528     v2[272 + actual_write_pos] = new_v30;\r
 529     v2[288 + actual_write_pos] = new_v29;\r
 530     v2[304 + actual_write_pos] = new_v28;\r
 531     v2[320 + actual_write_pos] = new_v27;\r
 532     v2[336 + actual_write_pos] = new_v26;\r
 533     v2[352 + actual_write_pos] = new_v25;\r
 534     v2[368 + actual_write_pos] = new_v24;\r
 535     v2[384 + actual_write_pos] = new_v23;\r
 536     v2[400 + actual_write_pos] = new_v22;\r
 537     v2[416 + actual_write_pos] = new_v21;\r
 538     v2[432 + actual_write_pos] = new_v20;\r
 539     v2[448 + actual_write_pos] = new_v19;\r
 540     v2[464 + actual_write_pos] = new_v18;\r
 541     v2[480 + actual_write_pos] = new_v17;\r
 542     v2[496 + actual_write_pos] = new_v16;\r
 543   }\r
 544 \r
 545   /**\r
 546    * Compute PCM Samples.\r
 547    */\r
 548 \r
 549   @LOC("TMP")\r
 550   private float[] _tmpOut = new float[32];\r
 551 \r
 552   @LATTICE("IN,THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 553   private void compute_pcm_samples0(@LOC("IN") Obuffer buffer) {\r
 554     // final float[] vp = v1; //subbed in variable name instead to reduce areas\r
 555     // int inc = v_inc;\r
 556     // final float[] tmpOut = _tmpOut; //subbed in variable name instread to\r
 557     // reduce areas\r
 558     @LOC("DVP") int dvp = 0;\r
 559 \r
 560     // fat chance of having this loop unroll\r
 561     for (@LOC("I") int i = 0; i < 32; i++) {\r
 562       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 563       // final float[] dp = d16[i]; //subbed in variable name instead to reduce\r
 564       // areas\r
 565       pcm_sample =\r
 566           (float) (((v1[0 + dvp] * d16[i][0]) + (v1[15 + dvp] * d16[i][1])\r
 567               + (v1[14 + dvp] * d16[i][2]) + (v1[13 + dvp] * d16[i][3])\r
 568               + (v1[12 + dvp] * d16[i][4]) + (v1[11 + dvp] * d16[i][5])\r
 569               + (v1[10 + dvp] * d16[i][6]) + (v1[9 + dvp] * d16[i][7]) + (v1[8 + dvp] * d16[i][8])\r
 570               + (v1[7 + dvp] * d16[i][9]) + (v1[6 + dvp] * d16[i][10]) + (v1[5 + dvp] * d16[i][11])\r
 571               + (v1[4 + dvp] * d16[i][12]) + (v1[3 + dvp] * d16[i][13])\r
 572               + (v1[2 + dvp] * d16[i][14]) + (v1[1 + dvp] * d16[i][15])) * scalefactor);\r
 573 \r
 574       _tmpOut[i] = pcm_sample;\r
 575 \r
 576       dvp += 16;\r
 577     } // for\r
 578   }\r
 579 \r
 580   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 581   private void compute_pcm_samples1(@LOC("THIS") Obuffer buffer) {\r
 582     // final float[] vp = v1;\r
 583     // int inc = v_inc;\r
 584     // final float[] tmpOut = _tmpOut;\r
 585     @LOC("DVP") int dvp = 0;\r
 586 \r
 587     // fat chance of having this loop unroll\r
 588     for (@LOC("I") int i = 0; i < 32; i++) {\r
 589       // final float[] dp = d16[i];\r
 590       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 591 \r
 592       pcm_sample =\r
 593           (float) (((v1[1 + dvp] * d16[i][0]) + (v1[0 + dvp] * d16[i][1])\r
 594               + (v1[15 + dvp] * d16[i][2]) + (v1[14 + dvp] * d16[i][3])\r
 595               + (v1[13 + dvp] * d16[i][4]) + (v1[12 + dvp] * d16[i][5])\r
 596               + (v1[11 + dvp] * d16[i][6]) + (v1[10 + dvp] * d16[i][7]) + (v1[9 + dvp] * d16[i][8])\r
 597               + (v1[8 + dvp] * d16[i][9]) + (v1[7 + dvp] * d16[i][10]) + (v1[6 + dvp] * d16[i][11])\r
 598               + (v1[5 + dvp] * d16[i][12]) + (v1[4 + dvp] * d16[i][13])\r
 599               + (v1[3 + dvp] * d16[i][14]) + (v1[2 + dvp] * d16[i][15])) * scalefactor);\r
 600 \r
 601       _tmpOut[i] = pcm_sample;\r
 602       // v1\r
 603       dvp += 16;\r
 604     } // for\r
 605   }\r
 606 \r
 607   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 608   private void compute_pcm_samples2(@LOC("THIS") Obuffer buffer) {\r
 609     // final float[] vp = v1;\r
 610 \r
 611     // int inc = v_inc;\r
 612     // final float[] tmpOut = _tmpOut;\r
 613     @LOC("DVP") int dvp = 0;\r
 614 \r
 615     // fat chance of having this loop unroll\r
 616     for (@LOC("I") int i = 0; i < 32; i++) {\r
 617       // final float[] dp = d16[i];\r
 618       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 619 \r
 620       pcm_sample =\r
 621           (float) (((v1[2 + dvp] * d16[i][0]) + (v1[1 + dvp] * d16[i][1])\r
 622               + (v1[0 + dvp] * d16[i][2]) + (v1[15 + dvp] * d16[i][3]) + (v1[14 + dvp] * d16[i][4])\r
 623               + (v1[13 + dvp] * d16[i][5]) + (v1[12 + dvp] * d16[i][6])\r
 624               + (v1[11 + dvp] * d16[i][7]) + (v1[10 + dvp] * d16[i][8]) + (v1[9 + dvp] * d16[i][9])\r
 625               + (v1[8 + dvp] * d16[i][10]) + (v1[7 + dvp] * d16[i][11])\r
 626               + (v1[6 + dvp] * d16[i][12]) + (v1[5 + dvp] * d16[i][13])\r
 627               + (v1[4 + dvp] * d16[i][14]) + (v1[3 + dvp] * d16[i][15])) * scalefactor);\r
 628 \r
 629       _tmpOut[i] = pcm_sample;\r
 630 \r
 631       dvp += 16;\r
 632     } // for\r
 633   }\r
 634 \r
 635   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 636   private void compute_pcm_samples3(@LOC("THIS") Obuffer buffer) {\r
 637     // final float[] vp = v1;\r
 638 \r
 639     @LOC("I") int idx = 0;\r
 640     // int inc = v_inc;\r
 641     // final float[] tmpOut = _tmpOut;\r
 642     @LOC("DVP") int dvp = 0;\r
 643 \r
 644     // fat chance of having this loop unroll\r
 645     for (@LOC("I") int i = 0; i < 32; i++) {\r
 646       // final float[] dp = d16[i];\r
 647       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 648 \r
 649       pcm_sample =\r
 650           (float) (((v1[3 + dvp] * d16[i][0]) + (v1[2 + dvp] * d16[i][1])\r
 651               + (v1[1 + dvp] * d16[i][2]) + (v1[0 + dvp] * d16[i][3]) + (v1[15 + dvp] * d16[i][4])\r
 652               + (v1[14 + dvp] * d16[i][5]) + (v1[13 + dvp] * d16[i][6])\r
 653               + (v1[12 + dvp] * d16[i][7]) + (v1[11 + dvp] * d16[i][8])\r
 654               + (v1[10 + dvp] * d16[i][9]) + (v1[9 + dvp] * d16[i][10])\r
 655               + (v1[8 + dvp] * d16[i][11]) + (v1[7 + dvp] * d16[i][12])\r
 656               + (v1[6 + dvp] * d16[i][13]) + (v1[5 + dvp] * d16[i][14]) + (v1[4 + dvp] * d16[i][15])) * scalefactor);\r
 657 \r
 658       _tmpOut[i] = pcm_sample;\r
 659 \r
 660       dvp += 16;\r
 661     } // for\r
 662   }\r
 663 \r
 664   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 665   private void compute_pcm_samples4(@LOC("THIS") Obuffer buffer) {\r
 666     // final float[] vp = v1;\r
 667 \r
 668     // int inc = v_inc;\r
 669     // final float[] tmpOut = _tmpOut;\r
 670     @LOC("DVP") int dvp = 0;\r
 671 \r
 672     // fat chance of having this loop unroll\r
 673     for (@LOC("I") int i = 0; i < 32; i++) {\r
 674       // final float[] dp = d16[i];\r
 675       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 676 \r
 677       pcm_sample =\r
 678           (float) (((v1[4 + dvp] * d16[i][0]) + (v1[3 + dvp] * d16[i][1])\r
 679               + (v1[2 + dvp] * d16[i][2]) + (v1[1 + dvp] * d16[i][3]) + (v1[0 + dvp] * d16[i][4])\r
 680               + (v1[15 + dvp] * d16[i][5]) + (v1[14 + dvp] * d16[i][6])\r
 681               + (v1[13 + dvp] * d16[i][7]) + (v1[12 + dvp] * d16[i][8])\r
 682               + (v1[11 + dvp] * d16[i][9]) + (v1[10 + dvp] * d16[i][10])\r
 683               + (v1[9 + dvp] * d16[i][11]) + (v1[8 + dvp] * d16[i][12])\r
 684               + (v1[7 + dvp] * d16[i][13]) + (v1[6 + dvp] * d16[i][14]) + (v1[5 + dvp] * d16[i][15])) * scalefactor);\r
 685 \r
 686       _tmpOut[i] = pcm_sample;\r
 687 \r
 688       dvp += 16;\r
 689     } // for\r
 690   }\r
 691 \r
 692   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 693   private void compute_pcm_samples5(@LOC("THIS") Obuffer buffer) {\r
 694     // final float[] vp = v1;\r
 695 \r
 696     // int inc = v_inc;\r
 697     // final float[] tmpOut = _tmpOut;\r
 698     @LOC("DVP") int dvp = 0;\r
 699 \r
 700     // fat chance of having this loop unroll\r
 701     for (@LOC("I") int i = 0; i < 32; i++) {\r
 702       // final float[] dp = d16[i];\r
 703       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 704 \r
 705       pcm_sample =\r
 706           (float) (((v1[5 + dvp] * d16[i][0]) + (v1[4 + dvp] * d16[i][1])\r
 707               + (v1[3 + dvp] * d16[i][2]) + (v1[2 + dvp] * d16[i][3]) + (v1[1 + dvp] * d16[i][4])\r
 708               + (v1[0 + dvp] * d16[i][5]) + (v1[15 + dvp] * d16[i][6]) + (v1[14 + dvp] * d16[i][7])\r
 709               + (v1[13 + dvp] * d16[i][8]) + (v1[12 + dvp] * d16[i][9])\r
 710               + (v1[11 + dvp] * d16[i][10]) + (v1[10 + dvp] * d16[i][11])\r
 711               + (v1[9 + dvp] * d16[i][12]) + (v1[8 + dvp] * d16[i][13])\r
 712               + (v1[7 + dvp] * d16[i][14]) + (v1[6 + dvp] * d16[i][15])) * scalefactor);\r
 713 \r
 714       _tmpOut[i] = pcm_sample;\r
 715 \r
 716       dvp += 16;\r
 717     } // for\r
 718   }\r
 719 \r
 720   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 721   private void compute_pcm_samples6(@LOC("THIS") Obuffer buffer) {\r
 722     // final float[] vp = v1;\r
 723     // int inc = v_inc;\r
 724     // final float[] tmpOut = _tmpOut;\r
 725     @LOC("DVP") int dvp = 0;\r
 726 \r
 727     // fat chance of having this loop unroll\r
 728     for (@LOC("I") int i = 0; i < 32; i++) {\r
 729       // final float[] dp = d16[i];\r
 730       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 731 \r
 732       pcm_sample =\r
 733           (float) (((v1[6 + dvp] * d16[i][0]) + (v1[5 + dvp] * d16[i][1])\r
 734               + (v1[4 + dvp] * d16[i][2]) + (v1[3 + dvp] * d16[i][3]) + (v1[2 + dvp] * d16[i][4])\r
 735               + (v1[1 + dvp] * d16[i][5]) + (v1[0 + dvp] * d16[i][6]) + (v1[15 + dvp] * d16[i][7])\r
 736               + (v1[14 + dvp] * d16[i][8]) + (v1[13 + dvp] * d16[i][9])\r
 737               + (v1[12 + dvp] * d16[i][10]) + (v1[11 + dvp] * d16[i][11])\r
 738               + (v1[10 + dvp] * d16[i][12]) + (v1[9 + dvp] * d16[i][13])\r
 739               + (v1[8 + dvp] * d16[i][14]) + (v1[7 + dvp] * d16[i][15])) * scalefactor);\r
 740 \r
 741       _tmpOut[i] = pcm_sample;\r
 742 \r
 743       dvp += 16;\r
 744     } // for\r
 745   }\r
 746 \r
 747   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 748   private void compute_pcm_samples7(@LOC("THIS") Obuffer buffer) {\r
 749     // final float[] vp = v1;\r
 750 \r
 751     // int inc = v_inc;\r
 752     // final float[] tmpOut = _tmpOut;\r
 753     @LOC("DVP") int dvp = 0;\r
 754 \r
 755     // fat chance of having this loop unroll\r
 756     for (@LOC("I") int i = 0; i < 32; i++) {\r
 757       // final float[] dp = d16[i];\r
 758       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 759 \r
 760       pcm_sample =\r
 761           (float) (((v1[7 + dvp] * d16[i][0]) + (v1[6 + dvp] * d16[i][1])\r
 762               + (v1[5 + dvp] * d16[i][2]) + (v1[4 + dvp] * d16[i][3]) + (v1[3 + dvp] * d16[i][4])\r
 763               + (v1[2 + dvp] * d16[i][5]) + (v1[1 + dvp] * d16[i][6]) + (v1[0 + dvp] * d16[i][7])\r
 764               + (v1[15 + dvp] * d16[i][8]) + (v1[14 + dvp] * d16[i][9])\r
 765               + (v1[13 + dvp] * d16[i][10]) + (v1[12 + dvp] * d16[i][11])\r
 766               + (v1[11 + dvp] * d16[i][12]) + (v1[10 + dvp] * d16[i][13])\r
 767               + (v1[9 + dvp] * d16[i][14]) + (v1[8 + dvp] * d16[i][15])) * scalefactor);\r
 768 \r
 769       _tmpOut[i] = pcm_sample;\r
 770 \r
 771       dvp += 16;\r
 772     } // for\r
 773   }\r
 774 \r
 775   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 776   private void compute_pcm_samples8(@LOC("THIS") Obuffer buffer) {\r
 777     // final float[] vp = v1;\r
 778 \r
 779     // int inc = v_inc;\r
 780     // final float[] tmpOut = _tmpOut;\r
 781     @LOC("DVP") int dvp = 0;\r
 782 \r
 783     // fat chance of having this loop unroll\r
 784     for (@LOC("I") int i = 0; i < 32; i++) {\r
 785       // final float[] dp = d16[i];\r
 786       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 787 \r
 788       pcm_sample =\r
 789           (float) (((v1[8 + dvp] * d16[i][0]) + (v1[7 + dvp] * d16[i][1])\r
 790               + (v1[6 + dvp] * d16[i][2]) + (v1[5 + dvp] * d16[i][3]) + (v1[4 + dvp] * d16[i][4])\r
 791               + (v1[3 + dvp] * d16[i][5]) + (v1[2 + dvp] * d16[i][6]) + (v1[1 + dvp] * d16[i][7])\r
 792               + (v1[0 + dvp] * d16[i][8]) + (v1[15 + dvp] * d16[i][9])\r
 793               + (v1[14 + dvp] * d16[i][10]) + (v1[13 + dvp] * d16[i][11])\r
 794               + (v1[12 + dvp] * d16[i][12]) + (v1[11 + dvp] * d16[i][13])\r
 795               + (v1[10 + dvp] * d16[i][14]) + (v1[9 + dvp] * d16[i][15])) * scalefactor);\r
 796 \r
 797       _tmpOut[i] = pcm_sample;\r
 798 \r
 799       dvp += 16;\r
 800     } // for\r
 801   }\r
 802 \r
 803   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 804   private void compute_pcm_samples9(@LOC("THIS") Obuffer buffer) {\r
 805     // final float[] vp = v1;\r
 806 \r
 807     // int inc = v_inc;\r
 808     // final float[] tmpOut = _tmpOut;\r
 809     @LOC("DVP") int dvp = 0;\r
 810 \r
 811     // fat chance of having this loop unroll\r
 812     for (@LOC("I") int i = 0; i < 32; i++) {\r
 813       // final float[] dp = d16[i];\r
 814       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 815 \r
 816       pcm_sample =\r
 817           (float) (((v1[9 + dvp] * d16[i][0]) + (v1[8 + dvp] * d16[i][1])\r
 818               + (v1[7 + dvp] * d16[i][2]) + (v1[6 + dvp] * d16[i][3]) + (v1[5 + dvp] * d16[i][4])\r
 819               + (v1[4 + dvp] * d16[i][5]) + (v1[3 + dvp] * d16[i][6]) + (v1[2 + dvp] * d16[i][7])\r
 820               + (v1[1 + dvp] * d16[i][8]) + (v1[0 + dvp] * d16[i][9]) + (v1[15 + dvp] * d16[i][10])\r
 821               + (v1[14 + dvp] * d16[i][11]) + (v1[13 + dvp] * d16[i][12])\r
 822               + (v1[12 + dvp] * d16[i][13]) + (v1[11 + dvp] * d16[i][14]) + (v1[10 + dvp] * d16[i][15])) * scalefactor);\r
 823 \r
 824       _tmpOut[i] = pcm_sample;\r
 825 \r
 826       dvp += 16;\r
 827     } // for\r
 828   }\r
 829 \r
 830   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 831   private void compute_pcm_samples10(@LOC("THIS") Obuffer buffer) {\r
 832     // final float[] vp = v1;\r
 833     // int inc = v_inc;\r
 834     // final float[] tmpOut = _tmpOut;\r
 835     @LOC("DVP") int dvp = 0;\r
 836 \r
 837     // fat chance of having this loop unroll\r
 838     for (@LOC("I") int i = 0; i < 32; i++) {\r
 839       // final float[] dp = d16[i];\r
 840       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 841 \r
 842       pcm_sample =\r
 843           (float) (((v1[10 + dvp] * d16[i][0]) + (v1[9 + dvp] * d16[i][1])\r
 844               + (v1[8 + dvp] * d16[i][2]) + (v1[7 + dvp] * d16[i][3]) + (v1[6 + dvp] * d16[i][4])\r
 845               + (v1[5 + dvp] * d16[i][5]) + (v1[4 + dvp] * d16[i][6]) + (v1[3 + dvp] * d16[i][7])\r
 846               + (v1[2 + dvp] * d16[i][8]) + (v1[1 + dvp] * d16[i][9]) + (v1[0 + dvp] * d16[i][10])\r
 847               + (v1[15 + dvp] * d16[i][11]) + (v1[14 + dvp] * d16[i][12])\r
 848               + (v1[13 + dvp] * d16[i][13]) + (v1[12 + dvp] * d16[i][14]) + (v1[11 + dvp] * d16[i][15])) * scalefactor);\r
 849 \r
 850       _tmpOut[i] = pcm_sample;\r
 851 \r
 852       dvp += 16;\r
 853     } // for\r
 854   }\r
 855 \r
 856   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 857   private void compute_pcm_samples11(@LOC("THIS") Obuffer buffer) {\r
 858     // final float[] vp = v1;\r
 859 \r
 860     // int inc = v_inc;\r
 861     // final float[] tmpOut = _tmpOut;\r
 862     @LOC("DVP") int dvp = 0;\r
 863 \r
 864     // fat chance of having this loop unroll\r
 865     for (@LOC("I") int i = 0; i < 32; i++) {\r
 866       // final float[] dp = d16[i];\r
 867       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 868 \r
 869       pcm_sample =\r
 870           (float) (((v1[11 + dvp] * d16[i][0]) + (v1[10 + dvp] * d16[i][1])\r
 871               + (v1[9 + dvp] * d16[i][2]) + (v1[8 + dvp] * d16[i][3]) + (v1[7 + dvp] * d16[i][4])\r
 872               + (v1[6 + dvp] * d16[i][5]) + (v1[5 + dvp] * d16[i][6]) + (v1[4 + dvp] * d16[i][7])\r
 873               + (v1[3 + dvp] * d16[i][8]) + (v1[2 + dvp] * d16[i][9]) + (v1[1 + dvp] * d16[i][10])\r
 874               + (v1[0 + dvp] * d16[i][11]) + (v1[15 + dvp] * d16[i][12])\r
 875               + (v1[14 + dvp] * d16[i][13]) + (v1[13 + dvp] * d16[i][14]) + (v1[12 + dvp] * d16[i][15])) * scalefactor);\r
 876 \r
 877       _tmpOut[i] = pcm_sample;\r
 878 \r
 879       dvp += 16;\r
 880     } // for\r
 881   }\r
 882 \r
 883   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 884   private void compute_pcm_samples12(@LOC("THIS") Obuffer buffer) {\r
 885     // final float[] vp = v1;\r
 886     // int inc = v_inc;\r
 887     // final float[] tmpOut = _tmpOut;\r
 888     @LOC("DVP") int dvp = 0;\r
 889 \r
 890     // fat chance of having this loop unroll\r
 891     for (@LOC("I") int i = 0; i < 32; i++) {\r
 892       // final float[] dp = d16[i];\r
 893       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 894 \r
 895       pcm_sample =\r
 896           (float) (((v1[12 + dvp] * d16[i][0]) + (v1[11 + dvp] * d16[i][1])\r
 897               + (v1[10 + dvp] * d16[i][2]) + (v1[9 + dvp] * d16[i][3]) + (v1[8 + dvp] * d16[i][4])\r
 898               + (v1[7 + dvp] * d16[i][5]) + (v1[6 + dvp] * d16[i][6]) + (v1[5 + dvp] * d16[i][7])\r
 899               + (v1[4 + dvp] * d16[i][8]) + (v1[3 + dvp] * d16[i][9]) + (v1[2 + dvp] * d16[i][10])\r
 900               + (v1[1 + dvp] * d16[i][11]) + (v1[0 + dvp] * d16[i][12])\r
 901               + (v1[15 + dvp] * d16[i][13]) + (v1[14 + dvp] * d16[i][14]) + (v1[13 + dvp] * d16[i][15])) * scalefactor);\r
 902 \r
 903       _tmpOut[i] = pcm_sample;\r
 904 \r
 905       dvp += 16;\r
 906     } // for\r
 907   }\r
 908 \r
 909   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 910   private void compute_pcm_samples13(@LOC("THIS") Obuffer buffer) {\r
 911     // final float[] vp = v1;\r
 912 \r
 913     // int inc = v_inc;\r
 914     // final float[] tmpOut = _tmpOut;\r
 915     @LOC("DVP") int dvp = 0;\r
 916 \r
 917     // fat chance of having this loop unroll\r
 918     for (@LOC("I") int i = 0; i < 32; i++) {\r
 919       // final float[] dp = d16[i];\r
 920       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 921 \r
 922       pcm_sample =\r
 923           (float) (((v1[13 + dvp] * d16[i][0]) + (v1[12 + dvp] * d16[i][1])\r
 924               + (v1[11 + dvp] * d16[i][2]) + (v1[10 + dvp] * d16[i][3]) + (v1[9 + dvp] * d16[i][4])\r
 925               + (v1[8 + dvp] * d16[i][5]) + (v1[7 + dvp] * d16[i][6]) + (v1[6 + dvp] * d16[i][7])\r
 926               + (v1[5 + dvp] * d16[i][8]) + (v1[4 + dvp] * d16[i][9]) + (v1[3 + dvp] * d16[i][10])\r
 927               + (v1[2 + dvp] * d16[i][11]) + (v1[1 + dvp] * d16[i][12])\r
 928               + (v1[0 + dvp] * d16[i][13]) + (v1[15 + dvp] * d16[i][14]) + (v1[14 + dvp] * d16[i][15])) * scalefactor);\r
 929 \r
 930       _tmpOut[i] = pcm_sample;\r
 931 \r
 932       dvp += 16;\r
 933     } // for\r
 934   }\r
 935 \r
 936   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 937   private void compute_pcm_samples14(@LOC("THIS") Obuffer buffer) {\r
 938     // final float[] vp = v1;\r
 939 \r
 940     // int inc = v_inc;\r
 941     // final float[] tmpOut = _tmpOut;\r
 942     @LOC("DVP") int dvp = 0;\r
 943 \r
 944     // fat chance of having this loop unroll\r
 945     for (@LOC("I") int i = 0; i < 32; i++) {\r
 946       // final float[] dp = d16[i];\r
 947       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 948 \r
 949       pcm_sample =\r
 950           (float) (((v1[14 + dvp] * d16[i][0]) + (v1[13 + dvp] * d16[i][1])\r
 951               + (v1[12 + dvp] * d16[i][2]) + (v1[11 + dvp] * d16[i][3])\r
 952               + (v1[10 + dvp] * d16[i][4]) + (v1[9 + dvp] * d16[i][5]) + (v1[8 + dvp] * d16[i][6])\r
 953               + (v1[7 + dvp] * d16[i][7]) + (v1[6 + dvp] * d16[i][8]) + (v1[5 + dvp] * d16[i][9])\r
 954               + (v1[4 + dvp] * d16[i][10]) + (v1[3 + dvp] * d16[i][11])\r
 955               + (v1[2 + dvp] * d16[i][12]) + (v1[1 + dvp] * d16[i][13])\r
 956               + (v1[0 + dvp] * d16[i][14]) + (v1[15 + dvp] * d16[i][15])) * scalefactor);\r
 957 \r
 958       _tmpOut[i] = pcm_sample;\r
 959 \r
 960       dvp += 16;\r
 961     } // for\r
 962   }\r
 963 \r
 964   @LATTICE("THIS<DVP,DVP<I,DVP*,I*,THISLOC=THIS,GLOBALLOC=THIS")\r
 965   private void compute_pcm_samples15(@LOC("THIS") Obuffer buffer) {\r
 966     // final float[] vp = v1;\r
 967 \r
 968     // int inc = v_inc;\r
 969     // final float[] tmpOut = _tmpOut;\r
 970     @LOC("DVP") int dvp = 0;\r
 971 \r
 972     // fat chance of having this loop unroll\r
 973     for (@LOC("I") int i = 0; i < 32; i++) {\r
 974       @LOC("THIS,SynthesisFilter.PCM") float pcm_sample;\r
 975       // final float dp[] = d16[i];\r
 976       pcm_sample =\r
 977           (float) (((v1[15 + dvp] * d16[i][0]) + (v1[14 + dvp] * d16[i][1])\r
 978               + (v1[13 + dvp] * d16[i][2]) + (v1[12 + dvp] * d16[i][3])\r
 979               + (v1[11 + dvp] * d16[i][4]) + (v1[10 + dvp] * d16[i][5]) + (v1[9 + dvp] * d16[i][6])\r
 980               + (v1[8 + dvp] * d16[i][7]) + (v1[7 + dvp] * d16[i][8]) + (v1[6 + dvp] * d16[i][9])\r
 981               + (v1[5 + dvp] * d16[i][10]) + (v1[4 + dvp] * d16[i][11])\r
 982               + (v1[3 + dvp] * d16[i][12]) + (v1[2 + dvp] * d16[i][13])\r
 983               + (v1[1 + dvp] * d16[i][14]) + (v1[0 + dvp] * d16[i][15])) * scalefactor);\r
 984 \r
 985       _tmpOut[i] = pcm_sample;\r
 986       dvp += 16;\r
 987     } // for\r
 988   }\r
 989 \r
 990   @LATTICE("THIS,THISLOC=THIS")\r
 991   private void compute_pcm_samples(@LOC("THIS") Obuffer buffer) {\r
 992 \r
 993     switch (actual_write_pos) {\r
 994     case 0:\r
 995       compute_pcm_samples0(buffer);\r
 996       break;\r
 997     case 1:\r
 998       compute_pcm_samples1(buffer);\r
 999       break;\r
1000     case 2:\r
1001       compute_pcm_samples2(buffer);\r
1002       break;\r
1003     case 3:\r
1004       compute_pcm_samples3(buffer);\r
1005       break;\r
1006     case 4:\r
1007       compute_pcm_samples4(buffer);\r
1008       break;\r
1009     case 5:\r
1010       compute_pcm_samples5(buffer);\r
1011       break;\r
1012     case 6:\r
1013       compute_pcm_samples6(buffer);\r
1014       break;\r
1015     case 7:\r
1016       compute_pcm_samples7(buffer);\r
1017       break;\r
1018     case 8:\r
1019       compute_pcm_samples8(buffer);\r
1020       break;\r
1021     case 9:\r
1022       compute_pcm_samples9(buffer);\r
1023       break;\r
1024     case 10:\r
1025       compute_pcm_samples10(buffer);\r
1026       break;\r
1027     case 11:\r
1028       compute_pcm_samples11(buffer);\r
1029       break;\r
1030     case 12:\r
1031       compute_pcm_samples12(buffer);\r
1032       break;\r
1033     case 13:\r
1034       compute_pcm_samples13(buffer);\r
1035       break;\r
1036     case 14:\r
1037       compute_pcm_samples14(buffer);\r
1038       break;\r
1039     case 15:\r
1040       compute_pcm_samples15(buffer);\r
1041       break;\r
1042     }\r
1043 \r
1044     if (buffer != null) {\r
1045       buffer.appendSamples(channel, _tmpOut);\r
1046     }\r
1047 \r
1048     /*\r
1049      * // MDM: I was considering putting in quality control for // low-spec\r
1050      * CPUs, but the performance gain (about 10-15%) // did not justify the\r
1051      * considerable drop in audio quality. switch (inc) { case 16:\r
1052      * buffer.appendSamples(channel, tmpOut); break; case 32: for (int i=0;\r
1053      * i<16; i++) { buffer.append(channel, (short)tmpOut[i]);\r
1054      * buffer.append(channel, (short)tmpOut[i]); } break; case 64: for (int i=0;\r
1055      * i<8; i++) { buffer.append(channel, (short)tmpOut[i]);\r
1056      * buffer.append(channel, (short)tmpOut[i]); buffer.append(channel,\r
1057      * (short)tmpOut[i]); buffer.append(channel, (short)tmpOut[i]); } break;\r
1058      * \r
1059      * }\r
1060      */\r
1061   }\r
1062 \r
1063   /**\r
1064    * Calculate 32 PCM samples and put the into the Obuffer-object.\r
1065    */\r
1066 \r
1067   @LATTICE("THIS<IN,THIS<SH,SH*,THISLOC=THIS")\r
1068   public void calculate_pcm_samples(@LOC("IN") Obuffer buffer) {\r
1069     compute_new_v();\r
1070     compute_pcm_samples(buffer);\r
1071 \r
1072     actual_write_pos = (actual_write_pos + 1) & 0xf;\r
1073     // actual_v = (actual_v == v1) ? v2 : v1;\r
1074 \r
1075     // initialize samples[]:\r
1076     // for (register float *floatp = samples + 32; floatp > samples; )\r
1077     // *--floatp = 0.0f;\r
1078 \r
1079     // MDM: this may not be necessary. The Layer III decoder always\r
1080     // outputs 32 subband samples, but I haven't checked layer I & II.\r
1081     for (@LOC("SH") int p = 0; p < 32; p++)\r
1082       samples[p] = 0.0f;\r
1083   }\r
1084 \r
1085   @LOC("EQ")\r
1086   private static final double MY_PI = 3.14159265358979323846;\r
1087   @LOC("SA")\r
1088   private static final float cos1_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 64.0)));\r
1089   @LOC("SA")\r
1090   private static final float cos3_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 64.0)));\r
1091   @LOC("SA")\r
1092   private static final float cos5_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 64.0)));\r
1093   @LOC("SA")\r
1094   private static final float cos7_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 64.0)));\r
1095   @LOC("SA")\r
1096   private static final float cos9_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 64.0)));\r
1097   @LOC("SA")\r
1098   private static final float cos11_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 64.0)));\r
1099   @LOC("SA")\r
1100   private static final float cos13_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 64.0)));\r
1101   @LOC("SA")\r
1102   private static final float cos15_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 64.0)));\r
1103   @LOC("SA")\r
1104   private static final float cos17_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 17.0 / 64.0)));\r
1105   @LOC("SA")\r
1106   private static final float cos19_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 19.0 / 64.0)));\r
1107   @LOC("SA")\r
1108   private static final float cos21_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 21.0 / 64.0)));\r
1109   @LOC("SA")\r
1110   private static final float cos23_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 23.0 / 64.0)));\r
1111   @LOC("SA")\r
1112   private static final float cos25_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 25.0 / 64.0)));\r
1113   @LOC("SA")\r
1114   private static final float cos27_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 27.0 / 64.0)));\r
1115   @LOC("SA")\r
1116   private static final float cos29_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 29.0 / 64.0)));\r
1117   @LOC("SA")\r
1118   private static final float cos31_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 31.0 / 64.0)));\r
1119   @LOC("SA")\r
1120   private static final float cos1_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 32.0)));\r
1121   @LOC("SA")\r
1122   private static final float cos3_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 32.0)));\r
1123   @LOC("SA")\r
1124   private static final float cos5_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 32.0)));\r
1125   @LOC("SA")\r
1126   private static final float cos7_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 32.0)));\r
1127   @LOC("SA")\r
1128   private static final float cos9_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 32.0)));\r
1129   @LOC("SA")\r
1130   private static final float cos11_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 32.0)));\r
1131   @LOC("SA")\r
1132   private static final float cos13_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 32.0)));\r
1133   @LOC("SA")\r
1134   private static final float cos15_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 32.0)));\r
1135   @LOC("SA")\r
1136   private static final float cos1_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 16.0)));\r
1137   @LOC("SA")\r
1138   private static final float cos3_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 16.0)));\r
1139   @LOC("SA")\r
1140   private static final float cos5_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 16.0)));\r
1141   @LOC("SA")\r
1142   private static final float cos7_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 16.0)));\r
1143   @LOC("SA")\r
1144   private static final float cos1_8 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 8.0)));\r
1145   @LOC("SA")\r
1146   private static final float cos3_8 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 8.0)));\r
1147   @LOC("SA")\r
1148   private static final float cos1_4 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 4.0)));\r
1149 \r
1150   // Note: These values are not in the same order\r
1151   // as in Annex 3-B.3 of the ISO/IEC DIS 11172-3\r
1152   // private float d[] = {0.000000000, -4.000442505};\r
1153 \r
1154   // @LOC("V2") private static float d[] = null;\r
1155 \r
1156   /**\r
1157    * d[] split into subarrays of length 16. This provides for more faster access\r
1158    * by allowing a block of 16 to be addressed with constant offset.\r
1159    **/\r
1160   @LOC("V2")\r
1161   private static float d16[][] = null;\r
1162 \r
1163   /**\r
1164    * Converts a 1D array into a number of smaller arrays. This is used to\r
1165    * achieve offset + constant indexing into an array. Each sub-array represents\r
1166    * a block of values of the original array.\r
1167    * \r
1168    * @param array\r
1169    *          The array to split up into blocks.\r
1170    * @param blockSize\r
1171    *          The size of the blocks to split the array into. This must be an\r
1172    *          exact divisor of the length of the array, or some data will be\r
1173    *          lost from the main array.\r
1174    * \r
1175    * @return An array of arrays in which each element in the returned array will\r
1176    *         be of length <code>blockSize</code>.\r
1177    */\r
1178   static private float[][] splitArray(final float[] array, final int blockSize) {\r
1179     int size = array.length / blockSize;\r
1180     float[][] split = new float[size][];\r
1181     for (int i = 0; i < size; i++) {\r
1182       split[i] = subArray(array, i * blockSize, blockSize);\r
1183     }\r
1184     return split;\r
1185   }\r
1186 \r
1187   /**\r
1188    * Returns a subarray of an existing array.\r
1189    * \r
1190    * @param array\r
1191    *          The array to retrieve a subarra from.\r
1192    * @param offs\r
1193    *          The offset in the array that corresponds to the first index of the\r
1194    *          subarray.\r
1195    * @param len\r
1196    *          The number of indeces in the subarray.\r
1197    * @return The subarray, which may be of length 0.\r
1198    */\r
1199   static private float[] subArray(final float[] array, final int offs, int len) {\r
1200     if (offs + len > array.length) {\r
1201       len = array.length - offs;\r
1202     }\r
1203 \r
1204     if (len < 0)\r
1205       len = 0;\r
1206 \r
1207     float[] subarray = new float[len];\r
1208     for (int i = 0; i < len; i++) {\r
1209       subarray[i] = array[offs + i];\r
1210     }\r
1211 \r
1212     return subarray;\r
1213   }\r
1214 \r
1215   // The original data for d[]. This data is loaded from a file\r
1216   // to reduce the overall package size and to improve performance.\r
1217 \r
1218   static final float d[] = { 0.000000000f, -0.000442505f, 0.003250122f, -0.007003784f,\r
1219       0.031082153f, -0.078628540f, 0.100311279f, -0.572036743f, 1.144989014f, 0.572036743f,\r
1220       0.100311279f, 0.078628540f, 0.031082153f, 0.007003784f, 0.003250122f, 0.000442505f,\r
1221       -0.000015259f, -0.000473022f, 0.003326416f, -0.007919312f, 0.030517578f, -0.084182739f,\r
1222       0.090927124f, -0.600219727f, 1.144287109f, 0.543823242f, 0.108856201f, 0.073059082f,\r
1223       0.031478882f, 0.006118774f, 0.003173828f, 0.000396729f, -0.000015259f, -0.000534058f,\r
1224       0.003387451f, -0.008865356f, 0.029785156f, -0.089706421f, 0.080688477f, -0.628295898f,\r
1225       1.142211914f, 0.515609741f, 0.116577148f, 0.067520142f, 0.031738281f, 0.005294800f,\r
1226       0.003082275f, 0.000366211f, -0.000015259f, -0.000579834f, 0.003433228f, -0.009841919f,\r
1227       0.028884888f, -0.095169067f, 0.069595337f, -0.656219482f, 1.138763428f, 0.487472534f,\r
1228       0.123474121f, 0.061996460f, 0.031845093f, 0.004486084f, 0.002990723f, 0.000320435f,\r
1229       -0.000015259f, -0.000625610f, 0.003463745f, -0.010848999f, 0.027801514f, -0.100540161f,\r
1230       0.057617188f, -0.683914185f, 1.133926392f, 0.459472656f, 0.129577637f, 0.056533813f,\r
1231       0.031814575f, 0.003723145f, 0.002899170f, 0.000289917f, -0.000015259f, -0.000686646f,\r
1232       0.003479004f, -0.011886597f, 0.026535034f, -0.105819702f, 0.044784546f, -0.711318970f,\r
1233       1.127746582f, 0.431655884f, 0.134887695f, 0.051132202f, 0.031661987f, 0.003005981f,\r
1234       0.002792358f, 0.000259399f, -0.000015259f, -0.000747681f, 0.003479004f, -0.012939453f,\r
1235       0.025085449f, -0.110946655f, 0.031082153f, -0.738372803f, 1.120223999f, 0.404083252f,\r
1236       0.139450073f, 0.045837402f, 0.031387329f, 0.002334595f, 0.002685547f, 0.000244141f,\r
1237       -0.000030518f, -0.000808716f, 0.003463745f, -0.014022827f, 0.023422241f, -0.115921021f,\r
1238       0.016510010f, -0.765029907f, 1.111373901f, 0.376800537f, 0.143264771f, 0.040634155f,\r
1239       0.031005859f, 0.001693726f, 0.002578735f, 0.000213623f, -0.000030518f, -0.000885010f,\r
1240       0.003417969f, -0.015121460f, 0.021575928f, -0.120697021f, 0.001068115f, -0.791213989f,\r
1241       1.101211548f, 0.349868774f, 0.146362305f, 0.035552979f, 0.030532837f, 0.001098633f,\r
1242       0.002456665f, 0.000198364f, -0.000030518f, -0.000961304f, 0.003372192f, -0.016235352f,\r
1243       0.019531250f, -0.125259399f, -0.015228271f, -0.816864014f, 1.089782715f, 0.323318481f,\r
1244       0.148773193f, 0.030609131f, 0.029937744f, 0.000549316f, 0.002349854f, 0.000167847f,\r
1245       -0.000030518f, -0.001037598f, 0.003280640f, -0.017349243f, 0.017257690f, -0.129562378f,\r
1246       -0.032379150f, -0.841949463f, 1.077117920f, 0.297210693f, 0.150497437f, 0.025817871f,\r
1247       0.029281616f, 0.000030518f, 0.002243042f, 0.000152588f, -0.000045776f, -0.001113892f,\r
1248       0.003173828f, -0.018463135f, 0.014801025f, -0.133590698f, -0.050354004f, -0.866363525f,\r
1249       1.063217163f, 0.271591187f, 0.151596069f, 0.021179199f, 0.028533936f, -0.000442505f,\r
1250       0.002120972f, 0.000137329f, -0.000045776f, -0.001205444f, 0.003051758f, -0.019577026f,\r
1251       0.012115479f, -0.137298584f, -0.069168091f, -0.890090942f, 1.048156738f, 0.246505737f,\r
1252       0.152069092f, 0.016708374f, 0.027725220f, -0.000869751f, 0.002014160f, 0.000122070f,\r
1253       -0.000061035f, -0.001296997f, 0.002883911f, -0.020690918f, 0.009231567f, -0.140670776f,\r
1254       -0.088775635f, -0.913055420f, 1.031936646f, 0.221984863f, 0.151962280f, 0.012420654f,\r
1255       0.026840210f, -0.001266479f, 0.001907349f, 0.000106812f, -0.000061035f, -0.001388550f,\r
1256       0.002700806f, -0.021789551f, 0.006134033f, -0.143676758f, -0.109161377f, -0.935195923f,\r
1257       1.014617920f, 0.198059082f, 0.151306152f, 0.008316040f, 0.025909424f, -0.001617432f,\r
1258       0.001785278f, 0.000106812f, -0.000076294f, -0.001480103f, 0.002487183f, -0.022857666f,\r
1259       0.002822876f, -0.146255493f, -0.130310059f, -0.956481934f, 0.996246338f, 0.174789429f,\r
1260       0.150115967f, 0.004394531f, 0.024932861f, -0.001937866f, 0.001693726f, 0.000091553f,\r
1261       -0.000076294f, -0.001586914f, 0.002227783f, -0.023910522f, -0.000686646f, -0.148422241f,\r
1262       -0.152206421f, -0.976852417f, 0.976852417f, 0.152206421f, 0.148422241f, 0.000686646f,\r
1263       0.023910522f, -0.002227783f, 0.001586914f, 0.000076294f, -0.000091553f, -0.001693726f,\r
1264       0.001937866f, -0.024932861f, -0.004394531f, -0.150115967f, -0.174789429f, -0.996246338f,\r
1265       0.956481934f, 0.130310059f, 0.146255493f, -0.002822876f, 0.022857666f, -0.002487183f,\r
1266       0.001480103f, 0.000076294f, -0.000106812f, -0.001785278f, 0.001617432f, -0.025909424f,\r
1267       -0.008316040f, -0.151306152f, -0.198059082f, -1.014617920f, 0.935195923f, 0.109161377f,\r
1268       0.143676758f, -0.006134033f, 0.021789551f, -0.002700806f, 0.001388550f, 0.000061035f,\r
1269       -0.000106812f, -0.001907349f, 0.001266479f, -0.026840210f, -0.012420654f, -0.151962280f,\r
1270       -0.221984863f, -1.031936646f, 0.913055420f, 0.088775635f, 0.140670776f, -0.009231567f,\r
1271       0.020690918f, -0.002883911f, 0.001296997f, 0.000061035f, -0.000122070f, -0.002014160f,\r
1272       0.000869751f, -0.027725220f, -0.016708374f, -0.152069092f, -0.246505737f, -1.048156738f,\r
1273       0.890090942f, 0.069168091f, 0.137298584f, -0.012115479f, 0.019577026f, -0.003051758f,\r
1274       0.001205444f, 0.000045776f, -0.000137329f, -0.002120972f, 0.000442505f, -0.028533936f,\r
1275       -0.021179199f, -0.151596069f, -0.271591187f, -1.063217163f, 0.866363525f, 0.050354004f,\r
1276       0.133590698f, -0.014801025f, 0.018463135f, -0.003173828f, 0.001113892f, 0.000045776f,\r
1277       -0.000152588f, -0.002243042f, -0.000030518f, -0.029281616f, -0.025817871f, -0.150497437f,\r
1278       -0.297210693f, -1.077117920f, 0.841949463f, 0.032379150f, 0.129562378f, -0.017257690f,\r
1279       0.017349243f, -0.003280640f, 0.001037598f, 0.000030518f, -0.000167847f, -0.002349854f,\r
1280       -0.000549316f, -0.029937744f, -0.030609131f, -0.148773193f, -0.323318481f, -1.089782715f,\r
1281       0.816864014f, 0.015228271f, 0.125259399f, -0.019531250f, 0.016235352f, -0.003372192f,\r
1282       0.000961304f, 0.000030518f, -0.000198364f, -0.002456665f, -0.001098633f, -0.030532837f,\r
1283       -0.035552979f, -0.146362305f, -0.349868774f, -1.101211548f, 0.791213989f, -0.001068115f,\r
1284       0.120697021f, -0.021575928f, 0.015121460f, -0.003417969f, 0.000885010f, 0.000030518f,\r
1285       -0.000213623f, -0.002578735f, -0.001693726f, -0.031005859f, -0.040634155f, -0.143264771f,\r
1286       -0.376800537f, -1.111373901f, 0.765029907f, -0.016510010f, 0.115921021f, -0.023422241f,\r
1287       0.014022827f, -0.003463745f, 0.000808716f, 0.000030518f, -0.000244141f, -0.002685547f,\r
1288       -0.002334595f, -0.031387329f, -0.045837402f, -0.139450073f, -0.404083252f, -1.120223999f,\r
1289       0.738372803f, -0.031082153f, 0.110946655f, -0.025085449f, 0.012939453f, -0.003479004f,\r
1290       0.000747681f, 0.000015259f, -0.000259399f, -0.002792358f, -0.003005981f, -0.031661987f,\r
1291       -0.051132202f, -0.134887695f, -0.431655884f, -1.127746582f, 0.711318970f, -0.044784546f,\r
1292       0.105819702f, -0.026535034f, 0.011886597f, -0.003479004f, 0.000686646f, 0.000015259f,\r
1293       -0.000289917f, -0.002899170f, -0.003723145f, -0.031814575f, -0.056533813f, -0.129577637f,\r
1294       -0.459472656f, -1.133926392f, 0.683914185f, -0.057617188f, 0.100540161f, -0.027801514f,\r
1295       0.010848999f, -0.003463745f, 0.000625610f, 0.000015259f, -0.000320435f, -0.002990723f,\r
1296       -0.004486084f, -0.031845093f, -0.061996460f, -0.123474121f, -0.487472534f, -1.138763428f,\r
1297       0.656219482f, -0.069595337f, 0.095169067f, -0.028884888f, 0.009841919f, -0.003433228f,\r
1298       0.000579834f, 0.000015259f, -0.000366211f, -0.003082275f, -0.005294800f, -0.031738281f,\r
1299       -0.067520142f, -0.116577148f, -0.515609741f, -1.142211914f, 0.628295898f, -0.080688477f,\r
1300       0.089706421f, -0.029785156f, 0.008865356f, -0.003387451f, 0.000534058f, 0.000015259f,\r
1301       -0.000396729f, -0.003173828f, -0.006118774f, -0.031478882f, -0.073059082f, -0.108856201f,\r
1302       -0.543823242f, -1.144287109f, 0.600219727f, -0.090927124f, 0.084182739f, -0.030517578f,\r
1303       0.007919312f, -0.003326416f, 0.000473022f, 0.000015259f };\r
1304 \r
1305 }\r