#include "dcpomatic_time.h"
#include "player_text.h"
-#include <boost/noncopyable.hpp>
#include <boost/thread/mutex.hpp>
#include <list>
#include <map>
/** @class ActiveText
* @brief A class to maintain information on active subtitles for Player.
*/
-class ActiveText : public boost::noncopyable
+class ActiveText
{
public:
+ ActiveText () {}
+
+ ActiveText (ActiveText const&) = delete;
+ ActiveText& operator= (ActiveText const&) = delete;
+
std::list<PlayerText> get_burnt (dcpomatic::DCPTimePeriod period, bool always_burn_captions) const;
void clear_before (dcpomatic::DCPTime time);
void clear ();
class Player;
class PlayerVideo;
-class Butler : public ExceptionStore, public boost::noncopyable
+class Butler : public ExceptionStore
{
public:
Butler (
~Butler ();
+ Butler (Butler const&) = delete;
+ Butler& operator= (Butler const&) = delete;
+
void seek (dcpomatic::DCPTime position, bool accurate);
class Error {
*/
+
#ifndef DCPOMATIC_DCP_CONTENT_TYPE_H
#define DCPOMATIC_DCP_CONTENT_TYPE_H
+
/** @file src/dcp_content_type.h
* @brief DCPContentType class.
*/
+
#include <dcp/dcp.h>
#include <string>
#include <vector>
+
/** @class DCPContentType
* @brief A description of the type of content for a DCP (e.g. feature, trailer etc.)
*/
-class DCPContentType : public boost::noncopyable
+class DCPContentType
{
public:
DCPContentType (std::string, dcp::ContentKind, std::string);
+ DCPContentType (DCPContentType const&) = delete;
+ DCPContentType& operator= (DCPContentType const&) = delete;
+
/** @return user-visible `pretty' name */
std::string pretty_name () const {
return _pretty_name;
static std::vector<DCPContentType const *> _dcp_content_types;
};
+
#endif
* Objects of this class are used for the queue that we keep
* of images that require encoding.
*/
-class DCPVideo : public boost::noncopyable
+class DCPVideo
{
public:
DCPVideo (std::shared_ptr<const PlayerVideo>, int index, int dcp_fps, int bandwidth, Resolution r);
DCPVideo (std::shared_ptr<const PlayerVideo>, cxml::ConstNodePtr);
+ DCPVideo (DCPVideo const&) = delete;
+ DCPVideo& operator= (DCPVideo const&) = delete;
+
dcp::ArrayData encode_locally ();
dcp::ArrayData encode_remotely (EncodeServerDescription, int timeout = 30);
#include "digester.h"
#include <boost/asio.hpp>
-#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
/** @class Socket
* This class wraps some things that I could not work out how to do easily with boost;
* most notably, sync read/write calls with timeouts.
*/
-class Socket : public boost::noncopyable
+class Socket
{
public:
explicit Socket (int timeout = 30);
+ Socket (Socket const&) = delete;
+ Socket& operator= (Socket const&) = delete;
+
/** @return Our underlying socket */
boost::asio::ip::tcp::socket& socket () {
return _socket;
void start_write_digest ();
void finish_write_digest ();
- Socket (Socket const &);
-
boost::asio::io_service _io_service;
boost::asio::deadline_timer _deadline;
boost::asio::ip::tcp::socket _socket;
*
* The content of a Film is held in a Playlist (created and managed by the Film).
*/
-class Film : public std::enable_shared_from_this<Film>, public Signaller, public boost::noncopyable
+class Film : public std::enable_shared_from_this<Film>, public Signaller
{
public:
explicit Film (boost::optional<boost::filesystem::path> dir);
~Film ();
+ Film (Film const&) = delete;
+ Film& operator= (Film const&) = delete;
+
std::shared_ptr<InfoFileHandle> info_file_handle (dcpomatic::DCPTimePeriod period, bool read) const;
boost::filesystem::path j2c_path (int, Frame, Eyes, bool) const;
boost::filesystem::path internal_video_asset_dir () const;
*/
+
/** @file src/filter.h
* @brief A class to describe one of FFmpeg's video or audio filters.
*/
+
#ifndef DCPOMATIC_FILTER_H
#define DCPOMATIC_FILTER_H
-#include <boost/utility.hpp>
+
#include <string>
#include <vector>
+
/** @class Filter
* @brief A class to describe one of FFmpeg's video or audio filters.
*
* 8bpp. FFmpeg quantizes e.g. yuv422p10le down to yuv422p before running such filters, which
* we don't really want to do.
*/
-class Filter : public boost::noncopyable
+class Filter
{
public:
Filter (std::string i, std::string n, std::string c, std::string f);
+ Filter (Filter const&) = delete;
+ Filter& operator= (Filter const&) = delete;
+
/** @return our id */
std::string id () const {
return _id;
static void maybe_add (std::string, std::string, std::string, std::string);
};
+
#endif
/** @class FilterGraph
* @brief A graph of FFmpeg filters.
*/
-class FilterGraph : public boost::noncopyable
+class FilterGraph
{
public:
FilterGraph ();
virtual ~FilterGraph ();
+ FilterGraph (FilterGraph const&) = delete;
+ FilterGraph& operator== (FilterGraph const&) = delete;
+
void setup (std::vector<Filter const *>);
AVFilterContext* get (std::string name);
* the TIFF data compressed until the decompressed image is needed.
* At this point, the class decodes the TIFF to an Image.
*/
-class ImageProxy : public boost::noncopyable
+class ImageProxy
{
public:
+ ImageProxy () {}
virtual ~ImageProxy () {}
+ ImageProxy (ImageProxy const&) = delete;
+ ImageProxy& operator= (ImageProxy const&) = delete;
+
struct Result {
Result (std::shared_ptr<Image> image_, int log2_scaling_)
: image (image_)
* This class keeps a queue of frames to be encoded and distributes
* the work around threads and encoding servers.
*/
-class J2KEncoder : public boost::noncopyable, public ExceptionStore, public std::enable_shared_from_this<J2KEncoder>
+class J2KEncoder : public ExceptionStore, public std::enable_shared_from_this<J2KEncoder>
{
public:
J2KEncoder (std::shared_ptr<const Film> film, std::shared_ptr<Writer> writer);
~J2KEncoder ();
+ J2KEncoder (J2KEncoder const&) = delete;
+ J2KEncoder& operator= (J2KEncoder const&) = delete;
+
/** Called to indicate that a processing run is about to begin */
void begin ();
/** @class Job
* @brief A parent class to represent long-running tasks which are run in their own thread.
*/
-class Job : public std::enable_shared_from_this<Job>, public Signaller, public boost::noncopyable
+class Job : public std::enable_shared_from_this<Job>, public Signaller
{
public:
explicit Job (std::shared_ptr<const Film> film);
virtual ~Job ();
+ Job (Job const&) = delete;
+ Job& operator= (Job const&) = delete;
+
/** @return user-readable name of this job */
virtual std::string name () const = 0;
virtual std::string json_name () const = 0;
*/
+
#include "types.h"
#include <samplerate.h>
-#include <boost/utility.hpp>
+
class AudioBuffers;
-class Resampler : public boost::noncopyable
+
+class Resampler
{
public:
Resampler (int, int, int);
~Resampler ();
+ Resampler (Resampler const&) = delete;
+ Resampler& operator= (Resampler const&) = delete;
+
std::shared_ptr<const AudioBuffers> run (std::shared_ptr<const AudioBuffers>);
std::shared_ptr<const AudioBuffers> flush ();
void reset ();
*/
+
#include <boost/filesystem.hpp>
-#include <boost/noncopyable.hpp>
#include <cstdio>
+
/** @class ScopedTemporary
* @brief A temporary file which is deleted when the ScopedTemporary object goes out of scope.
*/
-class ScopedTemporary : public boost::noncopyable
+class ScopedTemporary
{
public:
ScopedTemporary ();
~ScopedTemporary ();
+ ScopedTemporary (ScopedTemporary const&) = delete;
+ ScopedTemporary& operator= (ScopedTemporary const&) = delete;
+
/** @return temporary filename */
boost::filesystem::path file () const {
return _file;
#include "exception_store.h"
#include <boost/asio.hpp>
#include <boost/thread.hpp>
-#include <boost/noncopyable.hpp>
class Signaller;
#include "rect.h"
-#include <boost/noncopyable.hpp>
#include <boost/filesystem.hpp>
/** @class SubtitleAnalysis
* @brief Class to store the results of a SubtitleAnalysisJob.
*/
-class SubtitleAnalysis : public boost::noncopyable
+class SubtitleAnalysis
{
public:
explicit SubtitleAnalysis (boost::filesystem::path path);
, _analysis_y_offset (analysis_y_offset_)
{}
+ SubtitleAnalysis (SubtitleAnalysis const&) = delete;
+ SubtitleAnalysis& operator= (SubtitleAnalysis const&) = delete;
+
void write (boost::filesystem::path path) const;
boost::optional<dcpomatic::Rect<double>> bounding_box () const {
#include "dcpomatic_time.h"
#include "player_video.h"
#include "types.h"
-#include <boost/noncopyable.hpp>
#include <boost/thread/mutex.hpp>
#include <utility>
class PlayerVideo;
-class VideoRingBuffers : public boost::noncopyable
+class VideoRingBuffers
{
public:
+ VideoRingBuffers () {}
+
+ VideoRingBuffers (VideoRingBuffers const&) = delete;
+ VideoRingBuffers& operator= (VideoRingBuffers const&) = delete;
+
void put (std::shared_ptr<PlayerVideo> frame, dcpomatic::DCPTime time);
std::pair<std::shared_ptr<PlayerVideo>, dcpomatic::DCPTime> get ();
*/
-#include <boost/noncopyable.hpp>
#include <boost/filesystem.hpp>
#include <vector>
-class Zipper : public boost::noncopyable
+class Zipper
{
public:
Zipper (boost::filesystem::path file);
~Zipper ();
+ Zipper (Zipper const&) = delete;
+ Zipper& operator= (Zipper const&) = delete;
+
void add (std::string name, std::string content);
void close ();
class Job;
class DCPContent;
-class ContentMenu : public boost::noncopyable
+class ContentMenu
{
public:
explicit ContentMenu (wxWindow* p);
+ ContentMenu (ContentMenu const &) = delete;
+ ContentMenu& operator= (ContentMenu const &) = delete;
+
void popup (std::weak_ptr<Film>, ContentList, TimelineContentViewList, wxPoint);
private:
};
-class ContentPanel : public boost::noncopyable
+class ContentPanel
{
public:
ContentPanel (wxNotebook *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
+ ContentPanel (ContentPanel const&) = delete;
+ ContentPanel& operator= (ContentPanel const&) = delete;
+
std::shared_ptr<Film> film () const {
return _film;
}
#ifndef DCPOMATIC_JOB_VIEW_H
#define DCPOMATIC_JOB_VIEW_H
-#include <boost/noncopyable.hpp>
#include <boost/signals2.hpp>
class Job;
class wxSizer;
class wxCheckBox;
-class JobView : public boost::noncopyable
+class JobView
{
public:
JobView (std::shared_ptr<Job> job, wxWindow* parent, wxWindow* container, wxFlexGridSizer* table);
virtual ~JobView () {}
+ JobView (JobView const&) = delete;
+ JobView& operator= (JobView const&) = delete;
+
virtual int insert_position () const = 0;
virtual void job_list_changed () {}
#include <dcp/language_tag.h>
#include <wx/wx.h>
-#include <boost/noncopyable.hpp>
#include <boost/signals2.hpp>
class wxWindow;
-class LanguageTagWidget : public boost::noncopyable
+class LanguageTagWidget
{
public:
LanguageTagWidget (wxWindow* parent, wxString tooltip, boost::optional<dcp::LanguageTag> tag, boost::optional<wxString> size_to_fit = boost::none);
~LanguageTagWidget ();
+ LanguageTagWidget (LanguageTagWidget const&) = delete;
+ LanguageTagWidget& operator= (LanguageTagWidget const&) = delete;
+
wxSizer* sizer () const {
return _sizer;
}
projects / dcpomatic.git / commitdiff