src/lib/text_decoder.cc

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