InverseFilterbank.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2019 by Andrew Jameson, Dean Shaff, and Willem van Straten,
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/General/dsp/InverseFilterbank.h
 
#ifndef __InverseFilterbank_h
#define __InverseFilterbank_h
 
#include <string>
 
#include "dsp/Convolution.h"
 
namespace dsp {
 
 
  class InverseFilterbank: public Convolution {
 
  public:
 
    class Config;
 
    InverseFilterbank (const char* name = "InverseFilterbank",
                       Behaviour type = outofplace);
 
    void set_input (const TimeSeries* input);
 
    void prepare ();
 
    void reserve ();
 
    uint64_t get_minimum_samples () { return nsamp_fft; }
 
    uint64_t get_minimum_samples_lost () { return nsamp_overlap; }
 
    void set_input_nchan (unsigned _input_nchan) { input_nchan = _input_nchan; }
 
    unsigned get_input_nchan () const { return input_nchan; }
 
    void set_output_nchan (unsigned _output_nchan) { output_nchan = _output_nchan; }
 
    unsigned get_output_nchan () const { return output_nchan; }
 
    unsigned get_nchan_subband () const {return nchan_subband; }
 
    void set_freq_res (unsigned _freq_res) { freq_res = _freq_res; }
 
    void set_frequency_resolution (unsigned _freq_res) { freq_res = _freq_res; }
 
    unsigned get_freq_res () const { return freq_res; }
 
    unsigned get_frequency_resolution () const { return freq_res; }
 
    void set_frequency_overlap (unsigned over) { overlap_ratio = over; }
 
    unsigned get_frequency_overlap () const { return (unsigned) overlap_ratio; }
 
    void set_oversampling_factor (const Rational& _osf) { oversampling_factor = _osf; }
 
    const Rational& get_oversampling_factor () { return oversampling_factor; }
 
    bool get_pfb_all_chan () const { return pfb_all_chan; }
 
    void set_pfb_all_chan (bool);
 
    int get_input_discard_neg() const {return input_discard_neg;}
 
    void set_input_discard_neg(int _input_discard_neg) { input_discard_neg = _input_discard_neg;}
 
    int get_input_discard_pos() const {return input_discard_pos;}
 
    void set_input_discard_pos(int _input_discard_pos) { input_discard_pos = _input_discard_pos;}
 
    int get_output_discard_neg() const {return output_discard_neg;}
 
    void set_output_discard_neg(int _output_discard_neg) { output_discard_neg = _output_discard_neg;}
 
    int get_output_discard_pos() const {return output_discard_pos;}
 
    void set_output_discard_pos(int _output_discard_pos) { output_discard_pos = _output_discard_pos;}
 
    int get_input_fft_length() const {return input_fft_length;}
 
    void set_input_fft_length(int _input_fft_length) { input_fft_length = _input_fft_length;}
 
    int get_output_fft_length() const {return output_fft_length;}
 
    void set_output_fft_length(int _output_fft_length) { output_fft_length = _output_fft_length;}
 
 
    class Engine;
    void set_engine (Engine*);
 
  protected:
 
    virtual void transformation ();
 
    virtual void filterbank ();
 
    virtual void custom_prepare () {}
 
    unsigned input_nchan;
 
    unsigned output_nchan;
 
    unsigned freq_res;
 
    unsigned nchan_subband;
 
    double overlap_ratio;
 
    Rational oversampling_factor;
 
    bool pfb_all_chan;
 
    Reference::To<Engine> engine;
 
  private:
 
    // div_t calc_lcf (int a, int b, Rational osf);
 
    void make_preparations ();
 
    void prepare_output (uint64_t ndat = 0, bool set_ndat = false);
 
    void resize_output (bool reserve_extra = false);
 
    int input_fft_length;
 
    int output_fft_length;
 
    int input_discard_total;
 
    int input_sample_step;
 
    int output_discard_total;
 
    int output_sample_step;
 
    int input_discard_pos;
    int input_discard_neg;
 
    int output_discard_pos;
    int output_discard_neg;
 
 
  };
 
}
 
#endif