src/lib/ffmpeg_content.cc

   1 /*
   2     Copyright (C) 2013 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <libcxml/cxml.h>
  21 #include "ffmpeg_content.h"
  22 #include "ffmpeg_decoder.h"
  23 #include "compose.hpp"
  24 #include "job.h"
  25 #include "util.h"
  26 #include "log.h"
  27
  28 #include "i18n.h"
  29
  30 using std::string;
  31 using std::stringstream;
  32 using std::vector;
  33 using std::list;
  34 using boost::shared_ptr;
  35 using boost::lexical_cast;
  36
  37 int const FFmpegContentProperty::SUBTITLE_STREAMS = 100;
  38 int const FFmpegContentProperty::SUBTITLE_STREAM = 101;
  39 int const FFmpegContentProperty::AUDIO_STREAMS = 102;
  40 int const FFmpegContentProperty::AUDIO_STREAM = 103;
  41
  42 FFmpegContent::FFmpegContent (boost::filesystem::path f)
  43         : Content (f)
  44         , VideoContent (f)
  45         , AudioContent (f)
  46 {
  47
  48 }
  49
  50 FFmpegContent::FFmpegContent (shared_ptr<const cxml::Node> node)
  51         : Content (node)
  52         , VideoContent (node)
  53         , AudioContent (node)
  54 {
  55         list<shared_ptr<cxml::Node> > c = node->node_children ("SubtitleStream");
  56         for (list<shared_ptr<cxml::Node> >::const_iterator i = c.begin(); i != c.end(); ++i) {
  57                 _subtitle_streams.push_back (FFmpegSubtitleStream (*i));
  58                 if ((*i)->optional_number_child<int> ("Selected")) {
  59                         _subtitle_stream = _subtitle_streams.back ();
  60                 }
  61         }
  62
  63         c = node->node_children ("AudioStream");
  64         for (list<shared_ptr<cxml::Node> >::const_iterator i = c.begin(); i != c.end(); ++i) {
  65                 _audio_streams.push_back (FFmpegAudioStream (*i));
  66                 if ((*i)->optional_number_child<int> ("Selected")) {
  67                         _audio_stream = _audio_streams.back ();
  68                 }
  69         }
  70 }
  71
  72 FFmpegContent::FFmpegContent (FFmpegContent const & o)
  73         : Content (o)
  74         , VideoContent (o)
  75         , AudioContent (o)
  76         , _subtitle_streams (o._subtitle_streams)
  77         , _subtitle_stream (o._subtitle_stream)
  78         , _audio_streams (o._audio_streams)
  79         , _audio_stream (o._audio_stream)
  80 {
  81
  82 }
  83
  84 void
  85 FFmpegContent::as_xml (xmlpp::Node* node) const
  86 {
  87         node->add_child("Type")->add_child_text ("FFmpeg");
  88         Content::as_xml (node);
  89         VideoContent::as_xml (node);
  90
  91         boost::mutex::scoped_lock lm (_mutex);
  92
  93         for (vector<FFmpegSubtitleStream>::const_iterator i = _subtitle_streams.begin(); i != _subtitle_streams.end(); ++i) {
  94                 xmlpp::Node* t = node->add_child("SubtitleStream");
  95                 if (_subtitle_stream && *i == _subtitle_stream.get()) {
  96                         t->add_child("Selected")->add_child_text("1");
  97                 }
  98                 i->as_xml (t);
  99         }
 100
 101         for (vector<FFmpegAudioStream>::const_iterator i = _audio_streams.begin(); i != _audio_streams.end(); ++i) {
 102                 xmlpp::Node* t = node->add_child("AudioStream");
 103                 if (_audio_stream && *i == _audio_stream.get()) {
 104                         t->add_child("Selected")->add_child_text("1");
 105                 }
 106                 i->as_xml (t);
 107         }
 108 }
 109
 110 void
 111 FFmpegContent::examine (shared_ptr<Film> film, shared_ptr<Job> job, bool quick)
 112 {
 113         job->set_progress_unknown ();
 114
 115         Content::examine (film, job, quick);
 116
 117         shared_ptr<FFmpegDecoder> decoder (new FFmpegDecoder (film, shared_from_this (), true, false, false, true));
 118
 119         ContentVideoFrame video_length = 0;
 120         if (quick) {
 121                 video_length = decoder->video_length ();
 122                 film->log()->log (String::compose ("Video length obtained from header as %1 frames", decoder->video_length ()));
 123         } else {
 124                 while (!decoder->pass ()) {
 125                         /* keep going */
 126                 }
 127
 128                 video_length = decoder->video_frame ();
 129                 film->log()->log (String::compose ("Video length examined as %1 frames", decoder->video_frame ()));
 130         }
 131
 132         {
 133                 boost::mutex::scoped_lock lm (_mutex);
 134
 135                 _video_length = video_length;
 136
 137                 _subtitle_streams = decoder->subtitle_streams ();
 138                 if (!_subtitle_streams.empty ()) {
 139                         _subtitle_stream = _subtitle_streams.front ();
 140                 }
 141
 142                 _audio_streams = decoder->audio_streams ();
 143                 if (!_audio_streams.empty ()) {
 144                         _audio_stream = _audio_streams.front ();
 145                 }
 146         }
 147
 148         take_from_video_decoder (decoder);
 149
 150         signal_changed (VideoContentProperty::VIDEO_LENGTH);
 151         signal_changed (FFmpegContentProperty::SUBTITLE_STREAMS);
 152         signal_changed (FFmpegContentProperty::SUBTITLE_STREAM);
 153         signal_changed (FFmpegContentProperty::AUDIO_STREAMS);
 154         signal_changed (FFmpegContentProperty::AUDIO_STREAM);
 155 }
 156
 157 string
 158 FFmpegContent::summary () const
 159 {
 160         return String::compose (_("Movie: %1"), file().filename ());
 161 }
 162
 163 string
 164 FFmpegContent::information () const
 165 {
 166         if (video_length() == 0 || video_frame_rate() == 0) {
 167                 return "";
 168         }
 169
 170         stringstream s;
 171
 172         s << String::compose (_("%1 frames; %2 frames per second"), video_length(), video_frame_rate()) << "\n";
 173         s << VideoContent::information ();
 174
 175         return s.str ();
 176 }
 177
 178 void
 179 FFmpegContent::set_subtitle_stream (FFmpegSubtitleStream s)
 180 {
 181         {
 182                 boost::mutex::scoped_lock lm (_mutex);
 183                 _subtitle_stream = s;
 184         }
 185
 186         signal_changed (FFmpegContentProperty::SUBTITLE_STREAM);
 187 }
 188
 189 void
 190 FFmpegContent::set_audio_stream (FFmpegAudioStream s)
 191 {
 192         {
 193                 boost::mutex::scoped_lock lm (_mutex);
 194                 _audio_stream = s;
 195         }
 196
 197         signal_changed (FFmpegContentProperty::AUDIO_STREAM);
 198 }
 199
 200 ContentAudioFrame
 201 FFmpegContent::audio_length () const
 202 {
 203         if (!_audio_stream) {
 204                 return 0;
 205         }
 206
 207         return video_frames_to_audio_frames (_video_length, audio_frame_rate(), video_frame_rate());
 208 }
 209
 210 int
 211 FFmpegContent::audio_channels () const
 212 {
 213         if (!_audio_stream) {
 214                 return 0;
 215         }
 216
 217         return _audio_stream->channels ();
 218 }
 219
 220 int
 221 FFmpegContent::audio_frame_rate () const
 222 {
 223         if (!_audio_stream) {
 224                 return 0;
 225         }
 226
 227         return _audio_stream->frame_rate;
 228 }
 229
 230 int64_t
 231 FFmpegContent::audio_channel_layout () const
 232 {
 233         if (!_audio_stream) {
 234                 return 0;
 235         }
 236
 237         return _audio_stream->channel_layout;
 238 }
 239
 240 bool
 241 operator== (FFmpegSubtitleStream const & a, FFmpegSubtitleStream const & b)
 242 {
 243         return a.id == b.id;
 244 }
 245
 246 bool
 247 operator== (FFmpegAudioStream const & a, FFmpegAudioStream const & b)
 248 {
 249         return a.id == b.id;
 250 }
 251
 252 FFmpegAudioStream::FFmpegAudioStream (shared_ptr<const cxml::Node> node)
 253 {
 254         name = node->string_child ("Name");
 255         id = node->number_child<int> ("Id");
 256         frame_rate = node->number_child<int> ("FrameRate");
 257         channel_layout = node->number_child<int64_t> ("ChannelLayout");
 258 }
 259
 260 void
 261 FFmpegAudioStream::as_xml (xmlpp::Node* root) const
 262 {
 263         root->add_child("Name")->add_child_text (name);
 264         root->add_child("Id")->add_child_text (lexical_cast<string> (id));
 265         root->add_child("FrameRate")->add_child_text (lexical_cast<string> (frame_rate));
 266         root->add_child("ChannelLayout")->add_child_text (lexical_cast<string> (channel_layout));
 267 }
 268
 269 /** Construct a SubtitleStream from a value returned from to_string().
 270  *  @param t String returned from to_string().
 271  *  @param v State file version.
 272  */
 273 FFmpegSubtitleStream::FFmpegSubtitleStream (shared_ptr<const cxml::Node> node)
 274 {
 275         name = node->string_child ("Name");
 276         id = node->number_child<int> ("Id");
 277 }
 278
 279 void
 280 FFmpegSubtitleStream::as_xml (xmlpp::Node* root) const
 281 {
 282         root->add_child("Name")->add_child_text (name);
 283         root->add_child("Id")->add_child_text (lexical_cast<string> (id));
 284 }
 285
 286 shared_ptr<Content>
 287 FFmpegContent::clone () const
 288 {
 289         return shared_ptr<Content> (new FFmpegContent (*this));
 290 }