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

diff --git a/core/consumer/output.cpp b/core/consumer/output.cpp
index 8c07ceff5010f78be8b3668c5854fc9f595ee75c..e8adaca5e5d6dde92e1db5af56a29e913edc0da8 100644 (file)
--- a/core/consumer/output.cpp
+++ b/core/consumer/output.cpp
@@ -150,7 +150,7 @@ public:
                        scoped_oversubcription_token oversubscribe;\r
                        timer_.tick(1.0/format_desc_.fps);\r
                }\r
-               \r
+       \r
                std::vector<int> removables;            \r
                Concurrency::parallel_for_each(consumers_.begin(), consumers_.end(), [&](const decltype(*consumers_.begin())& pair)\r
                {               \r

diff --git a/core/mixer/gpu/ogl_device.cpp b/core/mixer/gpu/ogl_device.cpp
index 5716204899487b4615526637d8da993b58888482..35c9f978e86c7c13dbf6c9ce496e2f89dc397bc6 100644 (file)
--- a/core/mixer/gpu/ogl_device.cpp
+++ b/core/mixer/gpu/ogl_device.cpp
@@ -179,9 +179,9 @@ safe_ptr<host_buffer> ogl_device::create_host_buffer(size_t size, host_buffer::u
        //++pool->usage_count;\r
        \r
        auto self = safe_from_this();\r
-       return safe_ptr<host_buffer>(buffer.get(), [self, pool, buffer, usage](host_buffer*) mutable\r
+       return safe_ptr<host_buffer>(buffer.get(), [self, pool, buffer, usage](host_buffer*)\r
        {\r
-               self->begin_invoke([=]() mutable\r
+               self->begin_invoke([=]()\r
                {               \r
                        if(usage == host_buffer::write_only)\r
                                buffer->map();\r

diff --git a/core/mixer/mixer.cpp b/core/mixer/mixer.cpp
index 2b9768c858dc4561e3c45c2f625882b587ea1e83..2df61eb4745e8b23d0ee98d3cfc0fe1eeef76777 100644 (file)
--- a/core/mixer/mixer.cpp
+++ b/core/mixer/mixer.cpp
@@ -114,41 +114,51 @@ public:
        {               \r
                auto frames = msg->value();\r
 \r
-               {\r
-                       critical_section::scoped_lock lock(mutex_);\r
+               auto frame = make_safe<read_frame>();\r
 \r
-                       BOOST_FOREACH(auto& frame, frames)\r
+               try\r
+               {\r
                        {\r
-                               auto blend_it = blend_modes_.find(frame.first);\r
-                               image_mixer_.begin_layer(blend_it != blend_modes_.end() ? blend_it->second : blend_mode::normal);\r
+                               critical_section::scoped_lock lock(mutex_);\r
+\r
+                               BOOST_FOREACH(auto& frame, frames)\r
+                               {\r
+                                       auto blend_it = blend_modes_.find(frame.first);\r
+                                       image_mixer_.begin_layer(blend_it != blend_modes_.end() ? blend_it->second : blend_mode::normal);\r
                                \r
-                               auto frame1 = make_safe<core::basic_frame>(frame.second);\r
-                               frame1->get_frame_transform() = transforms_[frame.first].fetch_and_tick(1);\r
-\r
-                               if(format_desc_.field_mode != core::field_mode::progressive)\r
-                               {                               \r
-                                       auto frame2 = make_safe<core::basic_frame>(frame.second);\r
-                                       frame2->get_frame_transform() = transforms_[frame.first].fetch_and_tick(1);\r
-                                       frame1 = core::basic_frame::interlace(frame1, frame2, format_desc_.field_mode);\r
-                               }\r
+                                       auto frame1 = make_safe<core::basic_frame>(frame.second);\r
+                                       frame1->get_frame_transform() = transforms_[frame.first].fetch_and_tick(1);\r
+\r
+                                       if(format_desc_.field_mode != core::field_mode::progressive)\r
+                                       {                               \r
+                                               auto frame2 = make_safe<core::basic_frame>(frame.second);\r
+                                               frame2->get_frame_transform() = transforms_[frame.first].fetch_and_tick(1);\r
+                                               frame1 = core::basic_frame::interlace(frame1, frame2, format_desc_.field_mode);\r
+                                       }\r
                                                                        \r
-                               frame1->accept(audio_mixer_);                                   \r
-                               frame1->accept(image_mixer_);\r
+                                       frame1->accept(audio_mixer_);                                   \r
+                                       frame1->accept(image_mixer_);\r
 \r
-                               image_mixer_.end_layer();\r
+                                       image_mixer_.end_layer();\r
+                               }\r
                        }\r
-               }\r
 \r
-               auto image = image_mixer_.render();\r
-               auto audio = audio_mixer_.mix();\r
+                       auto image = image_mixer_.render();\r
+                       auto audio = audio_mixer_.mix();\r
                        \r
+                       {\r
+                               scoped_oversubcription_token oversubscribe;\r
+                               image.wait();\r
+                       }\r
+\r
+                       frame = make_safe<read_frame>(ogl_, format_desc_.size, std::move(image.get()), std::move(audio));\r
+               }\r
+               catch(...)\r
                {\r
-                       scoped_oversubcription_token oversubscribe;\r
-                       image.wait();\r
+                       CASPAR_LOG_CURRENT_EXCEPTION();\r
+                       Concurrency::wait(20);\r
                }\r
 \r
-               auto frame = make_safe<read_frame>(ogl_, format_desc_.size, std::move(image.get()), std::move(audio));\r
-\r
                return msg->transfer<safe_ptr<core::read_frame>>(std::move(frame));     \r
        }\r
                                                \r

diff --git a/core/producer/stage.cpp b/core/producer/stage.cpp
index fcba4597a8e859028102451ab5a71e7c46c14772..ff9d4d26e9cd415b1c1c1533cc5b13ef711c9118 100644 (file)
--- a/core/producer/stage.cpp
+++ b/core/producer/stage.cpp
@@ -89,6 +89,7 @@ public:
                        catch(...)\r
                        {\r
                                CASPAR_LOG_CURRENT_EXCEPTION();\r
+                               Concurrency::wait(20);\r
                        }       \r
                }\r
 \r

diff --git a/core/video_channel.cpp b/core/video_channel.cpp
index 433607162f560ac2983b80831f48912973ea949d..77057a7ab311c230eb089041a636a8bb6cdeda7c 100644 (file)
--- a/core/video_channel.cpp
+++ b/core/video_channel.cpp
@@ -42,31 +42,32 @@
 #pragma warning(disable : 4355)\r
 #endif\r
 \r
+using namespace Concurrency;\r
+\r
 namespace caspar { namespace core {\r
 \r
 struct video_channel::implementation : boost::noncopyable\r
 {\r
-       Concurrency::unbounded_buffer<safe_ptr<message<std::map<int, safe_ptr<basic_frame>>>>>  stage_frames_;\r
-       Concurrency::unbounded_buffer<safe_ptr<message<safe_ptr<read_frame>>>>                                  mixer_frames_;\r
+       unbounded_buffer<safe_ptr<message<std::map<int, safe_ptr<basic_frame>>>>>       stage_frames_;\r
+       unbounded_buffer<safe_ptr<message<safe_ptr<read_frame>>>>                                       mixer_frames_;\r
        \r
-       const video_format_desc format_desc_;\r
+       const video_format_desc                         format_desc_;\r
        \r
-       safe_ptr<Concurrency::semaphore>                semaphore_;\r
-       safe_ptr<caspar::core::output>                  output_;\r
-       std::shared_ptr<caspar::core::mixer>    mixer_;\r
-       safe_ptr<caspar::core::stage>                   stage_;\r
-\r
-       safe_ptr<diagnostics::graph>    graph_;\r
-       boost::timer                                    frame_timer_;\r
-       boost::timer                                    tick_timer_;\r
-       boost::timer                                    output_timer_;\r
-\r
+       safe_ptr<semaphore>                                     semaphore_;\r
+       safe_ptr<caspar::core::output>          output_;\r
+       safe_ptr<caspar::core::mixer>           mixer_;\r
+       safe_ptr<caspar::core::stage>           stage_;\r
+\r
+       safe_ptr<diagnostics::graph>            graph_;\r
+       boost::timer                                            frame_timer_;\r
+       boost::timer                                            tick_timer_;\r
+       boost::timer                                            output_timer_;\r
        \r
 public:\r
        implementation(int index, const video_format_desc& format_desc, ogl_device& ogl)  \r
                : graph_(diagnostics::create_graph(narrow(print()), false))\r
                , format_desc_(format_desc)\r
-               , semaphore_(make_safe<Concurrency::semaphore>(3))\r
+               , semaphore_(make_safe<semaphore>(3))\r
                , output_(new caspar::core::output(mixer_frames_, format_desc))\r
                , mixer_(new caspar::core::mixer(stage_frames_, mixer_frames_, format_desc, ogl))\r
                , stage_(new caspar::core::stage(stage_frames_, semaphore_))    \r
@@ -90,7 +91,7 @@ public:
 video_channel::video_channel(int index, const video_format_desc& format_desc, ogl_device& ogl) : impl_(new implementation(index, format_desc, ogl)){}\r
 video_channel::video_channel(video_channel&& other) : impl_(std::move(other.impl_)){}\r
 safe_ptr<stage> video_channel::stage() { return impl_->stage_;} \r
-safe_ptr<mixer> video_channel::mixer() { return make_safe_ptr(impl_->mixer_);} \r
+safe_ptr<mixer> video_channel::mixer() { return impl_->mixer_;} \r
 safe_ptr<output> video_channel::output() { return impl_->output_;} \r
 video_format_desc video_channel::get_video_format_desc() const{return impl_->format_desc_;}\r
 std::wstring video_channel::print() const { return impl_->print();}\r