int const Encoder::_history_size = 25;
/** @param f Film that we are encoding */
-Encoder::Encoder (shared_ptr<const Film> f, weak_ptr<Job> j)
+Encoder::Encoder (shared_ptr<const Film> f, weak_ptr<Job> j, shared_ptr<Writer> writer)
: _film (f)
, _job (j)
, _video_frames_out (0)
, _terminate (false)
+ , _writer (writer)
{
}
}
void
-Encoder::process_begin ()
+Encoder::begin ()
{
for (int i = 0; i < Config::instance()->num_local_encoding_threads (); ++i) {
_threads.push_back (new boost::thread (boost::bind (&Encoder::encoder_thread, this, optional<ServerDescription> ())));
}
- _writer.reset (new Writer (_film, _job));
ServerFinder::instance()->connect (boost::bind (&Encoder::server_found, this, _1));
}
void
-Encoder::process_end ()
+Encoder::end ()
{
boost::mutex::scoped_lock lock (_mutex);
LOG_ERROR (N_("Local encode failed (%1)"), e.what ());
}
}
-
- _writer->finish ();
- _writer.reset ();
}
/** @return an estimate of the current number of frames we are encoding per second,
}
void
-Encoder::process_video (shared_ptr<PlayerVideo> pvf)
+Encoder::enqueue (shared_ptr<PlayerVideo> pvf)
{
_waker.nudge ();
}
}
-void
-Encoder::process_audio (shared_ptr<const AudioBuffers> data)
-{
- _writer->write (data);
-}
-
void
Encoder::terminate_threads ()
{
class PlayerVideo;
/** @class Encoder
- * @brief Encoder to J2K and WAV for DCP.
+ * @brief Class to manage encoding to JPEG2000.
*
- * Video is supplied to process_video as RGB frames, and audio
- * is supplied as uncompressed PCM in blocks of various sizes.
+ * This class keeps a queue of frames to be encoded and distributes
+ * the work around threads and encoding servers.
*/
class Encoder : public boost::noncopyable, public ExceptionStore
{
public:
- Encoder (boost::shared_ptr<const Film> f, boost::weak_ptr<Job>);
+ Encoder (boost::shared_ptr<const Film> f, boost::weak_ptr<Job>, boost::shared_ptr<Writer>);
virtual ~Encoder ();
/** Called to indicate that a processing run is about to begin */
- void process_begin ();
+ void begin ();
/** Call with a frame of video.
* @param f Video frame.
*/
- void process_video (boost::shared_ptr<PlayerVideo> f);
-
- /** Call with some audio data */
- void process_audio (boost::shared_ptr<const AudioBuffers>);
+ void enqueue (boost::shared_ptr<PlayerVideo> f);
/** Called when a processing run has finished */
- void process_end ();
+ void end ();
float current_encoding_rate () const;
int video_frames_out () const;
#include "audio_decoder.h"
#include "player.h"
#include "job.h"
+#include "writer.h"
using std::string;
using std::cout;
Transcoder::Transcoder (shared_ptr<const Film> f, shared_ptr<Job> j)
: _film (f)
, _player (f->make_player ())
- , _encoder (new Encoder (f, j))
+ , _writer (new Writer (f, j))
+ , _encoder (new Encoder (f, j, _writer))
, _finishing (false)
{
void
Transcoder::go ()
{
- _encoder->process_begin ();
+ _encoder->begin ();
DCPTime const frame = DCPTime::from_frames (1, _film->video_frame_rate ());
for (DCPTime t; t < _film->length(); t += frame) {
list<shared_ptr<PlayerVideo> > v = _player->get_video (t, true);
for (list<shared_ptr<PlayerVideo> >::const_iterator i = v.begin(); i != v.end(); ++i) {
- _encoder->process_video (*i);
+ _encoder->enqueue (*i);
}
- _encoder->process_audio (_player->get_audio (t, frame, true));
+ _writer->write (_player->get_audio (t, frame, true));
}
_finishing = true;
- _encoder->process_end ();
+ _encoder->end ();
+ _writer->finish ();
_player->statistics().dump (_film->log ());
}
private:
boost::shared_ptr<const Film> _film;
boost::shared_ptr<Player> _player;
+ boost::shared_ptr<Writer> _writer;
boost::shared_ptr<Encoder> _encoder;
bool _finishing;
};