local INPUT2_SIGNAL_NUM = 2
local INPUT3_SIGNAL_NUM = 3
local INPUT4_SIGNAL_NUM = 4
-local STATIC_SIGNAL_NUM = NUM_CAMERAS
+local SBS_SIGNAL_NUM = NUM_CAMERAS
+local STATIC_SIGNAL_NUM = NUM_CAMERAS + 1
-- Preview-only signal showing the current signal with the overlay.
-- Not valid for live_signal_num!
-local OVERLAY_SIGNAL_NUM = NUM_CAMERAS + 1
+local OVERLAY_SIGNAL_NUM = NUM_CAMERAS + 2
-- Valid values for transition_type. (Cuts are done directly, so they need no entry.)
local NO_TRANSITION = 0
+local ZOOM_TRANSITION = 1
local FADE_TRANSITION = 2
-- Last width/height/frame rate for each channel, if we have it.
return make_fade_chain(input0_live, input0_deint, input0_scale, input1_live, input1_deint, input1_scale, has_overlay, hq)
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)
+
+ local resample_effect = nil
+ local resize_effect = nil
+ if (hq) then
+ resample_effect = chain:add_effect(ResampleEffect.new())
+ else
+ resize_effect = chain:add_effect(ResizeEffect.new())
+ end
+ local wb_effect = chain:add_effect(WhiteBalanceEffect.new())
+
+ local padding_effect = chain:add_effect(IntegralPaddingEffect.new())
+
+ return {
+ input = input,
+ wb_effect = wb_effect,
+ resample_effect = resample_effect,
+ resize_effect = resize_effect,
+ padding_effect = padding_effect
+ }
+end
+
+-- Side-by-side chains.
+function make_sbs_chain(input0_type, input0_overlay, input1_type, hq)
+ local chain = EffectChain.new(16, 9)
+
+ local input0 = make_sbs_input(chain, INPUT0_SIGNAL_NUM, input0_type == "livedeint", hq)
+ local input1 = make_sbs_input(chain, INPUT1_SIGNAL_NUM, input1_type == "livedeint", hq)
+
+ -- FIXME: input0_overlay
+
+ input0.padding_effect:set_vec4("border_color", 0.0, 0.0, 0.0, 1.0)
+ input1.padding_effect:set_vec4("border_color", 0.0, 0.0, 0.0, 0.0)
+
+ chain:add_effect(OverlayEffect.new(), input0.padding_effect, input1.padding_effect)
+ chain:finalize(hq)
+
+ return {
+ chain = chain,
+ input0 = input0,
+ input1 = input1
+ }
+end
+
+
+-- Make all possible combinations of side-by-side chains.
+local sbs_chains = make_cartesian_product({
+ {"live", "livedeint"}, -- input0_type
+ {true, false}, -- input0_overlay
+ {"live", "livedeint"}, -- input1_type
+ {true, false} -- hq
+}, function(input0_type, input0_overlay, input1_type, hq)
+ return make_sbs_chain(input0_type, input0_overlay, input1_type, hq)
+end)
+
-- A chain to show a single input on screen.
function make_simple_chain(input_deint, input_scale, has_overlay, hq)
local chain = EffectChain.new(16, 9)
-- 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 NUM_CAMERAS + 2 -- static picture and overlay
+ return NUM_CAMERAS + 3 -- sbs, static picture and overlay
end
function is_plain_signal(num)
elseif signal_num == INPUT3_SIGNAL_NUM then
return "Goal R (" .. get_channel_resolution(signal_num) .. ")"
elseif signal_num == INPUT4_SIGNAL_NUM then
- return "Ambience (" .. get_channel_resolution(signal_num) .. ")"
+ return "Commentators (" .. get_channel_resolution(signal_num) .. ")"
+ elseif signal_num == SBS_SIGNAL_NUM then
+ return "Side-by-side"
elseif signal_num == STATIC_SIGNAL_NUM then
return "Static picture"
elseif signal_num == OVERLAY_SIGNAL_NUM then
return {"Cut", "", "Fade"}
end
+ -- Various zooms.
+ if live_signal_num == SBS_SIGNAL_NUM and is_plain_signal(preview_signal_num) then
+ return {"Cut", "Zoom in"}
+ elseif is_plain_signal(live_signal_num) and preview_signal_num == SBS_SIGNAL_NUM then
+ return {"Cut", "Zoom out"}
+ end
+
return {"Cut"}
end
swap_preview_live()
return
end
+
+ if (live_signal_num == SBS_SIGNAL_NUM and is_plain_signal(preview_signal_num)) or
+ (preview_signal_num == SBS_SIGNAL_NUM and is_plain_signal(live_signal_num)) then
+ start_transition(ZOOM_TRANSITION, t, 1.0)
+ end
elseif num == 2 then
finish_transitions(t)
return chain.chain, prepare
end
+-- SBS code (live_signal_num == SBS_SIGNAL_NUM, or in a transition to/from it).
+function get_sbs_chain(signals, t, width, height, input_resolution)
+ local input0_type = get_input_type(signals, INPUT0_SIGNAL_NUM)
+ local input1_type = get_input_type(signals, INPUT1_SIGNAL_NUM)
+ return sbs_chains[input0_type][false][input1_type][true] -- FIXME: overlay is always false?
+end
+
-- API ENTRY POINT
-- Called every frame. Get the chain for displaying at input <num>,
-- where 0 is live, 1 is preview, 2 is the first channel to display
if num == 0 then -- Live.
-- See if we're in a transition.
finish_transitions(t)
- if transition_type == FADE_TRANSITION then
+ if transition_type == ZOOM_TRANSITION then
+ -- Transition in or out of SBS.
+ local chain = get_sbs_chain(signals, t, width, height, input_resolution)
+ prepare = function()
+ prepare_sbs_chain(chain, calc_zoom_progress(t), transition_type, transition_src_signal, transition_dst_signal, width, height, input_resolution)
+ end
+ return chain.chain, prepare
+ elseif transition_type == NO_TRANSITION and live_signal_num == SBS_SIGNAL_NUM then
+ -- Static SBS view.
+ local chain = get_sbs_chain(signals, t, width, height, input_resolution)
+ prepare = function()
+ prepare_sbs_chain(chain, 0.0, NO_TRANSITION, 0, SBS_SIGNAL_NUM, width, height, input_resolution)
+ end
+ return chain.chain, prepare
+ elseif transition_type == FADE_TRANSITION then
return get_fade_chain(signals, t, width, height, input_resolution)
elseif is_plain_signal(live_signal_num) then
local input_type = get_input_type(signals, live_signal_num)
end
return chain.chain, prepare
end
+ if num == SBS_SIGNAL_NUM + 2 then
+ local input0_type = get_input_type(signals, INPUT0_SIGNAL_NUM)
+ local input1_type = get_input_type(signals, INPUT1_SIGNAL_NUM)
+ local chain = sbs_chains[input0_type][show_overlay][input1_type][false]
+ prepare = function()
+ prepare_sbs_chain(chain, 0.0, NO_TRANSITION, 0, SBS_SIGNAL_NUM, width, height, input_resolution)
+ end
+ return chain.chain, prepare
+ end
if num == STATIC_SIGNAL_NUM + 2 then
local chain = static_chains[false]
prepare = function()
return math.floor(x + 0.5)
end
+function lerp(a, b, t)
+ return a + (b - a) * t
+end
+
+function lerp_pos(a, b, t)
+ return {
+ x0 = lerp(a.x0, b.x0, t),
+ y0 = lerp(a.y0, b.y0, t),
+ x1 = lerp(a.x1, b.x1, t),
+ y1 = lerp(a.y1, b.y1, t)
+ }
+end
+
+function pos_from_top_left(x, y, width, height, screen_width, screen_height)
+ local xs = screen_width / 1280.0
+ local ys = screen_height / 720.0
+ return {
+ x0 = round(xs * x),
+ y0 = round(ys * y),
+ x1 = round(xs * (x + width)),
+ y1 = round(ys * (y + height))
+ }
+end
+
+function prepare_sbs_chain(chain, t, transition_type, src_signal, dst_signal, screen_width, screen_height, input_resolution)
+ chain.input0.input:connect_signal(0)
+ chain.input1.input:connect_signal(1)
+ set_neutral_color(chain.input0.wb_effect, neutral_colors[1])
+ set_neutral_color(chain.input1.wb_effect, neutral_colors[2])
+
+ -- First input is positioned (16,48) from top-left.
+ -- Second input is positioned (16,48) from the bottom-right.
+ local pos0 = pos_from_top_left(16, 48, 848, 477, screen_width, screen_height)
+ local pos1 = pos_from_top_left(1280 - 384 - 16, 720 - 216 - 48, 384, 216, screen_width, screen_height)
+
+ local pos_fs = { x0 = 0, y0 = 0, x1 = screen_width, y1 = screen_height }
+ local affine_param
+ if transition_type == NO_TRANSITION then
+ -- Static SBS view.
+ affine_param = { sx = 1.0, sy = 1.0, tx = 0.0, ty = 0.0 } -- Identity.
+ else
+ -- Zooming to/from SBS view into or out of a single view.
+ assert(transition_type == ZOOM_TRANSITION)
+ local signal, real_t
+ if src_signal == SBS_SIGNAL_NUM then
+ signal = dst_signal
+ real_t = t
+ else
+ assert(dst_signal == SBS_SIGNAL_NUM)
+ signal = src_signal
+ real_t = 1.0 - t
+ end
+
+ if signal == INPUT0_SIGNAL_NUM then
+ affine_param = find_affine_param(pos0, lerp_pos(pos0, pos_fs, real_t))
+ elseif signal == INPUT1_SIGNAL_NUM then
+ affine_param = find_affine_param(pos1, lerp_pos(pos1, pos_fs, real_t))
+ end
+ end
+
+ -- NOTE: input_resolution is not 1-indexed, unlike usual Lua arrays.
+ place_rectangle_with_affine(chain.input0.resample_effect, chain.input0.resize_effect, chain.input0.padding_effect, pos0, affine_param, screen_width, screen_height, input_resolution[0].width, input_resolution[0].height)
+ place_rectangle_with_affine(chain.input1.resample_effect, chain.input1.resize_effect, chain.input1.padding_effect, pos1, affine_param, screen_width, screen_height, input_resolution[1].width, input_resolution[1].height)
+end
+
+-- Find the transformation that changes the first rectangle to the second one.
+function find_affine_param(a, b)
+ local sx = (b.x1 - b.x0) / (a.x1 - a.x0)
+ local sy = (b.y1 - b.y0) / (a.y1 - a.y0)
+ return {
+ sx = sx,
+ sy = sy,
+ tx = b.x0 - a.x0 * sx,
+ ty = b.y0 - a.y0 * sy
+ }
+end
+
+function place_rectangle_with_affine(resample_effect, resize_effect, padding_effect, pos, aff, screen_width, screen_height, input_width, input_height)
+ local x0 = pos.x0 * aff.sx + aff.tx
+ local x1 = pos.x1 * aff.sx + aff.tx
+ local y0 = pos.y0 * aff.sy + aff.ty
+ local y1 = pos.y1 * aff.sy + aff.ty
+
+ place_rectangle(resample_effect, resize_effect, padding_effect, x0, y0, x1, y1, screen_width, screen_height, input_width, input_height)
+end
+
+function place_rectangle(resample_effect, resize_effect, padding_effect, x0, y0, x1, y1, screen_width, screen_height, input_width, input_height)
+ local srcx0 = 0.0
+ local srcx1 = 1.0
+ local srcy0 = 0.0
+ local srcy1 = 1.0
+
+ padding_effect:set_int("width", screen_width)
+ padding_effect:set_int("height", screen_height)
+
+ -- Cull.
+ if x0 > screen_width or x1 < 0.0 or y0 > screen_height or y1 < 0.0 then
+ if resample_effect ~= nil then
+ resample_effect:set_int("width", 1)
+ resample_effect:set_int("height", 1)
+ resample_effect:set_float("zoom_x", screen_width)
+ resample_effect:set_float("zoom_y", screen_height)
+ else
+ resize_effect:set_int("width", 1)
+ resize_effect:set_int("height", 1)
+ end
+ padding_effect:set_int("left", screen_width + 100)
+ padding_effect:set_int("top", screen_height + 100)
+ return
+ end
+
+ -- Clip.
+ if x0 < 0 then
+ srcx0 = -x0 / (x1 - x0)
+ x0 = 0
+ end
+ if y0 < 0 then
+ srcy0 = -y0 / (y1 - y0)
+ y0 = 0
+ end
+ if x1 > screen_width then
+ srcx1 = (screen_width - x0) / (x1 - x0)
+ x1 = screen_width
+ end
+ if y1 > screen_height then
+ srcy1 = (screen_height - y0) / (y1 - y0)
+ y1 = screen_height
+ end
+
+ if resample_effect ~= nil then
+ -- High-quality resampling.
+ local x_subpixel_offset = x0 - math.floor(x0)
+ local y_subpixel_offset = y0 - math.floor(y0)
+
+ -- Resampling must be to an integral number of pixels. Round up,
+ -- and then add an extra pixel so we have some leeway for the border.
+ local width = math.ceil(x1 - x0) + 1
+ local height = math.ceil(y1 - y0) + 1
+ resample_effect:set_int("width", width)
+ resample_effect:set_int("height", height)
+
+ -- Correct the discrepancy with zoom. (This will leave a small
+ -- excess edge of pixels and subpixels, which we'll correct for soon.)
+ local zoom_x = (x1 - x0) / (width * (srcx1 - srcx0))
+ local zoom_y = (y1 - y0) / (height * (srcy1 - srcy0))
+ resample_effect:set_float("zoom_x", zoom_x)
+ resample_effect:set_float("zoom_y", zoom_y)
+ resample_effect:set_float("zoom_center_x", 0.0)
+ resample_effect:set_float("zoom_center_y", 0.0)
+
+ -- Padding must also be to a whole-pixel offset.
+ padding_effect:set_int("left", math.floor(x0))
+ padding_effect:set_int("top", math.floor(y0))
+
+ -- Correct _that_ discrepancy by subpixel offset in the resampling.
+ resample_effect:set_float("left", srcx0 * input_width - x_subpixel_offset / zoom_x)
+ resample_effect:set_float("top", srcy0 * input_height - y_subpixel_offset / zoom_y)
+
+ -- Finally, adjust the border so it is exactly where we want it.
+ padding_effect:set_float("border_offset_left", x_subpixel_offset)
+ padding_effect:set_float("border_offset_right", x1 - (math.floor(x0) + width))
+ padding_effect:set_float("border_offset_top", y_subpixel_offset)
+ padding_effect:set_float("border_offset_bottom", y1 - (math.floor(y0) + height))
+ else
+ -- Lower-quality simple resizing.
+ local width = round(x1 - x0)
+ local height = round(y1 - y0)
+ resize_effect:set_int("width", width)
+ resize_effect:set_int("height", height)
+
+ -- Padding must also be to a whole-pixel offset.
+ padding_effect:set_int("left", math.floor(x0))
+ padding_effect:set_int("top", math.floor(y0))
+ end
+end
+
function prepare_overlay_live(chain, t)
if chain.overlay then
local tt = calc_fade_progress(t, overlay_transition_start, overlay_transition_end)
projects / ultimatescore / commitdiff