*/
+
#include "active_text.h"
#include "text_content.h"
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
+
using std::list;
using std::pair;
using std::make_pair;
-using boost::weak_ptr;
-using boost::shared_ptr;
+using std::weak_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
std::list<PlayerText> get_burnt (dcpomatic::DCPTimePeriod period, bool always_burn_captions) const;
void clear_before (dcpomatic::DCPTime time);
void clear ();
- void add_from (boost::weak_ptr<const TextContent> content, PlayerText ps, dcpomatic::DCPTime from);
- std::pair<PlayerText, dcpomatic::DCPTime> add_to (boost::weak_ptr<const TextContent> content, dcpomatic::DCPTime to);
- bool have (boost::weak_ptr<const TextContent> content) const;
+ void add_from (std::weak_ptr<const TextContent> content, PlayerText ps, dcpomatic::DCPTime from);
+ std::pair<PlayerText, dcpomatic::DCPTime> add_to (std::weak_ptr<const TextContent> content, dcpomatic::DCPTime to);
+ bool have (std::weak_ptr<const TextContent> content) const;
private:
class Period
boost::optional<dcpomatic::DCPTime> to;
};
- typedef std::map<boost::weak_ptr<const TextContent>, std::list<Period> > Map;
+ typedef std::map<std::weak_ptr<const TextContent>, std::list<Period>, std::owner_less<std::weak_ptr<const TextContent>>> Map;
mutable boost::mutex _mutex;
Map _data;
using std::max;
using std::min;
using std::cout;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using namespace dcpomatic;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
class AnalyseAudioJob : public Job
{
public:
- AnalyseAudioJob (boost::shared_ptr<const Film>, boost::shared_ptr<const Playlist>, bool from_zero);
+ AnalyseAudioJob (std::shared_ptr<const Film>, std::shared_ptr<const Playlist>, bool from_zero);
~AnalyseAudioJob ();
std::string name () const;
}
private:
- void analyse (boost::shared_ptr<const AudioBuffers>, dcpomatic::DCPTime time);
+ void analyse (std::shared_ptr<const AudioBuffers>, dcpomatic::DCPTime time);
- boost::shared_ptr<const Playlist> _playlist;
+ std::shared_ptr<const Playlist> _playlist;
/** playlist's audio analysis path when the job was created */
boost::filesystem::path _path;
dcpomatic::DCPTime _start;
float* _sample_peak;
Frame* _sample_peak_frame;
-
boost::shared_ptr<AudioAnalysis> _analysis;
+
std::shared_ptr<AudioAnalysis> _analysis;
-
boost::shared_ptr<AudioFilterGraph> _ebur128;
+
std::shared_ptr<AudioFilterGraph> _ebur128;
std::vector<Filter const *> _filters;
boost::scoped_ptr<leqm_nrt::Calculator> _leqm;
#include "i18n.h"
using std::string;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
class AnalyseSubtitlesJob : public Job
{
public:
- AnalyseSubtitlesJob (boost::shared_ptr<const Film> film, boost::shared_ptr<Content> content);
+ AnalyseSubtitlesJob (std::shared_ptr<const Film> film, std::shared_ptr<Content> content);
std::string name () const;
std::string json_name () const;
private:
void analyse (PlayerText text, TextType type);
- boost::weak_ptr<Content> _content;
+ std::weak_ptr<Content> _content;
boost::filesystem::path _path;
boost::optional<dcpomatic::Rect<double> > _bounding_box;
};
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
int const AtmosContentProperty::EDIT_RATE = 700;
public:
AtmosContent (Content* parent);
- static
boost::shared_ptr<AtmosContent> from_xml (Content* parent, cxml::ConstNodePtr node);
+ static
std::shared_ptr<AtmosContent> from_xml (Content* parent, cxml::ConstNodePtr node);
void as_xml (xmlpp::Node* node) const;
#include "film.h"
-using boost::shared_ptr;
+using std::shared_ptr;
AtmosDecoder::AtmosDecoder (Decoder* parent, shared_ptr<const Content> content)
class AtmosDecoder : public DecoderPart
{
public:
- AtmosDecoder (Decoder* parent, boost::shared_ptr<const Content> content);
+ AtmosDecoder (Decoder* parent, std::shared_ptr<const Content> content);
- boost::optional<dcpomatic::ContentTime> position (boost::shared_ptr<const Film>) const {
+ boost::optional<dcpomatic::ContentTime> position (std::shared_ptr<const Film>) const {
return _position;
}
void seek ();
- void emit (boost::shared_ptr<const Film> film, boost::shared_ptr<const dcp::AtmosFrame> data, Frame frame, AtmosMetadata metadata);
+ void emit (std::shared_ptr<const Film> film, std::shared_ptr<const dcp::AtmosFrame> data, Frame frame, AtmosMetadata metadata);
boost::signals2::signal<void (ContentAtmos)> Data;
private:
- boost::shared_ptr<const Content> _content;
+ std::shared_ptr<const Content> _content;
boost::optional<dcpomatic::ContentTime> _position;
};
#include <dcp/atmos_asset.h>
-using boost::shared_ptr;
+using std::shared_ptr;
AtmosMetadata::AtmosMetadata (shared_ptr<const dcp::AtmosAsset> asset)
#define DCPOMATIC_ATMOS_METADATA_H
#include <dcp/atmos_asset.h>
-#include <boost/shared_ptr.hpp>
class AtmosMetadata
{
public:
- AtmosMetadata (boost::shared_ptr<const dcp::AtmosAsset> asset);
- boost::shared_ptr<dcp::AtmosAsset> create (dcp::Fraction edit_rate) const;
+ AtmosMetadata (std::shared_ptr<const dcp::AtmosAsset> asset);
+ std::shared_ptr<dcp::AtmosAsset> create (dcp::Fraction edit_rate) const;
private:
int _first_frame;
using std::list;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
AtmosMXFContent::AtmosMXFContent (boost::filesystem::path path)
*/
+
#include "content.h"
+#include <memory>
+
class AtmosMXFContent : public Content
{
AtmosMXFContent (boost::filesystem::path path);
AtmosMXFContent (cxml::ConstNodePtr node, int version);
-
boost::shared_ptr<AtmosMXFContent> shared_from_this () {
- return boost::dynamic_pointer_cast<AtmosMXFContent> (Content::shared_from_this ());
+
std::shared_ptr<AtmosMXFContent> shared_from_this () {
+ return std::dynamic_pointer_cast<AtmosMXFContent> (Content::shared_from_this());
}
- boost::shared_ptr<const AtmosMXFContent> shared_from_this () const {
- return boost::dynamic_pointer_cast<const AtmosMXFContent> (Content::shared_from_this ());
+ std::shared_ptr<const AtmosMXFContent> shared_from_this () const {
+ return std::dynamic_pointer_cast<const AtmosMXFContent> (Content::shared_from_this());
}
- void examine (boost::shared_ptr<const Film> film, boost::shared_ptr<Job> job);
+ void examine (std::shared_ptr<const Film> film, std::shared_ptr<Job> job);
std::string summary () const;
void as_xml (xmlpp::Node* node, bool with_path) const;
- dcpomatic::DCPTime full_length (boost::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime full_length (std::shared_ptr<const Film> film) const;
dcpomatic::DCPTime approximate_length () const;
static bool valid_mxf (boost::filesystem::path path);
#include <dcp/atmos_asset.h>
#include <dcp/atmos_asset_reader.h>
-using boost::shared_ptr;
+using std::shared_ptr;
-AtmosMXFDecoder::AtmosMXFDecoder (boost::shared_ptr<const Film> film, boost::shared_ptr<const AtmosMXFContent> content)
+AtmosMXFDecoder::AtmosMXFDecoder (std::shared_ptr<const Film> film, std::shared_ptr<const AtmosMXFContent> content)
: Decoder (film)
, _content (content)
{
class AtmosMXFDecoder : public Decoder
{
public:
- AtmosMXFDecoder (boost::shared_ptr<const Film> film, boost::shared_ptr<const AtmosMXFContent>);
+ AtmosMXFDecoder (std::shared_ptr<const Film> film, std::shared_ptr<const AtmosMXFContent>);
bool pass ();
void seek (dcpomatic::ContentTime t, bool accurate);
private:
- boost::shared_ptr<const AtmosMXFContent> _content;
+ std::shared_ptr<const AtmosMXFContent> _content;
dcpomatic::ContentTime _next;
- boost::shared_ptr<dcp::AtmosAssetReader> _reader;
+ std::shared_ptr<dcp::AtmosAssetReader> _reader;
boost::optional<AtmosMetadata> _metadata;
};
using std::pair;
using std::make_pair;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using dcp::raw_convert;
using namespace dcpomatic;
void write (boost::filesystem::path);
- float gain_correction (boost::shared_ptr<const Playlist> playlist);
+ float gain_correction (std::shared_ptr<const Playlist> playlist);
private:
std::vector<std::vector<AudioPoint> > _data;
#include <stdexcept>
using std::bad_alloc;
-using boost::shared_ptr;
+using std::shared_ptr;
/** Construct an AudioBuffers. Audio data is undefined after this constructor.
* @param channels Number of channels.
copy_from (&other, other._frames, 0, 0);
}
-AudioBuffers::AudioBuffers (boost::shared_ptr<const AudioBuffers> other)
+AudioBuffers::AudioBuffers (std::shared_ptr<const AudioBuffers> other)
{
allocate (other->_channels, other->_frames);
copy_from (other.get(), other->_frames, 0, 0);
}
-AudioBuffers::AudioBuffers (boost::shared_ptr<const AudioBuffers> other, int32_t frames_to_copy, int32_t read_offset)
+AudioBuffers::AudioBuffers (std::shared_ptr<const AudioBuffers> other, int32_t frames_to_copy, int32_t read_offset)
{
allocate (other->_channels, frames_to_copy);
copy_from (other.get(), frames_to_copy, read_offset, 0);
* @brief AudioBuffers class.
*/
+
#ifndef DCPOMATIC_AUDIO_BUFFERS_H
#define DCPOMATIC_AUDIO_BUFFERS_H
-#include <boost/shared_ptr.hpp>
+
#include <stdint.h>
+#include <memory>
+
/** @class AudioBuffers
* @brief A class to hold multi-channel audio data in float format.
public:
AudioBuffers (int channels, int32_t frames);
AudioBuffers (AudioBuffers const &);
- explicit AudioBuffers (boost::shared_ptr<const AudioBuffers>);
- AudioBuffers (boost::shared_ptr<const AudioBuffers> other, int32_t frames_to_copy, int32_t read_offset);
+ explicit AudioBuffers (std::shared_ptr<const AudioBuffers>);
+ AudioBuffers (std::shared_ptr<const AudioBuffers> other, int32_t frames_to_copy, int32_t read_offset);
~AudioBuffers ();
AudioBuffers & operator= (AudioBuffers const &);
-
boost::shared_ptr<AudioBuffers> clone () const;
-
boost::shared_ptr<AudioBuffers> channel (int) const;
+
std::shared_ptr<AudioBuffers> clone () const;
+
std::shared_ptr<AudioBuffers> channel (int) const;
void ensure_size (int32_t);
void move (int32_t frames, int32_t from, int32_t to);
void accumulate_channel (AudioBuffers const * from, int from_channel, int to_channel, float gain = 1);
void accumulate_frames (AudioBuffers const * from, int32_t frames, int32_t read_offset, int32_t write_offset);
- void append (boost::shared_ptr<const AudioBuffers> other);
+ void append (std::shared_ptr<const AudioBuffers> other);
void trim_start (int32_t frames);
private:
using std::list;
using std::pair;
using std::setprecision;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
using dcp::raw_convert;
using namespace dcpomatic;
{
public:
explicit AudioContent (Content* parent);
- AudioContent (Content* parent, std::vector<boost::shared_ptr<Content> >);
+ AudioContent (Content* parent, std::vector<std::shared_ptr<Content> >);
void as_xml (xmlpp::Node *) const;
std::string technical_summary () const;
- void take_settings_from (boost::shared_ptr<const AudioContent> c);
+ void take_settings_from (std::shared_ptr<const AudioContent> c);
AudioMapping mapping () const;
void set_mapping (AudioMapping);
- int resampled_frame_rate (boost::shared_ptr<const Film> film) const;
+ int resampled_frame_rate (std::shared_ptr<const Film> film) const;
std::vector<NamedChannel> channel_names () const;
void set_gain (double);
return _delay;
}
- std::string processing_description (boost::shared_ptr<const Film> film) const;
+ std::string processing_description (std::shared_ptr<const Film> film) const;
std::vector<AudioStreamPtr> streams () const {
boost::mutex::scoped_lock lm (_mutex);
void set_streams (std::vector<AudioStreamPtr> streams);
AudioStreamPtr stream () const;
- void add_properties (boost::shared_ptr<const Film> film, std::list<UserProperty> &) const;
+ void add_properties (std::shared_ptr<const Film> film, std::list<UserProperty> &) const;
- void modify_position (boost::shared_ptr<const Film> film, dcpomatic::DCPTime& pos) const;
+ void modify_position (std::shared_ptr<const Film> film, dcpomatic::DCPTime& pos) const;
void modify_trim_start (dcpomatic::ContentTime& pos) const;
- static
boost::shared_ptr<AudioContent> from_xml (Content* parent, cxml::ConstNodePtr, int version);
+ static
std::shared_ptr<AudioContent> from_xml (Content* parent, cxml::ConstNodePtr, int version);
private:
using std::cout;
using std::map;
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
#include "content_audio.h"
#include "audio_stream.h"
#include "decoder_part.h"
-#include <boost/enable_shared_from_this.hpp>
#include <boost/signals2.hpp>
class AudioBuffers;
/** @class AudioDecoder.
* @brief Parent class for audio decoders.
*/
-class AudioDecoder : public
boost::enable_shared_from_this<AudioDecoder>, public DecoderPart
+class AudioDecoder : public
std::enable_shared_from_this<AudioDecoder>, public DecoderPart
{
public:
- AudioDecoder (Decoder* parent, boost::shared_ptr<const AudioContent> content, bool fast);
+ AudioDecoder (Decoder* parent, std::shared_ptr<const AudioContent> content, bool fast);
- boost::optional<dcpomatic::ContentTime> position (boost::shared_ptr<const Film> film) const;
- void emit (boost::shared_ptr<const Film> film, AudioStreamPtr stream, boost::shared_ptr<const AudioBuffers>, dcpomatic::ContentTime, bool time_already_delayed = false);
+ boost::optional<dcpomatic::ContentTime> position (std::shared_ptr<const Film> film) const;
+ void emit (std::shared_ptr<const Film> film, AudioStreamPtr stream, std::shared_ptr<const AudioBuffers>, dcpomatic::ContentTime, bool time_already_delayed = false);
void seek ();
void flush ();
- dcpomatic::ContentTime stream_position (boost::shared_ptr<const Film> film, AudioStreamPtr stream) const;
+ dcpomatic::ContentTime stream_position (std::shared_ptr<const Film> film, AudioStreamPtr stream) const;
boost::signals2::signal<void (AudioStreamPtr, ContentAudio)> Data;
private:
void silence (int milliseconds);
- boost::shared_ptr<const AudioContent> _content;
+ std::shared_ptr<const AudioContent> _content;
/** Frame after the last one that was emitted from Data (i.e. at the resampled rate, if applicable)
* for each AudioStream.
*/
typedef std::map<AudioStreamPtr, Frame> PositionMap;
PositionMap _positions;
- typedef std::map<AudioStreamPtr, boost::shared_ptr<Resampler> > ResamplerMap;
+ typedef std::map<AudioStreamPtr, std::shared_ptr<Resampler> > ResamplerMap;
ResamplerMap _resamplers;
bool _fast;
#include <iostream>
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
AudioDelay::AudioDelay (int samples)
: _samples (samples)
*/
-#include <boost/shared_ptr.hpp>
+
+#include <memory>
+
class AudioBuffers;
{
public:
explicit AudioDelay (int samples);
- boost::shared_ptr<AudioBuffers> run (boost::shared_ptr<const AudioBuffers> in);
+ std::shared_ptr<AudioBuffers> run (std::shared_ptr<const AudioBuffers> in);
void flush ();
private:
-
boost::shared_ptr<AudioBuffers> _tail;
+
std::shared_ptr<AudioBuffers> _tail;
int _samples;
};
#include <cmath>
using std::min;
-using boost::shared_ptr;
+using std::shared_ptr;
/** @return array of floats which the caller must destroy with delete[] */
float *
#ifndef DCPOMATIC_AUDIO_FILTER_H
#define DCPOMATIC_AUDIO_FILTER_H
-#include <boost/shared_ptr.hpp>
+
+#include <memory>
+
class AudioBuffers;
struct audio_filter_impulse_input_test;
virtual ~AudioFilter ();
- boost::shared_ptr<AudioBuffers> run (boost::shared_ptr<const AudioBuffers> in);
+ std::shared_ptr<AudioBuffers> run (std::shared_ptr<const AudioBuffers> in);
void flush ();
float* _ir;
int _M;
-
boost::shared_ptr<AudioBuffers> _tail;
+
std::shared_ptr<AudioBuffers> _tail;
};
class LowPassAudioFilter : public AudioFilter
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
AudioFilterGraph::AudioFilterGraph (int sample_rate, int channels)
: _sample_rate (sample_rate)
AudioFilterGraph (int sample_rate, int channels);
~AudioFilterGraph ();
- void process (boost::shared_ptr<const AudioBuffers> audio);
+ void process (std::shared_ptr<const AudioBuffers> audio);
protected:
std::string src_parameters () const;
using std::min;
using std::vector;
using std::abs;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
using dcp::raw_convert;
using std::list;
using std::cout;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
/** Push some data into the merger at a given time */
void
-AudioMerger::push (boost::shared_ptr<const AudioBuffers> audio, DCPTime time)
+AudioMerger::push (std::shared_ptr<const AudioBuffers> audio, DCPTime time)
{
DCPOMATIC_ASSERT (audio->frames() > 0);
public:
explicit AudioMerger (int frame_rate);
- std::list<std::pair<
boost::shared_ptr<AudioBuffers>, dcpomatic::DCPTime> > pull (dcpomatic::DCPTime time);
- void push (boost::shared_ptr<const AudioBuffers> audio, dcpomatic::DCPTime time);
+ std::list<std::pair<
std::shared_ptr<AudioBuffers>, dcpomatic::DCPTime> > pull (dcpomatic::DCPTime time);
+ void push (std::shared_ptr<const AudioBuffers> audio, dcpomatic::DCPTime time);
void clear ();
private:
, frame_rate (r)
{}
- Buffer (
boost::shared_ptr<AudioBuffers> a, dcpomatic::DCPTime t, int r)
+ Buffer (
std::shared_ptr<AudioBuffers> a, dcpomatic::DCPTime t, int r)
: audio (a)
, time (t)
, frame_rate (r)
{}
-
boost::shared_ptr<AudioBuffers> audio;
+
std::shared_ptr<AudioBuffers> audio;
dcpomatic::DCPTime time;
int frame_rate;
#define DCPOMATIC_AUDIO_PROCESSOR_H
#include "types.h"
-#include <boost/shared_ptr.hpp>
#include <list>
#include <string>
#include <vector>
/** @return Number of output channels */
virtual int out_channels () const = 0;
/** @return A clone of this AudioProcessor for operation at the specified sampling rate */
- virtual
boost::shared_ptr<AudioProcessor> clone (int sampling_rate) const = 0;
+ virtual
std::shared_ptr<AudioProcessor> clone (int sampling_rate) const = 0;
/** Process some data, returning the processed result truncated or padded to `channels' */
- virtual boost::shared_ptr<AudioBuffers> run (boost::shared_ptr<const AudioBuffers>, int channels) = 0;
+ virtual std::shared_ptr<AudioBuffers> run (std::shared_ptr<const AudioBuffers>, int channels) = 0;
virtual void flush () {}
/** Make the supplied audio mapping into a sensible default for this processor */
virtual void make_audio_mapping_default (AudioMapping& mapping) const = 0;
using std::make_pair;
using std::pair;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
#include "audio_buffers.h"
#include "types.h"
#include "dcpomatic_time.h"
-#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <list>
public:
AudioRingBuffers ();
- void put (boost::shared_ptr<const AudioBuffers> data, dcpomatic::DCPTime time, int frame_rate);
+ void put (std::shared_ptr<const AudioBuffers> data, dcpomatic::DCPTime time, int frame_rate);
boost::optional<dcpomatic::DCPTime> get (float* out, int channels, int frames);
boost::optional<dcpomatic::DCPTime> peek () const;
private:
mutable boost::mutex _mutex;
- std::list<std::pair<boost::shared_ptr<const AudioBuffers>, dcpomatic::DCPTime> > _buffers;
+ std::list<std::pair<std::shared_ptr<const AudioBuffers>, dcpomatic::DCPTime> > _buffers;
int _used_in_head;
};
AudioMapping _mapping;
};
-typedef
boost::shared_ptr<AudioStream> AudioStreamPtr;
+typedef
std::shared_ptr<AudioStream> AudioStreamPtr;
#endif
#ifndef DCPOMATIC_BITMAP_CAPTION_H
#define DCPOMATIC_BITMAP_CAPTION_H
+
#include "rect.h"
-#include <boost/shared_ptr.hpp>
+#include <memory>
+
class Image;
class BitmapText
{
public:
- BitmapText (boost::shared_ptr<Image> i, dcpomatic::Rect<double> r)
+ BitmapText (std::shared_ptr<Image> i, dcpomatic::Rect<double> r)
: image (i)
, rectangle (r)
{}
- boost::shared_ptr<Image> image;
+ std::shared_ptr<Image> image;
/** Area that the subtitle covers on its corresponding video, expressed in
* proportions of the image size; e.g. rectangle.x = 0.5 would mean that
* the rectangle starts half-way across the video.
#include "compose.hpp"
#include "exceptions.h"
#include "video_content.h"
-#include <boost/weak_ptr.hpp>
-#include <boost/shared_ptr.hpp>
+
using std::cout;
using std::pair;
using std::make_pair;
using std::string;
-using boost::weak_ptr;
-using boost::shared_ptr;
+using std::weak_ptr;
+using std::shared_ptr;
using boost::bind;
using boost::optional;
using boost::function;
#include "text_ring_buffers.h"
#include "audio_mapping.h"
#include "exception_store.h"
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/signals2.hpp>
{
public:
Butler (
- boost::weak_ptr<const Film> film,
-
boost::shared_ptr<Player> player,
+ std::weak_ptr<const Film> film,
+
std::shared_ptr<Player> player,
AudioMapping map,
int audio_channels,
boost::function<AVPixelFormat (AVPixelFormat)> pixel_format,
std::string summary () const;
};
- std::pair<
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> get_video (bool blocking, Error* e = 0);
+ std::pair<
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> get_video (bool blocking, Error* e = 0);
boost::optional<dcpomatic::DCPTime> get_audio (float* out, Frame frames);
boost::optional<TextRingBuffers::Data> get_closed_caption ();
private:
void thread ();
- void video (
boost::shared_ptr<PlayerVideo> video, dcpomatic::DCPTime time);
- void audio (
boost::shared_ptr<AudioBuffers> audio, dcpomatic::DCPTime time, int frame_rate);
+ void video (
std::shared_ptr<PlayerVideo> video, dcpomatic::DCPTime time);
+ void audio (
std::shared_ptr<AudioBuffers> audio, dcpomatic::DCPTime time, int frame_rate);
void text (PlayerText pt, TextType type, boost::optional<DCPTextTrack> track, dcpomatic::DCPTimePeriod period);
bool should_run () const;
- void prepare (
boost::weak_ptr<PlayerVideo> video);
+ void prepare (
std::weak_ptr<PlayerVideo> video);
void player_change (ChangeType type, int property);
void seek_unlocked (dcpomatic::DCPTime position, bool accurate);
- boost::weak_ptr<const Film> _film;
-
boost::shared_ptr<Player> _player;
+ std::weak_ptr<const Film> _film;
+
std::shared_ptr<Player> _player;
boost::thread _thread;
VideoRingBuffers _video;
boost::thread_group _prepare_pool;
boost::asio::io_service _prepare_service;
- boost::shared_ptr<boost::asio::io_service::work> _prepare_work;
+ std::shared_ptr<boost::asio::io_service::work> _prepare_work;
/** mutex to protect _pending_seek_position, _pending_seek_accurate, _finished, _died, _stop_thread */
boost::mutex _mutex;
using std::string;
using std::list;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
/** @param gui true if we are running this job from the GUI, false if it's the CLI */
CheckContentChangeJob::CheckContentChangeJob (shared_ptr<const Film> film, shared_ptr<Job> following, bool gui)
class CheckContentChangeJob : public Job
{
public:
- CheckContentChangeJob (boost::shared_ptr<const Film>, boost::shared_ptr<Job> following = boost::shared_ptr<Job>(), bool gui = true);
+ CheckContentChangeJob (std::shared_ptr<const Film>, std::shared_ptr<Job> following = std::shared_ptr<Job>(), bool gui = true);
~CheckContentChangeJob ();
std::string name () const;
void run ();
private:
- boost::shared_ptr<Job> _following;
+ std::shared_ptr<Job> _following;
bool _gui;
};
using std::list;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::raw_convert;
using dcpomatic::Screen;
* @brief Cinema class.
*/
+
#include <libcxml/cxml.h>
-#include <boost/enable_shared_from_this.hpp>
+#include <memory>
+
namespace xmlpp {
class Element;
* This is a cinema name, some metadata and a list of
* Screen objects.
*/
-class Cinema : public boost::enable_shared_from_this<Cinema>
+class Cinema : public std::enable_shared_from_this<Cinema>
{
public:
Cinema (std::string const & name_, std::list<std::string> const & e, std::string notes_, int utc_offset_hour, int utc_offset_minute)
void as_xml (xmlpp::Element *) const;
- void add_screen (boost::shared_ptr<dcpomatic::Screen>);
- void remove_screen (boost::shared_ptr<dcpomatic::Screen>);
+ void add_screen (std::shared_ptr<dcpomatic::Screen>);
+ void remove_screen (std::shared_ptr<dcpomatic::Screen>);
void set_utc_offset_hour (int h);
void set_utc_offset_minute (int m);
return _utc_offset_minute;
}
- std::list<boost::shared_ptr<dcpomatic::Screen> > screens () const {
+ std::list<std::shared_ptr<dcpomatic::Screen> > screens () const {
return _screens;
}
private:
- std::list<boost::shared_ptr<dcpomatic::Screen> > _screens;
+ std::list<std::shared_ptr<dcpomatic::Screen> > _screens;
/** Offset such that the equivalent time in UTC can be determined
by subtracting the offset from the local time.
*/
using std::string;
using std::cout;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using dcp::raw_convert;
vector<PresetColourConversion> PresetColourConversion::_presets;
using std::string;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
CombineDCPJob::CombineDCPJob (vector<boost::filesystem::path> inputs, boost::filesystem::path output)
using std::remove;
using std::exception;
using std::cerr;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using boost::algorithm::trim;
using dcp::raw_convert;
#include <dcp/name_format.h>
#include <dcp/certificate_chain.h>
#include <dcp/encrypted_kdm.h>
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
#include <boost/filesystem.hpp>
#include <vector>
return _tms_password;
}
- std::list<boost::shared_ptr<Cinema> > cinemas () const {
+ std::list<std::shared_ptr<Cinema> > cinemas () const {
return _cinemas;
}
- std::list<boost::shared_ptr<DKDMRecipient> > dkdm_recipients () const {
+ std::list<std::shared_ptr<DKDMRecipient> > dkdm_recipients () const {
return _dkdm_recipients;
}
return _notification_email;
}
- boost::shared_ptr<const dcp::CertificateChain> signer_chain () const {
+ std::shared_ptr<const dcp::CertificateChain> signer_chain () const {
return _signer_chain;
}
- boost::shared_ptr<const dcp::CertificateChain> decryption_chain () const {
+ std::shared_ptr<const dcp::CertificateChain> decryption_chain () const {
return _decryption_chain;
}
return _player_history;
}
- boost::shared_ptr<DKDMGroup> dkdms () const {
+ std::shared_ptr<DKDMGroup> dkdms () const {
return _dkdms;
}
maybe_set (_tms_password, p);
}
- void add_cinema (boost::shared_ptr<Cinema> c) {
+ void add_cinema (std::shared_ptr<Cinema> c) {
_cinemas.push_back (c);
changed (CINEMAS);
}
- void remove_cinema (boost::shared_ptr<Cinema> c) {
+ void remove_cinema (std::shared_ptr<Cinema> c) {
_cinemas.remove (c);
changed (CINEMAS);
}
- void add_dkdm_recipient (boost::shared_ptr<DKDMRecipient> c) {
+ void add_dkdm_recipient (std::shared_ptr<DKDMRecipient> c) {
_dkdm_recipients.push_back (c);
changed (DKDM_RECIPIENTS);
}
- void remove_dkdm_recipient (boost::shared_ptr<DKDMRecipient> c) {
+ void remove_dkdm_recipient (std::shared_ptr<DKDMRecipient> c) {
_dkdm_recipients.remove (c);
changed (DKDM_RECIPIENTS);
}
void reset_notification_email ();
- void set_signer_chain (boost::shared_ptr<const dcp::CertificateChain> s) {
+ void set_signer_chain (std::shared_ptr<const dcp::CertificateChain> s) {
maybe_set (_signer_chain, s);
}
- void set_decryption_chain (boost::shared_ptr<const dcp::CertificateChain> c) {
+ void set_decryption_chain (std::shared_ptr<const dcp::CertificateChain> c) {
maybe_set (_decryption_chain, c);
}
}
#endif
- void set_dkdms (boost::shared_ptr<DKDMGroup> dkdms) {
+ void set_dkdms (std::shared_ptr<DKDMGroup> dkdms) {
_dkdms = dkdms;
changed ();
}
void copy_and_link (boost::filesystem::path new_file) const;
bool have_write_permission () const;
- void save_template (boost::shared_ptr<const Film> film, std::string name) const;
+ void save_template (std::shared_ptr<const Film> film, std::string name) const;
bool existing_template (std::string name) const;
std::list<std::string> templates () const;
boost::filesystem::path template_path (std::string name) const;
void set_cover_sheet_to_default ();
void read_cinemas (cxml::Document const & f);
void read_dkdm_recipients (cxml::Document const & f);
- boost::shared_ptr<dcp::CertificateChain> create_certificate_chain ();
+ std::shared_ptr<dcp::CertificateChain> create_certificate_chain ();
boost::filesystem::path directory_or (boost::optional<boost::filesystem::path> dir, boost::filesystem::path a) const;
void add_to_history_internal (std::vector<boost::filesystem::path>& h, boost::filesystem::path p);
void clean_history_internal (std::vector<boost::filesystem::path>& h);
*/
boost::optional<boost::filesystem::path> _default_kdm_directory;
bool _upload_after_make_dcp;
- std::list<boost::shared_ptr<Cinema> > _cinemas;
- std::list<boost::shared_ptr<DKDMRecipient> > _dkdm_recipients;
+ std::list<std::shared_ptr<Cinema> > _cinemas;
+ std::list<std::shared_ptr<DKDMRecipient> > _dkdm_recipients;
std::string _mail_server;
int _mail_port;
EmailProtocol _mail_protocol;
std::vector<std::string> _notification_cc;
std::string _notification_bcc;
std::string _notification_email;
- boost::shared_ptr<const dcp::CertificateChain> _signer_chain;
+ std::shared_ptr<const dcp::CertificateChain> _signer_chain;
/** Chain used to decrypt KDMs; the leaf of this chain is the target
* certificate for making KDMs given to DCP-o-matic.
*/
- boost::shared_ptr<const dcp::CertificateChain> _decryption_chain;
+ std::shared_ptr<const dcp::CertificateChain> _decryption_chain;
/** true to check for updates on startup */
bool _check_for_updates;
bool _check_for_test_updates;
#endif
std::vector<boost::filesystem::path> _history;
std::vector<boost::filesystem::path> _player_history;
- boost::shared_ptr<DKDMGroup> _dkdms;
+ std::shared_ptr<DKDMGroup> _dkdms;
boost::filesystem::path _cinemas_file;
boost::filesystem::path _dkdm_recipients_file;
bool _show_hints_before_make_dcp;
using std::vector;
using std::max;
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using dcp::raw_convert;
using dcp::locale_convert;
} else {
emit (boost::bind (boost::ref(Change), c, shared_from_this(), p, _change_signals_frequent));
}
- } catch (boost::bad_weak_ptr &) {
+ } catch (std::bad_weak_ptr &) {
/* This must be during construction; never mind */
}
}
#include <boost/filesystem.hpp>
#include <boost/signals2.hpp>
#include <boost/thread/mutex.hpp>
-#include <boost/enable_shared_from_this.hpp>
+
namespace xmlpp {
class Node;
/** @class Content
* @brief A piece of content represented by one or more files on disk.
*/
-class Content : public boost::enable_shared_from_this<Content>, public Signaller, public boost::noncopyable
+class Content : public std::enable_shared_from_this<Content>, public Signaller, public boost::noncopyable
{
public:
explicit Content ();
Content (dcpomatic::DCPTime);
Content (boost::filesystem::path);
Content (cxml::ConstNodePtr);
- Content (std::vector<boost::shared_ptr<Content> >);
+ Content (std::vector<std::shared_ptr<Content> >);
virtual ~Content () {}
/** Examine the content to establish digest, frame rates and any other
* useful metadata.
* @param job Job to use to report progress, or 0.
*/
- virtual void examine (boost::shared_ptr<const Film> film, boost::shared_ptr<Job> job);
+ virtual void examine (std::shared_ptr<const Film> film, std::shared_ptr<Job> job);
- virtual void take_settings_from (boost::shared_ptr<const Content> c);
+ virtual void take_settings_from (std::shared_ptr<const Content> c);
/** @return Quick one-line summary of the content, as will be presented in the
* film editor.
virtual std::string technical_summary () const;
virtual void as_xml (xmlpp::Node *, bool with_paths) const;
- virtual dcpomatic::DCPTime full_length (boost::shared_ptr<const Film>) const = 0;
+ virtual dcpomatic::DCPTime full_length (std::shared_ptr<const Film>) const = 0;
virtual dcpomatic::DCPTime approximate_length () const = 0;
virtual std::string identifier () const;
/** @return points at which to split this content when
* REELTYPE_BY_VIDEO_CONTENT is in use.
*/
- virtual std::list<dcpomatic::DCPTime> reel_split_points (boost::shared_ptr<const Film>) const;
+ virtual std::list<dcpomatic::DCPTime> reel_split_points (std::shared_ptr<const Film>) const;
- boost::shared_ptr<Content> clone () const;
+ std::shared_ptr<Content> clone () const;
void set_paths (std::vector<boost::filesystem::path> paths);
return _digest;
}
- void set_position (boost::shared_ptr<const Film> film, dcpomatic::DCPTime, bool force_emit = false);
+ void set_position (std::shared_ptr<const Film> film, dcpomatic::DCPTime, bool force_emit = false);
/** dcpomatic::DCPTime that this content starts; i.e. the time that the first
* bit of the content (trimmed or not) will happen.
}
/** @return Time immediately after the last thing in this content */
- dcpomatic::DCPTime end (boost::shared_ptr<const Film> film) const {
+ dcpomatic::DCPTime end (std::shared_ptr<const Film> film) const {
return position() + length_after_trim(film);
}
- dcpomatic::DCPTime length_after_trim (boost::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime length_after_trim (std::shared_ptr<const Film> film) const;
boost::optional<double> video_frame_rate () const {
boost::mutex::scoped_lock lm (_mutex);
void set_video_frame_rate (double r);
void unset_video_frame_rate ();
- double active_video_frame_rate (boost::shared_ptr<const Film> film) const;
+ double active_video_frame_rate (std::shared_ptr<const Film> film) const;
void set_change_signals_frequent (bool f) {
_change_signals_frequent = f;
}
- std::list<UserProperty> user_properties (boost::shared_ptr<const Film> film) const;
+ std::list<UserProperty> user_properties (std::shared_ptr<const Film> film) const;
std::string calculate_digest () const;
/* CHANGE_TYPE_PENDING and CHANGE_TYPE_CANCELLED may be emitted from any thread; CHANGE_TYPE_DONE always from GUI thread */
- boost::signals2::signal<void (ChangeType, boost::weak_ptr<Content>, int, bool)> Change;
+ boost::signals2::signal<void (ChangeType, std::weak_ptr<Content>, int, bool)> Change;
- boost::shared_ptr<VideoContent> video;
-
boost::shared_ptr<AudioContent> audio;
- std::list<boost::shared_ptr<TextContent> > text;
-
boost::shared_ptr<AtmosContent> atmos;
+ std::shared_ptr<VideoContent> video;
+
std::shared_ptr<AudioContent> audio;
+ std::list<std::shared_ptr<TextContent> > text;
+
std::shared_ptr<AtmosContent> atmos;
- boost::shared_ptr<TextContent> only_text () const;
- boost::shared_ptr<TextContent> text_of_original_type (TextType type) const;
+ std::shared_ptr<TextContent> only_text () const;
+ std::shared_ptr<TextContent> text_of_original_type (TextType type) const;
protected:
- virtual void add_properties (boost::shared_ptr<const Film> film, std::list<UserProperty> &) const;
+ virtual void add_properties (std::shared_ptr<const Film> film, std::list<UserProperty> &) const;
/** _mutex which should be used to protect accesses, as examine
* jobs can update content state in threads other than the main one.
#include "atmos_metadata.h"
#include "types.h"
#include <dcp/atmos_asset_reader.h>
-#include <boost/shared_ptr.hpp>
/** @class ContentAtmos
* @brief Some Atmos data that has come out of a decoder.
class ContentAtmos
{
public:
- ContentAtmos (boost::shared_ptr<const dcp::AtmosFrame> data_, Frame frame_, AtmosMetadata metadata_)
+ ContentAtmos (std::shared_ptr<const dcp::AtmosFrame> data_, Frame frame_, AtmosMetadata metadata_)
: data (data_)
, frame (frame_)
, metadata (metadata_)
{}
- boost::shared_ptr<const dcp::AtmosFrame> data;
+ std::shared_ptr<const dcp::AtmosFrame> data;
Frame frame;
AtmosMetadata metadata;
};
, frame (0)
{}
- ContentAudio (boost::shared_ptr<const AudioBuffers> a, Frame f)
+ ContentAudio (std::shared_ptr<const AudioBuffers> a, Frame f)
: audio (a)
, frame (f)
{}
- boost::shared_ptr<const AudioBuffers> audio;
+ std::shared_ptr<const AudioBuffers> audio;
Frame frame;
};
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
/** Create a Content object from an XML node.
{
string const type = node->string_child ("Type");
- boost::shared_ptr<Content> content;
+ std::shared_ptr<Content> content;
if (type == "FFmpeg") {
/* SndfileContent is now handled by the FFmpeg code rather than by
*/
#include <libcxml/cxml.h>
-#include <boost/shared_ptr.hpp>
class Film;
class Content;
-extern boost::shared_ptr<Content> content_factory (cxml::ConstNodePtr, int, std::list<std::string> &);
-extern std::list<boost::shared_ptr<Content> > content_factory (boost::filesystem::path);
+extern std::shared_ptr<Content> content_factory (cxml::ConstNodePtr, int, std::list<std::string> &);
+extern std::list<std::shared_ptr<Content> > content_factory (boost::filesystem::path);
#include "content.h"
#include "change_signaller.h"
-#include <boost/weak_ptr.hpp>
#include <boost/thread/mutex.hpp>
class Content;
*/
-#include <boost/shared_ptr.hpp>
+
+#include <memory>
+
class Content;
class ContentStore
{
public:
- virtual boost::shared_ptr<Content> get (std::string digest) const = 0;
+ virtual std::shared_ptr<Content> get (std::string digest) const = 0;
};
class ContentBitmapText : public ContentText
{
public:
- ContentBitmapText (dcpomatic::ContentTime f, boost::shared_ptr<Image> im, dcpomatic::Rect<double> r)
+ ContentBitmapText (dcpomatic::ContentTime f, std::shared_ptr<Image> im, dcpomatic::Rect<double> r)
: ContentText (f)
, sub (im, r)
{}
, part (PART_WHOLE)
{}
- ContentVideo (boost::shared_ptr<const ImageProxy> i, Frame f, Eyes e, Part p)
+ ContentVideo (std::shared_ptr<const ImageProxy> i, Frame f, Eyes e, Part p)
: image (i)
, frame (f)
, eyes (e)
, part (p)
{}
- boost::shared_ptr<const ImageProxy> image;
+ std::shared_ptr<const ImageProxy> image;
Frame frame;
Eyes eyes;
Part part;
#include "audio_content.h"
#include "ratio.h"
#include "dcp_content_type.h"
-#include <boost/shared_ptr.hpp>
#include <map>
using std::map;
using std::string;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
void
*/
-#include <boost/shared_ptr.hpp>
+
+#include <memory>
+
class DCPContent;
class Film;
-extern void copy_dcp_details_to_film (boost::shared_ptr<const DCPContent> dcp, boost::shared_ptr<Film> film);
+extern void copy_dcp_details_to_film (std::shared_ptr<const DCPContent> dcp, std::shared_ptr<Film> film);
using std::string;
using std::cout;
using std::min;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using dcp::raw_convert;
using std::cerr;
using std::cout;
using std::runtime_error;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::function;
using std::cout;
using std::runtime_error;
using std::map;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::function;
using std::cout;
using std::runtime_error;
using std::map;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
static std::vector<pair<HANDLE, string> > locked_volumes;
using std::list;
using std::string;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
/** Find all the CPLs in our directories, cross-add assets and return the CPLs */
#define DCPOMATIC_DCP_H
#include <dcp/cpl.h>
-#include <boost/shared_ptr.hpp>
#include <list>
#include <iostream>
class DCP
{
public:
- std::list<boost::shared_ptr<dcp::CPL> > cpls () const;
+ std::list<std::shared_ptr<dcp::CPL> > cpls () const;
protected:
- explicit DCP (boost::shared_ptr<const DCPContent> content, bool tolerant)
+ explicit DCP (std::shared_ptr<const DCPContent> content, bool tolerant)
: _dcp_content (content)
, _tolerant (tolerant)
{}
- boost::shared_ptr<const DCPContent> _dcp_content;
+ std::shared_ptr<const DCPContent> _dcp_content;
private:
bool _tolerant;
using std::vector;
using std::list;
using std::map;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::scoped_ptr;
using boost::optional;
using boost::function;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
DCPContent (boost::filesystem::path p);
DCPContent (cxml::ConstNodePtr, int version);
- boost::shared_ptr<DCPContent> shared_from_this () {
- return boost::dynamic_pointer_cast<DCPContent> (Content::shared_from_this ());
+ std::shared_ptr<DCPContent> shared_from_this () {
+ return std::dynamic_pointer_cast<DCPContent> (Content::shared_from_this ());
}
- boost::shared_ptr<const DCPContent> shared_from_this () const {
- return boost::dynamic_pointer_cast<const DCPContent> (Content::shared_from_this ());
+ std::shared_ptr<const DCPContent> shared_from_this () const {
+ return std::dynamic_pointer_cast<const DCPContent> (Content::shared_from_this ());
}
- dcpomatic::DCPTime full_length (boost::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime full_length (std::shared_ptr<const Film> film) const;
dcpomatic::DCPTime approximate_length () const;
- void examine (boost::shared_ptr<const Film> film, boost::shared_ptr<Job>);
+ void examine (std::shared_ptr<const Film> film, std::shared_ptr<Job>);
std::string summary () const;
std::string technical_summary () const;
void as_xml (xmlpp::Node *, bool with_paths) const;
std::string identifier () const;
- void take_settings_from (boost::shared_ptr<const Content> c);
+ void take_settings_from (std::shared_ptr<const Content> c);
void set_default_colour_conversion ();
- std::list<dcpomatic::DCPTime> reel_split_points (boost::shared_ptr<const Film> film) const;
+ std::list<dcpomatic::DCPTime> reel_split_points (std::shared_ptr<const Film> film) const;
std::vector<boost::filesystem::path> directories () const;
return _reference_video;
}
- bool can_reference_video (boost::shared_ptr<const Film> film, std::string &) const;
+ bool can_reference_video (std::shared_ptr<const Film> film, std::string &) const;
void set_reference_audio (bool r);
return _reference_audio;
}
- bool can_reference_audio (boost::shared_ptr<const Film> film, std::string &) const;
+ bool can_reference_audio (std::shared_ptr<const Film> film, std::string &) const;
void set_reference_text (TextType type, bool r);
return _reference_text[type];
}
- bool can_reference_text (boost::shared_ptr<const Film> film, TextType type, std::string &) const;
+ bool can_reference_text (std::shared_ptr<const Film> film, TextType type, std::string &) const;
void set_cpl (std::string id);
private:
friend struct reels_test5;
- void add_properties (boost::shared_ptr<const Film> film, std::list<UserProperty>& p) const;
+ void add_properties (std::shared_ptr<const Film> film, std::list<UserProperty>& p) const;
void read_directory (boost::filesystem::path);
void read_sub_directory (boost::filesystem::path);
- std::list<dcpomatic::DCPTimePeriod> reels (boost::shared_ptr<const Film> film) const;
+ std::list<dcpomatic::DCPTimePeriod> reels (std::shared_ptr<const Film> film) const;
bool can_reference (
- boost::shared_ptr<const Film> film,
- boost::function <bool (boost::shared_ptr<const Content>)>,
+ std::shared_ptr<const Film> film,
+ boost::function <bool (std::shared_ptr<const Content>)>,
std::string overlapping,
std::string& why_not
) const;
using std::map;
using std::string;
using std::vector;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
using namespace dcpomatic;
{
public:
DCPDecoder (
- boost::shared_ptr<const Film> film,
- boost::shared_ptr<const DCPContent>,
+ std::shared_ptr<const Film> film,
+ std::shared_ptr<const DCPContent>,
bool fast,
bool tolerant,
- boost::shared_ptr<DCPDecoder> old
+ std::shared_ptr<DCPDecoder> old
);
- std::list<boost::shared_ptr<dcp::Reel> > reels () const {
+ std::list<std::shared_ptr<dcp::Reel> > reels () const {
return _reels;
}
void pass_texts (dcpomatic::ContentTime next, dcp::Size size);
void pass_texts (
dcpomatic::ContentTime next,
- boost::shared_ptr<dcp::SubtitleAsset> asset,
+ std::shared_ptr<dcp::SubtitleAsset> asset,
bool reference,
int64_t entry_point,
- boost::shared_ptr<TextDecoder> decoder,
+ std::shared_ptr<TextDecoder> decoder,
dcp::Size size
);
- std::string calculate_lazy_digest (boost::shared_ptr<const DCPContent>) const;
+ std::string calculate_lazy_digest (std::shared_ptr<const DCPContent>) const;
/** Time of next thing to return from pass relative to the start of _reel */
dcpomatic::ContentTime _next;
- std::list<boost::shared_ptr<dcp::Reel> > _reels;
+ std::list<std::shared_ptr<dcp::Reel> > _reels;
- std::list<boost::shared_ptr<dcp::Reel> >::iterator _reel;
+ std::list<std::shared_ptr<dcp::Reel> >::iterator _reel;
/** Offset of _reel from the start of the content in frames */
int64_t _offset;
/** Reader for current mono picture asset, if applicable */
- boost::shared_ptr<dcp::MonoPictureAssetReader> _mono_reader;
+ std::shared_ptr<dcp::MonoPictureAssetReader> _mono_reader;
/** Reader for current stereo picture asset, if applicable */
- boost::shared_ptr<dcp::StereoPictureAssetReader> _stereo_reader;
+ std::shared_ptr<dcp::StereoPictureAssetReader> _stereo_reader;
/** Reader for current sound asset, if applicable */
- boost::shared_ptr<dcp::SoundAssetReader> _sound_reader;
- boost::shared_ptr<dcp::AtmosAssetReader> _atmos_reader;
+ std::shared_ptr<dcp::SoundAssetReader> _sound_reader;
+ std::shared_ptr<dcp::AtmosAssetReader> _atmos_reader;
boost::optional<AtmosMetadata> _atmos_metadata;
bool _decode_referenced;
using std::cout;
using std::list;
using std::vector;
-using boost::shared_ptr;
-using boost::weak_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::weak_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#include "dcp_text_track.h"
#include "encoder.h"
#include <dcp/atmos_frame.h>
-#include <boost/weak_ptr.hpp>
class Film;
class J2KEncoder;
class DCPEncoder : public Encoder
{
public:
- DCPEncoder (boost::shared_ptr<const Film> film, boost::weak_ptr<Job> job);
+ DCPEncoder (std::shared_ptr<const Film> film, std::weak_ptr<Job> job);
~DCPEncoder ();
void go ();
private:
- void video (
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime);
- void audio (
boost::shared_ptr<AudioBuffers>, dcpomatic::DCPTime);
+ void video (
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime);
+ void audio (
std::shared_ptr<AudioBuffers>, dcpomatic::DCPTime);
void text (PlayerText, TextType, boost::optional<DCPTextTrack>, dcpomatic::DCPTimePeriod);
- void atmos (boost::shared_ptr<const dcp::AtmosFrame>, dcpomatic::DCPTime, AtmosMetadata metadata);
+ void atmos (std::shared_ptr<const dcp::AtmosFrame>, dcpomatic::DCPTime, AtmosMetadata metadata);
- boost::shared_ptr<Writer> _writer;
- boost::shared_ptr<J2KEncoder> _j2k_encoder;
+ std::shared_ptr<Writer> _writer;
+ std::shared_ptr<J2KEncoder> _j2k_encoder;
bool _finishing;
bool _non_burnt_subtitles;
using std::cout;
using std::runtime_error;
using std::map;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
DCPExaminer::DCPExaminer (shared_ptr<const DCPContent> content, bool tolerant)
: DCP (content, tolerant)
class DCPExaminer : public DCP, public VideoExaminer, public AudioExaminer
{
public:
- explicit DCPExaminer (boost::shared_ptr<const DCPContent>, bool tolerant);
+ explicit DCPExaminer (std::shared_ptr<const DCPContent>, bool tolerant);
bool has_video () const {
return _has_video;
using std::string;
using std::exception;
-using boost::shared_ptr;
+using std::shared_ptr;
shared_ptr<dcp::SubtitleAsset>
DCPSubtitle::load (boost::filesystem::path file) const
#ifndef DCPOMATIC_DCP_SUBTITLE_H
#define DCPOMATIC_DCP_SUBTITLE_H
-#include <boost/shared_ptr.hpp>
#include <boost/filesystem.hpp>
namespace dcp {
class DCPSubtitle
{
protected:
- boost::shared_ptr<dcp::SubtitleAsset> load (boost::filesystem::path) const;
+ std::shared_ptr<dcp::SubtitleAsset> load (boost::filesystem::path) const;
};
#endif
using std::string;
using std::list;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using dcp::raw_convert;
using namespace dcpomatic;
DCPSubtitleContent (boost::filesystem::path);
DCPSubtitleContent (cxml::ConstNodePtr, int);
- void examine (boost::shared_ptr<const Film> film, boost::shared_ptr<Job>);
+ void examine (std::shared_ptr<const Film> film, std::shared_ptr<Job>);
std::string summary () const;
std::string technical_summary () const;
void as_xml (xmlpp::Node *, bool with_paths) const;
- dcpomatic::DCPTime full_length (boost::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime full_length (std::shared_ptr<const Film> film) const;
dcpomatic::DCPTime approximate_length () const;
private:
using std::map;
using std::string;
using std::vector;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::bind;
using namespace dcpomatic;
class DCPSubtitleDecoder : public DCPSubtitle, public Decoder
{
public:
- DCPSubtitleDecoder (boost::shared_ptr<const Film> film, boost::shared_ptr<const DCPSubtitleContent>);
+ DCPSubtitleDecoder (std::shared_ptr<const Film> film, std::shared_ptr<const DCPSubtitleContent>);
bool pass ();
void seek (dcpomatic::ContentTime time, bool accurate);
std::vector<dcpomatic::FontData> fonts () const;
private:
- dcpomatic::ContentTimePeriod content_time_period (boost::shared_ptr<dcp::Subtitle> s) const;
+ dcpomatic::ContentTimePeriod content_time_period (std::shared_ptr<dcp::Subtitle> s) const;
- std::list<boost::shared_ptr<dcp::Subtitle> > _subtitles;
- std::list<boost::shared_ptr<dcp::Subtitle> >::const_iterator _next;
+ std::list<std::shared_ptr<dcp::Subtitle> > _subtitles;
+ std::list<std::shared_ptr<dcp::Subtitle> >::const_iterator _next;
std::vector<dcpomatic::FontData> _fonts;
};
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::Size;
using dcp::ArrayData;
using dcp::raw_convert;
class DCPVideo : public boost::noncopyable
{
public:
- DCPVideo (boost::shared_ptr<const PlayerVideo>, int, int, int, Resolution);
- DCPVideo (boost::shared_ptr<const PlayerVideo>, cxml::ConstNodePtr);
+ DCPVideo (std::shared_ptr<const PlayerVideo>, int, int, int, Resolution);
+ DCPVideo (std::shared_ptr<const PlayerVideo>, cxml::ConstNodePtr);
dcp::ArrayData encode_locally ();
dcp::ArrayData encode_remotely (EncodeServerDescription, int timeout = 30);
Eyes eyes () const;
- bool same (boost::shared_ptr<const DCPVideo> other) const;
+ bool same (std::shared_ptr<const DCPVideo> other) const;
- static boost::shared_ptr<dcp::OpenJPEGImage> convert_to_xyz (boost::shared_ptr<const PlayerVideo> frame, dcp::NoteHandler note);
+ static std::shared_ptr<dcp::OpenJPEGImage> convert_to_xyz (std::shared_ptr<const PlayerVideo> frame, dcp::NoteHandler note);
private:
void add_metadata (xmlpp::Element *) const;
- boost::shared_ptr<const PlayerVideo> _frame;
+ std::shared_ptr<const PlayerVideo> _frame;
int _index; ///< frame index within the DCP's intrinsic duration
int _frames_per_second; ///< Frames per second that we will use for the DCP
int _j2k_bandwidth; ///< J2K bandwidth to use
#include "null_log.h"
/** The current log; set up by the front-ends when they have a Film to log into */
-boost::shared_ptr<Log> dcpomatic_log (new NullLog());
+std::shared_ptr<Log> dcpomatic_log (new NullLog());
#include "log.h"
#include "compose.hpp"
-#include <boost/shared_ptr.hpp>
/** The current log; set up by the front-ends when they have a Film to log into */
-extern boost::shared_ptr<Log> dcpomatic_log;
+extern std::shared_ptr<Log> dcpomatic_log;
#define LOG_GENERAL(...) dcpomatic_log->log(String::compose(__VA_ARGS__), LogEntry::TYPE_GENERAL);
#define LOG_GENERAL_NC(...) dcpomatic_log->log(__VA_ARGS__, LogEntry::TYPE_GENERAL);
#include "i18n.h"
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
/** @param timeout Timeout in seconds */
Socket::Socket (int timeout)
#include <boost/asio.hpp>
#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
-#include <boost/weak_ptr.hpp>
/** @class Socket
* @brief A class to wrap a boost::asio::ip::tcp::socket with some things
class ReadDigestScope
{
public:
- ReadDigestScope (boost::shared_ptr<Socket> socket);
+ ReadDigestScope (std::shared_ptr<Socket> socket);
bool check ();
private:
- boost::weak_ptr<Socket> _socket;
+ std::weak_ptr<Socket> _socket;
};
/** After one of these is created everything that is sent from the socket will be
class WriteDigestScope
{
public:
- WriteDigestScope (boost::shared_ptr<Socket> socket);
+ WriteDigestScope (std::shared_ptr<Socket> socket);
~WriteDigestScope ();
private:
- boost::weak_ptr<Socket> _socket;
+ std::weak_ptr<Socket> _socket;
};
private:
using std::cout;
using boost::optional;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using namespace dcpomatic;
Decoder::Decoder (weak_ptr<const Film> film)
class Decoder : public boost::noncopyable, public WeakConstFilm
{
public:
- Decoder (boost::weak_ptr<const Film> film);
+ Decoder (std::weak_ptr<const Film> film);
virtual ~Decoder () {}
- boost::shared_ptr<VideoDecoder> video;
-
boost::shared_ptr<AudioDecoder> audio;
- std::list<boost::shared_ptr<TextDecoder> > text;
-
boost::shared_ptr<AtmosDecoder> atmos;
+ std::shared_ptr<VideoDecoder> video;
+
std::shared_ptr<AudioDecoder> audio;
+ std::list<std::shared_ptr<TextDecoder> > text;
+
std::shared_ptr<AtmosDecoder> atmos;
- boost::shared_ptr<TextDecoder> only_text () const;
+ std::shared_ptr<TextDecoder> only_text () const;
/** Do some decoding and perhaps emit video, audio or subtitle data.
* @return true if this decoder will emit no more data unless a seek() happens.
#include <boost/foreach.hpp>
using std::list;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
template <class T>
shared_ptr<T>
class ImageDecoder;
-extern boost::shared_ptr<Decoder> decoder_factory (
- boost::shared_ptr<const Film> film,
- boost::shared_ptr<const Content> content,
+extern std::shared_ptr<Decoder> decoder_factory (
+ std::shared_ptr<const Film> film,
+ std::shared_ptr<const Content> content,
bool fast,
bool tolerant,
- boost::shared_ptr<Decoder> old_decoder
+ std::shared_ptr<Decoder> old_decoder
);
#include "decoder_part.h"
#include "decoder.h"
-using boost::shared_ptr;
+using std::shared_ptr;
DecoderPart::DecoderPart (Decoder* parent)
: _parent (parent)
DecoderPart (Decoder* parent);
virtual ~DecoderPart () {}
- virtual boost::optional<dcpomatic::ContentTime> position (boost::shared_ptr<const Film> film) const = 0;
+ virtual boost::optional<dcpomatic::ContentTime> position (std::shared_ptr<const Film> film) const = 0;
virtual void seek () = 0;
void set_ignore (bool i) {
using std::string;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::raw_convert;
KDMWithMetadataPtr
kdm_for_dkdm_recipient (
- boost::shared_ptr<const Film> film,
+ std::shared_ptr<const Film> film,
boost::filesystem::path cpl,
- boost::shared_ptr<DKDMRecipient> recipient,
+ std::shared_ptr<DKDMRecipient> recipient,
boost::posix_time::ptime valid_from,
boost::posix_time::ptime valid_to
);
using std::string;
using std::list;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
shared_ptr<DKDMBase>
DKDMBase::read (cxml::ConstNodePtr node)
#include <dcp/encrypted_kdm.h>
#include <libcxml/cxml.h>
-#include <boost/enable_shared_from_this.hpp>
+#include <memory>
+
namespace xmlpp {
class Element;
class DKDMGroup;
-class DKDMBase : public boost::enable_shared_from_this<DKDMBase>
+class DKDMBase : public std::enable_shared_from_this<DKDMBase>
{
public:
virtual ~DKDMBase () {}
virtual std::string name () const = 0;
virtual void as_xml (xmlpp::Element *) const = 0;
- static boost::shared_ptr<DKDMBase> read (cxml::ConstNodePtr node);
+ static std::shared_ptr<DKDMBase> read (cxml::ConstNodePtr node);
- boost::shared_ptr<DKDMGroup> parent () const {
+ std::shared_ptr<DKDMGroup> parent () const {
return _parent;
}
- void set_parent (boost::shared_ptr<DKDMGroup> parent) {
+ void set_parent (std::shared_ptr<DKDMGroup> parent) {
_parent = parent;
}
private:
- boost::shared_ptr<DKDMGroup> _parent;
+ std::shared_ptr<DKDMGroup> _parent;
};
class DKDM : public DKDMBase
void as_xml (xmlpp::Element *) const;
- std::list<boost::shared_ptr<DKDMBase> > children () const {
+ std::list<std::shared_ptr<DKDMBase> > children () const {
return _children;
}
- void add (boost::shared_ptr<DKDMBase> child, boost::shared_ptr<DKDM> previous = boost::shared_ptr<DKDM> ());
- void remove (boost::shared_ptr<DKDMBase> child);
+ void add (std::shared_ptr<DKDMBase> child, std::shared_ptr<DKDM> previous = std::shared_ptr<DKDM> ());
+ void remove (std::shared_ptr<DKDMBase> child);
private:
std::string _name;
- std::list<boost::shared_ptr<DKDMBase> > _children;
+ std::list<std::shared_ptr<DKDMBase> > _children;
};
using std::list;
using std::cout;
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::ArrayData;
Emailer::Emailer (string from, list<string> to, string subject, string body)
using std::cout;
using std::list;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::function;
using namespace dcpomatic;
{
public:
Empty () {}
- Empty (boost::shared_ptr<const Film> film, boost::shared_ptr<const Playlist> playlist, boost::function<bool (boost::shared_ptr<const Content>)> part, dcpomatic::DCPTime length);
+ Empty (std::shared_ptr<const Film> film, std::shared_ptr<const Playlist> playlist, boost::function<bool (std::shared_ptr<const Content>)> part, dcpomatic::DCPTime length);
dcpomatic::DCPTime position () const {
return _position;
using std::cout;
using std::cerr;
using std::fixed;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::thread;
using boost::bind;
using boost::scoped_array;
void run ();
private:
- void handle (boost::shared_ptr<Socket>);
+ void handle (std::shared_ptr<Socket>);
void worker_thread ();
- int process (boost::shared_ptr<Socket> socket, struct timeval &, struct timeval &);
+ int process (std::shared_ptr<Socket> socket, struct timeval &, struct timeval &);
void broadcast_thread ();
void broadcast_received ();
boost::thread_group _worker_threads;
- std::list<boost::shared_ptr<Socket> > _queue;
+ std::list<std::shared_ptr<Socket> > _queue;
boost::condition _full_condition;
boost::condition _empty_condition;
bool _verbose;
using std::list;
using std::vector;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::scoped_array;
-using boost::weak_ptr;
+using std::weak_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
boost::optional<std::list<EncodeServerDescription>::iterator> server_found (std::string);
void start_accept ();
- void handle_accept (boost::system::error_code ec, boost::shared_ptr<Socket> socket);
+ void handle_accept (boost::system::error_code ec, std::shared_ptr<Socket> socket);
void config_changed (Config::Property what);
mutable boost::mutex _servers_mutex;
boost::asio::io_service _listen_io_service;
- boost::shared_ptr<boost::asio::ip::tcp::acceptor> _listen_acceptor;
+ std::shared_ptr<boost::asio::ip::tcp::acceptor> _listen_acceptor;
bool _stop;
boost::condition _search_condition;
#include "i18n.h"
-using boost::weak_ptr;
-using boost::shared_ptr;
+using std::weak_ptr;
+using std::shared_ptr;
/** Construct an encoder.
* @param film Film that we are encoding.
#include "types.h"
#include "player_text.h"
-#include <boost/weak_ptr.hpp>
#include <boost/signals2.hpp>
class Film;
class Encoder : public boost::noncopyable
{
public:
- Encoder (boost::shared_ptr<const Film> film, boost::weak_ptr<Job> job);
+ Encoder (std::shared_ptr<const Film> film, std::weak_ptr<Job> job);
virtual ~Encoder () {}
virtual void go () = 0;
virtual bool finishing () const = 0;
protected:
- boost::shared_ptr<const Film> _film;
- boost::weak_ptr<Job> _job;
-
boost::shared_ptr<Player> _player;
+ std::shared_ptr<const Film> _film;
+ std::weak_ptr<Job> _job;
+
std::shared_ptr<Player> _player;
};
#endif
using std::string;
using std::list;
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
/** @param v Version as used by FFmpeg.
* @return A string representation of v.
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
ExamineContentJob::ExamineContentJob (shared_ptr<const Film> film, shared_ptr<Content> c)
: Job (film)
*/
#include "job.h"
-#include <boost/shared_ptr.hpp>
class Content;
class ExamineContentJob : public Job
{
public:
- ExamineContentJob (boost::shared_ptr<const Film>, boost::shared_ptr<Content>);
+ ExamineContentJob (std::shared_ptr<const Film>, std::shared_ptr<Content>);
~ExamineContentJob ();
std::string name () const;
std::string json_name () const;
void run ();
- boost::shared_ptr<Content> content () const {
+ std::shared_ptr<Content> content () const {
return _content;
}
private:
- boost::shared_ptr<Content> _content;
+ std::shared_ptr<Content> _content;
};
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
ExamineFFmpegSubtitlesJob::ExamineFFmpegSubtitlesJob (shared_ptr<const Film> film, shared_ptr<FFmpegContent> c)
: Job (film)
#include "job.h"
#include "ffmpeg.h"
-#include <boost/shared_ptr.hpp>
class FFmpegContent;
class ExamineFFmpegSubtitlesJob : public Job, public FFmpeg
{
public:
- ExamineFFmpegSubtitlesJob (boost::shared_ptr<const Film>, boost::shared_ptr<FFmpegContent>);
+ ExamineFFmpegSubtitlesJob (std::shared_ptr<const Film>, std::shared_ptr<FFmpegContent>);
~ExamineFFmpegSubtitlesJob ();
std::string name () const;
void run ();
private:
- boost::shared_ptr<FFmpegContent> _content;
+ std::shared_ptr<FFmpegContent> _content;
};
using std::cout;
using std::cerr;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using dcp::raw_convert;
using namespace dcpomatic;
boost::mutex FFmpeg::_mutex;
-FFmpeg::FFmpeg (boost::shared_ptr<const FFmpegContent> c)
+FFmpeg::FFmpeg (std::shared_ptr<const FFmpegContent> c)
: _ffmpeg_content (c)
, _avio_buffer (0)
, _avio_buffer_size (4096)
#include <libavcodec/avcodec.h>
}
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>
struct AVFormatContext;
class FFmpeg
{
public:
- explicit FFmpeg (boost::shared_ptr<const FFmpegContent>);
+ explicit FFmpeg (std::shared_ptr<const FFmpegContent>);
virtual ~FFmpeg ();
- boost::shared_ptr<const FFmpegContent> ffmpeg_content () const {
+ std::shared_ptr<const FFmpegContent> ffmpeg_content () const {
return _ffmpeg_content;
}
AVCodecContext* video_codec_context () const;
AVCodecContext* subtitle_codec_context () const;
dcpomatic::ContentTime pts_offset (
- std::vector<boost::shared_ptr<FFmpegAudioStream> > audio_streams, boost::optional<dcpomatic::ContentTime> first_video, double video_frame_rate
+ std::vector<std::shared_ptr<FFmpegAudioStream> > audio_streams, boost::optional<dcpomatic::ContentTime> first_video, double video_frame_rate
) const;
static FFmpegSubtitlePeriod subtitle_period (AVSubtitle const & sub);
- boost::shared_ptr<const FFmpegContent> _ffmpeg_content;
+ std::shared_ptr<const FFmpegContent> _ffmpeg_content;
uint8_t* _avio_buffer;
int _avio_buffer_size;
void setup_decoders ();
static void ffmpeg_log_callback (void* ptr, int level, const char* fmt, va_list vl);
- static boost::weak_ptr<Log> _ffmpeg_log;
+ static std::weak_ptr<Log> _ffmpeg_log;
};
#endif
using std::pair;
using std::make_pair;
using std::max;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
using dcp::raw_convert;
using namespace dcpomatic;
public:
FFmpegContent (boost::filesystem::path);
FFmpegContent (cxml::ConstNodePtr, int version, std::list<std::string> &);
- FFmpegContent (std::vector<boost::shared_ptr<Content> >);
+ FFmpegContent (std::vector<std::shared_ptr<Content> >);
- boost::shared_ptr<FFmpegContent> shared_from_this () {
- return boost::dynamic_pointer_cast<FFmpegContent> (Content::shared_from_this ());
+ std::shared_ptr<FFmpegContent> shared_from_this () {
+ return std::dynamic_pointer_cast<FFmpegContent> (Content::shared_from_this ());
}
- boost::shared_ptr<const FFmpegContent> shared_from_this () const {
- return boost::dynamic_pointer_cast<const FFmpegContent> (Content::shared_from_this ());
+ std::shared_ptr<const FFmpegContent> shared_from_this () const {
+ return std::dynamic_pointer_cast<const FFmpegContent> (Content::shared_from_this ());
}
- void examine (boost::shared_ptr<const Film> film, boost::shared_ptr<Job>);
- void take_settings_from (boost::shared_ptr<const Content> c);
+ void examine (std::shared_ptr<const Film> film, std::shared_ptr<Job>);
+ void take_settings_from (std::shared_ptr<const Content> c);
std::string summary () const;
std::string technical_summary () const;
void as_xml (xmlpp::Node *, bool with_paths) const;
- dcpomatic::DCPTime full_length (boost::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime full_length (std::shared_ptr<const Film> film) const;
dcpomatic::DCPTime approximate_length () const;
std::string identifier () const;
void set_filters (std::vector<Filter const *> const &);
- std::vector<boost::shared_ptr<FFmpegSubtitleStream> > subtitle_streams () const {
+ std::vector<std::shared_ptr<FFmpegSubtitleStream> > subtitle_streams () const {
boost::mutex::scoped_lock lm (_mutex);
return _subtitle_streams;
}
- boost::shared_ptr<FFmpegSubtitleStream> subtitle_stream () const {
+ std::shared_ptr<FFmpegSubtitleStream> subtitle_stream () const {
boost::mutex::scoped_lock lm (_mutex);
return _subtitle_stream;
}
- std::vector<boost::shared_ptr<FFmpegAudioStream> > ffmpeg_audio_streams () const;
+ std::vector<std::shared_ptr<FFmpegAudioStream> > ffmpeg_audio_streams () const;
std::vector<Filter const *> filters () const {
boost::mutex::scoped_lock lm (_mutex);
return _filters;
}
- void set_subtitle_stream (boost::shared_ptr<FFmpegSubtitleStream>);
+ void set_subtitle_stream (std::shared_ptr<FFmpegSubtitleStream>);
boost::optional<dcpomatic::ContentTime> first_video () const {
boost::mutex::scoped_lock lm (_mutex);
void signal_subtitle_stream_changed ();
private:
- void add_properties (boost::shared_ptr<const Film> film, std::list<UserProperty> &) const;
+ void add_properties (std::shared_ptr<const Film> film, std::list<UserProperty> &) const;
friend struct ffmpeg_pts_offset_test;
friend struct audio_sampling_rate_test;
- std::vector<boost::shared_ptr<FFmpegSubtitleStream> > _subtitle_streams;
- boost::shared_ptr<FFmpegSubtitleStream> _subtitle_stream;
+ std::vector<std::shared_ptr<FFmpegSubtitleStream> > _subtitle_streams;
+ std::shared_ptr<FFmpegSubtitleStream> _subtitle_stream;
boost::optional<dcpomatic::ContentTime> _first_video;
/** Video filters that should be used when generating DCPs */
std::vector<Filter const *> _filters;
using std::pair;
using std::max;
using std::map;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::is_any_of;
using boost::split;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using dcp::Size;
using namespace dcpomatic;
extern "C" {
#include <libavcodec/avcodec.h>
}
-#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <stdint.h>
class FFmpegDecoder : public FFmpeg, public Decoder
{
public:
- FFmpegDecoder (boost::shared_ptr<const Film> film, boost::shared_ptr<const FFmpegContent>, bool fast);
+ FFmpegDecoder (std::shared_ptr<const Film> film, std::shared_ptr<const FFmpegContent>, bool fast);
bool pass ();
void seek (dcpomatic::ContentTime time, bool);
void flush ();
- AVSampleFormat audio_sample_format (boost::shared_ptr<FFmpegAudioStream> stream) const;
- int bytes_per_audio_sample (boost::shared_ptr<FFmpegAudioStream> stream) const;
+ AVSampleFormat audio_sample_format (std::shared_ptr<FFmpegAudioStream> stream) const;
+ int bytes_per_audio_sample (std::shared_ptr<FFmpegAudioStream> stream) const;
bool decode_video_packet ();
void decode_audio_packet ();
void decode_ass_subtitle (std::string ass, dcpomatic::ContentTime from);
void maybe_add_subtitle ();
- boost::shared_ptr<AudioBuffers> deinterleave_audio (boost::shared_ptr<FFmpegAudioStream> stream) const;
+ std::shared_ptr<AudioBuffers> deinterleave_audio (std::shared_ptr<FFmpegAudioStream> stream) const;
- std::list<boost::shared_ptr<VideoFilterGraph> > _filter_graphs;
+ std::list<std::shared_ptr<VideoFilterGraph> > _filter_graphs;
boost::mutex _filter_graphs_mutex;
dcpomatic::ContentTime _pts_offset;
/** true if we have a subtitle which has not had emit_stop called for it yet */
bool _have_current_subtitle;
- boost::shared_ptr<Image> _black_image;
+ std::shared_ptr<Image> _black_image;
std::vector<boost::optional<dcpomatic::ContentTime> > _next_time;
};
using std::pair;
using std::list;
using std::map;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
-using boost::weak_ptr;
+using std::weak_ptr;
using boost::optional;
using namespace dcpomatic;
#if BOOST_VERSION >= 106100
}
}
- map<Eyes, boost::shared_ptr<FFmpegFileEncoder> >::const_iterator i = _encoders.find (eyes);
+ map<Eyes, std::shared_ptr<FFmpegFileEncoder> >::const_iterator i = _encoders.find (eyes);
DCPOMATIC_ASSERT (i != _encoders.end());
return i->second;
}
void
FFmpegEncoder::FileEncoderSet::flush ()
{
- for (map<Eyes, boost::shared_ptr<FFmpegFileEncoder> >::iterator i = _encoders.begin(); i != _encoders.end(); ++i) {
+ for (map<Eyes, std::shared_ptr<FFmpegFileEncoder> >::iterator i = _encoders.begin(); i != _encoders.end(); ++i) {
i->second->flush ();
}
}
void
FFmpegEncoder::FileEncoderSet::audio (shared_ptr<AudioBuffers> a)
{
- for (map<Eyes, boost::shared_ptr<FFmpegFileEncoder> >::iterator i = _encoders.begin(); i != _encoders.end(); ++i) {
+ for (map<Eyes, std::shared_ptr<FFmpegFileEncoder> >::iterator i = _encoders.begin(); i != _encoders.end(); ++i) {
i->second->audio (a);
}
}
{
public:
FFmpegEncoder (
- boost::shared_ptr<const Film> film,
- boost::weak_ptr<Job> job,
+ std::shared_ptr<const Film> film,
+ std::weak_ptr<Job> job,
boost::filesystem::path output,
ExportFormat format,
bool mixdown_to_stereo,
std::string extension
);
- boost::shared_ptr<FFmpegFileEncoder> get (Eyes eyes) const;
+ std::shared_ptr<FFmpegFileEncoder> get (Eyes eyes) const;
void flush ();
- void audio (
boost::shared_ptr<AudioBuffers>);
+ void audio (
std::shared_ptr<AudioBuffers>);
private:
- std::map<Eyes, boost::shared_ptr<FFmpegFileEncoder> > _encoders;
+ std::map<Eyes, std::shared_ptr<FFmpegFileEncoder> > _encoders;
};
int _output_audio_channels;
bool _audio_stream_per_channel;
int _x264_crf;
- boost::shared_ptr<Butler> _butler;
+ std::shared_ptr<Butler> _butler;
};
#endif
using std::cout;
using std::max;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
class FFmpegExaminer : public FFmpeg, public VideoExaminer
{
public:
- FFmpegExaminer (boost::shared_ptr<const FFmpegContent>, boost::shared_ptr<Job> job = boost::shared_ptr<Job> ());
+ FFmpegExaminer (std::shared_ptr<const FFmpegContent>, std::shared_ptr<Job> job = std::shared_ptr<Job> ());
bool has_video () const;
boost::optional<double> sample_aspect_ratio () const;
bool yuv () const;
- std::vector<boost::shared_ptr<FFmpegSubtitleStream> > subtitle_streams () const {
+ std::vector<std::shared_ptr<FFmpegSubtitleStream> > subtitle_streams () const {
return _subtitle_streams;
}
- std::vector<boost::shared_ptr<FFmpegAudioStream> > audio_streams () const {
+ std::vector<std::shared_ptr<FFmpegAudioStream> > audio_streams () const {
return _audio_streams;
}
private:
void video_packet (AVCodecContext *, std::string& temporal_reference);
- void audio_packet (AVCodecContext *, boost::shared_ptr<FFmpegAudioStream>);
+ void audio_packet (AVCodecContext *, std::shared_ptr<FFmpegAudioStream>);
std::string stream_name (AVStream* s) const;
std::string subtitle_stream_name (AVStream* s) const;
boost::optional<dcpomatic::ContentTime> frame_time (AVStream* s) const;
- std::vector<boost::shared_ptr<FFmpegSubtitleStream> > _subtitle_streams;
- std::vector<boost::shared_ptr<FFmpegAudioStream> > _audio_streams;
+ std::vector<std::shared_ptr<FFmpegSubtitleStream> > _subtitle_streams;
+ std::vector<std::shared_ptr<FFmpegAudioStream> > _audio_streams;
boost::optional<dcpomatic::ContentTime> _first_video;
/** Video length, either obtained from the header or derived by running
* through the whole file.
dcpomatic::ContentTime time;
};
- typedef std::map<boost::shared_ptr<FFmpegSubtitleStream>, boost::optional<SubtitleStart> > LastSubtitleMap;
+ typedef std::map<std::shared_ptr<FFmpegSubtitleStream>, boost::optional<SubtitleStart> > LastSubtitleMap;
LastSubtitleMap _last_subtitle_start;
};
using std::runtime_error;
using std::cout;
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
-using boost::weak_ptr;
+using std::weak_ptr;
using boost::optional;
using namespace dcpomatic;
#if BOOST_VERSION >= 106100
~FFmpegFileEncoder ();
- void video (
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime);
- void audio (
boost::shared_ptr<AudioBuffers>);
+ void video (
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime);
+ void audio (
std::shared_ptr<AudioBuffers>);
void subtitle (PlayerText, dcpomatic::DCPTimePeriod);
void flush ();
AVCodec* _video_codec;
AVCodecContext* _video_codec_context;
- std::vector<boost::shared_ptr<ExportAudioStream> > _audio_streams;
+ std::vector<std::shared_ptr<ExportAudioStream> > _audio_streams;
bool _audio_stream_per_channel;
AVFormatContext* _format_context;
AVStream* _video_stream;
int64_t _audio_frames;
-
boost::shared_ptr<AudioBuffers> _pending_audio;
+
std::shared_ptr<AudioBuffers> _pending_audio;
/** Store of shared_ptr<Image> to keep them alive whilst raw pointers into
their data have been passed to FFmpeg.
*/
- std::map<uint8_t*, boost::shared_ptr<const Image> > _pending_images;
+ std::map<uint8_t*, std::shared_ptr<const Image> > _pending_images;
boost::mutex _pending_images_mutex;
static int _video_stream_index;
using std::pair;
using std::min;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using dcp::raw_convert;
FFmpegImageProxy::FFmpegImageProxy (boost::filesystem::path path, VideoRange video_range)
public:
explicit FFmpegImageProxy (boost::filesystem::path, VideoRange video_range);
explicit FFmpegImageProxy (dcp::ArrayData, VideoRange video_range);
- FFmpegImageProxy (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket);
+ FFmpegImageProxy (std::shared_ptr<cxml::Node> xml, std::shared_ptr<Socket> socket);
Result image (
boost::optional<dcp::Size> size = boost::optional<dcp::Size> ()
) const;
void add_metadata (xmlpp::Node *) const;
- void write_to_socket (boost::shared_ptr<Socket>) const;
- bool same (boost::shared_ptr<const ImageProxy> other) const;
+ void write_to_socket (std::shared_ptr<Socket>) const;
+ bool same (std::shared_ptr<const ImageProxy> other) const;
size_t memory_used () const;
int avio_read (uint8_t* buffer, int const amount);
failed-decode errors can give more detail.
*/
boost::optional<boost::filesystem::path> _path;
- mutable boost::shared_ptr<Image> _image;
+ mutable std::shared_ptr<Image> _image;
mutable boost::mutex _mutex;
};
using std::cout;
using std::string;
using std::max;
-using boost::shared_ptr;
+using std::shared_ptr;
/** @param file Filename to write log to */
FileLog::FileLog (boost::filesystem::path file)
std::string head_and_tail (int amount = 1024) const;
private:
- void do_log (boost::shared_ptr<const LogEntry> entry);
+ void do_log (std::shared_ptr<const LogEntry> entry);
/** filename to write to */
boost::filesystem::path _file;
using std::map;
using std::exception;
using std::find;
-using boost::shared_ptr;
-using boost::weak_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::weak_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
using boost::is_any_of;
#if BOOST_VERSION >= 106100
#include <dcp/key.h>
#include <dcp/encrypted_kdm.h>
#include <boost/signals2.hpp>
-#include <boost/enable_shared_from_this.hpp>
#include <boost/thread.hpp>
#include <boost/filesystem.hpp>
#include <boost/thread/mutex.hpp>
*
* The content of a Film is held in a Playlist (created and managed by the Film).
*/
-class Film : public boost::enable_shared_from_this<Film>, public Signaller, public boost::noncopyable
+class Film : public std::enable_shared_from_this<Film>, public Signaller, public boost::noncopyable
{
public:
explicit Film (boost::optional<boost::filesystem::path> dir);
~Film ();
- boost::shared_ptr<InfoFileHandle> info_file_handle (dcpomatic::DCPTimePeriod period, bool read) const;
+ std::shared_ptr<InfoFileHandle> info_file_handle (dcpomatic::DCPTimePeriod period, bool read) const;
boost::filesystem::path j2c_path (int, Frame, Eyes, bool) const;
boost::filesystem::path internal_video_asset_dir () const;
boost::filesystem::path internal_video_asset_filename (dcpomatic::DCPTimePeriod p) const;
- boost::filesystem::path audio_analysis_path (boost::shared_ptr<const Playlist>) const;
- boost::filesystem::path subtitle_analysis_path (boost::shared_ptr<const Content>) const;
+ boost::filesystem::path audio_analysis_path (std::shared_ptr<const Playlist>) const;
+ boost::filesystem::path subtitle_analysis_path (std::shared_ptr<const Content>) const;
void send_dcp_to_tms ();
void make_dcp (bool gui = false, bool check = true);
/** @return Logger.
* It is safe to call this from any thread.
*/
- boost::shared_ptr<Log> log () const {
+ std::shared_ptr<Log> log () const {
return _log;
}
void write_metadata () const;
void write_metadata (boost::filesystem::path path) const;
void write_template (boost::filesystem::path path) const;
- boost::shared_ptr<xmlpp::Document> metadata (bool with_content_paths = true) const;
+ std::shared_ptr<xmlpp::Document> metadata (bool with_content_paths = true) const;
- void copy_from (boost::shared_ptr<const Film> film);
+ void copy_from (std::shared_ptr<const Film> film);
std::string isdcf_name (bool if_created_now) const;
std::string dcp_name (bool if_created_now = false) const;
void repeat_content (ContentList, int);
- boost::shared_ptr<const Playlist> playlist () const {
+ std::shared_ptr<const Playlist> playlist () const {
return _playlist;
}
void set_directory (boost::filesystem::path);
void set_name (std::string);
void set_use_isdcf_name (bool);
- void examine_and_add_content (boost::shared_ptr<Content> content, bool disable_audio_analysis = false);
- void add_content (boost::shared_ptr<Content>);
- void remove_content (boost::shared_ptr<Content>);
+ void examine_and_add_content (std::shared_ptr<Content> content, bool disable_audio_analysis = false);
+ void add_content (std::shared_ptr<Content>);
+ void remove_content (std::shared_ptr<Content>);
void remove_content (ContentList);
- void move_content_earlier (boost::shared_ptr<Content>);
- void move_content_later (boost::shared_ptr<Content>);
+ void move_content_earlier (std::shared_ptr<Content>);
+ void move_content_later (std::shared_ptr<Content>);
void set_dcp_content_type (DCPContentType const *);
void set_container (Ratio const *, bool user_explicit = true);
void set_resolution (Resolution, bool user_explicit = true);
mutable boost::signals2::signal<void (ChangeType, Property)> Change;
/** Emitted when some property of our content has changed */
- mutable boost::signals2::signal<void (ChangeType, boost::weak_ptr<Content>, int, bool)> ContentChange;
+ mutable boost::signals2::signal<void (ChangeType, std::weak_ptr<Content>, int, bool)> ContentChange;
/** Emitted when the film's length might have changed; this is not like a normal
property as its value is derived from the playlist, so it has its own signal.
std::string video_identifier () const;
void playlist_change (ChangeType);
void playlist_order_changed ();
- void playlist_content_change (ChangeType type, boost::weak_ptr<Content>, int, bool frequent);
+ void playlist_content_change (ChangeType type, std::weak_ptr<Content>, int, bool frequent);
void playlist_length_change ();
- void maybe_add_content (boost::weak_ptr<Job>, boost::weak_ptr<Content>, bool disable_audio_analysis);
+ void maybe_add_content (std::weak_ptr<Job>, std::weak_ptr<Content>, bool disable_audio_analysis);
void audio_analysis_finished ();
void check_settings_consistency ();
void maybe_set_container_and_resolution ();
static std::string const metadata_file;
/** Log to write to */
- boost::shared_ptr<Log> _log;
-
boost::shared_ptr<Playlist> _playlist;
+ std::shared_ptr<Log> _log;
+
std::shared_ptr<Playlist> _playlist;
/** Complete path to directory containing the film metadata;
* must not be relative.
/** true if our state has changed since we last saved it */
mutable bool _dirty;
/** film being used as a template, or 0 */
- boost::shared_ptr<Film> _template_film;
+ std::shared_ptr<Film> _template_film;
/** Be tolerant of errors in content (currently applies to DCP only).
Not saved as state.
using std::make_pair;
using std::cout;
using std::vector;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using dcp::Size;
/** Construct a FilterGraph for the settings in a piece of content */
#include "font.h"
#include "font_data.h"
#include "dcpomatic_assert.h"
-#include <boost/shared_ptr.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
dcpomatic::FontData::FontData (shared_ptr<const Font> font)
class FontData
{
public:
- FontData (boost::shared_ptr<const Font> font);
+ FontData (std::shared_ptr<const Font> font);
FontData (std::string id_, dcp::ArrayData data_)
: id(id_)
#include "i18n.h"
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
static bool
about_equal (double a, double b)
#ifndef DCPOMATIC_FRAME_RATE_CHANGE_H
#define DCPOMATIC_FRAME_RATE_CHANGE_H
-#include <boost/shared_ptr.hpp>
+
+#include <memory>
#include <string>
+
class Film;
class Content;
public:
FrameRateChange ();
FrameRateChange (double, int);
- FrameRateChange (boost::shared_ptr<const Film> film, boost::shared_ptr<const Content> content);
- FrameRateChange (boost::shared_ptr<const Film> film, Content const * content);
+ FrameRateChange (std::shared_ptr<const Film> film, std::shared_ptr<const Content> content);
+ FrameRateChange (std::shared_ptr<const Film> film, Content const * content);
/** @return factor by which to multiply a source frame rate
to get the effective rate after any skip or repeat has happened.
using std::min;
using std::max;
using std::cout;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::optional;
using boost::bind;
using namespace dcpomatic;
#include "dcp_text_track.h"
#include "dcpomatic_time.h"
#include "weak_film.h"
-#include <boost/weak_ptr.hpp>
#include <boost/signals2.hpp>
#include <boost/atomic.hpp>
#include <vector>
class Hints : public Signaller, public ExceptionStore, public WeakConstFilm
{
public:
- explicit Hints (boost::weak_ptr<const Film> film);
+ explicit Hints (std::weak_ptr<const Film> film);
~Hints ();
void start ();
* our final DCP will have. This means we can see how big the files will be and warn if they
* will be too big.
*/
- boost::shared_ptr<Writer> _writer;
+ std::shared_ptr<Writer> _writer;
bool _long_ccap;
bool _overlap_ccap;
using std::cerr;
using std::list;
using std::runtime_error;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::Size;
}
Image::Image (Image const & other)
- : boost::enable_shared_from_this<Image>(other)
+ : std::enable_shared_from_this<Image>(other)
, _size (other._size)
, _pixel_format (other._pixel_format)
, _aligned (other._aligned)
}
#include <dcp/array_data.h>
#include <dcp/colour_conversion.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
struct AVFrame;
class Socket;
-class Image : public boost::enable_shared_from_this<Image>
+class Image : public std::enable_shared_from_this<Image>
{
public:
Image (AVPixelFormat p, dcp::Size s, bool aligned);
explicit Image (AVFrame *);
explicit Image (Image const &);
- Image (boost::shared_ptr<const Image>, bool);
+ Image (std::shared_ptr<const Image>, bool);
Image& operator= (Image const &);
~Image ();
dcp::Size sample_size (int) const;
float bytes_per_pixel (int) const;
- boost::shared_ptr<Image> convert_pixel_format (dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_format, bool aligned, bool fast) const;
- boost::shared_ptr<Image> scale (dcp::Size out_size, dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_format, bool aligned, bool fast) const;
- boost::shared_ptr<Image> crop_scale_window (
+ std::shared_ptr<Image> convert_pixel_format (dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_format, bool aligned, bool fast) const;
+ std::shared_ptr<Image> scale (dcp::Size out_size, dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_format, bool aligned, bool fast) const;
+ std::shared_ptr<Image> crop_scale_window (
Crop crop,
dcp::Size inter_size,
dcp::Size out_size,
void make_black ();
void make_transparent ();
- void alpha_blend (boost::shared_ptr<const Image> image, Position<int> pos);
- void copy (boost::shared_ptr<const Image> image, Position<int> pos);
+ void alpha_blend (std::shared_ptr<const Image> image, Position<int> pos);
+ void copy (std::shared_ptr<const Image> image, Position<int> pos);
void fade (float);
void video_range_to_full_range ();
- void read_from_socket (boost::shared_ptr<Socket>);
- void write_to_socket (boost::shared_ptr<Socket>) const;
+ void read_from_socket (std::shared_ptr<Socket>);
+ void write_to_socket (std::shared_ptr<Socket>) const;
AVPixelFormat pixel_format () const {
return _pixel_format;
void png_error (char const * message);
- static boost::shared_ptr<const Image> ensure_aligned (boost::shared_ptr<const Image> image);
+ static std::shared_ptr<const Image> ensure_aligned (std::shared_ptr<const Image> image);
private:
friend struct pixel_formats_test;
using std::cout;
using std::list;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
ImageContent::ImageContent (boost::filesystem::path p)
ImageContent (boost::filesystem::path);
ImageContent (cxml::ConstNodePtr, int);
- boost::shared_ptr<ImageContent> shared_from_this () {
- return boost::dynamic_pointer_cast<ImageContent> (Content::shared_from_this ());
+ std::shared_ptr<ImageContent> shared_from_this () {
+ return std::dynamic_pointer_cast<ImageContent> (Content::shared_from_this ());
};
- boost::shared_ptr<const ImageContent> shared_from_this () const {
- return boost::dynamic_pointer_cast<const ImageContent> (Content::shared_from_this ());
+ std::shared_ptr<const ImageContent> shared_from_this () const {
+ return std::dynamic_pointer_cast<const ImageContent> (Content::shared_from_this ());
};
- void examine (boost::shared_ptr<const Film> film, boost::shared_ptr<Job>);
+ void examine (std::shared_ptr<const Film> film, std::shared_ptr<Job>);
std::string summary () const;
std::string technical_summary () const;
void as_xml (xmlpp::Node *, bool with_paths) const;
- dcpomatic::DCPTime full_length (boost::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime full_length (std::shared_ptr<const Film> film) const;
dcpomatic::DCPTime approximate_length () const;
std::string identifier () const;
bool still () const;
private:
- void add_properties (boost::shared_ptr<const Film> film, std::list<UserProperty>& p) const;
+ void add_properties (std::shared_ptr<const Film> film, std::list<UserProperty>& p) const;
boost::optional<boost::filesystem::path> _path_to_scan;
};
#include "i18n.h"
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::Size;
using namespace dcpomatic;
class ImageDecoder : public Decoder
{
public:
- ImageDecoder (boost::shared_ptr<const Film> film, boost::shared_ptr<const ImageContent> c);
+ ImageDecoder (std::shared_ptr<const Film> film, std::shared_ptr<const ImageContent> c);
- boost::shared_ptr<const ImageContent> content () {
+ std::shared_ptr<const ImageContent> content () {
return _image_content;
}
private:
- boost::shared_ptr<const ImageContent> _image_content;
- boost::shared_ptr<ImageProxy> _image;
+ std::shared_ptr<const ImageContent> _image_content;
+ std::shared_ptr<ImageProxy> _image;
Frame _frame_video_position;
};
using std::cout;
using std::list;
using std::sort;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
ImageExaminer::ImageExaminer (shared_ptr<const Film> film, shared_ptr<const ImageContent> content, shared_ptr<Job>)
class ImageExaminer : public VideoExaminer
{
public:
- ImageExaminer (boost::shared_ptr<const Film>, boost::shared_ptr<const ImageContent>, boost::shared_ptr<Job>);
+ ImageExaminer (std::shared_ptr<const Film>, std::shared_ptr<const ImageContent>, std::shared_ptr<Job>);
bool has_video () const {
return true;
}
private:
- boost::weak_ptr<const Film> _film;
- boost::shared_ptr<const ImageContent> _image_content;
+ std::weak_ptr<const Film> _film;
+ std::shared_ptr<const ImageContent> _image_content;
boost::optional<dcp::Size> _video_size;
Frame _video_length;
};
using std::cout;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
shared_ptr<ImageProxy>
image_proxy_factory (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket)
#include <libavutil/pixfmt.h>
}
#include <dcp/types.h>
-#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
#include <boost/utility.hpp>
virtual ~ImageProxy () {}
struct Result {
- Result (boost::shared_ptr<Image> image_, int log2_scaling_)
+ Result (std::shared_ptr<Image> image_, int log2_scaling_)
: image (image_)
, log2_scaling (log2_scaling_)
, error (false)
{}
- Result (boost::shared_ptr<Image> image_, int log2_scaling_, bool error_)
+ Result (std::shared_ptr<Image> image_, int log2_scaling_, bool error_)
: image (image_)
, log2_scaling (log2_scaling_)
, error (error_)
{}
/** Image (which will be aligned) */
- boost::shared_ptr<Image> image;
+ std::shared_ptr<Image> image;
/** log2 of any scaling down that has already been applied to the image;
* e.g. if the image is already half the size of the original, this value
* will be 1.
) const = 0;
virtual void add_metadata (xmlpp::Node *) const = 0;
- virtual void write_to_socket (boost::shared_ptr<Socket>) const = 0;
+ virtual void write_to_socket (std::shared_ptr<Socket>) const = 0;
/** @return true if our image is definitely the same as another, false if it is probably not */
- virtual bool same (boost::shared_ptr<const ImageProxy>) const = 0;
+ virtual bool same (std::shared_ptr<const ImageProxy>) const = 0;
/** Do any useful work that would speed up a subsequent call to ::image().
* This method may be called in a different thread to image().
* @return log2 of any scaling down that will be applied to the image.
virtual size_t memory_used () const = 0;
};
-boost::shared_ptr<ImageProxy> image_proxy_factory (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket);
+std::shared_ptr<ImageProxy> image_proxy_factory (std::shared_ptr<cxml::Node> xml, std::shared_ptr<Socket> socket);
#endif
#include "i18n.h"
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::raw_convert;
ISDCFMetadata::ISDCFMetadata (cxml::ConstNodePtr node)
using std::list;
using std::cout;
using std::exception;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::optional;
using dcp::Data;
using namespace dcpomatic;
#include "cross.h"
#include "event_history.h"
#include "exception_store.h"
-#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread.hpp>
#include <boost/optional.hpp>
#include <boost/signals2.hpp>
-#include <boost/enable_shared_from_this.hpp>
#include <list>
#include <stdint.h>
* the work around threads and encoding servers.
*/
-class J2KEncoder : public boost::noncopyable, public ExceptionStore, public boost::enable_shared_from_this<J2KEncoder>
+class J2KEncoder : public boost::noncopyable, public ExceptionStore, public std::enable_shared_from_this<J2KEncoder>
{
public:
- J2KEncoder (boost::shared_ptr<const Film> film, boost::shared_ptr<Writer> writer);
+ J2KEncoder (std::shared_ptr<const Film> film, std::shared_ptr<Writer> writer);
~J2KEncoder ();
/** Called to indicate that a processing run is about to begin */
void begin ();
/** Called to pass a bit of video to be encoded as the next DCP frame */
- void encode (
boost::shared_ptr<PlayerVideo> pv, dcpomatic::DCPTime time);
+ void encode (
std::shared_ptr<PlayerVideo> pv, dcpomatic::DCPTime time);
/** Called when a processing run has finished */
void end ();
private:
- static void call_servers_list_changed (boost::weak_ptr<J2KEncoder> encoder);
+ static void call_servers_list_changed (std::weak_ptr<J2KEncoder> encoder);
void frame_done ();
void terminate_threads ();
/** Film that we are encoding */
- boost::shared_ptr<const Film> _film;
+ std::shared_ptr<const Film> _film;
EventHistory _history;
boost::mutex _threads_mutex;
- boost::shared_ptr<boost::thread_group> _threads;
+ std::shared_ptr<boost::thread_group> _threads;
mutable boost::mutex _queue_mutex;
- std::list<boost::shared_ptr<DCPVideo> > _queue;
+ std::list<std::shared_ptr<DCPVideo> > _queue;
/** condition to manage thread wakeups when we have nothing to do */
boost::condition _empty_condition;
/** condition to manage thread wakeups when we have too much to do */
boost::condition _full_condition;
- boost::shared_ptr<Writer> _writer;
+ std::shared_ptr<Writer> _writer;
Waker _waker;
-
boost::shared_ptr<PlayerVideo> _last_player_video[EYES_COUNT];
+
std::shared_ptr<PlayerVideo> _last_player_video[EYES_COUNT];
boost::optional<dcpomatic::DCPTime> _last_player_video_time;
boost::signals2::scoped_connection _server_found_connection;
using std::max;
using std::pair;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using dcp::ArrayData;
using dcp::raw_convert;
J2KImageProxy (boost::filesystem::path path, dcp::Size, AVPixelFormat pixel_format);
J2KImageProxy (
- boost::shared_ptr<const dcp::MonoPictureFrame> frame,
+ std::shared_ptr<const dcp::MonoPictureFrame> frame,
dcp::Size,
AVPixelFormat pixel_format,
boost::optional<int> forced_reduction
);
J2KImageProxy (
- boost::shared_ptr<const dcp::StereoPictureFrame> frame,
+ std::shared_ptr<const dcp::StereoPictureFrame> frame,
dcp::Size,
dcp::Eye,
AVPixelFormat pixel_format,
boost::optional<int> forced_reduction
);
- J2KImageProxy (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket);
+ J2KImageProxy (std::shared_ptr<cxml::Node> xml, std::shared_ptr<Socket> socket);
Result image (
boost::optional<dcp::Size> size = boost::optional<dcp::Size> ()
) const;
void add_metadata (xmlpp::Node *) const;
- void write_to_socket (boost::shared_ptr<Socket>) const;
+ void write_to_socket (std::shared_ptr<Socket>) const;
/** @return true if our image is definitely the same as another, false if it is probably not */
- bool same (boost::shared_ptr<const ImageProxy>) const;
+ bool same (std::shared_ptr<const ImageProxy>) const;
int prepare (boost::optional<dcp::Size> = boost::optional<dcp::Size>()) const;
- boost::shared_ptr<const dcp::Data> j2k () const {
+ std::shared_ptr<const dcp::Data> j2k () const {
return _data;
}
/* For tests */
J2KImageProxy (dcp::ArrayData data, dcp::Size size, AVPixelFormat pixel_format);
- boost::shared_ptr<const dcp::Data> _data;
+ std::shared_ptr<const dcp::Data> _data;
dcp::Size _size;
boost::optional<dcp::Eye> _eye;
- mutable boost::shared_ptr<Image> _image;
+ mutable std::shared_ptr<Image> _image;
mutable boost::optional<dcp::Size> _target_size;
mutable boost::optional<int> _reduce;
AVPixelFormat _pixel_format;
using std::string;
using std::list;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::function;
using namespace dcpomatic;
#include "signaller.h"
#include <boost/thread/mutex.hpp>
-#include <boost/enable_shared_from_this.hpp>
#include <boost/signals2.hpp>
#include <boost/thread.hpp>
#include <string>
/** @class Job
* @brief A parent class to represent long-running tasks which are run in their own thread.
*/
-class Job : public boost::enable_shared_from_this<Job>, public Signaller, public boost::noncopyable
+class Job : public std::enable_shared_from_this<Job>, public Signaller, public boost::noncopyable
{
public:
- explicit Job (boost::shared_ptr<const Film> film);
+ explicit Job (std::shared_ptr<const Film> film);
virtual ~Job ();
/** @return user-readable name of this job */
void sub (std::string);
boost::optional<float> progress () const;
- boost::shared_ptr<const Film> film () const {
+ std::shared_ptr<const Film> film () const {
return _film;
}
void check_for_interruption_or_pause ();
void stop_thread ();
- boost::shared_ptr<const Film> _film;
+ std::shared_ptr<const Film> _film;
private:
using std::string;
using std::list;
using std::cout;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::function;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using boost::optional;
using boost::bind;
class JobManager : public Signaller, public boost::noncopyable
{
public:
- boost::shared_ptr<Job> add (boost::shared_ptr<Job>);
- boost::shared_ptr<Job> add_after (boost::shared_ptr<Job> after, boost::shared_ptr<Job> j);
- std::list<boost::shared_ptr<Job> > get () const;
+ std::shared_ptr<Job> add (std::shared_ptr<Job>);
+ std::shared_ptr<Job> add_after (std::shared_ptr<Job> after, std::shared_ptr<Job> j);
+ std::list<std::shared_ptr<Job> > get () const;
bool work_to_do () const;
bool errors () const;
- void increase_priority (boost::shared_ptr<Job>);
- void decrease_priority (boost::shared_ptr<Job>);
+ void increase_priority (std::shared_ptr<Job>);
+ void decrease_priority (std::shared_ptr<Job>);
void pause ();
void resume ();
bool paused () const {
}
void analyse_audio (
- boost::shared_ptr<const Film> film,
- boost::shared_ptr<const Playlist> playlist,
+ std::shared_ptr<const Film> film,
+ std::shared_ptr<const Playlist> playlist,
bool from_zero,
boost::signals2::connection& connection,
boost::function<void()> ready
);
void analyse_subtitles (
- boost::shared_ptr<const Film> film,
- boost::shared_ptr<Content> content,
+ std::shared_ptr<const Film> film,
+ std::shared_ptr<Content> content,
boost::signals2::connection& connection,
boost::function<void()> ready
);
- boost::signals2::signal<void (boost::weak_ptr<Job>)> JobAdded;
+ boost::signals2::signal<void (std::weak_ptr<Job>)> JobAdded;
boost::signals2::signal<void ()> JobsReordered;
boost::signals2::signal<void (boost::optional<std::string>, boost::optional<std::string>)> ActiveJobsChanged;
mutable boost::mutex _mutex;
boost::condition _empty_condition;
/** List of jobs in the order that they will be executed */
- std::list<boost::shared_ptr<Job> > _jobs;
+ std::list<std::shared_ptr<Job> > _jobs;
std::list<boost::signals2::connection> _connections;
bool _terminate;
bool _paused;
- boost::shared_ptr<Job> _paused_job;
+ std::shared_ptr<Job> _paused_job;
boost::optional<std::string> _last_active_job;
boost::thread _scheduler;
using std::map;
using std::list;
using boost::thread;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::asio::ip::tcp;
using dcp::raw_convert;
private:
void run (int port);
- void handle (boost::shared_ptr<boost::asio::ip::tcp::socket> socket);
- void request (std::string url, boost::shared_ptr<boost::asio::ip::tcp::socket> socket);
+ void handle (std::shared_ptr<boost::asio::ip::tcp::socket> socket);
+ void request (std::string url, std::shared_ptr<boost::asio::ip::tcp::socket> socket);
};
using std::string;
using std::cout;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::function;
#include <dcp/encrypted_kdm.h>
#include <dcp/name_format.h>
-#include <boost/shared_ptr.hpp>
class Cinema;
};
-typedef boost::shared_ptr<KDMWithMetadata> KDMWithMetadataPtr;
+typedef std::shared_ptr<KDMWithMetadata> KDMWithMetadataPtr;
int write_files (
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
Log::Log ()
: _types (0)
Log ();
virtual ~Log () {}
- void log (boost::shared_ptr<const LogEntry> entry);
+ void log (std::shared_ptr<const LogEntry> entry);
void log (std::string message, int type);
void dcp_log (dcp::NoteType type, std::string message);
mutable boost::mutex _mutex;
private:
- virtual void do_log (boost::shared_ptr<const LogEntry> entry) = 0;
+ virtual void do_log (std::shared_ptr<const LogEntry> entry) = 0;
/** bit-field of log types which should be put into the log (others are ignored) */
int _types;
using std::string;
using std::min;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
string
MidSideDecoder::name () const
std::string name () const;
std::string id () const;
int out_channels () const;
-
boost::shared_ptr<AudioProcessor> clone (int) const;
- boost::shared_ptr<AudioBuffers> run (boost::shared_ptr<const AudioBuffers>, int channels);
+
std::shared_ptr<AudioProcessor> clone (int) const;
+ std::shared_ptr<AudioBuffers> run (std::shared_ptr<const AudioBuffers>, int channels);
void make_audio_mapping_default (AudioMapping& mapping) const;
std::vector<NamedChannel> input_names () const;
};
class NullLog : public Log
{
private:
- void do_log (boost::shared_ptr<const LogEntry>) {}
+ void do_log (std::shared_ptr<const LogEntry>) {}
};
#include "content.h"
#include <boost/foreach.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
using namespace dcpomatic;
* ContentList
*/
ContentList overlaps (
- boost::shared_ptr<const Film> film, ContentList cl, boost::function<bool (boost::shared_ptr<const Content>)> part, dcpomatic::DCPTime from, dcpomatic::DCPTime to
+ std::shared_ptr<const Film> film, ContentList cl, boost::function<bool (std::shared_ptr<const Content>)> part, dcpomatic::DCPTime from, dcpomatic::DCPTime to
);
class Piece
{
public:
- Piece (boost::shared_ptr<Content> c, boost::shared_ptr<Decoder> d, FrameRateChange f)
+ Piece (std::shared_ptr<Content> c, std::shared_ptr<Decoder> d, FrameRateChange f)
: content (c)
, decoder (d)
, frc (f)
, done (false)
{}
- boost::shared_ptr<Content> content;
- boost::shared_ptr<Decoder> decoder;
+ std::shared_ptr<Content> content;
+ std::shared_ptr<Decoder> decoder;
FrameRateChange frc;
bool done;
};
using std::map;
using std::make_pair;
using std::copy;
-using boost::shared_ptr;
-using boost::weak_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::weak_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
using boost::scoped_ptr;
#if BOOST_VERSION >= 106100
PART_WHOLE,
PresetColourConversion::all().front().conversion,
VIDEO_RANGE_FULL,
- boost::weak_ptr<Content>(),
+ std::weak_ptr<Content>(),
boost::optional<Frame>(),
false
)
#include "audio_stream.h"
#include "audio_merger.h"
#include "empty.h"
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
#include <boost/atomic.hpp>
#include <list>
/** @class Player
* @brief A class which can play a Playlist.
*/
-class Player : public
boost::enable_shared_from_this<Player>, public boost::noncopyable
+class Player : public
std::enable_shared_from_this<Player>, public boost::noncopyable
{
public:
- Player (boost::shared_ptr<const Film>);
- Player (boost::shared_ptr<const Film>, boost::shared_ptr<const Playlist> playlist);
+ Player (std::shared_ptr<const Film>);
+ Player (std::shared_ptr<const Film>, std::shared_ptr<const Playlist> playlist);
~Player ();
bool pass ();
void set_play_referenced ();
void set_dcp_decode_reduction (boost::optional<int> reduction);
- boost::optional<dcpomatic::DCPTime> content_time_to_dcp (boost::shared_ptr<Content> content, dcpomatic::ContentTime t);
+ boost::optional<dcpomatic::DCPTime> content_time_to_dcp (std::shared_ptr<Content> content, dcpomatic::ContentTime t);
boost::signals2::signal<void (ChangeType, int, bool)> Change;
/** Emitted when a video frame is ready. These emissions happen in the correct order. */
- boost::signals2::signal<void (
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime)> Video;
- boost::signals2::signal<void (
boost::shared_ptr<AudioBuffers>, dcpomatic::DCPTime, int)> Audio;
+ boost::signals2::signal<void (
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime)> Video;
+ boost::signals2::signal<void (
std::shared_ptr<AudioBuffers>, dcpomatic::DCPTime, int)> Audio;
/** Emitted when a text is ready. This signal may be emitted considerably
* after the corresponding Video.
*/
boost::signals2::signal<void (PlayerText, TextType, boost::optional<DCPTextTrack>, dcpomatic::DCPTimePeriod)> Text;
- boost::signals2::signal<void (boost::shared_ptr<const dcp::AtmosFrame>, dcpomatic::DCPTime, AtmosMetadata)> Atmos;
+ boost::signals2::signal<void (std::shared_ptr<const dcp::AtmosFrame>, dcpomatic::DCPTime, AtmosMetadata)> Atmos;
private:
friend class PlayerWrapper;
void film_change (ChangeType, Film::Property);
void playlist_change (ChangeType);
void playlist_content_change (ChangeType, int, bool);
- Frame dcp_to_content_video (boost::shared_ptr<const Piece> piece, dcpomatic::DCPTime t) const;
- dcpomatic::DCPTime content_video_to_dcp (boost::shared_ptr<const Piece> piece, Frame f) const;
- Frame dcp_to_resampled_audio (boost::shared_ptr<const Piece> piece, dcpomatic::DCPTime t) const;
- dcpomatic::DCPTime resampled_audio_to_dcp (boost::shared_ptr<const Piece> piece, Frame f) const;
- dcpomatic::ContentTime dcp_to_content_time (boost::shared_ptr<const Piece> piece, dcpomatic::DCPTime t) const;
- dcpomatic::DCPTime content_time_to_dcp (boost::shared_ptr<const Piece> piece, dcpomatic::ContentTime t) const;
-
boost::shared_ptr<PlayerVideo> black_player_video_frame (Eyes eyes) const;
-
- void video (
boost::weak_ptr<Piece>, ContentVideo);
- void audio (
boost::weak_ptr<Piece>, AudioStreamPtr, ContentAudio);
- void bitmap_text_start (boost::weak_ptr<Piece>, boost::weak_ptr<const TextContent>, ContentBitmapText);
- void plain_text_start (boost::weak_ptr<Piece>, boost::weak_ptr<const TextContent>, ContentStringText);
- void subtitle_stop (boost::weak_ptr<Piece>, boost::weak_ptr<const TextContent>, dcpomatic::ContentTime);
- void atmos (
boost::weak_ptr<Piece>, ContentAtmos);
+ Frame dcp_to_content_video (std::shared_ptr<const Piece> piece, dcpomatic::DCPTime t) const;
+ dcpomatic::DCPTime content_video_to_dcp (std::shared_ptr<const Piece> piece, Frame f) const;
+ Frame dcp_to_resampled_audio (std::shared_ptr<const Piece> piece, dcpomatic::DCPTime t) const;
+ dcpomatic::DCPTime resampled_audio_to_dcp (std::shared_ptr<const Piece> piece, Frame f) const;
+ dcpomatic::ContentTime dcp_to_content_time (std::shared_ptr<const Piece> piece, dcpomatic::DCPTime t) const;
+ dcpomatic::DCPTime content_time_to_dcp (std::shared_ptr<const Piece> piece, dcpomatic::ContentTime t) const;
+
std::shared_ptr<PlayerVideo> black_player_video_frame (Eyes eyes) const;
+
+ void video (
std::weak_ptr<Piece>, ContentVideo);
+ void audio (
std::weak_ptr<Piece>, AudioStreamPtr, ContentAudio);
+ void bitmap_text_start (std::weak_ptr<Piece>, std::weak_ptr<const TextContent>, ContentBitmapText);
+ void plain_text_start (std::weak_ptr<Piece>, std::weak_ptr<const TextContent>, ContentStringText);
+ void subtitle_stop (std::weak_ptr<Piece>, std::weak_ptr<const TextContent>, dcpomatic::ContentTime);
+ void atmos (
std::weak_ptr<Piece>, ContentAtmos);
dcpomatic::DCPTime one_video_frame () const;
void fill_audio (dcpomatic::DCPTimePeriod period);
- std::pair<
boost::shared_ptr<AudioBuffers>, dcpomatic::DCPTime> discard_audio (
- boost::shared_ptr<const AudioBuffers> audio, dcpomatic::DCPTime time, dcpomatic::DCPTime discard_to
+ std::pair<
std::shared_ptr<AudioBuffers>, dcpomatic::DCPTime> discard_audio (
+ std::shared_ptr<const AudioBuffers> audio, dcpomatic::DCPTime time, dcpomatic::DCPTime discard_to
) const;
boost::optional<PositionImage> open_subtitles_for_frame (dcpomatic::DCPTime time) const;
- void emit_video (
boost::shared_ptr<PlayerVideo> pv, dcpomatic::DCPTime time);
- void do_emit_video (
boost::shared_ptr<PlayerVideo> pv, dcpomatic::DCPTime time);
- void emit_audio (
boost::shared_ptr<AudioBuffers> data, dcpomatic::DCPTime time);
- boost::shared_ptr<const Playlist> playlist () const;
+ void emit_video (
std::shared_ptr<PlayerVideo> pv, dcpomatic::DCPTime time);
+ void do_emit_video (
std::shared_ptr<PlayerVideo> pv, dcpomatic::DCPTime time);
+ void emit_audio (
std::shared_ptr<AudioBuffers> data, dcpomatic::DCPTime time);
+ std::shared_ptr<const Playlist> playlist () const;
/** Mutex to protect the whole Player state. When it's used for the preview we have
seek() and pass() called from the Butler thread and lots of other stuff called
*/
mutable boost::mutex _mutex;
- boost::shared_ptr<const Film> _film;
+ std::shared_ptr<const Film> _film;
/** Playlist, or 0 if we are using the one from the _film */
- boost::shared_ptr<const Playlist> _playlist;
+ std::shared_ptr<const Playlist> _playlist;
/** > 0 if we are suspended (i.e. pass() and seek() do nothing) */
boost::atomic<int> _suspended;
- std::list<
boost::shared_ptr<Piece> > _pieces;
+ std::list<
std::shared_ptr<Piece> > _pieces;
/** Size of the image we are rendering to; this may be the DCP frame size, or
* the size of preview in a window.
*/
dcp::Size _video_container_size;
- boost::shared_ptr<Image> _black_image;
+ std::shared_ptr<Image> _black_image;
/** true if the player should ignore all video; i.e. never produce any */
bool _ignore_video;
boost::optional<int> _dcp_decode_reduction;
- typedef std::map<boost::weak_ptr<Piece>, boost::shared_ptr<PlayerVideo> > LastVideoMap;
+ typedef std::map<std::weak_ptr<Piece>, std::shared_ptr<PlayerVideo>, std::owner_less<std::weak_ptr<Piece>>> LastVideoMap;
LastVideoMap _last_video;
AudioMerger _audio_merger;
Shuffler* _shuffler;
- std::list<std::pair<
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> > _delay;
+ std::list<std::pair<
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> > _delay;
class StreamState
{
public:
StreamState () {}
- StreamState (
boost::shared_ptr<Piece> p, dcpomatic::DCPTime l)
+ StreamState (
std::shared_ptr<Piece> p, dcpomatic::DCPTime l)
: piece(p)
, last_push_end(l)
{}
-
boost::shared_ptr<Piece> piece;
+
std::shared_ptr<Piece> piece;
dcpomatic::DCPTime last_push_end;
};
std::map<AudioStreamPtr, StreamState> _stream_states;
Empty _silent;
ActiveText _active_texts[TEXT_COUNT];
-
boost::shared_ptr<AudioProcessor> _audio_processor;
+
std::shared_ptr<AudioProcessor> _audio_processor;
dcpomatic::DCPTime _playback_length;
#include <boost/foreach.hpp>
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
void
class PlayerText
{
public:
- void add_fonts (std::list<boost::shared_ptr<dcpomatic::Font> > fonts_);
- std::list<boost::shared_ptr<dcpomatic::Font> > fonts;
+ void add_fonts (std::list<std::shared_ptr<dcpomatic::Font> > fonts_);
+ std::list<std::shared_ptr<dcpomatic::Font> > fonts;
/** BitmapTexts, with their rectangles transformed as specified by their content */
std::list<BitmapText> bitmap;
projects / dcpomatic.git / commitdiff