Finished libresample removal
git-svn-id: https://svn.code.sf.net/p/vbam/code/trunk@194 a31d4220-a93d-0410-bf67-fe4944624d44
This commit is contained in:
mudlord
parent
8f5d65d4ea
commit
ffc715a8d2
|
|
@ -1,481 +0,0 @@
|
|||
#include <math.h>
|
||||
|
||||
#include "libresample-0.1.3/include/libresample.h"
|
||||
#include "snd_interp.h"
|
||||
|
||||
// this was once borrowed from libmodplug, and was also used to generate the FIR coefficient
|
||||
// tables that ZSNES uses for its "FIR" interpolation mode
|
||||
|
||||
/*
|
||||
------------------------------------------------------------------------------------------------
|
||||
fir interpolation doc,
|
||||
(derived from "an engineer's guide to fir digital filters", n.j. loy)
|
||||
|
||||
calculate coefficients for ideal lowpass filter (with cutoff = fc in 0..1 (mapped to 0..nyquist))
|
||||
c[-N..N] = (i==0) ? fc : sin(fc*pi*i)/(pi*i)
|
||||
|
||||
then apply selected window to coefficients
|
||||
c[-N..N] *= w(0..N)
|
||||
with n in 2*N and w(n) being a window function (see loy)
|
||||
|
||||
then calculate gain and scale filter coefs to have unity gain.
|
||||
------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
// quantizer scale of window coefs
|
||||
#define WFIR_QUANTBITS 14
|
||||
#define WFIR_QUANTSCALE (1L<<WFIR_QUANTBITS)
|
||||
#define WFIR_8SHIFT (WFIR_QUANTBITS-8)
|
||||
#define WFIR_16BITSHIFT (WFIR_QUANTBITS)
|
||||
// log2(number)-1 of precalculated taps range is [4..12]
|
||||
#define WFIR_FRACBITS 12
|
||||
#define WFIR_LUTLEN ((1L<<(WFIR_FRACBITS+1))+1)
|
||||
// number of samples in window
|
||||
#define WFIR_LOG2WIDTH 3
|
||||
#define WFIR_WIDTH (1L<<WFIR_LOG2WIDTH)
|
||||
#define WFIR_SMPSPERWING ((WFIR_WIDTH-1)>>1)
|
||||
// cutoff (1.0 == pi/2)
|
||||
#define WFIR_CUTOFF 0.95f
|
||||
// wfir type
|
||||
#define WFIR_HANN 0
|
||||
#define WFIR_HAMMING 1
|
||||
#define WFIR_BLACKMANEXACT 2
|
||||
#define WFIR_BLACKMAN3T61 3
|
||||
#define WFIR_BLACKMAN3T67 4
|
||||
#define WFIR_BLACKMAN4T92 5
|
||||
#define WFIR_BLACKMAN4T74 6
|
||||
#define WFIR_KAISER4T 7
|
||||
#define WFIR_LANCZOS 8
|
||||
#define WFIR_TYPE WFIR_LANCZOS
|
||||
// wfir help
|
||||
#ifndef M_zPI
|
||||
#define M_zPI 3.1415926535897932384626433832795
|
||||
#endif
|
||||
#define M_zEPS 1e-8
|
||||
#define M_zBESSELEPS 1e-21
|
||||
|
||||
class CzWINDOWEDFIR
|
||||
{ public:
|
||||
CzWINDOWEDFIR( );
|
||||
~CzWINDOWEDFIR( );
|
||||
float coef( int _PCnr, float _POfs, float _PCut, int _PWidth, int _PType ) //float _PPos, float _PFc, int _PLen )
|
||||
{ double _LWidthM1 = _PWidth-1;
|
||||
double _LWidthM1Half = 0.5*_LWidthM1;
|
||||
double _LPosU = ((double)_PCnr - _POfs);
|
||||
double _LPos = _LPosU-_LWidthM1Half;
|
||||
double _LPIdl = 2.0*M_zPI/_LWidthM1;
|
||||
double _LWc,_LSi;
|
||||
if( fabs(_LPos)<M_zEPS )
|
||||
{ _LWc = 1.0;
|
||||
_LSi = _PCut;
|
||||
}
|
||||
else
|
||||
{ switch( _PType )
|
||||
{ case WFIR_HANN:
|
||||
_LWc = 0.50 - 0.50 * cos(_LPIdl*_LPosU);
|
||||
break;
|
||||
case WFIR_HAMMING:
|
||||
_LWc = 0.54 - 0.46 * cos(_LPIdl*_LPosU);
|
||||
break;
|
||||
case WFIR_BLACKMANEXACT:
|
||||
_LWc = 0.42 - 0.50 * cos(_LPIdl*_LPosU) + 0.08 * cos(2.0*_LPIdl*_LPosU);
|
||||
break;
|
||||
case WFIR_BLACKMAN3T61:
|
||||
_LWc = 0.44959 - 0.49364 * cos(_LPIdl*_LPosU) + 0.05677 * cos(2.0*_LPIdl*_LPosU);
|
||||
break;
|
||||
case WFIR_BLACKMAN3T67:
|
||||
_LWc = 0.42323 - 0.49755 * cos(_LPIdl*_LPosU) + 0.07922 * cos(2.0*_LPIdl*_LPosU);
|
||||
break;
|
||||
case WFIR_BLACKMAN4T92:
|
||||
_LWc = 0.35875 - 0.48829 * cos(_LPIdl*_LPosU) + 0.14128 * cos(2.0*_LPIdl*_LPosU) - 0.01168 * cos(3.0*_LPIdl*_LPosU);
|
||||
break;
|
||||
case WFIR_BLACKMAN4T74:
|
||||
_LWc = 0.40217 - 0.49703 * cos(_LPIdl*_LPosU) + 0.09392 * cos(2.0*_LPIdl*_LPosU) - 0.00183 * cos(3.0*_LPIdl*_LPosU);
|
||||
break;
|
||||
case WFIR_KAISER4T:
|
||||
_LWc = 0.40243 - 0.49804 * cos(_LPIdl*_LPosU) + 0.09831 * cos(2.0*_LPIdl*_LPosU) - 0.00122 * cos(3.0*_LPIdl*_LPosU);
|
||||
break;
|
||||
case WFIR_LANCZOS:
|
||||
_LWc = 1 - (sin(_LPIdl*_LPosU) / (_LPIdl*_LPosU));
|
||||
break;
|
||||
default:
|
||||
_LWc = 1.0;
|
||||
break;
|
||||
}
|
||||
_LPos *= M_zPI;
|
||||
_LSi = sin(_PCut*_LPos)/_LPos;
|
||||
}
|
||||
return (float)(_LWc*_LSi);
|
||||
}
|
||||
static signed short lut[WFIR_LUTLEN*WFIR_WIDTH];
|
||||
};
|
||||
|
||||
signed short CzWINDOWEDFIR::lut[WFIR_LUTLEN*WFIR_WIDTH];
|
||||
|
||||
CzWINDOWEDFIR::CzWINDOWEDFIR()
|
||||
{ int _LPcl;
|
||||
float _LPcllen = (float)(1L<<WFIR_FRACBITS); // number of precalculated lines for 0..1 (-1..0)
|
||||
float _LNorm = 1.0f / (float)(2.0f * _LPcllen);
|
||||
float _LCut = WFIR_CUTOFF;
|
||||
float _LScale = (float)WFIR_QUANTSCALE;
|
||||
float _LGain,_LCoefs[WFIR_WIDTH];
|
||||
for( _LPcl=0;_LPcl<WFIR_LUTLEN;_LPcl++ )
|
||||
{
|
||||
float _LOfs = ((float)_LPcl-_LPcllen)*_LNorm;
|
||||
int _LCc,_LIdx = _LPcl<<WFIR_LOG2WIDTH;
|
||||
for( _LCc=0,_LGain=0.0f;_LCc<WFIR_WIDTH;_LCc++ )
|
||||
{ _LGain += (_LCoefs[_LCc] = coef( _LCc, _LOfs, _LCut, WFIR_WIDTH, WFIR_TYPE ));
|
||||
}
|
||||
_LGain = 1.0f/_LGain;
|
||||
for( _LCc=0;_LCc<WFIR_WIDTH;_LCc++ )
|
||||
{ float _LCoef = (float)floor( 0.5 + _LScale*_LCoefs[_LCc]*_LGain );
|
||||
lut[_LIdx+_LCc] = (signed short)( (_LCoef<-_LScale)?-_LScale:((_LCoef>_LScale)?_LScale:_LCoef) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CzWINDOWEDFIR::~CzWINDOWEDFIR()
|
||||
{ // nothing todo
|
||||
}
|
||||
|
||||
CzWINDOWEDFIR sfir;
|
||||
|
||||
template <class T, int buffer_size>
|
||||
class sample_buffer
|
||||
{
|
||||
int ptr, filled;
|
||||
T * buffer;
|
||||
|
||||
public:
|
||||
sample_buffer() : ptr(0), filled(0)
|
||||
{
|
||||
buffer = new T[buffer_size];
|
||||
}
|
||||
~sample_buffer()
|
||||
{
|
||||
if (buffer) delete [] buffer;
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
ptr = filled = 0;
|
||||
}
|
||||
|
||||
inline int size() const
|
||||
{
|
||||
return filled;
|
||||
}
|
||||
|
||||
inline void push_back(T sample)
|
||||
{
|
||||
buffer[ptr] = sample;
|
||||
if (++ptr >= buffer_size) ptr = 0;
|
||||
if (filled < buffer_size) filled++;
|
||||
}
|
||||
|
||||
inline void erase(int count)
|
||||
{
|
||||
if (count > filled) filled = 0;
|
||||
else filled -= count;
|
||||
}
|
||||
|
||||
inline T operator[] (int index) const
|
||||
{
|
||||
index += ptr - filled;
|
||||
if (index < 0) index += buffer_size;
|
||||
else if (index > buffer_size) index -= buffer_size;
|
||||
return buffer[index];
|
||||
}
|
||||
};
|
||||
|
||||
class foo_null : public foo_interpolate
|
||||
{
|
||||
int sample;
|
||||
|
||||
public:
|
||||
foo_null() : sample(0) {}
|
||||
~foo_null() {}
|
||||
|
||||
void reset() {}
|
||||
|
||||
void push(int psample)
|
||||
{
|
||||
sample = psample;
|
||||
}
|
||||
|
||||
int pop()
|
||||
{
|
||||
return sample;
|
||||
}
|
||||
};
|
||||
|
||||
class foo_linear : public foo_interpolate
|
||||
{
|
||||
sample_buffer<int,4> samples;
|
||||
|
||||
int position;
|
||||
|
||||
inline int smp(int index)
|
||||
{
|
||||
return samples[index];
|
||||
}
|
||||
|
||||
public:
|
||||
foo_linear()
|
||||
{
|
||||
position = 0;
|
||||
}
|
||||
|
||||
~foo_linear() {}
|
||||
|
||||
void reset()
|
||||
{
|
||||
position = 0;
|
||||
samples.clear();
|
||||
}
|
||||
|
||||
|
||||
void push(int sample)
|
||||
{
|
||||
samples.push_back(sample);
|
||||
}
|
||||
|
||||
int pop()
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (position > 0x7fff)
|
||||
{
|
||||
int howmany = position >> 15;
|
||||
position &= 0x7fff;
|
||||
samples.erase(howmany);
|
||||
}
|
||||
|
||||
if (samples.size() < 2) return 0;
|
||||
|
||||
ret = smp(0) * (0x8000 - position);
|
||||
ret += smp(1) * position;
|
||||
ret >>= 15;
|
||||
|
||||
position+=lrate;
|
||||
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
// and this integer cubic interpolation implementation was kind of borrowed from either TiMidity
|
||||
// or the P.E.Op.S. SPU project, or is in use in both, or something...
|
||||
|
||||
class foo_cubic : public foo_interpolate
|
||||
{
|
||||
sample_buffer<int,12> samples;
|
||||
|
||||
int position;
|
||||
|
||||
inline int smp(int index)
|
||||
{
|
||||
return samples[index];
|
||||
}
|
||||
|
||||
public:
|
||||
foo_cubic()
|
||||
{
|
||||
position = 0;
|
||||
}
|
||||
|
||||
~foo_cubic() {}
|
||||
|
||||
void reset()
|
||||
{
|
||||
position = 0;
|
||||
samples.clear();
|
||||
}
|
||||
|
||||
void push(int sample)
|
||||
{
|
||||
samples.push_back(sample);
|
||||
}
|
||||
|
||||
int pop()
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (position > 0x7fff)
|
||||
{
|
||||
int howmany = position >> 15;
|
||||
position &= 0x7fff;
|
||||
samples.erase(howmany);
|
||||
}
|
||||
|
||||
if (samples.size() < 4) return 0;
|
||||
|
||||
ret = smp(3) - 3 * smp(2) + 3 * smp(1) - smp(0);
|
||||
ret *= (position - (2 << 15)) / 6;
|
||||
ret >>= 15;
|
||||
ret += smp(2) - 2 * smp(1) + smp(0);
|
||||
ret *= (position - (1 << 15)) >> 1;
|
||||
ret >>= 15;
|
||||
ret += smp(1) - smp(0);
|
||||
ret *= position;
|
||||
ret >>= 15;
|
||||
ret += smp(0);
|
||||
|
||||
if (ret > 32767) ret = 32767;
|
||||
else if (ret < -32768) ret = -32768;
|
||||
|
||||
position+=lrate;
|
||||
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
class foo_fir : public foo_interpolate
|
||||
{
|
||||
sample_buffer<int,24> samples;
|
||||
|
||||
int position;
|
||||
|
||||
inline int smp(int index)
|
||||
{
|
||||
return samples[index];
|
||||
}
|
||||
|
||||
public:
|
||||
foo_fir()
|
||||
{
|
||||
position = 0;
|
||||
}
|
||||
|
||||
~foo_fir()
|
||||
{
|
||||
position=666;
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
position = 0;
|
||||
samples.clear();
|
||||
}
|
||||
|
||||
void push(int sample)
|
||||
{
|
||||
samples.push_back(sample);
|
||||
}
|
||||
|
||||
int pop()
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (position > 0x7fff)
|
||||
{
|
||||
int howmany = position >> 15;
|
||||
position &= 0x7fff;
|
||||
samples.erase(howmany);
|
||||
}
|
||||
|
||||
if (samples.size() < 8) return 0;
|
||||
|
||||
ret = smp(0) * CzWINDOWEDFIR::lut[(position & ~7) ];
|
||||
ret += smp(1) * CzWINDOWEDFIR::lut[(position & ~7) + 1];
|
||||
ret += smp(2) * CzWINDOWEDFIR::lut[(position & ~7) + 2];
|
||||
ret += smp(3) * CzWINDOWEDFIR::lut[(position & ~7) + 3];
|
||||
ret += smp(4) * CzWINDOWEDFIR::lut[(position & ~7) + 4];
|
||||
ret += smp(5) * CzWINDOWEDFIR::lut[(position & ~7) + 5];
|
||||
ret += smp(6) * CzWINDOWEDFIR::lut[(position & ~7) + 6];
|
||||
ret += smp(7) * CzWINDOWEDFIR::lut[(position & ~7) + 7];
|
||||
ret >>= WFIR_QUANTBITS;
|
||||
|
||||
if (ret > 32767) ret = 32767;
|
||||
else if (ret < -32768) ret = -32768;
|
||||
|
||||
position+=lrate;
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
class foo_libresample : public foo_interpolate
|
||||
{
|
||||
sample_buffer<float,32> samples;
|
||||
|
||||
void * resampler;
|
||||
|
||||
public:
|
||||
foo_libresample()
|
||||
{
|
||||
resampler = 0;
|
||||
}
|
||||
|
||||
~foo_libresample()
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
samples.clear();
|
||||
if (resampler)
|
||||
{
|
||||
resample_close(resampler);
|
||||
resampler = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void push(int sample)
|
||||
{
|
||||
samples.push_back(float(sample));
|
||||
}
|
||||
|
||||
int pop()
|
||||
{
|
||||
int ret;
|
||||
if (!resampler)
|
||||
{
|
||||
resampler = resample_open(0, .25, 44100. / 4000.);
|
||||
}
|
||||
|
||||
{
|
||||
int count = samples.size();
|
||||
float * in = new float[count];
|
||||
float out;
|
||||
int used, returned;
|
||||
|
||||
for (used = 0; used < count; used++)
|
||||
{
|
||||
in[used] = samples[used];
|
||||
}
|
||||
|
||||
returned = resample_process(resampler, 32767. / lrate, in, count, 0, &used, &out, 1);
|
||||
if (used)
|
||||
{
|
||||
samples.erase(used);
|
||||
}
|
||||
|
||||
delete [] in;
|
||||
|
||||
if (returned < 1) return 0;
|
||||
|
||||
ret = (int)out;
|
||||
}
|
||||
|
||||
if (ret > 32767) ret = 32767;
|
||||
else if (ret < -32768) ret = -32768;
|
||||
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
foo_interpolate * get_filter(int which)
|
||||
{
|
||||
switch (which)
|
||||
{
|
||||
default:
|
||||
return new foo_null;
|
||||
case 1:
|
||||
return new foo_linear;
|
||||
case 2:
|
||||
return new foo_cubic;
|
||||
case 3:
|
||||
return new foo_fir;
|
||||
case 4:
|
||||
return new foo_libresample;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
#ifndef __SND_INTERP_H__
|
||||
#define __SND_INTERP_H__
|
||||
|
||||
class foo_interpolate
|
||||
{
|
||||
public:
|
||||
foo_interpolate() {}
|
||||
virtual ~foo_interpolate() {};
|
||||
|
||||
virtual void reset() = 0;
|
||||
|
||||
long lrate;
|
||||
|
||||
virtual void rate(double rate)
|
||||
{
|
||||
lrate = (int)(32768. * rate);
|
||||
};
|
||||
|
||||
virtual void push(int sample) = 0;
|
||||
virtual int pop() = 0;
|
||||
};
|
||||
|
||||
extern foo_interpolate * get_filter(int which);
|
||||
|
||||
/*
|
||||
|
||||
// complicated, synced interface, specific to this implementation
|
||||
|
||||
double calc_rate(int timer);
|
||||
void interp_switch(int which);
|
||||
void interp_reset(int ch);
|
||||
inline void interp_push(int ch, int sample);
|
||||
inline int interp_pop(int ch, double rate); */
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue