Remove unused tests from configure.ac
[speexdsp.git] / tmv / filters_tm.h
1 #include <ops/custom_defs.h>\r
2 #include "profile_tm.h"\r
3 \r
4 #ifdef FIXED_POINT\r
5 \r
6 #define iadd(a,b)       ((a) + (b))\r
7 \r
8 #define OVERRIDE_BW_LPC\r
9 void bw_lpc(Int16 gamma, const Int16 *lpc_in, Int16 *lpc_out, int order)\r
10 {\r
11         register int tmp, g, i;\r
12         \r
13         TMDEBUG_ALIGNMEM(lpc_in);\r
14         TMDEBUG_ALIGNMEM(lpc_out);\r
15 \r
16         BWLPC_START();\r
17 \r
18         tmp = g = gamma;\r
19         for ( i=0 ; i<4 ; i+=2,lpc_out+=4 )\r
20         {       register int in10, y1, y0, y10;\r
21                 register int in32, y3, y2, y32;\r
22 \r
23                 in10 = ld32x(lpc_in,i);\r
24                 y0       = ((tmp * sex16(in10)) + 16384) >> 15;\r
25                 tmp  = ((tmp * g) + 16384) >> 15;\r
26                 y1       = ((tmp * asri(16,in10)) + 16384) >> 15;\r
27                 tmp  = ((tmp * g) + 16384) >> 15;\r
28                 y10  =  pack16lsb(y1,y0);\r
29                 st32(lpc_out,y10);\r
30 \r
31                 in32 = ld32x(lpc_in,i+1);\r
32                 y2       = ((tmp * sex16(in32)) + 16384) >> 15;\r
33                 tmp  = ((tmp * g) + 16384) >> 15;\r
34                 y3       = ((tmp * asri(16,in32)) + 16384) >> 15;\r
35                 tmp  = ((tmp * g) + 16384) >> 15;\r
36                 y32  =  pack16lsb(y3,y2);\r
37                 st32d(4,lpc_out,y32);\r
38         }\r
39 \r
40         if ( order == 10 )\r
41         {       register int in10, y1, y0, y10;\r
42                 \r
43                 in10 = ld32x(lpc_in,i);\r
44                 y0       = ((tmp * sex16(in10)) + 16384) >> 15;\r
45                 tmp  = ((tmp * g) + 16384) >> 15;\r
46                 y1       = ((tmp * asri(16,in10)) + 16384) >> 15;\r
47                 tmp  = ((tmp * g) + 16384) >> 15;\r
48                 y10  =  pack16lsb(y1,y0);\r
49                 st32(lpc_out,y10);\r
50         }\r
51 \r
52         BWLPC_STOP();\r
53 }\r
54 \r
55 \r
56 #define OVERRIDE_HIGHPASS\r
57 void highpass(const Int16 *x, Int16 *y, int len, int filtID, Int32 *mem)\r
58 {\r
59         const Int16 Pcoef[5][3] = {{16384, -31313, 14991}, {16384, -31569, 15249}, {16384, -31677, 15328}, {16384, -32313, 15947}, {16384, -22446, 6537}};\r
60         const Int16 Zcoef[5][3] = {{15672, -31344, 15672}, {15802, -31601, 15802}, {15847, -31694, 15847}, {16162, -32322, 16162}, {14418, -28836, 14418}};\r
61         register int i;\r
62         register int den1, den2, num0, num1, num2, den11, den22, mem0, mem1;\r
63    \r
64         TMDEBUG_ALIGNMEM(mem);\r
65 \r
66         HIGHPASS_START();\r
67 \r
68         filtID = imin(4, filtID);\r
69 \r
70         den1 = -Pcoef[filtID][1];\r
71         den2 = -Pcoef[filtID][2];\r
72         num0 = Zcoef[filtID][0];\r
73         num1 = Zcoef[filtID][1];\r
74         num2 = Zcoef[filtID][2];\r
75         den11 = den1 << 1;\r
76         den22 = den2 << 1;\r
77         mem0 = mem[0];\r
78         mem1 = mem[1];\r
79         \r
80 #if (TM_UNROLL && TM_UNROLL_HIGHPASS)\r
81 #pragma TCS_unroll=4\r
82 #pragma TCS_unrollexact=1\r
83 #endif\r
84         for ( i=0 ; i<len ; ++i )\r
85         {\r
86                 register int yi;\r
87                 register int vout, xi, vout_i, vout_d;\r
88                         \r
89                 xi = x[i];\r
90 \r
91                 vout    = num0 * xi + mem0;\r
92                 vout_i  = vout >> 15;\r
93                 vout_d  = vout & 0x7FFF;\r
94                 yi              = iclipi(PSHR32(vout,14),32767);\r
95                 mem0    = (mem1 + num1 * xi) + (den11 * vout_i) + (((den1 * vout_d) >> 15) << 1);\r
96                 mem1    = (num2 * xi) + (den22 * vout_i) + (((den2 *  vout_d) >> 15) << 1);\r
97                 \r
98                 y[i] = yi;\r
99         }\r
100 #if (TM_UNROLL && TM_UNROLL_HIGHPASS)\r
101 #pragma TCS_unrollexact=0\r
102 #pragma TCS_unroll=0\r
103 #endif\r
104 \r
105         mem[0] = mem0;\r
106         mem[1] = mem1;\r
107 \r
108         HIGHPASS_STOP();\r
109 }\r
110 \r
111 \r
112 #define OVERRIDE_SIGNALMUL\r
113 void signal_mul(const Int32 *x, Int32 *y, Int32 scale, int len)\r
114 {\r
115         register int i, scale_i, scale_d;\r
116    \r
117         SIGNALMUL_START();\r
118 \r
119         scale_i = scale >> 14;\r
120         scale_d = scale & 0x3FFF;\r
121 \r
122 #if (TM_UNROLL && TM_UNROLL_SIGNALMUL)\r
123 #pragma TCS_unroll=4\r
124 #pragma TCS_unrollexact=1\r
125 #endif\r
126         for ( i=0 ; i<len ; ++i)\r
127         {\r
128                 register int xi;\r
129 \r
130                 xi = x[i] >> 7;\r
131 \r
132                 y[i] = ((xi * scale_i + ((xi * scale_d) >> 14)) << 7);\r
133                         \r
134         }\r
135 #if (TM_UNROLL && TM_UNROLL_SIGNALMUL)\r
136 #pragma TCS_unrollexact=0\r
137 #pragma TCS_unroll=0\r
138 #endif\r
139 \r
140         SIGNALMUL_STOP();\r
141 }\r
142 \r
143 #define OVERRIDE_SIGNALDIV\r
144 void signal_div(const Int16 *x, Int16 *y, Int32 scale, int len)\r
145 {\r
146         register int i;\r
147    \r
148         SIGNALDIV_START();\r
149 \r
150         if (scale > SHL32(EXTEND32(SIG_SCALING), 8))\r
151         {\r
152                 register int scale_1;\r
153                 scale   = PSHR32(scale, SIG_SHIFT);\r
154                 scale_1 = DIV32_16(SHL32(EXTEND32(SIG_SCALING),7),scale);\r
155 #if (TM_UNROLL && TM_UNROLL_SIGNALDIV)\r
156 #pragma TCS_unroll=4\r
157 #pragma TCS_unrollexact=1\r
158 #endif\r
159                 for ( i=0 ; i<len ; ++i)\r
160                 {\r
161                         y[i] = MULT16_16_P15(scale_1, x[i]);\r
162                 }\r
163 #if (TM_UNROLL && TM_UNROLL_SIGNALDIV)\r
164 #pragma TCS_unrollexact=0\r
165 #pragma TCS_unroll=0\r
166 #endif\r
167         } else if (scale > SHR32(EXTEND32(SIG_SCALING), 2)) {\r
168       \r
169                 register int scale_1;\r
170                 scale   = PSHR32(scale, SIG_SHIFT-5);\r
171                 scale_1 = DIV32_16(SHL32(EXTEND32(SIG_SCALING),3),scale);\r
172 #if (TM_UNROLL && TM_UNROLL_SIGNALDIV)\r
173 #pragma TCS_unroll=4\r
174 #pragma TCS_unrollexact=1\r
175 #endif\r
176                 for (i=0;i<len;i++)\r
177                 {\r
178                         y[i] = PSHR32(MULT16_16(scale_1, SHL16(x[i],2)),8);\r
179                 }\r
180 #if (TM_UNROLL && TM_UNROLL_SIGNALDIV)\r
181 #pragma TCS_unrollexact=0\r
182 #pragma TCS_unroll=0\r
183 #endif\r
184         } else {\r
185                 \r
186                 register int scale_1;\r
187                 scale = PSHR32(scale, SIG_SHIFT-7);\r
188                 scale = imax(5,scale);\r
189                 scale_1 = DIV32_16(SHL32(EXTEND32(SIG_SCALING),3),scale);\r
190 \r
191 #if (TM_UNROLL && TM_UNROLL_SIGNALDIV)\r
192 #pragma TCS_unroll=4\r
193 #pragma TCS_unrollexact=1\r
194 #endif\r
195                 for (i=0;i<len;i++)\r
196                 {\r
197                          y[i] = PSHR32(MULT16_16(scale_1, SHL16(x[i],2)),6);\r
198                 }\r
199 #if (TM_UNROLL && TM_UNROLL_SIGNALDIV)\r
200 #pragma TCS_unrollexact=0\r
201 #pragma TCS_unroll=0\r
202 #endif\r
203         }\r
204 \r
205         SIGNALMUL_STOP();\r
206 }\r
207 \r
208 \r
209 #define OVERRIDE_COMPUTE_RMS\r
210 Int16 compute_rms(const Int32 *x, int len)\r
211 {\r
212         register int i;\r
213         register int sum=0;\r
214         register int max_val=1;\r
215         register int sig_shift;\r
216         \r
217         TMDEBUG_ALIGNMEM(x);\r
218 \r
219         for ( i=0 ; i<len ; i+=4 )\r
220         {\r
221                 register int tmp0, tmp1, tmp2, tmp3;\r
222 \r
223                 tmp0 = ld32x(x,i);\r
224                 tmp1 = ld32x(x,i+1);\r
225 \r
226                 tmp0 = iabs(tmp0);\r
227                 tmp1 = iabs(tmp1);\r
228 \r
229                 tmp2 = ld32x(x,i+2);\r
230                 tmp3 = ld32x(x,i+3);\r
231 \r
232                 tmp2 = iabs(tmp2);\r
233                 tmp3 = iabs(tmp3);\r
234 \r
235                 tmp0 = imax(tmp0, tmp1);\r
236                 max_val = imax(max_val, tmp0); \r
237                 tmp2 = imax(tmp2, tmp3);                \r
238                 max_val = imax(max_val, tmp2);\r
239         }\r
240 \r
241         sig_shift = 0;\r
242         while ( max_val>16383 )\r
243         {       sig_shift++;\r
244                 max_val >>= 1;\r
245         }\r
246 \r
247 \r
248         for ( i=0 ; i<len ; i+=4 )\r
249         {\r
250                 register int acc0, acc1, acc2;\r
251 \r
252                 acc0 =  pack16lsb(ld32x(x,i) >> sig_shift, ld32x(x,i+1) >> sig_shift);\r
253                 acc1 =  pack16lsb(ld32x(x,i+2) >> sig_shift, ld32x(x,i+3) >> sig_shift);\r
254                 acc2 =  ifir16(acc0,acc0) + ifir16(acc1, acc1);\r
255                 sum      += acc2 >> 6;\r
256         }\r
257    \r
258    return EXTRACT16(PSHR32(SHL32(EXTEND32(spx_sqrt(DIV32(sum,len))),(sig_shift+3)),SIG_SHIFT));\r
259 }\r
260 \r
261 #define OVERRIDE_COMPUTE_RMS16\r
262 Int16 compute_rms16(const Int16 *x, int len)\r
263 {\r
264         register int max_val, i;\r
265         \r
266         COMPUTERMS16_START();\r
267         \r
268         max_val = 10;\r
269 \r
270 #if 0\r
271 \r
272         {\r
273                 register int len2 = len >> 1;\r
274 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
275 #pragma TCS_unroll=2\r
276 #pragma TCS_unrollexact=1\r
277 #endif\r
278                 for ( i=0 ; i<len2 ; i+=2 )\r
279                 {\r
280                         register int x10, x32;\r
281 \r
282                         x10 = ld32x(x,i);\r
283                         x32 = ld32x(x,i+1);\r
284                          \r
285                         x10 = dspidualabs(x10);\r
286                         x32 = dspidualabs(x32);\r
287                         \r
288                         x10 = imax(sex16(x10), asri(16,x10));\r
289                         x32 = imax(sex16(x32), asri(16,x32));\r
290                         \r
291                         max_val = imax(max_val,x10);\r
292                         max_val = imax(max_val,x32);\r
293                 }\r
294 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
295 #pragma TCS_unrollexact=0\r
296 #pragma TCS_unroll=0\r
297 #endif\r
298                 if (max_val>16383)\r
299                 {\r
300                         register int sum = 0;\r
301 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
302 #pragma TCS_unroll=2\r
303 #pragma TCS_unrollexact=1\r
304 #endif\r
305                         for ( i=0 ; i<len_2; i+=2 )\r
306                         {\r
307                                 register int x10, x32;\r
308                                 register int acc0, acc1;\r
309 \r
310                                 x10 = ld32x(x,i);\r
311                                 x32 = ld32x(x,i+1);\r
312                                 \r
313                                 x10 = dualasr(x10,1);\r
314                                 x32 = dualasr(x32,1);\r
315 \r
316                                 acc0 = ifir16(x10,x10);\r
317                                 acc1 = ifir16(x32,x32);\r
318                                 sum  += (acc0 + acc1) >> 6;\r
319                         }\r
320 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
321 #pragma TCS_unrollexact=0\r
322 #pragma TCS_unroll=0\r
323 #endif\r
324                         COMPUTERMS16_STOP();\r
325                         return spx_sqrt(sum/len) << 4;\r
326                 } else \r
327                 {\r
328                         register int sig_shift;\r
329                         register int sum=0;\r
330 \r
331                         sig_shift = mux(max_val < 8192, 1, 0);\r
332                         sig_shift = mux(max_val < 4096, 2, sig_shift);\r
333                         sig_shift = mux(max_val < 2048, 3, sig_shift);\r
334 \r
335 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
336 #pragma TCS_unroll=2\r
337 #pragma TCS_unrollexact=1\r
338 #endif\r
339                         for ( i=0 ; i<len_2 ; i+=2 )\r
340                         {\r
341                                 register int x10, x32;\r
342                                 register int acc0, acc1;\r
343 \r
344                                 x10 = ld32x(x,i);\r
345                                 x32 = ld32x(x,i+1);\r
346 \r
347                                 x10 = dualasl(x10,sig_shift);\r
348                                 x32 = dualasl(x32,sig_shift);\r
349                                 \r
350                                 acc0 = ifir16(x10,x10);\r
351                                 acc1 = ifir16(x32,x32);\r
352                                 sum  += (acc0 + acc1) >> 6;\r
353                         }\r
354 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
355 #pragma TCS_unrollexact=0\r
356 #pragma TCS_unroll=0\r
357 #endif\r
358                         COMPUTERMS16_STOP();\r
359                         return spx_sqrt(sum/len) << (3 - sig_shift);  \r
360                 }\r
361         }\r
362 \r
363 #else\r
364         {\r
365 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
366 #pragma TCS_unroll=4\r
367 #pragma TCS_unrollexact=1\r
368 #endif\r
369                 for ( i=0 ; i<len ; ++i )\r
370                 {\r
371                         register int xi;\r
372 \r
373                         xi = x[i];\r
374                         xi = iabs(xi);\r
375                         max_val = imax(xi,max_val);\r
376                 }\r
377 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
378 #pragma TCS_unrollexact=0\r
379 #pragma TCS_unroll=0\r
380 #endif\r
381                 if (max_val>16383)\r
382                 {\r
383                         register int sum = 0;\r
384 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
385 #pragma TCS_unroll=2\r
386 #pragma TCS_unrollexact=1\r
387 #endif\r
388                         for ( i=0 ; i<len ; i+=4 )\r
389                         {\r
390                                 register int x10, x32;\r
391                                 register int acc0, acc1;\r
392 \r
393                                 x10 = pack16lsb(x[i+1],x[i]);\r
394                                 x32 = pack16lsb(x[i+3],x[i+2]);\r
395                                 \r
396                                 x10 = dualasr(x10,1);\r
397                                 x32 = dualasr(x32,1);\r
398 \r
399                                 acc0 = ifir16(x10,x10);\r
400                                 acc1 = ifir16(x32,x32);\r
401                                 sum  += (acc0 + acc1) >> 6;\r
402                         }\r
403 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
404 #pragma TCS_unrollexact=0\r
405 #pragma TCS_unroll=0\r
406 #endif\r
407                         COMPUTERMS16_STOP();\r
408                         return spx_sqrt(sum/len) << 4;\r
409                 } else {\r
410                         register int sig_shift;\r
411                         register int sum=0;\r
412 \r
413                         sig_shift = mux(max_val < 8192, 1, 0);\r
414                         sig_shift = mux(max_val < 4096, 2, sig_shift);\r
415                         sig_shift = mux(max_val < 2048, 3, sig_shift);\r
416 \r
417 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
418 #pragma TCS_unroll=2\r
419 #pragma TCS_unrollexact=1\r
420 #endif\r
421                         for ( i=0 ; i<len ; i+=4 )\r
422                         {\r
423                                 register int x10, x32;\r
424                                 register int acc0, acc1;\r
425 \r
426                                 x10 = pack16lsb(x[i+1],x[i]);\r
427                                 x32 = pack16lsb(x[i+3],x[i+2]);\r
428 \r
429                                 x10 = dualasl(x10,sig_shift);\r
430                                 x32 = dualasl(x32,sig_shift);\r
431                                 \r
432                                 acc0 = ifir16(x10,x10);\r
433                                 acc1 = ifir16(x32,x32);\r
434                                 sum  += (acc0 + acc1) >> 6;\r
435                         }\r
436 #if (TM_UNROLL && TM_UNROLL_COMPUTERMS16)\r
437 #pragma TCS_unrollexact=0\r
438 #pragma TCS_unroll=0\r
439 #endif\r
440                         COMPUTERMS16_STOP();\r
441                         return spx_sqrt(sum/len) << (3 - sig_shift);  \r
442                 }\r
443         }\r
444 #endif\r
445 }\r
446 \r
447 int normalize16_9(const Int32* restrict x, Int16 * restrict y, Int32 max_scale)\r
448 {\r
449         register int x0, x1, x2, x3, x4, x5, x6, x7, x8;\r
450         register int max_val, m0, m1, m2, m3, m4;\r
451         register int sig_shift;\r
452         register int y10, y32, y54, y76;\r
453 \r
454         TMDEBUG_ALIGNMEM(x);\r
455 \r
456         x0 = ld32(x); \r
457         x1 = ld32x(x,1); x2 = ld32x(x,2); x3 = ld32x(x,3); x4 = ld32x(x,4); \r
458         x5 = ld32x(x,5); x6 = ld32x(x,6); x7 = ld32x(x,7); x8 = ld32x(x,8);\r
459 \r
460         m0 = imax(iabs(x0), iabs(x1));\r
461         m1 = imax(iabs(x2), iabs(x3));\r
462         m2 = imax(iabs(x4), iabs(x5));\r
463         m3 = imax(iabs(x6), iabs(x7));\r
464         m4 = imax(m0, iabs(x8));\r
465         m1 = imax(m1, m2);\r
466         m3 = imax(m3, m4);\r
467         max_val = imax(1,imax(m1,m3));\r
468 \r
469         sig_shift=0;\r
470         while (max_val>max_scale)\r
471         {       sig_shift++;\r
472                 max_val >>= 1;\r
473         }\r
474 \r
475         if ( sig_shift != 0 )\r
476         {\r
477                 y10 = pack16lsb(x1 >> sig_shift, x0 >> sig_shift);\r
478                 y32 = pack16lsb(x3 >> sig_shift, x2 >> sig_shift);\r
479                 y54 = pack16lsb(x5 >> sig_shift, x4 >> sig_shift);\r
480                 y76 = pack16lsb(x7 >> sig_shift, x6 >> sig_shift);\r
481 \r
482                 y[8] = x8 >> sig_shift;\r
483                 st32(y,y10);\r
484                 st32d(4,y,y32);\r
485                 st32d(8,y,y54);\r
486                 st32d(12,y,y76);\r
487         }\r
488         return sig_shift;\r
489 }\r
490 \r
491 int normalize16_mod8(const Int32 * restrict x, Int16 * restrict y, Int32 max_scale,int len)\r
492 {\r
493         register int i, max_val, sig_shift;\r
494         \r
495         TMDEBUG_ALIGNMEM(x);\r
496 \r
497         max_val = 1;\r
498 \r
499         for ( i=0 ; i<len ; i+=4 )\r
500         {\r
501                 register int tmp0, tmp1, tmp2, tmp3;\r
502 \r
503                 tmp0 = ld32x(x,i);\r
504                 tmp1 = ld32x(x,i+1);\r
505 \r
506                 tmp0 = iabs(tmp0);\r
507                 tmp1 = iabs(tmp1);\r
508 \r
509                 tmp2 = ld32x(x,i+2);\r
510                 tmp3 = ld32x(x,i+3);\r
511 \r
512                 tmp2 = iabs(tmp2);\r
513                 tmp3 = iabs(tmp3);\r
514 \r
515                 tmp0 = imax(tmp0, tmp1);\r
516                 max_val = imax(max_val, tmp0); \r
517                 tmp2 = imax(tmp2, tmp3);                \r
518                 max_val = imax(max_val, tmp2);\r
519         }\r
520 \r
521         sig_shift=0;\r
522         while (max_val>max_scale)\r
523         {       sig_shift++;\r
524                 max_val >>= 1;\r
525         }\r
526 \r
527         if ( sig_shift != 0 )\r
528         {\r
529                 for ( i=0 ; i<len ; i+=8, y+=8 )\r
530                 {\r
531                         register int x0, x1, x2, x3, x4, x5, x6, x7;\r
532                         register int y10, y32, y54, y76;\r
533 \r
534                         x0 = ld32x(x,i);   x1 = ld32x(x,i+1); x2 = ld32x(x,i+2); x3 = ld32x(x,i+3); \r
535                         x4 = ld32x(x,i+4); x5 = ld32x(x,i+5); x6 = ld32x(x,i+6); x7 = ld32x(x,i+7);\r
536 \r
537                         y10 = pack16lsb(x1 >> sig_shift, x0 >> sig_shift);\r
538                         y32 = pack16lsb(x3 >> sig_shift, x2 >> sig_shift);\r
539                         y54 = pack16lsb(x5 >> sig_shift, x4 >> sig_shift);\r
540                         y76 = pack16lsb(x7 >> sig_shift, x6 >> sig_shift);\r
541 \r
542                         st32(y,y10);\r
543                         st32d(4,y,y32);\r
544                         st32d(8,y,y54);\r
545                         st32d(12,y,y76);\r
546                 }\r
547         }\r
548         return sig_shift;\r
549 }\r
550 \r
551 \r
552 #define OVERRIDE_NORMALIZE16\r
553 int normalize16(const Int32 *x, Int16 *y, Int32 max_scale, int len)\r
554 {\r
555         TMDEBUG_ALIGNMEM(x);\r
556         TMDEBUG_ALIGNMEM(y);\r
557 \r
558         NORMALIZE16_START();\r
559 \r
560         if ( len == 9 )\r
561         {       NORMALIZE16_STOP();\r
562                 return normalize16_9(x,y,max_scale);\r
563         } else\r
564         {       NORMALIZE16_STOP();\r
565                 return normalize16_mod8(x,y,max_scale,len);\r
566         }\r
567 }\r
568 \r
569 \r
570 void filter_mem16_10(const Int16 *x, const Int16 *num, const Int16 *den, Int16 *y, int N, Int32 *mem)\r
571 {\r
572         register int i;\r
573         register int c9, c8, c7, c6, c5;\r
574         register int c4, c3, c2, c1, c0;\r
575         register int input;\r
576         register int output_0, output_1, output_2, output_3, output_4;\r
577         register int output_5, output_6, output_7, output_8, output_9;\r
578     register Int16 xi, yi;\r
579 \r
580         c9 = pack16lsb(-den[9],num[9]);\r
581         c8 = pack16lsb(-den[8],num[8]);\r
582         c7 = pack16lsb(-den[7],num[7]);\r
583         c6 = pack16lsb(-den[6],num[6]);\r
584         c5 = pack16lsb(-den[5],num[5]);\r
585         c4 = pack16lsb(-den[4],num[4]);\r
586         c3 = pack16lsb(-den[3],num[3]);\r
587         c2 = pack16lsb(-den[2],num[2]);\r
588         c1 = pack16lsb(-den[1],num[1]);\r
589         c0 = pack16lsb(-den[0],num[0]);\r
590 \r
591         output_0 = mem[0];\r
592         output_1 = mem[1];\r
593         output_2 = mem[2];\r
594         output_3 = mem[3];\r
595         output_4 = mem[4];\r
596         output_5 = mem[5];\r
597         output_6 = mem[6];\r
598         output_7 = mem[7];\r
599         output_8 = mem[8];\r
600         output_9 = mem[9];\r
601 \r
602 #if (TM_UNROLL && TM_UNROLL_FILTER)\r
603 #pragma TCS_unroll=4\r
604 #pragma TCS_unrollexact=1\r
605 #endif\r
606 \r
607         for ( i=0 ; i<N ; i++ )\r
608     {\r
609                 xi = (int)(x[i]);\r
610                 yi = iclipi(iadd(xi,PSHR32(output_0,LPC_SHIFT)),32767);\r
611 \r
612                 input   = pack16lsb(yi,xi);\r
613                 output_0= iadd(ifir16(c0,input),output_1);\r
614                 output_1= iadd(ifir16(c1,input),output_2);\r
615                 output_2= iadd(ifir16(c2,input),output_3);\r
616                 output_3= iadd(ifir16(c3,input),output_4);\r
617                 output_4= iadd(ifir16(c4,input),output_5);\r
618                 output_5= iadd(ifir16(c5,input),output_6);\r
619                 output_6= iadd(ifir16(c6,input),output_7);\r
620                 output_7= iadd(ifir16(c7,input),output_8);\r
621                 output_8= iadd(ifir16(c8,input),output_9);\r
622                 output_9= ifir16(c9,input);\r
623 \r
624                 y[i] = yi;\r
625    }\r
626 \r
627 #if (TM_UNROLL && TM_UNROLL_FILTER)\r
628 #pragma TCS_unrollexact=0\r
629 #pragma TCS_unroll=0\r
630 #endif\r
631 \r
632         mem[0] = output_0;\r
633         mem[1] = output_1;\r
634         mem[2] = output_2;\r
635         mem[3] = output_3;\r
636         mem[4] = output_4;\r
637         mem[5] = output_5;\r
638         mem[6] = output_6;\r
639         mem[7] = output_7;\r
640         mem[8] = output_8;\r
641         mem[9] = output_9;\r
642 }\r
643 \r
644 void filter_mem16_8(const Int16 *x, const Int16 *num, const Int16 *den, Int16 *y, int N, Int32 *mem)\r
645 {\r
646         register int i;\r
647         register int c7, c6, c5, c4, c3, c2, c1, c0;\r
648         register int output_0, output_1, output_2, output_3, output_4, output_5, output_6, output_7;\r
649         register int input;\r
650     register Int16 xi, yi;\r
651 \r
652         c7 = pack16lsb(-den[7],num[7]);\r
653         c6 = pack16lsb(-den[6],num[6]);\r
654         c5 = pack16lsb(-den[5],num[5]);\r
655         c4 = pack16lsb(-den[4],num[4]);\r
656         c3 = pack16lsb(-den[3],num[3]);\r
657         c2 = pack16lsb(-den[2],num[2]);\r
658         c1 = pack16lsb(-den[1],num[1]);\r
659         c0 = pack16lsb(-den[0],num[0]);\r
660 \r
661         output_0 = mem[0];\r
662         output_1 = mem[1];\r
663         output_2 = mem[2];\r
664         output_3 = mem[3];\r
665         output_4 = mem[4];\r
666         output_5 = mem[5];\r
667         output_6 = mem[6];\r
668         output_7 = mem[7];\r
669 \r
670 #if (TM_UNROLL && TM_UNROLL_FILTER)\r
671 #pragma TCS_unroll=4\r
672 #pragma TCS_unrollexact=1\r
673 #endif\r
674 \r
675         for ( i=0 ; i<N ; i++ )\r
676     {\r
677                 xi = x[i];\r
678                 yi = iclipi(iadd((int)(xi),PSHR32(output_0,LPC_SHIFT)),32767);\r
679 \r
680                 input   = pack16lsb(yi,xi);\r
681                 output_0= iadd(ifir16(c0,input),output_1);\r
682                 output_1= iadd(ifir16(c1,input),output_2);\r
683                 output_2= iadd(ifir16(c2,input),output_3);\r
684                 output_3= iadd(ifir16(c3,input),output_4);\r
685                 output_4= iadd(ifir16(c4,input),output_5);\r
686                 output_5= iadd(ifir16(c5,input),output_6);\r
687                 output_6= iadd(ifir16(c6,input),output_7);\r
688                 output_7= ifir16(c7,input);\r
689 \r
690                 y[i] = yi;\r
691    }\r
692 \r
693 #if (TM_UNROLL && TM_UNROLL_FILTER)\r
694 #pragma TCS_unrollexact=0\r
695 #pragma TCS_unroll=0\r
696 #endif\r
697 \r
698 \r
699         mem[0] = output_0;\r
700         mem[1] = output_1;\r
701         mem[2] = output_2;\r
702         mem[3] = output_3;\r
703         mem[4] = output_4;\r
704         mem[5] = output_5;\r
705         mem[6] = output_6;\r
706         mem[7] = output_7;\r
707 }\r
708 \r
709 #define OVERRIDE_FILTER_MEM16\r
710 void filter_mem16(const Int16 *x, const Int16 *num, const Int16 *den, Int16 *y, int N, int ord, Int32 *mem, char *stack)\r
711 {\r
712         TMDEBUG_ALIGNMEM(x);\r
713         TMDEBUG_ALIGNMEM(y);\r
714         TMDEBUG_ALIGNMEM(num);\r
715         TMDEBUG_ALIGNMEM(den);\r
716 \r
717         FILTERMEM16_START();\r
718 \r
719         if(ord==10)\r
720                 filter_mem16_10(x, num, den, y, N, mem);\r
721         else if (ord==8)\r
722                 filter_mem16_8(x, num, den, y, N, mem);\r
723 \r
724 #ifndef REMARK_ON\r
725         (void)stack;\r
726 #endif\r
727 \r
728         FILTERMEM16_STOP();\r
729 }\r
730 \r
731 void iir_mem16_8(const Int16 *x, const Int16 *den, Int16 *y, int N, Int32 *mem)\r
732 {\r
733         register int i;\r
734         register int c67, c45, c23, c01;\r
735         register int r1, r2, r3;\r
736         register int y10, y32, y54, y76, yi;\r
737         \r
738         c67 = pack16lsb(-den[6],-den[7]);\r
739         c45 = pack16lsb(-den[4],-den[5]);\r
740         c23 = pack16lsb(-den[2],-den[3]);\r
741         c01 = pack16lsb(-den[0],-den[1]);\r
742 \r
743         y10 = mem[0];\r
744         y32 = mem[1];\r
745         y54 = mem[2];\r
746         y76 = mem[3];\r
747 \r
748 #if (TM_UNROLL && TM_UNROLL_IIR)\r
749 #pragma TCS_unroll=4\r
750 #pragma TCS_unrollexact=1\r
751 #endif\r
752 \r
753         for ( i=0 ; i < N ; ++i )\r
754         {               \r
755                 r2 = iadd(ifir16(y10,c67),ifir16(y32,c45));\r
756                 r3 = iadd(ifir16(y54,c23),ifir16(y76,c01));\r
757                 r1 = iadd(r2,r3);\r
758 \r
759                 y10 = funshift2(y32, y10);\r
760                 y32 = funshift2(y54, y32);\r
761                 y54 = funshift2(y76, y54);\r
762                 \r
763                 yi      = iclipi(iadd((int)(x[i]),PSHR32(r1,LPC_SHIFT)),32767);\r
764                 y[i]= yi;\r
765                 y76 = funshift2(yi, y76);\r
766         }\r
767 \r
768 #if (TM_UNROLL && TM_UNROLL_IIR)\r
769 #pragma TCS_unrollexact=0\r
770 #pragma TCS_unroll=0\r
771 #endif\r
772 \r
773         mem[0] = y10;\r
774         mem[1] = y32;\r
775         mem[2] = y54;\r
776         mem[3] = y76;\r
777 \r
778 }\r
779 \r
780 void iir_mem16_10(const Int16 *x, const Int16 *den, Int16 *y, int N, Int32 *mem)\r
781 {\r
782         register int i;\r
783         register int c89, c67, c45, c23, c01;\r
784         register int r1, r2, r3, r4, r5;\r
785         register int y10, y32, y54, y76, y98, yi;\r
786         \r
787         c89 = pack16lsb(-den[8],-den[9]);\r
788         c67 = pack16lsb(-den[6],-den[7]);\r
789         c45 = pack16lsb(-den[4],-den[5]);\r
790         c23 = pack16lsb(-den[2],-den[3]);\r
791         c01 = pack16lsb(-den[0],-den[1]);\r
792 \r
793         y10 = mem[0];\r
794         y32 = mem[1];\r
795         y54 = mem[2];\r
796         y76 = mem[3];\r
797         y98 = mem[4];\r
798 \r
799 #if (TM_UNROLL && TM_UNROLL_IIR)\r
800 #pragma TCS_unroll=4\r
801 #pragma TCS_unrollexact=1\r
802 #endif\r
803 \r
804         for ( i=0 ; i < N ; ++i )\r
805         {               \r
806                 r2 = iadd(ifir16(y10,c89),ifir16(y32,c67));\r
807                 r3 = iadd(ifir16(y54,c45),ifir16(y76,c23));\r
808                 r4 = ifir16(y98,c01);\r
809                 r5 = iadd(r2,r3);\r
810                 r1 = iadd(r4,r5);\r
811 \r
812                 y10 = funshift2(y32, y10);\r
813                 y32 = funshift2(y54, y32);\r
814                 y54 = funshift2(y76, y54);\r
815                 y76 = funshift2(y98, y76);\r
816                 \r
817                 yi      = iclipi(iadd((int)(x[i]),PSHR32(r1,LPC_SHIFT)),32767);\r
818                 y[i]= yi;\r
819                 y98 = funshift2(yi, y98);               \r
820         }\r
821 \r
822 #if (TM_UNROLL && TM_UNROLL_IIR)\r
823 #pragma TCS_unrollexact=0\r
824 #pragma TCS_unroll=0\r
825 #endif\r
826 \r
827         mem[0] = y10;\r
828         mem[1] = y32;\r
829         mem[2] = y54;\r
830         mem[3] = y76;\r
831         mem[4] = y98;\r
832 }\r
833 \r
834 #define OVERRIDE_IIR_MEM16\r
835 void iir_mem16(const Int16 *x, const Int16 *den, Int16 *y, int N, int ord, Int32 *mem, char *stack)\r
836 {\r
837         TMDEBUG_ALIGNMEM(den);\r
838 \r
839         IIRMEM16_START();\r
840 \r
841         if(ord==10)\r
842                 iir_mem16_10(x, den, y, N, mem);\r
843         else if (ord==8)\r
844                 iir_mem16_8(x, den, y, N, mem);\r
845 \r
846 #ifndef REMARK_ON\r
847         (void)stack;\r
848 #endif\r
849 \r
850         IIRMEM16_STOP();\r
851 }\r
852 \r
853 void fir_mem16_8(const Int16 *x, const Int16 *num, Int16 *y, int N, Int32 *mem)\r
854 {\r
855         register int i, N_2;\r
856         register int c67, c45, c23, c01;\r
857         register int b0, b1, b2, b3;\r
858         register int r1, r2, r3;\r
859         register int x10, x32, x54, x76, xi;\r
860         register Int16 *a; \r
861 \r
862         N_2 = N >> 1;\r
863 \r
864         c67 = ld32x(num,3);\r
865         c45 = ld32x(num,2);\r
866         c23 = ld32x(num,1);\r
867         c01 = ld32x(num,0);\r
868 \r
869         c67 = funshift2(c67,c67);\r
870         c45 = funshift2(c45,c45);\r
871         c23 = funshift2(c23,c23);\r
872         c01 = funshift2(c01,c01);\r
873 \r
874         b3 = x76 = ld32x(x,N_2-1);\r
875         b2 = x54 = ld32x(x,N_2-2);\r
876         b1 = x32 = ld32x(x,N_2-3);\r
877         b0 = x10 = ld32x(x,N_2-4);\r
878 \r
879 #if (TM_UNROLL && TM_UNROLL_FILTER > 0)\r
880 #pragma TCS_unroll=4\r
881 #pragma TCS_unrollexact=1\r
882 #endif\r
883 \r
884         for ( i=N-1 ; i >= 8 ; --i )\r
885         {\r
886                 xi  = asri(16,x76);\r
887                 x76 = funshift2(x76, x54);\r
888                 x54 = funshift2(x54, x32);\r
889                 x32 = funshift2(x32, x10);\r
890                 x10 = pack16lsb(x10, (int)x[i-8]);\r
891 \r
892                 r2 = iadd(ifir16(x10,c67),ifir16(x32,c45));\r
893                 r3 = iadd(ifir16(x54,c23),ifir16(x76,c01));\r
894                 r1 = iadd(r2,r3);\r
895                 \r
896                 y[i] = iclipi(iadd(xi,PSHR32(r1,LPC_SHIFT)),32767);\r
897         }\r
898         for ( i=7, a=(Int16*)mem ; i>=0 ; --i )\r
899         {\r
900                 xi  = asri(16,x76);\r
901                 x76 = funshift2(x76, x54);\r
902                 x54 = funshift2(x54, x32);\r
903                 x32 = funshift2(x32, x10);\r
904                 x10 = pack16lsb(x10, (int)a[i]);\r
905         \r
906                 r2 = iadd(ifir16(x10,c67),ifir16(x32,c45));\r
907                 r3 = iadd(ifir16(x54,c23),ifir16(x76,c01));\r
908                 r1 = iadd(r2,r3);\r
909                 \r
910                 y[i] = iclipi(iadd(xi,PSHR32(r1,LPC_SHIFT)),32767);\r
911         }\r
912 \r
913 #if (TM_UNROLL && TM_UNROLL_FILTER > 0)\r
914 #pragma TCS_unrollexact=0\r
915 #pragma TCS_unroll=0\r
916 #endif\r
917 \r
918         mem[0] = b0;\r
919         mem[1] = b1;\r
920         mem[2] = b2;\r
921         mem[3] = b3;\r
922 }\r
923 \r
924 void fir_mem16_10(const Int16  *x, const Int16 *num, Int16  *y, int N, Int32  *mem)\r
925 {\r
926         register int N_2, i;\r
927         register int c89, c67, c45, c23, c01;\r
928         register int b0, b1, b2, b3, b4;\r
929         register int r1, r2, r3, r4, r5;\r
930         register int x10, x32, x54, x76, x98, xi;\r
931         register Int16 *a; \r
932 \r
933         N_2 = N >> 1;\r
934 \r
935         c89 = ld32x(num,4);\r
936         c67 = ld32x(num,3);\r
937         c45 = ld32x(num,2);\r
938         c23 = ld32x(num,1);\r
939         c01 = ld32x(num,0);\r
940 \r
941         c89 = funshift2(c89,c89);\r
942         c67 = funshift2(c67,c67);\r
943         c45 = funshift2(c45,c45);\r
944         c23 = funshift2(c23,c23);\r
945         c01 = funshift2(c01,c01);\r
946 \r
947         b4 = x98 = ld32x(x,N_2-1);\r
948         b3 = x76 = ld32x(x,N_2-2);\r
949         b2 = x54 = ld32x(x,N_2-3);\r
950         b1 = x32 = ld32x(x,N_2-4);\r
951         b0 = x10 = ld32x(x,N_2-5);\r
952 \r
953 #if (TM_UNROLL && TM_UNROLL_FIR > 0)\r
954 #pragma TCS_unroll=5\r
955 #pragma TCS_unrollexact=1\r
956 #endif\r
957 \r
958         for ( i=N-1 ; i >= 10 ; --i )\r
959         {\r
960                 xi  = asri(16,x98);\r
961                 x98 = funshift2(x98, x76);\r
962                 x76 = funshift2(x76, x54);\r
963                 x54 = funshift2(x54, x32);\r
964                 x32 = funshift2(x32, x10);\r
965                 x10 = pack16lsb(x10, (int)(x[i-10]));\r
966 \r
967                 r2 = iadd(ifir16(x10,c89),ifir16(x32,c67));\r
968                 r3 = iadd(ifir16(x54,c45),ifir16(x76,c23));\r
969                 r4 = ifir16(x98,c01);\r
970                 r5 = iadd(r2,r3);\r
971                 r1 = iadd(r4,r5);\r
972                 \r
973                 y[i] = iclipi(iadd(xi,PSHR32(r1,LPC_SHIFT)),32767);\r
974         }\r
975 \r
976         for ( i=9,a =(Int16*)mem ; i>=0 ; --i )\r
977         {\r
978                 xi  = asri(16,x98);\r
979                 x98 = funshift2(x98, x76);\r
980                 x76 = funshift2(x76, x54);\r
981                 x54 = funshift2(x54, x32);\r
982                 x32 = funshift2(x32, x10);\r
983                 x10 = pack16lsb(x10, (int)(a[i]));\r
984 \r
985                 r2 = iadd(ifir16(x10,c89),ifir16(x32,c67));\r
986                 r3 = iadd(ifir16(x54,c45),ifir16(x76,c23));\r
987                 r4 = ifir16(x98,c01);\r
988                 r5 = iadd(r2,r3);\r
989                 r1 = iadd(r4,r5);\r
990                 \r
991                 y[i] = iclipi(iadd(xi,PSHR32(r1,LPC_SHIFT)),32767);\r
992         }\r
993 \r
994 #if (TM_UNROLL && TM_UNROLL_FIR > 0)\r
995 #pragma TCS_unrollexact=0\r
996 #pragma TCS_unroll=0\r
997 #endif\r
998 \r
999         mem[0] = b0;\r
1000         mem[1] = b1;\r
1001         mem[2] = b2;\r
1002         mem[3] = b3;\r
1003         mem[4] = b4;\r
1004 \r
1005 \r
1006 }\r
1007 \r
1008 #define OVERRIDE_FIR_MEM16\r
1009 void fir_mem16(const spx_word16_t *x, const Int16 *num, spx_word16_t *y, int N, int ord, Int32 *mem, char *stack)\r
1010 {\r
1011         TMDEBUG_ALIGNMEM(x);\r
1012         TMDEBUG_ALIGNMEM(y);\r
1013         TMDEBUG_ALIGNMEM(num);\r
1014 \r
1015         FIRMEM16_START();\r
1016 \r
1017         if(ord==10)\r
1018                 fir_mem16_10(x, num, y, N, mem);\r
1019         else if (ord==8)\r
1020                 fir_mem16_8(x, num, y, N, mem);\r
1021 \r
1022 #ifndef REMARK_ON\r
1023         (void)stack;\r
1024 #endif\r
1025 \r
1026         FIRMEM16_STOP();\r
1027 }\r
1028 \r
1029 \r
1030 \r
1031 #define OVERRIDE_SYN_PERCEP_ZERO16\r
1032 void syn_percep_zero16(const Int16 *xx, const Int16 *ak, const Int16 *awk1, const Int16 *awk2, Int16 *y, int N, int ord, char *stack)\r
1033 {\r
1034         register int i,j;\r
1035         VARDECL(Int32 *mem);\r
1036         ALLOC(mem, ord, Int32);\r
1037         \r
1038         TMDEBUG_ALIGNMEM(mem);\r
1039 \r
1040         for ( i=0,j=0 ; i<ord ; ++i,j+=4 )\r
1041                 st32d(j,mem,0);\r
1042         iir_mem16(xx, ak, y, N, ord, mem, stack);\r
1043         for ( i=0,j=0 ; i<ord ; ++i,j+=4 )\r
1044                 st32d(j,mem,0);\r
1045         filter_mem16(y, awk1, awk2, y, N, ord, mem, stack);\r
1046 }\r
1047 \r
1048 \r
1049 #define OVERRIDE_RESIDUE_PERCEP_ZER016\r
1050 void residue_percep_zero16(const Int16 *xx, const Int16 *ak, const Int16 *awk1, const Int16 *awk2, Int16 *y, int N, int ord, char *stack)\r
1051 {\r
1052         register int i,j;\r
1053         VARDECL(Int32 *mem);\r
1054         ALLOC(mem, ord, Int32);\r
1055 \r
1056         TMDEBUG_ALIGNMEM(mem);\r
1057 \r
1058         for ( i=0,j=0 ; i<ord ; ++i,j+=4 )\r
1059                 st32d(j,mem,0);\r
1060         filter_mem16(xx, ak, awk1, y, N, ord, mem, stack);\r
1061         for ( i=0,j=0 ; i<ord ; ++i,j+=4 )\r
1062                 st32d(j,mem,0);\r
1063         fir_mem16(y, awk2, y, N, ord, mem, stack);\r
1064 }\r
1065 \r
1066 \r
1067 \r
1068 void compute_impulse_response_10(const Int16 *ak, const Int16 *awk1, const Int16 *awk2, Int16 *y, int N)\r
1069 {\r
1070         register int awk_01, awk_23, awk_45, awk_67, awk_89;\r
1071         register int y10, y32, y54, y76, y98, yi;\r
1072         register int i, acc0, acc1, N_2;\r
1073 \r
1074         N_2             = N << 1;\r
1075 \r
1076         awk_01 = ld32(awk1); \r
1077         awk_23 = ld32x(awk1,1); \r
1078         awk_45 = ld32x(awk1,2); \r
1079         awk_67 = ld32x(awk1,3); \r
1080         awk_89 = ld32x(awk1,4);\r
1081 \r
1082         y10 = funshift2(awk_01, LPC_SCALING << 16);\r
1083         st32d(0, y, y10);\r
1084         y32 = funshift2(awk_23, awk_01);\r
1085         st32d(4, y, y32);\r
1086         y54 = funshift2(awk_45, awk_23);\r
1087         st32d(8, y, y54);\r
1088         y76 = funshift2(awk_67, awk_45);\r
1089         st32d(12, y, y76);\r
1090         y98 = funshift2(awk_89, awk_67);\r
1091         st32d(16, y, y98);\r
1092         y10 = funshift2(0, awk_89);\r
1093         st32d(20, y, y10);\r
1094 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1095 #pragma TCS_unroll=2\r
1096 #pragma TCS_unrollexact=1\r
1097 #endif\r
1098         for ( i=24 ; i<N_2 ; i+=4 )\r
1099         {       st32d(i, y, 0);\r
1100         }\r
1101 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1102 #pragma TCS_unrollexact=0\r
1103 #pragma TCS_unroll=0\r
1104 #endif\r
1105         y10 = y32 = y54 = y76 = y98 = 0;\r
1106         awk_01 = ld32(awk2); \r
1107         awk_23 = ld32x(awk2,1); \r
1108         awk_45 = ld32x(awk2,2); \r
1109         awk_67 = ld32x(awk2,3); \r
1110         awk_89 = ld32x(awk2,4); \r
1111         \r
1112         awk_01 = funshift2(awk_01, awk_01);\r
1113         awk_23 = funshift2(awk_23, awk_23);\r
1114         awk_45 = funshift2(awk_45, awk_45);\r
1115         awk_67 = funshift2(awk_67, awk_67);\r
1116         awk_89 = funshift2(awk_89, awk_89);\r
1117 \r
1118 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1119 #pragma TCS_unroll=4\r
1120 #pragma TCS_unrollexact=1\r
1121 #endif\r
1122         for ( i=0 ; i<N ; ++i )\r
1123         {\r
1124                 yi      = y[i];\r
1125 \r
1126                 acc0 = ifir16(y10, awk_89) + ifir16(y32, awk_67);\r
1127                 acc1 = ifir16(y54, awk_45) + ifir16(y76, awk_23);\r
1128                 yi   += PSHR32(acc0 + acc1 + ifir16(y98, awk_01),LPC_SHIFT);\r
1129                 y[i] = yi;\r
1130 \r
1131                 y10 = funshift2(y32, y10);\r
1132                 y32 = funshift2(y54, y32);\r
1133                 y54 = funshift2(y76, y54);\r
1134                 y76 = funshift2(y98, y76);\r
1135                 y98 = funshift2(ineg(yi), y98);\r
1136         }\r
1137 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1138 #pragma TCS_unrollexact=0\r
1139 #pragma TCS_unroll=0\r
1140 #endif\r
1141         y10 = y32 = y54 = y76 = y98 = 0;\r
1142         awk_01 = ld32(ak); \r
1143         awk_23 = ld32x(ak,1); \r
1144         awk_45 = ld32x(ak,2); \r
1145         awk_67 = ld32x(ak,3); \r
1146         awk_89 = ld32x(ak,4);\r
1147         awk_01 = funshift2(awk_01, awk_01);\r
1148         awk_23 = funshift2(awk_23, awk_23);\r
1149         awk_45 = funshift2(awk_45, awk_45);\r
1150         awk_67 = funshift2(awk_67, awk_67);\r
1151         awk_89 = funshift2(awk_89, awk_89);\r
1152         \r
1153 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1154 #pragma TCS_unroll=4\r
1155 #pragma TCS_unrollexact=1\r
1156 #endif\r
1157         for ( i=0 ; i<N ; ++i )\r
1158         {\r
1159                 yi      = y[i];\r
1160 \r
1161                 acc0 = ifir16(y10, awk_89) + ifir16(y32, awk_67);\r
1162                 acc1 = ifir16(y54, awk_45) + ifir16(y76, awk_23);\r
1163                 yi   = PSHR32(SHL32(yi,LPC_SHIFT+1) + acc0 + acc1 + ifir16(y98, awk_01),LPC_SHIFT);\r
1164                 y[i] = yi;\r
1165 \r
1166                 y10 = funshift2(y32, y10);\r
1167                 y32 = funshift2(y54, y32);\r
1168                 y54 = funshift2(y76, y54);\r
1169                 y76 = funshift2(y98, y76);\r
1170                 y98 = funshift2(ineg(yi), y98);\r
1171         }\r
1172 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1173 #pragma TCS_unrollexact=0\r
1174 #pragma TCS_unroll=0\r
1175 #endif\r
1176 }\r
1177 \r
1178 void compute_impulse_response_8(const Int16 *ak, const Int16 *awk1, const Int16 *awk2, Int16 *y, int N)\r
1179 {\r
1180         register int awk_01, awk_23, awk_45, awk_67;\r
1181         register int y10, y32, y54, y76, yi;\r
1182         register int i, acc0, acc1, N_2;\r
1183 \r
1184         N_2             = N << 1;\r
1185 \r
1186         awk_01 = ld32(awk1); \r
1187         awk_23 = ld32x(awk1,1); \r
1188         awk_45 = ld32x(awk1,2); \r
1189         awk_67 = ld32x(awk1,3);\r
1190 \r
1191         y10 = funshift2(awk_01, LPC_SCALING << 16);\r
1192         st32d(0, y, y10);\r
1193         y32 = funshift2(awk_23, awk_01);\r
1194         st32d(4, y, y32);\r
1195         y54 = funshift2(awk_45, awk_23);\r
1196         st32d(8, y, y54);\r
1197         y76 = funshift2(awk_67, awk_45);\r
1198         st32d(12, y, y76);\r
1199         y10 = funshift2(0, awk_67);\r
1200         st32d(16, y, y10);\r
1201         st32d(20, y, 0);\r
1202 \r
1203 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1204 #pragma TCS_unroll=2\r
1205 #pragma TCS_unrollexact=1\r
1206 #endif\r
1207         for ( i=24 ; i<N_2 ; i+=4 )\r
1208         {       st32d(i, y, 0);\r
1209         }\r
1210 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1211 #pragma TCS_unrollexact=0\r
1212 #pragma TCS_unroll=0\r
1213 #endif\r
1214         y10 = y32 = y54 = y76 = 0;\r
1215         awk_01 = ld32(awk2); \r
1216         awk_23 = ld32x(awk2,1); \r
1217         awk_45 = ld32x(awk2,2); \r
1218         awk_67 = ld32x(awk2,3); \r
1219         \r
1220         awk_01 = funshift2(awk_01, awk_01);\r
1221         awk_23 = funshift2(awk_23, awk_23);\r
1222         awk_45 = funshift2(awk_45, awk_45);\r
1223         awk_67 = funshift2(awk_67, awk_67);\r
1224 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1225 #pragma TCS_unroll=4\r
1226 #pragma TCS_unrollexact=1\r
1227 #endif\r
1228         for ( i=0 ; i<N ; ++i )\r
1229         {\r
1230                 yi      = y[i];\r
1231 \r
1232                 acc0 = ifir16(y10, awk_67) + ifir16(y32, awk_45);\r
1233                 acc1 = ifir16(y54, awk_23) + ifir16(y76, awk_01);\r
1234                 yi   += PSHR32(acc0 + acc1,LPC_SHIFT);\r
1235                 y[i] = yi;\r
1236 \r
1237                 y10 = funshift2(y32, y10);\r
1238                 y32 = funshift2(y54, y32);\r
1239                 y54 = funshift2(y76, y54);\r
1240                 y76 = funshift2(ineg(yi), y76);\r
1241         }\r
1242 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1243 #pragma TCS_unrollexact=0\r
1244 #pragma TCS_unroll=0\r
1245 #endif\r
1246         y10 = y32 = y54 = y76 = 0;\r
1247         awk_01 = ld32(ak); \r
1248         awk_23 = ld32x(ak,1); \r
1249         awk_45 = ld32x(ak,2); \r
1250         awk_67 = ld32x(ak,3);\r
1251         awk_01 = funshift2(awk_01, awk_01);\r
1252         awk_23 = funshift2(awk_23, awk_23);\r
1253         awk_45 = funshift2(awk_45, awk_45);\r
1254         awk_67 = funshift2(awk_67, awk_67);\r
1255 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1256 #pragma TCS_unroll=4\r
1257 #pragma TCS_unrollexact=1\r
1258 #endif  \r
1259         for ( i=0 ; i<N ; ++i )\r
1260         {\r
1261                 yi      = y[i];\r
1262 \r
1263                 acc0 = ifir16(y10, awk_67) + ifir16(y32, awk_45);\r
1264                 acc1 = ifir16(y54, awk_23) + ifir16(y76, awk_01);\r
1265                 yi   = PSHR32(SHL32(yi,LPC_SHIFT+1) + acc0 + acc1,LPC_SHIFT);\r
1266                 y[i] = yi;\r
1267 \r
1268                 y10 = funshift2(y32, y10);\r
1269                 y32 = funshift2(y54, y32);\r
1270                 y54 = funshift2(y76, y54);\r
1271                 y76 = funshift2(ineg(yi), y76);\r
1272         }\r
1273 #if (TM_UNROLL && TM_UNROLL_COMPUTEIMPULSERESPONSE > 0)\r
1274 #pragma TCS_unrollexact=0\r
1275 #pragma TCS_unroll=0\r
1276 #endif\r
1277 }\r
1278 \r
1279 \r
1280 #define OVERRIDE_COMPUTE_IMPULSE_RESPONSE\r
1281 void compute_impulse_response(const Int16 *ak, const Int16 *awk1, const Int16 *awk2, Int16 *y, int N, int ord, char *stack)\r
1282 {\r
1283         TMDEBUG_ALIGNMEM(ak);\r
1284         TMDEBUG_ALIGNMEM(awk1);\r
1285         TMDEBUG_ALIGNMEM(awk2);\r
1286         TMDEBUG_ALIGNMEM(y);\r
1287 \r
1288         COMPUTEIMPULSERESPONSE_START();\r
1289         if ( ord == 10 )\r
1290                 compute_impulse_response_10(ak,awk1,awk2,y,N);\r
1291         else\r
1292                 compute_impulse_response_8(ak,awk1,awk2,y,N);\r
1293 \r
1294         (void)stack;\r
1295 \r
1296         COMPUTEIMPULSERESPONSE_STOP();\r
1297 }\r
1298 \r
1299 \r
1300 #define OVERRIDE_QMFSYNTH\r
1301 void qmf_synth(const Int16 *x1, const Int16 *x2, const Int16 *a, Int16 *y, int N, int M, Int32 *mem1, Int32 *mem2, char *stack)\r
1302    /* assumptions:\r
1303       all odd x[i] are zero -- well, actually they are left out of the array now\r
1304       N and M are multiples of 4 */\r
1305 {\r
1306         register int i, j;\r
1307         register int M2, N2;\r
1308         VARDECL(int *x12);\r
1309         M2 = M>>1;\r
1310         N2 = N>>1;\r
1311         ALLOC(x12, M2+N2, int);\r
1312 \r
1313 \r
1314         TMDEBUG_ALIGNMEM(a);\r
1315         TMDEBUG_ALIGNMEM(x12);\r
1316         TMDEBUG_ALIGNMEM(mem1);\r
1317         TMDEBUG_ALIGNMEM(mem2);\r
1318 \r
1319         QMFSYNTH_START();\r
1320    \r
1321 #if (TM_UNROLL && TM_UNROLL_QMFSYNTH > 0)\r
1322 #pragma TCS_unroll=4\r
1323 #pragma TCS_unrollexact=1\r
1324 #endif  \r
1325         for ( i=0 ; i<N2 ; ++i )\r
1326         {       register int index = N2-1-i;\r
1327                 x12[i] = pack16lsb(x1[index],x2[index]);\r
1328         }\r
1329 \r
1330         for ( j= 0; j<M2 ; ++j)\r
1331         {       register int index = (j << 1) + 1;\r
1332                 x12[N2+j] = pack16lsb(mem1[index],mem2[index]);\r
1333         }\r
1334 #if (TM_UNROLL && TM_UNROLL_QMFSYNTH > 0)\r
1335 #pragma TCS_unrollexact=0\r
1336 #pragma TCS_unroll=0\r
1337 #endif   \r
1338         for (i = 0; i < N2; i += 2) \r
1339         {\r
1340                 register int y0, y1, y2, y3;\r
1341                 register int x12_0;\r
1342 \r
1343                 y0 = y1 = y2 = y3 = 0;\r
1344                 x12_0 = x12[N2-2-i];\r
1345 \r
1346                 for (j = 0; j < M2; j += 2) \r
1347                 {\r
1348                         register int x12_1;\r
1349                         register int a10, a11, a0_0;\r
1350                         register int _a10, _a11, _a0_0;\r
1351 \r
1352                         a10 = ld32x(a,j);\r
1353                         a11 = pack16msb(a10,a10);\r
1354                         a0_0= pack16lsb(a10,ineg(sex16(a10)));\r
1355                         x12_1 = x12[N2-1+j-i];\r
1356 \r
1357                         y0 += ifir16(a0_0,x12_1);\r
1358                         y1 += ifir16(a11, x12_1);\r
1359                         y2 += ifir16(a0_0,x12_0);\r
1360                         y3 += ifir16(a11 ,x12_0);\r
1361 \r
1362 \r
1363                         _a10   = ld32x(a,j+1);\r
1364                         _a11   = pack16msb(_a10,_a10);\r
1365                         _a0_0  = pack16lsb(_a10,ineg(sex16(_a10)));\r
1366                         x12_0  = x12[N2+j-i];\r
1367                         \r
1368                         y0 += ifir16(_a0_0,x12_0);\r
1369                         y1 += ifir16(_a11, x12_0);\r
1370                         y2 += ifir16(_a0_0,x12_1);\r
1371                         y3 += ifir16(_a11 ,x12_1);\r
1372 \r
1373                 }\r
1374                 y[2*i]   = EXTRACT16(SATURATE32(PSHR32(y0,15),32767));\r
1375                 y[2*i+1] = EXTRACT16(SATURATE32(PSHR32(y1,15),32767));\r
1376                 y[2*i+2] = EXTRACT16(SATURATE32(PSHR32(y2,15),32767));\r
1377                 y[2*i+3] = EXTRACT16(SATURATE32(PSHR32(y3,15),32767));\r
1378         }\r
1379 \r
1380 #if (TM_UNROLL && TM_UNROLL_QMFSYNTH > 0)\r
1381 #pragma TCS_unroll=4\r
1382 #pragma TCS_unrollexact=1\r
1383 #endif  \r
1384         for (i = 0; i < M2; ++i)\r
1385         {       mem1[2*i+1] = asri(16,x12[i]);\r
1386                 mem2[2*i+1] = sex16(x12[i]);\r
1387         }\r
1388 #if (TM_UNROLL && TM_UNROLL_QMFSYNTH > 0)\r
1389 #pragma TCS_unrollexact=0\r
1390 #pragma TCS_unroll=0\r
1391 #endif   \r
1392 \r
1393         QMFSYNTH_STOP();\r
1394 }\r
1395 \r
1396 \r
1397 #define OVERRIDE_QMFDECOMP\r
1398 void qmf_decomp(const Int16 *xx, const Int16 *aa, Int16 *y1, Int16 *y2, int N, int M, Int16 *mem, char *stack)\r
1399 {\r
1400         VARDECL(int *_a);\r
1401         VARDECL(int *_x);\r
1402         register int i, j, k, MM, M2, N2;  \r
1403         register int _xx10, _mm10;\r
1404         register int *_x2;\r
1405 \r
1406         M2=M>>1;\r
1407         N2=N>>1;\r
1408         MM=(M-2)<<1;\r
1409 \r
1410         ALLOC(_a, M2, int);\r
1411         ALLOC(_x, N2+M2, int);\r
1412         _x2 = _x + M2 - 1;\r
1413 \r
1414         TMDEBUG_ALIGNMEM(xx);\r
1415         TMDEBUG_ALIGNMEM(aa);\r
1416         TMDEBUG_ALIGNMEM(y1);\r
1417         TMDEBUG_ALIGNMEM(y2);\r
1418         TMDEBUG_ALIGNMEM(mem);\r
1419         TMDEBUG_ALIGNMEM(_a);\r
1420         TMDEBUG_ALIGNMEM(_x);\r
1421 \r
1422         QMFDECOMP_START();\r
1423 \r
1424         _xx10 = ld32(xx);\r
1425         _xx10 = dualasr(_xx10,1);\r
1426         _mm10 = ld32(mem);\r
1427         _x2[0] = pack16lsb(_xx10,_mm10);\r
1428 \r
1429 #if (TM_UNROLL && TM_UNROLL_QMFSYNTH > 0)\r
1430 #pragma TCS_unroll=2\r
1431 #pragma TCS_unrollexact=1\r
1432 #endif  \r
1433         for ( i=0 ; i<M2 ; ++i )\r
1434         {       register int a10;\r
1435                 \r
1436                 a10 = ld32x(aa,i);\r
1437                 a10 = funshift2(a10, a10);\r
1438                 _a[M2-i-1] = a10;               \r
1439         }\r
1440 \r
1441         for ( j=1 ; j<N2 ; ++j )\r
1442         {       register int _xx32;\r
1443 \r
1444                 _xx32   = ld32x(xx,j);\r
1445                 _xx32   = dualasr(_xx32,1);\r
1446                 _x2[j]  = funshift2(_xx32, _xx10);\r
1447                 _xx10   = _xx32;\r
1448         }\r
1449 \r
1450         for ( k=1 ; k<M2; ++k )\r
1451         {       register int _mm32;\r
1452 \r
1453                 _mm32   = ld32x(mem,k);\r
1454                 _mm10   = funshift2(_mm10,_mm10);\r
1455                 _x2[-k] = pack16lsb(_mm10,_mm32);\r
1456                 _mm10 = _mm32;\r
1457         }\r
1458 \r
1459 \r
1460         for ( i=N2-1,j=0 ; j<MM ; --i,j+=4 )\r
1461         {       register int _xx;\r
1462 \r
1463                 _xx = ld32x(xx,i);\r
1464                 _xx = dualasr(_xx,1);\r
1465                 _xx = funshift2(_xx,_xx);\r
1466                 st32d(j, mem, _xx);\r
1467         }\r
1468 #if (TM_UNROLL && TM_UNROLL_QMFSYNTH > 0)\r
1469 #pragma TCS_unrollexact=0\r
1470 #pragma TCS_unroll=0\r
1471 #endif\r
1472         mem[M-2] = xx[N-M+1] >> 1;\r
1473 \r
1474 \r
1475         M2 >>= 1;\r
1476         for ( i=0 ; i<N2 ; ++i )\r
1477         {       register int y1k, y2k;\r
1478 \r
1479                 y1k = y2k = 0;\r
1480 \r
1481                 for ( j=0 ; j<M2 ; j+=2 )\r
1482                 {       register int _aa, _acc0, _acc1;\r
1483                         register int __xx10, __mm10, __acc0, __acc1, __aa;\r
1484                         register int _tmp0, _tmp1, _tmp2, _tmp3;\r
1485 \r
1486                         _xx10 = ld32x(_x, i+j);\r
1487                         _mm10 = ld32x(_x2,i-j);\r
1488                         _aa       = ld32x(_a, j);\r
1489                         _mm10 = funshift2(_mm10,_mm10);\r
1490                         _acc0 = dspidualadd(_xx10, _mm10);\r
1491                         _acc1 = dspidualsub(_xx10, _mm10);\r
1492 \r
1493                         __xx10 = ld32x(_x, i+j+1);\r
1494                         __mm10 = ld32x(_x2,i-j-1);\r
1495                         __aa   = ld32x(_a, j+1);\r
1496                         __mm10 = funshift2(__mm10,__mm10);\r
1497                         __acc0 = dspidualadd(__xx10, __mm10);\r
1498                         __acc1 = dspidualsub(__xx10, __mm10);\r
1499 \r
1500                         y1k   += ifir16(_aa, _acc0);\r
1501                         y1k   += ifir16(__aa, __acc0);\r
1502 \r
1503                         _tmp0 = pack16lsb(_aa,__aa);\r
1504                         _tmp1 = pack16msb(_aa,__aa);\r
1505                         _tmp2 = pack16lsb(_acc1, __acc1);\r
1506                         _tmp3 = pack16msb(_acc1, __acc1);\r
1507 \r
1508                         y2k       -= ifir16(_tmp0, _tmp2);\r
1509                         y2k       += ifir16(_tmp1, _tmp3);\r
1510 \r
1511                 }\r
1512 \r
1513                 y1[i] = iclipi(PSHR32(y1k,15),32767);\r
1514                 y2[i] = iclipi(PSHR32(y2k,15),32767);\r
1515         }\r
1516 \r
1517         QMFDECOMP_STOP();\r
1518 }\r
1519 \r
1520 #endif\r
1521 \r