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 boost::shared_ptr;
  37 using boost::optional;
  38 using boost::function;
  39 using namespace dcpomatic;
  40
  41 TextDecoder::TextDecoder (
  42         Decoder* parent,
  43         shared_ptr<const TextContent> c,
  44         ContentTime first
  45         )
  46         : DecoderPart (parent)
  47         , _content (c)
  48         , _position (first)
  49 {
  50
  51 }
  52
  53 /** Called by subclasses when an image subtitle is starting.
  54  *  @param from From time of the subtitle.
  55  *  @param image Subtitle image.
  56  *  @param rect Area expressed as a fraction of the video frame that this subtitle
  57  *  is for (e.g. a width of 0.5 means the width of the subtitle is half the width
  58  *  of the video frame)
  59  */
  60 void
  61 TextDecoder::emit_bitmap_start (ContentTime from, shared_ptr<Image> image, dcpomatic::Rect<double> rect)
  62 {
  63         BitmapStart (ContentBitmapText (from, image, rect));
  64         _position = from;
  65 }
  66
  67 void
  68 TextDecoder::emit_plain_start (ContentTime from, list<dcp::SubtitleString> s)
  69 {
  70         BOOST_FOREACH (dcp::SubtitleString& i, s) {
  71                 /* We must escape < and > in strings, otherwise they might confuse our subtitle
  72                    renderer (which uses some HTML-esque markup to do bold/italic etc.)
  73                 */
  74                 string t = i.text ();
  75                 boost::algorithm::replace_all (t, "<", "&lt;");
  76                 boost::algorithm::replace_all (t, ">", "&gt;");
  77                 i.set_text (t);
  78
  79                 /* Set any forced appearance */
  80                 if (content()->colour()) {
  81                         i.set_colour (*content()->colour());
  82                 }
  83                 if (content()->effect_colour()) {
  84                         i.set_effect_colour (*content()->effect_colour());
  85                 }
  86                 if (content()->effect()) {
  87                         i.set_effect (*content()->effect());
  88                 }
  89                 if (content()->fade_in()) {
  90                         i.set_fade_up_time (dcp::Time(content()->fade_in()->seconds(), 1000));
  91                 }
  92                 if (content()->fade_out()) {
  93                         i.set_fade_down_time (dcp::Time(content()->fade_out()->seconds(), 1000));
  94                 }
  95         }
  96
  97         PlainStart (ContentStringText (from, s));
  98         _position = from;
  99 }
 100
 101 void
 102 TextDecoder::emit_plain_start (ContentTime from, sub::Subtitle const & subtitle)
 103 {
 104         /* See if our next subtitle needs to be vertically placed on screen by us */
 105         bool needs_placement = false;
 106         optional<int> bottom_line;
 107         BOOST_FOREACH (sub::Line i, subtitle.lines) {
 108                 if (!i.vertical_position.reference || i.vertical_position.reference.get() == sub::TOP_OF_SUBTITLE) {
 109                         needs_placement = true;
 110                         DCPOMATIC_ASSERT (i.vertical_position.line);
 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                                 /* This 1.015 is an arbitrary value to lift the bottom sub off the bottom
 143                                    of the screen a bit to a pleasing degree.
 144                                 */
 145                                 v_position = 1.015 -
 146                                         (1 + bottom_line.get() - i.vertical_position.line.get())
 147                                         * 1.2 * content()->line_spacing() * content()->y_scale() * j.font_size.proportional (72 * 11);
 148
 149                                 v_align = dcp::VALIGN_TOP;
 150                         } else {
 151                                 DCPOMATIC_ASSERT (i.vertical_position.reference);
 152                                 if (i.vertical_position.proportional) {
 153                                         v_position = i.vertical_position.proportional.get();
 154                                 } else {
 155                                         DCPOMATIC_ASSERT (i.vertical_position.line);
 156                                         DCPOMATIC_ASSERT (i.vertical_position.lines);
 157                                         v_position = float(*i.vertical_position.line) / *i.vertical_position.lines;
 158                                 }
 159
 160                                 if (lowest_proportional) {
 161                                         /* Adjust line spacing */
 162                                         v_position = ((v_position - lowest_proportional.get()) * content()->line_spacing()) + lowest_proportional.get();
 163                                 }
 164
 165                                 switch (i.vertical_position.reference.get()) {
 166                                 case sub::TOP_OF_SCREEN:
 167                                         v_align = dcp::VALIGN_TOP;
 168                                         break;
 169                                 case sub::VERTICAL_CENTRE_OF_SCREEN:
 170                                         v_align = dcp::VALIGN_CENTER;
 171                                         break;
 172                                 case sub::BOTTOM_OF_SCREEN:
 173                                         v_align = dcp::VALIGN_BOTTOM;
 174                                         break;
 175                                 default:
 176                                         v_align = dcp::VALIGN_TOP;
 177                                         break;
 178                                 }
 179                         }
 180
 181                         dcp::HAlign h_align;
 182                         switch (i.horizontal_position.reference) {
 183                         case sub::LEFT_OF_SCREEN:
 184                                 h_align = dcp::HALIGN_LEFT;
 185                                 break;
 186                         case sub::HORIZONTAL_CENTRE_OF_SCREEN:
 187                                 h_align = dcp::HALIGN_CENTER;
 188                                 break;
 189                         case sub::RIGHT_OF_SCREEN:
 190                                 h_align = dcp::HALIGN_RIGHT;
 191                                 break;
 192                         default:
 193                                 h_align = dcp::HALIGN_CENTER;
 194                                 break;
 195                         }
 196
 197                         /* The idea here (rightly or wrongly) is that we set the appearance based on the
 198                            values in the libsub objects, and these are overridden with values from the
 199                            content by the other emit_plain_start() above.
 200                         */
 201
 202                         out.push_back (
 203                                 dcp::SubtitleString (
 204                                         string(TEXT_FONT_ID),
 205                                         j.italic,
 206                                         j.bold,
 207                                         j.underline,
 208                                         j.colour.dcp(),
 209                                         j.font_size.points (72 * 11),
 210                                         1.0,
 211                                         dcp::Time (from.seconds(), 1000),
 212                                         /* XXX: hmm; this is a bit ugly (we don't know the to time yet) */
 213                                         dcp::Time (),
 214                                         i.horizontal_position.proportional,
 215                                         h_align,
 216                                         v_position,
 217                                         v_align,
 218                                         dcp::DIRECTION_LTR,
 219                                         j.text,
 220                                         dcp::NONE,
 221                                         j.effect_colour.get_value_or(sub::Colour(0, 0, 0)).dcp(),
 222                                         /* Hack: we should use subtitle.fade_up and subtitle.fade_down here
 223                                            but the times of these often don't have a frame rate associated
 224                                            with them so the sub::Time won't convert them to milliseconds without
 225                                            throwing an exception.  Since only DCP subs fill those in (and we don't
 226                                            use libsub for DCP subs) we can cheat by just putting 0 in here.
 227                                         */
 228                                         dcp::Time (),
 229                                         dcp::Time ()
 230                                         )
 231                                 );
 232                 }
 233         }
 234
 235         emit_plain_start (from, out);
 236 }
 237
 238 void
 239 TextDecoder::emit_stop (ContentTime to)
 240 {
 241         Stop (to);
 242 }
 243
 244 void
 245 TextDecoder::emit_plain (ContentTimePeriod period, list<dcp::SubtitleString> s)
 246 {
 247         emit_plain_start (period.from, s);
 248         emit_stop (period.to);
 249 }
 250
 251 void
 252 TextDecoder::emit_plain (ContentTimePeriod period, sub::Subtitle const & s)
 253 {
 254         emit_plain_start (period.from, s);
 255         emit_stop (period.to);
 256 }
 257
 258 /*  @param rect Area expressed as a fraction of the video frame that this subtitle
 259  *  is for (e.g. a width of 0.5 means the width of the subtitle is half the width
 260  *  of the video frame)
 261  */
 262 void
 263 TextDecoder::emit_bitmap (ContentTimePeriod period, shared_ptr<Image> image, dcpomatic::Rect<double> rect)
 264 {
 265         emit_bitmap_start (period.from, image, rect);
 266         emit_stop (period.to);
 267 }
 268
 269 void
 270 TextDecoder::seek ()
 271 {
 272         _position = ContentTime ();
 273 }