*/
+
#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;
using std::string;
using std::cout;
using std::pair;
-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::function;
using dcp::Data;
extern "C" {
#include <libavutil/pixfmt.h>
}
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/noncopyable.hpp>
{
public:
PlayerVideo (
- boost::shared_ptr<const ImageProxy>,
+ std::shared_ptr<const ImageProxy>,
Crop,
boost::optional<double>,
dcp::Size,
Part,
boost::optional<ColourConversion>,
VideoRange video_range,
- boost::weak_ptr<Content>,
+ std::weak_ptr<Content>,
boost::optional<Frame>,
bool error
);
- PlayerVideo (boost::shared_ptr<cxml::Node>, boost::shared_ptr<Socket>);
+ PlayerVideo (std::shared_ptr<cxml::Node>, std::shared_ptr<Socket>);
-
boost::shared_ptr<PlayerVideo> shallow_copy () const;
+
std::shared_ptr<PlayerVideo> shallow_copy () const;
void set_text (PositionImage);
void prepare (boost::function<AVPixelFormat (AVPixelFormat)> pixel_format, VideoRange video_range, bool aligned, bool fast);
-
boost::shared_ptr<Image> image (boost::function<AVPixelFormat (AVPixelFormat)> pixel_format, VideoRange video_range, bool aligned, bool fast) const;
+
std::shared_ptr<Image> image (boost::function<AVPixelFormat (AVPixelFormat)> pixel_format, VideoRange video_range, bool aligned, bool fast) const;
static AVPixelFormat force (AVPixelFormat, AVPixelFormat);
static AVPixelFormat keep_xyz_or_rgb (AVPixelFormat);
void add_metadata (xmlpp::Node* node) const;
- void write_to_socket (boost::shared_ptr<Socket> socket) const;
+ void write_to_socket (std::shared_ptr<Socket> socket) const;
- bool reset_metadata (boost::shared_ptr<const Film> film, dcp::Size player_video_container_size);
+ bool reset_metadata (std::shared_ptr<const Film> film, dcp::Size player_video_container_size);
bool has_j2k () const;
- boost::shared_ptr<const dcp::Data> j2k () const;
+ std::shared_ptr<const dcp::Data> j2k () const;
Eyes eyes () const {
return _eyes;
return _inter_size;
}
- bool same (boost::shared_ptr<const PlayerVideo> other) const;
+ bool same (std::shared_ptr<const PlayerVideo> other) const;
size_t memory_used () const;
- boost::weak_ptr<Content> content () const {
+ std::weak_ptr<Content> content () const {
return _content;
}
private:
void make_image (boost::function<AVPixelFormat (AVPixelFormat)> pixel_format, VideoRange video_range, bool aligned, bool fast) const;
- boost::shared_ptr<const ImageProxy> _in;
+ std::shared_ptr<const ImageProxy> _in;
Crop _crop;
boost::optional<double> _fade;
dcp::Size _inter_size;
VideoRange _video_range;
boost::optional<PositionImage> _text;
/** Content that we came from. This is so that reset_metadata() can work. */
- boost::weak_ptr<Content> _content;
+ std::weak_ptr<Content> _content;
/** Video frame that we came from. Again, this is for reset_metadata() */
boost::optional<Frame> _video_frame;
mutable boost::mutex _mutex;
- mutable boost::shared_ptr<Image> _image;
+ mutable std::shared_ptr<Image> _image;
/** _crop that was used to make _image */
mutable Crop _image_crop;
/** _inter_size that was used to make _image */
#include <libcxml/cxml.h>
#include <libxml++/libxml++.h>
#include <boost/bind/placeholders.hpp>
-#include <boost/shared_ptr.hpp>
#include <boost/foreach.hpp>
#include <iostream>
using std::string;
using std::pair;
using boost::optional;
-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 namespace dcpomatic;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#include "util.h"
#include "frame_rate_change.h"
#include <libcxml/cxml.h>
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
#include <boost/thread.hpp>
#include <list>
struct ContentSorter
{
- bool operator() (boost::shared_ptr<Content> a, boost::shared_ptr<Content> b);
+ bool operator() (std::shared_ptr<Content> a, std::shared_ptr<Content> b);
};
/** @class Playlist
~Playlist ();
void as_xml (xmlpp::Node *, bool with_content_paths);
- void set_from_xml (boost::shared_ptr<const Film> film, cxml::ConstNodePtr node, int version, std::list<std::string>& notes);
+ void set_from_xml (std::shared_ptr<const Film> film, cxml::ConstNodePtr node, int version, std::list<std::string>& notes);
- void add (boost::shared_ptr<const Film> film, boost::shared_ptr<Content>);
- void remove (boost::shared_ptr<Content>);
+ void add (std::shared_ptr<const Film> film, std::shared_ptr<Content>);
+ void remove (std::shared_ptr<Content>);
void remove (ContentList);
- void move_earlier (boost::shared_ptr<const Film> film, boost::shared_ptr<Content>);
- void move_later (boost::shared_ptr<const Film> film, boost::shared_ptr<Content>);
+ void move_earlier (std::shared_ptr<const Film> film, std::shared_ptr<Content>);
+ void move_later (std::shared_ptr<const Film> film, std::shared_ptr<Content>);
ContentList content () const;
std::string video_identifier () const;
- dcpomatic::DCPTime length (boost::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime length (std::shared_ptr<const Film> film) const;
boost::optional<dcpomatic::DCPTime> start () const;
- int64_t required_disk_space (boost::shared_ptr<const Film> film, int j2k_bandwidth, int audio_channels, int audio_frame_rate) const;
+ int64_t required_disk_space (std::shared_ptr<const Film> film, int j2k_bandwidth, int audio_channels, int audio_frame_rate) const;
int best_video_frame_rate () const;
- dcpomatic::DCPTime video_end (boost::shared_ptr<const Film> film) const;
- dcpomatic::DCPTime text_end (boost::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime video_end (std::shared_ptr<const Film> film) const;
+ dcpomatic::DCPTime text_end (std::shared_ptr<const Film> film) const;
FrameRateChange active_frame_rate_change (dcpomatic::DCPTime, int dcp_frame_rate) const;
- std::string content_summary (boost::shared_ptr<const Film> film, dcpomatic::DCPTimePeriod period) const;
+ std::string content_summary (std::shared_ptr<const Film> film, dcpomatic::DCPTimePeriod period) const;
std::pair<double, double> speed_up_range (int dcp_video_frame_rate) const;
void set_sequence (bool);
- void maybe_sequence (boost::shared_ptr<const Film> film);
+ void maybe_sequence (std::shared_ptr<const Film> film);
- void repeat (boost::shared_ptr<const Film> film, ContentList, int);
+ void repeat (std::shared_ptr<const Film> film, ContentList, int);
/** Emitted when content has been added to or removed from the playlist; implies OrderChanged */
mutable boost::signals2::signal<void (ChangeType)> Change;
/** Emitted when the length might have changed; may sometimes be emitted when it has not */
mutable boost::signals2::signal<void ()> LengthChange;
- 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;
private:
- void content_change (boost::weak_ptr<const Film>, ChangeType, boost::weak_ptr<Content>, int, bool);
+ void content_change (std::weak_ptr<const Film>, ChangeType, std::weak_ptr<Content>, int, bool);
void disconnect ();
- void reconnect (boost::shared_ptr<const Film> film);
+ void reconnect (std::shared_ptr<const Film> film);
mutable boost::mutex _mutex;
/** List of content. Kept sorted in position order. */
#ifndef DCPOMATIC_POSITION_IMAGE_H
#define DCPOMATIC_POSITION_IMAGE_H
+
#include "position.h"
-#include <boost/shared_ptr.hpp>
+#include <memory>
+
class Image;
public:
PositionImage () {}
- PositionImage (boost::shared_ptr<Image> i, Position<int> p)
+ PositionImage (std::shared_ptr<Image> i, Position<int> p)
: image (i)
, position (p)
{}
- boost::shared_ptr<Image> image;
+ std::shared_ptr<Image> image;
Position<int> position;
bool same (PositionImage const & other) const;
using std::string;
using std::pair;
using std::make_pair;
-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;
class RawImageProxy : public ImageProxy
{
public:
- explicit RawImageProxy (boost::shared_ptr<Image>);
- RawImageProxy (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket);
+ explicit RawImageProxy (std::shared_ptr<Image>);
+ RawImageProxy (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>) const;
+ void write_to_socket (std::shared_ptr<Socket>) const;
+ bool same (std::shared_ptr<const ImageProxy>) const;
size_t memory_used () const;
private:
- boost::shared_ptr<Image> _image;
+ std::shared_ptr<Image> _image;
};
#endif
using std::map;
using std::set;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
-using boost::weak_ptr;
+using std::weak_ptr;
using dcp::ArrayData;
using dcp::Data;
using dcp::raw_convert;
#include "weak_film.h"
#include <dcp/picture_asset_writer.h>
#include <dcp/atmos_asset_writer.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
namespace dcpomatic {
class FontData;
{
public:
ReelWriter (
- boost::weak_ptr<const Film> film,
+ std::weak_ptr<const Film> film,
dcpomatic::DCPTimePeriod period,
- boost::shared_ptr<Job> job,
+ std::shared_ptr<Job> job,
int reel_index,
int reel_count,
bool text_only
);
- void write (boost::shared_ptr<const dcp::Data> encoded, Frame frame, Eyes eyes);
+ void write (std::shared_ptr<const dcp::Data> encoded, Frame frame, Eyes eyes);
void fake_write (int size);
void repeat_write (Frame frame, Eyes eyes);
- void write (boost::shared_ptr<const AudioBuffers> audio);
+ void write (std::shared_ptr<const AudioBuffers> audio);
void write (PlayerText text, TextType type, boost::optional<DCPTextTrack> track, dcpomatic::DCPTimePeriod period);
- void write (boost::shared_ptr<const dcp::AtmosFrame> atmos, AtmosMetadata metadata);
+ void write (std::shared_ptr<const dcp::AtmosFrame> atmos, AtmosMetadata metadata);
void finish (boost::filesystem::path output_dcp);
- boost::shared_ptr<dcp::Reel> create_reel (
+ std::shared_ptr<dcp::Reel> create_reel (
std::list<ReferencedReelAsset> const & refs,
std::vector<dcpomatic::FontData> const & fonts,
boost::filesystem::path output_dcp,
return _first_nonexistant_frame;
}
- dcp::FrameInfo read_frame_info (boost::shared_ptr<InfoFileHandle> info, Frame frame, Eyes eyes) const;
+ dcp::FrameInfo read_frame_info (std::shared_ptr<InfoFileHandle> info, Frame frame, Eyes eyes) const;
private:
void write_frame_info (Frame frame, Eyes eyes, dcp::FrameInfo info) const;
long frame_info_position (Frame frame, Eyes eyes) const;
Frame check_existing_picture_asset (boost::filesystem::path asset);
- bool existing_picture_frame_ok (FILE* asset_file, boost::shared_ptr<InfoFileHandle> info_file, Frame frame) const;
- boost::shared_ptr<dcp::SubtitleAsset> empty_text_asset (TextType type, boost::optional<DCPTextTrack> track) const;
+ bool existing_picture_frame_ok (FILE* asset_file, std::shared_ptr<InfoFileHandle> info_file, Frame frame) const;
+ std::shared_ptr<dcp::SubtitleAsset> empty_text_asset (TextType type, boost::optional<DCPTextTrack> track) const;
- boost::shared_ptr<dcp::ReelPictureAsset> create_reel_picture (boost::shared_ptr<dcp::Reel> reel, std::list<ReferencedReelAsset> const & refs) const;
- void create_reel_sound (boost::shared_ptr<dcp::Reel> reel, std::list<ReferencedReelAsset> const & refs) const;
+ std::shared_ptr<dcp::ReelPictureAsset> create_reel_picture (std::shared_ptr<dcp::Reel> reel, std::list<ReferencedReelAsset> const & refs) const;
+ void create_reel_sound (std::shared_ptr<dcp::Reel> reel, std::list<ReferencedReelAsset> const & refs) const;
void create_reel_text (
- boost::shared_ptr<dcp::Reel> reel,
+ std::shared_ptr<dcp::Reel> reel,
std::list<ReferencedReelAsset> const & refs,
std::vector<dcpomatic::FontData> const& fonts,
int64_t duration,
bool ensure_subtitles,
std::set<DCPTextTrack> ensure_closed_captions
) const;
- void create_reel_markers (boost::shared_ptr<dcp::Reel> reel) const;
+ void create_reel_markers (std::shared_ptr<dcp::Reel> reel) const;
dcpomatic::DCPTimePeriod _period;
/** the first picture frame index that does not already exist in our MXF */
int _first_nonexistant_frame;
/** the data of the last written frame, if there is one */
- boost::shared_ptr<const dcp::Data> _last_written[EYES_COUNT];
+ std::shared_ptr<const dcp::Data> _last_written[EYES_COUNT];
/** index of this reel within the DCP (starting from 0) */
int _reel_index;
/** number of reels in the DCP */
int _reel_count;
boost::optional<std::string> _content_summary;
- boost::weak_ptr<Job> _job;
+ std::weak_ptr<Job> _job;
bool _text_only;
dcp::ArrayData _default_font;
- boost::shared_ptr<dcp::PictureAsset> _picture_asset;
+ std::shared_ptr<dcp::PictureAsset> _picture_asset;
/** picture asset writer, or 0 if we are not writing any picture because we already have one */
- boost::shared_ptr<dcp::PictureAssetWriter> _picture_asset_writer;
- boost::shared_ptr<dcp::SoundAsset> _sound_asset;
- boost::shared_ptr<dcp::SoundAssetWriter> _sound_asset_writer;
- boost::shared_ptr<dcp::SubtitleAsset> _subtitle_asset;
- std::map<DCPTextTrack, boost::shared_ptr<dcp::SubtitleAsset> > _closed_caption_assets;
- boost::shared_ptr<dcp::AtmosAsset> _atmos_asset;
- boost::shared_ptr<dcp::AtmosAssetWriter> _atmos_asset_writer;
+ std::shared_ptr<dcp::PictureAssetWriter> _picture_asset_writer;
+ std::shared_ptr<dcp::SoundAsset> _sound_asset;
+ std::shared_ptr<dcp::SoundAssetWriter> _sound_asset_writer;
+ std::shared_ptr<dcp::SubtitleAsset> _subtitle_asset;
+ std::map<DCPTextTrack, std::shared_ptr<dcp::SubtitleAsset> > _closed_caption_assets;
+ std::shared_ptr<dcp::AtmosAsset> _atmos_asset;
+ std::shared_ptr<dcp::AtmosAssetWriter> _atmos_asset_writer;
static int const _info_size;
};
class ReferencedReelAsset
{
public:
- ReferencedReelAsset (boost::shared_ptr<dcp::ReelAsset> asset_, dcpomatic::DCPTimePeriod period_)
+ ReferencedReelAsset (std::shared_ptr<dcp::ReelAsset> asset_, dcpomatic::DCPTimePeriod period_)
: asset (asset_)
, period (period_)
{}
/** The asset */
- boost::shared_ptr<dcp::ReelAsset> asset;
+ std::shared_ptr<dcp::ReelAsset> asset;
/** Period that this asset covers in the DCP */
dcpomatic::DCPTimePeriod period;
};
using std::pair;
using std::cerr;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::algorithm::replace_all;
using namespace dcpomatic;
std::string marked_up (std::list<StringText> subtitles, int target_height, float fade_factor);
std::list<PositionImage> render_text (
- std::list<StringText>, std::list<boost::shared_ptr<dcpomatic::Font> > fonts, dcp::Size, dcpomatic::DCPTime, int
+ std::list<StringText>, std::list<std::shared_ptr<dcpomatic::Font> > fonts, dcp::Size, dcpomatic::DCPTime, int
);
using std::pair;
using std::make_pair;
using std::runtime_error;
-using boost::shared_ptr;
+using std::shared_ptr;
/** @param in Input sampling rate (Hz)
* @param out Output sampling rate (Hz)
#include "types.h"
#include <samplerate.h>
-#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
class AudioBuffers;
Resampler (int, int, int);
~Resampler ();
- boost::shared_ptr<const AudioBuffers> run (boost::shared_ptr<const AudioBuffers>);
- boost::shared_ptr<const AudioBuffers> flush ();
+ std::shared_ptr<const AudioBuffers> run (std::shared_ptr<const AudioBuffers>);
+ std::shared_ptr<const AudioBuffers> flush ();
void reset ();
void set_fast ();
using std::string;
using std::min;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
SCPUploader::SCPUploader (function<void (string)> set_status, function<void (float)> set_progress)
using std::string;
using std::vector;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
void as_xml (xmlpp::Element *) const;
std::vector<std::string> trusted_device_thumbprints () const;
- boost::shared_ptr<Cinema> cinema;
+ std::shared_ptr<Cinema> cinema;
std::vector<TrustedDevice> trusted_devices;
};
KDMWithMetadataPtr
kdm_for_screen (
- boost::shared_ptr<const Film> film,
+ std::shared_ptr<const Film> film,
boost::filesystem::path cpl,
- boost::shared_ptr<const dcpomatic::Screen> screen,
+ std::shared_ptr<const dcpomatic::Screen> screen,
boost::posix_time::ptime valid_from,
boost::posix_time::ptime valid_to,
dcp::Formulation formulation,
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
SendKDMEmailJob::SendKDMEmailJob (
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
/** @param body Email body */
SendNotificationEmailJob::SendNotificationEmailJob (string body)
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
/** @param film Film thta the problem is with, or 0.
* @param from Email address to use for From:
{
public:
SendProblemReportJob (
- boost::shared_ptr<const Film> film,
+ std::shared_ptr<const Film> film,
std::string from,
std::string summary
);
#include "i18n.h"
-using boost::shared_ptr;
+using std::shared_ptr;
Server::Server (int port, int timeout)
: _terminate (false)
bool _terminate;
private:
- virtual void handle (boost::shared_ptr<Socket> socket) = 0;
+ virtual void handle (std::shared_ptr<Socket> socket) = 0;
void start_accept ();
- void handle_accept (boost::shared_ptr<Socket>, boost::system::error_code const &);
+ void handle_accept (std::shared_ptr<Socket>, boost::system::error_code const &);
boost::asio::io_service _io_service;
boost::asio::ip::tcp::acceptor _acceptor;
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::optional;
int const Shuffler::_max_size = 64;
public:
void clear ();
void flush ();
- void video (
boost::weak_ptr<Piece>, ContentVideo video);
+ void video (
std::weak_ptr<Piece>, ContentVideo video);
- boost::signals2::signal<void (
boost::weak_ptr<Piece>, ContentVideo)> Video;
+ boost::signals2::signal<void (
std::weak_ptr<Piece>, ContentVideo)> Video;
- typedef std::pair<
boost::weak_ptr<Piece>, ContentVideo> Store;
+ typedef std::pair<
std::weak_ptr<Piece>, ContentVideo> Store;
private:
friend struct ::shuffler_test5;
using std::cout;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::raw_convert;
void
#include <libxml++/libxml++.h>
DCPOMATIC_ENABLE_WARNINGS
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
SPLEntry::SPLEntry (shared_ptr<Content> content)
{
#include <libcxml/cxml.h>
#include <dcp/types.h>
-#include <boost/shared_ptr.hpp>
namespace xmlpp {
class Element;
class SPLEntry
{
public:
- SPLEntry (boost::shared_ptr<Content> content);
+ SPLEntry (std::shared_ptr<Content> content);
void as_xml (xmlpp::Element* e);
- boost::shared_ptr<Content> content;
+ std::shared_ptr<Content> content;
std::string name;
/** Digest of this content */
std::string digest;
bool encrypted;
private:
- void construct (boost::shared_ptr<Content> content);
+ void construct (std::shared_ptr<Content> content);
};
#endif
using std::cout;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
StdoutLog::StdoutLog ()
{
explicit StdoutLog (int types);
private:
- void do_log (boost::shared_ptr<const LogEntry> entry);
+ void do_log (std::shared_ptr<const LogEntry> entry);
};
using std::vector;
using std::cout;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::scoped_array;
using boost::optional;
using dcp::ArrayData;
#include "dcpomatic_time.h"
#include <sub/subtitle.h>
-#include <boost/shared_ptr.hpp>
#include <vector>
class StringTextFileContent;
class StringTextFile
{
public:
- explicit StringTextFile (boost::shared_ptr<const StringTextFileContent>);
+ explicit StringTextFile (std::shared_ptr<const StringTextFileContent>);
boost::optional<dcpomatic::ContentTime> first () const;
dcpomatic::ContentTime length () const;
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using dcp::raw_convert;
using namespace dcpomatic;
StringTextFileContent (boost::filesystem::path);
StringTextFileContent (cxml::ConstNodePtr, int);
- boost::shared_ptr<StringTextFileContent> shared_from_this () {
- return boost::dynamic_pointer_cast<StringTextFileContent> (Content::shared_from_this ());
+ std::shared_ptr<StringTextFileContent> shared_from_this () {
+ return std::dynamic_pointer_cast<StringTextFileContent> (Content::shared_from_this ());
}
- boost::shared_ptr<const StringTextFileContent> shared_from_this () const {
- return boost::dynamic_pointer_cast<const StringTextFileContent> (Content::shared_from_this ());
+ std::shared_ptr<const StringTextFileContent> shared_from_this () const {
+ return std::dynamic_pointer_cast<const StringTextFileContent> (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;
using std::string;
using std::cout;
using std::max;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using namespace dcpomatic;
StringTextFileDecoder::StringTextFileDecoder (shared_ptr<const Film> film, shared_ptr<const StringTextFileContent> content)
class StringTextFileDecoder : public Decoder, public StringTextFile
{
public:
- StringTextFileDecoder (boost::shared_ptr<const Film> film, boost::shared_ptr<const StringTextFileContent>);
+ StringTextFileDecoder (std::shared_ptr<const Film> film, std::shared_ptr<const StringTextFileContent>);
void seek (dcpomatic::ContentTime time, bool accurate);
bool pass ();
using std::string;
using dcp::raw_convert;
-using boost::shared_ptr;
+using std::shared_ptr;
int const SubtitleAnalysis::_current_state_version = 1;
#include <dcp/interop_subtitle_asset.h>
#include <dcp/raw_convert.h>
#include <dcp/smpte_subtitle_asset.h>
-#include <boost/shared_ptr.hpp>
#include <boost/filesystem.hpp>
#include <boost/bind/bind.hpp>
using std::make_pair;
using std::pair;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#include "dcp_text_track.h"
#include "encoder.h"
#include "dcpomatic_time.h"
-#include <boost/weak_ptr.hpp>
namespace dcp {
class SubtitleAsset;
class SubtitleEncoder : public Encoder
{
public:
- SubtitleEncoder (boost::shared_ptr<const Film> film, boost::shared_ptr<Job> job, boost::filesystem::path output, std::string intial_name, bool split_reels, bool include_font);
+ SubtitleEncoder (std::shared_ptr<const Film> film, std::shared_ptr<Job> job, boost::filesystem::path output, std::string intial_name, bool split_reels, bool include_font);
void go ();
private:
void text (PlayerText subs, TextType type, boost::optional<DCPTextTrack> track, dcpomatic::DCPTimePeriod period);
- std::vector<std::pair<boost::shared_ptr<dcp::SubtitleAsset>, boost::filesystem::path> > _assets;
+ std::vector<std::pair<std::shared_ptr<dcp::SubtitleAsset>, boost::filesystem::path> > _assets;
std::vector<dcpomatic::DCPTimePeriod> _reels;
bool _split_reels;
bool _include_font;
using std::vector;
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::optional;
using dcp::raw_convert;
using namespace dcpomatic;
{
public:
TextContent (Content* parent, TextType type, TextType original_type);
- TextContent (Content* parent, std::vector<boost::shared_ptr<Content> >);
+ TextContent (Content* parent, std::vector<std::shared_ptr<Content> >);
void as_xml (xmlpp::Node *) const;
std::string identifier () const;
- void take_settings_from (boost::shared_ptr<const TextContent> c);
+ void take_settings_from (std::shared_ptr<const TextContent> c);
- void add_font (boost::shared_ptr<dcpomatic::Font> font);
+ void add_font (std::shared_ptr<dcpomatic::Font> font);
void set_use (bool);
void set_burn (bool);
return _y_scale;
}
- std::list<boost::shared_ptr<dcpomatic::Font> > fonts () const {
+ std::list<std::shared_ptr<dcpomatic::Font> > fonts () const {
boost::mutex::scoped_lock lm (_mutex);
return _fonts;
}
return _dcp_track;
}
- static std::list<boost::shared_ptr<TextContent> > from_xml (Content* parent, cxml::ConstNodePtr, int version);
+ static std::list<std::shared_ptr<TextContent> > from_xml (Content* parent, cxml::ConstNodePtr, int version);
private:
friend struct ffmpeg_pts_offset_test;
double _x_scale;
/** y scale factor to apply to subtitles */
double _y_scale;
- std::list<boost::shared_ptr<dcpomatic::Font> > _fonts;
+ std::list<std::shared_ptr<dcpomatic::Font> > _fonts;
boost::optional<dcp::Colour> _colour;
boost::optional<dcp::Effect> _effect;
boost::optional<dcp::Colour> _effect_colour;
#include "log.h"
#include "compose.hpp"
#include <sub/subtitle.h>
-#include <boost/shared_ptr.hpp>
#include <boost/foreach.hpp>
#include <boost/algorithm/string.hpp>
#include <iostream>
using std::string;
using std::min;
using std::max;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::function;
using namespace dcpomatic;
public:
TextDecoder (
Decoder* parent,
- boost::shared_ptr<const TextContent>,
+ std::shared_ptr<const TextContent>,
dcpomatic::ContentTime first
);
- 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 emit_bitmap_start (dcpomatic::ContentTime from, boost::shared_ptr<Image> image, dcpomatic::Rect<double> rect);
- void emit_bitmap (dcpomatic::ContentTimePeriod period, boost::shared_ptr<Image> image, dcpomatic::Rect<double> rect);
+ void emit_bitmap_start (dcpomatic::ContentTime from, std::shared_ptr<Image> image, dcpomatic::Rect<double> rect);
+ void emit_bitmap (dcpomatic::ContentTimePeriod period, std::shared_ptr<Image> image, dcpomatic::Rect<double> rect);
void emit_plain_start (dcpomatic::ContentTime from, std::list<dcp::SubtitleString> s);
void emit_plain_start (dcpomatic::ContentTime from, sub::Subtitle const & subtitle);
void emit_plain (dcpomatic::ContentTimePeriod period, std::list<dcp::SubtitleString> s);
void seek ();
- boost::shared_ptr<const TextContent> content () const {
+ std::shared_ptr<const TextContent> content () const {
return _content;
}
boost::signals2::signal<void (dcpomatic::ContentTime)> Stop;
private:
- boost::shared_ptr<const TextContent> _content;
+ std::shared_ptr<const TextContent> _content;
boost::optional<dcpomatic::ContentTime> _position;
};
using std::fixed;
using std::setprecision;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
/** @param film Film to use */
TranscodeJob::TranscodeJob (shared_ptr<const Film> film)
*/
#include "job.h"
-#include <boost/shared_ptr.hpp>
class Encoder;
class TranscodeJob : public Job
{
public:
- explicit TranscodeJob (boost::shared_ptr<const Film> film);
+ explicit TranscodeJob (std::shared_ptr<const Film> film);
~TranscodeJob ();
std::string name () const;
void run ();
std::string status () const;
- void set_encoder (boost::shared_ptr<Encoder> t);
+ void set_encoder (std::shared_ptr<Encoder> t);
private:
int remaining_time () const;
- boost::shared_ptr<Encoder> _encoder;
+ std::shared_ptr<Encoder> _encoder;
};
using std::min;
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using dcp::raw_convert;
bool operator== (Crop const & a, Crop const & b)
#include "position.h"
#include "rect.h"
#include <dcp/util.h>
-#include <boost/shared_ptr.hpp>
#include <vector>
#include <stdint.h>
/** Port on which player listens for play requests */
#define PLAYER_PLAY_PORT (Config::instance()->server_port_base()+5)
-typedef std::vector<boost::shared_ptr<Content> > ContentList;
-typedef std::vector<boost::shared_ptr<FFmpegContent> > FFmpegContentList;
+typedef std::vector<std::shared_ptr<Content> > ContentList;
+typedef std::vector<std::shared_ptr<FFmpegContent> > FFmpegContentList;
typedef int64_t Frame;
{
Crop () : left (0), right (0), top (0), bottom (0) {}
Crop (int l, int r, int t, int b) : left (l), right (r), top (t), bottom (b) {}
- explicit Crop (boost::shared_ptr<cxml::Node>);
+ explicit Crop (std::shared_ptr<cxml::Node>);
/** Number of pixels to remove from the left-hand side */
int left;
using std::string;
using std::min;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::scoped_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
class UploadJob : public Job
{
public:
- explicit UploadJob (boost::shared_ptr<const Film>);
+ explicit UploadJob (std::shared_ptr<const Film>);
~UploadJob ();
std::string name () const;
#include "i18n.h"
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
Uploader::Uploader (function<void (string)> set_status, function<void (float)> set_progress)
#ifndef DCPOMATIC_UPLOADER_H
#define DCPOMATIC_UPLOADER_H
-#include <boost/shared_ptr.hpp>
#include <boost/filesystem.hpp>
#include <boost/function.hpp>
using std::string;
using std::min;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
UpmixerA::UpmixerA (int sampling_rate)
: _left (0.02, 1900.0 / sampling_rate, 4800.0 / sampling_rate)
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 flush ();
void make_audio_mapping_default (AudioMapping& mapping) const;
std::vector<NamedChannel> input_names () const;
using std::string;
using std::min;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
UpmixerB::UpmixerB (int sampling_rate)
: _lfe (0.01, 150.0 / sampling_rate)
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 flush ();
void make_audio_mapping_default (AudioMapping& mapping) const;
std::vector<NamedChannel> input_names () const;
using std::bad_alloc;
using std::set_terminate;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::thread;
using boost::optional;
using boost::lexical_cast;
#include <dcp/decrypted_kdm.h>
#include <dcp/util.h>
#include <dcp/subtitle_image.h>
-#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
#include <boost/filesystem.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
extern void* wrapped_av_malloc (size_t);
extern void set_backtrace_file (boost::filesystem::path);
extern std::map<std::string, std::string> split_get_request (std::string url);
-extern std::string video_asset_filename (boost::shared_ptr<dcp::PictureAsset> asset, int reel_index, int reel_count, boost::optional<std::string> content_summary);
-extern std::string audio_asset_filename (boost::shared_ptr<dcp::SoundAsset> asset, int reel_index, int reel_count, boost::optional<std::string> content_summary);
-extern std::string atmos_asset_filename (boost::shared_ptr<dcp::AtmosAsset> asset, int reel_index, int reel_count, boost::optional<std::string> content_summary);
+extern std::string video_asset_filename (std::shared_ptr<dcp::PictureAsset> asset, int reel_index, int reel_count, boost::optional<std::string> content_summary);
+extern std::string audio_asset_filename (std::shared_ptr<dcp::SoundAsset> asset, int reel_index, int reel_count, boost::optional<std::string> content_summary);
+extern std::string atmos_asset_filename (std::shared_ptr<dcp::AtmosAsset> asset, int reel_index, int reel_count, boost::optional<std::string> content_summary);
extern float relaxed_string_to_float (std::string);
extern std::string careful_string_filter (std::string);
extern std::pair<int, int> audio_channel_types (std::list<int> mapped, int channels);
-extern boost::shared_ptr<AudioBuffers> remap (boost::shared_ptr<const AudioBuffers> input, int output_channels, AudioMapping map);
+extern std::shared_ptr<AudioBuffers> remap (std::shared_ptr<const AudioBuffers> input, int output_channels, AudioMapping map);
extern Eyes increment_eyes (Eyes e);
extern void checked_fread (void* ptr, size_t size, FILE* stream, boost::filesystem::path path);
extern void checked_fwrite (void const * ptr, size_t size, FILE* stream, boost::filesystem::path path);
extern size_t utf8_strlen (std::string s);
extern std::string day_of_week_to_string (boost::gregorian::greg_weekday d);
-extern void emit_subtitle_image (dcpomatic::ContentTimePeriod period, dcp::SubtitleImage sub, dcp::Size size, boost::shared_ptr<TextDecoder> decoder);
+extern void emit_subtitle_image (dcpomatic::ContentTimePeriod period, dcp::SubtitleImage sub, dcp::Size size, std::shared_ptr<TextDecoder> decoder);
extern bool show_jobs_on_console (bool progress);
extern void copy_in_bits (boost::filesystem::path from, boost::filesystem::path to, boost::function<void (float)>);
extern dcp::Size scale_for_display (dcp::Size s, dcp::Size display_container, dcp::Size film_container);
using std::string;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#include "job.h"
#include <dcp/verify.h>
-#include <boost/shared_ptr.hpp>
class Content;
using std::setprecision;
using std::list;
using std::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;
using namespace dcpomatic;
#include "types.h"
#include "content_part.h"
#include <boost/thread/mutex.hpp>
-#include <boost/weak_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
class VideoExaminer;
class Ratio;
static int const CUSTOM_SIZE;
};
-class VideoContent : public ContentPart, public boost::enable_shared_from_this<VideoContent>
+class VideoContent : public ContentPart, public std::enable_shared_from_this<VideoContent>
{
public:
explicit VideoContent (Content* parent);
- VideoContent (Content* parent, std::vector<boost::shared_ptr<Content> >);
+ VideoContent (Content* parent, std::vector<std::shared_ptr<Content> >);
void as_xml (xmlpp::Node *) const;
std::string technical_summary () const;
std::string identifier () const;
- void take_settings_from (boost::shared_ptr<const VideoContent> c);
+ void take_settings_from (std::shared_ptr<const VideoContent> c);
Frame length () const {
boost::mutex::scoped_lock lm (_mutex);
dcp::Size size_after_crop () const;
dcp::Size scaled_size (dcp::Size container_size);
- boost::optional<double> fade (boost::shared_ptr<const Film> film, Frame) const;
+ boost::optional<double> fade (std::shared_ptr<const Film> film, Frame) const;
- std::string processing_description (boost::shared_ptr<const Film> film);
+ std::string processing_description (std::shared_ptr<const Film> film);
void set_length (Frame);
- void take_from_examiner (boost::shared_ptr<VideoExaminer>);
+ void take_from_examiner (std::shared_ptr<VideoExaminer>);
void add_properties (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<VideoContent> from_xml (Content* parent, cxml::ConstNodePtr, int);
+ static std::shared_ptr<VideoContent> from_xml (Content* parent, cxml::ConstNodePtr, int);
private:
using std::list;
using std::max;
using std::back_inserter;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
#include "content_video.h"
#include "decoder_part.h"
#include <boost/signals2.hpp>
-#include <boost/shared_ptr.hpp>
class VideoContent;
class ImageProxy;
class VideoDecoder : public DecoderPart
{
public:
- VideoDecoder (Decoder* parent, boost::shared_ptr<const Content> c);
+ VideoDecoder (Decoder* parent, std::shared_ptr<const Content> c);
friend struct video_decoder_fill_test1;
friend struct video_decoder_fill_test2;
friend struct ffmpeg_pts_offset_test;
friend void ffmpeg_decoder_sequential_test_one (boost::filesystem::path file, float fps, int gaps, int video_length);
- 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 ImageProxy>, Frame frame);
+ void emit (std::shared_ptr<const Film> film, std::shared_ptr<const ImageProxy>, Frame frame);
boost::signals2::signal<void (ContentVideo)> Data;
private:
- boost::shared_ptr<const Content> _content;
+ std::shared_ptr<const Content> _content;
/** Frame of last thing to be emitted; only used for 3D */
boost::optional<Frame> _last_emitted_frame;
boost::optional<Eyes> _last_emitted_eyes;
using std::vector;
using std::string;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
VideoFilterGraph::VideoFilterGraph (dcp::Size s, AVPixelFormat p, dcp::Fraction r)
: _size (s)
VideoFilterGraph (dcp::Size s, AVPixelFormat p, dcp::Fraction r);
bool can_process (dcp::Size s, AVPixelFormat p) const;
- std::list<std::pair<boost::shared_ptr<Image>, int64_t> > process (AVFrame * frame);
+ std::list<std::pair<std::shared_ptr<Image>, int64_t> > process (AVFrame * frame);
protected:
std::string src_parameters () const;
using std::list;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
VideoMXFContent::VideoMXFContent (boost::filesystem::path path)
VideoMXFContent (boost::filesystem::path path);
VideoMXFContent (cxml::ConstNodePtr node, int version);
- boost::shared_ptr<VideoMXFContent> shared_from_this () {
- return boost::dynamic_pointer_cast<VideoMXFContent> (Content::shared_from_this ());
+ std::shared_ptr<VideoMXFContent> shared_from_this () {
+ return std::dynamic_pointer_cast<VideoMXFContent> (Content::shared_from_this ());
}
- boost::shared_ptr<const VideoMXFContent> shared_from_this () const {
- return boost::dynamic_pointer_cast<const VideoMXFContent> (Content::shared_from_this ());
+ std::shared_ptr<const VideoMXFContent> shared_from_this () const {
+ return std::dynamic_pointer_cast<const VideoMXFContent> (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;
std::string technical_summary () const;
std::string identifier () const;
void as_xml (xmlpp::Node* 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;
- 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;
static bool valid_mxf (boost::filesystem::path path);
};
#include <dcp/stereo_picture_asset_reader.h>
#include <dcp/exceptions.h>
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
class VideoMXFDecoder : public Decoder
{
public:
- VideoMXFDecoder (boost::shared_ptr<const Film> film, boost::shared_ptr<const VideoMXFContent>);
+ VideoMXFDecoder (std::shared_ptr<const Film> film, std::shared_ptr<const VideoMXFContent>);
bool pass ();
void seek (dcpomatic::ContentTime t, bool accurate);
private:
- boost::shared_ptr<const VideoMXFContent> _content;
+ std::shared_ptr<const VideoMXFContent> _content;
/** Time of next thing to return from pass */
dcpomatic::ContentTime _next;
- boost::shared_ptr<dcp::MonoPictureAssetReader> _mono_reader;
- boost::shared_ptr<dcp::StereoPictureAssetReader> _stereo_reader;
+ std::shared_ptr<dcp::MonoPictureAssetReader> _mono_reader;
+ std::shared_ptr<dcp::StereoPictureAssetReader> _stereo_reader;
dcp::Size _size;
};
#include <dcp/mono_picture_asset.h>
#include <dcp/stereo_picture_asset.h>
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
VideoMXFExaminer::VideoMXFExaminer (shared_ptr<const VideoMXFContent> content)
class VideoMXFExaminer : public VideoExaminer
{
public:
- explicit VideoMXFExaminer (boost::shared_ptr<const VideoMXFContent>);
+ explicit VideoMXFExaminer (std::shared_ptr<const VideoMXFContent>);
bool has_video () const {
return true;
}
private:
- boost::shared_ptr<dcp::PictureAsset> _asset;
+ std::shared_ptr<dcp::PictureAsset> _asset;
};
using std::cout;
using std::pair;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
#include "types.h"
#include <boost/noncopyable.hpp>
#include <boost/thread/mutex.hpp>
-#include <boost/shared_ptr.hpp>
#include <utility>
class VideoRingBuffers : public boost::noncopyable
{
public:
- void put (
boost::shared_ptr<PlayerVideo> frame, dcpomatic::DCPTime time);
- std::pair<
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> get ();
+ void put (
std::shared_ptr<PlayerVideo> frame, dcpomatic::DCPTime time);
+ std::pair<
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> get ();
void clear ();
Frame size () const;
bool empty () const;
- void reset_metadata (boost::shared_ptr<const Film> film, dcp::Size player_video_container_size);
+ void reset_metadata (std::shared_ptr<const Film> film, dcp::Size player_video_container_size);
std::pair<size_t, std::string> memory_used () const;
private:
mutable boost::mutex _mutex;
- std::list<std::pair<
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> > _data;
+ std::list<std::pair<
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> > _data;
};
#include "dcpomatic_assert.h"
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
class Film;
class WeakFilmTemplate
{
public:
- WeakFilmTemplate (boost::weak_ptr<T> f)
+ WeakFilmTemplate (std::weak_ptr<T> f)
: _film(f)
{}
protected:
- boost::weak_ptr<T> _film;
+ std::weak_ptr<T> _film;
- boost::shared_ptr<T> film () const {
- boost::shared_ptr<T> f = _film.lock();
+ std::shared_ptr<T> film () const {
+ std::shared_ptr<T> f = _film.lock();
DCPOMATIC_ASSERT (f);
return f;
}
using std::min;
using std::max;
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 "weak_film.h"
#include <dcp/atmos_frame.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/condition.hpp>
#include <list>
} type;
/** encoded data for FULL */
- boost::shared_ptr<const dcp::Data> encoded;
+ std::shared_ptr<const dcp::Data> encoded;
/** size of data for FAKE */
int size;
/** reel index */
class Writer : public ExceptionStore, public boost::noncopyable, public WeakConstFilm
{
public:
- Writer (boost::weak_ptr<const Film>, boost::weak_ptr<Job>, bool text_only = false);
+ Writer (std::weak_ptr<const Film>, std::weak_ptr<Job>, bool text_only = false);
~Writer ();
void start ();
bool can_fake_write (Frame) const;
- void write (boost::shared_ptr<const dcp::Data>, Frame, Eyes);
+ void write (std::shared_ptr<const dcp::Data>, Frame, Eyes);
void fake_write (Frame, Eyes);
bool can_repeat (Frame) const;
void repeat (Frame, Eyes);
- void write (boost::shared_ptr<const AudioBuffers>, dcpomatic::DCPTime time);
+ void write (std::shared_ptr<const AudioBuffers>, dcpomatic::DCPTime time);
void write (PlayerText text, TextType type, boost::optional<DCPTextTrack>, dcpomatic::DCPTimePeriod period);
void write (std::vector<dcpomatic::FontData> fonts);
void write (ReferencedReelAsset asset);
- void write (boost::shared_ptr<const dcp::AtmosFrame> atmos, dcpomatic::DCPTime time, AtmosMetadata metadata);
+ void write (std::shared_ptr<const dcp::AtmosFrame> atmos, dcpomatic::DCPTime time, AtmosMetadata metadata);
void finish (boost::filesystem::path output_dcp);
void set_encoder_threads (int threads);
void write_cover_sheet (boost::filesystem::path output_dcp);
void calculate_referenced_digests (boost::function<void (float)> set_progress);
- boost::weak_ptr<Job> _job;
+ std::weak_ptr<Job> _job;
std::vector<ReelWriter> _reels;
std::vector<ReelWriter>::iterator _audio_reel;
std::vector<ReelWriter>::iterator _subtitle_reel;
using std::string;
using std::runtime_error;
-using boost::shared_ptr;
+using std::shared_ptr;
Zipper::Zipper (boost::filesystem::path file)
#include <boost/noncopyable.hpp>
#include <boost/filesystem.hpp>
-#include <boost/shared_ptr.hpp>
#include <vector>
class Zipper : public boost::noncopyable
private:
struct zip* _zip;
- std::vector<boost::shared_ptr<std::string> > _store;
+ std::vector<std::shared_ptr<std::string> > _store;
};
using std::make_pair;
using std::list;
using std::exception;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
using boost::function;
using boost::is_any_of;
}
FilmEditor* _film_editor;
- boost::shared_ptr<FilmViewer> _film_viewer;
+ std::shared_ptr<FilmViewer> _film_viewer;
StandardControls* _controls;
VideoWaveformDialog* _video_waveform_dialog;
SystemInformationDialog* _system_information_dialog;
using std::cout;
using std::list;
using std::set;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::thread;
using boost::scoped_array;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
using std::pair;
using std::setw;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
static void
help (string n)
using std::exception;
using std::string;
using std::vector;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
using std::cerr;
using std::list;
using std::exception;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
class SimpleSignalManager : public SignalManager
using std::exception;
using std::cout;
using std::cerr;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
using std::vector;
using std::pair;
using std::map;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
using boost::optional;
using boost::ref;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
list<KDMWithMetadataPtr> kdms;
string title;
- shared_ptr<DKDM> dkdm = boost::dynamic_pointer_cast<DKDM> (dkdm_base);
+ shared_ptr<DKDM> dkdm = std::dynamic_pointer_cast<DKDM> (dkdm_base);
if (dkdm) {
/* Decrypt the DKDM */
ScreensPanel* _screens;
KDMTimingPanel* _timing;
wxTreeCtrl* _dkdm;
- typedef std::map<wxTreeItemId, boost::shared_ptr<DKDMBase> > DKDMMap;
+ typedef std::map<wxTreeItemId, std::shared_ptr<DKDMBase> > DKDMMap;
DKDMMap _dkdm_id;
wxButton* _add_dkdm;
wxButton* _add_dkdm_folder;
using std::list;
using std::vector;
using std::runtime_error;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::bind;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
}
if (list_cinemas) {
- list<boost::shared_ptr<Cinema> > cinemas = Config::instance()->cinemas ();
- for (list<boost::shared_ptr<Cinema> >::const_iterator i = cinemas.begin(); i != cinemas.end(); ++i) {
+ list<std::shared_ptr<Cinema> > cinemas = Config::instance()->cinemas ();
+ for (list<std::shared_ptr<Cinema> >::const_iterator i = cinemas.begin(); i != cinemas.end(); ++i) {
cout << (*i)->name << " (" << Emailer::address_list ((*i)->emails) << ")\n";
}
exit (EXIT_SUCCESS);
using std::list;
using std::exception;
using std::vector;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::scoped_array;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using boost::thread;
using boost::bind;
#if BOOST_VERSION >= 106100
if (r == wxID_OK) {
DCPOMATIC_ASSERT (_film);
- shared_ptr<DCPContent> dcp = boost::dynamic_pointer_cast<DCPContent>(_film->content().front());
+ shared_ptr<DCPContent> dcp = std::dynamic_pointer_cast<DCPContent>(_film->content().front());
DCPOMATIC_ASSERT (dcp);
dcp->add_ov (wx_to_std(c->GetPath()));
JobManager::instance()->add(shared_ptr<Job>(new ExamineContentJob (_film, dcp)));
if (d->ShowModal() == wxID_OK) {
DCPOMATIC_ASSERT (_film);
- shared_ptr<DCPContent> dcp = boost::dynamic_pointer_cast<DCPContent>(_film->content().front());
+ shared_ptr<DCPContent> dcp = std::dynamic_pointer_cast<DCPContent>(_film->content().front());
DCPOMATIC_ASSERT (dcp);
try {
if (dcp) {
void view_cpl (wxCommandEvent& ev)
{
- shared_ptr<DCPContent> dcp = boost::dynamic_pointer_cast<DCPContent>(_film->content().front());
+ shared_ptr<DCPContent> dcp = std::dynamic_pointer_cast<DCPContent>(_film->content().front());
DCPOMATIC_ASSERT (dcp);
DCPExaminer ex (dcp, true);
int id = ev.GetId() - ID_view_cpl;
void tools_verify ()
{
- shared_ptr<DCPContent> dcp = boost::dynamic_pointer_cast<DCPContent>(_film->content().front());
+ shared_ptr<DCPContent> dcp = std::dynamic_pointer_cast<DCPContent>(_film->content().front());
DCPOMATIC_ASSERT (dcp);
shared_ptr<VerifyDCPJob> job (new VerifyDCPJob(dcp->directories()));
shared_ptr<FilmViewer> _viewer;
Controls* _controls;
SystemInformationDialog* _system_information_dialog;
- boost::shared_ptr<Film> _film;
+ std::shared_ptr<Film> _film;
boost::signals2::scoped_connection _config_changed_connection;
boost::signals2::scoped_connection _examine_job_connection;
wxMenuItem* _file_add_ov;
using std::make_pair;
using std::vector;
using boost::optional;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::bind;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
using std::list;
using std::fixed;
using std::setprecision;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::thread;
using boost::bind;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
wxTextCtrl* _text;
wxStaticText* _fps;
- boost::shared_ptr<wxTimer> _timer;
+ std::shared_ptr<wxTimer> _timer;
};
class TaskBarIcon : public wxTaskBarIcon
using std::cerr;
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
static void
help (string n)
using std::cerr;
using std::string;
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::bind;
#if BOOST_VERSION >= 106100
using std::list;
using std::vector;
using std::pair;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::bind;
using boost::optional;
using boost::const_pointer_cast;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using namespace dcpomatic;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
class AudioPlot;
class AudioDialog : public wxDialog
{
public:
- AudioDialog (wxWindow* parent, boost::shared_ptr<Film> film, boost::weak_ptr<FilmViewer> viewer, boost::shared_ptr<Content> content = boost::shared_ptr<Content>());
+ AudioDialog (wxWindow* parent, std::shared_ptr<Film> film, std::weak_ptr<FilmViewer> viewer, std::shared_ptr<Content> content = std::shared_ptr<Content>());
bool Show (bool show = true);
void setup_statistics ();
void show_or_hide_channel_checkboxes ();
-
boost::shared_ptr<AudioAnalysis> _analysis;
- boost::weak_ptr<Film> _film;
- boost::weak_ptr<FilmViewer> _viewer;
+
std::shared_ptr<AudioAnalysis> _analysis;
+ std::weak_ptr<Film> _film;
+ std::weak_ptr<FilmViewer> _viewer;
/** content to analyse, or 0 to analyse all the film's content */
- boost::weak_ptr<Content> _content;
+ std::weak_ptr<Content> _content;
int _channels;
- boost::shared_ptr<const Playlist> _playlist;
+ std::shared_ptr<const Playlist> _playlist;
wxStaticText* _cursor;
AudioPlot* _plot;
wxStaticText* _sample_peak;
using std::vector;
using std::pair;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
using std::string;
using std::list;
using std::pair;
-using boost::dynamic_pointer_cast;
-using boost::shared_ptr;
+using std::dynamic_pointer_cast;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
void film_changed (Film::Property);
void film_content_changed (int);
void content_selection_changed ();
- void set_film (boost::shared_ptr<Film>);
+ void set_film (std::shared_ptr<Film>);
private:
void show_clicked ();
using std::map;
using boost::bind;
using boost::optional;
-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
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
#include <vector>
class AudioPlot : public wxPanel
{
public:
- explicit AudioPlot (wxWindow *, boost::weak_ptr<FilmViewer> viewer);
+ explicit AudioPlot (wxWindow *, std::weak_ptr<FilmViewer> viewer);
- void set_analysis (
boost::shared_ptr<AudioAnalysis>);
+ void set_analysis (
std::shared_ptr<AudioAnalysis>);
void set_channel_visible (int c, bool v);
void set_type_visible (int t, bool v);
void set_smoothing (int);
void mouse_leave (wxMouseEvent& ev);
void search (std::map<int, PointList> const & search, wxMouseEvent const & ev, double& min_dist, Point& min_point) const;
- boost::weak_ptr<FilmViewer> _viewer;
-
boost::shared_ptr<AudioAnalysis> _analysis;
+ std::weak_ptr<FilmViewer> _viewer;
+
std::shared_ptr<AudioAnalysis> _analysis;
bool _channel_visible[MAX_DCP_AUDIO_CHANNELS];
bool _type_visible[AudioPoint::COUNT];
int _smoothing;
#include <wx/button.h>
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
BatchJobView::BatchJobView (shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table)
: JobView (job, parent, container, table)
class BatchJobView : public JobView
{
public:
- BatchJobView (boost::shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table);
+ BatchJobView (std::shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table);
private:
int insert_position () const;
using std::cout;
using std::pair;
using std::make_pair;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
explicit ClosedCaptionsDialog (wxWindow* parent, FilmViewer* viewer);
void clear ();
- void update_tracks (boost::shared_ptr<const Film> film);
- void set_butler (boost::weak_ptr<Butler>);
+ void update_tracks (std::shared_ptr<const Film> film);
+ void set_butler (std::weak_ptr<Butler>);
private:
void shown (wxShowEvent);
bool _current_in_lines;
std::vector<wxString> _lines;
std::vector<DCPTextTrack> _tracks;
- boost::weak_ptr<Butler> _butler;
+ std::weak_ptr<Butler> _butler;
wxTimer _timer;
};
using std::string;
using std::cout;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::bind;
using dcp::locale_convert;
using std::map;
using boost::bind;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
wxWindow* parent,
wxString title,
int border,
- boost::function<void (boost::shared_ptr<dcp::CertificateChain>)> set,
- boost::function<boost::shared_ptr<const dcp::CertificateChain> (void)> get,
+ boost::function<void (std::shared_ptr<dcp::CertificateChain>)> set,
+ boost::function<std::shared_ptr<const dcp::CertificateChain> (void)> get,
boost::function<bool (void)> nag_alter
);
wxStaticText* _private_key_bad;
wxSizer* _sizer;
wxBoxSizer* _button_sizer;
- boost::function<void (boost::shared_ptr<dcp::CertificateChain>)> _set;
- boost::function<boost::shared_ptr<const dcp::CertificateChain> (void)> _get;
+ boost::function<void (std::shared_ptr<dcp::CertificateChain>)> _set;
+ boost::function<std::shared_ptr<const dcp::CertificateChain> (void)> _get;
boost::function<bool (void)> _nag_alter;
};
using std::string;
using std::vector;
using boost::bind;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
+#include <memory>
#include <vector>
class ContentAdvancedDialog : public wxDialog
{
public:
- ContentAdvancedDialog (wxWindow* parent, boost::shared_ptr<Content> content);
+ ContentAdvancedDialog (wxWindow* parent, std::shared_ptr<Content> content);
private:
void ignore_video_changed (wxCommandEvent& ev);
void set_video_frame_rate ();
void video_frame_rate_changed ();
- boost::shared_ptr<Content> _content;
+ std::shared_ptr<Content> _content;
wxStaticText* _filters;
wxButton* _filters_button;
using std::vector;
using std::exception;
using std::list;
-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;
bind (
&ContentMenu::maybe_found_missing,
this,
- boost::weak_ptr<Job> (j),
- boost::weak_ptr<Content> (_content.front ()),
- boost::weak_ptr<Content> (i)
+ std::weak_ptr<Job> (j),
+ std::weak_ptr<Content> (_content.front ()),
+ std::weak_ptr<Content> (i)
)
);
#include "timeline_content_view.h"
#include "lib/types.h"
#include <wx/wx.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
+#include <memory>
class Film;
class Job;
public:
explicit ContentMenu (wxWindow* p);
- void popup (boost::weak_ptr<Film>, ContentList, TimelineContentViewList, wxPoint);
+ void popup (std::weak_ptr<Film>, ContentList, TimelineContentViewList, wxPoint);
private:
void repeat ();
void ov ();
void set_dcp_settings ();
void remove ();
- void maybe_found_missing (boost::weak_ptr<Job>, boost::weak_ptr<Content>, boost::weak_ptr<Content>);
+ void maybe_found_missing (std::weak_ptr<Job>, std::weak_ptr<Content>, std::weak_ptr<Content>);
void cpl_selected (wxCommandEvent& ev);
wxMenu* _menu;
wxMenu* _cpl_menu;
/** Film that we are working with; set up by popup() */
- boost::weak_ptr<Film> _film;
+ std::weak_ptr<Film> _film;
wxWindow* _parent;
bool _pop_up_open;
ContentList _content;
using std::vector;
using std::max;
using std::exception;
-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 namespace dcpomatic;
#if BOOST_VERSION >= 106100
#include "lib/types.h"
#include "lib/film.h"
#include <wx/splitter.h>
-#include <boost/shared_ptr.hpp>
#include <list>
class wxNotebook;
class ContentPanel : public boost::noncopyable
{
public:
- ContentPanel (wxNotebook *, boost::shared_ptr<Film>, boost::weak_ptr<FilmViewer> viewer);
+ ContentPanel (wxNotebook *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
- boost::shared_ptr<Film> film () const {
+ std::shared_ptr<Film> film () const {
return _film;
}
- void set_film (boost::shared_ptr<Film>);
+ void set_film (std::shared_ptr<Film>);
void set_general_sensitivity (bool s);
- void set_selection (boost::weak_ptr<Content>);
+ void set_selection (std::weak_ptr<Content>);
void set_selection (ContentList cl);
void film_changed (Film::Property p);
bool remove_clicked (bool hotkey);
void timeline_clicked ();
- boost::weak_ptr<FilmViewer> film_viewer () const {
+ std::weak_ptr<FilmViewer> film_viewer () const {
return _film_viewer;
}
wxNotebook* _parent;
wxWindow* _last_selected_tab;
- boost::shared_ptr<Film> _film;
- boost::weak_ptr<FilmViewer> _film_viewer;
+ std::shared_ptr<Film> _film;
+ std::weak_ptr<FilmViewer> _film_viewer;
bool _generally_sensitive;
bool _ignore_deselect;
bool _no_check_selection;
using std::list;
using std::pair;
using std::map;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
ContentPropertiesDialog::ContentPropertiesDialog (wxWindow* parent, shared_ptr<const Film> film, shared_ptr<Content> content)
: TableDialog (parent, _("Content Properties"), 2, 1, false)
#include "table_dialog.h"
#include "lib/user_property.h"
-#include <boost/shared_ptr.hpp>
#include <list>
#include <map>
class ContentPropertiesDialog : public TableDialog
{
public:
- ContentPropertiesDialog (wxWindow* parent, boost::shared_ptr<const Film> film, boost::shared_ptr<Content> content);
+ ContentPropertiesDialog (wxWindow* parent, std::shared_ptr<const Film> film, std::shared_ptr<Content> content);
private:
void maybe_add_group (std::map<UserProperty::Category, std::list<UserProperty> > const & groups, UserProperty::Category category);
using std::list;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
class ContentPanel;
class Content;
protected:
- void setup_refer_button (wxCheckBox* button, wxStaticText* note, boost::shared_ptr<DCPContent> dcp, bool can_reference, wxString cannot) const;
+ void setup_refer_button (wxCheckBox* button, wxStaticText* note, std::shared_ptr<DCPContent> dcp, bool can_reference, wxString cannot) const;
virtual void add_to_grid () = 0;
ContentPanel* _parent;
using std::string;
using std::cout;
using std::list;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using namespace dcpomatic;
ContentView::ContentView (wxWindow* parent)
DCPOMATIC_DISABLE_WARNINGS
#include <wx/listctrl.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <vector>
class Content;
public:
ContentView (wxWindow* parent);
- boost::shared_ptr<Content> selected () const;
+ std::shared_ptr<Content> selected () const;
void update ();
- boost::shared_ptr<Content> get (std::string digest) const;
+ std::shared_ptr<Content> get (std::string digest) const;
private:
- void add (boost::shared_ptr<Content> content);
+ void add (std::shared_ptr<Content> content);
- boost::weak_ptr<Film> _film;
- std::vector<boost::shared_ptr<Content> > _content;
+ std::weak_ptr<Film> _film;
+ std::vector<std::shared_ptr<Content> > _content;
};
wxWindow* parent,
T* wrapped,
int property,
- boost::function<boost::shared_ptr<S> (Content*)> part,
+ boost::function<std::shared_ptr<S> (Content*)> part,
boost::function<U (S*)> model_getter,
boost::function<void (S*, U)> model_setter,
boost::function<void ()> view_changed,
return _wrapped;
}
- typedef std::vector<boost::shared_ptr<Content> > List;
+ typedef std::vector<std::shared_ptr<Content> > List;
/** Set the content that this control is working on (i.e. the selected content) */
void set_content (List content)
wxButton* _button;
List _content;
int _property;
- boost::function<boost::shared_ptr<S> (Content *)> _part;
+ boost::function<std::shared_ptr<S> (Content *)> _part;
boost::function<U (S*)> _model_getter;
boost::function<void (S*, U)> _model_setter;
boost::function<void ()> _view_changed;
wxWindow* parent,
wxSpinCtrl* wrapped,
int property,
- boost::function<boost::shared_ptr<S> (Content *)> part,
+ boost::function<std::shared_ptr<S> (Content *)> part,
boost::function<int (S*)> getter,
boost::function<void (S*, int)> setter,
boost::function<void ()> view_changed = boost::function<void ()>()
wxWindow* parent,
wxSpinCtrlDouble* wrapped,
int property,
- boost::function<boost::shared_ptr<S> (Content *)> part,
+ boost::function<std::shared_ptr<S> (Content *)> part,
boost::function<double (S*)> getter,
boost::function<void (S*, double)> setter,
boost::function<void ()> view_changed = boost::function<void ()>()
wxWindow* parent,
wxChoice* wrapped,
int property,
- boost::function<boost::shared_ptr<S> (Content *)> part,
+ boost::function<std::shared_ptr<S> (Content *)> part,
boost::function<U (S*)> getter,
boost::function<void (S*, U)> setter,
boost::function<U (int)> view_to_model,
using std::make_pair;
using std::exception;
using boost::optional;
-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;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
class FilmViewer;
public:
Controls (
wxWindow* parent,
- boost::shared_ptr<FilmViewer>,
+ std::shared_ptr<FilmViewer>,
bool editor_controls = true
);
virtual void log (wxString) {}
- virtual void set_film (boost::shared_ptr<Film> film);
+ virtual void set_film (std::shared_ptr<Film> film);
virtual void play () {};
virtual void stop () {};
void seek (int slider);
- boost::shared_ptr<Film> film () const;
+ std::shared_ptr<Film> film () const;
void back_frame ();
void forward_frame ();
wxSizer* _v_sizer;
wxBoxSizer* _button_sizer;
- boost::shared_ptr<Film> _film;
+ std::shared_ptr<Film> _film;
wxSlider* _slider;
- boost::shared_ptr<FilmViewer> _viewer;
+ std::shared_ptr<FilmViewer> _viewer;
boost::optional<std::string> _active_job;
private:
void timecode_clicked ();
void active_jobs_changed (boost::optional<std::string>);
dcpomatic::DCPTime nudge_amount (wxKeyboardState& ev);
- void image_changed (
boost::weak_ptr<PlayerVideo>);
+ void image_changed (
std::weak_ptr<PlayerVideo>);
void outline_content_changed ();
void eye_changed ();
void update_position ();
void film_change (ChangeType, Film::Property);
- typedef std::pair<boost::shared_ptr<dcp::CPL>, boost::filesystem::path> CPL;
+ typedef std::pair<std::shared_ptr<dcp::CPL>, boost::filesystem::path> CPL;
bool _slider_being_moved;
using std::max;
using std::make_pair;
using boost::lexical_cast;
-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
*/
#include "lib/config.h"
-#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
class wxNotebook;
class DCPPanel : public boost::noncopyable
{
public:
- DCPPanel (wxNotebook *, boost::shared_ptr<Film>, boost::weak_ptr<FilmViewer> viewer);
+ DCPPanel (wxNotebook *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
- void set_film (boost::shared_ptr<Film>);
+ void set_film (std::shared_ptr<Film>);
void set_general_sensitivity (bool);
void film_changed (int);
InteropMetadataDialog* _interop_metadata_dialog;
SMPTEMetadataDialog* _smpte_metadata_dialog;
- boost::shared_ptr<Film> _film;
- boost::weak_ptr<FilmViewer> _viewer;
+ std::shared_ptr<Film> _film;
+ std::weak_ptr<FilmViewer> _viewer;
bool _generally_sensitive;
};
using std::vector;
using std::make_pair;
using std::runtime_error;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
using boost::optional;
#if BOOST_VERSION >= 106100
#include "wx_util.h"
#include <wx/wx.h>
-#include <boost/shared_ptr.hpp>
#include <map>
class Film;
class DKDMDialog : public wxDialog
{
public:
- DKDMDialog (wxWindow *, boost::shared_ptr<const Film> film);
+ DKDMDialog (wxWindow *, std::shared_ptr<const Film> film);
private:
void setup_sensitivity ();
void make_clicked ();
bool confirm_overwrite (boost::filesystem::path path);
- boost::weak_ptr<const Film> _film;
+ std::weak_ptr<const Film> _film;
RecipientsPanel* _recipients;
KDMTimingPanel* _timing;
KDMCPLPanel* _cpl;
using std::list;
using std::exception;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
boost::filesystem::path directory () const;
- std::pair<boost::shared_ptr<Job>, int> make (
+ std::pair<std::shared_ptr<Job>, int> make (
std::list<KDMWithMetadataPtr > kdms,
std::string name,
boost::function<bool (boost::filesystem::path)> confirm_overwrite
#include "wx_util.h"
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
EmailDialog::EmailDialog (wxWindow* parent)
using std::cout;
using std::string;
using std::list;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
class FilmEditor : public wxPanel
{
public:
- FilmEditor (wxWindow *, boost::weak_ptr<FilmViewer> viewer);
+ FilmEditor (wxWindow *, std::weak_ptr<FilmViewer> viewer);
- void set_film (boost::shared_ptr<Film>);
+ void set_film (std::shared_ptr<Film>);
void first_shown ();
boost::signals2::signal<void (boost::filesystem::path)> FileChanged;
return _content_panel;
}
- boost::shared_ptr<Film> film () const {
+ std::shared_ptr<Film> film () const {
return _film;
}
DCPPanel* _dcp_panel;
/** The film we are editing */
- boost::shared_ptr<Film> _film;
+ std::shared_ptr<Film> _film;
};
using std::bad_alloc;
using std::make_pair;
using std::exception;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
+using std::weak_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
void show_closed_captions ();
- void set_film (boost::shared_ptr<Film>);
- boost::shared_ptr<Film> film () const {
+ void set_film (std::shared_ptr<Film>);
+ std::shared_ptr<Film> film () const {
return _film;
}
void seek (dcpomatic::DCPTime t, bool accurate);
- void seek (boost::shared_ptr<Content> content, dcpomatic::ContentTime p, bool accurate);
+ void seek (std::shared_ptr<Content> content, dcpomatic::ContentTime p, bool accurate);
void seek_by (dcpomatic::DCPTime by, bool accurate);
/** @return our `playhead' position; this may not lie exactly on a frame boundary */
dcpomatic::DCPTime position () const {
bool pad_black () const {
return _pad_black;
}
- boost::shared_ptr<Butler> butler () const {
+ std::shared_ptr<Butler> butler () const {
return _butler;
}
ClosedCaptionsDialog* closed_captions_dialog () const {
return _closed_captions_dialog;
}
void finished ();
- void image_changed (
boost::shared_ptr<PlayerVideo> video);
+ void image_changed (
std::shared_ptr<PlayerVideo> video);
bool pending_idle_get () const {
return _idle_get;
}
- boost::signals2::signal<void (
boost::shared_ptr<PlayerVideo>)> ImageChanged;
+ boost::signals2::signal<void (
std::shared_ptr<PlayerVideo>)> ImageChanged;
boost::signals2::signal<void (dcpomatic::DCPTime)> Started;
boost::signals2::signal<void (dcpomatic::DCPTime)> Stopped;
/** While playing back we reached the end of the film (emitted from GUI thread) */
bool quick_refresh ();
- boost::shared_ptr<Film> _film;
-
boost::shared_ptr<Player> _player;
+ std::shared_ptr<Film> _film;
+
std::shared_ptr<Player> _player;
VideoView* _video_view;
bool _coalesce_player_changes;
unsigned int _audio_block_size;
bool _playing;
int _suspended;
- boost::shared_ptr<Butler> _butler;
+ std::shared_ptr<Butler> _butler;
std::list<Frame> _latency_history;
/** Mutex to protect _latency_history */
using std::list;
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
FontsDialog::FontsDialog (wxWindow* parent, shared_ptr<Content> content, shared_ptr<TextContent> caption)
#include <wx/listctrl.h>
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <boost/filesystem.hpp>
class Content;
class FontsDialog : public wxDialog
{
public:
- FontsDialog (wxWindow* parent, boost::shared_ptr<Content>, boost::shared_ptr<TextContent> caption);
+ FontsDialog (wxWindow* parent, std::shared_ptr<Content>, std::shared_ptr<TextContent> caption);
private:
void setup ();
void selection_changed ();
void edit_clicked ();
- boost::weak_ptr<Content> _content;
- boost::weak_ptr<TextContent> _caption;
+ std::weak_ptr<Content> _content;
+ std::weak_ptr<TextContent> _caption;
wxListCtrl* _fonts;
wxButton* _edit;
};
using std::make_pair;
using std::map;
using boost::bind;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
using boost::optional;
#if BOOST_VERSION >= 106100
#endif
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
DCPOMATIC_ENABLE_WARNINGS
#include <dcp/util.h>
#include <boost/atomic.hpp>
-#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/condition.hpp>
#undef None
}
private:
- void set_image (boost::shared_ptr<const Image> image);
+ void set_image (std::shared_ptr<const Image> image);
void set_image_and_draw ();
void draw (Position<int> inter_position, dcp::Size inter_size);
void thread ();
boost::atomic<bool> _playing;
boost::atomic<bool> _one_shot;
- boost::shared_ptr<wxTimer> _timer;
+ std::shared_ptr<wxTimer> _timer;
};
using std::vector;
using std::string;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::bind;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
-HintsDialog::HintsDialog (wxWindow* parent, boost::weak_ptr<Film> film, bool ok)
+HintsDialog::HintsDialog (wxWindow* parent, std::weak_ptr<Film> film, bool ok)
: wxDialog (parent, wxID_ANY, _("Hints"))
, _film (film)
, _hints (0)
_text->GetCaret()->Hide ();
- boost::shared_ptr<Film> locked_film = _film.lock ();
+ std::shared_ptr<Film> locked_film = _film.lock ();
if (locked_film) {
_film_change_connection = locked_film->Change.connect (boost::bind (&HintsDialog::film_change, this, _1));
_film_content_change_connection = locked_film->ContentChange.connect (boost::bind (&HintsDialog::film_content_change, this, _1));
_text->Clear ();
_current.clear ();
- boost::shared_ptr<Film> film = _film.lock ();
+ std::shared_ptr<Film> film = _film.lock ();
if (!film) {
return;
}
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/weak_ptr.hpp>
#include <boost/signals2.hpp>
class wxRichTextCtrl;
class HintsDialog : public wxDialog
{
public:
- HintsDialog (wxWindow* parent, boost::weak_ptr<Film>, bool ok);
+ HintsDialog (wxWindow* parent, std::weak_ptr<Film>, bool ok);
private:
void film_change (ChangeType);
void finished ();
void progress (std::string m);
- boost::weak_ptr<Film> _film;
+ std::weak_ptr<Film> _film;
wxGauge* _gauge;
wxStaticText* _gauge_message;
wxRichTextCtrl* _text;
using std::string;
using std::vector;
-using boost::weak_ptr;
-using boost::shared_ptr;
+using std::weak_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
#include <dcp/language_tag.h>
#include <dcp/types.h>
#include <wx/wx.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <vector>
class Film;
class InteropMetadataDialog : public wxDialog
{
public:
- InteropMetadataDialog (wxWindow* parent, boost::weak_ptr<Film> film);
+ InteropMetadataDialog (wxWindow* parent, std::weak_ptr<Film> film);
private:
std::vector<dcp::Rating> ratings () const;
void setup_sensitivity ();
void subtitle_language_changed (dcp::LanguageTag tag);
- boost::weak_ptr<Film> _film;
+ std::weak_ptr<Film> _film;
wxCheckBox* _enable_subtitle_language;
LanguageTagWidget* _subtitle_language;
EditableList<dcp::Rating, RatingDialog>* _ratings;
#include <wx/sizer.h>
#include <wx/spinctrl.h>
-using boost::shared_ptr;
+using std::shared_ptr;
/** @param parent Parent window.
* @param dm Initial ISDCF metadata.
#include "table_dialog.h"
#include "lib/isdcf_metadata.h"
#include <wx/textctrl.h>
-#include <boost/shared_ptr.hpp>
class wxSpinCtrl;
class Film;
using std::map;
using std::min;
using std::cout;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::bind;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
* @brief Class which is a wxPanel for showing the progress of jobs.
*/
+
#include "lib/warnings.h"
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
#include <list>
+#include <memory>
+
class Job;
class JobView;
+
/** @class JobManagerView
* @brief Class which is a wxPanel for showing the progress of jobs.
*/
JobManagerView (wxWindow *, bool batch);
private:
- void job_added (boost::weak_ptr<Job>);
+ void job_added (std::weak_ptr<Job>);
void periodic ();
void replace ();
void job_list_changed ();
wxPanel* _panel;
wxFlexGridSizer* _table;
- boost::shared_ptr<wxTimer> _timer;
+ std::shared_ptr<wxTimer> _timer;
bool _batch;
- std::list<boost::shared_ptr<JobView> > _job_records;
+ std::list<std::shared_ptr<JobView> > _job_records;
};
using std::string;
using std::min;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
JobView::JobView (shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table)
: _job (job)
#define DCPOMATIC_JOB_VIEW_H
#include <boost/noncopyable.hpp>
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
class Job;
class JobView : public boost::noncopyable
{
public:
- JobView (boost::shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table);
+ JobView (std::shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table);
virtual ~JobView () {}
virtual int insert_position () const = 0;
void insert (int pos);
void detach ();
- boost::shared_ptr<Job> job () const {
+ std::shared_ptr<Job> job () const {
return _job;
}
protected:
virtual void finished ();
- boost::shared_ptr<Job> _job;
+ std::shared_ptr<Job> _job;
wxFlexGridSizer* _table;
/** sizer for buttons (cancel, details, pause etc.) */
wxBoxSizer* _buttons;
#include "normal_job_view.h"
#include "lib/job.h"
-using boost::shared_ptr;
+using std::shared_ptr;
JobViewDialog::JobViewDialog (wxWindow* parent, wxString title, shared_ptr<Job> job)
: TableDialog (parent, title, 4, 0, false)
*/
+
#include "table_dialog.h"
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
+#include <memory>
+
class JobView;
class Job;
class JobViewDialog : public TableDialog
{
public:
- JobViewDialog (wxWindow* parent, wxString title, boost::shared_ptr<Job> job);
+ JobViewDialog (wxWindow* parent, wxString title, std::shared_ptr<Job> job);
~JobViewDialog ();
private:
void periodic ();
JobView* _view;
- boost::weak_ptr<Job> _job;
- boost::shared_ptr<wxTimer> _timer;
+ std::weak_ptr<Job> _job;
+ std::shared_ptr<wxTimer> _timer;
};
using std::vector;
using std::make_pair;
using std::runtime_error;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
using boost::optional;
#if BOOST_VERSION >= 106100
#include "wx_util.h"
#include <dcp/types.h>
#include <wx/wx.h>
-#include <boost/shared_ptr.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <map>
class KDMDialog : public wxDialog
{
public:
- KDMDialog (wxWindow *, boost::shared_ptr<const Film> film);
+ KDMDialog (wxWindow *, std::shared_ptr<const Film> film);
private:
void setup_sensitivity ();
void make_clicked ();
bool confirm_overwrite (boost::filesystem::path path);
- boost::weak_ptr<const Film> _film;
+ std::weak_ptr<const Film> _film;
ScreensPanel* _screens;
KDMTimingPanel* _timing;
KDMCPLPanel* _cpl;
using std::list;
using std::exception;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
return _forensic_mark_audio_up_to;
}
- std::pair<boost::shared_ptr<Job>, int> make (
+ std::pair<std::shared_ptr<Job>, int> make (
std::list<KDMWithMetadataPtr > screen_kdms,
std::string name,
boost::function<bool (boost::filesystem::path)> confirm_overwrite
#include <boost/bind/bind.hpp>
#include <boost/foreach.hpp>
#include <boost/optional.hpp>
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
#include <iostream>
#include <iterator>
using std::string;
using std::vector;
using boost::optional;
-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
using std::cout;
using boost::bind;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::optional;
using dcpomatic::DCPTime;
*/
+
#include "lib/warnings.h"
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <list>
+#include <memory>
+
class Marker;
class Film;
class MarkersDialog : public wxDialog
{
public:
- MarkersDialog (wxWindow* parent, boost::weak_ptr<Film> film, boost::weak_ptr<FilmViewer> viewer);
+ MarkersDialog (wxWindow* parent, std::weak_ptr<Film> film, std::weak_ptr<FilmViewer> viewer);
private:
- std::list<boost::shared_ptr<Marker> > _markers;
- boost::weak_ptr<Film> _film;
+ std::list<std::shared_ptr<Marker> > _markers;
+ std::weak_ptr<Film> _film;
};
using std::string;
using dcp::locale_convert;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
MonitorDialog::MonitorDialog (wxWindow* parent)
#include <boost/foreach.hpp>
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
#include "table_dialog.h"
#include "lib/dcpomatic_time.h"
-#include <boost/weak_ptr.hpp>
#include <boost/optional.hpp>
class Film;
class MoveToDialog : public TableDialog
{
public:
- MoveToDialog (wxWindow* parent, boost::optional<dcpomatic::DCPTime> position, boost::shared_ptr<const Film> film);
+ MoveToDialog (wxWindow* parent, boost::optional<dcpomatic::DCPTime> position, std::shared_ptr<const Film> film);
dcpomatic::DCPTime position () const;
private:
- boost::weak_ptr<const Film> _film;
+ std::weak_ptr<const Film> _film;
wxSpinCtrl* _reel;
};
#include "check_box.h"
#include <boost/foreach.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
#include "lib/job.h"
#include <wx/wx.h>
-using boost::shared_ptr;
+using std::shared_ptr;
NormalJobView::NormalJobView (shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table)
: JobView (job, parent, container, table)
class NormalJobView : public JobView
{
public:
- NormalJobView (boost::shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table);
+ NormalJobView (std::shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table);
void setup ();
using std::make_pair;
using std::map;
using boost::bind;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
using boost::optional;
#if BOOST_VERSION >= 106100
using std::cout;
using std::string;
-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;
/* This should be even */
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
#include <boost/scoped_ptr.hpp>
-#include <boost/weak_ptr.hpp>
class FilmViewer;
class PlayerInformation : public wxPanel
{
public:
- PlayerInformation (wxWindow* parent, boost::weak_ptr<FilmViewer> viewer);
+ PlayerInformation (wxWindow* parent, std::weak_ptr<FilmViewer> viewer);
void triggered_update ();
void periodic_update ();
- boost::weak_ptr<FilmViewer> _viewer;
+ std::weak_ptr<FilmViewer> _viewer;
wxSizer* _sizer;
wxStaticText** _dcp;
wxStaticText* _dropped;
using std::cout;
using std::exception;
using std::sort;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::optional;
using namespace dcpomatic;
class PlaylistControls : public Controls
{
public:
- PlaylistControls (wxWindow* parent, boost::shared_ptr<FilmViewer> viewer);
+ PlaylistControls (wxWindow* parent, std::shared_ptr<FilmViewer> viewer);
void log (wxString s);
- void set_film (boost::shared_ptr<Film> film);
+ void set_film (std::shared_ptr<Film> film);
/** This is so that we can tell our parent player to reset the film
when we have created one from a SPL. We could call a method
in the player's DOMFrame but we don't have that in a header.
*/
- boost::signals2::signal<void (boost::weak_ptr<Film>)> ResetFilm;
+ boost::signals2::signal<void (std::weak_ptr<Film>)> ResetFilm;
void play ();
void stop ();
bool can_do_next ();
void deselect_playlist ();
- boost::optional<dcp::EncryptedKDM> get_kdm_from_directory (boost::shared_ptr<DCPContent> dcp);
+ boost::optional<dcp::EncryptedKDM> get_kdm_from_directory (std::shared_ptr<DCPContent> dcp);
wxButton* _play_button;
wxButton* _pause_button;
#include "lib/screen.h"
#include <dcp/certificate.h>
#include <wx/wx.h>
-#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
class Progress;
using std::map;
using std::string;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
#include <wx/srchctrl.h>
#include <wx/treectrl.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
#include <list>
#include <map>
void setup_sensitivity ();
- std::list<boost::shared_ptr<DKDMRecipient> > recipients () const;
+ std::list<std::shared_ptr<DKDMRecipient> > recipients () const;
boost::signals2::signal<void ()> RecipientsChanged;
private:
void add_recipients ();
- void add_recipient (boost::shared_ptr<DKDMRecipient>);
+ void add_recipient (std::shared_ptr<DKDMRecipient>);
void add_recipient_clicked ();
void edit_recipient_clicked ();
void remove_recipient_clicked ();
wxButton* _remove_recipient;
wxTreeItemId _root;
- typedef std::map<wxTreeItemId, boost::shared_ptr<DKDMRecipient> > RecipientMap;
+ typedef std::map<wxTreeItemId, std::shared_ptr<DKDMRecipient> > RecipientMap;
RecipientMap _recipients;
RecipientMap _selected;
#include <wx/sizer.h>
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
/** @param parent Parent window.
* @param film Film that we are working on, or 0.
*/
+
#include "lib/warnings.h"
DCPOMATIC_DISABLE_WARNINGS
#include <wx/dialog.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
+#include <memory>
+
class wxTextCtrl;
class wxFlexGridSizer;
class ReportProblemDialog : public wxDialog
{
public:
- ReportProblemDialog (wxWindow* parent, boost::shared_ptr<Film> film = boost::shared_ptr<Film>());
+ ReportProblemDialog (wxWindow* parent, std::shared_ptr<Film> film = std::shared_ptr<Film>());
void report ();
private:
- boost::shared_ptr<Film> _film;
+ std::shared_ptr<Film> _film;
wxSizer* _overall_sizer;
wxFlexGridSizer* _table;
#include "lib/screen.h"
#include <dcp/certificate.h>
#include <wx/wx.h>
-#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
class Progress;
using std::map;
using std::string;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
DCPOMATIC_ENABLE_WARNINGS
#include <wx/srchctrl.h>
#include <wx/treectrl.h>
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
#include <list>
#include <map>
explicit ScreensPanel (wxWindow* parent);
~ScreensPanel ();
- std::list<boost::shared_ptr<dcpomatic::Screen> > screens () const;
+ std::list<std::shared_ptr<dcpomatic::Screen> > screens () const;
void setup_sensitivity ();
boost::signals2::signal<void ()> ScreensChanged;
private:
void add_cinemas ();
- boost::optional<wxTreeItemId> add_cinema (boost::shared_ptr<Cinema>);
- boost::optional<wxTreeItemId> add_screen (boost::shared_ptr<Cinema>, boost::shared_ptr<dcpomatic::Screen>);
+ boost::optional<wxTreeItemId> add_cinema (std::shared_ptr<Cinema>);
+ boost::optional<wxTreeItemId> add_screen (std::shared_ptr<Cinema>, std::shared_ptr<dcpomatic::Screen>);
void add_cinema_clicked ();
void edit_cinema_clicked ();
void remove_cinema_clicked ();
wxButton* _remove_screen;
wxTreeItemId _root;
- typedef std::map<wxTreeItemId, boost::shared_ptr<Cinema> > CinemaMap;
- typedef std::map<wxTreeItemId, boost::shared_ptr<dcpomatic::Screen> > ScreenMap;
+ typedef std::map<wxTreeItemId, std::shared_ptr<Cinema> > CinemaMap;
+ typedef std::map<wxTreeItemId, std::shared_ptr<dcpomatic::Screen> > ScreenMap;
CinemaMap _cinemas;
ScreenMap _screens;
using std::cout;
using std::vector;
using std::make_pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
-SelfDKDMDialog::SelfDKDMDialog (wxWindow* parent, boost::shared_ptr<const Film> film)
+SelfDKDMDialog::SelfDKDMDialog (wxWindow* parent, std::shared_ptr<const Film> film)
: wxDialog (parent, wxID_ANY, _("Make DKDM for DCP-o-matic"))
{
/* Main sizer */
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <map>
class SelfDKDMDialog : public wxDialog
{
public:
- SelfDKDMDialog (wxWindow *, boost::shared_ptr<const Film>);
+ SelfDKDMDialog (wxWindow *, std::shared_ptr<const Film>);
boost::filesystem::path cpl () const;
#include "wx_util.h"
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
ServerDialog::ServerDialog (wxWindow* parent)
using std::max;
using std::string;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
NextFrameResult display_next_frame (bool non_blocking);
private:
- void set_image (boost::shared_ptr<const Image> image) {
+ void set_image (std::shared_ptr<const Image> image) {
_image = image;
}
void timer ();
wxPanel* _panel;
- boost::shared_ptr<const Image> _image;
+ std::shared_ptr<const Image> _image;
wxTimer _timer;
Position<int> _inter_position;
dcp::Size _inter_size;
using std::string;
using std::vector;
using boost::optional;
-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
#include <dcp/language_tag.h>
#include <dcp/types.h>
#include <wx/wx.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <vector>
class SMPTEMetadataDialog : public wxDialog, public WeakFilm
{
public:
- SMPTEMetadataDialog (wxWindow* parent, boost::weak_ptr<Film> film);
+ SMPTEMetadataDialog (wxWindow* parent, std::weak_ptr<Film> film);
private:
std::vector<dcp::Rating> ratings () const;
#include <wx/wx.h>
#include <wx/tglbtn.h>
-using boost::shared_ptr;
+using std::shared_ptr;
StandardControls::StandardControls (wxWindow* parent, shared_ptr<FilmViewer> viewer, bool editor_controls)
: Controls (parent, viewer, editor_controls)
class StandardControls : public Controls
{
public:
- StandardControls (wxWindow* parent, boost::shared_ptr<FilmViewer> viewer, bool editor_controls);
+ StandardControls (wxWindow* parent, std::shared_ptr<FilmViewer> viewer, bool editor_controls);
void play ();
void stop ();
using std::map;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using boost::optional;
using namespace dcpomatic;
#if BOOST_VERSION >= 106100
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
class wxRadioButton;
class SubtitleAppearanceDialog : public wxDialog
{
public:
- SubtitleAppearanceDialog (wxWindow* parent, boost::shared_ptr<const Film> film, boost::shared_ptr<Content> content, boost::shared_ptr<TextContent> caption);
+ SubtitleAppearanceDialog (wxWindow* parent, std::shared_ptr<const Film> film, std::shared_ptr<Content> content, std::shared_ptr<TextContent> caption);
void apply ();
void active_jobs_changed (boost::optional<std::string> last);
void add_colours ();
- boost::weak_ptr<const Film> _film;
+ std::weak_ptr<const Film> _film;
wxCheckBox* _force_colour;
wxColourPickerCtrl* _colour;
wxCheckBox* _force_effect;
wxStaticText* _finding;
wxFlexGridSizer* _colour_table;
- boost::shared_ptr<Content> _content;
- boost::shared_ptr<TextContent> _caption;
- boost::shared_ptr<FFmpegSubtitleStream> _stream;
+ std::shared_ptr<Content> _content;
+ std::shared_ptr<TextContent> _caption;
+ std::shared_ptr<FFmpegSubtitleStream> _stream;
boost::signals2::scoped_connection _content_connection;
boost::signals2::scoped_connection _job_manager_connection;
- boost::weak_ptr<Job> _job;
+ std::weak_ptr<Job> _job;
static int const NONE;
static int const OUTLINE;
#endif
using std::string;
-using boost::weak_ptr;
-using boost::shared_ptr;
+using std::weak_ptr;
+using std::shared_ptr;
SystemInformationDialog::SystemInformationDialog (wxWindow* parent, weak_ptr<FilmViewer> weak_viewer)
: TableDialog (parent, _("System information"), 2, 1, false)
*/
+
#include "table_dialog.h"
-#include <boost/weak_ptr.hpp>
+#include <memory>
+
class FilmViewer;
class SystemInformationDialog : public TableDialog
{
public:
- SystemInformationDialog (wxWindow* parent, boost::weak_ptr<FilmViewer> viewer);
+ SystemInformationDialog (wxWindow* parent, std::weak_ptr<FilmViewer> viewer);
};
using std::string;
using std::list;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using boost::bind;
/** @param t Original text type of the content, if known */
ContentList sel = _parent->selected_text ();
BOOST_FOREACH (shared_ptr<Content> i, sel) {
/* These are the content types that could include subtitles */
- shared_ptr<const FFmpegContent> fc = boost::dynamic_pointer_cast<const FFmpegContent> (i);
- shared_ptr<const StringTextFileContent> sc = boost::dynamic_pointer_cast<const StringTextFileContent> (i);
- shared_ptr<const DCPContent> dc = boost::dynamic_pointer_cast<const DCPContent> (i);
- shared_ptr<const DCPSubtitleContent> dsc = boost::dynamic_pointer_cast<const DCPSubtitleContent> (i);
+ shared_ptr<const FFmpegContent> fc = std::dynamic_pointer_cast<const FFmpegContent> (i);
+ shared_ptr<const StringTextFileContent> sc = std::dynamic_pointer_cast<const StringTextFileContent> (i);
+ shared_ptr<const DCPContent> dc = std::dynamic_pointer_cast<const DCPContent> (i);
+ shared_ptr<const DCPSubtitleContent> dsc = std::dynamic_pointer_cast<const DCPSubtitleContent> (i);
if (fc) {
if (!fc->text.empty()) {
++ffmpeg_subs;
int _outline_subtitles_row;
int _ccap_track_row;
- boost::weak_ptr<Content> _analysis_content;
+ std::weak_ptr<Content> _analysis_content;
boost::signals2::scoped_connection _analysis_finished_connection;
- boost::shared_ptr<SubtitleAnalysis> _analysis;
+ std::shared_ptr<SubtitleAnalysis> _analysis;
bool _loading_analysis;
};
#include "lib/text_decoder.h"
using std::list;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::bind;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using namespace dcpomatic;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
#include <wx/listctrl.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
class Decoder;
class FilmViewer;
public:
TextView (
wxWindow *,
- boost::shared_ptr<Film>,
- boost::shared_ptr<Content> content,
- boost::shared_ptr<TextContent> caption,
- boost::shared_ptr<Decoder>,
- boost::weak_ptr<FilmViewer> viewer
+ std::shared_ptr<Film>,
+ std::shared_ptr<Content> content,
+ std::shared_ptr<TextContent> caption,
+ std::shared_ptr<Decoder>,
+ std::weak_ptr<FilmViewer> viewer
);
private:
boost::optional<FrameRateChange> _frc;
boost::optional<int> _last_count;
std::vector<dcpomatic::ContentTime> _start_times;
- boost::weak_ptr<Content> _content;
- boost::weak_ptr<FilmViewer> _film_viewer;
+ std::weak_ptr<Content> _content;
+ std::weak_ptr<FilmViewer> _film_viewer;
};
#include "lib/video_content.h"
#include "lib/atmos_mxf_content.h"
#include <wx/graphics.h>
-#include <boost/weak_ptr.hpp>
#include <boost/foreach.hpp>
#include <list>
#include <iterator>
using std::min;
using std::max;
using std::abs;
-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::bind;
using boost::optional;
using namespace dcpomatic;
#include "lib/rect.h"
#include "lib/film.h"
#include <wx/wx.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <boost/signals2.hpp>
class Film;
class Timeline : public wxPanel
{
public:
- Timeline (wxWindow *, ContentPanel *, boost::shared_ptr<Film>, boost::weak_ptr<FilmViewer> viewer);
+ Timeline (wxWindow *, ContentPanel *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
- boost::shared_ptr<const Film> film () const;
+ std::shared_ptr<const Film> film () const;
void force_redraw (dcpomatic::Rect<int> const &);
void zoom_all ();
void update_playhead ();
- boost::shared_ptr<TimelineView> event_to_view (wxMouseEvent &);
+ std::shared_ptr<TimelineView> event_to_view (wxMouseEvent &);
TimelineContentViewList selected_views () const;
ContentList selected_content () const;
void maybe_snap (dcpomatic::DCPTime a, dcpomatic::DCPTime b, boost::optional<dcpomatic::DCPTime>& nearest_distance) const;
wxScrolledCanvas* _labels_canvas;
wxScrolledCanvas* _main_canvas;
ContentPanel* _content_panel;
- boost::weak_ptr<Film> _film;
- boost::weak_ptr<FilmViewer> _viewer;
+ std::weak_ptr<Film> _film;
+ std::weak_ptr<FilmViewer> _viewer;
TimelineViewList _views;
- boost::shared_ptr<TimelineTimeAxisView> _time_axis_view;
- boost::shared_ptr<TimelineReelsView> _reels_view;
- boost::shared_ptr<TimelineLabelsView> _labels_view;
+ std::shared_ptr<TimelineTimeAxisView> _time_axis_view;
+ std::shared_ptr<TimelineReelsView> _reels_view;
+ std::shared_ptr<TimelineLabelsView> _labels_view;
int _tracks;
boost::optional<double> _pixels_per_second;
bool _left_down;
wxPoint _down_point;
boost::optional<wxPoint> _zoom_point;
- boost::shared_ptr<TimelineContentView> _down_view;
+ std::shared_ptr<TimelineContentView> _down_view;
dcpomatic::DCPTime _down_view_position;
bool _first_move;
ContentMenu _menu;
#include "timeline_atmos_content_view.h"
-using boost::shared_ptr;
+using std::shared_ptr;
/** @class TimelineAtmosContentView
* @brief Timeline view for AtmosContent.
class TimelineAtmosContentView : public TimelineContentView
{
public:
- TimelineAtmosContentView (Timeline& tl, boost::shared_ptr<Content> c);
+ TimelineAtmosContentView (Timeline& tl, std::shared_ptr<Content> c);
private:
bool active () const {
#include "lib/util.h"
using std::list;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
/** @class TimelineAudioContentView
* @brief Timeline view for AudioContent.
class TimelineAudioContentView : public TimelineContentView
{
public:
- TimelineAudioContentView (Timeline& tl, boost::shared_ptr<Content> c);
+ TimelineAudioContentView (Timeline& tl, std::shared_ptr<Content> c);
private:
bool active () const {
#include <boost/foreach.hpp>
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
class TimelineContentView : public TimelineView
{
public:
- TimelineContentView (Timeline& tl, boost::shared_ptr<Content> c);
+ TimelineContentView (Timeline& tl, std::shared_ptr<Content> c);
dcpomatic::Rect<int> bbox () const;
void set_selected (bool s);
bool selected () const;
- boost::shared_ptr<Content> content () const;
+ std::shared_ptr<Content> content () const;
void set_track (int t);
void unset_track ();
boost::optional<int> track () const;
protected:
- boost::weak_ptr<Content> _content;
+ std::weak_ptr<Content> _content;
private:
boost::signals2::scoped_connection _content_connection;
};
-typedef std::vector<boost::shared_ptr<TimelineContentView> > TimelineContentViewList;
+typedef std::vector<std::shared_ptr<TimelineContentView> > TimelineContentViewList;
#endif
using std::list;
using std::cout;
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
*/
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <wx/wx.h>
#include "timeline.h"
class TimelineDialog : public wxDialog
{
public:
- TimelineDialog (ContentPanel *, boost::shared_ptr<Film>, boost::weak_ptr<FilmViewer> viewer);
+ TimelineDialog (ContentPanel *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
void set_selection (ContentList selection);
void film_change (ChangeType type, Film::Property);
void tool_clicked (wxCommandEvent& id);
- boost::weak_ptr<Film> _film;
+ std::weak_ptr<Film> _film;
Timeline _timeline;
wxToolBar* _toolbar;
boost::signals2::scoped_connection _film_changed_connection;
#include "lib/text_content.h"
#include "lib/content.h"
-using boost::shared_ptr;
+using std::shared_ptr;
TimelineTextContentView::TimelineTextContentView (Timeline& tl, shared_ptr<Content> c, shared_ptr<TextContent> caption)
: TimelineContentView (tl, c)
class TimelineTextContentView : public TimelineContentView
{
public:
- TimelineTextContentView (Timeline& tl, boost::shared_ptr<Content>, boost::shared_ptr<TextContent>);
+ TimelineTextContentView (Timeline& tl, std::shared_ptr<Content>, std::shared_ptr<TextContent>);
private:
bool active () const;
wxColour background_colour () const;
wxColour foreground_colour () const;
- boost::shared_ptr<TextContent> _caption;
+ std::shared_ptr<TextContent> _caption;
};
#include "lib/video_content.h"
#include "timeline_video_content_view.h"
-using boost::dynamic_pointer_cast;
-using boost::shared_ptr;
+using std::dynamic_pointer_cast;
+using std::shared_ptr;
TimelineVideoContentView::TimelineVideoContentView (Timeline& tl, shared_ptr<Content> c)
: TimelineContentView (tl, c)
class TimelineVideoContentView : public TimelineContentView
{
public:
- TimelineVideoContentView (Timeline& tl, boost::shared_ptr<Content> c);
+ TimelineVideoContentView (Timeline& tl, std::shared_ptr<Content> c);
private:
bool active () const;
dcpomatic::Rect<int> _last_paint_bbox;
};
-typedef std::vector<boost::shared_ptr<TimelineView> > TimelineViewList;
+typedef std::vector<std::shared_ptr<TimelineView> > TimelineViewList;
#endif
using std::cout;
using std::string;
using std::set;
-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;
class TimingPanel : public ContentSubPanel
{
public:
- TimingPanel (ContentPanel *, boost::weak_ptr<FilmViewer> viewer);
+ TimingPanel (ContentPanel *, std::weak_ptr<FilmViewer> viewer);
void film_changed (Film::Property);
void film_content_changed (int);
void setup_sensitivity ();
void add_to_grid ();
- boost::weak_ptr<FilmViewer> _viewer;
+ std::weak_ptr<FilmViewer> _viewer;
wxStaticText* _h_label;
wxStaticText* _m_label;
#include <boost/foreach.hpp>
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
VerifyDCPDialog::VerifyDCPDialog (wxWindow* parent, shared_ptr<VerifyDCPJob> job)
: wxDialog (parent, wxID_ANY, _("DCP verification"))
class VerifyDCPDialog : public wxDialog
{
public:
- VerifyDCPDialog (wxWindow* parent, boost::shared_ptr<VerifyDCPJob> job);
+ VerifyDCPDialog (wxWindow* parent, std::shared_ptr<VerifyDCPJob> job);
private:
wxRichTextCtrl* _text;
#include "lib/job.h"
#include "lib/job_manager.h"
#include <wx/evtloop.h>
-#include <boost/shared_ptr.hpp>
#include <string>
using std::string;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
static int const max_file_name_length = 80;
*/
+
#include "lib/warnings.h"
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
+#include <memory>
class Job;
public:
VerifyDCPProgressDialog (wxWindow* parent, wxString title);
- bool run (boost::shared_ptr<Job> job);
+ bool run (std::shared_ptr<Job> job);
private:
void cancel ();
using std::cout;
using std::list;
using std::set;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using boost::bind;
using boost::optional;
using namespace dcpomatic;
#include <boost/optional.hpp>
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
VideoView::VideoView (FilmViewer* viewer)
#include "lib/timer.h"
#include "lib/types.h"
#include "lib/exception_store.h"
-#include <boost/shared_ptr.hpp>
#include <boost/signals2.hpp>
#include <boost/thread.hpp>
#include <boost/noncopyable.hpp>
virtual NextFrameResult display_next_frame (bool) = 0;
void clear ();
- bool reset_metadata (boost::shared_ptr<const Film> film, dcp::Size player_video_container_size);
+ bool reset_metadata (std::shared_ptr<const Film> film, dcp::Size player_video_container_size);
/** Emitted from the GUI thread when our display changes in size */
boost::signals2::signal<void()> Sized;
return _length;
}
- std::pair<
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> player_video () const {
+ std::pair<
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> player_video () const {
boost::mutex::scoped_lock lm (_mutex);
return _player_video;
}
/** Mutex protecting all the state in this class */
mutable boost::mutex _mutex;
- std::pair<
boost::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> _player_video;
+ std::pair<
std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> _player_video;
int _video_frame_rate;
/** length of the film we are playing, or 0 if there is none */
dcpomatic::DCPTime _length;
using std::cout;
using boost::bind;
-using boost::weak_ptr;
-using boost::shared_ptr;
+using std::weak_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
*/
+
#include "lib/warnings.h"
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/weak_ptr.hpp>
+#include <memory>
+
class VideoWaveformPlot;
class FilmViewer;
class VideoWaveformDialog : public wxDialog
{
public:
- VideoWaveformDialog (wxWindow* parent, boost::weak_ptr<const Film> film, boost::weak_ptr<FilmViewer> viewer);
+ VideoWaveformDialog (wxWindow* parent, std::weak_ptr<const Film> film, std::weak_ptr<FilmViewer> viewer);
private:
void shown (wxShowEvent &);
void contrast_changed ();
void mouse_moved (int x1, int x2, int y1, int y2);
- boost::weak_ptr<FilmViewer> _viewer;
+ std::weak_ptr<FilmViewer> _viewer;
VideoWaveformPlot* _plot;
wxChoice* _component;
wxSlider* _contrast;
using std::min;
using std::max;
using std::string;
-using boost::weak_ptr;
-using boost::shared_ptr;
+using std::weak_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
DCPOMATIC_DISABLE_WARNINGS
#include <wx/wx.h>
DCPOMATIC_ENABLE_WARNINGS
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
#include <boost/signals2.hpp>
namespace dcp {
class VideoWaveformPlot : public wxPanel
{
public:
- VideoWaveformPlot (wxWindow* parent, boost::weak_ptr<const Film> film, boost::weak_ptr<FilmViewer> viewer);
+ VideoWaveformPlot (wxWindow* parent, std::weak_ptr<const Film> film, std::weak_ptr<FilmViewer> viewer);
void set_enabled (bool e);
void set_component (int c);
void paint ();
void sized (wxSizeEvent &);
void create_waveform ();
- void set_image (
boost::shared_ptr<PlayerVideo>);
+ void set_image (
std::shared_ptr<PlayerVideo>);
void mouse_moved (wxMouseEvent &);
- boost::weak_ptr<const Film> _film;
- boost::shared_ptr<dcp::OpenJPEGImage> _image;
- boost::shared_ptr<const Image> _waveform;
+ std::weak_ptr<const Film> _film;
+ std::shared_ptr<dcp::OpenJPEGImage> _image;
+ std::shared_ptr<const Image> _waveform;
bool _dirty;
bool _enabled;
int _component;
using std::string;
using std::vector;
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using dcp::locale_convert;
using namespace dcpomatic;
#include "lib/dcpomatic_log.h"
#include "test.h"
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (fourk_test)
{
using std::string;
using std::vector;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (atmos_passthrough_test)
#include <iostream>
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
static float
using std::string;
using std::cout;
using boost::lexical_cast;
-using boost::shared_ptr;
+using std::shared_ptr;
static
void test_audio_delay (int delay_in_ms)
#include "lib/audio_filter.h"
#include "lib/audio_buffers.h"
-using boost::shared_ptr;
+using std::shared_ptr;
static void
audio_filter_impulse_test_one (AudioFilter& f, int block_size, int num_blocks)
using std::list;
using std::cout;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
using namespace dcpomatic;
using std::cerr;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
#define CHECK_SAMPLE(c,f,r) \
if (fabs(out->data(c)[f] - (r)) > 0.1) { \
#include "test.h"
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
/** Test the mid-side decoder for analysis and DCP-making */
BOOST_AUTO_TEST_CASE (audio_processor_test)
#include <iostream>
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
#define CANARY 9999
using std::cout;
using std::map;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using namespace dcpomatic;
/** Build a small DCP with no picture and a single subtitle overlaid onto it from a SubRip file */
#include "test.h"
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
#include <boost/thread.hpp>
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::thread;
using boost::optional;
-using boost::weak_ptr;
+using std::weak_ptr;
using dcp::ArrayData;
void
#include <boost/test/unit_test.hpp>
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
/** Basic test that Interop closed captions are written */
BOOST_AUTO_TEST_CASE (closed_caption_test1)
#include <iostream>
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (colour_conversion_test1)
{
#include "test.h"
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
/** There has been garbled audio with this piece of content */
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (hash_added_to_imported_dcp_test)
using std::list;
using std::string;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
/* Check that DCPDecoder reuses old data when it should */
BOOST_AUTO_TEST_CASE (check_reuse_old_data_test)
BOOST_REQUIRE (!wait_for_jobs());
shared_ptr<Player> player (new Player(test));
- shared_ptr<DCPDecoder> decoder = boost::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
+ shared_ptr<DCPDecoder> decoder = std::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
BOOST_REQUIRE (decoder);
list<shared_ptr<dcp::Reel> > reels = decoder->reels();
ov_content->set_position (test, dcpomatic::DCPTime(96000));
- decoder = boost::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
+ decoder = std::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
BOOST_REQUIRE (decoder);
BOOST_REQUIRE (reels == decoder->reels());
BOOST_REQUIRE (!wait_for_jobs());
player.reset (new Player(test));
- decoder = boost::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
+ decoder = std::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
BOOST_REQUIRE (decoder);
reels = decoder->reels();
vf_content->add_ov (ov->dir(ov->dcp_name(false)));
JobManager::instance()->add (shared_ptr<Job>(new ExamineContentJob(test, vf_content)));
BOOST_REQUIRE (!wait_for_jobs());
- decoder = boost::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
+ decoder = std::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
BOOST_REQUIRE (decoder);
BOOST_REQUIRE (reels != decoder->reels());
BOOST_REQUIRE (!wait_for_jobs());
player.reset (new Player(test));
- decoder = boost::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
+ decoder = std::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
BOOST_REQUIRE (decoder);
reels = decoder->reels();
encrypted_content->add_kdm (kdm);
JobManager::instance()->add (shared_ptr<Job>(new ExamineContentJob(test, encrypted_content)));
BOOST_REQUIRE (!wait_for_jobs());
- decoder = boost::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
+ decoder = std::dynamic_pointer_cast<DCPDecoder>(player->_pieces.front()->decoder);
BOOST_REQUIRE (decoder);
BOOST_REQUIRE (reels != decoder->reels());
}
#include <boost/test/unit_test.hpp>
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
using std::cout;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
using std::list;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
static string
openssl_hash (boost::filesystem::path file)
#include <boost/test/unit_test.hpp>
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
-using boost::shared_ptr;
+using std::shared_ptr;
static SNDFILE* ref = 0;
static int ref_buffer_size = 0;
static float* ref_buffer = 0;
static void
-audio (
boost::shared_ptr<AudioBuffers> audio, int channels)
+audio (
std::shared_ptr<AudioBuffers> audio, int channels)
{
/* Check that we have a big enough buffer */
BOOST_CHECK (audio->frames() * audio->channels() < ref_buffer_size);
#include <boost/test/unit_test.hpp>
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (ffmpeg_audio_test)
{
#include "lib/video_content.h"
#include "test.h"
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (ffmpeg_dcp_test)
{
using std::vector;
using std::list;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
using std::cout;
using std::cerr;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using boost::bind;
#if BOOST_VERSION >= 106100
#include <boost/test/unit_test.hpp>
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
using namespace dcpomatic;
#include "lib/ffmpeg_audio_stream.h"
#include "test.h"
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
/** Check that the FFmpegExaminer can extract the first video and audio time
#include "lib/audio_content.h"
#include "test.h"
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
BOOST_AUTO_TEST_CASE (ffmpeg_pts_offset_test)
#include <boost/regex.hpp>
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
class Keep
{
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (film_metadata_test)
{
#include "lib/audio_content.h"
#include "test.h"
-using boost::shared_ptr;
+using std::shared_ptr;
/* Test Playlist::best_dcp_frame_rate and FrameRateChange
with a single piece of content.
#include "lib/text_content.h"
#include "lib/util.h"
#include "test.h"
-#include <boost/shared_ptr.hpp>
#include <boost/test/unit_test.hpp>
using std::string;
using std::vector;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
vector<string> current_hints;
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (image_content_fade_test)
{
#include "lib/ffmpeg_image_proxy.h"
#include "lib/j2k_image_proxy.h"
#include "test.h"
-#include <boost/shared_ptr.hpp>
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
static const boost::filesystem::path data_file0 = TestPaths::private_data() / "player_seek_test_0.png";
using std::string;
using std::list;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (aligned_image_test)
{
int N = 0;
for (list<AVPixelFormat>::const_iterator i = pix_fmts.begin(); i != pix_fmts.end(); ++i) {
- boost::shared_ptr<Image> foo (new Image (*i, in_size, true));
+ std::shared_ptr<Image> foo (new Image (*i, in_size, true));
foo->make_black ();
- boost::shared_ptr<Image> bar = foo->scale (out_size, dcp::YUV_TO_RGB_REC601, AV_PIX_FMT_RGB24, true, false);
+ std::shared_ptr<Image> bar = foo->scale (out_size, dcp::YUV_TO_RGB_REC601, AV_PIX_FMT_RGB24, true, false);
uint8_t* p = bar->data()[0];
for (int y = 0; y < bar->size().height; ++y) {
using std::vector;
using std::string;
using std::map;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
/** Make an encrypted DCP, import it and make a new unencrypted DCP */
BOOST_AUTO_TEST_CASE (import_dcp_test)
#include "test.h"
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
/** Interrupt a DCP encode when it is in progress, as this used to (still does?)
* sometimes give an error related to pthreads.
#include <iostream>
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (isdcf_name_test)
{
#include "lib/video_content.h"
#include <dcp/raw_convert.h>
#include <boost/test/unit_test.hpp>
-#include <boost/shared_ptr.hpp>
+
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
static void
check (int target_bits_per_second)
#include "lib/cross.h"
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
class TestJob : public Job
{
#include "lib/kdm_with_metadata.h"
#include "test.h"
#include <boost/test/unit_test.hpp>
-#include <boost/shared_ptr.hpp>
+
using std::list;
using std::string;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
static
bool
using std::string;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
/** Check that FFOC and LFOC are automatically added if not specified */
#include <boost/test/unit_test.hpp>
-using boost::dynamic_pointer_cast;
-using boost::shared_ptr;
+using std::dynamic_pointer_cast;
+using std::shared_ptr;
/** Overlay two video-only bits of content, don't use the video on one and
using std::vector;
using boost::starts_with;
using boost::split;
-using boost::dynamic_pointer_cast;
-using boost::shared_ptr;
+using std::dynamic_pointer_cast;
+using std::shared_ptr;
static
void
using std::cout;
using std::list;
using std::pair;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
using boost::optional;
#if BOOST_VERSION >= 106100
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (pulldown_detect_test1)
using std::cout;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
#include <boost/test/unit_test.hpp>
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
static bool equal (dcp::FrameInfo a, ReelWriter const & writer, shared_ptr<InfoFileHandle> file, Frame frame, Eyes eyes)
using std::cout;
using std::vector;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::function;
using namespace dcpomatic;
using std::string;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::optional;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
/** Check for bug #1126 whereby making a new DCP using the same video asset as an old one
* corrupts the old one.
#include "test.h"
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
/** Check that if we remake a DCP having turned off subtitles the code notices
* and doesn't re-use the old video data.
#include "lib/dcp_content_type.h"
#include "lib/video_content.h"
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (repeat_frame_test)
{
#include "test.h"
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
void check_within_n (int64_t a, int64_t b, int64_t n)
{
using std::pair;
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
static void
resampler_test_one (int from, int to)
#include "test.h"
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
static void scaling_test_for (shared_ptr<Film> film, shared_ptr<Content> content, float ratio, std::string image, string container)
{
#include <boost/test/unit_test.hpp>
using std::list;
-using boost::shared_ptr;
-using boost::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
using std::string;
using boost::lexical_cast;
-using boost::shared_ptr;
+using std::shared_ptr;
static void
test_silence_padding (int channels)
#include "lib/dcp_content_type.h"
#include "lib/video_content.h"
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (skip_frame_test)
{
#include <dcp/raw_convert.h>
#include <boost/thread.hpp>
#include <boost/test/unit_test.hpp>
-#include <boost/shared_ptr.hpp>
#include <cstring>
#include <iostream>
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::bind;
}
private:
- void handle (boost::shared_ptr<Socket> socket)
+ void handle (std::shared_ptr<Socket> socket)
{
boost::mutex::scoped_lock lm (_mutex);
BOOST_REQUIRE (_size);
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
/** Make a very short DCP with a single subtitle from .srt with no specified fonts */
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
/** Make a DCP with subs from a .ssa file */
BOOST_AUTO_TEST_CASE (ssa_subtitle_test1)
using std::pair;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (stream_test)
{
#include "lib/string_text_file_content.h"
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
/** Test parsing of UTF16 CR/LF input */
BOOST_AUTO_TEST_CASE (subtitle_charset_test1)
using std::string;
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (subtitle_language_interop_test)
#include "lib/film.h"
#include "test.h"
#include <boost/filesystem.hpp>
-#include <boost/shared_ptr.hpp>
#include <boost/test/unit_test.hpp>
using std::vector;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (subtitle_metadata_test1)
#include <boost/test/unit_test.hpp>
using std::string;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
/* Check that ReelNumber is setup correctly when making multi-reel subtitled DCPs */
BOOST_AUTO_TEST_CASE (subtitle_reel_number_test)
using std::list;
using std::string;
using boost::optional;
-using boost::shared_ptr;
+using std::shared_ptr;
/* Check that timings are done correctly for multi-reel DCPs with PNG subs */
list<shared_ptr<dcp::Reel> >::const_iterator i = reels.begin ();
BOOST_REQUIRE ((*i)->main_subtitle());
BOOST_REQUIRE ((*i)->main_subtitle()->asset());
- shared_ptr<dcp::InteropSubtitleAsset> A = boost::dynamic_pointer_cast<dcp::InteropSubtitleAsset>((*i)->main_subtitle()->asset());
+ shared_ptr<dcp::InteropSubtitleAsset> A = std::dynamic_pointer_cast<dcp::InteropSubtitleAsset>((*i)->main_subtitle()->asset());
BOOST_REQUIRE (A);
++i;
BOOST_REQUIRE ((*i)->main_subtitle());
BOOST_REQUIRE ((*i)->main_subtitle()->asset());
- shared_ptr<dcp::InteropSubtitleAsset> B = boost::dynamic_pointer_cast<dcp::InteropSubtitleAsset>((*i)->main_subtitle()->asset());
+ shared_ptr<dcp::InteropSubtitleAsset> B = std::dynamic_pointer_cast<dcp::InteropSubtitleAsset>((*i)->main_subtitle()->asset());
BOOST_REQUIRE (B);
BOOST_REQUIRE_EQUAL (A->subtitles().size(), 1U);
#include "test.h"
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
/** Check for no crash when trimming DCP subtitles (#1275) */
using std::cerr;
using std::list;
using std::abs;
-using boost::shared_ptr;
+using std::shared_ptr;
using boost::scoped_array;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
*/
+
#include "lib/warnings.h"
#include <boost/filesystem.hpp>
-#include <boost/shared_ptr.hpp>
+
class Film;
class Image;
extern bool wait_for_jobs ();
extern void setup_test_config ();
-extern boost::shared_ptr<Film> new_test_film (std::string);
-extern boost::shared_ptr<Film> new_test_film2 (std::string);
+extern std::shared_ptr<Film> new_test_film (std::string);
+extern std::shared_ptr<Film> new_test_film2 (std::string);
extern void check_dcp (boost::filesystem::path, boost::filesystem::path);
-extern void check_dcp (boost::filesystem::path, boost::shared_ptr<const Film>);
+extern void check_dcp (boost::filesystem::path, std::shared_ptr<const Film>);
extern void check_file (boost::filesystem::path ref, boost::filesystem::path check);
extern void check_wav_file (boost::filesystem::path ref, boost::filesystem::path check);
extern void check_mxf_audio_file (boost::filesystem::path ref, boost::filesystem::path check);
extern void check_ffmpeg (boost::filesystem::path, boost::filesystem::path, int audio_tolerance);
extern void check_image (boost::filesystem::path, boost::filesystem::path, double threshold = 4);
extern boost::filesystem::path test_film_dir (std::string);
-extern void write_image (boost::shared_ptr<const Image> image, boost::filesystem::path file);
-boost::filesystem::path dcp_file (boost::shared_ptr<const Film> film, std::string prefix);
+extern void write_image (std::shared_ptr<const Image> image, boost::filesystem::path file);
+boost::filesystem::path dcp_file (std::shared_ptr<const Film> film, std::string prefix);
void check_one_frame (boost::filesystem::path dcp, int64_t index, boost::filesystem::path ref);
-extern boost::filesystem::path subtitle_file (boost::shared_ptr<Film> film);
+extern boost::filesystem::path subtitle_file (std::shared_ptr<Film> film);
extern void make_random_file (boost::filesystem::path path, size_t size);
class LogSwitcher
{
public:
- LogSwitcher (boost::shared_ptr<Log> log);
+ LogSwitcher (std::shared_ptr<Log> log);
~LogSwitcher ();
private:
- boost::shared_ptr<Log> _old;
+ std::shared_ptr<Log> _old;
};
#include <iostream>
using std::cout;
-using boost::shared_ptr;
+using std::shared_ptr;
/** Basic sanity check of 3D_LEFT_RIGHT */
BOOST_AUTO_TEST_CASE (threed_test1)
using std::string;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
using namespace dcpomatic;
static string const xml = "<Content>"
using std::list;
using std::cout;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using namespace dcpomatic;
/** Test start/end trim and positioning of some audio content */
#include "lib/upmixer_a.h"
#include "test.h"
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
using std::string;
using std::vector;
using std::list;
-using boost::shared_ptr;
+using std::shared_ptr;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
using std::vector;
using std::string;
-using boost::shared_ptr;
+using std::shared_ptr;
BOOST_AUTO_TEST_CASE (vf_kdm_test)
{
using std::list;
using std::string;
using std::cout;
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
using namespace dcpomatic;
/** Test the logic which decides whether a DCP can be referenced or not */
using std::max;
using std::pair;
using std::string;
-using boost::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
-using boost::shared_ptr;
+using std::shared_ptr;
static
#include <dcp/mono_picture_asset.h>
#include <boost/test/unit_test.hpp>
-using boost::shared_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
static boost::filesystem::path ref_mxf = "test/data/scaling_test_185_185/j2c_c75af074-2809-453c-9192-6affb76b4ba3.mxf";
projects / dcpomatic.git / commitdiff