X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fmixer%2Fimage%2Fimage_mixer.cpp;h=f9676e068aeafd413f80362e35cc09655588d9fd;hb=517174ad8f15d5b6f71cdf8bc04a158cbe4bd278;hp=aa9741db76445bd0763ebc63d0db97c4a00329f4;hpb=0b6c8422d829280ed7edcb330fd08ce30b1467b5;p=casparcg diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp index aa9741db7..f9676e068 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,162 +37,190 @@ #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_; +{ + typedef std::deque layer; - std::shared_ptr reading_; + video_channel_context& channel_; - image_kernel kernel_; + std::vector transform_stack_; + std::vector mode_stack_; - safe_ptr context_; + std::deque> layers_; // layer/stream/items + + image_kernel kernel_; + + std::shared_ptr draw_buffer_; + std::shared_ptr write_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) - , context_(ogl_device::create()) + implementation(video_channel_context& video_channel) + : channel_(video_channel) + , transform_stack_(1) + , mode_stack_(1, video_mode::progressive) { - context_->invoke([] - { - if(!GLEE_VERSION_3_0) - BOOST_THROW_EXCEPTION(not_supported() << msg_info("Missing OpenGL 3.0 support.")); - }); - - context_->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)); - - render_targets_[0] = context_->create_device_buffer(format_desc.width, format_desc.height, 4); - render_targets_[1] = context_->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_ = context_->create_host_buffer(format_desc_.size, host_buffer::read_only); - }); + initialize_buffers(); } ~implementation() { - glDeleteFramebuffersEXT(1, &fbo_); + channel_.ogl().gc(); } - void begin(const core::basic_frame& frame) + void initialize_buffers() { - transform_stack_.push(transform_stack_.top()*frame.get_image_transform()); + write_buffer_ = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, 4); + layer_key_buffer_ = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, 1); + draw_buffer_ = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, 4); + local_key_buffer_ = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, 1); + channel_.ogl().gc(); + } + + void begin(core::basic_frame& frame) + { + 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 = boost::polymorphic_downcast(&frame); - auto& desc = gpu_frame->get_pixel_format_desc(); - auto& buffers = gpu_frame->get_plane_buffers(); + { + CASPAR_ASSERT(!layers_.empty()); - auto transform = transform_stack_.top(); - context_->begin_invoke([=] - { - GL(glColor4d(1.0, 1.0, 1.0, transform.get_opacity())); - GL(glViewport(0, 0, format_desc_.width, format_desc_.height)); - kernel_.apply(desc, transform); - - std::vector> device_buffers; - for(size_t n = 0; n < buffers.size(); ++n) - { - auto texture = context_->create_device_buffer(desc.planes[n].width, desc.planes[n].height, desc.planes[n].channels); - texture->read(*buffers[n]); - device_buffers.push_back(texture); - } - - for(size_t n = 0; n < buffers.size(); ++n) - { - GL(glActiveTexture(GL_TEXTURE0+n)); - device_buffers[n]->bind(); - } - - 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); - glTexCoord2d(0.0, 0.0); glVertex2d( f_p[0] *2.0-1.0, f_p[1] *2.0-1.0); - glTexCoord2d(1.0, 0.0); glVertex2d((f_p[0]+f_s[0])*2.0-1.0, f_p[1] *2.0-1.0); - glTexCoord2d(1.0, 1.0); glVertex2d((f_p[0]+f_s[0])*2.0-1.0, (f_p[1]+f_s[1])*2.0-1.0); - glTexCoord2d(0.0, 1.0); glVertex2d( f_p[0] *2.0-1.0, (f_p[1]+f_s[1])*2.0-1.0); - glEnd(); - GL(glDisable(GL_SCISSOR_TEST)); - }); + // 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; + + core::render_item item(frame.get_pixel_format_desc(), frame.get_textures(), transform_stack_.back(), mode_stack_.back(), frame.tag()); + + auto& layer = layers_.back(); + + auto it = boost::range::find(layer, item); + if(it == layer.end()) + layer.push_back(item); } void end() { - transform_stack_.pop(); + transform_stack_.pop_back(); + mode_stack_.pop_back(); } - boost::unique_future> begin_pass() + void begin_layer() { - return context_->begin_invoke([=]() -> safe_ptr - { - reading_->map(); - render_targets_[0]->attach(0); - GL(glClear(GL_COLOR_BUFFER_BIT)); - return safe_ptr(reading_); - }); + layers_.push_back(layer()); } - void end_pass() + void end_layer() { - context_->begin_invoke([=] - { - reading_ = context_->create_host_buffer(format_desc_.size, host_buffer::read_only); - render_targets_[0]->write(*reading_); - std::rotate(render_targets_.begin(), render_targets_.begin() + 1, render_targets_.end()); - }); } + + boost::unique_future> render() + { + auto layers = std::move(layers_); + return channel_.ogl().begin_invoke([=]()mutable{return render(std::move(layers));}); + } + + safe_ptr render(std::deque&& layers) + { + if(channel_.get_format_desc().width != write_buffer_->width() || channel_.get_format_desc().height != write_buffer_->height()) + initialize_buffers(); + + channel_.ogl().clear(*layer_key_buffer_); + channel_.ogl().clear(*local_key_buffer_); + channel_.ogl().clear(*draw_buffer_); + + bool layer_key = false; + + BOOST_FOREACH(auto& layer, layers) + draw(std::move(layer), layer_key); + + std::swap(draw_buffer_, write_buffer_); + + auto host_buffer = channel_.ogl().create_host_buffer(channel_.get_format_desc().size, host_buffer::read_only); + + channel_.ogl().attach(*write_buffer_); + host_buffer->begin_read(write_buffer_->width(), write_buffer_->height(), format(write_buffer_->stride())); + + GL(glFlush()); + + return host_buffer; + } + + void draw(layer&& layer, bool& layer_key) + { + bool local_key = false; - std::vector> create_buffers(const core::pixel_format_desc& format) + channel_.ogl().clear(*local_key_buffer_); + + BOOST_FOREACH(auto& item, layer) + draw(std::move(item), local_key, layer_key); + + layer_key = local_key; + + std::swap(local_key_buffer_, layer_key_buffer_); + } + + void draw(render_item&& item, bool& local_key, bool& layer_key) + { + if(item.transform.get_is_key()) + { + draw(local_key_buffer_, std::move(item), nullptr, nullptr); + local_key = true; + } + else + { + draw(draw_buffer_, std::move(item), local_key ? local_key_buffer_ : nullptr, layer_key ? layer_key_buffer_ : nullptr); + channel_.ogl().clear(*local_key_buffer_); + local_key = false; + } + } + + void draw(std::shared_ptr& target, render_item&& item, const std::shared_ptr& local_key, const std::shared_ptr& layer_key) { - std::vector> buffers; - std::transform(format.planes.begin(), format.planes.end(), std::back_inserter(buffers), [&](const core::pixel_format_desc::plane& plane) + if(!std::all_of(item.textures.begin(), item.textures.end(), std::mem_fn(&device_buffer::ready))) { - return context_->create_host_buffer(plane.size, host_buffer::write_only); - }); - return buffers; + 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. + } + + channel_.ogl().attach(*target); + kernel_.draw(channel_.ogl(), std::move(item), make_safe(target), local_key, layer_key); + } + + 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::begin_pass(){ return impl_->begin_pass();} -void image_mixer::end_pass(){impl_->end_pass();} -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