set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHa /Zi /W4 /WX /MP /fp:fast /FIcommon/compiler/vs/disable_silly_warnings.h")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /D TBB_USE_ASSERT=1 /D TBB_USE_DEBUG /bigobj")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Oi /Ot /Gy")
+
+elseif (CMAKE_COMPILER_IS_GNUCXX)
+ add_compile_options( -std=c++11 )
endif ()
-cmake_policy(SET CMP0045 OLD)
+#cmake_policy(SET CMP0045 OLD)
include(CMake/PrecompiledHeader.cmake)
add_subdirectory(accelerator)
project (common)
set(SOURCES
- compiler/vs/stack_walker.cpp
-
diagnostics/graph.cpp
gl/gl_check.cpp
base64.cpp
env.cpp
- except.cpp
log.cpp
- page_locked_allocator.cpp
polling_filesystem_monitor.cpp
- prec_timer.cpp
stdafx.cpp
tweener.cpp
utf.cpp
)
-set(HEADERS
- compiler/vs/disable_silly_warnings.h
- compiler/vs/stack_walker.h
+if (MSVC)
+ set(OS_SPECIFIC_SOURCES
+ compiler/vs/disable_silly_warnings.h
+ compiler/vs/stack_walker.cpp
+ compiler/vs/stack_walker.h
+ os/windows/current_version.h
+ os/windows/page_locked_allocator.cpp
+ os/windows/prec_timer.cpp
+ os/windows/stack_trace.cpp
+ os/windows/system_info.cpp
+ os/windows/win32_exception.cpp
+ os/windows/win32_exception.h
+ os/windows/windows.h
+ )
+elseif (CMAKE_COMPILER_IS_GNUCXX)
+ set(OS_SPECIFIC_SOURCES
+ os/linux/signal_handlers.cpp
+ os/linux/stack_trace.cpp
+ os/linux/system_info.cpp
+ )
+endif ()
+set(HEADERS
diagnostics/graph.h
gl/gl_check.h
- os/windows/windows.h
- os/windows/system_info.h
- os/windows/windows.h
+ os/general_protection_fault.h
+ os/page_locked_allocator.h
+ os/stack_trace.h
+ os/system_info.h
array.h
assert.h
log.h
memory.h
memshfl.h
- page_locked_allocator.h
param.h
polling_filesystem_monitor.h
prec_timer.h
utf.h
)
-add_library(common ${SOURCES} ${HEADERS})
+add_library(common ${SOURCES} ${HEADERS} ${OS_SPECIFIC_SOURCES})
add_precompiled_header(common stdafx.h FORCEINCLUDE)
include_directories(..)
#include <vector>
#include <algorithm>
+#include <cstring>
#include <boost/archive/iterators/insert_linebreaks.hpp>
#include <boost/archive/iterators/base64_from_binary.hpp>
}
}
-}
\ No newline at end of file
+}
private:
std::map<Prio, tbb::concurrent_queue<T>, std::greater<Prio>> queues_by_priority_;
size_type capacity_;
- semaphore space_available_ = capacity_;
- semaphore elements_available_ = 0u;
+ semaphore space_available_ { capacity_ };
+ semaphore elements_available_ { 0u };
mutable boost::mutex capacity_mutex_;
public:
/**
static const auto ints = boost::irange(static_cast<integer>(0), static_cast<integer>(E::count));
static const auto result = cpplinq::from(ints.begin(), ints.end())
- .cast<E>()
+ //.cast<E>()
+ .select([](int i) { return static_cast<E>(i); })
.to_vector();
return result;
}
-}
\ No newline at end of file
+}
#include <boost/property_tree/ptree.hpp>
#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 <fstream>
namespace caspar { namespace env {
{
auto initialPath = boost::filesystem::initial_path().wstring();
- std::wifstream file(initialPath + L"\\" + filename);
+ boost::filesystem::wifstream file(initialPath + L"\\" + filename);
boost::property_tree::read_xml(file, pt, boost::property_tree::xml_parser::trim_whitespace | boost::property_tree::xml_parser::no_comments);
auto paths = pt.get_child(L"configuration.paths");
return L"C:\\windows\\Fonts\\";
}
-}}
\ No newline at end of file
+}}
#include "utf.h"
-#include "log.h"
+#include "os/stack_trace.h"
#include <exception>
#include <boost/exception/all.hpp>
#include <boost/exception/error_info.hpp>
#include <boost/throw_exception.hpp>
-struct _EXCEPTION_RECORD;
-struct _EXCEPTION_POINTERS;
-
-typedef _EXCEPTION_RECORD EXCEPTION_RECORD;
-typedef _EXCEPTION_POINTERS EXCEPTION_POINTERS;
-
namespace caspar {
typedef boost::error_info<struct tag_arg_name_info, std::string> arg_name_info_t;
struct caspar_exception : virtual boost::exception, virtual std::exception
{
caspar_exception(){}
- explicit caspar_exception(const char* msg) : std::exception(msg) {}
+ explicit caspar_exception(const char* msg) : msg_(msg) {}
+ const char* what() const noexcept override
+ {
+ return msg_;
+ }
+private:
+ const char* msg_ = "";
};
struct io_error : virtual caspar_exception {};
struct not_supported : virtual caspar_exception {};
struct not_implemented : virtual caspar_exception {};
-class win32_exception : public std::exception
-{
-public:
- typedef const void* address;
- static void install_handler();
- static void ensure_handler_installed_for_thread(
- const char* thread_description = nullptr);
-
- address location() const { return location_; }
- unsigned int error_code() const { return errorCode_; }
- virtual const char* what() const { return message_; }
-
-protected:
- win32_exception(const EXCEPTION_RECORD& info);
- static void Handler(unsigned int errorCode, EXCEPTION_POINTERS* pInfo);
-
-private:
- const char* message_;
-
- address location_;
- unsigned int errorCode_;
-};
-
-class win32_access_violation : public win32_exception
-{
- mutable char messageBuffer_[256];
-
-public:
- bool is_write() const { return isWrite_; }
- address bad_address() const { return badAddress_;}
- virtual const char* what() const;
-
-protected:
- win32_access_violation(const EXCEPTION_RECORD& info);
- friend void win32_exception::Handler(unsigned int errorCode, EXCEPTION_POINTERS* pInfo);
-
-private:
- bool isWrite_;
- address badAddress_;
-};
-
-#define CASPAR_THROW_EXCEPTION(e) BOOST_THROW_EXCEPTION(e << call_stack_info(caspar::log::internal::get_call_stack()))
+#define CASPAR_THROW_EXCEPTION(e) BOOST_THROW_EXCEPTION(e << call_stack_info(caspar::get_call_stack()))
}
#pragma once
+#include "os/general_protection_fault.h"
#include "except.h"
#include "log.h"
#include "blocking_bounded_queue_adapter.h"
void run() // noexcept
{
- win32_exception::install_handler();
+ ensure_gpf_handler_installed_for_thread(u8(name_).c_str());
while(is_running_)
{
try
}
};
-}
\ No newline at end of file
+}
//
///////////////////////////
-#pragma once
-
#include "../stdafx.h"
#include "gl_check.h"
}
}
-}}
\ No newline at end of file
+}}
#include "except.h"
#include "utf.h"
-#include "compiler/vs/stack_walker.h"
#include <ios>
#include <iomanip>
#include <boost/lexical_cast.hpp>
#include <tbb/atomic.h>
-#include <tbb/enumerable_thread_specific.h>
namespace caspar { namespace log {
boost::log::core::get()->add_sink(stream_sink);
}
-std::wstring get_call_stack()
-{
- class log_call_stack_walker : public stack_walker
- {
- std::string str_;
- public:
- log_call_stack_walker() : stack_walker() {}
-
- std::string flush()
- {
- return std::move(str_);
- }
- protected:
- virtual void OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUserName)
- {
- }
- virtual void OnLoadModule(LPCSTR img, LPCSTR mod, DWORD64 baseAddr, DWORD size, DWORD result, LPCSTR symType, LPCSTR pdbName, ULONGLONG fileVersion)
- {
- }
- virtual void OnDbgHelpErr(LPCSTR szFuncName, DWORD gle, DWORD64 addr)
- {
- }
- virtual void OnOutput(LPCSTR szText)
- {
- std::string str = szText;
-
- if(str.find("internal::get_call_stack") == std::string::npos && str.find("stack_walker::ShowCallstack") == std::string::npos)
- str_ += std::move(str);
- }
- };
-
- static tbb::enumerable_thread_specific<log_call_stack_walker> walkers;
- try
- {
- auto& walker = walkers.local();
- walker.ShowCallstack();
- return u16(walker.flush());
- }
- catch(...)
- {
- return L"!!!";
- }
-}
-
}
void add_file_sink(const std::wstring& folder)
boost::log::core::get()->set_filter(boost::log::trivial::severity >= boost::log::trivial::fatal);
}
-}}
\ No newline at end of file
+}}
p_.swap(other.p_);
}
- template<class D, class T2>
- D* get_deleter(shared_ptr<T2> const& ptr)
+ D& get_deleter()
{
return p_.get_deleter();
}
{
return p_.owner_before(ptr);
}
-
- template<class D, class T2>
- D* get_deleter(shared_ptr<T2> const& ptr)
- {
- return p_.get_deleter();
- }
private:
std::shared_ptr<T> p_;
};
+template<class D, class T>
+D* get_deleter(shared_ptr<T> const& ptr)
+{
+ return ptr.get_deleter();
+}
+
template<class T, class T2>
bool operator==(const shared_ptr<T>& a, const shared_ptr<T2>& b)
{
--- /dev/null
+/*
+* Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
+*
+* This file is part of CasparCG (www.casparcg.com).
+*
+* CasparCG is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* CasparCG is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
+*
+* Author: Helge Norberg, helge.norberg@svt.se
+*/
+
+#pragma once
+
+#include <string>
+
+namespace caspar {
+
+void install_gpf_handler();
+void ensure_gpf_handler_installed_for_thread(
+ const char* thread_description = nullptr);
+
+}
--- /dev/null
+#include "../general_protection_fault.h"
+
+namespace caspar {
+
+void install_gpf_handler()
+{
+ // TODO: implement
+}
+
+void ensure_gpf_handler_installed_for_thread(
+ const char* thread_description)
+{
+ // TODO: implement
+}
+
+}
--- /dev/null
+/*
+* Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
+*
+* This file is part of CasparCG (www.casparcg.com).
+*
+* CasparCG is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* CasparCG is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
+*
+* Author: Helge Norberg, helge.norberg@svt.se
+*/
+
+#include "../stack_trace.h"
+
+namespace caspar {
+
+std::wstring get_call_stack()
+{
+ // TODO: implement
+ return L"";
+}
+
+}
--- /dev/null
+/*
+* Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
+*
+* This file is part of CasparCG (www.casparcg.com).
+*
+* CasparCG is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* CasparCG is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
+*
+* Author: Helge Norberg, helge.norberg@svt.se
+*/
+
+#include "../system_info.h"
+
+namespace caspar {
+
+std::wstring cpu_info()
+{
+ // TODO: implement
+ return L"Unknown CPU";
+}
+
+std::wstring system_product_name()
+{
+ // TODO: implement
+ return L"Unknown System";
+}
+
+std::wstring os_description()
+{
+ // TODO: implement
+ return L"Unknown OS";
+}
+
+}
--- /dev/null
+/*
+* Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
+*
+* This file is part of CasparCG (www.casparcg.com).
+*
+* CasparCG is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* CasparCG is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
+*
+* Author: Helge Norberg, helge.norberg@svt.se
+*/
+
+#pragma once
+
+#include <string>
+
+namespace caspar {
+
+std::wstring get_call_stack();
+
+}
--- /dev/null
+/*
+* Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
+*
+* This file is part of CasparCG (www.casparcg.com).
+*
+* CasparCG is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* CasparCG is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
+*
+* Author: Robert Nagy, ronag89@gmail.com
+*/
+
+#pragma once
+
+#include <string>
+
+namespace caspar {
+
+std::wstring cpu_info();
+std::wstring system_product_name();
+std::wstring os_description();
+
+}
-#include "stdafx.h"
+#include "../../stdafx.h"
-#include "os/windows/windows.h"
+#include "../page_locked_allocator.h"
+
+#include "windows.h"
#include <unordered_map>
#include <tbb/mutex.h>
g_map.erase(p);
}
-}}
\ No newline at end of file
+}}
* Author: Robert Nagy, ronag89@gmail.com
*/
-#include "stdafx.h"
+#include "../../stdafx.h"
-#include "prec_timer.h"
+#include "../../prec_timer.h"
#include "os/windows/windows.h"
time_ = t;
}
-}
\ No newline at end of file
+}
--- /dev/null
+/*
+* Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
+*
+* This file is part of CasparCG (www.casparcg.com).
+*
+* CasparCG is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* CasparCG is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
+*
+* Author: Helge Norberg, helge.norberg@svt.se
+*/
+
+#include "../../stdafx.h"
+
+#include "../stack_trace.h"
+
+#include "../../compiler/vs/stack_walker.h"
+
+#include <utility>
+
+#include <tbb/enumerable_thread_specific.h>
+
+namespace caspar {
+
+std::wstring get_call_stack()
+{
+ class log_call_stack_walker : public stack_walker
+ {
+ std::string str_;
+ public:
+ log_call_stack_walker() : stack_walker() {}
+
+ std::string flush()
+ {
+ return std::move(str_);
+ }
+ protected:
+ virtual void OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUserName)
+ {
+ }
+ virtual void OnLoadModule(LPCSTR img, LPCSTR mod, DWORD64 baseAddr, DWORD size, DWORD result, LPCSTR symType, LPCSTR pdbName, ULONGLONG fileVersion)
+ {
+ }
+ virtual void OnDbgHelpErr(LPCSTR szFuncName, DWORD gle, DWORD64 addr)
+ {
+ }
+ virtual void OnOutput(LPCSTR szText)
+ {
+ std::string str = szText;
+
+ if(str.find("internal::get_call_stack") == std::string::npos && str.find("stack_walker::ShowCallstack") == std::string::npos)
+ str_ += std::move(str);
+ }
+ };
+
+ static tbb::enumerable_thread_specific<log_call_stack_walker> walkers;
+ try
+ {
+ auto& walker = walkers.local();
+ walker.ShowCallstack();
+ return u16(walker.flush());
+ }
+ catch(...)
+ {
+ return L"!!!";
+ }
+}
+
+}
* Author: Robert Nagy, ronag89@gmail.com
*/
-#pragma once
+#include "../../stdafx.h"
+
+#include "../system_info.h"
+#include "current_version.h"
#include "windows.h"
-#include <string>
#include <sstream>
#include <map>
namespace caspar {
-static std::wstring cpu_info()
+std::wstring cpu_info()
{
std::wstring cpu_name = L"Unknown CPU";
HKEY hkey;
return s.str();
}
-static std::wstring system_product_name()
+std::wstring system_product_name()
{
std::wstring system_product_name = L"Unknown System";
HKEY hkey;
return system_product_name;
}
+std::wstring os_description()
+{
+ return win_product_name() + L" " + win_sp_version();
+}
+
+
/*static std::map<std::wstring, std::wstring> enumerate_fonts()
{
std::map<std::wstring, std::wstring> result;
return result;
}*/
-}
\ No newline at end of file
+}
-#include "stdafx.h"
+#include "../../stdafx.h"
-#include "except.h"
+#include "win32_exception.h"
#include <boost/thread.hpp>
return *for_thread;
}
-void win32_exception::install_handler()
+void install_gpf_handler()
{
//#ifndef _DEBUG
_set_se_translator(win32_exception::Handler);
//#endif
}
-void win32_exception::ensure_handler_installed_for_thread(
+void ensure_gpf_handler_installed_for_thread(
const char* thread_description)
{
if (!installed_for_thread())
{
- install_handler();
+ install_gpf_handler();
if (thread_description)
detail::SetThreadName(GetCurrentThreadId(), thread_description);
return messageBuffer_;
}
-}
\ No newline at end of file
+}
--- /dev/null
+/*
+* Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
+*
+* This file is part of CasparCG (www.casparcg.com).
+*
+* CasparCG is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* CasparCG is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
+*
+* Author: Robert Nagy, ronag89@gmail.com
+*/
+
+#pragma once
+
+#include "../../except.h"
+
+struct _EXCEPTION_RECORD;
+struct _EXCEPTION_POINTERS;
+
+typedef _EXCEPTION_RECORD EXCEPTION_RECORD;
+typedef _EXCEPTION_POINTERS EXCEPTION_POINTERS;
+
+namespace caspar {
+
+class win32_exception : public std::exception
+{
+public:
+ typedef const void* address;
+
+ address location() const { return location_; }
+ unsigned int error_code() const { return errorCode_; }
+ virtual const char* what() const noexcept override { return message_; }
+
+protected:
+ win32_exception(const EXCEPTION_RECORD& info);
+ static void Handler(unsigned int errorCode, EXCEPTION_POINTERS* pInfo);
+
+private:
+ const char* message_;
+
+ address location_;
+ unsigned int errorCode_;
+};
+
+class win32_access_violation : public win32_exception
+{
+ mutable char messageBuffer_[256];
+
+public:
+ bool is_write() const { return isWrite_; }
+ address bad_address() const { return badAddress_;}
+ virtual const char* what() const noexcept override;
+
+protected:
+ win32_access_violation(const EXCEPTION_RECORD& info);
+ friend void win32_exception::Handler(unsigned int errorCode, EXCEPTION_POINTERS* pInfo);
+
+private:
+ bool isWrite_;
+ address badAddress_;
+};
+
+}
+
#undef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
\ No newline at end of file
+#include <windows.h>
private:
void scanner()
{
- win32_exception::install_handler();
-
- //detail::SetThreadName(GetCurrentThreadId(), "polling_filesystem_monitor");
+ ensure_gpf_handler_installed_for_thread("polling_filesystem_monitor");
bool running = scan(false);
initial_scan_completion_.set_value();
try
{
if (sleep)
- boost::this_thread::sleep(boost::posix_time::milliseconds(scan_interval_millis_));
+ boost::this_thread::sleep_for(boost::chrono::milliseconds(scan_interval_millis_));
if (reemmit_all_.fetch_and_store(false))
root_monitor_.reemmit_all();
initial_files_handler);
}
-}
\ No newline at end of file
+}
public:
prec_timer();
+ void tick(double interval)
+ {
+ tick_millis(static_cast<int64_t>(interval * 1000.0));
+ }
+
// Author: Ryan M. Geiss
// http://www.geisswerks.com/ryan/FAQS/timing.html
- void tick(double interval);
void tick_millis(int64_t interval);
private:
};
-}
\ No newline at end of file
+}
*
* @param permits The initial number of permits.
*/
- semaphore(unsigned int permits)
+ explicit semaphore(unsigned int permits)
: permits_(permits)
{
}
#pragma once
-#include "os/windows/windows.h"
\ No newline at end of file
+//#include "os/windows/windows.h"
//
//Open source under the BSD License.
//
-//Copyright © 2001 Robert Penner
+//Copyright � 2001 Robert Penner
//All rights reserved.
//
//Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
tweener_t get_tweener(std::wstring name)
{
- std::transform(name.begin(), name.end(), name.begin(), std::tolower);
+ std::transform(name.begin(), name.end(), name.begin(), std::towlower);
if(name == L"linear")
return [](double t, double b, double c, double d){return ease_none(t, b, c, d, std::vector<double>());};
#include <common/env.h>
#include <common/future.h>
#include <common/param.h>
-#include <common/os/windows/system_info.h>
#include <memory>
#include <boost/algorithm/string.hpp>
#include <BlueVelvet4.h>
-#include <common/page_locked_allocator.h>
+#include <common/os/page_locked_allocator.h>
#include <vector>
};
typedef std::shared_ptr<blue_dma_buffer> blue_dma_buffer_ptr;
-}}
\ No newline at end of file
+}}
#include <common/log.h>
#include <common/param.h>
-#include <common/os/windows/current_version.h>
-#include <common/os/windows/system_info.h>
+#include <common/os/system_info.h>
#include <common/base64.h>
#include <core/producer/frame_producer.h>
boost::property_tree::wptree info;
info.add(L"system.name", caspar::system_product_name());
- info.add(L"system.windows.name", caspar::win_product_name());
- info.add(L"system.windows.service-pack", caspar::win_sp_version());
+ info.add(L"system.os.description", caspar::os_description());
info.add(L"system.cpu", caspar::cpu_info());
for (auto& device : caspar::decklink::device_list())
}
} //namespace amcp
-}} //namespace caspar
\ No newline at end of file
+}} //namespace caspar
#include <common/except.h>
#include <common/log.h>
#include <common/gl/gl_check.h>
-#include <common/os/windows/current_version.h>
-#include <common/os/windows/system_info.h>
+#include <common/os/system_info.h>
#include <boost/property_tree/detail/file_parser_error.hpp>
#include <boost/property_tree/xml_parser.hpp>
CASPAR_LOG(info) << L"http://www.casparcg.com/";
CASPAR_LOG(info) << L"############################################################################";
CASPAR_LOG(info) << L"Starting CasparCG Video and Graphics Playout Server " << env::version();
- CASPAR_LOG(info) << L"on " << win_product_name() << L" " << win_sp_version();
+ CASPAR_LOG(info) << L"on " << os_description();
CASPAR_LOG(info) << cpu_info();
CASPAR_LOG(info) << system_product_name();
}
return return_code;
-}
\ No newline at end of file
+}
projects / casparcg / commitdiff