steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/include/r8brain/CDSPHBUpsampler.h

805 lines
27 KiB
C++
Raw Blame History

//$ nobt
//$ nocpp
/**
* @file CDSPHBUpsampler.h
*
* @brief Half-band upsampling class.
*
* This file includes half-band upsampling class.
*
* r8brain-free-src Copyright (c) 2013-2022 Aleksey Vaneev
* See the "LICENSE" file for license.
*/
#ifndef R8B_CDSPHBUPSAMPLER_INCLUDED
#define R8B_CDSPHBUPSAMPLER_INCLUDED
#include "CDSPProcessor.h"
namespace r8b {
/**
* @brief Half-band upsampling class.
*
* Class implements brute-force half-band 2X upsampling that uses small
* sparse symmetric FIR filters. It is very efficient and should be used at
* latter upsampling steps after initial steep 2X upsampling.
*/
class CDSPHBUpsampler : public CDSPProcessor
{
public:
/**
* Function that provides filter data for various steepness indices and
* attenuations.
*
* @param ReqAtten Required half-band filter attentuation.
* @param SteepIndex Steepness index - 0=steepest. Corresponds to general
* upsampling/downsampling ratio, e.g. at 4x 0 is used, at 8x 1 is used,
* etc.
*/
static void getHBFilter( const double ReqAtten, const int SteepIndex,
const double*& flt, int& fltt, double& att )
{
static const double HBKernel_4A[ 4 ] = { // -54.5176 dB, 4
6.1729335650971517e-001, -1.5963945620743250e-001,
5.5073370934086312e-002, -1.4603578989932850e-002,};
static const double HBKernel_5A[ 5 ] = { // -66.3075 dB, 4
6.2068807424902472e-001, -1.6827573634467302e-001,
6.5263016720721170e-002, -2.2483331611592005e-002,
5.2917326684281110e-003,};
static const double HBKernel_6A[ 6 ] = { // -89.5271 dB, 4
6.2187202340480707e-001, -1.7132842113816371e-001,
6.9019169178765674e-002, -2.5799728312695277e-002,
7.4880112525741666e-003, -1.2844465869952567e-003,};
static const double HBKernel_7A[ 7 ] = { // -105.2842 dB, 4
6.2354494135775851e-001, -1.7571220703702045e-001,
7.4529843603968457e-002, -3.0701736822442153e-002,
1.0716755639039573e-002, -2.7833422930759735e-003,
4.1118797093875510e-004,};
static const double HBKernel_8A[ 8 ] = { // -121.0063 dB, 4
6.2488363107953926e-001, -1.7924942606514119e-001,
7.9068155655640557e-002, -3.4907523415495731e-002,
1.3710256799907897e-002, -4.3991142586987933e-003,
1.0259190163889602e-003, -1.3278941979339359e-004,};
static const double HBKernel_9A[ 9 ] = { // -136.6982 dB, 4
6.2597763804021977e-001, -1.8216414325139055e-001,
8.2879104876726728e-002, -3.8563442248249404e-002,
1.6471530499739394e-002, -6.0489108881335227e-003,
1.7805283804140392e-003, -3.7533200112729561e-004,
4.3172840558735476e-005,};
static const double HBKernel_10A[ 10 ] = { // -152.3572 dB, 4
6.2688767582974092e-001, -1.8460766807559420e-001,
8.6128943000481864e-002, -4.1774474147006607e-002,
1.9014801985747346e-002, -7.6870397465866507e-003,
2.6264590175341853e-003, -7.1106660285478562e-004,
1.3645852036179345e-004, -1.4113888783332969e-005,};
static const double HBKernel_11A[ 11 ] = { // -183.7962 dB, 4
6.2667167706948146e-001, -1.8407153342635879e-001,
8.5529995610836046e-002, -4.1346831462361310e-002,
1.8844831691322637e-002, -7.7125170365394992e-003,
2.7268674860562087e-003, -7.9745028501057233e-004,
1.8116344606360795e-004, -2.8569149754241848e-005,
2.3667022010173616e-006,};
static const double HBKernel_12A[ 12 ] = { // -199.4768 dB, 4
6.2747849730367999e-001, -1.8623616784506747e-001,
8.8409755898467945e-002, -4.4207468821462342e-002,
2.1149175945115381e-002, -9.2551508371115209e-003,
3.5871562170822330e-003, -1.1923167653750219e-003,
3.2627812189920129e-004, -6.9106902511490413e-005,
1.0122897863125124e-005, -7.7531878906846174e-007,};
static const double HBKernel_13A[ 13 ] = { // -215.1364 dB, 4
6.2816416252367324e-001, -1.8809076955230414e-001,
9.0918539867353029e-002, -4.6765502683599310e-002,
2.3287520498995663e-002, -1.0760627245014184e-002,
4.4853922948425683e-003, -1.6438775426910800e-003,
5.1441312354764978e-004, -1.3211725685765050e-004,
2.6191319837779187e-005, -3.5802430606313093e-006,
2.5491278270628601e-007,};
static const double HBKernel_14A[ 14 ] = { // -230.7526 dB, 4
6.2875473120929948e-001, -1.8969941936903847e-001,
9.3126094480960403e-002, -4.9067251179869126e-002,
2.5273008851199916e-002, -1.2218646153393291e-002,
5.4048942085580280e-003, -2.1409919546078581e-003,
7.4250292812927973e-004, -2.1924542206832172e-004,
5.3015808983125091e-005, -9.8743034923598196e-006,
1.2650391141650221e-006, -8.4146674637474946e-008,};
static const int FltCountA = 11;
static const int FlttBaseA = 4;
static const double FltAttensA[ FltCountA ] = {
54.5176, 66.3075, 89.5271, 105.2842, 121.0063, 136.6982, 152.3572, 183.7962, 199.4768, 215.1364, 230.7526, };
static const double* const FltPtrsA[ FltCountA ] = {
HBKernel_4A, HBKernel_5A, HBKernel_6A, HBKernel_7A, HBKernel_8A, HBKernel_9A, HBKernel_10A, HBKernel_11A, HBKernel_12A, HBKernel_13A, HBKernel_14A, };
static const double HBKernel_2B[ 2 ] = { // -56.6007 dB, 8
5.7361525854329076e-001, -7.5092074924827903e-002,};
static const double HBKernel_3B[ 3 ] = { // -83.0295 dB, 8
5.9277038608066912e-001, -1.0851340190268854e-001,
1.5813570475513079e-002,};
static const double HBKernel_4B[ 4 ] = { // -123.4724 dB, 8
6.0140277542879617e-001, -1.2564483854574138e-001,
2.7446500598038322e-002, -3.2051079559057435e-003,};
static const double HBKernel_5B[ 5 ] = { // -152.4411 dB, 8
6.0818642429088932e-001, -1.3981140187175697e-001,
3.8489164054503623e-002, -7.6218861797853104e-003,
7.5772358130952392e-004,};
static const double HBKernel_6B[ 6 ] = { // -181.2501 dB, 8
6.1278392271464355e-001, -1.5000053762513338e-001,
4.7575323511364960e-002, -1.2320702802243476e-002,
2.1462442592348487e-003, -1.8425092381892940e-004,};
static const double HBKernel_7B[ 7 ] = { // -209.9472 dB, 8
6.1610372263478952e-001, -1.5767891882524138e-001,
5.5089691170294691e-002, -1.6895755656366061e-002,
3.9416643438213977e-003, -6.0603623791604668e-004,
4.5632602433393365e-005,};
static const double HBKernel_8B[ 8 ] = { // -238.5616 dB, 8
6.1861282914465976e-001, -1.6367179451225150e-001,
6.1369861342939716e-002, -2.1184466539006987e-002,
5.9623357510842061e-003, -1.2483098507454090e-003,
1.7099297537964702e-004, -1.1448313239478885e-005,};
static const int FltCountB = 7;
static const int FlttBaseB = 2;
static const double FltAttensB[ FltCountB ] = {
56.6007, 83.0295, 123.4724, 152.4411, 181.2501, 209.9472, 238.5616, };
static const double* const FltPtrsB[ FltCountB ] = {
HBKernel_2B, HBKernel_3B, HBKernel_4B, HBKernel_5B, HBKernel_6B, HBKernel_7B, HBKernel_8B, };
static const double HBKernel_2C[ 2 ] = { // -89.0473 dB, 16
5.6430278013478008e-001, -6.4338068855763375e-002,};
static const double HBKernel_3C[ 3 ] = { // -130.8951 dB, 16
5.8706402915551448e-001, -9.9362380958670449e-002,
1.2298637065869358e-002,};
static const double HBKernel_4C[ 4 ] = { // -172.3192 dB, 16
5.9896586134984675e-001, -1.2111680603434927e-001,
2.4763118076458895e-002, -2.6121758132212989e-003,};
static const double HBKernel_5C[ 5 ] = { // -213.4984 dB, 16
6.0626808285230716e-001, -1.3588224032740795e-001,
3.5544305238309003e-002, -6.5127022377289654e-003,
5.8255449565950768e-004,};
static const double HBKernel_6C[ 6 ] = { // -254.5186 dB, 16
6.1120171263351242e-001, -1.4654486853757870e-001,
4.4582959299131253e-002, -1.0840543858123995e-002,
1.7343706485509962e-003, -1.3363018567985596e-004,};
static const int FltCountC = 5;
static const int FlttBaseC = 2;
static const double FltAttensC[ FltCountC ] = {
89.0473, 130.8951, 172.3192, 213.4984, 254.5186, };
static const double* const FltPtrsC[ FltCountC ] = {
HBKernel_2C, HBKernel_3C, HBKernel_4C, HBKernel_5C, HBKernel_6C, };
static const double HBKernel_1D[ 1 ] = { // -54.4754 dB, 32
5.0188900022775451e-001,};
static const double HBKernel_2D[ 2 ] = { // -113.2139 dB, 32
5.6295152180538044e-001, -6.2953706070191726e-002,};
static const double HBKernel_3D[ 3 ] = { // -167.1447 dB, 32
5.8621968728755036e-001, -9.8080551656524531e-002,
1.1860868761997080e-002,};
static const double HBKernel_4D[ 4 ] = { // -220.6519 dB, 32
5.9835028657163591e-001, -1.1999986086623511e-001,
2.4132530854004228e-002, -2.4829565686819706e-003,};
static const int FltCountD = 4;
static const int FlttBaseD = 1;
static const double FltAttensD[ FltCountD ] = {
54.4754, 113.2139, 167.1447, 220.6519, };
static const double* const FltPtrsD[ FltCountD ] = {
HBKernel_1D, HBKernel_2D, HBKernel_3D, HBKernel_4D, };
static const double HBKernel_1E[ 1 ] = { // -66.5391 dB, 64
5.0047102586416625e-001,};
static const double HBKernel_2E[ 2 ] = { // -137.3173 dB, 64
5.6261293163933568e-001, -6.2613067826620017e-002,};
static const double HBKernel_3E[ 3 ] = { // -203.2997 dB, 64
5.8600808139396787e-001, -9.7762185880067784e-002,
1.1754104554493029e-002,};
static const double HBKernel_4E[ 4 ] = { // -268.8550 dB, 64
5.9819599352772002e-001, -1.1972157555011861e-001,
2.3977305567947922e-002, -2.4517235455853992e-003,};
static const int FltCountE = 4;
static const int FlttBaseE = 1;
static const double FltAttensE[ FltCountE ] = {
66.5391, 137.3173, 203.2997, 268.8550, };
static const double* const FltPtrsE[ FltCountE ] = {
HBKernel_1E, HBKernel_2E, HBKernel_3E, HBKernel_4E, };
static const double HBKernel_1F[ 1 ] = { // -82.4633 dB, 128
5.0007530666642896e-001,};
static const double HBKernel_2F[ 2 ] = { // -161.4049 dB, 128
5.6252823610146030e-001, -6.2528244608044792e-002,};
static const double HBKernel_3F[ 3 ] = { // -239.4313 dB, 128
5.8595514744674237e-001, -9.7682725156791952e-002,
1.1727577711117231e-002,};
static const int FltCountF = 3;
static const int FlttBaseF = 1;
static const double FltAttensF[ FltCountF ] = {
82.4633, 161.4049, 239.4313, };
static const double* const FltPtrsF[ FltCountF ] = {
HBKernel_1F, HBKernel_2F, HBKernel_3F, };
static const double HBKernel_1G[ 1 ] = { // -94.5052 dB, 256
5.0001882524896712e-001,};
static const double HBKernel_2G[ 2 ] = { // -185.4886 dB, 256
5.6250705922479682e-001, -6.2507059756378394e-002,};
static const double HBKernel_3G[ 3 ] = { // -275.5501 dB, 256
5.8594191201187384e-001, -9.7662868266991207e-002,
1.1720956255134043e-002,};
static const int FltCountG = 3;
static const int FlttBaseG = 1;
static const double FltAttensG[ FltCountG ] = {
94.5052, 185.4886, 275.5501, };
static const double* const FltPtrsG[ FltCountG ] = {
HBKernel_1G, HBKernel_2G, HBKernel_3G, };
int k = 0;
if( SteepIndex <= 0 )
{
while( k != FltCountA - 1 && FltAttensA[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsA[ k ];
fltt = FlttBaseA + k;
att = FltAttensA[ k ];
}
else
if( SteepIndex == 1 )
{
while( k != FltCountB - 1 && FltAttensB[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsB[ k ];
fltt = FlttBaseB + k;
att = FltAttensB[ k ];
}
else
if( SteepIndex == 2 )
{
while( k != FltCountC - 1 && FltAttensC[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsC[ k ];
fltt = FlttBaseC + k;
att = FltAttensC[ k ];
}
else
if( SteepIndex == 3 )
{
while( k != FltCountD - 1 && FltAttensD[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsD[ k ];
fltt = FlttBaseD + k;
att = FltAttensD[ k ];
}
else
if( SteepIndex == 4 )
{
while( k != FltCountE - 1 && FltAttensE[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsE[ k ];
fltt = FlttBaseE + k;
att = FltAttensE[ k ];
}
else
if( SteepIndex == 5 )
{
while( k != FltCountF - 1 && FltAttensF[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsF[ k ];
fltt = FlttBaseF + k;
att = FltAttensF[ k ];
}
else
{
while( k != FltCountG - 1 && FltAttensG[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsG[ k ];
fltt = FlttBaseG + k;
att = FltAttensG[ k ];
}
}
/**
* Function that provides filter data for various steepness indices and
* attenuations. For 1/3 resamplings.
*
* @param ReqAtten Required half-band filter attentuation.
* @param SteepIndex Steepness index - 0=steepest. Corresponds to general
* upsampling/downsampling ratio, e.g. at 4x 0 is used, at 8x 1 is used,
* etc.
*/
static void getHBFilterThird( const double ReqAtten, const int SteepIndex,
const double*& flt, int& fltt, double& att )
{
static const double HBKernel_3A[ 3 ] = { // -66.3726 dB, 6
5.9811355069551475e-001, -1.1793396656733847e-001,
2.0300557211946322e-002,};
static const double HBKernel_4A[ 4 ] = { // -90.2546 dB, 6
6.0645499250612578e-001, -1.3555496505481171e-001,
3.4022804962365975e-002, -4.9535418595798757e-003,};
static const double HBKernel_5A[ 5 ] = { // -126.5507 dB, 6
6.1014115058940210e-001, -1.4393081816629907e-001,
4.1760642892852244e-002, -8.9692183234056175e-003,
9.9871340618342070e-004,};
static const double HBKernel_6A[ 6 ] = { // -150.1839 dB, 6
6.1439563420546972e-001, -1.5360187826905250e-001,
5.0840891345687034e-002, -1.4053648740561121e-002,
2.6771286587305727e-003, -2.5815816044823123e-004,};
static const double HBKernel_7A[ 7 ] = { // -173.7068 dB, 6
6.1747493476329918e-001, -1.6087373733313212e-001,
5.8263075641409430e-002, -1.8872408173431318e-002,
4.7421376543513687e-003, -8.0196529612267474e-004,
6.7964807393798996e-005,};
static const double HBKernel_8A[ 8 ] = { // -197.1454 dB, 6
6.1980610947775050e-001, -1.6654070578314714e-001,
6.4416567441730327e-002, -2.3307744348719822e-002,
6.9909157372312443e-003, -1.5871946293364403e-003,
2.4017727382382763e-004, -1.8125308241541697e-005,};
static const double HBKernel_9A[ 9 ] = { // -220.5199 dB, 6
6.2163188951899306e-001, -1.7108115323810941e-001,
6.9588370095600260e-002, -2.7339625080613838e-002,
9.2954469183791771e-003, -2.5537179959555429e-003,
5.2572290897951021e-004, -7.1813356135154921e-005,
4.8802382808892154e-006,};
static const int FltCountA = 7;
static const int FlttBaseA = 3;
static const double FltAttensA[ FltCountA ] = {
66.3726, 90.2546, 126.5507, 150.1839, 173.7068, 197.1454, 220.5199, };
static const double* const FltPtrsA[ FltCountA ] = {
HBKernel_3A, HBKernel_4A, HBKernel_5A, HBKernel_6A, HBKernel_7A, HBKernel_8A, HBKernel_9A, };
static const double HBKernel_2B[ 2 ] = { // -71.0965 dB, 12
5.6748544264806311e-001, -6.7764090509431732e-002,};
static const double HBKernel_3B[ 3 ] = { // -115.7707 dB, 12
5.8793612182667199e-001, -1.0070583248877293e-001,
1.2771337947163834e-002,};
static const double HBKernel_4B[ 4 ] = { // -152.1535 dB, 12
5.9960155600862808e-001, -1.2228154335199336e-001,
2.5433718917694709e-002, -2.7537562530837154e-003,};
static const double HBKernel_5B[ 5 ] = { // -188.2914 dB, 12
6.0676859170554343e-001, -1.3689667009876413e-001,
3.6288512631926818e-002, -6.7838855305035351e-003,
6.2345167677087547e-004,};
static const double HBKernel_6B[ 6 ] = { // -224.2705 dB, 12
6.1161456341904397e-001, -1.4743901958274458e-001,
4.5344160157313275e-002, -1.1207371780924531e-002,
1.8328497112594935e-003, -1.4518193006359589e-004,};
static const int FltCountB = 5;
static const int FlttBaseB = 2;
static const double FltAttensB[ FltCountB ] = {
71.0965, 115.7707, 152.1535, 188.2914, 224.2705, };
static const double* const FltPtrsB[ FltCountB ] = {
HBKernel_2B, HBKernel_3B, HBKernel_4B, HBKernel_5B, HBKernel_6B, };
static const double HBKernel_1C[ 1 ] = { // -49.4544 dB, 24
5.0336730531430562e-001,};
static const double HBKernel_2C[ 2 ] = { // -103.1970 dB, 24
5.6330232648142819e-001, -6.3309247177420452e-002,};
static const double HBKernel_3C[ 3 ] = { // -152.1195 dB, 24
5.8643891113580415e-001, -9.8411593011583087e-002,
1.1972706651483846e-002,};
static const double HBKernel_4C[ 4 ] = { // -200.6182 dB, 24
5.9851012363917222e-001, -1.2028885239978220e-001,
2.4294521083140615e-002, -2.5157924156609776e-003,};
static const double HBKernel_5C[ 5 ] = { // -248.8730 dB, 24
6.0590922882030196e-001, -1.3515953438018685e-001,
3.5020857107815606e-002, -6.3256196990467053e-003,
5.5506815147598793e-004,};
static const int FltCountC = 5;
static const int FlttBaseC = 1;
static const double FltAttensC[ FltCountC ] = {
49.4544, 103.1970, 152.1195, 200.6182, 248.8730, };
static const double* const FltPtrsC[ FltCountC ] = {
HBKernel_1C, HBKernel_2C, HBKernel_3C, HBKernel_4C, HBKernel_5C, };
static const double HBKernel_1D[ 1 ] = { // -61.5357 dB, 48
5.0083794231068057e-001,};
static const double HBKernel_2D[ 2 ] = { // -127.3167 dB, 48
5.6270074379958690e-001, -6.2701174487726344e-002,};
static const double HBKernel_3D[ 3 ] = { // -188.2990 dB, 48
5.8606296210323228e-001, -9.7844644765123029e-002,
1.1781683046528768e-002,};
static const double HBKernel_4D[ 4 ] = { // -248.8580 dB, 48
5.9823601243162516e-001, -1.1979368994739022e-001,
2.4017458606412575e-002, -2.4597810910081913e-003,};
static const int FltCountD = 4;
static const int FlttBaseD = 1;
static const double FltAttensD[ FltCountD ] = {
61.5357, 127.3167, 188.2990, 248.8580, };
static const double* const FltPtrsD[ FltCountD ] = {
HBKernel_1D, HBKernel_2D, HBKernel_3D, HBKernel_4D, };
static const double HBKernel_1E[ 1 ] = { // -77.4651 dB, 96
5.0013388897382527e-001,};
static const double HBKernel_2E[ 2 ] = { // -151.4084 dB, 96
5.6255019604317880e-001, -6.2550222932381064e-002,};
static const double HBKernel_3E[ 3 ] = { // -224.4365 dB, 96
5.8596887234201078e-001, -9.7703321113080305e-002,
1.1734448777069783e-002,};
static const int FltCountE = 3;
static const int FlttBaseE = 1;
static const double FltAttensE[ FltCountE ] = {
77.4651, 151.4084, 224.4365, };
static const double* const FltPtrsE[ FltCountE ] = {
HBKernel_1E, HBKernel_2E, HBKernel_3E, };
static const double HBKernel_1F[ 1 ] = { // -89.5075 dB, 192
5.0003346776264190e-001,};
static const double HBKernel_2F[ 2 ] = { // -175.4932 dB, 192
5.6251254964097952e-001, -6.2512551321105267e-002,};
static const double HBKernel_3F[ 3 ] = { // -260.5645 dB, 192
5.8594534336747051e-001, -9.7668015838639821e-002,
1.1722672471262996e-002,};
static const int FltCountF = 3;
static const int FlttBaseF = 1;
static const double FltAttensF[ FltCountF ] = {
89.5075, 175.4932, 260.5645, };
static const double* const FltPtrsF[ FltCountF ] = {
HBKernel_1F, HBKernel_2F, HBKernel_3F, };
static const double HBKernel_1G[ 1 ] = { // -101.5490 dB, 384
5.0000836666064941e-001,};
static const double HBKernel_2G[ 2 ] = { // -199.5761 dB, 384
5.6250313744943459e-001, -6.2503137554435345e-002,};
static const double HBKernel_3G[ 3 ] = { // -296.5185 dB, 384
5.8593945786963764e-001, -9.7659186853499613e-002,
1.1719728983863425e-002,};
static const int FltCountG = 3;
static const int FlttBaseG = 1;
static const double FltAttensG[ FltCountG ] = {
101.5490, 199.5761, 296.5185, };
static const double* const FltPtrsG[ FltCountG ] = {
HBKernel_1G, HBKernel_2G, HBKernel_3G, };
int k = 0;
if( SteepIndex <= 0 )
{
while( k != FltCountA - 1 && FltAttensA[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsA[ k ];
fltt = FlttBaseA + k;
att = FltAttensA[ k ];
}
else
if( SteepIndex == 1 )
{
while( k != FltCountB - 1 && FltAttensB[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsB[ k ];
fltt = FlttBaseB + k;
att = FltAttensB[ k ];
}
else
if( SteepIndex == 2 )
{
while( k != FltCountC - 1 && FltAttensC[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsC[ k ];
fltt = FlttBaseC + k;
att = FltAttensC[ k ];
}
else
if( SteepIndex == 3 )
{
while( k != FltCountD - 1 && FltAttensD[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsD[ k ];
fltt = FlttBaseD + k;
att = FltAttensD[ k ];
}
else
if( SteepIndex == 4 )
{
while( k != FltCountE - 1 && FltAttensE[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsE[ k ];
fltt = FlttBaseE + k;
att = FltAttensE[ k ];
}
else
if( SteepIndex == 5 )
{
while( k != FltCountF - 1 && FltAttensF[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsF[ k ];
fltt = FlttBaseF + k;
att = FltAttensF[ k ];
}
else
{
while( k != FltCountG - 1 && FltAttensG[ k ] < ReqAtten )
{
k++;
}
flt = FltPtrsG[ k ];
fltt = FlttBaseG + k;
att = FltAttensG[ k ];
}
}
/**
* Constructor initalizes the half-band upsampler.
*
* @param ReqAtten Required half-band filter attentuation.
* @param SteepIndex Steepness index - 0=steepest. Corresponds to general
* upsampling ratio, e.g. at 4x upsampling 0 is used, at 8x upsampling 1
* is used, etc.
* @param IsThird "True" if 1/3 of frequency response resampling is
* performed.
* @param PrevLatency Latency, in samples (any value >=0), which was left
* in the output signal by a previous process. Whole-number latency will
* be consumed by *this object while remaining fractional latency can be
* obtained via the getLatencyFrac() function.
* @param aDoConsumeLatency "True" if the output latency should be
* consumed. Does not apply to the fractional part of the latency (if such
* part is available).
*/
CDSPHBUpsampler( const double ReqAtten, const int SteepIndex,
const bool IsThird, const double PrevLatency,
const bool aDoConsumeLatency = true )
: DoConsumeLatency( aDoConsumeLatency )
{
static const CConvolveFn FltConvFn[ 14 ] = {
&CDSPHBUpsampler :: convolve1, &CDSPHBUpsampler :: convolve2,
&CDSPHBUpsampler :: convolve3, &CDSPHBUpsampler :: convolve4,
&CDSPHBUpsampler :: convolve5, &CDSPHBUpsampler :: convolve6,
&CDSPHBUpsampler :: convolve7, &CDSPHBUpsampler :: convolve8,
&CDSPHBUpsampler :: convolve9, &CDSPHBUpsampler :: convolve10,
&CDSPHBUpsampler :: convolve11, &CDSPHBUpsampler :: convolve12,
&CDSPHBUpsampler :: convolve13, &CDSPHBUpsampler :: convolve14 };
const double* fltp0;
int fltt;
double att;
if( IsThird )
{
getHBFilterThird( ReqAtten, SteepIndex, fltp0, fltt, att );
}
else
{
getHBFilter( ReqAtten, SteepIndex, fltp0, fltt, att );
}
// Copy obtained filter to address-aligned buffer.
fltp = alignptr( FltBuf, 16 );
memcpy( fltp, fltp0, fltt * sizeof( fltp[ 0 ]));
convfn = FltConvFn[ fltt - 1 ];
fll = fltt - 1;
fl2 = fltt;
flo = fll + fl2;
BufRP = Buf + fll;
LatencyFrac = PrevLatency * 2.0;
Latency = (int) LatencyFrac;
LatencyFrac -= Latency;
R8BASSERT( Latency >= 0 );
if( DoConsumeLatency )
{
flb = BufLen - fll;
}
else
{
Latency += fl2 + fl2;
flb = BufLen - flo;
}
R8BCONSOLE( "CDSPHBUpsampler: sti=%i third=%i taps=%i att=%.1f "
"io=2/1\n", SteepIndex, (int) IsThird, fltt, att );
clear();
}
virtual int getLatency() const
{
return( DoConsumeLatency ? 0 : Latency );
}
virtual double getLatencyFrac() const
{
return( LatencyFrac );
}
virtual int getMaxOutLen( const int MaxInLen ) const
{
R8BASSERT( MaxInLen >= 0 );
return( MaxInLen << 1 );
}
virtual void clear()
{
if( DoConsumeLatency )
{
LatencyLeft = Latency;
BufLeft = 0;
}
else
{
LatencyLeft = 0;
BufLeft = fl2;
}
WritePos = 0;
ReadPos = flb; // Set "read" position to account for filter's latency.
memset( &Buf[ ReadPos ], 0, ( BufLen - flb ) * sizeof( Buf[ 0 ]));
}
virtual int process( double* ip, int l, double*& op0 )
{
R8BASSERT( l >= 0 );
double* op = op0;
while( l > 0 )
{
// Add new input samples to both halves of the ring buffer.
const int b = min( min( l, BufLen - WritePos ), flb - BufLeft );
double* const wp1 = Buf + WritePos;
memcpy( wp1, ip, b * sizeof( wp1[ 0 ]));
if( WritePos < flo )
{
const int c = min( b, flo - WritePos );
memcpy( wp1 + BufLen, wp1, c * sizeof( wp1[ 0 ]));
}
ip += b;
WritePos = ( WritePos + b ) & BufLenMask;
l -= b;
BufLeft += b;
// Produce output.
if( BufLeft > fl2 )
{
const int c = BufLeft - fl2;
double* const opend = op + ( c + c );
( *convfn )( op, opend, fltp, BufRP, ReadPos );
op = opend;
ReadPos = ( ReadPos + c ) & BufLenMask;
BufLeft -= c;
}
}
int ol = (int) ( op - op0 );
if( LatencyLeft != 0 )
{
if( LatencyLeft >= ol )
{
LatencyLeft -= ol;
return( 0 );
}
ol -= LatencyLeft;
op0 += LatencyLeft;
LatencyLeft = 0;
}
return( ol );
}
private:
static const int BufLenBits = 9; ///< The length of the ring buffer,
///< expressed as Nth power of 2. This value can be reduced if it is
///< known that only short input buffers will be passed to the
///< interpolator. The minimum value of this parameter is 5, and
///< 1 << BufLenBits should be at least 3 times larger than the
///< FilterLen.
///<
static const int BufLen = 1 << BufLenBits; ///< The length of the ring
///< buffer. The actual length is twice as long to allow "beyond max
///< position" positioning.
///<
static const int BufLenMask = BufLen - 1; ///< Mask used for quick buffer
///< position wrapping.
///<
double Buf[ BufLen + 27 ]; ///< The ring buffer, including overrun
///< protection for the largest filter.
///<
double FltBuf[ 14 + 2 ]; ///< Holder for half-band filter taps, used with
///< 16-byte address-aligning, for SIMD use.
///<
double* fltp; ///< Half-band filter taps, points to FltBuf.
///<
int fll; ///< Input latency.
///<
int fl2; ///< Right-side filter length.
///<
int flo; ///< Overrrun length.
///<
int flb; ///< Initial read position and maximal buffer write length.
///<
const double* BufRP; ///< Offseted Buf pointer at ReadPos=0.
///<
bool DoConsumeLatency; ///< "True" if the output latency should be
///< consumed. Does not apply to the fractional part of the latency
///< (if such part is available).
///<
int Latency; ///< Initial latency that should be removed from the output.
///<
double LatencyFrac; ///< Fractional latency left on the output.
///<
int BufLeft; ///< The number of samples left in the buffer to process.
///< When this value is below FilterLenD2Plus1, the interpolation
///< cycle ends.
///<
int WritePos; ///< The current buffer write position. Incremented together
///< with the BufLeft variable.
///<
int ReadPos; ///< The current buffer read position.
///<
int LatencyLeft; ///< Latency left to remove.
///<
typedef void( *CConvolveFn )( double* op, double* const opend,
const double* const flt, const double* const rp0, int rpos ); ///<
///< Convolution function type.
///<
CConvolveFn convfn; ///< Convolution function in use.
///<
#define R8BHBC1( fn ) \
static void fn( double* op, double* const opend, const double* const flt, \
const double* const rp0, int rpos ) \
{ \
while( op != opend ) \
{ \
const double* const rp = rp0 + rpos; \
op[ 0 ] = rp[ 0 ];
#define R8BHBC2 \
rpos = ( rpos + 1 ) & BufLenMask; \
op += 2; \
} \
}
#include "CDSPHBUpsampler.inc"
#undef R8BHBC1
#undef R8BHBC2
};
// ---------------------------------------------------------------------------
} // namespace r8b
#endif // R8B_CDSPHBUPSAMPLER_INCLUDED
Reference in New Issue View Git Blame Copy Permalink