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

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