+ // TODO: Should this really be per-channel? Shouldn't it just be called for e.g. the live output?
+ typedef std::function<void(const std::vector<std::string> &)> transition_names_updated_callback_t;
+ void set_transition_names_updated_callback(Output output, transition_names_updated_callback_t callback)
+ {
+ output_channel[output].set_transition_names_updated_callback(callback);
+ }
+
+ typedef std::function<void(const std::string &)> name_updated_callback_t;
+ void set_name_updated_callback(Output output, name_updated_callback_t callback)
+ {
+ output_channel[output].set_name_updated_callback(callback);
+ }
+
+ typedef std::function<void(const std::string &)> color_updated_callback_t;
+ void set_color_updated_callback(Output output, color_updated_callback_t callback)
+ {
+ output_channel[output].set_color_updated_callback(callback);
+ }
+
+ typedef std::function<void(float level_lufs, float peak_db,
+ float global_level_lufs, float range_low_lufs, float range_high_lufs,
+ float gain_staging_db, float final_makeup_gain_db,
+ float correlation)> audio_level_callback_t;
+ void set_audio_level_callback(audio_level_callback_t callback)
+ {
+ audio_level_callback = callback;
+ }
+
+ std::vector<std::string> get_transition_names()
+ {
+ return theme->get_transition_names(pts());
+ }
+
+ unsigned get_num_channels() const
+ {
+ return theme->get_num_channels();
+ }
+
+ std::string get_channel_name(unsigned channel) const
+ {
+ return theme->get_channel_name(channel);
+ }
+
+ std::string get_channel_color(unsigned channel) const
+ {
+ return theme->get_channel_color(channel);
+ }
+
+ int get_channel_signal(unsigned channel) const
+ {
+ return theme->get_channel_signal(channel);
+ }
+
+ int map_signal(unsigned channel)
+ {
+ return theme->map_signal(channel);
+ }
+
+ unsigned get_audio_source() const
+ {
+ return audio_source_channel;
+ }
+
+ void set_audio_source(unsigned channel)
+ {
+ audio_source_channel = channel;
+ }
+
+ unsigned get_master_clock() const
+ {
+ return master_clock_channel;
+ }
+
+ void set_master_clock(unsigned channel)
+ {
+ master_clock_channel = channel;
+ }
+
+ void set_signal_mapping(int signal, int card)
+ {
+ return theme->set_signal_mapping(signal, card);
+ }
+
+ bool get_supports_set_wb(unsigned channel) const
+ {
+ return theme->get_supports_set_wb(channel);
+ }
+
+ void set_wb(unsigned channel, double r, double g, double b) const
+ {
+ theme->set_wb(channel, r, g, b);
+ }
+
+ void set_locut_cutoff(float cutoff_hz)
+ {
+ locut_cutoff_hz = cutoff_hz;
+ }
+
+ void set_locut_enabled(bool enabled)
+ {
+ locut_enabled = enabled;
+ }
+
+ bool get_locut_enabled() const
+ {
+ return locut_enabled;
+ }
+
+ float get_limiter_threshold_dbfs()
+ {
+ return limiter_threshold_dbfs;
+ }
+
+ float get_compressor_threshold_dbfs()
+ {
+ return compressor_threshold_dbfs;
+ }
+
+ void set_limiter_threshold_dbfs(float threshold_dbfs)
+ {
+ limiter_threshold_dbfs = threshold_dbfs;
+ }
+
+ void set_compressor_threshold_dbfs(float threshold_dbfs)
+ {
+ compressor_threshold_dbfs = threshold_dbfs;
+ }
+
+ void set_limiter_enabled(bool enabled)
+ {
+ limiter_enabled = enabled;
+ }
+
+ bool get_limiter_enabled() const
+ {
+ return limiter_enabled;
+ }
+
+ void set_compressor_enabled(bool enabled)
+ {
+ compressor_enabled = enabled;
+ }
+
+ bool get_compressor_enabled() const
+ {
+ return compressor_enabled;
+ }
+
+ void set_gain_staging_db(float gain_db)