if(color.length() != 9 || color[0] != '#')\r
BOOST_THROW_EXCEPTION(invalid_argument() << arg_name_info("color") << arg_value_info(narrow(color)) << msg_info("Invalid color code"));\r
\r
- auto frame = frame_factory->create_frame(1, 1, pixel_format::bgra);\r
+ auto frame = frame_factory->create_frame(this, 1, 1, pixel_format::bgra);\r
auto& value = *reinterpret_cast<unsigned long*>(frame->image_data().begin());\r
std::wstringstream str(color_str_.substr(1));\r
- str >> std::hex >> value; \r
+ str >> std::hex >> value;\r
frame_ = std::move(frame);\r
}\r
\r
\r
struct frame_factory : boost::noncopyable\r
{\r
- virtual safe_ptr<write_frame> create_frame(const pixel_format_desc& desc) = 0;\r
- virtual safe_ptr<write_frame> create_frame(size_t width, size_t height, pixel_format::type pix_fmt = pixel_format::bgra) = 0; \r
- virtual safe_ptr<write_frame> create_frame(pixel_format::type pix_fmt = pixel_format::bgra) = 0;\r
+ virtual safe_ptr<write_frame> create_frame(void* tag, const pixel_format_desc& desc) = 0;\r
+ virtual safe_ptr<write_frame> create_frame(void* tag, size_t width, size_t height, pixel_format::type pix_fmt = pixel_format::bgra) = 0; \r
+ virtual safe_ptr<write_frame> create_frame(void* tag, pixel_format::type pix_fmt = pixel_format::bgra) = 0;\r
\r
virtual const video_format_desc& get_video_format_desc() const = 0; // nothrow\r
};\r
\r
virtual void accept(frame_visitor& visitor) = 0;\r
\r
- virtual void tag(int tag) = 0;\r
virtual int tag() const = 0;\r
};\r
\r
diag_->set_value("input-buffer", static_cast<float>(executor_.size())/static_cast<float>(executor_.capacity()));\r
}\r
\r
- safe_ptr<write_frame> create_frame(const pixel_format_desc& desc)\r
+ safe_ptr<write_frame> create_frame(void* tag, const pixel_format_desc& desc)\r
{\r
- return make_safe<gpu_write_frame>(desc, image_mixer_.create_buffers(desc));\r
+ return make_safe<gpu_write_frame>(reinterpret_cast<int>(tag), desc, image_mixer_.create_buffers(desc));\r
}\r
\r
void set_image_transform(const image_transform& transform, int mix_duration, const std::wstring& tween)\r
boost::signals2::connection frame_mixer_device::connect(const output_t::slot_type& subscriber){return impl_->connect(subscriber);}\r
void frame_mixer_device::send(const std::vector<safe_ptr<basic_frame>>& frames){impl_->send(frames);}\r
const video_format_desc& frame_mixer_device::get_video_format_desc() const { return impl_->format_desc_; }\r
-safe_ptr<write_frame> frame_mixer_device::create_frame(const pixel_format_desc& desc){ return impl_->create_frame(desc); } \r
-safe_ptr<write_frame> frame_mixer_device::create_frame(size_t width, size_t height, pixel_format::type pix_fmt)\r
+safe_ptr<write_frame> frame_mixer_device::create_frame(void* tag, const pixel_format_desc& desc){ return impl_->create_frame(tag, desc); } \r
+safe_ptr<write_frame> frame_mixer_device::create_frame(void* tag, size_t width, size_t height, pixel_format::type pix_fmt)\r
{\r
// Create bgra frame\r
pixel_format_desc desc;\r
desc.pix_fmt = pix_fmt;\r
- desc.planes.push_back(pixel_format_desc::plane(width, height, 4));\r
- return create_frame(desc);\r
+ desc.planes.push_back( pixel_format_desc::plane(width, height, 4));\r
+ return create_frame(tag, desc);\r
}\r
\r
-safe_ptr<write_frame> frame_mixer_device::create_frame(pixel_format::type pix_fmt)\r
+safe_ptr<write_frame> frame_mixer_device::create_frame(void* tag, pixel_format::type pix_fmt)\r
{\r
// Create bgra frame with output resolution\r
pixel_format_desc desc;\r
desc.pix_fmt = pix_fmt;\r
- desc.planes.push_back(pixel_format_desc::plane(get_video_format_desc().width, get_video_format_desc().height, 4));\r
- return create_frame(desc);\r
+ desc.planes.push_back( pixel_format_desc::plane(get_video_format_desc().width, get_video_format_desc().height, 4));\r
+ return create_frame(tag, desc);\r
}\r
void frame_mixer_device::set_image_transform(const image_transform& transform, int mix_duration, const std::wstring& tween){impl_->set_image_transform(transform, mix_duration, tween);}\r
void frame_mixer_device::set_image_transform(int index, const image_transform& transform, int mix_duration, const std::wstring& tween){impl_->set_image_transform(index, transform, mix_duration, tween);}\r
\r
void send(const std::vector<safe_ptr<basic_frame>>& frames); // nothrow\r
\r
- safe_ptr<write_frame> create_frame(const pixel_format_desc& desc); \r
- safe_ptr<write_frame> create_frame(size_t width, size_t height, pixel_format::type pix_fmt = pixel_format::bgra); \r
- safe_ptr<write_frame> create_frame(pixel_format::type pix_fmt = pixel_format::bgra);\r
+ safe_ptr<write_frame> create_frame(void* tag, const pixel_format_desc& desc); \r
+ safe_ptr<write_frame> create_frame(void* tag, size_t width, size_t height, pixel_format::type pix_fmt = pixel_format::bgra); \r
+ safe_ptr<write_frame> create_frame(void* tag, pixel_format::type pix_fmt = pixel_format::bgra);\r
\r
const video_format_desc& get_video_format_desc() const; // nothrow\r
\r
int tag_;\r
\r
public:\r
- implementation(const pixel_format_desc& desc, const std::vector<safe_ptr<host_buffer>>& buffers) \r
+ implementation(int tag, const pixel_format_desc& desc, const std::vector<safe_ptr<host_buffer>>& buffers) \r
: desc_(desc)\r
, buffers_(buffers)\r
- , tag_(std::numeric_limits<int>::min()){}\r
+ , tag_(tag){}\r
\r
void accept(gpu_write_frame& self, frame_visitor& visitor)\r
{\r
}\r
};\r
\r
-gpu_write_frame::gpu_write_frame(const pixel_format_desc& desc, const std::vector<safe_ptr<host_buffer>>& buffers) : impl_(new implementation(desc, buffers)){}\r
+gpu_write_frame::gpu_write_frame(int tag, const pixel_format_desc& desc, const std::vector<safe_ptr<host_buffer>>& buffers) : impl_(new implementation(tag, desc, buffers)){}\r
gpu_write_frame::gpu_write_frame(gpu_write_frame&& other) : impl_(std::move(other.impl_)){}\r
void gpu_write_frame::swap(gpu_write_frame& other){impl_.swap(other.impl_);}\r
gpu_write_frame& gpu_write_frame::operator=(gpu_write_frame&& other)\r
{\r
return boost::iterator_range<const short*>(impl_->audio_data_.data(), impl_->audio_data_.data() + impl_->audio_data_.size());\r
}\r
-void gpu_write_frame::tag(int tag) { impl_->tag_ = tag;}\r
int gpu_write_frame::tag() const {return impl_->tag_;}\r
const pixel_format_desc& gpu_write_frame::get_pixel_format_desc() const{return impl_->desc_;}\r
std::vector<safe_ptr<host_buffer>>& gpu_write_frame::get_plane_buffers(){return impl_->buffers_;}\r
class gpu_write_frame : public core::write_frame\r
{\r
public: \r
- explicit gpu_write_frame(const pixel_format_desc& desc, const std::vector<safe_ptr<host_buffer>>& buffers);\r
+ explicit gpu_write_frame(int tag, const pixel_format_desc& desc, const std::vector<safe_ptr<host_buffer>>& buffers);\r
gpu_write_frame(gpu_write_frame&& other);\r
gpu_write_frame& operator=(gpu_write_frame&& other);\r
\r
void swap(gpu_write_frame& other);\r
+\r
+ const pixel_format_desc& get_pixel_format_desc() const;\r
+ std::vector<safe_ptr<host_buffer>>& get_plane_buffers();\r
\r
- boost::iterator_range<unsigned char*> image_data(size_t plane_index = 0); \r
- std::vector<short>& audio_data();\r
+ // core::write_frame\r
+ virtual boost::iterator_range<unsigned char*> image_data(size_t plane_index = 0); \r
+ virtual std::vector<short>& audio_data();\r
\r
- const boost::iterator_range<const unsigned char*> image_data(size_t plane_index = 0) const;\r
- const boost::iterator_range<const short*> audio_data() const;\r
+ virtual const boost::iterator_range<const unsigned char*> image_data(size_t plane_index = 0) const;\r
+ virtual const boost::iterator_range<const short*> audio_data() const;\r
\r
virtual void accept(frame_visitor& visitor);\r
\r
- void tag(int tag);\r
- int tag() const;\r
-\r
- const pixel_format_desc& get_pixel_format_desc() const;\r
- std::vector<safe_ptr<host_buffer>>& get_plane_buffers();\r
+ virtual int tag() const;\r
\r
private:\r
struct implementation;\r
desc.planes.push_back(core::pixel_format_desc::plane(d_mode_->GetWidth(), d_mode_->GetHeight(), 1));\r
desc.planes.push_back(core::pixel_format_desc::plane(d_mode_->GetWidth()/2, d_mode_->GetHeight(), 1));\r
desc.planes.push_back(core::pixel_format_desc::plane(d_mode_->GetWidth()/2, d_mode_->GetHeight(), 1)); \r
- auto frame = frame_factory_->create_frame(desc);\r
+ auto frame = frame_factory_->create_frame(this, desc);\r
\r
unsigned char* data = reinterpret_cast<unsigned char*>(bytes);\r
int frame_size = (d_mode_->GetWidth() * 16 / 8) * d_mode_->GetHeight();\r
{\r
try\r
{\r
- auto frame = video_decoder_->execute(video_packet);\r
- frame->tag(reinterpret_cast<int>(this));\r
+ auto frame = video_decoder_->execute(this, video_packet);\r
video_frame_channel_.push_back(std::move(frame));\r
}\r
catch(...)\r
{\r
if(!frame) // If there is no video create a dummy frame.\r
{\r
- frame = frame_factory_->create_frame(1, 1);\r
+ frame = frame_factory_->create_frame(this, 1, 1);\r
std::fill(frame->image_data().begin(), frame->image_data().end(), 0);\r
}\r
\r
}\r
}\r
\r
- safe_ptr<core::write_frame> execute(const aligned_buffer& video_packet)\r
+ safe_ptr<core::write_frame> execute(void* tag, const aligned_buffer& video_packet)\r
{ \r
safe_ptr<AVFrame> decoded_frame(avcodec_alloc_frame(), av_free);\r
\r
if(result < 0)\r
BOOST_THROW_EXCEPTION(invalid_operation() << msg_info("avcodec_decode_video failed"));\r
\r
- auto write = frame_factory_->create_frame(desc_);\r
+ auto write = frame_factory_->create_frame(tag, desc_);\r
if(sws_context_ == nullptr)\r
{\r
tbb::parallel_for(0, static_cast<int>(desc_.planes.size()), 1, [&](int n)\r
};\r
\r
video_decoder::video_decoder(AVCodecContext* codec_context, const safe_ptr<core::frame_factory>& frame_factory) : impl_(new implementation(codec_context, frame_factory)){}\r
-safe_ptr<core::write_frame> video_decoder::execute(const aligned_buffer& video_packet){return impl_->execute(video_packet);}\r
+safe_ptr<core::write_frame> video_decoder::execute(void* tag, const aligned_buffer& video_packet){return impl_->execute(tag, video_packet);}\r
\r
}
\ No newline at end of file
{\r
public:\r
explicit video_decoder(AVCodecContext* codec_context, const safe_ptr<core::frame_factory>& frame_factory);\r
- safe_ptr<core::write_frame> execute(const aligned_buffer& video_packet); \r
+ safe_ptr<core::write_frame> execute(void* tag, const aligned_buffer& video_packet); \r
private:\r
struct implementation;\r
safe_ptr<implementation> impl_;\r
std::fill_n(bmp_data_, format_desc_.size, 0);\r
ax_->DrawControl(static_cast<HDC>(hdc_.get()));\r
\r
- auto frame = frame_factory_->create_frame();\r
+ auto frame = frame_factory_->create_frame(this);\r
std::copy_n(bmp_data_, format_desc_.size, frame->image_data().begin());\r
head_ = frame;\r
} \r
{\r
auto bitmap = load_image(filename_);\r
FreeImage_FlipVertical(bitmap.get());\r
- auto frame = frame_factory->create_frame(FreeImage_GetWidth(bitmap.get()), FreeImage_GetHeight(bitmap.get()));\r
+ auto frame = frame_factory->create_frame(this, FreeImage_GetWidth(bitmap.get()), FreeImage_GetHeight(bitmap.get()));\r
std::copy_n(FreeImage_GetBits(bitmap.get()), frame->image_data().size(), frame->image_data().begin());\r
frame_ = std::move(frame);\r
}\r
while (window_.GetEvent(Event)){}\r
window_.Display();\r
\r
- auto frame = frame_factory_->create_frame();\r
+ auto frame = frame_factory_->create_frame(this);\r
::BitBlt(mem_, 0, 0, format_desc_.width, format_desc_.height, screen_, 0, 0, SRCCOPY); \r
std::copy_n(bmp_data_, format_desc_.size, frame->image_data().begin());\r
\r