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                                 /* 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                         float h_position = i.horizontal_position.proportional;
 183                         switch (i.horizontal_position.reference) {
 184                         case sub::LEFT_OF_SCREEN:
 185                                 h_align = dcp::HALIGN_LEFT;
 186                                 h_position = max(h_position, 0.05f);
 187                                 break;
 188                         case sub::HORIZONTAL_CENTRE_OF_SCREEN:
 189                                 h_align = dcp::HALIGN_CENTER;
 190                                 break;
 191                         case sub::RIGHT_OF_SCREEN:
 192                                 h_align = dcp::HALIGN_RIGHT;
 193                                 h_position = max(h_position, 0.05f);
 194                                 break;
 195                         default:
 196                                 h_align = dcp::HALIGN_CENTER;
 197                                 break;
 198                         }
 199
 200                         /* The idea here (rightly or wrongly) is that we set the appearance based on the
 201                            values in the libsub objects, and these are overridden with values from the
 202                            content by the other emit_plain_start() above.
 203                         */
 204
 205                         out.push_back (
 206                                 dcp::SubtitleString (
 207                                         string(TEXT_FONT_ID),
 208                                         j.italic,
 209                                         j.bold,
 210                                         j.underline,
 211                                         j.colour.dcp(),
 212                                         j.font_size.points (72 * 11),
 213                                         1.0,
 214                                         dcp::Time (from.seconds(), 1000),
 215                                         /* XXX: hmm; this is a bit ugly (we don't know the to time yet) */
 216                                         dcp::Time (),
 217                                         h_position,
 218                                         h_align,
 219                                         v_position,
 220                                         v_align,
 221                                         dcp::DIRECTION_LTR,
 222                                         j.text,
 223                                         dcp::NONE,
 224                                         j.effect_colour.get_value_or(sub::Colour(0, 0, 0)).dcp(),
 225                                         /* Hack: we should use subtitle.fade_up and subtitle.fade_down here
 226                                            but the times of these often don't have a frame rate associated
 227                                            with them so the sub::Time won't convert them to milliseconds without
 228                                            throwing an exception.  Since only DCP subs fill those in (and we don't
 229                                            use libsub for DCP subs) we can cheat by just putting 0 in here.
 230                                         */
 231                                         dcp::Time (),
 232                                         dcp::Time ()
 233                                         )
 234                                 );
 235                 }
 236         }
 237
 238         emit_plain_start (from, out);
 239 }
 240
 241 void
 242 TextDecoder::emit_stop (ContentTime to)
 243 {
 244         Stop (to);
 245 }
 246
 247 void
 248 TextDecoder::emit_plain (ContentTimePeriod period, list<dcp::SubtitleString> s)
 249 {
 250         emit_plain_start (period.from, s);
 251         emit_stop (period.to);
 252 }
 253
 254 void
 255 TextDecoder::emit_plain (ContentTimePeriod period, sub::Subtitle const & s)
 256 {
 257         emit_plain_start (period.from, s);
 258         emit_stop (period.to);
 259 }
 260
 261 /*  @param rect Area expressed as a fraction of the video frame that this subtitle
 262  *  is for (e.g. a width of 0.5 means the width of the subtitle is half the width
 263  *  of the video frame)
 264  */
 265 void
 266 TextDecoder::emit_bitmap (ContentTimePeriod period, shared_ptr<Image> image, dcpomatic::Rect<double> rect)
 267 {
 268         emit_bitmap_start (period.from, image, rect);
 269         emit_stop (period.to);
 270 }
 271
 272 void
 273 TextDecoder::seek ()
 274 {
 275         _position = ContentTime ();
 276 }