2.0 image_mixer: Refactored, core: Fixed destruction proxy usage.

[casparcg] / core / mixer / image / image_mixer.cpp

diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp
index eda73da2f3af2a2ed7eb612998ab1057a155a3ba..941e28d6c58fbbe18dd1c16af9671678bc07b915 100644 (file)
--- a/core/mixer/image/image_mixer.cpp
+++ b/core/mixer/image/image_mixer.cpp
@@ -30,6 +30,7 @@
 \r
 #include <common/exception/exceptions.h>\r
 #include <common/gl/gl_check.h>\r
+#include <common/utility/move_on_copy.h>\r
 \r
 #include <core/producer/frame/frame_transform.h>\r
 #include <core/producer/frame/pixel_format.h>\r
@@ -46,7 +47,15 @@ using namespace boost::assign;
 \r
 namespace caspar { namespace core {\r
        \r
-typedef std::deque<render_item>                                layer;\r
+struct layer\r
+{\r
+       std::vector<render_item> items;\r
+       blend_mode::type                 blend_mode;\r
+\r
+       layer(blend_mode::type blend_mode) : blend_mode(blend_mode)\r
+       {\r
+       }\r
+};\r
 \r
 class image_renderer\r
 {\r
@@ -59,17 +68,17 @@ public:
        {\r
        }\r
        \r
-       boost::unique_future<safe_ptr<host_buffer>> render(std::deque<layer>&& layers)\r
+       boost::unique_future<safe_ptr<host_buffer>> render(std::vector<layer>&& layers)\r
        {               \r
-               auto layers2 = std::move(layers);\r
-               return channel_.ogl().begin_invoke([=]() mutable\r
+               auto layers2 = make_move_on_copy(std::move(layers));\r
+               return channel_.ogl().begin_invoke([=]\r
                {\r
-                       return do_render(std::move(layers2));\r
+                       return do_render(std::move(layers2.value));\r
                });\r
        }\r
        \r
 private:\r
-       safe_ptr<host_buffer> do_render(std::deque<layer>&& layers)\r
+       safe_ptr<host_buffer> do_render(std::vector<layer>&& layers)\r
        {\r
                std::shared_ptr<device_buffer> layer_key_buffer;\r
 \r
@@ -91,34 +100,30 @@ private:
 \r
        void draw_layer(layer&& layer, const safe_ptr<device_buffer>& draw_buffer, std::shared_ptr<device_buffer>& layer_key_buffer)\r
        {                               \r
-               if(layer.empty())\r
+               if(layer.items.empty())\r
                        return;\r
 \r
                std::pair<int, std::shared_ptr<device_buffer>> local_key_buffer = std::make_pair(0, nullptr); // int is fields flag\r
                                \r
-               if(layer.front().blend_mode != blend_mode::normal && has_overlapping_items(layer))\r
+               if(layer.blend_mode != blend_mode::normal && has_overlapping_items(layer))\r
                {\r
                        auto layer_draw_buffer = create_device_buffer(4); // int is fields flag\r
-                       auto layer_blend_mode = layer.front().blend_mode;\r
 \r
-                       BOOST_FOREACH(auto& item, layer)\r
-                       {\r
-                               item.blend_mode = blend_mode::normal; // Disable blending and just merge.\r
+                       BOOST_FOREACH(auto& item, layer.items)\r
                                draw_item(std::move(item), *layer_draw_buffer, local_key_buffer, layer_key_buffer);             \r
-                       }\r
-                       \r
+                                               \r
                        render_item item;\r
                        item.pix_desc.pix_fmt   = pixel_format::bgra;\r
                        item.pix_desc.planes    = list_of(pixel_format_desc::plane(channel_.get_format_desc().width, channel_.get_format_desc().height, 4));\r
                        item.textures                   = list_of(layer_draw_buffer);\r
                        item.transform                  = frame_transform();\r
-                       item.blend_mode                 = layer_blend_mode;\r
+                       item.blend_mode                 = layer.blend_mode;\r
 \r
                        kernel_.draw(channel_.ogl(), std::move(item), *draw_buffer, nullptr, nullptr);\r
                }\r
                else // fast path\r
                {\r
-                       BOOST_FOREACH(auto& item, layer)                \r
+                       BOOST_FOREACH(auto& item, layer.items)          \r
                                draw_item(std::move(item), *draw_buffer, local_key_buffer, layer_key_buffer);           \r
                }                                       \r
 \r
@@ -158,12 +163,12 @@ private:
 \r
        bool has_overlapping_items(const layer& layer)\r
        {               \r
-               auto upper_count = boost::range::count_if(layer, [&](const render_item& item)\r
+               auto upper_count = boost::range::count_if(layer.items, [&](const render_item& item)\r
                {\r
                        return !item.transform.is_key && (item.transform.field_mode & field_mode::upper);\r
                });\r
 \r
-               auto lower_count = boost::range::count_if(layer, [&](const render_item& item)\r
+               auto lower_count = boost::range::count_if(layer.items, [&](const render_item& item)\r
                {\r
                        return  !item.transform.is_key && (item.transform.field_mode & field_mode::lower);\r
                });\r
@@ -182,24 +187,21 @@ private:
                \r
 struct image_mixer::implementation : boost::noncopyable\r
 {      \r
-       ogl_device&                                                             ogl_;\r
-       image_renderer                                                  renderer_;\r
-       std::vector<frame_transform>                    transform_stack_;\r
-       blend_mode::type                                                active_blend_mode_;\r
-       std::deque<std::deque<render_item>>             layers_; // layer/stream/items\r
+       ogl_device&                                             ogl_;\r
+       image_renderer                                  renderer_;\r
+       std::vector<frame_transform>    transform_stack_;\r
+       std::vector<layer>                              layers_; // layer/stream/items\r
 public:\r
        implementation(video_channel_context& video_channel) \r
                : ogl_(video_channel.ogl())\r
                , renderer_(video_channel)\r
-               , transform_stack_(1)\r
-               , active_blend_mode_(blend_mode::normal)                \r
+               , transform_stack_(1)   \r
        {\r
        }\r
 \r
        void begin_layer(blend_mode::type blend_mode)\r
        {\r
-               active_blend_mode_ = blend_mode;\r
-               layers_ += layer();\r
+               layers_.push_back(layer(blend_mode));\r
        }\r
                \r
        void begin(core::basic_frame& frame)\r
@@ -216,9 +218,8 @@ public:
                item.pix_desc   = frame.get_pixel_format_desc();\r
                item.textures   = frame.get_textures();\r
                item.transform  = transform_stack_.back();\r
-               item.blend_mode = active_blend_mode_;   \r
 \r
-               layers_.back() += item;\r
+               layers_.back().items.push_back(item);\r
        }\r
 \r
        void end()\r