smencoder.hh

// Licensed GNU LGPL v3 or later: http://www.gnu.org/licenses/lgpl.html

#ifndef SPECTMORPH_ENCODER_HH
#define SPECTMORPH_ENCODER_HH

#include <sys/types.h>
#include <vector>
#include <string>
#include <map>

#include "smaudio.hh"
#include "smwavdata.hh"

namespace SpectMorph
{

class EncoderParams
{
  /* config file parameters */
  std::vector<std::string>            param_name_d;   // names of all supported double parameters
  std::map<std::string, double>       param_value_d;  // values of double parameters from config file
  std::vector<std::string>            param_name_s;   // names of all supported string parameters
  std::map<std::string, std::string>  param_value_s;  // values of string parameters from config file

public:
  float   mix_freq = 0;

  float   frame_step_ms = 0;

  float   frame_size_ms = 0;

  int     zeropad = 0;

  size_t  frame_step = 0;

  size_t  frame_size = 0;

  size_t  block_size = 0;

  double  fundamental_freq = 0;

  bool    enable_phases = true;

  std::vector<float> window;

  std::function<bool()> kill_function;

  bool add_config_entry (const std::string& param, const std::string& value);

  bool load_config (const std::string& filename);
  bool get_param (const std::string& param, double& value) const;
  bool get_param (const std::string& param, std::string& value) const;

  EncoderParams();

  void setup_params (const WavData& wav_data, double fundamental_freq);

  void set_kill_function (const std::function<bool()>& kill_function);
};

struct Tracksel {
  size_t   frame;
  size_t   d;         /* FFT position */
  double   freq;
  double   mag;
  double   mag2;      /* magnitude in dB */
  double   phase;     /* phase */

  Tracksel *prev, *next;
};

class EncoderBlock
{
public:
  std::vector<float> noise;          
  std::vector<float> freqs;          
  std::vector<float> mags;           
  std::vector<float> phases;         
  std::vector<float> original_fft;   
  std::vector<float> debug_samples;  
};

class Encoder
{
  EncoderParams                        enc_params;
  int                                  loop_start;
  int                                  loop_end;
  Audio::LoopType                      loop_type;

  std::vector< std::vector<Tracksel> > frame_tracksels; 

  struct Attack
  {
    double attack_start_ms;
    double attack_end_ms;
  };
  double attack_error (const std::vector< std::vector<double> >& unscaled_signal, const Attack& attack, std::vector<double>& out_scale);

  // single encoder steps:
  void compute_stft (const WavData& wav_data, int channel);
  void search_local_maxima();
  void link_partials();
  void validate_partials();
  void optimize_partials (int optimization_level);
  void spectral_subtract();
  void approx_noise();
  void compute_attack_params();
  void sort_freqs();

  inline bool
  killed (const char *where, uint64_t z = 0)
  {
    if (z != 0)  // inlined fast check
      return false;

    // debugging: printf ("%-10s ", where);

    return enc_params.kill_function && enc_params.kill_function();
  }

  Attack                               optimal_attack;
  size_t                               zero_values_at_start;
  size_t                               sample_count;

public:
  std::vector<EncoderBlock>            audio_blocks;    
  std::vector<float>                   original_samples;

  Encoder (const EncoderParams& enc_params);

  void debug_decode (const std::string& filename);

  // all-in-one encoding function:
  bool encode (const WavData& wav_data, int channel, int optimization_level,
               bool attack, bool track_sines);

  void set_loop (Audio::LoopType loop_type, int loop_start, int loop_end);
  void set_loop_seconds (Audio::LoopType loop_type, double loop_start, double loop_end);

  Error  save (const std::string& filename);
  Audio *save_as_audio();
};

}

#endif