Reduces build time from 5:17 to 4:59 on my system.
#include <boost/range.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
-#include <boost/thread.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <tbb/concurrent_queue.h>
#include <boost/range/algorithm_ext/erase.hpp>
-#include <boost/thread/future.hpp>
#include <algorithm>
#include <cstdint>
#include <GL/glew.h>
#include <boost/range/algorithm_ext/erase.hpp>
-#include <boost/thread/future.hpp>
#include <algorithm>
#include <vector>
#include <tbb/atomic.h>
-#include <boost/thread/future.hpp>
-
namespace caspar { namespace accelerator { namespace ogl {
static GLenum FORMAT[] = {0, GL_RED, GL_RG, GL_BGR, GL_BGRA};
#include "semaphore.h"
-#include <boost/thread/mutex.hpp>
#include <boost/noncopyable.hpp>
namespace caspar {
typedef typename Q::value_type value_type;
typedef unsigned int size_type;
private:
- mutable boost::mutex capacity_mutex_;
+ mutable std::mutex capacity_mutex_;
size_type capacity_;
semaphore space_available_ = capacity_;
semaphore elements_available_ = 0;
*/
void set_capacity(size_type capacity)
{
- boost::unique_lock<boost::mutex> lock (capacity_mutex_);
+ std::unique_lock<std::mutex> lock (capacity_mutex_);
if (capacity_ < capacity)
{
*/
size_type capacity() const
{
- boost::unique_lock<boost::mutex> lock (capacity_mutex_);
+ std::unique_lock<std::mutex> lock (capacity_mutex_);
return capacity_;
}
#include <tbb/concurrent_queue.h>
-#include <boost/thread/mutex.hpp>
-
#include "semaphore.h"
namespace caspar {
size_type capacity_;
semaphore space_available_ { capacity_ };
semaphore elements_available_ { 0u };
- mutable boost::mutex capacity_mutex_;
+ mutable std::mutex capacity_mutex_;
public:
/**
* Constructor.
*/
void set_capacity(size_type capacity)
{
- boost::unique_lock<boost::mutex> lock(capacity_mutex_);
+ std::unique_lock<std::mutex> lock(capacity_mutex_);
if (capacity_ < capacity)
{
*/
size_type capacity() const
{
- boost::unique_lock<boost::mutex> lock (capacity_mutex_);
+ std::unique_lock<std::mutex> lock (capacity_mutex_);
return capacity_;
}
#include "../linq.h"
-#include <boost/thread.hpp>
-
#include <tbb/spin_mutex.h>
+#include <mutex>
#include <vector>
namespace caspar { namespace diagnostics {
}
typedef std::vector<spi::sink_factory_t> sink_factories_t;
-static boost::mutex g_sink_factories_mutex;
+static std::mutex g_sink_factories_mutex;
static sink_factories_t g_sink_factories;
std::vector<spl::shared_ptr<spi::graph_sink>> create_sinks()
{
- boost::lock_guard<boost::mutex> lock(g_sink_factories_mutex);
+ std::lock_guard<std::mutex> lock(g_sink_factories_mutex);
return cpplinq::from(g_sink_factories)
.select([](const spi::sink_factory_t& s){ return s(); })
void register_sink_factory(sink_factory_t factory)
{
- boost::lock_guard<boost::mutex> lock(g_sink_factories_mutex);
+ std::lock_guard<std::mutex> lock(g_sink_factories_mutex);
g_sink_factories.push_back(std::move(factory));
}
}
-}}
\ No newline at end of file
+}}
#include <boost/property_tree/xml_parser.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
-#include <boost/thread/once.hpp>
#include <functional>
#include <iostream>
#include "except.h"
-#include <boost/thread/tss.hpp>
#include <boost/algorithm/string/join.hpp>
namespace {
-boost::thread_specific_ptr<std::list<std::string>>& context_stacks_per_thread()
+std::list<std::string>& context_stacks_per_thread()
{
- static boost::thread_specific_ptr<std::list<std::string>> instances;
+ static thread_local std::list<std::string> instances;
return instances;
}
std::list<std::string>& context_stack_for_thread()
{
- auto local = context_stacks_per_thread().get();
-
- if (!local)
- {
- local = new std::list<std::string>();
- context_stacks_per_thread().reset(local);
- }
-
- return *local;
+ return context_stacks_per_thread();
}
std::string get_context()
#include <tbb/atomic.h>
#include <tbb/concurrent_priority_queue.h>
-#include <boost/thread.hpp>
#include <boost/optional.hpp>
#include <functional>
#include <future>
+#include <thread>
namespace caspar {
enum class task_priority
const std::wstring name_;
tbb::atomic<bool> is_running_;
- boost::thread thread_;
+ std::thread thread_;
function_queue_t execution_queue_;
tbb::atomic<bool> currently_in_task_;
{
is_running_ = true;
currently_in_task_ = false;
- thread_ = boost::thread([this]{run();});
+ thread_ = std::thread([this]{run();});
}
~executor()
bool is_current() const
{
- return boost::this_thread::get_id() == thread_.get_id();
+ return std::this_thread::get_id() == thread_.get_id();
}
bool is_currently_in_task() const
#pragma once
-#include <boost/thread/mutex.hpp>
#include <boost/function.hpp>
#include <boost/optional.hpp>
return p.get_future();
}
-}
\ No newline at end of file
+}
#pragma once
-#include <boost/thread/lock_guard.hpp>
+#include <mutex>
namespace caspar {
template<typename T, typename F>
auto lock(T& mutex, F&& func) -> decltype(func())
{
- boost::lock_guard<T> lock(mutex);
+ std::lock_guard<T> lock(mutex);
return func();
}
#include <ios>
#include <iomanip>
+#include <mutex>
#include <string>
+#include <thread>
#include <ostream>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/property_tree/ptree.hpp>
-#include <boost/thread/mutex.hpp>
#include <tbb/atomic.h>
});
}
-boost::mutex& get_filter_mutex()
+std::mutex& get_filter_mutex()
{
- static boost::mutex instance;
+ static std::mutex instance;
return instance;
}
void set_log_level(const std::wstring& lvl)
{
- boost::lock_guard<boost::mutex> lock(get_filter_mutex());
+ std::lock_guard<std::mutex> lock(get_filter_mutex());
if (boost::iequals(lvl, L"trace"))
get_level() = boost::log::trivial::trace;
else
return; // Ignore
- boost::lock_guard<boost::mutex> lock(get_filter_mutex());
+ std::lock_guard<std::mutex> lock(get_filter_mutex());
auto& disabled_categories = get_disabled_categories();
if (enabled)
#include "../../prec_timer.h"
-#include <boost/thread.hpp>
#include <boost/chrono/system_clocks.hpp>
#include <time.h>
#include "win32_exception.h"
-#include <boost/thread.hpp>
#include <boost/lexical_cast.hpp>
#include "../../thread_info.h"
bool& installed_for_thread()
{
- static boost::thread_specific_ptr<bool> installed;
+ static thread_local bool installed;
auto for_thread = installed.get();
#include <cstdint>
#include <boost/asio.hpp>
-#include <boost/thread.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem/convenience.hpp>
#include <cmath>
#include <boost/noncopyable.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition_variable.hpp>
#include <map>
+#include <mutex>
#include <queue>
#include <functional>
+#include <boost/thread/condition_variable.hpp>
+
namespace caspar {
/**
*/
class semaphore : boost::noncopyable
{
- mutable boost::mutex mutex_;
+ mutable std::mutex mutex_;
unsigned int permits_;
boost::condition_variable_any permits_available_;
std::map<unsigned int, std::queue<std::function<void()>>> callbacks_per_requested_permits_;
*/
void release()
{
- boost::unique_lock<boost::mutex> lock(mutex_);
+ std::unique_lock<std::mutex> lock(mutex_);
++permits_;
*/
void release(unsigned int permits)
{
- boost::unique_lock<boost::mutex> lock(mutex_);
+ std::unique_lock<std::mutex> lock(mutex_);
permits_ += permits;
*/
void acquire()
{
- boost::unique_lock<boost::mutex> lock(mutex_);
+ std::unique_lock<std::mutex> lock(mutex_);
while (permits_ == 0u)
{
*/
void acquire(unsigned int permits)
{
- boost::unique_lock<boost::mutex> lock(mutex_);
+ std::unique_lock<std::mutex> lock(mutex_);
auto num_acquired = 0u;
while (true)
*/
void acquire(unsigned int permits, std::function<void()> acquired_callback)
{
- boost::unique_lock<boost::mutex> lock(mutex_);
+ std::unique_lock<std::mutex> lock(mutex_);
if (permits_ >= permits)
{
template <typename Rep, typename Period>
bool try_acquire(unsigned int permits, const boost::chrono::duration<Rep, Period>& timeout)
{
- boost::unique_lock<boost::mutex> lock(mutex_);
+ std::unique_lock<std::mutex> lock(mutex_);
auto num_acquired = 0u;
while (true)
*/
bool try_acquire()
{
- boost::unique_lock<boost::mutex> lock(mutex_);
+ std::unique_lock<std::mutex> lock(mutex_);
if (permits_ == 0u)
return false;
*/
unsigned int permits() const
{
- boost::unique_lock<boost::mutex> lock(mutex_);
+ std::unique_lock<std::mutex> lock(mutex_);
return permits_;
}
#include "os/threading.h"
#include <map>
+#include <mutex>
#include <boost/thread/tss.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/lock_guard.hpp>
-#include <boost/lexical_cast.hpp>
namespace caspar {
class enumerable_thread_infos
{
- boost::mutex mutex_;
+ std::mutex mutex_;
std::map<void*, std::weak_ptr<thread_info>> enumerable_;
boost::thread_specific_ptr<std::shared_ptr<thread_info>> infos_;
public:
std::vector<spl::shared_ptr<thread_info>> get_thread_infos()
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
std::vector<spl::shared_ptr<thread_info>> result;
result.reserve(enumerable_.size());
std::unique_ptr<thread_info> p(new thread_info);
local = new std::shared_ptr<thread_info>(p.get(), [this](thread_info* p)
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
enumerable_.erase(p);
delete p;
});
p.release();
infos_.reset(local);
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
enumerable_.insert(std::make_pair(local->get(), *local));
}
#include <tbb/atomic.h>
-#include <boost/thread/thread.hpp>
-
namespace caspar {
struct thread_info
#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/algorithm/string.hpp>
-#include <boost/thread.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <core/frame/frame.h>
#include <core/frame/audio_channel_layout.h>
-#include <boost/thread.hpp>
-
#include <future>
#include <vector>
#include <map>
+#include <thread>
namespace caspar { namespace core {
CASPAR_VERIFY(counter < 8);
auto consumer = new std::shared_ptr<frame_consumer>(std::move(consumer_));
- boost::thread([=]
+ std::thread([=]
{
std::unique_ptr<std::shared_ptr<frame_consumer>> pointer_guard(consumer);
auto str = (*consumer)->print();
#include "call_context.h"
-#include <boost/thread/tss.hpp>
#include <boost/lexical_cast.hpp>
namespace caspar { namespace core { namespace diagnostics {
call_context& call_context::for_thread()
{
- static boost::thread_specific_ptr<call_context> contexts;
+ static call_context *contexts = nullptr;
- auto local = contexts.get();
-
- if (!local)
+ if (!contexts)
{
- local = new call_context;
- contexts.reset(local);
+ contexts = new call_context;
}
- return *local;
+ return *contexts;
}
std::wstring call_context::to_string() const
#include <boost/algorithm/string/join.hpp>
#include <boost/range/algorithm/equal.hpp>
#include <boost/lexical_cast.hpp>
-#include <boost/thread/mutex.hpp>
#include <boost/property_tree/ptree.hpp>
#include <map>
+#include <mutex>
namespace caspar { namespace core {
struct audio_channel_layout_repository::impl
{
- mutable boost::mutex mutex_;
+ mutable std::mutex mutex_;
std::map<std::wstring, audio_channel_layout> layouts_;
};
void audio_channel_layout_repository::register_layout(std::wstring name, audio_channel_layout layout)
{
auto& self = *impl_;
- boost::lock_guard<boost::mutex> lock(self.mutex_);
+ std::lock_guard<std::mutex> lock(self.mutex_);
boost::to_upper(name);
self.layouts_.insert(std::make_pair(std::move(name), std::move(layout)));
void audio_channel_layout_repository::register_all_layouts(const boost::property_tree::wptree& layouts)
{
auto& self = *impl_;
- boost::lock_guard<boost::mutex> lock(self.mutex_);
+ std::lock_guard<std::mutex> lock(self.mutex_);
for (auto& layout : layouts | welement_context_iteration)
{
boost::optional<audio_channel_layout> audio_channel_layout_repository::get_layout(const std::wstring& name) const
{
auto& self = *impl_;
- boost::lock_guard<boost::mutex> lock(self.mutex_);
+ std::lock_guard<std::mutex> lock(self.mutex_);
auto found = self.layouts_.find(boost::to_upper_copy(name));
struct audio_mix_config_repository::impl
{
- mutable boost::mutex mutex_;
+ mutable std::mutex mutex_;
std::map<std::wstring, std::map<std::wstring, std::wstring>> from_to_configs_;
};
const std::wstring& mix_config)
{
auto& self = *impl_;
- boost::lock_guard<boost::mutex> lock(self.mutex_);
+ std::lock_guard<std::mutex> lock(self.mutex_);
for (auto& to_type : to_types)
self.from_to_configs_[boost::to_upper_copy(from_type)][boost::to_upper_copy(to_type)] = mix_config;
void audio_mix_config_repository::register_all_configs(const boost::property_tree::wptree& configs)
{
auto& self = *impl_;
- boost::lock_guard<boost::mutex> lock(self.mutex_);
+ std::lock_guard<std::mutex> lock(self.mutex_);
for (auto& config : configs | welement_context_iteration)
{
const std::wstring& to_type) const
{
auto& self = *impl_;
- boost::lock_guard<boost::mutex> lock(self.mutex_);
+ std::lock_guard<std::mutex> lock(self.mutex_);
auto from_found = self.from_to_configs_.find(boost::to_upper_copy(from_type));
#include <vector>
#include <boost/lexical_cast.hpp>
-#include <boost/thread/future.hpp>
namespace caspar { namespace core {
#include "../StdAfx.h"
+#include <thread>
+
#include "frame_transform.h"
#include <boost/range/algorithm/equal.hpp>
-#include <boost/thread.hpp>
namespace caspar { namespace core {
namespace detail {
-boost::thread_specific_ptr<double>& get_thread_local_aspect_ratio()
-{
- static boost::thread_specific_ptr<double> aspect_ratio;
-
- if (!aspect_ratio.get())
- aspect_ratio.reset(new double(1.0));
+static thread_local double aspect_ratio = 1.0;
+double get_thread_local_aspect_ratio()
+{
return aspect_ratio;
}
-void set_current_aspect_ratio(double aspect_ratio)
+void set_current_aspect_ratio(double aspect_ratio_arg)
{
- *get_thread_local_aspect_ratio() = aspect_ratio;
+ aspect_ratio = aspect_ratio_arg;
}
double get_current_aspect_ratio()
{
- return *get_thread_local_aspect_ratio();
+ return aspect_ratio;
}
}}}
#include <common/os/filesystem.h>
#include <common/future.h>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/lock_guard.hpp>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/optional.hpp>
bool reusable_producer_instance;
};
- mutable boost::mutex mutex_;
+ mutable std::mutex mutex_;
std::map<std::wstring, record> records_by_extension_;
public:
void register_cg_producer(
cg_producer_factory producer_factory,
bool reusable_producer_instance)
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
record rec
{
{
auto producer_name = producer->name();
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
for (auto& elem : records_by_extension_)
{
auto basepath = path(env::template_folder()) / path(filename);
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
for (auto& rec : records_by_extension_)
{
bool is_cg_extension(const std::wstring& extension) const
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
return records_by_extension_.find(extension) != records_by_extension_.end();
}
auto basepath = path(env::template_folder()) / path(filename);
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
for (auto& rec : records_by_extension_)
{
#include <common/future.h>
#include <common/memory.h>
-#include <boost/thread.hpp>
-
namespace caspar { namespace core {
struct frame_producer_registry::impl
{
#include "../frame/frame_transform.h"
#include <boost/optional.hpp>
-#include <boost/thread/future.hpp>
namespace caspar { namespace core {
#include "in_memory_media_info_repository.h"
#include <map>
+#include <mutex>
#include <vector>
-#include <boost/thread/mutex.hpp>
#include <boost/foreach.hpp>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string/case_conv.hpp>
class in_memory_media_info_repository : public media_info_repository
{
- boost::mutex mutex_;
+ std::mutex mutex_;
std::map<std::wstring, boost::optional<media_info>> info_by_file_;
std::vector<media_info_extractor> extractors_;
public:
virtual void register_extractor(media_info_extractor extractor) override
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
extractors_.push_back(extractor);
}
virtual boost::optional<media_info> get(const std::wstring& file) override
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
auto iter = info_by_file_.find(file);
virtual void remove(const std::wstring& file) override
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
info_by_file_.erase(file);
}
#include "freetype_library.h"
-#include <boost/thread/tss.hpp>
+#include <memory>
namespace caspar { namespace core { namespace text {
-spl::shared_ptr<std::remove_pointer<FT_Library>::type> get_lib_for_thread()
+std::shared_ptr<std::remove_pointer<FT_Library>::type> get_lib_for_thread()
{
typedef std::remove_pointer<FT_Library>::type non_ptr_type;
- static boost::thread_specific_ptr<spl::shared_ptr<non_ptr_type>> libs;
+ static thread_local std::shared_ptr<non_ptr_type> libs;
- auto result = libs.get();
-
- if (!result)
+ if (libs.get() == nullptr)
{
FT_Library raw_lib;
if (FT_Init_FreeType(&raw_lib))
CASPAR_THROW_EXCEPTION(freetype_exception() << msg_info("Failed to initialize freetype"));
- auto lib = spl::shared_ptr<non_ptr_type>(raw_lib, FT_Done_FreeType);
- result = new spl::shared_ptr<non_ptr_type>(std::move(lib));
-
- libs.reset(result);
+ libs = spl::shared_ptr<non_ptr_type>(raw_lib, FT_Done_FreeType);
}
- return *result;
+ return libs;
}
-spl::shared_ptr<std::remove_pointer<FT_Face>::type> get_new_face(
+std::shared_ptr<std::remove_pointer<FT_Face>::type> get_new_face(
const std::string& font_file, const std::string& font_name)
{
if (font_file.empty())
#include <ft2build.h>
#include FT_FREETYPE_H
+#include <memory>
#include <string>
#include <type_traits>
struct freetype_exception : virtual caspar_exception { };
struct expected_freetype_exception : virtual user_error { };
-spl::shared_ptr<std::remove_pointer<FT_Library>::type> get_lib_for_thread();
-spl::shared_ptr<std::remove_pointer<FT_Face>::type> get_new_face(const std::string& font_file, const std::string& font_name = "");
+std::shared_ptr<std::remove_pointer<FT_Library>::type> get_lib_for_thread();
+std::shared_ptr<std::remove_pointer<FT_Face>::type> get_new_face(const std::string& font_file, const std::string& font_name = "");
}}}
#include "system_info_provider.h"
#include <boost/property_tree/ptree.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/lock_guard.hpp>
#include <boost/algorithm/string/case_conv.hpp>
-#include <vector>
#include <map>
+#include <mutex>
+#include <vector>
namespace caspar { namespace core {
struct system_info_provider_repository::impl
{
- mutable boost::mutex mutex_;
+ mutable std::mutex mutex_;
std::vector<system_info_provider> info_providers_;
std::map<std::wstring, version_provider> version_providers_;
void register_system_info_provider(system_info_provider provider)
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
info_providers_.push_back(std::move(provider));
}
void register_version_provider(const std::wstring& version_name, version_provider provider)
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
version_providers_.insert(std::make_pair(boost::algorithm::to_lower_copy(version_name), std::move(provider)));
}
void fill_information(boost::property_tree::wptree& info) const
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
for (auto& provider : info_providers_)
provider(info);
std::wstring get_version(const std::wstring& version_name) const
{
- boost::lock_guard<boost::mutex> lock(mutex_);
+ std::lock_guard<std::mutex> lock(mutex_);
auto found = version_providers_.find(boost::algorithm::to_lower_copy(version_name));
#include <iterator>
#include <set>
#include <future>
+#include <thread>
-#include <boost/thread.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/filesystem.hpp>
+#include <boost/thread.hpp>
#include <tbb/atomic.h>
int current_sleep = sleep_millis;
if (current_sleep > 0)
- boost::this_thread::sleep_for(boost::chrono::milliseconds(current_sleep));
+ std::this_thread::sleep_for(std::chrono::milliseconds(current_sleep));
on_send(std::move(frame));
on_send = nullptr;
#include <boost/lexical_cast.hpp>
#include <boost/circular_buffer.hpp>
#include <boost/property_tree/ptree.hpp>
-#include <boost/thread/mutex.hpp>
#include <future>
#include <boost/range/algorithm_ext/push_back.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/regex.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/once.hpp>
-#include <boost/thread/thread.hpp>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <tbb/parallel_for.h>
#include <numeric>
+#include <thread>
#pragma warning(push)
#pragma warning(disable: 4244)
avfilter_graph_free(&p);
});
- video_graph_->nb_threads = boost::thread::hardware_concurrency()/2;
+ video_graph_->nb_threads = std::thread::hardware_concurrency()/2;
video_graph_->thread_type = AVFILTER_THREAD_SLICE;
const auto sample_aspect_ratio =
filt_frame,
token);
- boost::this_thread::yield(); // TODO:
+ std::this_thread::yield(); // TODO:
});
}
}
nullptr,
token))
{
- boost::this_thread::yield(); // TODO:
+ std::this_thread::yield(); // TODO:
}
}
}
#include <core/system_info_provider.h>
#include <boost/property_tree/ptree.hpp>
-#include <boost/thread/tss.hpp>
#include <boost/bind.hpp>
#include <tbb/recursive_mutex.h>
void log_callback(void* ptr, int level, const char* fmt, va_list vl)
{
- static boost::thread_specific_ptr<bool> print_prefix_tss;
- auto print_prefix = print_prefix_tss.get();
-
- if (!print_prefix)
- {
- print_prefix = new bool(true);
- print_prefix_tss.reset(print_prefix);
- }
+ static thread_local bool print_prefix = true;
char line[1024];
AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
line[0]=0;
#undef fprintf
- if(*print_prefix && avc)
+ if(print_prefix && avc)
{
if (avc->parent_log_context_offset)
{
std::vsnprintf(line + strlen(line), sizeof(line) - strlen(line), fmt, vl);
- *print_prefix = strlen(line) && line[strlen(line)-1] == '\n';
+ print_prefix = strlen(line) && line[strlen(line)-1] == '\n';
sanitize((uint8_t*)line);
}
bool& get_quiet_logging_for_thread()
{
- static boost::thread_specific_ptr<bool> quiet_logging_for_thread;
-
- auto local = quiet_logging_for_thread.get();
-
- if (!local)
- {
- local = new bool(false);
- quiet_logging_for_thread.reset(local);
- }
-
- return *local;
+ static thread_local bool quiet_logging_for_thread = false;
+ return quiet_logging_for_thread;
}
void enable_quiet_logging_for_thread()
// therefore no seeking should be necessary for the first frame.
{
input_.seek(file_position > 1 ? file_position - 2: file_position).get();
- boost::this_thread::sleep_for(boost::chrono::milliseconds(40));
+ std::this_thread::sleep_for(std::chrono::milliseconds(40));
}
for (int i = 0; i < NUM_RETRIES; ++i)
{
- boost::this_thread::sleep_for(boost::chrono::milliseconds(40));
+ std::this_thread::sleep_for(std::chrono::milliseconds(40));
auto frame = render_frame();
{
CASPAR_LOG(trace) << print() << L" adjusting to " << adjusted_seek;
input_.seek(static_cast<uint32_t>(adjusted_seek) - 1).get();
- boost::this_thread::sleep_for(boost::chrono::milliseconds(40));
+ std::this_thread::sleep_for(std::chrono::milliseconds(40));
}
else
return frame.first;
#include <common/except.h>
#include <boost/algorithm/string.hpp>
-#include <boost/thread.hpp>
#include <boost/format.hpp>
#include <boost/rational.hpp>
#include <common/except.h>
#include <boost/algorithm/string.hpp>
-#include <boost/thread.hpp>
#include <boost/format.hpp>
#include <boost/rational.hpp>
#include <common/assert.h>
#include <boost/range/algorithm_ext/push_back.hpp>
#include <boost/algorithm/string/predicate.hpp>
-#include <boost/thread/mutex.hpp>
#include <boost/optional.hpp>
#include <deque>
+#include <mutex>
#include <queue>
#include <vector>
const bool multithreaded_filter_;
bool force_deinterlacing_;
- mutable boost::mutex out_framerate_mutex_;
+ mutable std::mutex out_framerate_mutex_;
boost::rational<int> out_framerate_;
impl(
boost::rational<int> out_framerate() const
{
- boost::lock_guard<boost::mutex> lock(out_framerate_mutex_);
+ std::lock_guard<std::mutex> lock(out_framerate_mutex_);
return out_framerate_;
}
void set_out_framerate(boost::rational<int> out_framerate)
{
- boost::lock_guard<boost::mutex> lock(out_framerate_mutex_);
+ std::lock_guard<std::mutex> lock(out_framerate_mutex_);
bool changed = out_framerate != out_framerate_;
out_framerate_ = std::move(out_framerate);
#include <boost/filesystem.hpp>
#include <boost/property_tree/ptree.hpp>
-#include <boost/thread.hpp>
#include <boost/timer.hpp>
#include <boost/algorithm/string.hpp>
return template_host;
}
-boost::mutex& get_global_init_destruct_mutex()
+std::mutex& get_global_init_destruct_mutex()
{
- static boost::mutex m;
+ static std::mutex m;
return m;
}
if (nothing_rendered++ < MAX_NOTHING_RENDERED_RETRIES)
{
// Flash player not ready with first frame, sleep to not busy-loop;
- boost::this_thread::sleep(boost::posix_time::milliseconds(10));
- boost::this_thread::yield();
+ std::this_thread::sleep(boost::posix_time::milliseconds(10));
+ std::this_thread::yield();
}
else
return;
return L"";
}
-}}
\ No newline at end of file
+}}
#include <core/producer/cg_proxy.h>
-#include <boost/thread.hpp>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/foreach.hpp>
#include <boost/timer.hpp>
#include <boost/range/algorithm/remove_if.hpp>
-#include <boost/thread/future.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/log/trivial.hpp>
#include <boost/property_tree/ptree.hpp>
tbb::atomic<bool> loaded_;
tbb::atomic<bool> removed_;
std::queue<core::draw_frame> frames_;
- mutable boost::mutex frames_mutex_;
+ mutable std::mutex frames_mutex_;
core::draw_frame last_frame_;
core::draw_frame last_progressive_frame_;
- mutable boost::mutex last_frame_mutex_;
+ mutable std::mutex last_frame_mutex_;
CefRefPtr<CefBrowser> browser_;
#include <core/help/help_repository.h>
#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/thread.hpp>
#include <boost/algorithm/string.hpp>
#include <tbb/concurrent_queue.h>
{
auto filename = filename_;
- boost::thread async([frame, filename]
+ std::thread async([frame, filename]
{
ensure_gpf_handler_installed_for_thread("image-consumer");
#include <boost/lexical_cast.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/timer.hpp>
-#include <boost/thread/once.hpp>
#include <boost/algorithm/string.hpp>
#include <tbb/concurrent_queue.h>
void init_device()
{
static std::unique_ptr<device> instance;
- static boost::once_flag f = BOOST_ONCE_INIT;
+ static std::once_flag f;
- boost::call_once(f, []{instance.reset(new device());});
+ std::call_once(f, []{instance.reset(new device());});
}
struct oal_consumer : public core::frame_consumer
#include <common/os/filesystem.h>
#include <boost/filesystem.hpp>
-#include <boost/thread/future.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/rational.hpp>
#include <core/frame/frame_factory.h>
#include <core/video_format.h>
-#include <boost/thread/once.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/range/algorithm/copy.hpp>
static int next_consumer_index()
{
static tbb::atomic<int> consumer_index_counter;
- static boost::once_flag consumer_index_counter_initialized;
+ static std::once_flag consumer_index_counter_initialized;
- boost::call_once(consumer_index_counter_initialized, [&]()
+ std::call_once(consumer_index_counter_initialized, [&]()
{
consumer_index_counter = 0;
});
#include <boost/circular_buffer.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/property_tree/ptree.hpp>
-#include <boost/thread.hpp>
#include <boost/algorithm/string.hpp>
#include <tbb/atomic.h>
tbb::concurrent_bounded_queue<core::const_frame> frame_buffer_;
core::interaction_sink* sink_;
- boost::thread thread_;
+ std::thread thread_;
tbb::atomic<bool> is_running_;
tbb::atomic<int64_t> current_presentation_age_;
polling_event_ = false;
is_running_ = true;
current_presentation_age_ = 0;
- thread_ = boost::thread([this]{run();});
+ thread_ = std::thread([this]{run();});
}
~screen_consumer()
#include <core/monitor/monitor.h>
+#include <condition_variable>
#include <functional>
-#include <vector>
+#include <mutex>
+#include <thread>
#include <unordered_map>
+#include <vector>
#include <boost/asio.hpp>
-#include <boost/bind.hpp>
-#include <boost/thread.hpp>
#include <tbb/spin_mutex.h>
std::map<udp::endpoint, int> reference_counts_by_endpoint_;
std::unordered_map<std::string, byte_vector> updates_;
- boost::mutex updates_mutex_;
- boost::condition_variable updates_cond_;
+ std::mutex updates_mutex_;
+ std::condition_variable updates_cond_;
tbb::atomic<bool> is_running_;
- boost::thread thread_;
+ std::thread thread_;
public:
impl(std::shared_ptr<boost::asio::io_service> service)
: service_(std::move(service))
, socket_(*service_, udp::v4())
- , thread_(boost::bind(&impl::run, this))
+ , thread_(std::bind(&impl::run, this))
{
}
private:
void propagate(const core::monitor::message& msg)
{
- boost::lock_guard<boost::mutex> lock(updates_mutex_);
+ std::lock_guard<std::mutex> lock(updates_mutex_);
try
{
destinations.clear();
{
- boost::unique_lock<boost::mutex> cond_lock(updates_mutex_);
+ std::unique_lock<std::mutex> cond_lock(updates_mutex_);
if (!is_running_)
return;
#include <boost/locale.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string/predicate.hpp>
-#include <boost/thread.hpp>
-#include <boost/thread/future.hpp>
#include <boost/algorithm/string/case_conv.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
// Use separate thread for the blocking console input, will be terminated
// anyway when the main thread terminates.
- boost::thread stdin_thread(std::bind(do_run, weak_amcp, std::ref(shutdown_server_now), std::ref(should_wait_for_keypress))); //compiler didn't like lambda here...
+ std::thread stdin_thread(std::bind(do_run, weak_amcp, std::ref(shutdown_server_now), std::ref(should_wait_for_keypress))); //compiler didn't like lambda here...
stdin_thread.detach();
bool should_restart = shutdown_server.get();
amcp.reset();
{
CASPAR_LOG_CURRENT_EXCEPTION();
CASPAR_LOG(fatal) << L"Unhandled exception in main thread. Please report this error on the CasparCG forums (www.casparcg.com/forum).";
- boost::this_thread::sleep_for(boost::chrono::milliseconds(1000));
+ std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::wcout << L"\n\nCasparCG will automatically shutdown. See the log file located at the configured log-file folder for more information.\n\n";
- boost::this_thread::sleep_for(boost::chrono::milliseconds(4000));
+ std::this_thread::sleep_for(std::chrono::milliseconds(4000));
}
return return_code;
#include <protocol/log/tcp_logger_protocol_strategy.h>
#include <boost/algorithm/string.hpp>
-#include <boost/thread.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <tbb/atomic.h>
#include <future>
+#include <thread>
namespace caspar {
// operations are posted.
auto work = std::make_shared<boost::asio::io_service::work>(*service);
auto weak_work = std::weak_ptr<boost::asio::io_service::work>(work);
- auto thread = std::make_shared<boost::thread>([service, weak_work]
+ auto thread = std::make_shared<std::thread>([service, weak_work]
{
ensure_gpf_handler_installed_for_thread("asio-thread");
CASPAR_LOG(info) << "[asio] Shutting down global io_service.";
work.reset();
service->stop();
- if (thread->get_id() != boost::this_thread::get_id())
+ if (thread->get_id() != std::this_thread::get_id())
thread->join();
else
thread->detach();
std::vector<std::shared_ptr<void>> predefined_osc_subscriptions_;
std::vector<spl::shared_ptr<video_channel>> channels_;
spl::shared_ptr<media_info_repository> media_info_repo_;
- boost::thread initial_media_info_thread_;
+ std::thread initial_media_info_thread_;
spl::shared_ptr<system_info_provider_repository> system_info_provider_repo_;
spl::shared_ptr<core::cg_producer_registry> cg_registry_;
spl::shared_ptr<core::frame_producer_registry> producer_registry_;
void start_initial_media_info_scan()
{
- initial_media_info_thread_ = boost::thread([this]
+ initial_media_info_thread_ = std::thread([this]
{
try
{
projects / casparcg / commitdiff