X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fffmpeg_subtitle_stream.cc;h=d389714e9e0c5ef9f194432e88bc34dfd08e2a82;hb=a11a63699106a07d1802331caa327d9d45f85cb8;hp=77a56e330297f608c84e6077c797190d5cad2809;hpb=83e5567530d0be24490abdda46d196e4279c5030;p=dcpomatic.git diff --git a/src/lib/ffmpeg_subtitle_stream.cc b/src/lib/ffmpeg_subtitle_stream.cc index 77a56e330..d389714e9 100644 --- a/src/lib/ffmpeg_subtitle_stream.cc +++ b/src/lib/ffmpeg_subtitle_stream.cc @@ -1,45 +1,94 @@ /* - Copyright (C) 2013-2014 Carl Hetherington + Copyright (C) 2013-2016 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ #include "ffmpeg_subtitle_stream.h" -#include "raw_convert.h" +#include #include #include +#include using std::string; using std::map; using std::list; +using std::cout; +using std::make_pair; +using dcp::raw_convert; /** Construct a SubtitleStream from a value returned from to_string(). * @param t String returned from to_string(). * @param v State file version. */ -FFmpegSubtitleStream::FFmpegSubtitleStream (cxml::ConstNodePtr node) +FFmpegSubtitleStream::FFmpegSubtitleStream (cxml::ConstNodePtr node, int version) : FFmpegStream (node) { - BOOST_FOREACH (cxml::NodePtr i, node->node_children ("Period")) { - add_subtitle ( - ContentTimePeriod ( - ContentTime (node->number_child ("From")), - ContentTime (node->number_child ("To")) - ) - ); + if (version == 32) { + BOOST_FOREACH (cxml::NodePtr i, node->node_children ("Period")) { + /* In version 32 we assumed that from times were unique, so they were + used as identifiers. All subtitles were image subtitles. + */ + add_image_subtitle ( + raw_convert (i->string_child ("From")), + ContentTimePeriod ( + ContentTime (i->number_child ("From")), + ContentTime (i->number_child ("To")) + ) + ); + } + } else { + /* In version 33 we use a hash of various parts of the subtitle as the id. + was initially used for image subtitles; later we have + and + */ + BOOST_FOREACH (cxml::NodePtr i, node->node_children ("Subtitle")) { + add_image_subtitle ( + raw_convert (i->string_child ("Id")), + ContentTimePeriod ( + ContentTime (i->number_child ("From")), + ContentTime (i->number_child ("To")) + ) + ); + } + + BOOST_FOREACH (cxml::NodePtr i, node->node_children ("ImageSubtitle")) { + add_image_subtitle ( + raw_convert (i->string_child ("Id")), + ContentTimePeriod ( + ContentTime (i->number_child ("From")), + ContentTime (i->number_child ("To")) + ) + ); + } + + BOOST_FOREACH (cxml::NodePtr i, node->node_children ("TextSubtitle")) { + add_text_subtitle ( + raw_convert (i->string_child ("Id")), + ContentTimePeriod ( + ContentTime (i->number_child ("From")), + ContentTime (i->number_child ("To")) + ) + ); + } + + BOOST_FOREACH (cxml::NodePtr i, node->node_children ("Colour")) { + _colours[RGBA(i->node_child("From"))] = RGBA (i->node_child("To")); + } } } @@ -48,39 +97,158 @@ FFmpegSubtitleStream::as_xml (xmlpp::Node* root) const { FFmpegStream::as_xml (root); - for (map::const_iterator i = _subtitles.begin(); i != _subtitles.end(); ++i) { - xmlpp::Node* node = root->add_child ("Subtitle"); - node->add_child("From")->add_child_text (raw_convert (i->first.get ())); - node->add_child("To")->add_child_text (raw_convert (i->second.get ())); + as_xml (root, _image_subtitles, "ImageSubtitle"); + as_xml (root, _text_subtitles, "TextSubtitle"); + + for (map::const_iterator i = _colours.begin(); i != _colours.end(); ++i) { + xmlpp::Node* node = root->add_child("Colour"); + i->first.as_xml (node->add_child("From")); + i->second.as_xml (node->add_child("To")); + } +} + +void +FFmpegSubtitleStream::as_xml (xmlpp::Node* root, PeriodMap const & subs, string node_name) const +{ + for (PeriodMap::const_iterator i = subs.begin(); i != subs.end(); ++i) { + xmlpp::Node* node = root->add_child (node_name); + node->add_child("Id")->add_child_text (i->first); + node->add_child("From")->add_child_text (raw_convert (i->second.from.get ())); + node->add_child("To")->add_child_text (raw_convert (i->second.to.get ())); } } void -FFmpegSubtitleStream::add_subtitle (ContentTimePeriod period) +FFmpegSubtitleStream::add_image_subtitle (string id, ContentTimePeriod period) +{ + DCPOMATIC_ASSERT (_image_subtitles.find (id) == _image_subtitles.end ()); + _image_subtitles[id] = period; +} + +void +FFmpegSubtitleStream::add_text_subtitle (string id, ContentTimePeriod period) +{ + DCPOMATIC_ASSERT (_text_subtitles.find (id) == _text_subtitles.end ()); + _text_subtitles[id] = period; +} + +list +FFmpegSubtitleStream::image_subtitles_during (ContentTimePeriod period, bool starting) const +{ + return subtitles_during (period, starting, _image_subtitles); +} + +list +FFmpegSubtitleStream::text_subtitles_during (ContentTimePeriod period, bool starting) const { - DCPOMATIC_ASSERT (_subtitles.find (period.from) == _subtitles.end ()); - _subtitles[period.from] = period.to; + return subtitles_during (period, starting, _text_subtitles); } -list -FFmpegSubtitleStream::subtitles_during (ContentTimePeriod period, bool starting) const +struct PeriodSorter +{ + bool operator() (ContentTimePeriod const & a, ContentTimePeriod const & b) { + return a.from < b.from; + } +}; + +list +FFmpegSubtitleStream::subtitles_during (ContentTimePeriod period, bool starting, PeriodMap const & subs) const { list d; - + /* XXX: inefficient */ - for (map::const_iterator i = _subtitles.begin(); i != _subtitles.end(); ++i) { - if ((starting && period.contains (i->first)) || (!starting && period.overlaps (ContentTimePeriod (i->first, i->second)))) { - d.push_back (ContentTimePeriod (i->first, i->second)); + for (map::const_iterator i = subs.begin(); i != subs.end(); ++i) { + if ((starting && period.contains(i->second.from)) || (!starting && period.overlap(i->second))) { + d.push_back (i->second); } } + d.sort (PeriodSorter ()); + return d; } ContentTime -FFmpegSubtitleStream::find_subtitle_to (ContentTime from) const +FFmpegSubtitleStream::find_subtitle_to (string id) const +{ + PeriodMap::const_iterator i = _image_subtitles.find (id); + if (i != _image_subtitles.end ()) { + return i->second.to; + } + + i = _text_subtitles.find (id); + DCPOMATIC_ASSERT (i != _text_subtitles.end ()); + return i->second.to; +} + +/** @param id Subtitle id. + * @return true if the `from' and `to' times for this id are equal, which indicates + * that the `to' time is unknown. + */ +bool +FFmpegSubtitleStream::unknown_to (string id) const +{ + PeriodMap::const_iterator i = _image_subtitles.find (id); + if (i != _image_subtitles.end ()) { + return i->second.from == i->second.to; + } + + i = _text_subtitles.find (id); + DCPOMATIC_ASSERT (i != _text_subtitles.end ()); + return i->second.from == i->second.to; +} + +/** Add some offset to all the times in the stream */ +void +FFmpegSubtitleStream::add_offset (ContentTime offset) +{ + for (PeriodMap::iterator i = _image_subtitles.begin(); i != _image_subtitles.end(); ++i) { + i->second.from += offset; + i->second.to += offset; + } + + for (PeriodMap::iterator i = _text_subtitles.begin(); i != _text_subtitles.end(); ++i) { + i->second.from += offset; + i->second.to += offset; + } +} + +map +FFmpegSubtitleStream::colours () const { - map::const_iterator i = _subtitles.find (from); - DCPOMATIC_ASSERT (i != _subtitles.end ()); - return i->second; + return _colours; +} + +void +FFmpegSubtitleStream::set_colour (RGBA from, RGBA to) +{ + _colours[from] = to; +} + +bool +FFmpegSubtitleStream::has_text () const +{ + return !_text_subtitles.empty (); +} + +bool +FFmpegSubtitleStream::has_image () const +{ + return !_image_subtitles.empty (); +} + +void +FFmpegSubtitleStream::set_subtitle_to (string id, ContentTime to) +{ + PeriodMap::iterator i = _image_subtitles.find (id); + if (i != _image_subtitles.end ()) { + i->second.to = to; + } else { + i = _text_subtitles.find (id); + if (i != _text_subtitles.end ()) { + i->second.to = to; + } else { + DCPOMATIC_ASSERT (false); + } + } }