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