src/lib/text_decoder.cc

   1 /*
   2     Copyright (C) 2013-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic 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 2 of the License, or
   9     (at your option) any later version.
  10
  11     DCP-o-matic 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.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21
  22 #include "text_decoder.h"
  23 #include "text_content.h"
  24 #include "util.h"
  25 #include "log.h"
  26 #include "compose.hpp"
  27 #include <sub/subtitle.h>
  28 #include <boost/algorithm/string.hpp>
  29 #include <iostream>
  30
  31
  32 using std::list;
  33 using std::cout;
  34 using std::string;
  35 using std::min;
  36 using std::max;
  37 using std::shared_ptr;
  38 using boost::optional;
  39 using namespace dcpomatic;
  40
  41
  42 TextDecoder::TextDecoder (
  43         Decoder* parent,
  44         shared_ptr<const TextContent> c,
  45         ContentTime first
  46         )
  47         : DecoderPart (parent)
  48         , _content (c)
  49         , _position (first)
  50 {
  51
  52 }
  53
  54
  55 /** Called by subclasses when an image subtitle is starting.
  56  *  @param from From time of the subtitle.
  57  *  @param image Subtitle image.
  58  *  @param rect Area expressed as a fraction of the video frame that this subtitle
  59  *  is for (e.g. a width of 0.5 means the width of the subtitle is half the width
  60  *  of the video frame)
  61  */
  62 void
  63 TextDecoder::emit_bitmap_start (ContentTime from, shared_ptr<const Image> image, dcpomatic::Rect<double> rect)
  64 {
  65         BitmapStart (ContentBitmapText (from, image, rect));
  66         _position = from;
  67 }
  68
  69
  70 void
  71 TextDecoder::emit_plain_start (ContentTime from, list<dcp::SubtitleString> s)
  72 {
  73         for (auto& i: s) {
  74                 /* We must escape some things, otherwise they might confuse our subtitle
  75                    renderer (which uses entities and some HTML-esque markup to do bold/italic etc.)
  76                 */
  77                 string t = i.text ();
  78                 boost::algorithm::replace_all (t, "&", "&amp;");
  79                 boost::algorithm::replace_all (t, "<", "&lt;");
  80                 boost::algorithm::replace_all (t, ">", "&gt;");
  81                 i.set_text (t);
  82
  83                 /* Set any forced appearance */
  84                 if (content()->colour()) {
  85                         i.set_colour (*content()->colour());
  86                 }
  87                 if (content()->effect_colour()) {
  88                         i.set_effect_colour (*content()->effect_colour());
  89                 }
  90                 if (content()->effect()) {
  91                         i.set_effect (*content()->effect());
  92                 }
  93                 if (content()->fade_in()) {
  94                         i.set_fade_up_time (dcp::Time(content()->fade_in()->seconds(), 1000));
  95                 }
  96                 if (content()->fade_out()) {
  97                         i.set_fade_down_time (dcp::Time(content()->fade_out()->seconds(), 1000));
  98                 }
  99         }
 100
 101         PlainStart (ContentStringText (from, s));
 102         _position = from;
 103 }
 104
 105
 106 void
 107 TextDecoder::emit_plain_start (ContentTime from, sub::Subtitle const & subtitle)
 108 {
 109         /* See if our next subtitle needs to be vertically placed on screen by us */
 110         bool needs_placement = false;
 111         optional<int> bottom_line;
 112         for (auto i: subtitle.lines) {
 113                 if (!i.vertical_position.reference || (i.vertical_position.line && !i.vertical_position.lines) || i.vertical_position.reference.get() == sub::TOP_OF_SUBTITLE) {
 114                         needs_placement = true;
 115                         if (!bottom_line || bottom_line.get() < i.vertical_position.line.get()) {
 116                                 bottom_line = i.vertical_position.line.get();
 117                         }
 118                 }
 119         }
 120
 121         /* Find the lowest proportional position */
 122         optional<float> lowest_proportional;
 123         for (auto i: subtitle.lines) {
 124                 if (i.vertical_position.proportional) {
 125                         if (!lowest_proportional) {
 126                                 lowest_proportional = i.vertical_position.proportional;
 127                         } else {
 128                                 lowest_proportional = min (lowest_proportional.get(), i.vertical_position.proportional.get());
 129                         }
 130                 }
 131         }
 132
 133         list<dcp::SubtitleString> out;
 134         for (auto i: subtitle.lines) {
 135                 for (auto j: i.blocks) {
 136
 137                         if (!j.font_size.specified()) {
 138                                 /* Fallback default font size if no other has been specified */
 139                                 j.font_size.set_points (48);
 140                         }
 141
 142                         float v_position;
 143                         dcp::VAlign v_align;
 144                         if (needs_placement) {
 145                                 DCPOMATIC_ASSERT (i.vertical_position.line);
 146                                 double const multiplier = 1.2 * content()->line_spacing() * content()->y_scale() * j.font_size.proportional (72 * 11);
 147                                 switch (i.vertical_position.reference.get_value_or(sub::BOTTOM_OF_SCREEN)) {
 148                                 case sub::BOTTOM_OF_SCREEN:
 149                                 case sub::TOP_OF_SUBTITLE:
 150                                         /* This 1.015 is an arbitrary value to lift the bottom sub off the bottom
 151                                            of the screen a bit to a pleasing degree.
 152                                            */
 153                                         v_position = 1.015 -
 154                                                 (1 + bottom_line.get() - i.vertical_position.line.get()) * multiplier;
 155
 156                                         v_align = dcp::VAlign::TOP;
 157                                         break;
 158                                 case sub::TOP_OF_SCREEN:
 159                                         /* This 0.1 is another fudge factor to bring the top line away from the top of the screen a little */
 160                                         v_position = 0.12 + i.vertical_position.line.get() * multiplier;
 161                                         v_align = dcp::VAlign::TOP;
 162                                         break;
 163                                 case sub::VERTICAL_CENTRE_OF_SCREEN:
 164                                         v_position = i.vertical_position.line.get() * multiplier;
 165                                         v_align = dcp::VAlign::CENTER;
 166                                         break;
 167                                 }
 168                         } else {
 169                                 DCPOMATIC_ASSERT (i.vertical_position.reference);
 170                                 if (i.vertical_position.proportional) {
 171                                         v_position = i.vertical_position.proportional.get();
 172                                 } else {
 173                                         DCPOMATIC_ASSERT (i.vertical_position.line);
 174                                         DCPOMATIC_ASSERT (i.vertical_position.lines);
 175                                         v_position = float(*i.vertical_position.line) / *i.vertical_position.lines;
 176                                 }
 177
 178                                 if (lowest_proportional) {
 179                                         /* Adjust line spacing */
 180                                         v_position = ((v_position - lowest_proportional.get()) * content()->line_spacing()) + lowest_proportional.get();
 181                                 }
 182
 183                                 switch (i.vertical_position.reference.get()) {
 184                                 case sub::TOP_OF_SCREEN:
 185                                         v_align = dcp::VAlign::TOP;
 186                                         break;
 187                                 case sub::VERTICAL_CENTRE_OF_SCREEN:
 188                                         v_align = dcp::VAlign::CENTER;
 189                                         break;
 190                                 case sub::BOTTOM_OF_SCREEN:
 191                                         v_align = dcp::VAlign::BOTTOM;
 192                                         break;
 193                                 default:
 194                                         v_align = dcp::VAlign::TOP;
 195                                         break;
 196                                 }
 197                         }
 198
 199                         dcp::HAlign h_align;
 200                         float h_position = i.horizontal_position.proportional;
 201                         switch (i.horizontal_position.reference) {
 202                         case sub::LEFT_OF_SCREEN:
 203                                 h_align = dcp::HAlign::LEFT;
 204                                 h_position = max(h_position, 0.05f);
 205                                 break;
 206                         case sub::HORIZONTAL_CENTRE_OF_SCREEN:
 207                                 h_align = dcp::HAlign::CENTER;
 208                                 break;
 209                         case sub::RIGHT_OF_SCREEN:
 210                                 h_align = dcp::HAlign::RIGHT;
 211                                 h_position = max(h_position, 0.05f);
 212                                 break;
 213                         default:
 214                                 h_align = dcp::HAlign::CENTER;
 215                                 break;
 216                         }
 217
 218                         /* The idea here (rightly or wrongly) is that we set the appearance based on the
 219                            values in the libsub objects, and these are overridden with values from the
 220                            content by the other emit_plain_start() above.
 221                         */
 222
 223                         out.push_back (
 224                                 dcp::SubtitleString (
 225                                         string(TEXT_FONT_ID),
 226                                         j.italic,
 227                                         j.bold,
 228                                         j.underline,
 229                                         j.colour.dcp(),
 230                                         j.font_size.points (72 * 11),
 231                                         1.0,
 232                                         dcp::Time (from.seconds(), 1000),
 233                                         /* XXX: hmm; this is a bit ugly (we don't know the to time yet) */
 234                                         dcp::Time (),
 235                                         h_position,
 236                                         h_align,
 237                                         v_position,
 238                                         v_align,
 239                                         dcp::Direction::LTR,
 240                                         j.text,
 241                                         dcp::Effect::NONE,
 242                                         j.effect_colour.get_value_or(sub::Colour(0, 0, 0)).dcp(),
 243                                         /* Hack: we should use subtitle.fade_up and subtitle.fade_down here
 244                                            but the times of these often don't have a frame rate associated
 245                                            with them so the sub::Time won't convert them to milliseconds without
 246                                            throwing an exception.  Since only DCP subs fill those in (and we don't
 247                                            use libsub for DCP subs) we can cheat by just putting 0 in here.
 248                                         */
 249                                         dcp::Time (),
 250                                         dcp::Time (),
 251                                         0
 252                                         )
 253                                 );
 254                 }
 255         }
 256
 257         emit_plain_start (from, out);
 258 }
 259
 260
 261 void
 262 TextDecoder::emit_stop (ContentTime to)
 263 {
 264         Stop (to);
 265 }
 266
 267
 268 void
 269 TextDecoder::emit_plain (ContentTimePeriod period, list<dcp::SubtitleString> s)
 270 {
 271         emit_plain_start (period.from, s);
 272         emit_stop (period.to);
 273 }
 274
 275
 276 void
 277 TextDecoder::emit_plain (ContentTimePeriod period, sub::Subtitle const & s)
 278 {
 279         emit_plain_start (period.from, s);
 280         emit_stop (period.to);
 281 }
 282
 283
 284 /*  @param rect Area expressed as a fraction of the video frame that this subtitle
 285  *  is for (e.g. a width of 0.5 means the width of the subtitle is half the width
 286  *  of the video frame)
 287  */
 288 void
 289 TextDecoder::emit_bitmap (ContentTimePeriod period, shared_ptr<const Image> image, dcpomatic::Rect<double> rect)
 290 {
 291         emit_bitmap_start (period.from, image, rect);
 292         emit_stop (period.to);
 293 }
 294
 295
 296 void
 297 TextDecoder::seek ()
 298 {
 299         _position = ContentTime ();
 300 }