X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=theme.cpp;h=0cc498e8ba0a4297be74bb320440f6c75cba2f7f;hb=2abf57fbc06f52c04fb2ca1f765459908e688890;hp=c832d29bcf9a19af4e1269690b355cd876ad6e53;hpb=c996b8ab73e27736a1807a3cc6df329c9fc46d4c;p=nageru diff --git a/theme.cpp b/theme.cpp index c832d29..0cc498e 100644 --- a/theme.cpp +++ b/theme.cpp @@ -1,13 +1,15 @@ #include "theme.h" #include +#include +#include #include -#include -#include +#include #include #include #include #include +#include #include #include #include @@ -19,13 +21,19 @@ #include #include #include +#include #include #include -#include #include "defs.h" +#include "deinterlace_effect.h" +#include "flags.h" #include "image_input.h" -#include "mixer.h" +#include "input.h" +#include "input_state.h" +#include "pbo_frame_allocator.h" + +class Mixer; namespace movit { class ResourcePool; @@ -44,23 +52,30 @@ namespace { struct InputStateInfo { InputStateInfo(const InputState& input_state); - unsigned last_width[MAX_CARDS], last_height[MAX_CARDS]; - bool last_interlaced[MAX_CARDS]; + unsigned last_width[MAX_VIDEO_CARDS], last_height[MAX_VIDEO_CARDS]; + bool last_interlaced[MAX_VIDEO_CARDS], last_has_signal[MAX_VIDEO_CARDS], last_is_connected[MAX_VIDEO_CARDS]; + unsigned last_frame_rate_nom[MAX_VIDEO_CARDS], last_frame_rate_den[MAX_VIDEO_CARDS]; }; InputStateInfo::InputStateInfo(const InputState &input_state) { - for (unsigned signal_num = 0; signal_num < MAX_CARDS; ++signal_num) { + for (unsigned signal_num = 0; signal_num < MAX_VIDEO_CARDS; ++signal_num) { BufferedFrame frame = input_state.buffered_frames[signal_num][0]; if (frame.frame == nullptr) { last_width[signal_num] = last_height[signal_num] = 0; last_interlaced[signal_num] = false; + last_has_signal[signal_num] = false; + last_is_connected[signal_num] = false; continue; } const PBOFrameAllocator::Userdata *userdata = (const PBOFrameAllocator::Userdata *)frame.frame->userdata; last_width[signal_num] = userdata->last_width[frame.field_number]; last_height[signal_num] = userdata->last_height[frame.field_number]; last_interlaced[signal_num] = userdata->last_interlaced; + last_has_signal[signal_num] = userdata->last_has_signal; + last_is_connected[signal_num] = userdata->last_is_connected; + last_frame_rate_nom[signal_num] = userdata->last_frame_rate_nom; + last_frame_rate_den[signal_num] = userdata->last_frame_rate_den; } } @@ -86,7 +101,29 @@ int wrap_lua_object(lua_State* L, const char *class_name, Args&&... args) { // Construct the C++ object and put it on the stack. void *mem = lua_newuserdata(L, sizeof(T)); - new(mem) T(std::forward(args)...); + new(mem) T(forward(args)...); + + // Look up the metatable named , and set it on the new object. + luaL_getmetatable(L, class_name); + lua_setmetatable(L, -2); + + return 1; +} + +// Like wrap_lua_object, but the object is not owned by Lua; ie. it's not freed +// by Lua GC. This is typically the case for Effects, which are owned by EffectChain +// and expected to be destructed by it. The object will be of type T** instead of T* +// when exposed to Lua. +// +// Note that we currently leak if you allocate an Effect in this way and never call +// add_effect. We should see if there's a way to e.g. set __gc on it at construction time +// and then release that once add_effect() takes ownership. +template +int wrap_lua_object_nonowned(lua_State* L, const char *class_name, Args&&... args) +{ + // Construct the pointer ot the C++ object and put it on the stack. + T **obj = (T **)lua_newuserdata(L, sizeof(T *)); + *obj = new T(forward(args)...); // Look up the metatable named , and set it on the new object. luaL_getmetatable(L, class_name); @@ -109,9 +146,10 @@ Effect *get_effect(lua_State *L, int idx) luaL_testudata(L, idx, "IntegralPaddingEffect") || luaL_testudata(L, idx, "OverlayEffect") || luaL_testudata(L, idx, "ResizeEffect") || + luaL_testudata(L, idx, "MultiplyEffect") || luaL_testudata(L, idx, "MixEffect") || luaL_testudata(L, idx, "ImageInput")) { - return (Effect *)lua_touserdata(L, idx); + return *(Effect **)lua_touserdata(L, idx); } luaL_error(L, "Error: Index #%d was not an Effect type\n", idx); return nullptr; @@ -132,11 +170,11 @@ bool checkbool(lua_State* L, int idx) return lua_toboolean(L, idx); } -std::string checkstdstring(lua_State *L, int index) +string checkstdstring(lua_State *L, int index) { size_t len; const char* cstr = lua_tolstring(L, index, &len); - return std::string(cstr, len); + return string(cstr, len); } int EffectChain_new(lua_State* L) @@ -149,6 +187,14 @@ int EffectChain_new(lua_State* L) return wrap_lua_object(L, "EffectChain", aspect_w, aspect_h, theme->get_resource_pool()); } +int EffectChain_gc(lua_State* L) +{ + assert(lua_gettop(L) == 1); + EffectChain *chain = (EffectChain *)luaL_checkudata(L, 1, "EffectChain"); + chain->~EffectChain(); + return 0; +} + int EffectChain_add_live_input(lua_State* L) { assert(lua_gettop(L) == 3); @@ -215,25 +261,36 @@ int EffectChain_finalize(lua_State* L) if (is_main_chain) { YCbCrFormat output_ycbcr_format; - // We actually output 4:2:0 in the end, but chroma subsampling - // happens in a pass not run by Movit (see Mixer::subsample_chroma()). + // We actually output 4:2:0 and/or 4:2:2 in the end, but chroma subsampling + // happens in a pass not run by Movit (see ChromaSubsampler::subsample_chroma()). output_ycbcr_format.chroma_subsampling_x = 1; output_ycbcr_format.chroma_subsampling_y = 1; - // Rec. 709 would be the sane thing to do, but it seems many players - // (e.g. MPlayer and VLC) just default to BT.601 coefficients no matter - // what (see discussions in e.g. https://trac.ffmpeg.org/ticket/4978). - // We _do_ set the right flags, though, so that a player that works - // properly doesn't have to guess. - output_ycbcr_format.luma_coefficients = YCBCR_REC_601; + // This will be overridden if HDMI/SDI output is in force. + if (global_flags.ycbcr_rec709_coefficients) { + output_ycbcr_format.luma_coefficients = YCBCR_REC_709; + } else { + output_ycbcr_format.luma_coefficients = YCBCR_REC_601; + } + output_ycbcr_format.full_range = false; - output_ycbcr_format.num_levels = 256; + output_ycbcr_format.num_levels = 1 << global_flags.x264_bit_depth; + + GLenum type = global_flags.x264_bit_depth > 8 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE; - chain->add_ycbcr_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED, output_ycbcr_format, YCBCR_OUTPUT_SPLIT_Y_AND_CBCR); - chain->set_dither_bits(8); + chain->add_ycbcr_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED, output_ycbcr_format, YCBCR_OUTPUT_SPLIT_Y_AND_CBCR, type); + + // If we're using zerocopy video encoding (so the destination + // Y texture is owned by VA-API and will be unavailable for + // display), add a copy, where we'll only be using the Y component. + if (global_flags.use_zerocopy) { + chain->add_ycbcr_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED, output_ycbcr_format, YCBCR_OUTPUT_INTERLEAVED, type); // Add a copy where we'll only be using the Y component. + } + chain->set_dither_bits(global_flags.x264_bit_depth > 8 ? 16 : 8); chain->set_output_origin(OUTPUT_ORIGIN_TOP_LEFT); + } else { + chain->add_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED); } - chain->add_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED); chain->finalize(); return 0; @@ -251,50 +308,56 @@ int LiveInputWrapper_connect_signal(lua_State* L) int ImageInput_new(lua_State* L) { assert(lua_gettop(L) == 1); - std::string filename = checkstdstring(L, 1); - return wrap_lua_object(L, "ImageInput", filename); + string filename = checkstdstring(L, 1); + return wrap_lua_object_nonowned(L, "ImageInput", filename); } int WhiteBalanceEffect_new(lua_State* L) { assert(lua_gettop(L) == 0); - return wrap_lua_object(L, "WhiteBalanceEffect"); + return wrap_lua_object_nonowned(L, "WhiteBalanceEffect"); } int ResampleEffect_new(lua_State* L) { assert(lua_gettop(L) == 0); - return wrap_lua_object(L, "ResampleEffect"); + return wrap_lua_object_nonowned(L, "ResampleEffect"); } int PaddingEffect_new(lua_State* L) { assert(lua_gettop(L) == 0); - return wrap_lua_object(L, "PaddingEffect"); + return wrap_lua_object_nonowned(L, "PaddingEffect"); } int IntegralPaddingEffect_new(lua_State* L) { assert(lua_gettop(L) == 0); - return wrap_lua_object(L, "IntegralPaddingEffect"); + return wrap_lua_object_nonowned(L, "IntegralPaddingEffect"); } int OverlayEffect_new(lua_State* L) { assert(lua_gettop(L) == 0); - return wrap_lua_object(L, "OverlayEffect"); + return wrap_lua_object_nonowned(L, "OverlayEffect"); } int ResizeEffect_new(lua_State* L) { assert(lua_gettop(L) == 0); - return wrap_lua_object(L, "ResizeEffect"); + return wrap_lua_object_nonowned(L, "ResizeEffect"); +} + +int MultiplyEffect_new(lua_State* L) +{ + assert(lua_gettop(L) == 0); + return wrap_lua_object_nonowned(L, "MultiplyEffect"); } int MixEffect_new(lua_State* L) { assert(lua_gettop(L) == 0); - return wrap_lua_object(L, "MixEffect"); + return wrap_lua_object_nonowned(L, "MixEffect"); } int InputStateInfo_get_width(lua_State* L) @@ -327,11 +390,51 @@ int InputStateInfo_get_interlaced(lua_State* L) return 1; } +int InputStateInfo_get_has_signal(lua_State* L) +{ + assert(lua_gettop(L) == 2); + InputStateInfo *input_state_info = get_input_state_info(L, 1); + Theme *theme = get_theme_updata(L); + int signal_num = theme->map_signal(luaL_checknumber(L, 2)); + lua_pushboolean(L, input_state_info->last_has_signal[signal_num]); + return 1; +} + +int InputStateInfo_get_is_connected(lua_State* L) +{ + assert(lua_gettop(L) == 2); + InputStateInfo *input_state_info = get_input_state_info(L, 1); + Theme *theme = get_theme_updata(L); + int signal_num = theme->map_signal(luaL_checknumber(L, 2)); + lua_pushboolean(L, input_state_info->last_is_connected[signal_num]); + return 1; +} + +int InputStateInfo_get_frame_rate_nom(lua_State* L) +{ + assert(lua_gettop(L) == 2); + InputStateInfo *input_state_info = get_input_state_info(L, 1); + Theme *theme = get_theme_updata(L); + int signal_num = theme->map_signal(luaL_checknumber(L, 2)); + lua_pushnumber(L, input_state_info->last_frame_rate_nom[signal_num]); + return 1; +} + +int InputStateInfo_get_frame_rate_den(lua_State* L) +{ + assert(lua_gettop(L) == 2); + InputStateInfo *input_state_info = get_input_state_info(L, 1); + Theme *theme = get_theme_updata(L); + int signal_num = theme->map_signal(luaL_checknumber(L, 2)); + lua_pushnumber(L, input_state_info->last_frame_rate_den[signal_num]); + return 1; +} + int Effect_set_float(lua_State *L) { assert(lua_gettop(L) == 3); Effect *effect = (Effect *)get_effect(L, 1); - std::string key = checkstdstring(L, 2); + string key = checkstdstring(L, 2); float value = luaL_checknumber(L, 3); if (!effect->set_float(key, value)) { luaL_error(L, "Effect refused set_float(\"%s\", %d) (invalid key?)", key.c_str(), int(value)); @@ -343,7 +446,7 @@ int Effect_set_int(lua_State *L) { assert(lua_gettop(L) == 3); Effect *effect = (Effect *)get_effect(L, 1); - std::string key = checkstdstring(L, 2); + string key = checkstdstring(L, 2); float value = luaL_checknumber(L, 3); if (!effect->set_int(key, value)) { luaL_error(L, "Effect refused set_int(\"%s\", %d) (invalid key?)", key.c_str(), int(value)); @@ -355,7 +458,7 @@ int Effect_set_vec3(lua_State *L) { assert(lua_gettop(L) == 5); Effect *effect = (Effect *)get_effect(L, 1); - std::string key = checkstdstring(L, 2); + string key = checkstdstring(L, 2); float v[3]; v[0] = luaL_checknumber(L, 3); v[1] = luaL_checknumber(L, 4); @@ -371,7 +474,7 @@ int Effect_set_vec4(lua_State *L) { assert(lua_gettop(L) == 6); Effect *effect = (Effect *)get_effect(L, 1); - std::string key = checkstdstring(L, 2); + string key = checkstdstring(L, 2); float v[4]; v[0] = luaL_checknumber(L, 3); v[1] = luaL_checknumber(L, 4); @@ -386,6 +489,7 @@ int Effect_set_vec4(lua_State *L) const luaL_Reg EffectChain_funcs[] = { { "new", EffectChain_new }, + { "__gc", EffectChain_gc }, { "add_live_input", EffectChain_add_live_input }, { "add_effect", EffectChain_add_effect }, { "finalize", EffectChain_finalize }, @@ -460,6 +564,15 @@ const luaL_Reg ResizeEffect_funcs[] = { { NULL, NULL } }; +const luaL_Reg MultiplyEffect_funcs[] = { + { "new", MultiplyEffect_new }, + { "set_float", Effect_set_float }, + { "set_int", Effect_set_int }, + { "set_vec3", Effect_set_vec3 }, + { "set_vec4", Effect_set_vec4 }, + { NULL, NULL } +}; + const luaL_Reg MixEffect_funcs[] = { { "new", MixEffect_new }, { "set_float", Effect_set_float }, @@ -473,6 +586,10 @@ const luaL_Reg InputStateInfo_funcs[] = { { "get_width", InputStateInfo_get_width }, { "get_height", InputStateInfo_get_height }, { "get_interlaced", InputStateInfo_get_interlaced }, + { "get_has_signal", InputStateInfo_get_has_signal }, + { "get_is_connected", InputStateInfo_get_is_connected }, + { "get_frame_rate_nom", InputStateInfo_get_frame_rate_nom }, + { "get_frame_rate_den", InputStateInfo_get_frame_rate_den }, { NULL, NULL } }; @@ -499,8 +616,9 @@ LiveInputWrapper::LiveInputWrapper(Theme *theme, EffectChain *chain, bool overri // Perhaps 601 was only to indicate the subsampling positions, not the // colorspace itself? Tested with a Lenovo X1 gen 3 as input. YCbCrFormat input_ycbcr_format; - input_ycbcr_format.chroma_subsampling_x = 2; + input_ycbcr_format.chroma_subsampling_x = global_flags.ten_bit_input ? 1 : 2; input_ycbcr_format.chroma_subsampling_y = 1; + input_ycbcr_format.num_levels = global_flags.ten_bit_input ? 1024 : 256; input_ycbcr_format.cb_x_position = 0.0; input_ycbcr_format.cr_x_position = 0.0; input_ycbcr_format.cb_y_position = 0.5; @@ -524,10 +642,12 @@ LiveInputWrapper::LiveInputWrapper(Theme *theme, EffectChain *chain, bool overri num_inputs = 1; } for (unsigned i = 0; i < num_inputs; ++i) { + // When using 10-bit input, we're converting to interleaved through v210Converter. + YCbCrInputSplitting splitting = global_flags.ten_bit_input ? YCBCR_INPUT_INTERLEAVED : YCBCR_INPUT_SPLIT_Y_AND_CBCR; if (override_bounce) { - inputs.push_back(new NonBouncingYCbCrInput(inout_format, input_ycbcr_format, WIDTH, HEIGHT, YCBCR_INPUT_SPLIT_Y_AND_CBCR)); + inputs.push_back(new NonBouncingYCbCrInput(inout_format, input_ycbcr_format, global_flags.width, global_flags.height, splitting)); } else { - inputs.push_back(new YCbCrInput(inout_format, input_ycbcr_format, WIDTH, HEIGHT, YCBCR_INPUT_SPLIT_Y_AND_CBCR)); + inputs.push_back(new YCbCrInput(inout_format, input_ycbcr_format, global_flags.width, global_flags.height, splitting)); } chain->add_input(inputs.back()); } @@ -576,8 +696,12 @@ void LiveInputWrapper::connect_signal(int signal_num) userdata = (const PBOFrameAllocator::Userdata *)frame.frame->userdata; } - inputs[i]->set_texture_num(0, userdata->tex_y[frame.field_number]); - inputs[i]->set_texture_num(1, userdata->tex_cbcr[frame.field_number]); + if (global_flags.ten_bit_input) { + inputs[i]->set_texture_num(0, userdata->tex_444[frame.field_number]); + } else { + inputs[i]->set_texture_num(0, userdata->tex_y[frame.field_number]); + inputs[i]->set_texture_num(1, userdata->tex_cbcr[frame.field_number]); + } inputs[i]->set_width(userdata->last_width[frame.field_number]); inputs[i]->set_height(userdata->last_height[frame.field_number]); @@ -590,8 +714,27 @@ void LiveInputWrapper::connect_signal(int signal_num) } } -Theme::Theme(const char *filename, ResourcePool *resource_pool, unsigned num_cards) - : resource_pool(resource_pool), num_cards(num_cards) +namespace { + +int call_num_channels(lua_State *L) +{ + lua_getglobal(L, "num_channels"); + + if (lua_pcall(L, 0, 1, 0) != 0) { + fprintf(stderr, "error running function `num_channels': %s\n", lua_tostring(L, -1)); + exit(1); + } + + int num_channels = luaL_checknumber(L, 1); + lua_pop(L, 1); + assert(lua_gettop(L) == 0); + return num_channels; +} + +} // namespace + +Theme::Theme(const string &filename, const vector &search_dirs, ResourcePool *resource_pool, unsigned num_cards) + : resource_pool(resource_pool), num_cards(num_cards), signal_to_card_mapping(global_flags.default_stream_mapping) { L = luaL_newstate(); luaL_openlibs(L); @@ -605,29 +748,51 @@ Theme::Theme(const char *filename, ResourcePool *resource_pool, unsigned num_car register_class("IntegralPaddingEffect", IntegralPaddingEffect_funcs); register_class("OverlayEffect", OverlayEffect_funcs); register_class("ResizeEffect", ResizeEffect_funcs); + register_class("MultiplyEffect", MultiplyEffect_funcs); register_class("MixEffect", MixEffect_funcs); register_class("InputStateInfo", InputStateInfo_funcs); - // Run script. + // Run script. Search through all directories until we find a file that will load + // (as in, does not return LUA_ERRFILE); then run it. We store load errors + // from all the attempts, and show them once we know we can't find any of them. lua_settop(L, 0); - if (luaL_dofile(L, filename)) { - fprintf(stderr, "error: %s\n", lua_tostring(L, -1)); + vector errors; + bool success = false; + for (size_t i = 0; i < search_dirs.size(); ++i) { + string path = search_dirs[i] + "/" + filename; + int err = luaL_loadfile(L, path.c_str()); + if (err == 0) { + // Success; actually call the code. + if (lua_pcall(L, 0, LUA_MULTRET, 0)) { + fprintf(stderr, "Error when running %s: %s\n", path.c_str(), lua_tostring(L, -1)); + exit(1); + } + success = true; + break; + } + errors.push_back(lua_tostring(L, -1)); lua_pop(L, 1); + if (err != LUA_ERRFILE) { + // The file actually loaded, but failed to parse somehow. Abort; don't try the next one. + break; + } + } + + if (!success) { + for (const string &error : errors) { + fprintf(stderr, "%s\n", error.c_str()); + } exit(1); } assert(lua_gettop(L) == 0); // Ask it for the number of channels. - lua_getglobal(L, "num_channels"); - - if (lua_pcall(L, 0, 1, 0) != 0) { - fprintf(stderr, "error running function `num_channels': %s\n", lua_tostring(L, -1)); - exit(1); - } + num_channels = call_num_channels(L); +} - num_channels = luaL_checknumber(L, 1); - lua_pop(L, 1); - assert(lua_gettop(L) == 0); +Theme::~Theme() +{ + lua_close(L); } void Theme::register_class(const char *class_name, const luaL_Reg *funcs) @@ -660,7 +825,12 @@ Theme::Chain Theme::get_chain(unsigned num, float t, unsigned width, unsigned he exit(1); } - chain.chain = (EffectChain *)luaL_checkudata(L, -2, "EffectChain"); + chain.chain = (EffectChain *)luaL_testudata(L, -2, "EffectChain"); + if (chain.chain == nullptr) { + fprintf(stderr, "get_chain() for chain number %d did not return an EffectChain\n", + num); + exit(1); + } if (!lua_isfunction(L, -1)) { fprintf(stderr, "Argument #-1 should be a function\n"); exit(1); @@ -695,22 +865,65 @@ Theme::Chain Theme::get_chain(unsigned num, float t, unsigned width, unsigned he return chain; } -std::string Theme::get_channel_name(unsigned channel) +string Theme::get_channel_name(unsigned channel) { unique_lock lock(m); lua_getglobal(L, "channel_name"); lua_pushnumber(L, channel); if (lua_pcall(L, 1, 1, 0) != 0) { - fprintf(stderr, "error running function `channel_nam': %s\n", lua_tostring(L, -1)); + fprintf(stderr, "error running function `channel_name': %s\n", lua_tostring(L, -1)); + exit(1); + } + const char *ret = lua_tostring(L, -1); + if (ret == nullptr) { + fprintf(stderr, "function `channel_name' returned nil for channel %d\n", channel); + exit(1); + } + + string retstr = ret; + lua_pop(L, 1); + assert(lua_gettop(L) == 0); + return retstr; +} + +int Theme::get_channel_signal(unsigned channel) +{ + unique_lock lock(m); + lua_getglobal(L, "channel_signal"); + lua_pushnumber(L, channel); + if (lua_pcall(L, 1, 1, 0) != 0) { + fprintf(stderr, "error running function `channel_signal': %s\n", lua_tostring(L, -1)); exit(1); } - std::string ret = lua_tostring(L, -1); + int ret = luaL_checknumber(L, 1); lua_pop(L, 1); assert(lua_gettop(L) == 0); return ret; } +std::string Theme::get_channel_color(unsigned channel) +{ + unique_lock lock(m); + lua_getglobal(L, "channel_color"); + lua_pushnumber(L, channel); + if (lua_pcall(L, 1, 1, 0) != 0) { + fprintf(stderr, "error running function `channel_color': %s\n", lua_tostring(L, -1)); + exit(1); + } + + const char *ret = lua_tostring(L, -1); + if (ret == nullptr) { + fprintf(stderr, "function `channel_color' returned nil for channel %d\n", channel); + exit(1); + } + + string retstr = ret; + lua_pop(L, 1); + assert(lua_gettop(L) == 0); + return retstr; +} + bool Theme::get_supports_set_wb(unsigned channel) { unique_lock lock(m); @@ -743,7 +956,7 @@ void Theme::set_wb(unsigned channel, double r, double g, double b) assert(lua_gettop(L) == 0); } -std::vector Theme::get_transition_names(float t) +vector Theme::get_transition_names(float t) { unique_lock lock(m); lua_getglobal(L, "get_transitions"); @@ -753,7 +966,7 @@ std::vector Theme::get_transition_names(float t) exit(1); } - std::vector ret; + vector ret; lua_pushnil(L); while (lua_next(L, -2) != 0) { ret.push_back(lua_tostring(L, -1)); @@ -766,14 +979,39 @@ std::vector Theme::get_transition_names(float t) int Theme::map_signal(int signal_num) { - if (signal_num >= int(num_cards)) { - if (signals_warned_about.insert(signal_num).second) { + unique_lock lock(map_m); + if (signal_to_card_mapping.count(signal_num)) { + return signal_to_card_mapping[signal_num]; + } + + int card_index; + if (global_flags.output_card != -1 && num_cards > 1) { + // Try to exclude the output card from the default card_index. + card_index = signal_num % (num_cards - 1); + if (card_index >= global_flags.output_card) { + ++card_index; + } + if (signal_num >= int(num_cards - 1)) { + fprintf(stderr, "WARNING: Theme asked for input %d, but we only have %u input card(s) (card %d is busy with output).\n", + signal_num, num_cards - 1, global_flags.output_card); + fprintf(stderr, "Mapping to card %d instead.\n", card_index); + } + } else { + card_index = signal_num % num_cards; + if (signal_num >= int(num_cards)) { fprintf(stderr, "WARNING: Theme asked for input %d, but we only have %u card(s).\n", signal_num, num_cards); - fprintf(stderr, "Mapping to card %d instead.\n", signal_num % num_cards); + fprintf(stderr, "Mapping to card %d instead.\n", card_index); } - signal_num %= num_cards; } - return signal_num; + signal_to_card_mapping[signal_num] = card_index; + return card_index; +} + +void Theme::set_signal_mapping(int signal_num, int card_num) +{ + unique_lock lock(map_m); + assert(card_num < int(num_cards)); + signal_to_card_mapping[signal_num] = card_num; } void Theme::transition_clicked(int transition_num, float t)