void apply_hann_on_begin_and_end(float *psamples, int sample_num, int samplerate)
{
int hann_length;
int i;
if (sample_num < samplerate / 2)
{
for (i = 0; i < sample_num; i++)
{
psamples[i] = psamples[i] * hann(i, sample_num);
}
}
else
{
hann_length = HANN_FCUT;
for (i = 0; i < hann_length / 2 && i < sample_num; i++)
{
psamples[i] = psamples[i] * hann(i, hann_length);
}
for (i = 0; i < hann_length / 2 && i < sample_num; i++)
{
psamples[sample_num - i - 1] = psamples[sample_num - i - 1] * hann(i, hann_length);
}
}
}
void MRFFT::calc(const float* input, float* output)
{
// temporary buffers
std::vector<kiss_fft_scalar> linput(m_size), rinput(m_size);
std::vector<kiss_fft_cpx> loutput(m_size), routput(m_size);
for (size_t i=0;i<m_size;++i)
{
linput[i] = input[2*i];
rinput[i] = input[2*i+1];
}
if (m_windowed)
{
hann(linput);
hann(rinput);
}
// transform channels
kiss_fftr(m_cfg, &linput[0], &loutput[0]);
kiss_fftr(m_cfg, &rinput[0], &routput[0]);
auto&& filter = [&](kiss_fft_cpx& data)
{
return sqrt(data.r*data.r+data.i*data.i) * 2.0/m_size * (m_windowed?sqrt(8.0/3.0):1.0);
};
// interleave while taking magnitudes and normalizing
for (size_t i=0;i<m_size/2;++i)
{
output[2*i] = filter(loutput[i]);
output[2*i+1] = filter(routput[i]);
}
}
void Window::generateWindow(RealVec &window, const WindowType& windowType, bool periodic)
{
switch (windowType_)
{
case HANN:
hann(window, periodic);
LOUDNESS_DEBUG(name_ << ": Using a Hann window.");
break;
default:
hann(window, periodic);
LOUDNESS_DEBUG(name_ << ": Using a Hann window.");
break;
}
}
void fapply_hann_window(int samples, float *pin)
{
int s;
for (s = 0; s < samples; s++)
pin[s] = pin[s] * hann(s, samples);
}
void apply_hann_window(int samples, double *pin)
{
int s;
for (s = 0; s < samples; s++)
pin[s] = pin[s] * hann(s, samples);
}
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;
}
/* psolas16: overlap-add two vectors. */
void psolas16(int outlen, short* out,
int length1, short* seq1,
int length2, short* seq2)
{
int i;
for (i = 0; i < outlen; i++) {
/* i < outlen ==> i*length/outlen < length */
double v = 0;
if (0 < length1) {
/* first half (decreasing) */
v += seq1[i*length1/outlen] * hann(i+outlen, outlen*2);
}
if (0 < length2) {
/* second half (increasing) */
v += seq2[i*length2/outlen] * hann(i, outlen*2);
}
out[i] = (short)v;
}
}
float get_hann_integral(int N)
{
int n;
float sum;
for (n = 0, sum = 0; n < N; n++)
{
sum += 1. * hann(n, N);
}
return (sum);
}
std::vector<SampleType> Window::get(std::size_t size, std::size_t type) {
switch(type) {
case HAMMING:
return hamming(size);
case BLACKMAN_HARRIS:
return blackmanHarris(size);
case HANN:
return hann(size);
case NONE:
default:
return none(size);
}
}
LV2_Handle PitchShifter::instantiate(const LV2_Descriptor* descriptor, double samplerate, const char* bundle_path, const LV2_Feature* const* features)
{
PitchShifter *plugin = new PitchShifter();
plugin->nBuffers = 20;
plugin->Qcolumn = plugin->nBuffers;
plugin->hopa = TAMANHO_DO_BUFFER;
plugin->N = plugin->nBuffers*plugin->hopa;
plugin->cont = 0;
plugin->s = 0;
plugin->g = 1;
plugin->Hops = (int*)calloc(plugin->Qcolumn,sizeof(int)); memset(plugin->Hops, plugin->hopa, plugin->Qcolumn );
plugin->frames = (double*)calloc(plugin->N,sizeof(double));
plugin->ysaida = (double*)calloc(2*(plugin->N + 2*(plugin->Qcolumn-1)*plugin->hopa),sizeof(double));
plugin->yshift = (double*)calloc(plugin->hopa,sizeof(double));
plugin->b = (double**)calloc(plugin->hopa,sizeof(double*));
plugin->frames2 = fftwf_alloc_real(plugin->N);
plugin->q = fftwf_alloc_real(plugin->N);
plugin->fXa = fftwf_alloc_complex(plugin->N/2 + 1);
plugin->fXs = fftwf_alloc_complex(plugin->N/2 + 1);
plugin->Xa.zeros(plugin->N/2 + 1);
plugin->Xs.zeros(plugin->N/2 + 1);
plugin->XaPrevious.zeros(plugin->N/2 + 1);
plugin->Xa_arg.zeros(plugin->N/2 + 1);
plugin->XaPrevious_arg.zeros(plugin->N/2 + 1);
plugin->Phi.zeros(plugin->N/2 + 1);
plugin->PhiPrevious.zeros(plugin->N/2 + 1);
plugin->d_phi.zeros(plugin->N/2 + 1);
plugin->d_phi_prime.zeros(plugin->N/2 + 1);
plugin->d_phi_wrapped.zeros(plugin->N/2 + 1);
plugin->omega_true_sobre_fs.zeros(plugin->N/2 + 1);
plugin->AUX.zeros(plugin->N/2 + 1);
plugin->Xa_abs.zeros(plugin->N/2 + 1);
plugin->w.zeros(plugin->N); hann(plugin->N,&plugin->w);
plugin->I.zeros(plugin->N/2 + 1); plugin->I = linspace(0, plugin->N/2,plugin->N/2 + 1);
for (int i=1 ; i<= (plugin->nBuffers); i++)
{
plugin->b[i-1] = &plugin->frames[(i-1)*plugin->hopa];
}
plugin->p = fftwf_plan_dft_r2c_1d(plugin->N, plugin->frames2, plugin->fXa, FFTW_ESTIMATE);
plugin->p2 = fftwf_plan_dft_c2r_1d(plugin->N, plugin->fXs, plugin->q, FFTW_ESTIMATE);
return (LV2_Handle)plugin;
}
void liquid_doc_compute_psdcf(float complex * _x,
unsigned int _n,
float complex * _X,
unsigned int _nfft,
liquid_doc_psdwindow _wtype,
int _normalize)
{
unsigned int i;
// compute window and norm
float w[_n];
float wnorm=0.0f;
for (i=0; i<_n; i++) {
switch (_wtype) {
case LIQUID_DOC_PSDWINDOW_NONE: w[i] = 1.0f; break;
case LIQUID_DOC_PSDWINDOW_HANN: w[i] = hann(i,_n); break;
case LIQUID_DOC_PSDWINDOW_HAMMING: w[i] = hamming(i,_n); break;
break;
default:
fprintf(stderr,"error: liquid_doc_compute_psd(), invalid window type\n");
exit(1);
}
wnorm += w[i];
}
wnorm /= (float)(_n);
float complex x[_nfft];
fftplan fft = fft_create_plan(_nfft,x,_X,FFT_FORWARD,0);
for (i=0; i<_nfft; i++) {
x[i] = i < _n ? _x[i] * w[i] / wnorm : 0.0f;
}
fft_execute(fft);
fft_destroy_plan(fft);
// normalize spectrum by maximum
if (_normalize) {
float X_max = 0.0f;
for (i=0; i<_nfft; i++)
X_max = cabsf(_X[i]) > X_max ? cabsf(_X[i]) : X_max;
for (i=0; i<_nfft; i++)
_X[i] /= X_max;
}
}
PSAnalysis::PSAnalysis(uint32_t n_samples, int nBuffers, const char* wisdomFile) //Construtor
{
Qcolumn = nBuffers;
hopa = n_samples;
N = nBuffers*n_samples;
frames = new double[N]; fill_n(frames,N,0);
b = new double*[hopa];
for (int i=0 ; i< nBuffers; i++)
b[i] = &frames[i*hopa];
frames2 = fftwf_alloc_real(N);
fXa = fftwf_alloc_complex(N/2 + 1);
Xa.zeros(N/2 + 1);
XaPrevious.zeros(N/2 + 1);
Xa_arg.zeros(N/2 + 1);
XaPrevious_arg.zeros(N/2 + 1);
d_phi.zeros(N/2 + 1);
d_phi_prime.zeros(N/2 + 1);
d_phi_wrapped.zeros(N/2 + 1);
omega_true_sobre_fs.zeros(N/2 + 1);
AUX.zeros(N/2 + 1);
Xa_abs.zeros(N/2 + 1);
w.zeros(N); hann(N,&w);
I.zeros(N/2 + 1); I = linspace(0, N/2, N/2 + 1);
if (fftwf_import_wisdom_from_filename(wisdomFile) != 0)
{
p = fftwf_plan_dft_r2c_1d(N, frames2, fXa, FFTW_WISDOM_ONLY);
}
else
{
p = NULL;
printf("PSAnalysis: failed to import wisdom file '%s'\n", wisdomFile);
}
}
int main (int argc, char *argv[]) {
char jack_name[64] = "alsa_out";
char alsa_device[64] = "hw:0";
char server_name[64] = "default";
extern char *optarg;
extern int optind, optopt;
int errflg=0;
int c;
while ((c = getopt(argc, argv, "ivj:r:c:p:n:d:q:m:t:f:F:C:Q:s:S:")) != -1) {
switch(c) {
case 'j':
strncpy(jack_name,optarg, sizeof(jack_name));
break;
case 'r':
sample_rate = atoi(optarg);
break;
case 'c':
num_channels = atoi(optarg);
break;
case 'p':
period_size = atoi(optarg);
break;
case 'n':
num_periods = atoi(optarg);
break;
case 'd':
strncpy(alsa_device,optarg,sizeof(alsa_device));
break;
case 't':
target_delay = atoi(optarg);
break;
case 'q':
samplerate_quality = atoi(optarg);
break;
case 'm':
max_diff = atoi(optarg);
break;
case 'f':
catch_factor = atoi(optarg);
break;
case 'F':
catch_factor2 = atoi(optarg);
break;
case 'C':
pclamp = (double) atoi(optarg);
break;
case 'Q':
controlquant = (double) atoi(optarg);
break;
case 'v':
verbose = 1;
break;
case 'i':
instrument = 1;
break;
case 's':
smooth_size = atoi(optarg);
break;
case 'S':
strncpy(server_name,optarg,sizeof(server_name));
break;
case ':':
fprintf(stderr,
"Option -%c requires an operand\n", optopt);
errflg++;
break;
case '?':
fprintf(stderr,
"Unrecognized option: -%c\n", optopt);
errflg++;
}
}
if (errflg) {
printUsage();
exit(2);
}
if( (samplerate_quality < 0) || (samplerate_quality > 4) ) {
fprintf (stderr, "invalid samplerate quality\n");
return 1;
}
if ((client = jack_client_open (jack_name, JackServerName, NULL, server_name)) == 0) {
fprintf (stderr, "jack server not running?\n");
return 1;
}
/* tell the JACK server to call `process()' whenever
there is work to be done.
*/
jack_set_process_callback (client, process, 0);
/* tell the JACK server to call `jack_shutdown()' if
it ever shuts down, either entirely, or if it
just decides to stop calling us.
*/
jack_on_shutdown (client, jack_shutdown, 0);
if (jack_set_latency_callback)
jack_set_latency_callback (client, latency_cb, 0);
// get jack sample_rate
jack_sample_rate = jack_get_sample_rate( client );
if( !sample_rate )
sample_rate = jack_sample_rate;
static_resample_factor = (double) sample_rate / (double) jack_sample_rate;
resample_lower_limit = static_resample_factor * 0.25;
resample_upper_limit = static_resample_factor * 4.0;
resample_mean = static_resample_factor;
offset_array = malloc( sizeof(double) * smooth_size );
if( offset_array == NULL ) {
fprintf( stderr, "no memory for offset_array !!!\n" );
exit(20);
}
window_array = malloc( sizeof(double) * smooth_size );
if( window_array == NULL ) {
fprintf( stderr, "no memory for window_array !!!\n" );
exit(20);
}
int i;
for( i=0; i<smooth_size; i++ ) {
offset_array[i] = 0.0;
window_array[i] = hann( (double) i / ((double) smooth_size - 1.0) );
}
jack_buffer_size = jack_get_buffer_size( client );
// Setup target delay and max_diff for the normal user, who does not play with them...
if( !target_delay )
target_delay = (num_periods*period_size / 2) - jack_buffer_size/2;
if( !max_diff )
max_diff = target_delay;
if( max_diff > target_delay ) {
fprintf( stderr, "target_delay (%d) cant be smaller than max_diff(%d)\n", target_delay, max_diff );
exit(20);
}
if( (target_delay+max_diff) > (num_periods*period_size) ) {
fprintf( stderr, "target_delay+max_diff (%d) cant be bigger than buffersize(%d)\n", target_delay+max_diff, num_periods*period_size );
exit(20);
}
// now open the alsa fd...
alsa_handle = open_audiofd( alsa_device, 0, sample_rate, num_channels, period_size, num_periods);
if( alsa_handle == 0 )
exit(20);
printf( "selected sample format: %s\n", formats[format].name );
// alloc input ports, which are blasted out to alsa...
alloc_ports( 0, num_channels );
outbuf = malloc( num_periods * period_size * formats[format].sample_size * num_channels );
resampbuf = malloc( num_periods * period_size * sizeof( float ) );
tmpbuf = malloc( 512 * formats[format].sample_size * num_channels );
if ((outbuf == NULL) || (resampbuf == NULL) || (tmpbuf == NULL))
{
fprintf( stderr, "no memory for buffers.\n" );
exit(20);
}
/* tell the JACK server that we are ready to roll */
if (jack_activate (client)) {
fprintf (stderr, "cannot activate client");
return 1;
}
signal( SIGTERM, sigterm_handler );
signal( SIGINT, sigterm_handler );
if( verbose ) {
while(!quit) {
usleep(500000);
if( output_new_delay ) {
printf( "delay = %d\n", output_new_delay );
output_new_delay = 0;
}
printf( "res: %f, \tdiff = %f, \toffset = %f \n", output_resampling_factor, output_diff, output_offset );
}
} else if( instrument ) {
printf( "# n\tresamp\tdiff\toffseti\tintegral\n");
int n=0;
while(!quit) {
usleep(1000);
printf( "%d\t%f\t%f\t%f\t%f\n", n++, output_resampling_factor, output_diff, output_offset, output_integral );
}
} else {
while(!quit)
{
usleep(500000);
if( output_new_delay ) {
printf( "delay = %d\n", output_new_delay );
output_new_delay = 0;
}
}
}
jack_deactivate( client );
jack_client_close (client);
exit (0);
}
// create spgram object
// _nfft : FFT size
// _wtype : window type, e.g. LIQUID_WINDOW_HAMMING
// _window_len : window length
// _delay : delay between transforms, _delay > 0
SPGRAM() SPGRAM(_create)(unsigned int _nfft,
int _wtype,
unsigned int _window_len,
unsigned int _delay)
{
// validate input
if (_nfft < 2) {
fprintf(stderr,"error: spgram%s_create(), fft size must be at least 2\n", EXTENSION);
exit(1);
} else if (_window_len > _nfft) {
fprintf(stderr,"error: spgram%s_create(), window size cannot exceed fft size\n", EXTENSION);
exit(1);
} else if (_window_len == 0) {
fprintf(stderr,"error: spgram%s_create(), window size must be greater than zero\n", EXTENSION);
exit(1);
} else if (_wtype == LIQUID_WINDOW_KBD && _window_len % 2) {
fprintf(stderr,"error: spgram%s_create(), KBD window length must be even\n", EXTENSION);
exit(1);
} else if (_delay == 0) {
fprintf(stderr,"error: spgram%s_create(), delay must be greater than 0\n", EXTENSION);
exit(1);
}
// allocate memory for main object
SPGRAM() q = (SPGRAM()) malloc(sizeof(struct SPGRAM(_s)));
// set input parameters
q->nfft = _nfft;
q->wtype = _wtype;
q->window_len = _window_len;
q->delay = _delay;
q->frequency = 0;
q->sample_rate= -1;
// set object for full accumulation
SPGRAM(_set_alpha)(q, -1.0f);
// create FFT arrays, object
q->buf_time = (TC*) malloc((q->nfft)*sizeof(TC));
q->buf_freq = (TC*) malloc((q->nfft)*sizeof(TC));
q->psd = (T *) malloc((q->nfft)*sizeof(T ));
q->fft = FFT_CREATE_PLAN(q->nfft, q->buf_time, q->buf_freq, FFT_DIR_FORWARD, FFT_METHOD);
// create buffer
q->buffer = WINDOW(_create)(q->window_len);
// create window
q->w = (T*) malloc((q->window_len)*sizeof(T));
unsigned int i;
unsigned int n = q->window_len;
float beta = 10.0f;
float zeta = 3.0f;
for (i=0; i<n; i++) {
switch (q->wtype) {
case LIQUID_WINDOW_HAMMING: q->w[i] = hamming(i,n); break;
case LIQUID_WINDOW_HANN: q->w[i] = hann(i,n); break;
case LIQUID_WINDOW_BLACKMANHARRIS: q->w[i] = blackmanharris(i,n); break;
case LIQUID_WINDOW_BLACKMANHARRIS7: q->w[i] = blackmanharris7(i,n); break;
case LIQUID_WINDOW_KAISER: q->w[i] = kaiser(i,n,beta,0); break;
case LIQUID_WINDOW_FLATTOP: q->w[i] = flattop(i,n); break;
case LIQUID_WINDOW_TRIANGULAR: q->w[i] = triangular(i,n,n); break;
case LIQUID_WINDOW_RCOSTAPER: q->w[i] = liquid_rcostaper_windowf(i,n/3,n); break;
case LIQUID_WINDOW_KBD: q->w[i] = liquid_kbd(i,n,zeta); break;
default:
fprintf(stderr,"error: spgram%s_create(), invalid window\n", EXTENSION);
exit(1);
}
}
// scale by window magnitude, FFT size
float g = 0.0f;
for (i=0; i<q->window_len; i++)
g += q->w[i] * q->w[i];
g = M_SQRT2 / ( sqrtf(g / q->window_len) * sqrtf((float)(q->nfft)) );
// scale window and copy
for (i=0; i<q->window_len; i++)
q->w[i] = g * q->w[i];
// reset the spgram object
q->num_samples_total = 0;
q->num_transforms_total = 0;
SPGRAM(_reset)(q);
// return new object
return q;
}
void PitchShifter::run(LV2_Handle instance, uint32_t n_samples)
{
PitchShifter *plugin;
plugin = (PitchShifter *) instance;
float media = 0;
for (uint32_t i=1; i<n_samples; i++)
{
media = media + abs(plugin->in[i-1]);
}
if (media == 0)
{
for (uint32_t i=1; i<n_samples; i++)
{
plugin->out_1[i-1] = 0;
}
}
else
{
int hops;
double g_before = plugin->g;
plugin->g = pow(10, (float)(*(plugin->gain))/20.0);
plugin->s = (double)(*(plugin->step));
hops = round(plugin->hopa*(pow(2,(plugin->s/12))));
for (int k=1; k<= plugin->Qcolumn-1; k++)
{
plugin->Hops[k-1] = plugin->Hops[k];
}
plugin->Hops[plugin->Qcolumn-1] = hops;
if ( ((plugin->hopa) != (int)n_samples) )
{
plugin->hopa = n_samples;
plugin->N = plugin->nBuffers*plugin->hopa;
plugin->frames = (double*)realloc(plugin->frames,plugin->N*sizeof(double)); memset(plugin->frames, 0, plugin->N );
plugin->ysaida = (double*)realloc(plugin->ysaida,2*(plugin->N + 2*(plugin->Qcolumn-1)*plugin->hopa)*sizeof(double)); memset(plugin->ysaida, 0, 2*(plugin->N + 2*(plugin->Qcolumn-1)*plugin->hopa) );
plugin->yshift = (double*)realloc(plugin->yshift,plugin->hopa*sizeof(double)); memset(plugin->yshift, 0, plugin->hopa );
plugin->b = (double**)realloc(plugin->b,plugin->hopa*sizeof(double*));
fftwf_free(plugin->frames2); plugin->frames2 = fftwf_alloc_real(plugin->N);
fftwf_free(plugin->q); plugin->q = fftwf_alloc_real(plugin->N);
fftwf_free(plugin->fXa); plugin->fXa = fftwf_alloc_complex(plugin->N/2 + 1);
fftwf_free(plugin->fXs); plugin->fXs = fftwf_alloc_complex(plugin->N/2 + 1);
plugin->Xa.zeros(plugin->N/2 + 1);
plugin->Xs.zeros(plugin->N/2 + 1);
plugin->XaPrevious.zeros(plugin->N/2 + 1);
plugin->Xa_arg.zeros(plugin->N/2 + 1);
plugin->XaPrevious_arg.zeros(plugin->N/2 + 1);
plugin->Phi.zeros(plugin->N/2 + 1);
plugin->PhiPrevious.zeros(plugin->N/2 + 1);
plugin->d_phi.zeros(plugin->N/2 + 1);
plugin->d_phi_prime.zeros(plugin->N/2 + 1);
plugin->d_phi_wrapped.zeros(plugin->N/2 + 1);
plugin->omega_true_sobre_fs.zeros(plugin->N/2 + 1);
plugin->AUX.zeros(plugin->N/2 + 1);
plugin->Xa_abs.zeros(plugin->N/2 + 1);
plugin->w.zeros(plugin->N); hann(plugin->N,&plugin->w);
plugin->I.zeros(plugin->N/2 + 1); plugin->I = linspace(0, plugin->N/2,plugin->N/2 + 1);
for (int i=1 ; i<= plugin->nBuffers; i++)
{
plugin->b[i-1] = &plugin->frames[(i-1)*plugin->hopa];
}
fftwf_destroy_plan(plugin->p); plugin->p = fftwf_plan_dft_r2c_1d(plugin->N, plugin->frames2, plugin->fXa, FFTW_ESTIMATE);
fftwf_destroy_plan(plugin->p2); plugin->p2 = fftwf_plan_dft_c2r_1d(plugin->N, plugin->fXs, plugin->q, FFTW_ESTIMATE);
return;
}
for (int i=1; i<=plugin->hopa; i++)
{
for (int j=1; j<=(plugin->nBuffers-1); j++)
{
plugin->b[j-1][i-1] = plugin->b[j][i-1];
}
plugin->b[plugin->nBuffers-1][i-1] = plugin->in[i-1];
}
if ( plugin->cont < plugin->nBuffers-1)
{
plugin->cont = plugin->cont + 1;
}
else
{
shift(plugin->N, plugin->hopa, plugin->Hops, plugin->frames, plugin->frames2, &plugin->w, &plugin->XaPrevious, &plugin->Xa_arg, &plugin->Xa_abs, &plugin->XaPrevious_arg, &plugin->PhiPrevious, plugin->yshift, &plugin->Xa, &plugin->Xs, plugin->q, &plugin->Phi, plugin->ysaida, plugin->ysaida2, plugin->Qcolumn, &plugin->d_phi, &plugin->d_phi_prime, &plugin->d_phi_wrapped, &plugin->omega_true_sobre_fs, &plugin->I, &plugin->AUX, plugin->p, plugin->p2, plugin->fXa, plugin->fXs);
for (int i=1; i<=plugin->hopa; i++)
{
plugin->out_1[i-1] = (g_before + ((plugin->g - g_before)/(plugin->hopa - 1))*(i-1) )*(float)plugin->yshift[i-1];
}
}
}
}
int main() {
// options
unsigned int D=4; // samples/symbol
unsigned int m=3; // filter delay
float beta = 0.3f; // filter excess bandwidth
unsigned int num_data_symbols=32; // number of data symbols
// derived values
unsigned int h_len = 2*D*m+1;
unsigned int num_symbols = num_data_symbols + 2*m;
unsigned int num_samples = D*num_symbols;
// design filter and create interpolator
float h[h_len];
liquid_firdes_rcos(D,m,beta,0.0f,h);
decim_crcf q = decim_crcf_create(D,h,h_len);
// generate input signal and interpolate
float complex x[num_samples];
float complex y[num_symbols];
unsigned int i;
for (i=0; i<num_samples; i++)
x[i] = 1.0f * hann(i,num_samples) * cexpf(_Complex_I * 2 * M_PI * i * 0.057f);
for (i=0; i<num_symbols; i++)
decim_crcf_execute(q, &x[D*i], &y[i], 0);
decim_crcf_destroy(q);
// open output file
FILE * fid = fopen(OUTPUT_FILENAME,"w");
fprintf(fid,"# %s: auto-generated file\n\n", OUTPUT_FILENAME);
fprintf(fid,"reset\n");
fprintf(fid,"set terminal postscript eps enhanced color solid rounded\n");
//fprintf(fid,"set xrange [0:%u];\n",n);
fprintf(fid,"set yrange [-1.5:1.5]\n");
fprintf(fid,"set size ratio 0.3\n");
fprintf(fid,"set xlabel 'Sample Index'\n");
fprintf(fid,"set key top right nobox\n");
fprintf(fid,"set ytics -5,1,5\n");
fprintf(fid,"set grid xtics ytics\n");
fprintf(fid,"set pointsize 0.6\n");
fprintf(fid,"set grid linetype 1 linecolor rgb '%s' lw 1\n", LIQUID_DOC_COLOR_GRID);
fprintf(fid,"set multiplot layout 2,1 scale 1.0,1.0\n");
fprintf(fid,"# real\n");
fprintf(fid,"set ylabel 'Real'\n");
fprintf(fid,"plot '-' using 1:2 with linespoints pointtype 7 pointsize 0.3 linecolor rgb '%s' linewidth 1 title 'input',\\\n",LIQUID_DOC_COLOR_GRAY);
fprintf(fid," '-' using 1:2 with points pointtype 7 linecolor rgb '%s' title 'decimated'\n",LIQUID_DOC_COLOR_GREEN);
for (i=0; i<num_samples; i++)
fprintf(fid,"%4u %12.4e\n", i, crealf(x[i]));
fprintf(fid,"e\n");
for (i=0; i<num_symbols; i++)
fprintf(fid,"%12.4e %12.4e\n", (float)(i*D) - (float)(D*m), crealf(y[i])/D);
fprintf(fid,"e\n");
fprintf(fid,"# imag\n");
fprintf(fid,"set ylabel 'Imag'\n");
fprintf(fid,"plot '-' using 1:2 with linespoints pointtype 7 pointsize 0.3 linecolor rgb '%s' linewidth 1 title 'input',\\\n",LIQUID_DOC_COLOR_GRAY);
fprintf(fid," '-' using 1:2 with points pointtype 7 linecolor rgb '%s' title 'decimated'\n", LIQUID_DOC_COLOR_RED);
for (i=0; i<num_samples; i++)
fprintf(fid,"%4u %12.4e\n", i, cimagf(x[i]));
fprintf(fid,"e\n");
for (i=0; i<num_symbols; i++)
fprintf(fid,"%12.4e %12.4e\n", (float)(i*D) - (float)(D*m), cimagf(y[i])/D);
fprintf(fid,"e\n");
// close output file
fclose(fid);
return 0;
}
