X-Git-Url: https://git.sesse.net/?p=nageru;a=blobdiff_plain;f=theme.h;h=f7897c77f9bf6b16ae3e5927af9b4c212ae21cc4;hp=a5ecebc5d8ba3746733a162383c3bfd82daac216;hb=refs%2Fheads%2Fcef;hpb=a98732df9454028ddaa54a9d07b5d7513767bfe9 diff --git a/theme.h b/theme.h index a5ecebc..f7897c7 100644 --- a/theme.h +++ b/theme.h @@ -1,95 +1,164 @@ #ifndef _THEME_H #define _THEME_H 1 -#include -#include -#include -#include +#include +#include #include #include -#include #include +#include #include -#include #include -#include #include -#include "defs.h" +#include "bmusb/bmusb.h" +#include "ref_counted_frame.h" +#include "tweaked_inputs.h" + +class CEFCapture; +class FFmpegCapture; +class LiveInputWrapper; +struct InputState; namespace movit { +class Effect; +class EffectChain; class ResourcePool; -struct ImageFormat; -struct YCbCrFormat; } // namespace movit -#define MAX_CARDS 16 - -class NonBouncingYCbCrInput : public movit::YCbCrInput { +class Theme { public: - NonBouncingYCbCrInput(const movit::ImageFormat &image_format, - const movit::YCbCrFormat &ycbcr_format, - unsigned width, unsigned height, - movit::YCbCrInputSplitting ycbcr_input_splitting = movit::YCBCR_INPUT_PLANAR) - : movit::YCbCrInput(image_format, ycbcr_format, width, height, ycbcr_input_splitting) {} + Theme(const std::string &filename, const std::vector &search_dirs, movit::ResourcePool *resource_pool, unsigned num_cards); + ~Theme(); - bool override_disable_bounce() const override { return true; } -}; + struct Chain { + movit::EffectChain *chain; + std::function setup_chain; -class Theme { -public: - Theme(const char *filename, movit::ResourcePool *resource_pool, unsigned num_cards); + // FRAME_HISTORY frames for each input, in order. Will contain duplicates + // for non-interlaced inputs. + std::vector input_frames; + }; - std::pair> - get_chain(unsigned num, float t, unsigned width, unsigned height); + Chain get_chain(unsigned num, float t, unsigned width, unsigned height, InputState input_state); - void set_input_textures(int signal_num, GLuint tex_y, GLuint tex_cbcr, GLuint width, GLuint height) { - auto &tex = input_textures[signal_num]; - tex.tex_y = tex_y; - tex.tex_cbcr = tex_cbcr; - tex.width = width; - tex.height = height; - } - int get_num_channels() { return num_channels; } + int get_num_channels() const { return num_channels; } + int map_signal(int signal_num); + void set_signal_mapping(int signal_num, int card_num); std::string get_channel_name(unsigned channel); + int get_channel_signal(unsigned channel); bool get_supports_set_wb(unsigned channel); void set_wb(unsigned channel, double r, double g, double b); + std::string get_channel_color(unsigned channel); std::vector get_transition_names(float t); - void connect_signal(movit::YCbCrInput *input, int signal_num); void transition_clicked(int transition_num, float t); void channel_clicked(int preview_num); + movit::ResourcePool *get_resource_pool() const { return resource_pool; } + + // Should be called as part of VideoInput.new() only. + void register_video_input(FFmpegCapture *capture) + { + video_inputs.push_back(capture); + } + + std::vector get_video_inputs() const + { + return video_inputs; + } + +#ifdef HAVE_CEF + // Should be called as part of HTMLInput.new() only. + void register_html_input(CEFCapture *capture) + { + html_inputs.push_back(capture); + } + + std::vector get_html_inputs() const + { + return html_inputs; + } +#endif + + void register_video_signal_connection(LiveInputWrapper *live_input, FFmpegCapture *capture) + { + video_signal_connections.emplace_back(live_input, capture); + } + + std::vector> get_video_signal_connections() const + { + return video_signal_connections; + } + +#ifdef HAVE_CEF + void register_html_signal_connection(LiveInputWrapper *live_input, CEFCapture *capture) + { + html_signal_connections.emplace_back(live_input, capture); + } + + std::vector> get_html_signal_connections() const + { + return html_signal_connections; + } +#endif + private: + void register_constants(); void register_class(const char *class_name, const luaL_Reg *funcs); std::mutex m; - lua_State *L; + lua_State *L; // Protected by . + const InputState *input_state = nullptr; // Protected by . Only set temporarily, during chain setup. movit::ResourcePool *resource_pool; - struct { - GLuint tex_y = 0, tex_cbcr = 0; - GLuint width = WIDTH, height = HEIGHT; - } input_textures[MAX_CARDS]; int num_channels; unsigned num_cards; - std::set signals_warned_about; + + std::mutex map_m; + std::map signal_to_card_mapping; // Protected by . + + std::vector video_inputs; + std::vector> video_signal_connections; +#ifdef HAVE_CEF + std::vector html_inputs; + std::vector> html_signal_connections; +#endif + + friend class LiveInputWrapper; }; +// LiveInputWrapper is a facade on top of an YCbCrInput, exposed to +// the Lua code. It contains a function (connect_signal()) intended +// to be called during chain setup, that picks out the current frame +// (in the form of a set of textures) from the input state given by +// the mixer, and communicates that state over to the actual YCbCrInput. class LiveInputWrapper { public: - LiveInputWrapper(Theme *theme, movit::EffectChain *chain, bool override_bounce); + // Note: is irrelevant for PixelFormat_8BitBGRA. + LiveInputWrapper(Theme *theme, movit::EffectChain *chain, bmusb::PixelFormat pixel_format, bool override_bounce, bool deinterlace); - void connect_signal(int signal_num); - movit::YCbCrInput *get_input() const + void connect_signal(int signal_num); // Must be called with the theme's lock held, since it accesses theme->input_state. + void connect_signal_raw(int signal_num, const InputState &input_state); + movit::Effect *get_effect() const { - return input; + if (deinterlace) { + return deinterlace_effect; + } else if (pixel_format == bmusb::PixelFormat_8BitBGRA) { + return rgba_inputs[0]; + } else { + return ycbcr_inputs[0]; + } } private: Theme *theme; // Not owned by us. - movit::YCbCrInput *input; // Owned by the chain. - int connected_signal_num = 0; + bmusb::PixelFormat pixel_format; + movit::YCbCrFormat input_ycbcr_format; + std::vector ycbcr_inputs; // Multiple ones if deinterlacing. Owned by the chain. + std::vector rgba_inputs; // Multiple ones if deinterlacing. Owned by the chain. + movit::Effect *deinterlace_effect = nullptr; // Owned by the chain. + bool deinterlace; }; #endif // !defined(_THEME_H)