Mercurial > SDL_sound_CoreAudio

comparison filter_templates.h @ 366:eda146d666d1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
More patches from Frank.
author Ryan C. Gordon <icculus@icculus.org>
date Fri, 21 Jun 2002 20:03:46 +0000
parents f61eadea1f44
children 1b463ef9bcc2
comparison
equal deleted inserted replaced
365:f61eadea1f44 366:eda146d666d1
27 27
28 #ifndef Suffix 28 #ifndef Suffix
29 #error include filter_template.h with defined Suffix macro! 29 #error include filter_template.h with defined Suffix macro!
30 #else 30 #else
31 #define CH(x) (Suffix((x)*)) 31 #define CH(x) (Suffix((x)*))
32 /*-------------------------------------------------------------------------*/
33 /*
34 * !!! FIXME !!!
35 *
36 *
37 * Tune doubleRate(), halfRate() and varRate() for speed
38 * - Frank
39 */
40 32
41 /*-------------------------------------------------------------------------*/ 33 /*-------------------------------------------------------------------------*/
34 /* this filter (Kaiser-window beta=6.8) gives a decent -80dB attentuation */
35 /*-------------------------------------------------------------------------*/
36 #define sum_d(v,dx) ((int) v[CH(dx)] + v[CH(1-dx)])
42 static Sint16* Suffix(doubleRate)( Sint16 *outp, Sint16 *inp, int length, 37 static Sint16* Suffix(doubleRate)( Sint16 *outp, Sint16 *inp, int length,
43 VarFilter* filt, int* cpos ) 38 VarFilter* filt, int* cpos )
44 { 39 {
45 static const int fsize = _fsize; 40 int out;
46 int i, out; 41 Sint16 *to;
47 Sint16* to;
48 42
49 inp += fsize; 43 to = inp - length;
50 to = inp + length;
51 44
52 for(; inp > to; inp -= CH(1) ) 45 while( inp > to )
53 { 46 {
54 out = 0; 47 out = 0;
55 for( i = 1; i < 1+fsize; i++ ) 48 out-= 9 * sum_d( inp, 16);
56 out+= filter[2*i] * ( inp[CH(i)] + inp[CH(1-i)] ); 49 out+= 23 * sum_d( inp, 15);
50 out-= 46 * sum_d( inp, 14);
51 out+= 83 * sum_d( inp, 13);
52 out-= 138 * sum_d( inp, 12);
53 out+= 217 * sum_d( inp, 11);
54 out-= 326 * sum_d( inp, 10);
55 out+= 474 * sum_d( inp, 9);
56 out-= 671 * sum_d( inp, 8);
57 out+= 936 * sum_d( inp, 7);
58 out-= 1295 * sum_d( inp, 6);
59 out+= 1800 * sum_d( inp, 5);
60 out-= 2560 * sum_d( inp, 4);
61 out+= 3863 * sum_d( inp, 3);
62 out-= 6764 * sum_d( inp, 2);
63 out+= 20798 * sum_d( inp, 1);
57 64
58 outp[CH(1)] = ( 32770 * inp[CH(1)] + out) >> 16; 65 outp[CH(1)] = ( 32770 * inp[CH(1)] + out) >> 16;
59 outp[CH(0)] = ( 32770 * inp[CH(0)] + out) >> 16; 66 outp[CH(0)] = ( 32770 * inp[CH(0)] + out) >> 16;
67
68 inp -= CH(1);
60 outp -= CH(2); 69 outp -= CH(2);
61 } 70 }
62 return outp; 71 return outp;
63 } 72 }
64 73
65 /*-------------------------------------------------------------------------*/ 74 /*-------------------------------------------------------------------------*/
75 #define sum_h(v,dx) ((int) v[CH(dx)] + v[CH(-dx)])
66 static Sint16* Suffix(halfRate)( Sint16 *outp, Sint16 *inp, int length, 76 static Sint16* Suffix(halfRate)( Sint16 *outp, Sint16 *inp, int length,
67 VarFilter* filt, int* cpos ) 77 VarFilter* filt, int* cpos )
68 { 78 {
69 static const int fsize = CH(_fsize/2); 79 int out;
70 int i, out;
71 Sint16* to; 80 Sint16* to;
72 81
73 inp -= fsize;
74 to = inp + length; 82 to = inp + length;
75 83
76 for(; inp < to; inp+= CH(2) ) 84 while( inp < to )
77 { 85 {
78 out = 32770 * inp[0]; 86 out = 0;
79 for( i = 1; i < fsize/2; i+=2 ) 87 out-= 9 * sum_h( inp, 31);
80 out+= filter[i]*( (int)inp[CH(i)] + inp[CH(-i)] ); 88 out+= 23 * sum_h( inp, 29);
89 out-= 46 * sum_h( inp, 27);
90 out+= 83 * sum_h( inp, 25);
91 out-= 138 * sum_h( inp, 23);
92 out+= 217 * sum_h( inp, 21);
93 out-= 326 * sum_h( inp, 19);
94 out+= 474 * sum_h( inp, 17);
95 out-= 671 * sum_h( inp, 15);
96 out+= 936 * sum_h( inp, 13);
97 out-= 1295 * sum_h( inp, 11);
98 out+= 1800 * sum_h( inp, 9);
99 out-= 2560 * sum_h( inp, 7);
100 out+= 3863 * sum_h( inp, 5);
101 out+= 20798 * sum_h( inp, 1);
102 out+= 32770 * (int)inp[0];
103
81 outp[0] = out >> 16; 104 outp[0] = out >> 16;
82 105
106 inp+= CH(2);
83 outp += CH(1); 107 outp += CH(1);
84 } 108 }
85 return outp; 109 return outp;
86 } 110 }
87 111
88 /*-------------------------------------------------------------------------*/ 112 /*-------------------------------------------------------------------------*/
89 static Sint16* Suffix(increaseRate)( Sint16 *outp, Sint16 *inp, int length, 113 static Sint16* Suffix(increaseRate)( Sint16 *outp, Sint16 *inp, int length,
90 VarFilter* filt, int* cpos ) 114 VarFilter* filt, int* cpos )
91 { 115 {
92 const static int fsize = 2*_fsize; 116 const static int fsize = CH(2*_fsize);
93 Sint16 *filter; 117 Sint16 *filter;
94 int out; 118 int out;
95 int i, pos; 119 int i, pos;
96 Sint16* to; 120 Sint16* to;
97 121
98 inp += fsize; 122 inp -= fsize;
99 to = inp + length; 123 to = inp - length;
100 124
101 while( inp > to ) 125 while( inp > to )
102 { 126 {
103 pos = *cpos; 127 pos = *cpos;
104 out = 0; 128 out = 0;
105 filter = filt->c[pos]; 129 filter = filt->c[pos];
106 for( i = 0; i < 2*_fsize; i++ ) 130 for( i = 0; i < 4*_fsize; i++ )
107 out+= filter[i] * (int)inp[CH(i)]; 131 out+= filter[i] * (int)inp[CH(i)];
108 outp[0] = out >> 16; 132 outp[0] = out >> 16;
109 133
110 inp -= CH(filt->incr[pos]); 134 inp -= CH(filt->incr[pos]);
111 outp -= CH(1); 135 outp -= CH(1);
116 140
117 /*-------------------------------------------------------------------------*/ 141 /*-------------------------------------------------------------------------*/
118 static Sint16* Suffix(decreaseRate)( Sint16 *outp, Sint16 *inp, int length, 142 static Sint16* Suffix(decreaseRate)( Sint16 *outp, Sint16 *inp, int length,
119 VarFilter* filt, int* cpos ) 143 VarFilter* filt, int* cpos )
120 { 144 {
121 const static int fsize = 2*_fsize; 145 const static int fsize = CH(2*_fsize);
122 Sint16 *filter; 146 Sint16 *filter;
123 int out; 147 int out;
124 int i, pos; 148 int i, pos;
125 Sint16 *to; 149 Sint16 *to;
126 150
130 while( inp < to ) 154 while( inp < to )
131 { 155 {
132 pos = *cpos; 156 pos = *cpos;
133 out = 0; 157 out = 0;
134 filter = filt->c[pos]; 158 filter = filt->c[pos];
135 for( i = 0; i < 2*_fsize; i++ ) 159 for( i = 0; i < 4*_fsize; i++ )
136 out+= filter[i] * (int)inp[CH(i)]; 160 out+= filter[i] * inp[CH(i)];
137 outp[0] = out >> 16; 161 outp[0] = out >> 16;
138 162
139 inp += CH(filt->incr[pos]); 163 inp += CH(filt->incr[pos]);
140 outp += CH(1); 164 outp += CH(1);
141 *cpos = ( pos + 1 ) % filt->denominator; 165 *cpos = ( pos + 1 ) % filt->denominator;
142 } 166 }
143 return outp; 167 return outp;
144 } 168 }
145 169
146 /*-------------------------------------------------------------------------*/ 170 /*-------------------------------------------------------------------------*/
171 #undef sum_d
172 #undef sum_h
147 #undef CH 173 #undef CH
148 #endif /* Suffix */ 174 #endif /* Suffix */
149 175