X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fmixer%2Fimage%2Fimage_mixer.cpp;h=35e95f0a34e1e75ad42b7a44709fab40b92e84e1;hb=580d5b82595893c83f7bf715c94de20b70745ae4;hp=6be5505c72cbbed06719737cd7c2b1b948627708;hpb=e5c75c0905ee1474ffe45bddfb5d568edf829fbc;p=casparcg diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp index 6be5505c7..35e95f0a3 100644 --- a/core/mixer/image/image_mixer.cpp +++ b/core/mixer/image/image_mixer.cpp @@ -20,217 +20,292 @@ #include "../../stdafx.h" #include "image_mixer.h" -#include "image_kernel.h" +#include "image_kernel.h" +#include "../write_frame.h" #include "../gpu/ogl_device.h" #include "../gpu/host_buffer.h" #include "../gpu/device_buffer.h" -#include "../write_frame.h" +#include "../../video_channel_context.h" -#include #include #include +#include -#include +#include #include #include +#include + #include +#include -#include -#include +#include +#include -namespace caspar { namespace core { - -struct image_mixer::implementation : boost::noncopyable -{ - static const size_t LOCAL_KEY_INDEX = 3; - static const size_t LAYER_KEY_INDEX = 4; - - struct render_item - { - pixel_format_desc desc; - std::vector> textures; - core::image_transform transform; - }; +using namespace boost::assign; - const core::video_format_desc format_desc_; - - std::stack transform_stack_; - std::queue> render_queue_; +namespace caspar { namespace core { - image_kernel kernel_; - - safe_ptr draw_buffer_; - safe_ptr write_buffer_; +struct item +{ + pixel_format_desc pix_desc; + std::vector> textures; + frame_transform transform; +}; - safe_ptr local_key_buffer_; - safe_ptr layer_key_buffer_; +struct layer +{ + std::vector items; + blend_mode::type blend_mode; - bool local_key_; - bool layer_key_; + layer(blend_mode::type blend_mode) : blend_mode(blend_mode) + { + } +}; +class image_renderer +{ + video_channel_context& channel_; + image_kernel kernel_; + std::shared_ptr active_buffer_; public: - implementation(const core::video_format_desc& format_desc) - : format_desc_(format_desc) - , draw_buffer_(ogl_device::create_device_buffer(format_desc.width, format_desc.height, 4)) - , write_buffer_ (ogl_device::create_device_buffer(format_desc.width, format_desc.height, 4)) - , local_key_buffer_(ogl_device::create_device_buffer(format_desc.width, format_desc.height, 1)) - , layer_key_buffer_(ogl_device::create_device_buffer(format_desc.width, format_desc.height, 1)) - , local_key_(false) - , layer_key_(false) + image_renderer(video_channel_context& channel) + : channel_(channel) { - transform_stack_.push(core::image_transform()); } - void begin(const core::basic_frame& frame) - { - transform_stack_.push(transform_stack_.top()*frame.get_image_transform()); + boost::unique_future> render(std::vector&& layers) + { + auto layers2 = make_move_on_copy(std::move(layers)); + return channel_.ogl().begin_invoke([=] + { + return do_render(std::move(layers2.value)); + }); } + +private: + safe_ptr do_render(std::vector&& layers) + { + auto draw_buffer = create_device_buffer(4); + + if(channel_.get_format_desc().field_mode != field_mode::progressive) + { + auto upper = layers; + auto lower = std::move(layers); + + BOOST_FOREACH(auto& layer, upper) + { + boost::remove_erase_if(layer.items, [](const item& item){return !(item.transform.field_mode & field_mode::upper);}); + BOOST_FOREACH(auto& item, layer.items) + item.transform.field_mode = field_mode::upper; + } + + BOOST_FOREACH(auto& layer, lower) + { + boost::remove_erase_if(layer.items, [](const item& item){return !(item.transform.field_mode & field_mode::lower);}); + BOOST_FOREACH(auto& item, layer.items) + item.transform.field_mode = field_mode::lower; + } + + draw(std::move(upper), draw_buffer); + draw(std::move(lower), draw_buffer); + } + else + { + draw(std::move(layers), draw_buffer); + } + + auto host_buffer = channel_.ogl().create_host_buffer(channel_.get_format_desc().size, host_buffer::read_only); + channel_.ogl().attach(*draw_buffer); + host_buffer->begin_read(draw_buffer->width(), draw_buffer->height(), format(draw_buffer->stride())); - void visit(core::write_frame& frame) - { - render_item item = {frame.get_pixel_format_desc(), frame.get_textures(), transform_stack_.top()*frame.get_image_transform()}; - render_queue_.back().push(item); - } + active_buffer_ = draw_buffer; - void end() - { - transform_stack_.pop(); + channel_.ogl().flush(); // NOTE: This is important, otherwise fences will deadlock. + + return host_buffer; } - void begin_layer() + void draw(std::vector&& layers, + safe_ptr& draw_buffer) { - render_queue_.push(std::queue()); - } + std::shared_ptr layer_key_buffer; - void end_layer() - { + BOOST_FOREACH(auto& layer, layers) + draw_layer(std::move(layer), draw_buffer, layer_key_buffer); } - boost::unique_future> render() - { - auto result = ogl_device::create_host_buffer(format_desc_.size, host_buffer::read_only); + void draw_layer(layer&& layer, + safe_ptr& draw_buffer, + std::shared_ptr& layer_key_buffer) + { + if(layer.items.empty()) + return; - auto render_queue = std::move(render_queue_); + std::shared_ptr local_key_buffer; + std::shared_ptr local_mix_buffer; + + if(layer.blend_mode != blend_mode::normal && layer.items.size() > 1) + { + auto layer_draw_buffer = create_device_buffer(4); - ogl_device::begin_invoke([=]() mutable + BOOST_FOREACH(auto& item, layer.items) + draw_item(std::move(item), layer_draw_buffer, layer_key_buffer, local_key_buffer, local_mix_buffer); + + draw_device_buffer(layer_draw_buffer, std::move(local_mix_buffer), blend_mode::normal); + draw_device_buffer(draw_buffer, std::move(layer_draw_buffer), layer.blend_mode); + } + else // fast path { - local_key_ = false; - layer_key_ = false; + BOOST_FOREACH(auto& item, layer.items) + draw_item(std::move(item), draw_buffer, layer_key_buffer, local_key_buffer, local_mix_buffer); + + draw_device_buffer(draw_buffer, std::move(local_mix_buffer), blend_mode::normal); + } - // Clear buffers. - local_key_buffer_->clear(); - layer_key_buffer_->clear(); - draw_buffer_->clear(); + std::swap(local_key_buffer, layer_key_buffer); + } - // Draw items in device. + void draw_item(item&& item, + safe_ptr& draw_buffer, + std::shared_ptr& layer_key_buffer, + std::shared_ptr& local_key_buffer, + std::shared_ptr& local_mix_buffer) + { + draw_params draw_params; + draw_params.pix_desc = std::move(item.pix_desc); + draw_params.textures = std::move(item.textures); + draw_params.transform = std::move(item.transform); - while(!render_queue.empty()) - { - auto layer = render_queue.front(); - render_queue.pop(); - - draw_buffer_->attach(); + if(item.transform.is_key) + { + local_key_buffer = local_key_buffer ? local_key_buffer : create_device_buffer(1); - while(!layer.empty()) - { - draw(layer.front()); - layer.pop(); - ogl_device::yield(); // Allow quick buffer allocation to execute. - } + draw_params.background = local_key_buffer; + draw_params.local_key = nullptr; + draw_params.layer_key = nullptr; - layer_key_ = local_key_; // If there was only key in last layer then use it as key for the entire next layer. - local_key_ = false; + kernel_.draw(channel_.ogl(), std::move(draw_params)); + } + else if(item.transform.is_mix) + { + local_mix_buffer = local_mix_buffer ? local_mix_buffer : create_device_buffer(4); - std::swap(local_key_buffer_, layer_key_buffer_); - } + draw_params.background = local_mix_buffer; + draw_params.local_key = std::move(local_key_buffer); + draw_params.layer_key = layer_key_buffer; - // Start transfer from device to host. + draw_params.keyer = keyer::additive; - draw_buffer_->write(*result); + kernel_.draw(channel_.ogl(), std::move(draw_params)); + } + else + { + draw_device_buffer(draw_buffer, std::move(local_mix_buffer), blend_mode::normal); + + draw_params.background = draw_buffer; + draw_params.local_key = std::move(local_key_buffer); + draw_params.layer_key = layer_key_buffer; - std::swap(draw_buffer_, write_buffer_); - }); + kernel_.draw(channel_.ogl(), std::move(draw_params)); + } + } - // While transferring do additional work which was queued during rendering. + void draw_device_buffer(safe_ptr& draw_buffer, std::shared_ptr&& source_buffer, blend_mode::type blend_mode = blend_mode::normal) + { + if(!source_buffer) + return; + + draw_params draw_params; + draw_params.pix_desc.pix_fmt = pixel_format::bgra; + draw_params.pix_desc.planes = list_of(pixel_format_desc::plane(source_buffer->width(), source_buffer->height(), 4)); + draw_params.textures = list_of(source_buffer); + draw_params.transform = frame_transform(); + draw_params.blend_mode = blend_mode; + draw_params.background = draw_buffer; + + kernel_.draw(channel_.ogl(), std::move(draw_params)); + } + + safe_ptr create_device_buffer(size_t stride) + { + auto buffer = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, stride); + channel_.ogl().clear(*buffer); + return buffer; + } +}; - return ogl_device::begin_invoke([=]() -> safe_ptr - { - result->map(); // Might block. - return result; - }); +struct image_mixer::implementation : boost::noncopyable +{ + ogl_device& ogl_; + image_renderer renderer_; + std::vector transform_stack_; + std::vector layers_; // layer/stream/items +public: + implementation(video_channel_context& video_channel) + : ogl_(video_channel.ogl()) + , renderer_(video_channel) + , transform_stack_(1) + { } - - void draw(const render_item& item) - { - // Bind textures - for(size_t n = 0; n < item.textures.size(); ++n) - item.textures[n]->bind(n); - - // Setup key and kernel - - bool local_key = false; - bool layer_key = false; + void begin_layer(blend_mode::type blend_mode) + { + layers_.push_back(layer(blend_mode)); + } - if(item.transform.get_is_key()) // This is a key frame, render it to the local_key buffer for later use. - { - if(!local_key_) // Initialize local-key if it is not active. - { - local_key_buffer_->clear(); - local_key_buffer_->attach(); - local_key_ = true; - } - } - else // This is a normal frame. Use key buffers if they are active. - { - local_key = local_key_; - layer_key = layer_key_; + void begin(core::basic_frame& frame) + { + transform_stack_.push_back(transform_stack_.back()*frame.get_frame_transform()); + } + + void visit(core::write_frame& frame) + { + if(frame.get_frame_transform().field_mode == field_mode::empty) + return; - if(local_key_) // Use local key if we have it. - { - local_key_buffer_->bind(LOCAL_KEY_INDEX); - draw_buffer_->attach(); - local_key_ = false; // Use it only one time. - } + item item; + item.pix_desc = frame.get_pixel_format_desc(); + item.textures = frame.get_textures(); + item.transform = transform_stack_.back(); - if(layer_key_) // Use layer key if we have it. - layer_key_buffer_->bind(LAYER_KEY_INDEX); - } + layers_.back().items.push_back(item); + } - // Draw + void end() + { + transform_stack_.pop_back(); + } - kernel_.draw(format_desc_.width, format_desc_.height, item.desc, item.transform, local_key, layer_key); + void end_layer() + { } - - safe_ptr create_frame(void* tag, const core::pixel_format_desc& desc) + + boost::unique_future> render() { - std::vector> buffers; - std::vector> textures; - ogl_device::invoke([&] - { - std::transform(desc.planes.begin(), desc.planes.end(), std::back_inserter(buffers), [&](const core::pixel_format_desc::plane& plane) - { - return ogl_device::create_host_buffer(plane.size, host_buffer::write_only); - }); - std::transform(desc.planes.begin(), desc.planes.end(), std::back_inserter(textures), [&](const core::pixel_format_desc::plane& plane) - { - return ogl_device::create_device_buffer(plane.width, plane.height, plane.channels); - }); - }); + return renderer_.render(std::move(layers_)); + } - return make_safe(reinterpret_cast(tag), desc, buffers, textures); + safe_ptr create_frame(const void* tag, const core::pixel_format_desc& desc) + { + return make_safe(ogl_, tag, desc); } }; -image_mixer::image_mixer(const core::video_format_desc& format_desc) : impl_(new implementation(format_desc)){} -void image_mixer::begin(const core::basic_frame& frame){impl_->begin(frame);} +image_mixer::image_mixer(video_channel_context& video_channel) : impl_(new implementation(video_channel)){} +void image_mixer::begin(core::basic_frame& frame){impl_->begin(frame);} void image_mixer::visit(core::write_frame& frame){impl_->visit(frame);} void image_mixer::end(){impl_->end();} -boost::unique_future> image_mixer::render(){return impl_->render();} -safe_ptr image_mixer::create_frame(void* tag, const core::pixel_format_desc& desc){return impl_->create_frame(tag, desc);} -void image_mixer::begin_layer(){impl_->begin_layer();} +boost::unique_future> image_mixer::render(){return impl_->render();} +safe_ptr image_mixer::create_frame(const void* tag, const core::pixel_format_desc& desc){return impl_->create_frame(tag, desc);} +void image_mixer::begin_layer(blend_mode::type blend_mode){impl_->begin_layer(blend_mode);} void image_mixer::end_layer(){impl_->end_layer();} +image_mixer& image_mixer::operator=(image_mixer&& other) +{ + impl_ = std::move(other.impl_); + return *this; +} }} \ No newline at end of file