#include "except.h"
#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
#include <type_traits>
#include <string>
namespace caspar {
-
+
+class param_comparer {
+ const std::wstring& lhs;
+ public:
+ explicit param_comparer(const std::wstring& p) : lhs(p) {}
+ bool operator()(const std::wstring& rhs) { return boost::iequals(lhs, rhs); }
+ };
+
+template<typename C>
+bool contains_param(const std::wstring& name, C&& params)
+{
+ return std::find_if(params.begin(), params.end(), param_comparer(name)) != params.end();
+}
+
template<typename T, typename C>
typename std::enable_if<!std::is_convertible<T, std::wstring>::value, typename std::decay<T>::type>::type get_param(const std::wstring& name, C&& params, T fail_value = T())
{
- auto it = std::find(std::begin(params), std::end(params), name);
+ auto it = std::find_if(std::begin(params), std::end(params), param_comparer(name));
+ //auto it = std::find(std::begin(params), std::end(params), name);
if(it == params.end())
return fail_value;
template<typename C>
std::wstring get_param(const std::wstring& name, C&& params, const std::wstring& fail_value = L"")
{
- auto it = std::find(std::begin(params), std::end(params), name);
+ auto it = std::find_if(std::begin(params), std::end(params), param_comparer(name));
+ //auto it = std::find(std::begin(params), std::end(params), name);
if(it == params.end())
return fail_value;
#include <boost/range.hpp>
#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>
spl::shared_ptr<frame_producer> create_freehand_producer(const spl::shared_ptr<frame_factory>& frame_factory, const std::vector<std::wstring>& params)
{
- if(params.size() < 3 || params.at(0) != L"[FREEHAND]")
+ if(params.size() < 3 || !boost::iequals(params.at(0), L"[FREEHAND]"))
return core::frame_producer::empty();
int width = boost::lexical_cast<int>(params.at(1));
spl::shared_ptr<frame_producer> create_dummy_scene_producer(const spl::shared_ptr<class frame_factory>& frame_factory, const video_format_desc& format_desc, const std::vector<std::wstring>& params)
{
- if (params.size() < 1 || params.at(0) != L"[SCENE]")
+ if (params.size() < 1 || !boost::iequals(params.at(0), L"[SCENE]"))
return core::frame_producer::empty();
auto scene = spl::make_shared<scene_producer>(format_desc.width, format_desc.height);
#include <common/array.h>
#include <common/env.h>
#include <common/future.h>
+#include <common/os/windows/system_info.h>
#include <memory>
#include <asmlib.h>
#include "utils\texture_atlas.h"
#include "utils\texture_font.h"
-namespace caspar { namespace core {
+class font_comparer {
+ const std::wstring& lhs;
+public:
+ explicit font_comparer(const std::wstring& p) : lhs(p) {}
+ bool operator()(const std::pair<std::wstring, std::wstring>&rhs) { return boost::iequals(lhs, rhs.first); }
+};
-std::wstring find_font_file(const std::wstring& font_name)
-{
- std::wstring filename = L"c:\\windows\\fonts\\" + font_name; //TODO: move font-folder setting to settings
- if(boost::filesystem::exists(filename + L".otf"))
- return filename + L".otf";
- if(boost::filesystem::exists(filename + L".ttf"))
- return filename + L".ttf";
- if(boost::filesystem::exists(filename + L".fon"))
- return filename + L".fon";
-
- //TODO: Searching by filename is not enough to identify some fonts. we need to extract the font-names somehow
- return L"";
-}
+
+namespace caspar { namespace core {
+ namespace text {
+
+ std::map<std::wstring, std::wstring> fonts;
+
+ void init()
+ {
+ fonts.swap(std::move(caspar::enumerate_fonts()));
+ }
+
+ std::wstring find_font_file(const std::wstring& font_name)
+ {
+ auto it = std::find_if(fonts.begin(), fonts.end(), font_comparer(font_name));
+ if(it != fonts.end())
+ {
+ std::wstring filename = L"c:\\windows\\fonts\\" + (*it).second; //TODO: move font-folder setting to settings
+ return filename;
+ }
+
+ //try the default font
+ it = std::find_if(fonts.begin(), fonts.end(), font_comparer(L"verdana")); //TODO: move default-font to settings
+ if(it != fonts.end())
+ {
+ std::wstring filename = L"c:\\windows\\fonts\\" + (*it).second; //TODO: move font-folder setting to settings
+ return filename;
+ }
+
+ //fail
+ return L"";
+ }
+ }
+
struct text_producer::impl
{
, x_(x), y_(y), parent_width_(parent_width), parent_height_(parent_height)
, standalone_(standalone)
, atlas_(512,512,4)
- , font_(atlas_, find_font_file(text_info.font), text_info.size, !standalone)
+ , font_(atlas_, text::find_font_file(text_info.font), text_info.size, !standalone)
{
font_.load_glyphs(text::Basic_Latin, text_info.color);
font_.load_glyphs(text::Latin_1_Supplement, text_info.color);
spl::shared_ptr<frame_producer> create_text_producer(const spl::shared_ptr<frame_factory>& frame_factory, const video_format_desc& format_desc, const std::vector<std::wstring>& params)
{
- if(params.size() < 2 || params.at(0) != L"[TEXT]")
+ if(params.size() < 2 || !boost::iequals(params.at(0), L"[TEXT]"))
return core::frame_producer::empty();
int x = 0, y = 0;
if(filename.empty())
return core::frame_producer::empty();
- auto loop = boost::range::find(params, L"LOOP") != params.end();
+ bool loop = contains_param(L"LOOP", params);
auto start = get_param(L"START", params, get_param(L"SEEK", params, static_cast<uint32_t>(0)));
auto length = get_param(L"LENGTH", params, std::numeric_limits<uint32_t>::max());
auto filter_str = get_param(L"FILTER", params, L"");
#include <common/except.h>
#include <common/array.h>
#include <common/tweener.h>
+#include <common/param.h>
#include <boost/assign.hpp>
#include <boost/filesystem.hpp>
if(ext == extensions.end())
return core::frame_producer::empty();
- double speed = 0.0;
double duration = 0.0;
- auto speed_it = std::find(params.begin(), params.end(), L"SPEED");
- if(speed_it != params.end())
- {
- if(++speed_it != params.end())
- speed = boost::lexical_cast<double>(*speed_it);
- }
+ double speed = get_param(L"SPEED", params, 0.0);
if (speed == 0)
- {
- auto duration_it = std::find(params.begin(), params.end(), L"DURATION");
-
- if (duration_it != params.end() && ++duration_it != params.end())
- {
- duration = boost::lexical_cast<double>(*duration_it);
- }
- }
+ duration = get_param(L"DURATION", params, 0.0);
if(speed == 0 && duration == 0)
return core::frame_producer::empty();
- int motion_blur_px = 0;
- auto blur_it = std::find(params.begin(), params.end(), L"BLUR");
- if (blur_it != params.end() && ++blur_it != params.end())
- {
- motion_blur_px = boost::lexical_cast<int>(*blur_it);
- }
+ int motion_blur_px = get_param(L"BLUR", params, 0);
- bool premultiply_with_alpha = std::find(params.begin(), params.end(), L"PREMULTIPLY") != params.end();
- bool progressive = std::find(params.begin(), params.end(), L"PROGRESSIVE") != params.end();
+ bool premultiply_with_alpha = contains_param(L"PREMULTIPLY", params);
+ bool progressive = contains_param(L"PROGRESSIVE", params);
return core::create_destroy_proxy(spl::make_shared<image_scroll_producer>(
frame_factory,
#include <common/env.h>
#include <common/log.h>
+#include <common/param.h>
#include <common/diagnostics/graph.h>
#include <common/os/windows/current_version.h>
#include <common/os/windows/system_info.h>
//Perform loading of the clip
try
{
- //auto what = _parameters.at(0);
auto result = GetChannel()->stage().call(GetLayerIndex(), parameters());
if(!result.timed_wait(boost::posix_time::seconds(2)))
//Perform loading of the clip
try
{
- //create_producer still expects all parameters to be uppercase
- BOOST_FOREACH(std::wstring& str, parameters())
- {
- boost::to_upper(str);
- }
-
auto pFP = create_producer(GetChannel()->frame_factory(), GetChannel()->video_format_desc(), parameters());
GetChannel()->stage().load(GetLayerIndex(), pFP, true);
}
else
{
- //create_producer still expects all parameters to be uppercase
- BOOST_FOREACH(std::wstring& str, parameters())
- {
- boost::to_upper(str);
- }
pFP = create_producer(GetChannel()->frame_factory(), GetChannel()->video_format_desc(), parameters());
}
if(pFP == frame_producer::empty())
CASPAR_THROW_EXCEPTION(file_not_found() << msg_info(parameters().size() > 0 ? parameters()[0] : L""));
- bool auto_play = std::find_if(parameters().begin(), parameters().end(), [](const std::wstring& p) { return boost::iequals(p, L"AUTO"); }) != parameters().end();
+ bool auto_play = contains_param(L"AUTO", parameters());
auto pFP2 = create_transition_producer(GetChannel()->video_format_desc().field_mode, spl::make_shared_ptr(pFP), transitionInfo);
if(auto_play)
{
std::getline(std::wcin, wcmd); // TODO: It's blocking...
- boost::to_upper(wcmd);
+ //boost::to_upper(wcmd);
- if(wcmd == L"EXIT" || wcmd == L"Q" || wcmd == L"QUIT" || wcmd == L"BYE")
+ if(boost::iequals(wcmd, L"EXIT") || boost::iequals(wcmd, L"Q") || boost::iequals(wcmd, L"QUIT") || boost::iequals(wcmd, L"BYE"))
break;
try