smaudio.hh

// Licensed GNU LGPL v3 or later: http://www.gnu.org/licenses/lgpl.html
 
#ifndef SPECTMORPH_AUDIO_HH
#define SPECTMORPH_AUDIO_HH
 
#include <vector>
 
#include "smgenericin.hh"
#include "smgenericout.hh"
#include "smmath.hh"
#include "smutils.hh"
 
#define SPECTMORPH_BINARY_FILE_VERSION   14
#define SPECTMORPH_SUPPORT_MULTI_CHANNEL 0
 
namespace SpectMorph
{
 
class AudioBlock
{
public:
  std::vector<uint16_t> noise;       
  std::vector<uint16_t> freqs;       
  std::vector<uint16_t> mags;        
  std::vector<uint16_t> phases;      
  std::vector<float> original_fft;   
  std::vector<float> debug_samples;  
 
  void    sort_freqs();
  double  estimate_fundamental (int n_partials = 1, double *mag = nullptr) const;
 
  double
  freqs_f (size_t i) const
  {
    return sm_ifreq2freq (freqs[i]);
  }
 
  double
  mags_f (size_t i) const
  {
    return sm_idb2factor (mags[i]);
  }
 
  double
  phases_f (size_t i) const
  {
    const double factor = 2.0 * M_PI / 65536.0;
    return phases[i] * factor;
  }
 
  double
  noise_f (size_t i) const
  {
    return sm_idb2factor (noise[i]);
  }
};
 
enum AudioLoadOptions
{
  AUDIO_LOAD_DEBUG,
  AUDIO_SKIP_DEBUG
};
 
class Audio
{
  SPECTMORPH_CLASS_NON_COPYABLE (Audio);
public:
  Audio();
  ~Audio();
 
  enum LoopType {
    LOOP_NONE = 0,
    LOOP_FRAME_FORWARD,
    LOOP_FRAME_PING_PONG,
    LOOP_TIME_FORWARD,
    LOOP_TIME_PING_PONG,
  };
 
  float    fundamental_freq         = 0;          
  float    mix_freq                 = 0;          
  float    frame_size_ms            = 0;          
  float    frame_step_ms            = 0;          
  float    attack_start_ms          = 0;          
  float    attack_end_ms            = 0;          
  int      zeropad                  = 0;          
  LoopType loop_type                = LOOP_NONE;  
  int      loop_start               = 0;          
  int      loop_end                 = 0;          
  int      zero_values_at_start     = 0;          
  int      sample_count             = 0;          
  std::vector<float> original_samples;            
  float    original_samples_norm_db = 0;          
  std::vector<AudioBlock> contents;               
 
  Error load (const std::string& filename, AudioLoadOptions load_options = AUDIO_LOAD_DEBUG);
  Error load (SpectMorph::GenericIn *file, AudioLoadOptions load_options = AUDIO_LOAD_DEBUG);
  Error save (const std::string& filename) const;
  Error save (SpectMorph::GenericOut *file) const;
 
  Audio *clone() const; // create a deep copy
 
  static bool loop_type_to_string (LoopType loop_type, std::string& s);
  static bool string_to_loop_type (const std::string& s, LoopType& loop_type);
};
 
}
 
#endif