{\r
core::pixel_format_desc pix_desc;\r
std::vector<spl::shared_ptr<host_buffer>> buffers;\r
- core::frame_transform transform;\r
+ core::image_transform transform;\r
\r
item()\r
: pix_desc(core::pixel_format::invalid)\r
struct image_mixer::impl : boost::noncopyable\r
{ \r
image_renderer renderer_;\r
- std::vector<core::frame_transform> transform_stack_;\r
+ std::vector<core::image_transform> transform_stack_;\r
std::vector<item> items_; // layer/stream/items\r
public:\r
impl() \r
\r
void push(const core::frame_transform& transform)\r
{\r
- transform_stack_.push_back(transform_stack_.back()*transform);\r
+ transform_stack_.push_back(transform_stack_.back()*transform.image_transform);\r
}\r
\r
void visit(const core::data_frame& frame2)\r
item.pix_desc = frame->get_pixel_format_desc();\r
item.buffers = frame->get_buffers(); \r
item.transform = transform_stack_.back();\r
- item.transform.volume = core::frame_transform().volume; // Set volume to default since we don't care about it here.\r
\r
items_.push_back(item);\r
}\r
\r
void accept(const write_frame& self, core::frame_visitor& visitor) const\r
{\r
- visitor.push(self.get_frame_transform());\r
+ visitor.push(self.frame_transform());\r
visitor.visit(self);\r
visitor.pop();\r
}\r
{\r
core::pixel_format_desc pix_desc;\r
std::vector<spl::shared_ptr<class device_buffer>> textures;\r
- core::frame_transform transform;\r
+ core::image_transform transform;\r
core::blend_mode blend_mode;\r
keyer keyer;\r
std::shared_ptr<class device_buffer> background;\r
core::pixel_format_desc pix_desc;\r
std::vector<spl::shared_ptr<host_buffer>> buffers;\r
std::vector<future_texture> textures;\r
- core::frame_transform transform;\r
+ core::image_transform transform;\r
\r
\r
item()\r
(kernel_.has_blend_modes() && layers.at(0).blend_mode != core::blend_mode::normal) == false &&\r
layers.at(0).items.at(0).pix_desc.format == core::pixel_format::bgra &&\r
layers.at(0).items.at(0).buffers.at(0)->size() == format_desc.size &&\r
- layers.at(0).items.at(0).transform == core::frame_transform())\r
+ layers.at(0).items.at(0).transform == core::image_transform())\r
{ // Bypass GPU using streaming loads to cachable memory.\r
auto uswc_buffer = layers.at(0).items.at(0).buffers.at(0);\r
auto buffer = std::make_shared<std::vector<uint8_t, tbb::cache_aligned_allocator<uint8_t>>>(uswc_buffer->size());\r
draw_params.pix_desc.format = core::pixel_format::bgra;\r
draw_params.pix_desc.planes = list_of(core::pixel_format_desc::plane(source_buffer->width(), source_buffer->height(), 4));\r
draw_params.textures = list_of(source_buffer);\r
- draw_params.transform = core::frame_transform();\r
+ draw_params.transform = core::image_transform();\r
draw_params.blend_mode = blend_mode;\r
draw_params.background = draw_buffer;\r
\r
{ \r
spl::shared_ptr<context> ogl_;\r
image_renderer renderer_;\r
- std::vector<core::frame_transform> transform_stack_;\r
+ std::vector<core::image_transform> transform_stack_;\r
std::vector<layer> layers_; // layer/stream/items\r
public:\r
impl(const spl::shared_ptr<context>& ogl) \r
\r
void push(const core::frame_transform& transform)\r
{\r
- transform_stack_.push_back(transform_stack_.back()*transform);\r
+ transform_stack_.push_back(transform_stack_.back()*transform.image_transform);\r
}\r
\r
void visit(const core::data_frame& frame2)\r
item.pix_desc = frame->get_pixel_format_desc();\r
item.buffers = frame->get_buffers(); \r
item.transform = transform_stack_.back();\r
- item.transform.volume = core::frame_transform().volume; // Set volume to default since we don't care about it here.\r
\r
layers_.back().items.push_back(item);\r
}\r
\r
void accept(const write_frame& self, core::frame_visitor& visitor) const\r
{\r
- visitor.push(self.get_frame_transform());\r
+ visitor.push(self.frame_transform());\r
visitor.visit(self);\r
visitor.pop();\r
}\r
{ \r
std::vector<spl::shared_ptr<const draw_frame>> frames_;\r
\r
- frame_transform frame_transform_; \r
+ core::frame_transform frame_transform_; \r
public:\r
impl()\r
{\r
frame->accept(visitor);\r
visitor.pop();\r
} \r
- \r
- core::field_mode field_mode() const\r
- {\r
- if(frame_transform_.field_mode == field_mode::upper || frame_transform_.field_mode == field_mode::lower)\r
- return frame_transform_.field_mode;\r
-\r
- if(frames_.empty())\r
- return field_mode::progressive;\r
- \r
- BOOST_FOREACH(auto frame, frames_)\r
- {\r
- auto mode = frame->field_mode();\r
- if(frame_transform_.field_mode == field_mode::upper || frame_transform_.field_mode == field_mode::lower)\r
- return mode;\r
- }\r
-\r
- return field_mode::progressive;\r
- }\r
};\r
\r
draw_frame::draw_frame() : impl_(new impl()){}\r
}\r
void draw_frame::swap(draw_frame& other){impl_.swap(other.impl_);}\r
\r
-const frame_transform& draw_frame::get_frame_transform() const { return impl_->frame_transform_;}\r
-frame_transform& draw_frame::get_frame_transform() { return impl_->frame_transform_;}\r
+const core::frame_transform& draw_frame::frame_transform() const { return impl_->frame_transform_;}\r
+core::frame_transform& draw_frame::frame_transform() { return impl_->frame_transform_;}\r
void draw_frame::accept(frame_visitor& visitor) const{impl_->accept(visitor);}\r
-field_mode draw_frame::field_mode() const{return impl_->field_mode();}\r
-\r
spl::shared_ptr<draw_frame> draw_frame::interlace(const spl::shared_ptr<const draw_frame>& frame1, const spl::shared_ptr<const draw_frame>& frame2, core::field_mode mode)\r
{ \r
if(frame1 == draw_frame::eof() || frame2 == draw_frame::eof())\r
\r
if(mode == field_mode::upper)\r
{\r
- my_frame1->get_frame_transform().field_mode = field_mode::upper; \r
- my_frame2->get_frame_transform().field_mode = field_mode::lower; \r
+ my_frame1->frame_transform().image_transform.field_mode = field_mode::upper; \r
+ my_frame2->frame_transform().image_transform.field_mode = field_mode::lower; \r
} \r
else \r
{ \r
- my_frame1->get_frame_transform().field_mode = field_mode::lower; \r
- my_frame2->get_frame_transform().field_mode = field_mode::upper; \r
+ my_frame1->frame_transform().image_transform.field_mode = field_mode::lower; \r
+ my_frame2->frame_transform().image_transform.field_mode = field_mode::upper; \r
}\r
\r
std::vector<spl::shared_ptr<const draw_frame>> frames;\r
\r
std::vector<spl::shared_ptr<const draw_frame>> frames;\r
auto key2 = spl::make_shared<draw_frame>(key);\r
- key2->get_frame_transform().is_key = true;\r
+ key2->frame_transform().image_transform.is_key = true;\r
frames.push_back(key2);\r
frames.push_back(fill);\r
return spl::make_shared<draw_frame>(std::move(frames));\r
spl::shared_ptr<draw_frame> draw_frame::still(const spl::shared_ptr<const draw_frame>& frame)\r
{\r
auto frame2 = spl::make_shared<draw_frame>(frame);\r
- frame2->get_frame_transform().is_still = true; \r
+ frame2->frame_transform().image_transform.is_still = true; \r
+ frame2->frame_transform().audio_transform.volume = 0.0; \r
return frame2;\r
}\r
\r
\r
namespace caspar { namespace core {\r
\r
+struct frame_transform;\r
+\r
class draw_frame\r
{\r
public:\r
draw_frame(std::vector<spl::shared_ptr<const draw_frame>> frames);\r
\r
void swap(draw_frame& other);\r
-\r
- field_mode field_mode() const;\r
-\r
- const struct frame_transform& get_frame_transform() const;\r
- struct frame_transform& get_frame_transform();\r
+ \r
+ const core::frame_transform& frame_transform() const;\r
+ core::frame_transform& frame_transform();\r
\r
static spl::shared_ptr<draw_frame> interlace(const spl::shared_ptr<const draw_frame>& frame1, const spl::shared_ptr<const draw_frame>& frame2, core::field_mode mode);\r
static spl::shared_ptr<draw_frame> over(const spl::shared_ptr<const draw_frame>& frame1, const spl::shared_ptr<const draw_frame>& frame2);\r
\r
namespace caspar { namespace core {\r
\r
-frame_transform::frame_transform() \r
- : volume(1.0)\r
- , opacity(1.0)\r
+// image_transform\r
+\r
+image_transform::image_transform() \r
+ : opacity(1.0)\r
, brightness(1.0)\r
, contrast(1.0)\r
, saturation(1.0)\r
boost::range::fill(clip_scale, 1.0);\r
}\r
\r
-frame_transform& frame_transform::operator*=(const frame_transform &other)\r
+image_transform& image_transform::operator*=(const image_transform &other)\r
{\r
- volume *= other.volume;\r
opacity *= other.opacity; \r
brightness *= other.brightness;\r
contrast *= other.contrast;\r
return *this;\r
}\r
\r
-frame_transform frame_transform::operator*(const frame_transform &other) const\r
+image_transform image_transform::operator*(const image_transform &other) const\r
{\r
- return frame_transform(*this) *= other;\r
+ return image_transform(*this) *= other;\r
}\r
\r
-frame_transform frame_transform::tween(double time, const frame_transform& source, const frame_transform& dest, double duration, const tweener& tween)\r
+image_transform image_transform::tween(double time, const image_transform& source, const image_transform& dest, double duration, const tweener& tween)\r
{ \r
auto do_tween = [](double time, double source, double dest, double duration, const tweener& tween)\r
{\r
return tween(time, source, dest-source, duration);\r
};\r
\r
- frame_transform result; \r
- result.volume = do_tween(time, source.volume, dest.volume, duration, tween);\r
+ image_transform result; \r
result.brightness = do_tween(time, source.brightness, dest.brightness, duration, tween);\r
result.contrast = do_tween(time, source.contrast, dest.contrast, duration, tween);\r
result.saturation = do_tween(time, source.saturation, dest.saturation, duration, tween);\r
return result;\r
}\r
\r
-bool operator==(const frame_transform& lhs, const frame_transform& rhs)\r
+bool operator==(const image_transform& lhs, const image_transform& rhs)\r
{\r
auto eq = [](double lhs, double rhs)\r
{\r
};\r
\r
return \r
- eq(lhs.volume, rhs.volume) &&\r
eq(lhs.opacity, rhs.opacity) &&\r
eq(lhs.contrast, rhs.contrast) &&\r
eq(lhs.brightness, rhs.brightness) &&\r
boost::range::equal(lhs.clip_scale, rhs.clip_scale, eq) &&\r
lhs.field_mode == rhs.field_mode &&\r
lhs.is_key == rhs.is_key &&\r
- lhs.is_mix == rhs.is_mix;\r
+ lhs.is_mix == rhs.is_mix &&\r
+ lhs.is_still == rhs.is_still;\r
+}\r
+\r
+bool operator!=(const image_transform& lhs, const image_transform& rhs)\r
+{\r
+ return !(lhs == rhs);\r
+}\r
+\r
+// audio_transform\r
+ \r
+audio_transform::audio_transform() \r
+ : volume(1.0)\r
+{\r
+}\r
+\r
+audio_transform& audio_transform::operator*=(const audio_transform &other)\r
+{\r
+ volume *= other.volume; \r
+ return *this;\r
+}\r
+\r
+audio_transform audio_transform::operator*(const audio_transform &other) const\r
+{\r
+ return audio_transform(*this) *= other;\r
+}\r
+\r
+audio_transform audio_transform::tween(double time, const audio_transform& source, const audio_transform& dest, double duration, const tweener& tween)\r
+{ \r
+ auto do_tween = [](double time, double source, double dest, double duration, const tweener& tween)\r
+ {\r
+ return tween(time, source, dest-source, duration);\r
+ };\r
+ \r
+ audio_transform result; \r
+ result.volume = do_tween(time, source.volume, dest.volume, duration, tween);\r
+ \r
+ return result;\r
+}\r
+\r
+bool operator==(const audio_transform& lhs, const audio_transform& rhs)\r
+{\r
+ auto eq = [](double lhs, double rhs)\r
+ {\r
+ return std::abs(lhs - rhs) < 5e-8;\r
+ };\r
+\r
+ return eq(lhs.volume, rhs.volume);\r
+}\r
+\r
+bool operator!=(const audio_transform& lhs, const audio_transform& rhs)\r
+{\r
+ return !(lhs == rhs);\r
+}\r
+\r
+// frame_transform\r
+frame_transform::frame_transform()\r
+{\r
+}\r
+\r
+frame_transform& frame_transform::operator*=(const frame_transform &other)\r
+{\r
+ image_transform *= other.image_transform;\r
+ audio_transform *= other.audio_transform;\r
+ return *this;\r
+}\r
+\r
+frame_transform frame_transform::operator*(const frame_transform &other) const\r
+{\r
+ return frame_transform(*this) *= other;\r
+}\r
+\r
+frame_transform frame_transform::tween(double time, const frame_transform& source, const frame_transform& dest, double duration, const tweener& tween)\r
+{\r
+ frame_transform result;\r
+ result.image_transform = image_transform::tween(time, source.image_transform, dest.image_transform, duration, tween);\r
+ result.audio_transform = audio_transform::tween(time, source.audio_transform, dest.audio_transform, duration, tween);\r
+ return result;\r
+}\r
+\r
+bool operator==(const frame_transform& lhs, const frame_transform& rhs)\r
+{\r
+ return lhs.image_transform == rhs.image_transform && \r
+ lhs.audio_transform == rhs.audio_transform;\r
}\r
\r
bool operator!=(const frame_transform& lhs, const frame_transform& rhs)\r
double max_output;\r
};\r
\r
-struct frame_transform sealed\r
+struct image_transform sealed\r
{\r
public:\r
+ image_transform();\r
\r
- frame_transform();\r
-\r
- double volume;\r
double opacity;\r
double contrast;\r
double brightness;\r
bool is_mix;\r
bool is_still;\r
\r
- frame_transform& frame_transform::operator*=(const frame_transform &other);\r
- frame_transform frame_transform::operator*(const frame_transform &other) const;\r
+ image_transform& operator*=(const image_transform &other);\r
+ image_transform operator*(const image_transform &other) const;\r
+\r
+ static image_transform tween(double time, const image_transform& source, const image_transform& dest, double duration, const tweener& tween);\r
+};\r
+\r
+bool operator==(const image_transform& lhs, const image_transform& rhs);\r
+bool operator!=(const image_transform& lhs, const image_transform& rhs);\r
+\r
+struct audio_transform sealed\r
+{\r
+public:\r
+ audio_transform();\r
+\r
+ double volume;\r
+ \r
+ audio_transform& operator*=(const audio_transform &other);\r
+ audio_transform operator*(const audio_transform &other) const;\r
+\r
+ static audio_transform tween(double time, const audio_transform& source, const audio_transform& dest, double duration, const tweener& tween);\r
+};\r
+\r
+bool operator==(const audio_transform& lhs, const audio_transform& rhs);\r
+bool operator!=(const audio_transform& lhs, const audio_transform& rhs);\r
+\r
+struct frame_transform sealed\r
+{\r
+public:\r
+\r
+ frame_transform();\r
+ \r
+ image_transform image_transform;\r
+ audio_transform audio_transform;\r
+ \r
+ frame_transform& operator*=(const frame_transform &other);\r
+ frame_transform operator*(const frame_transform &other) const;\r
\r
static frame_transform tween(double time, const frame_transform& source, const frame_transform& dest, double duration, const tweener& tween);\r
};\r
struct audio_item\r
{\r
const void* tag;\r
- frame_transform transform;\r
+ audio_transform transform;\r
audio_buffer audio_data;\r
\r
audio_item()\r
\r
struct audio_stream\r
{\r
- frame_transform prev_transform;\r
+ audio_transform prev_transform;\r
audio_buffer_ps audio_data;\r
};\r
\r
struct audio_mixer::impl : boost::noncopyable\r
{\r
- std::stack<core::frame_transform> transform_stack_;\r
+ std::stack<core::audio_transform> transform_stack_;\r
std::map<const void*, audio_stream> audio_streams_;\r
std::vector<audio_item> items_;\r
std::vector<int> audio_cadence_;\r
public:\r
impl()\r
{\r
- transform_stack_.push(core::frame_transform());\r
+ transform_stack_.push(core::audio_transform());\r
}\r
\r
void push(const frame_transform& transform)\r
{\r
- transform_stack_.push(transform_stack_.top()*transform);\r
+ transform_stack_.push(transform_stack_.top()*transform.audio_transform);\r
}\r
\r
void visit(const data_frame& frame)\r
item.tag = frame.tag();\r
item.transform = transform_stack_.top();\r
item.audio_data = frame.audio_data();\r
-\r
- if(item.transform.is_still)\r
- item.transform.volume = 0.0;\r
\r
items_.push_back(std::move(item)); \r
}\r
\r
- void begin(const core::frame_transform& transform)\r
+ void begin(const core::audio_transform& transform)\r
{\r
transform_stack_.push(transform_stack_.top()*transform);\r
}\r
frame_producer::flags flags = frame_producer::flags::none;\r
if(format_desc.field_mode != field_mode::progressive)\r
{\r
- flags |= std::abs(transform.fill_scale[1] - 1.0) > 0.0001 ? frame_producer::flags::deinterlace : frame_producer::flags::none;\r
- flags |= std::abs(transform.fill_translation[1]) > 0.0001 ? frame_producer::flags::deinterlace : frame_producer::flags::none;\r
+ flags |= std::abs(transform.image_transform.fill_scale[1] - 1.0) > 0.0001 ? frame_producer::flags::deinterlace : frame_producer::flags::none;\r
+ flags |= std::abs(transform.image_transform.fill_translation[1]) > 0.0001 ? frame_producer::flags::deinterlace : frame_producer::flags::none;\r
}\r
\r
- if(transform.is_key)\r
+ if(transform.image_transform.is_key)\r
flags |= frame_producer::flags::alpha_only;\r
\r
auto frame = layer.receive(flags, format_desc); \r
\r
auto frame1 = spl::make_shared<core::draw_frame>(frame);\r
- frame1->get_frame_transform() = transform;\r
+ frame1->frame_transform() = transform;\r
\r
if(format_desc.field_mode != core::field_mode::progressive)\r
{ \r
auto frame2 = spl::make_shared<core::draw_frame>(frame);\r
- frame2->get_frame_transform() = tween.fetch_and_tick(1);\r
+ frame2->frame_transform() = tween.fetch_and_tick(1);\r
frame1 = core::draw_frame::interlace(frame1, frame2, format_desc.field_mode);\r
}\r
\r
\r
// For interlaced transitions. Seperate fields into seperate frames which are transitioned accordingly.\r
\r
- src_frame->get_frame_transform().volume = 1.0-delta2;\r
+ src_frame->frame_transform().audio_transform.volume = 1.0-delta2;\r
auto s_frame1 = spl::make_shared<draw_frame>(src_frame);\r
auto s_frame2 = spl::make_shared<draw_frame>(src_frame);\r
\r
- dest_frame->get_frame_transform().volume = delta2;\r
+ dest_frame->frame_transform().audio_transform.volume = delta2;\r
auto d_frame1 = spl::make_shared<draw_frame>(dest_frame);\r
auto d_frame2 = spl::make_shared<draw_frame>(dest_frame);\r
\r
if(info_.type == transition_type::mix)\r
{\r
- d_frame1->get_frame_transform().opacity = delta1; \r
- d_frame1->get_frame_transform().is_mix = true;\r
- d_frame2->get_frame_transform().opacity = delta2;\r
- d_frame2->get_frame_transform().is_mix = true;\r
-\r
- s_frame1->get_frame_transform().opacity = 1.0-delta1; \r
- s_frame1->get_frame_transform().is_mix = true;\r
- s_frame2->get_frame_transform().opacity = 1.0-delta2; \r
- s_frame2->get_frame_transform().is_mix = true;\r
+ d_frame1->frame_transform().image_transform.opacity = delta1; \r
+ d_frame1->frame_transform().image_transform.is_mix = true;\r
+ d_frame2->frame_transform().image_transform.opacity = delta2;\r
+ d_frame2->frame_transform().image_transform.is_mix = true;\r
+\r
+ s_frame1->frame_transform().image_transform.opacity = 1.0-delta1; \r
+ s_frame1->frame_transform().image_transform.is_mix = true;\r
+ s_frame2->frame_transform().image_transform.opacity = 1.0-delta2; \r
+ s_frame2->frame_transform().image_transform.is_mix = true;\r
}\r
if(info_.type == transition_type::slide)\r
{\r
- d_frame1->get_frame_transform().fill_translation[0] = (-1.0+delta1)*dir; \r
- d_frame2->get_frame_transform().fill_translation[0] = (-1.0+delta2)*dir; \r
+ d_frame1->frame_transform().image_transform.fill_translation[0] = (-1.0+delta1)*dir; \r
+ d_frame2->frame_transform().image_transform.fill_translation[0] = (-1.0+delta2)*dir; \r
}\r
else if(info_.type == transition_type::push)\r
{\r
- d_frame1->get_frame_transform().fill_translation[0] = (-1.0+delta1)*dir;\r
- d_frame2->get_frame_transform().fill_translation[0] = (-1.0+delta2)*dir;\r
+ d_frame1->frame_transform().image_transform.fill_translation[0] = (-1.0+delta1)*dir;\r
+ d_frame2->frame_transform().image_transform.fill_translation[0] = (-1.0+delta2)*dir;\r
\r
- s_frame1->get_frame_transform().fill_translation[0] = (0.0+delta1)*dir; \r
- s_frame2->get_frame_transform().fill_translation[0] = (0.0+delta2)*dir; \r
+ s_frame1->frame_transform().image_transform.fill_translation[0] = (0.0+delta1)*dir; \r
+ s_frame2->frame_transform().image_transform.fill_translation[0] = (0.0+delta2)*dir; \r
}\r
else if(info_.type == transition_type::wipe) \r
{\r
- d_frame1->get_frame_transform().clip_scale[0] = delta1; \r
- d_frame2->get_frame_transform().clip_scale[0] = delta2; \r
+ d_frame1->frame_transform().image_transform.clip_scale[0] = delta1; \r
+ d_frame2->frame_transform().image_transform.clip_scale[0] = delta2; \r
}\r
\r
- const auto s_frame = s_frame1->get_frame_transform() == s_frame2->get_frame_transform() ? s_frame2 : draw_frame::interlace(s_frame1, s_frame2, mode_);\r
- const auto d_frame = d_frame1->get_frame_transform() == d_frame2->get_frame_transform() ? d_frame2 : draw_frame::interlace(d_frame1, d_frame2, mode_);\r
+ const auto s_frame = s_frame1->frame_transform() == s_frame2->frame_transform() ? s_frame2 : draw_frame::interlace(s_frame1, s_frame2, mode_);\r
+ const auto d_frame = d_frame1->frame_transform() == d_frame2->frame_transform() ? d_frame2 : draw_frame::interlace(d_frame1, d_frame2, mode_);\r
\r
return draw_frame::over(s_frame, d_frame);\r
}\r
\r
if(decoded_frame->height == 480) // NTSC DV\r
{\r
- write->get_frame_transform().fill_translation[1] += 2.0/static_cast<double>(frame_factory->video_format_desc().height);\r
- write->get_frame_transform().fill_scale[1] = 1.0 - 6.0*1.0/static_cast<double>(frame_factory->video_format_desc().height);\r
+ write->frame_transform().image_transform.fill_translation[1] += 2.0/static_cast<double>(frame_factory->video_format_desc().height);\r
+ write->frame_transform().image_transform.fill_scale[1] = 1.0 - 6.0*1.0/static_cast<double>(frame_factory->video_format_desc().height);\r
}\r
\r
// Fix field-order if needed\r
if(get_mode(*decoded_frame) == core::field_mode::lower && frame_factory->video_format_desc().field_mode == core::field_mode::upper)\r
- write->get_frame_transform().fill_translation[1] += 1.0/static_cast<double>(frame_factory->video_format_desc().height);\r
+ write->frame_transform().image_transform.fill_translation[1] += 1.0/static_cast<double>(frame_factory->video_format_desc().height);\r
else if(get_mode(*decoded_frame) == core::field_mode::upper && frame_factory->video_format_desc().field_mode == core::field_mode::lower)\r
- write->get_frame_transform().fill_translation[1] -= 1.0/static_cast<double>(frame_factory->video_format_desc().height);\r
+ write->frame_transform().image_transform.fill_translation[1] -= 1.0/static_cast<double>(frame_factory->video_format_desc().height);\r
\r
return spl::make_shared_ptr(write);\r
}\r
\r
for(int n = 0; n < frames_.size(); ++n)\r
{\r
- frames_[n]->get_frame_transform().fill_translation[0] = start_offset_[0];\r
- frames_[n]->get_frame_transform().fill_translation[1] = start_offset_[1] - (n+1) + delta_ * 0.5/static_cast<double>(format_desc_.height);\r
+ frames_[n]->frame_transform().image_transform.fill_translation[0] = start_offset_[0];\r
+ frames_[n]->frame_transform().image_transform.fill_translation[1] = start_offset_[1] - (n+1) + delta_ * 0.5/static_cast<double>(format_desc_.height);\r
}\r
}\r
else\r
\r
for(int n = 0; n < frames_.size(); ++n)\r
{\r
- frames_[n]->get_frame_transform().fill_translation[0] = start_offset_[0] - (n+1) + delta_ * 0.5/static_cast<double>(format_desc_.width); \r
- frames_[n]->get_frame_transform().fill_translation[1] = start_offset_[1];\r
+ frames_[n]->frame_transform().image_transform.fill_translation[0] = start_offset_[0] - (n+1) + delta_ * 0.5/static_cast<double>(format_desc_.width); \r
+ frames_[n]->frame_transform().image_transform.fill_translation[1] = start_offset_[1];\r
}\r
}\r
\r
int index = x+y*n+1;\r
auto transform = [=](frame_transform transform) -> frame_transform\r
{ \r
- transform.fill_translation[0] = x*delta;\r
- transform.fill_translation[1] = y*delta;\r
- transform.fill_scale[0] = delta;\r
- transform.fill_scale[1] = delta;\r
- transform.clip_translation[0] = x*delta;\r
- transform.clip_translation[1] = y*delta;\r
- transform.clip_scale[0] = delta;\r
- transform.clip_scale[1] = delta; \r
+ transform.image_transform.fill_translation[0] = x*delta;\r
+ transform.image_transform.fill_translation[1] = y*delta;\r
+ transform.image_transform.fill_scale[0] = delta;\r
+ transform.image_transform.fill_scale[1] = delta;\r
+ transform.image_transform.clip_translation[0] = x*delta;\r
+ transform.image_transform.clip_translation[1] = y*delta;\r
+ transform.image_transform.clip_scale[0] = delta;\r
+ transform.image_transform.clip_scale[1] = delta; \r
return transform;\r
};\r
self->stage().apply_transform(index, transform);\r
bool value = boost::lexical_cast<int>(_parameters.at(1));\r
transforms.push_back(stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) -> frame_transform\r
{\r
- transform.is_key = value;\r
+ transform.image_transform.is_key = value;\r
return transform; \r
}, 0, L"linear"));\r
}\r
\r
transforms.push_back(stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) -> frame_transform\r
{\r
- transform.opacity = value;\r
+ transform.image_transform.opacity = value;\r
return transform; \r
}, duration, tween));\r
}\r
\r
transforms.push_back(stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) mutable -> frame_transform\r
{\r
- transform.fill_translation[0] = x;\r
- transform.fill_translation[1] = y;\r
- transform.fill_scale[0] = x_s;\r
- transform.fill_scale[1] = y_s;\r
- transform.clip_translation[0] = x;\r
- transform.clip_translation[1] = y;\r
- transform.clip_scale[0] = x_s;\r
- transform.clip_scale[1] = y_s;\r
+ transform.image_transform.fill_translation[0] = x;\r
+ transform.image_transform.fill_translation[1] = y;\r
+ transform.image_transform.fill_scale[0] = x_s;\r
+ transform.image_transform.fill_scale[1] = y_s;\r
+ transform.image_transform.clip_translation[0] = x;\r
+ transform.image_transform.clip_translation[1] = y;\r
+ transform.image_transform.clip_scale[0] = x_s;\r
+ transform.image_transform.clip_scale[1] = y_s;\r
return transform;\r
}, duration, tween));\r
}\r
\r
transforms.push_back(stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) -> frame_transform\r
{\r
- transform.clip_translation[0] = x;\r
- transform.clip_translation[1] = y;\r
- transform.clip_scale[0] = x_s;\r
- transform.clip_scale[1] = y_s;\r
+ transform.image_transform.clip_translation[0] = x;\r
+ transform.image_transform.clip_translation[1] = y;\r
+ transform.image_transform.clip_scale[0] = x_s;\r
+ transform.image_transform.clip_scale[1] = y_s;\r
return transform;\r
}, duration, tween));\r
}\r
int index = x+y*n+1;\r
transforms.push_back(stage::transform_tuple_t(index, [=](frame_transform transform) -> frame_transform\r
{ \r
- transform.fill_translation[0] = x*delta;\r
- transform.fill_translation[1] = y*delta;\r
- transform.fill_scale[0] = delta;\r
- transform.fill_scale[1] = delta;\r
- transform.clip_translation[0] = x*delta;\r
- transform.clip_translation[1] = y*delta;\r
- transform.clip_scale[0] = delta;\r
- transform.clip_scale[1] = delta; \r
+ transform.image_transform.fill_translation[0] = x*delta;\r
+ transform.image_transform.fill_translation[1] = y*delta;\r
+ transform.image_transform.fill_scale[0] = delta;\r
+ transform.image_transform.fill_scale[1] = delta;\r
+ transform.image_transform.clip_translation[0] = x*delta;\r
+ transform.image_transform.clip_translation[1] = y*delta;\r
+ transform.image_transform.clip_scale[0] = delta;\r
+ transform.image_transform.clip_scale[1] = delta; \r
return transform;\r
}, duration, tween));\r
}\r
std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";\r
auto transform = stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) -> frame_transform\r
{\r
- transform.brightness = value;\r
+ transform.image_transform.brightness = value;\r
return transform;\r
}, duration, tween);\r
}\r
std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";\r
auto transform = stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) -> frame_transform\r
{\r
- transform.saturation = value;\r
+ transform.image_transform.saturation = value;\r
return transform;\r
}, duration, tween); \r
}\r
std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";\r
auto transform = stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) -> frame_transform\r
{\r
- transform.contrast = value;\r
+ transform.image_transform.contrast = value;\r
return transform;\r
}, duration, tween); \r
}\r
\r
auto transform = stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) -> frame_transform\r
{\r
- transform.levels = value;\r
+ transform.image_transform.levels = value;\r
return transform;\r
}, duration, tween);\r
}\r
\r
auto transform = stage::transform_tuple_t(GetLayerIndex(), [=](frame_transform transform) -> frame_transform\r
{\r
- transform.volume = value;\r
+ transform.audio_transform.volume = value;\r
return transform;\r
}, duration, tween);\r
}\r
projects / casparcg / commitdiff