/*  icfir.c

This file is part of a program that implements a Software-Defined Radio.

Copyright (C) 2018 Warren Pratt, NR0V

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@pratt.one

*/
#define _CRT_SECURE_NO_DEPRECATE
#include "comm.h"

void calc_icfir (ICFIR a)
{
    double* impulse;
    a->scale = 1.0 / (double)(2 * a->size);
    impulse = icfir_impulse (a->nc, a->DD, a->R, a->Pairs, a->runrate, a->cicrate, a->cutoff, a->xtype, a->xbw, 1, a->scale, a->wintype);
    a->p = create_fircore (a->size, a->in, a->out, a->nc, a->mp, impulse);
    _aligned_free (impulse);
}

void decalc_icfir (ICFIR a)
{
    destroy_fircore (a->p);
}

ICFIR create_icfir (int run, int size, int nc, int mp, double* in, double* out, int runrate, int cicrate,
    int DD, int R, int Pairs, double cutoff, int xtype, double xbw, int wintype)
//  run:  0 - no action; 1 - operate
//  size:  number of complex samples in an input buffer to the CFIR filter
//  nc:  number of filter coefficients
//  mp:  minimum phase flag
//  in:  pointer to the input buffer
//  out:  pointer to the output buffer
//  rate:  samplerate
//  DD:  differential delay of the CIC to be compensated (usually 1 or 2)
//  R:  interpolation factor of CIC
//  Pairs:  number of comb-integrator pairs in the CIC
//  cutoff:  cutoff frequency
//  xtype:  0 - fourth power transition; 1 - raised cosine transition
//  xbw:  width of raised cosine transition
{
    ICFIR a = (ICFIR) malloc0 (sizeof (icfir));
    a->run = run;
    a->size = size;
    a->nc = nc;
    a->mp = mp;
    a->in = in;
    a->out = out;
    a->runrate = runrate;
    a->cicrate = cicrate;
    a->DD = DD;
    a->R = R;
    a->Pairs = Pairs;
    a->cutoff = cutoff;
    a->xtype = xtype;
    a->xbw = xbw;
    a->wintype = wintype;
    calc_icfir (a);
    return a;
}

void destroy_icfir (ICFIR a)
{
    decalc_icfir (a);
    _aligned_free (a);
}

void flush_icfir (ICFIR a)
{
    flush_fircore (a->p);
}

void xicfir (ICFIR a)
{
    if (a->run)
        xfircore (a->p);
    else if (a->in != a->out)
        memcpy (a->out, a->in, a->size * sizeof (complex));
}

void setBuffers_icfir (ICFIR a, double* in, double* out)
{
    decalc_icfir (a);
    a->in = in;
    a->out = out;
    calc_icfir (a);
}

void setSamplerate_icfir (ICFIR a, int rate)
{
    decalc_icfir (a);
    a->runrate = rate;
    calc_icfir (a);
}

void setSize_icfir (ICFIR a, int size)
{
    decalc_icfir (a);
    a->size = size;
    calc_icfir (a);
}

void setOutRate_icfir (ICFIR a, int rate)
{
    decalc_icfir (a);
    a->cicrate = rate;
    calc_icfir (a);
}

double* icfir_impulse (int N, int DD, int R, int Pairs, double runrate, double cicrate, double cutoff, int xtype, double xbw, int rtype, double scale, int wintype)
{
    // N:       number of impulse response samples
    // DD:      differential delay used in the CIC filter
    // R:       interpolation / decimation factor of the CIC
    // Pairs:   number of comb-integrator pairs in the CIC
    // runrate: sample rate at which this filter is to run (assumes there may be flat interp. between this filter and the CIC)
    // cicrate: sample rate at interface to CIC
    // cutoff:  cutoff frequency
    // xtype:   transition type, 0 for 4th-power rolloff, 1 for raised cosine
    // xbw:     transition bandwidth for raised cosine
    // rtype:   0 for real output, 1 for complex output
    // scale:   scale factor to be applied to the output
    int i, j;
    double tmp, local_scale, ri, mag, fn;
    double* impulse;
    double* A = (double *) malloc0 (N * sizeof (double));
    double ft = cutoff / cicrate;                                       // normalized cutoff frequency
    int u_samps = (N + 1) / 2;                                          // number of unique samples,  OK for odd or even N
    int c_samps = (int)(cutoff / runrate * N) + (N + 1) / 2 - N / 2;    // number of unique samples within bandpass, OK for odd or even N
    int x_samps = (int)(xbw / runrate * N);                             // number of unique samples in transition region, OK for odd or even N
    double offset = 0.5 - 0.5 * (double)((N + 1) / 2 - N / 2);          // sample offset from center, OK for odd or even N
    double* xistion = (double *) malloc0 ((x_samps + 1) * sizeof (double));
    double delta = PI / (double)x_samps;
    double L = cicrate / runrate;
    double phs = 0.0;
    for (i = 0; i <= x_samps; i++)
    {
        xistion[i] = 0.5 * (cos (phs) + 1.0);
        phs += delta;
    }
    if ((tmp = DD * R * sin (PI * ft / R) / sin (PI * DD * ft)) < 0.0)  //normalize by peak gain
        tmp = -tmp;
    local_scale = scale / pow (tmp, Pairs);
    if (xtype == 0)
    {
        for (i = 0, ri = offset; i < u_samps; i++, ri += 1.0)
        {
            fn = ri / (L * (double)N);
            if (fn <= ft)
            {
                if (fn == 0.0) tmp = 1.0;
                else if ((tmp = sin (PI * DD * fn) / (DD * R * sin (PI * fn / R))) < 0.0)
                    tmp = -tmp;
                mag = pow (tmp, Pairs) * local_scale;
            }
            else
                mag *= (ft * ft * ft * ft) / (fn * fn * fn * fn);
            A[i] = mag;
        }
    }
    else if (xtype == 1)
    {
        for (i = 0, ri = offset; i < u_samps; i++, ri += 1.0)
        {
            fn = ri / (L *(double)N);
            if (i < c_samps)
            {
                if (fn == 0.0) tmp = 1.0;
                else if ((tmp = sin (PI * DD * fn) / (DD * R * sin (PI * fn / R))) < 0.0)
                    tmp = -tmp;
                mag = pow (tmp, Pairs) * local_scale;
                A[i] = mag;
            }
            else if ( i >= c_samps && i <= c_samps + x_samps)
                A[i] = mag * xistion[i - c_samps];
            else
                A[i] = 0.0;
        }
    }
    if (N & 1)
        for (i = u_samps, j = 2; i < N; i++, j++)
            A[i] = A[u_samps - j];
    else
        for (i = u_samps, j = 1; i < N; i++, j++)
            A[i] = A[u_samps - j];
    impulse = fir_fsamp (N, A, rtype, 1.0, wintype);
    // print_impulse ("icfirImpulse.txt", N, impulse, 1, 0);
    _aligned_free (A);
    return impulse;
}

/********************************************************************************************************
*                                                                                                       *
*                                           TXA Properties                                              *
*                                                                                                       *
********************************************************************************************************/

//PORT void
//SetTXAICFIRRun (int channel, int run)
//{
//  EnterCriticalSection(&ch[channel].csDSP);
//  txa[channel].icfir.p->run = run;
//  LeaveCriticalSection(&ch[channel].csDSP);
//}
