X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fmixer%2Fimage%2Fimage_mixer.cpp;h=eda73da2f3af2a2ed7eb612998ab1057a155a3ba;hb=8f091990c8e3c1997b4b2d89f97b319cb6ea889d;hp=edf38213358bf778182108df2786b70fb24c1000;hpb=11f2a57b1d27aaf02f27d8e5d88c312b292f254c;p=casparcg diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp index edf382133..eda73da2f 100644 --- a/core/mixer/image/image_mixer.cpp +++ b/core/mixer/image/image_mixer.cpp @@ -20,120 +20,63 @@ #include "../../stdafx.h" #include "image_mixer.h" -#include "image_kernel.h" +#include "image_kernel.h" +#include "../write_frame.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 -namespace caspar { namespace core { - -struct image_mixer::implementation : boost::noncopyable -{ - typedef std::deque layer; - - video_channel_context& channel_; - - std::vector transform_stack_; - std::vector mode_stack_; - std::stack blend_stack_; +using namespace boost::assign; - std::deque> layers_; // layer/stream/items +namespace caspar { namespace core { - image_kernel kernel_; +typedef std::deque layer; +class image_renderer +{ + video_channel_context& channel_; + image_kernel kernel_; std::shared_ptr active_buffer_; public: - implementation(video_channel_context& video_channel) - : channel_(video_channel) - , transform_stack_(1) - , mode_stack_(1, video_mode::progressive) - { - } - - ~implementation() + image_renderer(video_channel_context& channel) + : channel_(channel) { - 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()); - - // 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(), blend_stack_.top()); - - auto& layer = layers_.back(); - - if(boost::range::find(layer, item) == layer.end()) - layer.push_back(item); - } - - void end() - { - transform_stack_.pop_back(); - mode_stack_.pop_back(); - } - - void begin_layer(blend_mode::type blend_mode) - { - blend_stack_.push(blend_mode); - layers_.push_back(layer()); - } - - void end_layer() - { - blend_stack_.pop(); - } - - boost::unique_future> render() + boost::unique_future> render(std::deque&& layers) { - auto layers = std::move(layers_); + auto layers2 = std::move(layers); return channel_.ogl().begin_invoke([=]() mutable { - return render(std::move(layers)); + return do_render(std::move(layers2)); }); } - safe_ptr render(std::deque&& layers) +private: + safe_ptr do_render(std::deque&& layers) { std::shared_ptr layer_key_buffer; auto draw_buffer = create_device_buffer(4); BOOST_FOREACH(auto& layer, layers) - draw(std::move(layer), draw_buffer, layer_key_buffer); + draw_layer(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); @@ -146,54 +89,50 @@ public: return host_buffer; } - // 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) + void draw_layer(layer&& layer, const safe_ptr& draw_buffer, std::shared_ptr& layer_key_buffer) { if(layer.empty()) return; - std::pair> local_key_buffer; + std::pair> local_key_buffer = std::make_pair(0, nullptr); // int is fields flag - if(has_overlapping_items(layer, layer.front().blend_mode)) + if(layer.front().blend_mode != blend_mode::normal && has_overlapping_items(layer)) { - auto local_draw_buffer = create_device_buffer(4); - - auto local_blend_mode = layer.front().blend_mode; + auto layer_draw_buffer = create_device_buffer(4); // int is fields flag + auto layer_blend_mode = layer.front().blend_mode; - int fields = 0; BOOST_FOREACH(auto& item, layer) { - if(fields & item.mode) - item.blend_mode = blend_mode::normal; // Disable blending, it will be used when merging back into render stack. - else - { - item.blend_mode = blend_mode::replace; // Target field is empty, no blending, just copy - fields |= item.mode; - } - - draw_item(std::move(item), local_draw_buffer, local_key_buffer, layer_key_buffer); + item.blend_mode = blend_mode::normal; // Disable blending and just merge. + draw_item(std::move(item), *layer_draw_buffer, local_key_buffer, layer_key_buffer); } - - kernel_.draw(channel_.ogl(), create_render_item(local_draw_buffer, local_blend_mode), draw_buffer, nullptr, nullptr); + + render_item item; + item.pix_desc.pix_fmt = pixel_format::bgra; + item.pix_desc.planes = list_of(pixel_format_desc::plane(channel_.get_format_desc().width, channel_.get_format_desc().height, 4)); + item.textures = list_of(layer_draw_buffer); + item.transform = frame_transform(); + item.blend_mode = layer_blend_mode; + + kernel_.draw(channel_.ogl(), std::move(item), *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); + draw_item(std::move(item), *draw_buffer, local_key_buffer, layer_key_buffer); } - CASPAR_ASSERT(local_key_buffer.first == 0 || local_key_buffer.first == core::video_mode::progressive); + CASPAR_ASSERT(local_key_buffer.first == 0 || local_key_buffer.first == core::field_mode::progressive); std::swap(local_key_buffer.second, layer_key_buffer); } void draw_item(render_item&& item, - const safe_ptr& draw_buffer, + device_buffer& draw_buffer, std::pair>& local_key_buffer, std::shared_ptr& layer_key_buffer) { - if(item.transform.get_is_key()) + if(item.transform.is_key) { if(!local_key_buffer.second) { @@ -201,15 +140,15 @@ public: local_key_buffer.second = create_device_buffer(1); } - local_key_buffer.first |= item.mode; - kernel_.draw(channel_.ogl(), std::move(item), make_safe(local_key_buffer.second), nullptr, nullptr); + local_key_buffer.first |= item.transform.field_mode; // Add field to flag. + kernel_.draw(channel_.ogl(), std::move(item), *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; + local_key_buffer.first ^= item.transform.field_mode; // Remove field from flag. - if(local_key_buffer.first == 0) + if(local_key_buffer.first == 0) // If all fields from key has been used, reset it { local_key_buffer.first = 0; local_key_buffer.second.reset(); @@ -217,64 +156,88 @@ public: } } - //// TODO: Optimize - bool has_overlapping_items(const layer& layer, blend_mode::type blend_mode) - { - if(layer.size() < 2) - return false; - - if(blend_mode == blend_mode::normal) - return false; - - return std::any_of(layer.begin(), layer.end(), [&](const render_item& item) + bool has_overlapping_items(const layer& layer) + { + auto upper_count = boost::range::count_if(layer, [&](const render_item& item) { - return item.tag != layer.front().tag; + return !item.transform.is_key && (item.transform.field_mode & field_mode::upper); }); - //std::copy_if(layer.begin(), layer.end(), std::back_inserter(fill), [&](const render_item& item) - //{ - // return !item.transform.get_is_key(); - //}); - // - //if(blend_mode == 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; - // }); - //} + auto lower_count = boost::range::count_if(layer, [&](const render_item& item) + { + return !item.transform.is_key && (item.transform.field_mode & field_mode::lower); + }); - //// 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; - //}); + return upper_count > 1 || lower_count > 1; } - render_item create_render_item(const safe_ptr& buffer, blend_mode::type blend_mode) + safe_ptr create_device_buffer(size_t stride) { - CASPAR_ASSERT(buffer->stride() == 4 && "Only used for bgra textures"); + auto buffer = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, stride); + channel_.ogl().clear(*buffer); + return buffer; + } +}; - 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)); + +struct image_mixer::implementation : boost::noncopyable +{ + ogl_device& ogl_; + image_renderer renderer_; + std::vector transform_stack_; + blend_mode::type active_blend_mode_; + std::deque> layers_; // layer/stream/items +public: + implementation(video_channel_context& video_channel) + : ogl_(video_channel.ogl()) + , renderer_(video_channel) + , transform_stack_(1) + , active_blend_mode_(blend_mode::normal) + { + } - std::vector> textures; - textures.push_back(buffer); - - return render_item(desc, std::move(textures), image_transform(), video_mode::progressive, nullptr, blend_mode); + void begin_layer(blend_mode::type blend_mode) + { + active_blend_mode_ = blend_mode; + layers_ += layer(); + } + + void begin(core::basic_frame& frame) + { + transform_stack_.push_back(transform_stack_.back()*frame.get_frame_transform()); + } + + void visit(core::write_frame& frame) + { + if(transform_stack_.back().field_mode == field_mode::empty) + return; + + core::render_item item; + item.pix_desc = frame.get_pixel_format_desc(); + item.textures = frame.get_textures(); + item.transform = transform_stack_.back(); + item.blend_mode = active_blend_mode_; + + layers_.back() += item; } - safe_ptr create_device_buffer(size_t stride) + void end() { - auto buffer = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, stride); - channel_.ogl().clear(*buffer); - return buffer; + transform_stack_.pop_back(); + } + + void end_layer() + { + } + + boost::unique_future> render() + { + return renderer_.render(std::move(layers_)); } safe_ptr create_frame(const void* tag, const core::pixel_format_desc& desc) { - return make_safe(channel_.ogl(), tag, desc); + return make_safe(ogl_, tag, desc); } };