#include "FilterVideo.hpp"
|
|
#include <stdexcept>
|
|
extern "C"{
|
#include <libavutil/opt.h>
|
#include <libavcodec/avcodec.h>
|
#include <libavfilter/avfilter.h>
|
//#include <libavfilter/avfiltergraph.h>
|
#include <libavfilter/buffersink.h>
|
#include <libavfilter/buffersrc.h>
|
}
|
|
#include "../log/log.hpp"
|
#include "../configure/conf.hpp"
|
|
using namespace logif;
|
|
namespace ffwrapper{
|
|
FilterVideo::FilterVideo()
|
:graph_(NULL)
|
,src_(NULL)
|
,out_(NULL)
|
,func_out_filtered_frame_(nullptr)
|
{}
|
|
FilterVideo::~FilterVideo()
|
{
|
if (graph_)
|
{
|
for (int i = 0; i < graph_->nb_filters; ++i)
|
{
|
avfilter_free(graph_->filters[i]);
|
}
|
avfilter_graph_free(&graph_);
|
graph_ = NULL;
|
}
|
|
}
|
|
FilterVideo::FilterVideo(const AVCodecContext *dec, const AVCodecContext *enc,
|
const char *filter_spec, FUNC_OUT_FILTERED_FRAME cb)
|
:graph_(NULL)
|
,src_(NULL)
|
,out_(NULL)
|
,func_out_filtered_frame_(cb)
|
{
|
bool flag = initFilterGraph(dec, enc);
|
flag = configureFilterGraph(filter_spec) && flag;
|
if(!flag){
|
throw std::runtime_error("FilterVideo Init Failed!");
|
}
|
}
|
///////////////////////////////////////////////////////////////
|
|
bool FilterVideo::initFilterGraph(const AVCodecContext *dec_ctx, const AVCodecContext *enc_ctx){
|
graph_ = avfilter_graph_alloc();
|
if(!graph_){
|
logIt("alloc filter graph error");
|
|
return false;
|
}
|
|
AVFilter* buffersrc = (AVFilter*)avfilter_get_by_name("buffer");
|
AVFilter* buffersink = (AVFilter*)avfilter_get_by_name("buffersink");
|
if(!buffersrc || !buffersink){
|
logIt("can't get \"buffer/sink\" filters");
|
|
return false;
|
}
|
|
char args[512];
|
|
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);
|
printf("%s\n", args);
|
int ret = avfilter_graph_create_filter(&src_, buffersrc, "in",
|
args, NULL, graph_);
|
if(ret < 0)
|
{
|
logIt("create in filter failed:%s",
|
getAVErrorDesc(ret).c_str());
|
|
return false;
|
}
|
|
ret = avfilter_graph_create_filter(&out_, buffersink, "out",
|
NULL, NULL, graph_);
|
if(ret < 0)
|
{
|
logIt("create out filter failed:%s",
|
getAVErrorDesc(ret).c_str());
|
return false;
|
}
|
|
|
ret = av_opt_set_bin(out_, "pix_fmts",(uint8_t *)&enc_ctx->pix_fmt,
|
sizeof(enc_ctx->pix_fmt),AV_OPT_SEARCH_CHILDREN);
|
if(ret < 0)
|
{
|
logIt("set out filter opt failed:%s",
|
getAVErrorDesc(ret).c_str());
|
return false;
|
}
|
|
return true;
|
}
|
|
bool FilterVideo::configureFilterGraph(const char *filter_spec){
|
|
AVFilterInOut *outputs = avfilter_inout_alloc();
|
AVFilterInOut *inputs = avfilter_inout_alloc();
|
|
if(!outputs || !inputs){
|
logIt("create filter in/out failed:{}");
|
return false;
|
}
|
|
/* Endpoints for the filter graph. */
|
outputs->name = av_strdup("in");
|
outputs->filter_ctx = src_;
|
outputs->pad_idx = 0;
|
outputs->next = NULL;
|
|
inputs->name = av_strdup("out");
|
inputs->filter_ctx = out_;
|
inputs->pad_idx = 0;
|
inputs->next = NULL;
|
|
int ret = avfilter_graph_parse_ptr(graph_, filter_spec,
|
&inputs, &outputs, NULL);
|
if(ret < 0){
|
logIt("parse filter graph failed:%s",
|
getAVErrorDesc(ret).c_str());
|
return false;
|
}
|
|
ret = avfilter_graph_config(graph_, NULL);
|
if(ret < 0){
|
logIt("config filter graph failed:%s",
|
getAVErrorDesc(ret).c_str());
|
return false;
|
}
|
|
avfilter_inout_free(&inputs);
|
avfilter_inout_free(&outputs);
|
|
return true;
|
}
|
|
static int64_t frame_pts = 0;
|
bool FilterVideo::filterFrame(AVFrame *frame){
|
|
// printf("pre filter pts : %lld\n", frame->pts);
|
// frame->pts = frame->best_effort_timestamp;
|
// printf("post filter pts : %lld\n", frame->pts);
|
|
frame->pts = frame_pts++;
|
|
int ret = av_buffersrc_add_frame_flags(in(),frame,
|
AV_BUFFERSRC_FLAG_PUSH);
|
if(ret < 0){
|
logIt("push frame to filter failed:%s",
|
getAVErrorDesc(ret).c_str());
|
|
return false;
|
}
|
|
AVFrame *filtered_frame;
|
|
bool flag = true;
|
|
while(true){
|
filtered_frame = av_frame_alloc();
|
if(!filtered_frame){
|
logIt("alloc filtered frame failed");
|
|
break;
|
}
|
|
ret = av_buffersink_get_frame(out(),filtered_frame);
|
if(ret < 0){
|
if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){
|
// printf("need more frame\n");
|
ret = 0;
|
}else{
|
logIt("pull frame from filter failed:%s",
|
getAVErrorDesc(ret).c_str());
|
}
|
av_frame_free(&filtered_frame);
|
|
break;
|
}
|
|
if(func_out_filtered_frame_){
|
flag = func_out_filtered_frame_(filtered_frame);
|
}
|
|
av_frame_free(&filtered_frame);
|
|
}
|
return flag;
|
}
|
|
}
|
