root/SigProc/trunk/SigProc/SigProc.h @ 3087

/****************************************************************************

Copyright 2005,2006 Virginia Polytechnic Institute and State University

This file is part of the OSSIE Decimator.

OSSIE Decimator 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.

OSSIE Decimator 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 OSSIE Decimator; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


****************************************************************************/

#ifndef SIG_PROC_H
#define SIG_PROC_H

#include <iostream>
#include <fstream>
#include <string>

#ifdef FPM
#include "fixed.h"
#endif

namespace SigProc {

//-----------------------------------------------------------------------------
//
// Design root raised-cosine filter
//
//-----------------------------------------------------------------------------
void DesignRRCFilter(
  unsigned int k,      // samples per symbol
  unsigned int m,      // delay
  float beta,          // rolloff factor ( 0 < beta <= 1 )
  float *& h,          // pointer to filter coefficients
  unsigned int & h_len // length of filter (len = 2*m*k+1)
);

//-----------------------------------------------------------------------------
//
// P/N Sequence
//
//-----------------------------------------------------------------------------

/// P/N Sequence
class PNSequence
{
  public:
    /// default constructor
    PNSequence();

    /// destructor
    ~PNSequence();

  private:
    // g: generator polynomial
    // a: initial polynomial state
};

//-----------------------------------------------------------------------------
//
// Automatic Gain Control class
//
//-----------------------------------------------------------------------------
/** \brief Automatic gain control signal processor
 *
 */
class AutomaticGainControl
{
  public:
    /// default constructor
    AutomaticGainControl();

    /// Destructor
    ~AutomaticGainControl();

    /// Set signal processing values
    void SetValues(
            float _elo,
            float _ehi,
            float _ka,
            float _kr,
            float _gmin,
            float _gmax);

    /// Get signal processing values
    void GetValues(
            float & _elo,
            float & _ehi,
            float & _ka,
            float & _kr,
            float & _gmin,
            float & _gmax);
    
    /// Get status
    void GetStatus(float & _gain, float & _energy);
    
    /// track signal energy and apply gain (real)
    void ApplyGain(short & I);

    /// track signal energy and apply gain (complex)
    void ApplyGain(short & I, short & Q);

  private:
    /// disallow copy constructor
    AutomaticGainControl(AutomaticGainControl &);

    /// compute necessary gain value from measured energy
    void ComputeGain();

    /// low energy threshold
    float energy_lo;

    /// high energy threshold
    float energy_hi;

    /// attack time constant
    float ka;

    /// release time constant
    float kr;

    /// minimum gain value
    float gmin;

    /// maximum gain value
    float gmax;

    /// actual tracking gain value
    float gain;

    /// actual tracking average energy value
    float energy;

    /// low-pass filter coefficient for estimating average energy
    float zeta;

    /// average energy threshold for smoother tracking
    float energy_av;

};

class phase_detect {

 public:
    phase_detect(float scale_factor);
 
    void do_work(short I_in, short Q_in, short I_nco, short Q_nco, short &out);

 private:
    phase_detect(const phase_detect &);

    float scale_factor;
};


class nco {
  public:
    nco();
    nco(unsigned int max_out);

    void do_work(short control_voltage, short &sine, short &cosine);

  private:
    nco(const nco &);

    int freq_index;
    int max_out;
};

class gain {
  public:
    gain();

    void do_work(float gain, short data_in, short &out);

  private:
    gain(const gain &);

};

class iir_filter {
  public:
    iir_filter(float a[], unsigned int len_a, float b[], unsigned int len_b);

    void do_work(short x, short &y);

  private:
    iir_filter(const iir_filter &);

    float *A;
    float *B;
    unsigned int len_A, len_B;

    float *v;
    unsigned int len_v;
    unsigned int next_v;
};


//-----------------------------------------------------------------------------
//
// FIR polyphase filter bank
//
//-----------------------------------------------------------------------------
/** \brief Finite impulse response (FIR) polyphase filter bank
 *
 * This class implementes a finite impulse response (FIR) polyphase filter
 * bank useful for decimators that need to interpolate samples in digital
 * receivers.
 *
 * Certain filter prototypes are supported, including
 *   - raised-cosine
 *   - root raised-cosine
 *   - gaussian
 *   - triangular
 *   - hamming
 *
 * The user can also load coefficients...
 *
 */
class FIRPolyphaseFilterBank {
  public:
    /// Initializing constructor
    FIRPolyphaseFilterBank(
            char * _type,       // type of filter
            unsigned int _k,    // samples per symbol
            unsigned int _m,    // delay
            float _beta,        // excess bandwidth factor
            unsigned int _Npfb  // number of filters
            );

    ///
    FIRPolyphaseFilterBank(
            unsigned int * _H,  // filter bank coefficients
            unsigned int _h_len,// 
            unsigned int _Npfb  // number of filters
            );

    /// destructor
    ~FIRPolyphaseFilterBank();

    /// push input value into buffer
    void PushInput(int _x);

    /// compute filter output from current buffer state using specific filter
    void ComputeOutput(
            short &y,           // output sample
            unsigned int _b     // filter bank index
            );

    /// reset filter buffer
    void ResetBuffer();

    /// prints filter bank coefficients to the screen
    void PrintFilterBankCoefficients();

  private:
    /// disallow copy constructor
    FIRPolyphaseFilterBank(const FIRPolyphaseFilterBank&);

    /// type of filter; can be one of the following
    ///   - 'rrcos'
    ///   - 'gaussian'
    char * type;

    /// samples per symbol
    unsigned int k;

    /// symbol delay
    unsigned int m;

    /// excess bandwidth factor
    float beta;

    /// number of filters in bank
    unsigned int Npfb;

    /// filter bank coefficients
    float *H;

    /// length of each filter
    unsigned int h_len;

    /// circular input buffer (header ptr)
    short *v;

    /// input buffer read ptr
    short *v_head_ptr;

    /// input buffer length
    unsigned int v_len;

    /// transpose filter bank coefficient matrix
    void TransposeCoefficientMatrix();

    // ----- calculate filter bank coefficients -----

    /// Calculate root raised-cosine coefficients
    void CalculateRRCFilterCoefficients();

    /// Calculate derivative root raised-cosine coefficients
    void CalculateDerivativeRRCFilterCoefficients();

    /// 
    void CalculateGaussianFilterCoefficients();

    ///
    void CalculateDerivativeGaussianFilterCoefficients();
};



class fir_filter {
  public:
    fir_filter(float a[], unsigned int len_a);

    void do_work(bool run_filter, short in_sample, short &out_sample);
    void reset();

  private:
    fir_filter(const fir_filter &);

#ifdef FPM
    mad_fixed_t *A;
    mad_fixed_t *v;
#else
    float *A;
    short *v;
#endif
    unsigned int len_A;

    unsigned int len_v;
    unsigned int next_v;
};

class dump_data {
 public:
  dump_data(const char *filename, long start_sample, long number_of_samples);
  ~dump_data();

  void write_data(float data, const char *msg = "");
  void write_data(float a, float b, const char *msg = "");

 private:
  dump_data();
  dump_data(const dump_data &);

  std::ofstream *out_file;

  long start_sample, stop_sample;
  long current_sample;

};

class dc_block {
  public:
    dc_block(const float forget_factor);
    ~dc_block();

    void do_work(short in, short &out);

  private:
    dc_block();
    dc_block(const dc_block &);

    float forget_factor;
    int prev_input, prev_output;

};
}

#endif