/** @param f Film to compare.
* @param o Options.
*/
-ABTranscodeJob::ABTranscodeJob (shared_ptr<Film> f, shared_ptr<const Options> o, shared_ptr<Job> req)
+ABTranscodeJob::ABTranscodeJob (shared_ptr<Film> f, shared_ptr<const DecodeOptions> od, shared_ptr<const EncodeOptions> oe, shared_ptr<Job> req)
: Job (f, req)
- , _opt (o)
+ , _decode_opt (od)
+ , _encode_opt (oe)
{
_film_b.reset (new Film (*_film));
_film_b->set_scaler (Config::instance()->reference_scaler ());
{
try {
/* _film_b is the one with reference filters */
- ABTranscoder w (_film_b, _film, _opt, this, encoder_factory (_film, _opt));
+ ABTranscoder w (_film_b, _film, _decode_opt, this, encoder_factory (_film, _encode_opt));
w.go ();
set_progress (1);
set_state (FINISHED_OK);
#include "job.h"
class Film;
+class DecodeOptions;
+class EncodeOptions;
/** @class ABTranscodeJob
* @brief Job to run a transcoder which produces output for A/B comparison of various settings.
class ABTranscodeJob : public Job
{
public:
- ABTranscodeJob (boost::shared_ptr<Film> f, boost::shared_ptr<const Options> o, boost::shared_ptr<Job> req);
+ ABTranscodeJob (
+ boost::shared_ptr<Film> f,
+ boost::shared_ptr<const DecodeOptions> od,
+ boost::shared_ptr<const EncodeOptions> oe,
+ boost::shared_ptr<Job> req
+ );
std::string name () const;
void run ();
private:
- boost::shared_ptr<const Options> _opt;
+ boost::shared_ptr<const DecodeOptions> _decode_opt;
+ boost::shared_ptr<const EncodeOptions> _encode_opt;
/** Copy of our Film using the reference filters and scaler */
boost::shared_ptr<Film> _film_b;
/** @param a Film to use for the left half of the screen.
* @param b Film to use for the right half of the screen.
- * @param o Options.
+ * @param o Decoder options.
* @param j Job that we are associated with.
* @param e Encoder to use.
*/
ABTranscoder::ABTranscoder (
- shared_ptr<Film> a, shared_ptr<Film> b, shared_ptr<const Options> o, Job* j, shared_ptr<Encoder> e)
+ shared_ptr<Film> a, shared_ptr<Film> b, shared_ptr<const DecodeOptions> o, Job* j, shared_ptr<Encoder> e)
: _film_a (a)
, _film_b (b)
- , _opt (o)
, _job (j)
, _encoder (e)
{
class Encoder;
class VideoDecoder;
class AudioDecoder;
-class Options;
+class DecodeOptions;
class Image;
class Log;
class Subtitle;
ABTranscoder (
boost::shared_ptr<Film> a,
boost::shared_ptr<Film> b,
- boost::shared_ptr<const Options> o,
+ boost::shared_ptr<const DecodeOptions> o,
Job* j,
boost::shared_ptr<Encoder> e
);
private:
boost::shared_ptr<Film> _film_a;
boost::shared_ptr<Film> _film_b;
- boost::shared_ptr<const Options> _opt;
Job* _job;
boost::shared_ptr<Encoder> _encoder;
Decoders _da;
using boost::optional;
using boost::shared_ptr;
-AudioDecoder::AudioDecoder (shared_ptr<Film> f, shared_ptr<const Options> o, Job* j)
+AudioDecoder::AudioDecoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j)
: Decoder (f, o, j)
{
class AudioDecoder : public AudioSource, public virtual Decoder
{
public:
- AudioDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const Options>, Job *);
+ AudioDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
virtual void set_audio_stream (boost::shared_ptr<AudioStream>);
using std::ifstream;
using boost::shared_ptr;
-CheckHashesJob::CheckHashesJob (shared_ptr<Film> f, shared_ptr<const Options> o, shared_ptr<Job> req)
+CheckHashesJob::CheckHashesJob (shared_ptr<Film> f, shared_ptr<const DecodeOptions> od, shared_ptr<const EncodeOptions> oe, shared_ptr<Job> req)
: Job (f, req)
- , _opt (o)
+ , _decode_opt (od)
+ , _encode_opt (oe)
, _bad (0)
{
DCPFrameRate const dfr = dcp_frame_rate (_film->frames_per_second ());
for (SourceFrame i = _film->dcp_trim_start(); i < N; i += dfr.skip) {
- string const j2k_file = _opt->frame_out_path (i, false);
+ string const j2k_file = _encode_opt->frame_out_path (i, false);
string const hash_file = j2k_file + ".md5";
if (!boost::filesystem::exists (j2k_file)) {
shared_ptr<Job> tc;
if (_film->dcp_ab()) {
- tc.reset (new ABTranscodeJob (_film, _opt, shared_from_this()));
+ tc.reset (new ABTranscodeJob (_film, _decode_opt, _encode_opt, shared_from_this()));
} else {
- tc.reset (new TranscodeJob (_film, _opt, shared_from_this()));
+ tc.reset (new TranscodeJob (_film, _decode_opt, _encode_opt, shared_from_this()));
}
JobManager::instance()->add_after (shared_from_this(), tc);
- JobManager::instance()->add_after (tc, shared_ptr<Job> (new CheckHashesJob (_film, _opt, tc)));
+ JobManager::instance()->add_after (tc, shared_ptr<Job> (new CheckHashesJob (_film, _decode_opt, _encode_opt, tc)));
}
set_progress (1);
#include "job.h"
+class DecodeOptions;
+class EncodeOptions;
+
class CheckHashesJob : public Job
{
public:
- CheckHashesJob (boost::shared_ptr<Film> f, boost::shared_ptr<const Options> o, boost::shared_ptr<Job> req);
+ CheckHashesJob (
+ boost::shared_ptr<Film> f,
+ boost::shared_ptr<const DecodeOptions> od,
+ boost::shared_ptr<const EncodeOptions> oe,
+ boost::shared_ptr<Job> req
+ );
std::string name () const;
void run ();
std::string status () const;
private:
- boost::shared_ptr<const Options> _opt;
+ boost::shared_ptr<const DecodeOptions> _decode_opt;
+ boost::shared_ptr<const EncodeOptions> _encode_opt;
int _bad;
};
* @param frame Frame index.
*/
void
-EncodedData::write (shared_ptr<const Options> opt, SourceFrame frame)
+EncodedData::write (shared_ptr<const EncodeOptions> opt, SourceFrame frame)
{
string const tmp_j2k = opt->frame_out_path (frame, true);
*/
class FilmState;
-class Options;
+class EncodeOptions;
class ServerDescription;
class Scaler;
class Image;
virtual ~EncodedData () {}
void send (boost::shared_ptr<Socket> socket);
- void write (boost::shared_ptr<const Options>, SourceFrame);
+ void write (boost::shared_ptr<const EncodeOptions>, SourceFrame);
/** @return data */
uint8_t* data () const {
private:
void create_openjpeg_container ();
- void write_encoded (boost::shared_ptr<const Options>, uint8_t *, int);
boost::shared_ptr<const Image> _input; ///< the input image
boost::shared_ptr<Subtitle> _subtitle; ///< any subtitle that should be on the image
* @param o Options.
* @param j Job that we are running within, or 0
*/
-Decoder::Decoder (boost::shared_ptr<Film> f, boost::shared_ptr<const Options> o, Job* j)
+Decoder::Decoder (boost::shared_ptr<Film> f, boost::shared_ptr<const DecodeOptions> o, Job* j)
: _film (f)
, _opt (o)
, _job (j)
#include "audio_source.h"
class Job;
-class Options;
+class DecodeOptions;
class Image;
class Log;
class DelayLine;
class Decoder
{
public:
- Decoder (boost::shared_ptr<Film>, boost::shared_ptr<const Options>, Job *);
+ Decoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
virtual ~Decoder () {}
virtual bool pass () = 0;
/** our Film */
boost::shared_ptr<Film> _film;
/** our options */
- boost::shared_ptr<const Options> _opt;
+ boost::shared_ptr<const DecodeOptions> _opt;
/** associated Job, or 0 */
Job* _job;
};
Decoders
decoder_factory (
- shared_ptr<Film> f, shared_ptr<const Options> o, Job* j
+ shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j
)
{
if (boost::filesystem::is_directory (f->content_path()) || f->content_type() == STILL) {
*/
class Film;
-class Options;
+class DecodeOptions;
class Job;
class VideoDecoder;
class AudioDecoder;
};
extern Decoders decoder_factory (
- boost::shared_ptr<Film>, boost::shared_ptr<const Options>, Job *
+ boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *
);
#endif
/** @param f Film that we are encoding.
* @param o Options.
*/
-Encoder::Encoder (shared_ptr<const Film> f, shared_ptr<const Options> o)
+Encoder::Encoder (shared_ptr<const Film> f, shared_ptr<const EncodeOptions> o)
: _film (f)
, _opt (o)
, _just_skipped (false)
void
Encoder::process_video (shared_ptr<Image> i, boost::shared_ptr<Subtitle> s)
{
- if (_opt->decode_video_skip != 0 && (_video_frame % _opt->decode_video_skip) != 0) {
+ if (_opt->video_skip != 0 && (_video_frame % _opt->video_skip) != 0) {
++_video_frame;
return;
}
- if (_opt->video_decode_range) {
- pair<SourceFrame, SourceFrame> const r = _opt->video_decode_range.get();
+ if (_opt->video_range) {
+ pair<SourceFrame, SourceFrame> const r = _opt->video_range.get();
if (_video_frame < r.first || _video_frame >= r.second) {
++_video_frame;
return;
void
Encoder::process_audio (shared_ptr<AudioBuffers> data)
{
- if (_opt->audio_decode_range) {
+ if (_opt->audio_range) {
shared_ptr<AudioBuffers> trimmed (new AudioBuffers (*data.get ()));
/* Range that we are encoding */
- pair<int64_t, int64_t> required_range = _opt->audio_decode_range.get();
+ pair<int64_t, int64_t> required_range = _opt->audio_range.get();
/* Range of this block of data */
pair<int64_t, int64_t> this_range (_audio_frame, _audio_frame + trimmed->frames());
#include "video_sink.h"
#include "audio_sink.h"
-class Options;
+class EncodeOptions;
class Image;
class Subtitle;
class AudioBuffers;
class Encoder : public VideoSink, public AudioSink
{
public:
- Encoder (boost::shared_ptr<const Film> f, boost::shared_ptr<const Options> o);
+ Encoder (boost::shared_ptr<const Film> f, boost::shared_ptr<const EncodeOptions> o);
virtual ~Encoder () {}
/** Called to indicate that a processing run is about to begin */
/** Film that we are encoding */
boost::shared_ptr<const Film> _film;
/** Options */
- boost::shared_ptr<const Options> _opt;
+ boost::shared_ptr<const EncodeOptions> _opt;
/** Mutex for _time_history, _just_skipped and _last_frame */
mutable boost::mutex _history_mutex;
using boost::shared_ptr;
shared_ptr<Encoder>
-encoder_factory (shared_ptr<const Film> f, shared_ptr<const Options> o)
+encoder_factory (shared_ptr<const Film> f, shared_ptr<const EncodeOptions> o)
{
if (!boost::filesystem::is_directory (f->content_path()) && f->content_type() == STILL) {
return shared_ptr<Encoder> (new J2KStillEncoder (f, o));
*/
class Encoder;
-class Options;
+class EncodeOptions;
class Job;
class Log;
class Film;
-extern boost::shared_ptr<Encoder> encoder_factory (boost::shared_ptr<const Film>, boost::shared_ptr<const Options>);
+extern boost::shared_ptr<Encoder> encoder_factory (boost::shared_ptr<const Film>, boost::shared_ptr<const EncodeOptions>);
_film->unset_length ();
_film->set_crop (Crop ());
- shared_ptr<Options> o (new Options ("", "", ""));
- o->out_size = Size (512, 512);
+ shared_ptr<DecodeOptions> o (new DecodeOptions);
o->decode_audio = false;
descend (1);
using boost::shared_ptr;
using boost::optional;
-ExternalAudioDecoder::ExternalAudioDecoder (shared_ptr<Film> f, shared_ptr<const Options> o, Job* j)
+ExternalAudioDecoder::ExternalAudioDecoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j)
: Decoder (f, o, j)
, AudioDecoder (f, o, j)
{
class ExternalAudioDecoder : public AudioDecoder
{
public:
- ExternalAudioDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const Options>, Job *);
+ ExternalAudioDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
bool pass ();
using boost::optional;
using boost::dynamic_pointer_cast;
-FFmpegDecoder::FFmpegDecoder (shared_ptr<Film> f, shared_ptr<const Options> o, Job* j)
+FFmpegDecoder::FFmpegDecoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j)
: Decoder (f, o, j)
, VideoDecoder (f, o, j)
, AudioDecoder (f, o, j)
_film->log()->log (String::compose ("Used only %1 bytes of %2 in packet", r, _packet.size));
}
- if (_opt->decoder_alignment) {
+ if (_opt->video_sync) {
out_careful ();
} else {
filter_and_emit_video (_frame);
class FFmpegDecoder : public VideoDecoder, public AudioDecoder
{
public:
- FFmpegDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const Options>, Job *);
+ FFmpegDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
~FFmpegDecoder ();
float frames_per_second () const;
throw MissingSettingError ("name");
}
- shared_ptr<Options> o (new Options (j2k_dir(), ".j2c", dir ("wavs")));
- o->out_size = format()->dcp_size ();
- o->padding = format()->dcp_padding (shared_from_this ());
- o->ratio = format()->ratio_as_float (shared_from_this ());
+ shared_ptr<EncodeOptions> oe (new EncodeOptions (j2k_dir(), ".j2c", dir ("wavs")));
+ oe->out_size = format()->dcp_size ();
+ oe->padding = format()->dcp_padding (shared_from_this ());
if (dcp_length ()) {
- o->video_decode_range = make_pair (dcp_trim_start(), dcp_trim_start() + dcp_length().get());
+ oe->video_range = make_pair (dcp_trim_start(), dcp_trim_start() + dcp_length().get());
if (audio_stream()) {
- o->audio_decode_range = make_pair (
- video_frames_to_audio_frames (o->video_decode_range.get().first, audio_stream()->sample_rate(), frames_per_second()),
- video_frames_to_audio_frames (o->video_decode_range.get().second, audio_stream()->sample_rate(), frames_per_second())
+ oe->audio_range = make_pair (
+ video_frames_to_audio_frames (oe->video_range.get().first, audio_stream()->sample_rate(), frames_per_second()),
+ video_frames_to_audio_frames (oe->video_range.get().second, audio_stream()->sample_rate(), frames_per_second())
);
}
}
- o->decode_subtitles = with_subtitles ();
- o->decode_video_skip = dcp_frame_rate (frames_per_second()).skip;
+
+ oe->video_skip = dcp_frame_rate (frames_per_second()).skip;
+
+ shared_ptr<DecodeOptions> od (new DecodeOptions);
+ od->decode_subtitles = with_subtitles ();
shared_ptr<Job> r;
if (transcode) {
if (dcp_ab()) {
- r = JobManager::instance()->add (shared_ptr<Job> (new ABTranscodeJob (shared_from_this(), o, shared_ptr<Job> ())));
+ r = JobManager::instance()->add (shared_ptr<Job> (new ABTranscodeJob (shared_from_this(), od, oe, shared_ptr<Job> ())));
} else {
- r = JobManager::instance()->add (shared_ptr<Job> (new TranscodeJob (shared_from_this(), o, shared_ptr<Job> ())));
+ r = JobManager::instance()->add (shared_ptr<Job> (new TranscodeJob (shared_from_this(), od, oe, shared_ptr<Job> ())));
}
}
- r = JobManager::instance()->add (shared_ptr<Job> (new CheckHashesJob (shared_from_this(), o, r)));
- JobManager::instance()->add (shared_ptr<Job> (new MakeDCPJob (shared_from_this(), o, r)));
+ r = JobManager::instance()->add (shared_ptr<Job> (new CheckHashesJob (shared_from_this(), od, oe, r)));
+ JobManager::instance()->add (shared_ptr<Job> (new MakeDCPJob (shared_from_this(), oe, r)));
}
/** Start a job to examine our content file */
*/
try {
- shared_ptr<Options> o (new Options ("", "", ""));
- o->out_size = Size (1024, 1024);
-
+ shared_ptr<DecodeOptions> o (new DecodeOptions);
Decoders d = decoder_factory (shared_from_this(), o, 0);
set_size (d.video->native_size ());
_external_audio = a;
}
- shared_ptr<Options> o (new Options ("", "", ""));
- o->decode_audio = true;
+ shared_ptr<DecodeOptions> o (new DecodeOptions);
shared_ptr<ExternalAudioDecoder> decoder (new ExternalAudioDecoder (shared_from_this(), o, 0));
if (decoder->audio_stream()) {
_external_audio_stream = decoder->audio_stream ();
using boost::shared_ptr;
ImageMagickDecoder::ImageMagickDecoder (
- boost::shared_ptr<Film> f, boost::shared_ptr<const Options> o, Job* j)
+ boost::shared_ptr<Film> f, boost::shared_ptr<const DecodeOptions> o, Job* j)
: Decoder (f, o, j)
, VideoDecoder (f, o, j)
{
class ImageMagickDecoder : public VideoDecoder
{
public:
- ImageMagickDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const Options>, Job *);
+ ImageMagickDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
float frames_per_second () const {
/* We don't know */
using std::pair;
using boost::shared_ptr;
-J2KStillEncoder::J2KStillEncoder (shared_ptr<const Film> f, shared_ptr<const Options> o)
+J2KStillEncoder::J2KStillEncoder (shared_ptr<const Film> f, shared_ptr<const EncodeOptions> o)
: Encoder (f, o)
{
class Image;
class Log;
+class EncodeOptions;
/** @class J2KStillEncoder
* @brief An encoder which writes repeated JPEG2000 files from a single decoded input.
class J2KStillEncoder : public Encoder
{
public:
- J2KStillEncoder (boost::shared_ptr<const Film>, boost::shared_ptr<const Options>);
+ J2KStillEncoder (boost::shared_ptr<const Film>, boost::shared_ptr<const EncodeOptions>);
private:
void do_process_video (boost::shared_ptr<Image>, boost::shared_ptr<Subtitle>);
using boost::thread;
using boost::lexical_cast;
-J2KWAVEncoder::J2KWAVEncoder (shared_ptr<const Film> f, shared_ptr<const Options> o)
+J2KWAVEncoder::J2KWAVEncoder (shared_ptr<const Film> f, shared_ptr<const EncodeOptions> o)
: Encoder (f, o)
#ifdef HAVE_SWRESAMPLE
, _swr_context (0)
class J2KWAVEncoder : public Encoder
{
public:
- J2KWAVEncoder (boost::shared_ptr<const Film>, boost::shared_ptr<const Options>);
+ J2KWAVEncoder (boost::shared_ptr<const Film>, boost::shared_ptr<const EncodeOptions>);
~J2KWAVEncoder ();
void process_begin ();
#include <boost/signals2.hpp>
class Film;
-class Options;
/** @class Job
* @brief A parent class to represent long-running tasks which are run in their own thread.
/** @param f Film we are making the DCP for.
* @param o Options.
*/
-MakeDCPJob::MakeDCPJob (shared_ptr<Film> f, shared_ptr<const Options> o, shared_ptr<Job> req)
+MakeDCPJob::MakeDCPJob (shared_ptr<Film> f, shared_ptr<const EncodeOptions> o, shared_ptr<Job> req)
: Job (f, req)
, _opt (o)
{
#include "job.h"
+class EncodeOptions;
+
/** @class MakeDCPJob
* @brief A job to create DCPs
*/
class MakeDCPJob : public Job
{
public:
- MakeDCPJob (boost::shared_ptr<Film>, boost::shared_ptr<const Options>, boost::shared_ptr<Job> req);
+ MakeDCPJob (boost::shared_ptr<Film>, boost::shared_ptr<const EncodeOptions>, boost::shared_ptr<Job> req);
std::string name () const;
void run ();
std::string j2c_path (int) const;
std::string wav_path (libdcp::Channel) const;
- boost::shared_ptr<const Options> _opt;
+ boost::shared_ptr<const EncodeOptions> _opt;
};
#include <boost/optional.hpp>
#include "util.h"
-/** @class Options
- * @brief Options for a transcoding operation.
+/** @class EncodeOptions
+ * @brief EncodeOptions for an encoding operation.
*
* These are settings which may be different, in different circumstances, for
- * the same film; ie they are options for a particular transcode operation.
+ * the same film; ie they are options for a particular operation.
*/
-class Options
+class EncodeOptions
{
public:
- Options (std::string f, std::string e, std::string m)
+ EncodeOptions (std::string f, std::string e, std::string m)
: padding (0)
- , decode_video_skip (0)
- , decode_audio (true)
- , decode_subtitles (false)
- , decoder_alignment (true)
+ , video_skip (0)
, _frame_out_path (f)
, _frame_out_extension (e)
, _multichannel_audio_out_path (m)
}
Size out_size; ///< size of output images
- float ratio; ///< ratio of the wanted output image (not considering padding)
int padding; ///< number of pixels of padding (in terms of the output size) each side of the image
/** Range of video frames to decode */
- boost::optional<std::pair<SourceFrame, SourceFrame> > video_decode_range;
+ boost::optional<std::pair<SourceFrame, SourceFrame> > video_range;
/** Range of audio frames to decode */
- boost::optional<std::pair<int64_t, int64_t> > audio_decode_range;
+ boost::optional<std::pair<int64_t, int64_t> > audio_range;
/** Skip frames such that we don't decode any frame where (index % decode_video_skip) != 0; e.g.
* 1 for every frame, 2 for every other frame, etc.
*/
- SourceFrame decode_video_skip;
- bool decode_audio; ///< true to decode audio, otherwise false
- bool decode_subtitles;
-
- bool decoder_alignment;
+ SourceFrame video_skip;
private:
/** Path of the directory to write video frames to */
/** Path of the directory to write audio files to */
std::string _multichannel_audio_out_path;
};
+
+
+class DecodeOptions
+{
+public:
+ DecodeOptions ()
+ : decode_audio (true)
+ , decode_subtitles (false)
+ , video_sync (true)
+ {}
+
+ bool decode_audio;
+ bool decode_subtitles;
+ bool video_sync;
+};
* @param o Options.
* @param req Job that must be completed before this job is run.
*/
-TranscodeJob::TranscodeJob (shared_ptr<Film> f, shared_ptr<const Options> o, shared_ptr<Job> req)
+TranscodeJob::TranscodeJob (shared_ptr<Film> f, shared_ptr<const DecodeOptions> od, shared_ptr<const EncodeOptions> oe, shared_ptr<Job> req)
: Job (f, req)
- , _opt (o)
+ , _decode_opt (od)
+ , _encode_opt (oe)
{
}
_film->log()->log ("Transcode job starting");
_film->log()->log (String::compose ("Audio delay is %1ms", _film->audio_delay()));
- _encoder = encoder_factory (_film, _opt);
- Transcoder w (_film, _opt, this, _encoder);
+ _encoder = encoder_factory (_film, _encode_opt);
+ Transcoder w (_film, _decode_opt, this, _encoder);
w.go ();
set_progress (1);
set_state (FINISHED_OK);
#include "job.h"
class Encoder;
+class DecodeOptions;
+class EncodeOptions;
/** @class TranscodeJob
* @brief A job which transcodes from one format to another.
class TranscodeJob : public Job
{
public:
- TranscodeJob (boost::shared_ptr<Film> f, boost::shared_ptr<const Options> o, boost::shared_ptr<Job> req);
+ TranscodeJob (boost::shared_ptr<Film> f, boost::shared_ptr<const DecodeOptions> od, boost::shared_ptr<const EncodeOptions> oe, boost::shared_ptr<Job> req);
std::string name () const;
void run ();
int remaining_time () const;
private:
- boost::shared_ptr<const Options> _opt;
+ boost::shared_ptr<const DecodeOptions> _decode_opt;
+ boost::shared_ptr<const EncodeOptions> _encode_opt;
boost::shared_ptr<Encoder> _encoder;
};
/** Construct a transcoder using a Decoder that we create and a supplied Encoder.
* @param f Film that we are transcoding.
- * @param o Options.
+ * @param o Decode options.
* @param j Job that we are running under, or 0.
* @param e Encoder to use.
*/
-Transcoder::Transcoder (shared_ptr<Film> f, shared_ptr<const Options> o, Job* j, shared_ptr<Encoder> e)
+Transcoder::Transcoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j, shared_ptr<Encoder> e)
: _job (j)
, _encoder (e)
, _decoders (decoder_factory (f, o, j))
class VideoDecoder;
class AudioDecoder;
class DelayLine;
-class Options;
+class EncodeOptions;
+class DecodeOptions;
/** @class Transcoder
* @brief A class which takes a FilmState and some Options, then uses those to transcode a Film.
class Transcoder
{
public:
- Transcoder (boost::shared_ptr<Film> f, boost::shared_ptr<const Options> o, Job* j, boost::shared_ptr<Encoder> e);
+ Transcoder (
+ boost::shared_ptr<Film> f,
+ boost::shared_ptr<const DecodeOptions> o,
+ Job* j,
+ boost::shared_ptr<Encoder> e
+ );
void go ();
using boost::shared_ptr;
using boost::optional;
-VideoDecoder::VideoDecoder (shared_ptr<Film> f, shared_ptr<const Options> o, Job* j)
+VideoDecoder::VideoDecoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j)
: Decoder (f, o, j)
, _video_frame (0)
{
class VideoDecoder : public VideoSource, public virtual Decoder
{
public:
- VideoDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const Options>, Job *);
+ VideoDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
/** @return video frames per second, or 0 if unknown */
virtual float frames_per_second () const = 0;
return;
}
- /* XXX: Options is not decoder-specific at all */
- shared_ptr<Options> o (new Options ("", "", ""));
+ shared_ptr<DecodeOptions> o (new DecodeOptions);
o->decode_audio = false;
- o->decoder_alignment = false;
+ o->video_sync = false;
_decoders = decoder_factory (_film, o, 0);
_decoders.video->Video.connect (bind (&FilmViewer::process_video, this, _1, _2));