on my Thinkpad X240[1]); almost all pixel processing is done on the GPU.
- High output quality; Lanczos3 scaling, subpixel precision everywhere,
- white balance adjustment (*), mix of 16- and 32-bit floating point
+ white balance adjustment, mix of 16- and 32-bit floating point
for intermediate calculations, dithered output.
- Proper sound support: Syncing of multiple unrelated sources through
mainWindow.resize(QSize(1500, 685));
mainWindow.show();
+ app.installEventFilter(&mainWindow); // For white balance color picking.
+
int rc = app.exec();
global_mixer->quit();
delete global_mixer;
Ui::Display *ui_display = new Ui::Display;
ui_display->setupUi(preview);
ui_display->label->setText(mixer->get_channel_name(output).c_str());
- ui_display->wb_button->setVisible(mixer->get_supports_set_wb(output));
ui_display->display->set_output(output);
ui->preview_displays->insertWidget(previews.size(), preview, 1);
previews.push_back(ui_display);
// Hook up the keyboard key.
QShortcut *shortcut = new QShortcut(QKeySequence(Qt::Key_1 + i), this);
connect(shortcut, &QShortcut::activated, std::bind(&MainWindow::channel_clicked, this, i));
+
+ // Hook up the white balance button (irrelevant if invisible).
+ ui_display->wb_button->setVisible(mixer->get_supports_set_wb(output));
+ connect(ui_display->wb_button, &QPushButton::clicked, std::bind(&MainWindow::wb_button_clicked, this, i));
}
mixer->set_audio_level_callback([this](float level_lufs, float peak_db, float global_level_lufs, float range_low_lufs, float range_high_lufs){
void MainWindow::channel_clicked(int channel_number)
{
- global_mixer->channel_clicked(channel_number);
+ if (current_wb_pick_display == channel_number) {
+ // The picking was already done from eventFilter(), since we don't get
+ // the mouse pointer here.
+ } else {
+ global_mixer->channel_clicked(channel_number);
+ }
+}
+
+void MainWindow::wb_button_clicked(int channel_number)
+{
+ current_wb_pick_display = channel_number;
+ QApplication::setOverrideCursor(Qt::CrossCursor);
+}
+
+bool MainWindow::eventFilter(QObject *watched, QEvent *event)
+{
+ if (current_wb_pick_display != -1 &&
+ event->type() == QEvent::MouseButtonRelease &&
+ watched->isWidgetType()) {
+ QApplication::restoreOverrideCursor();
+ if (watched == previews[current_wb_pick_display]->display) {
+ const QMouseEvent *mouse_event = (QMouseEvent *)event;
+ set_white_balance(current_wb_pick_display, mouse_event->x(), mouse_event->y());
+ } else {
+ // The user clicked on something else, give up.
+ // (The click goes through, which might not be ideal, but, yes.)
+ current_wb_pick_display = -1;
+ }
+ }
+ return false;
+}
+
+namespace {
+
+double srgb_to_linear(double x)
+{
+ if (x < 0.04045) {
+ return x / 12.92;
+ } else {
+ return pow((x + 0.055) / 1.055, 2.4);
+ }
+}
+
+} // namespace
+
+void MainWindow::set_white_balance(int channel_number, int x, int y)
+{
+ // FIXME: This is wrong. We should really reset the white balance and then
+ // re-render, but renderToPixmap() crashes for me.
+ QRgb reference_color = previews[channel_number]->display->grabFrameBuffer().pixel(x, y);
+ double r = srgb_to_linear(qRed(reference_color) / 255.0);
+ double g = srgb_to_linear(qGreen(reference_color) / 255.0);
+ double b = srgb_to_linear(qBlue(reference_color) / 255.0);
+ global_mixer->set_wb(Mixer::OUTPUT_INPUT0 + channel_number, r, g, b);
}
public slots:
void transition_clicked(int transition_number);
void channel_clicked(int channel_number);
+ void wb_button_clicked(int channel_number);
void set_transition_names(std::vector<std::string> transition_names);
void relayout();
private:
+ bool eventFilter(QObject *watched, QEvent *event) override;
+ void set_white_balance(int channel_number, int x, int y);
+
Ui::MainWindow *ui;
QPushButton *transition_btn1, *transition_btn2, *transition_btn3;
std::vector<Ui::Display *> previews;
+ int current_wb_pick_display = -1;
};
extern MainWindow *global_mainwindow;
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);
+ }
+
private:
void bm_frame(unsigned card_index, uint16_t timecode,
FrameAllocator::Frame video_frame, size_t video_offset, uint16_t video_format,
return 0;
}
+int Effect_set_vec3(lua_State *L)
+{
+ assert(lua_gettop(L) == 5);
+ Effect *effect = (Effect *)get_effect(L, 1);
+ size_t len;
+ const char* cstr = lua_tolstring(L, 2, &len);
+ std::string key(cstr, len);
+ float v[3];
+ v[0] = luaL_checknumber(L, 3);
+ v[1] = luaL_checknumber(L, 4);
+ v[2] = luaL_checknumber(L, 5);
+ if (!effect->set_vec3(key, v)) {
+ luaL_error(L, "Effect refused set_vec3(\"%s\", %f, %f, %f) (invalid key?)", cstr,
+ v[0], v[1], v[2]);
+ }
+ return 0;
+}
+
int Effect_set_vec4(lua_State *L)
{
assert(lua_gettop(L) == 6);
{ "new", WhiteBalanceEffect_new },
{ "set_float", Effect_set_float },
{ "set_int", Effect_set_int },
+ { "set_vec3", Effect_set_vec3 },
{ "set_vec4", Effect_set_vec4 },
{ NULL, NULL }
};
{ "new", ResampleEffect_new },
{ "set_float", Effect_set_float },
{ "set_int", Effect_set_int },
+ { "set_vec3", Effect_set_vec3 },
{ "set_vec4", Effect_set_vec4 },
{ NULL, NULL }
};
{ "new", PaddingEffect_new },
{ "set_float", Effect_set_float },
{ "set_int", Effect_set_int },
+ { "set_vec3", Effect_set_vec3 },
{ "set_vec4", Effect_set_vec4 },
{ NULL, NULL }
};
{ "new", IntegralPaddingEffect_new },
{ "set_float", Effect_set_float },
{ "set_int", Effect_set_int },
+ { "set_vec3", Effect_set_vec3 },
{ "set_vec4", Effect_set_vec4 },
{ NULL, NULL }
};
{ "new", OverlayEffect_new },
{ "set_float", Effect_set_float },
{ "set_int", Effect_set_int },
+ { "set_vec3", Effect_set_vec3 },
{ "set_vec4", Effect_set_vec4 },
{ NULL, NULL }
};
{ "new", ResizeEffect_new },
{ "set_float", Effect_set_float },
{ "set_int", Effect_set_int },
+ { "set_vec3", Effect_set_vec3 },
{ "set_vec4", Effect_set_vec4 },
{ NULL, NULL }
};
{ "new", MixEffect_new },
{ "set_float", Effect_set_float },
{ "set_int", Effect_set_int },
+ { "set_vec3", Effect_set_vec3 },
{ "set_vec4", Effect_set_vec4 },
{ NULL, NULL }
};
return ret;
}
+void Theme::set_wb(unsigned channel, double r, double g, double b)
+{
+ unique_lock<mutex> lock(m);
+ lua_getglobal(L, "set_wb");
+ lua_pushnumber(L, channel);
+ lua_pushnumber(L, r);
+ lua_pushnumber(L, g);
+ lua_pushnumber(L, b);
+ if (lua_pcall(L, 4, 0, 0) != 0) {
+ fprintf(stderr, "error running function `set_wb': %s\n", lua_tostring(L, -1));
+ exit(1);
+ }
+
+ assert(lua_gettop(L) == 0);
+}
+
std::vector<std::string> Theme::get_transition_names(float t)
{
unique_lock<mutex> lock(m);
int get_num_channels() { return num_channels; }
std::string get_channel_name(unsigned channel);
bool get_supports_set_wb(unsigned channel);
+ void set_wb(unsigned channel, double r, double g, double b);
std::vector<std::string> get_transition_names(float t);
local fade_src = 0.0
local fade_dst = 1.0
+local input0_neutral_color = {0.5, 0.5, 0.5}
+local input1_neutral_color = {0.5, 0.5, 0.5}
+
local live_signal_num = 0
local preview_signal_num = 1
local chain = EffectChain.new(16, 9)
local input0 = chain:add_live_input(true)
input0:connect_signal(0)
+ local input0_wb_effect = chain:add_effect(WhiteBalanceEffect.new())
local input1 = chain:add_live_input(true)
input1:connect_signal(1)
+ local input1_wb_effect = chain:add_effect(WhiteBalanceEffect.new())
local resample_effect = nil
local resize_effect = nil
if (hq) then
- resample_effect = chain:add_effect(ResampleEffect.new(), input0)
+ resample_effect = chain:add_effect(ResampleEffect.new(), input0_wb_effect)
else
- resize_effect = chain:add_effect(ResizeEffect.new(), input0)
+ resize_effect = chain:add_effect(ResizeEffect.new(), input0_wb_effect)
end
local padding_effect = chain:add_effect(IntegralPaddingEffect.new())
local resample2_effect = nil
local resize2_effect = nil
if (hq) then
- resample2_effect = chain:add_effect(ResampleEffect.new(), input1)
+ resample2_effect = chain:add_effect(ResampleEffect.new(), input1_wb_effect)
else
- resize2_effect = chain:add_effect(ResizeEffect.new(), input1)
+ resize2_effect = chain:add_effect(ResizeEffect.new(), input1_wb_effect)
end
- -- Effect *saturation_effect = chain->add_effect(new SaturationEffect())
- -- CHECK(saturation_effect->set_float("saturation", 0.3f))
- local wb_effect = chain:add_effect(WhiteBalanceEffect.new())
- wb_effect:set_float("output_color_temperature", 3500.0)
local padding2_effect = chain:add_effect(IntegralPaddingEffect.new())
chain:add_effect(OverlayEffect.new(), padding_effect, padding2_effect)
chain = chain,
input0 = {
input = input0,
+ white_balance_effect = input0_wb_effect,
resample_effect = resample_effect,
resize_effect = resize_effect,
padding_effect = padding_effect
},
input1 = {
input = input1,
+ white_balance_effect = input1_wb_effect,
resample_effect = resample2_effect,
resize_effect = resize2_effect,
padding_effect = padding2_effect
-- A chain to fade between two inputs (live chain only)
local fade_chain_hq = EffectChain.new(16, 9)
local fade_chain_hq_input0 = fade_chain_hq:add_live_input(true)
+local fade_chain_hq_wb0_effect = fade_chain_hq:add_effect(WhiteBalanceEffect.new())
local fade_chain_hq_input1 = fade_chain_hq:add_live_input(true)
+local fade_chain_hq_wb1_effect = fade_chain_hq:add_effect(WhiteBalanceEffect.new())
fade_chain_hq_input0:connect_signal(0)
fade_chain_hq_input1:connect_signal(1)
-local fade_chain_mix_effect = fade_chain_hq:add_effect(MixEffect.new(), fade_chain_hq_input0, fade_chain_hq_input1)
+local fade_chain_mix_effect = fade_chain_hq:add_effect(MixEffect.new(), fade_chain_hq_wb0_effect, fade_chain_hq_wb1_effect)
fade_chain_hq:finalize(true)
-- A chain to show a single input on screen (HQ version).
local simple_chain_hq = EffectChain.new(16, 9)
local simple_chain_hq_input = simple_chain_hq:add_live_input(true)
simple_chain_hq_input:connect_signal(0) -- First input card. Can be changed whenever you want.
+local simple_chain_hq_wb_effect = simple_chain_hq:add_effect(WhiteBalanceEffect.new())
simple_chain_hq:finalize(true)
-- A chain to show a single input on screen (LQ version).
local simple_chain_lq = EffectChain.new(16, 9)
local simple_chain_lq_input = simple_chain_lq:add_live_input(true)
simple_chain_lq_input:connect_signal(0) -- First input card. Can be changed whenever you want.
+local simple_chain_lq_wb_effect = simple_chain_lq:add_effect(WhiteBalanceEffect.new())
simple_chain_lq:finalize(false)
-- Returns the number of outputs in addition to the live (0) and preview (1).
return channel == 2 or channel == 3
end
+-- Gets called with a new gray point when the white balance is changing.
+-- The color is in linear light (not sRGB gamma).
+function set_wb(channel, red, green, blue)
+ if channel == 2 then
+ input0_neutral_color = { red, green, blue }
+ elseif channel == 3 then
+ input1_neutral_color = { red, green, blue }
+ end
+end
+
function finish_transitions(t)
-- If live is 2 (SBS) but de-facto single, make it so.
if live_signal_num == 2 and t >= transition_end and zoom_dst == 1.0 then
if live_signal_num == 0 or live_signal_num == 1 then -- Plain inputs.
prepare = function()
simple_chain_hq_input:connect_signal(live_signal_num)
+ if live_signal_num == 0 then
+ set_neutral_color(simple_chain_hq_wb_effect, input0_neutral_color)
+ else
+ set_neutral_color(simple_chain_hq_wb_effect, input1_neutral_color)
+ end
end
return simple_chain_hq, prepare
elseif live_signal_num == 3 then -- Fade.
prepare = function()
fade_chain_hq_input0:connect_signal(0)
+ set_neutral_color(fade_chain_hq_wb0_effect, input0_neutral_color)
fade_chain_hq_input1:connect_signal(1)
+ set_neutral_color(fade_chain_hq_wb1_effect, input1_neutral_color)
local tt = (t - transition_start) / (transition_end - transition_start)
if tt < 0.0 then
tt = 0.0
-- Special case: Show only the single image on screen.
prepare = function()
simple_chain_hq_input:connect_signal(0)
+ set_neutral_color(simple_chain_hq_wb_effect, input0_neutral_color)
end
return simple_chain_hq, prepare
end
if num == 2 then
prepare = function()
simple_chain_lq_input:connect_signal(0)
+ set_neutral_color(simple_chain_lq_wb_effect, input0_neutral_color)
end
return simple_chain_lq, prepare
end
if num == 3 then
prepare = function()
simple_chain_lq_input:connect_signal(1)
+ set_neutral_color(simple_chain_lq_wb_effect, input1_neutral_color)
end
return simple_chain_lq, prepare
end
function prepare_sbs_chain(chain, t, screen_width, screen_height)
chain.input0.input:connect_signal(0)
chain.input1.input:connect_signal(1)
+ set_neutral_color(chain.input0.white_balance_effect, input0_neutral_color)
+ set_neutral_color(chain.input1.white_balance_effect, input1_neutral_color)
-- First input is positioned (16,48) from top-left.
local width0 = round(848 * screen_width/1280.0)
place_rectangle(chain.input0.resample_effect, chain.input0.resize_effect, chain.input0.padding_effect, left0, top0, right0, bottom0, screen_width, screen_height, 1280, 720)
place_rectangle(chain.input1.resample_effect, chain.input1.resize_effect, chain.input1.padding_effect, left1, top1, right1, bottom1, screen_width, screen_height, 1280, 720)
end
+
+function set_neutral_color(effect, color)
+ effect:set_vec3("neutral_color", color[1], color[2], color[3])
+end
projects / nageru / commitdiff