using boost::shared_ptr;
/** @param f Film to compare.
- * @param o Options.
+ * @param o Decode options.
*/
-ABTranscodeJob::ABTranscodeJob (shared_ptr<Film> f, shared_ptr<const DecodeOptions> od, shared_ptr<Job> req)
+ABTranscodeJob::ABTranscodeJob (shared_ptr<Film> f, DecodeOptions o, shared_ptr<Job> req)
: Job (f, req)
- , _decode_opt (od)
+ , _decode_opt (o)
{
_film_b.reset (new Film (*_film));
_film_b->set_scaler (Config::instance()->reference_scaler ());
#include <boost/shared_ptr.hpp>
#include "job.h"
+#include "options.h"
class Film;
-class DecodeOptions;
/** @class ABTranscodeJob
* @brief Job to run a transcoder which produces output for A/B comparison of various settings.
public:
ABTranscodeJob (
boost::shared_ptr<Film> f,
- boost::shared_ptr<const DecodeOptions> od,
+ DecodeOptions o,
boost::shared_ptr<Job> req
);
void run ();
private:
- boost::shared_ptr<const DecodeOptions> _decode_opt;
+ DecodeOptions _decode_opt;
/** Copy of our Film using the reference filters and scaler */
boost::shared_ptr<Film> _film_b;
*/
ABTranscoder::ABTranscoder (
- shared_ptr<Film> a, shared_ptr<Film> b, shared_ptr<const DecodeOptions> o, Job* j, shared_ptr<Encoder> e)
+ shared_ptr<Film> a, shared_ptr<Film> b, DecodeOptions o, Job* j, shared_ptr<Encoder> e)
: _film_a (a)
, _film_b (b)
, _job (j)
class Encoder;
class VideoDecoder;
class AudioDecoder;
-class DecodeOptions;
class Image;
class Log;
class Subtitle;
ABTranscoder (
boost::shared_ptr<Film> a,
boost::shared_ptr<Film> b,
- boost::shared_ptr<const DecodeOptions> o,
+ DecodeOptions o,
Job* j,
boost::shared_ptr<Encoder> e
);
using boost::optional;
using boost::shared_ptr;
-AudioDecoder::AudioDecoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j)
+AudioDecoder::AudioDecoder (shared_ptr<Film> f, 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 DecodeOptions>, Job *);
+ AudioDecoder (boost::shared_ptr<Film>, 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 DecodeOptions> od, shared_ptr<Job> req)
+CheckHashesJob::CheckHashesJob (shared_ptr<Film> f, DecodeOptions o, shared_ptr<Job> req)
: Job (f, req)
- , _decode_opt (od)
+ , _decode_opt (o)
, _bad (0)
{
*/
#include "job.h"
-
-class DecodeOptions;
+#include "options.h"
class CheckHashesJob : public Job
{
public:
CheckHashesJob (
boost::shared_ptr<Film> f,
- boost::shared_ptr<const DecodeOptions> od,
+ DecodeOptions od,
boost::shared_ptr<Job> req
);
std::string status () const;
private:
- boost::shared_ptr<const DecodeOptions> _decode_opt;
+ DecodeOptions _decode_opt;
int _bad;
};
using boost::optional;
/** @param f Film.
- * @param o Options.
+ * @param o Decode options.
* @param j Job that we are running within, or 0
*/
-Decoder::Decoder (boost::shared_ptr<Film> f, boost::shared_ptr<const DecodeOptions> o, Job* j)
+Decoder::Decoder (boost::shared_ptr<Film> f, DecodeOptions o, Job* j)
: _film (f)
, _opt (o)
, _job (j)
#include "video_source.h"
#include "audio_source.h"
#include "film.h"
+#include "options.h"
class Job;
-class DecodeOptions;
class Image;
class Log;
class DelayLine;
class Decoder
{
public:
- Decoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
+ Decoder (boost::shared_ptr<Film>, DecodeOptions, Job *);
virtual ~Decoder () {}
virtual bool pass () = 0;
protected:
/** our Film */
boost::shared_ptr<Film> _film;
- /** our options */
- boost::shared_ptr<const DecodeOptions> _opt;
+ /** our decode options */
+ DecodeOptions _opt;
/** associated Job, or 0 */
Job* _job;
Decoders
decoder_factory (
- shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j
+ shared_ptr<Film> f, DecodeOptions o, Job* j
)
{
if (boost::filesystem::is_directory (f->content_path()) || f->content_type() == STILL) {
* @brief A method to create appropriate decoders for some content.
*/
+#include "options.h"
+
class Film;
-class DecodeOptions;
class Job;
class VideoDecoder;
class AudioDecoder;
};
extern Decoders decoder_factory (
- boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *
+ boost::shared_ptr<Film>, DecodeOptions, Job *
);
#endif
_film->unset_length ();
_film->set_crop (Crop ());
- shared_ptr<DecodeOptions> o (new DecodeOptions);
- o->decode_audio = false;
+ DecodeOptions o;
+ o.decode_audio = false;
Decoders decoders = decoder_factory (_film, o, this);
/* Get a quick decoder to get the content's length from its header */
- shared_ptr<DecodeOptions> o (new DecodeOptions);
- Decoders d = decoder_factory (_film, o, 0);
+ Decoders d = decoder_factory (_film, DecodeOptions(), 0);
_film->set_length (d.video->length());
_film->log()->log (String::compose ("Video length obtained from header as %1 frames", _film->length().get()));
using boost::shared_ptr;
using boost::optional;
-ExternalAudioDecoder::ExternalAudioDecoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j)
+ExternalAudioDecoder::ExternalAudioDecoder (shared_ptr<Film> f, 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 DecodeOptions>, Job *);
+ ExternalAudioDecoder (boost::shared_ptr<Film>, DecodeOptions, Job *);
bool pass ();
using boost::optional;
using boost::dynamic_pointer_cast;
-FFmpegDecoder::FFmpegDecoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j)
+FFmpegDecoder::FFmpegDecoder (shared_ptr<Film> f, DecodeOptions o, Job* j)
: Decoder (f, o, j)
, VideoDecoder (f, o, j)
, AudioDecoder (f, o, j)
setup_audio ();
setup_subtitle ();
- if (!o->video_sync) {
+ if (!o.video_sync) {
_first_video = 0;
}
}
filter_and_emit_video (_frame);
}
- if (_audio_stream && _opt->decode_audio) {
+ if (_audio_stream && _opt.decode_audio) {
while (avcodec_decode_audio4 (_audio_codec_context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) {
int const data_size = av_samples_get_buffer_size (
0, _audio_codec_context->channels, _frame->nb_samples, audio_sample_format (), 1
_film->log()->log (String::compose ("Used only %1 bytes of %2 in packet", r, _packet.size));
}
- if (_opt->video_sync) {
+ if (_opt.video_sync) {
out_with_sync ();
} else {
filter_and_emit_video (_frame);
}
}
- } else if (ffa && _packet.stream_index == ffa->id() && _opt->decode_audio) {
+ } else if (ffa && _packet.stream_index == ffa->id() && _opt.decode_audio) {
int frame_finished;
if (avcodec_decode_audio4 (_audio_codec_context, _frame, &frame_finished, &_packet) >= 0 && frame_finished) {
}
}
- } else if (_subtitle_stream && _packet.stream_index == _subtitle_stream->id() && _opt->decode_subtitles && _first_video) {
+ } else if (_subtitle_stream && _packet.stream_index == _subtitle_stream->id() && _opt.decode_subtitles && _first_video) {
int got_subtitle;
AVSubtitle sub;
class FFmpegDecoder : public VideoDecoder, public AudioDecoder
{
public:
- FFmpegDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
+ FFmpegDecoder (boost::shared_ptr<Film>, DecodeOptions, Job *);
~FFmpegDecoder ();
float frames_per_second () const;
throw MissingSettingError ("name");
}
- shared_ptr<DecodeOptions> od (new DecodeOptions);
- od->decode_subtitles = with_subtitles ();
+ DecodeOptions od;
+ od.decode_subtitles = with_subtitles ();
shared_ptr<Job> r;
*/
try {
- shared_ptr<DecodeOptions> o (new DecodeOptions);
- Decoders d = decoder_factory (shared_from_this(), o, 0);
+ Decoders d = decoder_factory (shared_from_this(), DecodeOptions(), 0);
set_size (d.video->native_size ());
set_frames_per_second (d.video->frames_per_second ());
_external_audio = a;
}
- shared_ptr<DecodeOptions> o (new DecodeOptions);
- shared_ptr<ExternalAudioDecoder> decoder (new ExternalAudioDecoder (shared_from_this(), o, 0));
+ shared_ptr<ExternalAudioDecoder> decoder (new ExternalAudioDecoder (shared_from_this(), DecodeOptions(), 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 DecodeOptions> o, Job* j)
+ boost::shared_ptr<Film> f, 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 DecodeOptions>, Job *);
+ ImageMagickDecoder (boost::shared_ptr<Film>, DecodeOptions, Job *);
float frames_per_second () const {
/* We don't know */
*/
+#ifndef DVDOMATIC_OPTIONS_H
+#define DVDOMATIC_OPTIONS_H
+
/** @file src/options.h
- * @brief Options for a transcoding operation.
+ * @brief Options for a decoding operation.
*/
-#include <string>
-#include <iomanip>
-#include <sstream>
-#include <boost/optional.hpp>
-#include "util.h"
-
class DecodeOptions
{
public:
bool decode_subtitles;
bool video_sync;
};
+
+#endif
using boost::shared_ptr;
/** @param s Film to use.
- * @param o Options.
+ * @param o Decode options.
* @param req Job that must be completed before this job is run.
*/
-TranscodeJob::TranscodeJob (shared_ptr<Film> f, shared_ptr<const DecodeOptions> od, shared_ptr<Job> req)
+TranscodeJob::TranscodeJob (shared_ptr<Film> f, DecodeOptions o, shared_ptr<Job> req)
: Job (f, req)
- , _decode_opt (od)
+ , _decode_opt (o)
{
}
#include <boost/shared_ptr.hpp>
#include "job.h"
+#include "options.h"
class Encoder;
-class DecodeOptions;
/** @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 DecodeOptions> od, boost::shared_ptr<Job> req);
+ TranscodeJob (boost::shared_ptr<Film> f, DecodeOptions od, boost::shared_ptr<Job> req);
std::string name () const;
void run ();
int remaining_time () const;
private:
- boost::shared_ptr<const DecodeOptions> _decode_opt;
+ DecodeOptions _decode_opt;
boost::shared_ptr<Encoder> _encoder;
};
* @param j Job that we are running under, or 0.
* @param e Encoder to use.
*/
-Transcoder::Transcoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j, shared_ptr<Encoder> e)
+Transcoder::Transcoder (shared_ptr<Film> f, 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 DecodeOptions;
/** @class Transcoder
* @brief A class which takes a FilmState and some Options, then uses those to transcode a Film.
public:
Transcoder (
boost::shared_ptr<Film> f,
- boost::shared_ptr<const DecodeOptions> o,
+ DecodeOptions o,
Job* j,
boost::shared_ptr<Encoder> e
);
using boost::shared_ptr;
using boost::optional;
-VideoDecoder::VideoDecoder (shared_ptr<Film> f, shared_ptr<const DecodeOptions> o, Job* j)
+VideoDecoder::VideoDecoder (shared_ptr<Film> f, DecodeOptions o, Job* j)
: Decoder (f, o, j)
, _video_frame (0)
, _last_source_time (0)
class VideoDecoder : public VideoSource, public virtual Decoder
{
public:
- VideoDecoder (boost::shared_ptr<Film>, boost::shared_ptr<const DecodeOptions>, Job *);
+ VideoDecoder (boost::shared_ptr<Film>, DecodeOptions, Job *);
/** @return video frames per second, or 0 if unknown */
virtual float frames_per_second () const = 0;
break;
case Film::CONTENT:
{
- shared_ptr<DecodeOptions> o (new DecodeOptions);
- o->decode_audio = false;
- o->decode_subtitles = true;
- o->video_sync = false;
+ DecodeOptions o;
+ o.decode_audio = false;
+ o.decode_subtitles = true;
+ o.video_sync = false;
_decoders = decoder_factory (_film, o, 0);
_decoders.video->Video.connect (bind (&FilmViewer::process_video, this, _1, _2, _3));
_decoders.video->OutputChanged.connect (boost::bind (&FilmViewer::decoder_changed, this));