Make so that auto white balance is stored per (physical) card, not per signal.

[nageru] / nageru / theme.cpp

diff --git a/nageru/theme.cpp b/nageru/theme.cpp
index 65d82dae0bfa0c14d195e74f931496caf2f8514e..d63c853ff2fef227e0d620fe66ddc5511d3c3575 100644 (file)
--- a/nageru/theme.cpp
+++ b/nageru/theme.cpp
@@ -1124,11 +1124,11 @@ bool LiveInputWrapper::connect_signal(int signal_num)
        }
 
        int card_idx = theme->map_signal_to_card(signal_num);
-       connect_signal_raw(card_idx, *theme->input_state);
+       connect_card(card_idx, *theme->input_state);
        return true;
 }
 
-void LiveInputWrapper::connect_signal_raw(int card_idx, const InputState &input_state)
+void LiveInputWrapper::connect_card(int card_idx, const InputState &input_state)
 {
        BufferedFrame first_frame = input_state.buffered_frames[card_idx][0];
        if (first_frame.frame == nullptr) {
@@ -1677,13 +1677,13 @@ Theme::Chain Theme::get_chain_from_effect_chain(EffectChain *effect_chain, unsig
                // each FFmpeg or CEF input, so we'll do it here.
                if (video_signal_connections.count(effect_chain)) {
                        for (const VideoSignalConnection &conn : video_signal_connections[effect_chain]) {
-                               conn.wrapper->connect_signal_raw(conn.source->get_card_index(), input_state);
+                               conn.wrapper->connect_card(conn.source->get_card_index(), input_state);
                        }
                }
 #ifdef HAVE_CEF
                if (html_signal_connections.count(effect_chain)) {
                        for (const CEFSignalConnection &conn : html_signal_connections[effect_chain]) {
-                               conn.wrapper->connect_signal_raw(conn.source->get_card_index(), input_state);
+                               conn.wrapper->connect_card(conn.source->get_card_index(), input_state);
                        }
                }
 #endif
@@ -1868,19 +1868,20 @@ void Theme::set_wb(unsigned channel, float r, float g, float b)
 
        lock_guard<mutex> lock(m);
        if (signal != -1) {
-               white_balance_for_signal[signal] = RGBTriplet{ r, g, b };
+               int card_idx = map_signal_to_card(signal);
+               white_balance_for_card[card_idx] = RGBTriplet{ r, g, b };
        }
 
        call_lua_wb_callback(channel, r, g, b);
 }
 
-void Theme::set_wb_for_signal(int signal, float r, float g, float b)
+void Theme::set_wb_for_card(int card_idx, float r, float g, float b)
 {
        lock_guard<mutex> lock(m);
-       white_balance_for_signal[signal] = RGBTriplet{ r, g, b };
+       white_balance_for_card[card_idx] = RGBTriplet{ r, g, b };
 
        for (const auto &channel_and_signal : channel_signals) {
-               if (channel_and_signal.second == signal) {
+               if (map_signal_to_card(channel_and_signal.second) == card_idx) {
                        call_lua_wb_callback(channel_and_signal.first, r, g, b);
                }
        }
@@ -1907,10 +1908,10 @@ void Theme::call_lua_wb_callback(unsigned channel, float r, float g, float b)
        assert(lua_gettop(L) == 0);
 }
 
-RGBTriplet Theme::get_white_balance_for_signal(int signal)
+RGBTriplet Theme::get_white_balance_for_card(int card_idx)
 {
-       if (white_balance_for_signal.count(signal)) {
-               return white_balance_for_signal[signal];
+       if (white_balance_for_card.count(card_idx)) {
+               return white_balance_for_card[card_idx];
        } else {
                return RGBTriplet{ 1.0, 1.0, 1.0 };
        }