Robust/src/Benchmarks/SSJava/MP3Decoder/SynthesisFilter.java

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