git.sesse.net Git - nageru/blob - audio_mixer.h

   1 #ifndef _AUDIO_MIXER_H
   2 #define _AUDIO_MIXER_H 1
   3
   4 // The audio mixer, dealing with extracting the right signals from
   5 // each capture card, resampling signals so that they are in sync,
   6 // processing them with effects (if desired), and then mixing them
   7 // all together into one final audio signal.
   8 //
   9 // All operations on AudioMixer (except destruction) are thread-safe.
  10 //
  11 // TODO: There might be more audio stuff that should be moved here
  12 // from Mixer.
  13
  14 #include <math.h>
  15 #include <stdint.h>
  16 #include <atomic>
  17 #include <memory>
  18 #include <mutex>
  19 #include <vector>
  20
  21 #include "bmusb/bmusb.h"
  22 #include "db.h"
  23 #include "defs.h"
  24 #include "filter.h"
  25 #include "resampling_queue.h"
  26 #include "stereocompressor.h"
  27
  28 namespace bmusb {
  29 struct AudioFormat;
  30 }  // namespace bmusb
  31
  32 class AudioMixer {
  33 public:
  34         AudioMixer(unsigned num_cards);
  35         void reset_card(unsigned card_index);
  36
  37         // frame_length is in TIMEBASE units.
  38         void add_audio(unsigned card_index, const uint8_t *data, unsigned num_samples, bmusb::AudioFormat audio_format, int64_t frame_length);
  39         void add_silence(unsigned card_index, unsigned samples_per_frame, unsigned num_frames, int64_t frame_length);
  40         std::vector<float> get_output(double pts, unsigned num_samples, ResamplingQueue::RateAdjustmentPolicy rate_adjustment_policy);
  41
  42         // See comments inside get_output().
  43         void set_current_loudness(double level_lufs) { loudness_lufs = level_lufs; }
  44
  45         void set_locut_cutoff(float cutoff_hz)
  46         {
  47                 locut_cutoff_hz = cutoff_hz;
  48         }
  49
  50         void set_locut_enabled(bool enabled)
  51         {
  52                 locut_enabled = enabled;
  53         }
  54
  55         bool get_locut_enabled() const
  56         {
  57                 return locut_enabled;
  58         }
  59
  60         float get_limiter_threshold_dbfs() const
  61         {
  62                 return limiter_threshold_dbfs;
  63         }
  64
  65         float get_compressor_threshold_dbfs() const
  66         {
  67                 return compressor_threshold_dbfs;
  68         }
  69
  70         void set_limiter_threshold_dbfs(float threshold_dbfs)
  71         {
  72                 limiter_threshold_dbfs = threshold_dbfs;
  73         }
  74
  75         void set_compressor_threshold_dbfs(float threshold_dbfs)
  76         {
  77                 compressor_threshold_dbfs = threshold_dbfs;
  78         }
  79
  80         void set_limiter_enabled(bool enabled)
  81         {
  82                 limiter_enabled = enabled;
  83         }
  84
  85         bool get_limiter_enabled() const
  86         {
  87                 return limiter_enabled;
  88         }
  89
  90         void set_compressor_enabled(bool enabled)
  91         {
  92                 compressor_enabled = enabled;
  93         }
  94
  95         bool get_compressor_enabled() const
  96         {
  97                 return compressor_enabled;
  98         }
  99
 100         void set_gain_staging_db(float gain_db)
 101         {
 102                 std::unique_lock<std::mutex> lock(compressor_mutex);
 103                 level_compressor_enabled = false;
 104                 gain_staging_db = gain_db;
 105         }
 106
 107         float get_gain_staging_db() const
 108         {
 109                 std::unique_lock<std::mutex> lock(compressor_mutex);
 110                 return gain_staging_db;
 111         }
 112
 113         void set_gain_staging_auto(bool enabled)
 114         {
 115                 std::unique_lock<std::mutex> lock(compressor_mutex);
 116                 level_compressor_enabled = enabled;
 117         }
 118
 119         bool get_gain_staging_auto() const
 120         {
 121                 std::unique_lock<std::mutex> lock(compressor_mutex);
 122                 return level_compressor_enabled;
 123         }
 124
 125         void set_final_makeup_gain_db(float gain_db)
 126         {
 127                 std::unique_lock<std::mutex> lock(compressor_mutex);
 128                 final_makeup_gain_auto = false;
 129                 final_makeup_gain = from_db(gain_db);
 130         }
 131
 132         float get_final_makeup_gain_db()
 133         {
 134                 std::unique_lock<std::mutex> lock(compressor_mutex);
 135                 return to_db(final_makeup_gain);
 136         }
 137
 138         void set_final_makeup_gain_auto(bool enabled)
 139         {
 140                 std::unique_lock<std::mutex> lock(compressor_mutex);
 141                 final_makeup_gain_auto = enabled;
 142         }
 143
 144         bool get_final_makeup_gain_auto() const
 145         {
 146                 std::unique_lock<std::mutex> lock(compressor_mutex);
 147                 return final_makeup_gain_auto;
 148         }
 149
 150 private:
 151         unsigned num_cards;
 152
 153         struct CaptureCard {
 154                 std::mutex audio_mutex;
 155                 std::unique_ptr<ResamplingQueue> resampling_queue;  // Under audio_mutex.
 156                 int64_t next_local_pts = 0;  // Beginning of next frame, in TIMEBASE units. Under audio_mutex.
 157         };
 158         CaptureCard cards[MAX_CARDS];
 159
 160         StereoFilter locut;  // Default cutoff 120 Hz, 24 dB/oct.
 161         std::atomic<float> locut_cutoff_hz;
 162         std::atomic<bool> locut_enabled{true};
 163
 164         // First compressor; takes us up to about -12 dBFS.
 165         mutable std::mutex compressor_mutex;
 166         StereoCompressor level_compressor;  // Under compressor_mutex. Used to set/override gain_staging_db if <level_compressor_enabled>.
 167         float gain_staging_db = 0.0f;  // Under compressor_mutex.
 168         bool level_compressor_enabled = true;  // Under compressor_mutex.
 169
 170         static constexpr float ref_level_dbfs = -14.0f;  // Chosen so that we end up around 0 LU in practice.
 171         static constexpr float ref_level_lufs = -23.0f;  // 0 LU, more or less by definition.
 172
 173         std::atomic<float> loudness_lufs{ref_level_lufs};
 174
 175         StereoCompressor limiter;
 176         std::atomic<float> limiter_threshold_dbfs{ref_level_dbfs + 4.0f};   // 4 dB.
 177         std::atomic<bool> limiter_enabled{true};
 178         StereoCompressor compressor;
 179         std::atomic<float> compressor_threshold_dbfs{ref_level_dbfs - 12.0f};  // -12 dB.
 180         std::atomic<bool> compressor_enabled{true};
 181
 182         double final_makeup_gain = 1.0;  // Under compressor_mutex. Read/write by the user. Note: Not in dB, we want the numeric precision so that we can change it slowly.
 183         bool final_makeup_gain_auto = true;  // Under compressor_mutex.
 184 };
 185
 186 #endif  // !defined(_AUDIO_MIXER_H)