/* prepare window for FFT
* INPUT
* n : # of samples for FFT
* flag_window : 0 : no-window (default -- that is, other than 1 ~ 6)
* 1 : parzen window
* 2 : welch window
* 3 : hanning window
* 4 : hamming window
* 5 : blackman window
* 6 : steeper 30-dB/octave rolloff window
* OUTPUT
* density factor as RETURN VALUE
*/
double
init_den (int n, char flag_window)
{
double den;
int i;
den = 0.0;
for (i = 0; i < n; i ++)
{
switch (flag_window)
{
case 1: // parzen window
den += parzen (i, n) * parzen (i, n);
break;
case 2: // welch window
den += welch (i, n) * welch (i, n);
break;
case 3: // hanning window
den += hanning (i, n) * hanning (i, n);
break;
case 4: // hamming window
den += hamming (i, n) * hamming (i, n);
break;
case 5: // blackman window
den += blackman (i, n) * blackman (i, n);
break;
case 6: // steeper 30-dB/octave rolloff window
den += steeper (i, n) * steeper (i, n);
break;
default:
fprintf (stderr, "invalid flag_window\n");
case 0: // square (no window)
den += 1.0;
break;
}
}
den *= (double)n;
return den;
}
// Generate polyphase coefficients for channeliser
float *generatePolyphaseCoefficients(unsigned nchans, unsigned ntaps, FirWindow windowType)
{
unsigned n = nchans * ntaps;
double* window = new double[n];
switch (windowType) {
case HAMMING:
{
hamming(n, window);
break;
}
case BLACKMAN:
{
blackman(n, window);
break;
}
case GAUSSIAN:
{
double alpha = 3.5;
gaussian(n, alpha, window);
break;
}
case KAISER:
{
double beta = 9.0695;
kaiser(n, beta, window);
break;
}
default:
{
fprintf(stderr, "Invalid PFB window type. Exiting\n");
exit(-1);
}
}
double* result = new double[n];
generateFirFilter(n - 1, 1.0 / nchans, window, result);
delete[] window;
float *coeff = (float *) malloc(nchans * ntaps * sizeof(float));
for(unsigned t = 0; t < ntaps; ++t) {
for(unsigned c = 0; c < nchans; ++c) {
unsigned index = t * nchans + c;
coeff[index] = result[index] / nchans;
if (c % 2 == 0)
coeff[index] = result[index] / nchans;
else
coeff[index] = -result[index] / nchans;
}
}
delete[] result;
return coeff;
}
double Denoise::fft_window(int k, int N, int window_type)
{
if(window_type == DENOISE_WINDOW_BLACKMAN) {
return blackman(k, N);
} else if(window_type == DENOISE_WINDOW_BLACKMAN_HYBRID) {
return blackman_hybrid(k, N-N/4, N);
} else if(window_type == DENOISE_WINDOW_HANNING_OVERLAP_ADD) {
return hanning(k, N);
}
return 0.0;
}
static void init_sinc_table(struct sinc_resampler *resamp)
{
for (unsigned i = 0; i <= PHASES; i++)
{
for (unsigned j = 0; j < SIDELOBES; j++)
{
double sinc_phase = M_PI * ((double)i / PHASES + (double)j);
resamp->phase_table[i][j] = sinc(sinc_phase) * blackman(sinc_phase / SIDELOBES);
}
}
// Optimize linear interpolation.
for (unsigned i = 0; i < PHASES; i++)
for (unsigned j = 0; j < SIDELOBES; j++)
resamp->delta_table[i][j] = resamp->phase_table[i + 1][j] - resamp->phase_table[i][j];
}
//-----------------------------------------------------------------------------
// name: init()
// desc: ...
//-----------------------------------------------------------------------------
t_CKBOOL AudicleFaceVMSpace::init( )
{
if( !AudicleFace::init() )
return FALSE;
// set the buffer_size
g_buffer_size = Digitalio::m_buffer_size;
// set the channels
g_num_channels = Digitalio::m_num_channels_out;
// allocate buffers
g_out_buffer = new SAMPLE[g_buffer_size*g_num_channels];
g_in_buffer = new SAMPLE[g_buffer_size*g_num_channels];
g_buffer = new SAMPLE[g_buffer_size*g_num_channels];
g_window = NULL;
// set the buffer
Digitalio::set_extern( g_in_buffer, g_out_buffer );
g_rect = new SAMPLE[g_buffer_size];
g_hamm = new SAMPLE[g_buffer_size];
g_hann = new SAMPLE[g_buffer_size];
// blackmann
blackman( g_rect, g_buffer_size );
// hanning
hanning( g_hann, g_buffer_size );
// hamming window
hamming( g_hamm, g_buffer_size );
g_window = g_hamm;
g_spectrums = new Pt2D *[g_depth];
for( int i = 0; i < g_depth; i++ )
{
g_spectrums[i] = new Pt2D[g_buffer_size];
memset( g_spectrums[i], 0, sizeof(Pt2D)*g_buffer_size );
}
g_draw = new GLboolean[g_depth];
memset( g_draw, 0, sizeof(GLboolean)*g_depth );
m_name = "VM-Space";
m_bg_speed = .2;
g_id = IDManager::instance()->getPickID();
g_id2 = IDManager::instance()->getPickID();
return TRUE;
}
double *xtract_init_window(const int N, const int type)
{
double *window;
window = malloc(N * sizeof(double));
switch (type)
{
case XTRACT_GAUSS:
gauss(window, N, 0.4);
break;
case XTRACT_HAMMING:
hamming(window, N);
break;
case XTRACT_HANN:
hann(window, N);
break;
case XTRACT_BARTLETT:
bartlett(window, N);
break;
case XTRACT_TRIANGULAR:
triangular(window, N);
break;
case XTRACT_BARTLETT_HANN:
bartlett_hann(window, N);
break;
case XTRACT_BLACKMAN:
blackman(window, N);
break;
case XTRACT_KAISER:
kaiser(window, N, 3 * PI);
break;
case XTRACT_BLACKMAN_HARRIS:
blackman_harris(window, N);
break;
default:
hann(window, N);
break;
}
return window;
}
/* apply window function to data[]
* INPUT
* flag_window : 0 : no-window (default -- that is, other than 1 ~ 6)
* 1 : parzen window
* 2 : welch window
* 3 : hanning window
* 4 : hamming window
* 5 : blackman window
* 6 : steeper 30-dB/octave rolloff window
*/
void
windowing (int n, const double *data, int flag_window, double scale,
double *out)
{
int i;
for (i = 0; i < n; i ++)
{
switch (flag_window)
{
case 1: // parzen window
out [i] = data [i] * parzen (i, n) / scale;
break;
case 2: // welch window
out [i] = data [i] * welch (i, n) / scale;
break;
case 3: // hanning window
out [i] = data [i] * hanning (i, n) / scale;
break;
case 4: // hamming window
out [i] = data [i] * hamming (i, n) / scale;
break;
case 5: // blackman window
out [i] = data [i] * blackman (i, n) / scale;
break;
case 6: // steeper 30-dB/octave rolloff window
out [i] = data [i] * steeper (i, n) / scale;
break;
default:
fprintf (stderr, "invalid flag_window\n");
case 0: // square (no window)
out [i] = data [i] / scale;
break;
}
}
}
void Visualizer::Initialize()
{
CoInitializeEx(NULL, COINIT_MULTITHREADED);
CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), (void**)&pMMDeviceEnumerator);
pMMDeviceEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pMMDevice);
pMMDevice->Activate(__uuidof(IAudioClient), CLSCTX_ALL, NULL, (void**)&pAudioClient);
pAudioClient->GetMixFormat(&waveformat);
pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_LOOPBACK, 0, 0, waveformat, 0);
pAudioClient->GetService(__uuidof(IAudioCaptureClient), (void**)&pAudioCaptureClient);
pAudioClient->Start();
rkb.Initialize();
ckb.Initialize();
//str.Initialize();
amplitude = 100;
avg_mode = 0;
avg_size = 8;
bkgd_step = 0;
bkgd_bright = 10;
bkgd_mode = 0;
delay = 50;
window_mode = 1;
decay = 80;
frgd_mode = 8;
single_color_mode = 1;
hanning(win_hanning, 256);
hamming(win_hamming, 256);
blackman(win_blackman, 256);
nrml_ofst = 0.04f;
nrml_scl = 0.5f;
SetNormalization(nrml_ofst, nrml_scl);
}
int
fill_buffer_resample(lame_global_flags const *gfp,
sample_t * outbuf,
int desired_len, sample_t const *inbuf, int len, int *num_used, int ch)
{
lame_internal_flags *const gfc = gfp->internal_flags;
int BLACKSIZE;
FLOAT offset, xvalue;
int i, j = 0, k;
int filter_l;
FLOAT fcn, intratio;
FLOAT *inbuf_old;
int bpc; /* number of convolution functions to pre-compute */
bpc = gfp->out_samplerate / gcd(gfp->out_samplerate, gfp->in_samplerate);
if (bpc > BPC)
bpc = BPC;
intratio = (fabs(gfc->resample_ratio - floor(.5 + gfc->resample_ratio)) < .0001);
fcn = 1.00 / gfc->resample_ratio;
if (fcn > 1.00)
fcn = 1.00;
filter_l = 31;
if (0 == filter_l % 2)
--filter_l; /* must be odd */
filter_l += intratio; /* unless resample_ratio=int, it must be even */
BLACKSIZE = filter_l + 1; /* size of data needed for FIR */
if (gfc->fill_buffer_resample_init == 0) {
gfc->inbuf_old[0] = calloc(BLACKSIZE, sizeof(gfc->inbuf_old[0][0]));
gfc->inbuf_old[1] = calloc(BLACKSIZE, sizeof(gfc->inbuf_old[0][0]));
for (i = 0; i <= 2 * bpc; ++i)
gfc->blackfilt[i] = calloc(BLACKSIZE, sizeof(gfc->blackfilt[0][0]));
gfc->itime[0] = 0;
gfc->itime[1] = 0;
/* precompute blackman filter coefficients */
for (j = 0; j <= 2 * bpc; j++) {
FLOAT sum = 0.;
offset = (j - bpc) / (2. * bpc);
for (i = 0; i <= filter_l; i++)
sum += gfc->blackfilt[j][i] = blackman(i - offset, fcn, filter_l);
for (i = 0; i <= filter_l; i++)
gfc->blackfilt[j][i] /= sum;
}
gfc->fill_buffer_resample_init = 1;
}
inbuf_old = gfc->inbuf_old[ch];
/* time of j'th element in inbuf = itime + j/ifreq; */
/* time of k'th element in outbuf = j/ofreq */
for (k = 0; k < desired_len; k++) {
double time0;
int joff;
time0 = k * gfc->resample_ratio; /* time of k'th output sample */
j = floor(time0 - gfc->itime[ch]);
/* check if we need more input data */
if ((filter_l + j - filter_l / 2) >= len)
break;
/* blackman filter. by default, window centered at j+.5(filter_l%2) */
/* but we want a window centered at time0. */
offset = (time0 - gfc->itime[ch] - (j + .5 * (filter_l % 2)));
assert(fabs(offset) <= .501);
/* find the closest precomputed window for this offset: */
joff = floor((offset * 2 * bpc) + bpc + .5);
xvalue = 0.;
for (i = 0; i <= filter_l; ++i) {
int const j2 = i + j - filter_l / 2;
sample_t y;
assert(j2 < len);
assert(j2 + BLACKSIZE >= 0);
y = (j2 < 0) ? inbuf_old[BLACKSIZE + j2] : inbuf[j2];
#ifdef PRECOMPUTE
xvalue += y * gfc->blackfilt[joff][i];
#else
xvalue += y * blackman(i - offset, fcn, filter_l); /* very slow! */
/* Design FIR filter using the Window method
n filter length must be odd for HP and BS filters
w buffer for the filter taps (must be n long)
fc cutoff frequencies (1 for LP and HP, 2 for BP and BS)
0 < fc < 1 where 1 <=> Fs/2
flags window and filter type as defined in filter.h
variables are ored together: i.e. LP|HAMMING will give a
low pass filter designed using a hamming window
opt beta constant used only when designing using kaiser windows
returns 0 if OK, -1 if fail
*/
TfirFilter::_ftype_t* TfirFilter::design_fir(unsigned int *n, _ftype_t* fc, int type, int window, _ftype_t opt)
{
unsigned int o = *n & 1; // Indicator for odd filter length
unsigned int end = ((*n + 1) >> 1) - o; // Loop end
unsigned int i; // Loop index
_ftype_t k1 = 2 * _ftype_t(M_PI); // 2*pi*fc1
_ftype_t k2 = 0.5f * (_ftype_t)(1 - o);// Constant used if the filter has even length
_ftype_t k3; // 2*pi*fc2 Constant used in BP and BS design
_ftype_t g = 0.0f; // Gain
_ftype_t t1,t2,t3; // Temporary variables
_ftype_t fc1,fc2; // Cutoff frequencies
// Sanity check
if(*n==0) return NULL;
fc[0]=limit(fc[0],_ftype_t(0.001),_ftype_t(1));
if (!o && (type==TfirSettings::BANDSTOP || type==TfirSettings::HIGHPASS))
(*n)++;
_ftype_t *w=(_ftype_t*)aligned_calloc(sizeof(_ftype_t),*n);
// Get window coefficients
switch(window){
case(TfirSettings::WINDOW_BOX):
boxcar(*n,w); break;
case(TfirSettings::WINDOW_TRIANGLE):
triang(*n,w); break;
case(TfirSettings::WINDOW_HAMMING):
hamming(*n,w); break;
case(TfirSettings::WINDOW_HANNING):
hanning(*n,w); break;
case(TfirSettings::WINDOW_BLACKMAN):
blackman(*n,w); break;
case(TfirSettings::WINDOW_FLATTOP):
flattop(*n,w); break;
case(TfirSettings::WINDOW_KAISER):
kaiser(*n,w,opt); break;
default:
{
delete []w;
return NULL;
}
}
if(type==TfirSettings::LOWPASS || type==TfirSettings::HIGHPASS){
fc1=*fc;
// Cutoff frequency must be < 0.5 where 0.5 <=> Fs/2
fc1 = ((fc1 <= 1.0) && (fc1 > 0.0)) ? fc1/2 : 0.25f;
k1 *= fc1;
if(type==TfirSettings::LOWPASS){ // Low pass filter
// If the filter length is odd, there is one point which is exactly
// in the middle. The value at this point is 2*fCutoff*sin(x)/x,
// where x is zero. To make sure nothing strange happens, we set this
// value separately.
if (o){
w[end] = fc1 * w[end] * 2.0f;
g=w[end];
}
// Create filter
for (i=0 ; i<end ; i++){
t1 = (_ftype_t)(i+1) - k2;
w[end-i-1] = w[*n-end+i] = _ftype_t(w[end-i-1] * sin(k1 * t1)/(M_PI * t1)); // Sinc
g += 2*w[end-i-1]; // Total gain in filter
}
}
else{ // High pass filter
//if (!o) // High pass filters must have odd length
// return -1;
w[end] = _ftype_t(1.0 - (fc1 * w[end] * 2.0));
g= w[end];
// Create filter
for (i=0 ; i<end ; i++){
t1 = (_ftype_t)(i+1);
w[end-i-1] = w[*n-end+i] = _ftype_t(-1 * w[end-i-1] * sin(k1 * t1)/(M_PI * t1)); // Sinc
g += ((i&1) ? (2*w[end-i-1]) : (-2*w[end-i-1])); // Total gain in filter
}
}
}
if(type==TfirSettings::BANDPASS || type==TfirSettings::BANDSTOP){
fc1=fc[0];
fc2=limit(fc[1],_ftype_t(0.001),_ftype_t(1));
// Cutoff frequencies must be < 1.0 where 1.0 <=> Fs/2
fc1 = ((fc1 <= 1.0) && (fc1 > 0.0)) ? fc1/2 : 0.25f;
fc2 = ((fc2 <= 1.0) && (fc2 > 0.0)) ? fc2/2 : 0.25f;
k3 = k1 * fc2; // 2*pi*fc2
k1 *= fc1; // 2*pi*fc1
if(type==TfirSettings::BANDPASS){ // Band pass
// Calculate center tap
if (o){
g=w[end]*(fc1+fc2);
w[end] = (fc2 - fc1) * w[end] * 2.0f;
}
// Create filter
for (i=0 ; i<end ; i++){
t1 = (_ftype_t)(i+1) - k2;
t2 = _ftype_t(sin(k3 * t1)/(M_PI * t1)); // Sinc fc2
t3 = _ftype_t(sin(k1 * t1)/(M_PI * t1)); // Sinc fc1
g += w[end-i-1] * (t3 + t2); // Total gain in filter
w[end-i-1] = w[*n-end+i] = w[end-i-1] * (t2 - t3);
}
}
else{ // Band stop
//if (!o) // Band stop filters must have odd length
// return -1;
w[end] = _ftype_t(1.0 - (fc2 - fc1) * w[end] * 2.0);
g= w[end];
// Create filter
for (i=0 ; i<end ; i++){
t1 = (_ftype_t)(i+1);
t2 = _ftype_t(sin(k1 * t1)/(M_PI * t1)); // Sinc fc1
t3 = _ftype_t(sin(k3 * t1)/(M_PI * t1)); // Sinc fc2
w[end-i-1] = w[*n-end+i] = w[end-i-1] * (t2 - t3);
g += 2*w[end-i-1]; // Total gain in filter
}
}
}
// Normalize gain
g=1/g;
for (i=0; i<*n; i++)
w[i] *= g;
return w;
}
