src/lib/transcoder.cc

   1 /*
   2     Copyright (C) 2012-2016 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 /** @file  src/transcoder.cc
  22  *  @brief A class which takes a Film and some Options, then uses those to transcode the film.
  23  *
  24  *  A decoder is selected according to the content type, and the encoder can be specified
  25  *  as a parameter to the constructor.
  26  */
  27
  28 #include "transcoder.h"
  29 #include "encoder.h"
  30 #include "film.h"
  31 #include "video_decoder.h"
  32 #include "audio_decoder.h"
  33 #include "player.h"
  34 #include "job.h"
  35 #include "writer.h"
  36 #include "compose.hpp"
  37 #include "referenced_reel_asset.h"
  38 #include "subtitle_content.h"
  39 #include "player_video.h"
  40 #include <boost/signals2.hpp>
  41 #include <boost/foreach.hpp>
  42 #include <iostream>
  43
  44 #include "i18n.h"
  45
  46 using std::string;
  47 using std::cout;
  48 using std::list;
  49 using boost::shared_ptr;
  50 using boost::weak_ptr;
  51 using boost::dynamic_pointer_cast;
  52
  53 /** Construct a transcoder.
  54  *  @param f Film that we are transcoding.
  55  *  @param j Job that this transcoder is being used in.
  56  */
  57 Transcoder::Transcoder (shared_ptr<const Film> film, weak_ptr<Job> j)
  58         : _film (film)
  59         , _job (j)
  60         , _player (new Player (film, film->playlist ()))
  61         , _writer (new Writer (film, j))
  62         , _encoder (new Encoder (film, _writer))
  63         , _finishing (false)
  64         , _non_burnt_subtitles (false)
  65 {
  66         _player->Video.connect (bind (&Transcoder::video, this, _1, _2));
  67         _player->Audio.connect (bind (&Transcoder::audio, this, _1, _2));
  68         _player->Subtitle.connect (bind (&Transcoder::subtitle, this, _1, _2));
  69
  70         BOOST_FOREACH (shared_ptr<const Content> c, _film->content ()) {
  71                 if (c->subtitle && c->subtitle->use() && !c->subtitle->burn()) {
  72                         _non_burnt_subtitles = true;
  73                 }
  74         }
  75 }
  76
  77 void
  78 Transcoder::go ()
  79 {
  80         _writer->start ();
  81         _encoder->begin ();
  82
  83         {
  84                 shared_ptr<Job> job = _job.lock ();
  85                 DCPOMATIC_ASSERT (job);
  86                 job->sub (_("Encoding"));
  87         }
  88
  89         if (_non_burnt_subtitles) {
  90                 _writer->write (_player->get_subtitle_fonts ());
  91         }
  92
  93         while (!_player->pass ()) {}
  94
  95         BOOST_FOREACH (ReferencedReelAsset i, _player->get_reel_assets ()) {
  96                 _writer->write (i);
  97         }
  98
  99         _finishing = true;
 100         _encoder->end ();
 101         _writer->finish ();
 102 }
 103
 104 void
 105 Transcoder::video (shared_ptr<PlayerVideo> data, DCPTime time)
 106 {
 107         if (!_film->three_d() && data->eyes() == EYES_LEFT) {
 108                 /* Use left-eye images for both eyes */
 109                 data->set_eyes (EYES_BOTH);
 110         }
 111
 112         _encoder->encode (data, time);
 113 }
 114
 115 void
 116 Transcoder::audio (shared_ptr<AudioBuffers> data, DCPTime time)
 117 {
 118         cout << "tx receives " << data->frames() << " @ " << to_string(time) << "\n";
 119         _writer->write (data);
 120
 121         shared_ptr<Job> job = _job.lock ();
 122         DCPOMATIC_ASSERT (job);
 123         job->set_progress (float(time.get()) / _film->length().get());
 124 }
 125
 126 void
 127 Transcoder::subtitle (PlayerSubtitles data, DCPTimePeriod period)
 128 {
 129         if (_non_burnt_subtitles) {
 130                 _writer->write (data, period);
 131         }
 132 }
 133
 134 float
 135 Transcoder::current_encoding_rate () const
 136 {
 137         return _encoder->current_encoding_rate ();
 138 }
 139
 140 int
 141 Transcoder::video_frames_enqueued () const
 142 {
 143         return _encoder->video_frames_enqueued ();
 144 }