X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fmixer%2Fimage%2Fimage_mixer.cpp;h=ae8fec69ddf1bee20f56f712b42ce0434cba160a;hb=2fcb2929a931f68cea258bf5ec1f1642b954801b;hp=5aa6a2bee3f44d4d16c7da6905d882ae6d97bb4a;hpb=89a83b868463e2b917748d6af14538d0f3bb97c9;p=casparcg diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp index 5aa6a2bee..ae8fec69d 100644 --- a/core/mixer/image/image_mixer.cpp +++ b/core/mixer/image/image_mixer.cpp @@ -1,161 +1,205 @@ -#include "../../StdAfx.h" +/* +* copyright (c) 2010 Sveriges Television AB +* +* This file is part of CasparCG. +* +* CasparCG is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* CasparCG is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. + +* You should have received a copy of the GNU General Public License +* along with CasparCG. If not, see . +* +*/ +#include "../../stdafx.h" #include "image_mixer.h" #include "image_kernel.h" -#include "image_transform.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 +#include #include namespace caspar { namespace core { struct image_mixer::implementation : boost::noncopyable -{ - const 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 local_key_buffer_; + std::shared_ptr layer_key_buffer_; + public: - implementation(const 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_->begin_invoke([=] - { - transform_stack_.push(image_transform()); - transform_stack_.top().set_mode(video_mode::progressive); - - GL(glEnable(GL_TEXTURE_2D)); - GL(glEnable(GL_STENCIL_TEST)); - GL(glEnable(GL_SCISSOR_TEST)); - 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); - }); } ~implementation() { - glDeleteFramebuffersEXT(1, &fbo_); + channel_.ogl().gc(); } - - void begin(const image_transform& transform) + + void begin(core::basic_frame& frame) { - transform_stack_.push(transform_stack_.top()*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 render(const pixel_format_desc& desc, std::vector>& buffers) - { - 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.pix_fmt, transform); + void visit(core::write_frame& frame) + { + CASPAR_ASSERT(!layers_.empty()); - 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); - } + // 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()); - for(size_t n = 0; n < buffers.size(); ++n) - { - glActiveTexture(GL_TEXTURE0+n); - device_buffers[n]->bind(); - } + auto& layer = layers_.back(); - auto m_p = transform.get_mask_translation(); - auto m_s = transform.get_mask_scale(); - double w = static_cast(format_desc_.width); - double h = static_cast(format_desc_.height); - - 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_image_translation(); - auto f_s = transform.get_image_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(glScissor(0, 0, format_desc_.width, format_desc_.height)); - }); + 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> 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([=] + } + + boost::unique_future> render() + { + auto layers = std::move(layers_); + return channel_.ogl().begin_invoke([=]()mutable { - 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()); + 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; + } + + void draw(layer&& layer) + { + BOOST_FOREACH(auto& item, layer) + draw(std::move(item)); - std::vector> create_buffers(const pixel_format_desc& format) + std::swap(local_key_buffer_, layer_key_buffer_); + } + + void draw(render_item&& item) + { + if(item.transform.get_is_key()) + { + if(!local_key_buffer_) + { + 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_); + } + + 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) { - std::vector> buffers; - std::transform(format.planes.begin(), format.planes.end(), std::back_inserter(buffers), [&](const pixel_format_desc::plane& plane) -> safe_ptr + 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. + } + + 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 video_format_desc& format_desc) : impl_(new implementation(format_desc)){} -void image_mixer::begin(const image_transform& transform) { impl_->begin(transform);} -void image_mixer::process(const pixel_format_desc& desc, std::vector>& buffers){ impl_->render(desc, buffers);} +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 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