typedef std::vector<uint8_t, tbb::cache_aligned_allocator<uint8_t>> buffer;
-class image_mixer sealed : public core::image_mixer
+class image_mixer /* final */ : public core::image_mixer
{
public:
};
typedef enum_class<keyer_def> keyer;
-struct draw_params sealed
+struct draw_params /* final */
{
core::pixel_format_desc pix_desc;
std::vector<spl::shared_ptr<class texture>> textures;
}
};
-class image_kernel sealed
+class image_kernel /* final */
{
image_kernel(const image_kernel&);
image_kernel& operator=(const image_kernel&);
namespace caspar { namespace accelerator { namespace ogl {
-class image_mixer sealed : public core::image_mixer
+class image_mixer /* final */ : public core::image_mixer
{
image_mixer(const image_mixer&);
image_mixer& operator=(const image_mixer&);
namespace caspar { namespace accelerator { namespace ogl {
-class buffer sealed
+class buffer /* final */
{
buffer(const buffer&);
buffer& operator=(const buffer&);
class texture;
-class device sealed : public std::enable_shared_from_this<device>
+class device /* final */ : public std::enable_shared_from_this<device>
{
device(const device&);
device& operator=(const device&);
namespace caspar { namespace accelerator { namespace ogl {
-class shader sealed
+class shader /* final */
{
shader(const shader&);
shader& operator=(const shader&);
class buffer;
class device;
-class texture sealed
+class texture /* final */
{
texture(const texture&);
texture& operator=(const texture&);
namespace caspar {
template<typename T>
-class array sealed
+class array /* final */
{
array(const array<std::uint8_t>&);
array& operator=(const array<std::uint8_t>&);
};
template<typename T>
-class array<const T> sealed
+class array<const T> /* final */
{
public:
};
typedef enum_class<task_priority_def> task_priority;
-class executor sealed
+class executor /* final */
{
executor(const executor&);
executor& operator=(const executor&);
};
template<typename I, typename O = I>
-class basic_subject_impl : public subject<I, O>
+class basic_subject_impl /* final */ : public subject<I, O>
{
template <typename, typename> friend class basic_subject_impl;
namespace caspar { namespace core {
-class output sealed : public monitor::observable
+class output /* final */ : public monitor::observable
{
output(const output&);
output& operator=(const output&);
struct frame_transform;
-class draw_frame sealed
+class draw_frame /* final */
{
public:
// Static Members
typedef std::vector<int32_t, tbb::cache_aligned_allocator<int32_t>> audio_buffer;
class frame_geometry;
-class mutable_frame sealed
+class mutable_frame /* final */
{
mutable_frame(const mutable_frame&);
mutable_frame& operator=(const mutable_frame&);
spl::unique_ptr<impl> impl_;
};
-class const_frame sealed
+class const_frame /* final */
{
public:
namespace caspar { namespace core {
-struct levels sealed
+struct levels /* final */
{
levels()
: min_input(0.0)
double max_output;
};
-struct image_transform sealed
+struct image_transform /* final */
{
public:
image_transform();
bool operator==(const image_transform& lhs, const image_transform& rhs);
bool operator!=(const image_transform& lhs, const image_transform& rhs);
-struct audio_transform sealed
+struct audio_transform /* final */
{
public:
audio_transform();
bool operator!=(const audio_transform& lhs, const audio_transform& rhs);
//__declspec(align(16))
-struct frame_transform sealed
+struct frame_transform /* final */
{
public:
frame_transform();
};
typedef enum_class<pixel_format_def> pixel_format;
-struct pixel_format_desc sealed
+struct pixel_format_desc /* final */
{
struct plane
{
typedef std::vector<int32_t, tbb::cache_aligned_allocator<int32_t>> audio_buffer;
-class audio_mixer sealed : public frame_visitor
+class audio_mixer /* final */ : public frame_visitor
{
audio_mixer(const audio_mixer&);
audio_mixer& operator=(const audio_mixer&);
namespace caspar { namespace core {
-class mixer sealed
+class mixer /* final */
{
mixer(const mixer&);
mixer& operator=(const mixer&);
// path
-class path sealed
+class path /* final */
{
public:
// event
-class event sealed
+class event /* final */
{
public:
typedef reactive::observer<monitor::event> observer;
typedef reactive::subject<monitor::event> subject;
-class basic_subject sealed : public reactive::subject<monitor::event>
+class basic_subject /* final */ : public reactive::subject<monitor::event>
{
basic_subject(const basic_subject&);
basic_subject& operator=(const basic_subject&);
namespace caspar { namespace core {
-class layer sealed : public monitor::observable, public interaction_sink
+class layer /* final */ : public monitor::observable, public interaction_sink
{
layer(const layer&);
layer& operator=(const layer&);
typedef reactive::observable<std::map<int, class draw_frame>> frame_observable;
-class stage sealed : public monitor::observable, public frame_observable, public interaction_sink
+class stage /* final */ : public monitor::observable, public frame_observable, public interaction_sink
{
stage(const stage&);
stage& operator=(const stage&);
namespace caspar { namespace core {
-struct video_channel::impl sealed
+struct video_channel::impl /* final */
{
monitor::basic_subject event_subject_;
namespace caspar { namespace core {
-class video_channel sealed : public monitor::observable
+class video_channel /* final */ : public monitor::observable
{
video_channel(const video_channel&);
video_channel& operator=(const video_channel&);
};
typedef enum_class<field_mode_def> field_mode;
-struct video_format_desc sealed
+struct video_format_desc /* final */
{
video_format format;
class thumbnail_generator;
}
-class server sealed : public monitor::observable
- , boost::noncopyable
+class server /* final */ : public monitor::observable
+ , boost::noncopyable
{
public:
explicit server(boost::promise<bool>& shutdown_server_now);