mirror
/
sdrangel
kopia lustrzana https://github.com/f4exb/sdrangel
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
sdrangel/wdsp/resample.cpp

361 wiersze
9.6 KiB
C++
Czysty Wina Historia

/* resample.c
This file is part of a program that implements a Software-Defined Radio.
Copyright (C) 2013 Warren Pratt, NR0V
Copyright (C) 2024 Edouard Griffiths, F4EXB Adapted to SDRangel
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
The author can be reached by email at
warren@wpratt.com
*/
#include "comm.hpp"
#include "fir.hpp"
#include "resample.hpp"
namespace WDSP {
/************************************************************************************************
* *
* VERSION FOR COMPLEX DOUBLE-PRECISION *
* *
************************************************************************************************/
void RESAMPLE::calc_resample (RESAMPLE *a)
{
int x, y, z;
int i, j, k;
int min_rate;
float full_rate;
float fc_norm_high, fc_norm_low;
float* impulse;
a->fc = a->fcin;
a->ncoef = a->ncoefin;
x = a->in_rate;
y = a->out_rate;
while (y != 0)
{
z = y;
y = x % y;
x = z;
}
a->L = a->out_rate / x;
a->M = a->in_rate / x;
if (a->in_rate < a->out_rate) min_rate = a->in_rate;
else min_rate = a->out_rate;
if (a->fc == 0.0) a->fc = 0.45 * (float)min_rate;
full_rate = (float)(a->in_rate * a->L);
fc_norm_high = a->fc / full_rate;
if (a->fc_low < 0.0)
fc_norm_low = - fc_norm_high;
else
fc_norm_low = a->fc_low / full_rate;
if (a->ncoef == 0) a->ncoef = (int)(140.0 * full_rate / min_rate);
a->ncoef = (a->ncoef / a->L + 1) * a->L;
a->cpp = a->ncoef / a->L;
a->h = new float[a->ncoef]; // (float *)malloc0(a->ncoef * sizeof(float));
impulse = FIR::fir_bandpass(a->ncoef, fc_norm_low, fc_norm_high, 1.0, 1, 0, a->gain * (float)a->L);
i = 0;
for (j = 0; j < a->L; j++)
for (k = 0; k < a->ncoef; k += a->L)
a->h[i++] = impulse[j + k];
a->ringsize = a->cpp;
a->ring = new float[a->ringsize]; // (float *)malloc0(a->ringsize * sizeof(complex));
a->idx_in = a->ringsize - 1;
a->phnum = 0;
delete[] (impulse);
}
void RESAMPLE::decalc_resample (RESAMPLE *a)
{
delete[] (a->ring);
delete[] (a->h);
}
RESAMPLE* RESAMPLE::create_resample ( int run, int size, float* in, float* out, int in_rate, int out_rate, float fc, int ncoef, float gain)
{
RESAMPLE *a = new RESAMPLE;
a->run = run;
a->size = size;
a->in = in;
a->out = out;
a->in_rate = in_rate;
a->out_rate = out_rate;
a->fcin = fc;
a->fc_low = -1.0; // could add to create_resample() parameters
a->ncoefin = ncoef;
a->gain = gain;
calc_resample (a);
return a;
}
void RESAMPLE::destroy_resample (RESAMPLE *a)
{
decalc_resample (a);
delete (a);
}
void RESAMPLE::flush_resample (RESAMPLE *a)
{
memset (a->ring, 0, a->ringsize * sizeof (wcomplex));
a->idx_in = a->ringsize - 1;
a->phnum = 0;
}
int RESAMPLE::xresample (RESAMPLE *a)
{
int outsamps = 0;
if (a->run)
{
int i, j, n;
int idx_out;
float I, Q;
for (i = 0; i < a->size; i++)
{
a->ring[2 * a->idx_in + 0] = a->in[2 * i + 0];
a->ring[2 * a->idx_in + 1] = a->in[2 * i + 1];
while (a->phnum < a->L)
{
I = 0.0;
Q = 0.0;
n = a->cpp * a->phnum;
for (j = 0; j < a->cpp; j++)
{
if ((idx_out = a->idx_in + j) >= a->ringsize) idx_out -= a->ringsize;
I += a->h[n + j] * a->ring[2 * idx_out + 0];
Q += a->h[n + j] * a->ring[2 * idx_out + 1];
}
a->out[2 * outsamps + 0] = I;
a->out[2 * outsamps + 1] = Q;
outsamps++;
a->phnum += a->M;
}
a->phnum -= a->L;
if (--a->idx_in < 0) a->idx_in = a->ringsize - 1;
}
}
else if (a->in != a->out)
memcpy (a->out, a->in, a->size * sizeof (wcomplex));
return outsamps;
}
void RESAMPLE::setBuffers_resample(RESAMPLE *a, float* in, float* out)
{
a->in = in;
a->out = out;
}
void RESAMPLE::setSize_resample(RESAMPLE *a, int size)
{
a->size = size;
flush_resample (a);
}
void RESAMPLE::setInRate_resample(RESAMPLE *a, int rate)
{
decalc_resample (a);
a->in_rate = rate;
calc_resample (a);
}
void RESAMPLE::setOutRate_resample(RESAMPLE *a, int rate)
{
decalc_resample (a);
a->out_rate = rate;
calc_resample (a);
}
void RESAMPLE::setFCLow_resample (RESAMPLE *a, float fc_low)
{
if (fc_low != a->fc_low)
{
decalc_resample (a);
a->fc_low = fc_low;
calc_resample (a);
}
}
void RESAMPLE::setBandwidth_resample (RESAMPLE *a, float fc_low, float fc_high)
{
if (fc_low != a->fc_low || fc_high != a->fcin)
{
decalc_resample (a);
a->fc_low = fc_low;
a->fcin = fc_high;
calc_resample (a);
}
}
// exported calls
void* RESAMPLE::create_resampleV (int in_rate, int out_rate)
{
return (void *)create_resample (1, 0, 0, 0, in_rate, out_rate, 0.0, 0, 1.0);
}
void RESAMPLE::xresampleV (float* input, float* output, int numsamps, int* outsamps, void* ptr)
{
RESAMPLE *a = (RESAMPLE*) ptr;
a->in = input;
a->out = output;
a->size = numsamps;
*outsamps = xresample(a);
}
void RESAMPLE::destroy_resampleV (void* ptr)
{
destroy_resample ( (RESAMPLE*) ptr );
}
/************************************************************************************************
* *
* VERSION FOR NON-COMPLEX FLOATS *
* *
************************************************************************************************/
RESAMPLEF* RESAMPLEF::create_resampleF ( int run, int size, float* in, float* out, int in_rate, int out_rate)
{
RESAMPLEF *a = new RESAMPLEF;
int x, y, z;
int i, j, k;
int min_rate;
float full_rate;
float fc;
float fc_norm;
float* impulse;
a->run = run;
a->size = size;
a->in = in;
a->out = out;
x = in_rate;
y = out_rate;
while (y != 0)
{
z = y;
y = x % y;
x = z;
}
a->L = out_rate / x;
a->M = in_rate / x;
if (in_rate < out_rate) min_rate = in_rate;
else min_rate = out_rate;
fc = 0.45 * (float)min_rate;
full_rate = (float)(in_rate * a->L);
fc_norm = fc / full_rate;
a->ncoef = (int)(60.0 / fc_norm);
a->ncoef = (a->ncoef / a->L + 1) * a->L;
a->cpp = a->ncoef / a->L;
a->h = new float[a->ncoef]; // (float *) malloc0 (a->ncoef * sizeof (float));
impulse = FIR::fir_bandpass (a->ncoef, -fc_norm, +fc_norm, 1.0, 1, 0, (float)a->L);
i = 0;
for (j = 0; j < a->L; j ++)
for (k = 0; k < a->ncoef; k += a->L)
a->h[i++] = impulse[j + k];
a->ringsize = a->cpp;
a->ring = new float[a->ringsize]; //(float *) malloc0 (a->ringsize * sizeof (float));
a->idx_in = a->ringsize - 1;
a->phnum = 0;
delete[] (impulse);
return a;
}
void RESAMPLEF::destroy_resampleF (RESAMPLEF *a)
{
delete[] (a->ring);
delete[] (a->h);
delete (a);
}
void RESAMPLEF::flush_resampleF (RESAMPLEF *a)
{
memset (a->ring, 0, a->ringsize * sizeof (float));
a->idx_in = a->ringsize - 1;
a->phnum = 0;
}
int RESAMPLEF::xresampleF (RESAMPLEF *a)
{
int outsamps = 0;
if (a->run)
{
int i, j, n;
int idx_out;
float I;
for (i = 0; i < a->size; i++)
{
a->ring[a->idx_in] = (float)a->in[i];
while (a->phnum < a->L)
{
I = 0.0;
n = a->cpp * a->phnum;
for (j = 0; j < a->cpp; j++)
{
if ((idx_out = a->idx_in + j) >= a->ringsize) idx_out -= a->ringsize;
I += a->h[n + j] * a->ring[idx_out];
}
a->out[outsamps] = (float)I;
outsamps++;
a->phnum += a->M;
}
a->phnum -= a->L;
if (--a->idx_in < 0) a->idx_in = a->ringsize - 1;
}
}
else if (a->in != a->out)
memcpy (a->out, a->in, a->size * sizeof (float));
return outsamps;
}
// Exported calls
void* RESAMPLEF::create_resampleFV (int in_rate, int out_rate)
{
return (void *) create_resampleF (1, 0, 0, 0, in_rate, out_rate);
}
void RESAMPLEF::xresampleFV (float* input, float* output, int numsamps, int* outsamps, void* ptr)
{
RESAMPLEF *a = (RESAMPLEF*) ptr;
a->in = input;
a->out = output;
a->size = numsamps;
*outsamps = xresampleF(a);
}
void RESAMPLEF::destroy_resampleFV (void* ptr)
{
destroy_resampleF ( (RESAMPLEF*) ptr );
}
} // namespace WDSP
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik