case IDENTITY_EFFECT:
return new IdentityEffect;
case WHITE_BALANCE_EFFECT:
+ case AUTO_WHITE_BALANCE_EFFECT:
return new WhiteBalanceEffect;
case RESAMPLE_EFFECT:
return new ResampleEffect;
return 1;
}
+int InputStateInfo_get_frame_height(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));
+ unsigned height = input_state_info->last_height[signal_num];
+ if (input_state_info->last_interlaced[signal_num]) {
+ height *= 2;
+ }
+ lua_pushnumber(L, height);
+ return 1;
+}
+
int InputStateInfo_get_interlaced(lua_State* L)
{
assert(lua_gettop(L) == 2);
return 1;
}
+namespace {
+
+// Helper function to write e.g. “60” or “59.94”.
+string format_frame_rate(int nom, int den)
+{
+ char buf[256];
+ if (nom % den == 0) {
+ snprintf(buf, sizeof(buf), "%d", nom / den);
+ } else {
+ snprintf(buf, sizeof(buf), "%.2f", double(nom) / den);
+ }
+ return buf;
+}
+
+// Helper function to write e.g. “720p60”.
+string get_human_readable_resolution(const InputStateInfo *input_state_info, int signal_num)
+{
+ char buf[256];
+ if (input_state_info->last_interlaced[signal_num]) {
+ snprintf(buf, sizeof(buf), "%di", input_state_info->last_height[signal_num] * 2);
+
+ // Show field rate instead of frame rate; really for cosmetics only
+ // (and actually contrary to EBU recommendations, although in line
+ // with typical user expectations).
+ return buf + format_frame_rate(input_state_info->last_frame_rate_nom[signal_num] * 2,
+ input_state_info->last_frame_rate_den[signal_num]);
+ } else {
+ snprintf(buf, sizeof(buf), "%dp", input_state_info->last_height[signal_num]);
+ return buf + format_frame_rate(input_state_info->last_frame_rate_nom[signal_num],
+ input_state_info->last_frame_rate_den[signal_num]);
+ }
+}
+
+} // namespace
+
+int InputStateInfo_get_human_readable_resolution(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));
+
+ string str;
+ if (!input_state_info->last_is_connected[signal_num]) {
+ str = "disconnected";
+ } else if (input_state_info->last_height[signal_num] <= 0) {
+ str = "no signal";
+ } else if (!input_state_info->last_has_signal[signal_num]) {
+ if (input_state_info->last_height[signal_num] == 525) {
+ // Special mode for the USB3 cards.
+ str = "no signal";
+ } else {
+ str = get_human_readable_resolution(input_state_info, signal_num) + ", no signal";
+ }
+ } else {
+ str = get_human_readable_resolution(input_state_info, signal_num);
+ }
+
+ lua_pushstring(L, str.c_str());
+ return 1;
+}
+
+
int EffectBlueprint_set_int(lua_State *L)
{
assert(lua_gettop(L) == 3);
{ "new", Scene_new },
{ "__gc", Scene_gc },
{ "add_input", Scene::add_input },
+ { "add_auto_white_balance", Scene::add_auto_white_balance },
{ "add_effect", Scene::add_effect },
{ "add_optional_effect", Scene::add_optional_effect },
{ "finalize", Scene::finalize },
{ "enable", Block_enable },
{ "enable_if", Block_enable_if },
{ "disable", Block_disable },
+ { "always_disable_if_disabled", Block_always_disable_if_disabled },
+ { "promise_to_disable_if_enabled", Block_promise_to_disable_if_enabled },
{ "set_int", Block_set_int },
{ "set_float", Block_set_float },
{ "set_vec3", Block_set_vec3 },
const luaL_Reg InputStateInfo_funcs[] = {
{ "get_width", InputStateInfo_get_width },
{ "get_height", InputStateInfo_get_height },
+ { "get_frame_width", InputStateInfo_get_width }, // Same as get_width().
+ { "get_frame_height", InputStateInfo_get_frame_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 },
{ "get_last_subtitle", InputStateInfo_get_last_subtitle },
+ { "get_human_readable_resolution", InputStateInfo_get_human_readable_resolution },
{ NULL, NULL }
};
if (lua_pcall(L, 0, 1, 0) != 0) {
fprintf(stderr, "error running function `num_channels': %s\n", lua_tostring(L, -1));
+ fprintf(stderr, "Try Nageru.set_num_channels(...) at the start of the script instead.\n");
abort();
}
} // namespace
+int Nageru_set_channel_name(lua_State *L)
+{
+ // NOTE: m is already locked.
+ Theme *theme = get_theme_updata(L);
+ unsigned channel = luaL_checknumber(L, 1);
+ const string text = checkstdstring(L, 2);
+ theme->channel_names[channel] = text;
+ lua_pop(L, 2);
+ return 0;
+}
+
+int Nageru_set_num_channels(lua_State *L)
+{
+ // NOTE: m is already locked.
+ Theme *theme = get_theme_updata(L);
+ if (theme->startup_finished) {
+ luaL_error(L, "set_num_channels() can only be called at startup.");
+ }
+ theme->num_channels = luaL_checknumber(L, 1);
+ lua_pop(L, 1);
+ return 0;
+}
+
+int Nageru_set_channel_signal(lua_State *L)
+{
+ // NOTE: m is already locked.
+ Theme *theme = get_theme_updata(L);
+ if (theme->startup_finished) {
+ luaL_error(L, "set_channel_signal() can only be called at startup.");
+ }
+ unsigned channel = luaL_checknumber(L, 1);
+ int signal = luaL_checknumber(L, 2);
+ theme->channel_signals[channel] = signal;
+ lua_pop(L, 2);
+ return 0;
+}
+
+int Nageru_set_supports_wb(lua_State *L)
+{
+ // NOTE: m is already locked.
+ Theme *theme = get_theme_updata(L);
+ if (theme->startup_finished) {
+ luaL_error(L, "set_supports_wb() can only be called at startup.");
+ }
+ unsigned channel = luaL_checknumber(L, 1);
+ bool supports_wb = checkbool(L, 2);
+ theme->channel_supports_wb[channel] = supports_wb;
+ lua_pop(L, 2);
+ return 0;
+}
+
Theme::Theme(const string &filename, const vector<string> &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)
{
+ // Defaults.
+ channel_names[0] = "Live";
+ channel_names[1] = "Preview";
+
L = luaL_newstate();
luaL_openlibs(L);
}
// Set up the API we provide.
- register_constants();
+ register_globals();
register_class("Scene", Scene_funcs);
register_class("Block", Block_funcs);
register_class("EffectBlueprint", EffectBlueprint_funcs);
}
assert(lua_gettop(L) == 0);
- // Ask it for the number of channels.
- num_channels = call_num_channels(L);
+ if (num_channels == -1) {
+ // Ask it for the number of channels.
+ num_channels = call_num_channels(L);
+ }
+ startup_finished = true;
}
Theme::~Theme()
{
+ theme_menu.reset();
lua_close(L);
}
-void Theme::register_constants()
+void Theme::register_globals()
{
// Set Nageru.VIDEO_FORMAT_BGRA = bmusb::PixelFormat_8BitBGRA, etc.
const vector<pair<string, int>> num_constants = {
{ "VIDEO_FORMAT_BGRA", bmusb::PixelFormat_8BitBGRA },
{ "VIDEO_FORMAT_YCBCR", bmusb::PixelFormat_8BitYCbCrPlanar },
+ { "CHECKABLE", MenuEntry::CHECKABLE },
+ { "CHECKED", MenuEntry::CHECKED },
};
const vector<pair<string, string>> str_constants = {
{ "THEME_PATH", theme_path },
lua_settable(L, 1); // t[key] = value
}
+ const luaL_Reg Nageru_funcs[] = {
+ { "set_channel_name", Nageru_set_channel_name },
+ { "set_num_channels", Nageru_set_num_channels },
+ { "set_channel_signal", Nageru_set_channel_signal },
+ { "set_supports_wb", Nageru_set_supports_wb },
+ { NULL, NULL }
+ };
+ lua_pushlightuserdata(L, this);
+ luaL_setfuncs(L, Nageru_funcs, 1); // for (name,f in funcs) { mt[name] = f, with upvalue {theme} }
+
lua_setglobal(L, "Nageru"); // Nageru = t
assert(lua_gettop(L) == 0);
}
string Theme::get_channel_name(unsigned channel)
{
lock_guard<mutex> lock(m);
+
+ // We never ask the legacy channel_name() about live and preview.
+ // The defaults are set in our constructor.
+ if (channel == 0 || channel == 1) {
+ return channel_names[channel];
+ }
+
lua_getglobal(L, "channel_name");
+ if (lua_isnil(L, -1)) {
+ lua_pop(L, 1);
+ if (channel_names.count(channel)) {
+ return channel_names[channel];
+ } else {
+ return "(no title)";
+ }
+ }
+
lua_pushnumber(L, channel);
if (lua_pcall(L, 1, 1, 0) != 0) {
fprintf(stderr, "error running function `channel_name': %s\n", lua_tostring(L, -1));
const char *ret = lua_tostring(L, -1);
if (ret == nullptr) {
fprintf(stderr, "function `channel_name' returned nil for channel %d\n", channel);
+ fprintf(stderr, "Try Nageru.set_channel_name(channel, name) at the start of the script instead.\n");
abort();
}
{
lock_guard<mutex> lock(m);
lua_getglobal(L, "channel_signal");
+ if (lua_isnil(L, -1)) {
+ lua_pop(L, 1);
+ if (channel_signals.count(channel)) {
+ return channel_signals[channel];
+ } else {
+ return -1;
+ }
+ }
+
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));
+ fprintf(stderr, "Try Nageru.set_channel_signal(channel, signal) at the start of the script instead.\n");
abort();
}
{
lock_guard<mutex> lock(m);
lua_getglobal(L, "supports_set_wb");
+ if (lua_isnil(L, -1)) {
+ lua_pop(L, 1);
+ if (channel_supports_wb.count(channel)) {
+ return channel_supports_wb[channel];
+ } else {
+ return false;
+ }
+ }
+
lua_pushnumber(L, channel);
if (lua_pcall(L, 1, 1, 0) != 0) {
fprintf(stderr, "error running function `supports_set_wb': %s\n", lua_tostring(L, -1));
+ fprintf(stderr, "Try Nageru.set_supports_wb(channel, bool) at the start of the script instead.\n");
abort();
}
return ret;
}
-void Theme::set_wb(unsigned channel, double r, double g, double b)
+void Theme::set_wb(unsigned channel, float r, float g, float b)
+{
+ int signal = get_channel_signal(channel);
+
+ lock_guard<mutex> lock(m);
+ if (signal != -1) {
+ white_balance_for_signal[signal] = 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)
{
lock_guard<mutex> lock(m);
+ white_balance_for_signal[signal] = RGBTriplet{ r, g, b };
+
+ for (const auto &channel_and_signal : channel_signals) {
+ if (channel_and_signal.second == signal) {
+ call_lua_wb_callback(channel_and_signal.first, r, g, b);
+ }
+ }
+}
+
+void Theme::call_lua_wb_callback(unsigned channel, float r, float g, float b)
+{
lua_getglobal(L, "set_wb");
+ if (lua_isnil(L, -1)) {
+ // The function doesn't exist, to just ignore. We've stored the white balance,
+ // and most likely, it will be picked up by auto white balance instead.
+ lua_pop(L, 1);
+ return;
+ }
lua_pushnumber(L, channel);
lua_pushnumber(L, r);
lua_pushnumber(L, g);
assert(lua_gettop(L) == 0);
}
+RGBTriplet Theme::get_white_balance_for_signal(int signal)
+{
+ if (white_balance_for_signal.count(signal)) {
+ return white_balance_for_signal[signal];
+ } else {
+ return RGBTriplet{ 1.0, 1.0, 1.0 };
+ }
+}
+
vector<string> Theme::get_transition_names(float t)
{
lock_guard<mutex> lock(m);
assert(lua_gettop(L) == 0);
}
-int Theme::set_theme_menu(lua_State *L)
+template <class T>
+void destroy(T &ref)
{
- for (const Theme::MenuEntry &entry : theme_menu) {
- luaL_unref(L, LUA_REGISTRYINDEX, entry.lua_ref);
+ ref.~T();
+}
+
+Theme::MenuEntry::~MenuEntry()
+{
+ if (is_submenu) {
+ destroy(submenu);
+ } else {
+ luaL_unref(entry.L, LUA_REGISTRYINDEX, entry.lua_ref);
}
- theme_menu.clear();
+}
- int num_elements = lua_gettop(L);
- for (int i = 1; i <= num_elements; ++i) {
- lua_rawgeti(L, i, 1);
- const string text = checkstdstring(L, -1);
+namespace {
+
+vector<unique_ptr<Theme::MenuEntry>> create_recursive_theme_menu(lua_State *L);
+
+unique_ptr<Theme::MenuEntry> create_theme_menu_entry(lua_State *L, int index)
+{
+ unique_ptr<Theme::MenuEntry> entry;
+
+ lua_rawgeti(L, index, 1);
+ const string text = checkstdstring(L, -1);
+ lua_pop(L, 1);
+
+ unsigned flags = 0;
+ if (lua_objlen(L, -1) > 2) {
+ lua_rawgeti(L, -1, 3);
+ flags = luaL_checknumber(L, -1);
lua_pop(L, 1);
+ }
- lua_rawgeti(L, i, 2);
+ lua_rawgeti(L, index, 2);
+ if (lua_istable(L, -1)) {
+ vector<unique_ptr<Theme::MenuEntry>> submenu = create_recursive_theme_menu(L);
+ entry.reset(new Theme::MenuEntry{ text, move(submenu) });
+ lua_pop(L, 1);
+ } else {
luaL_checktype(L, -1, LUA_TFUNCTION);
int ref = luaL_ref(L, LUA_REGISTRYINDEX);
+ entry.reset(new Theme::MenuEntry{ text, L, ref, flags });
+ }
+ return entry;
+}
- theme_menu.push_back(MenuEntry{ text, ref });
+vector<unique_ptr<Theme::MenuEntry>> create_recursive_theme_menu(lua_State *L)
+{
+ vector<unique_ptr<Theme::MenuEntry>> menu;
+ size_t num_elements = lua_objlen(L, -1);
+ for (size_t i = 1; i <= num_elements; ++i) {
+ lua_rawgeti(L, -1, i);
+ menu.emplace_back(create_theme_menu_entry(L, -1));
+ lua_pop(L, 1);
}
+ return menu;
+}
+
+} // namespace
+
+int Theme::set_theme_menu(lua_State *L)
+{
+ theme_menu.reset();
+
+ vector<unique_ptr<MenuEntry>> root_menu;
+ int num_elements = lua_gettop(L);
+ for (int i = 1; i <= num_elements; ++i) {
+ root_menu.emplace_back(create_theme_menu_entry(L, i));
+ }
+ theme_menu.reset(new MenuEntry("", move(root_menu)));
+
lua_pop(L, num_elements);
assert(lua_gettop(L) == 0);
abort();
}
}
+
+string Theme::format_status_line(const string &disk_space_left_text, double file_length_seconds)
+{
+ lock_guard<mutex> lock(m);
+ lua_getglobal(L, "format_status_line");
+ if (lua_isnil(L, -1)) {
+ lua_pop(L, 1);
+ return disk_space_left_text;
+ }
+
+ lua_pushstring(L, disk_space_left_text.c_str());
+ lua_pushnumber(L, file_length_seconds);
+ if (lua_pcall(L, 2, 1, 0) != 0) {
+ fprintf(stderr, "error running function format_status_line(): %s\n", lua_tostring(L, -1));
+ abort();
+ }
+ string text = checkstdstring(L, 1);
+ lua_pop(L, 1);
+ assert(lua_gettop(L) == 0);
+ return text;
+}