LoadToQuantize.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2024 by Andrew Jameson and Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/General/dsp/LoadToQuantize.h
 
#ifndef __dsp_LoadToQuantize_h
#define __dsp_LoadToQuantize_h
 
#include "dsp/BitSeries.h"
#include "dsp/ChanPolSelect.h"
#include "dsp/GenericVoltageDigitizer.h"
#include "dsp/Rescale.h"
#include "dsp/SingleThread.h"
#include "dsp/Sink.h"
 
namespace dsp {
 
 
  class LoadToQuantize : public SingleThread
  {
 
  public:
 
    class Config;
 
    void set_configuration(Config*);
 
    LoadToQuantize(Sink<BitSeries>* sink, Config* config = 0);
 
    void construct() override;
 
    void prepare() override;
 
    void finish() override;
 
  private:
 
    friend class LoadToQuantizeN;
 
    Reference::To<Config> config;
 
    Reference::To<ChanPolSelect> chanpolselect;
 
    Reference::To<Rescale> rescale;
 
    Reference::To<GenericVoltageDigitizer> digitzer;
 
    Reference::To<BitSeries> quantized;
 
    Sink<BitSeries>* output;
 
    unsigned output_npol = 0;
 
    unsigned output_nchan = 0;
 
    unsigned output_nbit = 0;
 
  };
 
  class LoadToQuantize::Config : public SingleThread::Config
  {
  public:
 
    // Sets default values
    Config() = default;
 
    Config(const std::string& _channel_range, const std::string& _pol_range, unsigned _output_nbit)
    {
      channel_range = _channel_range;
      pol_range = _pol_range;
      output_nbit = _output_nbit;
    }
 
    void add_options(CommandLine::Menu&) override;
 
    std::pair<uint32_t, uint32_t> parse_range(const std::string &range, uint32_t max_range);
 
    unsigned output_nbit = 8;
 
    std::string channel_range;
 
    std::string pol_range;
 
  };
 
} // namespace dsp
 
#endif // !defined(__dsp_LoadToQuantize_h)