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 /**\r
  33  * A class for the synthesis filter bank. This class does a fast downsampling\r
  34  * from 32, 44.1 or 48 kHz to 8 kHz, if ULAW is defined. Frequencies above 4 kHz\r
  35  * are removed by ignoring higher subbands.\r
  36  */\r
  37 @LATTICE("OUT<V1,V1<V,V<NEWV,NEWV<SAMPLE,SAMPLE<EQ,EQ<IDX,NEWV*,IDX*")\r
  38 @METHODDEFAULT("OUT<THIS,THIS<C,C<IN,C*,THISLOC=THIS,GLOBALLOC=THIS")\r
  39 final class SynthesisFilter {\r
  40 \r
  41   @LOC("IDX")\r
  42   private int vidx = 1;\r
  43   @LOC("V")\r
  44   private float[] v1;\r
  45   @LOC("V")\r
  46   private float[] v2;\r
  47   // private float[] actual_v; // v1 or v2\r
  48   @LOC("IDX")\r
  49   private int actual_write_pos; // 0-15\r
  50   @LOC("SAMPLE")\r
  51   private float[] samples; // 32 new subband samples\r
  52   @LOC("V")\r
  53   private int channel;\r
  54   @LOC("V")\r
  55   private float scalefactor;\r
  56   @LOC("EQ")\r
  57   private float[] eq;\r
  58 \r
  59   /**\r
  60    * Quality value for controlling CPU usage/quality tradeoff.\r
  61    */\r
  62   /*\r
  63    * private int quality;\r
  64    * \r
  65    * private int v_inc;\r
  66    * \r
  67    * \r
  68    * \r
  69    * public static final int HIGH_QUALITY = 1; public static final int\r
  70    * MEDIUM_QUALITY = 2; public static final int LOW_QUALITY = 4;\r
  71    */\r
  72 \r
  73   /**\r
  74    * Contructor. The scalefactor scales the calculated float pcm samples to\r
  75    * short values (raw pcm samples are in [-1.0, 1.0], if no violations occur).\r
  76    */\r
  77   public SynthesisFilter(int channelnumber, float factor, float[] eq0) {\r
  78 \r
  79     d16 = splitArray(d, 16);\r
  80 \r
  81     v1 = new float[512];\r
  82     v2 = new float[512];\r
  83     samples = new float[32];\r
  84     channel = channelnumber;\r
  85     scalefactor = factor;\r
  86     // setEQ(eq);\r
  87     // setQuality(HIGH_QUALITY);\r
  88 \r
  89     if (eq == null) {\r
  90       eq = new float[32];\r
  91       for (int i = 0; i < 32; i++)\r
  92         eq[i] = 1.0f;\r
  93     }\r
  94     if (eq.length < 32) {\r
  95       throw new IllegalArgumentException("eq0");\r
  96     }\r
  97 \r
  98     // reset();\r
  99 \r
 100     for (int p = 0; p < 512; p++)\r
 101       v1[p] = v2[p] = 0.0f;\r
 102 \r
 103     for (int p2 = 0; p2 < 32; p2++)\r
 104       samples[p2] = 0.0f;\r
 105 \r
 106     // actual_v = v1;\r
 107     actual_write_pos = 15;\r
 108 \r
 109   }\r
 110 \r
 111   /*\r
 112    * private void setQuality(int quality0) { switch (quality0) { case\r
 113    * HIGH_QUALITY: case MEDIUM_QUALITY: case LOW_QUALITY: v_inc = 16 * quality0;\r
 114    * quality = quality0; break; default : throw new\r
 115    * IllegalArgumentException("Unknown quality value"); } }\r
 116    * \r
 117    * public int getQuality() { return quality; }\r
 118    */\r
 119 \r
 120   /**\r
 121    * Inject Sample.\r
 122    */\r
 123   public void input_sample(@LOC("IN") float sample, @LOC("IN") int subbandnumber) {\r
 124     samples[subbandnumber] = eq[subbandnumber] * sample;\r
 125   }\r
 126 \r
 127   public void input_samples(@LOC("IN") float[] s) {\r
 128     for (@LOC("C") int i = 31; i >= 0; i--) {\r
 129       samples[i] = s[i] * eq[i];\r
 130     }\r
 131   }\r
 132 \r
 133   private void compute_new_v2_v1() {\r
 134 \r
 135     @LOC("THIS,SynthesisFilter.NEWV") float new_v0 = 0.0f;\r
 136     @LOC("THIS,SynthesisFilter.NEWV") float new_v1 = 0.0f;\r
 137     @LOC("THIS,SynthesisFilter.NEWV") float new_v2 = 0.0f;\r
 138     @LOC("THIS,SynthesisFilter.NEWV") float new_v3 = 0.0f;\r
 139     @LOC("THIS,SynthesisFilter.NEWV") float new_v4 = 0.0f;\r
 140     @LOC("THIS,SynthesisFilter.NEWV") float new_v5 = 0.0f;\r
 141     @LOC("THIS,SynthesisFilter.NEWV") float new_v6 = 0.0f;\r
 142     @LOC("THIS,SynthesisFilter.NEWV") float new_v7 = 0.0f;\r
 143     @LOC("THIS,SynthesisFilter.NEWV") float new_v8 = 0.0f;\r
 144     @LOC("THIS,SynthesisFilter.NEWV") float new_v9 = 0.0f;\r
 145     @LOC("THIS,SynthesisFilter.NEWV") float new_v10 = 0.0f;\r
 146     @LOC("THIS,SynthesisFilter.NEWV") float new_v11 = 0.0f;\r
 147     @LOC("THIS,SynthesisFilter.NEWV") float new_v12 = 0.0f;\r
 148     @LOC("THIS,SynthesisFilter.NEWV") float new_v13 = 0.0f;\r
 149     @LOC("THIS,SynthesisFilter.NEWV") float new_v14 = 0.0f;\r
 150     @LOC("THIS,SynthesisFilter.NEWV") float new_v15 = 0.0f;\r
 151     @LOC("THIS,SynthesisFilter.NEWV") float new_v16 = 0.0f;\r
 152     @LOC("THIS,SynthesisFilter.NEWV") float new_v17 = 0.0f;\r
 153     @LOC("THIS,SynthesisFilter.NEWV") float new_v18 = 0.0f;\r
 154     @LOC("THIS,SynthesisFilter.NEWV") float new_v19 = 0.0f;\r
 155     @LOC("THIS,SynthesisFilter.NEWV") float new_v20 = 0.0f;\r
 156     @LOC("THIS,SynthesisFilter.NEWV") float new_v21 = 0.0f;\r
 157     @LOC("THIS,SynthesisFilter.NEWV") float new_v22 = 0.0f;\r
 158     @LOC("THIS,SynthesisFilter.NEWV") float new_v23 = 0.0f;\r
 159     @LOC("THIS,SynthesisFilter.NEWV") float new_v24 = 0.0f;\r
 160     @LOC("THIS,SynthesisFilter.NEWV") float new_v25 = 0.0f;\r
 161     @LOC("THIS,SynthesisFilter.NEWV") float new_v26 = 0.0f;\r
 162     @LOC("THIS,SynthesisFilter.NEWV") float new_v27 = 0.0f;\r
 163     @LOC("THIS,SynthesisFilter.NEWV") float new_v28 = 0.0f;\r
 164     @LOC("THIS,SynthesisFilter.NEWV") float new_v29 = 0.0f;\r
 165     @LOC("THIS,SynthesisFilter.NEWV") float new_v30 = 0.0f;\r
 166     @LOC("THIS,SynthesisFilter.NEWV") float new_v31 = 0.0f;\r
 167 \r
 168     // float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure\r
 169     // 3-A.2 in ISO DIS 11172-3\r
 170     // float[] p = new float[16];\r
 171     // float[] pp = new float[16];\r
 172 \r
 173     // float[] s = samples;\r
 174 \r
 175     @LOC("THIS,SynthesisFilter.NEWV") float s0 = samples[0];\r
 176     @LOC("THIS,SynthesisFilter.NEWV") float s1 = samples[1];\r
 177     @LOC("THIS,SynthesisFilter.NEWV") float s2 = samples[2];\r
 178     @LOC("THIS,SynthesisFilter.NEWV") float s3 = samples[3];\r
 179     @LOC("THIS,SynthesisFilter.NEWV") float s4 = samples[4];\r
 180     @LOC("THIS,SynthesisFilter.NEWV") float s5 = samples[5];\r
 181     @LOC("THIS,SynthesisFilter.NEWV") float s6 = samples[6];\r
 182     @LOC("THIS,SynthesisFilter.NEWV") float s7 = samples[7];\r
 183     @LOC("THIS,SynthesisFilter.NEWV") float s8 = samples[8];\r
 184     @LOC("THIS,SynthesisFilter.NEWV") float s9 = samples[9];\r
 185     @LOC("THIS,SynthesisFilter.NEWV") float s10 = samples[10];\r
 186     @LOC("THIS,SynthesisFilter.NEWV") float s11 = samples[11];\r
 187     @LOC("THIS,SynthesisFilter.NEWV") float s12 = samples[12];\r
 188     @LOC("THIS,SynthesisFilter.NEWV") float s13 = samples[13];\r
 189     @LOC("THIS,SynthesisFilter.NEWV") float s14 = samples[14];\r
 190     @LOC("THIS,SynthesisFilter.NEWV") float s15 = samples[15];\r
 191     @LOC("THIS,SynthesisFilter.NEWV") float s16 = samples[16];\r
 192     @LOC("THIS,SynthesisFilter.NEWV") float s17 = samples[17];\r
 193     @LOC("THIS,SynthesisFilter.NEWV") float s18 = samples[18];\r
 194     @LOC("THIS,SynthesisFilter.NEWV") float s19 = samples[19];\r
 195     @LOC("THIS,SynthesisFilter.NEWV") float s20 = samples[20];\r
 196     @LOC("THIS,SynthesisFilter.NEWV") float s21 = samples[21];\r
 197     @LOC("THIS,SynthesisFilter.NEWV") float s22 = samples[22];\r
 198     @LOC("THIS,SynthesisFilter.NEWV") float s23 = samples[23];\r
 199     @LOC("THIS,SynthesisFilter.NEWV") float s24 = samples[24];\r
 200     @LOC("THIS,SynthesisFilter.NEWV") float s25 = samples[25];\r
 201     @LOC("THIS,SynthesisFilter.NEWV") float s26 = samples[26];\r
 202     @LOC("THIS,SynthesisFilter.NEWV") float s27 = samples[27];\r
 203     @LOC("THIS,SynthesisFilter.NEWV") float s28 = samples[28];\r
 204     @LOC("THIS,SynthesisFilter.NEWV") float s29 = samples[29];\r
 205     @LOC("THIS,SynthesisFilter.NEWV") float s30 = samples[30];\r
 206     @LOC("THIS,SynthesisFilter.NEWV") float s31 = samples[31];\r
 207 \r
 208     @LOC("THIS,SynthesisFilter.NEWV") float p0 = s0 + s31;\r
 209     @LOC("THIS,SynthesisFilter.NEWV") float p1 = s1 + s30;\r
 210     @LOC("THIS,SynthesisFilter.NEWV") float p2 = s2 + s29;\r
 211     @LOC("THIS,SynthesisFilter.NEWV") float p3 = s3 + s28;\r
 212     @LOC("THIS,SynthesisFilter.NEWV") float p4 = s4 + s27;\r
 213     @LOC("THIS,SynthesisFilter.NEWV") float p5 = s5 + s26;\r
 214     @LOC("THIS,SynthesisFilter.NEWV") float p6 = s6 + s25;\r
 215     @LOC("THIS,SynthesisFilter.NEWV") float p7 = s7 + s24;\r
 216     @LOC("THIS,SynthesisFilter.NEWV") float p8 = s8 + s23;\r
 217     @LOC("THIS,SynthesisFilter.NEWV") float p9 = s9 + s22;\r
 218     @LOC("THIS,SynthesisFilter.NEWV") float p10 = s10 + s21;\r
 219     @LOC("THIS,SynthesisFilter.NEWV") float p11 = s11 + s20;\r
 220     @LOC("THIS,SynthesisFilter.NEWV") float p12 = s12 + s19;\r
 221     @LOC("THIS,SynthesisFilter.NEWV") float p13 = s13 + s18;\r
 222     @LOC("THIS,SynthesisFilter.NEWV") float p14 = s14 + s17;\r
 223     @LOC("THIS,SynthesisFilter.NEWV") float p15 = s15 + s16;\r
 224 \r
 225     @LOC("THIS,SynthesisFilter.NEWV") float pp0 = p0 + p15;\r
 226     @LOC("THIS,SynthesisFilter.NEWV") float pp1 = p1 + p14;\r
 227     @LOC("THIS,SynthesisFilter.NEWV") float pp2 = p2 + p13;\r
 228     @LOC("THIS,SynthesisFilter.NEWV") float pp3 = p3 + p12;\r
 229     @LOC("THIS,SynthesisFilter.NEWV") float pp4 = p4 + p11;\r
 230     @LOC("THIS,SynthesisFilter.NEWV") float pp5 = p5 + p10;\r
 231     @LOC("THIS,SynthesisFilter.NEWV") float pp6 = p6 + p9;\r
 232     @LOC("THIS,SynthesisFilter.NEWV") float pp7 = p7 + p8;\r
 233     @LOC("THIS,SynthesisFilter.NEWV") float pp8 = (p0 - p15) * cos1_32;\r
 234     @LOC("THIS,SynthesisFilter.NEWV") float pp9 = (p1 - p14) * cos3_32;\r
 235     @LOC("THIS,SynthesisFilter.NEWV") float pp10 = (p2 - p13) * cos5_32;\r
 236     @LOC("THIS,SynthesisFilter.NEWV") float pp11 = (p3 - p12) * cos7_32;\r
 237     @LOC("THIS,SynthesisFilter.NEWV") float pp12 = (p4 - p11) * cos9_32;\r
 238     @LOC("THIS,SynthesisFilter.NEWV") float pp13 = (p5 - p10) * cos11_32;\r
 239     @LOC("THIS,SynthesisFilter.NEWV") float pp14 = (p6 - p9) * cos13_32;\r
 240     @LOC("THIS,SynthesisFilter.NEWV") float pp15 = (p7 - p8) * cos15_32;\r
 241 \r
 242     p0 = pp0 + pp7;\r
 243     p1 = pp1 + pp6;\r
 244     p2 = pp2 + pp5;\r
 245     p3 = pp3 + pp4;\r
 246     p4 = (pp0 - pp7) * cos1_16;\r
 247     p5 = (pp1 - pp6) * cos3_16;\r
 248     p6 = (pp2 - pp5) * cos5_16;\r
 249     p7 = (pp3 - pp4) * cos7_16;\r
 250     p8 = pp8 + pp15;\r
 251     p9 = pp9 + pp14;\r
 252     p10 = pp10 + pp13;\r
 253     p11 = pp11 + pp12;\r
 254     p12 = (pp8 - pp15) * cos1_16;\r
 255     p13 = (pp9 - pp14) * cos3_16;\r
 256     p14 = (pp10 - pp13) * cos5_16;\r
 257     p15 = (pp11 - pp12) * cos7_16;\r
 258 \r
 259     pp0 = p0 + p3;\r
 260     pp1 = p1 + p2;\r
 261     pp2 = (p0 - p3) * cos1_8;\r
 262     pp3 = (p1 - p2) * cos3_8;\r
 263     pp4 = p4 + p7;\r
 264     pp5 = p5 + p6;\r
 265     pp6 = (p4 - p7) * cos1_8;\r
 266     pp7 = (p5 - p6) * cos3_8;\r
 267     pp8 = p8 + p11;\r
 268     pp9 = p9 + p10;\r
 269     pp10 = (p8 - p11) * cos1_8;\r
 270     pp11 = (p9 - p10) * cos3_8;\r
 271     pp12 = p12 + p15;\r
 272     pp13 = p13 + p14;\r
 273     pp14 = (p12 - p15) * cos1_8;\r
 274     pp15 = (p13 - p14) * cos3_8;\r
 275 \r
 276     p0 = pp0 + pp1;\r
 277     p1 = (pp0 - pp1) * cos1_4;\r
 278     p2 = pp2 + pp3;\r
 279     p3 = (pp2 - pp3) * cos1_4;\r
 280     p4 = pp4 + pp5;\r
 281     p5 = (pp4 - pp5) * cos1_4;\r
 282     p6 = pp6 + pp7;\r
 283     p7 = (pp6 - pp7) * cos1_4;\r
 284     p8 = pp8 + pp9;\r
 285     p9 = (pp8 - pp9) * cos1_4;\r
 286     p10 = pp10 + pp11;\r
 287     p11 = (pp10 - pp11) * cos1_4;\r
 288     p12 = pp12 + pp13;\r
 289     p13 = (pp12 - pp13) * cos1_4;\r
 290     p14 = pp14 + pp15;\r
 291     p15 = (pp14 - pp15) * cos1_4;\r
 292 \r
 293     // this is pretty insane coding\r
 294     @LOC("THIS,SynthesisFilter.NEWV") float tmp1;\r
 295     new_v19/* 36-17 */= -(new_v4 = (new_v12 = p7) + p5) - p6;\r
 296     new_v27/* 44-17 */= -p6 - p7 - p4;\r
 297     new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13;\r
 298     new_v17/* 34-17 */= -(new_v2 = p15 + p13 + p9) - p14;\r
 299     new_v21/* 38-17 */= (tmp1 = -p14 - p15 - p10 - p11) - p13;\r
 300     new_v29/* 46-17 */= -p14 - p15 - p12 - p8;\r
 301     new_v25/* 42-17 */= tmp1 - p12;\r
 302     new_v31/* 48-17 */= -p0;\r
 303     new_v0 = p1;\r
 304     new_v23/* 40-17 */= -(new_v8 = p3) - p2;\r
 305 \r
 306     p0 = (s0 - s31) * cos1_64;\r
 307     p1 = (s1 - s30) * cos3_64;\r
 308     p2 = (s2 - s29) * cos5_64;\r
 309     p3 = (s3 - s28) * cos7_64;\r
 310     p4 = (s4 - s27) * cos9_64;\r
 311     p5 = (s5 - s26) * cos11_64;\r
 312     p6 = (s6 - s25) * cos13_64;\r
 313     p7 = (s7 - s24) * cos15_64;\r
 314     p8 = (s8 - s23) * cos17_64;\r
 315     p9 = (s9 - s22) * cos19_64;\r
 316     p10 = (s10 - s21) * cos21_64;\r
 317     p11 = (s11 - s20) * cos23_64;\r
 318     p12 = (s12 - s19) * cos25_64;\r
 319     p13 = (s13 - s18) * cos27_64;\r
 320     p14 = (s14 - s17) * cos29_64;\r
 321     p15 = (s15 - s16) * cos31_64;\r
 322 \r
 323     pp0 = p0 + p15;\r
 324     pp1 = p1 + p14;\r
 325     pp2 = p2 + p13;\r
 326     pp3 = p3 + p12;\r
 327     pp4 = p4 + p11;\r
 328     pp5 = p5 + p10;\r
 329     pp6 = p6 + p9;\r
 330     pp7 = p7 + p8;\r
 331     pp8 = (p0 - p15) * cos1_32;\r
 332     pp9 = (p1 - p14) * cos3_32;\r
 333     pp10 = (p2 - p13) * cos5_32;\r
 334     pp11 = (p3 - p12) * cos7_32;\r
 335     pp12 = (p4 - p11) * cos9_32;\r
 336     pp13 = (p5 - p10) * cos11_32;\r
 337     pp14 = (p6 - p9) * cos13_32;\r
 338     pp15 = (p7 - p8) * cos15_32;\r
 339 \r
 340     p0 = pp0 + pp7;\r
 341     p1 = pp1 + pp6;\r
 342     p2 = pp2 + pp5;\r
 343     p3 = pp3 + pp4;\r
 344     p4 = (pp0 - pp7) * cos1_16;\r
 345     p5 = (pp1 - pp6) * cos3_16;\r
 346     p6 = (pp2 - pp5) * cos5_16;\r
 347     p7 = (pp3 - pp4) * cos7_16;\r
 348     p8 = pp8 + pp15;\r
 349     p9 = pp9 + pp14;\r
 350     p10 = pp10 + pp13;\r
 351     p11 = pp11 + pp12;\r
 352     p12 = (pp8 - pp15) * cos1_16;\r
 353     p13 = (pp9 - pp14) * cos3_16;\r
 354     p14 = (pp10 - pp13) * cos5_16;\r
 355     p15 = (pp11 - pp12) * cos7_16;\r
 356 \r
 357     pp0 = p0 + p3;\r
 358     pp1 = p1 + p2;\r
 359     pp2 = (p0 - p3) * cos1_8;\r
 360     pp3 = (p1 - p2) * cos3_8;\r
 361     pp4 = p4 + p7;\r
 362     pp5 = p5 + p6;\r
 363     pp6 = (p4 - p7) * cos1_8;\r
 364     pp7 = (p5 - p6) * cos3_8;\r
 365     pp8 = p8 + p11;\r
 366     pp9 = p9 + p10;\r
 367     pp10 = (p8 - p11) * cos1_8;\r
 368     pp11 = (p9 - p10) * cos3_8;\r
 369     pp12 = p12 + p15;\r
 370     pp13 = p13 + p14;\r
 371     pp14 = (p12 - p15) * cos1_8;\r
 372     pp15 = (p13 - p14) * cos3_8;\r
 373 \r
 374     p0 = pp0 + pp1;\r
 375     p1 = (pp0 - pp1) * cos1_4;\r
 376     p2 = pp2 + pp3;\r
 377     p3 = (pp2 - pp3) * cos1_4;\r
 378     p4 = pp4 + pp5;\r
 379     p5 = (pp4 - pp5) * cos1_4;\r
 380     p6 = pp6 + pp7;\r
 381     p7 = (pp6 - pp7) * cos1_4;\r
 382     p8 = pp8 + pp9;\r
 383     p9 = (pp8 - pp9) * cos1_4;\r
 384     p10 = pp10 + pp11;\r
 385     p11 = (pp10 - pp11) * cos1_4;\r
 386     p12 = pp12 + pp13;\r
 387     p13 = (pp12 - pp13) * cos1_4;\r
 388     p14 = pp14 + pp15;\r
 389     p15 = (pp14 - pp15) * cos1_4;\r
 390 \r
 391     // manually doing something that a compiler should handle sucks\r
 392     // coding like this is hard to read\r
 393     @LOC("THIS,SynthesisFilter.NEWV") float tmp2;\r
 394     new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11) + p5 + p13;\r
 395     new_v7 = (new_v9 = p15 + p11 + p3) + p13;\r
 396     new_v16/* 33-17 */= -(new_v1 = (tmp1 = p13 + p15 + p9) + p1) - p14;\r
 397     new_v18/* 35-17 */= -(new_v3 = tmp1 + p5 + p7) - p6 - p14;\r
 398 \r
 399     new_v22/* 39-17 */= (tmp1 = -p10 - p11 - p14 - p15) - p13 - p2 - p3;\r
 400     new_v20/* 37-17 */= tmp1 - p13 - p5 - p6 - p7;\r
 401     new_v24/* 41-17 */= tmp1 - p12 - p2 - p3;\r
 402     new_v26/* 43-17 */= tmp1 - p12 - (tmp2 = p4 + p6 + p7);\r
 403     new_v30/* 47-17 */= (tmp1 = -p8 - p12 - p14 - p15) - p0;\r
 404     new_v28/* 45-17 */= tmp1 - tmp2;\r
 405 \r
 406     // insert V[0-15] (== new_v[0-15]) into actual v:\r
 407     // float[] x2 = actual_v + actual_write_pos;\r
 408     // float dest[] = actual_v; v2\r
 409 \r
 410     @LOC("THIS,SynthesisFilter.NEWV") int pos = actual_write_pos;\r
 411 \r
 412     v2[0 + pos] = new_v0;\r
 413     v2[16 + pos] = new_v1;\r
 414     v2[32 + pos] = new_v2;\r
 415     v2[48 + pos] = new_v3;\r
 416     v2[64 + pos] = new_v4;\r
 417     v2[80 + pos] = new_v5;\r
 418     v2[96 + pos] = new_v6;\r
 419     v2[112 + pos] = new_v7;\r
 420     v2[128 + pos] = new_v8;\r
 421     v2[144 + pos] = new_v9;\r
 422     v2[160 + pos] = new_v10;\r
 423     v2[176 + pos] = new_v11;\r
 424     v2[192 + pos] = new_v12;\r
 425     v2[208 + pos] = new_v13;\r
 426     v2[224 + pos] = new_v14;\r
 427     v2[240 + pos] = new_v15;\r
 428 \r
 429     // V[16] is always 0.0:\r
 430     v2[256 + pos] = 0.0f;\r
 431 \r
 432     // insert V[17-31] (== -new_v[15-1]) into actual v:\r
 433     v2[272 + pos] = -new_v15;\r
 434     v2[288 + pos] = -new_v14;\r
 435     v2[304 + pos] = -new_v13;\r
 436     v2[320 + pos] = -new_v12;\r
 437     v2[336 + pos] = -new_v11;\r
 438     v2[352 + pos] = -new_v10;\r
 439     v2[368 + pos] = -new_v9;\r
 440     v2[384 + pos] = -new_v8;\r
 441     v2[400 + pos] = -new_v7;\r
 442     v2[416 + pos] = -new_v6;\r
 443     v2[432 + pos] = -new_v5;\r
 444     v2[448 + pos] = -new_v4;\r
 445     v2[464 + pos] = -new_v3;\r
 446     v2[480 + pos] = -new_v2;\r
 447     v2[496 + pos] = -new_v1;\r
 448 \r
 449     // insert V[32] (== -new_v[0]) into other v:\r
 450     // dest = (actual_v == v1) ? v2 : v1;\r
 451 \r
 452     v1[0 + pos] = -new_v0;\r
 453     // insert V[33-48] (== new_v[16-31]) into other v:\r
 454     v1[16 + pos] = new_v16;\r
 455     v1[32 + pos] = new_v17;\r
 456     v1[48 + pos] = new_v18;\r
 457     v1[64 + pos] = new_v19;\r
 458     v1[80 + pos] = new_v20;\r
 459     v1[96 + pos] = new_v21;\r
 460     v1[112 + pos] = new_v22;\r
 461     v1[128 + pos] = new_v23;\r
 462     v1[144 + pos] = new_v24;\r
 463     v1[160 + pos] = new_v25;\r
 464     v1[176 + pos] = new_v26;\r
 465     v1[192 + pos] = new_v27;\r
 466     v1[208 + pos] = new_v28;\r
 467     v1[224 + pos] = new_v29;\r
 468     v1[240 + pos] = new_v30;\r
 469     v1[256 + pos] = new_v31;\r
 470 \r
 471     // insert V[49-63] (== new_v[30-16]) into other v:\r
 472     v1[272 + pos] = new_v30;\r
 473     v1[288 + pos] = new_v29;\r
 474     v1[304 + pos] = new_v28;\r
 475     v1[320 + pos] = new_v27;\r
 476     v1[336 + pos] = new_v26;\r
 477     v1[352 + pos] = new_v25;\r
 478     v1[368 + pos] = new_v24;\r
 479     v1[384 + pos] = new_v23;\r
 480     v1[400 + pos] = new_v22;\r
 481     v1[416 + pos] = new_v21;\r
 482     v1[432 + pos] = new_v20;\r
 483     v1[448 + pos] = new_v19;\r
 484     v1[464 + pos] = new_v18;\r
 485     v1[480 + pos] = new_v17;\r
 486     v1[496 + pos] = new_v16;\r
 487   }\r
 488 \r
 489   private void compute_new_v1_v2() {\r
 490 \r
 491     @LOC("THIS,SynthesisFilter.NEWV") float new_v0 = 0.0f;\r
 492     @LOC("THIS,SynthesisFilter.NEWV") float new_v1 = 0.0f;\r
 493     @LOC("THIS,SynthesisFilter.NEWV") float new_v2 = 0.0f;\r
 494     @LOC("THIS,SynthesisFilter.NEWV") float new_v3 = 0.0f;\r
 495     @LOC("THIS,SynthesisFilter.NEWV") float new_v4 = 0.0f;\r
 496     @LOC("THIS,SynthesisFilter.NEWV") float new_v5 = 0.0f;\r
 497     @LOC("THIS,SynthesisFilter.NEWV") float new_v6 = 0.0f;\r
 498     @LOC("THIS,SynthesisFilter.NEWV") float new_v7 = 0.0f;\r
 499     @LOC("THIS,SynthesisFilter.NEWV") float new_v8 = 0.0f;\r
 500     @LOC("THIS,SynthesisFilter.NEWV") float new_v9 = 0.0f;\r
 501     @LOC("THIS,SynthesisFilter.NEWV") float new_v10 = 0.0f;\r
 502     @LOC("THIS,SynthesisFilter.NEWV") float new_v11 = 0.0f;\r
 503     @LOC("THIS,SynthesisFilter.NEWV") float new_v12 = 0.0f;\r
 504     @LOC("THIS,SynthesisFilter.NEWV") float new_v13 = 0.0f;\r
 505     @LOC("THIS,SynthesisFilter.NEWV") float new_v14 = 0.0f;\r
 506     @LOC("THIS,SynthesisFilter.NEWV") float new_v15 = 0.0f;\r
 507     @LOC("THIS,SynthesisFilter.NEWV") float new_v16 = 0.0f;\r
 508     @LOC("THIS,SynthesisFilter.NEWV") float new_v17 = 0.0f;\r
 509     @LOC("THIS,SynthesisFilter.NEWV") float new_v18 = 0.0f;\r
 510     @LOC("THIS,SynthesisFilter.NEWV") float new_v19 = 0.0f;\r
 511     @LOC("THIS,SynthesisFilter.NEWV") float new_v20 = 0.0f;\r
 512     @LOC("THIS,SynthesisFilter.NEWV") float new_v21 = 0.0f;\r
 513     @LOC("THIS,SynthesisFilter.NEWV") float new_v22 = 0.0f;\r
 514     @LOC("THIS,SynthesisFilter.NEWV") float new_v23 = 0.0f;\r
 515     @LOC("THIS,SynthesisFilter.NEWV") float new_v24 = 0.0f;\r
 516     @LOC("THIS,SynthesisFilter.NEWV") float new_v25 = 0.0f;\r
 517     @LOC("THIS,SynthesisFilter.NEWV") float new_v26 = 0.0f;\r
 518     @LOC("THIS,SynthesisFilter.NEWV") float new_v27 = 0.0f;\r
 519     @LOC("THIS,SynthesisFilter.NEWV") float new_v28 = 0.0f;\r
 520     @LOC("THIS,SynthesisFilter.NEWV") float new_v29 = 0.0f;\r
 521     @LOC("THIS,SynthesisFilter.NEWV") float new_v30 = 0.0f;\r
 522     @LOC("THIS,SynthesisFilter.NEWV") float new_v31 = 0.0f;\r
 523 \r
 524     // float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure\r
 525     // 3-A.2 in ISO DIS 11172-3\r
 526     // float[] p = new float[16];\r
 527     // float[] pp = new float[16];\r
 528 \r
 529     // float[] s = samples;\r
 530 \r
 531     @LOC("THIS,SynthesisFilter.NEWV") float s0 = samples[0];\r
 532     @LOC("THIS,SynthesisFilter.NEWV") float s1 = samples[1];\r
 533     @LOC("THIS,SynthesisFilter.NEWV") float s2 = samples[2];\r
 534     @LOC("THIS,SynthesisFilter.NEWV") float s3 = samples[3];\r
 535     @LOC("THIS,SynthesisFilter.NEWV") float s4 = samples[4];\r
 536     @LOC("THIS,SynthesisFilter.NEWV") float s5 = samples[5];\r
 537     @LOC("THIS,SynthesisFilter.NEWV") float s6 = samples[6];\r
 538     @LOC("THIS,SynthesisFilter.NEWV") float s7 = samples[7];\r
 539     @LOC("THIS,SynthesisFilter.NEWV") float s8 = samples[8];\r
 540     @LOC("THIS,SynthesisFilter.NEWV") float s9 = samples[9];\r
 541     @LOC("THIS,SynthesisFilter.NEWV") float s10 = samples[10];\r
 542     @LOC("THIS,SynthesisFilter.NEWV") float s11 = samples[11];\r
 543     @LOC("THIS,SynthesisFilter.NEWV") float s12 = samples[12];\r
 544     @LOC("THIS,SynthesisFilter.NEWV") float s13 = samples[13];\r
 545     @LOC("THIS,SynthesisFilter.NEWV") float s14 = samples[14];\r
 546     @LOC("THIS,SynthesisFilter.NEWV") float s15 = samples[15];\r
 547     @LOC("THIS,SynthesisFilter.NEWV") float s16 = samples[16];\r
 548     @LOC("THIS,SynthesisFilter.NEWV") float s17 = samples[17];\r
 549     @LOC("THIS,SynthesisFilter.NEWV") float s18 = samples[18];\r
 550     @LOC("THIS,SynthesisFilter.NEWV") float s19 = samples[19];\r
 551     @LOC("THIS,SynthesisFilter.NEWV") float s20 = samples[20];\r
 552     @LOC("THIS,SynthesisFilter.NEWV") float s21 = samples[21];\r
 553     @LOC("THIS,SynthesisFilter.NEWV") float s22 = samples[22];\r
 554     @LOC("THIS,SynthesisFilter.NEWV") float s23 = samples[23];\r
 555     @LOC("THIS,SynthesisFilter.NEWV") float s24 = samples[24];\r
 556     @LOC("THIS,SynthesisFilter.NEWV") float s25 = samples[25];\r
 557     @LOC("THIS,SynthesisFilter.NEWV") float s26 = samples[26];\r
 558     @LOC("THIS,SynthesisFilter.NEWV") float s27 = samples[27];\r
 559     @LOC("THIS,SynthesisFilter.NEWV") float s28 = samples[28];\r
 560     @LOC("THIS,SynthesisFilter.NEWV") float s29 = samples[29];\r
 561     @LOC("THIS,SynthesisFilter.NEWV") float s30 = samples[30];\r
 562     @LOC("THIS,SynthesisFilter.NEWV") float s31 = samples[31];\r
 563 \r
 564     @LOC("THIS,SynthesisFilter.NEWV") float p0 = s0 + s31;\r
 565     @LOC("THIS,SynthesisFilter.NEWV") float p1 = s1 + s30;\r
 566     @LOC("THIS,SynthesisFilter.NEWV") float p2 = s2 + s29;\r
 567     @LOC("THIS,SynthesisFilter.NEWV") float p3 = s3 + s28;\r
 568     @LOC("THIS,SynthesisFilter.NEWV") float p4 = s4 + s27;\r
 569     @LOC("THIS,SynthesisFilter.NEWV") float p5 = s5 + s26;\r
 570     @LOC("THIS,SynthesisFilter.NEWV") float p6 = s6 + s25;\r
 571     @LOC("THIS,SynthesisFilter.NEWV") float p7 = s7 + s24;\r
 572     @LOC("THIS,SynthesisFilter.NEWV") float p8 = s8 + s23;\r
 573     @LOC("THIS,SynthesisFilter.NEWV") float p9 = s9 + s22;\r
 574     @LOC("THIS,SynthesisFilter.NEWV") float p10 = s10 + s21;\r
 575     @LOC("THIS,SynthesisFilter.NEWV") float p11 = s11 + s20;\r
 576     @LOC("THIS,SynthesisFilter.NEWV") float p12 = s12 + s19;\r
 577     @LOC("THIS,SynthesisFilter.NEWV") float p13 = s13 + s18;\r
 578     @LOC("THIS,SynthesisFilter.NEWV") float p14 = s14 + s17;\r
 579     @LOC("THIS,SynthesisFilter.NEWV") float p15 = s15 + s16;\r
 580 \r
 581     @LOC("THIS,SynthesisFilter.NEWV") float pp0 = p0 + p15;\r
 582     @LOC("THIS,SynthesisFilter.NEWV") float pp1 = p1 + p14;\r
 583     @LOC("THIS,SynthesisFilter.NEWV") float pp2 = p2 + p13;\r
 584     @LOC("THIS,SynthesisFilter.NEWV") float pp3 = p3 + p12;\r
 585     @LOC("THIS,SynthesisFilter.NEWV") float pp4 = p4 + p11;\r
 586     @LOC("THIS,SynthesisFilter.NEWV") float pp5 = p5 + p10;\r
 587     @LOC("THIS,SynthesisFilter.NEWV") float pp6 = p6 + p9;\r
 588     @LOC("THIS,SynthesisFilter.NEWV") float pp7 = p7 + p8;\r
 589     @LOC("THIS,SynthesisFilter.NEWV") float pp8 = (p0 - p15) * cos1_32;\r
 590     @LOC("THIS,SynthesisFilter.NEWV") float pp9 = (p1 - p14) * cos3_32;\r
 591     @LOC("THIS,SynthesisFilter.NEWV") float pp10 = (p2 - p13) * cos5_32;\r
 592     @LOC("THIS,SynthesisFilter.NEWV") float pp11 = (p3 - p12) * cos7_32;\r
 593     @LOC("THIS,SynthesisFilter.NEWV") float pp12 = (p4 - p11) * cos9_32;\r
 594     @LOC("THIS,SynthesisFilter.NEWV") float pp13 = (p5 - p10) * cos11_32;\r
 595     @LOC("THIS,SynthesisFilter.NEWV") float pp14 = (p6 - p9) * cos13_32;\r
 596     @LOC("THIS,SynthesisFilter.NEWV") float pp15 = (p7 - p8) * cos15_32;\r
 597 \r
 598     p0 = pp0 + pp7;\r
 599     p1 = pp1 + pp6;\r
 600     p2 = pp2 + pp5;\r
 601     p3 = pp3 + pp4;\r
 602     p4 = (pp0 - pp7) * cos1_16;\r
 603     p5 = (pp1 - pp6) * cos3_16;\r
 604     p6 = (pp2 - pp5) * cos5_16;\r
 605     p7 = (pp3 - pp4) * cos7_16;\r
 606     p8 = pp8 + pp15;\r
 607     p9 = pp9 + pp14;\r
 608     p10 = pp10 + pp13;\r
 609     p11 = pp11 + pp12;\r
 610     p12 = (pp8 - pp15) * cos1_16;\r
 611     p13 = (pp9 - pp14) * cos3_16;\r
 612     p14 = (pp10 - pp13) * cos5_16;\r
 613     p15 = (pp11 - pp12) * cos7_16;\r
 614 \r
 615     pp0 = p0 + p3;\r
 616     pp1 = p1 + p2;\r
 617     pp2 = (p0 - p3) * cos1_8;\r
 618     pp3 = (p1 - p2) * cos3_8;\r
 619     pp4 = p4 + p7;\r
 620     pp5 = p5 + p6;\r
 621     pp6 = (p4 - p7) * cos1_8;\r
 622     pp7 = (p5 - p6) * cos3_8;\r
 623     pp8 = p8 + p11;\r
 624     pp9 = p9 + p10;\r
 625     pp10 = (p8 - p11) * cos1_8;\r
 626     pp11 = (p9 - p10) * cos3_8;\r
 627     pp12 = p12 + p15;\r
 628     pp13 = p13 + p14;\r
 629     pp14 = (p12 - p15) * cos1_8;\r
 630     pp15 = (p13 - p14) * cos3_8;\r
 631 \r
 632     p0 = pp0 + pp1;\r
 633     p1 = (pp0 - pp1) * cos1_4;\r
 634     p2 = pp2 + pp3;\r
 635     p3 = (pp2 - pp3) * cos1_4;\r
 636     p4 = pp4 + pp5;\r
 637     p5 = (pp4 - pp5) * cos1_4;\r
 638     p6 = pp6 + pp7;\r
 639     p7 = (pp6 - pp7) * cos1_4;\r
 640     p8 = pp8 + pp9;\r
 641     p9 = (pp8 - pp9) * cos1_4;\r
 642     p10 = pp10 + pp11;\r
 643     p11 = (pp10 - pp11) * cos1_4;\r
 644     p12 = pp12 + pp13;\r
 645     p13 = (pp12 - pp13) * cos1_4;\r
 646     p14 = pp14 + pp15;\r
 647     p15 = (pp14 - pp15) * cos1_4;\r
 648 \r
 649     // this is pretty insane coding\r
 650     @LOC("THIS,SynthesisFilter.NEWV") float tmp1;\r
 651     new_v19/* 36-17 */= -(new_v4 = (new_v12 = p7) + p5) - p6;\r
 652     new_v27/* 44-17 */= -p6 - p7 - p4;\r
 653     new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13;\r
 654     new_v17/* 34-17 */= -(new_v2 = p15 + p13 + p9) - p14;\r
 655     new_v21/* 38-17 */= (tmp1 = -p14 - p15 - p10 - p11) - p13;\r
 656     new_v29/* 46-17 */= -p14 - p15 - p12 - p8;\r
 657     new_v25/* 42-17 */= tmp1 - p12;\r
 658     new_v31/* 48-17 */= -p0;\r
 659     new_v0 = p1;\r
 660     new_v23/* 40-17 */= -(new_v8 = p3) - p2;\r
 661 \r
 662     p0 = (s0 - s31) * cos1_64;\r
 663     p1 = (s1 - s30) * cos3_64;\r
 664     p2 = (s2 - s29) * cos5_64;\r
 665     p3 = (s3 - s28) * cos7_64;\r
 666     p4 = (s4 - s27) * cos9_64;\r
 667     p5 = (s5 - s26) * cos11_64;\r
 668     p6 = (s6 - s25) * cos13_64;\r
 669     p7 = (s7 - s24) * cos15_64;\r
 670     p8 = (s8 - s23) * cos17_64;\r
 671     p9 = (s9 - s22) * cos19_64;\r
 672     p10 = (s10 - s21) * cos21_64;\r
 673     p11 = (s11 - s20) * cos23_64;\r
 674     p12 = (s12 - s19) * cos25_64;\r
 675     p13 = (s13 - s18) * cos27_64;\r
 676     p14 = (s14 - s17) * cos29_64;\r
 677     p15 = (s15 - s16) * cos31_64;\r
 678 \r
 679     pp0 = p0 + p15;\r
 680     pp1 = p1 + p14;\r
 681     pp2 = p2 + p13;\r
 682     pp3 = p3 + p12;\r
 683     pp4 = p4 + p11;\r
 684     pp5 = p5 + p10;\r
 685     pp6 = p6 + p9;\r
 686     pp7 = p7 + p8;\r
 687     pp8 = (p0 - p15) * cos1_32;\r
 688     pp9 = (p1 - p14) * cos3_32;\r
 689     pp10 = (p2 - p13) * cos5_32;\r
 690     pp11 = (p3 - p12) * cos7_32;\r
 691     pp12 = (p4 - p11) * cos9_32;\r
 692     pp13 = (p5 - p10) * cos11_32;\r
 693     pp14 = (p6 - p9) * cos13_32;\r
 694     pp15 = (p7 - p8) * cos15_32;\r
 695 \r
 696     p0 = pp0 + pp7;\r
 697     p1 = pp1 + pp6;\r
 698     p2 = pp2 + pp5;\r
 699     p3 = pp3 + pp4;\r
 700     p4 = (pp0 - pp7) * cos1_16;\r
 701     p5 = (pp1 - pp6) * cos3_16;\r
 702     p6 = (pp2 - pp5) * cos5_16;\r
 703     p7 = (pp3 - pp4) * cos7_16;\r
 704     p8 = pp8 + pp15;\r
 705     p9 = pp9 + pp14;\r
 706     p10 = pp10 + pp13;\r
 707     p11 = pp11 + pp12;\r
 708     p12 = (pp8 - pp15) * cos1_16;\r
 709     p13 = (pp9 - pp14) * cos3_16;\r
 710     p14 = (pp10 - pp13) * cos5_16;\r
 711     p15 = (pp11 - pp12) * cos7_16;\r
 712 \r
 713     pp0 = p0 + p3;\r
 714     pp1 = p1 + p2;\r
 715     pp2 = (p0 - p3) * cos1_8;\r
 716     pp3 = (p1 - p2) * cos3_8;\r
 717     pp4 = p4 + p7;\r
 718     pp5 = p5 + p6;\r
 719     pp6 = (p4 - p7) * cos1_8;\r
 720     pp7 = (p5 - p6) * cos3_8;\r
 721     pp8 = p8 + p11;\r
 722     pp9 = p9 + p10;\r
 723     pp10 = (p8 - p11) * cos1_8;\r
 724     pp11 = (p9 - p10) * cos3_8;\r
 725     pp12 = p12 + p15;\r
 726     pp13 = p13 + p14;\r
 727     pp14 = (p12 - p15) * cos1_8;\r
 728     pp15 = (p13 - p14) * cos3_8;\r
 729 \r
 730     p0 = pp0 + pp1;\r
 731     p1 = (pp0 - pp1) * cos1_4;\r
 732     p2 = pp2 + pp3;\r
 733     p3 = (pp2 - pp3) * cos1_4;\r
 734     p4 = pp4 + pp5;\r
 735     p5 = (pp4 - pp5) * cos1_4;\r
 736     p6 = pp6 + pp7;\r
 737     p7 = (pp6 - pp7) * cos1_4;\r
 738     p8 = pp8 + pp9;\r
 739     p9 = (pp8 - pp9) * cos1_4;\r
 740     p10 = pp10 + pp11;\r
 741     p11 = (pp10 - pp11) * cos1_4;\r
 742     p12 = pp12 + pp13;\r
 743     p13 = (pp12 - pp13) * cos1_4;\r
 744     p14 = pp14 + pp15;\r
 745     p15 = (pp14 - pp15) * cos1_4;\r
 746 \r
 747     // manually doing something that a compiler should handle sucks\r
 748     // coding like this is hard to read\r
 749     @LOC("THIS,SynthesisFilter.NEWV") float tmp2;\r
 750     new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11) + p5 + p13;\r
 751     new_v7 = (new_v9 = p15 + p11 + p3) + p13;\r
 752     new_v16/* 33-17 */= -(new_v1 = (tmp1 = p13 + p15 + p9) + p1) - p14;\r
 753     new_v18/* 35-17 */= -(new_v3 = tmp1 + p5 + p7) - p6 - p14;\r
 754 \r
 755     new_v22/* 39-17 */= (tmp1 = -p10 - p11 - p14 - p15) - p13 - p2 - p3;\r
 756     new_v20/* 37-17 */= tmp1 - p13 - p5 - p6 - p7;\r
 757     new_v24/* 41-17 */= tmp1 - p12 - p2 - p3;\r
 758     new_v26/* 43-17 */= tmp1 - p12 - (tmp2 = p4 + p6 + p7);\r
 759     new_v30/* 47-17 */= (tmp1 = -p8 - p12 - p14 - p15) - p0;\r
 760     new_v28/* 45-17 */= tmp1 - tmp2;\r
 761 \r
 762     // insert V[0-15] (== new_v[0-15]) into actual v:\r
 763     // float[] x2 = actual_v + actual_write_pos;\r
 764     // float dest[] = actual_v; actual_v=v1;\r
 765 \r
 766     @LOC("THIS,SynthesisFilter.NEWV") int pos = actual_write_pos;\r
 767 \r
 768     v1[0 + pos] = new_v0;\r
 769     v1[16 + pos] = new_v1;\r
 770     v1[32 + pos] = new_v2;\r
 771     v1[48 + pos] = new_v3;\r
 772     v1[64 + pos] = new_v4;\r
 773     v1[80 + pos] = new_v5;\r
 774     v1[96 + pos] = new_v6;\r
 775     v1[112 + pos] = new_v7;\r
 776     v1[128 + pos] = new_v8;\r
 777     v1[144 + pos] = new_v9;\r
 778     v1[160 + pos] = new_v10;\r
 779     v1[176 + pos] = new_v11;\r
 780     v1[192 + pos] = new_v12;\r
 781     v1[208 + pos] = new_v13;\r
 782     v1[224 + pos] = new_v14;\r
 783     v1[240 + pos] = new_v15;\r
 784 \r
 785     // V[16] is always 0.0:\r
 786     v1[256 + pos] = 0.0f;\r
 787 \r
 788     // insert V[17-31] (== -new_v[15-1]) into actual v:\r
 789     v1[272 + pos] = -new_v15;\r
 790     v1[288 + pos] = -new_v14;\r
 791     v1[304 + pos] = -new_v13;\r
 792     v1[320 + pos] = -new_v12;\r
 793     v1[336 + pos] = -new_v11;\r
 794     v1[352 + pos] = -new_v10;\r
 795     v1[368 + pos] = -new_v9;\r
 796     v1[384 + pos] = -new_v8;\r
 797     v1[400 + pos] = -new_v7;\r
 798     v1[416 + pos] = -new_v6;\r
 799     v1[432 + pos] = -new_v5;\r
 800     v1[448 + pos] = -new_v4;\r
 801     v1[464 + pos] = -new_v3;\r
 802     v1[480 + pos] = -new_v2;\r
 803     v1[496 + pos] = -new_v1;\r
 804 \r
 805     // insert V[32] (== -new_v[0]) into other v:\r
 806     // dest = (actual_v == v1) ? v2 : v1;\r
 807 \r
 808     v2[0 + pos] = -new_v0;\r
 809     // insert V[33-48] (== new_v[16-31]) into other v:\r
 810     v2[16 + pos] = new_v16;\r
 811     v2[32 + pos] = new_v17;\r
 812     v2[48 + pos] = new_v18;\r
 813     v2[64 + pos] = new_v19;\r
 814     v2[80 + pos] = new_v20;\r
 815     v2[96 + pos] = new_v21;\r
 816     v2[112 + pos] = new_v22;\r
 817     v2[128 + pos] = new_v23;\r
 818     v2[144 + pos] = new_v24;\r
 819     v2[160 + pos] = new_v25;\r
 820     v2[176 + pos] = new_v26;\r
 821     v2[192 + pos] = new_v27;\r
 822     v2[208 + pos] = new_v28;\r
 823     v2[224 + pos] = new_v29;\r
 824     v2[240 + pos] = new_v30;\r
 825     v2[256 + pos] = new_v31;\r
 826 \r
 827     // insert V[49-63] (== new_v[30-16]) into other v:\r
 828     v2[272 + pos] = new_v30;\r
 829     v2[288 + pos] = new_v29;\r
 830     v2[304 + pos] = new_v28;\r
 831     v2[320 + pos] = new_v27;\r
 832     v2[336 + pos] = new_v26;\r
 833     v2[352 + pos] = new_v25;\r
 834     v2[368 + pos] = new_v24;\r
 835     v2[384 + pos] = new_v23;\r
 836     v2[400 + pos] = new_v22;\r
 837     v2[416 + pos] = new_v21;\r
 838     v2[432 + pos] = new_v20;\r
 839     v2[448 + pos] = new_v19;\r
 840     v2[464 + pos] = new_v18;\r
 841     v2[480 + pos] = new_v17;\r
 842     v2[496 + pos] = new_v16;\r
 843   }\r
 844 \r
 845   /**\r
 846    * Compute PCM Samples.\r
 847    */\r
 848 \r
 849   @LOC("OUT")\r
 850   private float[] _tmpOut = new float[32];\r
 851 \r
 852   private void compute_pcm_samples0() {\r
 853 \r
 854     if (vidx == 1) {\r
 855       // final float[] vp = actual_v;\r
 856       // int inc = v_inc;\r
 857       // final float[] tmpOut = _tmpOut;\r
 858       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
 859 \r
 860       // fat chance of having this loop unroll\r
 861       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
 862         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
 863         // final float[] dp = d16[i];\r
 864         pcm_sample =\r
 865             (float) (((v1[0 + dvp] * d16[i][0]) + (v1[15 + dvp] * d16[i][1])\r
 866                 + (v1[14 + dvp] * d16[i][2]) + (v1[13 + dvp] * d16[i][3])\r
 867                 + (v1[12 + dvp] * d16[i][4]) + (v1[11 + dvp] * d16[i][5])\r
 868                 + (v1[10 + dvp] * d16[i][6]) + (v1[9 + dvp] * d16[i][7])\r
 869                 + (v1[8 + dvp] * d16[i][8]) + (v1[7 + dvp] * d16[i][9])\r
 870                 + (v1[6 + dvp] * d16[i][10]) + (v1[5 + dvp] * d16[i][11])\r
 871                 + (v1[4 + dvp] * d16[i][12]) + (v1[3 + dvp] * d16[i][13])\r
 872                 + (v1[2 + dvp] * d16[i][14]) + (v1[1 + dvp] * d16[i][15])) * scalefactor);\r
 873 \r
 874         _tmpOut[i] = pcm_sample;\r
 875 \r
 876         dvp += 16;\r
 877       } // for\r
 878     } else {\r
 879       // final float[] vp = actual_v;\r
 880       // int inc = v_inc;\r
 881       // final float[] tmpOut = _tmpOut;\r
 882       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
 883 \r
 884       // fat chance of having this loop unroll\r
 885       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
 886         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
 887         // final float[] dp = d16[i];\r
 888         pcm_sample =\r
 889             (float) (((v2[0 + dvp] * d16[i][0]) + (v2[15 + dvp] * d16[i][1])\r
 890                 + (v2[14 + dvp] * d16[i][2]) + (v2[13 + dvp] * d16[i][3])\r
 891                 + (v2[12 + dvp] * d16[i][4]) + (v2[11 + dvp] * d16[i][5])\r
 892                 + (v2[10 + dvp] * d16[i][6]) + (v2[9 + dvp] * d16[i][7])\r
 893                 + (v2[8 + dvp] * d16[i][8]) + (v2[7 + dvp] * d16[i][9])\r
 894                 + (v2[6 + dvp] * d16[i][10]) + (v2[5 + dvp] * d16[i][11])\r
 895                 + (v2[4 + dvp] * d16[i][12]) + (v2[3 + dvp] * d16[i][13])\r
 896                 + (v2[2 + dvp] * d16[i][14]) + (v2[1 + dvp] * d16[i][15])) * scalefactor);\r
 897 \r
 898         _tmpOut[i] = pcm_sample;\r
 899 \r
 900         dvp += 16;\r
 901       } // for\r
 902     }\r
 903 \r
 904   }\r
 905 \r
 906   private void compute_pcm_samples1() {\r
 907 \r
 908     if (vidx == 1) {\r
 909       // final float[] vp = actual_v;\r
 910       // int inc = v_inc;\r
 911       // final float[] tmpOut = _tmpOut;\r
 912       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
 913 \r
 914       // fat chance of having this loop unroll\r
 915       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
 916         // final float[] dp = d16[i];\r
 917         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
 918 \r
 919         pcm_sample =\r
 920             (float) (((v1[1 + dvp] * d16[i][0]) + (v1[0 + dvp] * d16[i][1])\r
 921                 + (v1[15 + dvp] * d16[i][2]) + (v1[14 + dvp] * d16[i][3])\r
 922                 + (v1[13 + dvp] * d16[i][4]) + (v1[12 + dvp] * d16[i][5])\r
 923                 + (v1[11 + dvp] * d16[i][6]) + (v1[10 + dvp] * d16[i][7])\r
 924                 + (v1[9 + dvp] * d16[i][8]) + (v1[8 + dvp] * d16[i][9])\r
 925                 + (v1[7 + dvp] * d16[i][10]) + (v1[6 + dvp] * d16[i][11])\r
 926                 + (v1[5 + dvp] * d16[i][12]) + (v1[4 + dvp] * d16[i][13])\r
 927                 + (v1[3 + dvp] * d16[i][14]) + (v1[2 + dvp] * d16[i][15])) * scalefactor);\r
 928 \r
 929         _tmpOut[i] = pcm_sample;\r
 930 \r
 931         dvp += 16;\r
 932       } // for\r
 933     } else {\r
 934       // final float[] vp = actual_v;\r
 935       // int inc = v_inc;\r
 936       // final float[] tmpOut = _tmpOut;\r
 937       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
 938 \r
 939       // fat chance of having this loop unroll\r
 940       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
 941         // final float[] dp = d16[i];\r
 942         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
 943 \r
 944         pcm_sample =\r
 945             (float) (((v2[1 + dvp] * d16[i][0]) + (v2[0 + dvp] * d16[i][1])\r
 946                 + (v2[15 + dvp] * d16[i][2]) + (v2[14 + dvp] * d16[i][3])\r
 947                 + (v2[13 + dvp] * d16[i][4]) + (v2[12 + dvp] * d16[i][5])\r
 948                 + (v2[11 + dvp] * d16[i][6]) + (v2[10 + dvp] * d16[i][7])\r
 949                 + (v2[9 + dvp] * d16[i][8]) + (v2[8 + dvp] * d16[i][9])\r
 950                 + (v2[7 + dvp] * d16[i][10]) + (v2[6 + dvp] * d16[i][11])\r
 951                 + (v2[5 + dvp] * d16[i][12]) + (v2[4 + dvp] * d16[i][13])\r
 952                 + (v2[3 + dvp] * d16[i][14]) + (v2[2 + dvp] * d16[i][15])) * scalefactor);\r
 953 \r
 954         _tmpOut[i] = pcm_sample;\r
 955 \r
 956         dvp += 16;\r
 957       } // for\r
 958     }\r
 959 \r
 960   }\r
 961 \r
 962   private void compute_pcm_samples2() {\r
 963 \r
 964     if (vidx == 1) {\r
 965       // final float[] vp = actual_v;\r
 966       // int inc = v_inc;\r
 967       // final float[] tmpOut = _tmpOut;\r
 968       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
 969 \r
 970       // fat chance of having this loop unroll\r
 971       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
 972         // final float[] dp = d16[i];\r
 973         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
 974 \r
 975         pcm_sample =\r
 976             (float) (((v1[2 + dvp] * d16[i][0]) + (v1[1 + dvp] * d16[i][1])\r
 977                 + (v1[0 + dvp] * d16[i][2]) + (v1[15 + dvp] * d16[i][3])\r
 978                 + (v1[14 + dvp] * d16[i][4]) + (v1[13 + dvp] * d16[i][5])\r
 979                 + (v1[12 + dvp] * d16[i][6]) + (v1[11 + dvp] * d16[i][7])\r
 980                 + (v1[10 + dvp] * d16[i][8]) + (v1[9 + dvp] * d16[i][9])\r
 981                 + (v1[8 + dvp] * d16[i][10]) + (v1[7 + dvp] * d16[i][11])\r
 982                 + (v1[6 + dvp] * d16[i][12]) + (v1[5 + dvp] * d16[i][13])\r
 983                 + (v1[4 + dvp] * d16[i][14]) + (v1[3 + dvp] * d16[i][15])) * scalefactor);\r
 984 \r
 985         _tmpOut[i] = pcm_sample;\r
 986 \r
 987         dvp += 16;\r
 988       } // for\r
 989     } else {\r
 990       // final float[] vp = actual_v;\r
 991       // int inc = v_inc;\r
 992       // final float[] tmpOut = _tmpOut;\r
 993       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
 994 \r
 995       // fat chance of having this loop unroll\r
 996       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
 997         // final float[] dp = d16[i];\r
 998         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
 999 \r
1000         pcm_sample =\r
1001             (float) (((v2[2 + dvp] * d16[i][0]) + (v2[1 + dvp] * d16[i][1])\r
1002                 + (v2[0 + dvp] * d16[i][2]) + (v2[15 + dvp] * d16[i][3])\r
1003                 + (v2[14 + dvp] * d16[i][4]) + (v2[13 + dvp] * d16[i][5])\r
1004                 + (v2[12 + dvp] * d16[i][6]) + (v2[11 + dvp] * d16[i][7])\r
1005                 + (v2[10 + dvp] * d16[i][8]) + (v2[9 + dvp] * d16[i][9])\r
1006                 + (v2[8 + dvp] * d16[i][10]) + (v2[7 + dvp] * d16[i][11])\r
1007                 + (v2[6 + dvp] * d16[i][12]) + (v2[5 + dvp] * d16[i][13])\r
1008                 + (v2[4 + dvp] * d16[i][14]) + (v2[3 + dvp] * d16[i][15])) * scalefactor);\r
1009 \r
1010         _tmpOut[i] = pcm_sample;\r
1011 \r
1012         dvp += 16;\r
1013       } // for\r
1014     }\r
1015 \r
1016   }\r
1017 \r
1018   private void compute_pcm_samples3() {\r
1019 \r
1020     if (vidx == 1) {\r
1021       // final float[] vp = actual_v;\r
1022 \r
1023       // int inc = v_inc;\r
1024       // final float[] tmpOut = _tmpOut;\r
1025       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1026 \r
1027       // fat chance of having this loop unroll\r
1028       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1029         // final float[] dp = d16[i];\r
1030         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1031 \r
1032         pcm_sample =\r
1033             (float) (((v1[3 + dvp] * d16[i][0]) + (v1[2 + dvp] * d16[i][1])\r
1034                 + (v1[1 + dvp] * d16[i][2]) + (v1[0 + dvp] * d16[i][3])\r
1035                 + (v1[15 + dvp] * d16[i][4]) + (v1[14 + dvp] * d16[i][5])\r
1036                 + (v1[13 + dvp] * d16[i][6]) + (v1[12 + dvp] * d16[i][7])\r
1037                 + (v1[11 + dvp] * d16[i][8]) + (v1[10 + dvp] * d16[i][9])\r
1038                 + (v1[9 + dvp] * d16[i][10]) + (v1[8 + dvp] * d16[i][11])\r
1039                 + (v1[7 + dvp] * d16[i][12]) + (v1[6 + dvp] * d16[i][13])\r
1040                 + (v1[5 + dvp] * d16[i][14]) + (v1[4 + dvp] * d16[i][15])) * scalefactor);\r
1041 \r
1042         _tmpOut[i] = pcm_sample;\r
1043 \r
1044         dvp += 16;\r
1045       } // for\r
1046     } else {\r
1047       // final float[] vp = actual_v;\r
1048 \r
1049       // int inc = v_inc;\r
1050       // final float[] tmpOut = _tmpOut;\r
1051       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1052 \r
1053       // fat chance of having this loop unroll\r
1054       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1055         // final float[] dp = d16[i];\r
1056         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1057 \r
1058         pcm_sample =\r
1059             (float) (((v2[3 + dvp] * d16[i][0]) + (v2[2 + dvp] * d16[i][1])\r
1060                 + (v2[1 + dvp] * d16[i][2]) + (v2[0 + dvp] * d16[i][3])\r
1061                 + (v2[15 + dvp] * d16[i][4]) + (v2[14 + dvp] * d16[i][5])\r
1062                 + (v2[13 + dvp] * d16[i][6]) + (v2[12 + dvp] * d16[i][7])\r
1063                 + (v2[11 + dvp] * d16[i][8]) + (v2[10 + dvp] * d16[i][9])\r
1064                 + (v2[9 + dvp] * d16[i][10]) + (v2[8 + dvp] * d16[i][11])\r
1065                 + (v2[7 + dvp] * d16[i][12]) + (v2[6 + dvp] * d16[i][13])\r
1066                 + (v2[5 + dvp] * d16[i][14]) + (v2[4 + dvp] * d16[i][15])) * scalefactor);\r
1067 \r
1068         _tmpOut[i] = pcm_sample;\r
1069 \r
1070         dvp += 16;\r
1071       } // for\r
1072     }\r
1073 \r
1074   }\r
1075 \r
1076   private void compute_pcm_samples4() {\r
1077 \r
1078     if (vidx == 1) {\r
1079       // final float[] vp = actual_v;\r
1080 \r
1081       // int inc = v_inc;\r
1082       // final float[] tmpOut = _tmpOut;\r
1083       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1084 \r
1085       // fat chance of having this loop unroll\r
1086       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1087         // final float[] dp = d16[i];\r
1088         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1089 \r
1090         pcm_sample =\r
1091             (float) (((v1[4 + dvp] * d16[i][0]) + (v1[3 + dvp] * d16[i][1])\r
1092                 + (v1[2 + dvp] * d16[i][2]) + (v1[1 + dvp] * d16[i][3]) + (v1[0 + dvp] * d16[i][4])\r
1093                 + (v1[15 + dvp] * d16[i][5]) + (v1[14 + dvp] * d16[i][6])\r
1094                 + (v1[13 + dvp] * d16[i][7]) + (v1[12 + dvp] * d16[i][8])\r
1095                 + (v1[11 + dvp] * d16[i][9]) + (v1[10 + dvp] * d16[i][10])\r
1096                 + (v1[9 + dvp] * d16[i][11]) + (v1[8 + dvp] * d16[i][12])\r
1097                 + (v1[7 + dvp] * d16[i][13]) + (v1[6 + dvp] * d16[i][14]) + (v1[5 + dvp] * d16[i][15])) * scalefactor);\r
1098 \r
1099         _tmpOut[i] = pcm_sample;\r
1100 \r
1101         dvp += 16;\r
1102       } // for\r
1103     } else {\r
1104       // final float[] vp = actual_v;\r
1105 \r
1106       // int inc = v_inc;\r
1107       // final float[] tmpOut = _tmpOut;\r
1108       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1109 \r
1110       // fat chance of having this loop unroll\r
1111       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1112         // final float[] dp = d16[i];\r
1113         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1114 \r
1115         pcm_sample =\r
1116             (float) (((v2[4 + dvp] * d16[i][0]) + (v2[3 + dvp] * d16[i][1])\r
1117                 + (v2[2 + dvp] * d16[i][2]) + (v2[1 + dvp] * d16[i][3]) + (v2[0 + dvp] * d16[i][4])\r
1118                 + (v2[15 + dvp] * d16[i][5]) + (v2[14 + dvp] * d16[i][6])\r
1119                 + (v2[13 + dvp] * d16[i][7]) + (v2[12 + dvp] * d16[i][8])\r
1120                 + (v2[11 + dvp] * d16[i][9]) + (v2[10 + dvp] * d16[i][10])\r
1121                 + (v2[9 + dvp] * d16[i][11]) + (v2[8 + dvp] * d16[i][12])\r
1122                 + (v2[7 + dvp] * d16[i][13]) + (v2[6 + dvp] * d16[i][14]) + (v2[5 + dvp] * d16[i][15])) * scalefactor);\r
1123 \r
1124         _tmpOut[i] = pcm_sample;\r
1125 \r
1126         dvp += 16;\r
1127       } // for\r
1128     }\r
1129 \r
1130   }\r
1131 \r
1132   private void compute_pcm_samples5() {\r
1133 \r
1134     if (vidx == 1) {\r
1135       // final float[] vp = actual_v;\r
1136 \r
1137       // int inc = v_inc;\r
1138       // final float[] tmpOut = _tmpOut;\r
1139       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1140 \r
1141       // fat chance of having this loop unroll\r
1142       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1143         // final float[] dp = d16[i];\r
1144         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1145 \r
1146         pcm_sample =\r
1147             (float) (((v1[5 + dvp] * d16[i][0]) + (v1[4 + dvp] * d16[i][1])\r
1148                 + (v1[3 + dvp] * d16[i][2]) + (v1[2 + dvp] * d16[i][3]) + (v1[1 + dvp] * d16[i][4])\r
1149                 + (v1[0 + dvp] * d16[i][5]) + (v1[15 + dvp] * d16[i][6])\r
1150                 + (v1[14 + dvp] * d16[i][7]) + (v1[13 + dvp] * d16[i][8])\r
1151                 + (v1[12 + dvp] * d16[i][9]) + (v1[11 + dvp] * d16[i][10])\r
1152                 + (v1[10 + dvp] * d16[i][11]) + (v1[9 + dvp] * d16[i][12])\r
1153                 + (v1[8 + dvp] * d16[i][13]) + (v1[7 + dvp] * d16[i][14]) + (v1[6 + dvp] * d16[i][15])) * scalefactor);\r
1154 \r
1155         _tmpOut[i] = pcm_sample;\r
1156 \r
1157         dvp += 16;\r
1158       } // for\r
1159     } else {\r
1160       // final float[] vp = actual_v;\r
1161 \r
1162       // int inc = v_inc;\r
1163       // final float[] tmpOut = _tmpOut;\r
1164       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1165 \r
1166       // fat chance of having this loop unroll\r
1167       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1168         // final float[] dp = d16[i];\r
1169         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1170 \r
1171         pcm_sample =\r
1172             (float) (((v2[5 + dvp] * d16[i][0]) + (v2[4 + dvp] * d16[i][1])\r
1173                 + (v2[3 + dvp] * d16[i][2]) + (v2[2 + dvp] * d16[i][3]) + (v2[1 + dvp] * d16[i][4])\r
1174                 + (v2[0 + dvp] * d16[i][5]) + (v2[15 + dvp] * d16[i][6])\r
1175                 + (v2[14 + dvp] * d16[i][7]) + (v2[13 + dvp] * d16[i][8])\r
1176                 + (v2[12 + dvp] * d16[i][9]) + (v2[11 + dvp] * d16[i][10])\r
1177                 + (v2[10 + dvp] * d16[i][11]) + (v2[9 + dvp] * d16[i][12])\r
1178                 + (v2[8 + dvp] * d16[i][13]) + (v2[7 + dvp] * d16[i][14]) + (v2[6 + dvp] * d16[i][15])) * scalefactor);\r
1179 \r
1180         _tmpOut[i] = pcm_sample;\r
1181 \r
1182         dvp += 16;\r
1183       } // for\r
1184     }\r
1185 \r
1186   }\r
1187 \r
1188   private void compute_pcm_samples6() {\r
1189 \r
1190     if (vidx == 1) {\r
1191 \r
1192       // final float[] vp = actual_v;\r
1193       // int inc = v_inc;\r
1194       // final float[] tmpOut = _tmpOut;\r
1195       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1196 \r
1197       // fat chance of having this loop unroll\r
1198       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1199         // final float[] dp = d16[i];\r
1200         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1201 \r
1202         pcm_sample =\r
1203             (float) (((v1[6 + dvp] * d16[i][0]) + (v1[5 + dvp] * d16[i][1])\r
1204                 + (v1[4 + dvp] * d16[i][2]) + (v1[3 + dvp] * d16[i][3]) + (v1[2 + dvp] * d16[i][4])\r
1205                 + (v1[1 + dvp] * d16[i][5]) + (v1[0 + dvp] * d16[i][6])\r
1206                 + (v1[15 + dvp] * d16[i][7]) + (v1[14 + dvp] * d16[i][8])\r
1207                 + (v1[13 + dvp] * d16[i][9]) + (v1[12 + dvp] * d16[i][10])\r
1208                 + (v1[11 + dvp] * d16[i][11]) + (v1[10 + dvp] * d16[i][12])\r
1209                 + (v1[9 + dvp] * d16[i][13]) + (v1[8 + dvp] * d16[i][14]) + (v1[7 + dvp] * d16[i][15])) * scalefactor);\r
1210 \r
1211         _tmpOut[i] = pcm_sample;\r
1212 \r
1213         dvp += 16;\r
1214       } // for\r
1215     } else {\r
1216 \r
1217       // final float[] vp = actual_v;\r
1218       // int inc = v_inc;\r
1219       // final float[] tmpOut = _tmpOut;\r
1220       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1221 \r
1222       // fat chance of having this loop unroll\r
1223       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1224         // final float[] dp = d16[i];\r
1225         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1226 \r
1227         pcm_sample =\r
1228             (float) (((v2[6 + dvp] * d16[i][0]) + (v2[5 + dvp] * d16[i][1])\r
1229                 + (v2[4 + dvp] * d16[i][2]) + (v2[3 + dvp] * d16[i][3]) + (v2[2 + dvp] * d16[i][4])\r
1230                 + (v2[1 + dvp] * d16[i][5]) + (v2[0 + dvp] * d16[i][6])\r
1231                 + (v2[15 + dvp] * d16[i][7]) + (v2[14 + dvp] * d16[i][8])\r
1232                 + (v2[13 + dvp] * d16[i][9]) + (v2[12 + dvp] * d16[i][10])\r
1233                 + (v2[11 + dvp] * d16[i][11]) + (v2[10 + dvp] * d16[i][12])\r
1234                 + (v2[9 + dvp] * d16[i][13]) + (v2[8 + dvp] * d16[i][14]) + (v2[7 + dvp] * d16[i][15])) * scalefactor);\r
1235 \r
1236         _tmpOut[i] = pcm_sample;\r
1237 \r
1238         dvp += 16;\r
1239       } // for\r
1240     }\r
1241 \r
1242   }\r
1243 \r
1244   private void compute_pcm_samples7() {\r
1245 \r
1246     if (vidx == 1) {\r
1247       // final float[] vp = actual_v;\r
1248 \r
1249       // int inc = v_inc;\r
1250       // final float[] tmpOut = _tmpOut;\r
1251       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1252 \r
1253       // fat chance of having this loop unroll\r
1254       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1255         // final float[] dp = d16[i];\r
1256         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1257 \r
1258         pcm_sample =\r
1259             (float) (((v1[7 + dvp] * d16[i][0]) + (v1[6 + dvp] * d16[i][1])\r
1260                 + (v1[5 + dvp] * d16[i][2]) + (v1[4 + dvp] * d16[i][3]) + (v1[3 + dvp] * d16[i][4])\r
1261                 + (v1[2 + dvp] * d16[i][5]) + (v1[1 + dvp] * d16[i][6]) + (v1[0 + dvp] * d16[i][7])\r
1262                 + (v1[15 + dvp] * d16[i][8]) + (v1[14 + dvp] * d16[i][9])\r
1263                 + (v1[13 + dvp] * d16[i][10]) + (v1[12 + dvp] * d16[i][11])\r
1264                 + (v1[11 + dvp] * d16[i][12]) + (v1[10 + dvp] * d16[i][13])\r
1265                 + (v1[9 + dvp] * d16[i][14]) + (v1[8 + dvp] * d16[i][15])) * scalefactor);\r
1266 \r
1267         _tmpOut[i] = pcm_sample;\r
1268 \r
1269         dvp += 16;\r
1270       } // for\r
1271     } else {\r
1272       // final float[] vp = actual_v;\r
1273 \r
1274       // int inc = v_inc;\r
1275       // final float[] tmpOut = _tmpOut;\r
1276       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1277 \r
1278       // fat chance of having this loop unroll\r
1279       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1280         // final float[] dp = d16[i];\r
1281         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1282 \r
1283         pcm_sample =\r
1284             (float) (((v2[7 + dvp] * d16[i][0]) + (v2[6 + dvp] * d16[i][1])\r
1285                 + (v2[5 + dvp] * d16[i][2]) + (v2[4 + dvp] * d16[i][3]) + (v2[3 + dvp] * d16[i][4])\r
1286                 + (v2[2 + dvp] * d16[i][5]) + (v2[1 + dvp] * d16[i][6]) + (v2[0 + dvp] * d16[i][7])\r
1287                 + (v2[15 + dvp] * d16[i][8]) + (v2[14 + dvp] * d16[i][9])\r
1288                 + (v2[13 + dvp] * d16[i][10]) + (v2[12 + dvp] * d16[i][11])\r
1289                 + (v2[11 + dvp] * d16[i][12]) + (v2[10 + dvp] * d16[i][13])\r
1290                 + (v2[9 + dvp] * d16[i][14]) + (v2[8 + dvp] * d16[i][15])) * scalefactor);\r
1291 \r
1292         _tmpOut[i] = pcm_sample;\r
1293 \r
1294         dvp += 16;\r
1295       } // for\r
1296     }\r
1297 \r
1298   }\r
1299 \r
1300   private void compute_pcm_samples8() {\r
1301 \r
1302     if (vidx == 1) {\r
1303 \r
1304       // final float[] vp = actual_v;\r
1305 \r
1306       // int inc = v_inc;\r
1307       // final float[] tmpOut = _tmpOut;\r
1308       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1309 \r
1310       // fat chance of having this loop unroll\r
1311       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1312         // final float[] dp = d16[i];\r
1313         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1314 \r
1315         pcm_sample =\r
1316             (float) (((v1[8 + dvp] * d16[i][0]) + (v1[7 + dvp] * d16[i][1])\r
1317                 + (v1[6 + dvp] * d16[i][2]) + (v1[5 + dvp] * d16[i][3]) + (v1[4 + dvp] * d16[i][4])\r
1318                 + (v1[3 + dvp] * d16[i][5]) + (v1[2 + dvp] * d16[i][6]) + (v1[1 + dvp] * d16[i][7])\r
1319                 + (v1[0 + dvp] * d16[i][8]) + (v1[15 + dvp] * d16[i][9])\r
1320                 + (v1[14 + dvp] * d16[i][10]) + (v1[13 + dvp] * d16[i][11])\r
1321                 + (v1[12 + dvp] * d16[i][12]) + (v1[11 + dvp] * d16[i][13])\r
1322                 + (v1[10 + dvp] * d16[i][14]) + (v1[9 + dvp] * d16[i][15])) * scalefactor);\r
1323 \r
1324         _tmpOut[i] = pcm_sample;\r
1325 \r
1326         dvp += 16;\r
1327       } // for\r
1328     } else {\r
1329 \r
1330       // final float[] vp = actual_v;\r
1331 \r
1332       // int inc = v_inc;\r
1333       // final float[] tmpOut = _tmpOut;\r
1334       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1335 \r
1336       // fat chance of having this loop unroll\r
1337       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1338         // final float[] dp = d16[i];\r
1339         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1340 \r
1341         pcm_sample =\r
1342             (float) (((v2[8 + dvp] * d16[i][0]) + (v2[7 + dvp] * d16[i][1])\r
1343                 + (v2[6 + dvp] * d16[i][2]) + (v2[5 + dvp] * d16[i][3]) + (v2[4 + dvp] * d16[i][4])\r
1344                 + (v2[3 + dvp] * d16[i][5]) + (v2[2 + dvp] * d16[i][6]) + (v2[1 + dvp] * d16[i][7])\r
1345                 + (v2[0 + dvp] * d16[i][8]) + (v2[15 + dvp] * d16[i][9])\r
1346                 + (v2[14 + dvp] * d16[i][10]) + (v2[13 + dvp] * d16[i][11])\r
1347                 + (v2[12 + dvp] * d16[i][12]) + (v2[11 + dvp] * d16[i][13])\r
1348                 + (v2[10 + dvp] * d16[i][14]) + (v2[9 + dvp] * d16[i][15])) * scalefactor);\r
1349 \r
1350         _tmpOut[i] = pcm_sample;\r
1351 \r
1352         dvp += 16;\r
1353       } // for\r
1354     }\r
1355 \r
1356   }\r
1357 \r
1358   private void compute_pcm_samples9() {\r
1359 \r
1360     if (vidx == 1) {\r
1361       // final float[] vp = actual_v;\r
1362 \r
1363       // int inc = v_inc;\r
1364       // final float[] tmpOut = _tmpOut;\r
1365       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1366 \r
1367       // fat chance of having this loop unroll\r
1368       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1369         // final float[] dp = d16[i];\r
1370         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1371 \r
1372         pcm_sample =\r
1373             (float) (((v1[9 + dvp] * d16[i][0]) + (v1[8 + dvp] * d16[i][1])\r
1374                 + (v1[7 + dvp] * d16[i][2]) + (v1[6 + dvp] * d16[i][3]) + (v1[5 + dvp] * d16[i][4])\r
1375                 + (v1[4 + dvp] * d16[i][5]) + (v1[3 + dvp] * d16[i][6]) + (v1[2 + dvp] * d16[i][7])\r
1376                 + (v1[1 + dvp] * d16[i][8]) + (v1[0 + dvp] * d16[i][9])\r
1377                 + (v1[15 + dvp] * d16[i][10]) + (v1[14 + dvp] * d16[i][11])\r
1378                 + (v1[13 + dvp] * d16[i][12]) + (v1[12 + dvp] * d16[i][13])\r
1379                 + (v1[11 + dvp] * d16[i][14]) + (v1[10 + dvp] * d16[i][15])) * scalefactor);\r
1380 \r
1381         _tmpOut[i] = pcm_sample;\r
1382 \r
1383         dvp += 16;\r
1384       } // for\r
1385     } else {\r
1386       // final float[] vp = actual_v;\r
1387 \r
1388       // int inc = v_inc;\r
1389       // final float[] tmpOut = _tmpOut;\r
1390       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1391 \r
1392       // fat chance of having this loop unroll\r
1393       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1394         // final float[] dp = d16[i];\r
1395         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1396 \r
1397         pcm_sample =\r
1398             (float) (((v2[9 + dvp] * d16[i][0]) + (v2[8 + dvp] * d16[i][1])\r
1399                 + (v2[7 + dvp] * d16[i][2]) + (v2[6 + dvp] * d16[i][3]) + (v2[5 + dvp] * d16[i][4])\r
1400                 + (v2[4 + dvp] * d16[i][5]) + (v2[3 + dvp] * d16[i][6]) + (v2[2 + dvp] * d16[i][7])\r
1401                 + (v2[1 + dvp] * d16[i][8]) + (v2[0 + dvp] * d16[i][9])\r
1402                 + (v2[15 + dvp] * d16[i][10]) + (v2[14 + dvp] * d16[i][11])\r
1403                 + (v2[13 + dvp] * d16[i][12]) + (v2[12 + dvp] * d16[i][13])\r
1404                 + (v2[11 + dvp] * d16[i][14]) + (v2[10 + dvp] * d16[i][15])) * scalefactor);\r
1405 \r
1406         _tmpOut[i] = pcm_sample;\r
1407 \r
1408         dvp += 16;\r
1409       } // for\r
1410     }\r
1411 \r
1412   }\r
1413 \r
1414   private void compute_pcm_samples10() {\r
1415     if (vidx == 1) {\r
1416       // final float[] vp = actual_v;\r
1417       // int inc = v_inc;\r
1418       // final float[] tmpOut = _tmpOut;\r
1419       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1420 \r
1421       // fat chance of having this loop unroll\r
1422       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1423         // final float[] dp = d16[i];\r
1424         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1425 \r
1426         pcm_sample =\r
1427             (float) (((v1[10 + dvp] * d16[i][0]) + (v1[9 + dvp] * d16[i][1])\r
1428                 + (v1[8 + dvp] * d16[i][2]) + (v1[7 + dvp] * d16[i][3]) + (v1[6 + dvp] * d16[i][4])\r
1429                 + (v1[5 + dvp] * d16[i][5]) + (v1[4 + dvp] * d16[i][6]) + (v1[3 + dvp] * d16[i][7])\r
1430                 + (v1[2 + dvp] * d16[i][8]) + (v1[1 + dvp] * d16[i][9])\r
1431                 + (v1[0 + dvp] * d16[i][10]) + (v1[15 + dvp] * d16[i][11])\r
1432                 + (v1[14 + dvp] * d16[i][12]) + (v1[13 + dvp] * d16[i][13])\r
1433                 + (v1[12 + dvp] * d16[i][14]) + (v1[11 + dvp] * d16[i][15])) * scalefactor);\r
1434 \r
1435         _tmpOut[i] = pcm_sample;\r
1436 \r
1437         dvp += 16;\r
1438       } // for\r
1439     } else {\r
1440       // final float[] vp = actual_v;\r
1441       // int inc = v_inc;\r
1442       // final float[] tmpOut = _tmpOut;\r
1443       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1444 \r
1445       // fat chance of having this loop unroll\r
1446       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1447         // final float[] dp = d16[i];\r
1448         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1449 \r
1450         pcm_sample =\r
1451             (float) (((v2[10 + dvp] * d16[i][0]) + (v2[9 + dvp] * d16[i][1])\r
1452                 + (v2[8 + dvp] * d16[i][2]) + (v2[7 + dvp] * d16[i][3]) + (v2[6 + dvp] * d16[i][4])\r
1453                 + (v2[5 + dvp] * d16[i][5]) + (v2[4 + dvp] * d16[i][6]) + (v2[3 + dvp] * d16[i][7])\r
1454                 + (v2[2 + dvp] * d16[i][8]) + (v2[1 + dvp] * d16[i][9])\r
1455                 + (v2[0 + dvp] * d16[i][10]) + (v2[15 + dvp] * d16[i][11])\r
1456                 + (v2[14 + dvp] * d16[i][12]) + (v2[13 + dvp] * d16[i][13])\r
1457                 + (v2[12 + dvp] * d16[i][14]) + (v2[11 + dvp] * d16[i][15])) * scalefactor);\r
1458 \r
1459         _tmpOut[i] = pcm_sample;\r
1460 \r
1461         dvp += 16;\r
1462       } // for\r
1463     }\r
1464 \r
1465   }\r
1466 \r
1467   private void compute_pcm_samples11() {\r
1468 \r
1469     if (vidx == 1) {\r
1470       // final float[] vp = actual_v;\r
1471 \r
1472       // int inc = v_inc;\r
1473       // final float[] tmpOut = _tmpOut;\r
1474       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1475 \r
1476       // fat chance of having this loop unroll\r
1477       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1478         // final float[] dp = d16[i];\r
1479         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1480 \r
1481         pcm_sample =\r
1482             (float) (((v1[11 + dvp] * d16[i][0]) + (v1[10 + dvp] * d16[i][1])\r
1483                 + (v1[9 + dvp] * d16[i][2]) + (v1[8 + dvp] * d16[i][3]) + (v1[7 + dvp] * d16[i][4])\r
1484                 + (v1[6 + dvp] * d16[i][5]) + (v1[5 + dvp] * d16[i][6]) + (v1[4 + dvp] * d16[i][7])\r
1485                 + (v1[3 + dvp] * d16[i][8]) + (v1[2 + dvp] * d16[i][9])\r
1486                 + (v1[1 + dvp] * d16[i][10]) + (v1[0 + dvp] * d16[i][11])\r
1487                 + (v1[15 + dvp] * d16[i][12]) + (v1[14 + dvp] * d16[i][13])\r
1488                 + (v1[13 + dvp] * d16[i][14]) + (v1[12 + dvp] * d16[i][15])) * scalefactor);\r
1489 \r
1490         _tmpOut[i] = pcm_sample;\r
1491 \r
1492         dvp += 16;\r
1493       } // for\r
1494     } else {\r
1495       // final float[] vp = actual_v;\r
1496 \r
1497       // int inc = v_inc;\r
1498       // final float[] tmpOut = _tmpOut;\r
1499       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1500 \r
1501       // fat chance of having this loop unroll\r
1502       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1503         // final float[] dp = d16[i];\r
1504         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1505 \r
1506         pcm_sample =\r
1507             (float) (((v2[11 + dvp] * d16[i][0]) + (v2[10 + dvp] * d16[i][1])\r
1508                 + (v2[9 + dvp] * d16[i][2]) + (v2[8 + dvp] * d16[i][3]) + (v2[7 + dvp] * d16[i][4])\r
1509                 + (v2[6 + dvp] * d16[i][5]) + (v2[5 + dvp] * d16[i][6]) + (v2[4 + dvp] * d16[i][7])\r
1510                 + (v2[3 + dvp] * d16[i][8]) + (v2[2 + dvp] * d16[i][9])\r
1511                 + (v2[1 + dvp] * d16[i][10]) + (v2[0 + dvp] * d16[i][11])\r
1512                 + (v2[15 + dvp] * d16[i][12]) + (v2[14 + dvp] * d16[i][13])\r
1513                 + (v2[13 + dvp] * d16[i][14]) + (v2[12 + dvp] * d16[i][15])) * scalefactor);\r
1514 \r
1515         _tmpOut[i] = pcm_sample;\r
1516 \r
1517         dvp += 16;\r
1518       } // for\r
1519     }\r
1520 \r
1521   }\r
1522 \r
1523   private void compute_pcm_samples12() {\r
1524 \r
1525     if (vidx == 1) {\r
1526       // final float[] vp = actual_v;\r
1527       // int inc = v_inc;\r
1528       // final float[] tmpOut = _tmpOut;\r
1529       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1530 \r
1531       // fat chance of having this loop unroll\r
1532       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1533         // final float[] dp = d16[i];\r
1534         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1535 \r
1536         pcm_sample =\r
1537             (float) (((v1[12 + dvp] * d16[i][0]) + (v1[11 + dvp] * d16[i][1])\r
1538                 + (v1[10 + dvp] * d16[i][2]) + (v1[9 + dvp] * d16[i][3])\r
1539                 + (v1[8 + dvp] * d16[i][4]) + (v1[7 + dvp] * d16[i][5]) + (v1[6 + dvp] * d16[i][6])\r
1540                 + (v1[5 + dvp] * d16[i][7]) + (v1[4 + dvp] * d16[i][8]) + (v1[3 + dvp] * d16[i][9])\r
1541                 + (v1[2 + dvp] * d16[i][10]) + (v1[1 + dvp] * d16[i][11])\r
1542                 + (v1[0 + dvp] * d16[i][12]) + (v1[15 + dvp] * d16[i][13])\r
1543                 + (v1[14 + dvp] * d16[i][14]) + (v1[13 + dvp] * d16[i][15])) * scalefactor);\r
1544 \r
1545         _tmpOut[i] = pcm_sample;\r
1546 \r
1547         dvp += 16;\r
1548       } // for\r
1549     } else {\r
1550       // final float[] vp = actual_v;\r
1551       // int inc = v_inc;\r
1552       // final float[] tmpOut = _tmpOut;\r
1553       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1554 \r
1555       // fat chance of having this loop unroll\r
1556       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1557         // final float[] dp = d16[i];\r
1558         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1559 \r
1560         pcm_sample =\r
1561             (float) (((v2[12 + dvp] * d16[i][0]) + (v2[11 + dvp] * d16[i][1])\r
1562                 + (v2[10 + dvp] * d16[i][2]) + (v2[9 + dvp] * d16[i][3])\r
1563                 + (v2[8 + dvp] * d16[i][4]) + (v2[7 + dvp] * d16[i][5]) + (v2[6 + dvp] * d16[i][6])\r
1564                 + (v2[5 + dvp] * d16[i][7]) + (v2[4 + dvp] * d16[i][8]) + (v2[3 + dvp] * d16[i][9])\r
1565                 + (v2[2 + dvp] * d16[i][10]) + (v2[1 + dvp] * d16[i][11])\r
1566                 + (v2[0 + dvp] * d16[i][12]) + (v2[15 + dvp] * d16[i][13])\r
1567                 + (v2[14 + dvp] * d16[i][14]) + (v2[13 + dvp] * d16[i][15])) * scalefactor);\r
1568 \r
1569         _tmpOut[i] = pcm_sample;\r
1570 \r
1571         dvp += 16;\r
1572       } // for\r
1573     }\r
1574 \r
1575   }\r
1576 \r
1577   private void compute_pcm_samples13() {\r
1578 \r
1579     if (vidx == 1) {\r
1580       // final float[] vp = actual_v;\r
1581 \r
1582       // int inc = v_inc;\r
1583       // final float[] tmpOut = _tmpOut;\r
1584       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1585 \r
1586       // fat chance of having this loop unroll\r
1587       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1588         // final float[] dp = d16[i];\r
1589         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1590 \r
1591         pcm_sample =\r
1592             (float) (((v1[13 + dvp] * d16[i][0]) + (v1[12 + dvp] * d16[i][1])\r
1593                 + (v1[11 + dvp] * d16[i][2]) + (v1[10 + dvp] * d16[i][3])\r
1594                 + (v1[9 + dvp] * d16[i][4]) + (v1[8 + dvp] * d16[i][5]) + (v1[7 + dvp] * d16[i][6])\r
1595                 + (v1[6 + dvp] * d16[i][7]) + (v1[5 + dvp] * d16[i][8]) + (v1[4 + dvp] * d16[i][9])\r
1596                 + (v1[3 + dvp] * d16[i][10]) + (v1[2 + dvp] * d16[i][11])\r
1597                 + (v1[1 + dvp] * d16[i][12]) + (v1[0 + dvp] * d16[i][13])\r
1598                 + (v1[15 + dvp] * d16[i][14]) + (v1[14 + dvp] * d16[i][15])) * scalefactor);\r
1599 \r
1600         _tmpOut[i] = pcm_sample;\r
1601 \r
1602         dvp += 16;\r
1603       } // for\r
1604     } else {\r
1605       // final float[] vp = actual_v;\r
1606 \r
1607       // int inc = v_inc;\r
1608       // final float[] tmpOut = _tmpOut;\r
1609       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1610 \r
1611       // fat chance of having this loop unroll\r
1612       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1613         // final float[] dp = d16[i];\r
1614         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1615 \r
1616         pcm_sample =\r
1617             (float) (((v2[13 + dvp] * d16[i][0]) + (v2[12 + dvp] * d16[i][1])\r
1618                 + (v2[11 + dvp] * d16[i][2]) + (v2[10 + dvp] * d16[i][3])\r
1619                 + (v2[9 + dvp] * d16[i][4]) + (v2[8 + dvp] * d16[i][5]) + (v2[7 + dvp] * d16[i][6])\r
1620                 + (v2[6 + dvp] * d16[i][7]) + (v2[5 + dvp] * d16[i][8]) + (v2[4 + dvp] * d16[i][9])\r
1621                 + (v2[3 + dvp] * d16[i][10]) + (v2[2 + dvp] * d16[i][11])\r
1622                 + (v2[1 + dvp] * d16[i][12]) + (v2[0 + dvp] * d16[i][13])\r
1623                 + (v2[15 + dvp] * d16[i][14]) + (v2[14 + dvp] * d16[i][15])) * scalefactor);\r
1624 \r
1625         _tmpOut[i] = pcm_sample;\r
1626 \r
1627         dvp += 16;\r
1628       } // for\r
1629     }\r
1630 \r
1631   }\r
1632 \r
1633   private void compute_pcm_samples14() {\r
1634 \r
1635     if (vidx == 1) {\r
1636       // final float[] vp = actual_v;\r
1637 \r
1638       // int inc = v_inc;\r
1639       // final float[] tmpOut = _tmpOut;\r
1640       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1641 \r
1642       // fat chance of having this loop unroll\r
1643       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1644         // final float[] dp = d16[i];\r
1645         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1646 \r
1647         pcm_sample =\r
1648             (float) (((v1[14 + dvp] * d16[i][0]) + (v1[13 + dvp] * d16[i][1])\r
1649                 + (v1[12 + dvp] * d16[i][2]) + (v1[11 + dvp] * d16[i][3])\r
1650                 + (v1[10 + dvp] * d16[i][4]) + (v1[9 + dvp] * d16[i][5])\r
1651                 + (v1[8 + dvp] * d16[i][6]) + (v1[7 + dvp] * d16[i][7]) + (v1[6 + dvp] * d16[i][8])\r
1652                 + (v1[5 + dvp] * d16[i][9]) + (v1[4 + dvp] * d16[i][10])\r
1653                 + (v1[3 + dvp] * d16[i][11]) + (v1[2 + dvp] * d16[i][12])\r
1654                 + (v1[1 + dvp] * d16[i][13]) + (v1[0 + dvp] * d16[i][14]) + (v1[15 + dvp] * d16[i][15])) * scalefactor);\r
1655 \r
1656         _tmpOut[i] = pcm_sample;\r
1657 \r
1658         dvp += 16;\r
1659       } // for\r
1660     } else {\r
1661       // final float[] vp = actual_v;\r
1662 \r
1663       // int inc = v_inc;\r
1664       // final float[] tmpOut = _tmpOut;\r
1665       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1666 \r
1667       // fat chance of having this loop unroll\r
1668       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1669         // final float[] dp = d16[i];\r
1670         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1671 \r
1672         pcm_sample =\r
1673             (float) (((v2[14 + dvp] * d16[i][0]) + (v2[13 + dvp] * d16[i][1])\r
1674                 + (v2[12 + dvp] * d16[i][2]) + (v2[11 + dvp] * d16[i][3])\r
1675                 + (v2[10 + dvp] * d16[i][4]) + (v2[9 + dvp] * d16[i][5])\r
1676                 + (v2[8 + dvp] * d16[i][6]) + (v2[7 + dvp] * d16[i][7]) + (v2[6 + dvp] * d16[i][8])\r
1677                 + (v2[5 + dvp] * d16[i][9]) + (v2[4 + dvp] * d16[i][10])\r
1678                 + (v2[3 + dvp] * d16[i][11]) + (v2[2 + dvp] * d16[i][12])\r
1679                 + (v2[1 + dvp] * d16[i][13]) + (v2[0 + dvp] * d16[i][14]) + (v2[15 + dvp] * d16[i][15])) * scalefactor);\r
1680 \r
1681         _tmpOut[i] = pcm_sample;\r
1682 \r
1683         dvp += 16;\r
1684       } // for\r
1685     }\r
1686 \r
1687   }\r
1688 \r
1689   private void compute_pcm_samples15() {\r
1690     if (vidx == 1) {\r
1691       // final float[] vp = actual_v;\r
1692 \r
1693       // int inc = v_inc;\r
1694       // final float[] tmpOut = _tmpOut;\r
1695       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1696 \r
1697       // fat chance of having this loop unroll\r
1698       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1699         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1700         // final float d16[i][] = d16[i];\r
1701         pcm_sample =\r
1702             (float) (((v1[15 + dvp] * d16[i][0]) + (v1[14 + dvp] * d16[i][1])\r
1703                 + (v1[13 + dvp] * d16[i][2]) + (v1[12 + dvp] * d16[i][3])\r
1704                 + (v1[11 + dvp] * d16[i][4]) + (v1[10 + dvp] * d16[i][5])\r
1705                 + (v1[9 + dvp] * d16[i][6]) + (v1[8 + dvp] * d16[i][7]) + (v1[7 + dvp] * d16[i][8])\r
1706                 + (v1[6 + dvp] * d16[i][9]) + (v1[5 + dvp] * d16[i][10])\r
1707                 + (v1[4 + dvp] * d16[i][11]) + (v1[3 + dvp] * d16[i][12])\r
1708                 + (v1[2 + dvp] * d16[i][13]) + (v1[1 + dvp] * d16[i][14]) + (v1[0 + dvp] * d16[i][15])) * scalefactor);\r
1709 \r
1710         _tmpOut[i] = pcm_sample;\r
1711         dvp += 16;\r
1712       } // for\r
1713     } else {\r
1714       // final float[] vp = actual_v;\r
1715 \r
1716       // int inc = v_inc;\r
1717       // final float[] tmpOut = _tmpOut;\r
1718       @LOC("THIS,SynthesisFilter.NEWV") int dvp = 0;\r
1719 \r
1720       // fat chance of having this loop unroll\r
1721       for (@LOC("THIS,SynthesisFilter.NEWV") int i = 0; i < 32; i++) {\r
1722         @LOC("THIS,SynthesisFilter.V1") float pcm_sample;\r
1723         // final float d16[i][] = d16[i];\r
1724         pcm_sample =\r
1725             (float) (((v2[15 + dvp] * d16[i][0]) + (v2[14 + dvp] * d16[i][1])\r
1726                 + (v2[13 + dvp] * d16[i][2]) + (v2[12 + dvp] * d16[i][3])\r
1727                 + (v2[11 + dvp] * d16[i][4]) + (v2[10 + dvp] * d16[i][5])\r
1728                 + (v2[9 + dvp] * d16[i][6]) + (v2[8 + dvp] * d16[i][7]) + (v2[7 + dvp] * d16[i][8])\r
1729                 + (v2[6 + dvp] * d16[i][9]) + (v2[5 + dvp] * d16[i][10])\r
1730                 + (v2[4 + dvp] * d16[i][11]) + (v2[3 + dvp] * d16[i][12])\r
1731                 + (v2[2 + dvp] * d16[i][13]) + (v2[1 + dvp] * d16[i][14]) + (v2[0 + dvp] * d16[i][15])) * scalefactor);\r
1732 \r
1733         _tmpOut[i] = pcm_sample;\r
1734         dvp += 16;\r
1735       } // for\r
1736     }\r
1737 \r
1738   }\r
1739 \r
1740   private void compute_pcm_samples() {\r
1741 \r
1742     switch (actual_write_pos) {\r
1743     case 0:\r
1744       compute_pcm_samples0();\r
1745       break;\r
1746     case 1:\r
1747       compute_pcm_samples1();\r
1748       break;\r
1749     case 2:\r
1750       compute_pcm_samples2();\r
1751       break;\r
1752     case 3:\r
1753       compute_pcm_samples3();\r
1754       break;\r
1755     case 4:\r
1756       compute_pcm_samples4();\r
1757       break;\r
1758     case 5:\r
1759       compute_pcm_samples5();\r
1760       break;\r
1761     case 6:\r
1762       compute_pcm_samples6();\r
1763       break;\r
1764     case 7:\r
1765       compute_pcm_samples7();\r
1766       break;\r
1767     case 8:\r
1768       compute_pcm_samples8();\r
1769       break;\r
1770     case 9:\r
1771       compute_pcm_samples9();\r
1772       break;\r
1773     case 10:\r
1774       compute_pcm_samples10();\r
1775       break;\r
1776     case 11:\r
1777       compute_pcm_samples11();\r
1778       break;\r
1779     case 12:\r
1780       compute_pcm_samples12();\r
1781       break;\r
1782     case 13:\r
1783       compute_pcm_samples13();\r
1784       break;\r
1785     case 14:\r
1786       compute_pcm_samples14();\r
1787       break;\r
1788     case 15:\r
1789       compute_pcm_samples15();\r
1790       break;\r
1791     }\r
1792 \r
1793     // if (buffer != null) {\r
1794     // buffer.appendSamples(channel, _tmpOut);\r
1795     // }\r
1796     SampleBufferWrapper.appendSamples(channel, _tmpOut);\r
1797 \r
1798     /*\r
1799      * // MDM: I was considering putting in quality control for // low-spec\r
1800      * CPUs, but the performance gain (about 10-15%) // did not justify the\r
1801      * considerable drop in audio quality. switch (inc) { case 16:\r
1802      * buffer.appendSamples(channel, tmpOut); break; case 32: for (int i=0;\r
1803      * i<16; i++) { buffer.append(channel, (short)tmpOut[i]);\r
1804      * buffer.append(channel, (short)tmpOut[i]); } break; case 64: for (int i=0;\r
1805      * i<8; i++) { buffer.append(channel, (short)tmpOut[i]);\r
1806      * buffer.append(channel, (short)tmpOut[i]); buffer.append(channel,\r
1807      * (short)tmpOut[i]); buffer.append(channel, (short)tmpOut[i]); } break;\r
1808      * \r
1809      * }\r
1810      */\r
1811   }\r
1812 \r
1813   /**\r
1814    * Calculate 32 PCM samples and put the into the Obuffer-object.\r
1815    */\r
1816 \r
1817   public void calculate_pcm_samples() {\r
1818 \r
1819     if (vidx == 1) {\r
1820       compute_new_v1_v2();\r
1821     } else {\r
1822       compute_new_v2_v1();\r
1823     }\r
1824 \r
1825     // System.out.println("1.actual_v=" + (actual_v == v1) + " vidx=" + vidx);\r
1826     // compute_new_v();\r
1827     // System.out.println("2.actual_v=" + (actual_v == v1) + " vidx=" + vidx);\r
1828     compute_pcm_samples();\r
1829     // System.out.println("3.actual_v=" + (actual_v == v1) + " vidx=" + vidx);\r
1830 \r
1831     actual_write_pos = (actual_write_pos + 1) & 0xf;\r
1832     // actual_v = (actual_v == v1) ? v2 : v1;\r
1833 \r
1834     if (vidx == 1) {\r
1835       vidx = 2;\r
1836     } else {\r
1837       vidx = 1;\r
1838     }\r
1839 \r
1840     // initialize samples[]:\r
1841     // for (register float *floatp = samples + 32; floatp > samples; )\r
1842     // *--floatp = 0.0f;\r
1843 \r
1844     // MDM: this may not be necessary. The Layer III decoder always\r
1845     // outputs 32 subband samples, but I haven't checked layer I & II.\r
1846     for (@LOC("C") int p = 0; p < 32; p++)\r
1847       samples[p] = 0.0f;\r
1848   }\r
1849 \r
1850   private static final double MY_PI = 3.14159265358979323846;\r
1851   private static final float cos1_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 64.0)));\r
1852   private static final float cos3_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 64.0)));\r
1853   private static final float cos5_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 64.0)));\r
1854   private static final float cos7_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 64.0)));\r
1855   private static final float cos9_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 64.0)));\r
1856   private static final float cos11_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 64.0)));\r
1857   private static final float cos13_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 64.0)));\r
1858   private static final float cos15_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 64.0)));\r
1859   private static final float cos17_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 17.0 / 64.0)));\r
1860   private static final float cos19_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 19.0 / 64.0)));\r
1861   private static final float cos21_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 21.0 / 64.0)));\r
1862   private static final float cos23_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 23.0 / 64.0)));\r
1863   private static final float cos25_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 25.0 / 64.0)));\r
1864   private static final float cos27_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 27.0 / 64.0)));\r
1865   private static final float cos29_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 29.0 / 64.0)));\r
1866   private static final float cos31_64 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 31.0 / 64.0)));\r
1867   private static final float cos1_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 32.0)));\r
1868   private static final float cos3_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 32.0)));\r
1869   private static final float cos5_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 32.0)));\r
1870   private static final float cos7_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 32.0)));\r
1871   private static final float cos9_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0 / 32.0)));\r
1872   private static final float cos11_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 32.0)));\r
1873   private static final float cos13_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 32.0)));\r
1874   private static final float cos15_32 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 32.0)));\r
1875   private static final float cos1_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 16.0)));\r
1876   private static final float cos3_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 16.0)));\r
1877   private static final float cos5_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0 / 16.0)));\r
1878   private static final float cos7_16 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0 / 16.0)));\r
1879   private static final float cos1_8 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 8.0)));\r
1880   private static final float cos3_8 = (float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0 / 8.0)));\r
1881   private static final float cos1_4 = (float) (1.0 / (2.0 * Math.cos(MY_PI / 4.0)));\r
1882 \r
1883   // Note: These values are not in the same order\r
1884   // as in Annex 3-B.3 of the ISO/IEC DIS 11172-3\r
1885   // private float d[] = {0.000000000, -4.000442505};\r
1886 \r
1887   /**\r
1888    * d[] split into subarrays of length 16. This provides for more faster access\r
1889    * by allowing a block of 16 to be addressed with constant offset.\r
1890    **/\r
1891   @LOC("V")\r
1892   private static float d16[][] = null;\r
1893 \r
1894   /**\r
1895    * Converts a 1D array into a number of smaller arrays. This is used to\r
1896    * achieve offset + constant indexing into an array. Each sub-array represents\r
1897    * a block of values of the original array.\r
1898    * \r
1899    * @param array\r
1900    *          The array to split up into blocks.\r
1901    * @param blockSize\r
1902    *          The size of the blocks to split the array into. This must be an\r
1903    *          exact divisor of the length of the array, or some data will be\r
1904    *          lost from the main array.\r
1905    * \r
1906    * @return An array of arrays in which each element in the returned array will\r
1907    *         be of length <code>blockSize</code>.\r
1908    */\r
1909   static private float[][] splitArray(final float[] array, final int blockSize) {\r
1910     int size = array.length / blockSize;\r
1911     float[][] split = new float[size][];\r
1912     for (int i = 0; i < size; i++) {\r
1913       split[i] = subArray(array, i * blockSize, blockSize);\r
1914     }\r
1915     return split;\r
1916   }\r
1917 \r
1918   /**\r
1919    * Returns a subarray of an existing array.\r
1920    * \r
1921    * @param array\r
1922    *          The array to retrieve a subarra from.\r
1923    * @param offs\r
1924    *          The offset in the array that corresponds to the first index of the\r
1925    *          subarray.\r
1926    * @param len\r
1927    *          The number of indeces in the subarray.\r
1928    * @return The subarray, which may be of length 0.\r
1929    */\r
1930   static private float[] subArray(final float[] array, final int offs, int len) {\r
1931     if (offs + len > array.length) {\r
1932       len = array.length - offs;\r
1933     }\r
1934 \r
1935     if (len < 0)\r
1936       len = 0;\r
1937 \r
1938     float[] subarray = new float[len];\r
1939     for (int i = 0; i < len; i++) {\r
1940       subarray[i] = array[offs + i];\r
1941     }\r
1942 \r
1943     return subarray;\r
1944   }\r
1945 \r
1946   // The original data for d[]. This data is loaded from a file\r
1947   // to reduce the overall package size and to improve performance.\r
1948 \r
1949   static final float d[] = { 0.000000000f, -0.000442505f, 0.003250122f, -0.007003784f,\r
1950       0.031082153f, -0.078628540f, 0.100311279f, -0.572036743f, 1.144989014f, 0.572036743f,\r
1951       0.100311279f, 0.078628540f, 0.031082153f, 0.007003784f, 0.003250122f, 0.000442505f,\r
1952       -0.000015259f, -0.000473022f, 0.003326416f, -0.007919312f, 0.030517578f, -0.084182739f,\r
1953       0.090927124f, -0.600219727f, 1.144287109f, 0.543823242f, 0.108856201f, 0.073059082f,\r
1954       0.031478882f, 0.006118774f, 0.003173828f, 0.000396729f, -0.000015259f, -0.000534058f,\r
1955       0.003387451f, -0.008865356f, 0.029785156f, -0.089706421f, 0.080688477f, -0.628295898f,\r
1956       1.142211914f, 0.515609741f, 0.116577148f, 0.067520142f, 0.031738281f, 0.005294800f,\r
1957       0.003082275f, 0.000366211f, -0.000015259f, -0.000579834f, 0.003433228f, -0.009841919f,\r
1958       0.028884888f, -0.095169067f, 0.069595337f, -0.656219482f, 1.138763428f, 0.487472534f,\r
1959       0.123474121f, 0.061996460f, 0.031845093f, 0.004486084f, 0.002990723f, 0.000320435f,\r
1960       -0.000015259f, -0.000625610f, 0.003463745f, -0.010848999f, 0.027801514f, -0.100540161f,\r
1961       0.057617188f, -0.683914185f, 1.133926392f, 0.459472656f, 0.129577637f, 0.056533813f,\r
1962       0.031814575f, 0.003723145f, 0.002899170f, 0.000289917f, -0.000015259f, -0.000686646f,\r
1963       0.003479004f, -0.011886597f, 0.026535034f, -0.105819702f, 0.044784546f, -0.711318970f,\r
1964       1.127746582f, 0.431655884f, 0.134887695f, 0.051132202f, 0.031661987f, 0.003005981f,\r
1965       0.002792358f, 0.000259399f, -0.000015259f, -0.000747681f, 0.003479004f, -0.012939453f,\r
1966       0.025085449f, -0.110946655f, 0.031082153f, -0.738372803f, 1.120223999f, 0.404083252f,\r
1967       0.139450073f, 0.045837402f, 0.031387329f, 0.002334595f, 0.002685547f, 0.000244141f,\r
1968       -0.000030518f, -0.000808716f, 0.003463745f, -0.014022827f, 0.023422241f, -0.115921021f,\r
1969       0.016510010f, -0.765029907f, 1.111373901f, 0.376800537f, 0.143264771f, 0.040634155f,\r
1970       0.031005859f, 0.001693726f, 0.002578735f, 0.000213623f, -0.000030518f, -0.000885010f,\r
1971       0.003417969f, -0.015121460f, 0.021575928f, -0.120697021f, 0.001068115f, -0.791213989f,\r
1972       1.101211548f, 0.349868774f, 0.146362305f, 0.035552979f, 0.030532837f, 0.001098633f,\r
1973       0.002456665f, 0.000198364f, -0.000030518f, -0.000961304f, 0.003372192f, -0.016235352f,\r
1974       0.019531250f, -0.125259399f, -0.015228271f, -0.816864014f, 1.089782715f, 0.323318481f,\r
1975       0.148773193f, 0.030609131f, 0.029937744f, 0.000549316f, 0.002349854f, 0.000167847f,\r
1976       -0.000030518f, -0.001037598f, 0.003280640f, -0.017349243f, 0.017257690f, -0.129562378f,\r
1977       -0.032379150f, -0.841949463f, 1.077117920f, 0.297210693f, 0.150497437f, 0.025817871f,\r
1978       0.029281616f, 0.000030518f, 0.002243042f, 0.000152588f, -0.000045776f, -0.001113892f,\r
1979       0.003173828f, -0.018463135f, 0.014801025f, -0.133590698f, -0.050354004f, -0.866363525f,\r
1980       1.063217163f, 0.271591187f, 0.151596069f, 0.021179199f, 0.028533936f, -0.000442505f,\r
1981       0.002120972f, 0.000137329f, -0.000045776f, -0.001205444f, 0.003051758f, -0.019577026f,\r
1982       0.012115479f, -0.137298584f, -0.069168091f, -0.890090942f, 1.048156738f, 0.246505737f,\r
1983       0.152069092f, 0.016708374f, 0.027725220f, -0.000869751f, 0.002014160f, 0.000122070f,\r
1984       -0.000061035f, -0.001296997f, 0.002883911f, -0.020690918f, 0.009231567f, -0.140670776f,\r
1985       -0.088775635f, -0.913055420f, 1.031936646f, 0.221984863f, 0.151962280f, 0.012420654f,\r
1986       0.026840210f, -0.001266479f, 0.001907349f, 0.000106812f, -0.000061035f, -0.001388550f,\r
1987       0.002700806f, -0.021789551f, 0.006134033f, -0.143676758f, -0.109161377f, -0.935195923f,\r
1988       1.014617920f, 0.198059082f, 0.151306152f, 0.008316040f, 0.025909424f, -0.001617432f,\r
1989       0.001785278f, 0.000106812f, -0.000076294f, -0.001480103f, 0.002487183f, -0.022857666f,\r
1990       0.002822876f, -0.146255493f, -0.130310059f, -0.956481934f, 0.996246338f, 0.174789429f,\r
1991       0.150115967f, 0.004394531f, 0.024932861f, -0.001937866f, 0.001693726f, 0.000091553f,\r
1992       -0.000076294f, -0.001586914f, 0.002227783f, -0.023910522f, -0.000686646f, -0.148422241f,\r
1993       -0.152206421f, -0.976852417f, 0.976852417f, 0.152206421f, 0.148422241f, 0.000686646f,\r
1994       0.023910522f, -0.002227783f, 0.001586914f, 0.000076294f, -0.000091553f, -0.001693726f,\r
1995       0.001937866f, -0.024932861f, -0.004394531f, -0.150115967f, -0.174789429f, -0.996246338f,\r
1996       0.956481934f, 0.130310059f, 0.146255493f, -0.002822876f, 0.022857666f, -0.002487183f,\r
1997       0.001480103f, 0.000076294f, -0.000106812f, -0.001785278f, 0.001617432f, -0.025909424f,\r
1998       -0.008316040f, -0.151306152f, -0.198059082f, -1.014617920f, 0.935195923f, 0.109161377f,\r
1999       0.143676758f, -0.006134033f, 0.021789551f, -0.002700806f, 0.001388550f, 0.000061035f,\r
2000       -0.000106812f, -0.001907349f, 0.001266479f, -0.026840210f, -0.012420654f, -0.151962280f,\r
2001       -0.221984863f, -1.031936646f, 0.913055420f, 0.088775635f, 0.140670776f, -0.009231567f,\r
2002       0.020690918f, -0.002883911f, 0.001296997f, 0.000061035f, -0.000122070f, -0.002014160f,\r
2003       0.000869751f, -0.027725220f, -0.016708374f, -0.152069092f, -0.246505737f, -1.048156738f,\r
2004       0.890090942f, 0.069168091f, 0.137298584f, -0.012115479f, 0.019577026f, -0.003051758f,\r
2005       0.001205444f, 0.000045776f, -0.000137329f, -0.002120972f, 0.000442505f, -0.028533936f,\r
2006       -0.021179199f, -0.151596069f, -0.271591187f, -1.063217163f, 0.866363525f, 0.050354004f,\r
2007       0.133590698f, -0.014801025f, 0.018463135f, -0.003173828f, 0.001113892f, 0.000045776f,\r
2008       -0.000152588f, -0.002243042f, -0.000030518f, -0.029281616f, -0.025817871f, -0.150497437f,\r
2009       -0.297210693f, -1.077117920f, 0.841949463f, 0.032379150f, 0.129562378f, -0.017257690f,\r
2010       0.017349243f, -0.003280640f, 0.001037598f, 0.000030518f, -0.000167847f, -0.002349854f,\r
2011       -0.000549316f, -0.029937744f, -0.030609131f, -0.148773193f, -0.323318481f, -1.089782715f,\r
2012       0.816864014f, 0.015228271f, 0.125259399f, -0.019531250f, 0.016235352f, -0.003372192f,\r
2013       0.000961304f, 0.000030518f, -0.000198364f, -0.002456665f, -0.001098633f, -0.030532837f,\r
2014       -0.035552979f, -0.146362305f, -0.349868774f, -1.101211548f, 0.791213989f, -0.001068115f,\r
2015       0.120697021f, -0.021575928f, 0.015121460f, -0.003417969f, 0.000885010f, 0.000030518f,\r
2016       -0.000213623f, -0.002578735f, -0.001693726f, -0.031005859f, -0.040634155f, -0.143264771f,\r
2017       -0.376800537f, -1.111373901f, 0.765029907f, -0.016510010f, 0.115921021f, -0.023422241f,\r
2018       0.014022827f, -0.003463745f, 0.000808716f, 0.000030518f, -0.000244141f, -0.002685547f,\r
2019       -0.002334595f, -0.031387329f, -0.045837402f, -0.139450073f, -0.404083252f, -1.120223999f,\r
2020       0.738372803f, -0.031082153f, 0.110946655f, -0.025085449f, 0.012939453f, -0.003479004f,\r
2021       0.000747681f, 0.000015259f, -0.000259399f, -0.002792358f, -0.003005981f, -0.031661987f,\r
2022       -0.051132202f, -0.134887695f, -0.431655884f, -1.127746582f, 0.711318970f, -0.044784546f,\r
2023       0.105819702f, -0.026535034f, 0.011886597f, -0.003479004f, 0.000686646f, 0.000015259f,\r
2024       -0.000289917f, -0.002899170f, -0.003723145f, -0.031814575f, -0.056533813f, -0.129577637f,\r
2025       -0.459472656f, -1.133926392f, 0.683914185f, -0.057617188f, 0.100540161f, -0.027801514f,\r
2026       0.010848999f, -0.003463745f, 0.000625610f, 0.000015259f, -0.000320435f, -0.002990723f,\r
2027       -0.004486084f, -0.031845093f, -0.061996460f, -0.123474121f, -0.487472534f, -1.138763428f,\r
2028       0.656219482f, -0.069595337f, 0.095169067f, -0.028884888f, 0.009841919f, -0.003433228f,\r
2029       0.000579834f, 0.000015259f, -0.000366211f, -0.003082275f, -0.005294800f, -0.031738281f,\r
2030       -0.067520142f, -0.116577148f, -0.515609741f, -1.142211914f, 0.628295898f, -0.080688477f,\r
2031       0.089706421f, -0.029785156f, 0.008865356f, -0.003387451f, 0.000534058f, 0.000015259f,\r
2032       -0.000396729f, -0.003173828f, -0.006118774f, -0.031478882f, -0.073059082f, -0.108856201f,\r
2033       -0.543823242f, -1.144287109f, 0.600219727f, -0.090927124f, 0.084182739f, -0.030517578f,\r
2034       0.007919312f, -0.003326416f, 0.000473022f, 0.000015259f };\r
2035 \r
2036 }\r