X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fmixer%2Fimage%2Fimage_mixer.cpp;h=f82f60cd489d3db118bc6af27708833fa24f261a;hb=5391bc8ee9d44c6622a33db7efdb91f7bf99fa18;hp=4a7e561182d0b82dffe26b89560018a271a1b59a;hpb=b3d8e941e49b43a8eb3a96c1fa86b62e5230f938;p=casparcg diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp index 4a7e56118..f82f60cd4 100644 --- a/core/mixer/image/image_mixer.cpp +++ b/core/mixer/image/image_mixer.cpp @@ -1,4 +1,23 @@ -#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" @@ -6,254 +25,264 @@ #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 -namespace caspar { namespace core { - -image_transform::image_transform() - : opacity_(1.0) - , gain_(1.0) - , mode_(video_mode::invalid) -{ - std::fill(pos_.begin(), pos_.end(), 0.0); - std::fill(size_.begin(), size_.end(), 1.0); - std::fill(uv_.begin(), uv_.end(), 0.0); -} +#include -void image_transform::set_opacity(double value) -{ - tbb::spin_mutex::scoped_lock(mutex_); - opacity_ = value; -} - -double image_transform::get_opacity() const -{ - tbb::spin_mutex::scoped_lock(mutex_); - return opacity_; -} - -void image_transform::set_gain(double value) -{ - tbb::spin_mutex::scoped_lock(mutex_); - gain_ = value; -} +#include +#include +#include -double image_transform::get_gain() const -{ - tbb::spin_mutex::scoped_lock(mutex_); - return gain_; -} +#include +#include +#include +#include -void image_transform::set_position(double x, double y) -{ - std::array value = {x, y}; - tbb::spin_mutex::scoped_lock(mutex_); - pos_ = value; -} +namespace caspar { namespace core { + +struct image_mixer::implementation : boost::noncopyable +{ + typedef std::deque layer; -std::array image_transform::get_position() const -{ - tbb::spin_mutex::scoped_lock(mutex_); - return pos_; -} + video_channel_context& channel_; -void image_transform::set_size(double x, double y) -{ - std::array value = {x, y}; - tbb::spin_mutex::scoped_lock(mutex_); - size_ = value; -} + std::vector transform_stack_; + std::vector mode_stack_; -std::array image_transform::get_size() const -{ - tbb::spin_mutex::scoped_lock(mutex_); - return size_; -} + std::deque> layers_; // layer/stream/items + + image_kernel kernel_; -void image_transform::set_uv(double left, double top, double right, double bottom) -{ - std::array value = {left, top, right, bottom}; - tbb::spin_mutex::scoped_lock(mutex_); - uv_ = value; -} + std::shared_ptr active_buffer_; +public: + implementation(video_channel_context& video_channel) + : channel_(video_channel) + , transform_stack_(1) + , mode_stack_(1, video_mode::progressive) + { + } -std::array image_transform::get_uv() const -{ - tbb::spin_mutex::scoped_lock(mutex_); - return uv_; -} + ~implementation() + { + 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) + { + CASPAR_ASSERT(!layers_.empty()); -void image_transform::set_mode(video_mode::type mode) -{ - tbb::spin_mutex::scoped_lock(mutex_); - mode_ = mode; -} + // 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()); -video_mode::type image_transform::get_mode() const -{ - tbb::spin_mutex::scoped_lock(mutex_); - return mode_; -} + auto& layer = layers_.back(); + if(boost::range::find(layer, item) == layer.end()) + layer.push_back(item); + } -image_transform& image_transform::operator*=(const image_transform &other) -{ - tbb::spin_mutex::scoped_lock(mutex_); - opacity_ *= other.opacity_; - mode_ = other.mode_; - gain_ *= other.gain_; - uv_[0] += other.uv_[0]; - uv_[1] += other.uv_[1]; - uv_[2] += other.uv_[2]; - uv_[3] += other.uv_[3]; - pos_[0] += other.pos_[0]; - pos_[1] += other.pos_[1]; - size_[0] *= other.size_[0]; - size_[1] *= other.size_[1]; - return *this; -} + void end() + { + transform_stack_.pop_back(); + mode_stack_.pop_back(); + } -const image_transform image_transform::operator*(const image_transform &other) const -{ - return image_transform(*this) *= other; -} + void begin_layer() + { + layers_.push_back(layer()); + } -struct image_mixer::implementation : boost::noncopyable -{ - const video_format_desc format_desc_; + void end_layer() + { + } - std::stack transform_stack_; - - GLuint fbo_; - std::array, 2> render_targets_; + 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) + { + std::shared_ptr layer_key_buffer; - std::shared_ptr reading_; + 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; - image_kernel kernel_; + channel_.ogl().flush(); // NOTE: This is important, otherwise fences will deadlock. + + return host_buffer; + } - safe_ptr context_; + // 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; -public: - implementation(const video_format_desc& format_desc) - : format_desc_(format_desc) - , context_(ogl_device::create()) - { - context_->begin_invoke([=] + std::pair> local_key_buffer; + + if(has_overlapping_items(layer, layer.front().transform.get_blend_mode())) { - transform_stack_.push(image_transform()); - transform_stack_.top().set_mode(video_mode::progressive); - transform_stack_.top().set_uv(0.0, 1.0, 1.0, 0.0); + auto local_draw_buffer = create_device_buffer(4); + + // First item should just be "copied" to empty framebuffer. + auto item = layer.begin(); + item->transform.set_blend_mode(image_transform::blend_mode::replace); + draw_item(std::move(*item++), local_draw_buffer, local_key_buffer, layer_key_buffer); - GL(glEnable(GL_TEXTURE_2D)); - GL(glDisable(GL_DEPTH_TEST)); + for(; item != layer.end(); ++item) + { + item->transform.set_blend_mode(image_transform::blend_mode::normal); // Disable blending, it will be used when merging back into render stack. + draw_item(std::move(*item), local_draw_buffer, local_key_buffer, layer_key_buffer); + } - 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)); + 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_ = context_->create_host_buffer(format_desc_.size, host_buffer::read_only); - }); - } + CASPAR_ASSERT(local_key_buffer.first == 0 || local_key_buffer.first == core::video_mode::progressive); - ~implementation() - { - glDeleteFramebuffersEXT(1, &fbo_); + std::swap(local_key_buffer.second, layer_key_buffer); } - void begin(const image_transform& transform) - { - transform_stack_.push(transform_stack_.top()*transform); - } - - void render(const pixel_format_desc& desc, std::vector>& buffers) - { - auto transform = transform_stack_.top(); - context_->begin_invoke([=] + 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(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); - - std::vector> device_buffers; - for(size_t n = 0; n < buffers.size(); ++n) + if(!local_key_buffer.second) { - 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); + local_key_buffer.first = 0; + local_key_buffer.second = create_device_buffer(1); } - for(size_t n = 0; n < buffers.size(); ++n) + // No transparency for key + item.transform.set_opacity(1.0); + item.transform.set_blend_mode(image_transform::blend_mode::normal); + + local_key_buffer.first |= item.mode; + kernel_.draw(channel_.ogl(), std::move(item), make_safe(local_key_buffer.second), nullptr, nullptr); + } + else + { + 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) { - glActiveTexture(GL_TEXTURE0+n); - device_buffers[n]->bind(); + local_key_buffer.first = 0; + local_key_buffer.second.reset(); } - - auto& p = transform.get_position(); - auto& s = transform.get_size(); - auto& uv = transform.get_uv(); - - glBegin(GL_QUADS); - glTexCoord2d(uv[0], uv[3]); glVertex2d( p[0]*2.0-1.0, p[1]*2.0-1.0); - glTexCoord2d(uv[2], uv[3]); glVertex2d((p[0]+s[0])*2.0-1.0, p[1]*2.0-1.0); - glTexCoord2d(uv[2], uv[1]); glVertex2d((p[0]+s[0])*2.0-1.0, (p[1]+s[1])*2.0-1.0); - glTexCoord2d(uv[0], uv[1]); glVertex2d( p[0]*2.0-1.0, (p[1]+s[1])*2.0-1.0); - glEnd(); - }); + } } - void end() + // TODO: Optimize + bool has_overlapping_items(const layer& layer, image_transform::blend_mode::type blend_mode) { - transform_stack_.pop(); - } + if(layer.size() < 2) + return false; + + implementation::layer fill; - boost::unique_future> begin_pass() - { - return context_->begin_invoke([=]() -> safe_ptr + std::copy_if(layer.begin(), layer.end(), std::back_inserter(fill), [&](const render_item& item) { - reading_->map(); - render_targets_[0]->attach(0); - GL(glClear(GL_COLOR_BUFFER_BIT)); - return safe_ptr(reading_); + 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) + { + return item.transform.get_opacity() < 1.0 - 0.001; + }); + } - void end_pass() - { - context_->begin_invoke([=] + // Simple solution, just check if we have differnt video streams / tags. + return std::any_of(fill.begin(), fill.end(), [&](const render_item& item) { - 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 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"); + + 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)); + + 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 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 pixel_format_desc::plane& plane) -> safe_ptr - { - return context_->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 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