\r
#include <boost/lexical_cast.hpp>\r
\r
-namespace caspar {\r
+namespace caspar { namespace bluefish {\r
\r
-void init_bluefish()\r
+void init()\r
{\r
try\r
{\r
blue_initialize();\r
core::register_consumer_factory([](const std::vector<std::wstring>& params)\r
{\r
- return create_bluefish_consumer(params);\r
+ return create_consumer(params);\r
});\r
}\r
catch(...)\r
}\r
}\r
\r
-std::wstring get_bluefish_version()\r
+std::wstring get_version()\r
{\r
try\r
{\r
return widen(std::string(BlueVelvetVersion()));\r
}\r
\r
-std::vector<std::wstring> get_bluefish_device_list()\r
+std::vector<std::wstring> get_device_list()\r
{\r
std::vector<std::wstring> devices;\r
\r
\r
return devices;\r
}\r
-}
\ No newline at end of file
+\r
+}}
\ No newline at end of file
#include <string>\r
#include <vector>\r
\r
-namespace caspar {\r
+namespace caspar { namespace bluefish {\r
\r
-void init_bluefish();\r
+void init();\r
\r
-std::wstring get_bluefish_version();\r
-std::vector<std::wstring> get_bluefish_device_list();\r
+std::wstring get_version();\r
+std::vector<std::wstring> get_device_list();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <memory>\r
#include <array>\r
\r
-namespace caspar { \r
+namespace caspar { namespace bluefish { \r
\r
struct bluefish_consumer : boost::noncopyable\r
{\r
}\r
}; \r
\r
-safe_ptr<core::frame_consumer> create_bluefish_consumer(const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params)\r
{\r
if(params.size() < 1 || params[0] != L"BLUEFISH")\r
return core::frame_consumer::empty();\r
return make_safe<bluefish_consumer_proxy>(device_index, embedded_audio, key_only);\r
}\r
\r
-safe_ptr<core::frame_consumer> create_bluefish_consumer(const boost::property_tree::ptree& ptree) \r
+safe_ptr<core::frame_consumer> create_consumer(const boost::property_tree::ptree& ptree) \r
{ \r
const auto device_index = ptree.get("device", 1);\r
const auto embedded_audio = ptree.get("embedded-audio", false);\r
return make_safe<bluefish_consumer_proxy>(device_index, embedded_audio, key_only);\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
namespace core {\r
struct frame_consumer;\r
}\r
- \r
-safe_ptr<core::frame_consumer> create_bluefish_consumer(const std::vector<std::wstring>& params);\r
-safe_ptr<core::frame_consumer> create_bluefish_consumer(const boost::property_tree::ptree& ptree);\r
+ \r
+namespace bluefish {\r
\r
-}
\ No newline at end of file
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_consumer> create_consumer(const boost::property_tree::ptree& ptree);\r
+\r
+}}
\ No newline at end of file
\r
#include <core/video_format.h>\r
\r
-namespace caspar {\r
+namespace caspar { namespace bluefish {\r
\r
CBlueVelvet4* (*BlueVelvetFactory4)() = nullptr;\r
void (*BlueVelvetDestroy)(CBlueVelvet4* pObj) = nullptr;\r
return blue;\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
}\r
\r
+namespace bluefish {\r
+\r
extern const char* (*BlueVelvetVersion)();\r
extern BLUE_UINT32 (*encode_hanc_frame)(struct hanc_stream_info_struct * hanc_stream_ptr, void * audio_pcm_ptr,BLUE_UINT32 no_audio_ch,BLUE_UINT32 no_audio_samples,BLUE_UINT32 nTypeOfSample,BLUE_UINT32 emb_audio_flag);\r
extern BLUE_UINT32 (*encode_hanc_frame_ex)(BLUE_UINT32 card_type, struct hanc_stream_info_struct * hanc_stream_ptr, void * audio_pcm_ptr, BLUE_UINT32 no_audio_ch, BLUE_UINT32 no_audio_samples, BLUE_UINT32 nTypeOfSample, BLUE_UINT32 emb_audio_flag);\r
return (pSdk->SetCardProperty(prop,variantValue));\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <vector>\r
\r
-namespace caspar { \r
+namespace caspar { namespace bluefish {\r
\r
static const size_t MAX_HANC_BUFFER_SIZE = 256*1024;\r
static const size_t MAX_VBI_BUFFER_SIZE = 36*1920*4;\r
};\r
typedef std::shared_ptr<blue_dma_buffer> blue_dma_buffer_ptr;\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <boost/circular_buffer.hpp>\r
#include <boost/timer.hpp>\r
\r
-namespace caspar { \r
+namespace caspar { namespace decklink { \r
\r
struct configuration\r
{\r
}\r
}; \r
\r
-safe_ptr<core::frame_consumer> create_decklink_consumer(const std::vector<std::wstring>& params) \r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params) \r
{\r
if(params.size() < 1 || params[0] != L"DECKLINK")\r
return core::frame_consumer::empty();\r
return make_safe<decklink_consumer_proxy>(config);\r
}\r
\r
-safe_ptr<core::frame_consumer> create_decklink_consumer(const boost::property_tree::ptree& ptree) \r
+safe_ptr<core::frame_consumer> create_consumer(const boost::property_tree::ptree& ptree) \r
{\r
configuration config;\r
\r
return make_safe<decklink_consumer_proxy>(config);\r
}\r
\r
-}\r
+}}\r
\r
/*\r
##############################################################################\r
#include <string>\r
#include <vector>\r
\r
-namespace caspar { \r
+namespace caspar {\r
\r
namespace core {\r
struct frame_consumer;\r
}\r
- \r
-safe_ptr<core::frame_consumer> create_decklink_consumer(const std::vector<std::wstring>& params);\r
-safe_ptr<core::frame_consumer> create_decklink_consumer(const boost::property_tree::ptree& ptree);\r
\r
-}
\ No newline at end of file
+namespace decklink {\r
+\r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_consumer> create_consumer(const boost::property_tree::ptree& ptree);\r
+\r
+}}
\ No newline at end of file
\r
#pragma warning(push)\r
\r
-namespace caspar{\r
+namespace caspar { namespace decklink {\r
\r
-void init_decklink()\r
+void init()\r
{\r
- core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_decklink_consumer(params);});\r
- core::register_producer_factory(create_decklink_producer);\r
+ core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_consumer(params);});\r
+ core::register_producer_factory(create_producer);\r
}\r
\r
-std::wstring get_decklink_version() \r
+std::wstring get_version() \r
{\r
std::wstring version = L"Not found";\r
\r
return version;\r
}\r
\r
-std::vector<std::wstring> get_decklink_device_list()\r
+std::vector<std::wstring> get_device_list()\r
{\r
std::vector<std::wstring> devices;\r
\r
return devices;\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <string>\r
#include <vector>\r
\r
-namespace caspar {\r
+namespace caspar { namespace decklink {\r
\r
-void init_decklink();\r
+void init();\r
\r
-std::wstring get_decklink_version();\r
-std::vector<std::wstring> get_decklink_device_list();\r
+std::wstring get_version();\r
+std::vector<std::wstring> get_device_list();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <functional>\r
\r
-namespace caspar { \r
+namespace caspar { namespace decklink {\r
\r
class decklink_producer : boost::noncopyable, public IDeckLinkInputCallback\r
{ \r
tbb::concurrent_bounded_queue<safe_ptr<core::basic_frame>> frame_buffer_;\r
\r
std::exception_ptr exception_;\r
- filter filter_;\r
+ ffmpeg::filter filter_;\r
\r
- frame_muxer muxer_;\r
+ ffmpeg::frame_muxer muxer_;\r
\r
public:\r
decklink_producer(const core::video_format_desc& format_desc, size_t device_index, const safe_ptr<core::frame_factory>& frame_factory, const std::wstring& filter)\r
, device_index_(device_index)\r
, frame_factory_(frame_factory)\r
, filter_(filter)\r
- , muxer_(double_rate(filter) ? format_desc.fps * 2.0 : format_desc.fps, frame_factory)\r
+ , muxer_(ffmpeg::double_rate(filter) ? format_desc.fps * 2.0 : format_desc.fps, frame_factory)\r
{\r
frame_buffer_.set_capacity(2);\r
\r
}\r
};\r
\r
-safe_ptr<core::frame_producer> create_decklink_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
{\r
if(params.empty() || !boost::iequals(params[0], "decklink"))\r
return core::frame_producer::empty();\r
return make_safe<decklink_producer_proxy>(frame_factory, format_desc, device_index, filter_str, length);\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <string>\r
#include <vector>\r
\r
-namespace caspar { \r
+namespace caspar { namespace decklink {\r
\r
-safe_ptr<core::frame_producer> create_decklink_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
\r
-}\r
+}}\r
\r
#include <string>\r
\r
-namespace caspar { \r
+namespace caspar { namespace decklink {\r
\r
static BMDDisplayMode get_decklink_video_format(core::video_format::type fmt) \r
{\r
return std::wstring(pModelName);\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <libavfilter/avfilter.h>\r
}\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
int ffmpeg_lock_callback(void **mutex, enum AVLockOp op) \r
{ \r
//colored_fputs(av_clip(level>>3, 0, 6), line);\r
}\r
\r
-void init_ffmpeg()\r
+void init()\r
{\r
avfilter_register_all();\r
av_register_all();\r
av_log_set_callback(log_callback);\r
\r
//core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_ffmpeg_consumer(params);});\r
- core::register_producer_factory(create_ffmpeg_producer);\r
+ core::register_producer_factory(create_producer);\r
}\r
\r
-void uninit_ffmpeg()\r
+void uninit()\r
{\r
avfilter_uninit();\r
av_lockmgr_register(nullptr);\r
return make_version(swscale_version());\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <string>\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
-void init_ffmpeg();\r
-void uninit_ffmpeg();\r
+void init();\r
+void uninit();\r
\r
std::wstring get_avcodec_version();\r
std::wstring get_avformat_version();\r
std::wstring get_avfilter_version();\r
std::wstring get_swscale_version();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#pragma warning(pop)\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
struct ffmpeg_error : virtual caspar_exception{};\r
\r
return ret; \\r
}();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#pragma warning (pop)\r
#endif\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
struct audio_decoder::implementation : boost::noncopyable\r
{ \r
bool audio_decoder::ready() const{return impl_->ready();}\r
std::vector<std::shared_ptr<core::audio_buffer>> audio_decoder::poll(){return impl_->poll();}\r
int64_t audio_decoder::nb_frames() const{return impl_->nb_frames_;}\r
-}
\ No newline at end of file
+\r
+}}
\ No newline at end of file
\r
}\r
\r
+namespace ffmpeg {\r
+\r
class audio_decoder : boost::noncopyable\r
{\r
public:\r
safe_ptr<implementation> impl_;\r
};\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#pragma warning (pop)\r
#endif\r
\r
-\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
struct audio_resampler::implementation\r
{ \r
: impl_(new implementation(output_channels, input_channels, output_sample_rate, input_sample_rate, output_sample_format, input_sample_format)){}\r
std::vector<int8_t, tbb::cache_aligned_allocator<int8_t>> audio_resampler::resample(std::vector<int8_t, tbb::cache_aligned_allocator<int8_t>>&& data){return impl_->resample(std::move(data));}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <libavutil/samplefmt.h>\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
class audio_resampler\r
{\r
std::shared_ptr<implementation> impl_;\r
};\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <tbb/parallel_invoke.h>\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
struct ffmpeg_producer : public core::frame_producer\r
{\r
}\r
};\r
\r
-safe_ptr<core::frame_producer> create_ffmpeg_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
{ \r
static const std::vector<std::wstring> extensions = boost::assign::list_of\r
(L"mpg")(L"mpeg")(L"m2v")(L"m4v")(L"mp3")(L"mp4")(L"mpga")\r
return make_safe<ffmpeg_producer>(frame_factory, path, filter_str, loop, start, length);\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
}\r
\r
-safe_ptr<core::frame_producer> create_ffmpeg_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
+namespace ffmpeg {\r
\r
-}
\ No newline at end of file
+safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
+\r
+}}
\ No newline at end of file
#pragma warning (pop)\r
#endif\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
struct filter::implementation\r
{\r
filter::filter(filter&& other) : impl_(std::move(other.impl_)){}\r
filter& filter::operator=(filter&& other){impl_ = std::move(other.impl_); return *this;}\r
std::vector<safe_ptr<AVFrame>> filter::execute(const std::shared_ptr<AVFrame>& frame) {return impl_->execute(frame);}\r
-}
\ No newline at end of file
+\r
+}}
\ No newline at end of file
struct AVFrame;\r
enum PixelFormat;\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
static bool double_rate(const std::wstring& filters)\r
{\r
safe_ptr<implementation> impl_;\r
};\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
}\r
}\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
tbb::concurrent_bounded_queue<decltype(org_yadif_filter_line)> parallel_line_func_pool;\r
std::array<parallel_yadif_context, 18> ctxs;\r
++index;\r
\r
ctxs[index].last_index = 0;\r
- for (int y = 0; y < ctx->inputs[0]->h; y++)
- {
+ for (int y = 0; y < ctx->inputs[0]->h; y++)\r
+ {\r
if ((y ^ yadif->parity) & 1)\r
++ctxs[index].last_index;\r
}\r
return std::shared_ptr<void>(func, return_parallel_yadif);\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
struct AVFilterContext;\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
std::shared_ptr<void> make_parallel_yadif(AVFilterContext* ctx);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <unordered_map>\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
std::map<std::string, std::string> read_flv_meta_info(const std::string& filename)\r
{\r
return values;\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#pragma once\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
std::map<std::string, std::string> read_flv_meta_info(const std::string& filename);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
using namespace caspar::core;\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
struct display_mode\r
{\r
bool frame_muxer::audio_ready() const{return impl_->audio_ready();}\r
int64_t frame_muxer::calc_nb_frames(int64_t nb_frames) const {return impl_->calc_nb_frames(nb_frames);}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
}\r
\r
+namespace ffmpeg {\r
+\r
class frame_muxer : boost::noncopyable\r
{\r
public:\r
safe_ptr<implementation> impl_;\r
};\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#pragma warning (pop)\r
#endif\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
static const size_t MAX_BUFFER_COUNT = 100;\r
static const size_t MIN_BUFFER_COUNT = 4;\r
safe_ptr<AVFormatContext> input::context(){return make_safe(impl_->format_context_);}\r
size_t input::nb_frames() const {return impl_->nb_frames();}\r
size_t input::nb_loops() const {return impl_->nb_loops();}\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
class graph;\r
\r
}\r
- \r
+ \r
+namespace ffmpeg {\r
+\r
class input : boost::noncopyable\r
{\r
public:\r
};\r
\r
\r
-}\r
+}}\r
#pragma warning (pop)\r
#endif\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
core::field_mode::type get_mode(AVFrame& frame)\r
{\r
video_context.time_base.den = static_cast<int>(closest_fps*1000000.0);\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
}\r
\r
+namespace ffmpeg {\r
+\r
static const PixelFormat CASPAR_PIX_FMT_LUMA = PIX_FMT_MONOBLACK; // Just hijack some unual pixel format.\r
\r
core::field_mode::type get_mode(AVFrame& frame);\r
\r
void fix_meta_data(AVFormatContext& context);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#pragma warning (pop)\r
#endif\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
struct video_decoder::implementation : boost::noncopyable\r
{\r
int64_t video_decoder::nb_frames() const{return impl_->nb_frames_;}\r
size_t video_decoder::width() const{return impl_->width_;}\r
size_t video_decoder::height() const{return impl_->height_;}\r
-}
\ No newline at end of file
+\r
+}}
\ No newline at end of file
class write_frame;\r
}\r
\r
+namespace ffmpeg {\r
+\r
class video_decoder : boost::noncopyable\r
{\r
public:\r
safe_ptr<implementation> impl_;\r
};\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#pragma warning (pop)\r
#endif\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
int thread_execute(AVCodecContext* s, int (*func)(AVCodecContext *c2, void *arg2), void* arg, int* ret, int count, int size)\r
{\r
return avcodec_close(avctx); \r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
struct AVCodecContext;\r
struct AVCodec;\r
\r
-namespace caspar {\r
+namespace caspar { namespace ffmpeg {\r
\r
int tbb_avcodec_open(AVCodecContext *avctx, AVCodec *codec);\r
int tbb_avcodec_close(AVCodecContext *avctx);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <common/env.h>\r
\r
-namespace caspar{\r
+namespace caspar { namespace flash {\r
\r
-void init_flash()\r
+void init()\r
{\r
core::register_producer_factory(create_ct_producer);\r
}\r
return L"Unknown";\r
}\r
\r
-std::wstring get_flash_version()\r
+std::wstring get_version()\r
{ \r
std::wstring version = L"Not found";\r
#ifdef WIN32\r
return version;\r
}\r
\r
-}\r
+}}\r
\r
#include <string>\r
\r
-namespace caspar{\r
+namespace caspar { namespace flash {\r
\r
-void init_flash();\r
+void init();\r
\r
std::wstring get_cg_version();\r
-std::wstring get_flash_version();\r
+std::wstring get_version();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <boost/filesystem.hpp>\r
#include <boost/format.hpp>\r
\r
-namespace caspar {\r
+namespace caspar { namespace flash {\r
\r
struct cg_producer::implementation : boost::noncopyable\r
{\r
\r
if(flash_producer->print().find(L"flash[") == std::string::npos) // UGLY hack\r
{\r
- flash_producer = create_flash_producer(video_channel->mixer(), boost::assign::list_of<std::wstring>()); \r
+ flash_producer = flash::create_producer(video_channel->mixer(), boost::assign::list_of<std::wstring>()); \r
video_channel->stage()->load(render_layer, flash_producer); \r
video_channel->stage()->play(render_layer);\r
}\r
if(!boost::filesystem::exists(filename))\r
return core::frame_producer::empty();\r
\r
- auto flash_producer = create_flash_producer(frame_factory, boost::assign::list_of<std::wstring>()); \r
+ auto flash_producer = flash::create_producer(frame_factory, boost::assign::list_of<std::wstring>()); \r
auto producer = make_safe<cg_producer>(flash_producer);\r
producer->add(0, filename, 1);\r
\r
void cg_producer::invoke(int layer, const std::wstring& label){impl_->invoke(layer, label);}\r
std::wstring cg_producer::print() const{return impl_->print();}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <string>\r
\r
-namespace caspar {\r
+namespace caspar { namespace flash {\r
\r
class cg_producer : public core::frame_producer\r
{\r
\r
safe_ptr<core::frame_producer> create_ct_producer(const safe_ptr<core::frame_factory> frame_factory, const std::vector<std::wstring>& params);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <tbb/spin_mutex.h>\r
\r
-namespace caspar {\r
+namespace caspar { namespace flash {\r
\r
class bitmap\r
{\r
}\r
};\r
\r
-safe_ptr<core::frame_producer> create_flash_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
{\r
auto template_host = get_template_host(frame_factory->get_video_format_desc());\r
\r
return make_safe<flash_producer>(frame_factory, env::template_folder() + L"\\" + widen(template_host.filename), template_host.width, template_host.height);\r
}\r
\r
-std::wstring find_flash_template(const std::wstring& template_name)\r
+std::wstring find_template(const std::wstring& template_name)\r
{\r
if(boost::filesystem::exists(template_name + L".ft")) \r
return template_name + L".ft";\r
return L"";\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <vector>\r
#include <string>\r
\r
-namespace caspar {\r
+namespace caspar { namespace flash {\r
\r
-safe_ptr<core::frame_producer> create_flash_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
\r
-std::wstring find_flash_template(const std::wstring& templateName);\r
+std::wstring find_template(const std::wstring& templateName);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <vector>\r
\r
-namespace caspar {\r
+namespace caspar { namespace image {\r
\r
struct image_consumer : public core::frame_consumer\r
{\r
}\r
};\r
\r
-safe_ptr<core::frame_consumer> create_image_consumer(const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params)\r
{\r
if(params.size() < 1 || params[0] != L"IMAGE")\r
return core::frame_consumer::empty();\r
return make_safe<image_consumer>();\r
}\r
\r
-\r
-}\r
+}}\r
namespace core {\r
struct frame_consumer;\r
}\r
+\r
+namespace image {\r
\r
-safe_ptr<core::frame_consumer> create_image_consumer(const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <FreeImage.h>\r
\r
-namespace caspar {\r
+namespace caspar { namespace image {\r
\r
-void init_image()\r
+void init()\r
{\r
- core::register_producer_factory(create_image_scroll_producer);\r
- core::register_producer_factory(create_image_producer);\r
- core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_image_consumer(params);});\r
+ core::register_producer_factory(create_scroll_producer);\r
+ core::register_producer_factory(create_producer);\r
+ core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_consumer(params);});\r
}\r
\r
-std::wstring get_image_version()\r
+std::wstring get_version()\r
{\r
return widen(std::string(FreeImage_GetVersion()));\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <string>\r
\r
-namespace caspar{\r
+namespace caspar { namespace image {\r
\r
-void init_image();\r
+void init();\r
\r
-std::wstring get_image_version();\r
+std::wstring get_version();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
using namespace boost::assign;\r
\r
-namespace caspar {\r
+namespace caspar { namespace image {\r
\r
struct image_producer : public core::frame_producer\r
{ \r
}\r
};\r
\r
-safe_ptr<core::frame_producer> create_image_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
{\r
static const std::vector<std::wstring> extensions = list_of(L"png")(L"tga")(L"bmp")(L"jpg")(L"jpeg")(L"gif")(L"tiff")(L"tif")(L"jp2")(L"jpx")(L"j2k")(L"j2c");\r
std::wstring filename = env::media_folder() + L"\\" + params[0];\r
}\r
\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <string>\r
#include <vector>\r
\r
-namespace caspar { \r
+namespace caspar { namespace image {\r
\r
-safe_ptr<core::frame_producer> create_image_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
using namespace boost::assign;\r
\r
-namespace caspar {\r
+namespace caspar { namespace image {\r
\r
struct image_scroll_producer : public core::frame_producer\r
{ \r
}\r
};\r
\r
-safe_ptr<core::frame_producer> create_image_scroll_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_producer> create_scroll_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
{\r
static const std::vector<std::wstring> extensions = list_of(L"png")(L"tga")(L"bmp")(L"jpg")(L"jpeg")(L"gif")(L"tiff")(L"tif")(L"jp2")(L"jpx")(L"j2k")(L"j2c");\r
std::wstring filename = env::media_folder() + L"\\" + params[0];\r
return make_safe<image_scroll_producer>(frame_factory, filename + L"." + *ext, speed);\r
}\r
\r
-\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <string>\r
#include <vector>\r
\r
-namespace caspar { \r
+namespace caspar { namespace image {\r
\r
-safe_ptr<core::frame_producer> create_image_scroll_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_producer> create_scroll_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <boost/exception/errinfo_file_name.hpp>\r
#include <boost/filesystem.hpp>\r
\r
-namespace caspar { \r
+namespace caspar { namespace image {\r
\r
std::shared_ptr<FIBITMAP> load_image(const std::string& filename)\r
{\r
return load_image(narrow(filename));\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <memory>\r
#include <string>\r
\r
-namespace caspar { \r
+namespace caspar { namespace image {\r
\r
std::shared_ptr<FIBITMAP> load_image(const std::string& filename);\r
std::shared_ptr<FIBITMAP> load_image(const std::wstring& filename);\r
\r
-}\r
+}}\r
\r
#include <tbb/concurrent_queue.h>\r
\r
-namespace caspar {\r
+namespace caspar { namespace oal {\r
\r
struct oal_consumer : public core::frame_consumer, public sf::SoundStream\r
{\r
}\r
};\r
\r
-safe_ptr<core::frame_consumer> create_oal_consumer(const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params)\r
{\r
if(params.size() < 1 || params[0] != L"AUDIO")\r
return core::frame_consumer::empty();\r
return make_safe<oal_consumer>();\r
}\r
\r
-safe_ptr<core::frame_consumer> create_oal_consumer()\r
+safe_ptr<core::frame_consumer> create_consumer()\r
{\r
return make_safe<oal_consumer>();\r
}\r
\r
-}\r
+}}\r
\r
#include <vector>\r
\r
-namespace caspar {\r
+namespace caspar { \r
\r
namespace core {\r
struct frame_consumer;\r
} \r
\r
-safe_ptr<core::frame_consumer> create_oal_consumer(const std::vector<std::wstring>& params);\r
-safe_ptr<core::frame_consumer> create_oal_consumer();\r
+namespace oal {\r
+ \r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_consumer> create_consumer();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <core/consumer/frame_consumer.h>\r
\r
-namespace caspar\r
-{\r
+namespace caspar { namespace oal {\r
\r
-void init_oal()\r
+void init()\r
{\r
- core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_oal_consumer(params);});\r
+ core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_consumer(params);});\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
*/\r
#pragma once\r
\r
-namespace caspar{\r
+namespace caspar { namespace oal {\r
\r
-void init_oal();\r
+void init();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#pragma warning (pop)\r
#endif\r
\r
-namespace caspar {\r
+namespace caspar { namespace ogl {\r
\r
enum stretch\r
{\r
size_t screen_index;\r
stretch stretch;\r
bool windowed;\r
- bool key_only;\r
bool auto_deinterlace;\r
+ bool key_only;\r
\r
configuration()\r
: screen_index(0)\r
, stretch(fill)\r
, windowed(true)\r
- , key_only(false)\r
, auto_deinterlace(true)\r
+ , key_only(false)\r
{\r
}\r
};\r
tbb::atomic<bool> is_running_;\r
\r
\r
- filter filter_;\r
+ ffmpeg::filter filter_;\r
public:\r
ogl_consumer(const configuration& config, const core::video_format_desc& format_desc) \r
: config_(config)\r
}\r
}; \r
\r
-safe_ptr<core::frame_consumer> create_ogl_consumer(const std::vector<std::wstring>& params)\r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params)\r
{\r
if(params.size() < 1 || params[0] != L"SCREEN")\r
return core::frame_consumer::empty();\r
return make_safe<ogl_consumer_proxy>(config);\r
}\r
\r
-safe_ptr<core::frame_consumer> create_ogl_consumer(const boost::property_tree::ptree& ptree) \r
+safe_ptr<core::frame_consumer> create_consumer(const boost::property_tree::ptree& ptree) \r
{\r
configuration config;\r
config.screen_index = ptree.get("device", config.screen_index);\r
return make_safe<ogl_consumer_proxy>(config);\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
#include <vector>\r
#include <boost/property_tree/ptree.hpp>\r
\r
-namespace caspar {\r
-\r
+namespace caspar { \r
+ \r
namespace core {\r
struct frame_consumer;\r
}\r
\r
-safe_ptr<core::frame_consumer> create_ogl_consumer(const std::vector<std::wstring>& params);\r
-safe_ptr<core::frame_consumer> create_ogl_consumer(const boost::property_tree::ptree& ptree);\r
+namespace ogl {\r
+\r
+\r
+safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params);\r
+safe_ptr<core::frame_consumer> create_consumer(const boost::property_tree::ptree& ptree);\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
\r
#include <core/consumer/frame_consumer.h>\r
\r
-namespace caspar\r
-{\r
+namespace caspar { namespace ogl {\r
\r
-void init_ogl()\r
+void init()\r
{\r
- core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_ogl_consumer(params);});\r
+ caspar::core::register_consumer_factory([](const std::vector<std::wstring>& params){return create_consumer(params);});\r
}\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
*/\r
#pragma once\r
\r
-namespace caspar{\r
+namespace caspar { namespace ogl {\r
\r
-void init_ogl();\r
+void init();\r
\r
-}
\ No newline at end of file
+}}
\ No newline at end of file
// std::wstring filename = templatename;\r
// filename.append(extension);\r
//\r
-// flash::get_default_cg_producer(info.video_channel, std::max<int>(DEFAULT_CHANNEL_LAYER+1, info.layer_index))\r
+// flash::flash::get_default_cg_producer(info.video_channel, std::max<int>(DEFAULT_CHANNEL_LAYER+1, info.layer_index))\r
// ->add(flash_layer_index, filename, play_on_load, start_label, data);\r
//\r
// CASPAR_LOG(info) << L"Executed [amcp_channel_cg_add]";\r
}\r
}\r
\r
- std::wstring fullFilename = find_flash_template(env::template_folder() + _parameters[2]);\r
+ std::wstring fullFilename = flash::find_template(env::template_folder() + _parameters[2]);\r
if(!fullFilename.empty())\r
{\r
std::wstring extension = boost::filesystem::wpath(fullFilename).extension();\r
std::wstring filename = _parameters[2];\r
filename.append(extension);\r
\r
- get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));\r
+ flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));\r
SetReplyString(TEXT("202 CG OK\r\n"));\r
}\r
else\r
return false;\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
- get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->play(layer);\r
+ flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->play(layer);\r
}\r
else\r
{\r
return false;\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
- get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->stop(layer, 0);\r
+ flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->stop(layer, 0);\r
}\r
else \r
{\r
}\r
\r
int layer = _ttoi(_parameters[1].c_str());\r
- get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->next(layer);\r
+ flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->next(layer);\r
}\r
else \r
{\r
}\r
\r
int layer = _ttoi(_parameters[1].c_str());\r
- get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->remove(layer);\r
+ flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->remove(layer);\r
}\r
else \r
{\r
\r
bool CGCommand::DoExecuteClear() \r
{\r
- GetChannel()->stage()->clear(GetLayerIndex(cg_producer::DEFAULT_LAYER));\r
+ GetChannel()->stage()->clear(GetLayerIndex(flash::cg_producer::DEFAULT_LAYER));\r
SetReplyString(TEXT("202 CG OK\r\n"));\r
return true;\r
}\r
} \r
\r
int layer = _ttoi(_parameters.at(1).c_str());\r
- get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->update(layer, dataString);\r
+ flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->update(layer, dataString);\r
}\r
catch(...)\r
{\r
return false;\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
- get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->invoke(layer, _parameters2[2]);\r
+ flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->invoke(layer, _parameters2[2]);\r
}\r
else \r
{\r
bool CGCommand::DoExecuteInfo() \r
{\r
// TODO\r
- //get_default_cg_producer(GetChannel())->Info();\r
+ //flash::get_default_cg_producer(GetChannel())->Info();\r
SetReplyString(TEXT("600 CG FAILED\r\n"));\r
return true;\r
}\r
if(_parameters.size() > 0)\r
{\r
if(_parameters[0] == L"FLASH")\r
- replyString = TEXT("201 VERSION OK\r\n FLASH: ") + get_flash_version() + TEXT("\r\n");\r
+ replyString = TEXT("201 VERSION OK\r\n FLASH: ") + flash::get_version() + TEXT("\r\n");\r
else if(_parameters[0] == L"TEMPLATEHOST")\r
- replyString = TEXT("201 VERSION OK\r\n TEMPLATEHOST: ") + get_cg_version() + TEXT("\r\n");\r
+ replyString = TEXT("201 VERSION OK\r\n TEMPLATEHOST: ") + flash::get_cg_version() + TEXT("\r\n");\r
else if(_parameters[0] != L"SERVER")\r
replyString = TEXT("403 VERSION ERROR\r\n");\r
}\r
\r
//TODO: Need to be checked for validity\r
else if(state_ == 1)\r
- get_default_cg_producer(pCIIStrategy_->GetChannel())->add(layer_, filename_, false, TEXT(""), xmlData_);\r
+ flash::get_default_cg_producer(pCIIStrategy_->GetChannel())->add(layer_, filename_, false, TEXT(""), xmlData_);\r
}\r
\r
\r
\r
//TODO: Need to be checked for validity\r
else if(state_ == 1)\r
- get_default_cg_producer(pCIIStrategy_->GetChannel())->stop(layer_, 0);\r
+ flash::get_default_cg_producer(pCIIStrategy_->GetChannel())->stop(layer_, 0);\r
else if(state_ == 2)\r
- pCIIStrategy_->GetChannel()->stage()->clear(cg_producer::DEFAULT_LAYER);\r
+ pCIIStrategy_->GetChannel()->stage()->clear(flash::cg_producer::DEFAULT_LAYER);\r
else if(state_ == 3)\r
- get_default_cg_producer(pCIIStrategy_->GetChannel())->play(layer_);\r
+ flash::get_default_cg_producer(pCIIStrategy_->GetChannel())->play(layer_);\r
}\r
\r
void KeydataCommand::Setup(const std::vector<std::wstring>& parameters) {\r
fullTemplateFilename += TEXT("\\");\r
}\r
fullTemplateFilename += templateName;\r
- fullTemplateFilename = find_flash_template(fullTemplateFilename);\r
+ fullTemplateFilename = flash::find_template(fullTemplateFilename);\r
if(fullTemplateFilename.empty())\r
{\r
CASPAR_LOG(error) << "Failed to save instance of " << templateName << TEXT(" as ") << titleName << TEXT(", template ") << fullTemplateFilename << " not found";\r
return;\r
}\r
\r
- auto producer = create_flash_producer(this->GetChannel()->mixer(), boost::assign::list_of(env::template_folder()+TEXT("CG.fth")));\r
+ auto producer = flash::create_producer(this->GetChannel()->mixer(), boost::assign::list_of(env::template_folder()+TEXT("CG.fth")));\r
\r
std::wstringstream flashParam;\r
flashParam << TEXT("<invoke name=\"Add\" returntype=\"xml\"><arguments><number>1</number><string>") << currentProfile_ << '/' << templateName << TEXT("</string><number>0</number><true/><string> </string><string><![CDATA[ ") << xmlData << TEXT(" ]]></string></arguments></invoke>");\r
\r
if(currentCommand_.command_ == CLKCommand::CLKReset) \r
{\r
- pChannel_->stage()->clear(cg_producer::DEFAULT_LAYER);\r
+ pChannel_->stage()->clear(flash::cg_producer::DEFAULT_LAYER);\r
bClockLoaded_ = false;\r
\r
CASPAR_LOG(info) << L"CLK: Recieved and executed reset-command";\r
{\r
if(!bClockLoaded_) \r
{\r
- get_default_cg_producer(pChannel_)->add(0, TEXT("hawrysklocka/clock.ft"), true, TEXT(""), currentCommand_.GetData());\r
+ flash::get_default_cg_producer(pChannel_)->add(0, TEXT("hawrysklocka/clock.ft"), true, TEXT(""), currentCommand_.GetData());\r
bClockLoaded_ = true;\r
}\r
else \r
- get_default_cg_producer(pChannel_)->update(0, currentCommand_.GetData());\r
+ flash::get_default_cg_producer(pChannel_)->update(0, currentCommand_.GetData());\r
\r
CASPAR_LOG(debug) << L"CLK: Clockdata sent: " << currentCommand_.GetData();\r
CASPAR_LOG(debug) << L"CLK: Executed valid command: " << currentCommandString_.str();\r
<device>1</device>\r
<embedded-audio>true</embedded-audio>\r
</decklink>\r
+ <screen></screen>\r
</consumers>\r
</channel>\r
</channels>\r
CASPAR_LOG(info) << L"on " << caspar::get_win_product_name() << L" " << caspar::get_win_sp_version();\r
CASPAR_LOG(info) << caspar::get_cpu_info();\r
CASPAR_LOG(info) << caspar::get_system_product_name();\r
- CASPAR_LOG(info) << L"Flash " << caspar::get_flash_version();\r
- CASPAR_LOG(info) << L"Flash-Template-Host " << caspar::get_cg_version();\r
- CASPAR_LOG(info) << L"FreeImage " << caspar::get_image_version();\r
+ CASPAR_LOG(info) << L"Flash " << caspar::flash::get_version();\r
+ CASPAR_LOG(info) << L"Flash-Template-Host " << caspar::flash::get_cg_version();\r
+ CASPAR_LOG(info) << L"FreeImage " << caspar::image::get_version();\r
\r
- CASPAR_LOG(info) << L"Decklink " << caspar::get_decklink_version();\r
- auto deck = caspar::get_decklink_device_list();\r
+ CASPAR_LOG(info) << L"Decklink " << caspar::decklink::get_version();\r
+ auto deck = caspar::decklink::get_device_list();\r
std::for_each(deck.begin(), deck.end(), [](const std::wstring& device)\r
{\r
CASPAR_LOG(info) << device;\r
});\r
\r
- auto blue = caspar::get_bluefish_device_list();\r
+ auto blue = caspar::bluefish::get_device_list();\r
std::for_each(blue.begin(), blue.end(), [](const std::wstring& device)\r
{\r
CASPAR_LOG(info) << device;\r
});\r
\r
- CASPAR_LOG(info) << L"FFMPEG-avcodec " << caspar::get_avcodec_version();\r
- CASPAR_LOG(info) << L"FFMPEG-avformat " << caspar::get_avformat_version();\r
- CASPAR_LOG(info) << L"FFMPEG-avfilter " << caspar::get_avfilter_version();\r
- CASPAR_LOG(info) << L"FFMPEG-avutil " << caspar::get_avutil_version();\r
- CASPAR_LOG(info) << L"FFMPEG-swscale " << caspar::get_swscale_version();\r
+ CASPAR_LOG(info) << L"FFMPEG-avcodec " << caspar::ffmpeg::get_avcodec_version();\r
+ CASPAR_LOG(info) << L"FFMPEG-avformat " << caspar::ffmpeg::get_avformat_version();\r
+ CASPAR_LOG(info) << L"FFMPEG-avfilter " << caspar::ffmpeg::get_avfilter_version();\r
+ CASPAR_LOG(info) << L"FFMPEG-avutil " << caspar::ffmpeg::get_avutil_version();\r
+ CASPAR_LOG(info) << L"FFMPEG-swscale " << caspar::ffmpeg::get_swscale_version();\r
CASPAR_LOG(info) << L"OpenGL " << caspar::core::ogl_device::get_version() << "\n\n";\r
}\r
\r
\r
implementation() \r
{ \r
- init_ffmpeg();\r
- init_bluefish();\r
- init_decklink();\r
- init_flash();\r
- init_oal();\r
- init_ogl();\r
+ ffmpeg::init();\r
+ bluefish::init();\r
+ decklink::init();\r
+ flash::init();\r
+ oal::init();\r
+ ogl::init();\r
//init_silverlight();\r
- init_image();\r
+ image::init();\r
\r
setup_channels(env::properties());\r
setup_controllers(env::properties());\r
\r
~implementation()\r
{ \r
- uninit_ffmpeg();\r
+ ffmpeg::uninit();\r
\r
async_servers_.clear();\r
channels_.clear();\r
{\r
const std::string name = xml_consumer.first;\r
if(name == "screen")\r
- channels_.back()->output()->add(index++, create_ogl_consumer(xml_consumer.second)); \r
+ channels_.back()->output()->add(index++, ogl::create_consumer(xml_consumer.second)); \r
else if(name == "bluefish") \r
- channels_.back()->output()->add(index++, create_bluefish_consumer(xml_consumer.second)); \r
+ channels_.back()->output()->add(index++, bluefish::create_consumer(xml_consumer.second)); \r
else if(name == "decklink") \r
- channels_.back()->output()->add(index++, create_decklink_consumer(xml_consumer.second)); \r
+ channels_.back()->output()->add(index++, decklink::create_consumer(xml_consumer.second)); \r
//else if(name == "file") \r
// channels_.back()->output()->add(index++, create_ffmpeg_consumer(xml_consumer.second)); \r
else if(name == "audio")\r
- channels_.back()->output()->add(index++, create_oal_consumer()); \r
+ channels_.back()->output()->add(index++, oal::create_consumer()); \r
else if(name != "<xmlcomment>")\r
CASPAR_LOG(warning) << "Invalid consumer: " << widen(name); \r
}\r