#endif
}
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::cout;
using boost::shared_ptr;
using boost::dynamic_pointer_cast;
+using boost::make_shared;
int const AnalyseAudioJob::_num_points = 1024;
void
AnalyseAudioJob::run ()
{
- shared_ptr<Player> player (new Player (_film, _playlist));
+ shared_ptr<Player> player = make_shared<Player> (_film, _playlist);
player->set_ignore_video ();
player->set_fast ();
player->set_play_referenced ();
#include <dcp/atmos_asset.h>
#include <dcp/exceptions.h>
#include <libxml++/libxml++.h>
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::list;
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
AtmosMXFContent::AtmosMXFContent (shared_ptr<const Film> film, boost::filesystem::path path)
: Content (film, path)
AtmosMXFContent::valid_mxf (boost::filesystem::path path)
{
try {
- shared_ptr<dcp::AtmosAsset> a (new dcp::AtmosAsset (path));
+ shared_ptr<dcp::AtmosAsset> a = make_shared<dcp::AtmosAsset> (path);
return true;
} catch (dcp::MXFFileError& e) {
{
job->set_progress_unknown ();
Content::examine (job);
- shared_ptr<dcp::AtmosAsset> a (new dcp::AtmosAsset (path(0)));
+ shared_ptr<dcp::AtmosAsset> a = make_shared<dcp::AtmosAsset> (path(0));
{
boost::mutex::scoped_lock lm (_mutex);
#include <libxml++/libxml++.h>
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <stdint.h>
#include <cmath>
#include <cstdio>
using std::max;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
using boost::dynamic_pointer_cast;
AudioAnalysis::AudioAnalysis (int channels)
void
AudioAnalysis::write (boost::filesystem::path filename)
{
- shared_ptr<xmlpp::Document> doc (new xmlpp::Document);
+ shared_ptr<xmlpp::Document> doc = make_shared<xmlpp::Document> ();
xmlpp::Element* root = doc->create_root_node ("AudioAnalysis");
BOOST_FOREACH (vector<AudioPoint>& i, _data) {
#include "audio_buffers.h"
#include "dcpomatic_assert.h"
+#include <boost/make_shared.hpp>
#include <cassert>
#include <cstring>
#include <cmath>
using std::bad_alloc;
using boost::shared_ptr;
+using boost::make_shared;
/** Construct an AudioBuffers. Audio data is undefined after this constructor.
* @param channels Number of channels.
shared_ptr<AudioBuffers>
AudioBuffers::channel (int c) const
{
- shared_ptr<AudioBuffers> o (new AudioBuffers (1, frames ()));
+ shared_ptr<AudioBuffers> o = make_shared<AudioBuffers> (1, frames ());
o->copy_channel_from (this, c, 0);
return o;
}
shared_ptr<AudioBuffers>
AudioBuffers::clone () const
{
- shared_ptr<AudioBuffers> b (new AudioBuffers (channels (), frames ()));
+ shared_ptr<AudioBuffers> b = make_shared<AudioBuffers> (channels (), frames ());
b->copy_from (this, frames (), 0, 0);
return b;
}
return shared_ptr<AudioContent> ();
}
+ /* Can't use make_shared here as the constructor is private */
return shared_ptr<AudioContent> (new AudioContent (parent, node));
}
#include "audio_decoder_stream.h"
#include "audio_content.h"
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::cout;
using std::map;
using boost::shared_ptr;
+using boost::make_shared;
AudioDecoder::AudioDecoder (Decoder* parent, shared_ptr<const AudioContent> content, bool fast, shared_ptr<Log> log)
: _ignore (false)
, _fast (fast)
{
BOOST_FOREACH (AudioStreamPtr i, content->streams ()) {
- _streams[i] = shared_ptr<AudioDecoderStream> (new AudioDecoderStream (content, i, parent, fast, log));
+ _streams[i] = make_shared<AudioDecoderStream> (content, i, parent, fast, log);
}
}
#include "log.h"
#include "audio_content.h"
#include "compose.hpp"
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::max;
using boost::optional;
using boost::shared_ptr;
+using boost::make_shared;
AudioDecoderStream::AudioDecoderStream (shared_ptr<const AudioContent> content, AudioStreamPtr stream, Decoder* decoder, bool fast, shared_ptr<Log> log)
: _content (content)
void
AudioDecoderStream::reset_decoded ()
{
- _decoded = ContentAudio (shared_ptr<AudioBuffers> (new AudioBuffers (_stream->channels(), 0)), 0);
+ _decoded = ContentAudio (make_shared<AudioBuffers> (_stream->channels(), 0), 0);
}
ContentAudio
Frame const to_return = max ((Frame) 0, min (available, length));
/* Copy our data to the output */
- shared_ptr<AudioBuffers> out (new AudioBuffers (_decoded.audio->channels(), to_return));
+ shared_ptr<AudioBuffers> out = make_shared<AudioBuffers> (_decoded.audio->channels(), to_return);
out->copy_from (_decoded.audio.get(), to_return, decoded_offset, 0);
Frame const remaining = max ((Frame) 0, available - to_return);
Frame const delta_frames = delta.frames_round (frame_rate);
if (delta_frames > 0) {
/* This data comes after the seek time. Pad the data with some silence. */
- shared_ptr<AudioBuffers> padded (new AudioBuffers (data->channels(), data->frames() + delta_frames));
+ shared_ptr<AudioBuffers> padded = make_shared<AudioBuffers> (data->channels(), data->frames() + delta_frames);
padded->make_silent ();
padded->copy_from (data.get(), data->frames(), 0, delta_frames);
data = padded;
*/
return;
}
- shared_ptr<AudioBuffers> trimmed (new AudioBuffers (data->channels(), to_keep));
+ shared_ptr<AudioBuffers> trimmed = make_shared<AudioBuffers> (data->channels(), to_keep);
trimmed->copy_from (data.get(), to_keep, to_discard, 0);
data = trimmed;
time += ContentTime::from_frames (to_discard, frame_rate);
#include "audio_delay.h"
#include "audio_buffers.h"
#include "dcpomatic_assert.h"
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
AudioDelay::AudioDelay (int samples)
: _samples (samples)
/* You can't call this with varying channel counts */
DCPOMATIC_ASSERT (!_tail || in->channels() == _tail->channels());
- shared_ptr<AudioBuffers> out (new AudioBuffers (in->channels(), in->frames()));
+ shared_ptr<AudioBuffers> out = make_shared<AudioBuffers> (in->channels(), in->frames());
if (in->frames() > _samples) {
#include "audio_filter.h"
#include "audio_buffers.h"
+#include <boost/make_shared.hpp>
#include <cmath>
using std::min;
using boost::shared_ptr;
+using boost::make_shared;
/** @return array of floats which the caller must destroy with delete[] */
float *
shared_ptr<AudioBuffers>
AudioFilter::run (shared_ptr<const AudioBuffers> in)
{
- shared_ptr<AudioBuffers> out (new AudioBuffers (in->channels(), in->frames()));
+ shared_ptr<AudioBuffers> out = make_shared<AudioBuffers> (in->channels(), in->frames());
if (!_tail) {
_tail.reset (new AudioBuffers (in->channels(), _M + 1));
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
}
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::string;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
AudioFilterGraph::AudioFilterGraph (int sample_rate, int channels)
: _sample_rate (sample_rate)
the constructor) so we need to create new buffers with some extra
silent channels.
*/
- shared_ptr<AudioBuffers> extended_buffers (new AudioBuffers (process_channels, buffers->frames()));
+ shared_ptr<AudioBuffers> extended_buffers = make_shared<AudioBuffers> (process_channels, buffers->frames());
for (int i = 0; i < buffers->channels(); ++i) {
extended_buffers->copy_channel_from (buffers.get(), i, i);
}
#include <dcp/raw_convert.h>
#include <libxml++/libxml++.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::list;
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
Cinema::Cinema (cxml::ConstNodePtr node)
: name (node->string_child ("Name"))
{
list<cxml::NodePtr> s = node->node_children ("Screen");
for (list<cxml::NodePtr>::iterator i = s.begin(); i != s.end(); ++i) {
- add_screen (shared_ptr<Screen> (new Screen (*i)));
+ add_screen (make_shared<Screen> (*i));
}
}
#include "log.h"
#include <zip.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::string;
using std::runtime_error;
using boost::shared_ptr;
+using boost::make_shared;
void
CinemaKDMs::make_zip_file (string film_name, boost::filesystem::path zip_file) const
list<shared_ptr<string> > kdm_strings;
BOOST_FOREACH (ScreenKDM const & i, screen_kdms) {
- shared_ptr<string> kdm (new string (i.kdm.as_xml ()));
+ shared_ptr<string> kdm = boost::make_shared<string> (i.kdm.as_xml ());
kdm_strings.push_back (kdm);
struct zip_source* source = zip_source_buffer (zip, kdm->c_str(), kdm->length(), 0);
#include <boost/algorithm/string.hpp>
#include <boost/foreach.hpp>
#include <boost/thread.hpp>
+#include <boost/make_shared.hpp>
#include <cstdlib>
#include <fstream>
#include <iostream>
using std::exception;
using std::cerr;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
using boost::algorithm::trim;
cxml::NodePtr signer = f.optional_node_child ("Signer");
if (signer) {
- shared_ptr<dcp::CertificateChain> c (new dcp::CertificateChain ());
+ shared_ptr<dcp::CertificateChain> c = make_shared<dcp::CertificateChain> ();
/* Read the signing certificates and private key in from the config file */
BOOST_FOREACH (cxml::NodePtr i, signer->node_children ("Certificate")) {
c->add (dcp::Certificate (i->content ()));
cxml::NodePtr decryption = f.optional_node_child ("Decryption");
if (decryption) {
- shared_ptr<dcp::CertificateChain> c (new dcp::CertificateChain ());
+ shared_ptr<dcp::CertificateChain> c = make_shared<dcp::CertificateChain> ();
BOOST_FOREACH (cxml::NodePtr i, decryption->node_children ("Certificate")) {
c->add (dcp::Certificate (i->content ()));
}
/* Slightly grotty two-part construction of Cinema here so that we can use
shared_from_this.
*/
- shared_ptr<Cinema> cinema (new Cinema (*i));
+ shared_ptr<Cinema> cinema = make_shared<Cinema> (*i);
cinema->read_screens (*i);
_cinemas.push_back (cinema);
}
#include <dcp/reel.h>
#include <libxml++/libxml++.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iterator>
#include <iostream>
using std::vector;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
using boost::scoped_ptr;
using boost::optional;
using boost::function;
job->set_progress_unknown ();
Content::examine (job);
- shared_ptr<DCPExaminer> examiner (new DCPExaminer (shared_from_this ()));
+ shared_ptr<DCPExaminer> examiner = make_shared<DCPExaminer> (shared_from_this ());
video->take_from_examiner (examiner);
set_default_colour_conversion ();
#include <dcp/sound_frame.h>
#include <dcp/sound_asset_reader.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::list;
using std::cout;
using boost::shared_ptr;
using boost::dynamic_pointer_cast;
+using boost::make_shared;
DCPDecoder::DCPDecoder (shared_ptr<const DCPContent> c, shared_ptr<Log> log, bool fast)
: _dcp_content (c)
shared_ptr<dcp::PictureAsset> asset = (*_reel)->main_picture()->asset ();
int64_t const entry_point = (*_reel)->main_picture()->entry_point ();
if (_mono_reader) {
- video->give (shared_ptr<ImageProxy> (new J2KImageProxy (_mono_reader->get_frame (entry_point + frame), asset->size())), _offset + frame);
+ video->give (make_shared<J2KImageProxy> (_mono_reader->get_frame (entry_point + frame), asset->size()), _offset + frame);
} else {
video->give (
- shared_ptr<ImageProxy> (new J2KImageProxy (_stereo_reader->get_frame (entry_point + frame), asset->size(), dcp::EYE_LEFT)),
+ make_shared<J2KImageProxy> (_stereo_reader->get_frame (entry_point + frame), asset->size(), dcp::EYE_LEFT),
_offset + frame
);
video->give (
- shared_ptr<ImageProxy> (new J2KImageProxy (_stereo_reader->get_frame (entry_point + frame), asset->size(), dcp::EYE_RIGHT)),
+ make_shared<J2KImageProxy> (_stereo_reader->get_frame (entry_point + frame), asset->size(), dcp::EYE_RIGHT),
_offset + frame
);
}
int const channels = _dcp_content->audio->stream()->channels ();
int const frames = sf->size() / (3 * channels);
- shared_ptr<AudioBuffers> data (new AudioBuffers (channels, frames));
+ shared_ptr<AudioBuffers> data = make_shared<AudioBuffers> (channels, frames);
for (int i = 0; i < frames; ++i) {
for (int j = 0; j < channels; ++j) {
data->data()[j][i] = static_cast<int> ((from[0] << 8) | (from[1] << 16) | (from[2] << 24)) / static_cast<float> (INT_MAX - 256);
#include <dcp/interop_load_font_node.h>
#include <libxml++/libxml++.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::list;
using boost::shared_ptr;
using boost::dynamic_pointer_cast;
+using boost::make_shared;
DCPSubtitleContent::DCPSubtitleContent (shared_ptr<const Film> film, boost::filesystem::path path)
: Content (film, path)
_length = ContentTime::from_seconds (sc->latest_subtitle_out().as_seconds ());
BOOST_FOREACH (shared_ptr<dcp::LoadFontNode> i, sc->load_font_nodes ()) {
- subtitle->add_font (shared_ptr<Font> (new Font (i->id)));
+ subtitle->add_font (boost::make_shared<Font> (i->id));
}
}
#include <libxml++/libxml++.h>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
+#include <boost/make_shared.hpp>
#include <stdint.h>
#include <iomanip>
#include <iostream>
using std::string;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
using dcp::Size;
using dcp::Data;
boost::asio::ip::tcp::resolver::query query (serv.host_name(), raw_convert<string> (Config::instance()->server_port_base ()));
boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve (query);
- shared_ptr<Socket> socket (new Socket (timeout));
+ shared_ptr<Socket> socket = make_shared<Socket> (timeout);
socket->connect (*endpoint_iterator);
#include "video_mxf_content.h"
#include "video_mxf_decoder.h"
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
using std::list;
using boost::shared_ptr;
using boost::dynamic_pointer_cast;
+using boost::make_shared;
shared_ptr<Decoder>
decoder_factory (shared_ptr<const Content> content, shared_ptr<Log> log, bool fast)
{
shared_ptr<const FFmpegContent> fc = dynamic_pointer_cast<const FFmpegContent> (content);
if (fc) {
- return shared_ptr<Decoder> (new FFmpegDecoder (fc, log, fast));
+ return make_shared<FFmpegDecoder> (fc, log, fast);
}
shared_ptr<const DCPContent> dc = dynamic_pointer_cast<const DCPContent> (content);
if (dc) {
- return shared_ptr<Decoder> (new DCPDecoder (dc, log, fast));
+ return make_shared<DCPDecoder> (dc, log, fast);
}
shared_ptr<const ImageContent> ic = dynamic_pointer_cast<const ImageContent> (content);
if (ic) {
- return shared_ptr<Decoder> (new ImageDecoder (ic, log));
+ return make_shared<ImageDecoder> (ic, log);
}
shared_ptr<const TextSubtitleContent> rc = dynamic_pointer_cast<const TextSubtitleContent> (content);
if (rc) {
- return shared_ptr<Decoder> (new TextSubtitleDecoder (rc));
+ return make_shared<TextSubtitleDecoder> (rc);
}
shared_ptr<const DCPSubtitleContent> dsc = dynamic_pointer_cast<const DCPSubtitleContent> (content);
if (dsc) {
- return shared_ptr<Decoder> (new DCPSubtitleDecoder (dsc));
+ return make_shared<DCPSubtitleDecoder> (dsc);
}
shared_ptr<const VideoMXFContent> vmc = dynamic_pointer_cast<const VideoMXFContent> (content);
if (vmc) {
- return shared_ptr<Decoder> (new VideoMXFDecoder (vmc, log));
+ return make_shared<VideoMXFDecoder> (vmc, log);
}
return shared_ptr<Decoder> ();
#include <boost/algorithm/string.hpp>
#include <boost/scoped_array.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <string>
#include <vector>
#include <iostream>
using boost::bind;
using boost::scoped_array;
using boost::optional;
+using boost::make_shared;
using dcp::Size;
using dcp::Data;
socket->read (reinterpret_cast<uint8_t*> (buffer.get()), length);
string s (buffer.get());
- shared_ptr<cxml::Document> xml (new cxml::Document ("EncodingRequest"));
+ shared_ptr<cxml::Document> xml = make_shared<cxml::Document> ("EncodingRequest");
xml->read_string (s);
/* This is a double-check; the server shouldn't even be on the candidate list
if it is the wrong version, but it doesn't hurt to make sure here.
return -1;
}
- shared_ptr<PlayerVideo> pvf (new PlayerVideo (xml, socket));
+ shared_ptr<PlayerVideo> pvf = make_shared<PlayerVideo> (xml, socket);
DCPVideo dcp_video_frame (pvf, xml, _log);
if (_verbose) {
cout << "Offering services to master " << _broadcast.send_endpoint.address().to_string () << "\n";
}
- shared_ptr<Socket> socket (new Socket);
+ shared_ptr<Socket> socket = make_shared<Socket> ();
try {
socket->connect (boost::asio::ip::tcp::endpoint (_broadcast.send_endpoint.address(), Config::instance()->server_port_base() + 1));
socket->write (xml.length() + 1);
#include "raw_convert.h"
#include <libcxml/cxml.h>
#include <boost/lambda/lambda.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using boost::shared_ptr;
using boost::scoped_array;
using boost::weak_ptr;
+using boost::make_shared;
EncodeServerFinder* EncodeServerFinder::_instance = 0;
void
EncodeServerFinder::start_accept ()
{
- shared_ptr<Socket> socket (new Socket ());
+ shared_ptr<Socket> socket = make_shared<Socket> ();
_listen_acceptor->async_accept (
socket->socket(),
boost::bind (&EncodeServerFinder::handle_accept, this, boost::asio::placeholders::error, socket)
socket->read (reinterpret_cast<uint8_t*> (buffer.get()), length);
string s (buffer.get());
- shared_ptr<cxml::Document> xml (new cxml::Document ("ServerAvailable"));
+ shared_ptr<cxml::Document> xml = make_shared<cxml::Document> ("ServerAvailable");
xml->read_string (s);
string const ip = socket->socket().remote_endpoint().address().to_string ();
}
#include <libxml++/libxml++.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::make_pair;
using std::max;
using boost::shared_ptr;
+using boost::make_shared;
using boost::dynamic_pointer_cast;
using boost::optional;
list<cxml::NodePtr> c = node->node_children ("SubtitleStream");
for (list<cxml::NodePtr>::const_iterator i = c.begin(); i != c.end(); ++i) {
- _subtitle_streams.push_back (shared_ptr<FFmpegSubtitleStream> (new FFmpegSubtitleStream (*i, version)));
+ _subtitle_streams.push_back (make_shared<FFmpegSubtitleStream> (*i, version));
if ((*i)->optional_number_child<int> ("Selected")) {
_subtitle_stream = _subtitle_streams.back ();
}
c = node->node_children ("AudioStream");
for (list<cxml::NodePtr>::const_iterator i = c.begin(); i != c.end(); ++i) {
- shared_ptr<FFmpegAudioStream> as (new FFmpegAudioStream (*i, version));
+ shared_ptr<FFmpegAudioStream> as = make_shared<FFmpegAudioStream> (*i, version);
audio->add_stream (as);
if (version < 11 && !(*i)->optional_node_child ("Selected")) {
/* This is an old file and this stream is not selected, so un-map it */
Content::examine (job);
- shared_ptr<FFmpegExaminer> examiner (new FFmpegExaminer (shared_from_this (), job));
+ shared_ptr<FFmpegExaminer> examiner = make_shared<FFmpegExaminer> (shared_from_this (), job);
if (examiner->has_video ()) {
video.reset (new VideoContent (this));
}
#include <boost/foreach.hpp>
#include <boost/algorithm/string.hpp>
+#include <boost/make_shared.hpp>
#include <vector>
#include <iomanip>
#include <iostream>
using std::max;
using std::map;
using boost::shared_ptr;
+using boost::make_shared;
using boost::is_any_of;
using boost::split;
using dcp::Size;
*/
int const total_samples = size / bytes_per_audio_sample (stream);
int const frames = total_samples / stream->channels();
- shared_ptr<AudioBuffers> audio (new AudioBuffers (stream->channels(), frames));
+ shared_ptr<AudioBuffers> audio = make_shared<AudioBuffers> (stream->channels(), frames);
switch (audio_sample_format (stream)) {
case AV_SAMPLE_FMT_U8:
if (i->second != AV_NOPTS_VALUE) {
double const pts = i->second * av_q2d (_format_context->streams[_video_stream.get()]->time_base) + _pts_offset.seconds ();
video->give (
- shared_ptr<ImageProxy> (new RawImageProxy (image)),
+ make_shared<RawImageProxy> (image),
llrint (pts * _ffmpeg_content->active_video_frame_rate ())
);
} else {
/* Note RGBA is expressed little-endian, so the first byte in the word is R, second
G, third B, fourth A.
*/
- shared_ptr<Image> image (new Image (AV_PIX_FMT_RGBA, dcp::Size (rect->w, rect->h), true));
+ shared_ptr<Image> image = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (rect->w, rect->h), true);
#ifdef DCPOMATIC_HAVE_AVSUBTITLERECT_PICT
/* Start of the first line in the subtitle */
#include "util.h"
#include "safe_stringstream.h"
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::cout;
using std::max;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
/** @param job job that the examiner is operating in, or 0 */
);
} else if (s->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
- _subtitle_streams.push_back (shared_ptr<FFmpegSubtitleStream> (new FFmpegSubtitleStream (subtitle_stream_name (s), s->id)));
+ _subtitle_streams.push_back (boost::make_shared<FFmpegSubtitleStream> (subtitle_stream_name (s), s->id));
}
}
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <boost/regex.hpp>
#include <unistd.h>
#include <stdexcept>
using boost::dynamic_pointer_cast;
using boost::optional;
using boost::is_any_of;
+using boost::make_shared;
#define LOG_GENERAL(...) log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL);
#define LOG_GENERAL_NC(...) log()->log (__VA_ARGS__, LogEntry::TYPE_GENERAL);
throw MissingSettingError (_("name"));
}
- JobManager::instance()->add (shared_ptr<Job> (new TranscodeJob (shared_from_this())));
+ JobManager::instance()->add (make_shared<TranscodeJob> (shared_from_this()));
}
/** Start a job to send our DCP to the configured TMS */
void
Film::send_dcp_to_tms ()
{
- shared_ptr<Job> j (new UploadJob (shared_from_this()));
+ shared_ptr<Job> j = make_shared<UploadJob> (shared_from_this());
JobManager::instance()->add (j);
}
shared_ptr<xmlpp::Document>
Film::metadata () const
{
- shared_ptr<xmlpp::Document> doc (new xmlpp::Document);
+ shared_ptr<xmlpp::Document> doc = make_shared<xmlpp::Document> ();
xmlpp::Element* root = doc->create_root_node ("Metadata");
root->add_child("Version")->add_child_text (raw_convert<string> (current_state_version));
void
Film::examine_content (shared_ptr<Content> c)
{
- shared_ptr<Job> j (new ExamineContentJob (shared_from_this(), c));
+ shared_ptr<Job> j = make_shared<ExamineContentJob> (shared_from_this(), c);
JobManager::instance()->add (j);
}
run_ffprobe (c->path(0), file ("ffprobe.log"), _log);
}
- shared_ptr<Job> j (new ExamineContentJob (shared_from_this(), c));
+ shared_ptr<Job> j = make_shared<ExamineContentJob> (shared_from_this(), c);
_job_connections.push_back (
j->Finished.connect (bind (&Film::maybe_add_content, this, weak_ptr<Job> (j), weak_ptr<Content> (c)))
add_content (content);
if (Config::instance()->automatic_audio_analysis() && content->audio) {
- shared_ptr<Playlist> playlist (new Playlist);
+ shared_ptr<Playlist> playlist = make_shared<Playlist> ();
playlist->add (content);
boost::signals2::connection c;
JobManager::instance()->analyse_audio (
dcp::Formulation formulation
) const
{
- shared_ptr<const dcp::CPL> cpl (new dcp::CPL (cpl_file));
+ shared_ptr<const dcp::CPL> cpl = make_shared<dcp::CPL> (cpl_file);
shared_ptr<const dcp::CertificateChain> signer = Config::instance()->signer_chain ();
if (!signer->valid ()) {
throw InvalidSignerError ();
#include <libavutil/pixdesc.h>
#include <libavutil/frame.h>
}
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::list;
using std::runtime_error;
using boost::shared_ptr;
+using boost::make_shared;
using dcp::Size;
int
To get around this, we ask Image to overallocate its buffers by the overrun.
*/
- shared_ptr<Image> out (new Image (out_format, out_size, out_aligned, (out_size.width - inter_size.width) / 2));
+ shared_ptr<Image> out = make_shared<Image> (out_format, out_size, out_aligned, (out_size.width - inter_size.width) / 2);
out->make_black ();
/* Size of the image after any crop */
*/
DCPOMATIC_ASSERT (aligned ());
- shared_ptr<Image> scaled (new Image (out_format, out_size, out_aligned));
+ shared_ptr<Image> scaled = make_shared<Image> (out_format, out_size, out_aligned);
struct SwsContext* scale_context = sws_getContext (
size().width, size().height, pixel_format(),
all.extend (dcpomatic::Rect<int> (i->position, i->image->size().width, i->image->size().height));
}
- shared_ptr<Image> merged (new Image (images.front().image->pixel_format (), dcp::Size (all.width, all.height), true));
+ shared_ptr<Image> merged = make_shared<Image> (images.front().image->pixel_format (), dcp::Size (all.width, all.height), true);
merged->make_transparent ();
for (list<PositionImage>::const_iterator i = images.begin(); i != images.end(); ++i) {
merged->alpha_blend (i->image, i->position - all.position());
#include <libcxml/cxml.h>
#include <libxml++/libxml++.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::cout;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
ImageContent::ImageContent (shared_ptr<const Film> film, boost::filesystem::path p)
: Content (film)
shared_ptr<const Film> film = _film.lock ();
DCPOMATIC_ASSERT (film);
- shared_ptr<ImageExaminer> examiner (new ImageExaminer (film, shared_from_this(), job));
+ shared_ptr<ImageExaminer> examiner = make_shared<ImageExaminer> (film, shared_from_this(), job);
video->take_from_examiner (examiner);
set_default_colour_conversion ();
}
#include "cross.h"
#include <dcp/util.h>
#include <libcxml/cxml.h>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::cout;
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
shared_ptr<ImageProxy>
image_proxy_factory (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket)
{
if (xml->string_child("Type") == N_("Raw")) {
- return shared_ptr<ImageProxy> (new RawImageProxy (xml, socket));
+ return make_shared<RawImageProxy> (xml, socket);
} else if (xml->string_child("Type") == N_("Magick")) {
- return shared_ptr<MagickImageProxy> (new MagickImageProxy (xml, socket));
+ return make_shared<MagickImageProxy> (xml, socket);
} else if (xml->string_child("Type") == N_("J2K")) {
- return shared_ptr<J2KImageProxy> (new J2KImageProxy (xml, socket));
+ return make_shared<J2KImageProxy> (xml, socket);
}
throw NetworkError (_("Unexpected image type received by server"));
#include <dcp/j2k.h>
#include <libcxml/cxml.h>
#include <libxml++/libxml++.h>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using boost::shared_ptr;
using boost::optional;
using boost::dynamic_pointer_cast;
+using boost::make_shared;
using dcp::Data;
/** Construct a J2KImageProxy from a JPEG2000 file */
}
}
- shared_ptr<Image> image (new Image (pixel_format(), _size, true));
+ shared_ptr<Image> image = make_shared<Image> (pixel_format(), _size, true);
/* Copy data in whatever format (sRGB or XYZ) into our Image; I'm assuming
the data is 12-bit either way.
#include "util.h"
#include "film.h"
#include "transcode_job.h"
+#include <boost/make_shared.hpp>
#include <iostream>
using std::string;
using std::list;
using boost::thread;
using boost::shared_ptr;
+using boost::make_shared;
using boost::dynamic_pointer_cast;
using boost::asio::ip::tcp;
tcp::acceptor a (io_service, tcp::endpoint (tcp::v4 (), port));
while (true) {
try {
- shared_ptr<tcp::socket> s (new tcp::socket (io_service));
+ shared_ptr<tcp::socket> s = make_shared<tcp::socket> (io_service);
a.accept (*s);
handle (s);
}
#include "config.h"
#include "safe_stringstream.h"
#include "string_log_entry.h"
+#include <boost/make_shared.hpp>
#include <time.h>
#include <cstdio>
using std::string;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
Log::Log ()
: _types (0)
return;
}
- shared_ptr<StringLogEntry> e (new StringLogEntry (type, message));
+ shared_ptr<StringLogEntry> e = boost::make_shared<StringLogEntry> (type, message);
do_log (e);
}
{
switch (type) {
case dcp::DCP_PROGRESS:
- do_log (shared_ptr<const LogEntry> (new StringLogEntry (LogEntry::TYPE_GENERAL, m)));
+ do_log (boost::make_shared<const StringLogEntry> (LogEntry::TYPE_GENERAL, m));
break;
case dcp::DCP_ERROR:
- do_log (shared_ptr<const LogEntry> (new StringLogEntry (LogEntry::TYPE_ERROR, m)));
+ do_log (boost::make_shared<const StringLogEntry> (LogEntry::TYPE_ERROR, m));
break;
case dcp::DCP_NOTE:
- do_log (shared_ptr<const LogEntry> (new StringLogEntry (LogEntry::TYPE_WARNING, m)));
+ do_log (boost::make_shared<const StringLogEntry> (LogEntry::TYPE_WARNING, m));
break;
}
}
#include "mid_side_decoder.h"
#include "audio_buffers.h"
#include "audio_mapping.h"
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::min;
using std::vector;
using boost::shared_ptr;
+using boost::make_shared;
string
MidSideDecoder::name () const
shared_ptr<AudioProcessor>
MidSideDecoder::clone (int) const
{
- return shared_ptr<AudioProcessor> (new MidSideDecoder ());
+ return make_shared<MidSideDecoder> ();
}
shared_ptr<AudioBuffers>
MidSideDecoder::run (shared_ptr<const AudioBuffers> in, int channels)
{
int const N = min (channels, 3);
- shared_ptr<AudioBuffers> out (new AudioBuffers (channels, in->frames ()));
+ shared_ptr<AudioBuffers> out = make_shared<AudioBuffers> (channels, in->frames ());
for (int i = 0; i < in->frames(); ++i) {
float const left = in->data()[0][i];
float const right = in->data()[1][i];
#include <dcp/reel_subtitle_asset.h>
#include <dcp/reel_picture_asset.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <stdint.h>
#include <algorithm>
#include <iostream>
using std::make_pair;
using std::copy;
using boost::shared_ptr;
+using boost::make_shared;
using boost::weak_ptr;
using boost::dynamic_pointer_cast;
using boost::optional;
decoder->audio->set_ignore ();
}
- _pieces.push_back (shared_ptr<Piece> (new Piece (i, decoder, frc)));
+ _pieces.push_back (make_shared<Piece> (i, decoder, frc));
}
_have_valid_pieces = true;
{
return shared_ptr<PlayerVideo> (
new PlayerVideo (
- shared_ptr<const ImageProxy> (new RawImageProxy (_black_image)),
+ make_shared<RawImageProxy> (_black_image),
time,
Crop (),
optional<double> (),
Frame const length_frames = length.frames_round (_film->audio_frame_rate ());
- shared_ptr<AudioBuffers> audio (new AudioBuffers (_film->audio_channels(), length_frames));
+ shared_ptr<AudioBuffers> audio = make_shared<AudioBuffers> (_film->audio_channels(), length_frames);
audio->make_silent ();
list<shared_ptr<Piece> > ov = overlaps (time, time + length, has_audio);
/* Gain */
if (i->content->audio->gain() != 0) {
- shared_ptr<AudioBuffers> gain (new AudioBuffers (all.audio));
+ shared_ptr<AudioBuffers> gain = make_shared<AudioBuffers> (all.audio);
gain->apply_gain (i->content->audio->gain ());
all.audio = gain;
}
/* Remap channels */
- shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->audio_channels(), all.audio->frames()));
+ shared_ptr<AudioBuffers> dcp_mapped = make_shared<AudioBuffers> (_film->audio_channels(), all.audio->frames());
dcp_mapped->make_silent ();
AudioMapping map = j->mapping ();
for (int i = 0; i < map.input_channels(); ++i) {
#include <dcp/interop_subtitle_asset.h>
#include <dcp/smpte_subtitle_asset.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::string;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
using boost::dynamic_pointer_cast;
using dcp::Data;
shared_ptr<dcp::Reel>
ReelWriter::create_reel (list<ReferencedReelAsset> const & refs, list<shared_ptr<Font> > const & fonts)
{
- shared_ptr<dcp::Reel> reel (new dcp::Reel ());
+ shared_ptr<dcp::Reel> reel = make_shared<dcp::Reel> ();
shared_ptr<dcp::ReelPictureAsset> reel_picture_asset;
if (_sound_asset) {
/* We have made a sound asset of our own. Put it into the reel */
- reel->add (shared_ptr<dcp::ReelSoundAsset> (new dcp::ReelSoundAsset (_sound_asset, 0)));
+ reel->add (make_shared<dcp::ReelSoundAsset> (_sound_asset, 0));
} else {
/* We don't have a sound asset of our own; hopefully we have one to reference */
BOOST_FOREACH (ReferencedReelAsset j, refs) {
lang = "Unknown";
}
if (_film->interop ()) {
- shared_ptr<dcp::InteropSubtitleAsset> s (new dcp::InteropSubtitleAsset ());
+ shared_ptr<dcp::InteropSubtitleAsset> s = make_shared<dcp::InteropSubtitleAsset> ();
s->set_movie_title (_film->name ());
s->set_language (lang);
s->set_reel_number ("1");
_subtitle_asset = s;
} else {
- shared_ptr<dcp::SMPTESubtitleAsset> s (new dcp::SMPTESubtitleAsset ());
+ shared_ptr<dcp::SMPTESubtitleAsset> s = make_shared<dcp::SMPTESubtitleAsset> ();
s->set_content_title_text (_film->name ());
s->set_language (lang);
s->set_edit_rate (dcp::Fraction (_film->video_frame_rate (), 1));
#include <cairomm/cairomm.h>
#include <pangomm.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::list;
using std::cerr;
using std::make_pair;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
static FcConfig* fc_config = 0;
/* ...and add a bit more for luck */
height += target.height / 11;
- shared_ptr<Image> image (new Image (AV_PIX_FMT_RGBA, dcp::Size (target.width, height), false));
+ shared_ptr<Image> image = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (target.width, height), false);
image->make_black ();
#ifdef DCPOMATIC_HAVE_FORMAT_STRIDE_FOR_WIDTH
#include "compose.hpp"
#include "dcpomatic_assert.h"
#include <samplerate.h>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::make_pair;
using std::runtime_error;
using boost::shared_ptr;
+using boost::make_shared;
/** @param in Input sampling rate (Hz)
* @param out Output sampling rate (Hz)
int in_frames = in->frames ();
int in_offset = 0;
int out_offset = 0;
- shared_ptr<AudioBuffers> resampled (new AudioBuffers (_channels, 0));
+ shared_ptr<AudioBuffers> resampled = make_shared<AudioBuffers> (_channels, 0);
while (in_frames > 0) {
shared_ptr<const AudioBuffers>
Resampler::flush ()
{
- shared_ptr<AudioBuffers> out (new AudioBuffers (_channels, 0));
+ shared_ptr<AudioBuffers> out = make_shared<AudioBuffers> (_channels, 0);
int out_offset = 0;
int64_t const output_size = 65536;
#include "server.h"
#include "dcpomatic_socket.h"
+#include <boost/make_shared.hpp>
#include "i18n.h"
using boost::shared_ptr;
+using boost::make_shared;
Server::Server (int port)
: _terminate (false)
}
}
- shared_ptr<Socket> socket (new Socket);
+ shared_ptr<Socket> socket = make_shared<Socket> ();
_acceptor.async_accept (socket->socket (), boost::bind (&Server::handle_accept, this, socket, boost::asio::placeholders::error));
}
#include <libcxml/cxml.h>
#include <libxml++/libxml++.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::cout;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
using boost::dynamic_pointer_cast;
int const SubtitleContentProperty::X_OFFSET = 500;
return shared_ptr<SubtitleContent> ();
}
+ /* Can't use make_shared here as the constructor is private */
return shared_ptr<SubtitleContent> (new SubtitleContent (parent, node, version));
}
list<cxml::NodePtr> fonts = node->node_children ("Font");
for (list<cxml::NodePtr>::const_iterator i = fonts.begin(); i != fonts.end(); ++i) {
- _fonts.push_back (shared_ptr<Font> (new Font (*i)));
+ _fonts.push_back (make_shared<Font> (*i));
}
connect_to_fonts ();
#include "raw_convert.h"
#include "subtitle_content.h"
#include <libxml++/libxml++.h>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::string;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
TextSubtitleContent::TextSubtitleContent (shared_ptr<const Film> film, boost::filesystem::path path)
: Content (film, path)
boost::mutex::scoped_lock lm (_mutex);
_length = s.length ();
- subtitle->add_font (shared_ptr<Font> (new Font (TEXT_FONT_ID)));
+ subtitle->add_font (make_shared<Font> (TEXT_FONT_ID));
}
string
#include "log.h"
#include "safe_stringstream.h"
#include "compose.hpp"
+#include <boost/make_shared.hpp>
#include <iostream>
#include <iomanip>
using std::setprecision;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
/** @param s Film to use.
*/
_transcoder.reset ();
if (_film->upload_after_make_dcp ()) {
- shared_ptr<Job> job (new UploadJob (_film));
+ shared_ptr<Job> job = make_shared<UploadJob> (_film);
JobManager::instance()->add (job);
}
#include "upmixer_a.h"
#include "audio_buffers.h"
#include "audio_mapping.h"
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::min;
using std::vector;
using boost::shared_ptr;
+using boost::make_shared;
UpmixerA::UpmixerA (int sampling_rate)
: _left (0.02, 1900.0 / sampling_rate, 4800.0 / sampling_rate)
shared_ptr<AudioProcessor>
UpmixerA::clone (int sampling_rate) const
{
- return shared_ptr<AudioProcessor> (new UpmixerA (sampling_rate));
+ return make_shared<UpmixerA> (sampling_rate);
}
shared_ptr<AudioBuffers>
all_out.push_back (_ls.run (in_L));
all_out.push_back (_rs.run (in_R));
- shared_ptr<AudioBuffers> out (new AudioBuffers (channels, in->frames ()));
+ shared_ptr<AudioBuffers> out = make_shared<AudioBuffers> (channels, in->frames ());
int const N = min (channels, 6);
for (int i = 0; i < N; ++i) {
#include "upmixer_b.h"
#include "audio_buffers.h"
#include "audio_mapping.h"
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::min;
using std::vector;
using boost::shared_ptr;
+using boost::make_shared;
UpmixerB::UpmixerB (int sampling_rate)
: _lfe (0.01, 150.0 / sampling_rate)
shared_ptr<AudioProcessor>
UpmixerB::clone (int sampling_rate) const
{
- return shared_ptr<AudioProcessor> (new UpmixerB (sampling_rate));
+ return make_shared<UpmixerB> (sampling_rate);
}
shared_ptr<AudioBuffers>
UpmixerB::run (shared_ptr<const AudioBuffers> in, int channels)
{
- shared_ptr<AudioBuffers> out (new AudioBuffers (channels, in->frames()));
+ shared_ptr<AudioBuffers> out = make_shared<AudioBuffers> (channels, in->frames());
/* L + R minus 6dB (in terms of amplitude) */
shared_ptr<AudioBuffers> in_LR = in->channel(0);
shared_ptr<AudioBuffers> S;
if (channels > 4) {
/* Ls is L - R with some delay */
- shared_ptr<AudioBuffers> sub (new AudioBuffers (1, in->frames()));
+ shared_ptr<AudioBuffers> sub = make_shared<AudioBuffers> (1, in->frames());
sub->copy_channel_from (in.get(), 0, 0);
float* p = sub->data (0);
float const * q = in->data (1);
return shared_ptr<VideoContent> ();
}
+ /* Can't use make_shared here as the constructor is private */
return shared_ptr<VideoContent> (new VideoContent (parent, node, version));
}
#include "log.h"
#include "compose.hpp"
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include "i18n.h"
using std::max;
using std::back_inserter;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
VideoDecoder::VideoDecoder (Decoder* parent, shared_ptr<const Content> c, shared_ptr<Log> log)
}
/* Fill with black... */
- shared_ptr<const ImageProxy> filler_image (new RawImageProxy (_black_image));
+ shared_ptr<const ImageProxy> filler_image = make_shared<RawImageProxy> (_black_image);
Part filler_part = PART_WHOLE;
/* ...unless there's some video we can fill with */
VideoDecoder::fill_both_eyes (VideoFrame from, VideoFrame to)
{
/* Fill with black... */
- shared_ptr<const ImageProxy> filler_left_image (new RawImageProxy (_black_image));
- shared_ptr<const ImageProxy> filler_right_image (new RawImageProxy (_black_image));
+ shared_ptr<const ImageProxy> filler_left_image = make_shared<RawImageProxy> (_black_image);
+ shared_ptr<const ImageProxy> filler_right_image = make_shared<RawImageProxy> (_black_image);
Part filler_left_part = PART_WHOLE;
Part filler_right_part = PART_WHOLE;
#include <libavfilter/buffersrc.h>
#include <libavfilter/buffersink.h>
}
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::string;
using std::make_pair;
using boost::shared_ptr;
+using boost::make_shared;
VideoFilterGraph::VideoFilterGraph (dcp::Size s, AVPixelFormat p)
: _size (s)
list<pair<shared_ptr<Image>, int64_t> > images;
if (_copy) {
- images.push_back (make_pair (shared_ptr<Image> (new Image (frame)), av_frame_get_best_effort_timestamp (frame)));
+ images.push_back (make_pair (make_shared<Image> (frame), av_frame_get_best_effort_timestamp (frame)));
} else {
int r = av_buffersrc_write_frame (_buffer_src_context, frame);
if (r < 0) {
break;
}
- images.push_back (make_pair (shared_ptr<Image> (new Image (_frame)), av_frame_get_best_effort_timestamp (_frame)));
+ images.push_back (make_pair (make_shared<Image> (_frame), av_frame_get_best_effort_timestamp (_frame)));
av_frame_unref (_frame);
}
}
{
return "buffersink";
}
-
#include <dcp/stereo_picture_asset.h>
#include <dcp/exceptions.h>
#include <libxml++/libxml++.h>
+#include <boost/make_shared.hpp>
#include "i18n.h"
using std::list;
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
VideoMXFContent::VideoMXFContent (shared_ptr<const Film> film, boost::filesystem::path path)
: Content (film, path)
VideoMXFContent::valid_mxf (boost::filesystem::path path)
{
try {
- shared_ptr<dcp::MonoPictureAsset> mp (new dcp::MonoPictureAsset (path));
+ shared_ptr<dcp::MonoPictureAsset> mp = make_shared<dcp::MonoPictureAsset> (path);
return true;
} catch (dcp::MXFFileError& e) {
}
try {
- shared_ptr<dcp::StereoPictureAsset> sp (new dcp::StereoPictureAsset (path));
+ shared_ptr<dcp::StereoPictureAsset> sp = make_shared<dcp::StereoPictureAsset> (path);
return true;
} catch (dcp::MXFFileError& e) {
Content::examine (job);
video.reset (new VideoContent (this));
- shared_ptr<VideoMXFExaminer> examiner (new VideoMXFExaminer (shared_from_this ()));
+ shared_ptr<VideoMXFExaminer> examiner = make_shared<VideoMXFExaminer> (shared_from_this ());
video->take_from_examiner (examiner);
}
#include <dcp/stereo_picture_asset.h>
#include <dcp/stereo_picture_asset_reader.h>
#include <dcp/exceptions.h>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
VideoMXFDecoder::VideoMXFDecoder (shared_ptr<const VideoMXFContent> content, shared_ptr<Log> log)
: _content (content)
}
if (_mono_reader) {
- video->give (shared_ptr<ImageProxy> (new J2KImageProxy (_mono_reader->get_frame(frame), _size)), frame);
+ video->give (make_shared<J2KImageProxy> (_mono_reader->get_frame(frame), _size), frame);
} else {
- video->give (shared_ptr<ImageProxy> (new J2KImageProxy (_stereo_reader->get_frame(frame), _size, dcp::EYE_LEFT)), frame);
- video->give (shared_ptr<ImageProxy> (new J2KImageProxy (_stereo_reader->get_frame(frame), _size, dcp::EYE_RIGHT)), frame);
+ video->give (make_shared<J2KImageProxy> (_stereo_reader->get_frame(frame), _size, dcp::EYE_LEFT), frame);
+ video->give (make_shared<J2KImageProxy> (_stereo_reader->get_frame(frame), _size, dcp::EYE_RIGHT), frame);
}
_next += ContentTime::from_frames (1, vfr);
#endif
#include <boost/filesystem.hpp>
#include <boost/noncopyable.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
#include <fstream>
#include <sstream>
using boost::shared_ptr;
using boost::dynamic_pointer_cast;
using boost::optional;
+using boost::make_shared;
class FilmChangedDialog : public boost::noncopyable
{
void new_film (boost::filesystem::path path)
{
- shared_ptr<Film> film (new Film (path));
+ shared_ptr<Film> film = make_shared<Film> (path);
film->write_metadata ();
film->set_name (path.filename().generic_string());
set_film (film);
void load_film (boost::filesystem::path file)
try
{
- shared_ptr<Film> film (new Film (file));
+ shared_ptr<Film> film = make_shared<Film> (file);
list<string> const notes = film->read_metadata ();
if (film->state_version() == 4) {
);
} else {
JobManager::instance()->add (
- shared_ptr<Job> (new SendKDMEmailJob (
- _film->name(),
- _film->dcp_name(),
- d->from(),
- d->until(),
- CinemaKDMs::collect (screen_kdms),
- _film->log()
- ))
+ boost::make_shared<SendKDMEmailJob> (
+ _film->name(),
+ _film->dcp_name(),
+ d->from(),
+ d->until(),
+ CinemaKDMs::collect (screen_kdms),
+ _film->log()
+ )
);
}
} catch (dcp::NotEncryptedError& e) {
#include <wx/cmdline.h>
#include <wx/preferences.h>
#include <wx/wx.h>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::exception;
using std::string;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
using boost::thread;
using boost::scoped_array;
void start_job (boost::filesystem::path path)
{
try {
- shared_ptr<Film> film (new Film (path));
+ shared_ptr<Film> film = make_shared<Film> (path);
film->read_metadata ();
film->make_dcp ();
} catch (std::exception& e) {
#include "lib/video_content.h"
#include <libxml++/libxml++.h>
#include <boost/filesystem.hpp>
+#include <boost/make_shared.hpp>
#include <getopt.h>
#include <string>
#include <iostream>
using std::list;
using std::exception;
using boost::shared_ptr;
+using boost::make_shared;
using boost::dynamic_pointer_cast;
static void
}
try {
- shared_ptr<Film> film (new Film (output, false));
+ shared_ptr<Film> film = make_shared<Film> (output, false);
film->set_name (name);
film->set_container (container_ratio);
#endif
#include <boost/bind.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#ifdef check
#undef check
using std::string;
using std::vector;
using boost::shared_ptr;
+using boost::make_shared;
using boost::bind;
enum {
if (film_name.empty ()) {
film_name = decrypted.content_title_text ();
}
- shared_ptr<Job> job (new SendKDMEmailJob (
- film_name,
- decrypted.content_title_text(),
- _timing->from(), _timing->until(),
- CinemaKDMs::collect (screen_kdms),
- shared_ptr<Log> ()
- ));
+ shared_ptr<Job> job = boost::make_shared<SendKDMEmailJob> (
+ film_name,
+ decrypted.content_title_text(),
+ _timing->from(), _timing->until(),
+ CinemaKDMs::collect (screen_kdms),
+ shared_ptr<Log> ()
+ );
JobManager::instance()->add (job);
if (_job_view) {
#include "lib/player.h"
#include "lib/player_video.h"
#include "lib/encode_server_description.h"
+#include <boost/make_shared.hpp>
#include <getopt.h>
#include <iostream>
#include <iomanip>
using std::string;
using std::pair;
using boost::shared_ptr;
+using boost::make_shared;
using dcp::Data;
static shared_ptr<Film> film;
static EncodeServerDescription* server;
-static shared_ptr<FileLog> log_ (new FileLog ("servomatictest.log"));
+static shared_ptr<FileLog> log_ = make_shared<FileLog> ("servomatictest.log");
static int frame_count = 0;
void
process_video (shared_ptr<PlayerVideo> pvf)
{
- shared_ptr<DCPVideo> local (new DCPVideo (pvf, frame_count, film->video_frame_rate(), 250000000, RESOLUTION_2K, log_));
- shared_ptr<DCPVideo> remote (new DCPVideo (pvf, frame_count, film->video_frame_rate(), 250000000, RESOLUTION_2K, log_));
+ shared_ptr<DCPVideo> local = make_shared<DCPVideo> (pvf, frame_count, film->video_frame_rate(), 250000000, RESOLUTION_2K, log_);
+ shared_ptr<DCPVideo> remote = make_shared<DCPVideo> (pvf, frame_count, film->video_frame_rate(), 250000000, RESOLUTION_2K, log_);
cout << "Frame " << frame_count << ": ";
cout.flush ();
film.reset (new Film (film_dir));
film->read_metadata ();
- shared_ptr<Player> player (new Player (film, film->playlist ()));
+ shared_ptr<Player> player = make_shared<Player> (film, film->playlist ());
DCPTime const frame = DCPTime::from_frames (1, film->video_frame_rate ());
for (DCPTime t; t < film->length(); t += frame) {
#include "lib/audio_content.h"
#include <wx/spinctrl.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::vector;
using std::pair;
using boost::dynamic_pointer_cast;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
AudioPanel::AudioPanel (ContentPanel* p)
if (sel.size() != 1) {
_peak->SetLabel (wxT (""));
} else {
- shared_ptr<Playlist> playlist (new Playlist);
+ shared_ptr<Playlist> playlist = make_shared<Playlist> ();
playlist->add (sel.front ());
try {
- shared_ptr<AudioAnalysis> analysis (new AudioAnalysis (_parent->film()->audio_analysis_path (playlist)));
+ shared_ptr<AudioAnalysis> analysis = make_shared<AudioAnalysis> (_parent->film()->audio_analysis_path (playlist));
if (analysis->sample_peak ()) {
float const peak_dB = 20 * log10 (analysis->sample_peak().get()) + analysis->gain_correction (playlist);
if (peak_dB > -3) {
#include <dcp/modified_gamma_transfer_function.h>
#include <wx/spinctrl.h>
#include <wx/gbsizer.h>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::string;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
using boost::dynamic_pointer_cast;
ColourConversionEditor::ColourConversionEditor (wxWindow* parent, bool yuv)
if (_input_gamma_linearised->GetValue ()) {
conversion.set_in (
- shared_ptr<dcp::ModifiedGammaTransferFunction> (
- new dcp::ModifiedGammaTransferFunction (
- _input_power->GetValue (),
- raw_convert<double> (wx_to_std (_input_threshold->GetValue ())),
- raw_convert<double> (wx_to_std (_input_A->GetValue ())),
- raw_convert<double> (wx_to_std (_input_B->GetValue ()))
- )
+ make_shared<dcp::ModifiedGammaTransferFunction> (
+ _input_power->GetValue (),
+ raw_convert<double> (wx_to_std (_input_threshold->GetValue ())),
+ raw_convert<double> (wx_to_std (_input_A->GetValue ())),
+ raw_convert<double> (wx_to_std (_input_B->GetValue ()))
)
);
} else {
- conversion.set_in (
- shared_ptr<dcp::GammaTransferFunction> (new dcp::GammaTransferFunction (_input_gamma->GetValue ()))
- );
+ conversion.set_in (make_shared<dcp::GammaTransferFunction> (_input_gamma->GetValue ()));
}
conversion.set_yuv_to_rgb (static_cast<dcp::YUVToRGB> (_yuv_to_rgb->GetSelection ()));
conversion.unset_adjusted_white ();
}
- conversion.set_out (shared_ptr<dcp::GammaTransferFunction> (new dcp::GammaTransferFunction (2.6)));
+ conversion.set_out (make_shared<dcp::GammaTransferFunction> (2.6));
return conversion;
}
#include <wx/wx.h>
#include <wx/dirdlg.h>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using std::vector;
using std::exception;
using boost::shared_ptr;
+using boost::make_shared;
using boost::weak_ptr;
using boost::dynamic_pointer_cast;
}
try {
- shared_ptr<FFmpegContent> joined (new FFmpegContent (film, fc));
+ shared_ptr<FFmpegContent> joined = boost::make_shared<FFmpegContent> (film, fc);
BOOST_FOREACH (shared_ptr<Content> i, _content) {
film->remove_content (i);
}
return;
}
- shared_ptr<Job> j (new ExamineContentJob (film, content));
+ shared_ptr<Job> j = make_shared<ExamineContentJob> (film, content);
_job_connection = j->Finished.connect (
bind (
#include <wx/richtext/richtextctrl.h>
#include <boost/algorithm/string.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
using std::max;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
using boost::dynamic_pointer_cast;
boost::filesystem::path path = film->audio_analysis_path (film->playlist ());
if (boost::filesystem::exists (path)) {
- shared_ptr<AudioAnalysis> an (new AudioAnalysis (path));
+ shared_ptr<AudioAnalysis> an = make_shared<AudioAnalysis> (path);
if (an->sample_peak() || an->true_peak()) {
float const peak = max (an->sample_peak().get_value_or(0), an->true_peak().get_value_or(0));
float const peak_dB = 20 * log10 (peak) + an->gain_correction (film->playlist ());
*/
/** @file src/job_manager_view.cc
- * @brief Class generating a GTK widget to show the progress of jobs.
+ * @brief Class generating a widget to show the progress of jobs.
*/
#include "job_manager_view.h"
#include "lib/util.h"
#include "lib/exceptions.h"
#include "lib/compose.hpp"
+#include <boost/make_shared.hpp>
#include <iostream>
using std::string;
using std::min;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
using boost::weak_ptr;
/** Must be called in the GUI thread */
{
shared_ptr<Job> job = j.lock ();
if (job) {
- _job_records.push_back (shared_ptr<JobView> (new JobView (job, this, _panel, _table)));
+ _job_records.push_back (make_shared<JobView> (job, this, _panel, _table));
}
}
#include "lib/job_manager.h"
#include "lib/send_problem_report_job.h"
#include <wx/sizer.h>
+#include <boost/make_shared.hpp>
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
/** @param film Film that we are working on, or 0 */
ReportProblemDialog::ReportProblemDialog (wxWindow* parent, shared_ptr<Film> film)
return;
}
- JobManager::instance()->add (shared_ptr<Job> (new SendProblemReportJob (_film, wx_to_std (_email->GetValue ()), wx_to_std (_summary->GetValue ()))));
+ JobManager::instance()->add (boost::make_shared<SendProblemReportJob> (_film, wx_to_std (_email->GetValue ()), wx_to_std (_summary->GetValue ())));
}
#include "cinema_dialog.h"
#include "screen_dialog.h"
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
using std::list;
using std::pair;
using std::string;
using std::make_pair;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
ScreensPanel::ScreensPanel (wxWindow* parent)
{
CinemaDialog* d = new CinemaDialog (this, _("Add Cinema"));
if (d->ShowModal () == wxID_OK) {
- shared_ptr<Cinema> c (new Cinema (d->name(), d->emails(), d->notes(), d->utc_offset_hour(), d->utc_offset_minute()));
+ shared_ptr<Cinema> c = boost::make_shared<Cinema> (d->name(), d->emails(), d->notes(), d->utc_offset_hour(), d->utc_offset_minute());
Config::instance()->add_cinema (c);
add_cinema (c);
}
return;
}
- shared_ptr<Screen> s (new Screen (d->name(), d->recipient(), d->trusted_devices()));
+ shared_ptr<Screen> s = boost::make_shared<Screen> (d->name(), d->recipient(), d->trusted_devices());
c->add_screen (s);
optional<wxTreeItemId> id = add_screen (c, s);
if (id) {
#include <wx/graphics.h>
#include <boost/weak_ptr.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <list>
#include <iostream>
using std::cout;
using std::max;
using boost::shared_ptr;
+using boost::make_shared;
using boost::weak_ptr;
using boost::dynamic_pointer_cast;
using boost::bind;
BOOST_FOREACH (shared_ptr<Content> i, film->content ()) {
if (i->video) {
- _views.push_back (shared_ptr<TimelineView> (new TimelineVideoContentView (*this, i)));
+ _views.push_back (make_shared<TimelineVideoContentView> (*this, i));
}
if (i->audio && !i->audio->mapping().mapped_output_channels().empty ()) {
- _views.push_back (shared_ptr<TimelineView> (new TimelineAudioContentView (*this, i)));
+ _views.push_back (make_shared<TimelineAudioContentView> (*this, i));
}
if (i->subtitle) {
- _views.push_back (shared_ptr<TimelineView> (new TimelineSubtitleContentView (*this, i)));
+ _views.push_back (make_shared<TimelineSubtitleContentView> (*this, i));
}
if (dynamic_pointer_cast<AtmosMXFContent> (i)) {
- _views.push_back (shared_ptr<TimelineView> (new TimelineAtmosContentView (*this, i)));
+ _views.push_back (make_shared<TimelineAtmosContentView> (*this, i));
}
}
* The output is checked against test/data/4k_test.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/film.h"
#include "lib/ffmpeg_content.h"
#include "lib/dcp_content_type.h"
#include "lib/video_content.h"
#include "lib/ratio.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (fourk_test)
{
shared_ptr<Film> film = new_test_film ("4k_test");
film->set_name ("4k_test");
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->set_resolution (RESOLUTION_4K);
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
film->set_container (Ratio::from_id ("185"));
* @brief Check audio analysis code.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/audio_analysis.h"
#include "lib/analyse_audio_job.h"
#include "lib/film.h"
#include "lib/job_manager.h"
#include "lib/audio_content.h"
#include "test.h"
+#include <boost/make_shared.hpp>
+#include <boost/test/unit_test.hpp>
using boost::shared_ptr;
+using boost::make_shared;
static float
random_float ()
film->set_name ("audio_analysis_test");
boost::filesystem::path p = private_data / "betty_L.wav";
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, p));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, p);
film->examine_and_add_content (c);
wait_for_jobs ();
- shared_ptr<AnalyseAudioJob> job (new AnalyseAudioJob (film, film->playlist ()));
+ shared_ptr<AnalyseAudioJob> job = make_shared<AnalyseAudioJob> (film, film->playlist ());
job->Finished.connect (boost::bind (&finished));
JobManager::instance()->add (job);
wait_for_jobs ();
{
shared_ptr<Film> film = new_test_film ("audio_analysis_negative_delay_test");
film->set_name ("audio_analysis_negative_delay_test");
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, private_data / "boon_telly.mkv"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, private_data / "boon_telly.mkv");
film->examine_and_add_content (c);
wait_for_jobs ();
c->audio->set_delay (-250);
- shared_ptr<AnalyseAudioJob> job (new AnalyseAudioJob (film, film->playlist ()));
+ shared_ptr<AnalyseAudioJob> job = make_shared<AnalyseAudioJob> (film, film->playlist ());
job->Finished.connect (boost::bind (&finished));
JobManager::instance()->add (job);
wait_for_jobs ();
{
shared_ptr<Film> film = new_test_film ("audio_analysis_test2");
film->set_name ("audio_analysis_test2");
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, private_data / "3d_thx_broadway_2010_lossless.m2ts"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, private_data / "3d_thx_broadway_2010_lossless.m2ts");
film->examine_and_add_content (c);
wait_for_jobs ();
- shared_ptr<AnalyseAudioJob> job (new AnalyseAudioJob (film, film->playlist ()));
+ shared_ptr<AnalyseAudioJob> job = make_shared<AnalyseAudioJob> (film, film->playlist ());
job->Finished.connect (boost::bind (&finished));
JobManager::instance()->add (job);
wait_for_jobs ();
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/white.wav"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/white.wav");
film->examine_and_add_content (content);
wait_for_jobs ();
#include "lib/audio_content.h"
#include "lib/film.h"
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <cassert>
#include <iostream>
using std::cout;
using std::min;
using boost::shared_ptr;
+using boost::make_shared;
class TestAudioContent : public Content
{
_test_audio_content->audio_length() - _position
);
- shared_ptr<AudioBuffers> buffers (new AudioBuffers (_test_audio_content->audio->stream()->channels(), N));
+ shared_ptr<AudioBuffers> buffers = make_shared<AudioBuffers> (_test_audio_content->audio->stream()->channels(), N);
for (int i = 0; i < _test_audio_content->audio->stream()->channels(); ++i) {
for (int j = 0; j < N; ++j) {
buffers->data(i)[j] = j + _position;
* The output is checked algorithmically using knowledge of the input.
*/
-#include <boost/test/unit_test.hpp>
-#include <dcp/sound_frame.h>
-#include <dcp/cpl.h>
-#include <dcp/reel.h>
-#include <dcp/sound_asset.h>
-#include <dcp/sound_asset_reader.h>
-#include <dcp/reel_sound_asset.h>
#include "lib/ffmpeg_content.h"
#include "lib/dcp_content_type.h"
#include "lib/ratio.h"
#include "lib/film.h"
#include "lib/audio_content.h"
#include "test.h"
+#include <dcp/sound_frame.h>
+#include <dcp/cpl.h>
+#include <dcp/reel.h>
+#include <dcp/sound_asset.h>
+#include <dcp/sound_asset_reader.h>
+#include <dcp/reel_sound_asset.h>
+#include <boost/make_shared.hpp>
+#include <boost/test/unit_test.hpp>
#include <iostream>
using std::string;
using std::cout;
using boost::lexical_cast;
using boost::shared_ptr;
+using boost::make_shared;
static
void test_audio_delay (int delay_in_ms)
film->set_container (Ratio::from_id ("185"));
film->set_name (film_name);
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/staircase.wav"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/staircase.wav");
film->examine_and_add_content (content);
wait_for_jobs ();
content->audio->set_delay (delay_in_ms);
* @brief Basic tests of audio filters.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/audio_filter.h"
#include "lib/audio_buffers.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
static void
audio_filter_impulse_test_one (AudioFilter& f, int block_size, int num_blocks)
for (int i = 0; i < num_blocks; ++i) {
- shared_ptr<AudioBuffers> in (new AudioBuffers (1, block_size));
+ shared_ptr<AudioBuffers> in = make_shared<AudioBuffers> (1, block_size);
for (int j = 0; j < block_size; ++j) {
in->data()[0][j] = c + j;
}
{
LowPassAudioFilter lpf (0.02, 0.3);
- shared_ptr<AudioBuffers> in (new AudioBuffers (1, 1751));
+ shared_ptr<AudioBuffers> in = make_shared<AudioBuffers> (1, 1751);
in->make_silent ();
in->data(0)[0] = 1;
#include "lib/audio_delay.h"
#include "lib/audio_buffers.h"
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <cmath>
#include <iostream>
using std::cerr;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
#define CHECK_SAMPLE(c,f,r) \
if (fabs(out->data(c)[f] - (r)) > 0.1) { \
int const C = 2;
- shared_ptr<AudioBuffers> in (new AudioBuffers (C, 256));
+ shared_ptr<AudioBuffers> in = make_shared<AudioBuffers> (C, 256);
for (int i = 0; i < C; ++i) {
for (int j = 0; j < 256; ++j) {
in->data(i)[j] = j;
/* Feeding 4 blocks of 64 should give silence each time */
for (int i = 0; i < 4; ++i) {
- shared_ptr<AudioBuffers> in (new AudioBuffers (C, 64));
+ shared_ptr<AudioBuffers> in = make_shared<AudioBuffers> (C, 64);
for (int j = 0; j < C; ++j) {
for (int k = 0; k < 64; ++k) {
in->data(j)[k] = k + i * 64;
/* Now feed 4 blocks of silence and we should see the data */
for (int i = 0; i < 4; ++i) {
/* Feed some silence */
- shared_ptr<AudioBuffers> in (new AudioBuffers (C, 64));
+ shared_ptr<AudioBuffers> in = make_shared<AudioBuffers> (C, 64);
in->make_silent ();
shared_ptr<AudioBuffers> out = delay.run (in);
#include "lib/film.h"
#include "test.h"
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
/** Test the mid-side decoder for analysis and DCP-making */
BOOST_AUTO_TEST_CASE (audio_processor_test)
{
shared_ptr<Film> film = new_test_film ("audio_processor_test");
film->set_name ("audio_processor_test");
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, "test/data/white.wav"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, "test/data/white.wav");
film->examine_and_add_content (c);
wait_for_jobs ();
film->set_audio_processor (AudioProcessor::from_id ("mid-side-decoder"));
/* Analyse the audio and check it doesn't crash */
- shared_ptr<AnalyseAudioJob> job (new AnalyseAudioJob (film, film->playlist ()));
+ shared_ptr<AnalyseAudioJob> job = make_shared<AnalyseAudioJob> (film, film->playlist ());
JobManager::instance()->add (job);
wait_for_jobs ();
*/
-#include <boost/test/unit_test.hpp>
#include "lib/image_content.h"
#include "lib/dcp_content_type.h"
#include "lib/film.h"
#include "lib/ratio.h"
#include "lib/video_content.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
/** @file test/black_fill_test.cc
* @brief Test insertion of black frames between separate bits of video content.
*/
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (black_fill_test)
{
film->set_name ("black_fill_test");
film->set_container (Ratio::from_id ("185"));
film->set_sequence (false);
- shared_ptr<ImageContent> contentA (new ImageContent (film, "test/data/simple_testcard_640x480.png"));
- shared_ptr<ImageContent> contentB (new ImageContent (film, "test/data/simple_testcard_640x480.png"));
+ shared_ptr<ImageContent> contentA = make_shared<ImageContent> (film, "test/data/simple_testcard_640x480.png");
+ shared_ptr<ImageContent> contentB = make_shared<ImageContent> (film, "test/data/simple_testcard_640x480.png");
film->examine_and_add_content (contentA);
film->examine_and_add_content (contentB);
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
- shared_ptr<TextSubtitleContent> content (new TextSubtitleContent (film, "test/data/subrip2.srt"));
+ shared_ptr<TextSubtitleContent> content = make_shared<TextSubtitleContent> (film, "test/data/subrip2.srt");
content->set_use_subtitles (true);
content->set_burn_subtitles (true);
film->examine_and_add_content (content, true);
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
film->set_burn_subtitles (true);
- shared_ptr<DCPSubtitleContent> content (new DCPSubtitleContent (film, "test/data/dcp_sub.xml"));
+ shared_ptr<DCPSubtitleContent> content = make_shared<DCPSubtitleContent> (film, "test/data/dcp_sub.xml");
content->set_use_subtitles (true);
film->examine_and_add_content (content, true);
wait_for_jobs ();
#include "lib/file_log.h"
#include <boost/test/unit_test.hpp>
#include <boost/thread.hpp>
+#include <boost/make_shared.hpp>
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
using boost::thread;
using boost::optional;
using dcp::Data;
BOOST_AUTO_TEST_CASE (client_server_test_rgb)
{
- shared_ptr<Image> image (new Image (AV_PIX_FMT_RGB24, dcp::Size (1998, 1080), true));
+ shared_ptr<Image> image = make_shared<Image> (AV_PIX_FMT_RGB24, dcp::Size (1998, 1080), true);
uint8_t* p = image->data()[0];
for (int y = 0; y < 1080; ++y) {
p += image->stride()[0];
}
- shared_ptr<Image> sub_image (new Image (AV_PIX_FMT_RGBA, dcp::Size (100, 200), true));
+ shared_ptr<Image> sub_image = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (100, 200), true);
p = sub_image->data()[0];
for (int y = 0; y < 200; ++y) {
uint8_t* q = p;
p += sub_image->stride()[0];
}
- shared_ptr<FileLog> log (new FileLog ("build/test/client_server_test_rgb.log"));
+ shared_ptr<FileLog> log = make_shared<FileLog> ("build/test/client_server_test_rgb.log");
shared_ptr<PlayerVideo> pvf (
new PlayerVideo (
- shared_ptr<ImageProxy> (new RawImageProxy (image)),
+ make_shared<RawImageProxy> (image),
DCPTime (),
Crop (),
optional<double> (),
BOOST_AUTO_TEST_CASE (client_server_test_yuv)
{
- shared_ptr<Image> image (new Image (AV_PIX_FMT_YUV420P, dcp::Size (1998, 1080), true));
+ shared_ptr<Image> image = make_shared<Image> (AV_PIX_FMT_YUV420P, dcp::Size (1998, 1080), true);
for (int i = 0; i < image->planes(); ++i) {
uint8_t* p = image->data()[i];
}
}
- shared_ptr<Image> sub_image (new Image (AV_PIX_FMT_RGBA, dcp::Size (100, 200), true));
+ shared_ptr<Image> sub_image = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (100, 200), true);
uint8_t* p = sub_image->data()[0];
for (int y = 0; y < 200; ++y) {
uint8_t* q = p;
p += sub_image->stride()[0];
}
- shared_ptr<FileLog> log (new FileLog ("build/test/client_server_test_yuv.log"));
+ shared_ptr<FileLog> log = make_shared<FileLog> ("build/test/client_server_test_yuv.log");
shared_ptr<PlayerVideo> pvf (
new PlayerVideo (
- shared_ptr<ImageProxy> (new RawImageProxy (image)),
+ make_shared<RawImageProxy> (image),
DCPTime (),
Crop (),
optional<double> (),
BOOST_AUTO_TEST_CASE (client_server_test_j2k)
{
- shared_ptr<Image> image (new Image (AV_PIX_FMT_YUV420P, dcp::Size (1998, 1080), true));
+ shared_ptr<Image> image = make_shared<Image> (AV_PIX_FMT_YUV420P, dcp::Size (1998, 1080), true);
for (int i = 0; i < image->planes(); ++i) {
uint8_t* p = image->data()[i];
}
}
- shared_ptr<FileLog> log (new FileLog ("build/test/client_server_test_j2k.log"));
+ shared_ptr<FileLog> log = make_shared<FileLog> ("build/test/client_server_test_j2k.log");
shared_ptr<PlayerVideo> raw_pvf (
new PlayerVideo (
- shared_ptr<ImageProxy> (new RawImageProxy (image)),
+ make_shared<RawImageProxy> (image),
DCPTime (),
Crop (),
optional<double> (),
shared_ptr<PlayerVideo> j2k_pvf (
new PlayerVideo (
- shared_ptr<ImageProxy> (new J2KImageProxy (raw_locally_encoded, dcp::Size (1998, 1080))),
+ /* This J2KImageProxy constructor is private, so no make_shared */
+ shared_ptr<J2KImageProxy> (new J2KImageProxy (raw_locally_encoded, dcp::Size (1998, 1080))),
DCPTime (),
Crop (),
optional<double> (),
#include <libxml++/libxml++.h>
#include <boost/test/unit_test.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (colour_conversion_test1)
{
xmlpp::Document out;
xmlpp::Element* out_root = out.create_root_node ("Test");
i.conversion.as_xml (out_root);
- shared_ptr<cxml::Document> in (new cxml::Document ("Test"));
+ shared_ptr<cxml::Document> in = make_shared<cxml::Document> ("Test");
in->read_string (out.write_to_string ("UTF-8"));
BOOST_CHECK (ColourConversion::from_xml (in, Film::current_state_version).get () == i.conversion);
}
* @brief Test DCP subtitle content in various ways.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/film.h"
#include "lib/dcp_subtitle_content.h"
#include "lib/dcp_content.h"
#include "lib/content_subtitle.h"
#include "lib/subtitle_decoder.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
/** Test pass-through of a very simple DCP subtitle file */
BOOST_AUTO_TEST_CASE (dcp_subtitle_test)
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
- shared_ptr<DCPSubtitleContent> content (new DCPSubtitleContent (film, "test/data/dcp_sub.xml"));
+ shared_ptr<DCPSubtitleContent> content = make_shared<DCPSubtitleContent> (film, "test/data/dcp_sub.xml");
film->examine_and_add_content (content);
wait_for_jobs ();
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
- shared_ptr<DCPContent> content (new DCPContent (film, private_data / "JourneyToJah_TLR-1_F_EN-DE-FR_CH_51_2K_LOK_20140225_DGL_SMPTE_OV"));
+ shared_ptr<DCPContent> content = make_shared<DCPContent> (film, private_data / "JourneyToJah_TLR-1_F_EN-DE-FR_CH_51_2K_LOK_20140225_DGL_SMPTE_OV");
film->examine_and_add_content (content);
wait_for_jobs ();
- shared_ptr<DCPDecoder> decoder (new DCPDecoder (content, film->log(), false));
+ shared_ptr<DCPDecoder> decoder = make_shared<DCPDecoder> (content, film->log(), false);
list<ContentTimePeriod> ctp = decoder->text_subtitles_during (
ContentTimePeriod (
#include "test.h"
#include <sndfile.h>
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
/** Test the FFmpeg code with audio-only content */
static void
shared_ptr<Film> film = new_test_film ("ffmpeg_audio_only_test");
film->set_name ("test_film");
film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, file));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, file);
film->examine_and_add_content (c);
wait_for_jobs ();
film->write_metadata ();
BOOST_REQUIRE_EQUAL (info.samplerate, 48000);
float* ref_buffer = new float[info.samplerate * info.channels];
- shared_ptr<Player> player (new Player (film, film->playlist ()));
+ shared_ptr<Player> player = make_shared<Player> (film, film->playlist ());
for (DCPTime t; t < film->length(); t += DCPTime::from_seconds (1)) {
int const N = sf_readf_float (ref, ref_buffer, info.samplerate);
#include <dcp/sound_asset_reader.h>
#include <dcp/reel.h>
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (ffmpeg_audio_test)
{
shared_ptr<Film> film = new_test_film ("ffmpeg_audio_test");
film->set_name ("ffmpeg_audio_test");
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, "test/data/staircase.mov"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, "test/data/staircase.mov");
film->examine_and_add_content (c);
wait_for_jobs ();
* Also a quick test of Film::have_dcp ().
*/
-#include <boost/test/unit_test.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/algorithm/string.hpp>
#include "lib/film.h"
#include "lib/ffmpeg_content.h"
#include "lib/ratio.h"
#include "lib/dcp_content_type.h"
#include "lib/video_content.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (ffmpeg_dcp_test)
{
shared_ptr<Film> film = new_test_film ("ffmpeg_dcp_test");
film->set_name ("test_film2");
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (c);
wait_for_jobs ();
BOOST_AUTO_TEST_CASE (ffmpeg_have_dcp_test)
{
boost::filesystem::path p = test_film_dir ("ffmpeg_dcp_test");
- shared_ptr<Film> film (new Film (p.string ()));
+ shared_ptr<Film> film = boost::make_shared<Film> (p.string ());
film->read_metadata ();
BOOST_CHECK (!film->cpls().empty());
#include "test.h"
#include <boost/test/unit_test.hpp>
#include <boost/filesystem.hpp>
+#include <boost/make_shared.hpp>
#include <vector>
using std::cerr;
using std::vector;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
static void
}
shared_ptr<Film> film = new_test_film ("ffmpeg_decoder_seek_test_" + file.string());
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, path));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, path);
film->examine_and_add_content (content);
wait_for_jobs ();
- shared_ptr<Log> log (new NullLog);
- shared_ptr<FFmpegDecoder> decoder (new FFmpegDecoder (content, log, false));
+ shared_ptr<Log> log = make_shared<NullLog> ();
+ shared_ptr<FFmpegDecoder> decoder = make_shared<FFmpegDecoder> (content, log, false);
for (vector<int>::const_iterator i = frames.begin(); i != frames.end(); ++i) {
check (decoder, *i);
#include "lib/film.h"
#include "test.h"
#include <boost/filesystem.hpp>
+#include <boost/make_shared.hpp>
#include <boost/test/unit_test.hpp>
#include <iostream>
using std::cerr;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
void
}
shared_ptr<Film> film = new_test_film ("ffmpeg_decoder_seek_test_" + file.string());
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, path));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, path);
film->examine_and_add_content (content);
wait_for_jobs ();
- shared_ptr<Log> log (new NullLog);
- shared_ptr<FFmpegDecoder> decoder (new FFmpegDecoder (content, log, false));
+ shared_ptr<Log> log = make_shared<NullLog> ();
+ shared_ptr<FFmpegDecoder> decoder = make_shared<FFmpegDecoder> (content, log, false);
BOOST_REQUIRE (decoder->video->_content->video_frame_rate());
BOOST_CHECK_CLOSE (decoder->video->_content->video_frame_rate().get(), fps, 0.01);
* correctly from data/count300bd24.m2ts.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/ffmpeg_examiner.h"
#include "lib/ffmpeg_content.h"
#include "lib/ffmpeg_audio_stream.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (ffmpeg_examiner_test)
{
shared_ptr<Film> film = new_test_film ("ffmpeg_examiner_test");
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/count300bd24.m2ts"));
- shared_ptr<FFmpegExaminer> examiner (new FFmpegExaminer (content));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/count300bd24.m2ts");
+ shared_ptr<FFmpegExaminer> examiner = make_shared<FFmpegExaminer> (content);
BOOST_CHECK_EQUAL (examiner->first_video().get(), ContentTime::from_seconds (600));
BOOST_CHECK_EQUAL (examiner->audio_streams().size(), 1U);
* @brief Check the computation of _pts_offset in FFmpegDecoder.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/film.h"
#include "lib/ffmpeg_decoder.h"
#include "lib/ffmpeg_content.h"
#include "lib/ffmpeg_audio_stream.h"
#include "lib/audio_content.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (ffmpeg_pts_offset_test)
{
shared_ptr<Film> film = new_test_film ("ffmpeg_pts_offset_test");
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (content);
wait_for_jobs ();
content->audio.reset (new AudioContent (content.get()));
+ /* Can't use make_shared here */
content->audio->add_stream (shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream));
content->_video_frame_rate = 24;
* @brief Test some basic reading/writing of film metadata.
*/
-#include <boost/test/unit_test.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/date_time.hpp>
#include "lib/film.h"
#include "lib/dcp_content_type.h"
#include "lib/ratio.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/date_time.hpp>
+#include <boost/make_shared.hpp>
using std::string;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (film_metadata_test)
{
ignore.push_back ("Key");
check_xml ("test/data/metadata.xml.ref", dir.string() + "/metadata.xml", ignore);
- shared_ptr<Film> g (new Film (dir));
+ shared_ptr<Film> g = make_shared<Film> (dir);
g->read_metadata ();
BOOST_CHECK_EQUAL (g->name(), "fred");
* frame rate for the DCP.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/film.h"
#include "lib/config.h"
#include "lib/ffmpeg_content.h"
#include "lib/video_content.h"
#include "lib/audio_content.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
/* Test Playlist::best_dcp_frame_rate and FrameRateChange
with a single piece of content.
{
shared_ptr<Film> film = new_test_film ("best_dcp_frame_rate_test_single");
/* Get any piece of content, it doesn't matter what */
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (content);
wait_for_jobs ();
{
shared_ptr<Film> film = new_test_film ("best_dcp_frame_rate_test_double");
/* Get any old content, it doesn't matter what */
- shared_ptr<FFmpegContent> A (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> A = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (A);
- shared_ptr<FFmpegContent> B (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> B = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (B);
wait_for_jobs ();
{
shared_ptr<Film> film = new_test_film ("audio_sampling_rate_test");
/* Get any piece of content, it doesn't matter what */
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (content);
wait_for_jobs ();
afr.push_back (30);
Config::instance()->set_allowed_dcp_frame_rates (afr);
- shared_ptr<FFmpegAudioStream> stream (new FFmpegAudioStream ("foo", 0, 0, 0, 0));
+ shared_ptr<FFmpegAudioStream> stream = make_shared<FFmpegAudioStream> ("foo", 0, 0, 0, 0);
content->audio.reset (new AudioContent (content.get()));
content->audio->add_stream (stream);
content->_video_frame_rate = 24;
* @see test/make_black_test.cc, test/pixel_formats_test.cc
*/
-#include <boost/test/unit_test.hpp>
#include <Magick++.h>
#include "lib/image.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::string;
using std::list;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (aligned_image_test)
{
{
int const stride = 48 * 4;
- shared_ptr<Image> A (new Image (AV_PIX_FMT_RGBA, dcp::Size (48, 48), false));
+ shared_ptr<Image> A = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (48, 48), false);
A->make_black ();
uint8_t* a = A->data()[0];
}
}
- shared_ptr<Image> B (new Image (AV_PIX_FMT_RGBA, dcp::Size (48, 48), true));
+ shared_ptr<Image> B = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (48, 48), true);
B->make_transparent ();
uint8_t* b = B->data()[0];
{
int const stride = 48 * 4;
- shared_ptr<Image> A (new Image (AV_PIX_FMT_RGBA, dcp::Size (48, 48), false));
+ shared_ptr<Image> A = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (48, 48), false);
A->make_transparent ();
uint8_t* a = A->data()[0];
/** Test merge (list<PositionImage>) with two images */
BOOST_AUTO_TEST_CASE (merge_test2)
{
- shared_ptr<Image> A (new Image (AV_PIX_FMT_RGBA, dcp::Size (48, 1), false));
+ shared_ptr<Image> A = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (48, 1), false);
A->make_transparent ();
uint8_t* a = A->data()[0];
for (int x = 0; x < 16; ++x) {
a[x * 4 + 3] = 255;
}
- shared_ptr<Image> B (new Image (AV_PIX_FMT_RGBA, dcp::Size (48, 1), false));
+ shared_ptr<Image> B = make_shared<Image> (AV_PIX_FMT_RGBA, dcp::Size (48, 1), false);
B->make_transparent ();
uint8_t* b = B->data()[0];
for (int x = 0; x < 16; ++x) {
#include "lib/cross.h"
#include <dcp/cpl.h>
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using std::vector;
using boost::shared_ptr;
+using boost::make_shared;
/** Make an encrypted DCP, import it and make a new unencrypted DCP */
BOOST_AUTO_TEST_CASE (import_dcp_test)
A->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
A->set_name ("frobozz");
- shared_ptr<FFmpegContent> c (new FFmpegContent (A, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (A, "test/data/test.mp4");
A->examine_and_add_content (c);
A->set_encrypted (true);
wait_for_jobs ();
dcp::DCP A_dcp ("build/test/import_dcp_test/" + A->dcp_name());
A_dcp.read ();
- Config::instance()->set_decryption_chain (shared_ptr<dcp::CertificateChain> (new dcp::CertificateChain (openssl_path ())));
+ Config::instance()->set_decryption_chain (make_shared<dcp::CertificateChain> (openssl_path ()));
dcp::EncryptedKDM kdm = A->make_kdm (
Config::instance()->decryption_chain()->leaf (),
B->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
B->set_name ("frobozz");
- shared_ptr<DCPContent> d (new DCPContent (B, "build/test/import_dcp_test/" + A->dcp_name()));
+ shared_ptr<DCPContent> d = boost::make_shared<DCPContent> (B, "build/test/import_dcp_test/" + A->dcp_name());
d->add_kdm (kdm);
B->examine_and_add_content (d);
wait_for_jobs ();
#include "lib/cross.h"
#include "test.h"
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
/** Interrupt a DCP encode when it is in progress, as this used to (still does?)
* sometimes give an error related to pthreads.
film->set_container (Ratio::from_id ("185"));
film->set_name ("interrupt_encoder_test");
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, private_data / "prophet_clip.mkv"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, private_data / "prophet_clip.mkv");
film->examine_and_add_content (content);
wait_for_jobs ();
#include "lib/ffmpeg_content.h"
#include "lib/audio_content.h"
#include "test.h"
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (isdcf_name_test)
{
/* Test interior aspect ratio: shouldn't be shown with trailers */
- shared_ptr<ImageContent> content (new ImageContent (film, "test/data/simple_testcard_640x480.png"));
+ shared_ptr<ImageContent> content = make_shared<ImageContent> (film, "test/data/simple_testcard_640x480.png");
film->examine_and_add_content (content);
wait_for_jobs ();
content->video->set_scale (VideoContentScale (Ratio::from_id ("133")));
/* Test audio channel markup */
film->set_audio_channels (6);
- shared_ptr<FFmpegContent> sound (new FFmpegContent (film, "test/data/sine_440.wav"));
+ shared_ptr<FFmpegContent> sound = make_shared<FFmpegContent> (film, "test/data/sine_440.wav");
film->examine_and_add_content (sound);
wait_for_jobs ();
BOOST_CHECK_EQUAL (film->isdcf_name(false), "LikeShouting_XSN-2_F-133_DE-fr_US-R_10_4K_DI_20140704_PP_SMPTE_OV");
* @brief Basic tests of Job and JobManager.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/job.h"
#include "lib/job_manager.h"
#include "lib/cross.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
class TestJob : public Job
{
shared_ptr<Film> film;
/* Single job */
- shared_ptr<TestJob> a (new TestJob (film));
+ shared_ptr<TestJob> a = make_shared<TestJob> (film);
JobManager::instance()->add (a);
dcpomatic_sleep (1);
* @see test/image_test.cc
*/
-#include <boost/test/unit_test.hpp>
#include <dcp/util.h>
extern "C" {
#include <libavutil/pixfmt.h>
}
#include "lib/image.h"
+#include <boost/make_shared.hpp>
+#include <boost/test/unit_test.hpp>
using std::list;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (make_black_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));
+ boost::shared_ptr<Image> foo = make_shared<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);
film->set_container (Ratio::from_id ("185"));
film->set_name ("play_test");
- shared_ptr<FFmpegContent> A (new FFmpegContent (film, "test/data/red_24.mp4"));
+ shared_ptr<FFmpegContent> A = make_shared<FFmpegContent> (film, "test/data/red_24.mp4");
film->examine_and_add_content (A);
wait_for_jobs ();
BOOST_CHECK_EQUAL (A->video_length_after_3d_combine(), 16);
- shared_ptr<FFmpegContent> B (new FFmpegContent (film, "test/data/red_30.mp4"));
+ shared_ptr<FFmpegContent> B = make_shared<FFmpegContent> (film, "test/data/red_30.mp4");
film->examine_and_add_content (B);
wait_for_jobs ();
/* A is 16 frames long at 25 fps */
BOOST_CHECK_EQUAL (B->position(), 16 * TIME_HZ / 25);
- shared_ptr<Player> player (new Player (film));
+ shared_ptr<Player> player = make_shared<Player> (film);
PlayerWrapper wrap (player);
/* Seek and audio don't get on at the moment */
player->disable_audio ();
* @brief Various tests of Player.
*/
-#include <iostream>
-#include <boost/test/unit_test.hpp>
#include "lib/film.h"
#include "lib/ffmpeg_content.h"
#include "lib/dcp_content_type.h"
#include "lib/audio_buffers.h"
#include "lib/player.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
+#include <iostream>
using std::cout;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
static bool
valid (Content const *)
film->set_container (Ratio::from_id ("185"));
/* This content is 3s long */
- shared_ptr<FFmpegContent> A (new FFmpegContent (film, "test/data/test.mp4"));
- shared_ptr<FFmpegContent> B (new FFmpegContent (film, "test/data/test.mp4"));
- shared_ptr<FFmpegContent> C (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> A = make_shared<FFmpegContent> (film, "test/data/test.mp4");
+ shared_ptr<FFmpegContent> B = make_shared<FFmpegContent> (film, "test/data/test.mp4");
+ shared_ptr<FFmpegContent> C = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (A);
film->examine_and_add_content (B);
B->set_position (DCPTime::from_seconds (10));
C->set_position (DCPTime::from_seconds (20));
- shared_ptr<Player> player (new Player (film, film->playlist ()));
+ shared_ptr<Player> player = make_shared<Player> (film, film->playlist ());
list<shared_ptr<Piece> > o = player->overlaps (DCPTime::from_seconds (0), DCPTime::from_seconds (5), &valid);
BOOST_CHECK_EQUAL (o.size(), 1U);
{
shared_ptr<Film> film = new_test_film ("player_silence_padding_test");
film->set_name ("player_silence_padding_test");
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->set_container (Ratio::from_id ("185"));
film->set_audio_channels (6);
film->examine_and_add_content (c);
wait_for_jobs ();
- shared_ptr<Player> player (new Player (film, film->playlist ()));
+ shared_ptr<Player> player = make_shared<Player> (film, film->playlist ());
shared_ptr<AudioBuffers> test = player->get_audio (DCPTime (0), DCPTime::from_seconds (1), true);
BOOST_CHECK_EQUAL (test->frames(), 48000);
BOOST_CHECK_EQUAL (test->channels(), film->audio_channels ());
#include <dcp/mono_picture_asset.h>
#include <dcp/stereo_picture_asset.h>
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
static void
note (dcp::NoteType t, string n)
film->set_container (Ratio::from_id ("185"));
film->set_name ("recover_test");
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/count300bd24.m2ts"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/count300bd24.m2ts");
film->examine_and_add_content (content);
wait_for_jobs ();
film->make_dcp ();
wait_for_jobs ();
- shared_ptr<dcp::MonoPictureAsset> A (new dcp::MonoPictureAsset ("build/test/recover_test_2d/original.mxf"));
- shared_ptr<dcp::MonoPictureAsset> B (new dcp::MonoPictureAsset (video));
+ shared_ptr<dcp::MonoPictureAsset> A = make_shared<dcp::MonoPictureAsset> ("build/test/recover_test_2d/original.mxf");
+ shared_ptr<dcp::MonoPictureAsset> B = make_shared<dcp::MonoPictureAsset> (video);
dcp::EqualityOptions eq;
BOOST_CHECK (A->equals (B, eq, boost::bind (¬e, _1, _2)));
film->set_name ("recover_test");
film->set_three_d (true);
- shared_ptr<ImageContent> content (new ImageContent (film, "test/data/3d_test"));
+ shared_ptr<ImageContent> content = make_shared<ImageContent> (film, "test/data/3d_test");
content->video->set_frame_type (VIDEO_FRAME_TYPE_3D_LEFT_RIGHT);
film->examine_and_add_content (content);
wait_for_jobs ();
film->make_dcp ();
wait_for_jobs ();
- shared_ptr<dcp::StereoPictureAsset> A (new dcp::StereoPictureAsset ("build/test/recover_test_3d/original.mxf"));
- shared_ptr<dcp::StereoPictureAsset> B (new dcp::StereoPictureAsset (video));
+ shared_ptr<dcp::StereoPictureAsset> A = make_shared<dcp::StereoPictureAsset> ("build/test/recover_test_3d/original.mxf");
+ shared_ptr<dcp::StereoPictureAsset> B = make_shared<dcp::StereoPictureAsset> (video);
dcp::EqualityOptions eq;
BOOST_CHECK (A->equals (B, eq, boost::bind (¬e, _1, _2)));
#include "test.h"
#include <boost/test/unit_test.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
/** Test Film::reels() */
BOOST_AUTO_TEST_CASE (reels_test1)
{
shared_ptr<Film> film = new_test_film ("reels_test1");
film->set_container (Ratio::from_id ("185"));
- shared_ptr<FFmpegContent> A (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> A = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (A);
- shared_ptr<FFmpegContent> B (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> B = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (B);
wait_for_jobs ();
BOOST_CHECK_EQUAL (A->full_length(), DCPTime (288000));
film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
{
- shared_ptr<ImageContent> c (new ImageContent (film, "test/data/flat_red.png"));
+ shared_ptr<ImageContent> c = make_shared<ImageContent> (film, "test/data/flat_red.png");
film->examine_and_add_content (c);
wait_for_jobs ();
c->video->set_length (24);
}
{
- shared_ptr<ImageContent> c (new ImageContent (film, "test/data/flat_green.png"));
+ shared_ptr<ImageContent> c = make_shared<ImageContent> (film, "test/data/flat_green.png");
film->examine_and_add_content (c);
wait_for_jobs ();
c->video->set_length (24);
}
{
- shared_ptr<ImageContent> c (new ImageContent (film, "test/data/flat_blue.png"));
+ shared_ptr<ImageContent> c = make_shared<ImageContent> (film, "test/data/flat_blue.png");
film->examine_and_add_content (c);
wait_for_jobs ();
c->video->set_length (24);
film2->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
film2->set_reel_type (REELTYPE_BY_VIDEO_CONTENT);
- shared_ptr<DCPContent> c (new DCPContent (film2, film->dir (film->dcp_name ())));
+ shared_ptr<DCPContent> c = make_shared<DCPContent> (film2, film->dir (film->dcp_name ()));
film2->examine_and_add_content (c);
wait_for_jobs ();
film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
film->set_reel_type (REELTYPE_BY_VIDEO_CONTENT);
- shared_ptr<Content> dcp (new DCPContent (film, "test/data/reels_test2"));
+ shared_ptr<Content> dcp = make_shared<DCPContent> (film, "test/data/reels_test2");
film->examine_and_add_content (dcp);
- shared_ptr<Content> sub (new TextSubtitleContent (film, "test/data/subrip.srt"));
+ shared_ptr<Content> sub = make_shared<TextSubtitleContent> (film, "test/data/subrip.srt");
film->examine_and_add_content (sub);
wait_for_jobs ();
content[i]->video->set_length (24);
}
- shared_ptr<TextSubtitleContent> subs (new TextSubtitleContent (film, "test/data/subrip3.srt"));
+ shared_ptr<TextSubtitleContent> subs = make_shared<TextSubtitleContent> (film, "test/data/subrip3.srt");
film->examine_and_add_content (subs);
wait_for_jobs ();
* @see test/skip_frame_test.cc
*/
-#include <boost/test/unit_test.hpp>
#include "test.h"
#include "lib/film.h"
#include "lib/ratio.h"
#include "lib/ffmpeg_content.h"
#include "lib/dcp_content_type.h"
#include "lib/video_content.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (repeat_frame_test)
{
film->set_name ("repeat_frame_test");
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, "test/data/red_24.mp4"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, "test/data/red_24.mp4");
film->examine_and_add_content (c);
wait_for_jobs ();
* to the number of samples it generates.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/audio_buffers.h"
#include "lib/resampler.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::pair;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
static void
resampler_test_one (int from, int to)
/* XXX: no longer checks anything */
for (int64_t i = 0; i < N; i += 1000) {
- shared_ptr<AudioBuffers> a (new AudioBuffers (1, 1000));
+ shared_ptr<AudioBuffers> a = make_shared<AudioBuffers> (1, 1000);
a->make_silent ();
shared_ptr<const AudioBuffers> r = resamp.run (a);
}
* @brief Test scaling and black-padding of images from a still-image source.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/image_content.h"
#include "lib/ratio.h"
#include "lib/film.h"
#include "lib/dcp_content_type.h"
#include "lib/video_content.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
static void scaling_test_for (shared_ptr<Film> film, shared_ptr<Content> content, string image, string container)
{
shared_ptr<Film> film = new_test_film ("scaling_test");
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("FTR"));
film->set_name ("scaling_test");
- shared_ptr<ImageContent> imc (new ImageContent (film, "test/data/simple_testcard_640x480.png"));
+ shared_ptr<ImageContent> imc = make_shared<ImageContent> (film, "test/data/simple_testcard_640x480.png");
film->examine_and_add_content (imc);
* confusing things as it might in ffmpeg_seek_test).
*/
-#include <boost/test/unit_test.hpp>
#include "lib/film.h"
#include "lib/ffmpeg_content.h"
#include "lib/ratio.h"
#include "lib/video_content.h"
#include "lib/video_decoder.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using boost::shared_ptr;
using boost::dynamic_pointer_cast;
using boost::optional;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (seek_zero_test)
{
film->set_name ("seek_zero_test");
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/count300bd48.m2ts"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/count300bd48.m2ts");
film->examine_and_add_content (content);
wait_for_jobs ();
content->video->set_scale (VideoContentScale (Ratio::from_id ("185")));
#include <dcp/reel_sound_asset.h>
#include <dcp/sound_asset_reader.h>
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using std::string;
using boost::lexical_cast;
using boost::shared_ptr;
+using boost::make_shared;
static void
test_silence_padding (int channels)
film->set_container (Ratio::from_id ("185"));
film->set_name (film_name);
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/staircase.wav"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/staircase.wav");
film->examine_and_add_content (content);
wait_for_jobs ();
* @see test/repeat_frame_test.cc
*/
-#include <boost/test/unit_test.hpp>
#include "test.h"
#include "lib/film.h"
#include "lib/ratio.h"
#include "lib/ffmpeg_content.h"
#include "lib/dcp_content_type.h"
#include "lib/video_content.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (skip_frame_test)
{
film->set_name ("skip_frame_test");
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, "test/data/count300bd48.m2ts"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, "test/data/count300bd48.m2ts");
film->examine_and_add_content (c);
wait_for_jobs ();
#include "test.h"
#include <boost/test/unit_test.hpp>
#include <boost/algorithm/string.hpp>
+#include <boost/make_shared.hpp>
#include <list>
using std::string;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
/** Make a very short DCP with a single subtitle from .srt with no specified fonts */
BOOST_AUTO_TEST_CASE (srt_subtitle_test)
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
- shared_ptr<TextSubtitleContent> content (new TextSubtitleContent (film, "test/data/subrip2.srt"));
+ shared_ptr<TextSubtitleContent> content = make_shared<TextSubtitleContent> (film, "test/data/subrip2.srt");
film->examine_and_add_content (content);
wait_for_jobs ();
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
- shared_ptr<TextSubtitleContent> content (new TextSubtitleContent (film, "test/data/subrip2.srt"));
+ shared_ptr<TextSubtitleContent> content = make_shared<TextSubtitleContent> (film, "test/data/subrip2.srt");
film->examine_and_add_content (content);
wait_for_jobs ();
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
film->set_interop (true);
- shared_ptr<TextSubtitleContent> content (new TextSubtitleContent (film, private_data / "Ankoemmling.srt"));
+ shared_ptr<TextSubtitleContent> content = make_shared<TextSubtitleContent> (film, private_data / "Ankoemmling.srt");
film->examine_and_add_content (content);
wait_for_jobs ();
BOOST_AUTO_TEST_CASE (srt_subtitle_test4)
{
shared_ptr<Film> film = new_test_film ("subrip_render_test");
- shared_ptr<TextSubtitleContent> content (new TextSubtitleContent (film, "test/data/subrip.srt"));
+ shared_ptr<TextSubtitleContent> content = make_shared<TextSubtitleContent> (film, "test/data/subrip.srt");
content->examine (shared_ptr<Job> (), true);
BOOST_CHECK_EQUAL (content->full_length(), DCPTime::from_seconds ((3 * 60) + 56.471));
- shared_ptr<SubRipDecoder> decoder (new SubRipDecoder (content));
+ shared_ptr<SubRipDecoder> decoder = make_shared<SubRipDecoder> (content);
list<ContentTextSubtitle> cts = decoder->get_text_subtitles (
ContentTimePeriod (
ContentTime::from_seconds (109), ContentTime::from_seconds (110)
#include "test.h"
#include <boost/test/unit_test.hpp>
#include <boost/algorithm/string.hpp>
+#include <boost/make_shared.hpp>
#include <list>
using std::string;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
/** Make a DCP with subs from a .ssa file */
BOOST_AUTO_TEST_CASE (ssa_subtitle_test1)
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
film->set_interop (true);
- shared_ptr<TextSubtitleContent> content (new TextSubtitleContent (film, private_data / "DKH_UT_EN20160601def.ssa"));
+ shared_ptr<TextSubtitleContent> content = make_shared<TextSubtitleContent> (film, private_data / "DKH_UT_EN20160601def.ssa");
film->examine_and_add_content (content);
wait_for_jobs ();
#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE dcpomatic_test
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <list>
#include <vector>
#include <iostream>
using std::abs;
using boost::shared_ptr;
using boost::scoped_array;
+using boost::make_shared;
boost::filesystem::path private_data = boost::filesystem::path ("..") / boost::filesystem::path ("dcpomatic-test-private");
boost::filesystem::remove_all (p);
}
- shared_ptr<Film> film = shared_ptr<Film> (new Film (p.string()));
+ shared_ptr<Film> film = boost::make_shared<Film> (p.string());
film->write_metadata ();
return film;
}
#include "lib/dcp_content_type.h"
#include "lib/ffmpeg_content.h"
#include "lib/video_content.h"
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (threed_test)
{
shared_ptr<Film> film = new_test_film ("threed_test");
film->set_name ("test_film2");
- shared_ptr<FFmpegContent> c (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> c = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (c);
wait_for_jobs ();
#include "lib/audio_content.h"
#include "test.h"
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using std::string;
using std::list;
using boost::shared_ptr;
+using boost::make_shared;
static string const xml = "<Content>"
"<Type>FFmpeg</Type>"
{
shared_ptr<Film> film = new_test_film ("ffmpeg_time_calculation_test");
- shared_ptr<cxml::Document> doc (new cxml::Document);
+ shared_ptr<cxml::Document> doc = make_shared<cxml::Document> ();
doc->read_string (xml);
list<string> notes;
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, doc, film->state_version(), notes));
+ shared_ptr<FFmpegContent> content = boost::make_shared<FFmpegContent> (film, doc, film->state_version(), notes);
/* 25fps content, 25fps DCP */
film->set_video_frame_rate (25);
{
shared_ptr<Film> film = new_test_film ("player_time_calculation_test1");
- shared_ptr<cxml::Document> doc (new cxml::Document);
+ shared_ptr<cxml::Document> doc = make_shared<cxml::Document> ();
doc->read_string (xml);
list<string> notes;
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, doc, film->state_version(), notes));
+ shared_ptr<FFmpegContent> content = boost::make_shared<FFmpegContent> (film, doc, film->state_version(), notes);
film->set_sequence (false);
film->add_content (content);
- shared_ptr<Player> player (new Player (film, film->playlist ()));
+ shared_ptr<Player> player = make_shared<Player> (film, film->playlist ());
/* Position 0, no trim, content rate = DCP rate */
content->set_position (DCPTime ());
{
shared_ptr<Film> film = new_test_film ("player_time_calculation_test2");
- shared_ptr<cxml::Document> doc (new cxml::Document);
+ shared_ptr<cxml::Document> doc = make_shared<cxml::Document> ();
doc->read_string (xml);
list<string> notes;
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, doc, film->state_version(), notes));
+ shared_ptr<FFmpegContent> content = boost::make_shared<FFmpegContent> (film, doc, film->state_version(), notes);
film->set_sequence (false);
film->add_content (content);
- shared_ptr<Player> player (new Player (film, film->playlist ()));
+ shared_ptr<Player> player = make_shared<Player> (film, film->playlist ());
/* Position 0, no trim, content rate = DCP rate */
content->set_position (DCPTime ());
{
shared_ptr<Film> film = new_test_film ("player_time_calculation_test3");
- shared_ptr<cxml::Document> doc (new cxml::Document);
+ shared_ptr<cxml::Document> doc = make_shared<cxml::Document> ();
doc->read_string (xml);
list<string> notes;
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, doc, film->state_version(), notes));
+ shared_ptr<FFmpegContent> content = boost::make_shared<FFmpegContent> (film, doc, film->state_version(), notes);
AudioStreamPtr stream = content->audio->streams().front();
film->set_sequence (false);
film->add_content (content);
- shared_ptr<Player> player (new Player (film, film->playlist ()));
+ shared_ptr<Player> player = make_shared<Player> (film, film->playlist ());
/* Position 0, no trim, video/audio content rate = video/audio DCP rate */
content->set_position (DCPTime ());
*/
-#include <boost/test/unit_test.hpp>
-#include <sndfile.h>
#include "lib/film.h"
#include "lib/ratio.h"
#include "lib/dcp_content_type.h"
#include "lib/audio_buffers.h"
#include "lib/upmixer_a.h"
#include "test.h"
+#include <sndfile.h>
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (upmixer_a_test)
{
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
film->set_audio_processor (AudioProcessor::from_id ("stereo-5.1-upmix-a"));
- shared_ptr<FFmpegContent> content (new FFmpegContent (film, "test/data/white.wav"));
+ shared_ptr<FFmpegContent> content = make_shared<FFmpegContent> (film, "test/data/white.wav");
film->examine_and_add_content (content);
wait_for_jobs ();
SNDFILE* Ls = sf_open ("build/test/upmixer_a_test/Ls.wav", SFM_WRITE, &info);
SNDFILE* Rs = sf_open ("build/test/upmixer_a_test/Rs.wav", SFM_WRITE, &info);
- shared_ptr<Player> player (new Player (film, film->playlist ()));
+ shared_ptr<Player> player = make_shared<Player> (film, film->playlist ());
for (DCPTime t; t < film->length(); t += DCPTime::from_seconds (1)) {
shared_ptr<AudioBuffers> b = player->get_audio (t, DCPTime::from_seconds (1), true);
sf_write_float (L, b->data(0), b->frames());
#include "test.h"
#include <boost/test/unit_test.hpp>
#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
using std::list;
using std::string;
using boost::shared_ptr;
+using boost::make_shared;
/** Test the logic which decides whether a DCP can be referenced or not */
BOOST_AUTO_TEST_CASE (vf_test1)
{
shared_ptr<Film> film = new_test_film ("vf_test1");
- shared_ptr<DCPContent> dcp (new DCPContent (film, "test/data/reels_test2"));
+ shared_ptr<DCPContent> dcp = make_shared<DCPContent> (film, "test/data/reels_test2");
film->examine_and_add_content (dcp);
wait_for_jobs ();
/* (but reels_test2 has no subtitles to reference) */
BOOST_CHECK (!dcp->can_reference_subtitle(why_not));
- shared_ptr<FFmpegContent> other (new FFmpegContent (film, "test/data/test.mp4"));
+ shared_ptr<FFmpegContent> other = make_shared<FFmpegContent> (film, "test/data/test.mp4");
film->examine_and_add_content (other);
wait_for_jobs ();
*/
-#include <boost/test/unit_test.hpp>
#include "lib/ffmpeg_content.h"
#include "lib/ratio.h"
#include "lib/video_content.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using std::list;
using std::string;
using std::cerr;
using boost::shared_ptr;
+using boost::make_shared;
using boost::optional;
static
"<SubtitleYScale>0</SubtitleYScale>"
"</Content>";
- shared_ptr<cxml::Document> doc (new cxml::Document ());
+ shared_ptr<cxml::Document> doc = make_shared<cxml::Document> ();
doc->read_string(s.str ());
list<string> notes;
- shared_ptr<FFmpegContent> vc (new FFmpegContent (film, doc, 10, notes));
+ shared_ptr<FFmpegContent> vc = boost::make_shared<FFmpegContent> (film, doc, 10, notes);
optional<VideoContentScale> sc;
if (ratio) {
*/
-#include <boost/test/unit_test.hpp>
#include "lib/image_decoder.h"
#include "lib/image_content.h"
#include "lib/content_video.h"
#include "lib/video_decoder.h"
#include "lib/film.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::list;
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
BOOST_AUTO_TEST_CASE (video_decoder_fill_test1)
{
shared_ptr<Film> film = new_test_film ("video_decoder_fill_test");
- shared_ptr<ImageContent> c (new ImageContent (film, "test/data/simple_testcard_640x480.png"));
+ shared_ptr<ImageContent> c = make_shared<ImageContent> (film, "test/data/simple_testcard_640x480.png");
ImageDecoder decoder (c, film->log());
decoder.video->fill_one_eye (0, 4, EYES_BOTH);
BOOST_AUTO_TEST_CASE (video_decoder_fill_test2)
{
shared_ptr<Film> film = new_test_film ("video_decoder_fill_test");
- shared_ptr<ImageContent> c (new ImageContent (film, "test/data/simple_testcard_640x480.png"));
+ shared_ptr<ImageContent> c = make_shared<ImageContent> (film, "test/data/simple_testcard_640x480.png");
ImageDecoder decoder (c, film->log());
decoder.video->fill_both_eyes (VideoFrame (0, EYES_LEFT), VideoFrame (4, EYES_LEFT));
#include "test.h"
#include <dcp/mono_picture_asset.h>
#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
using boost::shared_ptr;
+using boost::make_shared;
using boost::dynamic_pointer_cast;
static boost::filesystem::path ref_mxf = "test/data/scaling_test_185_185/j2c_a41afbff-e1ad-41c4-9a84-de315b95dd0f.mxf";
film->make_dcp ();
wait_for_jobs ();
- shared_ptr<dcp::MonoPictureAsset> ref (new dcp::MonoPictureAsset (ref_mxf));
+ shared_ptr<dcp::MonoPictureAsset> ref = make_shared<dcp::MonoPictureAsset> (ref_mxf);
boost::filesystem::directory_iterator i ("build/test/video_mxf_content_test/video");
- shared_ptr<dcp::MonoPictureAsset> comp (new dcp::MonoPictureAsset (*i));
+ shared_ptr<dcp::MonoPictureAsset> comp = make_shared<dcp::MonoPictureAsset> (*i);
dcp::EqualityOptions op;
BOOST_CHECK (ref->equals (comp, op, note));
}
* @brief Test creation of XML DCP subtitles.
*/
-#include <boost/test/unit_test.hpp>
#include "lib/text_subtitle_content.h"
#include "lib/film.h"
#include "lib/ratio.h"
#include "lib/dcp_content_type.h"
#include "lib/subtitle_content.h"
#include "test.h"
+#include <boost/test/unit_test.hpp>
+#include <boost/make_shared.hpp>
#include <iostream>
using std::cout;
using boost::shared_ptr;
+using boost::make_shared;
/** Build a small DCP with no picture and a single subtitle overlaid onto it */
BOOST_AUTO_TEST_CASE (xml_subtitle_test)
film->set_container (Ratio::from_id ("185"));
film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
film->set_name ("frobozz");
- shared_ptr<TextSubtitleContent> content (new TextSubtitleContent (film, "test/data/subrip2.srt"));
+ shared_ptr<TextSubtitleContent> content = make_shared<TextSubtitleContent> (film, "test/data/subrip2.srt");
content->subtitle->set_use (true);
content->subtitle->set_burn (false);
film->examine_and_add_content (content);
film->set_name ("frobozz");
film->set_interop (true);
film->set_sequence (false);
- shared_ptr<TextSubtitleContent> content (new TextSubtitleContent (film, "test/data/subrip2.srt"));
+ shared_ptr<TextSubtitleContent> content = make_shared<TextSubtitleContent> (film, "test/data/subrip2.srt");
content->subtitle->set_use (true);
content->subtitle->set_burn (false);
film->examine_and_add_content (content);
projects / dcpomatic.git / commitdiff