2.0. - image_mixer: Fixed bug where amongst others mixing to alpha did not work.

     - misc: Added some todo comments.

git-svn-id: https://casparcg.svn.sourceforge.net/svnroot/casparcg/server/branches/2.0.0.2@1191 362d55ac-95cf-4e76-9f9a-cbaa9c17b72d

diff --git a/common/log/log.cpp b/common/log/log.cpp
index d6cc96d5777207df480e2a038f9c676cee915a70..607e050523c6e929e4357f1da26a0134fed9cf46 100644 (file)
--- a/common/log/log.cpp
+++ b/common/log/log.cpp
@@ -17,6 +17,9 @@
 *    along with CasparCG.  If not, see <http://www.gnu.org/licenses/>.\r
 *\r
 */\r
+// TODO: Colors in console.\r
+// TODO: Think through filters.\r
+\r
 #include "../stdafx.h"\r
 \r
 #if defined(_MSC_VER)\r

diff --git a/common/memory/safe_ptr.h b/common/memory/safe_ptr.h
index f649f0e06c7f5efe82fef3c86d239bd350491f8b..e4269e69bd2166f96f984fb8287e930b77aafa7a 100644 (file)
--- a/common/memory/safe_ptr.h
+++ b/common/memory/safe_ptr.h
@@ -154,6 +154,18 @@ bool operator==(const safe_ptr<T>& a, const safe_ptr<U>& b)  // noexcept
        return a.get() == b.get();\r
 }\r
 \r
+template<class T, class U>\r
+bool operator!=(const std::shared_ptr<T>& a, const safe_ptr<U>& b)  // noexcept\r
+{\r
+       return a.get() != b.get();\r
+}\r
+\r
+template<class T, class U>\r
+bool operator!=(const safe_ptr<T>& a, const std::shared_ptr<U>& b)  // noexcept\r
+{\r
+       return a.get() != b.get();\r
+}\r
+\r
 template<class T, class U>\r
 bool operator!=(const safe_ptr<T>& a, const safe_ptr<U>& b) // noexcept\r
 {\r

diff --git a/core/mixer/gpu/ogl_device.cpp b/core/mixer/gpu/ogl_device.cpp
index 2d8aad35b44f625e4cf967af63944bc33a5d5e46..95c5ca3b3806c7337cc6d3817e2cc1d0f5ab990a 100644 (file)
--- a/core/mixer/gpu/ogl_device.cpp
+++ b/core/mixer/gpu/ogl_device.cpp
@@ -17,6 +17,8 @@
 *    along with CasparCG.  If not, see <http://www.gnu.org/licenses/>.\r
 *\r
 */\r
+// TODO: Smart GC\r
+\r
 #include "../../stdafx.h"\r
 \r
 #include "ogl_device.h"\r

diff --git a/core/mixer/image/image_kernel.cpp b/core/mixer/image/image_kernel.cpp
index 1e3722762e385e471b99fb1e44721e1da729b070..31e7440ff76101ef0904ebd2fc446821b26ecb8a 100644 (file)
--- a/core/mixer/image/image_kernel.cpp
+++ b/core/mixer/image/image_kernel.cpp
@@ -77,6 +77,12 @@ struct image_kernel::implementation : boost::noncopyable
                if(item.transform.get_opacity() < epsilon)\r
                        return;\r
                \r
+               if(!std::all_of(item.textures.begin(), item.textures.end(), std::mem_fn(&device_buffer::ready)))\r
+               {\r
+                       CASPAR_LOG(warning) << L"[image_mixer] Performance warning. Host to device transfer not complete, GPU will be stalled";\r
+                       ogl.yield(); // Try to give it some more time.\r
+               }               \r
+               \r
                // Bind textures\r
 \r
                for(size_t n = 0; n < item.textures.size(); ++n)\r
@@ -167,7 +173,7 @@ struct image_kernel::implementation : boost::noncopyable
                \r
                ogl.viewport(0, 0, background->width(), background->height());\r
 \r
-               GL(glColor4d(item.transform.get_gain(), item.transform.get_gain(), item.transform.get_gain(), item.transform.get_opacity()));\r
+               GL(glColor4d(item.transform.get_gain(), item.transform.get_gain(), item.transform.get_gain(), item.transform.get_is_key() ? 1.0 : item.transform.get_opacity()));\r
                                                \r
                auto m_p = item.transform.get_clip_translation();\r
                auto m_s = item.transform.get_clip_scale();\r

diff --git a/core/mixer/image/image_mixer.cpp b/core/mixer/image/image_mixer.cpp
index c0f82f07d1a4095e40631d774b72f8d5677997c8..9192b67f83125af680c4720af532229447e4d784 100644 (file)
--- a/core/mixer/image/image_mixer.cpp
+++ b/core/mixer/image/image_mixer.cpp
@@ -142,53 +142,35 @@ public:
                return host_buffer;\r
        }\r
 \r
+       // TODO: We might have more overlaps for opacity transitions\r
+       // TODO: What about blending modes, are they ok? Maybe only overlap detection is required for opacity?\r
        void draw(layer&& layer, std::shared_ptr<device_buffer>& layer_key_buffer)\r
-       {                                       \r
-               std::shared_ptr<device_buffer> local_key_buffer;\r
-                               \r
-               std::shared_ptr<device_buffer> atomic_draw_buffer;              \r
-               std::shared_ptr<device_buffer> atomic_local_key_buffer;\r
+       {                               \r
+               if(layer.empty())\r
+                       return;\r
 \r
-               BOOST_FOREACH(auto& item, layer)\r
+               std::shared_ptr<device_buffer> local_key_buffer;\r
+                                       \r
+               if(has_overlapping_items(layer, layer.front().transform.get_blend_mode()))\r
                {\r
-                       //if(item.transform.get_is_atomic()) // layers need to be atomic in-order to support blend-modes properly\r
-                       //{\r
-                       //      if(!atomic_draw_buffer)\r
-                       //      {\r
-                       //              atomic_draw_buffer = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, 4);       \r
-                       //              channel_.ogl().clear(*atomic_draw_buffer);\r
-                       //      }\r
-\r
-                       //      draw(std::move(item), atomic_draw_buffer, atomic_local_key_buffer, nullptr);\r
-                       //}\r
-                       //else\r
-                       //{\r
-                       //      if(atomic_draw_buffer)\r
-                       //      {\r
-                       //              pixel_format_desc desc;\r
-                       //              desc.pix_fmt = pixel_format::bgra;\r
-                       //              desc.planes.push_back(pixel_format_desc::plane(channel_.get_format_desc().width, channel_.get_format_desc().height, 4));\r
-\r
-                       //              std::vector<safe_ptr<device_buffer>> textures;\r
-                       //              textures.push_back(make_safe(atomic_draw_buffer));\r
-                       //              \r
-                       //              atomic_draw_buffer.reset();\r
-                       //              atomic_local_key_buffer.reset();\r
-                       //              \r
-                       //              render_item atomic_item(desc, std::move(textures), image_transform(), video_mode::progressive, nullptr);\r
-                       //              draw(std::move(atomic_item), draw_buffer_, local_key_buffer, layer_key_buffer);\r
-                       //      }\r
-\r
-                       //      draw(std::move(item), draw_buffer_, local_key_buffer, layer_key_buffer);\r
-                       //}\r
-\r
-                       draw(std::move(item), local_key_buffer, layer_key_buffer);\r
+                       auto local_draw_buffer = channel_.ogl().create_device_buffer(channel_.get_format_desc().width, channel_.get_format_desc().height, 4);   \r
+                       channel_.ogl().clear(*local_draw_buffer);\r
+\r
+                       BOOST_FOREACH(auto& item, layer)                \r
+                               draw_item(std::move(item), local_draw_buffer, local_key_buffer, layer_key_buffer);              \r
+                                                       \r
+                       kernel_.draw(channel_.ogl(), create_render_item(local_draw_buffer, layer.front().transform.get_blend_mode()), make_safe(draw_buffer_), nullptr, nullptr);\r
                }\r
-               \r
+               else // fast path\r
+               {\r
+                       BOOST_FOREACH(auto& item, layer)                \r
+                               draw_item(std::move(item), make_safe(draw_buffer_), local_key_buffer, layer_key_buffer);                \r
+               }                                       \r
+\r
                std::swap(local_key_buffer, layer_key_buffer);\r
        }\r
 \r
-       void draw(render_item&& item, std::shared_ptr<device_buffer>& local_key_buffer, std::shared_ptr<device_buffer>& layer_key_buffer)\r
+       void draw_item(render_item&& item, const safe_ptr<device_buffer>& draw_buffer, std::shared_ptr<device_buffer>& local_key_buffer, std::shared_ptr<device_buffer>& layer_key_buffer)\r
        {                                                                                       \r
                if(item.transform.get_is_key())\r
                {\r
@@ -198,26 +180,60 @@ public:
                                channel_.ogl().clear(*local_key_buffer);\r
                        }\r
 \r
-                       draw(std::move(item), local_key_buffer, nullptr, nullptr);\r
+                       kernel_.draw(channel_.ogl(), std::move(item), make_safe(local_key_buffer), nullptr, nullptr);\r
                }\r
                else\r
                {\r
-                       draw(std::move(item), draw_buffer_, local_key_buffer, layer_key_buffer);        \r
+                       kernel_.draw(channel_.ogl(), std::move(item), draw_buffer, local_key_buffer, layer_key_buffer);\r
                        local_key_buffer.reset();\r
                }\r
        }\r
-       \r
-       void draw(render_item&& item, std::shared_ptr<device_buffer>& draw_buffer, const std::shared_ptr<device_buffer>& local_key, const std::shared_ptr<device_buffer>& layer_key)\r
+                       \r
+       render_item create_render_item(const safe_ptr<device_buffer>& buffer, image_transform::blend_mode::type blend_mode)\r
        {\r
-               if(!std::all_of(item.textures.begin(), item.textures.end(), std::mem_fn(&device_buffer::ready)))\r
-               {\r
-                       CASPAR_LOG(warning) << L"[image_mixer] Performance warning. Host to device transfer not complete, GPU will be stalled";\r
-                       channel_.ogl().yield(); // Try to give it some more time.\r
-               }               \r
+               CASPAR_ASSERT(buffer->stride() == 4 && "Only used for bgra textures");\r
 \r
-               kernel_.draw(channel_.ogl(), std::move(item), make_safe(draw_buffer), local_key, layer_key);\r
-       }\r
+               pixel_format_desc desc;\r
+               desc.pix_fmt = pixel_format::bgra;\r
+               desc.planes.push_back(pixel_format_desc::plane(channel_.get_format_desc().width, channel_.get_format_desc().height, 4));\r
+\r
+               std::vector<safe_ptr<device_buffer>> textures;\r
+               textures.push_back(buffer);\r
                                \r
+               image_transform transform;\r
+               transform.set_blend_mode(blend_mode);\r
+\r
+               return render_item(desc, std::move(textures), transform, video_mode::progressive, nullptr);              \r
+       }\r
+\r
+       // TODO: Optimize\r
+       bool has_overlapping_items(const layer& layer, image_transform::blend_mode::type blend_mode)\r
+       {\r
+               if(layer.empty())\r
+                       return false;   \r
+               \r
+               implementation::layer fill;\r
+\r
+               std::copy_if(layer.begin(), layer.end(), std::back_inserter(fill), [&](const render_item& item)\r
+               {\r
+                       return !item.transform.get_is_key();\r
+               });\r
+                       \r
+               if(blend_mode == image_transform::blend_mode::normal) // Only overlap if opacity\r
+               {\r
+                       return std::any_of(fill.begin(), fill.end(), [&](const render_item& item)\r
+                       {\r
+                               return item.transform.get_opacity() < 1.0 - 0.001;\r
+                       });\r
+               }\r
+\r
+               // Simple solution, just check if we have differnt video streams / tags.\r
+               return std::any_of(fill.begin(), fill.end(), [&](const render_item& item)\r
+               {\r
+                       return item.tag != fill.front().tag;\r
+               });\r
+       }               \r
+\r
        safe_ptr<write_frame> create_frame(const void* tag, const core::pixel_format_desc& desc)\r
        {\r
                return make_safe<write_frame>(channel_.ogl(), tag, desc);\r

diff --git a/core/producer/transition/transition_producer.cpp b/core/producer/transition/transition_producer.cpp
index 66c79b9ee3bfbc03d054b3ad951c5d39e034686e..b2f1dbafb7a4c04ea98971e525cdc740b1c92693 100644 (file)
--- a/core/producer/transition/transition_producer.cpp
+++ b/core/producer/transition/transition_producer.cpp
@@ -134,8 +134,8 @@ struct transition_producer : public frame_producer
                        d_frame1->get_image_transform().set_opacity(delta1);    \r
                        d_frame2->get_image_transform().set_opacity(delta2);\r
 \r
-                       //s_frame1->get_image_transform().set_opacity(1.0-delta1);      \r
-                       //s_frame2->get_image_transform().set_opacity(1.0-delta2);              \r
+                       s_frame1->get_image_transform().set_opacity(1.0-delta1);        \r
+                       s_frame2->get_image_transform().set_opacity(1.0-delta2);                \r
                }\r
                else if(info_.type == transition::slide)\r
                {\r

diff --git a/modules/image/producer/image_scroll_producer.cpp b/modules/image/producer/image_scroll_producer.cpp
index 900a7ab7da9135435edbe723e5c348797245f8df..cb48246b4f76159dce6fcbf495bf6e642f6d9b18 100644 (file)
--- a/modules/image/producer/image_scroll_producer.cpp
+++ b/modules/image/producer/image_scroll_producer.cpp
@@ -17,6 +17,9 @@
 *    along with CasparCG.  If not, see <http://www.gnu.org/licenses/>.\r
 *\r
 */\r
+// TODO: Refactor.\r
+// TODO: Looping.\r
+\r
 #include "image_scroll_producer.h"\r
 \r
 #include "../util/image_loader.h"\r