void Utility::FilterApplier::initFilters() {
int ret=0;
filterGraph_=avfilter_graph_alloc();
if(!filterGraph_) {
throw std::runtime_error("Could not create filtergraph");
}
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
std::string args="video_size="+std::to_string(width_)+"x"+std::to_string(
height_)+":pix_fmt="+std::to_string(pixelFormat_)+":time_base=1/1";
ret=avfilter_graph_create_filter(&buffersourceContext_, buffersrc, "in",args.c_str(), NULL,
filterGraph_);
if(ret<0) {
throw std::runtime_error("Could not create the buffersource for the filtergraph.");
}
ret = avfilter_graph_create_filter(&buffersinkContext_, buffersink, "out",NULL, NULL, filterGraph_);
if(ret<0) {
throw std::runtime_error("Could not create the buffersink for the filtergraph.");
}
enum AVPixelFormat pixelFormats[]= {AV_PIX_FMT_RGB24,AV_PIX_FMT_NONE};
ret = av_opt_set_int_list(buffersinkContext_, "pix_fmts", pixelFormats,AV_PIX_FMT_NONE,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
throw std::runtime_error("Could net set output pixelformat for the graph");
}
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersourceContext_;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersinkContext_;
inputs->pad_idx = 0;
inputs->next = NULL;
ret = avfilter_graph_parse_ptr(filterGraph_, filterDescription_.c_str(), &inputs, &outputs, NULL);
if(ret<0) {
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
throw std::runtime_error("Could not parse the filter descritopns.");
}
ret = avfilter_graph_config(filterGraph_, NULL);
if(ret<0) {
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
throw std::runtime_error("Could not configure filtergraph.");
}
}
bool setup() {
avfilter_graph_free(&filter_graph);
filter_graph = avfilter_graph_alloc();
//QString sws_flags_str;
QString buffersrc_args = QString("video_size=%1x%2:pix_fmt=%3:time_base=%4/%5:sar=1")
.arg(width).arg(height).arg(pixfmt).arg(1).arg(AV_TIME_BASE);
qDebug("buffersrc_args=%s", buffersrc_args.toUtf8().constData());
AVFilter *buffersrc = avfilter_get_by_name("buffer");
Q_ASSERT(buffersrc);
int ret = avfilter_graph_create_filter(&in_filter_ctx,
buffersrc,
"in", buffersrc_args.toUtf8().constData(), NULL,
filter_graph);
if (ret < 0) {
qWarning("Can not create buffer source: %s", av_err2str(ret));
return false;
}
/* buffer video sink: to terminate the filter chain. */
AVFilter *buffersink = avfilter_get_by_name("buffersink");
Q_ASSERT(buffersink);
if ((ret = avfilter_graph_create_filter(&out_filter_ctx, buffersink, "out",
NULL, NULL, filter_graph)) < 0) {
qWarning("Can not create buffer sink: %s", av_err2str(ret));
return false;
}
/* Endpoints for the filter graph. */
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
outputs->name = av_strdup("in");
outputs->filter_ctx = in_filter_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = out_filter_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
//avfilter_graph_parse, avfilter_graph_parse2?
if ((ret = avfilter_graph_parse_ptr(filter_graph, options.toUtf8().constData(),
&inputs, &outputs, NULL)) < 0) {
qWarning("avfilter_graph_parse_ptr fail: %s", av_err2str(ret));
avfilter_inout_free(&outputs);
avfilter_inout_free(&inputs);
return false;
}
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0) {
qWarning("avfilter_graph_config fail: %s", av_err2str(ret));
avfilter_inout_free(&outputs);
avfilter_inout_free(&inputs);
return false;
}
avfilter_inout_free(&outputs);
avfilter_inout_free(&inputs);
avframe = av_frame_alloc();
return true;
}
static int init_filters(const char *filters_descr)
{
char args[512];
int ret;
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
AVBufferSinkParams *buffersink_params;
filter_graph = avfilter_graph_alloc();
/* buffer video source: the decoded frames from the decoder will be inserted here. */
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
dec_ctx->time_base.num, dec_ctx->time_base.den,
dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
return ret;
}
/* buffer video sink: to terminate the filter chain. */
buffersink_params = av_buffersink_params_alloc();
buffersink_params->pixel_fmts = pix_fmts;
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, buffersink_params, filter_graph);
av_free(buffersink_params);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
return ret;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
&inputs, &outputs, NULL)) < 0)
return ret;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
return ret;
return 0;
}
int CDVDVideoCodecFFmpeg::FilterOpen(const std::string& filters, bool scale)
{
int result;
if (m_pFilterGraph)
FilterClose();
if (filters.empty() && !scale)
return 0;
if (m_pHardware)
{
CLog::Log(LOGWARNING, "CDVDVideoCodecFFmpeg::FilterOpen - skipped opening filters on hardware decode");
return 0;
}
if (!(m_pFilterGraph = avfilter_graph_alloc()))
{
CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - unable to alloc filter graph");
return -1;
}
AVFilter* srcFilter = avfilter_get_by_name("buffer");
AVFilter* outFilter = avfilter_get_by_name("buffersink"); // should be last filter in the graph for now
std::string args = StringUtils::Format("%d:%d:%d:%d:%d:%d:%d",
m_pCodecContext->width,
m_pCodecContext->height,
m_pCodecContext->pix_fmt,
m_pCodecContext->time_base.num ? m_pCodecContext->time_base.num : 1,
m_pCodecContext->time_base.num ? m_pCodecContext->time_base.den : 1,
m_pCodecContext->sample_aspect_ratio.num != 0 ? m_pCodecContext->sample_aspect_ratio.num : 1,
m_pCodecContext->sample_aspect_ratio.num != 0 ? m_pCodecContext->sample_aspect_ratio.den : 1);
if ((result = avfilter_graph_create_filter(&m_pFilterIn, srcFilter, "src", args.c_str(), NULL, m_pFilterGraph)) < 0)
{
CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_graph_create_filter: src");
return result;
}
if ((result = avfilter_graph_create_filter(&m_pFilterOut, outFilter, "out", NULL, NULL, m_pFilterGraph)) < 0)
{
CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_graph_create_filter: out");
return result;
}
if ((result = av_opt_set_int_list(m_pFilterOut, "pix_fmts", &m_formats[0], AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
{
CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - failed settings pix formats");
return result;
}
if (!filters.empty())
{
AVFilterInOut* outputs = avfilter_inout_alloc();
AVFilterInOut* inputs = avfilter_inout_alloc();
outputs->name = av_strdup("in");
outputs->filter_ctx = m_pFilterIn;
outputs->pad_idx = 0;
outputs->next = nullptr;
inputs->name = av_strdup("out");
inputs->filter_ctx = m_pFilterOut;
inputs->pad_idx = 0;
inputs->next = nullptr;
if ((result = avfilter_graph_parse_ptr(m_pFilterGraph, (const char*)m_filters.c_str(), &inputs, &outputs, NULL)) < 0)
{
CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_graph_parse");
return result;
}
avfilter_inout_free(&outputs);
avfilter_inout_free(&inputs);
}
else
{
if ((result = avfilter_link(m_pFilterIn, 0, m_pFilterOut, 0)) < 0)
{
CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_link");
return result;
}
}
if ((result = avfilter_graph_config(m_pFilterGraph, nullptr)) < 0)
{
CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_graph_config");
return result;
}
m_filterEof = false;
return result;
}
static int init_filters(const char *filters_descr)
{
char args[512];
int ret = 0;
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
AVRational time_base = fmt_ctx->streams[video_stream_index]->time_base;
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
filter_graph = avfilter_graph_alloc();
if (!outputs || !inputs || !filter_graph) {
ret = AVERROR(ENOMEM);
goto end;
}
/* buffer video source: the decoded frames from the decoder will be inserted here. */
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
time_base.num, time_base.den,
dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
goto end;
}
/* buffer video sink: to terminate the filter chain. */
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,
AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
goto end;
}
/*
* Set the endpoints for the filter graph. The filter_graph will
* be linked to the graph described by filters_descr.
*/
/*
* The buffer source output must be connected to the input pad of
* the first filter described by filters_descr; since the first
* filter input label is not specified, it is set to "in" by
* default.
*/
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
/*
* The buffer sink input must be connected to the output pad of
* the last filter described by filters_descr; since the last
* filter output label is not specified, it is set to "out" by
* default.
*/
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
&inputs, &outputs, NULL)) < 0)
goto end;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
goto end;
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}
static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
AVCodecContext *enc_ctx, const char *filter_spec)
{
char args[512];
int ret = 0;
AVFilter *bufferSrc = NULL;
AVFilter *bufferSink = NULL;
AVFilterContext* bufferSrcCtx = NULL;
AVFilterContext* bufferSinkCtx = NULL;
AVFilterInOut* outputs = avfilter_inout_alloc();
AVFilterInOut* inputs = avfilter_inout_alloc();
AVFilterGraph* filterGraph = avfilter_graph_alloc();
if (!outputs || !inputs || !filterGraph) {
ret = AVERROR(ENOMEM);
goto end;
}
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
bufferSrc = avfilter_get_by_name("buffer");
bufferSink = avfilter_get_by_name("buffersink");
if (!bufferSrc || !bufferSink) {
av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
ret = AVERROR_UNKNOWN;
goto end;
}
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
dec_ctx->time_base.num, dec_ctx->time_base.den,
dec_ctx->sample_aspect_ratio.num,
dec_ctx->sample_aspect_ratio.den);
ret = avfilter_graph_create_filter(&bufferSrcCtx, bufferSrc, "in",
args, NULL, filterGraph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
goto end;
}
ret = avfilter_graph_create_filter(&bufferSinkCtx, bufferSink, "out",
NULL, NULL, filterGraph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
goto end;
}
ret = av_opt_set_bin(bufferSinkCtx, "pix_fmts",
(uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
goto end;
}
}
else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
bufferSrc = avfilter_get_by_name("abuffer");
bufferSink = avfilter_get_by_name("abuffersink");
if (!bufferSrc || !bufferSink) {
av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
ret = AVERROR_UNKNOWN;
goto end;
}
if (!dec_ctx->channel_layout) {
dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);
}
snprintf(args, sizeof(args),
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,
av_get_sample_fmt_name(dec_ctx->sample_fmt),
dec_ctx->channel_layout);
ret = avfilter_graph_create_filter(&bufferSrcCtx, bufferSrc, "in", args, NULL, filterGraph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
goto end;
}
ret = avfilter_graph_create_filter(&bufferSinkCtx, bufferSink, "out", NULL, NULL, filterGraph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
goto end;
}
ret = av_opt_set_bin(bufferSinkCtx, "sample_fmts", (uint8_t*)&enc_ctx->sample_fmt,
sizeof(enc_ctx->sample_fmt), AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
goto end;
}
ret = av_opt_set_bin(bufferSinkCtx, "channel_layouts", (uint8_t*)&enc_ctx->channel_layout,
sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
goto end;
}
ret = av_opt_set_bin(bufferSinkCtx, "sample_rates", (uint8_t*)&enc_ctx->sample_rate,
sizeof(enc_ctx->sample_rate), AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
goto end;
}
}
else {
ret = AVERROR_UNKNOWN;
goto end;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = bufferSrcCtx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = bufferSinkCtx;
inputs->pad_idx = 0;
inputs->next = NULL;
if (!outputs->name || !inputs->name) {
ret = AVERROR(ENOMEM);
goto end;
}
if ((ret = avfilter_graph_parse_ptr(filterGraph, filter_spec,
&inputs, &outputs, NULL)) < 0)
goto end;
if ((ret = avfilter_graph_config(filterGraph, NULL)) < 0)
goto end;
/* Fill FilteringContext */
fctx->BuffersrcCtx = bufferSrcCtx;
fctx->BuffersinkCtx = bufferSinkCtx;
fctx->FilterGraph = filterGraph;
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}
int main(int argc, char **argv)
{
char *in_graph_desc, **out_dev_name;
int nb_out_dev = 0, nb_streams = 0;
AVFilterGraph *in_graph = NULL;
Stream *streams = NULL, *st;
AVFrame *frame = NULL;
int i, j, run = 1, ret;
//av_log_set_level(AV_LOG_DEBUG);
if (argc < 3) {
av_log(NULL, AV_LOG_ERROR,
"Usage: %s filter_graph dev:out [dev2:out2...]\n\n"
"Examples:\n"
"%s movie=file.nut:s=v+a xv:- alsa:default\n"
"%s movie=file.nut:s=v+a uncodedframecrc:pipe:0\n",
argv[0], argv[0], argv[0]);
exit(1);
}
in_graph_desc = argv[1];
out_dev_name = argv + 2;
nb_out_dev = argc - 2;
av_register_all();
avdevice_register_all();
avfilter_register_all();
/* Create input graph */
if (!(in_graph = avfilter_graph_alloc())) {
ret = AVERROR(ENOMEM);
av_log(NULL, AV_LOG_ERROR, "Unable to alloc graph graph: %s\n",
av_err2str(ret));
goto fail;
}
ret = avfilter_graph_parse_ptr(in_graph, in_graph_desc, NULL, NULL, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Unable to parse graph: %s\n",
av_err2str(ret));
goto fail;
}
nb_streams = 0;
for (i = 0; i < in_graph->nb_filters; i++) {
AVFilterContext *f = in_graph->filters[i];
for (j = 0; j < f->nb_inputs; j++) {
if (!f->inputs[j]) {
av_log(NULL, AV_LOG_ERROR, "Graph has unconnected inputs\n");
ret = AVERROR(EINVAL);
goto fail;
}
}
for (j = 0; j < f->nb_outputs; j++)
if (!f->outputs[j])
nb_streams++;
}
if (!nb_streams) {
av_log(NULL, AV_LOG_ERROR, "Graph has no output stream\n");
ret = AVERROR(EINVAL);
goto fail;
}
if (nb_out_dev != 1 && nb_out_dev != nb_streams) {
av_log(NULL, AV_LOG_ERROR,
"Graph has %d output streams, %d devices given\n",
nb_streams, nb_out_dev);
ret = AVERROR(EINVAL);
goto fail;
}
if (!(streams = av_calloc(nb_streams, sizeof(*streams)))) {
ret = AVERROR(ENOMEM);
av_log(NULL, AV_LOG_ERROR, "Could not allocate streams\n");
}
st = streams;
for (i = 0; i < in_graph->nb_filters; i++) {
AVFilterContext *f = in_graph->filters[i];
for (j = 0; j < f->nb_outputs; j++) {
if (!f->outputs[j]) {
if ((ret = create_sink(st++, in_graph, f, j)) < 0)
goto fail;
}
}
}
av_assert0(st - streams == nb_streams);
if ((ret = avfilter_graph_config(in_graph, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to configure graph\n");
goto fail;
}
/* Create output devices */
for (i = 0; i < nb_out_dev; i++) {
char *fmt = NULL, *dev = out_dev_name[i];
st = &streams[i];
if ((dev = strchr(dev, ':'))) {
*(dev++) = 0;
fmt = out_dev_name[i];
}
ret = avformat_alloc_output_context2(&st->mux, NULL, fmt, dev);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to allocate output: %s\n",
av_err2str(ret));
goto fail;
}
if (!(st->mux->oformat->flags & AVFMT_NOFILE)) {
ret = avio_open2(&st->mux->pb, st->mux->filename, AVIO_FLAG_WRITE,
NULL, NULL);
if (ret < 0) {
av_log(st->mux, AV_LOG_ERROR, "Failed to init output: %s\n",
av_err2str(ret));
goto fail;
}
}
}
for (; i < nb_streams; i++)
streams[i].mux = streams[0].mux;
/* Create output device streams */
for (i = 0; i < nb_streams; i++) {
st = &streams[i];
if (!(st->stream = avformat_new_stream(st->mux, NULL))) {
ret = AVERROR(ENOMEM);
av_log(NULL, AV_LOG_ERROR, "Failed to create output stream\n");
goto fail;
}
st->stream->codec->codec_type = st->link->type;
st->stream->time_base = st->stream->codec->time_base =
st->link->time_base;
switch (st->link->type) {
case AVMEDIA_TYPE_VIDEO:
st->stream->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
st->stream->avg_frame_rate =
st->stream-> r_frame_rate = av_buffersink_get_frame_rate(st->sink);
st->stream->codec->width = st->link->w;
st->stream->codec->height = st->link->h;
st->stream->codec->sample_aspect_ratio = st->link->sample_aspect_ratio;
st->stream->codec->pix_fmt = st->link->format;
break;
case AVMEDIA_TYPE_AUDIO:
st->stream->codec->channel_layout = st->link->channel_layout;
st->stream->codec->channels = avfilter_link_get_channels(st->link);
st->stream->codec->sample_rate = st->link->sample_rate;
st->stream->codec->sample_fmt = st->link->format;
st->stream->codec->codec_id =
av_get_pcm_codec(st->stream->codec->sample_fmt, -1);
break;
default:
av_assert0(!"reached");
}
}
/* Init output devices */
for (i = 0; i < nb_out_dev; i++) {
st = &streams[i];
if ((ret = avformat_write_header(st->mux, NULL)) < 0) {
av_log(st->mux, AV_LOG_ERROR, "Failed to init output: %s\n",
av_err2str(ret));
goto fail;
}
}
/* Check output devices */
for (i = 0; i < nb_streams; i++) {
st = &streams[i];
ret = av_write_uncoded_frame_query(st->mux, st->stream->index);
if (ret < 0) {
av_log(st->mux, AV_LOG_ERROR,
"Uncoded frames not supported on stream #%d: %s\n",
i, av_err2str(ret));
goto fail;
}
}
while (run) {
ret = avfilter_graph_request_oldest(in_graph);
if (ret < 0) {
if (ret == AVERROR_EOF) {
run = 0;
} else {
av_log(NULL, AV_LOG_ERROR, "Error filtering: %s\n",
av_err2str(ret));
break;
}
}
for (i = 0; i < nb_streams; i++) {
st = &streams[i];
while (1) {
if (!frame && !(frame = av_frame_alloc())) {
ret = AVERROR(ENOMEM);
av_log(NULL, AV_LOG_ERROR, "Could not allocate frame\n");
goto fail;
}
ret = av_buffersink_get_frame_flags(st->sink, frame,
AV_BUFFERSINK_FLAG_NO_REQUEST);
if (ret < 0) {
if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
av_log(NULL, AV_LOG_WARNING, "Error in sink: %s\n",
av_err2str(ret));
break;
}
if (frame->pts != AV_NOPTS_VALUE)
frame->pts = av_rescale_q(frame->pts,
st->link ->time_base,
st->stream->time_base);
ret = av_interleaved_write_uncoded_frame(st->mux,
st->stream->index,
frame);
frame = NULL;
if (ret < 0) {
av_log(st->stream->codec, AV_LOG_ERROR,
"Error writing frame: %s\n", av_err2str(ret));
goto fail;
}
}
}
}
ret = 0;
for (i = 0; i < nb_out_dev; i++) {
st = &streams[i];
av_write_trailer(st->mux);
}
fail:
av_frame_free(&frame);
avfilter_graph_free(&in_graph);
if (streams) {
for (i = 0; i < nb_out_dev; i++) {
st = &streams[i];
if (st->mux) {
if (st->mux->pb)
avio_closep(&st->mux->pb);
avformat_free_context(st->mux);
}
}
}
av_freep(&streams);
return ret < 0;
}
static int init_filters(const char *filters_descr)
{
char args[512];
int ret = 0;
AVFilter *abuffersrc = avfilter_get_by_name("abuffer");
AVFilter *abuffersink = avfilter_get_by_name("abuffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
static const enum AVSampleFormat out_sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 };
static const int64_t out_channel_layouts[] = { AV_CH_LAYOUT_MONO, -1 };
static const int out_sample_rates[] = { 8000, -1 };
const AVFilterLink *outlink;
AVRational time_base = fmt_ctx->streams[audio_stream_index]->time_base;
filter_graph = avfilter_graph_alloc();
if (!outputs || !inputs || !filter_graph) {
ret = AVERROR(ENOMEM);
goto end;
}
/* buffer audio source: the decoded frames from the decoder will be inserted here. */
if (!dec_ctx->channel_layout)
dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);
snprintf(args, sizeof(args),
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
time_base.num, time_base.den, dec_ctx->sample_rate,
av_get_sample_fmt_name(dec_ctx->sample_fmt), dec_ctx->channel_layout);
ret = avfilter_graph_create_filter(&buffersrc_ctx, abuffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
goto end;
}
/* buffer audio sink: to terminate the filter chain. */
ret = avfilter_graph_create_filter(&buffersink_ctx, abuffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "sample_fmts", out_sample_fmts, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "channel_layouts", out_channel_layouts, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "sample_rates", out_sample_rates, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
goto end;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
&inputs, &outputs, NULL)) < 0)
goto end;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
goto end;
/* Print summary of the sink buffer
* Note: args buffer is reused to store channel layout string */
outlink = buffersink_ctx->inputs[0];
av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout);
av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n",
(int)outlink->sample_rate,
(char *)av_x_if_null(av_get_sample_fmt_name(outlink->format), "?"),
args);
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}
//初始化滤波器
int init_filters(const char *filters_descr) {
char args[512];
int ret = 0;
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
AVRational time_base = pFormatCtx->streams[video_stream_index]->time_base;
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
filter_graph = avfilter_graph_alloc();
if (!outputs || !inputs || !filter_graph) {
ret = AVERROR(ENOMEM);
goto end;
}
/* buffer video source: the decoded frames from the decoder will be inserted here. */
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
time_base.num, time_base.den,
pCodecCtx->sample_aspect_ratio.num, pCodecCtx->sample_aspect_ratio.den);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
LOGE("Cannot create buffer source\n");
goto end;
}
/* buffer video sink: to terminate the filter chain. */
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
LOGE("Cannot create buffer sink\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,
AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
LOGE("Cannot set output pixel format\n");
goto end;
}
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
&inputs, &outputs, NULL)) < 0)
goto end;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
goto end;
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}
HRESULT CLAVVideo::Filter(LAVFrame *pFrame)
{
int ret = 0;
BOOL bFlush = pFrame->flags & LAV_FRAME_FLAG_FLUSH;
if (m_Decoder.IsInterlaced(FALSE) && m_settings.DeintMode != DeintMode_Disable
&& (m_settings.SWDeintMode == SWDeintMode_YADIF || m_settings.SWDeintMode == SWDeintMode_W3FDIF_Simple || m_settings.SWDeintMode == SWDeintMode_W3FDIF_Complex)
&& ((bFlush && m_pFilterGraph) || pFrame->format == LAVPixFmt_YUV420 || pFrame->format == LAVPixFmt_YUV422 || pFrame->format == LAVPixFmt_NV12)) {
AVPixelFormat ff_pixfmt = (pFrame->format == LAVPixFmt_YUV420) ? AV_PIX_FMT_YUV420P : (pFrame->format == LAVPixFmt_YUV422) ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_NV12;
if (!bFlush && (!m_pFilterGraph || pFrame->format != m_filterPixFmt || pFrame->width != m_filterWidth || pFrame->height != m_filterHeight)) {
DbgLog((LOG_TRACE, 10, L":Filter()(init) Initializing YADIF deinterlacing filter..."));
if (m_pFilterGraph) {
avfilter_graph_free(&m_pFilterGraph);
m_pFilterBufferSrc = nullptr;
m_pFilterBufferSink = nullptr;
}
m_filterPixFmt = pFrame->format;
m_filterWidth = pFrame->width;
m_filterHeight = pFrame->height;
char args[512];
enum AVPixelFormat pix_fmts[3];
if (ff_pixfmt == AV_PIX_FMT_NV12) {
pix_fmts[0] = AV_PIX_FMT_NV12;
pix_fmts[1] = AV_PIX_FMT_YUV420P;
} else {
pix_fmts[0] = ff_pixfmt;
pix_fmts[1] = AV_PIX_FMT_NONE;
}
pix_fmts[2] = AV_PIX_FMT_NONE;
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
m_pFilterGraph = avfilter_graph_alloc();
av_opt_set(m_pFilterGraph, "thread_type", "slice", AV_OPT_SEARCH_CHILDREN);
av_opt_set_int(m_pFilterGraph, "threads", FFMAX(1, av_cpu_count() / 2), AV_OPT_SEARCH_CHILDREN);
// 0/0 is not a valid value for avfilter, make sure it doesn't happen
AVRational aspect_ratio = pFrame->aspect_ratio;
if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
aspect_ratio = { 0, 1 };
_snprintf_s(args, sizeof(args), "video_size=%dx%d:pix_fmt=%s:time_base=1/10000000:pixel_aspect=%d/%d", pFrame->width, pFrame->height, av_get_pix_fmt_name(ff_pixfmt), pFrame->aspect_ratio.num, pFrame->aspect_ratio.den);
ret = avfilter_graph_create_filter(&m_pFilterBufferSrc, buffersrc, "in", args, nullptr, m_pFilterGraph);
if (ret < 0) {
DbgLog((LOG_TRACE, 10, L"::Filter()(init) Creating the input buffer filter failed with code %d", ret));
avfilter_graph_free(&m_pFilterGraph);
goto deliver;
}
ret = avfilter_graph_create_filter(&m_pFilterBufferSink, buffersink, "out", nullptr, nullptr, m_pFilterGraph);
if (ret < 0) {
DbgLog((LOG_TRACE, 10, L"::Filter()(init) Creating the buffer sink filter failed with code %d", ret));
avfilter_free(m_pFilterBufferSrc);
m_pFilterBufferSrc = nullptr;
avfilter_graph_free(&m_pFilterGraph);
goto deliver;
}
/* set allowed pixfmts on the output */
av_opt_set_int_list(m_pFilterBufferSink->priv, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, 0);
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = m_pFilterBufferSrc;
outputs->pad_idx = 0;
outputs->next = nullptr;
inputs->name = av_strdup("out");
inputs->filter_ctx = m_pFilterBufferSink;
inputs->pad_idx = 0;
inputs->next = nullptr;
if (m_settings.SWDeintMode == SWDeintMode_YADIF)
_snprintf_s(args, sizeof(args), "yadif=mode=%s:parity=auto:deint=interlaced", (m_settings.SWDeintOutput == DeintOutput_FramePerField) ? "send_field" : "send_frame");
else if (m_settings.SWDeintMode == SWDeintMode_W3FDIF_Simple)
_snprintf_s(args, sizeof(args), "w3fdif=filter=simple:deint=interlaced");
else if (m_settings.SWDeintMode == SWDeintMode_W3FDIF_Complex)
_snprintf_s(args, sizeof(args), "w3fdif=filter=complex:deint=interlaced");
else
ASSERT(0);
if ((ret = avfilter_graph_parse_ptr(m_pFilterGraph, args, &inputs, &outputs, nullptr)) < 0) {
DbgLog((LOG_TRACE, 10, L"::Filter()(init) Parsing the graph failed with code %d", ret));
avfilter_graph_free(&m_pFilterGraph);
goto deliver;
}
if ((ret = avfilter_graph_config(m_pFilterGraph, nullptr)) < 0) {
DbgLog((LOG_TRACE, 10, L"::Filter()(init) Configuring the graph failed with code %d", ret));
avfilter_graph_free(&m_pFilterGraph);
goto deliver;
}
DbgLog((LOG_TRACE, 10, L":Filter()(init) avfilter Initialization complete"));
}
if (!m_pFilterGraph)
goto deliver;
if (pFrame->direct) {
HRESULT hr = DeDirectFrame(pFrame, true);
if (FAILED(hr)) {
ReleaseFrame(&pFrame);
return hr;
}
}
AVFrame *in_frame = nullptr;
BOOL refcountedFrame = (m_Decoder.HasThreadSafeBuffers() == S_OK);
// When flushing, we feed a NULL frame
if (!bFlush) {
in_frame = av_frame_alloc();
for (int i = 0; i < 4; i++) {
in_frame->data[i] = pFrame->data[i];
in_frame->linesize[i] = (int)pFrame->stride[i];
}
in_frame->width = pFrame->width;
in_frame->height = pFrame->height;
in_frame->format = ff_pixfmt;
in_frame->pts = pFrame->rtStart;
in_frame->interlaced_frame = pFrame->interlaced;
in_frame->top_field_first = pFrame->tff;
in_frame->sample_aspect_ratio = pFrame->aspect_ratio;
if (refcountedFrame) {
AVBufferRef *pFrameBuf = av_buffer_create(nullptr, 0, lav_free_lavframe, pFrame, 0);
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get((AVPixelFormat)in_frame->format);
int planes = (in_frame->format == AV_PIX_FMT_NV12) ? 2 : desc->nb_components;
for (int i = 0; i < planes; i++) {
int h_shift = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
int plane_size = (in_frame->height >> h_shift) * in_frame->linesize[i];
AVBufferRef *planeRef = av_buffer_ref(pFrameBuf);
in_frame->buf[i] = av_buffer_create(in_frame->data[i], plane_size, lav_unref_frame, planeRef, AV_BUFFER_FLAG_READONLY);
}
av_buffer_unref(&pFrameBuf);
}
m_FilterPrevFrame = *pFrame;
memset(m_FilterPrevFrame.data, 0, sizeof(m_FilterPrevFrame.data));
m_FilterPrevFrame.destruct = nullptr;
} else {
vod_status_t
audio_filter_alloc_state(
request_context_t* request_context,
media_sequence_t* sequence,
media_clip_t* clip,
media_track_t* output_track,
size_t* cache_buffer_count,
void** result)
{
audio_filter_init_context_t init_context;
u_char filter_name[VOD_INT32_LEN + 1];
audio_filter_state_t* state;
vod_pool_cleanup_t *cln;
AVFilterInOut *outputs = NULL;
AVFilterInOut *inputs = NULL;
uint32_t initial_alloc_size;
vod_status_t rc;
int avrc;
if (!initialized)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: module failed to initialize successfully");
return VOD_UNEXPECTED;
}
// get the source count and graph desc size
init_context.request_context = request_context;
init_context.graph_desc_size = 0;
init_context.source_count = 0;
init_context.output_frame_count = 0;
rc = audio_filter_walk_filters_prepare_init(&init_context, &clip, 100, 100);
if (rc != VOD_OK)
{
return rc;
}
if (clip == NULL || init_context.source_count <= 0)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: unexpected - no sources found");
return VOD_UNEXPECTED;
}
if (clip->type == MEDIA_CLIP_SOURCE)
{
// got left with a source, following a mix of a single source, nothing to do
return VOD_OK;
}
if (init_context.output_frame_count > MAX_FRAME_COUNT)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: expected output frame count %uD too big", init_context.output_frame_count);
return VOD_BAD_REQUEST;
}
// allocate the state
state = vod_alloc(request_context->pool, sizeof(*state));
if (state == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_alloc failed");
return VOD_ALLOC_FAILED;
}
vod_memzero(state, sizeof(*state));
// add to the cleanup pool
cln = vod_pool_cleanup_add(request_context->pool, 0);
if (cln == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_pool_cleanup_add failed");
return VOD_ALLOC_FAILED;
}
cln->handler = audio_filter_free_state;
cln->data = state;
// allocate the filter graph
state->filter_graph = avfilter_graph_alloc();
if (state->filter_graph == NULL)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_alloc_state: avfilter_graph_alloc failed");
return VOD_ALLOC_FAILED;
}
// allocate the graph desc and sources
init_context.graph_desc = vod_alloc(request_context->pool, init_context.graph_desc_size +
sizeof(state->sources[0]) * init_context.source_count);
if (init_context.graph_desc == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_alloc failed (1)");
return VOD_ALLOC_FAILED;
}
state->sources = (void*)(init_context.graph_desc + init_context.graph_desc_size);
state->sources_end = state->sources + init_context.source_count;
vod_memzero(state->sources, (u_char*)state->sources_end - (u_char*)state->sources);
// initialize the sources and the graph description
init_context.filter_graph = state->filter_graph;
init_context.outputs = &outputs;
init_context.cur_source = state->sources;
init_context.graph_desc_pos = init_context.graph_desc;
init_context.max_frame_size = 0;
init_context.cache_slot_id = 0;
rc = audio_filter_init_sources_and_graph_desc(&init_context, clip);
if (rc != VOD_OK)
{
goto end;
}
*init_context.graph_desc_pos = '\0';
// initialize the sink
vod_sprintf(filter_name, "%uD%Z", clip->id);
rc = audio_filter_init_sink(
request_context,
state->filter_graph,
output_track,
filter_name,
&state->sink,
&inputs);
if (rc != VOD_OK)
{
goto end;
}
// parse the graph description
avrc = avfilter_graph_parse_ptr(state->filter_graph, (char*)init_context.graph_desc, &inputs, &outputs, NULL);
if (avrc < 0)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: avfilter_graph_parse_ptr failed %d", avrc);
rc = VOD_UNEXPECTED;
goto end;
}
// validate and configure the graph
avrc = avfilter_graph_config(state->filter_graph, NULL);
if (avrc < 0)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: avfilter_graph_config failed %d", avrc);
rc = VOD_UNEXPECTED;
goto end;
}
// set the buffer sink frame size
if ((state->sink.encoder->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE) == 0)
{
av_buffersink_set_frame_size(state->sink.buffer_sink, state->sink.encoder->frame_size);
}
// allocate frames
state->decoded_frame = av_frame_alloc();
if (state->decoded_frame == NULL)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: av_frame_alloc failed (1)");
return VOD_ALLOC_FAILED;
}
state->filtered_frame = av_frame_alloc();
if (state->filtered_frame == NULL)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: av_frame_alloc failed (2)");
return VOD_ALLOC_FAILED;
}
// allocate the frame buffer
state->frame_buffer = vod_alloc(request_context->pool, init_context.max_frame_size);
if (state->frame_buffer == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_alloc failed (2)");
rc = VOD_ALLOC_FAILED;
goto end;
}
// initialize the output arrays
initial_alloc_size = init_context.output_frame_count + 10;
if (vod_array_init(&state->frames_array, request_context->pool, initial_alloc_size, sizeof(input_frame_t)) != VOD_OK)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_array_init failed (1)");
return VOD_ALLOC_FAILED;
}
state->request_context = request_context;
state->sequence = sequence;
state->output = output_track;
state->cur_frame_pos = 0;
state->first_time = TRUE;
state->cur_source = NULL;
*cache_buffer_count = init_context.cache_slot_id;
*result = state;
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return rc;
}
static vod_status_t
audio_filter_init_filters(
audio_filter_state_t* state,
mpeg_stream_metadata_t* stream_metadata,
const char *filters_descr)
{
char filter_args[sizeof(BUFFERSRC_ARGS_FORMAT) + 4 * VOD_INT64_LEN + MAX_SAMPLE_FORMAT_NAME_LEN];
enum AVSampleFormat out_sample_fmts[2];
int64_t out_channel_layouts[2];
int out_sample_rates[2];
AVFilterInOut *outputs = NULL;
AVFilterInOut *inputs = NULL;
int ret;
int rc;
// allocate the filter graph
state->filter_graph = avfilter_graph_alloc();
if (state->filter_graph == NULL)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: avfilter_graph_alloc failed");
rc = VOD_ALLOC_FAILED;
goto end;
}
// create the buffer source
vod_sprintf(filter_args, BUFFERSRC_ARGS_FORMAT,
state->decoder->time_base.num,
state->decoder->time_base.den,
state->decoder->sample_rate,
av_get_sample_fmt_name(state->decoder->sample_fmt),
state->decoder->channel_layout);
ret = avfilter_graph_create_filter(
&state->buffer_src,
buffersrc_filter,
INPUT_FILTER_NAME,
filter_args,
NULL,
state->filter_graph);
if (ret < 0)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: avfilter_graph_create_filter(input) failed %d", ret);
rc = VOD_ALLOC_FAILED;
goto end;
}
// create the buffer sink
ret = avfilter_graph_create_filter(
&state->buffer_sink,
buffersink_filter,
OUTPUT_FILTER_NAME,
NULL,
NULL,
state->filter_graph);
if (ret < 0)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: avfilter_graph_create_filter(output) failed %d", ret);
rc = VOD_ALLOC_FAILED;
goto end;
}
// configure the buffer sink
out_sample_fmts[0] = ENCODER_INPUT_SAMPLE_FORMAT;
out_sample_fmts[1] = -1;
ret = av_opt_set_int_list(
state->buffer_sink,
BUFFERSINK_PARAM_SAMPLE_FORMATS,
out_sample_fmts,
-1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: av_opt_set_int_list(sample format) failed %d", ret);
rc = VOD_UNEXPECTED;
goto end;
}
out_channel_layouts[0] = state->decoder->channel_layout;
out_channel_layouts[1] = -1;
ret = av_opt_set_int_list(
state->buffer_sink,
BUFFERSINK_PARAM_CHANNEL_LAYOUTS,
out_channel_layouts,
-1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: av_opt_set_int_list(channel layouts) failed %d", ret);
rc = VOD_UNEXPECTED;
goto end;
}
out_sample_rates[0] = state->decoder->sample_rate;
out_sample_rates[1] = -1;
ret = av_opt_set_int_list(
state->buffer_sink,
BUFFERSINK_PARAM_SAMPLE_RATES,
out_sample_rates,
-1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: av_opt_set_int_list(sample rates) failed %d", ret);
rc = VOD_UNEXPECTED;
goto end;
}
// create the filter outputs
outputs = avfilter_inout_alloc();
if (outputs == NULL)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: avfilter_inout_alloc failed (1)");
rc = VOD_ALLOC_FAILED;
goto end;
}
outputs->name = av_strdup(INPUT_FILTER_NAME);
outputs->filter_ctx = state->buffer_src;
outputs->pad_idx = 0;
outputs->next = NULL;
// create the filter inputs
inputs = avfilter_inout_alloc();
if (inputs == NULL)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: avfilter_inout_alloc failed (2)");
rc = VOD_ALLOC_FAILED;
goto end;
}
inputs->name = av_strdup(OUTPUT_FILTER_NAME);
inputs->filter_ctx = state->buffer_sink;
inputs->pad_idx = 0;
inputs->next = NULL;
// parse the filter description
ret = avfilter_graph_parse_ptr(state->filter_graph, filters_descr, &inputs, &outputs, NULL);
if (ret < 0)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: avfilter_graph_parse_ptr failed %d", ret);
rc = VOD_UNEXPECTED;
goto end;
}
// validate and configure the graph
ret = avfilter_graph_config(state->filter_graph, NULL);
if (ret < 0)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_init_filters: avfilter_graph_config failed %d", ret);
rc = VOD_UNEXPECTED;
goto end;
}
// set the buffer sink frame size
if ((state->encoder->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE) == 0)
{
av_buffersink_set_frame_size(state->buffer_sink, state->encoder->frame_size);
}
rc = VOD_OK;
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return rc;
}
static int init_filters(AVStream *audio_stream, int audio_stream_index)
{
AVCodecContext *dec_ctx = audio_stream->codec;
char args[512];
int ret = 0;
AVFilter *abuffersrc = avfilter_get_by_name("abuffer");
AVFilter *abuffersink = avfilter_get_by_name("abuffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
static const enum AVSampleFormat out_sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
static const int64_t out_channel_layouts[] = { AV_CH_LAYOUT_STEREO, -1 };
static const int out_sample_rates[] = { dec_ctx->sample_rate, -1 };
const AVFilterLink *outlink;
AVRational time_base = fmt_ctx->streams[audio_stream_index]->time_base;
filter_graph = avfilter_graph_alloc();
if (!outputs || !inputs || !filter_graph) {
ret = AVERROR(ENOMEM);
goto end;
}
/* buffer audio source: the decoded frames from the decoder will be inserted here. */
if (!dec_ctx->channel_layout)
dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);
_snprintf_s(args, sizeof(args),
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%I64d",
time_base.num, time_base.den, dec_ctx->sample_rate,
av_get_sample_fmt_name(dec_ctx->sample_fmt), dec_ctx->channel_layout);
ret = avfilter_graph_create_filter(&buffersrc_ctx, abuffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
goto end;
}
/* buffer audio sink: to terminate the filter chain. */
ret = avfilter_graph_create_filter(&buffersink_ctx, abuffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "sample_fmts", out_sample_fmts, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "channel_layouts", out_channel_layouts, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
goto end;
}
ret = av_opt_set_int_list(buffersink_ctx, "sample_rates", out_sample_rates, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
goto end;
}
last_flt_ctx = buffersink_ctx;
int index = 1;
while(filter_descr[index]) {
const char* name = NULL;
const char* arg = NULL;
char tmp[64] = {0};
char* pos = NULL;
strncpy_s(tmp, 64, filter_descr[index], 64);
pos = strchr(tmp, '=');
if (pos != NULL) {
*pos = '\0';
name = tmp;
arg = pos + 1;
}
else {
name = filter_descr[index];
arg = NULL;
}
insert_filter(name, arg, &last_flt_ctx);
index++;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = last_flt_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_descr[0],
&inputs, &outputs, NULL)) < 0)
goto end;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
goto end;
/* Print summary of the sink buffer
* Note: args buffer is reused to store channel layout string */
outlink = buffersink_ctx->inputs[0];
av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout);
av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n",
(int)outlink->sample_rate,
(char *)av_x_if_null(av_get_sample_fmt_name((AVSampleFormat)outlink->format), "?"),
args);
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}
int main(int argc, char* argv[])
{
int ret;
AVFrame *frame_in;
AVFrame *frame_out;
unsigned char *frame_buffer_in;
unsigned char *frame_buffer_out;
AVFilterContext *buffersink_ctx;
AVFilterContext *buffersrc_ctx;
AVFilterGraph *filter_graph;
static int video_stream_index = -1;
//Input YUV
FILE *fp_in=fopen("sintel_480x272_yuv420p.yuv","rb+");
if(fp_in==NULL){
printf("Error open input file.\n");
return -1;
}
int in_width=480;
int in_height=272;
//Output YUV
FILE *fp_out=fopen("output.yuv","wb+");
if(fp_out==NULL){
printf("Error open output file.\n");
return -1;
}
//const char *filter_descr = "lutyuv='u=128:v=128'";
const char *filter_descr = "boxblur";
//const char *filter_descr = "hflip";
//const char *filter_descr = "hue='h=60:s=-3'";
//const char *filter_descr = "crop=2/3*in_w:2/3*in_h";
//const char *filter_descr = "drawbox=x=100:y=100:w=100:h=100:[email protected]";
//const char *filter_descr = "drawtext=fontfile=arial.ttf:fontcolor=green:fontsize=30:text='Lei Xiaohua'";
avfilter_register_all();
char args[512];
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("ffbuffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
enum PixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, PIX_FMT_NONE };
AVBufferSinkParams *buffersink_params;
filter_graph = avfilter_graph_alloc();
/* buffer video source: the decoded frames from the decoder will be inserted here. */
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
in_width,in_height,AV_PIX_FMT_YUV420P,
1, 25,1,1);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
printf("Cannot create buffer source\n");
return ret;
}
/* buffer video sink: to terminate the filter chain. */
buffersink_params = av_buffersink_params_alloc();
buffersink_params->pixel_fmts = pix_fmts;
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, buffersink_params, filter_graph);
av_free(buffersink_params);
if (ret < 0) {
printf("Cannot create buffer sink\n");
return ret;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_descr,
&inputs, &outputs, NULL)) < 0)
return ret;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
return ret;
frame_in=av_frame_alloc();
frame_buffer_in=(unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, in_width,in_height,1));
av_image_fill_arrays(frame_in->data, frame_in->linesize,frame_buffer_in,
AV_PIX_FMT_YUV420P,in_width, in_height,1);
frame_out=av_frame_alloc();
frame_buffer_out=(unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, in_width,in_height,1));
av_image_fill_arrays(frame_out->data, frame_out->linesize,frame_buffer_out,
AV_PIX_FMT_YUV420P,in_width, in_height,1);
frame_in->width=in_width;
frame_in->height=in_height;
frame_in->format=AV_PIX_FMT_YUV420P;
while (1) {
if(fread(frame_buffer_in, 1, in_width*in_height*3/2, fp_in)!= in_width*in_height*3/2){
break;
}
//input Y,U,V
frame_in->data[0]=frame_buffer_in;
frame_in->data[1]=frame_buffer_in+in_width*in_height;
frame_in->data[2]=frame_buffer_in+in_width*in_height*5/4;
if (av_buffersrc_add_frame(buffersrc_ctx, frame_in) < 0) {
printf( "Error while add frame.\n");
break;
}
/* pull filtered pictures from the filtergraph */
ret = av_buffersink_get_frame(buffersink_ctx, frame_out);
if (ret < 0)
break;
//output Y,U,V
if(frame_out->format==AV_PIX_FMT_YUV420P){
for(int i=0;i<frame_out->height;i++){
fwrite(frame_out->data[0]+frame_out->linesize[0]*i,1,frame_out->width,fp_out);
}
for(int i=0;i<frame_out->height/2;i++){
fwrite(frame_out->data[1]+frame_out->linesize[1]*i,1,frame_out->width/2,fp_out);
}
for(int i=0;i<frame_out->height/2;i++){
fwrite(frame_out->data[2]+frame_out->linesize[2]*i,1,frame_out->width/2,fp_out);
}
}
printf("Process 1 frame!\n");
av_frame_unref(frame_out);
}
fclose(fp_in);
fclose(fp_out);
av_frame_free(&frame_in);
av_frame_free(&frame_out);
avfilter_graph_free(&filter_graph);
return 0;
}
int Filters::init(VideoDecoder *decoder)
{
char args[512];
int ret = 0;
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB8, AV_PIX_FMT_NONE };
mFilterGraphPtr = avfilter_graph_alloc();
if (!inputs || !outputs || !mFilterGraphPtr) {
LOGE("Alloc filter graph failed");
goto end;
}
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
decoder->mVideoCodecCtxPtr->width,
decoder->mVideoCodecCtxPtr->height,
decoder->mVideoCodecCtxPtr->pix_fmt,
decoder->mVideoCodecCtxPtr->time_base.num,
decoder->mVideoCodecCtxPtr->time_base.den,
decoder->mVideoCodecCtxPtr->sample_aspect_ratio.num,
decoder->mVideoCodecCtxPtr->sample_aspect_ratio.den);
LOGD("Buffer args: %s", args);
ret = avfilter_graph_create_filter(&(mBufSrcCtxPtr), buffersrc, "in",
args, NULL, mFilterGraphPtr);
if (ret < 0) {
LOGE("Create buffer src context failed");
goto end;
}
ret = avfilter_graph_create_filter(&(mBufSinkCtxPtr), buffersink, "out",
NULL, NULL, mFilterGraphPtr);
if (ret < 0) {
LOGE("Create buffer sink context failed");
goto end;
}
ret = av_opt_set_int_list(mBufSinkCtxPtr, "pix_fmts", pix_fmts,
AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
LOGE("Cannot set output pixel format");
goto end;
}
outputs->name = av_strdup("in");
outputs->filter_ctx = mBufSrcCtxPtr;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = mBufSinkCtxPtr;
inputs->pad_idx = 0;
inputs->next = NULL;
setPixFmt(decoder->mPixFmt);
LOGD("Filter desc %s", mDesc.c_str());
if ((ret = avfilter_graph_parse_ptr(mFilterGraphPtr, mDesc.c_str(),
&inputs, &outputs, NULL)) < 0) {
LOGE("Parse filter graph failed");
goto end;
}
if ((ret = avfilter_graph_config(mFilterGraphPtr, NULL)) < 0) {
LOGE("Config filter graph failed");
goto end;
}
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
AVFilterInOut *open_inputs,
AVFilterInOut *open_outputs, void *log_ctx)
{
int ret;
AVFilterInOut *cur, *match, *inputs = NULL, *outputs = NULL;
if ((ret = avfilter_graph_parse2(graph, filters, &inputs, &outputs)) < 0)
goto fail;
/* First input can be omitted if it is "[in]" */
if (inputs && !inputs->name)
inputs->name = av_strdup("in");
for (cur = inputs; cur; cur = cur->next) {
if (!cur->name) {
av_log(log_ctx, AV_LOG_ERROR,
"Not enough inputs specified for the \"%s\" filter.\n",
cur->filter_ctx->filter->name);
ret = AVERROR(EINVAL);
goto fail;
}
if (!(match = extract_inout(cur->name, &open_outputs)))
continue;
ret = avfilter_link(match->filter_ctx, match->pad_idx,
cur->filter_ctx, cur->pad_idx);
avfilter_inout_free(&match);
if (ret < 0)
goto fail;
}
/* Last output can be omitted if it is "[out]" */
if (outputs && !outputs->name)
outputs->name = av_strdup("out");
for (cur = outputs; cur; cur = cur->next) {
if (!cur->name) {
av_log(log_ctx, AV_LOG_ERROR,
"Invalid filterchain containing an unlabelled output pad: \"%s\"\n",
filters);
ret = AVERROR(EINVAL);
goto fail;
}
if (!(match = extract_inout(cur->name, &open_inputs)))
continue;
ret = avfilter_link(cur->filter_ctx, cur->pad_idx,
match->filter_ctx, match->pad_idx);
avfilter_inout_free(&match);
if (ret < 0)
goto fail;
}
fail:
if (ret < 0) {
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
av_freep(&graph->filters);
}
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
avfilter_inout_free(&open_inputs);
avfilter_inout_free(&open_outputs);
return ret;
#else
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
AVFilterInOut **inputs, AVFilterInOut **outputs,
void *log_ctx)
{
return avfilter_graph_parse_ptr(graph, filters, inputs, outputs, log_ctx);
#endif
}
int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters,
AVFilterInOut **open_inputs_ptr, AVFilterInOut **open_outputs_ptr,
void *log_ctx)
{
int index = 0, ret = 0;
char chr = 0;
AVFilterInOut *curr_inputs = NULL;
AVFilterInOut *open_inputs = open_inputs_ptr ? *open_inputs_ptr : NULL;
AVFilterInOut *open_outputs = open_outputs_ptr ? *open_outputs_ptr : NULL;
if ((ret = parse_sws_flags(&filters, graph)) < 0)
goto end;
do {
AVFilterContext *filter;
const char *filterchain = filters;
filters += strspn(filters, WHITESPACES);
if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, log_ctx)) < 0)
goto end;
if ((ret = parse_filter(&filter, &filters, graph, index, log_ctx)) < 0)
goto end;
if (filter->nb_inputs == 1 && !curr_inputs && !index) {
/* First input pad, assume it is "[in]" if not specified */
const char *tmp = "[in]";
if ((ret = parse_inputs(&tmp, &curr_inputs, &open_outputs, log_ctx)) < 0)
goto end;
}
if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, log_ctx)) < 0)
goto end;
if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,
log_ctx)) < 0)
goto end;
filters += strspn(filters, WHITESPACES);
chr = *filters++;
if (chr == ';' && curr_inputs) {
av_log(log_ctx, AV_LOG_ERROR,
"Invalid filterchain containing an unlabelled output pad: \"%s\"\n",
filterchain);
ret = AVERROR(EINVAL);
goto end;
}
index++;
} while (chr == ',' || chr == ';');
if (chr) {
av_log(log_ctx, AV_LOG_ERROR,
"Unable to parse graph description substring: \"%s\"\n",
filters - 1);
ret = AVERROR(EINVAL);
goto end;
}
if (curr_inputs) {
/* Last output pad, assume it is "[out]" if not specified */
const char *tmp = "[out]";
if ((ret = parse_outputs(&tmp, &curr_inputs, &open_inputs, &open_outputs,
log_ctx)) < 0)
goto end;
}
end:
/* clear open_in/outputs only if not passed as parameters */
if (open_inputs_ptr) *open_inputs_ptr = open_inputs;
else avfilter_inout_free(&open_inputs);
if (open_outputs_ptr) *open_outputs_ptr = open_outputs;
else avfilter_inout_free(&open_outputs);
avfilter_inout_free(&curr_inputs);
if (ret < 0) {
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
av_freep(&graph->filters);
}
return ret;
}
static int apply_filters(AVFormatContext *ifmt_ctx)
{
char args[512];
int ret;
AVFilterInOut *outputs = avfilter_inout_alloc();
if (!outputs)
{
printf("Cannot alloc output\n");
return -1;
}
AVFilterInOut *inputs = avfilter_inout_alloc();
if (!inputs)
{
printf("Cannot alloc input\n");
return -1;
}
if (filter_graph)
avfilter_graph_free(&filter_graph);
filter_graph = avfilter_graph_alloc();
if (!filter_graph)
{
printf("Cannot create filter graph\n");
return -1;
}
/* buffer video source: the decoded frames from the decoder will be inserted here. */
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
ifmt_ctx->streams[0]->codec->width, ifmt_ctx->streams[0]->codec->height, ifmt_ctx->streams[0]->codec->pix_fmt,
ifmt_ctx->streams[0]->time_base.num, ifmt_ctx->streams[0]->time_base.den,
ifmt_ctx->streams[0]->codec->sample_aspect_ratio.num, ifmt_ctx->streams[0]->codec->sample_aspect_ratio.den);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
printf("Cannot create buffer source\n");
return ret;
}
/* buffer video sink: to terminate the filter chain. */
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
printf("Cannot create buffer sink\n");
return ret;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_descr,
&inputs, &outputs, NULL)) < 0)
return ret;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
return ret;
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return 0;
}
filter_wrapper::filter_wrapper(int width, int height, int width_out, int height_out, int fps, const std::string& filter_descr)
{
if (once)
{
once = false;
avfilter_register_all();
}
this->width_ = width;
this->height_ = height;
this->width_out = width_out;
this->height_out = height_out;
this->fps_ = fps;
this->filter_descr_ = filter_descr;
outputs = avfilter_inout_alloc();
inputs = avfilter_inout_alloc();
char args[512] = { 0 };
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("ffbuffersink");
AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
AVBufferSinkParams *buffersink_params;
filter_graph = avfilter_graph_alloc();
/* buffer video source: the decoded frames from the decoder will be inserted here. */
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
width, height, AV_PIX_FMT_YUV420P, 1, fps, 1, 1);
int ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
printf("Cannot create buffer source\n");
return;
}
/* buffer video sink: to terminate the filter chain. */
buffersink_params = av_buffersink_params_alloc();
buffersink_params->pixel_fmts = pix_fmts;
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, buffersink_params, filter_graph);
av_free(buffersink_params);
if (ret < 0) {
printf("Cannot create buffer sink\n");
return;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_descr.c_str(), &inputs, &outputs, NULL)) < 0)
return;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
return;
frame_in = av_frame_alloc();
frame_buffer_in = (unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, width, height, 1));
av_image_fill_arrays(frame_in->data, frame_in->linesize, frame_buffer_in,
AV_PIX_FMT_YUV420P, width, height, 1);
frame_out = av_frame_alloc();
frame_buffer_out = (unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, width_out, height_out, 1));
av_image_fill_arrays(frame_out->data, frame_out->linesize, frame_buffer_out,
AV_PIX_FMT_YUV420P, width_out, height_out, 1);
frame_in->width = width;
frame_in->height = height;
frame_in->format = AV_PIX_FMT_YUV420P;
}
