2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
4 * This file is part of CasparCG (www.casparcg.com).
6 * CasparCG is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * CasparCG is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
19 * Author: Niklas P Andersson, niklas.p.andersson@svt.se
22 #include "../../StdAfx.h"
24 #include "text_producer.h"
26 #include <core/producer/frame_producer.h>
27 #include <core/producer/color/color_producer.h>
28 #include <core/producer/variable.h>
29 #include <core/frame/geometry.h>
30 #include <core/frame/frame.h>
31 #include <core/frame/draw_frame.h>
32 #include <core/frame/frame_factory.h>
33 #include <core/frame/pixel_format.h>
34 #include <core/frame/audio_channel_layout.h>
35 #include <core/monitor/monitor.h>
36 #include <core/consumer/frame_consumer.h>
37 #include <core/module_dependencies.h>
38 #include <core/help/help_repository.h>
39 #include <core/help/help_sink.h>
41 #include <modules/image/consumer/image_consumer.h>
43 #include <common/except.h>
44 #include <common/array.h>
45 #include <common/env.h>
46 #include <common/future.h>
47 #include <common/param.h>
50 #include <boost/algorithm/string.hpp>
51 #include <boost/property_tree/ptree.hpp>
52 #include <boost/filesystem.hpp>
55 #include FT_FREETYPE_H
58 #include "utils/texture_atlas.h"
59 #include "utils/texture_font.h"
60 #include "utils/freetype_library.h"
63 const std::wstring& lhs;
65 explicit font_comparer(const std::wstring& p) : lhs(p) {}
66 bool operator()(const std::pair<std::wstring, std::wstring>&rhs) { return boost::iequals(lhs, rhs.first); }
70 namespace caspar { namespace core { namespace text {
72 using namespace boost::filesystem;
74 std::map<std::wstring, std::wstring> enumerate_fonts()
76 std::map<std::wstring, std::wstring> result;
78 for(auto iter = directory_iterator(env::font_folder()), end = directory_iterator(); iter != end; ++iter)
83 if (is_regular_file(file.path()))
85 auto face = get_new_face(u8(file.path().native()));
86 const char* fontname = FT_Get_Postscript_Name(face.get()); //this doesn't work for .fon fonts. Ignoring those for now
87 if (fontname != nullptr)
89 std::string fontname_str(fontname);
90 result.insert(std::make_pair(u16(fontname_str), u16(file.path().native())));
100 std::vector<std::pair<std::wstring, std::wstring>> list_fonts()
102 auto fonts = enumerate_fonts();
103 return std::vector<std::pair<std::wstring, std::wstring>>(fonts.begin(), fonts.end());
106 void describe_text_producer(help_sink&, const help_repository&);
107 spl::shared_ptr<frame_producer> create_text_producer(const frame_producer_dependencies&, const std::vector<std::wstring>&);
109 void init(module_dependencies dependencies)
111 dependencies.producer_registry->register_producer_factory(L"Text Producer", create_text_producer, describe_text_producer);
114 text_info& find_font_file(text_info& info)
116 auto& font_name = info.font;
117 auto fonts = enumerate_fonts();
118 auto it = std::find_if(fonts.begin(), fonts.end(), font_comparer(font_name));
119 info.font_file = (it != fonts.end()) ? (*it).second : L"";
126 struct text_producer::impl
128 monitor::subject monitor_subject_;
129 spl::shared_ptr<core::frame_factory> frame_factory_;
135 constraints constraints_ { parent_width_, parent_height_ };
136 variable_impl<std::wstring> text_;
137 std::shared_ptr<void> text_subscription_;
138 variable_impl<double> tracking_;
139 variable_impl<double> scale_x_;
140 variable_impl<double> scale_y_;
141 variable_impl<double> shear_;
142 std::shared_ptr<void> tracking_subscription_;
143 variable_impl<double> current_bearing_y_;
144 variable_impl<double> current_protrude_under_y_;
146 text::texture_atlas atlas_ { 1024, 512, 4 };
147 text::texture_font font_;
148 const_frame atlas_frame_;
151 explicit impl(const spl::shared_ptr<frame_factory>& frame_factory, int x, int y, const std::wstring& str, text::text_info& text_info, long parent_width, long parent_height, bool standalone)
152 : frame_factory_(frame_factory)
154 , parent_width_(parent_width), parent_height_(parent_height)
155 , standalone_(standalone)
156 , font_(atlas_, text::find_font_file(text_info), !standalone)
158 //TODO: examine str to determine which unicode_blocks to load
159 font_.load_glyphs(text::unicode_block::Basic_Latin, text_info.color);
160 font_.load_glyphs(text::unicode_block::Latin_1_Supplement, text_info.color);
161 font_.load_glyphs(text::unicode_block::Latin_Extended_A, text_info.color);
163 atlas_frame_ = create_atlas_frame();
165 tracking_.value().set(text_info.tracking);
166 scale_x_.value().set(text_info.scale_x);
167 scale_y_.value().set(text_info.scale_y);
168 shear_.value().set(text_info.shear);
169 text_subscription_ = text_.value().on_change([this]()
173 tracking_subscription_ = tracking_.value().on_change([this]()
178 constraints_.height.depend_on(text());
179 constraints_.width.depend_on(text());
180 current_bearing_y_.as<double>().depend_on(text());
181 current_protrude_under_y_.as<double>().depend_on(text());
184 text_.value().set(str);
186 CASPAR_LOG(info) << print() << L" Initialized";
189 core::const_frame create_atlas_frame() const
191 core::pixel_format_desc pfd(core::pixel_format::bgra);
192 pfd.planes.push_back(core::pixel_format_desc::plane(static_cast<int>(atlas_.width()), static_cast<int>(atlas_.height()), static_cast<int>(atlas_.depth())));
193 auto frame = frame_factory_->create_frame(this, pfd, core::audio_channel_layout::invalid());
194 memcpy(frame.image_data().data(), atlas_.data(), frame.image_data().size());
195 return std::move(frame);
198 void generate_frame()
200 text::string_metrics metrics;
201 font_.set_tracking(tracking_.value().get());
203 auto vertex_stream = font_.create_vertex_stream(text_.value().get(), x_, y_, parent_width_, parent_height_, &metrics, shear_.value().get());
204 auto frame = atlas_frame_.with_geometry(frame_geometry(frame_geometry::geometry_type::quad_list, std::move(vertex_stream)));
206 this->constraints_.width.set(metrics.width * this->scale_x_.value().get());
207 this->constraints_.height.set(metrics.height * this->scale_y_.value().get());
208 current_bearing_y_.value().set(metrics.bearingY);
209 current_protrude_under_y_.value().set(metrics.protrudeUnderY);
210 frame_ = core::draw_frame(std::move(frame));
213 text::string_metrics measure_string(const std::wstring& str)
215 return font_.measure_string(str);
220 draw_frame receive_impl()
225 std::future<std::wstring> call(const std::vector<std::wstring>& param)
228 text_.value().set(param.empty() ? L"" : param[0]);
230 return make_ready_future(std::move(result));
233 variable& get_variable(const std::wstring& name)
237 else if (name == L"current_bearing_y")
238 return current_bearing_y_;
239 else if (name == L"current_protrude_under_y")
240 return current_protrude_under_y_;
241 else if (name == L"tracking")
244 CASPAR_THROW_EXCEPTION(user_error() << msg_info(L"text_producer does not have a variable called " + name));
247 const std::vector<std::wstring>& get_variables() const
249 static const std::vector<std::wstring> vars = {
252 L"current_bearing_y",
253 L"current_protrude_under_y"
259 constraints& pixel_constraints()
264 binding<std::wstring>& text()
266 return text_.value();
269 binding<double>& tracking()
271 return tracking_.value();
274 const binding<double>& current_bearing_y() const
276 return current_bearing_y_.value();
279 const binding<double>& current_protrude_under_y() const
281 return current_protrude_under_y_.value();
284 std::wstring print() const
286 return L"text[" + text_.value().get() + L"]";
289 std::wstring name() const
294 boost::property_tree::wptree info() const
296 boost::property_tree::wptree info;
297 info.add(L"type", L"text");
298 info.add(L"text", text_.value().get());
299 info.add(L"font", font_.get_name());
300 info.add(L"size", font_.get_size());
305 text_producer::text_producer(const spl::shared_ptr<frame_factory>& frame_factory, int x, int y, const std::wstring& str, text::text_info& text_info, long parent_width, long parent_height, bool standalone)
306 : impl_(new impl(frame_factory, x, y, str, text_info, parent_width, parent_height, standalone))
309 draw_frame text_producer::receive_impl() { return impl_->receive_impl(); }
310 std::future<std::wstring> text_producer::call(const std::vector<std::wstring>& param) { return impl_->call(param); }
311 variable& text_producer::get_variable(const std::wstring& name) { return impl_->get_variable(name); }
312 const std::vector<std::wstring>& text_producer::get_variables() const { return impl_->get_variables(); }
313 text::string_metrics text_producer::measure_string(const std::wstring& str) { return impl_->measure_string(str); }
315 constraints& text_producer::pixel_constraints() { return impl_->pixel_constraints(); }
316 std::wstring text_producer::print() const { return impl_->print(); }
317 std::wstring text_producer::name() const { return impl_->name(); }
318 boost::property_tree::wptree text_producer::info() const { return impl_->info(); }
319 monitor::subject& text_producer::monitor_output() { return impl_->monitor_subject_; }
320 binding<std::wstring>& text_producer::text() { return impl_->text(); }
321 binding<double>& text_producer::tracking() { return impl_->tracking(); }
322 const binding<double>& text_producer::current_bearing_y() const { return impl_->current_bearing_y(); }
323 const binding<double>& text_producer::current_protrude_under_y() const { return impl_->current_protrude_under_y(); }
325 spl::shared_ptr<text_producer> text_producer::create(const spl::shared_ptr<frame_factory>& frame_factory, int x, int y, const std::wstring& str, text::text_info& text_info, long parent_width, long parent_height, bool standalone)
327 return spl::make_shared<text_producer>(frame_factory, x, y, str, text_info, parent_width, parent_height, standalone);
331 void describe_text_producer(help_sink& sink, const help_repository& repo)
333 sink.short_description(L"A producer for rendering dynamic text.");
334 sink.syntax(L"[TEXT] [text:string] {[x:int] [y:int]} {FONT [font:string]|verdana} {SIZE [size:float]|30.0} {COLOR [color:string]|#ffffffff} {STANDALONE [standalone:0,1]|0}");
336 ->text(L"Renders dynamic text using fonts found under the ")->code(L"fonts")->text(L" folder. ")
337 ->text(L"Parameters:");
339 ->item(L"text", L"The text to display. Can be changed later via CALL as well.")
340 ->item(L"x", L"The x position of the text.")
341 ->item(L"y", L"The y position of the text.")
342 ->item(L"font", L"The name of the font (not the actual filename, but the font name).")
343 ->item(L"size", L"The point size.")
344 ->item(L"color", L"The color as an ARGB hex value.")
345 ->item(L"standalone", L"Whether to normalize coordinates or not.");
346 sink.para()->text(L"Examples:");
347 sink.example(L">> PLAY 1-10 [TEXT] \"John Doe\" 0 0 FONT ArialMT SIZE 30 COLOR #1b698d STANDALONE 1");
348 sink.example(L">> CALL 1-10 \"Jane Doe\"", L"for modifying the text while playing.");
349 sink.para()->text(L"See ")->see(L"FLS")->text(L" for listing the available fonts.");
352 spl::shared_ptr<frame_producer> create_text_producer(const frame_producer_dependencies& dependencies, const std::vector<std::wstring>& params)
354 if(params.size() < 2 || !boost::iequals(params.at(0), L"[text]"))
355 return core::frame_producer::empty();
358 if(params.size() >= 4)
360 x = boost::lexical_cast<int>(params.at(2));
361 y = boost::lexical_cast<int>(params.at(3));
364 text::text_info text_info;
365 text_info.font = get_param(L"FONT", params, L"verdana");
366 text_info.size = get_param(L"SIZE", params, 30.0); // 30.0f does not seem to work to get as float directly
368 std::wstring col_str = get_param(L"color", params, L"#ffffffff");
369 uint32_t col_val = 0xffffffff;
370 try_get_color(col_str, col_val);
371 text_info.color = core::text::color<double>(col_val);
373 bool standalone = get_param(L"STANDALONE", params, false);
375 return text_producer::create(
376 dependencies.frame_factory,
380 dependencies.format_desc.width, dependencies.format_desc.height,