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