void apf(short *in, short *coeff, short *out, long delayi, short alpha,
short beta, short u, short agc, short ltgain, short order, short length, short br)
{
static int FirstTime = 1;
static short FIRmem[ORDER]; /* FIR filter memory */
static short IIRmem[ORDER]; /* IIR filter memory */
static short last;
static short Residual[ACBMemSize + SubFrameSize]; /* local residual */
short wcoef1[ORDER];
short wcoef2[ORDER];
short scratch[SubFrameSize];
short temp[SubFrameSize];
short mem[ORDER];
long sum1, sum2;
long gamma, APFgain;
short i, j, n, best;
short Stemp, shift1, shift2;
long Ltemp;
/* initialization -- should be done in init routine for implementation */
if (FirstTime)
{
FirstTime = 0;
for (i = 0; i < ORDER; i++)
FIRmem[i] = 0;
for (i = 0; i < ORDER; i++)
IIRmem[i] = 0;
for (i = 0; i < ACBMemSize; i++)
Residual[i] = 0;
last = 0;
}
/* Compute weighted LPC coefficients */
weight(wcoef1, coeff, alpha, order);
weight(wcoef2, coeff, beta, order);
/* Tilt speech */
/*...no tilt in non-voiced regions...*/
for (i = 0, sum2 = 0; i < length - 1; i++)
sum2 = L_mac(sum2, in[i], in[i + 1]);
if (sum2 < 0)
u = 0; /*...no tilt...*/
for (i = 0; i < length; i++)
{
scratch[i] = msu_r(L_deposit_h(in[i]), u, last);
last = in[i];
}
/* Compute residual */
fir(scratch, scratch, wcoef1, FIRmem, order, length);
for (i = 0; i < SubFrameSize ; i++)
Residual[ACBMemSize+i] = scratch[i];
/* long term filtering */
/* Find best integer delay around delayi */
j = extract_h(L_add(delayi, 32768));
sum1 = 0;
shift1 = 1;
best = j;
for (i = Max(DMIN, j - 3); i <= Min(DMAX, j + 3); i++)
{
shift2 = 1;
for (n = ACBMemSize, sum2 = 0; n < ACBMemSize + length; n++)
{
Ltemp = L_mult(Residual[n], Residual[n - i]);
Ltemp = L_shr(Ltemp, shift2);
sum2 = L_add(sum2, Ltemp);
if (sum2 >= 0x40000000)
{
sum2 = L_shr(sum2, 1);
shift2++;
}
}
if( ((shift1 >= shift2) && (L_shr(sum2,sub(shift1,shift2)) > sum1))
|| ((shift1 < shift2) && (sum2 > L_shr(sum1,sub(shift2,shift1)))))
{
sum1 = sum2;
shift1 = shift2;
best = i;
}
}
/* Get beta for delayi */
shift1 = 1;
for (i = ACBMemSize, sum1 = 0; i < ACBMemSize + length; i++)
{
Ltemp = L_mult(Residual[i - best], Residual[i - best]);
Ltemp = L_shr(Ltemp, shift1);
sum1 = L_add(sum1, Ltemp);
if (sum1 >= 0x40000000)
{
sum1 = L_shr(sum1, 1);
shift1++;
}
}
shift2 = 1;
for (i = ACBMemSize, sum2 = 0; i < ACBMemSize + length; i++)
{
Ltemp = L_mult(Residual[i], Residual[i - best]);
Ltemp = L_shr(Ltemp, shift2);
sum2 = L_add(sum2, Ltemp);
if (sum2 >= 0x40000000)
{
sum2 = L_shr(sum2, 1);
shift2++;
}
}
if (shift1 > shift2)
{
shift1 = sub(shift1, shift2);
sum2 = L_shr(sum2, shift1);
}
else if (shift1 < shift2)
{
shift2 = sub(shift2, shift1);
sum1 = L_shr(sum1, shift2);
}
if ((sum2 == 0) || (sum1 == 0) || (br == 1))
for (i = 0; i < length; i++)
temp[i] = Residual[i + ACBMemSize];
else
{
if (sum2 >= sum1)
gamma = 0x7fffffff; /* Clip gamma at 1.0 */
else if (sum2 < 0)
gamma = 0;
else
{
shift1 = norm_l(sum1);
sum1 = L_shl(sum1, shift1);
sum2 = L_shl(sum2, shift1);
gamma = L_divide(sum2, sum1);
}
if (gamma < 0x40000000)
for (i = 0; i < length; i++)
temp[i] = Residual[i + ACBMemSize];
else
{
/* Do actual filtering */
for (i = 0; i < length; i++)
{
Ltemp = L_mpy_ls(gamma, ltgain);
Ltemp = L_mpy_ls(Ltemp, Residual[ACBMemSize + i - best]);
temp[i] = add(Residual[ACBMemSize + i], round(Ltemp));
}
}
}
/* iir short term filter - first run */
for (i = 0; i < length; i++)
scratch[i] = temp[i];
for (i = 0; i < order; i++)
mem[i] = IIRmem[i];
iir(scratch, scratch, wcoef2, mem, order, length);
/* Get filter gain */
shift1 = 1;
for (i = 0, sum1 = 0; i < length; i++)
{
Ltemp = L_mult(in[i], in[i]);
Ltemp = L_shr(Ltemp, shift1);
sum1 = L_add(sum1, Ltemp);
if (sum1 >= 0x40000000)
{
sum1 = L_shr(sum1, 1);
shift1++;
}
}
shift2 = 1;
for (i = 0, sum2 = 0; i < length; i++)
{
Ltemp = L_mult(scratch[i], scratch[i]);
Ltemp = L_shr(Ltemp, shift2);
sum2 = L_add(sum2, Ltemp);
if (sum2 >= 0x40000000)
{
sum2 = L_shr(sum2, 1);
shift2++;
}
}
if (shift1 > shift2)
{
shift1 = sub(shift1, shift2);
sum2 = L_shr(sum2, shift1);
}
else if (shift1 < shift2)
{
shift2 = sub(shift2, shift1);
sum1 = L_shr(sum1, shift2);
}
if (sum2 != 0)
{
shift1 = norm_l(sum2);
sum2 = L_shl(sum2, shift1);
shift1 = sub(shift1, 2); /* For (1. < APFgain < 2.) */
sum1 = L_shl(sum1, shift1);
Ltemp = L_divide(sum1, sum2);
shift1 = norm_l(Ltemp);
Ltemp = L_shl(Ltemp, shift1);
Stemp = sqroot(Ltemp);
if (shift1 & 1)
APFgain = L_mult(0x5a82, Stemp);
else
APFgain = L_deposit_h(Stemp);
shift1 = shr(shift1, 1);
APFgain = L_shr(APFgain, shift1);
/* Re-normalize the speech signal */
for (i = 0; i < length; i++)
{
Ltemp = L_mpy_ls(APFgain, temp[i]);
Ltemp = L_shl(Ltemp, 1); /* For (1. < APFgain < 2.) */
temp[i] = round(Ltemp);
}
}
else
APFgain = 0x40000000;
/* iir short term filter - second run */
iir(out, temp, wcoef2, IIRmem, order, length);
/* Update residual buffer */
for (i = 0; i < ACBMemSize; i++)
Residual[i] = Residual[i + length];
}
int main() {
Sine_f32 sine_1KHz( 1000, SAMPLE_RATE, 1.0);
Sine_f32 sine_15KHz(15000, SAMPLE_RATE, 0.5);
FIR_f32<NUM_TAPS> fir(firCoeffs32);
float32_t buffer_a[BLOCK_SIZE];
float32_t buffer_b[BLOCK_SIZE];
for (float32_t *sgn=output; sgn<(output+TEST_LENGTH_SAMPLES); sgn += BLOCK_SIZE) {
sine_1KHz.generate(buffer_a); // Generate a 1KHz sine wave
sine_15KHz.process(buffer_a, buffer_b); // Add a 15KHz sine wave
fir.process(buffer_b, sgn); // FIR low pass filter: 6KHz cutoff
}
sine_1KHz.reset();
for (float32_t *sgn=expected_output; sgn<(expected_output+TEST_LENGTH_SAMPLES); sgn += BLOCK_SIZE) {
sine_1KHz.generate(sgn); // Generate a 1KHz sine wave
}
float snr = arm_snr_f32(&expected_output[DELAY-1], &output[WARMUP-1], TEST_LENGTH_SAMPLES-WARMUP);
printf("snr: %f\n\r", snr);
if (snr < SNR_THRESHOLD_F32) {
printf("Failed\n\r");
} else {
printf("Success\n\r");
}
}
int main()
{
//Local variables (declared in wcdma_signal_fixed.h)
//int Signal_I [(SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR]
//int Signal_Q [(SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR]
//int FIR_COEFF[FILTER_NB_CELL]
//int symbole_flow_user1[NB_SYMBOL]
//int ovsf_code_user1[SF]
//local variables (others)
int Signal_I_symb[SF/2*SAMPLING_FACTOR];
int Signal_Q_symb[SF/2*SAMPLING_FACTOR];
int Signal_I_filtered[(SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR] ;
int Signal_Q_filtered[(SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR] ;
int Signal [ (SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR * 2 ] ;
int amplitude ;
//Other variables
int b,i;
//Inits
fir ( FIR_COEFF, FILTER_NB_CELL, Signal_I, (SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR, Signal_I_filtered ) ;
fir ( FIR_COEFF, FILTER_NB_CELL, Signal_Q, (SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR, Signal_Q_filtered ) ;
QPSKinv ( Signal_I_filtered, Signal_Q_filtered, (SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR, Signal, &litude ) ;
for ( i = 0 ; i < (SF/2*NB_SYMBOL+DELAY_MAX/2)*SAMPLING_FACTOR*2 ; i++ )
{
printf ( "%d ", Signal[i] ) ;
if ( i % 8 == 0 )
printf ( "\n" ) ;
}
printf ( "\n" ) ;
//Check results
//End
return(0);
}
void
FIR_vst::processReplacing (float** inputs, float** outputs, VstInt32 nSamples)
{
float* pIn = *inputs;
float* pOut = *outputs;
const float vol = powf(10.0f, (m_afParameters[PORT_VOL] * 80.0f - 60.0f) / 20.0f);
uint model = (uint) MAX(m_afParameters[PORT_MODEL] * NUM_MODELS, NUM_MODELS - 1);
fir(&m_State, pIn, pOut, nSamples, (uint)getSampleRate(), model, vol);
}
int main() {
int i;
double x;
double y;
double h[4] = {1.,1.,1.,1.};
double w[4] = {0};
while (fscanf(stdin, "%lf", &x) == 1) {
y = fir(M, h, w, x);
fprintf(stdout, "%lf\n", y);
}
/* Input-off transient. */
for (i = 0; i < M; i++) {
y = fir(M, h, w, 0.);
fprintf(stdout, "%lf\n", y);
}
return 0;
}
void test(
INHERIT *ip, // - pointer to INHERIT structure
BASE& br, // - reference to BASE of INHERIT structure
INHERIT& ir ) // - reference to INHERITE structure
{
BASE *bp;
// 4.7
init_inherit( ip );
if( ip->b != 1 ) fail(__LINE__);
fir( ir );
if( ip->a != -1 ) fail(__LINE__);
if( ip->b != -1 ) fail(__LINE__);
init_inherit( ip );
fbr( br );
if( ip->a != -1 ) fail(__LINE__);
if( ip->b != 1 ) fail(__LINE__);
init_inherit( &i );
fir( i );
if( i.a != -1 ) fail(__LINE__);
if( i.b != -1 ) fail(__LINE__);
init_inherit( &i );
bp = &i;
fbr( *bp );
if( i.a != -1 ) fail(__LINE__);
if( i.b != 1 ) fail(__LINE__);
// 5
init_inherit( &i );
br.a++;
ir.a += 5;
ir.b *= 3;
if( i.a != 7 ) fail(__LINE__);
if( i.b != 3 ) fail(__LINE__);
// 5.2.2
static_int = 0;
return_int_ref() = 7;
if( static_int != 7 ) fail(__LINE__);
}
/** \fn main()
* \brief Prueba de los módulos implementados.
* @return No tiene salida.
*/
int main() {
/// Señal de entrada.
sample_t u[SIGNAL_LENGTH]; //señal de entrada
/// Señal de salida.
sample_t y[SIGNAL_LENGTH]; //señal de salida del filtro
sample_t ma = 1.0/TAP_LENGTH; //moving average
/// Coeficientes del FIR.
sample_t coefs[TAP_LENGTH] = {ma,ma,ma,ma}; //coeficientes de media movil
/// Retardo de la señal de entrada (en muestras).
int retardo = 4; //retardo
/// Altura de la señal de entrada
sample_t altura = 4; //altura
printf("\n");
printf("************** Filtrado FIR ***************\n");
printf("* *\n");
printf("* _________ *\n");
printf("* U | | Y *\n");
printf("* -------->| FIR |-------> *\n");
printf("* |_________| *\n");
printf("* *\n");
printf("*******************************************\n");
printf("\n");
/*Generar señal de entrada*/
step(&u[0],retardo,altura);
//impulso(&u[0],retardo,altura);
/*Imprimir señal de entrada*/
printf("Señal de entrada al filtro:\n");
for (int i=0; i<SIGNAL_LENGTH; printf("%1.1f ",u[i]),i++);
printf("\n\n");
/*Inicialización del filtro*/
ini_fir(coefs); //printf("Coeficientes del filtro: %1.1f\n",c[0]);
/*Filtrado de la señal*/
for (int i=0; i<SIGNAL_LENGTH; i++) {
//printf("Taps disponibles: %d\n",taps);
y[i] = fir(&u[i]); //printf("Señal de salida: %f\n",y[i]);
};
/*Imprimir señal de salida*/
printf("Señal de salida al filtro:\n");
for (int i=0; i<SIGNAL_LENGTH; printf("%1.1f ",y[i]),i++);
printf("\n\n");
}
void forest (int n) //N - количество елочек в лесу
{
int h0=150;
int i,a,b,h;
int col;
for (i=1; i<=n; i++)
{
h=rand()%h0+10; // высота треугольника от 10 до h0 точек
a=rand()%700; // координата x вершины елочки - от 20 до ширины окна
b=rand()%500; // координата y вершины елочки - от 5 до высоты окна
col=rand()%15+1; // цвет линий
fir(a,b,h,col); // ќбращение к процедуре рисовани¤ елочки
}
}
int main () {
const int SAMPLES=600;
FILE *fp;
data_t signal, output;
coef_t taps[11] = {0,-10,-9,23,56,63,56,23,-9,-10,0,};
int i, ramp_up;
signal = 0;
ramp_up = 1;
fp=fopen("out.dat","w");
for (i=0;i<=SAMPLES;i++) {
if (ramp_up == 1)
signal = signal + 1;
else
signal = signal - 1;
fir(&output,taps,signal);
if ((ramp_up == 1) && (signal >= 75))
ramp_up = 0;
else if ((ramp_up == 0) && (signal <= -75))
ramp_up = 1;
fprintf(fp,"%i %d %d\n",i,signal,output);
}
fclose(fp);
printf ("Comparing against output data \n");
if (system("diff -w out.dat out.gold.dat")) {
fprintf(stdout, "*******************************************\n");
fprintf(stdout, "FAIL: Output DOES NOT match the golden output\n");
fprintf(stdout, "*******************************************\n");
return 1;
} else {
fprintf(stdout, "*******************************************\n");
fprintf(stdout, "PASS: The output matches the golden output!\n");
fprintf(stdout, "*******************************************\n");
return 0;
}
}
int main()
{
int size_i = 10;
int size_coef = 3;
int s_in[10]= {1, 2, 3, 4, 5, 1, 2, 5, 6, 10};
int coef[3] = {2, 8, 9};
int out[8];
int outc[8];
int firReturn = fir(s_in, size_i, coef, size_coef, out);
printf("FIR filter in assembly returned %d.\n",firReturn);
firFilterInC(s_in, size_i, coef, size_coef, outc);
printArray(out,8,"out");
printArray(outc,8,"outc");
return 0;
}
int main (void)
{
check_vect ();
int i, j;
float diff;
for (i = 0; i < M; i++)
coeff[i] = i;
for (i = 0; i < N+M; i++)
in[i] = i;
foo ();
fir ();
for (i = 0; i < N; i++) {
if (out[i] != fir_out[i])
abort ();
}
return 0;
}
// (p/q) fractional resampler
// * length of the used FIR filter is q*l
// * consumes q*num_blocks samples and
// * produces p*num_blocks samples per call to process
fractional_resampler(int p,
int q,
int l,
int num_blocks=1)
: p_(p)
, q_(q)
, l_(l)
, num_blocks_(num_blocks)
, counter_(0)
, history_(2*q*l_, 0)
, b_(p*q*l_, 0)
, out_(p*num_blocks, 0) {
typedef filter::fir::lowpass<float> fir_type;
fir_type fir(p*q*l_);
fir.design(1.0f/p, 0.1f/p);
for (int i=0; i<q*l; ++i) {
for (int j=0; j<p; ++j) {
b_[q*l-1-i + j*q*l] = p*fir.coeff()[i*p + j];
}
}
}
int main (int,char**)
{
// inits the filter
Fir1 fir("coefficients.dat");
// resets the delay line to zero
fir.reset ();
// gets the number of taps
int taps = fir.getTaps();
printf("taps = %d\n",taps);
FILE *fimpulse = fopen("impulse.dat","wt");
for(int i=0;i<taps*2;i++)
{
float a=0;
if (i==10) a = 1;
float b = fir.filter(a);
fprintf(fimpulse,"%f\n",b);
}
fclose(fimpulse);
fprintf(stderr,"Written the impulse response to 'impulse.dat'\n");
}
vvi floydwarshall(vvi &g)
{
vvi f=g; int n=f.si;
fkr(n) fir(n) fjr(n) f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
return f;
}
void main(void)
{
// Local variables
int i,k;
unsigned char preamble=0;
unsigned char datachar=0;
unsigned char count_bits=0;
unsigned char count_bytes=0;
unsigned char trig=0;
unsigned char led_cnt = 0;
// Setup 21364 board
Setup21364();
for (k=0;k < N_bp+1; k++)
{
state_bp[k] = 0.0;
}
for (k=0; k< N_mf ; k++)
{
x2[k]=0.0;
}
for (k=0;k < N_mf+1; k++)
{
state_mf[k]=0.0;
}
//Initialise buffer contents
for (k=0;k < N_mf; k++)
{
x5[k]=0.0;
}
for(;;)
{
while(blockReady)
{
//Clear the Block Ready Semaphore
blockReady = 0;
//Set the Processing Active Semaphore before starting processing
isProcessing = 1;
// Pointer to input samples
unsigned int * sample_in=src_pointer[int_cntr];
// Pointer to output ssamples
unsigned int * sample_out=src_pointer[int_cntr];
for(i=0;i<NUM_SAMPLES/2;i++)
{
/*
Important Notes:
1. Conversion from 24 to 32 bit and input scaling
2. Index [2*i+1] corresponds to ADC channel 1, [2*i] to ADC channel 2
3. The differential input range for the ADC is ~2.8Vpp
4. Do not overdrive the ADC with the signal generator (see point 3 for range)
5. C-language elements implemented: bit-shifting, pointer casting, array indexing
*/
x0=(float)((int)(sample_in[2*i+1]<<8)*scale_in);
x1=fir(x0,h_bp,state_bp,N_bp);
//demodulator
x3=x1*x2[19];
for(k=N_mf-1;k>0;k--)
{
x2[k]=x2[k-1];
}
x2[0]=x1;
//low pass filter
x4=fir(x3, h_mf, state_mf, N_mf);
//x5 input by shifting
for(k=0;k<N_mf-1;k++)
{
x5[k]=x5[k+1];
}
x5[N_mf-1]=x4;
Nc0=Nc0+1; //define Nc0
if(Nc0 == Nc1)
{
Ee=0;
El=0;
for (k=0;k<10;k++)
{
Ee= Ee + x5[k]*x5[k];
El = El + x5[k+10]*x5[k+10];
}
//set nc2 to vary nc1
if(Ee > El)
Nc2=Nc2+1;
else if(Ee < El)
Nc2=Nc2-1;
else
Nc2=Nc2;
//set nc1 to control shifting of X5
if(Nc2 == 10)
{
Nc2=0;
Nc1=19;
}
else if (Nc2 == -10)
{
Nc2=0;
Nc1=21;
}
else
Nc1=20;
Nc0=0; //reset the counter for X5shifting
Em=0.5*(x5[9]+x5[10]);
//Frame synchronisation Search ++++
if(trig == 0)
{
preamble=preamble>>1;
if(Em<0)
{
preamble=preamble+0x80000000;
}
if(preamble == 0x2B2B2B2B)
{
trig=1;
preamble=0;
led_cnt=led_cnt%2;
LED_ON(led_cnt++);
}
}
//Frame synchronisation get info
else // data detection should happened in next bits!!!
{
datachar>>=1;
if(Em<0)
{
datachar+=0x80;
}
count_bits++;
if(count_bits == 8)
{
count_bits=0;
data[count_bytes] = datachar;
count_bytes++;
datachar=0;
if(count_bytes>71)
{
count_bytes = 0;
trig=0;
}
}
}
}
// Buffer ADC 1 output for inspection after DSP is halted
scope1[k]=x0;
scope2[k++]=x0;
/*
Important Notes: the code below implements:
1. 32-to-24 bit convesion and output to DAC 1 & 2
2. Index 2*i+1 corresponds to DAC channel 1, 2i to DAC channel 2
3. Full-Scale Output Voltage at Each Pin (Single-Ended) 1 Vrms or 2.8Vpp.
Current setup: DACVOL_MAX in init1835viaSPI.c gives ~ 2.8Vpp
4. Depending on the input signal strength additional scaling is required.
5. The code below sends x0 and -x0 to the DAC outputs.
*/
sample_out[2*i+1]=(unsigned int)(((int)(Em*scale_out))>>8); // DAC 1
sample_out[2*i]=(unsigned int)(((int)(x4*scale_out))>>8); // DAC 2
}
int main(int argc, char* argv[])
{
if (argc != 3) {
fprintf(stderr, "usage: inputpcm outputpcm\n");
return 1;
}
const char* iname = argv[1];
const char* oname = argv[2];
FILE* fin = fopen(iname, "rb");
FILE* fout = fopen(oname, "wb");
// Set up the FFT.
fftw_complex* infft = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
fftw_complex* outfft = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
fftw_plan forward = fftw_plan_dft_1d(N, infft, outfft, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_plan reverse = fftw_plan_dft_1d(N, infft, outfft, FFTW_BACKWARD, FFTW_ESTIMATE);
// window - holds the window samples.
// We shift through from right to left S samples at a time.
short window[N] = {0};
// outblock - holds the output samples we shift out from right to left.
short outblock[N] = {0};
int i;
while (!feof(fin)) {
// Read in the next S samples
short samples[S];
fread(samples, sizeof(short), S, fin);
// Pass the samples through the fir filter.
for (i = 0; i < S; i++) {
samples[i] = fir(samples[i]);
}
// Shift input samples left by S and copy in the next S sample values.
// (Oversampling)
memmove(window, window + S, sizeof(short) * (N-S));
memcpy(window + (N-S), samples, sizeof(short)*S);
// Convert audio samples to complex numbers
for (i = 0; i < N; i++) {
infft[i] = (double complex)window[i];
}
// Forward FFT
fftw_execute(forward);
// Pitch Adjustment.
pitchadjust(outfft, infft);
// Inverse FFT
// We have to scale down by N because fftw doesn't for us.
fftw_execute(reverse);
for (i = 0; i < N; i++) {
outfft[i] /= (double)N;
}
// Average in new samples with output block and shift out ready
// samples. (Overlayer)
for (i = 0; i < N; i++) {
outblock[i] += (short)(creal(outfft[i])*S/(double)(N));
}
fwrite(outblock, sizeof(short), S, fout);
memmove(outblock, outblock+S, sizeof(short) * (N-S));
for (i = N-S; i < N; i++) {
outblock[i] = 0;
}
}
fftw_destroy_plan(forward);
fftw_destroy_plan(reverse);
fftw_free(infft);
fftw_free(outfft);
fclose(fin);
fclose(fout);
}
int apt_decode(apt_t *apt, buffer_t *sound_buffer, float *pixels_out)
{
double corr, ecorr, lcorr;
float pixelv[APT_IMG_WIDTH + SyncFilterLen] = {};
int res;
int npv = apt->num_leftover_pixels;
if (apt->num_leftover_pixels > 0) {
memmove(pixelv, apt->leftover_pixels, npv * sizeof(float));
apt->num_leftover_pixels = 0;
}
if (npv < SyncFilterLen + 2) {
res = getpixelv(sound_buffer, apt, &(pixelv[npv]), SyncFilterLen + 2 - npv);
npv += res;
if (npv < SyncFilterLen + 2)
return (0);
}
/* test sync */
corr = fir(&(pixelv[1]), Sync, SyncFilterLen);
ecorr = fir(pixelv, Sync, SyncFilterLen);
lcorr = fir(&(pixelv[2]), Sync, SyncFilterLen);
apt->FreqLine = 1.0 + (ecorr - lcorr) / corr / APT_IMG_WIDTH / 4.0;
if (corr <= 0.75 * apt->last_max_correlation) {
apt->synced = 0;
apt->FreqLine = 1.0;
}
apt->last_max_correlation = corr;
if (apt->synced < 8) {
int shift, mshift;
if (npv < APT_IMG_WIDTH + SyncFilterLen) {
res =
getpixelv(sound_buffer, apt, &(pixelv[npv]), APT_IMG_WIDTH + SyncFilterLen - npv);
npv += res;
if (npv < APT_IMG_WIDTH + SyncFilterLen)
return (0);
}
/* lookup sync start */
mshift = 0;
for (shift = 1; shift < APT_IMG_WIDTH; shift++) {
double corr;
corr = fir(&(pixelv[shift + 1]), Sync, SyncFilterLen);
if (corr > apt->last_max_correlation) {
mshift = shift;
apt->last_max_correlation = corr;
}
}
if (mshift != 0) {
memmove(pixelv, &(pixelv[mshift]),
(npv - mshift) * sizeof(float));
npv -= mshift;
apt->synced = 0;
apt->FreqLine = 1.0;
} else
apt->synced += 1;
}
if (npv < APT_IMG_WIDTH) {
res = getpixelv(sound_buffer, apt, &(pixelv[npv]), APT_IMG_WIDTH - npv);
npv += res;
if (npv < APT_IMG_WIDTH)
return (0);
}
if (npv == APT_IMG_WIDTH) {
npv = 0;
} else {
memmove(apt->leftover_pixels, &(pixelv[APT_IMG_WIDTH]),
(npv - APT_IMG_WIDTH) * sizeof(float));
apt->num_leftover_pixels = npv - APT_IMG_WIDTH;
}
memcpy(pixels_out, pixelv, APT_IMG_WIDTH*sizeof(float));
return (1);
}
/* ------------------------------------------------------------------ run --- */
int BASE::run()
{
int i = 0;
double roomsig[2][BUFLEN], rvbsig[2][BUFLEN];
const int totalSamps = insamps + tapcount;
const int frameCount = framesToRun();
DBG1(printf("%s::run(): totalSamps = %d\n", name(), totalSamps));
// this will return frameCount' worth of input, even if we have
// passed the end of the input (will produce zeros)
getInput(cursamp, frameCount);
DBG1(printf("getInput(%d, %d) called\n", cursamp, frameCount));
int bufsamps = getBufferSize();
// loop for required number of output samples
while (i < frameCount) {
// limit buffer size to end of current pull (chunksamps)
if (frameCount - i < bufsamps)
bufsamps = max(0, frameCount - i);
DBG1(printf("top of main loop: i = %d cursamp = %d bufsamps = %d\n",
i, cursamp, bufsamps));
DBG(printf("input signal:\n"));
DBG(PrintInput(&in[i], bufsamps));
// add signal to delay
put_tap(cursamp, &in[i], bufsamps);
// if processing input signal or flushing delay lines ...
if (cursamp < totalSamps) {
// limit buffer size of end of input data
if (totalSamps - cursamp < bufsamps)
bufsamps = max(0, totalSamps - cursamp);
if ((tapcount = updatePosition(cursamp)) < 0)
return PARAM_ERROR;
DBG1(printf(" inner loop: bufsamps = %d\n", bufsamps));
for (int ch = 0; ch < 2; ch++) {
for (int path = 0; path < 13; path++) {
Vector *vec = &m_vectors[ch][path];
DBG(printf("vector[%d][%d]:\n", ch, path));
/* get delayed samps */
get_tap(cursamp, ch, path, bufsamps);
DBG(PrintSig(vec->Sig, bufsamps));
/* air absorpt. filters */
air(vec->Sig, bufsamps, vec->Airdata);
/* wall absorpt. filters */
if (path > 0) // no filtering of direct signal
wall(vec->Sig, bufsamps, vec->Walldata);
/* do binaural angle filters if necessary*/
if (m_binaural)
fir(vec->Sig, cursamp, g_Nterms[path],
vec->Fircoeffs, vec->Firtaps, bufsamps);
// sum unscaled reflected paths as input for RVB.
// first path is set; the rest are summed
if (path == 1)
copyBuf(&roomsig[ch][0], vec->Sig, bufsamps);
else if (path > 1)
addBuf(&roomsig[ch][0], vec->Sig, bufsamps);
/* now do cardioid mike effect if not binaural mode */
if (!m_binaural)
scale(vec->Sig, bufsamps, vec->MikeAmp);
DBG(printf("after final scale before rvb:\n"));
DBG(PrintSig(vec->Sig, bufsamps, 0.1));
}
/* scale reverb input by amp factor */
scale(&roomsig[ch][0], bufsamps, m_rvbamp);
}
/* run 1st and 2nd generation paths through reverberator */
for (int n = 0; n < bufsamps; n++) {
if (m_rvbamp != 0.0) {
double rmPair[2];
double rvbPair[2];
rmPair[0] = roomsig[0][n];
rmPair[1] = roomsig[1][n];
RVB(rmPair, rvbPair, cursamp + n);
rvbsig[0][n] = rvbPair[0];
rvbsig[1][n] = rvbPair[1];
}
else
rvbsig[0][n] = rvbsig[1][n] = 0.0;
}
DBG(printf("summing vectors\n"));
if (!m_binaural) {
// re-sum scaled direct and reflected paths as early response
// first path is set; the rest are summed
for (int path = 0; path < 13; path++) {
if (path == 0) {
copyBuf(&roomsig[0][0], m_vectors[0][path].Sig, bufsamps);
copyBuf(&roomsig[1][0], m_vectors[1][path].Sig, bufsamps);
}
else {
addBuf(&roomsig[0][0], m_vectors[0][path].Sig, bufsamps);
addBuf(&roomsig[1][0], m_vectors[1][path].Sig, bufsamps);
}
}
}
DBG(printf("left signal:\n"));
DBG(PrintSig(roomsig[0], bufsamps, 0.1));
DBG(printf("right signal:\n"));
DBG(PrintSig(roomsig[1], bufsamps, 0.1));
/* sum the early response & reverbed sigs */
register float *outptr = &this->outbuf[i*2];
for (int n = 0; n < bufsamps; n++) {
*outptr++ = roomsig[0][n] + rvbsig[0][n];
*outptr++ = roomsig[1][n] + rvbsig[1][n];
}
DBG(printf("FINAL MIX:\n"));
DBG(PrintInput(&this->outbuf[i], bufsamps));
}
else { /* flushing reverb */
// this is the current location in the main output buffer
// to write to now
register float *outptr = &this->outbuf[i*2];
DBG1(printf(" flushing reverb: i = %d, bufsamps = %d\n", i, bufsamps));
for (int n = 0; n < bufsamps; n++) {
if (m_rvbamp > 0.0) {
double rmPair[2];
double rvbPair[2];
rmPair[0] = 0.0;
rmPair[1] = 0.0;
RVB(rmPair, rvbPair, cursamp + n);
*outptr++ = rvbPair[0];
*outptr++ = rvbPair[1];
}
else {
*outptr++ = 0.0;
*outptr++ = 0.0;
}
}
}
cursamp += bufsamps;
i += bufsamps;
bufsamps = getBufferSize(); // update
}
DBG1(printf("%s::run done\n\n", name()));
return i;
}
/* ------------------------------------------------------------------ run --- */
int MBASE::run()
{
const int totalSamps = insamps + tapcount;
int thisFrame = currentFrame();
const int outChans = outputChannels();
DBG1(printf("%s::run(): totalSamps = %d\n", name(), totalSamps));
// this will return chunksamps' worth of input, even if we have
// passed the end of the input (will produce zeros)
getInput(thisFrame, framesToRun());
DBG1(printf("getInput(%d, %d) called\n", thisFrame, framesToRun()));
int bufsamps = getBufferSize();
const int outputOffset = this->output_offset;
// loop for required number of output samples
const int frameCount = framesToRun();
memset(this->outbuf, 0, frameCount * outChans * sizeof(BUFTYPE));
int frame = 0;
while (frame < frameCount) {
// limit buffer size to end of current pull (chunksamps)
if (frameCount - frame < bufsamps)
bufsamps = max(0, frameCount - frame);
thisFrame = currentFrame(); // store this locally for efficiency
DBG1(printf("top of main loop: frame = %d thisFrame = %d bufsamps = %d\n",
frame, thisFrame, bufsamps));
DBG(printf("input signal:\n"));
DBG(PrintInput(&in[frame], bufsamps));
// add signal to delay
put_tap(thisFrame, &in[frame], bufsamps);
// if processing input signal or flushing delay lines ...
if (thisFrame < totalSamps) {
// limit buffer size of end of input data
if (totalSamps - thisFrame < bufsamps)
bufsamps = max(0, totalSamps - thisFrame);
if ((tapcount = updatePosition(thisFrame)) < 0)
RTExit(-1);
DBG1(printf(" vector loop: bufsamps = %d\n", bufsamps));
for (int ch = 0; ch < 2; ch++) {
for (int path = 0; path < m_paths; path++) {
Vector *vec = &m_vectors[ch][path];
/* get delayed samps */
get_tap(thisFrame, ch, path, bufsamps);
#if 0
DBG(printf("signal [%d][%d] before filters:\n", ch, path));
DBG(PrintSig(vec->Sig, bufsamps));
#endif
/* air absorpt. filters */
air(vec->Sig, bufsamps, vec->Airdata);
/* wall absorpt. filters */
if (path > 0) // no filtering of direct signal
wall(vec->Sig, bufsamps, vec->Walldata);
/* do binaural angle filters if necessary*/
if (m_binaural) {
fir(vec->Sig, thisFrame, g_Nterms[path],
vec->Fircoeffs, vec->Firtaps, bufsamps);
}
DBG(printf("signal [%d][%d] before rvb:\n", ch, path));
DBG(PrintSig(vec->Sig, bufsamps));
// DBG(PrintSig(vec->Sig, bufsamps, SIG_THRESH));
}
}
DBG(printf("summing vectors\n"));
Vector *vec;
register float *outptr = &this->outbuf[frame*outChans];
// sum unscaled reflected paths as global input for RVB.
for (int path = 0; path < m_paths; path++) {
vec = &m_vectors[0][path];
addScaleBufToOut(&outptr[2], vec->Sig, bufsamps, outChans, 1.0);
vec = &m_vectors[1][path];
addScaleBufToOut(&outptr[3], vec->Sig, bufsamps, outChans, 1.0);
}
if (!m_binaural) {
// now do cardioid mike effect
// add scaled reflected paths to output as early response
for (int path = 1; path < m_paths; path++) {
vec = &m_vectors[0][path];
addScaleBufToOut(&outptr[0], vec->Sig, bufsamps, outChans, vec->MikeAmp);
vec = &m_vectors[1][path];
addScaleBufToOut(&outptr[1], vec->Sig, bufsamps, outChans, vec->MikeAmp);
#if 0
DBG(printf("early response L and R:\n"));
DBG(PrintOutput(&outptr[0], bufsamps, outChans, SIG_THRESH));
DBG(PrintOutput(&outptr[1], bufsamps, outChans, SIG_THRESH));
#endif
}
}
else {
// copy scaled, filtered reflected paths (reverb input) as the early reponse
// to the output
for (int ch = 0; ch < 2; ++ch) {
float *dest = &outptr[ch];
float *src = &outptr[ch+2];
for (int n=0; n<bufsamps; ++n) {
*dest = *src;
dest += outChans;
src += outChans;
}
}
}
/* add the direct signal into the output bus */
for (int n = 0; n < bufsamps; n++) {
outptr[0] += m_vectors[0][0].Sig[n];
outptr[1] += m_vectors[1][0].Sig[n];
outptr += outChans;
}
DBG(printf("FINAL MIX LEFT CHAN:\n"));
DBG(PrintOutput(&this->outbuf[frame*outChans], bufsamps, outChans));
}
increment(bufsamps);
frame += bufsamps;
bufsamps = getBufferSize(); // update
DBG1(printf("\tmain loop done. thisFrame now %d\n", currentFrame()));
}
DBG1(printf("%s::run done\n\n", name()));
return frame;
}
int getpixelrow(float *pixelv)
{
static float pixels[PixelLine + SyncFilterLen];
static int npv = 0;
static int synced = 0;
static double max = 0.0;
double corr, ecorr, lcorr;
int res;
if (npv > 0)
memmove(pixelv, pixels, npv * sizeof(float));
if (npv < SyncFilterLen + 2) {
res = getpixelv(&(pixelv[npv]), SyncFilterLen + 2 - npv);
npv += res;
if (npv < SyncFilterLen + 2)
return (0);
}
/* test sync */
ecorr = fir(pixelv, Sync, SyncFilterLen);
corr = fir(&(pixelv[1]), Sync, SyncFilterLen);
lcorr = fir(&(pixelv[2]), Sync, SyncFilterLen);
FreqLine = 1.0+((ecorr-lcorr) / corr / PixelLine / 4.0);
if (corr < 0.75 * max) {
synced = 0;
FreqLine = 1.0;
}
max = corr;
if (synced < 8) {
int shift, mshift;
if (npv < PixelLine + SyncFilterLen) {
res =
getpixelv(&(pixelv[npv]), PixelLine + SyncFilterLen - npv);
npv += res;
if (npv < PixelLine + SyncFilterLen)
return (0);
}
/* lookup sync start */
mshift = 0;
for (shift = 1; shift < PixelLine; shift++) {
double corr;
corr = fir(&(pixelv[shift + 1]), Sync, SyncFilterLen);
if (corr > max) {
mshift = shift;
max = corr;
}
}
if (mshift != 0) {
memmove(pixelv, &(pixelv[mshift]),
(npv - mshift) * sizeof(float));
npv -= mshift;
synced = 0;
FreqLine = 1.0;
} else
synced += 1;
}
if (npv < PixelLine) {
res = getpixelv(&(pixelv[npv]), PixelLine - npv);
npv += res;
if (npv < PixelLine)
return (0);
}
if (npv == PixelLine) {
npv = 0;
} else {
memmove(pixels, &(pixelv[PixelLine]),
(npv - PixelLine) * sizeof(float));
npv -= PixelLine;
}
return (1);
}
int main(int argc, char** argv, char** envp)
{
//int num_proc = get_proc_id();
unsigned myId;
start_metric();
register int a, iSymbol, iBuffer, iPosCode ;
const int bufferSize = SF/2*SAMPLING_FACTOR;
int Signal_I_symb[80] ;
int Signal_Q_symb[80] ;
register int bit ;
int Signal_I_filtered[bufferSize] ;
int Signal_Q_filtered[bufferSize] ;
int Signal [ 16 ] ;
for ( a = 0 ; a < 80 ; a++ )
{
Signal_I_symb[a] = 0 ;
Signal_Q_symb[a] = 0 ;
}
for ( a = 0 ; a < bufferSize ; a++ )
{
Signal_I_filtered[a] = 0 ;
Signal_Q_filtered[a] = 0 ;
}
for ( a = 0 ; a < 16 ; a++ )
{
Signal[a] = 0 ;
}
//if(num_proc==1)
//{
//For each symbol
for(iSymbol=0;iSymbol<NB_SYMBOL;iSymbol++)
{
//Get first symbol
for(iBuffer=0;iBuffer<bufferSize;iBuffer++)
{
// Shifting the old values at the beginning of the buffer
Signal_I_symb[iBuffer] = Signal_I_symb[iBuffer+16] ;
Signal_Q_symb[iBuffer] = Signal_Q_symb[iBuffer+16] ;
Signal_I_symb[iBuffer+16] = Signal_I_symb[iBuffer+32] ;
Signal_Q_symb[iBuffer+16] = Signal_Q_symb[iBuffer+32] ;
Signal_I_symb[iBuffer+32] = Signal_I_symb[iBuffer+48] ;
Signal_Q_symb[iBuffer+32] = Signal_Q_symb[iBuffer+48] ;
Signal_I_symb[iBuffer+48] = Signal_I_symb[iBuffer+64] ;
Signal_Q_symb[iBuffer+48] = Signal_Q_symb[iBuffer+64] ;
// Put the new values at the end of the buffer
Signal_I_symb[iBuffer+64] = Signal_I[iBuffer+iSymbol*SF/2*SAMPLING_FACTOR];
Signal_Q_symb[iBuffer+64] = Signal_Q[iBuffer+iSymbol*SF/2*SAMPLING_FACTOR];
}
//-------------------------------------- FIRST STAGE -----------------------------------------------
//FIR for I and Q
pr("Time before FIR = ", 0x10, PR_STRING | PR_TSTAMP | PR_NEWL);
#pragma omp parallel
{
fir ( FIR_COEFF, FILTER_NB_CELL, Signal_I_symb, Signal_Q_symb, bufferSize, Signal_I_filtered, Signal_Q_filtered ) ;
}
//fir ( FIR_COEFF, FILTER_NB_CELL, Signal_Q_symb, bufferSize, Signal_Q_filtered ) ;
// pr("Time after FIR = ", 0x10, PR_STRING | PR_TSTAMP | PR_NEWL);
//
// //------------------------------------- SECOND STAGE -----------------------------------------------
// //---- QPSK-1 (parallel to serial)
// pr("Time before QPSK = ", 0x10, PR_STRING | PR_TSTAMP | PR_NEWL);
// for ( iBuffer = 0 ; iBuffer < bufferSize/2 ; iBuffer+=2 )
// {
// Signal[iBuffer] = Signal[iBuffer+bufferSize/2] ;
// /*Signal[iBuffer+bufferSize/2] = Signal_I_filtered[iBuffer*4] ;
//
// Signal[iBuffer+1] = Signal[iBuffer+1+bufferSize/2] ;
// Signal[iBuffer+1+bufferSize/2] = Signal_Q_filtered[iBuffer*4] ; */
//
// }
// QPSKinv ( Signal_I_filtered, Signal_Q_filtered, bufferSize/2, &Signal[8] ) ;
// pr("Time after QPSK = ", 0x10, PR_STRING | PR_TSTAMP | PR_NEWL);
//
// //-------------------------------------- THIRD STAGE -----------------------------------------------
// if ( iSymbol != 0 )
// {
// //---- Rake receiver
// pr("Time before RakeReceiver = ", 0x10, PR_STRING | PR_TSTAMP | PR_NEWL) ;
//
// bit = 0 ;
//
// for ( iPosCode = 0 ; iPosCode < SF ; iPosCode++ )
// {
// bit += Signal[iPosCode]*ovsf_code_user1[iPosCode] + Signal[iPosCode+1]*ovsf_code_user1[iPosCode] + Signal[iPosCode+2]*ovsf_code_user1[iPosCode] + Signal[iPosCode+3]*ovsf_code_user1[iPosCode] + Signal[iPosCode+4]*ovsf_code_user1[iPosCode] + Signal[iPosCode+5]*ovsf_code_user1[iPosCode] ;
// }
// pr("Time after RakeReceiver = ", 0x10, PR_STRING | PR_TSTAMP | PR_NEWL);
// _printdecn("Bit ", (int) ( (bit > 0) ? 1 : 0) ) ;
// pr("", 0x10, PR_NEWL);
// }
}
/*}
else
{
_printstrn("Only 1 processor is supported!");
}*/
stop_metric();
//Stop metrics
_printstrn("Done");
//Check results
//End
return(0);
}
void Hrtf::hrtf(const unsigned channel_idx, s16 *dst, const s16 *src, int src_ch, int src_n, int idt_offset, const kemar_ptr& kemar_data, int kemar_idx, float freq_decay) {
assert(channel_idx < 2);
//LOG_DEBUG(("channel %d: window %d: adding %d, buffer size: %u, decay: %g", channel_idx, window, WINDOW_SIZE, (unsigned)result.get_size(), freq_decay));
if (channel_idx <= 1) {
bool left = channel_idx == 0;
if (!left && idt_offset > 0) {
idt_offset = 0;
} else if (left && idt_offset < 0) {
idt_offset = 0;
}
if (idt_offset < 0)
idt_offset = - idt_offset;
} else
idt_offset = 0;
assert(std::min(0, idt_offset) >= 0);
assert(std::max(0, idt_offset) + WINDOW_SIZE <= src_n);
for(int i = 0; i < WINDOW_SIZE; ++i) {
//-1 0 1 2 3
int p = idt_offset + i;
assert(p >= 0 && p < src_n);
//printf("%d of %d, ", p, src_n);
int v = src[p * src_ch];
_mdct.data[i] = v / 32768.0f;
//fprintf(stderr, "%g ", _mdct.data[i]);
}
_mdct.apply_window();
_mdct.mdct();
{
for(size_t i = 0; i < mdct_type::M; ++i)
{
const int kemar_sample = i * 257 / mdct_type::M;
std::complex<float> fir(kemar_data[kemar_idx][0][kemar_sample][0], kemar_data[kemar_idx][0][kemar_sample][1]);
//_mdct.data[i] *= std::abs(fir); TODO: fix HRTF
}
}
//LOG_DEBUG(("kemar angle index: %d\n", kemar_idx));
assert(freq_decay >= 1);
_mdct.imdct();
_mdct.apply_window();
{
//stupid msvc
int i;
for(i = 0; i < WINDOW_SIZE / 2; ++i) {
float v = _mdct.data[i] + overlap_data[channel_idx][i];
if (v < -1) {
LOG_DEBUG(("clipping %f", v));
v = -1;
} else if (v > 1) {
LOG_DEBUG(("clipping %f", v));
v = 1;
}
*dst++ = (int)(v * 32767);
}
for(; i < WINDOW_SIZE; ++i) {
overlap_data[channel_idx][i - WINDOW_SIZE / 2] = _mdct.data[i];
}
}
}
