Begin working on a delay analyzer.

[nageru] / nageru / audio_mixer.h

diff --git a/nageru/audio_mixer.h b/nageru/audio_mixer.h
index e435b46280c0d28e549c2fb36ae3df40f810f640..0beaf103ab08dcfcd03ecef99eaed32ff83292df 100644 (file)
--- a/nageru/audio_mixer.h
+++ b/nageru/audio_mixer.h
@@ -6,7 +6,8 @@
 // processing them with effects (if desired), and then mixing them
 // all together into one final audio signal.
 //
-// All operations on AudioMixer (except destruction) are thread-safe.
+// All operations on AudioMixer, except destruction and set_delay_analyzer(),
+// are thread-safe.
 
 #include <assert.h>
 #include <stdint.h>
@@ -31,12 +32,22 @@
 #include "resampling_queue.h"
 #include "stereocompressor.h"
 
+class DelayAnalyzerInterface;
 class DeviceSpecProto;
 
 namespace bmusb {
 struct AudioFormat;
 }  // namespace bmusb
 
+// Convert the given audio from {16,24,32}-bit M-channel to 32-bit N-channel PCM.
+// Assumes little-endian and chunky, signed PCM throughout.
+std::vector<int32_t> convert_audio_to_fixed32(const uint8_t *data, unsigned num_samples, bmusb::AudioFormat audio_format, unsigned num_destination_channels);
+
+// Similar, except converts to floating-point instead, and converts only one channel.
+void convert_audio_to_fp32(float *dst, size_t out_channel, size_t out_num_channels,
+                           const uint8_t *src, size_t in_channel, bmusb::AudioFormat in_audio_format,
+                           size_t num_samples);
+
 enum EQBand {
        EQ_BAND_BASS = 0,
        EQ_BAND_MID,
@@ -54,9 +65,9 @@ public:
        // the lock wasn't successfully taken; if so, you should simply try again.
        // (This is to avoid a deadlock where a card hangs on the mutex in add_audio()
        // while we are trying to shut it down from another thread that also holds
-       // the mutex.) frame_length is in TIMEBASE units.
-       bool add_audio(DeviceSpec device_spec, const uint8_t *data, unsigned num_samples, bmusb::AudioFormat audio_format, int64_t frame_length, std::chrono::steady_clock::time_point frame_time);
-       bool add_silence(DeviceSpec device_spec, unsigned samples_per_frame, unsigned num_frames, int64_t frame_length);
+       // the mutex.)
+       bool add_audio(DeviceSpec device_spec, const uint8_t *data, unsigned num_samples, bmusb::AudioFormat audio_format, std::chrono::steady_clock::time_point frame_time);
+       bool add_silence(DeviceSpec device_spec, unsigned samples_per_frame, unsigned num_frames);
 
        // If a given device is offline for whatever reason and cannot deliver audio
        // (by means of add_audio() or add_silence()), you can call put it in silence mode,
@@ -73,10 +84,15 @@ public:
        bool get_mute(unsigned bus_index) const { return mute[bus_index]; }
        void set_mute(unsigned bus_index, bool muted) { mute[bus_index] = muted; }
 
-       // Note: This operation holds all ALSA devices (see ALSAPool::get_devices()).
-       // You will need to call set_input_mapping() to get the hold state correctly,
-       // or every card will be held forever.
-       std::map<DeviceSpec, DeviceInfo> get_devices();
+       enum HoldDevices {
+               HOLD_NO_DEVICES,
+
+               // Note: Holds all ALSA devices (see ALSAPool::get_devices()).
+               // You will need to call set_input_mapping() to get the hold state correctly,
+               // or every card will be held forever.
+               HOLD_ALSA_DEVICES
+       };
+       std::map<DeviceSpec, DeviceInfo> get_devices(HoldDevices hold_devices);
 
        // See comments on ALSAPool::get_card_state().
        ALSAPool::Device::State get_alsa_card_state(unsigned index)
@@ -312,6 +328,12 @@ public:
        BusSettings get_bus_settings(unsigned bus_index) const;
        void set_bus_settings(unsigned bus_index, const BusSettings &settings);
 
+       // Does not take ownership. Not thread-safe (so only call when the mixer is being created).
+       void set_delay_analyzer(DelayAnalyzerInterface *delay_analyzer)
+       {
+               this->delay_analyzer = delay_analyzer;
+       }
+
 private:
        struct AudioDevice {
                std::unique_ptr<ResamplingQueue> resampling_queue;
@@ -320,6 +342,10 @@ private:
                // Which channels we consider interesting (ie., are part of some input_mapping).
                std::set<unsigned> interesting_channels;
                bool silenced = false;
+
+               // Positive means the audio is delayed, negative means we try to have it earlier
+               // (although we can't time-travel!). Stored together with the input mapping.
+               double extra_delay_ms = 0.0;
        };
 
        const AudioDevice *find_audio_device(DeviceSpec device_spec) const
@@ -422,6 +448,8 @@ private:
                std::atomic<double> compressor_attenuation_db{0.0/0.0};
        };
        std::unique_ptr<BusMetrics[]> bus_metrics;  // One for each bus in <input_mapping>.
+
+       DelayAnalyzerInterface *delay_analyzer = nullptr;
 };
 
 extern AudioMixer *global_audio_mixer;