← Back to branch summary

~ubuntu-branches/debian/wheezy/vlc/wheezy

« back to all changes in this revision

Viewing changes to plugins/mpeg_adec/adec_math.c

Tags: upstream-0.7.2.final
Import upstream version 0.7.2.final

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/mpeg_adec/adec_math.c
1
 
/*****************************************************************************
2
 
 * adec_math.c: Inverse Discrete Cosine Transform and Pulse Code Modulation
3
 
 *****************************************************************************
4
 
 * Copyright (C) 1999, 2000 VideoLAN
5
 
 * $Id: adec_math.c,v 1.1 2001/11/13 12:09:18 henri Exp $
6
 
 *
7
 
 * Authors: Michel Kaempf <maxx@via.ecp.fr>
8
 
 *          Michel Lespinasse <walken@via.ecp.fr>
9
 
 *
10
 
 * This program is free software; you can redistribute it and/or modify
11
 
 * it under the terms of the GNU General Public License as published by
12
 
 * the Free Software Foundation; either version 2 of the License, or
13
 
 * (at your option) any later version.
14
 
 * 
15
 
 * This program is distributed in the hope that it will be useful,
16
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
 
 * GNU General Public License for more details.
19
 
 *
20
 
 * You should have received a copy of the GNU General Public License
21
 
 * along with this program; if not, write to the Free Software
22
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23
 
 *****************************************************************************/
24
 
 
25
 
#include "int_types.h"
26
 
#include "mpeg_adec_generic.h"
27
 
 
28
 
/*****************************************************************************
29
 
 * DCT32: Fast 32 points Discrete Cosine Transform
30
 
 *****************************************************************************
31
 
 * 289 additions and multiplications
32
 
 * F(u)=alpha(u)*SUM(x=0, x<N) f(x)*cos((2x+1)u*pi/2N)
33
 
 * where alpha(u) = sqrt(2)/N if u=0, 2/N otherwise.
34
 
 * See fastdct.ps, and fast.tar.gz for a (Fortran :) implementation.
35
 
 *****************************************************************************/
36
 
 
37
 
void DCT32(float *x, adec_bank_t *b)
38
 
{
39
 
    /* cosine coefficients */
40
 
    static const float c2  =  .70710678118655;
41
 
    static const float c3  =  .54119610014620;
42
 
    static const float c4  = -1.3065629648764;
43
 
    static const float c5  =  .50979557910416;
44
 
    static const float c6  =  .89997622313642;
45
 
    static const float c7  = -2.5629154477415;
46
 
    static const float c8  = -.60134488693505;
47
 
    static const float c9  =  .50241928618816;
48
 
    static const float c10 =  .56694403481636;
49
 
    static const float c11 =  .78815462345125;
50
 
    static const float c12 =  1.7224470982383;
51
 
    static const float c13 = -5.1011486186892;
52
 
    static const float c14 = -1.0606776859903;
53
 
    static const float c15 = -.64682178335999;
54
 
    static const float c16 = -.52249861493969;
55
 
    static const float c17 =  .50060299823520;
56
 
    static const float c18 =  .51544730992262;
57
 
    static const float c19 =  .55310389603444;
58
 
    static const float c20 =  .62250412303566;
59
 
    static const float c21 =  .74453627100230;
60
 
    static const float c22 =  .97256823786196;
61
 
    static const float c23 =  1.4841646163142;
62
 
    static const float c24 =  3.4076084184687;
63
 
    static const float c25 = -10.190008123548;
64
 
    static const float c26 = -2.0577810099534;
65
 
    static const float c27 = -1.1694399334329;
66
 
    static const float c28 = -.83934964541553;
67
 
    static const float c29 = -.67480834145501;
68
 
    static const float c30 = -.58293496820613;
69
 
    static const float c31 = -.53104259108978;
70
 
    static const float c32 = -.50547095989754;
71
 
 
72
 
    /* temporary variables */
73
 
    float  t1  , t2  , t3  , t4  , t5  , t6  , t7  , t8  ,
74
 
           t9  , t10 , t11 , t12 , t13 , t14 , t15 , t16 ,
75
 
           t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 ,
76
 
           t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32 ,
77
 
           tt1 , tt2 , tt3 , tt4 , tt5 , tt6 , tt7 , tt8 ,
78
 
           tt9 , tt10, tt11, tt12, tt13, tt14, tt15, tt16,
79
 
           tt17, tt18, tt19, tt20, tt21, tt22, tt23, tt24,
80
 
           tt25, tt26, tt27, tt28, tt29, tt30, tt31, tt32, *y;
81
 
 
82
 
    /* We unrolled the loops */
83
 
    /* Odd-even ordering is integrated before the 1st stage */
84
 
    t17 = c17 * (x[0] - x[31]);
85
 
    t1  = x[0] + x[31];
86
 
    t18 = c18 * (x[2] - x[29]);
87
 
    t2  = x[2] + x[29];
88
 
    t19 = c19 * (x[4] - x[27]);
89
 
    t3  = x[4] + x[27];
90
 
    t20 = c20 * (x[6] - x[25]);
91
 
    t4  = x[6] + x[25];
92
 
    t21 = c21 * (x[8] - x[23]);
93
 
    t5  = x[8] + x[23];
94
 
    t22 = c22 * (x[10] - x[21]);
95
 
    t6  = x[10] + x[21];
96
 
    t23 = c23 * (x[12] - x[19]);
97
 
    t7  = x[12] + x[19];
98
 
    t24 = c24 * (x[14] - x[17]);
99
 
    t8  = x[14] + x[17];
100
 
    t25 = c25 * (x[16] - x[15]);
101
 
    t9  = x[16] + x[15];
102
 
    t26 = c26 * (x[18] - x[13]);
103
 
    t10 = x[18] + x[13];
104
 
    t27 = c27 * (x[20] - x[11]);
105
 
    t11 = x[20] + x[11];
106
 
    t28 = c28 * (x[22] - x[9]);
107
 
    t12 = x[22] + x[9];
108
 
    t29 = c29 * (x[24] - x[7]);
109
 
    t13 = x[24] + x[7];
110
 
    t30 = c30 * (x[26] - x[5]);
111
 
    t14 = x[26] + x[5];
112
 
    t31 = c31 * (x[28] - x[3]);
113
 
    t15 = x[28] + x[3];
114
 
    t32 = c32 * (x[30] - x[1]);
115
 
    t16 = x[30] + x[1];
116
 
    /* 2nd stage */
117
 
    tt9  = c9  * (t1  - t9);
118
 
    tt1  = t1  + t9;
119
 
    tt10 = c10 * (t2  - t10);
120
 
    tt2  = t2  + t10;
121
 
    tt11 = c11 * (t3  - t11);
122
 
    tt3  = t3  + t11;
123
 
    tt12 = c12 * (t4  - t12);
124
 
    tt4  = t4  + t12;
125
 
    tt13 = c13 * (t5  - t13);
126
 
    tt5  = t5  + t13;
127
 
    tt14 = c14 * (t6  - t14);
128
 
    tt6  = t6  + t14;
129
 
    tt15 = c15 * (t7  - t15);
130
 
    tt7  = t7  + t15;
131
 
    tt16 = c16 * (t8  - t16);
132
 
    tt8  = t8  + t16;
133
 
    tt25 = c9  * (t17 - t25);
134
 
    tt17 = t17 + t25;
135
 
    tt26 = c10 * (t18 - t26);
136
 
    tt18 = t18 + t26;
137
 
    tt27 = c11 * (t19 - t27);
138
 
    tt19 = t19 + t27;
139
 
    tt28 = c12 * (t20 - t28);
140
 
    tt20 = t20 + t28;
141
 
    tt29 = c13 * (t21 - t29);
142
 
    tt21 = t21 + t29;
143
 
    tt30 = c14 * (t22 - t30);
144
 
    tt22 = t22 + t30;
145
 
    tt31 = c15 * (t23 - t31);
146
 
    tt23 = t23 + t31;
147
 
    tt32 = c16 * (t24 - t32);
148
 
    tt24 = t24 + t32;
149
 
    /* 3rd stage */
150
 
    t5  = c5 * (tt1  - tt5);
151
 
    t1  = tt1  + tt5;
152
 
    t6  = c6 * (tt2  - tt6);
153
 
    t2  = tt2  + tt6;
154
 
    t7  = c7 * (tt3  - tt7);
155
 
    t3  = tt3  + tt7;
156
 
    t8  = c8 * (tt4  - tt8);
157
 
    t4  = tt4  + tt8;
158
 
    t13 = c5 * (tt9  - tt13);
159
 
    t9  = tt9  + tt13;
160
 
    t14 = c6 * (tt10 - tt14);
161
 
    t10 = tt10 + tt14;
162
 
    t15 = c7 * (tt11 - tt15);
163
 
    t11 = tt11 + tt15;
164
 
    t16 = c8 * (tt12 - tt16);
165
 
    t12 = tt12 + tt16;
166
 
    t21 = c5 * (tt17 - tt21);
167
 
    t17 = tt17 + tt21;
168
 
    t22 = c6 * (tt18 - tt22);
169
 
    t18 = tt18 + tt22;
170
 
    t23 = c7 * (tt19 - tt23);
171
 
    t19 = tt19 + tt23;
172
 
    t24 = c8 * (tt20 - tt24);
173
 
    t20 = tt20 + tt24;
174
 
    t29 = c5 * (tt25 - tt29);
175
 
    t25 = tt25 + tt29;
176
 
    t30 = c6 * (tt26 - tt30);
177
 
    t26 = tt26 + tt30;
178
 
    t31 = c7 * (tt27 - tt31);
179
 
    t27 = tt27 + tt31;
180
 
    t32 = c8 * (tt28 - tt32);
181
 
    t28 = tt28 + tt32;
182
 
    /* 4th stage */
183
 
    tt3  = c3 * (t1  - t3);
184
 
    tt1  = t1  + t3;
185
 
    tt4  = c4 * (t2  - t4);
186
 
    tt2  = t2  + t4;
187
 
    tt7  = c3 * (t5  - t7);
188
 
    tt5  = t5  + t7;
189
 
    tt8  = c4 * (t6  - t8);
190
 
    tt6  = t6  + t8;
191
 
    tt11 = c3 * (t9  - t11);
192
 
    tt9  = t9  + t11;
193
 
    tt12 = c4 * (t10 - t12);
194
 
    tt10 = t10 + t12;
195
 
    tt15 = c3 * (t13 - t15);
196
 
    tt13 = t13 + t15;
197
 
    tt16 = c4 * (t14 - t16);
198
 
    tt14 = t14 + t16;
199
 
    tt19 = c3 * (t17 - t19);
200
 
    tt17 = t17 + t19;
201
 
    tt20 = c4 * (t18 - t20);
202
 
    tt18 = t18 + t20;
203
 
    tt23 = c3 * (t21 - t23);
204
 
    tt21 = t21 + t23;
205
 
    tt24 = c4 * (t22 - t24);
206
 
    tt22 = t22 + t24;
207
 
    tt27 = c3 * (t25 - t27);
208
 
    tt25 = t25 + t27;
209
 
    tt28 = c4 * (t26 - t28);
210
 
    tt26 = t26 + t28;
211
 
    tt31 = c3 * (t29 - t31);
212
 
    tt29 = t29 + t31;
213
 
    tt32 = c4 * (t30 - t32);
214
 
    tt30 = t30 + t32;
215
 
    /* Bit-reverse ordering is integrated after the 5th stage */
216
 
    /* Begin to split the result of the DCT (t1 to t32) in the filter bank */
217
 
    x = b->actual + b->pos;
218
 
    y = (b->actual == b->v1 ? b->v2 : b->v1) + b->pos;
219
 
    x[0] = -(y[0] = c2 * (tt1  - tt2)); /* t17 */
220
 
    x[256] = 0; y[256] = tt1  + tt2; /* t1  */
221
 
    t25 = c2 * (tt3  - tt4);
222
 
    t9  = tt3  + tt4;
223
 
    t21 = c2 * (tt5  - tt6);
224
 
    t5  = tt5  + tt6;
225
 
    t29 = c2 * (tt7  - tt8);
226
 
    t13 = tt7  + tt8;
227
 
    t19 = c2 * (tt9  - tt10);
228
 
    t3  = tt9  + tt10;
229
 
    t27 = c2 * (tt11 - tt12);
230
 
    t11 = tt11 + tt12;
231
 
    t23 = c2 * (tt13 - tt14);
232
 
    t7  = tt13 + tt14;
233
 
    t31 = c2 * (tt15 - tt16);
234
 
    t15 = tt15 + tt16;
235
 
    t18 = c2 * (tt17 - tt18);
236
 
    t2  = tt17 + tt18;
237
 
    t26 = c2 * (tt19 - tt20);
238
 
    t10 = tt19 + tt20;
239
 
    t22 = c2 * (tt21 - tt22);
240
 
    t6  = tt21 + tt22;
241
 
    t30 = c2 * (tt23 - tt24);
242
 
    t14 = tt23 + tt24;
243
 
    t20 = c2 * (tt25 - tt26);
244
 
    t4  = tt25 + tt26;
245
 
    t28 = c2 * (tt27 - tt28);
246
 
    t12 = tt27 + tt28;
247
 
    t24 = c2 * (tt29 - tt30);
248
 
    t8  = tt29 + tt30;
249
 
    t32 = c2 * (tt31 - tt32);
250
 
    t16 = tt31 + tt32;
251
 
    /* Do the sums */
252
 
    /* Keep on splitting the result */
253
 
    y[384] = y[128] = t9 - (x[128] = -(x[384] = t25)); /* t25, t9  */
254
 
    t10 += t26;
255
 
    t11 += t27;
256
 
    t12 += t28;
257
 
    t13 += t29;
258
 
    t14 += t30;
259
 
    t15 += t31;
260
 
    t16 += t32;
261
 
    y[320] = y[192] = t5 + t13; /* t5  */
262
 
    y[448] = y[64] = t13 + t21; /* t13 */
263
 
    x[64] = -(x[448] = t21 - (x[192] = -(x[320] = t29))); /* t29, t21 */
264
 
    t6  += t14;
265
 
    t14 += t22;
266
 
    t22 += t30;
267
 
    t7  += t15;
268
 
    t15 += t23;
269
 
    t23 += t31;
270
 
    t8  += t16;
271
 
    t16 += t24;
272
 
    t24 += t32;
273
 
    y[288] = y[224] = t3 + t7; /* t3  */
274
 
    y[352] = y[160] = t7 + t11; /* t7  */
275
 
    y[416] = y[96] = t11 + t15; /* t11 */
276
 
    y[480] = y[32] = t15 + t19; /* t15 */
277
 
    x[32] = -(x[480] = t19 + t23); /* t19 */
278
 
    x[96] = -(x[416] = t23 + t27); /* t23 */
279
 
    x[160] = -(x[352] = t27 - (x[224] = -(x[288] = t31))); /* t31, t27 */
280
 
    t4  += t8 ;
281
 
    t8  += t12;
282
 
    t12 += t16;
283
 
    t16 += t20;
284
 
    t20 += t24;
285
 
    t24 += t28;
286
 
    t28 += t32;
287
 
    y[272] = y[240] = t2 + t4; /* t2  */
288
 
    y[304] = y[208] = t4 + t6; /* t4  */
289
 
    y[336] = y[176] = t6 + t8; /* t6  */
290
 
    y[368] = y[144] = t8 + t10; /* t8  */
291
 
    y[400] = y[112] = t10 + t12; /* t10 */
292
 
    y[432] = y[80] = t12 + t14; /* t12 */
293
 
    y[464] = y[48] = t14 + t16; /* t14 */
294
 
    y[496] = y[16] = t16 + t18; /* t16 */
295
 
    x[16] = -(x[496] = t18 + t20); /* t18 */
296
 
    x[48] = -(x[464] = t20 + t22); /* t20 */
297
 
    x[80] = -(x[432] = t22 + t24); /* t22 */
298
 
    x[112] = -(x[400] = t24 + t26); /* t24 */
299
 
    x[144] = -(x[368] = t26 + t28); /* t26 */
300
 
    x[176] = -(x[336] = t28 + t30); /* t28 */
301
 
    x[208] = -(x[304] = t30 - (x[240] = -(x[272] = t32))); /* t32, t30 */
302
 
    /* Note that to be really complete, the DCT should multiply t1 by sqrt(2)/N
303
 
       and t2 to t32 by 2/N, and would take 321 additions and multiplications.
304
 
       But that's unuseful in this application. */
305
 
}
306
 
 
307
 
 
308
 
/*****************************************************************************
309
 
 * PCM: Pulse Code Modulation
310
 
 *****************************************************************************
311
 
 * Compute 32 PCM samples with a convolution product
312
 
 *****************************************************************************/
313
 
 
314
 
void PCM(adec_bank_t *b, s16 **pcm, int jump)
315
 
{
316
 
    /* scale factor */
317
 
#define F -32768
318
 
    /* These values are not in the same order as in Annex 3-B.3 of the ISO/IEC
319
 
       DIS 11172-3 */
320
 
    static const float c[512] =
321
 
    {
322
 
        0.000000000 * F, -0.000442505 * F,  0.003250122 * F, -0.007003784 * F,
323
 
        0.031082153 * F, -0.078628540 * F,  0.100311279 * F, -0.572036743 * F,
324
 
        1.144989014 * F,  0.572036743 * F,  0.100311279 * F,  0.078628540 * F,
325
 
        0.031082153 * F,  0.007003784 * F,  0.003250122 * F,  0.000442505 * F,
326
 
       -0.000015259 * F, -0.000473022 * F,  0.003326416 * F, -0.007919312 * F,
327
 
        0.030517578 * F, -0.084182739 * F,  0.090927124 * F, -0.600219727 * F,
328
 
        1.144287109 * F,  0.543823242 * F,  0.108856201 * F,  0.073059082 * F,
329
 
        0.031478882 * F,  0.006118774 * F,  0.003173828 * F,  0.000396729 * F,
330
 
       -0.000015259 * F, -0.000534058 * F,  0.003387451 * F, -0.008865356 * F,
331
 
        0.029785156 * F, -0.089706421 * F,  0.080688477 * F, -0.628295898 * F,
332
 
        1.142211914 * F,  0.515609741 * F,  0.116577148 * F,  0.067520142 * F,
333
 
        0.031738281 * F,  0.005294800 * F,  0.003082275 * F,  0.000366211 * F,
334
 
       -0.000015259 * F, -0.000579834 * F,  0.003433228 * F, -0.009841919 * F,
335
 
        0.028884888 * F, -0.095169067 * F,  0.069595337 * F, -0.656219482 * F,
336
 
        1.138763428 * F,  0.487472534 * F,  0.123474121 * F,  0.061996460 * F,
337
 
        0.031845093 * F,  0.004486084 * F,  0.002990723 * F,  0.000320435 * F,
338
 
       -0.000015259 * F, -0.000625610 * F,  0.003463745 * F, -0.010848999 * F,
339
 
        0.027801514 * F, -0.100540161 * F,  0.057617188 * F, -0.683914185 * F,
340
 
        1.133926392 * F,  0.459472656 * F,  0.129577637 * F,  0.056533813 * F,
341
 
        0.031814575 * F,  0.003723145 * F,  0.002899170 * F,  0.000289917 * F,
342
 
       -0.000015259 * F, -0.000686646 * F,  0.003479004 * F, -0.011886597 * F,
343
 
        0.026535034 * F, -0.105819702 * F,  0.044784546 * F, -0.711318970 * F,
344
 
        1.127746582 * F,  0.431655884 * F,  0.134887695 * F,  0.051132202 * F,
345
 
        0.031661987 * F,  0.003005981 * F,  0.002792358 * F,  0.000259399 * F,
346
 
       -0.000015259 * F, -0.000747681 * F,  0.003479004 * F, -0.012939453 * F,
347
 
        0.025085449 * F, -0.110946655 * F,  0.031082153 * F, -0.738372803 * F,
348
 
        1.120223999 * F,  0.404083252 * F,  0.139450073 * F,  0.045837402 * F,
349
 
        0.031387329 * F,  0.002334595 * F,  0.002685547 * F,  0.000244141 * F,
350
 
       -0.000030518 * F, -0.000808716 * F,  0.003463745 * F, -0.014022827 * F,
351
 
        0.023422241 * F, -0.115921021 * F,  0.016510010 * F, -0.765029907 * F,
352
 
        1.111373901 * F,  0.376800537 * F,  0.143264771 * F,  0.040634155 * F,
353
 
        0.031005859 * F,  0.001693726 * F,  0.002578735 * F,  0.000213623 * F,
354
 
       -0.000030518 * F, -0.000885010 * F,  0.003417969 * F, -0.015121460 * F,
355
 
        0.021575928 * F, -0.120697021 * F,  0.001068115 * F, -0.791213989 * F,
356
 
        1.101211548 * F,  0.349868774 * F,  0.146362305 * F,  0.035552979 * F,
357
 
        0.030532837 * F,  0.001098633 * F,  0.002456665 * F,  0.000198364 * F,
358
 
       -0.000030518 * F, -0.000961304 * F,  0.003372192 * F, -0.016235352 * F,
359
 
        0.019531250 * F, -0.125259399 * F, -0.015228271 * F, -0.816864014 * F,
360
 
        1.089782715 * F,  0.323318481 * F,  0.148773193 * F,  0.030609131 * F,
361
 
        0.029937744 * F,  0.000549316 * F,  0.002349854 * F,  0.000167847 * F,
362
 
       -0.000030518 * F, -0.001037598 * F,  0.003280640 * F, -0.017349243 * F,
363
 
        0.017257690 * F, -0.129562378 * F, -0.032379150 * F, -0.841949463 * F,
364
 
        1.077117920 * F,  0.297210693 * F,  0.150497437 * F,  0.025817871 * F,
365
 
        0.029281616 * F,  0.000030518 * F,  0.002243042 * F,  0.000152588 * F,
366
 
       -0.000045776 * F, -0.001113892 * F,  0.003173828 * F, -0.018463135 * F,
367
 
        0.014801025 * F, -0.133590698 * F, -0.050354004 * F, -0.866363525 * F,
368
 
        1.063217163 * F,  0.271591187 * F,  0.151596069 * F,  0.021179199 * F,
369
 
        0.028533936 * F, -0.000442505 * F,  0.002120972 * F,  0.000137329 * F,
370
 
       -0.000045776 * F, -0.001205444 * F,  0.003051758 * F, -0.019577026 * F,
371
 
        0.012115479 * F, -0.137298584 * F, -0.069168091 * F, -0.890090942 * F,
372
 
        1.048156738 * F,  0.246505737 * F,  0.152069092 * F,  0.016708374 * F,
373
 
        0.027725220 * F, -0.000869751 * F,  0.002014160 * F,  0.000122070 * F,
374
 
       -0.000061035 * F, -0.001296997 * F,  0.002883911 * F, -0.020690918 * F,
375
 
        0.009231567 * F, -0.140670776 * F, -0.088775635 * F, -0.913055420 * F,
376
 
        1.031936646 * F,  0.221984863 * F,  0.151962280 * F,  0.012420654 * F,
377
 
        0.026840210 * F, -0.001266479 * F,  0.001907349 * F,  0.000106812 * F,
378
 
       -0.000061035 * F, -0.001388550 * F,  0.002700806 * F, -0.021789551 * F,
379
 
        0.006134033 * F, -0.143676758 * F, -0.109161377 * F, -0.935195923 * F,
380
 
        1.014617920 * F,  0.198059082 * F,  0.151306152 * F,  0.008316040 * F,
381
 
        0.025909424 * F, -0.001617432 * F,  0.001785278 * F,  0.000106812 * F,
382
 
       -0.000076294 * F, -0.001480103 * F,  0.002487183 * F, -0.022857666 * F,
383
 
        0.002822876 * F, -0.146255493 * F, -0.130310059 * F, -0.956481934 * F,
384
 
        0.996246338 * F,  0.174789429 * F,  0.150115967 * F,  0.004394531 * F,
385
 
        0.024932861 * F, -0.001937866 * F,  0.001693726 * F,  0.000091553 * F,
386
 
       -0.000076294 * F, -0.001586914 * F,  0.002227783 * F, -0.023910522 * F,
387
 
       -0.000686646 * F, -0.148422241 * F, -0.152206421 * F, -0.976852417 * F,
388
 
        0.976852417 * F,  0.152206421 * F,  0.148422241 * F,  0.000686646 * F,
389
 
        0.023910522 * F, -0.002227783 * F,  0.001586914 * F,  0.000076294 * F,
390
 
       -0.000091553 * F, -0.001693726 * F,  0.001937866 * F, -0.024932861 * F,
391
 
       -0.004394531 * F, -0.150115967 * F, -0.174789429 * F, -0.996246338 * F,
392
 
        0.956481934 * F,  0.130310059 * F,  0.146255493 * F, -0.002822876 * F,
393
 
        0.022857666 * F, -0.002487183 * F,  0.001480103 * F,  0.000076294 * F,
394
 
       -0.000106812 * F, -0.001785278 * F,  0.001617432 * F, -0.025909424 * F,
395
 
       -0.008316040 * F, -0.151306152 * F, -0.198059082 * F, -1.014617920 * F,
396
 
        0.935195923 * F,  0.109161377 * F,  0.143676758 * F, -0.006134033 * F,
397
 
        0.021789551 * F, -0.002700806 * F,  0.001388550 * F,  0.000061035 * F,
398
 
       -0.000106812 * F, -0.001907349 * F,  0.001266479 * F, -0.026840210 * F,
399
 
       -0.012420654 * F, -0.151962280 * F, -0.221984863 * F, -1.031936646 * F,
400
 
        0.913055420 * F,  0.088775635 * F,  0.140670776 * F, -0.009231567 * F,
401
 
        0.020690918 * F, -0.002883911 * F,  0.001296997 * F,  0.000061035 * F,
402
 
       -0.000122070 * F, -0.002014160 * F,  0.000869751 * F, -0.027725220 * F,
403
 
       -0.016708374 * F, -0.152069092 * F, -0.246505737 * F, -1.048156738 * F,
404
 
        0.890090942 * F,  0.069168091 * F,  0.137298584 * F, -0.012115479 * F,
405
 
        0.019577026 * F, -0.003051758 * F,  0.001205444 * F,  0.000045776 * F,
406
 
       -0.000137329 * F, -0.002120972 * F,  0.000442505 * F, -0.028533936 * F,
407
 
       -0.021179199 * F, -0.151596069 * F, -0.271591187 * F, -1.063217163 * F,
408
 
        0.866363525 * F,  0.050354004 * F,  0.133590698 * F, -0.014801025 * F,
409
 
        0.018463135 * F, -0.003173828 * F,  0.001113892 * F,  0.000045776 * F,
410
 
       -0.000152588 * F, -0.002243042 * F, -0.000030518 * F, -0.029281616 * F,
411
 
       -0.025817871 * F, -0.150497437 * F, -0.297210693 * F, -1.077117920 * F,
412
 
        0.841949463 * F,  0.032379150 * F,  0.129562378 * F, -0.017257690 * F,
413
 
        0.017349243 * F, -0.003280640 * F,  0.001037598 * F,  0.000030518 * F,
414
 
       -0.000167847 * F, -0.002349854 * F, -0.000549316 * F, -0.029937744 * F,
415
 
       -0.030609131 * F, -0.148773193 * F, -0.323318481 * F, -1.089782715 * F,
416
 
        0.816864014 * F,  0.015228271 * F,  0.125259399 * F, -0.019531250 * F,
417
 
        0.016235352 * F, -0.003372192 * F,  0.000961304 * F,  0.000030518 * F,
418
 
       -0.000198364 * F, -0.002456665 * F, -0.001098633 * F, -0.030532837 * F,
419
 
       -0.035552979 * F, -0.146362305 * F, -0.349868774 * F, -1.101211548 * F,
420
 
        0.791213989 * F, -0.001068115 * F,  0.120697021 * F, -0.021575928 * F,
421
 
        0.015121460 * F, -0.003417969 * F,  0.000885010 * F,  0.000030518 * F,
422
 
       -0.000213623 * F, -0.002578735 * F, -0.001693726 * F, -0.031005859 * F,
423
 
       -0.040634155 * F, -0.143264771 * F, -0.376800537 * F, -1.111373901 * F,
424
 
        0.765029907 * F, -0.016510010 * F,  0.115921021 * F, -0.023422241 * F,
425
 
        0.014022827 * F, -0.003463745 * F,  0.000808716 * F,  0.000030518 * F,
426
 
       -0.000244141 * F, -0.002685547 * F, -0.002334595 * F, -0.031387329 * F,
427
 
       -0.045837402 * F, -0.139450073 * F, -0.404083252 * F, -1.120223999 * F,
428
 
        0.738372803 * F, -0.031082153 * F,  0.110946655 * F, -0.025085449 * F,
429
 
        0.012939453 * F, -0.003479004 * F,  0.000747681 * F,  0.000015259 * F,
430
 
       -0.000259399 * F, -0.002792358 * F, -0.003005981 * F, -0.031661987 * F,
431
 
       -0.051132202 * F, -0.134887695 * F, -0.431655884 * F, -1.127746582 * F,
432
 
        0.711318970 * F, -0.044784546 * F,  0.105819702 * F, -0.026535034 * F,
433
 
        0.011886597 * F, -0.003479004 * F,  0.000686646 * F,  0.000015259 * F,
434
 
       -0.000289917 * F, -0.002899170 * F, -0.003723145 * F, -0.031814575 * F,
435
 
       -0.056533813 * F, -0.129577637 * F, -0.459472656 * F, -1.133926392 * F,
436
 
        0.683914185 * F, -0.057617188 * F,  0.100540161 * F, -0.027801514 * F,
437
 
        0.010848999 * F, -0.003463745 * F,  0.000625610 * F,  0.000015259 * F,
438
 
       -0.000320435 * F, -0.002990723 * F, -0.004486084 * F, -0.031845093 * F,
439
 
       -0.061996460 * F, -0.123474121 * F, -0.487472534 * F, -1.138763428 * F,
440
 
        0.656219482 * F, -0.069595337 * F,  0.095169067 * F, -0.028884888 * F,
441
 
        0.009841919 * F, -0.003433228 * F,  0.000579834 * F,  0.000015259 * F,
442
 
       -0.000366211 * F, -0.003082275 * F, -0.005294800 * F, -0.031738281 * F,
443
 
       -0.067520142 * F, -0.116577148 * F, -0.515609741 * F, -1.142211914 * F,
444
 
        0.628295898 * F, -0.080688477 * F,  0.089706421 * F, -0.029785156 * F,
445
 
        0.008865356 * F, -0.003387451 * F,  0.000534058 * F,  0.000015259 * F,
446
 
       -0.000396729 * F, -0.003173828 * F, -0.006118774 * F, -0.031478882 * F,
447
 
       -0.073059082 * F, -0.108856201 * F, -0.543823242 * F, -1.144287109 * F,
448
 
        0.600219727 * F, -0.090927124 * F,  0.084182739 * F, -0.030517578 * F,
449
 
        0.007919312 * F, -0.003326416 * F,  0.000473022 * F,  0.000015259 * F
450
 
    };
451
 
#undef F
452
 
    int i;
453
 
    float tmp, *v;
454
 
    const float *f;
455
 
 
456
 
    f = c;
457
 
 
458
 
    switch(b->pos)
459
 
    {
460
 
        case 0:
461
 
            v = b->actual;
462
 
            for (i=0; i<32; i++)
463
 
            {
464
 
                tmp = *f++ * *v;
465
 
                v += 15;
466
 
                tmp += *f++ * *v--;
467
 
                tmp += *f++ * *v--;
468
 
                tmp += *f++ * *v--;
469
 
                tmp += *f++ * *v--;
470
 
                tmp += *f++ * *v--;
471
 
                tmp += *f++ * *v--;
472
 
                tmp += *f++ * *v--;
473
 
                tmp += *f++ * *v--;
474
 
                tmp += *f++ * *v--;
475
 
                tmp += *f++ * *v--;
476
 
                tmp += *f++ * *v--;
477
 
                tmp += *f++ * *v--;
478
 
                tmp += *f++ * *v--;
479
 
                tmp += *f++ * *v--;
480
 
                if ((tmp += *f++ * *v) > 32767)
481
 
                {
482
 
                    /* ceiling saturation */
483
 
                    **pcm = 0x7FFF;
484
 
                }
485
 
                else if (tmp < -32768)
486
 
                {
487
 
                    /* floor saturation */
488
 
                    **pcm = 0x8000;
489
 
                }
490
 
                else
491
 
                {
492
 
                    **pcm = (s16)tmp;
493
 
                }
494
 
                *pcm += jump;
495
 
                v += 15;
496
 
            }
497
 
            break;
498
 
        case 1:
499
 
            v = b->actual + 1;
500
 
            for (i=0; i<32; i++)
501
 
            {
502
 
                tmp = *f++ * *v--;
503
 
                tmp += *f++ * *v;
504
 
                v += 15;
505
 
                tmp += *f++ * *v--;
506
 
                tmp += *f++ * *v--;
507
 
                tmp += *f++ * *v--;
508
 
                tmp += *f++ * *v--;
509
 
                tmp += *f++ * *v--;
510
 
                tmp += *f++ * *v--;
511
 
                tmp += *f++ * *v--;
512
 
                tmp += *f++ * *v--;
513
 
                tmp += *f++ * *v--;
514
 
                tmp += *f++ * *v--;
515
 
                tmp += *f++ * *v--;
516
 
                tmp += *f++ * *v--;
517
 
                tmp += *f++ * *v--;
518
 
                if ((tmp += *f++ * *v) > 32767)
519
 
                {
520
 
                    **pcm = 0x7FFF;
521
 
                }
522
 
                else if (tmp < -32768)
523
 
                {
524
 
                    **pcm = 0x8000;
525
 
                }
526
 
                else
527
 
                {
528
 
                    **pcm = (s16)tmp;
529
 
                }
530
 
                *pcm += jump;
531
 
                v += 15;
532
 
            }
533
 
            break;
534
 
        case 2:
535
 
            v = b->actual + 2;
536
 
            for (i=0; i<32; i++)
537
 
            {
538
 
                tmp = *f++ * *v--;
539
 
                tmp += *f++ * *v--;
540
 
                tmp += *f++ * *v;
541
 
                v += 15;
542
 
                tmp += *f++ * *v--;
543
 
                tmp += *f++ * *v--;
544
 
                tmp += *f++ * *v--;
545
 
                tmp += *f++ * *v--;
546
 
                tmp += *f++ * *v--;
547
 
                tmp += *f++ * *v--;
548
 
                tmp += *f++ * *v--;
549
 
                tmp += *f++ * *v--;
550
 
                tmp += *f++ * *v--;
551
 
                tmp += *f++ * *v--;
552
 
                tmp += *f++ * *v--;
553
 
                tmp += *f++ * *v--;
554
 
                if ((tmp += *f++ * *v) > 32767)
555
 
                {
556
 
                    **pcm = 0x7FFF;
557
 
                }
558
 
                else if (tmp < -32768)
559
 
                {
560
 
                    **pcm = 0x8000;
561
 
                }
562
 
                else
563
 
                {
564
 
                    **pcm = (s16)tmp;
565
 
                }
566
 
                *pcm += jump;
567
 
                v += 15;
568
 
            }
569
 
            break;
570
 
        case 3:
571
 
            v = b->actual + 3;
572
 
            for (i=0; i<32; i++)
573
 
            {
574
 
                tmp = *f++ * *v--;
575
 
                tmp += *f++ * *v--;
576
 
                tmp += *f++ * *v--;
577
 
                tmp += *f++ * *v;
578
 
                v += 15;
579
 
                tmp += *f++ * *v--;
580
 
                tmp += *f++ * *v--;
581
 
                tmp += *f++ * *v--;
582
 
                tmp += *f++ * *v--;
583
 
                tmp += *f++ * *v--;
584
 
                tmp += *f++ * *v--;
585
 
                tmp += *f++ * *v--;
586
 
                tmp += *f++ * *v--;
587
 
                tmp += *f++ * *v--;
588
 
                tmp += *f++ * *v--;
589
 
                tmp += *f++ * *v--;
590
 
                if ((tmp += *f++ * *v) > 32767)
591
 
                {
592
 
                    **pcm = 0x7FFF;
593
 
                }
594
 
                else if (tmp < -32768)
595
 
                {
596
 
                    **pcm = 0x8000;
597
 
                }
598
 
                else
599
 
                {
600
 
                    **pcm = (s16)tmp;
601
 
                }
602
 
                *pcm += jump;
603
 
                v += 15;
604
 
            }
605
 
            break;
606
 
        case 4:
607
 
            v = b->actual + 4;
608
 
            for (i=0; i<32; i++)
609
 
            {
610
 
                tmp = *f++ * *v--;
611
 
                tmp += *f++ * *v--;
612
 
                tmp += *f++ * *v--;
613
 
                tmp += *f++ * *v--;
614
 
                tmp += *f++ * *v;
615
 
                v += 15;
616
 
                tmp += *f++ * *v--;
617
 
                tmp += *f++ * *v--;
618
 
                tmp += *f++ * *v--;
619
 
                tmp += *f++ * *v--;
620
 
                tmp += *f++ * *v--;
621
 
                tmp += *f++ * *v--;
622
 
                tmp += *f++ * *v--;
623
 
                tmp += *f++ * *v--;
624
 
                tmp += *f++ * *v--;
625
 
                tmp += *f++ * *v--;
626
 
                if ((tmp += *f++ * *v) > 32767)
627
 
                {
628
 
                    **pcm = 0x7FFF;
629
 
                }
630
 
                else if (tmp < -32768)
631
 
                {
632
 
                    **pcm = 0x8000;
633
 
                }
634
 
                else
635
 
                {
636
 
                    **pcm = (s16)tmp;
637
 
                }
638
 
                *pcm += jump;
639
 
                v += 15;
640
 
            }
641
 
            break;
642
 
        case 5:
643
 
            v = b->actual + 5;
644
 
            for (i=0; i<32; i++)
645
 
            {
646
 
                tmp = *f++ * *v--;
647
 
                tmp += *f++ * *v--;
648
 
                tmp += *f++ * *v--;
649
 
                tmp += *f++ * *v--;
650
 
                tmp += *f++ * *v--;
651
 
                tmp += *f++ * *v;
652
 
                v += 15;
653
 
                tmp += *f++ * *v--;
654
 
                tmp += *f++ * *v--;
655
 
                tmp += *f++ * *v--;
656
 
                tmp += *f++ * *v--;
657
 
                tmp += *f++ * *v--;
658
 
                tmp += *f++ * *v--;
659
 
                tmp += *f++ * *v--;
660
 
                tmp += *f++ * *v--;
661
 
                tmp += *f++ * *v--;
662
 
                if ((tmp += *f++ * *v) > 32767)
663
 
                {
664
 
                    **pcm = 0x7FFF;
665
 
                }
666
 
                else if (tmp < -32768)
667
 
                {
668
 
                    **pcm = 0x8000;
669
 
                }
670
 
                else
671
 
                {
672
 
                    **pcm = (s16)tmp;
673
 
                }
674
 
                *pcm += jump;
675
 
                v += 15;
676
 
            }
677
 
            break;
678
 
        case 6:
679
 
            v = b->actual + 6;
680
 
            for (i=0; i<32; i++)
681
 
            {
682
 
                tmp = *f++ * *v--;
683
 
                tmp += *f++ * *v--;
684
 
                tmp += *f++ * *v--;
685
 
                tmp += *f++ * *v--;
686
 
                tmp += *f++ * *v--;
687
 
                tmp += *f++ * *v--;
688
 
                tmp += *f++ * *v;
689
 
                v += 15;
690
 
                tmp += *f++ * *v--;
691
 
                tmp += *f++ * *v--;
692
 
                tmp += *f++ * *v--;
693
 
                tmp += *f++ * *v--;
694
 
                tmp += *f++ * *v--;
695
 
                tmp += *f++ * *v--;
696
 
                tmp += *f++ * *v--;
697
 
                tmp += *f++ * *v--;
698
 
                if ((tmp += *f++ * *v) > 32767)
699
 
                {
700
 
                    **pcm = 0x7FFF;
701
 
                }
702
 
                else if (tmp < -32768)
703
 
                {
704
 
                    **pcm = 0x8000;
705
 
                }
706
 
                else
707
 
                {
708
 
                    **pcm = (s16)tmp;
709
 
                }
710
 
                *pcm += jump;
711
 
                v += 15;
712
 
            }
713
 
            break;
714
 
        case 7:
715
 
            v = b->actual + 7;
716
 
            for (i=0; i<32; i++)
717
 
            {
718
 
                tmp = *f++ * *v--;
719
 
                tmp += *f++ * *v--;
720
 
                tmp += *f++ * *v--;
721
 
                tmp += *f++ * *v--;
722
 
                tmp += *f++ * *v--;
723
 
                tmp += *f++ * *v--;
724
 
                tmp += *f++ * *v--;
725
 
                tmp += *f++ * *v;
726
 
                v += 15;
727
 
                tmp += *f++ * *v--;
728
 
                tmp += *f++ * *v--;
729
 
                tmp += *f++ * *v--;
730
 
                tmp += *f++ * *v--;
731
 
                tmp += *f++ * *v--;
732
 
                tmp += *f++ * *v--;
733
 
                tmp += *f++ * *v--;
734
 
                if ((tmp += *f++ * *v) > 32767)
735
 
                {
736
 
                    **pcm = 0x7FFF;
737
 
                }
738
 
                else if (tmp < -32768)
739
 
                {
740
 
                    **pcm = 0x8000;
741
 
                }
742
 
                else
743
 
                {
744
 
                     **pcm = (s16)tmp;
745
 
                }
746
 
                *pcm += jump;
747
 
                v += 15;
748
 
            }
749
 
            break;
750
 
        case 8:
751
 
            v = b->actual + 8;
752
 
            for (i=0; i<32; i++)
753
 
            {
754
 
                tmp = *f++ * *v--;
755
 
                tmp += *f++ * *v--;
756
 
                tmp += *f++ * *v--;
757
 
                tmp += *f++ * *v--;
758
 
                tmp += *f++ * *v--;
759
 
                tmp += *f++ * *v--;
760
 
                tmp += *f++ * *v--;
761
 
                tmp += *f++ * *v--;
762
 
                tmp += *f++ * *v;
763
 
                v += 15;
764
 
                tmp += *f++ * *v--;
765
 
                tmp += *f++ * *v--;
766
 
                tmp += *f++ * *v--;
767
 
                tmp += *f++ * *v--;
768
 
                tmp += *f++ * *v--;
769
 
                tmp += *f++ * *v--;
770
 
                if ((tmp += *f++ * *v) > 32767)
771
 
                {
772
 
                    **pcm = 0x7FFF;
773
 
                }
774
 
                else if (tmp < -32768)
775
 
                {
776
 
                    **pcm = 0x8000;
777
 
                }
778
 
                else
779
 
                {
780
 
                    **pcm = (s16)tmp;
781
 
                }
782
 
                *pcm += jump;
783
 
                v += 15;
784
 
            }
785
 
            break;
786
 
        case 9:
787
 
            v = b->actual + 9;
788
 
            for (i=0; i<32; i++)
789
 
            {
790
 
                tmp = *f++ * *v--;
791
 
                tmp += *f++ * *v--;
792
 
                tmp += *f++ * *v--;
793
 
                tmp += *f++ * *v--;
794
 
                tmp += *f++ * *v--;
795
 
                tmp += *f++ * *v--;
796
 
                tmp += *f++ * *v--;
797
 
                tmp += *f++ * *v--;
798
 
                tmp += *f++ * *v--;
799
 
                tmp += *f++ * *v;
800
 
                v += 15;
801
 
                tmp += *f++ * *v--;
802
 
                tmp += *f++ * *v--;
803
 
                tmp += *f++ * *v--;
804
 
                tmp += *f++ * *v--;
805
 
                tmp += *f++ * *v--;
806
 
                if ((tmp += *f++ * *v) > 32767)
807
 
                {
808
 
                    **pcm = 0x7FFF;
809
 
                }
810
 
                else if (tmp < -32768)
811
 
                {
812
 
                    **pcm = 0x8000;
813
 
                }
814
 
                else
815
 
                {
816
 
                    **pcm = (s16)tmp;
817
 
                } 
818
 
                *pcm += jump;
819
 
                v += 15;
820
 
            }
821
 
            break;
822
 
        case 10:
823
 
            v = b->actual + 10;
824
 
            for (i=0; i<32; i++)
825
 
            {
826
 
                tmp = *f++ * *v--;
827
 
                tmp += *f++ * *v--;
828
 
                tmp += *f++ * *v--;
829
 
                tmp += *f++ * *v--;
830
 
                tmp += *f++ * *v--;
831
 
                tmp += *f++ * *v--;
832
 
                tmp += *f++ * *v--;
833
 
                tmp += *f++ * *v--;
834
 
                tmp += *f++ * *v--;
835
 
                tmp += *f++ * *v--;
836
 
                tmp += *f++ * *v;
837
 
                v += 15;
838
 
                tmp += *f++ * *v--;
839
 
                tmp += *f++ * *v--;
840
 
                tmp += *f++ * *v--;
841
 
                tmp += *f++ * *v--;
842
 
                if ((tmp += *f++ * *v) > 32767)
843
 
                {
844
 
                    **pcm = 0x7FFF;
845
 
                }
846
 
                else if (tmp < -32768)
847
 
                {    
848
 
                    **pcm = 0x8000;
849
 
                }
850
 
                else
851
 
                {
852
 
                    **pcm = (s16)tmp;
853
 
                }
854
 
                *pcm += jump;
855
 
                v += 15;
856
 
            }
857
 
            break;
858
 
        case 11:
859
 
            v = b->actual + 11;
860
 
            for (i=0; i<32; i++)
861
 
            {
862
 
                tmp = *f++ * *v--;
863
 
                tmp += *f++ * *v--;
864
 
                tmp += *f++ * *v--;
865
 
                tmp += *f++ * *v--;
866
 
                tmp += *f++ * *v--;
867
 
                tmp += *f++ * *v--;
868
 
                tmp += *f++ * *v--;
869
 
                tmp += *f++ * *v--;
870
 
                tmp += *f++ * *v--;
871
 
                tmp += *f++ * *v--;
872
 
                tmp += *f++ * *v--;
873
 
                tmp += *f++ * *v;
874
 
                v += 15;
875
 
                tmp += *f++ * *v--;
876
 
                tmp += *f++ * *v--;
877
 
                tmp += *f++ * *v--;
878
 
                if ((tmp += *f++ * *v) > 32767)
879
 
                {
880
 
                    **pcm = 0x7FFF;
881
 
                }
882
 
                else if (tmp < -32768)
883
 
                {
884
 
                    **pcm = 0x8000;
885
 
                }
886
 
                else
887
 
                {
888
 
                    **pcm = (s16)tmp;
889
 
                }
890
 
                *pcm += jump;
891
 
                v += 15;
892
 
            }
893
 
            break;
894
 
        case 12:
895
 
            v = b->actual + 12;
896
 
            for (i=0; i<32; i++)
897
 
            {
898
 
                tmp = *f++ * *v--;
899
 
                tmp += *f++ * *v--;
900
 
                tmp += *f++ * *v--;
901
 
                tmp += *f++ * *v--;
902
 
                tmp += *f++ * *v--;
903
 
                tmp += *f++ * *v--;
904
 
                tmp += *f++ * *v--;
905
 
                tmp += *f++ * *v--;
906
 
                tmp += *f++ * *v--;
907
 
                tmp += *f++ * *v--;
908
 
                tmp += *f++ * *v--;
909
 
                tmp += *f++ * *v--;
910
 
                tmp += *f++ * *v;
911
 
                v += 15;
912
 
                tmp += *f++ * *v--;
913
 
                tmp += *f++ * *v--;
914
 
                if ((tmp += *f++ * *v) > 32767)
915
 
                {
916
 
                    **pcm = 0x7FFF;
917
 
                }
918
 
                else if (tmp < -32768)
919
 
                {
920
 
                    **pcm = 0x8000;
921
 
                }
922
 
                else
923
 
                {
924
 
                    **pcm = (s16)tmp;
925
 
                }
926
 
                *pcm += jump;
927
 
                v += 15;
928
 
            }
929
 
            break;
930
 
        case 13:
931
 
            v = b->actual + 13;
932
 
            for (i=0; i<32; i++)
933
 
            {
934
 
                tmp = *f++ * *v--;
935
 
                tmp += *f++ * *v--;
936
 
                tmp += *f++ * *v--;
937
 
                tmp += *f++ * *v--;
938
 
                tmp += *f++ * *v--;
939
 
                tmp += *f++ * *v--;
940
 
                tmp += *f++ * *v--;
941
 
                tmp += *f++ * *v--;
942
 
                tmp += *f++ * *v--;
943
 
                tmp += *f++ * *v--;
944
 
                tmp += *f++ * *v--;
945
 
                tmp += *f++ * *v--;
946
 
                tmp += *f++ * *v--;
947
 
                tmp += *f++ * *v;
948
 
                v += 15;
949
 
                tmp += *f++ * *v--;
950
 
                if ((tmp += *f++ * *v) > 32767)
951
 
                {
952
 
                    **pcm = 0x7FFF;
953
 
                }
954
 
                else if (tmp < -32768)
955
 
                {
956
 
                    **pcm = 0x8000;
957
 
                }
958
 
                else
959
 
                {
960
 
                    **pcm = (s16)tmp;
961
 
                }
962
 
                *pcm += jump;
963
 
                v += 15;
964
 
            }
965
 
            break;
966
 
        case 14:
967
 
            v = b->actual + 14;
968
 
            for (i=0; i<32; i++)
969
 
            {
970
 
                tmp = *f++ * *v--;
971
 
                tmp += *f++ * *v--;
972
 
                tmp += *f++ * *v--;
973
 
                tmp += *f++ * *v--;
974
 
                tmp += *f++ * *v--;
975
 
                tmp += *f++ * *v--;
976
 
                tmp += *f++ * *v--;
977
 
                tmp += *f++ * *v--;
978
 
                tmp += *f++ * *v--;
979
 
                tmp += *f++ * *v--;
980
 
                tmp += *f++ * *v--;
981
 
                tmp += *f++ * *v--;
982
 
                tmp += *f++ * *v--;
983
 
                tmp += *f++ * *v--;
984
 
                tmp += *f++ * *v;
985
 
                v += 15;
986
 
                if ((tmp += *f++ * *v) > 32767)
987
 
                {
988
 
                    **pcm = 0x7FFF;
989
 
                }
990
 
                else if (tmp < -32768)
991
 
                {
992
 
                    **pcm = 0x8000;
993
 
                }
994
 
                else
995
 
                {
996
 
                    **pcm = (s16)tmp;
997
 
                }
998
 
                *pcm += jump;
999
 
                v += 15;
1000
 
            }
1001
 
            break;
1002
 
        case 15:
1003
 
            v = b->actual + 15;
1004
 
            for (i=0; i<32; i++)
1005
 
            {
1006
 
                tmp = *f++ * *v--;
1007
 
                tmp += *f++ * *v--;
1008
 
                tmp += *f++ * *v--;
1009
 
                tmp += *f++ * *v--;
1010
 
                tmp += *f++ * *v--;
1011
 
                tmp += *f++ * *v--;
1012
 
                tmp += *f++ * *v--;
1013
 
                tmp += *f++ * *v--;
1014
 
                tmp += *f++ * *v--;
1015
 
                tmp += *f++ * *v--;
1016
 
                tmp += *f++ * *v--;
1017
 
                tmp += *f++ * *v--;
1018
 
                tmp += *f++ * *v--;
1019
 
                tmp += *f++ * *v--;
1020
 
                tmp += *f++ * *v--;
1021
 
                if ((tmp += *f++ * *v) > 32767)
1022
 
                {
1023
 
                    **pcm = 0x7FFF;
1024
 
                }
1025
 
                else if (tmp < -32768)
1026
 
                {
1027
 
                    **pcm = 0x8000;
1028
 
                }
1029
 
                else
1030
 
                {
1031
 
                    **pcm = (s16)tmp;
1032
 
                }
1033
 
                *pcm += jump;
1034
 
                v += 31;
1035
 
            }
1036
 
            break;
1037
 
    }
1038
 
 
1039
 
    /* Set the next position in the filter bank */
1040
 
    b->pos++;
1041
 
    b->pos &= 15;
1042
 
    b->actual = (b->actual == b->v1 ? b->v2 : b->v1);
1043
 
}