X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fmixer%2Fimage%2Fimage_mixer.cpp;h=ae8fec69ddf1bee20f56f712b42ce0434cba160a;hb=2fcb2929a931f68cea258bf5ec1f1642b954801b;hp=4b531ecf1e39242cb784be6c0b4b67c34a3583ce;hpb=1614cde357c6de1c1422d7ac935c38978bfa8423;p=casparcg diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp index 4b531ecf1..ae8fec69d 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,234 +37,169 @@ #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 -{ - const core::video_format_desc format_desc_; - - std::stack transform_stack_; - - GLuint fbo_; - std::array, 2> render_targets_; - std::shared_ptr key_target_; - bool is_key_; +{ + typedef std::deque layer; - std::shared_ptr reading_; + video_channel_context& channel_; - image_kernel kernel_; + std::vector transform_stack_; + std::vector mode_stack_; - struct render_item - { - core::pixel_format_desc desc; - std::vector> textures; - core::image_transform transform; - }; + std::deque> layers_; // layer/stream/items - std::vector waiting_queue_; - std::vector render_queue_; + image_kernel kernel_; + + std::shared_ptr draw_buffer_; + std::shared_ptr local_key_buffer_; + std::shared_ptr layer_key_buffer_; + public: - implementation(const core::video_format_desc& format_desc) - : format_desc_(format_desc) - , is_key_(false) + implementation(video_channel_context& video_channel) + : channel_(video_channel) + , transform_stack_(1) + , mode_stack_(1, video_mode::progressive) { - ogl_device::invoke([] - { - if(!GLEE_VERSION_3_0) - BOOST_THROW_EXCEPTION(not_supported() << msg_info("Missing OpenGL 3.0 support.")); - }); - - ogl_device::begin_invoke([=] - { - transform_stack_.push(core::image_transform()); - transform_stack_.top().set_mode(core::video_mode::progressive); - - GL(glEnable(GL_TEXTURE_2D)); - GL(glDisable(GL_DEPTH_TEST)); - - key_target_ = ogl_device::create_device_buffer(format_desc.width, format_desc.height, 4); - render_targets_[0] = ogl_device::create_device_buffer(format_desc.width, format_desc.height, 4); - render_targets_[1] = ogl_device::create_device_buffer(format_desc.width, format_desc.height, 4); - - GL(glGenFramebuffers(1, &fbo_)); - GL(glBindFramebuffer(GL_FRAMEBUFFER_EXT, fbo_)); - GL(glReadBuffer(GL_COLOR_ATTACHMENT0_EXT)); - - reading_ = ogl_device::create_host_buffer(format_desc_.size, host_buffer::read_only); - }); } ~implementation() { - glDeleteFramebuffersEXT(1, &fbo_); + 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; - - 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); - } + auto& layer = layers_.back(); - 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 - { - reading_->map(); // Might block. - return make_safe(reading_); - }); - - ogl_device::begin_invoke([=] - { - is_key_ = false; - - // Clear and bind frame-buffers. - - key_target_->attach(); - GL(glClear(GL_COLOR_BUFFER_BIT)); - - render_targets_[0]->attach(); - GL(glClear(GL_COLOR_BUFFER_BIT)); - - // Render items. - - BOOST_FOREACH(auto item, render_queue_) - render(item); - - // Move waiting items to queue. - - render_queue_ = std::move(waiting_queue_); - - // Start read-back. - - reading_ = ogl_device::create_host_buffer(format_desc_.size, host_buffer::read_only); - render_targets_[0]->attach(); - render_targets_[0]->write(*reading_); - std::swap(render_targets_[0], render_targets_[1]); - }); - - return std::move(result); + layers_.push_back(layer()); } - void render(const render_item& item) + void end_layer() + { + } + + boost::unique_future> render() { - 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) + auto layers = std::move(layers_); + return channel_.ogl().begin_invoke([=]()mutable { - GL(glActiveTexture(GL_TEXTURE0+n)); - textures[n]->bind(); - } + return render(std::move(layers)); + }); + } + + safe_ptr render(std::deque&& layers) + { + draw_buffer_ = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, 4); + channel_.ogl().clear(*draw_buffer_); + + BOOST_FOREACH(auto& layer, layers) + draw(std::move(layer)); + + 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())); + + GL(glFlush()); + + return host_buffer; + } - // Setup key and kernel + void draw(layer&& layer) + { + BOOST_FOREACH(auto& item, layer) + draw(std::move(item)); + + std::swap(local_key_buffer_, layer_key_buffer_); + } - if(transform.get_is_key()) + void draw(render_item&& item) + { + if(item.transform.get_is_key()) { - kernel_.apply(desc, transform, false); - if(!is_key_) + if(!local_key_buffer_) { - key_target_->attach(); - is_key_ = true; - GL(glClear(GL_COLOR_BUFFER_BIT)); + local_key_buffer_ = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, 1); + channel_.ogl().clear(*local_key_buffer_); } - } - else - { - kernel_.apply(desc, transform, is_key_); - if(is_key_) - { - is_key_ = false; - render_targets_[0]->attach(); - GL(glActiveTexture(GL_TEXTURE0+3)); - key_target_->bind(); - } + draw(local_key_buffer_, std::move(item), nullptr, nullptr); + } + else + { + draw(draw_buffer_, std::move(item), local_key_buffer_, layer_key_buffer_); + local_key_buffer_.reset(); + } + } + + void draw(std::shared_ptr& target, render_item&& item, const std::shared_ptr& local_key, const std::shared_ptr& layer_key) + { + if(!std::all_of(item.textures.begin(), item.textures.end(), std::mem_fn(&device_buffer::ready))) + { + CASPAR_LOG(warning) << L"[image_mixer] Performance warning. Host to device transfer not complete, GPU will be stalled"; + channel_.ogl().yield(); // Try to give it some more time. } - GL(glColor4d(1.0, 1.0, 1.0, transform.get_opacity())); - GL(glViewport(0, 0, format_desc_.width, format_desc_.height)); - - auto m_p = transform.get_key_translation(); - auto m_s = transform.get_key_scale(); - double w = static_cast(format_desc_.width); - double h = static_cast(format_desc_.height); - - GL(glEnable(GL_SCISSOR_TEST)); - GL(glScissor(static_cast(m_p[0]*w), static_cast(m_p[1]*h), static_cast(m_s[0]*w), static_cast(m_s[1]*h))); - - auto f_p = transform.get_fill_translation(); - auto f_s = transform.get_fill_scale(); - - glBegin(GL_QUADS); - glMultiTexCoord2d(GL_TEXTURE0, 0.0, 0.0); glMultiTexCoord2d(GL_TEXTURE1, f_p[0] , f_p[1] ); glVertex2d( f_p[0] *2.0-1.0, f_p[1] *2.0-1.0); - glMultiTexCoord2d(GL_TEXTURE0, 1.0, 0.0); glMultiTexCoord2d(GL_TEXTURE1, (f_p[0]+f_s[0]), f_p[1] ); glVertex2d((f_p[0]+f_s[0])*2.0-1.0, f_p[1] *2.0-1.0); - glMultiTexCoord2d(GL_TEXTURE0, 1.0, 1.0); glMultiTexCoord2d(GL_TEXTURE1, (f_p[0]+f_s[0]), (f_p[1]+f_s[1])); glVertex2d((f_p[0]+f_s[0])*2.0-1.0, (f_p[1]+f_s[1])*2.0-1.0); - glMultiTexCoord2d(GL_TEXTURE0, 0.0, 1.0); glMultiTexCoord2d(GL_TEXTURE1, f_p[0] , (f_p[1]+f_s[1])); glVertex2d( f_p[0] *2.0-1.0, (f_p[1]+f_s[1])*2.0-1.0); - glEnd(); - GL(glDisable(GL_SCISSOR_TEST)); + kernel_.draw(channel_.ogl(), std::move(item), make_safe(target), local_key, layer_key); } - - std::vector> create_buffers(const core::pixel_format_desc& format) + + safe_ptr create_frame(const void* tag, const core::pixel_format_desc& desc) { - 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; + 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