lib/smencoder.hh

/* 
 * Copyright (C) 2010 Stefan Westerfeld
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 3 of the License, or (at your
 * option) any later version.
 *
 * This library 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 Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef SPECTMORPH_ENCODER_HH
#define SPECTMORPH_ENCODER_HH

#include <sys/types.h>
#include <vector>
#include <string>
#include <bse/gsldatautils.h>

#include "smaudio.hh"

namespace SpectMorph
{

struct EncoderParams
{
  float   mix_freq;         

  float   frame_step_ms;

  float   frame_size_ms;

  int     zeropad;

  size_t  frame_step;

  size_t  frame_size;

  size_t  block_size;

  double  fundamental_freq;
};

struct Tracksel {
  size_t   frame;
  size_t   d;         /* FFT position */
  double   freq;
  double   mag;
  double   mag2;      /* magnitude in dB */
  double   phase;     /* phase */
  bool     is_harmonic;
  Tracksel *prev, *next;
};

class Encoder
{
  EncoderParams                        enc_params;
  int                                  loop_start;
  int                                  loop_end;

  bool check_harmonic (double freq, double& new_freq, double mix_freq);

  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 std::vector<float>& window, const Attack& attack, std::vector<double>& out_scale);

public:
  std::vector<AudioBlock>              audio_blocks;    
  Attack                               optimal_attack;
  size_t                               zero_values_at_start;
  size_t                               sample_count;
  std::vector<float>                   original_samples;

  Encoder (const EncoderParams& enc_params);

  // single encoder steps:
  void compute_stft (GslDataHandle *dhandle, int channel, const std::vector<float>& window);
  void search_local_maxima();
  void link_partials();
  void validate_partials();
  void optimize_partials (const std::vector<float>& window, int optimization_level);
  void spectral_subtract (const std::vector<float>& window);
  void approx_noise (const std::vector<float>& window);
  void compute_attack_params (const std::vector<float>& window);
  void compute_lpc_lsf();
  void sort_freqs();

  // all-in-one encoding function:
  void encode (GslDataHandle *dhandle, int channel, const std::vector<float>& window, int optimization_level,
               bool attack, bool track_sines);

  void set_time_loop (int loop_start, int loop_end);
  void save (const std::string& filename, double fundamental_freq);
};

}

#endif