git-svn-id: https://casparcg.svn.sourceforge.net/svnroot/casparcg/server/branches...

diff --git a/accelerator/ogl/image/image_kernel.cpp b/accelerator/ogl/image/image_kernel.cpp
index 1919a75e8927034a7f9104f2e66acaeff4688ba8..37e67c2d7c8f73037696d2ef2e0e752037b1f59c 100644 (file)
--- a/accelerator/ogl/image/image_kernel.cpp
+++ b/accelerator/ogl/image/image_kernel.cpp
@@ -66,7 +66,7 @@ struct image_kernel::impl : boost::noncopyable
        {\r
        }\r
 \r
-       void draw(draw_params&& params)\r
+       void draw(draw_params params)\r
        {\r
                static const double epsilon = 0.001;            \r
                \r
@@ -227,13 +227,8 @@ struct image_kernel::impl : boost::noncopyable
 };\r
 \r
 image_kernel::image_kernel(const spl::shared_ptr<device>& ogl) : impl_(new impl(ogl)){}\r
-void image_kernel::draw(draw_params&& params)\r
-{\r
-       impl_->draw(std::move(params));\r
-}\r
-bool image_kernel::has_blend_modes() const\r
-{\r
-       return impl_->blend_modes_;\r
-}\r
+image_kernel::~image_kernel(){}\r
+void image_kernel::draw(const draw_params& params){impl_->draw(params);}\r
+bool image_kernel::has_blend_modes() const{return impl_->blend_modes_;}\r
 \r
 }}}
\ No newline at end of file

diff --git a/accelerator/ogl/image/image_kernel.h b/accelerator/ogl/image/image_kernel.h
index aaef959f4717d4065d1c52fd5e800453e0df475e..37def871ccf164ca3db8eb51efeea7cc623b7c65 100644 (file)
--- a/accelerator/ogl/image/image_kernel.h
+++ b/accelerator/ogl/image/image_kernel.h
@@ -29,8 +29,6 @@
 #include <core/frame/pixel_format.h>\r
 #include <core/frame/frame_transform.h>\r
 \r
-#include <boost/noncopyable.hpp>\r
-\r
 namespace caspar { namespace accelerator { namespace ogl {\r
        \r
 struct keyer_def\r
@@ -45,11 +43,11 @@ typedef enum_class<keyer_def> keyer;
 \r
 struct draw_params sealed\r
 {\r
-       core::pixel_format_desc                                                         pix_desc;\r
+       core::pixel_format_desc                                         pix_desc;\r
        std::vector<spl::shared_ptr<class texture>>     textures;\r
-       core::image_transform                                                           transform;\r
-       core::blend_mode                                                                        blend_mode;\r
-       keyer                                                                                           keyer;\r
+       core::image_transform                                           transform;\r
+       core::blend_mode                                                        blend_mode;\r
+       keyer                                                                           keyer;\r
        std::shared_ptr<class texture>                          background;\r
        std::shared_ptr<class texture>                          local_key;\r
        std::shared_ptr<class texture>                          layer_key;\r
@@ -62,8 +60,10 @@ struct draw_params sealed
        }\r
 };\r
 \r
-class image_kernel sealed : boost::noncopyable\r
+class image_kernel sealed\r
 {\r
+       image_kernel(const image_kernel&);\r
+       image_kernel& operator=(const image_kernel&);\r
 public:\r
 \r
        // Static Members\r
@@ -71,17 +71,18 @@ public:
        // Constructors\r
 \r
        image_kernel(const spl::shared_ptr<class device>& ogl);\r
+       ~image_kernel();\r
 \r
        // Methods\r
 \r
-       void draw(draw_params&& params);\r
+       void draw(const draw_params& params);\r
        \r
        // Properties\r
 \r
        bool has_blend_modes() const;\r
 private:\r
        struct impl;\r
-       spl::shared_ptr<impl> impl_;\r
+       spl::unique_ptr<impl> impl_;\r
 };\r
 \r
 }}}
\ No newline at end of file

diff --git a/accelerator/ogl/image/image_mixer.cpp b/accelerator/ogl/image/image_mixer.cpp
index aa0359b12728c0aac3612814cc26cab2c1d3f9f7..df815f0d3dc98c6ce35b0749da0409d839a0ee3e 100644 (file)
--- a/accelerator/ogl/image/image_mixer.cpp
+++ b/accelerator/ogl/image/image_mixer.cpp
@@ -109,38 +109,38 @@ public:
 \r
                return flatten(ogl_->begin_invoke([=]() mutable -> boost::shared_future<array<const std::uint8_t>>\r
                {\r
-                       auto draw_buffer = create_mixer_buffer(format_desc.width, format_desc.height, 4);\r
+                       auto target_texture = ogl_->create_texture(format_desc.width, format_desc.height, 4);\r
 \r
                        if(format_desc.field_mode != core::field_mode::progressive)\r
                        {\r
-                               draw(layers,                    draw_buffer, format_desc, core::field_mode::upper);\r
-                               draw(std::move(layers), draw_buffer, format_desc, core::field_mode::lower);\r
+                               draw(target_texture, layers,                    format_desc, core::field_mode::upper);\r
+                               draw(target_texture, std::move(layers), format_desc, core::field_mode::lower);\r
                        }\r
                        else                    \r
-                               draw(std::move(layers), draw_buffer, format_desc, core::field_mode::progressive);\r
+                               draw(target_texture, std::move(layers), format_desc, core::field_mode::progressive);\r
                                                                \r
-                       return make_shared(ogl_->copy_async(draw_buffer));\r
+                       return make_shared(ogl_->copy_async(target_texture));\r
                }));\r
        }\r
 \r
 private:       \r
        \r
-       void draw(std::vector<layer>                            layers, \r
-                         spl::shared_ptr<texture>&                     draw_buffer, \r
+       void draw(spl::shared_ptr<texture>&                     target_texture, \r
+                         std::vector<layer>                            layers, \r
                          const core::video_format_desc&        format_desc,\r
                          core::field_mode                                      field_mode)\r
        {\r
-               std::shared_ptr<texture> layer_key_buffer;\r
+               std::shared_ptr<texture> layer_key_texture;\r
 \r
                BOOST_FOREACH(auto& layer, layers)\r
-                       draw_layer(std::move(layer), draw_buffer, layer_key_buffer, format_desc, field_mode);\r
+                       draw(target_texture, std::move(layer), layer_key_texture, format_desc, field_mode);\r
        }\r
 \r
-       void draw_layer(layer                                                   layer, \r
-                                       spl::shared_ptr<texture>&               draw_buffer,\r
-                                       std::shared_ptr<texture>&               layer_key_buffer,\r
-                                       const core::video_format_desc&  format_desc,\r
-                                       core::field_mode                                field_mode)\r
+       void draw(spl::shared_ptr<texture>&             target_texture,\r
+                         layer                                                 layer, \r
+                         std::shared_ptr<texture>&             layer_key_texture,\r
+                         const core::video_format_desc&        format_desc,\r
+                         core::field_mode                              field_mode)\r
        {               \r
                // Fix frames           \r
                BOOST_FOREACH(auto& item, layer.items)          \r
@@ -177,35 +177,35 @@ private:
                if(layer.items.empty())\r
                        return;\r
 \r
-               std::shared_ptr<texture> local_key_buffer;\r
-               std::shared_ptr<texture> local_mix_buffer;\r
+               std::shared_ptr<texture> local_key_texture;\r
+               std::shared_ptr<texture> local_mix_texture;\r
                                \r
                if(layer.blend_mode != core::blend_mode::normal)\r
                {\r
-                       auto layer_draw_buffer = create_mixer_buffer(draw_buffer->width(), draw_buffer->height(), 4);\r
+                       auto layer_texture = ogl_->create_texture(target_texture->width(), target_texture->height(), 4);\r
 \r
                        BOOST_FOREACH(auto& item, layer.items)\r
-                               draw_item(std::move(item), layer_draw_buffer, layer_key_buffer, local_key_buffer, local_mix_buffer);    \r
+                               draw(layer_texture, std::move(item), layer_key_texture, local_key_texture, local_mix_texture);  \r
                \r
-                       draw_mixer_buffer(layer_draw_buffer, std::move(local_mix_buffer), core::blend_mode::normal);                                                    \r
-                       draw_mixer_buffer(draw_buffer, std::move(layer_draw_buffer), layer.blend_mode);\r
+                       draw(layer_texture, std::move(local_mix_texture), core::blend_mode::normal);                                                    \r
+                       draw(target_texture, std::move(layer_texture), layer.blend_mode);\r
                }\r
                else // fast path\r
                {\r
                        BOOST_FOREACH(auto& item, layer.items)          \r
-                               draw_item(std::move(item), draw_buffer, layer_key_buffer, local_key_buffer, local_mix_buffer);          \r
+                               draw(target_texture, std::move(item), layer_key_texture, local_key_texture, local_mix_texture);         \r
                                        \r
-                       draw_mixer_buffer(draw_buffer, std::move(local_mix_buffer), core::blend_mode::normal);\r
+                       draw(target_texture, std::move(local_mix_texture), core::blend_mode::normal);\r
                }                                       \r
 \r
-               layer_key_buffer = std::move(local_key_buffer);\r
+               layer_key_texture = std::move(local_key_texture);\r
        }\r
 \r
-       void draw_item(item                                                     item, \r
-                                  spl::shared_ptr<texture>&    draw_buffer, \r
-                                  std::shared_ptr<texture>&    layer_key_buffer, \r
-                                  std::shared_ptr<texture>&    local_key_buffer, \r
-                                  std::shared_ptr<texture>&    local_mix_buffer)\r
+       void draw(spl::shared_ptr<texture>&     target_texture, \r
+                         item                                          item, \r
+                     std::shared_ptr<texture>& layer_key_texture, \r
+                         std::shared_ptr<texture>&     local_key_texture, \r
+                         std::shared_ptr<texture>&     local_mix_texture)\r
        {                                       \r
                draw_params draw_params;\r
                draw_params.pix_desc    = std::move(item.pix_desc);\r
@@ -215,9 +215,9 @@ private:
 \r
                if(item.transform.is_key)\r
                {\r
-                       local_key_buffer = local_key_buffer ? local_key_buffer : create_mixer_buffer(draw_buffer->width(), draw_buffer->height(), 1);\r
+                       local_key_texture = local_key_texture ? local_key_texture : ogl_->create_texture(target_texture->width(), target_texture->height(), 1);\r
 \r
-                       draw_params.background                  = local_key_buffer;\r
+                       draw_params.background                  = local_key_texture;\r
                        draw_params.local_key                   = nullptr;\r
                        draw_params.layer_key                   = nullptr;\r
 \r
@@ -225,11 +225,11 @@ private:
                }\r
                else if(item.transform.is_mix)\r
                {\r
-                       local_mix_buffer = local_mix_buffer ? local_mix_buffer : create_mixer_buffer(draw_buffer->width(), draw_buffer->height(), 4);\r
+                       local_mix_texture = local_mix_texture ? local_mix_texture : ogl_->create_texture(target_texture->width(), target_texture->height(), 4);\r
 \r
-                       draw_params.background                  = local_mix_buffer;\r
-                       draw_params.local_key                   = std::move(local_key_buffer);\r
-                       draw_params.layer_key                   = layer_key_buffer;\r
+                       draw_params.background                  = local_mix_texture;\r
+                       draw_params.local_key                   = std::move(local_key_texture);\r
+                       draw_params.layer_key                   = layer_key_texture;\r
 \r
                        draw_params.keyer                               = keyer::additive;\r
 \r
@@ -237,19 +237,19 @@ private:
                }\r
                else\r
                {\r
-                       draw_mixer_buffer(draw_buffer, std::move(local_mix_buffer), core::blend_mode::normal);\r
+                       draw(target_texture, std::move(local_mix_texture), core::blend_mode::normal);\r
                        \r
-                       draw_params.background                  = draw_buffer;\r
-                       draw_params.local_key                   = std::move(local_key_buffer);\r
-                       draw_params.layer_key                   = layer_key_buffer;\r
+                       draw_params.background                  = target_texture;\r
+                       draw_params.local_key                   = std::move(local_key_texture);\r
+                       draw_params.layer_key                   = layer_key_texture;\r
 \r
                        kernel_.draw(std::move(draw_params));\r
                }       \r
        }\r
 \r
-       void draw_mixer_buffer(spl::shared_ptr<texture>&        draw_buffer, \r
-                                                  std::shared_ptr<texture>&&   source_buffer, \r
-                                                  core::blend_mode                             blend_mode = core::blend_mode::normal)\r
+       void draw(spl::shared_ptr<texture>&      target_texture, \r
+                         std::shared_ptr<texture>&& source_buffer, \r
+                         core::blend_mode                       blend_mode = core::blend_mode::normal)\r
        {\r
                if(!source_buffer)\r
                        return;\r
@@ -260,17 +260,10 @@ private:
                draw_params.textures                    = list_of(source_buffer);\r
                draw_params.transform                   = core::image_transform();\r
                draw_params.blend_mode                  = blend_mode;\r
-               draw_params.background                  = draw_buffer;\r
+               draw_params.background                  = target_texture;\r
 \r
                kernel_.draw(std::move(draw_params));\r
        }\r
-                       \r
-       spl::shared_ptr<texture> create_mixer_buffer(int width, int height, int stride)\r
-       {\r
-               auto buffer = ogl_->create_texture(width, height, stride);\r
-               buffer->clear();\r
-               return buffer;\r
-       }\r
 };\r
                \r
 struct image_mixer::impl : boost::noncopyable\r

diff --git a/accelerator/ogl/util/device.cpp b/accelerator/ogl/util/device.cpp
index 6d10667743b5c79c47bd0f38562e719420d94843..d01b380c382fc0ca712d368924b97b10c7dde43e 100644 (file)
--- a/accelerator/ogl/util/device.cpp
+++ b/accelerator/ogl/util/device.cpp
@@ -154,20 +154,26 @@ struct device::impl : public std::enable_shared_from_this<impl>
                }\r
        }\r
                                                        \r
-       spl::shared_ptr<texture> create_texture(int width, int height, int stride)\r
+       spl::shared_ptr<texture> create_texture(int width, int height, int stride, bool clear = false)\r
        {\r
-               CASPAR_VERIFY(stride > 0 && stride < 5);\r
-               CASPAR_VERIFY(width > 0 && height > 0);\r
+               return render_executor_.invoke([=]() -> spl::shared_ptr<texture>\r
+               {\r
+                       CASPAR_VERIFY(stride > 0 && stride < 5);\r
+                       CASPAR_VERIFY(width > 0 && height > 0);\r
                \r
-               auto pool = &device_pools_[stride-1][((width << 16) & 0xFFFF0000) | (height & 0x0000FFFF)];\r
+                       auto pool = &device_pools_[stride-1][((width << 16) & 0xFFFF0000) | (height & 0x0000FFFF)];\r
                \r
-               std::shared_ptr<texture> buffer;\r
-               if(!pool->try_pop(buffer))              \r
-                       buffer = spl::make_shared<texture>(width, height, stride);\r
+                       std::shared_ptr<texture> buffer;\r
+                       if(!pool->try_pop(buffer))              \r
+                               buffer = spl::make_shared<texture>(width, height, stride);\r
        \r
-               return spl::shared_ptr<texture>(buffer.get(), [buffer, pool](texture*) mutable\r
-               {               \r
-                       pool->push(buffer);     \r
+                       if(clear)\r
+                               buffer->clear();\r
+\r
+                       return spl::shared_ptr<texture>(buffer.get(), [buffer, pool](texture*) mutable\r
+                       {               \r
+                               pool->push(buffer);     \r
+                       });\r
                });\r
        }\r
                \r
@@ -229,7 +235,6 @@ struct device::impl : public std::enable_shared_from_this<impl>
                        texture_cache_.insert(std::make_pair(buf.get(), texture));\r
 \r
                        return texture;\r
-\r
                }, task_priority::high_priority);\r
        }\r
        \r
@@ -239,7 +244,7 @@ struct device::impl : public std::enable_shared_from_this<impl>
                                \r
                return render_executor_.begin_invoke([=]() -> spl::shared_ptr<texture>\r
                {\r
-                       auto texture = create_texture(width, height, stride);\r
+                       auto texture = create_texture(width, height, stride, false);\r
                        texture->copy_from(*buf);                               \r
                        return texture;\r
                }, task_priority::high_priority);\r
@@ -269,7 +274,7 @@ device::device()
        : executor_(L"OpenGL Rendering Context.")\r
        , impl_(new impl(executor_)){}\r
 device::~device(){}\r
-spl::shared_ptr<texture>                                                       device::create_texture(int width, int height, int stride){return impl_->create_texture(width, height, stride);}\r
+spl::shared_ptr<texture>                                                       device::create_texture(int width, int height, int stride){return impl_->create_texture(width, height, stride, true);}\r
 array<std::uint8_t>                                                                    device::create_array(int size){return impl_->create_array(size);}\r
 boost::unique_future<spl::shared_ptr<texture>>         device::copy_async(const array<const std::uint8_t>& source, int width, int height, int stride){return impl_->copy_async(source, width, height, stride);}\r
 boost::unique_future<spl::shared_ptr<texture>>         device::copy_async(const array<std::uint8_t>& source, int width, int height, int stride){return impl_->copy_async(source, width, height, stride);}\r

diff --git a/accelerator/ogl/util/texture.cpp b/accelerator/ogl/util/texture.cpp
index a1b7af20928f362403660be6b4b9d93049219272..34d7a344c2ccf341d8a5142a1eb715314e8fb972 100644 (file)
--- a/accelerator/ogl/util/texture.cpp
+++ b/accelerator/ogl/util/texture.cpp
@@ -40,11 +40,6 @@ static GLenum FORMAT[] = {0, GL_RED, GL_RG, GL_BGR, GL_BGRA};
 static GLenum INTERNAL_FORMAT[] = {0, GL_R8, GL_RG8, GL_RGB8, GL_RGBA8};       \r
 static GLenum TYPE[] = {0, GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE, GL_UNSIGNED_INT_8_8_8_8_REV}; \r
 \r
-unsigned int format(int stride)\r
-{\r
-       return FORMAT[stride];\r
-}\r
-\r
 static tbb::atomic<int> g_total_count;\r
 \r
 struct texture::impl : boost::noncopyable\r

diff --git a/accelerator/ogl/util/texture.h b/accelerator/ogl/util/texture.h
index 1f05b9c47832afd36b58fa6489842b859637e2b8..3793bdc12fd82c812dcc158b690686f44bba0c05 100644 (file)
--- a/accelerator/ogl/util/texture.h
+++ b/accelerator/ogl/util/texture.h
@@ -70,6 +70,4 @@ private:
        spl::unique_ptr<impl> impl_;\r
 };\r
        \r
-unsigned int format(int stride);\r
-\r
 }}}
\ No newline at end of file

diff --git a/core/mixer/mixer.cpp b/core/mixer/mixer.cpp
index 3ce5dda3cd0eb8d84a59005f5694e612858dba0f..70bade57f905709474557f9b89d8f6875f7d6543 100644 (file)
--- a/core/mixer/mixer.cpp
+++ b/core/mixer/mixer.cpp
@@ -71,8 +71,6 @@ public:
                , executor_(L"mixer")\r
        {                       \r
                graph_->set_color("mix-time", diagnostics::color(1.0f, 0.0f, 0.9f, 0.8));\r
-               graph_->set_color("audio-mix-time", diagnostics::color(1.0f, 0.0f, 0.0f, 0.8));\r
-               graph_->set_color("video-mix-time", diagnostics::color(0.0f, 1.0f, 1.0f, 0.8));\r
        }       \r
        \r
        const_frame operator()(std::map<int, draw_frame> frames, const video_format_desc& format_desc)\r
@@ -94,14 +92,8 @@ public:
                                        image_mixer_->end_layer();\r
                                }\r
                                \r
-                               boost::timer video_frame_timer;\r
                                auto image = (*image_mixer_)(format_desc);\r
-                               graph_->set_value("video-mix-time", video_frame_timer.elapsed()*format_desc.fps*0.5);\r
-\r
-                               \r
-                               boost::timer audio_frame_timer;\r
                                auto audio = audio_mixer_(format_desc);\r
-                               graph_->set_value("audio-mix-time", audio_frame_timer.elapsed()*format_desc.fps*0.5);\r
                                \r
                                graph_->set_value("mix-time", frame_timer.elapsed()*format_desc.fps*0.5);\r
 \r