r8brain-free-src
High-quality pro audio sample rate converter library
 
Loading...
Searching...
No Matches
CDSPHBUpsampler.h
Go to the documentation of this file.
1//$ nobt
2//$ nocpp
3
15
16#ifndef R8B_CDSPHBUPSAMPLER_INCLUDED
17#define R8B_CDSPHBUPSAMPLER_INCLUDED
18
19#include "CDSPProcessor.h"
20
21namespace r8b {
22
30
31class CDSPHBUpsampler : public CDSPProcessor
32{
33public:
46
47 static void getHBFilter( const double ReqAtten, const int SteepIndex,
48 const double*& flt, int& fltt, double& att )
49 {
50 static const double HBKernel_4A[ 4 ] = { // -54.5176 dB, 4
51 6.1729335650971517e-001, -1.5963945620743250e-001,
52 5.5073370934086312e-002, -1.4603578989932850e-002,};
53 static const double HBKernel_5A[ 5 ] = { // -66.3075 dB, 4
54 6.2068807424902472e-001, -1.6827573634467302e-001,
55 6.5263016720721170e-002, -2.2483331611592005e-002,
56 5.2917326684281110e-003,};
57 static const double HBKernel_6A[ 6 ] = { // -89.5271 dB, 4
58 6.2187202340480707e-001, -1.7132842113816371e-001,
59 6.9019169178765674e-002, -2.5799728312695277e-002,
60 7.4880112525741666e-003, -1.2844465869952567e-003,};
61 static const double HBKernel_7A[ 7 ] = { // -105.2842 dB, 4
62 6.2354494135775851e-001, -1.7571220703702045e-001,
63 7.4529843603968457e-002, -3.0701736822442153e-002,
64 1.0716755639039573e-002, -2.7833422930759735e-003,
65 4.1118797093875510e-004,};
66 static const double HBKernel_8A[ 8 ] = { // -121.0063 dB, 4
67 6.2488363107953926e-001, -1.7924942606514119e-001,
68 7.9068155655640557e-002, -3.4907523415495731e-002,
69 1.3710256799907897e-002, -4.3991142586987933e-003,
70 1.0259190163889602e-003, -1.3278941979339359e-004,};
71 static const double HBKernel_9A[ 9 ] = { // -136.6982 dB, 4
72 6.2597763804021977e-001, -1.8216414325139055e-001,
73 8.2879104876726728e-002, -3.8563442248249404e-002,
74 1.6471530499739394e-002, -6.0489108881335227e-003,
75 1.7805283804140392e-003, -3.7533200112729561e-004,
76 4.3172840558735476e-005,};
77 static const double HBKernel_10A[ 10 ] = { // -152.3572 dB, 4
78 6.2688767582974092e-001, -1.8460766807559420e-001,
79 8.6128943000481864e-002, -4.1774474147006607e-002,
80 1.9014801985747346e-002, -7.6870397465866507e-003,
81 2.6264590175341853e-003, -7.1106660285478562e-004,
82 1.3645852036179345e-004, -1.4113888783332969e-005,};
83 static const double HBKernel_11A[ 11 ] = { // -183.7962 dB, 4
84 6.2667167706948146e-001, -1.8407153342635879e-001,
85 8.5529995610836046e-002, -4.1346831462361310e-002,
86 1.8844831691322637e-002, -7.7125170365394992e-003,
87 2.7268674860562087e-003, -7.9745028501057233e-004,
88 1.8116344606360795e-004, -2.8569149754241848e-005,
89 2.3667022010173616e-006,};
90 static const double HBKernel_12A[ 12 ] = { // -199.4768 dB, 4
91 6.2747849730367999e-001, -1.8623616784506747e-001,
92 8.8409755898467945e-002, -4.4207468821462342e-002,
93 2.1149175945115381e-002, -9.2551508371115209e-003,
94 3.5871562170822330e-003, -1.1923167653750219e-003,
95 3.2627812189920129e-004, -6.9106902511490413e-005,
96 1.0122897863125124e-005, -7.7531878906846174e-007,};
97 static const double HBKernel_13A[ 13 ] = { // -215.1364 dB, 4
98 6.2816416252367324e-001, -1.8809076955230414e-001,
99 9.0918539867353029e-002, -4.6765502683599310e-002,
100 2.3287520498995663e-002, -1.0760627245014184e-002,
101 4.4853922948425683e-003, -1.6438775426910800e-003,
102 5.1441312354764978e-004, -1.3211725685765050e-004,
103 2.6191319837779187e-005, -3.5802430606313093e-006,
104 2.5491278270628601e-007,};
105 static const double HBKernel_14A[ 14 ] = { // -230.7526 dB, 4
106 6.2875473120929948e-001, -1.8969941936903847e-001,
107 9.3126094480960403e-002, -4.9067251179869126e-002,
108 2.5273008851199916e-002, -1.2218646153393291e-002,
109 5.4048942085580280e-003, -2.1409919546078581e-003,
110 7.4250292812927973e-004, -2.1924542206832172e-004,
111 5.3015808983125091e-005, -9.8743034923598196e-006,
112 1.2650391141650221e-006, -8.4146674637474946e-008,};
113 static const int FltCountA = 11;
114 static const int FlttBaseA = 4;
115 static const double FltAttensA[ FltCountA ] = {
116 54.5176, 66.3075, 89.5271, 105.2842, 121.0063, 136.6982, 152.3572, 183.7962, 199.4768, 215.1364, 230.7526, };
117 static const double* const FltPtrsA[ FltCountA ] = {
118 HBKernel_4A, HBKernel_5A, HBKernel_6A, HBKernel_7A, HBKernel_8A, HBKernel_9A, HBKernel_10A, HBKernel_11A, HBKernel_12A, HBKernel_13A, HBKernel_14A, };
119 static const double HBKernel_2B[ 2 ] = { // -56.6007 dB, 8
120 5.7361525854329076e-001, -7.5092074924827903e-002,};
121 static const double HBKernel_3B[ 3 ] = { // -83.0295 dB, 8
122 5.9277038608066912e-001, -1.0851340190268854e-001,
123 1.5813570475513079e-002,};
124 static const double HBKernel_4B[ 4 ] = { // -123.4724 dB, 8
125 6.0140277542879617e-001, -1.2564483854574138e-001,
126 2.7446500598038322e-002, -3.2051079559057435e-003,};
127 static const double HBKernel_5B[ 5 ] = { // -152.4411 dB, 8
128 6.0818642429088932e-001, -1.3981140187175697e-001,
129 3.8489164054503623e-002, -7.6218861797853104e-003,
130 7.5772358130952392e-004,};
131 static const double HBKernel_6B[ 6 ] = { // -181.2501 dB, 8
132 6.1278392271464355e-001, -1.5000053762513338e-001,
133 4.7575323511364960e-002, -1.2320702802243476e-002,
134 2.1462442592348487e-003, -1.8425092381892940e-004,};
135 static const double HBKernel_7B[ 7 ] = { // -209.9472 dB, 8
136 6.1610372263478952e-001, -1.5767891882524138e-001,
137 5.5089691170294691e-002, -1.6895755656366061e-002,
138 3.9416643438213977e-003, -6.0603623791604668e-004,
139 4.5632602433393365e-005,};
140 static const double HBKernel_8B[ 8 ] = { // -238.5616 dB, 8
141 6.1861282914465976e-001, -1.6367179451225150e-001,
142 6.1369861342939716e-002, -2.1184466539006987e-002,
143 5.9623357510842061e-003, -1.2483098507454090e-003,
144 1.7099297537964702e-004, -1.1448313239478885e-005,};
145 static const int FltCountB = 7;
146 static const int FlttBaseB = 2;
147 static const double FltAttensB[ FltCountB ] = {
148 56.6007, 83.0295, 123.4724, 152.4411, 181.2501, 209.9472, 238.5616, };
149 static const double* const FltPtrsB[ FltCountB ] = {
150 HBKernel_2B, HBKernel_3B, HBKernel_4B, HBKernel_5B, HBKernel_6B, HBKernel_7B, HBKernel_8B, };
151 static const double HBKernel_2C[ 2 ] = { // -89.0473 dB, 16
152 5.6430278013478008e-001, -6.4338068855763375e-002,};
153 static const double HBKernel_3C[ 3 ] = { // -130.8951 dB, 16
154 5.8706402915551448e-001, -9.9362380958670449e-002,
155 1.2298637065869358e-002,};
156 static const double HBKernel_4C[ 4 ] = { // -172.3192 dB, 16
157 5.9896586134984675e-001, -1.2111680603434927e-001,
158 2.4763118076458895e-002, -2.6121758132212989e-003,};
159 static const double HBKernel_5C[ 5 ] = { // -213.4984 dB, 16
160 6.0626808285230716e-001, -1.3588224032740795e-001,
161 3.5544305238309003e-002, -6.5127022377289654e-003,
162 5.8255449565950768e-004,};
163 static const double HBKernel_6C[ 6 ] = { // -254.5186 dB, 16
164 6.1120171263351242e-001, -1.4654486853757870e-001,
165 4.4582959299131253e-002, -1.0840543858123995e-002,
166 1.7343706485509962e-003, -1.3363018567985596e-004,};
167 static const int FltCountC = 5;
168 static const int FlttBaseC = 2;
169 static const double FltAttensC[ FltCountC ] = {
170 89.0473, 130.8951, 172.3192, 213.4984, 254.5186, };
171 static const double* const FltPtrsC[ FltCountC ] = {
172 HBKernel_2C, HBKernel_3C, HBKernel_4C, HBKernel_5C, HBKernel_6C, };
173 static const double HBKernel_1D[ 1 ] = { // -54.4754 dB, 32
174 5.0188900022775451e-001,};
175 static const double HBKernel_2D[ 2 ] = { // -113.2139 dB, 32
176 5.6295152180538044e-001, -6.2953706070191726e-002,};
177 static const double HBKernel_3D[ 3 ] = { // -167.1447 dB, 32
178 5.8621968728755036e-001, -9.8080551656524531e-002,
179 1.1860868761997080e-002,};
180 static const double HBKernel_4D[ 4 ] = { // -220.6519 dB, 32
181 5.9835028657163591e-001, -1.1999986086623511e-001,
182 2.4132530854004228e-002, -2.4829565686819706e-003,};
183 static const int FltCountD = 4;
184 static const int FlttBaseD = 1;
185 static const double FltAttensD[ FltCountD ] = {
186 54.4754, 113.2139, 167.1447, 220.6519, };
187 static const double* const FltPtrsD[ FltCountD ] = {
188 HBKernel_1D, HBKernel_2D, HBKernel_3D, HBKernel_4D, };
189 static const double HBKernel_1E[ 1 ] = { // -66.5391 dB, 64
190 5.0047102586416625e-001,};
191 static const double HBKernel_2E[ 2 ] = { // -137.3173 dB, 64
192 5.6261293163933568e-001, -6.2613067826620017e-002,};
193 static const double HBKernel_3E[ 3 ] = { // -203.2997 dB, 64
194 5.8600808139396787e-001, -9.7762185880067784e-002,
195 1.1754104554493029e-002,};
196 static const double HBKernel_4E[ 4 ] = { // -268.8550 dB, 64
197 5.9819599352772002e-001, -1.1972157555011861e-001,
198 2.3977305567947922e-002, -2.4517235455853992e-003,};
199 static const int FltCountE = 4;
200 static const int FlttBaseE = 1;
201 static const double FltAttensE[ FltCountE ] = {
202 66.5391, 137.3173, 203.2997, 268.8550, };
203 static const double* const FltPtrsE[ FltCountE ] = {
204 HBKernel_1E, HBKernel_2E, HBKernel_3E, HBKernel_4E, };
205 static const double HBKernel_1F[ 1 ] = { // -82.4633 dB, 128
206 5.0007530666642896e-001,};
207 static const double HBKernel_2F[ 2 ] = { // -161.4049 dB, 128
208 5.6252823610146030e-001, -6.2528244608044792e-002,};
209 static const double HBKernel_3F[ 3 ] = { // -239.4313 dB, 128
210 5.8595514744674237e-001, -9.7682725156791952e-002,
211 1.1727577711117231e-002,};
212 static const int FltCountF = 3;
213 static const int FlttBaseF = 1;
214 static const double FltAttensF[ FltCountF ] = {
215 82.4633, 161.4049, 239.4313, };
216 static const double* const FltPtrsF[ FltCountF ] = {
217 HBKernel_1F, HBKernel_2F, HBKernel_3F, };
218 static const double HBKernel_1G[ 1 ] = { // -94.5052 dB, 256
219 5.0001882524896712e-001,};
220 static const double HBKernel_2G[ 2 ] = { // -185.4886 dB, 256
221 5.6250705922479682e-001, -6.2507059756378394e-002,};
222 static const double HBKernel_3G[ 3 ] = { // -275.5501 dB, 256
223 5.8594191201187384e-001, -9.7662868266991207e-002,
224 1.1720956255134043e-002,};
225 static const int FltCountG = 3;
226 static const int FlttBaseG = 1;
227 static const double FltAttensG[ FltCountG ] = {
228 94.5052, 185.4886, 275.5501, };
229 static const double* const FltPtrsG[ FltCountG ] = {
230 HBKernel_1G, HBKernel_2G, HBKernel_3G, };
231
232 int k = 0;
233
234 if( SteepIndex <= 0 )
235 {
236 while( k != FltCountA - 1 && FltAttensA[ k ] < ReqAtten )
237 {
238 k++;
239 }
240
241 flt = FltPtrsA[ k ];
242 fltt = FlttBaseA + k;
243 att = FltAttensA[ k ];
244 }
245 else
246 if( SteepIndex == 1 )
247 {
248 while( k != FltCountB - 1 && FltAttensB[ k ] < ReqAtten )
249 {
250 k++;
251 }
252
253 flt = FltPtrsB[ k ];
254 fltt = FlttBaseB + k;
255 att = FltAttensB[ k ];
256 }
257 else
258 if( SteepIndex == 2 )
259 {
260 while( k != FltCountC - 1 && FltAttensC[ k ] < ReqAtten )
261 {
262 k++;
263 }
264
265 flt = FltPtrsC[ k ];
266 fltt = FlttBaseC + k;
267 att = FltAttensC[ k ];
268 }
269 else
270 if( SteepIndex == 3 )
271 {
272 while( k != FltCountD - 1 && FltAttensD[ k ] < ReqAtten )
273 {
274 k++;
275 }
276
277 flt = FltPtrsD[ k ];
278 fltt = FlttBaseD + k;
279 att = FltAttensD[ k ];
280 }
281 else
282 if( SteepIndex == 4 )
283 {
284 while( k != FltCountE - 1 && FltAttensE[ k ] < ReqAtten )
285 {
286 k++;
287 }
288
289 flt = FltPtrsE[ k ];
290 fltt = FlttBaseE + k;
291 att = FltAttensE[ k ];
292 }
293 else
294 if( SteepIndex == 5 )
295 {
296 while( k != FltCountF - 1 && FltAttensF[ k ] < ReqAtten )
297 {
298 k++;
299 }
300
301 flt = FltPtrsF[ k ];
302 fltt = FlttBaseF + k;
303 att = FltAttensF[ k ];
304 }
305 else
306 {
307 while( k != FltCountG - 1 && FltAttensG[ k ] < ReqAtten )
308 {
309 k++;
310 }
311
312 flt = FltPtrsG[ k ];
313 fltt = FlttBaseG + k;
314 att = FltAttensG[ k ];
315 }
316 }
317
330
331 static void getHBFilterThird( const double ReqAtten, const int SteepIndex,
332 const double*& flt, int& fltt, double& att )
333 {
334 static const double HBKernel_3A[ 3 ] = { // -66.3726 dB, 6
335 5.9811355069551475e-001, -1.1793396656733847e-001,
336 2.0300557211946322e-002,};
337 static const double HBKernel_4A[ 4 ] = { // -90.2546 dB, 6
338 6.0645499250612578e-001, -1.3555496505481171e-001,
339 3.4022804962365975e-002, -4.9535418595798757e-003,};
340 static const double HBKernel_5A[ 5 ] = { // -126.5507 dB, 6
341 6.1014115058940210e-001, -1.4393081816629907e-001,
342 4.1760642892852244e-002, -8.9692183234056175e-003,
343 9.9871340618342070e-004,};
344 static const double HBKernel_6A[ 6 ] = { // -150.1839 dB, 6
345 6.1439563420546972e-001, -1.5360187826905250e-001,
346 5.0840891345687034e-002, -1.4053648740561121e-002,
347 2.6771286587305727e-003, -2.5815816044823123e-004,};
348 static const double HBKernel_7A[ 7 ] = { // -173.7068 dB, 6
349 6.1747493476329918e-001, -1.6087373733313212e-001,
350 5.8263075641409430e-002, -1.8872408173431318e-002,
351 4.7421376543513687e-003, -8.0196529612267474e-004,
352 6.7964807393798996e-005,};
353 static const double HBKernel_8A[ 8 ] = { // -197.1454 dB, 6
354 6.1980610947775050e-001, -1.6654070578314714e-001,
355 6.4416567441730327e-002, -2.3307744348719822e-002,
356 6.9909157372312443e-003, -1.5871946293364403e-003,
357 2.4017727382382763e-004, -1.8125308241541697e-005,};
358 static const double HBKernel_9A[ 9 ] = { // -220.5199 dB, 6
359 6.2163188951899306e-001, -1.7108115323810941e-001,
360 6.9588370095600260e-002, -2.7339625080613838e-002,
361 9.2954469183791771e-003, -2.5537179959555429e-003,
362 5.2572290897951021e-004, -7.1813356135154921e-005,
363 4.8802382808892154e-006,};
364 static const int FltCountA = 7;
365 static const int FlttBaseA = 3;
366 static const double FltAttensA[ FltCountA ] = {
367 66.3726, 90.2546, 126.5507, 150.1839, 173.7068, 197.1454, 220.5199, };
368 static const double* const FltPtrsA[ FltCountA ] = {
369 HBKernel_3A, HBKernel_4A, HBKernel_5A, HBKernel_6A, HBKernel_7A, HBKernel_8A, HBKernel_9A, };
370 static const double HBKernel_2B[ 2 ] = { // -71.0965 dB, 12
371 5.6748544264806311e-001, -6.7764090509431732e-002,};
372 static const double HBKernel_3B[ 3 ] = { // -115.7707 dB, 12
373 5.8793612182667199e-001, -1.0070583248877293e-001,
374 1.2771337947163834e-002,};
375 static const double HBKernel_4B[ 4 ] = { // -152.1535 dB, 12
376 5.9960155600862808e-001, -1.2228154335199336e-001,
377 2.5433718917694709e-002, -2.7537562530837154e-003,};
378 static const double HBKernel_5B[ 5 ] = { // -188.2914 dB, 12
379 6.0676859170554343e-001, -1.3689667009876413e-001,
380 3.6288512631926818e-002, -6.7838855305035351e-003,
381 6.2345167677087547e-004,};
382 static const double HBKernel_6B[ 6 ] = { // -224.2705 dB, 12
383 6.1161456341904397e-001, -1.4743901958274458e-001,
384 4.5344160157313275e-002, -1.1207371780924531e-002,
385 1.8328497112594935e-003, -1.4518193006359589e-004,};
386 static const int FltCountB = 5;
387 static const int FlttBaseB = 2;
388 static const double FltAttensB[ FltCountB ] = {
389 71.0965, 115.7707, 152.1535, 188.2914, 224.2705, };
390 static const double* const FltPtrsB[ FltCountB ] = {
391 HBKernel_2B, HBKernel_3B, HBKernel_4B, HBKernel_5B, HBKernel_6B, };
392 static const double HBKernel_1C[ 1 ] = { // -49.4544 dB, 24
393 5.0336730531430562e-001,};
394 static const double HBKernel_2C[ 2 ] = { // -103.1970 dB, 24
395 5.6330232648142819e-001, -6.3309247177420452e-002,};
396 static const double HBKernel_3C[ 3 ] = { // -152.1195 dB, 24
397 5.8643891113580415e-001, -9.8411593011583087e-002,
398 1.1972706651483846e-002,};
399 static const double HBKernel_4C[ 4 ] = { // -200.6182 dB, 24
400 5.9851012363917222e-001, -1.2028885239978220e-001,
401 2.4294521083140615e-002, -2.5157924156609776e-003,};
402 static const double HBKernel_5C[ 5 ] = { // -248.8730 dB, 24
403 6.0590922882030196e-001, -1.3515953438018685e-001,
404 3.5020857107815606e-002, -6.3256196990467053e-003,
405 5.5506815147598793e-004,};
406 static const int FltCountC = 5;
407 static const int FlttBaseC = 1;
408 static const double FltAttensC[ FltCountC ] = {
409 49.4544, 103.1970, 152.1195, 200.6182, 248.8730, };
410 static const double* const FltPtrsC[ FltCountC ] = {
411 HBKernel_1C, HBKernel_2C, HBKernel_3C, HBKernel_4C, HBKernel_5C, };
412 static const double HBKernel_1D[ 1 ] = { // -61.5357 dB, 48
413 5.0083794231068057e-001,};
414 static const double HBKernel_2D[ 2 ] = { // -127.3167 dB, 48
415 5.6270074379958690e-001, -6.2701174487726344e-002,};
416 static const double HBKernel_3D[ 3 ] = { // -188.2990 dB, 48
417 5.8606296210323228e-001, -9.7844644765123029e-002,
418 1.1781683046528768e-002,};
419 static const double HBKernel_4D[ 4 ] = { // -248.8580 dB, 48
420 5.9823601243162516e-001, -1.1979368994739022e-001,
421 2.4017458606412575e-002, -2.4597810910081913e-003,};
422 static const int FltCountD = 4;
423 static const int FlttBaseD = 1;
424 static const double FltAttensD[ FltCountD ] = {
425 61.5357, 127.3167, 188.2990, 248.8580, };
426 static const double* const FltPtrsD[ FltCountD ] = {
427 HBKernel_1D, HBKernel_2D, HBKernel_3D, HBKernel_4D, };
428 static const double HBKernel_1E[ 1 ] = { // -77.4651 dB, 96
429 5.0013388897382527e-001,};
430 static const double HBKernel_2E[ 2 ] = { // -151.4084 dB, 96
431 5.6255019604317880e-001, -6.2550222932381064e-002,};
432 static const double HBKernel_3E[ 3 ] = { // -224.4365 dB, 96
433 5.8596887234201078e-001, -9.7703321113080305e-002,
434 1.1734448777069783e-002,};
435 static const int FltCountE = 3;
436 static const int FlttBaseE = 1;
437 static const double FltAttensE[ FltCountE ] = {
438 77.4651, 151.4084, 224.4365, };
439 static const double* const FltPtrsE[ FltCountE ] = {
440 HBKernel_1E, HBKernel_2E, HBKernel_3E, };
441 static const double HBKernel_1F[ 1 ] = { // -89.5075 dB, 192
442 5.0003346776264190e-001,};
443 static const double HBKernel_2F[ 2 ] = { // -175.4932 dB, 192
444 5.6251254964097952e-001, -6.2512551321105267e-002,};
445 static const double HBKernel_3F[ 3 ] = { // -260.5645 dB, 192
446 5.8594534336747051e-001, -9.7668015838639821e-002,
447 1.1722672471262996e-002,};
448 static const int FltCountF = 3;
449 static const int FlttBaseF = 1;
450 static const double FltAttensF[ FltCountF ] = {
451 89.5075, 175.4932, 260.5645, };
452 static const double* const FltPtrsF[ FltCountF ] = {
453 HBKernel_1F, HBKernel_2F, HBKernel_3F, };
454 static const double HBKernel_1G[ 1 ] = { // -101.5490 dB, 384
455 5.0000836666064941e-001,};
456 static const double HBKernel_2G[ 2 ] = { // -199.5761 dB, 384
457 5.6250313744943459e-001, -6.2503137554435345e-002,};
458 static const double HBKernel_3G[ 3 ] = { // -296.5185 dB, 384
459 5.8593945786963764e-001, -9.7659186853499613e-002,
460 1.1719728983863425e-002,};
461 static const int FltCountG = 3;
462 static const int FlttBaseG = 1;
463 static const double FltAttensG[ FltCountG ] = {
464 101.5490, 199.5761, 296.5185, };
465 static const double* const FltPtrsG[ FltCountG ] = {
466 HBKernel_1G, HBKernel_2G, HBKernel_3G, };
467
468 int k = 0;
469
470 if( SteepIndex <= 0 )
471 {
472 while( k != FltCountA - 1 && FltAttensA[ k ] < ReqAtten )
473 {
474 k++;
475 }
476
477 flt = FltPtrsA[ k ];
478 fltt = FlttBaseA + k;
479 att = FltAttensA[ k ];
480 }
481 else
482 if( SteepIndex == 1 )
483 {
484 while( k != FltCountB - 1 && FltAttensB[ k ] < ReqAtten )
485 {
486 k++;
487 }
488
489 flt = FltPtrsB[ k ];
490 fltt = FlttBaseB + k;
491 att = FltAttensB[ k ];
492 }
493 else
494 if( SteepIndex == 2 )
495 {
496 while( k != FltCountC - 1 && FltAttensC[ k ] < ReqAtten )
497 {
498 k++;
499 }
500
501 flt = FltPtrsC[ k ];
502 fltt = FlttBaseC + k;
503 att = FltAttensC[ k ];
504 }
505 else
506 if( SteepIndex == 3 )
507 {
508 while( k != FltCountD - 1 && FltAttensD[ k ] < ReqAtten )
509 {
510 k++;
511 }
512
513 flt = FltPtrsD[ k ];
514 fltt = FlttBaseD + k;
515 att = FltAttensD[ k ];
516 }
517 else
518 if( SteepIndex == 4 )
519 {
520 while( k != FltCountE - 1 && FltAttensE[ k ] < ReqAtten )
521 {
522 k++;
523 }
524
525 flt = FltPtrsE[ k ];
526 fltt = FlttBaseE + k;
527 att = FltAttensE[ k ];
528 }
529 else
530 if( SteepIndex == 5 )
531 {
532 while( k != FltCountF - 1 && FltAttensF[ k ] < ReqAtten )
533 {
534 k++;
535 }
536
537 flt = FltPtrsF[ k ];
538 fltt = FlttBaseF + k;
539 att = FltAttensF[ k ];
540 }
541 else
542 {
543 while( k != FltCountG - 1 && FltAttensG[ k ] < ReqAtten )
544 {
545 k++;
546 }
547
548 flt = FltPtrsG[ k ];
549 fltt = FlttBaseG + k;
550 att = FltAttensG[ k ];
551 }
552 }
553
571
572 CDSPHBUpsampler( const double ReqAtten, const int SteepIndex,
573 const bool IsThird, const double PrevLatency,
574 const bool aDoConsumeLatency = true )
575 : DoConsumeLatency( aDoConsumeLatency )
576 {
577 static const CConvolveFn FltConvFn[ 14 ] = {
578 &CDSPHBUpsampler :: convolve1, &CDSPHBUpsampler :: convolve2,
579 &CDSPHBUpsampler :: convolve3, &CDSPHBUpsampler :: convolve4,
580 &CDSPHBUpsampler :: convolve5, &CDSPHBUpsampler :: convolve6,
581 &CDSPHBUpsampler :: convolve7, &CDSPHBUpsampler :: convolve8,
582 &CDSPHBUpsampler :: convolve9, &CDSPHBUpsampler :: convolve10,
583 &CDSPHBUpsampler :: convolve11, &CDSPHBUpsampler :: convolve12,
584 &CDSPHBUpsampler :: convolve13, &CDSPHBUpsampler :: convolve14 };
585
586 const double* fltp0;
587 int fltt;
588 double att;
589
590 if( IsThird )
591 {
592 getHBFilterThird( ReqAtten, SteepIndex, fltp0, fltt, att );
593 }
594 else
595 {
596 getHBFilter( ReqAtten, SteepIndex, fltp0, fltt, att );
597 }
598
599 // Copy obtained filter to address-aligned buffer.
600
601 fltp = alignptr( FltBuf, 16 );
602 memcpy( fltp, fltp0, (size_t) fltt * sizeof( fltp[ 0 ]));
603
604 convfn = FltConvFn[ fltt - 1 ];
605 fll = fltt - 1;
606 fl2 = fltt;
607 flo = fll + fl2;
608 BufRP = Buf + fll;
609
610 LatencyFrac = PrevLatency * 2.0;
611 Latency = (int) LatencyFrac;
612 LatencyFrac -= Latency;
613
614 R8BASSERT( Latency >= 0 );
615
616 if( DoConsumeLatency )
617 {
618 flb = BufLen - fll;
619 }
620 else
621 {
622 Latency += fl2 + fl2;
623 flb = BufLen - flo;
624 }
625
626 R8BCONSOLE( "CDSPHBUpsampler: sti=%i third=%i taps=%i att=%.1f "
627 "io=2/1\n", SteepIndex, (int) IsThird, fltt, att );
628
629 clear();
630 }
631
632 virtual int getInLenBeforeOutPos( const int ReqOutPos ) const
633 {
634 return( fl2 + (int) (( Latency + LatencyFrac + ReqOutPos ) * 0.5 ));
635 }
636
637 virtual int getLatency() const
638 {
639 return( DoConsumeLatency ? 0 : Latency );
640 }
641
642 virtual double getLatencyFrac() const
643 {
644 return( LatencyFrac );
645 }
646
647 virtual int getMaxOutLen( const int MaxInLen ) const
648 {
649 R8BASSERT( MaxInLen >= 0 );
650
651 return( MaxInLen * 2 );
652 }
653
654 virtual void clear()
655 {
656 if( DoConsumeLatency )
657 {
658 LatencyLeft = Latency;
659 BufLeft = 0;
660 }
661 else
662 {
663 LatencyLeft = 0;
664 BufLeft = fl2;
665 }
666
667 WritePos = 0;
668 ReadPos = flb; // Set "read" position to account for filter's latency.
669
670 memset( &Buf[ ReadPos ], 0,
671 (size_t) ( BufLen - flb ) * sizeof( Buf[ 0 ]));
672 }
673
674 virtual int process( double* ip, int l, double*& op0 )
675 {
676 R8BASSERT( l >= 0 );
677
678 double* op = op0;
679
680 while( l > 0 )
681 {
682 // Copy new input samples to the ring buffer.
683
684 const int b = min( l, min( BufLen - WritePos, flb - BufLeft ));
685
686 double* const wp1 = Buf + WritePos;
687 memcpy( wp1, ip, (size_t) b * sizeof( wp1[ 0 ]));
688 const int ec = flo - WritePos;
689
690 if( ec > 0 )
691 {
692 memcpy( wp1 + BufLen, ip,
693 (size_t) min( b, ec ) * sizeof( wp1[ 0 ]));
694 }
695
696 ip += b;
697 WritePos = ( WritePos + b ) & BufLenMask;
698 l -= b;
699 BufLeft += b;
700
701 // Produce output.
702
703 const int c = BufLeft - fl2;
704
705 if( c > 0 )
706 {
707 double* const opend = op + c * 2;
708 ( *convfn )( op, opend, fltp, BufRP, ReadPos );
709
710 op = opend;
711 ReadPos = ( ReadPos + c ) & BufLenMask;
712 BufLeft -= c;
713 }
714 }
715
716 int ol = (int) ( op - op0 );
717
718 if( LatencyLeft != 0 )
719 {
720 if( LatencyLeft >= ol )
721 {
722 LatencyLeft -= ol;
723 return( 0 );
724 }
725
726 ol -= LatencyLeft;
727 op0 += LatencyLeft;
728 LatencyLeft = 0;
729 }
730
731 return( ol );
732 }
733
734private:
735 static const int BufLenBits = 9;
741 static const int BufLen = 1 << BufLenBits;
744 static const int BufLenMask = BufLen - 1;
746 double Buf[ BufLen + 27 ];
748 double FltBuf[ 14 + 2 ];
750 const double* BufRP;
751 double* fltp;
752 int fll;
753 int fl2;
754 int flo;
755 int flb;
756 double LatencyFrac;
757 int Latency;
758 int LatencyLeft;
759 int BufLeft;
761 int WritePos;
763 int ReadPos;
764 bool DoConsumeLatency;
767
768 typedef void( *CConvolveFn )( double* op, double* const opend,
769 const double* const flt, const double* const rp0, int rpos );
771 CConvolveFn convfn;
772
773#define R8BHBC1( fn ) \
774 static void fn( double* op, double* const opend, const double* const flt, \
775 const double* const rp0, int rpos ) \
776 { \
777 while( op != opend ) \
778 { \
779 const double* const rp = rp0 + rpos; \
780 op[ 0 ] = rp[ 0 ];
781
782#define R8BHBC2 \
783 rpos = ( rpos + 1 ) & BufLenMask; \
784 op += 2; \
785 } \
786 }
787
788#include "CDSPHBUpsampler.inc"
789
790#undef R8BHBC1
791#undef R8BHBC2
792};
793
794// ---------------------------------------------------------------------------
795
796} // namespace r8b
797
798#endif // R8B_CDSPHBUPSAMPLER_INCLUDED
CDSPProcessor.h
The base virtual class for DSP processing algorithms.
R8BASSERT
#define R8BASSERT(e)
Assertion macro used to check for certain run-time conditions. By default, no action is taken if asse...
Definition r8bconf.h:28
R8BCONSOLE
#define R8BCONSOLE(...)
Console output macro, used to output various resampler status strings, including filter design parame...
Definition r8bconf.h:41
r8b
The "r8brain-free-src" library namespace.
Definition CDSPBlockConvolver.h:22
r8b::alignptr
T * alignptr(T *const ptr, const uintptr_t align)
Forces the provided ptr pointer to be aligned to align bytes.
Definition r8bbase.h:256
r8b::min
T min(const T &v1, const T &v2)
Returns minimum of two values.
Definition r8bbase.h:1079
r8b::CDSPHBUpsampler::getMaxOutLen
virtual int getMaxOutLen(const int MaxInLen) const
Returns the maximal length of the output buffer required when processing the MaxInLen number of input...
Definition CDSPHBUpsampler.h:647
r8b::CDSPHBUpsampler::getLatencyFrac
virtual double getLatencyFrac() const
Returns fractional latency, in samples, which is present in the output signal.
Definition CDSPHBUpsampler.h:642
r8b::CDSPHBUpsampler::getHBFilter
static void getHBFilter(const double ReqAtten, const int SteepIndex, const double *&flt, int &fltt, double &att)
Provides filter data for various steepness indices and attenuations.
Definition CDSPHBUpsampler.h:47
r8b::CDSPHBUpsampler::getHBFilterThird
static void getHBFilterThird(const double ReqAtten, const int SteepIndex, const double *&flt, int &fltt, double &att)
Provides filter data for various steepness indices and attenuations. For 1/3 resamplings.
Definition CDSPHBUpsampler.h:331
r8b::CDSPHBUpsampler::clear
virtual void clear()
Clears (resets) the state of this object and returns it to the state after construction.
Definition CDSPHBUpsampler.h:654
r8b::CDSPHBUpsampler::CDSPHBUpsampler
CDSPHBUpsampler(const double ReqAtten, const int SteepIndex, const bool IsThird, const double PrevLatency, const bool aDoConsumeLatency=true)
Initalizes the half-band upsampler.
Definition CDSPHBUpsampler.h:572
r8b::CDSPHBUpsampler::process
virtual int process(double *ip, int l, double *&op0)
Performs DSP processing.
Definition CDSPHBUpsampler.h:674
r8b::CDSPHBUpsampler::getInLenBeforeOutPos
virtual int getInLenBeforeOutPos(const int ReqOutPos) const
Returns the number of input samples required to advance to the specified output sample position (so t...
Definition CDSPHBUpsampler.h:632
r8b::CDSPHBUpsampler::getLatency
virtual int getLatency() const
Return the latency, in samples, which is present in the output signal.
Definition CDSPHBUpsampler.h:637