*
* Author: Robert Nagy, ronag89@gmail.com
*/
-
+
#include "../StdAfx.h"
#include "../ffmpeg_error.h"
#include "ffmpeg_consumer.h"
#include "../producer/tbb_avcodec.h"
+#include "../producer/util/util.h"
#include <core/frame/frame.h>
+#include <core/frame/audio_channel_layout.h>
#include <core/mixer/audio/audio_util.h>
#include <core/consumer/frame_consumer.h>
#include <core/video_format.h>
+#include <core/help/help_repository.h>
+#include <core/help/help_sink.h>
#include <common/array.h>
#include <common/env.h>
#include <common/except.h>
#include <common/executor.h>
+#include <common/future.h>
#include <common/diagnostics/graph.h>
#include <common/lock.h>
#include <common/memory.h>
#include <common/param.h>
#include <common/utf.h>
#include <common/assert.h>
+#include <common/memshfl.h>
+#include <common/timer.h>
+#include <common/ptree.h>
#include <boost/algorithm/string.hpp>
-#include <boost/timer.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/filesystem.hpp>
#include <boost/range/algorithm.hpp>
#include <tbb/spin_mutex.h>
#include <numeric>
+#include <cstring>
#if defined(_MSC_VER)
#pragma warning (push)
#pragma warning (disable : 4244)
#endif
-extern "C"
+extern "C"
{
#define __STDC_CONSTANT_MACROS
#define __STDC_LIMIT_MACROS
#endif
namespace caspar { namespace ffmpeg {
-
+
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
{
AVClass* av_class = *(AVClass**)obj;
if((strcmp(name, "pix_fmt") == 0 || strcmp(name, "pixel_format") == 0) && strcmp(av_class->class_name, "AVCodecContext") == 0)
{
- AVCodecContext* c = (AVCodecContext*)obj;
+ AVCodecContext* c = (AVCodecContext*)obj;
auto pix_fmt = av_get_pix_fmt(val);
if(pix_fmt == PIX_FMT_NONE)
- return -1;
+ return -1;
c->pix_fmt = pix_fmt;
return 0;
}
//if((strcmp(name, "r") == 0 || strcmp(name, "frame_rate") == 0) && strcmp(av_class->class_name, "AVCodecContext") == 0)
//{
- // AVCodecContext* c = (AVCodecContext*)obj;
+ // AVCodecContext* c = (AVCodecContext*)obj;
// if(c->codec_type != AVMEDIA_TYPE_VIDEO)
// return -1;
{
}
};
-
+
struct output_format
{
AVOutputFormat* format;
int width;
int height;
- CodecID vcodec;
- CodecID acodec;
+ AVCodecID vcodec;
+ AVCodecID acodec;
int croptop;
int cropbot;
{
return set_opt(o.name, o.value);
});
-
+
if(vcodec == CODEC_ID_NONE && format)
vcodec = format->video_codec;
if(acodec == CODEC_ID_NONE && format)
acodec = format->audio_codec;
-
+
if(vcodec == CODEC_ID_NONE)
vcodec = CODEC_ID_H264;
-
+
if(acodec == CODEC_ID_NONE)
acodec = CODEC_ID_PCM_S16LE;
}
-
+
bool set_opt(const std::string& name, const std::string& value)
{
//if(name == "target")
- //{
+ //{
// enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
- //
+ //
// if(name.find("pal-") != std::string::npos)
// norm = PAL;
// else if(name.find("ntsc-") != std::string::npos)
// if(norm == UNKNOWN)
// CASPAR_THROW_EXCEPTION(invalid_argument() << arg_name_info("target"));
- //
- // if (name.find("-dv") != std::string::npos)
+ //
+ // if (name.find("-dv") != std::string::npos)
// {
// set_opt("f", "dv");
// if(norm == PAL)
// }
// }
// set_opt("s", norm == PAL ? "720x576" : "720x480");
- // }
+ // }
// return true;
//}
- //else
+ //else
if(name == "f")
{
format = av_guess_format(value.c_str(), nullptr, nullptr);
if(format == nullptr)
- CASPAR_THROW_EXCEPTION(invalid_argument() << arg_name_info("f"));
+ CASPAR_THROW_EXCEPTION(user_error() << msg_info("Unknown format " + value));
return true;
}
{
auto c = avcodec_find_encoder_by_name(value.c_str());
if(c == nullptr)
- CASPAR_THROW_EXCEPTION(invalid_argument() << arg_name_info("vcodec"));
+ CASPAR_THROW_EXCEPTION(user_error() << msg_info("Unknown video codec " + value));
vcodec = avcodec_find_encoder_by_name(value.c_str())->id;
return true;
{
auto c = avcodec_find_encoder_by_name(value.c_str());
if(c == nullptr)
- CASPAR_THROW_EXCEPTION(invalid_argument() << arg_name_info("acodec"));
+ CASPAR_THROW_EXCEPTION(user_error() << msg_info("Unknown audio codec " + value));
acodec = avcodec_find_encoder_by_name(value.c_str())->id;
else if(name == "s")
{
if(av_parse_video_size(&width, &height, value.c_str()) < 0)
- CASPAR_THROW_EXCEPTION(invalid_argument() << arg_name_info("s"));
-
+ CASPAR_THROW_EXCEPTION(user_error() << msg_info("Unknown video size " + value));
+
return true;
}
else if(name == "croptop")
return true;
}
-
+
return false;
}
};
-typedef std::vector<uint8_t, tbb::cache_aligned_allocator<uint8_t>> byte_vector;
+typedef cache_aligned_vector<uint8_t> byte_vector;
struct ffmpeg_consumer : boost::noncopyable
-{
+{
const spl::shared_ptr<diagnostics::graph> graph_;
- const std::string filename_;
- const std::shared_ptr<AVFormatContext> oc_;
- const core::video_format_desc format_desc_;
+ const std::string filename_;
+ const std::string full_filename_ = u8(env::media_folder()) + filename_;
+ const std::shared_ptr<AVFormatContext> oc_ { avformat_alloc_context(), avformat_free_context };
+ const core::video_format_desc format_desc_;
+ const core::audio_channel_layout channel_layout_;
+
+ core::monitor::subject monitor_subject_;
- monitor::basic_subject event_subject_;
-
tbb::spin_mutex exception_mutex_;
std::exception_ptr exception_;
-
+
std::shared_ptr<AVStream> audio_st_;
std::shared_ptr<AVStream> video_st_;
-
+
byte_vector picture_buffer_;
+ byte_vector key_picture_buf_;
byte_vector audio_buffer_;
std::shared_ptr<SwrContext> swr_;
std::shared_ptr<SwsContext> sws_;
- int64_t frame_number_;
+ int64_t frame_number_ = 0;
output_format output_format_;
-
+ bool key_only_;
+ tbb::atomic<int64_t> current_encoding_delay_;
+
executor executor_;
public:
- ffmpeg_consumer(const std::string& filename, const core::video_format_desc& format_desc, std::vector<option> options)
+ ffmpeg_consumer(
+ const std::string& filename,
+ const core::video_format_desc& format_desc,
+ const core::audio_channel_layout& channel_layout,
+ std::vector<option> options,
+ bool key_only)
: filename_(filename)
- , oc_(avformat_alloc_context(), av_free)
, format_desc_(format_desc)
- , frame_number_(0)
- , output_format_(format_desc, filename, options)
+ , channel_layout_(channel_layout)
+ , output_format_(format_desc, full_filename_, options)
+ , key_only_(key_only)
, executor_(print())
{
+ current_encoding_delay_ = 0;
check_space();
// TODO: Ask stakeholders about case where file already exists.
- boost::filesystem::remove(boost::filesystem::path(env::media_folder() + u16(filename))); // Delete the file if it exists
+ boost::filesystem::remove(boost::filesystem::path(full_filename_)); // Delete the file if it exists
graph_->set_color("frame-time", diagnostics::color(0.1f, 1.0f, 0.1f));
+ graph_->set_color("dropped-frame", diagnostics::color(0.3f, 0.6f, 0.3f));
graph_->set_text(print());
diagnostics::register_graph(graph_);
executor_.set_capacity(8);
oc_->oformat = output_format_.format;
-
- strcpy_s(oc_->filename, filename_.c_str());
-
+
+ std::strcpy(oc_->filename, full_filename_.c_str());
+
// Add the audio and video streams using the default format codecs and initialize the codecs.
video_st_ = add_video_stream(options);
- audio_st_ = add_audio_stream(options);
-
- av_dump_format(oc_.get(), 0, filename_.c_str(), 1);
-
+
+ if (!key_only)
+ audio_st_ = add_audio_stream(options);
+
+ av_dump_format(oc_.get(), 0, full_filename_.c_str(), 1);
+
// Open the output ffmpeg, if needed.
- if (!(oc_->oformat->flags & AVFMT_NOFILE))
- THROW_ON_ERROR2(avio_open(&oc_->pb, filename.c_str(), AVIO_FLAG_WRITE), "[ffmpeg_consumer]");
-
+ if (!(oc_->oformat->flags & AVFMT_NOFILE))
+ THROW_ON_ERROR2(avio_open(&oc_->pb, full_filename_.c_str(), AVIO_FLAG_WRITE), "[ffmpeg_consumer]");
+
THROW_ON_ERROR2(avformat_write_header(oc_.get(), nullptr), "[ffmpeg_consumer]");
if(options.size() > 0)
{
- BOOST_FOREACH(auto& option, options)
+ for (auto& option : options)
CASPAR_LOG(warning) << L"Invalid option: -" << u16(option.name) << L" " << u16(option.value);
}
-
- CASPAR_LOG(info) << print() << L" Successfully Initialized.";
}
~ffmpeg_consumer()
- {
+ {
try
{
executor_.wait();
}
LOG_ON_ERROR2(av_write_trailer(oc_.get()), "[ffmpeg_consumer]");
-
- audio_st_.reset();
+
+ if (!key_only_)
+ audio_st_.reset();
+
video_st_.reset();
-
- if (!(oc_->oformat->flags & AVFMT_NOFILE))
- LOG_ON_ERROR2(avio_close(oc_->pb), "[ffmpeg_consumer]");
- CASPAR_LOG(info) << print() << L" Successfully Uninitialized.";
+ if (!(oc_->oformat->flags & AVFMT_NOFILE))
+ LOG_ON_ERROR2(avio_close(oc_->pb), "[ffmpeg_consumer]");
}
-
+
// frame_consumer
- bool send(core::const_frame& frame)
+ void send(core::const_frame& frame)
{
auto exception = lock(exception_mutex_, [&]
{
if(exception != nullptr)
std::rethrow_exception(exception);
-
+
executor_.begin_invoke([=]
- {
+ {
encode(frame);
+ current_encoding_delay_ = frame.get_age_millis();
});
-
- return true;
}
- std::wstring print() const
+ bool ready_for_frame() const
{
- return L"ffmpeg[" + u16(filename_) + L"]";
+ return !executor_.is_full();
}
-
- void subscribe(const monitor::observable::observer_ptr& o)
+
+ void mark_dropped()
+ {
+ graph_->set_tag(diagnostics::tag_severity::WARNING, "dropped-frame");
+ }
+
+ std::wstring print() const
{
- event_subject_.subscribe(o);
+ return L"ffmpeg[" + u16(filename_) + L"]";
}
- void unsubscribe(const monitor::observable::observer_ptr& o)
+ core::monitor::subject& monitor_output()
{
- event_subject_.unsubscribe(o);
- }
+ return monitor_subject_;
+ }
private:
std::shared_ptr<AVStream> add_video_stream(std::vector<option>& options)
- {
+ {
if(output_format_.vcodec == CODEC_ID_NONE)
return nullptr;
- auto st = av_new_stream(oc_.get(), 0);
- if (!st)
- CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("Could not allocate video-stream.") << boost::errinfo_api_function("av_new_stream"));
+ auto st = avformat_new_stream(oc_.get(), 0);
+ if (!st)
+ CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("Could not allocate video-stream.") << boost::errinfo_api_function("av_new_stream"));
auto encoder = avcodec_find_encoder(output_format_.vcodec);
if (!encoder)
auto c = st->codec;
avcodec_get_context_defaults3(c, encoder);
-
+
c->codec_id = output_format_.vcodec;
c->codec_type = AVMEDIA_TYPE_VIDEO;
c->width = output_format_.width;
c->pix_fmt = c->pix_fmt != PIX_FMT_NONE ? c->pix_fmt : PIX_FMT_YUV420P;
if(c->codec_id == CODEC_ID_PRORES)
- {
+ {
c->bit_rate = output_format_.width < 1280 ? 63*1000000 : 220*1000000;
c->pix_fmt = PIX_FMT_YUV422P10;
}
else if(c->codec_id == CODEC_ID_DVVIDEO)
{
c->width = c->height == 1280 ? 960 : c->width;
-
+
if(format_desc_.format == core::video_format::ntsc)
{
c->pix_fmt = PIX_FMT_YUV411P;
c->pix_fmt = PIX_FMT_YUV420P;
else // dv50
c->pix_fmt = PIX_FMT_YUV422P;
-
- if(format_desc_.duration == 1001)
- c->width = c->height == 1080 ? 1280 : c->width;
+
+ if(format_desc_.duration == 1001)
+ c->width = c->height == 1080 ? 1280 : c->width;
else
- c->width = c->height == 1080 ? 1440 : c->width;
+ c->width = c->height == 1080 ? 1440 : c->width;
}
else if(c->codec_id == CODEC_ID_H264)
- {
- c->pix_fmt = PIX_FMT_YUV420P;
+ {
+ c->pix_fmt = PIX_FMT_YUV420P;
av_opt_set(c->priv_data, "preset", "ultrafast", 0);
av_opt_set(c->priv_data, "tune", "fastdecode", 0);
av_opt_set(c->priv_data, "crf", "5", 0);
{
c->pix_fmt = PIX_FMT_ARGB;
}
-
+
boost::range::remove_erase_if(options, [&](const option& o)
{
return o.name.at(0) != 'a' && ffmpeg::av_opt_set(c, o.name.c_str(), o.value.c_str(), AV_OPT_SEARCH_CHILDREN) > -1;
});
-
+
if(output_format_.format->flags & AVFMT_GLOBALHEADER)
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
-
- THROW_ON_ERROR2(tbb_avcodec_open(c, encoder), "[ffmpeg_consumer]");
+
+ THROW_ON_ERROR2(tbb_avcodec_open(c, encoder, false), "[ffmpeg_consumer]");
return std::shared_ptr<AVStream>(st, [](AVStream* st)
{
LOG_ON_ERROR2(tbb_avcodec_close(st->codec), "[ffmpeg_consumer]");
- av_freep(&st->codec);
- av_freep(&st);
});
}
-
+
std::shared_ptr<AVStream> add_audio_stream(std::vector<option>& options)
{
if(output_format_.acodec == CODEC_ID_NONE)
return nullptr;
- auto st = av_new_stream(oc_.get(), 1);
+ auto st = avformat_new_stream(oc_.get(), nullptr);
if(!st)
- CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("Could not allocate audio-stream") << boost::errinfo_api_function("av_new_stream"));
-
+ CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("Could not allocate audio-stream") << boost::errinfo_api_function("av_new_stream"));
+
auto encoder = avcodec_find_encoder(output_format_.acodec);
if (!encoder)
CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("codec not found"));
-
+
auto c = st->codec;
avcodec_get_context_defaults3(c, encoder);
c->time_base.num = 1;
c->time_base.den = c->sample_rate;
- if(output_format_.vcodec == CODEC_ID_FLV1)
- c->sample_rate = 44100;
+ if(output_format_.vcodec == CODEC_ID_FLV1)
+ c->sample_rate = 44100;
if(output_format_.format->flags & AVFMT_GLOBALHEADER)
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
-
+
boost::range::remove_erase_if(options, [&](const option& o)
{
return ffmpeg::av_opt_set(c, o.name.c_str(), o.value.c_str(), AV_OPT_SEARCH_CHILDREN) > -1;
});
- THROW_ON_ERROR2(avcodec_open(c, encoder), "[ffmpeg_consumer]");
+ THROW_ON_ERROR2(avcodec_open2(c, encoder, nullptr), "[ffmpeg_consumer]");
return std::shared_ptr<AVStream>(st, [](AVStream* st)
{
- LOG_ON_ERROR2(avcodec_close(st->codec), "[ffmpeg_consumer]");;
- av_freep(&st->codec);
- av_freep(&st);
+ LOG_ON_ERROR2(avcodec_close(st->codec), "[ffmpeg_consumer]");
});
}
-
+
void encode_video_frame(core::const_frame frame)
- {
+ {
if(!video_st_)
return;
-
+
auto enc = video_st_->codec;
-
+
auto av_frame = convert_video(frame, enc);
av_frame->interlaced_frame = format_desc_.field_mode != core::field_mode::progressive;
av_frame->top_field_first = format_desc_.field_mode == core::field_mode::upper;
- av_frame->pts = frame_number_++;
+ av_frame->pts = frame_number_++;
- event_subject_ << monitor::event("frame") % static_cast<int64_t>(frame_number_)
- % static_cast<int64_t>(std::numeric_limits<int64_t>::max());
+ monitor_subject_
+ << core::monitor::message("/frame") % static_cast<int64_t>(frame_number_)
+ << core::monitor::message("/path") % filename_
+ << core::monitor::message("/fps") % format_desc_.fps;
AVPacket pkt;
av_init_packet(&pkt);
if(!got_packet)
return;
-
+
if (pkt.pts != AV_NOPTS_VALUE)
pkt.pts = av_rescale_q(pkt.pts, enc->time_base, video_st_->time_base);
if (pkt.dts != AV_NOPTS_VALUE)
pkt.dts = av_rescale_q(pkt.dts, enc->time_base, video_st_->time_base);
-
+
pkt.stream_index = video_st_->index;
-
+
THROW_ON_ERROR2(av_interleaved_write_frame(oc_.get(), &pkt), "[ffmpeg_consumer]");
}
-
+
uint64_t get_channel_layout(AVCodecContext* dec)
{
auto layout = (dec->channel_layout && dec->channels == av_get_channel_layout_nb_channels(dec->channel_layout)) ? dec->channel_layout : av_get_default_channel_layout(dec->channels);
return layout;
}
-
+
void encode_audio_frame(core::const_frame frame)
- {
+ {
if(!audio_st_)
return;
-
+
auto enc = audio_st_->codec;
boost::push_back(audio_buffer_, convert_audio(frame, enc));
-
+
auto frame_size = enc->frame_size != 0 ? enc->frame_size * enc->channels * av_get_bytes_per_sample(enc->sample_fmt) : static_cast<int>(audio_buffer_.size());
-
+
while(audio_buffer_.size() >= frame_size)
- {
- std::shared_ptr<AVFrame> av_frame(avcodec_alloc_frame(), av_free);
- avcodec_get_frame_defaults(av_frame.get());
+ {
+ auto av_frame = create_frame();
av_frame->nb_samples = frame_size / (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
AVPacket pkt;
av_init_packet(&pkt);
pkt.data = nullptr;
- pkt.size = 0;
-
+ pkt.size = 0;
+
THROW_ON_ERROR2(avcodec_fill_audio_frame(av_frame.get(), enc->channels, enc->sample_fmt, audio_buffer_.data(), frame_size, 1), "[ffmpeg_consumer]");
int got_packet = 0;
THROW_ON_ERROR2(avcodec_encode_audio2(enc, &pkt, av_frame.get(), &got_packet), "[ffmpeg_consumer]");
std::shared_ptr<AVPacket> guard(&pkt, av_free_packet);
-
+
audio_buffer_.erase(audio_buffer_.begin(), audio_buffer_.begin() + frame_size);
if(!got_packet)
return;
-
+
if (pkt.pts != AV_NOPTS_VALUE)
pkt.pts = av_rescale_q(pkt.pts, enc->time_base, audio_st_->time_base);
if (pkt.dts != AV_NOPTS_VALUE)
pkt.dts = av_rescale_q(pkt.dts, enc->time_base, audio_st_->time_base);
if (pkt.duration > 0)
pkt.duration = static_cast<int>(av_rescale_q(pkt.duration, enc->time_base, audio_st_->time_base));
-
+
pkt.stream_index = audio_st_->index;
-
+
THROW_ON_ERROR2(av_interleaved_write_frame(oc_.get(), &pkt), "[ffmpeg_consumer]");
}
- }
-
+ }
+
std::shared_ptr<AVFrame> convert_video(core::const_frame frame, AVCodecContext* c)
{
- if(!sws_)
+ if(!sws_)
{
- sws_.reset(sws_getContext(format_desc_.width,
- format_desc_.height - output_format_.croptop - output_format_.cropbot,
+ sws_.reset(sws_getContext(format_desc_.width,
+ format_desc_.height - output_format_.croptop - output_format_.cropbot,
PIX_FMT_BGRA,
c->width,
- c->height,
- c->pix_fmt,
- SWS_BICUBIC, nullptr, nullptr, nullptr),
+ c->height,
+ c->pix_fmt,
+ SWS_BICUBIC, nullptr, nullptr, nullptr),
sws_freeContext);
- if (sws_ == nullptr)
+ if (sws_ == nullptr)
CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("Cannot initialize the conversion context"));
}
std::shared_ptr<AVFrame> in_frame(avcodec_alloc_frame(), av_free);
- avpicture_fill(reinterpret_cast<AVPicture*>(in_frame.get()),
- const_cast<uint8_t*>(frame.image_data().begin()),
- PIX_FMT_BGRA,
- format_desc_.width,
- format_desc_.height - output_format_.croptop - output_format_.cropbot);
+ auto in_picture = reinterpret_cast<AVPicture*>(in_frame.get());
+
+ if (key_only_)
+ {
+ key_picture_buf_.resize(frame.image_data().size());
+ in_picture->linesize[0] = format_desc_.width * 4;
+ in_picture->data[0] = key_picture_buf_.data();
+
+ aligned_memshfl(in_picture->data[0], frame.image_data().begin(), frame.image_data().size(), 0x0F0F0F0F, 0x0B0B0B0B, 0x07070707, 0x03030303);
+ }
+ else
+ {
+ avpicture_fill(
+ in_picture,
+ const_cast<uint8_t*>(frame.image_data().begin()),
+ PIX_FMT_BGRA,
+ format_desc_.width,
+ format_desc_.height - output_format_.croptop - output_format_.cropbot);
+ }
+
// crop-top
- for(int n = 0; n < 4; ++n)
- in_frame->data[n] += in_frame->linesize[n] * output_format_.croptop;
-
+ for(int n = 0; n < 4; ++n)
+ in_frame->data[n] += in_frame->linesize[n] * output_format_.croptop;
+
// #out_frame
std::shared_ptr<AVFrame> out_frame(avcodec_alloc_frame(), av_free);
-
+
av_image_fill_linesizes(out_frame->linesize, c->pix_fmt, c->width);
for(int n = 0; n < 4; ++n)
out_frame->linesize[n] += 32 - (out_frame->linesize[n] % 32); // align
picture_buffer_.resize(av_image_fill_pointers(out_frame->data, c->pix_fmt, c->height, nullptr, out_frame->linesize));
av_image_fill_pointers(out_frame->data, c->pix_fmt, c->height, picture_buffer_.data(), out_frame->linesize);
-
+
// #scale
- sws_scale(sws_.get(),
- in_frame->data,
+ sws_scale(sws_.get(),
+ in_frame->data,
in_frame->linesize,
- 0,
- format_desc_.height - output_format_.cropbot - output_format_.croptop,
- out_frame->data,
+ 0,
+ format_desc_.height - output_format_.cropbot - output_format_.croptop,
+ out_frame->data,
out_frame->linesize);
+ out_frame->format = c->pix_fmt;
+ out_frame->width = c->width;
+ out_frame->height = c->height;
+
return out_frame;
}
-
+
byte_vector convert_audio(core::const_frame& frame, AVCodecContext* c)
{
- if(!swr_)
+ if(!swr_)
{
swr_ = std::shared_ptr<SwrContext>(swr_alloc_set_opts(nullptr,
get_channel_layout(c), c->sample_fmt, c->sample_rate,
- av_get_default_channel_layout(format_desc_.audio_channels), AV_SAMPLE_FMT_S32, format_desc_.audio_sample_rate,
+ av_get_default_channel_layout(channel_layout_.num_channels), AV_SAMPLE_FMT_S32, format_desc_.audio_sample_rate,
0, nullptr), [](SwrContext* p){swr_free(&p);});
if(!swr_)
THROW_ON_ERROR2(swr_init(swr_.get()), "[audio_decoder]");
}
-
+
byte_vector buffer(48000);
const uint8_t* in[] = {reinterpret_cast<const uint8_t*>(frame.audio_data().data())};
uint8_t* out[] = {buffer.data()};
- auto channel_samples = swr_convert(swr_.get(),
- out, static_cast<int>(buffer.size()) / c->channels / av_get_bytes_per_sample(c->sample_fmt),
- in, static_cast<int>(frame.audio_data().size()/format_desc_.audio_channels));
+ auto channel_samples = swr_convert(swr_.get(),
+ out, static_cast<int>(buffer.size()) / c->channels / av_get_bytes_per_sample(c->sample_fmt),
+ in, static_cast<int>(frame.audio_data().size()/channel_layout_.num_channels));
- buffer.resize(channel_samples * c->channels * av_get_bytes_per_sample(c->sample_fmt));
+ buffer.resize(channel_samples * c->channels * av_get_bytes_per_sample(c->sample_fmt));
return buffer;
}
void check_space()
{
- auto space = boost::filesystem::space(boost::filesystem::path(filename_).parent_path());
+ auto space = boost::filesystem::space(boost::filesystem::path(full_filename_).parent_path());
if(space.available < 512*1000000)
- BOOST_THROW_EXCEPTION(file_write_error() << msg_info("out of space"));
+ CASPAR_THROW_EXCEPTION(file_write_error() << msg_info("out of space"));
}
void encode(const core::const_frame& frame)
if(frame_number_ % 25 == 0)
check_space();
- boost::timer frame_timer;
+ caspar::timer frame_timer;
encode_video_frame(frame);
encode_audio_frame(frame);
graph_->set_value("frame-time", frame_timer.elapsed()*format_desc_.fps*0.5);
}
catch(...)
- {
+ {
lock(exception_mutex_, [&]
{
exception_ = std::current_exception();
struct ffmpeg_consumer_proxy : public core::frame_consumer
{
- const std::wstring filename_;
- const std::vector<option> options_;
+ const std::wstring filename_;
+ const std::vector<option> options_;
+ const bool separate_key_;
std::unique_ptr<ffmpeg_consumer> consumer_;
+ std::unique_ptr<ffmpeg_consumer> key_only_consumer_;
public:
- ffmpeg_consumer_proxy(const std::wstring& filename, const std::vector<option>& options)
+ ffmpeg_consumer_proxy(const std::wstring& filename, const std::vector<option>& options, bool separate_key)
: filename_(filename)
, options_(options)
+ , separate_key_(separate_key)
{
}
-
- virtual void initialize(const core::video_format_desc& format_desc, int)
+
+ void initialize(const core::video_format_desc& format_desc, const core::audio_channel_layout& channel_layout, int) override
{
if(consumer_)
- BOOST_THROW_EXCEPTION(invalid_operation() << msg_info("Cannot reinitialize ffmpeg-consumer."));
+ CASPAR_THROW_EXCEPTION(invalid_operation() << msg_info("Cannot reinitialize ffmpeg-consumer."));
+
+ consumer_.reset(new ffmpeg_consumer(u8(filename_), format_desc, channel_layout, options_, false));
- consumer_.reset(new ffmpeg_consumer(u8(filename_), format_desc, options_));
+ if (separate_key_)
+ {
+ boost::filesystem::path fill_file(filename_);
+ auto without_extension = u16(fill_file.stem().string());
+ auto key_file = without_extension + L"_A" + u16(fill_file.extension().string());
+
+ key_only_consumer_.reset(new ffmpeg_consumer(u8(key_file), format_desc, channel_layout, options_, true));
+ }
}
-
- bool send(core::const_frame frame) override
+
+ int64_t presentation_frame_age_millis() const override
{
- return consumer_->send(frame);
+ return consumer_ ? static_cast<int64_t>(consumer_->current_encoding_delay_) : 0;
}
-
+
+ std::future<bool> send(core::const_frame frame) override
+ {
+ bool ready_for_frame = consumer_->ready_for_frame();
+
+ if (ready_for_frame && separate_key_)
+ ready_for_frame = ready_for_frame && key_only_consumer_->ready_for_frame();
+
+ if (ready_for_frame)
+ {
+ consumer_->send(frame);
+
+ if (separate_key_)
+ key_only_consumer_->send(frame);
+ }
+ else
+ {
+ consumer_->mark_dropped();
+
+ if (separate_key_)
+ key_only_consumer_->mark_dropped();
+ }
+
+ return make_ready_future(true);
+ }
+
std::wstring print() const override
{
return consumer_ ? consumer_->print() : L"[ffmpeg_consumer]";
boost::property_tree::wptree info;
info.add(L"type", L"file");
info.add(L"filename", filename_);
+ info.add(L"separate_key", separate_key_);
return info;
}
-
+
bool has_synchronization_clock() const override
{
return false;
int buffer_depth() const override
{
- return 1;
+ return -1;
}
int index() const override
return 200;
}
- void subscribe(const monitor::observable::observer_ptr& o) override
+ core::monitor::subject& monitor_output()
{
- consumer_->subscribe(o);
+ return consumer_->monitor_output();
}
+};
- void unsubscribe(const monitor::observable::observer_ptr& o) override
- {
- consumer_->unsubscribe(o);
- }
-};
-spl::shared_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params)
+void describe_consumer(core::help_sink& sink, const core::help_repository& repo)
+{
+ sink.short_description(L"Can record a channel to a file supported by FFmpeg.");
+ sink.syntax(L"FILE [filename:string] {-[ffmpeg_param1:string] [value1:string] {-[ffmpeg_param2:string] [value2:string] {...}}} {[separate_key:SEPARATE_KEY]}");
+ sink.para()->text(L"Can record a channel to a file supported by FFmpeg.");
+ sink.definitions()
+ ->item(L"filename", L"The filename under the media folder including the extension (decides which kind of container format that will be used).")
+ ->item(L"ffmpeg_paramX", L"A parameter supported by FFmpeg. For example vcodec or acodec etc.")
+ ->item(L"separate_key", L"If defined will create two files simultaneously -- One for fill and one for key (_A will be appended).")
+ ;
+ sink.para()->text(L"Examples:");
+ sink.example(L">> ADD 1 FILE output.mov -vcodec dnxhd");
+ sink.example(L">> ADD 1 FILE output.mov -vcodec prores");
+ sink.example(L">> ADD 1 FILE output.mov -vcodec dvvideo");
+ sink.example(L">> ADD 1 FILE output.mov -vcodec libx264 -preset ultrafast -tune fastdecode -crf 25");
+ sink.example(L">> ADD 1 FILE output.mov -vcodec dnxhd SEPARATE_KEY", L"for creating output.mov with fill and output_A.mov with key/alpha");
+}
+
+spl::shared_ptr<core::frame_consumer> create_consumer(
+ const std::vector<std::wstring>& params, core::interaction_sink*)
{
- auto str = std::accumulate(params.begin(), params.end(), std::wstring(), [](const std::wstring& lhs, const std::wstring& rhs) {return lhs + L" " + rhs;});
-
- boost::wregex path_exp(L"\\s*FILE(\\s(?<PATH>.+\\.[^\\s]+))?.*", boost::regex::icase);
+ auto params2 = params;
+ auto separate_key_it = std::find_if(params2.begin(), params2.end(), param_comparer(L"SEPARATE_KEY"));
+ bool separate_key = false;
+
+ if (separate_key_it != params2.end())
+ {
+ separate_key = true;
+ params2.erase(separate_key_it);
+ }
+
+ auto str = std::accumulate(params2.begin(), params2.end(), std::wstring(), [](const std::wstring& lhs, const std::wstring& rhs) {return lhs + L" " + rhs;});
+
+ boost::wregex path_exp(LR"(\s*FILE(\s(?<PATH>.+\.[^\s]+))?.*)", boost::regex::icase);
boost::wsmatch path;
if(!boost::regex_match(str, path, path_exp))
return core::frame_consumer::empty();
-
- boost::wregex opt_exp(L"-((?<NAME>[^\\s]+)\\s+(?<VALUE>[^\\s]+))");
-
+
+ boost::wregex opt_exp(LR"(-((?<NAME>[^\s]+)\s+(?<VALUE>[^\s]+)))");
+
std::vector<option> options;
for(boost::wsregex_iterator it(str.begin(), str.end(), opt_exp); it != boost::wsregex_iterator(); ++it)
{
auto name = u8(boost::trim_copy(boost::to_lower_copy((*it)["NAME"].str())));
auto value = u8(boost::trim_copy(boost::to_lower_copy((*it)["VALUE"].str())));
-
+
if(value == "h264")
value = "libx264";
else if(value == "dvcpro")
options.push_back(option(name, value));
}
-
- return spl::make_shared<ffmpeg_consumer_proxy>(env::media_folder() + path["PATH"].str(), options);
+
+ return spl::make_shared<ffmpeg_consumer_proxy>(path["PATH"].str(), options, separate_key);
}
-spl::shared_ptr<core::frame_consumer> create_consumer(const boost::property_tree::wptree& ptree)
+spl::shared_ptr<core::frame_consumer> create_preconfigured_consumer(
+ const boost::property_tree::wptree& ptree, core::interaction_sink*)
{
- auto filename = ptree.get<std::wstring>(L"path");
- auto codec = ptree.get(L"vcodec", L"libx264");
+ auto filename = ptree_get<std::wstring>(ptree, L"path");
+ auto codec = ptree.get(L"vcodec", L"libx264");
+ auto separate_key = ptree.get(L"separate-key", false);
std::vector<option> options;
options.push_back(option("vcodec", u8(codec)));
-
- return spl::make_shared<ffmpeg_consumer_proxy>(env::media_folder() + filename, options);
+
+ return spl::make_shared<ffmpeg_consumer_proxy>(filename, options, separate_key);
}
}}
projects / casparcg / blobdiff