\r
void draw(ogl_device& ogl,\r
render_item&& item,\r
- const safe_ptr<device_buffer>& background,\r
+ device_buffer& background,\r
const std::shared_ptr<device_buffer>& local_key, \r
const std::shared_ptr<device_buffer>& layer_key)\r
{\r
\r
if(blend_modes_)\r
{\r
- background->bind(6);\r
+ background.bind(6);\r
\r
shader_->set("background", texture_id::background);\r
shader_->set("blend_mode", item.blend_mode);\r
\r
// Setup interlacing\r
\r
- if(item.mode == core::video_mode::progressive) \r
+ if(item.transform.get_field_mode() == core::field_mode::progressive) \r
ogl.disable(GL_POLYGON_STIPPLE); \r
else \r
{\r
ogl.enable(GL_POLYGON_STIPPLE);\r
\r
- if(item.mode == core::video_mode::upper)\r
+ if(item.transform.get_field_mode() == core::field_mode::upper)\r
ogl.stipple_pattern(upper_pattern);\r
- else if(item.mode == core::video_mode::lower)\r
+ else if(item.transform.get_field_mode() == core::field_mode::lower)\r
ogl.stipple_pattern(lower_pattern);\r
}\r
\r
// Setup drawing area\r
\r
- ogl.viewport(0, 0, background->width(), background->height());\r
+ ogl.viewport(0, 0, background.width(), background.height());\r
\r
auto m_p = item.transform.get_clip_translation();\r
auto m_s = item.transform.get_clip_scale();\r
\r
if(scissor)\r
{\r
- double w = static_cast<double>(background->width());\r
- double h = static_cast<double>(background->height());\r
+ double w = static_cast<double>(background.width());\r
+ double h = static_cast<double>(background.height());\r
\r
ogl.enable(GL_SCISSOR_TEST);\r
ogl.scissor(static_cast<size_t>(m_p[0]*w), static_cast<size_t>(m_p[1]*h), static_cast<size_t>(m_s[0]*w), static_cast<size_t>(m_s[1]*h));\r
\r
// Set render target\r
\r
- ogl.attach(*background);\r
+ ogl.attach(background);\r
\r
// Draw\r
\r
image_kernel::image_kernel() : impl_(new implementation()){}\r
void image_kernel::draw(ogl_device& ogl, \r
render_item&& item, \r
- const safe_ptr<device_buffer>& background,\r
+ device_buffer& background,\r
const std::shared_ptr<device_buffer>& local_key, \r
const std::shared_ptr<device_buffer>& layer_key)\r
{\r
\r
bool operator==(const render_item& lhs, const render_item& rhs)\r
{\r
- return lhs.textures == rhs.textures && lhs.transform == rhs.transform && lhs.tag == rhs.tag && lhs.mode == rhs.mode;\r
+ return lhs.textures == rhs.textures && lhs.transform == rhs.transform && lhs.tag == rhs.tag;\r
}\r
\r
}}
\ No newline at end of file
pixel_format_desc pix_desc;\r
std::vector<safe_ptr<device_buffer>> textures;\r
image_transform transform;\r
- video_mode::type mode;\r
const void* tag;\r
blend_mode::type blend_mode;\r
};\r
image_kernel();\r
void draw(ogl_device& ogl, \r
render_item&& item, \r
- const safe_ptr<device_buffer>& background, \r
+ device_buffer& background, \r
const std::shared_ptr<device_buffer>& local_key = nullptr, \r
const std::shared_ptr<device_buffer>& layer_key = nullptr);\r
private:\r
video_channel_context& channel_;\r
\r
std::vector<image_transform> transform_stack_;\r
- std::vector<video_mode::type> video_mode_stack_;\r
std::stack<blend_mode::type> blend_mode_stack_;\r
\r
std::deque<std::deque<render_item>> layers_; // layer/stream/items\r
implementation(video_channel_context& video_channel) \r
: channel_(video_channel)\r
, transform_stack_(1)\r
- , video_mode_stack_(1, video_mode::progressive)\r
{\r
}\r
\r
void begin(core::basic_frame& frame)\r
{\r
transform_stack_.push_back(transform_stack_.back()*frame.get_image_transform());\r
- video_mode_stack_.push_back(frame.get_mode() == video_mode::progressive ? video_mode_stack_.back() : frame.get_mode());\r
}\r
\r
void visit(core::write_frame& frame)\r
{ \r
- CASPAR_ASSERT(!layers_.empty());\r
-\r
- // Check if frame has been discarded by interlacing\r
- if(boost::range::find(video_mode_stack_, video_mode::upper) != video_mode_stack_.end() && boost::range::find(video_mode_stack_, video_mode::lower) != video_mode_stack_.end())\r
+ if(transform_stack_.back().get_field_mode() == field_mode::empty)\r
return;\r
\r
core::render_item item;\r
item.pix_desc = frame.get_pixel_format_desc();\r
item.textures = frame.get_textures();\r
item.transform = transform_stack_.back();\r
- item.mode = video_mode_stack_.back();\r
item.tag = frame.tag();\r
item.blend_mode = blend_mode_stack_.top(); \r
\r
void end()\r
{\r
transform_stack_.pop_back();\r
- video_mode_stack_.pop_back();\r
}\r
\r
void begin_layer(blend_mode::type blend_mode)\r
int fields = 0;\r
BOOST_FOREACH(auto& item, layer)\r
{\r
- if(fields & item.mode)\r
+ if(fields & item.transform.get_field_mode())\r
item.blend_mode = blend_mode::normal; // Disable blending, it will be used when merging back into render stack.\r
else\r
{\r
item.blend_mode = blend_mode::replace; // Target field is empty, no blending, just copy\r
- fields |= item.mode;\r
+ fields |= item.transform.get_field_mode();\r
}\r
\r
- draw_item(std::move(item), local_draw_buffer, local_key_buffer, layer_key_buffer); \r
+ draw_item(std::move(item), *local_draw_buffer, local_key_buffer, layer_key_buffer); \r
}\r
\r
render_item item;\r
item.textures.push_back(local_draw_buffer);\r
item.blend_mode = local_blend_mode;\r
\r
- kernel_.draw(channel_.ogl(), std::move(item), draw_buffer, nullptr, nullptr);\r
+ kernel_.draw(channel_.ogl(), std::move(item), *draw_buffer, nullptr, nullptr);\r
}\r
else // fast path\r
{\r
BOOST_FOREACH(auto& item, layer) \r
- draw_item(std::move(item), draw_buffer, local_key_buffer, layer_key_buffer); \r
+ draw_item(std::move(item), *draw_buffer, local_key_buffer, layer_key_buffer); \r
} \r
\r
- CASPAR_ASSERT(local_key_buffer.first == 0 || local_key_buffer.first == core::video_mode::progressive);\r
+ CASPAR_ASSERT(local_key_buffer.first == 0 || local_key_buffer.first == core::field_mode::progressive);\r
\r
std::swap(local_key_buffer.second, layer_key_buffer);\r
}\r
\r
void draw_item(render_item&& item, \r
- const safe_ptr<device_buffer>& draw_buffer, \r
+ device_buffer& draw_buffer, \r
std::pair<int, std::shared_ptr<device_buffer>>& local_key_buffer, \r
std::shared_ptr<device_buffer>& layer_key_buffer)\r
{ \r
local_key_buffer.second = create_device_buffer(1);\r
}\r
\r
- local_key_buffer.first |= item.mode; // Add field to flag.\r
- kernel_.draw(channel_.ogl(), std::move(item), make_safe(local_key_buffer.second), nullptr, nullptr);\r
+ local_key_buffer.first |= item.transform.get_field_mode(); // Add field to flag.\r
+ kernel_.draw(channel_.ogl(), std::move(item), *local_key_buffer.second, nullptr, nullptr);\r
}\r
else\r
{\r
kernel_.draw(channel_.ogl(), std::move(item), draw_buffer, local_key_buffer.second, layer_key_buffer);\r
- local_key_buffer.first ^= item.mode; // Remove field from flag.\r
+ local_key_buffer.first ^= item.transform.get_field_mode(); // Remove field from flag.\r
\r
if(local_key_buffer.first == 0) // If all fields from key has been used, reset it\r
{\r
auto frame1 = make_safe<core::basic_frame>(frame.second);\r
frame1->get_image_transform() = image_transforms[frame.first].fetch_and_tick(1);\r
\r
- if(channel_.get_format_desc().mode != core::video_mode::progressive)\r
+ if(channel_.get_format_desc().mode != core::field_mode::progressive)\r
{\r
auto frame2 = make_safe<core::basic_frame>(frame.second);\r
frame2->get_image_transform() = image_transforms[frame.first].fetch_and_tick(1);\r
\r
BOOST_FOREACH(auto& frame, frames)\r
{\r
- const unsigned int num = channel_.get_format_desc().mode == core::video_mode::progressive ? 1 : 2;\r
+ const unsigned int num = channel_.get_format_desc().mode == core::field_mode::progressive ? 1 : 2;\r
\r
auto frame1 = make_safe<core::basic_frame>(frame.second);\r
frame1->get_audio_transform() = audio_transforms[frame.first].fetch_and_tick(num);\r
std::vector<int16_t> audio_data_;\r
const core::pixel_format_desc desc_;\r
const void* tag_;\r
- core::video_mode::type mode_;\r
+ core::field_mode::type mode_;\r
\r
implementation(const void* tag)\r
: tag_(tag)\r
: ogl_(&ogl)\r
, desc_(desc)\r
, tag_(tag)\r
- , mode_(core::video_mode::progressive)\r
+ , mode_(core::field_mode::progressive)\r
{\r
ogl_->invoke([&]\r
{\r
const std::vector<safe_ptr<device_buffer>>& write_frame::get_textures() const{return impl_->textures_;}\r
void write_frame::commit(size_t plane_index){impl_->commit(plane_index);}\r
void write_frame::commit(){impl_->commit();}\r
-void write_frame::set_type(const video_mode::type& mode){impl_->mode_ = mode;}\r
-core::video_mode::type write_frame::get_type() const{return impl_->mode_;}\r
+void write_frame::set_type(const field_mode::type& mode){impl_->mode_ = mode;}\r
+core::field_mode::type write_frame::get_type() const{return impl_->mode_;}\r
\r
std::wstring write_frame::print() const{return impl_->print();}\r
void write_frame::accept(core::frame_visitor& visitor){impl_->accept(*this, visitor);}\r
void commit(uint32_t plane_index);\r
void commit();\r
\r
- void set_type(const core::video_mode::type& mode);\r
- core::video_mode::type get_type() const;\r
+ void set_type(const core::field_mode::type& mode);\r
+ core::field_mode::type get_type() const;\r
\r
const void* tag() const;\r
\r
\r
image_transform image_transform_; \r
audio_transform audio_transform_;\r
-\r
- core::video_mode::type mode_;\r
\r
public:\r
- implementation(const std::vector<safe_ptr<basic_frame>>& frames) \r
- : mode_(core::video_mode::progressive), frames_(frames) \r
+ implementation(const std::vector<safe_ptr<basic_frame>>& frames) : frames_(frames) \r
{\r
}\r
- implementation(std::vector<safe_ptr<basic_frame>>&& frames) \r
- : mode_(core::video_mode::progressive), frames_(std::move(frames))\r
+ implementation(std::vector<safe_ptr<basic_frame>>&& frames) : frames_(std::move(frames))\r
{\r
}\r
implementation(safe_ptr<basic_frame>&& frame) \r
- : mode_(core::video_mode::progressive)\r
{\r
frames_.push_back(std::move(frame));\r
}\r
- implementation(const safe_ptr<basic_frame>& frame) \r
- : mode_(core::video_mode::progressive) \r
+ implementation(const safe_ptr<basic_frame>& frame) \r
{ \r
frames_.push_back(frame);\r
}\r
}\r
void basic_frame::swap(basic_frame& other){impl_.swap(other.impl_);}\r
\r
-core::video_mode::type basic_frame::get_mode() const{return impl_->mode_;}\r
const image_transform& basic_frame::get_image_transform() const { return impl_->image_transform_;}\r
image_transform& basic_frame::get_image_transform() { return impl_->image_transform_;}\r
const audio_transform& basic_frame::get_audio_transform() const { return impl_->audio_transform_;}\r
std::wstring basic_frame::print() const{return impl_->print();}\r
void basic_frame::accept(frame_visitor& visitor){impl_->accept(*this, visitor);}\r
\r
-safe_ptr<basic_frame> basic_frame::interlace(const safe_ptr<basic_frame>& frame1, const safe_ptr<basic_frame>& frame2, video_mode::type mode)\r
+safe_ptr<basic_frame> basic_frame::interlace(const safe_ptr<basic_frame>& frame1, const safe_ptr<basic_frame>& frame2, field_mode::type mode)\r
{ \r
if(frame1 == basic_frame::eof() || frame2 == basic_frame::eof())\r
return basic_frame::eof();\r
if(frame1 == basic_frame::empty() && frame2 == basic_frame::empty())\r
return basic_frame::empty();\r
\r
- if(frame1 == frame2 || mode == video_mode::progressive)\r
+ if(frame1 == frame2 || mode == field_mode::progressive)\r
return frame2;\r
\r
auto my_frame1 = make_safe<basic_frame>(frame1);\r
auto my_frame2 = make_safe<basic_frame>(frame2);\r
- if(mode == video_mode::upper)\r
+ if(mode == field_mode::upper)\r
{\r
- my_frame1->impl_->mode_ = video_mode::upper; \r
- my_frame2->impl_->mode_ = video_mode::lower; \r
+ my_frame1->get_image_transform().set_field_mode(field_mode::upper); \r
+ my_frame2->get_image_transform().set_field_mode(field_mode::lower); \r
} \r
else \r
{ \r
- my_frame1->impl_->mode_ = video_mode::lower; \r
- my_frame2->impl_->mode_ = video_mode::upper; \r
+ my_frame1->get_image_transform().set_field_mode(field_mode::lower); \r
+ my_frame2->get_image_transform().set_field_mode(field_mode::upper); \r
}\r
\r
std::vector<safe_ptr<basic_frame>> frames;\r
\r
const audio_transform& get_audio_transform() const;\r
audio_transform& get_audio_transform();\r
-\r
- core::video_mode::type get_mode() const;\r
- \r
- static safe_ptr<basic_frame> interlace(const safe_ptr<basic_frame>& frame1, const safe_ptr<basic_frame>& frame2, video_mode::type mode);\r
+ \r
+ static safe_ptr<basic_frame> interlace(const safe_ptr<basic_frame>& frame1, const safe_ptr<basic_frame>& frame2, field_mode::type mode);\r
static safe_ptr<basic_frame> combine(const safe_ptr<basic_frame>& frame1, const safe_ptr<basic_frame>& frame2);\r
static safe_ptr<basic_frame> fill_and_key(const safe_ptr<basic_frame>& fill, const safe_ptr<basic_frame>& key);\r
\r
, contrast_(1.0)\r
, saturation_(1.0)\r
, is_key_(false)\r
+ , field_mode_(field_mode::progressive)\r
{\r
std::fill(fill_translation_.begin(), fill_translation_.end(), 0.0);\r
std::fill(fill_scale_.begin(), fill_scale_.end(), 1.0);\r
return clip_scale_;\r
}\r
\r
+void image_transform::set_field_mode(field_mode::type field_mode)\r
+{\r
+ field_mode_ = field_mode;\r
+}\r
+\r
+field_mode::type image_transform::get_field_mode() const\r
+{\r
+ return field_mode_;\r
+}\r
+\r
image_transform& image_transform::operator*=(const image_transform &other)\r
{\r
opacity_ *= other.opacity_; \r
\r
levels_.gamma *= other.levels_.gamma;\r
\r
+ field_mode_ = static_cast<field_mode::type>(field_mode_ & other.field_mode_);\r
is_key_ |= other.is_key_;\r
fill_translation_[0] += other.fill_translation_[0]*fill_scale_[0];\r
fill_translation_[1] += other.fill_translation_[1]*fill_scale_[1];\r
\r
image_transform result; \r
result.set_is_key (source.get_is_key() | dest.get_is_key());\r
+ result.set_field_mode (static_cast<field_mode::type>(source.get_field_mode() & dest.get_field_mode()));\r
result.set_brightness (do_tween(time, source.get_brightness(), dest.get_brightness(), duration, tweener));\r
result.set_contrast (do_tween(time, source.get_contrast(), dest.get_contrast(), duration, tweener));\r
result.set_saturation (do_tween(time, source.get_saturation(), dest.get_saturation(), duration, tweener));\r
\r
void set_is_key(bool value);\r
bool get_is_key() const;\r
+\r
+ void set_field_mode(field_mode::type field_mode);\r
+ field_mode::type get_field_mode() const;\r
\r
private:\r
double opacity_;\r
std::array<double, 2> fill_scale_; \r
std::array<double, 2> clip_translation_; \r
std::array<double, 2> clip_scale_; \r
- video_mode::type mode_;\r
+ field_mode::type field_mode_;\r
bool is_key_;\r
};\r
\r
\r
struct transition_producer : public frame_producer\r
{ \r
- const video_mode::type mode_;\r
+ const field_mode::type mode_;\r
unsigned int current_frame_;\r
\r
const transition_info info_;\r
\r
safe_ptr<basic_frame> last_frame_;\r
\r
- explicit transition_producer(const video_mode::type& mode, const safe_ptr<frame_producer>& dest, const transition_info& info) \r
+ explicit transition_producer(const field_mode::type& mode, const safe_ptr<frame_producer>& dest, const transition_info& info) \r
: mode_(mode)\r
, current_frame_(0)\r
, info_(info)\r
}\r
};\r
\r
-safe_ptr<frame_producer> create_transition_producer(const video_mode::type& mode, const safe_ptr<frame_producer>& destination, const transition_info& info)\r
+safe_ptr<frame_producer> create_transition_producer(const field_mode::type& mode, const safe_ptr<frame_producer>& destination, const transition_info& info)\r
{\r
return make_safe<transition_producer>(mode, destination, info);\r
}\r
tweener_t tweener;\r
};\r
\r
-safe_ptr<frame_producer> create_transition_producer(const video_mode::type& mode, const safe_ptr<frame_producer>& destination, const transition_info& info);\r
+safe_ptr<frame_producer> create_transition_producer(const field_mode::type& mode, const safe_ptr<frame_producer>& destination, const transition_info& info);\r
\r
}}
\ No newline at end of file
((double)scale/(double)duration),\\r
(scale),\\r
(duration),\\r
- (m == video_mode::progressive ? 1 : 2),\\r
+ (m == field_mode::progressive ? 1 : 2),\\r
((w)*(h)*4),\\r
(name),\\r
(2),\\r
\r
const video_format_desc format_descs[video_format::count] = \r
{ \r
- DEFINE_VIDEOFORMATDESC(video_format::pal ,720, 576, video_mode::upper, 25, 1, L"PAL"), \r
- DEFINE_VIDEOFORMATDESC(video_format::ntsc ,720, 486, video_mode::lower, 30000, 1001, L"NTSC"), \r
- DEFINE_VIDEOFORMATDESC(video_format::x576p2500 ,720, 576, video_mode::progressive, 25, 1, L"576p2500"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x720p2500 ,1280, 720, video_mode::progressive, 25, 1, L"720p2500"), \r
- DEFINE_VIDEOFORMATDESC(video_format::x720p5000 ,1280, 720, video_mode::progressive, 50, 1, L"720p5000"), \r
- DEFINE_VIDEOFORMATDESC(video_format::x720p5994 ,1280, 720, video_mode::progressive, 60000, 1001, L"720p5994"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x720p6000 ,1280, 720, video_mode::progressive, 60, 1, L"720p6000"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080p2397 ,1920, 1080, video_mode::progressive, 24000, 1001, L"1080p2398"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080p2400 ,1920, 1080, video_mode::progressive, 24, 1, L"1080p2400"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080i5000 ,1920, 1080, video_mode::upper, 25, 1, L"1080i5000"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080i5994 ,1920, 1080, video_mode::upper, 30000, 1001, L"1080i5994"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080i6000 ,1920, 1080, video_mode::upper, 30, 1, L"1080i6000"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080p2500 ,1920, 1080, video_mode::progressive, 25, 1, L"1080p2500"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080p2997 ,1920, 1080, video_mode::progressive, 30000, 1001, L"1080p2997"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080p3000 ,1920, 1080, video_mode::progressive, 30, 1, L"1080p3000"),\r
- DEFINE_VIDEOFORMATDESC(video_format::x1080p5000 ,1920, 1080, video_mode::progressive, 50, 1, L"1080p5000"),\r
- DEFINE_VIDEOFORMATDESC(video_format::invalid ,0, 0, video_mode::progressive, 1, 1, L"invalid")\r
+ DEFINE_VIDEOFORMATDESC(video_format::pal ,720, 576, field_mode::upper, 25, 1, L"PAL"), \r
+ DEFINE_VIDEOFORMATDESC(video_format::ntsc ,720, 486, field_mode::lower, 30000, 1001, L"NTSC"), \r
+ DEFINE_VIDEOFORMATDESC(video_format::x576p2500 ,720, 576, field_mode::progressive, 25, 1, L"576p2500"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x720p2500 ,1280, 720, field_mode::progressive, 25, 1, L"720p2500"), \r
+ DEFINE_VIDEOFORMATDESC(video_format::x720p5000 ,1280, 720, field_mode::progressive, 50, 1, L"720p5000"), \r
+ DEFINE_VIDEOFORMATDESC(video_format::x720p5994 ,1280, 720, field_mode::progressive, 60000, 1001, L"720p5994"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x720p6000 ,1280, 720, field_mode::progressive, 60, 1, L"720p6000"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080p2397 ,1920, 1080, field_mode::progressive, 24000, 1001, L"1080p2398"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080p2400 ,1920, 1080, field_mode::progressive, 24, 1, L"1080p2400"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080i5000 ,1920, 1080, field_mode::upper, 25, 1, L"1080i5000"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080i5994 ,1920, 1080, field_mode::upper, 30000, 1001, L"1080i5994"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080i6000 ,1920, 1080, field_mode::upper, 30, 1, L"1080i6000"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080p2500 ,1920, 1080, field_mode::progressive, 25, 1, L"1080p2500"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080p2997 ,1920, 1080, field_mode::progressive, 30000, 1001, L"1080p2997"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080p3000 ,1920, 1080, field_mode::progressive, 30, 1, L"1080p3000"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::x1080p5000 ,1920, 1080, field_mode::progressive, 50, 1, L"1080p5000"),\r
+ DEFINE_VIDEOFORMATDESC(video_format::invalid ,0, 0, field_mode::progressive, 1, 1, L"invalid")\r
};\r
\r
const video_format_desc& video_format_desc::get(video_format::type format) \r
};\r
};\r
\r
-struct video_mode \r
+struct field_mode \r
{ \r
enum type\r
{\r
+ empty = 0,\r
lower = 1,\r
upper = 2,\r
progressive = 3 // NOTE: progressive == lower | upper;\r
};\r
\r
- static std::wstring print(video_mode::type value)\r
+ static std::wstring print(field_mode::type value)\r
{\r
switch(value)\r
{\r
\r
size_t width; // output frame width\r
size_t height; // output frame height\r
- video_mode::type mode; // progressive, interlaced upper field first, interlaced lower field first\r
+ field_mode::type mode; // progressive, interlaced upper field first, interlaced lower field first\r
double fps; // actual framerate, e.g. i50 = 25 fps, p50 = 50 fps\r
size_t time_scale;\r
size_t duration;\r
av_frame->format = PIX_FMT_UYVY422;\r
av_frame->width = video->GetWidth();\r
av_frame->height = video->GetHeight();\r
- av_frame->interlaced_frame = format_desc_.mode != core::video_mode::progressive;\r
- av_frame->top_field_first = format_desc_.mode == core::video_mode::upper ? 1 : 0;\r
+ av_frame->interlaced_frame = format_desc_.mode != core::field_mode::progressive;\r
+ av_frame->top_field_first = format_desc_.mode == core::field_mode::upper ? 1 : 0;\r
\r
BOOST_FOREACH(auto& av_frame2, filter_.execute(av_frame))\r
muxer_.push(av_frame2); \r
}\r
};\r
\r
-display_mode::type get_display_mode(const core::video_mode::type in_mode, double in_fps, const core::video_mode::type out_mode, double out_fps)\r
+display_mode::type get_display_mode(const core::field_mode::type in_mode, double in_fps, const core::field_mode::type out_mode, double out_fps)\r
{ \r
static const auto epsilon = 2.0;\r
\r
if(in_fps < 20.0 || in_fps > 80.0)\r
{\r
- //if(out_mode != core::video_mode::progressive && in_mode == core::video_mode::progressive)\r
+ //if(out_mode != core::field_mode::progressive && in_mode == core::field_mode::progressive)\r
// return display_mode::interlace;\r
\r
- if(out_mode == core::video_mode::progressive && in_mode != core::video_mode::progressive)\r
+ if(out_mode == core::field_mode::progressive && in_mode != core::field_mode::progressive)\r
{\r
if(in_fps < 35.0)\r
return display_mode::deinterlace;\r
\r
if(std::abs(in_fps - out_fps) < epsilon)\r
{\r
- if(in_mode != core::video_mode::progressive && out_mode == core::video_mode::progressive)\r
+ if(in_mode != core::field_mode::progressive && out_mode == core::field_mode::progressive)\r
return display_mode::deinterlace;\r
- //else if(in_mode == core::video_mode::progressive && out_mode != core::video_mode::progressive)\r
+ //else if(in_mode == core::field_mode::progressive && out_mode != core::field_mode::progressive)\r
// simple(); // interlace_duplicate();\r
else\r
return display_mode::simple;\r
}\r
else if(std::abs(in_fps/2.0 - out_fps) < epsilon)\r
{\r
- if(in_mode != core::video_mode::progressive)\r
+ if(in_mode != core::field_mode::progressive)\r
return display_mode::invalid;\r
\r
- if(out_mode != core::video_mode::progressive)\r
+ if(out_mode != core::field_mode::progressive)\r
return display_mode::interlace;\r
else\r
return display_mode::half;\r
}\r
else if(std::abs(in_fps - out_fps/2.0) < epsilon)\r
{\r
- if(out_mode != core::video_mode::progressive)\r
+ if(out_mode != core::field_mode::progressive)\r
return display_mode::invalid;\r
\r
- if(in_mode != core::video_mode::progressive)\r
+ if(in_mode != core::field_mode::progressive)\r
return display_mode::deinterlace_bob;\r
else\r
return display_mode::duplicate;\r
auto in_mode = get_mode(*video_frame);\r
display_mode_ = get_display_mode(in_mode, in_fps_, format_desc_.mode, format_desc_.fps);\r
\r
- if(display_mode_ == display_mode::simple && in_mode != core::video_mode::progressive && format_desc_.mode != core::video_mode::progressive && video_frame->height != static_cast<int>(format_desc_.height))\r
+ if(display_mode_ == display_mode::simple && in_mode != core::field_mode::progressive && format_desc_.mode != core::field_mode::progressive && video_frame->height != static_cast<int>(format_desc_.height))\r
display_mode_ = display_mode::deinterlace_bob_reinterlace; // The frame will most likely be scaled, we need to deinterlace->reinterlace \r
\r
if(display_mode_ == display_mode::deinterlace)\r
auto frame = make_write_frame(this, av_frame, frame_factory_, hints);\r
\r
// Fix field-order if needed\r
- if(frame->get_type() == core::video_mode::lower && format_desc_.mode == core::video_mode::upper)\r
+ if(frame->get_type() == core::field_mode::lower && format_desc_.mode == core::field_mode::upper)\r
frame->get_image_transform().set_fill_translation(0.0f, 0.5/static_cast<double>(frame->get_pixel_format_desc().planes[0].height));\r
- else if(frame->get_type() == core::video_mode::upper && format_desc_.mode == core::video_mode::lower)\r
+ else if(frame->get_type() == core::field_mode::upper && format_desc_.mode == core::field_mode::lower)\r
frame->get_image_transform().set_fill_translation(0.0f, -0.5/static_cast<double>(frame->get_pixel_format_desc().planes[0].height));\r
\r
video_streams_.back().push(frame);\r
\r
namespace caspar {\r
\r
-core::video_mode::type get_mode(AVFrame& frame)\r
+core::field_mode::type get_mode(AVFrame& frame)\r
{\r
if(!frame.interlaced_frame)\r
- return core::video_mode::progressive;\r
+ return core::field_mode::progressive;\r
\r
- return frame.top_field_first ? core::video_mode::upper : core::video_mode::lower;\r
+ return frame.top_field_first ? core::field_mode::upper : core::field_mode::lower;\r
}\r
\r
core::pixel_format::type get_pixel_format(PixelFormat pix_fmt)\r
\r
static const PixelFormat CASPAR_PIX_FMT_LUMA = PIX_FMT_MONOBLACK; // Just hijack some unual pixel format.\r
\r
-core::video_mode::type get_mode(AVFrame& frame);\r
+core::field_mode::type get_mode(AVFrame& frame);\r
core::pixel_format::type get_pixel_format(PixelFormat pix_fmt);\r
core::pixel_format_desc get_pixel_format_desc(PixelFormat pix_fmt, size_t width, size_t height);\r
int make_alpha_format(int format); // NOTE: Be careful about CASPAR_PIX_FMT_LUMA, change it to PIX_FMT_GRAY8 if you want to use the frame inside some ffmpeg function.\r
\r
struct template_host\r
{\r
- std::string video_mode;\r
+ std::string field_mode;\r
std::string filename;\r
size_t width;\r
size_t height;\r
try\r
{\r
template_host template_host;\r
- template_host.video_mode = xml_mapping.second.get("video-mode", narrow(desc.name));\r
+ template_host.field_mode = xml_mapping.second.get("video-mode", narrow(desc.name));\r
template_host.filename = xml_mapping.second.get("filename", "cg.fth");\r
template_host.width = xml_mapping.second.get("width", desc.width);\r
template_host.height = xml_mapping.second.get("height", desc.height);\r
catch(...){}\r
}\r
\r
- auto template_host_it = boost::find_if(template_hosts, [&](template_host template_host){return template_host.video_mode == narrow(desc.name);});\r
+ auto template_host_it = boost::find_if(template_hosts, [&](template_host template_host){return template_host.field_mode == narrow(desc.name);});\r
if(template_host_it == template_hosts.end())\r
- template_host_it = boost::find_if(template_hosts, [&](template_host template_host){return template_host.video_mode == "";});\r
+ template_host_it = boost::find_if(template_hosts, [&](template_host template_host){return template_host.field_mode == "";});\r
\r
if(template_host_it != template_hosts.end())\r
return *template_host_it;\r
</producers>\r
<channels>\r
<channel>\r
- <video-mode>720p5000</video-mode>\r
+ <video-mode>PAL</video-mode>\r
<consumers>\r
<screen>\r
<key-only>false</key-only>\r
projects / casparcg / commitdiff