X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fmixer%2Fimage%2Fimage_mixer.cpp;h=bcdf592d20adff3d2b2568658ee6cf5eb5b5ae9c;hb=2d37a4e2f1f5aedf3975796f7b775ab3cea5ccf4;hp=a3b68a257a6c17a4ce48cbe058bccd4dd0408942;hpb=9f50785e2357f13850e0c34760b82a481b77988e;p=casparcg diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp index a3b68a257..bcdf592d2 100644 --- a/core/mixer/image/image_mixer.cpp +++ b/core/mixer/image/image_mixer.cpp @@ -25,7 +25,9 @@ #include "../gpu/ogl_device.h" #include "../gpu/host_buffer.h" #include "../gpu/device_buffer.h" -#include "../gpu/gpu_write_frame.h" +#include "../write_frame.h" + +#include "../../video_channel_context.h" #include #include @@ -35,194 +37,246 @@ #include #include -#include +#include -#include -#include +#include +#include +#include +#include #include +#include #include -namespace caspar { namespace mixer { +namespace caspar { namespace core { struct image_mixer::implementation : boost::noncopyable -{ - struct render_item - { - core::pixel_format_desc desc; - std::vector> textures; - core::image_transform transform; - }; +{ + typedef std::deque layer; - const core::video_format_desc format_desc_; - - std::stack transform_stack_; - - bool is_key_; - - safe_ptr front_target_; - safe_ptr back_target_; - safe_ptr key_target_; + video_channel_context& channel_; - safe_ptr reading_; + std::vector transform_stack_; + std::vector mode_stack_; - image_kernel kernel_; - - std::vector waiting_queue_; - std::vector render_queue_; + std::deque> layers_; // layer/stream/items + + image_kernel kernel_; + std::shared_ptr active_buffer_; public: - implementation(const core::video_format_desc& format_desc) - : format_desc_(format_desc) - , is_key_(false) - , back_target_(ogl_device::create_device_buffer(format_desc.width, format_desc.height, 4)) - , front_target_(ogl_device::create_device_buffer(format_desc.width, format_desc.height, 4)) - , key_target_(ogl_device::create_device_buffer(format_desc.width, format_desc.height, 4)) - , reading_(ogl_device::create_host_buffer(format_desc_.size, host_buffer::read_only)) + implementation(video_channel_context& video_channel) + : channel_(video_channel) + , transform_stack_(1) + , mode_stack_(1, video_mode::progressive) { - transform_stack_.push(core::image_transform()); + } + + ~implementation() + { + channel_.ogl().gc(); } - void begin(const core::basic_frame& frame) + void begin(core::basic_frame& frame) { - transform_stack_.push(transform_stack_.top()*frame.get_image_transform()); + transform_stack_.push_back(transform_stack_.back()*frame.get_image_transform()); + mode_stack_.push_back(frame.get_mode() == video_mode::progressive ? mode_stack_.back() : frame.get_mode()); } void visit(core::write_frame& frame) - { - auto gpu_frame = dynamic_cast(&frame); - if(!gpu_frame) + { + CASPAR_ASSERT(!layers_.empty()); + + // Check if frame has been discarded by interlacing + if(boost::range::find(mode_stack_, video_mode::upper) != mode_stack_.end() && boost::range::find(mode_stack_, video_mode::lower) != mode_stack_.end()) return; - auto desc = gpu_frame->get_pixel_format_desc(); - auto buffers = gpu_frame->get_plane_buffers(); - auto transform = transform_stack_.top(); + core::render_item item(frame.get_pixel_format_desc(), frame.get_textures(), transform_stack_.back(), mode_stack_.back(), frame.tag()); - ogl_device::begin_invoke([=] - { - render_item item; + auto& layer = layers_.back(); - item.desc = desc; - item.transform = transform; - - for(size_t n = 0; n < buffers.size(); ++n) - { - GL(glActiveTexture(GL_TEXTURE0+n)); - auto texture = ogl_device::create_device_buffer(desc.planes[n].width, desc.planes[n].height, desc.planes[n].channels); - texture->read(*buffers[n]); - item.textures.push_back(texture); - } - - waiting_queue_.push_back(item); - }); + if(boost::range::find(layer, item) == layer.end()) + layer.push_back(item); } void end() { - transform_stack_.pop(); + transform_stack_.pop_back(); + mode_stack_.pop_back(); } - boost::unique_future> render() + void begin_layer() { - auto result = ogl_device::begin_invoke([=]() -> safe_ptr + layers_.push_back(layer()); + } + + void end_layer() + { + } + + boost::unique_future> render() + { + auto layers = std::move(layers_); + return channel_.ogl().begin_invoke([=]() mutable { - reading_->map(); // Might block. - return reading_; + return render(std::move(layers)); }); - - ogl_device::begin_invoke([=] - { - is_key_ = false; - - // Clear and bind frame-buffers. - - key_target_->attach(); - GL(glClear(GL_COLOR_BUFFER_BIT)); - - front_target_->attach(); - GL(glClear(GL_COLOR_BUFFER_BIT)); + } + + safe_ptr render(std::deque&& layers) + { + std::shared_ptr layer_key_buffer; - // Render items. + auto draw_buffer = create_device_buffer(4); + + BOOST_FOREACH(auto& layer, layers) + draw(std::move(layer), draw_buffer, layer_key_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())); + + active_buffer_ = draw_buffer; - BOOST_FOREACH(auto item, render_queue_) - render(item); + channel_.ogl().flush(); // NOTE: This is important, otherwise fences will deadlock. + + return host_buffer; + } - // Move waiting items to queue. + // TODO: We might have more overlaps for opacity transitions + // TODO: What about blending modes, are they ok? Maybe only overlap detection is required for opacity? + void draw(layer&& layer, const safe_ptr& draw_buffer, std::shared_ptr& layer_key_buffer) + { + if(layer.empty()) + return; - render_queue_ = std::move(waiting_queue_); + std::pair> local_key_buffer; + + if(has_overlapping_items(layer, layer.front().transform.get_blend_mode())) + { + auto local_draw_buffer = create_device_buffer(4); + + BOOST_FOREACH(auto& item, layer) + { + item.transform.set_blend_mode(image_transform::blend_mode::normal); + draw_item(std::move(item), local_draw_buffer, local_key_buffer, layer_key_buffer); + } - // Start read-back. + kernel_.draw(channel_.ogl(), create_render_item(local_draw_buffer, layer.front().transform.get_blend_mode()), draw_buffer, nullptr, nullptr); + } + else // fast path + { + BOOST_FOREACH(auto& item, layer) + draw_item(std::move(item), draw_buffer, local_key_buffer, layer_key_buffer); + } - reading_ = ogl_device::create_host_buffer(format_desc_.size, host_buffer::read_only); - front_target_->attach(); - front_target_->write(*reading_); - std::swap(front_target_, back_target_); - }); + CASPAR_ASSERT(local_key_buffer.first == 0 || local_key_buffer.first == core::video_mode::progressive); - return std::move(result); + std::swap(local_key_buffer.second, layer_key_buffer); } - void render(const render_item& item) - { - const auto desc = item.desc; - auto textures = item.textures; - const auto transform = item.transform; - - // Bind textures - - for(size_t n = 0; n < textures.size(); ++n) + void draw_item(render_item&& item, + const safe_ptr& draw_buffer, + std::pair>& local_key_buffer, + std::shared_ptr& layer_key_buffer) + { + if(item.transform.get_is_key()) { - GL(glActiveTexture(GL_TEXTURE0+n)); - textures[n]->bind(); - } - - // Setup key and kernel + if(!local_key_buffer.second) + { + local_key_buffer.first = 0; + local_key_buffer.second = create_device_buffer(1); + } - bool has_separate_key = false; + item.transform.set_opacity(1.0); + item.transform.set_blend_mode(image_transform::blend_mode::normal); - if(transform.get_is_key()) + local_key_buffer.first |= item.mode; + kernel_.draw(channel_.ogl(), std::move(item), make_safe(local_key_buffer.second), nullptr, nullptr); + } + else { - if(!is_key_) + kernel_.draw(channel_.ogl(), std::move(item), draw_buffer, local_key_buffer.second, layer_key_buffer); + local_key_buffer.first ^= item.mode; + + if(local_key_buffer.first == 0) { - key_target_->attach(); - is_key_ = true; - GL(glClear(GL_COLOR_BUFFER_BIT)); + local_key_buffer.first = 0; + local_key_buffer.second.reset(); } - } - else - { - if(is_key_) + } + } + + // TODO: Optimize + bool has_overlapping_items(const layer& layer, image_transform::blend_mode::type blend_mode) + { + if(layer.empty()) + return false; + + implementation::layer fill; + + std::copy_if(layer.begin(), layer.end(), std::back_inserter(fill), [&](const render_item& item) + { + return !item.transform.get_is_key(); + }); + + if(blend_mode == image_transform::blend_mode::normal) // Only overlap if opacity + { + return std::any_of(fill.begin(), fill.end(), [&](const render_item& item) { - has_separate_key = true; - is_key_ = false; + return item.transform.get_opacity() < 1.0 - 0.001; + }); + } - front_target_->attach(); - GL(glActiveTexture(GL_TEXTURE0+3)); - key_target_->bind(); - } - } + // Simple solution, just check if we have differnt video streams / tags. + return std::any_of(fill.begin(), fill.end(), [&](const render_item& item) + { + return item.tag != fill.front().tag; + }); + } + + render_item create_render_item(const safe_ptr& buffer, image_transform::blend_mode::type blend_mode) + { + CASPAR_ASSERT(buffer->stride() == 4 && "Only used for bgra textures"); - // Draw + pixel_format_desc desc; + desc.pix_fmt = pixel_format::bgra; + desc.planes.push_back(pixel_format_desc::plane(channel_.get_format_desc().width, channel_.get_format_desc().height, 4)); - kernel_.draw(format_desc_.width, format_desc_.height, desc, transform, has_separate_key); + std::vector> textures; + textures.push_back(buffer); + + image_transform transform; + transform.set_blend_mode(blend_mode); + + return render_item(desc, std::move(textures), transform, video_mode::progressive, nullptr); } - - std::vector> create_buffers(const core::pixel_format_desc& format) + + safe_ptr create_device_buffer(size_t stride) { - std::vector> buffers; - std::transform(format.planes.begin(), format.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); - }); - return buffers; + auto buffer = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, stride); + channel_.ogl().clear(*buffer); + return buffer; + } + + safe_ptr create_frame(const void* tag, const core::pixel_format_desc& desc) + { + return make_safe(channel_.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();} -std::vector> image_mixer::create_buffers(const core::pixel_format_desc& format){return impl_->create_buffers(format);} +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(){impl_->begin_layer();} +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