* removed some lambda workarounds no longer required.
typedef std::vector<uint8_t, tbb::cache_aligned_allocator<uint8_t>> buffer;
-class image_mixer /* final */ : public core::image_mixer
+class image_mixer final : public core::image_mixer
{
public:
};
typedef enum_class<keyer_def> keyer;
-struct draw_params /* final */
+struct draw_params final
{
core::pixel_format_desc pix_desc;
std::vector<spl::shared_ptr<class texture>> textures;
}
};
-class image_kernel /* final */
+class image_kernel final
{
image_kernel(const image_kernel&);
image_kernel& operator=(const image_kernel&);
namespace caspar { namespace accelerator { namespace ogl {
-class image_mixer /* final */ : 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 /* final */
+class buffer final
{
buffer(const buffer&);
buffer& operator=(const buffer&);
class texture;
-class device /* final */ : 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 /* final */
+class shader final
{
shader(const shader&);
shader& operator=(const shader&);
class buffer;
class device;
-class texture /* final */
+class texture final
{
texture(const texture&);
texture& operator=(const texture&);
namespace caspar {
template<typename T>
-class array /* final */
+class array final
{
array(const array<std::uint8_t>&);
array& operator=(const array<std::uint8_t>&);
};
template<typename T>
-class array<const T> /* final */
+class array<const T> final
{
public:
};
typedef enum_class<task_priority_def> task_priority;
-class executor /* final */
+class executor final
{
executor(const executor&);
executor& operator=(const executor&);
};
template<typename I, typename O = I>
-class basic_subject_impl /* final */ : public subject<I, O>
+class basic_subject_impl final : public subject<I, O>
{
template <typename, typename> friend class basic_subject_impl;
return std::make_pair(0, 0);
auto buffer_depths = ports_ |
- boost::adaptors::map_values | // std::function is MSVC workaround
- boost::adaptors::transformed(std::function<int(const port&)>([](const port& p){return p.buffer_depth();}));
+ boost::adaptors::map_values |
+ boost::adaptors::transformed([](const port& p){return p.buffer_depth();});
return std::make_pair(*boost::range::min_element(buffer_depths), *boost::range::max_element(buffer_depths));
namespace caspar { namespace core {
-class output sealed
+class output final
{
output(const output&);
output& operator=(const output&);
struct frame_transform;
-class draw_frame /* final */
+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 /* final */
+class mutable_frame final
{
mutable_frame(const mutable_frame&);
mutable_frame& operator=(const mutable_frame&);
spl::unique_ptr<impl> impl_;
};
-class const_frame /* final */
+class const_frame final
{
public:
namespace caspar { namespace core {
-struct levels /* final */
+struct levels final
{
levels()
: min_input(0.0)
double max_output;
};
-struct image_transform /* final */
+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 /* final */
+struct audio_transform final
{
public:
audio_transform();
bool operator!=(const audio_transform& lhs, const audio_transform& rhs);
//__declspec(align(16))
-struct frame_transform /* final */
+struct frame_transform final
{
public:
frame_transform();
};
typedef enum_class<pixel_format_def> pixel_format;
-struct pixel_format_desc /* final */
+struct pixel_format_desc final
{
struct plane
{
typedef std::vector<int32_t, tbb::cache_aligned_allocator<int32_t>> audio_buffer;
-class audio_mixer /* final */ : 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 /* final */
+class mixer final
{
mixer(const mixer&);
mixer& operator=(const mixer&);
namespace caspar { namespace core {
-class layer /*final*/ : public interaction_sink
+class layer final : public interaction_sink
{
layer(const layer&);
layer& operator=(const layer&);
aggregator_.translate_and_send();
- // WORKAROUND: Compiler doesn't seem to like lambda.
tbb::parallel_for_each(indices.begin(), indices.end(), [&](int index)
{
draw(index, format_desc, frames);
//typedef reactive::observable<std::map<int, class draw_frame>> frame_observable;
-class stage /* final */ : public interaction_sink
+class stage final : public interaction_sink
{
stage(const stage&);
stage& operator=(const stage&);
namespace caspar { namespace core {
-struct video_channel::impl /* final */
+struct video_channel::impl final
{
spl::shared_ptr<monitor::subject> monitor_subject_;
namespace caspar { namespace core {
-class video_channel /*final*/
+class video_channel final
{
video_channel(const video_channel&);
video_channel& operator=(const video_channel&);
};
typedef enum_class<field_mode_def> field_mode;
-struct video_format_desc /* final */
+struct video_format_desc final
{
video_format format;
std::wstring widened_result;
// The first 255 codepoints in unicode is the same as in latin1
- auto from_signed_to_signed = std::function<unsigned char(char)>(
- [] (char c) { return static_cast<unsigned char>(c); }
- );
boost::copy(
- result | boost::adaptors::transformed(from_signed_to_signed),
+ result | boost::adaptors::transformed(
+ [](char c) { return static_cast<unsigned char>(c); }),
std::back_inserter(widened_result));
return widened_result;
class thumbnail_generator;
}
-class server /* final */ : public boost::noncopyable
+class server final : public boost::noncopyable
{
public:
explicit server(std::promise<bool>& shutdown_server_now);