X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=nageru%2Ftheme.h;h=8a0a92af7361d1cb50de5a1e9ee9f802f48c172c;hb=6e5ded9f44606841fb5e905394cca803c7d7abdf;hp=0a239953baebf515f99c9b831e75ccdf6fc1b822;hpb=9b7d691b4cc5db7dbfc18c82e86c1207fcac4722;p=nageru diff --git a/nageru/theme.h b/nageru/theme.h index 0a23995..8a0a92a 100644 --- a/nageru/theme.h +++ b/nageru/theme.h @@ -2,6 +2,7 @@ #define _THEME_H 1 #include +#include #include #include #include @@ -13,9 +14,11 @@ #include #include "bmusb/bmusb.h" +#include "defs.h" #include "ref_counted_frame.h" #include "tweaked_inputs.h" +class Scene; class CEFCapture; class FFmpegCapture; class LiveInputWrapper; @@ -27,9 +30,64 @@ class EffectChain; class ResourcePool; } // namespace movit +enum EffectType { + // LIVE_INPUT_* also covers CEF and video inputs. + LIVE_INPUT_YCBCR, + LIVE_INPUT_YCBCR_WITH_DEINTERLACE, + LIVE_INPUT_YCBCR_PLANAR, + LIVE_INPUT_BGRA, + IMAGE_INPUT, + + IDENTITY_EFFECT, + WHITE_BALANCE_EFFECT, + AUTO_WHITE_BALANCE_EFFECT, // Same as WHITE_BALANCE_EFFECT, but sets its value automatically. + RESAMPLE_EFFECT, + PADDING_EFFECT, + INTEGRAL_PADDING_EFFECT, + OVERLAY_EFFECT, + RESIZE_EFFECT, + MULTIPLY_EFFECT, + MIX_EFFECT, + LIFT_GAMMA_GAIN_EFFECT, + BLUR_EFFECT, + UNSHARP_MASK_EFFECT, + + NO_EFFECT_TYPE +}; + +// An EffectBlueprint refers to an Effect before it's being added to the graph. +// It contains enough information to instantiate the effect, including any +// parameters that were set before it was added to the graph. Once it is +// instantiated, it forwards its calls on to the real Effect instead. +struct EffectBlueprint { + EffectBlueprint(EffectType effect_type) : effect_type(effect_type) {} + + EffectType effect_type; + std::map int_parameters; + std::map float_parameters; + std::map> vec3_parameters; + std::map> vec4_parameters; + + movit::Effect *effect = nullptr; // Gets filled out when it's instantiated. +}; + +// Contains basically the same data as InputState, but does not hold on to +// a reference to the frames. This is important so that we can release them +// without having to wait for Lua's GC. +struct InputStateInfo { + explicit InputStateInfo(const InputState& input_state); + + 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]; + bmusb::PixelFormat last_pixel_format[MAX_VIDEO_CARDS]; + bool has_last_subtitle[MAX_VIDEO_CARDS]; + std::string last_subtitle[MAX_VIDEO_CARDS]; +}; + class Theme { public: - Theme(const std::string &filename, const std::vector &search_dirs, movit::ResourcePool *resource_pool, unsigned num_cards); + Theme(const std::string &filename, const std::vector &search_dirs, movit::ResourcePool *resource_pool); ~Theme(); struct Chain { @@ -41,17 +99,21 @@ public: std::vector input_frames; }; - Chain get_chain(unsigned num, float t, unsigned width, unsigned height, InputState input_state); + Chain get_chain(unsigned num, float t, unsigned width, unsigned height, const InputState &input_state); int get_num_channels() const { return num_channels; } - int map_signal(int signal_num); - void set_signal_mapping(int signal_num, int card_num); + int map_signal_to_card(int signal_num); + void set_signal_mapping(int signal_num, int card_idx); std::string get_channel_name(unsigned channel); - int get_channel_signal(unsigned channel); + int map_channel_to_signal(unsigned channel); bool get_supports_set_wb(unsigned channel); - void set_wb(unsigned channel, double r, double g, double b); + void set_wb(unsigned channel, float r, float g, float b); + void set_wb_for_card(int card_idx, float r, float g, float b); + movit::RGBTriplet get_white_balance_for_card(int card_idx); std::string get_channel_color(unsigned channel); + std::unordered_map white_balance_for_card; + std::vector get_transition_names(float t); void transition_clicked(int transition_num, float t); @@ -96,10 +158,31 @@ public: #endif struct MenuEntry { + MenuEntry(const std::string &text, lua_State *L, int lua_ref, unsigned flags) + : text(text), is_submenu(false), entry{L, lua_ref, flags} {} + MenuEntry(const std::string &text, std::vector> submenu) + : text(text), is_submenu(true), submenu(std::move(submenu)) {} + ~MenuEntry(); + + static constexpr unsigned CHECKABLE = 1; + static constexpr unsigned CHECKED = 2; + std::string text; - int lua_ref; + bool is_submenu; + + union { + // is_submenu = false. + struct { + lua_State *L; + int lua_ref; + unsigned flags; + } entry; + + // is_submenu = true. + std::vector> submenu; + }; }; - std::vector get_theme_menu() { return theme_menu; } // Can be empty for no menu. + MenuEntry *get_theme_menu() { return theme_menu.get(); } // Can be empty for no menu. void theme_menu_entry_clicked(int lua_ref); // Will be invoked every time the theme sets a new menu. @@ -109,10 +192,19 @@ public: theme_menu_callback = callback; } + std::string format_status_line(const std::string &disk_space_left_text, double file_length_seconds); + + // Signal that the given card is going away and will not be replaced + // with a fake capture card, so remove all connections to it so that + // they don't automatically come back on the next frame. + void remove_card(unsigned card_index); + private: - void register_constants(); - void register_class(const char *class_name, const luaL_Reg *funcs); + void register_globals(); + void register_class(const char *class_name, const luaL_Reg *funcs, EffectType effect_type = NO_EFFECT_TYPE); int set_theme_menu(lua_State *L); + Chain get_chain_from_effect_chain(movit::EffectChain *effect_chain, unsigned num, const InputState &input_state); + void call_lua_wb_callback(unsigned channel, float r, float g, float b); std::string theme_path; @@ -120,8 +212,8 @@ private: lua_State *L; // Protected by . const InputState *input_state = nullptr; // Protected by . Only set temporarily, during chain setup. movit::ResourcePool *resource_pool; - int num_channels; - unsigned num_cards; + int num_channels = -1; + bool startup_finished = false; std::mutex map_m; std::map signal_to_card_mapping; // Protected by . @@ -143,11 +235,20 @@ private: html_signal_connections; #endif - std::vector theme_menu; + std::unique_ptr theme_menu; std::function theme_menu_callback; + std::map channel_names; // Set using Nageru.set_channel_name(). Protected by . + std::map channel_signals; // Set using Nageru.set_channel_signal(). Protected by . + std::map channel_supports_wb; // Set using Nageru.set_supports_wb(). Protected by . + friend class LiveInputWrapper; + friend class Scene; friend int ThemeMenu_set(lua_State *L); + friend int Nageru_set_channel_name(lua_State *L); + friend int Nageru_set_num_channels(lua_State *L); + friend int Nageru_set_channel_signal(lua_State *L); + friend int Nageru_set_supports_wb(lua_State *L); }; // LiveInputWrapper is a facade on top of an YCbCrInput, exposed to @@ -161,7 +262,7 @@ public: LiveInputWrapper(Theme *theme, movit::EffectChain *chain, bmusb::PixelFormat pixel_format, bool override_bounce, bool deinterlace, bool user_connectable); bool connect_signal(int signal_num); // Must be called with the theme's lock held, since it accesses theme->input_state. Returns false on error. - void connect_signal_raw(int signal_num, const InputState &input_state); + void connect_card(int signal_num, const InputState &input_state); movit::Effect *get_effect() const { if (deinterlace) { @@ -184,4 +285,12 @@ private: bool user_connectable; }; +// Utility functions used by Scene. +void add_outputs_and_finalize(movit::EffectChain *chain, bool is_main_chain); +Theme *get_theme_updata(lua_State* L); +bool checkbool(lua_State* L, int idx); +std::string checkstdstring(lua_State *L, int index); +movit::Effect *instantiate_effect(movit::EffectChain *chain, EffectType effect_type); +void print_warning(lua_State* L, const char *format, ...); + #endif // !defined(_THEME_H)