home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / maplay-1.2 / synthesis_filter.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-04  |  39.0 KB  |  1,179 lines
  1. /*
  2.  *  @(#) synthesis_filter.cc 1.14, last edit: 6/21/94 11:22:20
  3.  *  @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
  4.  *  @(#) Berlin University of Technology
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21. /*
  22.  *  Changes from version 1.1 to 1.2:
  23.  *    - compute_new_v() uses a 32 point fast cosine transform as described by
  24.  *      Byeong Gi Lee in IEEE Transactions ASSP-32 Part 2, August 1984,
  25.  *      "A New Algorithm to Compute the Discrete Cosine Transform"
  26.  *      instead of the matrix-vector multiplication in V1.1
  27.  *    - loop unrolling done in compute_pcm_samples()
  28.  *    - if ULAW is defined, the synthesis filter does a downsampling
  29.  *      to 8 kHz by dropping samples and ignoring subbands above 4 kHz
  30.  */
  31.  
  32. #include <stdlib.h>
  33. #include <unistd.h>
  34. #include <math.h>
  35. #include "all.h"
  36. #include "synthesis_filter.h"
  37.  
  38.  
  39. static const real MY_PI = 3.14159265358979323846;
  40.  
  41. static const real cos1_64  = 1.0 / (2.0 * cos(MY_PI        / 64.0));
  42. static const real cos3_64  = 1.0 / (2.0 * cos(MY_PI * 3.0  / 64.0));
  43. static const real cos5_64  = 1.0 / (2.0 * cos(MY_PI * 5.0  / 64.0));
  44. static const real cos7_64  = 1.0 / (2.0 * cos(MY_PI * 7.0  / 64.0));
  45. static const real cos9_64  = 1.0 / (2.0 * cos(MY_PI * 9.0  / 64.0));
  46. static const real cos11_64 = 1.0 / (2.0 * cos(MY_PI * 11.0 / 64.0));
  47. static const real cos13_64 = 1.0 / (2.0 * cos(MY_PI * 13.0 / 64.0));
  48. static const real cos15_64 = 1.0 / (2.0 * cos(MY_PI * 15.0 / 64.0));
  49. static const real cos17_64 = 1.0 / (2.0 * cos(MY_PI * 17.0 / 64.0));
  50. static const real cos19_64 = 1.0 / (2.0 * cos(MY_PI * 19.0 / 64.0));
  51. static const real cos21_64 = 1.0 / (2.0 * cos(MY_PI * 21.0 / 64.0));
  52. static const real cos23_64 = 1.0 / (2.0 * cos(MY_PI * 23.0 / 64.0));
  53. static const real cos25_64 = 1.0 / (2.0 * cos(MY_PI * 25.0 / 64.0));
  54. static const real cos27_64 = 1.0 / (2.0 * cos(MY_PI * 27.0 / 64.0));
  55. static const real cos29_64 = 1.0 / (2.0 * cos(MY_PI * 29.0 / 64.0));
  56. static const real cos31_64 = 1.0 / (2.0 * cos(MY_PI * 31.0 / 64.0));
  57. static const real cos1_32  = 1.0 / (2.0 * cos(MY_PI        / 32.0));
  58. static const real cos3_32  = 1.0 / (2.0 * cos(MY_PI * 3.0  / 32.0));
  59. static const real cos5_32  = 1.0 / (2.0 * cos(MY_PI * 5.0  / 32.0));
  60. static const real cos7_32  = 1.0 / (2.0 * cos(MY_PI * 7.0  / 32.0));
  61. static const real cos9_32  = 1.0 / (2.0 * cos(MY_PI * 9.0  / 32.0));
  62. static const real cos11_32 = 1.0 / (2.0 * cos(MY_PI * 11.0 / 32.0));
  63. static const real cos13_32 = 1.0 / (2.0 * cos(MY_PI * 13.0 / 32.0));
  64. static const real cos15_32 = 1.0 / (2.0 * cos(MY_PI * 15.0 / 32.0));
  65. static const real cos1_16  = 1.0 / (2.0 * cos(MY_PI        / 16.0));
  66. static const real cos3_16  = 1.0 / (2.0 * cos(MY_PI * 3.0  / 16.0));
  67. static const real cos5_16  = 1.0 / (2.0 * cos(MY_PI * 5.0  / 16.0));
  68. static const real cos7_16  = 1.0 / (2.0 * cos(MY_PI * 7.0  / 16.0));
  69. static const real cos1_8   = 1.0 / (2.0 * cos(MY_PI        / 8.0));
  70. static const real cos3_8   = 1.0 / (2.0 * cos(MY_PI * 3.0  / 8.0));
  71. static const real cos1_4   = 1.0 / (2.0 * cos(MY_PI / 4.0));
  72.  
  73.  
  74. const real SynthesisFilter::d[512] = {
  75.   // Note: These values are not in the same order
  76.   // as in Annex 3-B.3 of the ISO/IEC DIS 11172-3
  77.    0.000000000, -0.000442505,  0.003250122, -0.007003784,
  78.    0.031082153, -0.078628540,  0.100311279, -0.572036743,
  79.    1.144989014,  0.572036743,  0.100311279,  0.078628540,
  80.    0.031082153,  0.007003784,  0.003250122,  0.000442505,
  81.   -0.000015259, -0.000473022,  0.003326416, -0.007919312,
  82.    0.030517578, -0.084182739,  0.090927124, -0.600219727,
  83.    1.144287109,  0.543823242,  0.108856201,  0.073059082,
  84.    0.031478882,  0.006118774,  0.003173828,  0.000396729,
  85.   -0.000015259, -0.000534058,  0.003387451, -0.008865356,
  86.    0.029785156, -0.089706421,  0.080688477, -0.628295898,
  87.    1.142211914,  0.515609741,  0.116577148,  0.067520142,
  88.    0.031738281,  0.005294800,  0.003082275,  0.000366211,
  89.   -0.000015259, -0.000579834,  0.003433228, -0.009841919,
  90.    0.028884888, -0.095169067,  0.069595337, -0.656219482,
  91.    1.138763428,  0.487472534,  0.123474121,  0.061996460,
  92.    0.031845093,  0.004486084,  0.002990723,  0.000320435,
  93.   -0.000015259, -0.000625610,  0.003463745, -0.010848999,
  94.    0.027801514, -0.100540161,  0.057617188, -0.683914185,
  95.    1.133926392,  0.459472656,  0.129577637,  0.056533813,
  96.    0.031814575,  0.003723145,  0.002899170,  0.000289917,
  97.   -0.000015259, -0.000686646,  0.003479004, -0.011886597,
  98.    0.026535034, -0.105819702,  0.044784546, -0.711318970,
  99.    1.127746582,  0.431655884,  0.134887695,  0.051132202,
  100.    0.031661987,  0.003005981,  0.002792358,  0.000259399,
  101.   -0.000015259, -0.000747681,  0.003479004, -0.012939453,
  102.    0.025085449, -0.110946655,  0.031082153, -0.738372803,
  103.    1.120223999,  0.404083252,  0.139450073,  0.045837402,
  104.    0.031387329,  0.002334595,  0.002685547,  0.000244141,
  105.   -0.000030518, -0.000808716,  0.003463745, -0.014022827,
  106.    0.023422241, -0.115921021,  0.016510010, -0.765029907,
  107.    1.111373901,  0.376800537,  0.143264771,  0.040634155,
  108.    0.031005859,  0.001693726,  0.002578735,  0.000213623,
  109.   -0.000030518, -0.000885010,  0.003417969, -0.015121460,
  110.    0.021575928, -0.120697021,  0.001068115, -0.791213989,
  111.    1.101211548,  0.349868774,  0.146362305,  0.035552979,
  112.    0.030532837,  0.001098633,  0.002456665,  0.000198364,
  113.   -0.000030518, -0.000961304,  0.003372192, -0.016235352,
  114.    0.019531250, -0.125259399, -0.015228271, -0.816864014,
  115.    1.089782715,  0.323318481,  0.148773193,  0.030609131,
  116.    0.029937744,  0.000549316,  0.002349854,  0.000167847,
  117.   -0.000030518, -0.001037598,  0.003280640, -0.017349243,
  118.    0.017257690, -0.129562378, -0.032379150, -0.841949463,
  119.    1.077117920,  0.297210693,  0.150497437,  0.025817871,
  120.    0.029281616,  0.000030518,  0.002243042,  0.000152588,
  121.   -0.000045776, -0.001113892,  0.003173828, -0.018463135,
  122.    0.014801025, -0.133590698, -0.050354004, -0.866363525,
  123.    1.063217163,  0.271591187,  0.151596069,  0.021179199,
  124.    0.028533936, -0.000442505,  0.002120972,  0.000137329,
  125.   -0.000045776, -0.001205444,  0.003051758, -0.019577026,
  126.    0.012115479, -0.137298584, -0.069168091, -0.890090942,
  127.    1.048156738,  0.246505737,  0.152069092,  0.016708374,
  128.    0.027725220, -0.000869751,  0.002014160,  0.000122070,
  129.   -0.000061035, -0.001296997,  0.002883911, -0.020690918,
  130.    0.009231567, -0.140670776, -0.088775635, -0.913055420,
  131.    1.031936646,  0.221984863,  0.151962280,  0.012420654,
  132.    0.026840210, -0.001266479,  0.001907349,  0.000106812,
  133.   -0.000061035, -0.001388550,  0.002700806, -0.021789551,
  134.    0.006134033, -0.143676758, -0.109161377, -0.935195923,
  135.    1.014617920,  0.198059082,  0.151306152,  0.008316040,
  136.    0.025909424, -0.001617432,  0.001785278,  0.000106812,
  137.   -0.000076294, -0.001480103,  0.002487183, -0.022857666,
  138.    0.002822876, -0.146255493, -0.130310059, -0.956481934,
  139.    0.996246338,  0.174789429,  0.150115967,  0.004394531,
  140.    0.024932861, -0.001937866,  0.001693726,  0.000091553,
  141.   -0.000076294, -0.001586914,  0.002227783, -0.023910522,
  142.   -0.000686646, -0.148422241, -0.152206421, -0.976852417,
  143.    0.976852417,  0.152206421,  0.148422241,  0.000686646,
  144.    0.023910522, -0.002227783,  0.001586914,  0.000076294,
  145.   -0.000091553, -0.001693726,  0.001937866, -0.024932861,
  146.   -0.004394531, -0.150115967, -0.174789429, -0.996246338,
  147.    0.956481934,  0.130310059,  0.146255493, -0.002822876,
  148.    0.022857666, -0.002487183,  0.001480103,  0.000076294,
  149.   -0.000106812, -0.001785278,  0.001617432, -0.025909424,
  150.   -0.008316040, -0.151306152, -0.198059082, -1.014617920,
  151.    0.935195923,  0.109161377,  0.143676758, -0.006134033,
  152.    0.021789551, -0.002700806,  0.001388550,  0.000061035,
  153.   -0.000106812, -0.001907349,  0.001266479, -0.026840210,
  154.   -0.012420654, -0.151962280, -0.221984863, -1.031936646,
  155.    0.913055420,  0.088775635,  0.140670776, -0.009231567,
  156.    0.020690918, -0.002883911,  0.001296997,  0.000061035,
  157.   -0.000122070, -0.002014160,  0.000869751, -0.027725220,
  158.   -0.016708374, -0.152069092, -0.246505737, -1.048156738,
  159.    0.890090942,  0.069168091,  0.137298584, -0.012115479,
  160.    0.019577026, -0.003051758,  0.001205444,  0.000045776,
  161.   -0.000137329, -0.002120972,  0.000442505, -0.028533936,
  162.   -0.021179199, -0.151596069, -0.271591187, -1.063217163,
  163.    0.866363525,  0.050354004,  0.133590698, -0.014801025,
  164.    0.018463135, -0.003173828,  0.001113892,  0.000045776,
  165.   -0.000152588, -0.002243042, -0.000030518, -0.029281616,
  166.   -0.025817871, -0.150497437, -0.297210693, -1.077117920,
  167.    0.841949463,  0.032379150,  0.129562378, -0.017257690,
  168.    0.017349243, -0.003280640,  0.001037598,  0.000030518,
  169.   -0.000167847, -0.002349854, -0.000549316, -0.029937744,
  170.   -0.030609131, -0.148773193, -0.323318481, -1.089782715,
  171.    0.816864014,  0.015228271,  0.125259399, -0.019531250,
  172.    0.016235352, -0.003372192,  0.000961304,  0.000030518,
  173.   -0.000198364, -0.002456665, -0.001098633, -0.030532837,
  174.   -0.035552979, -0.146362305, -0.349868774, -1.101211548,
  175.    0.791213989, -0.001068115,  0.120697021, -0.021575928,
  176.    0.015121460, -0.003417969,  0.000885010,  0.000030518,
  177.   -0.000213623, -0.002578735, -0.001693726, -0.031005859,
  178.   -0.040634155, -0.143264771, -0.376800537, -1.111373901,
  179.    0.765029907, -0.016510010,  0.115921021, -0.023422241,
  180.    0.014022827, -0.003463745,  0.000808716,  0.000030518,
  181.   -0.000244141, -0.002685547, -0.002334595, -0.031387329,
  182.   -0.045837402, -0.139450073, -0.404083252, -1.120223999,
  183.    0.738372803, -0.031082153,  0.110946655, -0.025085449,
  184.    0.012939453, -0.003479004,  0.000747681,  0.000015259,
  185.   -0.000259399, -0.002792358, -0.003005981, -0.031661987,
  186.   -0.051132202, -0.134887695, -0.431655884, -1.127746582,
  187.    0.711318970, -0.044784546,  0.105819702, -0.026535034,
  188.    0.011886597, -0.003479004,  0.000686646,  0.000015259,
  189.   -0.000289917, -0.002899170, -0.003723145, -0.031814575,
  190.   -0.056533813, -0.129577637, -0.459472656, -1.133926392,
  191.    0.683914185, -0.057617188,  0.100540161, -0.027801514,
  192.    0.010848999, -0.003463745,  0.000625610,  0.000015259,
  193.   -0.000320435, -0.002990723, -0.004486084, -0.031845093,
  194.   -0.061996460, -0.123474121, -0.487472534, -1.138763428,
  195.    0.656219482, -0.069595337,  0.095169067, -0.028884888,
  196.    0.009841919, -0.003433228,  0.000579834,  0.000015259,
  197.   -0.000366211, -0.003082275, -0.005294800, -0.031738281,
  198.   -0.067520142, -0.116577148, -0.515609741, -1.142211914,
  199.    0.628295898, -0.080688477,  0.089706421, -0.029785156,
  200.    0.008865356, -0.003387451,  0.000534058,  0.000015259,
  201.   -0.000396729, -0.003173828, -0.006118774, -0.031478882,
  202.   -0.073059082, -0.108856201, -0.543823242, -1.144287109,
  203.    0.600219727, -0.090927124,  0.084182739, -0.030517578,
  204.    0.007919312, -0.003326416,  0.000473022,  0.000015259
  205. };
  206.  
  207.  
  208.  
  209. #ifdef ULAW
  210. SynthesisFilter::SynthesisFilter (uint32 channelnumber, e_sample_frequency frequency, real factor)
  211. #else
  212. SynthesisFilter::SynthesisFilter (uint32 channelnumber, real factor)
  213. #endif
  214. {
  215.   register real *floatp, *floatp2;
  216.  
  217.   // initialize v1[] and v2[]:
  218.   for (floatp = v1 + 512, floatp2 = v2 + 512; floatp > v1; )
  219.     *--floatp = *--floatp2 = 0.0;
  220.  
  221.   // initialize samples[]:
  222.   for (floatp = samples + 32; floatp > samples; )
  223.     *--floatp = 0.0;
  224.  
  225.   channel = channelnumber;
  226.   range_violations = written_samples = 0;
  227.   actual_v = v1;
  228.   actual_write_pos = 15;
  229.   scalefactor = factor;
  230.  
  231. #ifdef ULAW
  232.  
  233.   /*
  234.      Downsampling from 32, 44.1 or 48 kHz to 8 kHz is done by dropping most of the samples.
  235.      The needed lowpass filtering is done by ignoring subbands above 4 kHz.
  236.  
  237.      offset1 and offset2 specify the number of samples to skip, e.g.
  238.      offset1 = 4 and offset2 = 5 means:
  239.      take only samples s[0], s[offset1+1], s[offset1+1+offset2+1], s[2*(offset1+1)+offset2+1],
  240.                s[2*(offset1+1)+2*(offset2+1)], s[3*(offset1+1)+2*(offset2+1)] and so on.
  241.      This choice of offset1 and offset2 does a conversion from 44.1 kHz to 8 kHz
  242.      (well, 8.01818.. kHz to be precise)
  243.   */
  244.  
  245.   switch (frequency)
  246.   {
  247.     case thirtytwo:
  248.       highest_subband = 7;        // use 8 of 32 subbands (500 Hz per subband)
  249.       offset1 = offset2 = 3;        // take every 4. sample, forget the rest
  250.       break;
  251.     case fourtyfour_point_one:
  252. //    highest_subband = 4;        // use 5 of 32 subbands (689 Hz per subband)
  253.       highest_subband = 5;        // use 6 of 32 subbands (some aliasing)
  254.       offset1 = 4;            // take 2 of 11 samples, forget the rest
  255.       offset2 = 5;
  256.       break;
  257.     case fourtyeight:
  258.       highest_subband = 4;        // use 5 of 32 subbands (750 Hz per subband)
  259. //    highest_subband = 5;        // use 6 of 32 subbands (some aliasing)
  260.       offset1 = offset2 = 5;        // take every 6. sample, forget the rest
  261.   }
  262.   remaining_offset = 0;
  263. #endif    // ULAW
  264. }
  265.  
  266.  
  267. void SynthesisFilter::compute_new_v (void)
  268. {
  269.   real new_v[32];        // new V[0-15] and V[33-48] of Figure 3-A.2 in ISO DIS 11172-3
  270.   register real *x1, *x2, tmp;
  271.   real p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15;
  272.   real pp0, pp1, pp2, pp3, pp4, pp5, pp6, pp7, pp8, pp9, pp10, pp11, pp12, pp13, pp14, pp15;
  273.  
  274.   // compute new values via a fast cosine transform:
  275.   x1 = samples;
  276.   x2 = samples + 31;
  277.   p0  = *x1++ + *x2;   p1  = *x1++ + *--x2; p2  = *x1++ + *--x2; p3  = *x1++ + *--x2;
  278.   p4  = *x1++ + *--x2; p5  = *x1++ + *--x2; p6  = *x1++ + *--x2; p7  = *x1++ + *--x2;
  279.   p8  = *x1++ + *--x2; p9  = *x1++ + *--x2; p10 = *x1++ + *--x2; p11 = *x1++ + *--x2;
  280.   p12 = *x1++ + *--x2; p13 = *x1++ + *--x2; p14 = *x1++ + *--x2; p15 = *x1   + *--x2;
  281.  
  282.   pp0  = p0 + p15; pp1 = p1 + p14; pp2 = p2 + p13; pp3 = p3 + p12;
  283.   pp4  = p4 + p11; pp5 = p5 + p10; pp6 = p6 + p9;  pp7 = p7 + p8;
  284.   pp8  = cos1_32  * (p0 - p15);
  285.   pp9  = cos3_32  * (p1 - p14);
  286.   pp10 = cos5_32  * (p2 - p13);
  287.   pp11 = cos7_32  * (p3 - p12);
  288.   pp12 = cos9_32  * (p4 - p11);
  289.   pp13 = cos11_32 * (p5 - p10);
  290.   pp14 = cos13_32 * (p6 - p9);
  291.   pp15 = cos15_32 * (p7 - p8);
  292.  
  293.   p0  = pp0 + pp7; p1 = pp1 + pp6; p2 = pp2 + pp5; p3 = pp3 + pp4;
  294.   p4  = cos1_16 * (pp0 - pp7);
  295.   p5  = cos3_16 * (pp1 - pp6);
  296.   p6  = cos5_16 * (pp2 - pp5);
  297.   p7  = cos7_16 * (pp3 - pp4);
  298.   p8  = pp8 + pp15; p9 = pp9 + pp14; p10 = pp10 + pp13; p11 = pp11 + pp12;
  299.   p12 = cos1_16 * (pp8  - pp15);
  300.   p13 = cos3_16 * (pp9  - pp14);
  301.   p14 = cos5_16 * (pp10 - pp13);
  302.   p15 = cos7_16 * (pp11 - pp12);
  303.  
  304.   pp0  = p0 + p3; pp1 = p1 + p2;
  305.   pp2  = cos1_8 * (p0 - p3);
  306.   pp3  = cos3_8 * (p1 - p2);
  307.   pp4  = p4 + p7; pp5 = p5 + p6;
  308.   pp6  = cos1_8 * (p4 - p7);
  309.   pp7  = cos3_8 * (p5 - p6);
  310.   pp8  = p8 + p11; pp9 = p9 + p10;
  311.   pp10 = cos1_8 * (p8 - p11);
  312.   pp11 = cos3_8 * (p9 - p10);
  313.   pp12 = p12 + p15; pp13 = p13 + p14;
  314.   pp14 = cos1_8 * (p12 - p15);
  315.   pp15 = cos3_8 * (p13 - p14);
  316.  
  317.   p0 = pp0 + pp1;
  318.   p1 = cos1_4 * (pp0 - pp1);
  319.   p2 = pp2 + pp3;
  320.   p3 = cos1_4 * (pp2 - pp3);
  321.   p4 = pp4 + pp5;
  322.   p5 = cos1_4 * (pp4 - pp5);
  323.   p6 = pp6 + pp7;
  324.   p7 = cos1_4 * (pp6 - pp7);
  325.   p8  = pp8 + pp9;
  326.   p9  = cos1_4 * (pp8 - pp9);
  327.   p10 = pp10 + pp11;
  328.   p11 = cos1_4 * (pp10 - pp11);
  329.   p12 = pp12 + pp13;
  330.   p13 = cos1_4 * (pp12 - pp13);
  331.   p14 = pp14 + pp15;
  332.   p15 = cos1_4 * (pp14 - pp15);
  333.  
  334.   tmp          = p6 + p7;
  335.   new_v[36-17] = -(p5 + tmp);
  336.   new_v[44-17] = -(p4 + tmp);
  337.   tmp          = p11 + p15;
  338.   new_v[10]    = tmp;
  339.   new_v[6]     = p13 + tmp;
  340.   tmp          = p14 + p15;
  341.   new_v[46-17] = -(p8  + p12 + tmp);
  342.   new_v[34-17] = -(p9  + p13 + tmp);
  343.   tmp         += p10 + p11;
  344.   new_v[38-17] = -(p13 + tmp);
  345.   new_v[42-17] = -(p12 + tmp);
  346.   new_v[2]     = p9 + p13 + p15;
  347.   new_v[4]     = p5 + p7;
  348.   new_v[48-17] = -p0;
  349.   new_v[0]     = p1;
  350.   new_v[8]     = p3;
  351.   new_v[12]    = p7;
  352.   new_v[14]    = p15;
  353.   new_v[40-17] = -(p2  + p3);
  354.  
  355.   x1 = samples;
  356.   x2 = samples + 31;
  357.   p0  = cos1_64  * (*x1++ - *x2);   p1  = cos3_64  * (*x1++ - *--x2);
  358.   p2  = cos5_64  * (*x1++ - *--x2); p3  = cos7_64  * (*x1++ - *--x2);
  359.   p4  = cos9_64  * (*x1++ - *--x2); p5  = cos11_64 * (*x1++ - *--x2);
  360.   p6  = cos13_64 * (*x1++ - *--x2); p7  = cos15_64 * (*x1++ - *--x2);
  361.   p8  = cos17_64 * (*x1++ - *--x2); p9  = cos19_64 * (*x1++ - *--x2);
  362.   p10 = cos21_64 * (*x1++ - *--x2); p11 = cos23_64 * (*x1++ - *--x2);
  363.   p12 = cos25_64 * (*x1++ - *--x2); p13 = cos27_64 * (*x1++ - *--x2);
  364.   p14 = cos29_64 * (*x1++ - *--x2); p15 = cos31_64 * (*x1   - *--x2);
  365.  
  366.   pp0  = p0 + p15; pp1 = p1 + p14; pp2 = p2 + p13; pp3 = p3 + p12;
  367.   pp4  = p4 + p11; pp5 = p5 + p10; pp6 = p6 + p9;  pp7 = p7 + p8;
  368.   pp8  = cos1_32  * (p0 - p15);
  369.   pp9  = cos3_32  * (p1 - p14);
  370.   pp10 = cos5_32  * (p2 - p13);
  371.   pp11 = cos7_32  * (p3 - p12);
  372.   pp12 = cos9_32  * (p4 - p11);
  373.   pp13 = cos11_32 * (p5 - p10);
  374.   pp14 = cos13_32 * (p6 - p9);
  375.   pp15 = cos15_32 * (p7 - p8);
  376.  
  377.   p0  = pp0 + pp7; p1 = pp1 + pp6; p2 = pp2 + pp5; p3 = pp3 + pp4;
  378.   p4  = cos1_16 * (pp0 - pp7);
  379.   p5  = cos3_16 * (pp1 - pp6);
  380.   p6  = cos5_16 * (pp2 - pp5);
  381.   p7  = cos7_16 * (pp3 - pp4);
  382.   p8  = pp8  + pp15; p9 = pp9  + pp14; p10 = pp10 + pp13; p11 = pp11 + pp12;
  383.   p12 = cos1_16 * (pp8  - pp15);
  384.   p13 = cos3_16 * (pp9  - pp14);
  385.   p14 = cos5_16 * (pp10 - pp13);
  386.   p15 = cos7_16 * (pp11 - pp12);
  387.  
  388.   pp0  = p0 + p3; pp1 = p1 + p2;
  389.   pp2  = cos1_8 * (p0 - p3);
  390.   pp3  = cos3_8 * (p1 - p2);
  391.   pp4  = p4 + p7; pp5 = p5 + p6;
  392.   pp6  = cos1_8 * (p4 - p7);
  393.   pp7  = cos3_8 * (p5 - p6);
  394.   pp8  = p8 + p11; pp9 = p9 + p10;
  395.   pp10 = cos1_8 * (p8 - p11);
  396.   pp11 = cos3_8 * (p9 - p10);
  397.   pp12 = p12 + p15; pp13 = p13 + p14;
  398.   pp14 = cos1_8 * (p12 - p15);
  399.   pp15 = cos3_8 * (p13 - p14);
  400.  
  401.   p0 = pp0 + pp1;
  402.   p1 = cos1_4 * (pp0 - pp1);
  403.   p2 = pp2 + pp3;
  404.   p3 = cos1_4 * (pp2 - pp3);
  405.   p4 = pp4 + pp5;
  406.   p5 = cos1_4 * (pp4 - pp5);
  407.   p6 = pp6 + pp7;
  408.   p7 = cos1_4 * (pp6 - pp7);
  409.   p8  = pp8 + pp9;
  410.   p9  = cos1_4 * (pp8 - pp9);
  411.   p10 = pp10 + pp11;
  412.   p11 = cos1_4 * (pp10 - pp11);
  413.   p12 = pp12 + pp13;
  414.   p13 = cos1_4 * (pp12 - pp13);
  415.   p14 = pp14 + pp15;
  416.   p15 = cos1_4 * (pp14 - pp15);
  417.  
  418.   tmp          = p13 + p15;
  419.   new_v[1]     = p1 + p9 + tmp;
  420.   new_v[5]     = p5 + p7 + p11 + tmp;
  421.   tmp         += p9;
  422.   new_v[33-17] = -(p1 + p14 + tmp);
  423.   tmp         += p5 + p7;
  424.   new_v[3]     = tmp;
  425.   new_v[35-17] = -(p6 + p14 + tmp);
  426.   tmp          = p10 + p11 + p12 + p13 + p14 + p15;
  427.   new_v[39-17] = -(p2 + p3 + tmp - p12);
  428.   new_v[43-17] = -(p4 + p6 + p7 + tmp - p13);
  429.   new_v[37-17] = -(p5 + p6 + p7 + tmp - p12);
  430.   new_v[41-17] = -(p2 + p3 + tmp - p13);
  431.   tmp          = p8 + p12 + p14 + p15;
  432.   new_v[47-17] = -(p0 + tmp);
  433.   new_v[45-17] = -(p4 + p6 + p7 + tmp);
  434.   tmp          = p11 + p15;
  435.   new_v[11]    = p7  + tmp;
  436.   tmp         += p3;
  437.   new_v[9]     = tmp;
  438.   new_v[7]     = p13 + tmp;
  439.   new_v[13]    = p7 + p15;
  440.   new_v[15]    = p15;
  441.  
  442.   // insert V[0-15] (== new_v[0-15]) into actual v:
  443.   x1 = new_v;
  444.   x2 = actual_v + actual_write_pos;
  445.   *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16;
  446.   *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16;
  447.   *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16;
  448.   *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1;   x2 += 16;
  449.   // V[16] is always 0.0:
  450.   *x2 = 0.0; x2 += 16;
  451.   // insert V[17-31] (== -new_v[15-1]) into actual v:
  452.   *x2 = -*x1;   x2 += 16; *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16;
  453.   *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16;
  454.   *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16;
  455.   *x2 = -*--x1; x2 += 16; *x2 = -*--x1; x2 += 16; *x2 = -*--x1;
  456.  
  457.   // insert V[32] (== -new_v[0]) into other v:
  458.   x2 = (actual_v == v1 ? v2 : v1) + actual_write_pos;
  459.   *x2 = -*--x1; x2 += 16;
  460.   // insert V[33-48] (== new_v[16-31]) into other v:
  461.   x1 = new_v + 16;
  462.   *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16;
  463.   *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16;
  464.   *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16;
  465.   *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1++; x2 += 16; *x2 = *x1;   x2 += 16;
  466.   // insert V[49-63] (== new_v[30-16]) into other v:
  467.   *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16;
  468.   *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16;
  469.   *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16;
  470.   *x2 = *--x1; x2 += 16; *x2 = *--x1; x2 += 16; *x2 = *--x1;
  471. }
  472.  
  473.  
  474. void SynthesisFilter::compute_pcm_samples (Obuffer *buffer)
  475. {
  476.   uint32 i;
  477.   register real floatreg, *vp;
  478.   register const real *dp;
  479.   int32 pcm_sample;
  480.  
  481. #ifdef ULAW
  482.   int32 offset;
  483.  
  484.   i = remaining_offset;
  485.   dp = d + (i << 4);
  486. #else
  487.   i = 0;
  488.   dp = d;
  489. #endif
  490.  
  491.   switch (actual_write_pos)
  492.   {
  493.     case 0:
  494. #ifdef ULAW
  495.       vp = actual_v + (i << 4);
  496.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  497.       {
  498.     offset = offset1;
  499.     offset1 = offset2;
  500.     offset2 = offset;
  501. #else
  502.       vp = actual_v;
  503.       for (; i < 32; ++i)
  504.       {
  505. #endif
  506.     floatreg = *vp * *dp++;
  507.     vp += 15;
  508.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  509.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  510.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  511.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  512.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  513.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  514.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  515.     floatreg += *--vp * *dp++;
  516.     pcm_sample = (int)(floatreg * scalefactor);
  517.     if (pcm_sample > 32767)
  518.     {
  519.       ++range_violations;
  520.       if (floatreg > max_violation)
  521.         max_violation = floatreg;
  522.       pcm_sample = 32767;
  523.     }
  524.     else if (pcm_sample < -32768)
  525.     {
  526.       ++range_violations;
  527.       if (-floatreg > max_violation)
  528.         max_violation = -floatreg;
  529.       pcm_sample = -32768;
  530.     }
  531.     buffer->append (channel, (int16)pcm_sample);
  532.     vp += 15;
  533.       }
  534.       break;
  535.     case 1:
  536. #ifdef ULAW
  537.       vp = actual_v + 1 + (i << 4);
  538.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  539.       {
  540.     offset = offset1;
  541.     offset1 = offset2;
  542.     offset2 = offset;
  543. #else
  544.       vp = actual_v + 1;
  545.       for (; i < 32; ++i)
  546.       {
  547. #endif
  548.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  549.     vp += 15;
  550.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  551.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  552.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  553.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  554.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  555.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  556.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  557.     pcm_sample = (int)(floatreg * scalefactor);
  558.     if (pcm_sample > 32767)
  559.     {
  560.       ++range_violations;
  561.       if (floatreg > max_violation)
  562.         max_violation = floatreg;
  563.       pcm_sample = 32767;
  564.     }
  565.     else if (pcm_sample < -32768)
  566.     {
  567.       ++range_violations;
  568.       if (-floatreg > max_violation)
  569.         max_violation = -floatreg;
  570.       pcm_sample = -32768;
  571.     }
  572.     buffer->append (channel, (int16)pcm_sample);
  573.     vp += 15;
  574.       }
  575.       break;
  576.     case 2:
  577. #ifdef ULAW
  578.       vp = actual_v + 2 + (i << 4);
  579.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  580.       {
  581.     offset = offset1;
  582.     offset1 = offset2;
  583.     offset2 = offset;
  584. #else
  585.       vp = actual_v + 2;
  586.       for (; i < 32; ++i)
  587.       {
  588. #endif
  589.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  590.     floatreg += *--vp * *dp++;
  591.     vp += 15;
  592.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  593.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  594.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  595.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  596.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  597.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  598.     floatreg += *--vp * *dp++;
  599.     pcm_sample = (int)(floatreg * scalefactor);
  600.     if (pcm_sample > 32767)
  601.     {
  602.       ++range_violations;
  603.       if (floatreg > max_violation)
  604.         max_violation = floatreg;
  605.       pcm_sample = 32767;
  606.     }
  607.     else if (pcm_sample < -32768)
  608.     {
  609.       ++range_violations;
  610.       if (-floatreg > max_violation)
  611.         max_violation = -floatreg;
  612.       pcm_sample = -32768;
  613.     }
  614.     buffer->append (channel, (int16)pcm_sample);
  615.     vp += 15;
  616.       }
  617.       break;
  618.     case 3:
  619. #ifdef ULAW
  620.       vp = actual_v + 3 + (i << 4);
  621.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  622.       {
  623.     offset = offset1;
  624.     offset1 = offset2;
  625.     offset2 = offset;
  626. #else
  627.       vp = actual_v + 3;
  628.       for (; i < 32; ++i)
  629.       {
  630. #endif
  631.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  632.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  633.     vp += 15;
  634.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  635.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  636.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  637.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  638.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  639.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  640.     pcm_sample = (int)(floatreg * scalefactor);
  641.     if (pcm_sample > 32767)
  642.     {
  643.       ++range_violations;
  644.       if (floatreg > max_violation)
  645.         max_violation = floatreg;
  646.       pcm_sample = 32767;
  647.     }
  648.     else if (pcm_sample < -32768)
  649.     {
  650.       ++range_violations;
  651.       if (-floatreg > max_violation)
  652.         max_violation = -floatreg;
  653.       pcm_sample = -32768;
  654.     }
  655.     buffer->append (channel, (int16)pcm_sample);
  656.     vp += 15;
  657.       }
  658.       break;
  659.     case 4:
  660. #ifdef ULAW
  661.       vp = actual_v + 4 + (i << 4);
  662.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  663.       {
  664.     offset = offset1;
  665.     offset1 = offset2;
  666.     offset2 = offset;
  667. #else
  668.       vp = actual_v + 4;
  669.       for (; i < 32; ++i)
  670.       {
  671. #endif
  672.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  673.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  674.     floatreg += *--vp * *dp++;
  675.     vp += 15;
  676.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  677.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  678.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  679.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  680.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  681.     floatreg += *--vp * *dp++;
  682.     pcm_sample = (int)(floatreg * scalefactor);
  683.     if (pcm_sample > 32767)
  684.     {
  685.       ++range_violations;
  686.       if (floatreg > max_violation)
  687.         max_violation = floatreg;
  688.       pcm_sample = 32767;
  689.     }
  690.     else if (pcm_sample < -32768)
  691.     {
  692.       ++range_violations;
  693.       if (-floatreg > max_violation)
  694.         max_violation = -floatreg;
  695.       pcm_sample = -32768;
  696.     }
  697.     buffer->append (channel, (int16)pcm_sample);
  698.     vp += 15;
  699.       }
  700.       break;
  701.     case 5:
  702. #ifdef ULAW
  703.       vp = actual_v + 5 + (i << 4);
  704.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  705.       {
  706.     offset = offset1;
  707.     offset1 = offset2;
  708.     offset2 = offset;
  709. #else
  710.       vp = actual_v + 5;
  711.       for (; i < 32; ++i)
  712.       {
  713. #endif
  714.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  715.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  716.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  717.     vp += 15;
  718.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  719.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  720.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  721.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  722.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  723.     pcm_sample = (int)(floatreg * scalefactor);
  724.     if (pcm_sample > 32767)
  725.     {
  726.       ++range_violations;
  727.       if (floatreg > max_violation)
  728.         max_violation = floatreg;
  729.       pcm_sample = 32767;
  730.     }
  731.     else if (pcm_sample < -32768)
  732.     {
  733.       ++range_violations;
  734.       if (-floatreg > max_violation)
  735.         max_violation = -floatreg;
  736.       pcm_sample = -32768;
  737.     }
  738.     buffer->append (channel, (int16)pcm_sample);
  739.     vp += 15;
  740.       }
  741.       break;
  742.     case 6:
  743. #ifdef ULAW
  744.       vp = actual_v + 6 + (i << 4);
  745.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  746.       {
  747.     offset = offset1;
  748.     offset1 = offset2;
  749.     offset2 = offset;
  750. #else
  751.       vp = actual_v + 6;
  752.       for (; i < 32; ++i)
  753.       {
  754. #endif
  755.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  756.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  757.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  758.     floatreg += *--vp * *dp++;
  759.     vp += 15;
  760.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  761.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  762.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  763.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  764.     floatreg += *--vp * *dp++;
  765.     pcm_sample = (int)(floatreg * scalefactor);
  766.     if (pcm_sample > 32767)
  767.     {
  768.       ++range_violations;
  769.       if (floatreg > max_violation)
  770.         max_violation = floatreg;
  771.       pcm_sample = 32767;
  772.     }
  773.     else if (pcm_sample < -32768)
  774.     {
  775.       ++range_violations;
  776.       if (-floatreg > max_violation)
  777.         max_violation = -floatreg;
  778.       pcm_sample = -32768;
  779.     }
  780.     buffer->append (channel, (int16)pcm_sample);
  781.     vp += 15;
  782.       }
  783.       break;
  784.     case 7:
  785. #ifdef ULAW
  786.       vp = actual_v + 7 + (i << 4);
  787.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  788.       {
  789.     offset = offset1;
  790.     offset1 = offset2;
  791.     offset2 = offset;
  792. #else
  793.       vp = actual_v + 7;
  794.       for (; i < 32; ++i)
  795.       {
  796. #endif
  797.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  798.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  799.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  800.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  801.     vp += 15;
  802.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  803.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  804.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  805.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  806.     pcm_sample = (int)(floatreg * scalefactor);
  807.     if (pcm_sample > 32767)
  808.     {
  809.       ++range_violations;
  810.       if (floatreg > max_violation)
  811.         max_violation = floatreg;
  812.       pcm_sample = 32767;
  813.     }
  814.     else if (pcm_sample < -32768)
  815.     {
  816.       ++range_violations;
  817.       if (-floatreg > max_violation)
  818.         max_violation = -floatreg;
  819.       pcm_sample = -32768;
  820.     }
  821.     buffer->append (channel, (int16)pcm_sample);
  822.     vp += 15;
  823.       }
  824.       break;
  825.     case 8:
  826. #ifdef ULAW
  827.       vp = actual_v + 8 + (i << 4);
  828.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  829.       {
  830.     offset = offset1;
  831.     offset1 = offset2;
  832.     offset2 = offset;
  833. #else
  834.       vp = actual_v + 8;
  835.       for (; i < 32; ++i)
  836.       {
  837. #endif
  838.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  839.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  840.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  841.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  842.     floatreg += *--vp * *dp++;
  843.     vp += 15;
  844.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  845.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  846.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  847.     floatreg += *--vp * *dp++;
  848.     pcm_sample = (int)(floatreg * scalefactor);
  849.     if (pcm_sample > 32767)
  850.     {
  851.       ++range_violations;
  852.       if (floatreg > max_violation)
  853.         max_violation = floatreg;
  854.       pcm_sample = 32767;
  855.     }
  856.     else if (pcm_sample < -32768)
  857.     {
  858.       ++range_violations;
  859.       if (-floatreg > max_violation)
  860.         max_violation = -floatreg;
  861.       pcm_sample = -32768;
  862.     }
  863.     buffer->append (channel, (int16)pcm_sample);
  864.     vp += 15;
  865.       }
  866.       break;
  867.     case 9:
  868. #ifdef ULAW
  869.       vp = actual_v + 9 + (i << 4);
  870.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  871.       {
  872.     offset = offset1;
  873.     offset1 = offset2;
  874.     offset2 = offset;
  875. #else
  876.       vp = actual_v + 9;
  877.       for (; i < 32; ++i)
  878.       {
  879. #endif
  880.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  881.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  882.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  883.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  884.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  885.     vp += 15;
  886.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  887.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  888.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  889.     pcm_sample = (int)(floatreg * scalefactor);
  890.     if (pcm_sample > 32767)
  891.     {
  892.       ++range_violations;
  893.       if (floatreg > max_violation)
  894.         max_violation = floatreg;
  895.       pcm_sample = 32767;
  896.     }
  897.     else if (pcm_sample < -32768)
  898.     {
  899.       ++range_violations;
  900.       if (-floatreg > max_violation)
  901.         max_violation = -floatreg;
  902.       pcm_sample = -32768;
  903.     }
  904.     buffer->append (channel, (int16)pcm_sample);
  905.     vp += 15;
  906.       }
  907.       break;
  908.     case 10:
  909. #ifdef ULAW
  910.       vp = actual_v + 10 + (i << 4);
  911.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  912.       {
  913.     offset = offset1;
  914.     offset1 = offset2;
  915.     offset2 = offset;
  916. #else
  917.       vp = actual_v + 10;
  918.       for (; i < 32; ++i)
  919.       {
  920. #endif
  921.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  922.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  923.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  924.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  925.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  926.     floatreg += *--vp * *dp++;
  927.     vp += 15;
  928.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  929.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  930.     floatreg += *--vp * *dp++;
  931.     pcm_sample = (int)(floatreg * scalefactor);
  932.     if (pcm_sample > 32767)
  933.     {
  934.       ++range_violations;
  935.       if (floatreg > max_violation)
  936.         max_violation = floatreg;
  937.       pcm_sample = 32767;
  938.     }
  939.     else if (pcm_sample < -32768)
  940.     {
  941.       ++range_violations;
  942.       if (-floatreg > max_violation)
  943.         max_violation = -floatreg;
  944.       pcm_sample = -32768;
  945.     }
  946.     buffer->append (channel, (int16)pcm_sample);
  947.     vp += 15;
  948.       }
  949.       break;
  950.     case 11:
  951. #ifdef ULAW
  952.       vp = actual_v + 11 + (i << 4);
  953.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  954.       {
  955.     offset = offset1;
  956.     offset1 = offset2;
  957.     offset2 = offset;
  958. #else
  959.       vp = actual_v + 11;
  960.       for (; i < 32; ++i)
  961.       {
  962. #endif
  963.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  964.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  965.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  966.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  967.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  968.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  969.     vp += 15;
  970.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  971.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  972.     pcm_sample = (int)(floatreg * scalefactor);
  973.     if (pcm_sample > 32767)
  974.     {
  975.       ++range_violations;
  976.       if (floatreg > max_violation)
  977.         max_violation = floatreg;
  978.       pcm_sample = 32767;
  979.     }
  980.     else if (pcm_sample < -32768)
  981.     {
  982.       ++range_violations;
  983.       if (-floatreg > max_violation)
  984.         max_violation = -floatreg;
  985.       pcm_sample = -32768;
  986.     }
  987.     buffer->append (channel, (int16)pcm_sample);
  988.     vp += 15;
  989.       }
  990.       break;
  991.     case 12:
  992. #ifdef ULAW
  993.       vp = actual_v + 12 + (i << 4);
  994.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  995.       {
  996.     offset = offset1;
  997.     offset1 = offset2;
  998.     offset2 = offset;
  999. #else
  1000.       vp = actual_v + 12;
  1001.       for (; i < 32; ++i)
  1002.       {
  1003. #endif
  1004.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  1005.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1006.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1007.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1008.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1009.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1010.     floatreg += *--vp * *dp++;
  1011.     vp += 15;
  1012.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  1013.     floatreg += *--vp * *dp++;
  1014.     pcm_sample = (int)(floatreg * scalefactor);
  1015.     if (pcm_sample > 32767)
  1016.     {
  1017.       ++range_violations;
  1018.       if (floatreg > max_violation)
  1019.         max_violation = floatreg;
  1020.       pcm_sample = 32767;
  1021.     }
  1022.     else if (pcm_sample < -32768)
  1023.     {
  1024.       ++range_violations;
  1025.       if (-floatreg > max_violation)
  1026.         max_violation = -floatreg;
  1027.       pcm_sample = -32768;
  1028.     }
  1029.     buffer->append (channel, (int16)pcm_sample);
  1030.     vp += 15;
  1031.       }
  1032.       break;
  1033.     case 13:
  1034. #ifdef ULAW
  1035.       vp = actual_v + 13 + (i << 4);
  1036.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  1037.       {
  1038.     offset = offset1;
  1039.     offset1 = offset2;
  1040.     offset2 = offset;
  1041. #else
  1042.       vp = actual_v + 13;
  1043.       for (; i < 32; ++i)
  1044.       {
  1045. #endif
  1046.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  1047.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1048.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1049.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1050.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1051.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1052.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1053.     vp += 15;
  1054.     floatreg += *vp * *dp++;   floatreg += *--vp * *dp++;
  1055.     pcm_sample = (int)(floatreg * scalefactor);
  1056.     if (pcm_sample > 32767)
  1057.     {
  1058.       ++range_violations;
  1059.       if (floatreg > max_violation)
  1060.         max_violation = floatreg;
  1061.       pcm_sample = 32767;
  1062.     }
  1063.     else if (pcm_sample < -32768)
  1064.     {
  1065.       ++range_violations;
  1066.       if (-floatreg > max_violation)
  1067.         max_violation = -floatreg;
  1068.       pcm_sample = -32768;
  1069.     }
  1070.     buffer->append (channel, (int16)pcm_sample);
  1071.     vp += 15;
  1072.       }
  1073.       break;
  1074.     case 14:
  1075. #ifdef ULAW
  1076.       vp = actual_v + 14 + (i << 4);
  1077.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  1078.       {
  1079.     offset = offset1;
  1080.     offset1 = offset2;
  1081.     offset2 = offset;
  1082. #else
  1083.       vp = actual_v + 14;
  1084.       for (; i < 32; ++i)
  1085.       {
  1086. #endif
  1087.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  1088.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1089.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1090.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1091.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1092.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1093.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1094.     floatreg += *--vp * *dp++;
  1095.     vp += 15;
  1096.     floatreg += *vp * *dp++;
  1097.     pcm_sample = (int)(floatreg * scalefactor);
  1098.     if (pcm_sample > 32767)
  1099.     {
  1100.       ++range_violations;
  1101.       if (floatreg > max_violation)
  1102.         max_violation = floatreg;
  1103.       pcm_sample = 32767;
  1104.     }
  1105.     else if (pcm_sample < -32768)
  1106.     {
  1107.       ++range_violations;
  1108.       if (-floatreg > max_violation)
  1109.         max_violation = -floatreg;
  1110.       pcm_sample = -32768;
  1111.     }
  1112.     buffer->append (channel, (int16)pcm_sample);
  1113.     vp += 15;
  1114.       }
  1115.       break;
  1116.     case 15:
  1117. #ifdef ULAW
  1118.       vp = actual_v + 15 + (i << 4);
  1119.       for (; i < 32; i += offset + 1, offset <<= 4, vp += offset, dp += offset)
  1120.       {
  1121.     offset = offset1;
  1122.     offset1 = offset2;
  1123.     offset2 = offset;
  1124. #else
  1125.       vp = actual_v + 15;
  1126.       for (; i < 32; ++i)
  1127.       {
  1128. #endif
  1129.     floatreg = *vp * *dp++;    floatreg += *--vp * *dp++;
  1130.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1131.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1132.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1133.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1134.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1135.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1136.     floatreg += *--vp * *dp++; floatreg += *--vp * *dp++;
  1137.     pcm_sample = (int)(floatreg * scalefactor);
  1138.     if (pcm_sample > 32767)
  1139.     {
  1140.       ++range_violations;
  1141.       if (floatreg > max_violation)
  1142.         max_violation = floatreg;
  1143.       pcm_sample = 32767;
  1144.     }
  1145.     else if (pcm_sample < -32768)
  1146.     {
  1147.       ++range_violations;
  1148.       if (-floatreg > max_violation)
  1149.         max_violation = -floatreg;
  1150.       pcm_sample = -32768;
  1151.     }
  1152.     buffer->append (channel, (int16)pcm_sample);
  1153.     vp += 31;
  1154.       }
  1155.   }
  1156.  
  1157. #ifdef ULAW
  1158.   remaining_offset = i - 32;
  1159. #endif
  1160. }
  1161.  
  1162.  
  1163. void SynthesisFilter::calculate_pcm_samples (Obuffer *buffer)
  1164. {
  1165.   compute_new_v ();
  1166.   compute_pcm_samples (buffer);
  1167.  
  1168.   written_samples += 32;
  1169.   if (actual_write_pos < 15)
  1170.     ++actual_write_pos;
  1171.   else
  1172.     actual_write_pos = 0;
  1173.   actual_v = (actual_v == v1 ? v2 : v1);
  1174.  
  1175.   // initialize samples[]:
  1176.   for (register real *floatp = samples + 32; floatp > samples; )
  1177.     *--floatp = 0.0;
  1178. }
  1179.