src/lib/active_text.cc

   1 /*
   2     Copyright (C) 2017-2018 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 "active_text.h"
  23 #include "text_content.h"
  24
  25
  26 using std::list;
  27 using std::pair;
  28 using std::make_pair;
  29 using std::weak_ptr;
  30 using std::shared_ptr;
  31 using boost::optional;
  32 using namespace dcpomatic;
  33
  34
  35 ActiveText::ActiveText(ActiveText&& other)
  36         : _data(std::move(other._data))
  37 {
  38
  39 }
  40
  41
  42 ActiveText&
  43 ActiveText::operator=(ActiveText&& other)
  44 {
  45         if (this != &other) {
  46                 _data = std::move(other._data);
  47         }
  48         return *this;
  49 }
  50
  51
  52 /** Get the open captions that should be burnt into a given period.
  53  *  @param period Period of interest.
  54  *  @param always_burn_captions Always burn captions even if their content is not set to burn.
  55  */
  56 list<PlayerText>
  57 ActiveText::get_burnt (DCPTimePeriod period, bool always_burn_captions) const
  58 {
  59         boost::mutex::scoped_lock lm (_mutex);
  60
  61         list<PlayerText> ps;
  62
  63         for (auto const& i: _data) {
  64
  65                 auto caption = i.first.lock ();
  66                 if (!caption) {
  67                         continue;
  68                 }
  69
  70                 if (!caption->use() || (!always_burn_captions && !caption->burn())) {
  71                         /* Not burning this content */
  72                         continue;
  73                 }
  74
  75                 for (auto j: i.second) {
  76                         DCPTimePeriod test (j.from, j.to.get_value_or(DCPTime::max()));
  77                         auto overlap = period.overlap (test);
  78                         if (overlap && overlap->duration() > DCPTime(period.duration().get() / 2)) {
  79                                 ps.push_back (j.subs);
  80                         }
  81                 }
  82         }
  83
  84         return ps;
  85 }
  86
  87
  88 /** Remove subtitles that finish before a given time from our list.
  89  *  @param time Time to remove before.
  90  */
  91 void
  92 ActiveText::clear_before (DCPTime time)
  93 {
  94         boost::mutex::scoped_lock lm (_mutex);
  95
  96         Map updated;
  97         for (auto const& i: _data) {
  98                 list<Period> as;
  99                 for (auto j: i.second) {
 100                         if (!j.to || j.to.get() >= time) {
 101                                 as.push_back (j);
 102                         }
 103                 }
 104                 if (!as.empty ()) {
 105                         updated[i.first] = as;
 106                 }
 107         }
 108         _data = updated;
 109 }
 110
 111
 112 /** Add a new subtitle with a from time.
 113  *  @param content Content that the subtitle is from.
 114  *  @param ps Subtitles.
 115  *  @param from From time for these subtitles.
 116  */
 117 void
 118 ActiveText::add_from (weak_ptr<const TextContent> content, PlayerText ps, DCPTime from)
 119 {
 120         boost::mutex::scoped_lock lm (_mutex);
 121
 122         if (_data.find(content) == _data.end()) {
 123                 _data[content] = list<Period>();
 124         }
 125         _data[content].push_back (Period (ps, from));
 126 }
 127
 128
 129 /** Add the to time for the last subtitle added from a piece of content.
 130  *  @param content Content that the subtitle is from.
 131  *  @param to To time for the last subtitle submitted to add_from for this content.
 132  *  @return Return the corresponding subtitles and their from time.
 133  */
 134 pair<PlayerText, DCPTime>
 135 ActiveText::add_to (weak_ptr<const TextContent> content, DCPTime to)
 136 {
 137         boost::mutex::scoped_lock lm (_mutex);
 138
 139         DCPOMATIC_ASSERT (_data.find(content) != _data.end());
 140
 141         _data[content].back().to = to;
 142
 143         for (auto& i: _data[content].back().subs.string) {
 144                 i.set_out (dcp::Time(to.seconds(), 1000));
 145         }
 146
 147         return make_pair (_data[content].back().subs, _data[content].back().from);
 148 }
 149
 150
 151 /** @param content Some content.
 152  *  @return true if we have any active subtitles from this content.
 153  */
 154 bool
 155 ActiveText::have (weak_ptr<const TextContent> content) const
 156 {
 157         boost::mutex::scoped_lock lm (_mutex);
 158
 159         auto i = _data.find(content);
 160         if (i == _data.end()) {
 161                 return false;
 162         }
 163
 164         return !i->second.empty();
 165 }
 166
 167
 168 void
 169 ActiveText::clear ()
 170 {
 171         boost::mutex::scoped_lock lm (_mutex);
 172         _data.clear ();
 173 }