]> git.sesse.net Git - nageru/blobdiff - theme.lua
Show the current resolution next to the inputs.
[nageru] / theme.lua
index 709797c4878b1a64fc616e41f384a7433774dc7d..1f00d52165aa4b7d5be0c042bd8028da734f4e5f 100644 (file)
--- a/theme.lua
+++ b/theme.lua
@@ -7,8 +7,6 @@
 -- where all the low-level details (such as texture formats) are handled by the
 -- C++ side and you generally just build chains.
 
--- TODO: Deal with inputs that are different from our native 1280x720 resolution.
-
 local transition_start = -2.0
 local transition_end = -1.0
 local zoom_src = 0.0
@@ -33,6 +31,27 @@ local STATIC_SIGNAL_NUM = 3
 -- to the next.
 local FADE_SIGNAL_NUM = 4
 
+-- Last width/height/resolution for each channel, if we have it.
+local last_resolution = {}
+
+-- Utility function to help creating many similar chains that can differ
+-- in a free set of chosen parameters.
+function make_cartesian_product(parms, callback)
+       return make_cartesian_product_internal(parms, callback, 1, {})
+end
+
+function make_cartesian_product_internal(parms, callback, index, args)
+       if index > #parms then
+               return callback(unpack(args))
+       end
+       local ret = {}
+       for _, value in ipairs(parms[index]) do
+               args[index] = value
+               ret[value] = make_cartesian_product_internal(parms, callback, index + 1, args)
+       end
+       return ret
+end
+
 function make_sbs_input(chain, signal, deint, hq)
        local input = chain:add_live_input(not deint, deint)  -- Override bounce only if not deinterlacing.
        input:connect_signal(signal)
@@ -78,20 +97,18 @@ function make_sbs_chain(input0_deint, input1_deint, hq)
 end
 
 -- Make all possible combinations of side-by-side chains.
-local sbs_chains = {}
-for input0_type, input0_deint in pairs({live = false, livedeint = true}) do
-       sbs_chains[input0_type] = {}
-       for input1_type, input1_deint in pairs({live = false, livedeint = true}) do
-               sbs_chains[input0_type][input1_type] = {}
-               for _, hq in pairs({true, false}) do
-                       sbs_chains[input0_type][input1_type][hq] =
-                               make_sbs_chain(input0_deint, input1_deint, hq)
-               end
-       end
-end
-
-function make_fade_input(chain, signal, live, deint)
-       local input, wb_effect, last
+local sbs_chains = make_cartesian_product({
+       {"live", "livedeint"},  -- input0_type
+       {"live", "livedeint"},  -- input1_type
+       {true, false}           -- hq
+}, function(input0_type, input1_type, hq)
+       local input0_deint = (input0_type == "livedeint")
+       local input1_deint = (input1_type == "livedeint")
+       return make_sbs_chain(input0_deint, input1_deint, hq)
+end)
+
+function make_fade_input(chain, signal, live, deint, scale)
+       local input, wb_effect, resample_effect, last
        if live then
                input = chain:add_live_input(false, deint)
                wb_effect = chain:add_effect(WhiteBalanceEffect.new())
@@ -102,9 +119,17 @@ function make_fade_input(chain, signal, live, deint)
                last = input
        end
 
+       -- If we cared about this for the non-main inputs, we would have
+       -- checked hq here and invoked ResizeEffect instead.
+       if scale then
+               resample_effect = chain:add_effect(ResampleEffect.new())
+               last = resample_effect
+       end
+
        return {
                input = input,
                wb_effect = wb_effect,
+               resample_effect = resample_effect,
                last = last
        }
 end
@@ -112,11 +137,11 @@ end
 -- A chain to fade between two inputs, of which either can be a picture
 -- or a live input. In practice only used live, but we still support the
 -- hq parameter.
-function make_fade_chain(input0_live, input0_deint, input1_live, input1_deint, hq)
+function make_fade_chain(input0_live, input0_deint, input0_scale, input1_live, input1_deint, input1_scale, hq)
        local chain = EffectChain.new(16, 9)
 
-       local input0 = make_fade_input(chain, INPUT0_SIGNAL_NUM, input0_live, input0_deint)
-       local input1 = make_fade_input(chain, INPUT1_SIGNAL_NUM, input1_live, input1_deint)
+       local input0 = make_fade_input(chain, INPUT0_SIGNAL_NUM, input0_live, input0_deint, input0_scale)
+       local input1 = make_fade_input(chain, INPUT1_SIGNAL_NUM, input1_live, input1_deint, input1_scale)
 
        local mix_effect = chain:add_effect(MixEffect.new(), input0.last, input1.last)
        chain:finalize(hq)
@@ -130,22 +155,22 @@ function make_fade_chain(input0_live, input0_deint, input1_live, input1_deint, h
 end
 
 -- Chains to fade between two inputs, in various configurations.
-local fade_chains = {}
-for input0_type, input0_live in pairs({static = false, live = true, livedeint = true}) do
-       local input0_deint = (input0_live == "livedeint")
-       fade_chains[input0_type] = {}
-       for input1_type, input1_live in pairs({static = false, live = true, livedeint = true}) do
-               local input1_deint = (input1_live == "livedeint")
-               fade_chains[input0_type][input1_type] = {}
-               for _, hq in pairs({true, false}) do
-                       fade_chains[input0_type][input1_type][hq] =
-                               make_fade_chain(input0_live, input0_deint, input1_live, input1_deint, hq)
-               end
-       end
-end
+local fade_chains = make_cartesian_product({
+       {"static", "live", "livedeint"},  -- input0_type
+       {true, false},                    -- input0_scale
+       {"static", "live", "livedeint"},  -- input1_type
+       {true, false},                    -- input1_scale
+       {true}                            -- hq
+}, function(input0_type, input0_scale, input1_type, input1_scale, hq)
+       local input0_live = (input0_type ~= "static")
+       local input1_live = (input1_type ~= "static")
+       local input0_deint = (input0_type == "livedeint")
+       local input1_deint = (input1_type == "livedeint")
+       return make_fade_chain(input0_live, input0_deint, input0_scale, input1_live, input1_deint, input1_scale, hq)
+end)
 
 -- A chain to show a single input on screen.
-function make_simple_chain(input_deint, hq)
+function make_simple_chain(input_deint, input_scale, hq)
        local chain = EffectChain.new(16, 9)
 
        local input = chain:add_live_input(false, input_deint)
@@ -153,21 +178,33 @@ function make_simple_chain(input_deint, hq)
        local wb_effect = chain:add_effect(WhiteBalanceEffect.new())
        chain:finalize(hq)
 
+       local resample_effect, resize_effect
+       if scale then
+               if hq then
+                       resample_effect = chain:add_effect(ResampleEffect.new())
+               else
+                       resize_effect = chain:add_effect(ResizeEffect.new())
+               end
+       end
+
        return {
                chain = chain,
                input = input,
-               wb_effect = wb_effect
+               wb_effect = wb_effect,
+               resample_effect = resample_effect,
+               resize_effect = resize_effect
        }
 end
 
 -- Make all possible combinations of single-input chains.
-local simple_chains = {}
-for input_type, input_deint in pairs({live = false, livedeint = true}) do
-       simple_chains[input_type] = {}
-       for _, hq in pairs({true, false}) do
-               simple_chains[input_type][hq] = make_simple_chain(input_deint, hq)
-       end
-end
+local simple_chains = make_cartesian_product({
+       {"live", "livedeint"},  -- input_type
+       {true, false},          -- input_scale
+       {true, false}           -- hq
+}, function(input_type, input_scale, hq)
+       local input_deint = (input_type == "livedeint")
+       return make_simple_chain(input_deint, input_scale, hq)
+end)
 
 -- A chain to show a single static picture on screen (HQ version).
 local static_chain_hq = EffectChain.new(16, 9)
@@ -190,19 +227,50 @@ function get_input_type(signals, signal_num)
        end
 end
 
+function needs_scale(signals, signal_num, width, height)
+       return (signals:get_width(signal_num) ~= width or signals:get_height(signal_num) ~= height)
+end
+
+function set_scale_parameters_if_needed(chain_or_input, width, height)
+       if chain_or_input.resample_effect then
+               chain_or_input.resample_effect:set_int("width", width)
+               chain_or_input.resample_effect:set_int("height", height)
+       elseif chain_or_input.resize_effect then
+               chain_or_input.resize_effect:set_int("width", width)
+               chain_or_input.resize_effect:set_int("height", height)
+       end
+end
+
 -- Returns the number of outputs in addition to the live (0) and preview (1).
 -- Called only once, at the start of the program.
 function num_channels()
        return 4
 end
 
+-- Helper function to write e.g. ā€œ720pā€.
+function get_channel_resolution(signal_num)
+       if last_resolution[signal_num] then
+               if last_resolution[signal_num].height == 0 or
+                  last_resolution[signal_num].height == 525 then
+                       return "no signal"
+               elseif last_resolution[signal_num].interlaced then
+                       return (last_resolution[signal_num].height * 2) .. "i"
+               else
+                       return last_resolution[signal_num].height .. "p"
+               end
+       else
+               return "no signal"
+       end
+end
+
 -- Returns the name for each additional channel (starting from 2).
--- Called only once for each channel, at the start of the program.
+-- Called at the start of the program, and then each frame for live
+-- channels in case they change resolution.
 function channel_name(channel)
        if channel == 2 then
-               return "Input 1"
+               return "Input 1 (" .. get_channel_resolution(0) .. ")"
        elseif channel == 3 then
-               return "Input 2"
+               return "Input 2 (" .. get_channel_resolution(1) .. ")"
        elseif channel == 4 then
                return "Side-by-side"
        elseif channel == 5 then
@@ -382,12 +450,22 @@ end
 -- NOTE: The chain returned must be finalized with the Y'CbCr flag
 -- if and only if num==0.
 function get_chain(num, t, width, height, signals)
+       for signal_num=0,1 do
+               last_resolution[signal_num] = {
+                       width = signals:get_width(signal_num),
+                       height = signals:get_height(signal_num),
+                       interlaced = signals:get_interlaced(signal_num)
+               }
+       end
+
        if num == 0 then  -- Live.
                if live_signal_num == INPUT0_SIGNAL_NUM or live_signal_num == INPUT1_SIGNAL_NUM then  -- Plain input.
                        local input_type = get_input_type(signals, live_signal_num)
-                       local chain = simple_chains[input_type][true]
+                       local input_scale = needs_scale(signals, live_signal_num, width, height)
+                       local chain = simple_chains[input_type][input_scale][true]
                        prepare = function()
                                chain.input:connect_signal(live_signal_num)
+                               set_scale_parameters_if_needed(chain, width, height)
                                set_neutral_color_from_signal(chain.wb_effect, live_signal_num)
                        end
                        return chain.chain, prepare
@@ -397,17 +475,21 @@ function get_chain(num, t, width, height, signals)
                        return static_chain_hq, prepare
                elseif live_signal_num == FADE_SIGNAL_NUM then  -- Fade.
                        local input0_type = get_input_type(signals, fade_src_signal)
+                       local input0_scale = needs_scale(signals, fade_src_signal, width, height)
                        local input1_type = get_input_type(signals, fade_dst_signal)
-                       local chain = fade_chains[input0_type][input1_type][true]
+                       local input1_scale = needs_scale(signals, fade_dst_signal, width, height)
+                       local chain = fade_chains[input0_type][input0_scale][input1_type][input1_scale][true]
                        prepare = function()
                                if input0_type == "live" then
                                        chain.input0.input:connect_signal(fade_src_signal)
                                        set_neutral_color_from_signal(chain.input0.wb_effect, fade_src_signal)
                                end
+                               set_scale_parameters_if_needed(chain.input0, width, height)
                                if input1_type == "live" then
                                        chain.input1.input:connect_signal(fade_dst_signal)
                                        set_neutral_color_from_signal(chain.input1.wb_effect, fade_dst_signal)
                                end
+                               set_scale_parameters_if_needed(chain.input1, width, height)
                                local tt = calc_fade_progress(t, transition_start, transition_end)
 
                                chain.mix_effect:set_float("strength_first", 1.0 - tt)
@@ -421,9 +503,11 @@ function get_chain(num, t, width, height, signals)
                local input1_type = get_input_type(signals, INPUT1_SIGNAL_NUM)
                if t > transition_end and zoom_dst == 1.0 then
                        -- Special case: Show only the single image on screen.
-                       local chain = simple_chains[input0_type][true]
+                       local input0_scale = needs_scale(signals, fade_src_signal, width, height)
+                       local chain = simple_chains[input0_type][input0_scale][true]
                        prepare = function()
                                chain.input:connect_signal(INPUT0_SIGNAL_NUM)
+                               set_scale_parameters_if_needed(chain, width, height)
                                set_neutral_color(chain.wb_effect, input0_neutral_color)
                        end
                        return chain.chain, prepare
@@ -450,18 +534,22 @@ function get_chain(num, t, width, height, signals)
        -- Individual preview inputs.
        if num == INPUT0_SIGNAL_NUM + 2 then
                local input_type = get_input_type(signals, INPUT0_SIGNAL_NUM)
-               local chain = simple_chains[input_type][false]
+               local input_scale = needs_scale(signals, INPUT0_SIGNAL_NUM, width, height)
+               local chain = simple_chains[input_type][input_scale][false]
                prepare = function()
                        chain.input:connect_signal(INPUT0_SIGNAL_NUM)
+                       set_scale_parameters_if_needed(chain, width, height)
                        set_neutral_color(chain.wb_effect, input0_neutral_color)
                end
                return chain.chain, prepare
        end
        if num == INPUT1_SIGNAL_NUM + 2 then
                local input_type = get_input_type(signals, INPUT1_SIGNAL_NUM)
-               local chain = simple_chains[input_type][false]
+               local input_scale = needs_scale(signals, INPUT1_SIGNAL_NUM, width, height)
+               local chain = simple_chains[input_type][input_scale][false]
                prepare = function()
                        chain.input:connect_signal(INPUT1_SIGNAL_NUM)
+                       set_scale_parameters_if_needed(chain, width, height)
                        set_neutral_color(chain.wb_effect, input1_neutral_color)
                end
                return chain.chain, prepare