X-Git-Url: https://git.sesse.net/?p=nageru;a=blobdiff_plain;f=audio_mixer.h;h=ebe142a74cbc9e6f81d125505022d88588cb00cd;hp=1570d26373eb3592fbf897990954521ba36d1fb4;hb=703e00da89118df9be0354dda621bed023e6030e;hpb=1f32e9e2f4d6b87d8b46a7e4a024a4f43af1b7a2 diff --git a/audio_mixer.h b/audio_mixer.h index 1570d26..ebe142a 100644 --- a/audio_mixer.h +++ b/audio_mixer.h @@ -8,19 +8,20 @@ // // All operations on AudioMixer (except destruction) are thread-safe. -#include +#include #include +#include #include +#include +#include #include #include #include #include +#include #include -#include -#include "alsa_input.h" #include "alsa_pool.h" -#include "bmusb/bmusb.h" #include "correlation_measurer.h" #include "db.h" #include "defs.h" @@ -30,6 +31,8 @@ #include "resampling_queue.h" #include "stereocompressor.h" +class DeviceSpecProto; + namespace bmusb { struct AudioFormat; } // namespace bmusb @@ -43,7 +46,7 @@ enum EQBand { class AudioMixer { public: - AudioMixer(unsigned num_cards); + AudioMixer(unsigned num_capture_cards, unsigned num_ffmpeg_inputs); void reset_resampler(DeviceSpec device_spec); void reset_meters(); @@ -52,7 +55,7 @@ public: // (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); + 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); // If a given device is offline for whatever reason and cannot deliver audio @@ -62,11 +65,14 @@ public: // affect it. Same true/false behavior as add_audio(). bool silence_card(DeviceSpec device_spec, bool silence); - std::vector get_output(double pts, unsigned num_samples, ResamplingQueue::RateAdjustmentPolicy rate_adjustment_policy); + std::vector get_output(std::chrono::steady_clock::time_point ts, unsigned num_samples, ResamplingQueue::RateAdjustmentPolicy rate_adjustment_policy); float get_fader_volume(unsigned bus_index) const { return fader_volume_db[bus_index]; } void set_fader_volume(unsigned bus_index, float level_db) { fader_volume_db[bus_index] = level_db; } + 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. @@ -90,9 +96,32 @@ public: // Note: The card should be held (currently this isn't enforced, though). void serialize_device(DeviceSpec device_spec, DeviceSpecProto *device_spec_proto); + enum class MappingMode { + // A single bus, only from a video card (no ALSA devices), + // only channel 1 and 2, locked to +0 dB. Note that this is + // only an UI abstraction around exactly the same audio code + // as MULTICHANNEL; it's just less flexible. + SIMPLE, + + // Full, arbitrary mappings. + MULTICHANNEL + }; + + // Automatically sets mapping mode to MappingMode::SIMPLE. + void set_simple_input(unsigned card_index); + + // If mapping mode is not representable as a MappingMode::SIMPLE type + // mapping, returns numeric_limits::max(). + unsigned get_simple_input() const; + + // Implicitly sets mapping mode to MappingMode::MULTICHANNEL. void set_input_mapping(const InputMapping &input_mapping); + + MappingMode get_mapping_mode() const; InputMapping get_input_mapping() const; + unsigned num_buses() const; + void set_locut_cutoff(float cutoff_hz) { locut_cutoff_hz = cutoff_hz; @@ -258,6 +287,7 @@ public: // or set_* functions for that bus. struct BusSettings { float fader_volume_db; + bool muted; bool locut_enabled; float eq_level_db[NUM_EQ_BANDS]; float gain_staging_db; @@ -272,7 +302,6 @@ public: private: struct AudioDevice { std::unique_ptr resampling_queue; - int64_t next_local_pts = 0; std::string display_name; unsigned capture_frequency = OUTPUT_FREQUENCY; // Which channels we consider interesting (ie., are part of some input_mapping). @@ -296,14 +325,16 @@ private: void measure_bus_levels(unsigned bus_index, const std::vector &left, const std::vector &right); void send_audio_level_callback(); std::vector get_active_devices() const; + void set_input_mapping_lock_held(const InputMapping &input_mapping); - unsigned num_cards; + unsigned num_capture_cards, num_ffmpeg_inputs; mutable std::timed_mutex audio_mutex; ALSAPool alsa_pool; AudioDevice video_cards[MAX_VIDEO_CARDS]; // Under audio_mutex. AudioDevice alsa_inputs[MAX_ALSA_CARDS]; // Under audio_mutex. + std::unique_ptr ffmpeg_inputs; // Under audio_mutex. std::atomic locut_cutoff_hz{120}; StereoFilter locut[MAX_BUSES]; // Default cutoff 120 Hz, 24 dB/oct. @@ -314,6 +345,7 @@ private: mutable std::mutex compressor_mutex; std::unique_ptr level_compressor[MAX_BUSES]; // Under compressor_mutex. Used to set/override gain_staging_db if . float gain_staging_db[MAX_BUSES]; // Under compressor_mutex. + float last_gain_staging_db[MAX_BUSES]; // Under compressor_mutex. bool level_compressor_enabled[MAX_BUSES]; // Under compressor_mutex. static constexpr float ref_level_dbfs = -14.0f; // Chosen so that we end up around 0 LU in practice. @@ -339,8 +371,10 @@ private: 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. bool final_makeup_gain_auto = true; // Under compressor_mutex. + MappingMode current_mapping_mode; // Under audio_mutex. InputMapping input_mapping; // Under audio_mutex. std::atomic fader_volume_db[MAX_BUSES] {{ 0.0f }}; + std::atomic mute[MAX_BUSES] {{ false }}; float last_fader_volume_db[MAX_BUSES] { 0.0f }; // Under audio_mutex. std::atomic eq_level_db[MAX_BUSES][NUM_EQ_BANDS] {{{ 0.0f }}}; float last_eq_level_db[MAX_BUSES][NUM_EQ_BANDS] {{ 0.0f }}; @@ -352,6 +386,28 @@ private: CorrelationMeasurer correlation; // Under audio_measure_mutex. Resampler peak_resampler; // Under audio_measure_mutex. std::atomic peak{0.0f}; + + // Metrics. + std::atomic metric_audio_loudness_short_lufs{0.0 / 0.0}; + std::atomic metric_audio_loudness_integrated_lufs{0.0 / 0.0}; + std::atomic metric_audio_loudness_range_low_lufs{0.0 / 0.0}; + std::atomic metric_audio_loudness_range_high_lufs{0.0 / 0.0}; + std::atomic metric_audio_peak_dbfs{0.0 / 0.0}; + std::atomic metric_audio_final_makeup_gain_db{0.0}; + std::atomic metric_audio_correlation{0.0}; + + // These are all gauges corresponding to the elements of BusLevel. + // In a sense, they'd probably do better as histograms, but that's an + // awful lot of time series when you have many buses. + struct BusMetrics { + std::vector> labels; + std::atomic current_level_dbfs[2]{{0.0/0.0},{0.0/0.0}}; + std::atomic peak_level_dbfs[2]{{0.0/0.0},{0.0/0.0}}; + std::atomic historic_peak_dbfs{0.0/0.0}; + std::atomic gain_staging_db{0.0/0.0}; + std::atomic compressor_attenuation_db{0.0/0.0}; + }; + std::unique_ptr bus_metrics; // One for each bus in . }; extern AudioMixer *global_audio_mixer;