Revert "Use make_shared<>."
authorCarl Hetherington <cth@carlh.net>
Tue, 21 Jun 2016 22:08:53 +0000 (23:08 +0100)
committerCarl Hetherington <cth@carlh.net>
Tue, 21 Jun 2016 22:08:53 +0000 (23:08 +0100)
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:
src/lib/analyse_audio_job.cc
src/lib/atmos_mxf_content.cc
src/lib/audio_analysis.cc
src/lib/audio_buffers.cc
src/lib/audio_content.cc
src/lib/audio_decoder.cc
src/lib/audio_decoder_stream.cc
src/lib/audio_delay.cc
src/lib/audio_filter.cc
src/lib/audio_filter_graph.cc
src/lib/cinema.cc
src/lib/cinema_kdms.cc
src/lib/config.cc
src/lib/dcp_content.cc
src/lib/dcp_decoder.cc
src/lib/dcp_subtitle_content.cc
src/lib/dcp_video.cc
src/lib/decoder_factory.cc
src/lib/encode_server.cc
src/lib/encode_server_finder.cc
src/lib/ffmpeg_content.cc
src/lib/ffmpeg_decoder.cc
src/lib/ffmpeg_examiner.cc
src/lib/film.cc
src/lib/image.cc
src/lib/image_content.cc
src/lib/image_proxy.cc
src/lib/j2k_image_proxy.cc
src/lib/json_server.cc
src/lib/log.cc
src/lib/mid_side_decoder.cc
src/lib/player.cc
src/lib/reel_writer.cc
src/lib/render_subtitles.cc
src/lib/resampler.cc
src/lib/server.cc
src/lib/subtitle_content.cc
src/lib/text_subtitle_content.cc
src/lib/transcode_job.cc
src/lib/upmixer_a.cc
src/lib/upmixer_b.cc
src/lib/video_content.cc
src/lib/video_decoder.cc
src/lib/video_filter_graph.cc
src/lib/video_mxf_content.cc
src/lib/video_mxf_decoder.cc
src/tools/dcpomatic.cc
src/tools/dcpomatic_batch.cc
src/tools/dcpomatic_create.cc
src/tools/dcpomatic_kdm.cc
src/tools/server_test.cc
src/wx/audio_panel.cc
src/wx/colour_conversion_editor.cc
src/wx/content_menu.cc
src/wx/hints_dialog.cc
src/wx/job_manager_view.cc
src/wx/report_problem_dialog.cc
src/wx/screens_panel.cc
src/wx/timeline.cc
test/4k_test.cc
test/audio_analysis_test.cc
test/audio_decoder_test.cc
test/audio_delay_test.cc
test/audio_filter_test.cc
test/audio_processor_delay_test.cc
test/audio_processor_test.cc
test/black_fill_test.cc
test/burnt_subtitle_test.cc
test/client_server_test.cc
test/colour_conversion_test.cc
test/dcp_subtitle_test.cc
test/ffmpeg_audio_only_test.cc
test/ffmpeg_audio_test.cc
test/ffmpeg_dcp_test.cc
test/ffmpeg_decoder_seek_test.cc
test/ffmpeg_decoder_sequential_test.cc
test/ffmpeg_examiner_test.cc
test/ffmpeg_pts_offset_test.cc
test/film_metadata_test.cc
test/frame_rate_test.cc
test/image_test.cc
test/import_dcp_test.cc
test/interrupt_encoder_test.cc
test/isdcf_name_test.cc
test/job_test.cc
test/make_black_test.cc
test/play_test.cc
test/player_test.cc
test/recover_test.cc
test/reels_test.cc
test/repeat_frame_test.cc
test/resampler_test.cc
test/scaling_test.cc
test/seek_zero_test.cc
test/silence_padding_test.cc
test/skip_frame_test.cc
test/srt_subtitle_test.cc
test/ssa_subtitle_test.cc
test/test.cc
test/threed_test.cc
test/time_calculation_test.cc
test/upmixer_a_test.cc
test/vf_test.cc
test/video_content_scale_test.cc
test/video_decoder_fill_test.cc
test/video_mxf_content_test.cc
test/xml_subtitle_test.cc

index ffe7c0f..8d0accf 100644 (file)
@@ -36,7 +36,6 @@ extern "C" {
 #endif
 }
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -47,7 +46,6 @@ using std::min;
 using std::cout;
 using boost::shared_ptr;
 using boost::dynamic_pointer_cast;
-using boost::make_shared;
 
 int const AnalyseAudioJob::_num_points = 1024;
 
@@ -92,7 +90,7 @@ AnalyseAudioJob::json_name () const
 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 ();
index 870fca5..f8cc051 100644 (file)
 #include <dcp/atmos_asset.h>
 #include <dcp/exceptions.h>
 #include <libxml++/libxml++.h>
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
 using std::list;
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 AtmosMXFContent::AtmosMXFContent (shared_ptr<const Film> film, boost::filesystem::path path)
        : Content (film, path)
@@ -50,7 +48,7 @@ bool
 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) {
 
@@ -66,7 +64,7 @@ AtmosMXFContent::examine (shared_ptr<Job> 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);
index b133dec..1863e38 100644 (file)
@@ -27,7 +27,6 @@
 #include <libxml++/libxml++.h>
 #include <boost/filesystem.hpp>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <stdint.h>
 #include <cmath>
 #include <cstdio>
@@ -42,7 +41,6 @@ using std::cout;
 using std::max;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::dynamic_pointer_cast;
 
 AudioAnalysis::AudioAnalysis (int channels)
@@ -114,7 +112,7 @@ AudioAnalysis::points (int c) const
 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) {
index 4c3c2d4..2ab8e18 100644 (file)
@@ -20,7 +20,6 @@
 
 #include "audio_buffers.h"
 #include "dcpomatic_assert.h"
-#include <boost/make_shared.hpp>
 #include <cassert>
 #include <cstring>
 #include <cmath>
@@ -28,7 +27,6 @@
 
 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.
@@ -307,7 +305,7 @@ AudioBuffers::apply_gain (float dB)
 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;
 }
@@ -322,7 +320,7 @@ AudioBuffers::copy_channel_from (AudioBuffers const * from, int from_channel, in
 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;
 }
index 57f878b..7a4ca63 100644 (file)
@@ -75,7 +75,6 @@ AudioContent::from_xml (Content* parent, cxml::ConstNodePtr node, int version)
                return shared_ptr<AudioContent> ();
        }
 
-       /* Can't use make_shared here as the constructor is private */
        return shared_ptr<AudioContent> (new AudioContent (parent, node));
 }
 
index fa9fe97..8c395cb 100644 (file)
@@ -23,7 +23,6 @@
 #include "audio_decoder_stream.h"
 #include "audio_content.h"
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
 using std::cout;
 using std::map;
 using boost::shared_ptr;
-using boost::make_shared;
 
 AudioDecoder::AudioDecoder (Decoder* parent, shared_ptr<const AudioContent> content, bool fast, shared_ptr<Log> log)
        : _ignore (false)
        , _fast (fast)
 {
        BOOST_FOREACH (AudioStreamPtr i, content->streams ()) {
-               _streams[i] = make_shared<AudioDecoderStream> (content, i, parent, fast, log);
+               _streams[i] = shared_ptr<AudioDecoderStream> (new AudioDecoderStream (content, i, parent, fast, log));
        }
 }
 
index 527610c..1bfc658 100644 (file)
@@ -28,7 +28,6 @@
 #include "log.h"
 #include "audio_content.h"
 #include "compose.hpp"
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -40,7 +39,6 @@ using std::min;
 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)
@@ -58,7 +56,7 @@ AudioDecoderStream::AudioDecoderStream (shared_ptr<const AudioContent> content,
 void
 AudioDecoderStream::reset_decoded ()
 {
-       _decoded = ContentAudio (make_shared<AudioBuffers> (_stream->channels(), 0), 0);
+       _decoded = ContentAudio (shared_ptr<AudioBuffers> (new AudioBuffers (_stream->channels(), 0)), 0);
 }
 
 ContentAudio
@@ -120,7 +118,7 @@ AudioDecoderStream::get (Frame frame, Frame length, bool accurate)
        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);
@@ -159,7 +157,7 @@ AudioDecoderStream::audio (shared_ptr<const AudioBuffers> data, ContentTime time
                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;
@@ -174,7 +172,7 @@ AudioDecoderStream::audio (shared_ptr<const AudioBuffers> data, ContentTime time
                                */
                                return;
                        }
-                       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);
index e33d987..893773d 100644 (file)
 #include "audio_delay.h"
 #include "audio_buffers.h"
 #include "dcpomatic_assert.h"
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 AudioDelay::AudioDelay (int samples)
        : _samples (samples)
@@ -40,7 +38,7 @@ AudioDelay::run (shared_ptr<const AudioBuffers> in)
        /* 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) {
 
index 4203d07..44345fc 100644 (file)
 
 #include "audio_filter.h"
 #include "audio_buffers.h"
-#include <boost/make_shared.hpp>
 #include <cmath>
 
 using std::min;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** @return array of floats which the caller must destroy with delete[] */
 float *
@@ -77,7 +75,7 @@ AudioFilter::~AudioFilter ()
 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));
index f27befb..87a158a 100644 (file)
@@ -25,14 +25,12 @@ extern "C" {
 #include <libavfilter/buffersink.h>
 #include <libavfilter/buffersrc.h>
 }
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
 using std::string;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 AudioFilterGraph::AudioFilterGraph (int sample_rate, int channels)
        : _sample_rate (sample_rate)
@@ -115,7 +113,7 @@ AudioFilterGraph::process (shared_ptr<const AudioBuffers> buffers)
                   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);
                }
index 3f17506..469cf2e 100644 (file)
 #include <dcp/raw_convert.h>
 #include <libxml++/libxml++.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::list;
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 Cinema::Cinema (cxml::ConstNodePtr node)
        : name (node->string_child ("Name"))
@@ -58,7 +56,7 @@ Cinema::read_screens (cxml::ConstNodePtr node)
 {
        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)));
        }
 }
 
index b32da4d..84cd9c1 100644 (file)
@@ -29,7 +29,6 @@
 #include "log.h"
 #include <zip.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
@@ -38,7 +37,6 @@ using std::cout;
 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
@@ -55,7 +53,7 @@ CinemaKDMs::make_zip_file (string film_name, boost::filesystem::path zip_file) c
        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);
index 8e19973..891d832 100644 (file)
@@ -39,7 +39,6 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/foreach.hpp>
 #include <boost/thread.hpp>
-#include <boost/make_shared.hpp>
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
@@ -56,7 +55,6 @@ using std::remove;
 using std::exception;
 using std::cerr;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::optional;
 using boost::algorithm::trim;
 
@@ -269,7 +267,7 @@ Config::read ()
 
        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 ()));
@@ -283,7 +281,7 @@ Config::read ()
 
        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 ()));
                }
@@ -561,7 +559,7 @@ Config::read_cinemas (cxml::Document const & f)
                /* 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);
        }
index dbbd650..295f33b 100644 (file)
@@ -35,7 +35,6 @@
 #include <dcp/reel.h>
 #include <libxml++/libxml++.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iterator>
 #include <iostream>
 
@@ -48,7 +47,6 @@ using std::pair;
 using std::vector;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::scoped_ptr;
 using boost::optional;
 using boost::function;
@@ -134,7 +132,7 @@ DCPContent::examine (shared_ptr<Job> 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 ();
 
index 3bf7c14..e7e88d3 100644 (file)
 #include <dcp/sound_frame.h>
 #include <dcp/sound_asset_reader.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::list;
 using std::cout;
 using boost::shared_ptr;
 using boost::dynamic_pointer_cast;
-using boost::make_shared;
 
 DCPDecoder::DCPDecoder (shared_ptr<const DCPContent> c, shared_ptr<Log> log, bool fast)
        : _dcp_content (c)
@@ -96,15 +94,15 @@ DCPDecoder::pass (PassReason reason, bool)
                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);
                } else {
                        video->give (
-                               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 (
-                               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)),
                                _offset + frame
                                );
                }
@@ -117,7 +115,7 @@ DCPDecoder::pass (PassReason reason, bool)
 
                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);
index b361b94..e7057ef 100644 (file)
@@ -28,7 +28,6 @@
 #include <dcp/interop_load_font_node.h>
 #include <libxml++/libxml++.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
@@ -36,7 +35,6 @@ using std::string;
 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)
@@ -78,7 +76,7 @@ DCPSubtitleContent::examine (shared_ptr<Job> job)
        _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)));
        }
 }
 
index 6d270da..be69f3e 100644 (file)
@@ -47,7 +47,6 @@
 #include <libxml++/libxml++.h>
 #include <boost/asio.hpp>
 #include <boost/thread.hpp>
-#include <boost/make_shared.hpp>
 #include <stdint.h>
 #include <iomanip>
 #include <iostream>
@@ -61,7 +60,6 @@
 using std::string;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 using dcp::Size;
 using dcp::Data;
 
@@ -160,7 +158,7 @@ DCPVideo::encode_remotely (EncodeServerDescription serv, int timeout)
        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);
 
index ec0140b..dc01a04 100644 (file)
 #include "video_mxf_content.h"
 #include "video_mxf_decoder.h"
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 using std::list;
 using boost::shared_ptr;
 using boost::dynamic_pointer_cast;
-using boost::make_shared;
 
 shared_ptr<Decoder>
 decoder_factory (shared_ptr<const Content> content, shared_ptr<Log> log, bool fast)
 {
        shared_ptr<const FFmpegContent> fc = dynamic_pointer_cast<const FFmpegContent> (content);
        if (fc) {
-               return 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) {
-               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) {
-               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) {
-               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) {
-               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) {
-               return make_shared<VideoMXFDecoder> (vmc, log);
+               return shared_ptr<Decoder> (new VideoMXFDecoder (vmc, log));
        }
 
        return shared_ptr<Decoder> ();
index 635913c..f318da0 100644 (file)
@@ -41,7 +41,6 @@
 #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>
@@ -64,7 +63,6 @@ using boost::thread;
 using boost::bind;
 using boost::scoped_array;
 using boost::optional;
-using boost::make_shared;
 using dcp::Size;
 using dcp::Data;
 
@@ -110,7 +108,7 @@ EncodeServer::process (shared_ptr<Socket> socket, struct timeval& after_read, st
        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.
@@ -121,7 +119,7 @@ EncodeServer::process (shared_ptr<Socket> socket, struct timeval& after_read, st
                return -1;
        }
 
-       shared_ptr<PlayerVideo> pvf = make_shared<PlayerVideo> (xml, socket);
+       shared_ptr<PlayerVideo> pvf (new PlayerVideo (xml, socket));
 
        DCPVideo dcp_video_frame (pvf, xml, _log);
 
@@ -266,7 +264,7 @@ EncodeServer::broadcast_received ()
                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);
index a017a0a..7491d9e 100644 (file)
@@ -28,7 +28,6 @@
 #include "raw_convert.h"
 #include <libcxml/cxml.h>
 #include <boost/lambda/lambda.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -40,7 +39,6 @@ using std::cout;
 using boost::shared_ptr;
 using boost::scoped_array;
 using boost::weak_ptr;
-using boost::make_shared;
 
 EncodeServerFinder* EncodeServerFinder::_instance = 0;
 
@@ -153,7 +151,7 @@ catch (...)
 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)
@@ -176,7 +174,7 @@ EncodeServerFinder::handle_accept (boost::system::error_code ec, shared_ptr<Sock
        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 ();
index f3a4c4c..b34fdf6 100644 (file)
@@ -42,7 +42,6 @@ extern "C" {
 }
 #include <libxml++/libxml++.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -57,7 +56,6 @@ using std::pair;
 using std::make_pair;
 using std::max;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::dynamic_pointer_cast;
 using boost::optional;
 
@@ -80,7 +78,7 @@ FFmpegContent::FFmpegContent (shared_ptr<const Film> film, cxml::ConstNodePtr no
 
        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 ();
                }
@@ -88,7 +86,7 @@ FFmpegContent::FFmpegContent (shared_ptr<const Film> film, cxml::ConstNodePtr no
 
        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 */
@@ -212,7 +210,7 @@ FFmpegContent::examine (shared_ptr<Job> job)
 
        Content::examine (job);
 
-       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));
index 69ed7ac..df6b741 100644 (file)
@@ -50,7 +50,6 @@ extern "C" {
 }
 #include <boost/foreach.hpp>
 #include <boost/algorithm/string.hpp>
-#include <boost/make_shared.hpp>
 #include <vector>
 #include <iomanip>
 #include <iostream>
@@ -72,7 +71,6 @@ using std::pair;
 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;
@@ -177,7 +175,7 @@ FFmpegDecoder::deinterleave_audio (shared_ptr<FFmpegAudioStream> stream) const
        */
        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:
@@ -454,7 +452,7 @@ FFmpegDecoder::decode_video_packet ()
                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 {
@@ -534,7 +532,7 @@ FFmpegDecoder::decode_bitmap_subtitle (AVSubtitleRect const * rect, ContentTimeP
        /* 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 */
index 2e48810..18a87f4 100644 (file)
@@ -32,7 +32,6 @@ extern "C" {
 #include "util.h"
 #include "safe_stringstream.h"
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -41,7 +40,6 @@ using std::string;
 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 */
@@ -82,7 +80,7 @@ FFmpegExaminer::FFmpegExaminer (shared_ptr<const FFmpegContent> c, shared_ptr<Jo
                                );
 
                } 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)));
                }
        }
 
index 3378b20..3cd3f0f 100644 (file)
@@ -62,7 +62,6 @@
 #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>
@@ -90,7 +89,6 @@ using boost::weak_ptr;
 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);
@@ -320,21 +318,21 @@ Film::make_dcp ()
                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 ()
 {
-       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
 {
-       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));
@@ -1005,7 +1003,7 @@ Film::content () const
 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);
 }
 
@@ -1016,7 +1014,7 @@ Film::examine_and_add_content (shared_ptr<Content> c)
                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)))
@@ -1040,7 +1038,7 @@ Film::maybe_add_content (weak_ptr<Job> j, weak_ptr<Content> c)
 
        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 (
@@ -1182,7 +1180,7 @@ Film::make_kdm (
        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 ();
index 1107f0a..71a3a5b 100644 (file)
@@ -34,7 +34,6 @@ extern "C" {
 #include <libavutil/pixdesc.h>
 #include <libavutil/frame.h>
 }
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -46,7 +45,6 @@ using std::cerr;
 using std::list;
 using std::runtime_error;
 using boost::shared_ptr;
-using boost::make_shared;
 using dcp::Size;
 
 int
@@ -151,7 +149,7 @@ Image::crop_scale_window (
           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 */
@@ -229,7 +227,7 @@ Image::scale (dcp::Size out_size, dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_fo
        */
        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(),
@@ -821,7 +819,7 @@ merge (list<PositionImage> images)
                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());
index ca8bd38..d4e7367 100644 (file)
@@ -31,7 +31,6 @@
 #include <libcxml/cxml.h>
 #include <libxml++/libxml++.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -40,7 +39,6 @@ using std::string;
 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)
@@ -121,7 +119,7 @@ ImageContent::examine (shared_ptr<Job> job)
        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 ();
 }
index 69c2966..3a09cb8 100644 (file)
@@ -27,7 +27,6 @@
 #include "cross.h"
 #include <dcp/util.h>
 #include <libcxml/cxml.h>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
 using std::cout;
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 shared_ptr<ImageProxy>
 image_proxy_factory (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket)
 {
        if (xml->string_child("Type") == N_("Raw")) {
-               return make_shared<RawImageProxy> (xml, socket);
+               return shared_ptr<ImageProxy> (new RawImageProxy (xml, socket));
        } 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")) {
-               return make_shared<J2KImageProxy> (xml, socket);
+               return shared_ptr<J2KImageProxy> (new J2KImageProxy (xml, socket));
        }
 
        throw NetworkError (_("Unexpected image type received by server"));
index 35d7016..44b5ebe 100644 (file)
@@ -30,7 +30,6 @@
 #include <dcp/j2k.h>
 #include <libcxml/cxml.h>
 #include <libxml++/libxml++.h>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -40,7 +39,6 @@ using std::cout;
 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 */
@@ -109,7 +107,7 @@ J2KImageProxy::image (optional<dcp::NoteHandler>) const
                }
        }
 
-       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.
index 6e53f98..0006201 100644 (file)
@@ -27,7 +27,6 @@
 #include "util.h"
 #include "film.h"
 #include "transcode_job.h"
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::string;
@@ -36,7 +35,6 @@ using std::map;
 using std::list;
 using boost::thread;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::dynamic_pointer_cast;
 using boost::asio::ip::tcp;
 
@@ -63,7 +61,7 @@ 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);
                }
index 7698520..b7edd4e 100644 (file)
@@ -27,7 +27,6 @@
 #include "config.h"
 #include "safe_stringstream.h"
 #include "string_log_entry.h"
-#include <boost/make_shared.hpp>
 #include <time.h>
 #include <cstdio>
 
@@ -36,7 +35,6 @@
 using std::string;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 Log::Log ()
        : _types (0)
@@ -73,7 +71,7 @@ Log::log (string message, int type)
                return;
        }
 
-       shared_ptr<StringLogEntry> e = boost::make_shared<StringLogEntry> (type, message);
+       shared_ptr<StringLogEntry> e (new StringLogEntry (type, message));
 
        do_log (e);
 }
@@ -83,13 +81,13 @@ Log::dcp_log (dcp::NoteType type, string m)
 {
        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:
-               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:
-               do_log (boost::make_shared<const StringLogEntry> (LogEntry::TYPE_WARNING, m));
+               do_log (shared_ptr<const LogEntry> (new StringLogEntry (LogEntry::TYPE_WARNING, m)));
                break;
        }
 }
index 8d5dc18..b9b8dd0 100644 (file)
@@ -21,7 +21,6 @@
 #include "mid_side_decoder.h"
 #include "audio_buffers.h"
 #include "audio_mapping.h"
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
@@ -29,7 +28,6 @@ using std::string;
 using std::min;
 using std::vector;
 using boost::shared_ptr;
-using boost::make_shared;
 
 string
 MidSideDecoder::name () const
@@ -52,14 +50,14 @@ MidSideDecoder::out_channels () 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> 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];
index 1d3e22e..30313d3 100644 (file)
@@ -52,7 +52,6 @@
 #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>
@@ -72,7 +71,6 @@ using std::map;
 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;
@@ -141,7 +139,7 @@ Player::setup_pieces ()
                        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;
@@ -280,7 +278,7 @@ Player::black_player_video_frame (DCPTime time) const
 {
        return shared_ptr<PlayerVideo> (
                new PlayerVideo (
-                       make_shared<RawImageProxy> (_black_image),
+                       shared_ptr<const ImageProxy> (new RawImageProxy (_black_image)),
                        time,
                        Crop (),
                        optional<double> (),
@@ -415,7 +413,7 @@ Player::get_audio (DCPTime time, DCPTime length, bool accurate)
 
        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);
@@ -472,13 +470,13 @@ Player::get_audio (DCPTime time, DCPTime length, bool accurate)
 
                        /* 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 */
-                       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) {
index eff5c48..e6533d2 100644 (file)
@@ -42,7 +42,6 @@
 #include <dcp/interop_subtitle_asset.h>
 #include <dcp/smpte_subtitle_asset.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
@@ -55,7 +54,6 @@ using std::list;
 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;
@@ -305,7 +303,7 @@ ReelWriter::finish ()
 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;
 
@@ -338,7 +336,7 @@ ReelWriter::create_reel (list<ReferencedReelAsset> const & refs, list<shared_ptr
 
        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) {
@@ -462,13 +460,13 @@ ReelWriter::write (PlayerSubtitles subs)
                        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 {
-                       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));
index 94a6b83..76aa092 100644 (file)
@@ -28,7 +28,6 @@
 #include <cairomm/cairomm.h>
 #include <pangomm.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::list;
@@ -40,7 +39,6 @@ using std::pair;
 using std::cerr;
 using std::make_pair;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::optional;
 
 static FcConfig* fc_config = 0;
@@ -82,7 +80,7 @@ render_line (list<dcp::SubtitleString> subtitles, list<shared_ptr<Font> > fonts,
        /* ...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
index 4476d9f..db5552d 100644 (file)
@@ -24,7 +24,6 @@
 #include "compose.hpp"
 #include "dcpomatic_assert.h"
 #include <samplerate.h>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -34,7 +33,6 @@ using std::pair;
 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)
@@ -64,7 +62,7 @@ Resampler::run (shared_ptr<const AudioBuffers> in)
        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));
 
        while (in_frames > 0) {
 
@@ -138,7 +136,7 @@ Resampler::run (shared_ptr<const AudioBuffers> in)
 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;
 
index d90ec91..09e0a4b 100644 (file)
 
 #include "server.h"
 #include "dcpomatic_socket.h"
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 Server::Server (int port)
        : _terminate (false)
@@ -58,7 +56,7 @@ Server::start_accept ()
                }
        }
 
-       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));
 }
 
index 9fd4983..5b3b453 100644 (file)
@@ -28,7 +28,6 @@
 #include <libcxml/cxml.h>
 #include <libxml++/libxml++.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -38,7 +37,6 @@ using std::vector;
 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;
@@ -86,7 +84,6 @@ SubtitleContent::from_xml (Content* parent, cxml::ConstNodePtr node, int version
                return shared_ptr<SubtitleContent> ();
        }
 
-       /* Can't use make_shared here as the constructor is private */
        return shared_ptr<SubtitleContent> (new SubtitleContent (parent, node, version));
 }
 
@@ -133,7 +130,7 @@ SubtitleContent::SubtitleContent (Content* parent, cxml::ConstNodePtr node, int
 
        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)));
        }
 
        connect_to_fonts ();
index ea56ac7..24a328d 100644 (file)
@@ -26,7 +26,6 @@
 #include "raw_convert.h"
 #include "subtitle_content.h"
 #include <libxml++/libxml++.h>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -34,7 +33,6 @@
 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)
@@ -60,7 +58,7 @@ TextSubtitleContent::examine (boost::shared_ptr<Job> job)
 
        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)));
 }
 
 string
index 5e41253..7144f70 100644 (file)
@@ -30,7 +30,6 @@
 #include "log.h"
 #include "safe_stringstream.h"
 #include "compose.hpp"
-#include <boost/make_shared.hpp>
 #include <iostream>
 #include <iomanip>
 
@@ -45,7 +44,6 @@ using std::fixed;
 using std::setprecision;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** @param s Film to use.
  */
@@ -92,7 +90,7 @@ TranscodeJob::run ()
                _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);
                }
 
index e390487..a1221e5 100644 (file)
@@ -21,7 +21,6 @@
 #include "upmixer_a.h"
 #include "audio_buffers.h"
 #include "audio_mapping.h"
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
@@ -29,7 +28,6 @@ using std::string;
 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)
@@ -63,7 +61,7 @@ UpmixerA::out_channels () 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>
@@ -87,7 +85,7 @@ UpmixerA::run (shared_ptr<const AudioBuffers> in, int channels)
        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) {
index 6545242..90e1267 100644 (file)
@@ -21,7 +21,6 @@
 #include "upmixer_b.h"
 #include "audio_buffers.h"
 #include "audio_mapping.h"
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
@@ -29,7 +28,6 @@ using std::string;
 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)
@@ -60,13 +58,13 @@ UpmixerB::out_channels () 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> 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);
@@ -96,7 +94,7 @@ UpmixerB::run (shared_ptr<const AudioBuffers> in, int channels)
        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);
index ae6cb64..a59e966 100644 (file)
@@ -83,7 +83,6 @@ VideoContent::from_xml (Content* parent, cxml::ConstNodePtr node, int version)
                return shared_ptr<VideoContent> ();
        }
 
-       /* Can't use make_shared here as the constructor is private */
        return shared_ptr<VideoContent> (new VideoContent (parent, node, version));
 }
 
index fbc8de9..edc7460 100644 (file)
@@ -25,7 +25,6 @@
 #include "log.h"
 #include "compose.hpp"
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 #include "i18n.h"
@@ -35,7 +34,6 @@ using std::list;
 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)
@@ -168,7 +166,7 @@ VideoDecoder::fill_one_eye (Frame from, Frame to, Eyes eye)
        }
 
        /* 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 */
@@ -194,8 +192,8 @@ void
 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;
 
index b6b3c26..2011505 100644 (file)
@@ -25,7 +25,6 @@ extern "C" {
 #include <libavfilter/buffersrc.h>
 #include <libavfilter/buffersink.h>
 }
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
@@ -35,7 +34,6 @@ using std::vector;
 using std::string;
 using std::make_pair;
 using boost::shared_ptr;
-using boost::make_shared;
 
 VideoFilterGraph::VideoFilterGraph (dcp::Size s, AVPixelFormat p)
        : _size (s)
@@ -53,7 +51,7 @@ VideoFilterGraph::process (AVFrame* frame)
        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) {
@@ -65,7 +63,7 @@ VideoFilterGraph::process (AVFrame* frame)
                                break;
                        }
 
-                       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);
                }
        }
@@ -119,3 +117,4 @@ VideoFilterGraph::sink_name () const
 {
        return "buffersink";
 }
+
index f5fab48..d86fc4c 100644 (file)
 #include <dcp/stereo_picture_asset.h>
 #include <dcp/exceptions.h>
 #include <libxml++/libxml++.h>
-#include <boost/make_shared.hpp>
 
 #include "i18n.h"
 
 using std::list;
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 VideoMXFContent::VideoMXFContent (shared_ptr<const Film> film, boost::filesystem::path path)
        : Content (film, path)
@@ -53,7 +51,7 @@ bool
 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) {
 
@@ -62,7 +60,7 @@ VideoMXFContent::valid_mxf (boost::filesystem::path path)
        }
 
        try {
-               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) {
 
@@ -81,7 +79,7 @@ VideoMXFContent::examine (shared_ptr<Job> job)
        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);
 }
 
index 24f5c31..938d7de 100644 (file)
 #include <dcp/stereo_picture_asset.h>
 #include <dcp/stereo_picture_asset_reader.h>
 #include <dcp/exceptions.h>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 VideoMXFDecoder::VideoMXFDecoder (shared_ptr<const VideoMXFContent> content, shared_ptr<Log> log)
        : _content (content)
@@ -79,10 +77,10 @@ VideoMXFDecoder::pass (PassReason, bool)
        }
 
        if (_mono_reader) {
-               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);
        } else {
-               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);
index 6c78963..6b1d4d2 100644 (file)
@@ -72,7 +72,6 @@
 #endif
 #include <boost/filesystem.hpp>
 #include <boost/noncopyable.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 #include <fstream>
 #include <sstream>
@@ -94,7 +93,6 @@ using std::exception;
 using boost::shared_ptr;
 using boost::dynamic_pointer_cast;
 using boost::optional;
-using boost::make_shared;
 
 class FilmChangedDialog : public boost::noncopyable
 {
@@ -277,7 +275,7 @@ public:
 
        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);
@@ -286,7 +284,7 @@ public:
        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) {
@@ -492,14 +490,14 @@ private:
                                        );
                        } 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) {
index 3570dda..a112e45 100644 (file)
 #include <wx/cmdline.h>
 #include <wx/preferences.h>
 #include <wx/wx.h>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::exception;
 using std::string;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::thread;
 using boost::scoped_array;
 
@@ -130,7 +128,7 @@ public:
        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) {
index 3697b4e..fd95080 100644 (file)
@@ -31,7 +31,6 @@
 #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>
@@ -44,7 +43,6 @@ using std::cerr;
 using std::list;
 using std::exception;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::dynamic_pointer_cast;
 
 static void
@@ -208,7 +206,7 @@ main (int argc, char* argv[])
        }
 
        try {
-               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);
index eb44b49..c686a97 100644 (file)
@@ -51,7 +51,6 @@
 #endif
 #include <boost/bind.hpp>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 #ifdef check
 #undef check
@@ -62,7 +61,6 @@ using std::list;
 using std::string;
 using std::vector;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::bind;
 
 enum {
@@ -303,13 +301,13 @@ private:
                                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) {
index 0de05c3..5e50df2 100644 (file)
@@ -31,7 +31,6 @@
 #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>
@@ -42,19 +41,18 @@ using std::cerr;
 using std::string;
 using std::pair;
 using boost::shared_ptr;
-using boost::make_shared;
 using dcp::Data;
 
 static shared_ptr<Film> film;
 static EncodeServerDescription* server;
-static shared_ptr<FileLog> log_ = 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)
 {
-       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 ();
@@ -146,7 +144,7 @@ main (int argc, char* argv[])
                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) {
index 8ffe8b7..ab26329 100644 (file)
@@ -33,7 +33,6 @@
 #include "lib/audio_content.h"
 #include <wx/spinctrl.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::vector;
@@ -43,7 +42,6 @@ using std::list;
 using std::pair;
 using boost::dynamic_pointer_cast;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::optional;
 
 AudioPanel::AudioPanel (ContentPanel* p)
@@ -314,10 +312,10 @@ AudioPanel::setup_peak ()
        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 {
-                       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) {
index 19ebc90..01b1ca0 100644 (file)
 #include <dcp/modified_gamma_transfer_function.h>
 #include <wx/spinctrl.h>
 #include <wx/gbsizer.h>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::string;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::dynamic_pointer_cast;
 
 ColourConversionEditor::ColourConversionEditor (wxWindow* parent, bool yuv)
@@ -310,15 +308,19 @@ ColourConversionEditor::get () const
 
        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 ()))
+                                       )
                                )
                        );
        } else {
-               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 ()));
@@ -347,7 +349,7 @@ ColourConversionEditor::get () const
                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)));
 
        return conversion;
 }
index 99b9421..3d5b002 100644 (file)
 #include <wx/wx.h>
 #include <wx/dirdlg.h>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::cout;
 using std::vector;
 using std::exception;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::weak_ptr;
 using boost::dynamic_pointer_cast;
 
@@ -161,7 +159,7 @@ ContentMenu::join ()
        }
 
        try {
-               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);
                }
@@ -266,7 +264,7 @@ ContentMenu::find_missing ()
                return;
        }
 
-       shared_ptr<Job> j = make_shared<ExamineContentJob> (film, content);
+       shared_ptr<Job> j (new ExamineContentJob (film, content));
 
        _job_connection = j->Finished.connect (
                bind (
index 2150d45..72ab0ee 100644 (file)
 #include <wx/richtext/richtextctrl.h>
 #include <boost/algorithm/string.hpp>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 using std::max;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::optional;
 using boost::dynamic_pointer_cast;
 
@@ -178,7 +176,7 @@ HintsDialog::film_changed ()
 
        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 ());
index cba2217..cd6918b 100644 (file)
@@ -19,7 +19,7 @@
 */
 
 /** @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"
@@ -30,7 +30,6 @@
 #include "lib/util.h"
 #include "lib/exceptions.h"
 #include "lib/compose.hpp"
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::string;
@@ -39,7 +38,6 @@ using std::map;
 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 */
@@ -70,7 +68,7 @@ JobManagerView::job_added (weak_ptr<Job> j)
 {
        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)));
        }
 }
 
index 1a32e8f..68411ee 100644 (file)
 #include "lib/job_manager.h"
 #include "lib/send_problem_report_job.h"
 #include <wx/sizer.h>
-#include <boost/make_shared.hpp>
 
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** @param film Film that we are working on, or 0 */
 ReportProblemDialog::ReportProblemDialog (wxWindow* parent, shared_ptr<Film> film)
@@ -105,5 +103,5 @@ ReportProblemDialog::report ()
                return;
        }
 
-       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 ()))));
 }
index df07a08..0638763 100644 (file)
@@ -26,7 +26,6 @@
 #include "cinema_dialog.h"
 #include "screen_dialog.h"
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 using std::list;
 using std::pair;
@@ -35,7 +34,6 @@ using std::map;
 using std::string;
 using std::make_pair;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::optional;
 
 ScreensPanel::ScreensPanel (wxWindow* parent)
@@ -151,7 +149,7 @@ ScreensPanel::add_cinema_clicked ()
 {
        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);
        }
@@ -210,7 +208,7 @@ ScreensPanel::add_screen_clicked ()
                return;
        }
 
-       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) {
index ef8549d..6bb216d 100644 (file)
@@ -40,7 +40,6 @@
 #include <wx/graphics.h>
 #include <boost/weak_ptr.hpp>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <list>
 #include <iostream>
 
@@ -48,7 +47,6 @@ using std::list;
 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;
@@ -152,19 +150,19 @@ Timeline::recreate_views ()
 
        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 ()) {
-                       _views.push_back (make_shared<TimelineAudioContentView> (*this, i));
+                       _views.push_back (shared_ptr<TimelineView> (new TimelineAudioContentView (*this, i)));
                }
 
                if (i->subtitle) {
-                       _views.push_back (make_shared<TimelineSubtitleContentView> (*this, i));
+                       _views.push_back (shared_ptr<TimelineView> (new TimelineSubtitleContentView (*this, 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)));
                }
        }
 
index c5418e9..033796a 100644 (file)
  *  The output is checked against test/data/4k_test.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/film.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/dcp_content_type.h"
 #include "lib/video_content.h"
 #include "lib/ratio.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (fourk_test)
 {
        shared_ptr<Film> film = new_test_film ("4k_test");
        film->set_name ("4k_test");
-       shared_ptr<FFmpegContent> c = 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"));
index 9fd9282..5923e06 100644 (file)
@@ -22,6 +22,7 @@
  *  @brief Check audio analysis code.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/audio_analysis.h"
 #include "lib/analyse_audio_job.h"
 #include "lib/film.h"
 #include "lib/job_manager.h"
 #include "lib/audio_content.h"
 #include "test.h"
-#include <boost/make_shared.hpp>
-#include <boost/test/unit_test.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 static float
 random_float ()
@@ -99,11 +97,11 @@ BOOST_AUTO_TEST_CASE (audio_analysis_test)
        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 ();
 
-       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 ();
@@ -114,13 +112,13 @@ BOOST_AUTO_TEST_CASE (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);
 
-       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 ();
@@ -131,11 +129,11 @@ BOOST_AUTO_TEST_CASE (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 ();
 
-       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 ();
@@ -160,7 +158,7 @@ BOOST_AUTO_TEST_CASE (audio_analysis_test3)
        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 ();
 
index 92c99a3..945773d 100644 (file)
@@ -28,7 +28,6 @@
 #include "lib/audio_content.h"
 #include "lib/film.h"
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 #include <cassert>
 #include <iostream>
 
@@ -36,7 +35,6 @@ using std::string;
 using std::cout;
 using std::min;
 using boost::shared_ptr;
-using boost::make_shared;
 
 class TestAudioContent : public Content
 {
@@ -78,7 +76,7 @@ public:
                        _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;
index a87c301..1d2d171 100644 (file)
  *  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 <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;
-using boost::make_shared;
 
 static
 void test_audio_delay (int delay_in_ms)
@@ -57,7 +55,7 @@ void test_audio_delay (int delay_in_ms)
        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);
index 0ad91dd..b92d005 100644 (file)
  *  @brief Basic tests of audio filters.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/audio_filter.h"
 #include "lib/audio_buffers.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 static void
 audio_filter_impulse_test_one (AudioFilter& f, int block_size, int num_blocks)
@@ -37,7 +35,7 @@ audio_filter_impulse_test_one (AudioFilter& f, int block_size, int num_blocks)
 
        for (int i = 0; i < num_blocks; ++i) {
 
-               shared_ptr<AudioBuffers> in = 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;
                }
@@ -78,7 +76,7 @@ BOOST_AUTO_TEST_CASE (audio_filter_impulse_input_test)
 {
        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;
 
index 9fc2d72..78f8e68 100644 (file)
 #include "lib/audio_delay.h"
 #include "lib/audio_buffers.h"
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 #include <cmath>
 #include <iostream>
 
 using std::cerr;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 #define CHECK_SAMPLE(c,f,r) \
        if (fabs(out->data(c)[f] - (r)) > 0.1) {                        \
@@ -43,7 +41,7 @@ BOOST_AUTO_TEST_CASE (audio_processor_delay_test1)
 
        int const C = 2;
 
-       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;
@@ -93,7 +91,7 @@ BOOST_AUTO_TEST_CASE (audio_processor_delay_test2)
        /* 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;
@@ -114,7 +112,7 @@ BOOST_AUTO_TEST_CASE (audio_processor_delay_test2)
        /* 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);
 
index 97d2cd7..8357cff 100644 (file)
 #include "lib/film.h"
 #include "test.h"
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Test the mid-side decoder for analysis and DCP-making */
 BOOST_AUTO_TEST_CASE (audio_processor_test)
 {
        shared_ptr<Film> film = new_test_film ("audio_processor_test");
        film->set_name ("audio_processor_test");
-       shared_ptr<FFmpegContent> c = 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 ();
 
@@ -45,7 +43,7 @@ BOOST_AUTO_TEST_CASE (audio_processor_test)
        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 ();
 
index 77ee908..79b97ad 100644 (file)
 
 */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/image_content.h"
 #include "lib/dcp_content_type.h"
 #include "lib/film.h"
 #include "lib/ratio.h"
 #include "lib/video_content.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 /** @file test/black_fill_test.cc
  *  @brief Test insertion of black frames between separate bits of video content.
  */
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (black_fill_test)
 {
@@ -41,8 +39,8 @@ BOOST_AUTO_TEST_CASE (black_fill_test)
        film->set_name ("black_fill_test");
        film->set_container (Ratio::from_id ("185"));
        film->set_sequence (false);
-       shared_ptr<ImageContent> contentA = 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);
index 71758e0..d7ccbc6 100644 (file)
@@ -41,7 +41,7 @@ BOOST_AUTO_TEST_CASE (burnt_subtitle_test_subrip)
        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);
@@ -60,7 +60,7 @@ BOOST_AUTO_TEST_CASE (burnt_subtitle_test_dcp)
        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 ();
index 68ef336..1f77f7f 100644 (file)
 #include "lib/file_log.h"
 #include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
-#include <boost/make_shared.hpp>
 
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::thread;
 using boost::optional;
 using dcp::Data;
@@ -58,7 +56,7 @@ do_remote_encode (shared_ptr<DCPVideo> frame, EncodeServerDescription descriptio
 
 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) {
@@ -71,7 +69,7 @@ BOOST_AUTO_TEST_CASE (client_server_test_rgb)
                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;
@@ -84,11 +82,11 @@ BOOST_AUTO_TEST_CASE (client_server_test_rgb)
                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 (
-                       make_shared<RawImageProxy> (image),
+                       shared_ptr<ImageProxy> (new RawImageProxy (image)),
                        DCPTime (),
                        Crop (),
                        optional<double> (),
@@ -142,7 +140,7 @@ BOOST_AUTO_TEST_CASE (client_server_test_rgb)
 
 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];
@@ -151,7 +149,7 @@ BOOST_AUTO_TEST_CASE (client_server_test_yuv)
                }
        }
 
-       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;
@@ -164,11 +162,11 @@ BOOST_AUTO_TEST_CASE (client_server_test_yuv)
                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 (
-                       make_shared<RawImageProxy> (image),
+                       shared_ptr<ImageProxy> (new RawImageProxy (image)),
                        DCPTime (),
                        Crop (),
                        optional<double> (),
@@ -222,7 +220,7 @@ BOOST_AUTO_TEST_CASE (client_server_test_yuv)
 
 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];
@@ -231,11 +229,11 @@ BOOST_AUTO_TEST_CASE (client_server_test_j2k)
                }
        }
 
-       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 (
-                       make_shared<RawImageProxy> (image),
+                       shared_ptr<ImageProxy> (new RawImageProxy (image)),
                        DCPTime (),
                        Crop (),
                        optional<double> (),
@@ -262,8 +260,7 @@ BOOST_AUTO_TEST_CASE (client_server_test_j2k)
 
        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> (),
index 00e830d..6c25e8a 100644 (file)
 #include <libxml++/libxml++.h>
 #include <boost/test/unit_test.hpp>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (colour_conversion_test1)
 {
@@ -111,7 +109,7 @@ BOOST_AUTO_TEST_CASE (colour_conversion_test4)
                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);
        }
index 85dea39..ef733d3 100644 (file)
@@ -22,6 +22,7 @@
  *  @brief Test DCP subtitle content in various ways.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/film.h"
 #include "lib/dcp_subtitle_content.h"
 #include "lib/dcp_content.h"
 #include "lib/content_subtitle.h"
 #include "lib/subtitle_decoder.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::cout;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Test pass-through of a very simple DCP subtitle file */
 BOOST_AUTO_TEST_CASE (dcp_subtitle_test)
@@ -48,7 +46,7 @@ BOOST_AUTO_TEST_CASE (dcp_subtitle_test)
        film->set_container (Ratio::from_id ("185"));
        film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
        film->set_name ("frobozz");
-       shared_ptr<DCPSubtitleContent> content = 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 ();
 
@@ -69,11 +67,11 @@ BOOST_AUTO_TEST_CASE (dcp_subtitle_within_dcp_test)
        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 ();
 
-       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 (
index 2101e97..bad800e 100644 (file)
 #include "test.h"
 #include <sndfile.h>
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Test the FFmpeg code with audio-only content */
 static void
@@ -39,7 +37,7 @@ test (boost::filesystem::path file)
        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 ();
@@ -58,7 +56,7 @@ test (boost::filesystem::path file)
        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);
index 07e6e03..cfbaf46 100644 (file)
 #include <dcp/sound_asset_reader.h>
 #include <dcp/reel.h>
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (ffmpeg_audio_test)
 {
        shared_ptr<Film> film = new_test_film ("ffmpeg_audio_test");
        film->set_name ("ffmpeg_audio_test");
-       shared_ptr<FFmpegContent> c = 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 ();
index c69516b..18decee 100644 (file)
  *  Also a quick test of Film::have_dcp ().
  */
 
+#include <boost/test/unit_test.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
 #include "lib/film.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/ratio.h"
 #include "lib/dcp_content_type.h"
 #include "lib/video_content.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (ffmpeg_dcp_test)
 {
        shared_ptr<Film> film = new_test_film ("ffmpeg_dcp_test");
        film->set_name ("test_film2");
-       shared_ptr<FFmpegContent> c = 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 ();
@@ -61,7 +59,7 @@ BOOST_AUTO_TEST_CASE (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());
 
index 5e310cd..8a854b0 100644 (file)
 #include "test.h"
 #include <boost/test/unit_test.hpp>
 #include <boost/filesystem.hpp>
-#include <boost/make_shared.hpp>
 #include <vector>
 
 using std::cerr;
 using std::vector;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::optional;
 
 static void
@@ -64,11 +62,11 @@ test (boost::filesystem::path file, vector<int> frames)
        }
 
        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 ();
-       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);
index 9edca01..6a27d69 100644 (file)
@@ -31,7 +31,6 @@
 #include "lib/film.h"
 #include "test.h"
 #include <boost/filesystem.hpp>
-#include <boost/make_shared.hpp>
 #include <boost/test/unit_test.hpp>
 #include <iostream>
 
@@ -39,7 +38,6 @@ using std::cout;
 using std::cerr;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::optional;
 
 void
@@ -52,11 +50,11 @@ ffmpeg_decoder_sequential_test_one (boost::filesystem::path file, float fps, int
        }
 
        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 ();
-       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);
index 2900689..13846a8 100644 (file)
  *  correctly from data/count300bd24.m2ts.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/ffmpeg_examiner.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/ffmpeg_audio_stream.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (ffmpeg_examiner_test)
 {
        shared_ptr<Film> film = new_test_film ("ffmpeg_examiner_test");
-       shared_ptr<FFmpegContent> content = 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);
index ccc2a10..02ea023 100644 (file)
  *  @brief Check the computation of _pts_offset in FFmpegDecoder.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/film.h"
 #include "lib/ffmpeg_decoder.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/ffmpeg_audio_stream.h"
 #include "lib/audio_content.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (ffmpeg_pts_offset_test)
 {
        shared_ptr<Film> film = new_test_film ("ffmpeg_pts_offset_test");
-       shared_ptr<FFmpegContent> content = 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()));
-       /* Can't use make_shared here */
        content->audio->add_stream (shared_ptr<FFmpegAudioStream> (new FFmpegAudioStream));
        content->_video_frame_rate = 24;
 
index d61f5f0..970c652 100644 (file)
  *  @brief Test some basic reading/writing of film metadata.
  */
 
+#include <boost/test/unit_test.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/date_time.hpp>
 #include "lib/film.h"
 #include "lib/dcp_content_type.h"
 #include "lib/ratio.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/date_time.hpp>
-#include <boost/make_shared.hpp>
 
 using std::string;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (film_metadata_test)
 {
@@ -55,7 +53,7 @@ BOOST_AUTO_TEST_CASE (film_metadata_test)
        ignore.push_back ("Key");
        check_xml ("test/data/metadata.xml.ref", dir.string() + "/metadata.xml", ignore);
 
-       shared_ptr<Film> g = make_shared<Film> (dir);
+       shared_ptr<Film> g (new Film (dir));
        g->read_metadata ();
 
        BOOST_CHECK_EQUAL (g->name(), "fred");
index 490836a..592b7af 100644 (file)
@@ -23,6 +23,7 @@
  *  frame rate for the DCP.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/film.h"
 #include "lib/config.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/video_content.h"
 #include "lib/audio_content.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 /* Test Playlist::best_dcp_frame_rate and FrameRateChange
    with a single piece of content.
@@ -45,7 +43,7 @@ BOOST_AUTO_TEST_CASE (best_dcp_frame_rate_test_single)
 {
        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 ();
 
@@ -223,9 +221,9 @@ BOOST_AUTO_TEST_CASE (best_dcp_frame_rate_test_double)
 {
        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);
-       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 ();
 
@@ -254,7 +252,7 @@ BOOST_AUTO_TEST_CASE (audio_sampling_rate_test)
 {
        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 ();
 
@@ -264,7 +262,7 @@ BOOST_AUTO_TEST_CASE (audio_sampling_rate_test)
        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;
index 59b35a9..d002630 100644 (file)
  *  @see test/make_black_test.cc, test/pixel_formats_test.cc
  */
 
+#include <boost/test/unit_test.hpp>
 #include <Magick++.h>
 #include "lib/image.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::string;
 using std::list;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (aligned_image_test)
 {
@@ -140,7 +138,7 @@ BOOST_AUTO_TEST_CASE (alpha_blend_test)
 {
        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];
 
@@ -153,7 +151,7 @@ BOOST_AUTO_TEST_CASE (alpha_blend_test)
                }
        }
 
-       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];
 
@@ -194,7 +192,7 @@ BOOST_AUTO_TEST_CASE (merge_test1)
 {
        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];
 
@@ -219,7 +217,7 @@ BOOST_AUTO_TEST_CASE (merge_test1)
 /** 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) {
@@ -229,7 +227,7 @@ BOOST_AUTO_TEST_CASE (merge_test2)
                a[x * 4 + 3] = 255;
        }
 
-       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) {
index 3dc9333..69ffa9c 100644 (file)
 #include "lib/cross.h"
 #include <dcp/cpl.h>
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using std::vector;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Make an encrypted DCP, import it and make a new unencrypted DCP */
 BOOST_AUTO_TEST_CASE (import_dcp_test)
@@ -43,7 +41,7 @@ BOOST_AUTO_TEST_CASE (import_dcp_test)
        A->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
        A->set_name ("frobozz");
 
-       shared_ptr<FFmpegContent> c = 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 ();
@@ -54,7 +52,7 @@ BOOST_AUTO_TEST_CASE (import_dcp_test)
        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 (),
@@ -70,7 +68,7 @@ BOOST_AUTO_TEST_CASE (import_dcp_test)
        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 ();
index 4d57879..8883c2d 100644 (file)
 #include "lib/cross.h"
 #include "test.h"
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Interrupt a DCP encode when it is in progress, as this used to (still does?)
  *  sometimes give an error related to pthreads.
@@ -42,7 +40,7 @@ BOOST_AUTO_TEST_CASE (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 ();
 
index e3023f9..bb47fa9 100644 (file)
 #include "lib/ffmpeg_content.h"
 #include "lib/audio_content.h"
 #include "test.h"
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (isdcf_name_test)
 {
@@ -78,7 +76,7 @@ BOOST_AUTO_TEST_CASE (isdcf_name_test)
 
        /* 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")));
@@ -130,7 +128,7 @@ BOOST_AUTO_TEST_CASE (isdcf_name_test)
        /* 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");
index 5212ec1..8728b73 100644 (file)
  *  @brief Basic tests of Job and JobManager.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/job.h"
 #include "lib/job_manager.h"
 #include "lib/cross.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 class TestJob : public Job
 {
@@ -72,7 +70,7 @@ BOOST_AUTO_TEST_CASE (job_manager_test)
        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);
index 88bf4bb..405cc83 100644 (file)
  *  @see test/image_test.cc
  */
 
+#include <boost/test/unit_test.hpp>
 #include <dcp/util.h>
 extern "C" {
 #include <libavutil/pixfmt.h>
 }
 #include "lib/image.h"
-#include <boost/make_shared.hpp>
-#include <boost/test/unit_test.hpp>
 
 using std::list;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (make_black_test)
 {
@@ -81,7 +79,7 @@ BOOST_AUTO_TEST_CASE (make_black_test)
 
        int N = 0;
        for (list<AVPixelFormat>::const_iterator i = pix_fmts.begin(); i != pix_fmts.end(); ++i) {
-               boost::shared_ptr<Image> foo = 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);
 
index 9b9e2c8..92c49a1 100644 (file)
@@ -88,13 +88,13 @@ BOOST_AUTO_TEST_CASE (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);
 
-       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 ();
 
@@ -107,7 +107,7 @@ BOOST_AUTO_TEST_CASE (play_test)
        /* 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 ();
index 6ca0073..1b628f7 100644 (file)
@@ -22,6 +22,8 @@
  *  @brief Various tests of Player.
  */
 
+#include <iostream>
+#include <boost/test/unit_test.hpp>
 #include "lib/film.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/dcp_content_type.h"
 #include "lib/audio_buffers.h"
 #include "lib/player.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
-#include <iostream>
 
 using std::cout;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 
 static bool
 valid (Content const *)
@@ -51,9 +49,9 @@ BOOST_AUTO_TEST_CASE (player_overlaps_test)
        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);
@@ -66,7 +64,7 @@ BOOST_AUTO_TEST_CASE (player_overlaps_test)
        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);
@@ -94,14 +92,14 @@ BOOST_AUTO_TEST_CASE (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 ();
 
-       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 ());
index 83e83d8..f9ef879 100644 (file)
 #include <dcp/mono_picture_asset.h>
 #include <dcp/stereo_picture_asset.h>
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::cout;
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 static void
 note (dcp::NoteType t, string n)
@@ -55,7 +53,7 @@ BOOST_AUTO_TEST_CASE (recover_test_2d)
        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 ();
 
@@ -73,8 +71,8 @@ BOOST_AUTO_TEST_CASE (recover_test_2d)
        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 (&note, _1, _2)));
@@ -88,7 +86,7 @@ BOOST_AUTO_TEST_CASE (recover_test_3d)
        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 ();
@@ -108,8 +106,8 @@ BOOST_AUTO_TEST_CASE (recover_test_3d)
        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 (&note, _1, _2)));
index f516fb2..6178c88 100644 (file)
 #include "test.h"
 #include <boost/test/unit_test.hpp>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Test Film::reels() */
 BOOST_AUTO_TEST_CASE (reels_test1)
 {
        shared_ptr<Film> film = new_test_film ("reels_test1");
        film->set_container (Ratio::from_id ("185"));
-       shared_ptr<FFmpegContent> A = 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);
-       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));
@@ -89,21 +87,21 @@ BOOST_AUTO_TEST_CASE (reels_test2)
        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);
        }
 
        {
-               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);
        }
 
        {
-               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);
@@ -123,7 +121,7 @@ BOOST_AUTO_TEST_CASE (reels_test2)
        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 ();
 
@@ -157,9 +155,9 @@ BOOST_AUTO_TEST_CASE (reels_test3)
        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);
-       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 ();
 
@@ -199,7 +197,7 @@ BOOST_AUTO_TEST_CASE (reels_test4)
                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 ();
 
index be39242..d145ccb 100644 (file)
  *  @see test/skip_frame_test.cc
  */
 
+#include <boost/test/unit_test.hpp>
 #include "test.h"
 #include "lib/film.h"
 #include "lib/ratio.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/dcp_content_type.h"
 #include "lib/video_content.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (repeat_frame_test)
 {
@@ -43,7 +41,7 @@ BOOST_AUTO_TEST_CASE (repeat_frame_test)
        film->set_name ("repeat_frame_test");
        film->set_container (Ratio::from_id ("185"));
        film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
-       shared_ptr<FFmpegContent> c = 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 ();
index cb5cddc..fb4b988 100644 (file)
  *  to the number of samples it generates.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/audio_buffers.h"
 #include "lib/resampler.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::pair;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 static void
 resampler_test_one (int from, int to)
@@ -44,7 +42,7 @@ resampler_test_one (int from, int to)
 
        /* XXX: no longer checks anything */
        for (int64_t i = 0; i < N; i += 1000) {
-               shared_ptr<AudioBuffers> a = make_shared<AudioBuffers> (1, 1000);
+               shared_ptr<AudioBuffers> a (new AudioBuffers (1, 1000));
                a->make_silent ();
                shared_ptr<const AudioBuffers> r = resamp.run (a);
        }
index 4bb6551..5ac5c75 100644 (file)
  *  @brief Test scaling and black-padding of images from a still-image source.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/image_content.h"
 #include "lib/ratio.h"
 #include "lib/film.h"
 #include "lib/dcp_content_type.h"
 #include "lib/video_content.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 static void scaling_test_for (shared_ptr<Film> film, shared_ptr<Content> content, string image, string container)
 {
@@ -62,7 +60,7 @@ BOOST_AUTO_TEST_CASE (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);
 
index c22cadb..05bf1b5 100644 (file)
@@ -23,6 +23,7 @@
  *  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"
@@ -34,8 +35,6 @@
 #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;
@@ -43,7 +42,6 @@ using std::list;
 using boost::shared_ptr;
 using boost::dynamic_pointer_cast;
 using boost::optional;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (seek_zero_test)
 {
@@ -51,7 +49,7 @@ BOOST_AUTO_TEST_CASE (seek_zero_test)
        film->set_name ("seek_zero_test");
        film->set_container (Ratio::from_id ("185"));
        film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
-       shared_ptr<FFmpegContent> content = 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")));
index 5ece7d9..9791b71 100644 (file)
 #include <dcp/reel_sound_asset.h>
 #include <dcp/sound_asset_reader.h>
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using std::string;
 using boost::lexical_cast;
 using boost::shared_ptr;
-using boost::make_shared;
 
 static void
 test_silence_padding (int channels)
@@ -51,7 +49,7 @@ test_silence_padding (int channels)
        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 ();
 
index b98b803..8ff43a4 100644 (file)
  *  @see test/repeat_frame_test.cc
  */
 
+#include <boost/test/unit_test.hpp>
 #include "test.h"
 #include "lib/film.h"
 #include "lib/ratio.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/dcp_content_type.h"
 #include "lib/video_content.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (skip_frame_test)
 {
@@ -43,7 +41,7 @@ BOOST_AUTO_TEST_CASE (skip_frame_test)
        film->set_name ("skip_frame_test");
        film->set_container (Ratio::from_id ("185"));
        film->set_dcp_content_type (DCPContentType::from_pretty_name ("Test"));
-       shared_ptr<FFmpegContent> c = 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 ();
index 2899d50..123d04d 100644 (file)
 #include "test.h"
 #include <boost/test/unit_test.hpp>
 #include <boost/algorithm/string.hpp>
-#include <boost/make_shared.hpp>
 #include <list>
 
 using std::string;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Make a very short DCP with a single subtitle from .srt with no specified fonts */
 BOOST_AUTO_TEST_CASE (srt_subtitle_test)
@@ -46,7 +44,7 @@ BOOST_AUTO_TEST_CASE (srt_subtitle_test)
        film->set_container (Ratio::from_id ("185"));
        film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
        film->set_name ("frobozz");
-       shared_ptr<TextSubtitleContent> content = 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 ();
 
@@ -66,7 +64,7 @@ BOOST_AUTO_TEST_CASE (srt_subtitle_test2)
        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 ();
 
@@ -91,7 +89,7 @@ BOOST_AUTO_TEST_CASE (srt_subtitle_test3)
        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 ();
 
@@ -132,11 +130,11 @@ BOOST_AUTO_TEST_CASE (srt_subtitle_test3)
 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));
 
-       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)
index 0bfa39e..f6c65b1 100644 (file)
 #include "test.h"
 #include <boost/test/unit_test.hpp>
 #include <boost/algorithm/string.hpp>
-#include <boost/make_shared.hpp>
 #include <list>
 
 using std::string;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Make a DCP with subs from a .ssa file */
 BOOST_AUTO_TEST_CASE (ssa_subtitle_test1)
@@ -44,7 +42,7 @@ BOOST_AUTO_TEST_CASE (ssa_subtitle_test1)
        film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
        film->set_name ("frobozz");
        film->set_interop (true);
-       shared_ptr<TextSubtitleContent> content = 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 ();
 
index d318043..c7a9e95 100644 (file)
@@ -40,7 +40,6 @@
 #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>
@@ -54,7 +53,6 @@ using std::list;
 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");
 
@@ -114,7 +112,7 @@ new_test_film (string name)
                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;
 }
index 23236fb..ab94cf8 100644 (file)
 #include "lib/dcp_content_type.h"
 #include "lib/ffmpeg_content.h"
 #include "lib/video_content.h"
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (threed_test)
 {
        shared_ptr<Film> film = new_test_film ("threed_test");
        film->set_name ("test_film2");
-       shared_ptr<FFmpegContent> c = 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 ();
 
index bf21e54..ddd685d 100644 (file)
 #include "lib/audio_content.h"
 #include "test.h"
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using std::string;
 using std::list;
 using boost::shared_ptr;
-using boost::make_shared;
 
 static string const xml = "<Content>"
        "<Type>FFmpeg</Type>"
@@ -125,11 +123,11 @@ BOOST_AUTO_TEST_CASE (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;
-       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);
@@ -178,15 +176,15 @@ BOOST_AUTO_TEST_CASE (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;
-       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);
 
-       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 ());
@@ -383,15 +381,15 @@ BOOST_AUTO_TEST_CASE (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;
-       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);
 
-       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 ());
@@ -559,16 +557,16 @@ BOOST_AUTO_TEST_CASE (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;
-       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);
 
-       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 ());
index 4c611c3..e0117c7 100644 (file)
@@ -18,6 +18,8 @@
 
 */
 
+#include <boost/test/unit_test.hpp>
+#include <sndfile.h>
 #include "lib/film.h"
 #include "lib/ratio.h"
 #include "lib/dcp_content_type.h"
 #include "lib/audio_buffers.h"
 #include "lib/upmixer_a.h"
 #include "test.h"
-#include <sndfile.h>
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (upmixer_a_test)
 {
@@ -40,7 +38,7 @@ BOOST_AUTO_TEST_CASE (upmixer_a_test)
        film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
        film->set_name ("frobozz");
        film->set_audio_processor (AudioProcessor::from_id ("stereo-5.1-upmix-a"));
-       shared_ptr<FFmpegContent> content = 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 ();
@@ -56,7 +54,7 @@ BOOST_AUTO_TEST_CASE (upmixer_a_test)
        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());
index 480df0b..ae7c30b 100644 (file)
 #include "test.h"
 #include <boost/test/unit_test.hpp>
 #include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
 
 using std::list;
 using std::string;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Test the logic which decides whether a DCP can be referenced or not */
 BOOST_AUTO_TEST_CASE (vf_test1)
 {
        shared_ptr<Film> film = new_test_film ("vf_test1");
-       shared_ptr<DCPContent> dcp = 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 ();
 
@@ -53,7 +51,7 @@ BOOST_AUTO_TEST_CASE (vf_test1)
        /* (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 ();
 
index f1edce0..6f5d85a 100644 (file)
 
 */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/ffmpeg_content.h"
 #include "lib/ratio.h"
 #include "lib/video_content.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using std::list;
 using std::string;
 using std::cerr;
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::optional;
 
 static
@@ -88,11 +86,11 @@ test (dcp::Size content_size, dcp::Size display_size, dcp::Size film_size, Crop
                "<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;
-       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) {
index 8aa5e83..2d783f5 100644 (file)
 
 */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/image_decoder.h"
 #include "lib/image_content.h"
 #include "lib/content_video.h"
 #include "lib/video_decoder.h"
 #include "lib/film.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::list;
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 BOOST_AUTO_TEST_CASE (video_decoder_fill_test1)
 {
        shared_ptr<Film> film = new_test_film ("video_decoder_fill_test");
-       shared_ptr<ImageContent> c = 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);
@@ -61,7 +59,7 @@ BOOST_AUTO_TEST_CASE (video_decoder_fill_test1)
 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));
index 4759cb6..953e9b7 100644 (file)
 #include "test.h"
 #include <dcp/mono_picture_asset.h>
 #include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 
 using boost::shared_ptr;
-using boost::make_shared;
 using boost::dynamic_pointer_cast;
 
 static boost::filesystem::path ref_mxf = "test/data/scaling_test_185_185/j2c_a41afbff-e1ad-41c4-9a84-de315b95dd0f.mxf";
@@ -55,9 +53,9 @@ BOOST_AUTO_TEST_CASE (video_mxf_content_test)
        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");
-       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));
 }
index 408d46b..678f2b8 100644 (file)
  *  @brief Test creation of XML DCP subtitles.
  */
 
+#include <boost/test/unit_test.hpp>
 #include "lib/text_subtitle_content.h"
 #include "lib/film.h"
 #include "lib/ratio.h"
 #include "lib/dcp_content_type.h"
 #include "lib/subtitle_content.h"
 #include "test.h"
-#include <boost/test/unit_test.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 
 using std::cout;
 using boost::shared_ptr;
-using boost::make_shared;
 
 /** Build a small DCP with no picture and a single subtitle overlaid onto it */
 BOOST_AUTO_TEST_CASE (xml_subtitle_test)
@@ -43,7 +41,7 @@ BOOST_AUTO_TEST_CASE (xml_subtitle_test)
        film->set_container (Ratio::from_id ("185"));
        film->set_dcp_content_type (DCPContentType::from_isdcf_name ("TLR"));
        film->set_name ("frobozz");
-       shared_ptr<TextSubtitleContent> content = 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);
@@ -64,7 +62,7 @@ BOOST_AUTO_TEST_CASE (xml_subtitle_test2)
        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);