Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

fftools/ffmpeg_filter: add an AVClass to OutputFilter

Browse Source 
Use it for logging where appropriate, avoid logging to OutputStream as
we do not own it.

This is a step towards decoupling filtering from encoding.
release/7.1
Anton Khirnov 8 months ago
parent 3c3e04c8a3
commit fc6354c39c
2 changed files with 51 additions and 19 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      fftools/ffmpeg.h
  2. 68
      fftools/ffmpeg_filter.c

2
fftools/ffmpeg.h
Unescape View File

@ -302,6 +302,8 @@ typedef struct InputFilter {
} InputFilter; } InputFilter;
typedef struct OutputFilter { typedef struct OutputFilter {
const AVClass *class;
struct OutputStream *ost; struct OutputStream *ost;
struct FilterGraph *graph; struct FilterGraph *graph;
uint8_t *name; uint8_t *name;

68
fftools/ffmpeg_filter.c
Unescape View File

@ -188,6 +188,9 @@ typedef struct OutputFilterPriv {
int index; int index;
void *log_parent;
char log_name[32];
char *name; char *name;
AVFilterContext *filter; AVFilterContext *filter;
@ -629,7 +632,21 @@ static char *describe_filter_link(FilterGraph *fg, AVFilterInOut *inout, int in)
avfilter_pad_get_name(pads, inout->pad_idx)); avfilter_pad_get_name(pads, inout->pad_idx));
} }
static OutputFilter *ofilter_alloc(FilterGraph *fg) static const char *ofilter_item_name(void *obj)
{
OutputFilterPriv *ofp = obj;
return ofp->log_name;
}
static const AVClass ofilter_class = {
.class_name = "OutputFilter",
.version = LIBAVUTIL_VERSION_INT,
.item_name = ofilter_item_name,
.parent_log_context_offset = offsetof(OutputFilterPriv, log_parent),
.category = AV_CLASS_CATEGORY_FILTER,
};
static OutputFilter *ofilter_alloc(FilterGraph *fg, enum AVMediaType type)
{ {
OutputFilterPriv *ofp; OutputFilterPriv *ofp;
OutputFilter *ofilter; OutputFilter *ofilter;
@ -639,10 +656,16 @@ static OutputFilter *ofilter_alloc(FilterGraph *fg)
return NULL; return NULL;
ofilter = &ofp->ofilter; ofilter = &ofp->ofilter;
ofilter->class = &ofilter_class;
ofp->log_parent = fg;
ofilter->graph = fg; ofilter->graph = fg;
ofilter->type = type;
ofp->format = -1; ofp->format = -1;
ofp->index = fg->nb_outputs - 1; ofp->index = fg->nb_outputs - 1;
snprintf(ofp->log_name, sizeof(ofp->log_name), "%co%d",
av_get_media_type_string(type)[0], ofp->index);
return ofilter; return ofilter;
} }
@ -790,6 +813,14 @@ int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost,
if (!ofp->name) if (!ofp->name)
return AVERROR(EINVAL); return AVERROR(EINVAL);
if (fgp->is_simple) {
// for simple filtergraph there is just one output,
// so use only graph-level information for logging
ofp->log_parent = NULL;
av_strlcpy(ofp->log_name, fgp->log_name, sizeof(ofp->log_name));
} else
av_strlcatf(ofp->log_name, sizeof(ofp->log_name), "->%s", ofp->name);
switch (ofilter->type) { switch (ofilter->type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
ofp->width = opts->width; ofp->width = opts->width;
@ -1025,7 +1056,9 @@ int fg_create(FilterGraph **pfg, char *graph_desc, Scheduler *sch)
} }
for (AVFilterInOut *cur = outputs; cur; cur = cur->next) { for (AVFilterInOut *cur = outputs; cur; cur = cur->next) {
OutputFilter *const ofilter = ofilter_alloc(fg); const enum AVMediaType type = avfilter_pad_get_type(cur->filter_ctx->output_pads,
cur->pad_idx);
OutputFilter *const ofilter = ofilter_alloc(fg, type);
if (!ofilter) { if (!ofilter) {
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
@ -1035,8 +1068,6 @@ int fg_create(FilterGraph **pfg, char *graph_desc, Scheduler *sch)
ofilter->linklabel = cur->name; ofilter->linklabel = cur->name;
cur->name = NULL; cur->name = NULL;
ofilter->type = avfilter_pad_get_type(cur->filter_ctx->output_pads,
cur->pad_idx);
ofilter->name = describe_filter_link(fg, cur, 0); ofilter->name = describe_filter_link(fg, cur, 0);
if (!ofilter->name) { if (!ofilter->name) {
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
@ -1400,7 +1431,7 @@ static int configure_output_audio_filter(FilterGraph *fg, AVFilterGraph *graph,
#define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \ #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \
AVFilterContext *filt_ctx; \ AVFilterContext *filt_ctx; \
\ \
av_log(fg, AV_LOG_INFO, opt_name " is forwarded to lavfi " \ av_log(ofilter, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
"similarly to -af " filter_name "=%s.\n", arg); \ "similarly to -af " filter_name "=%s.\n", arg); \
\ \
ret = avfilter_graph_create_filter(&filt_ctx, \ ret = avfilter_graph_create_filter(&filt_ctx, \
@ -1929,7 +1960,7 @@ static int choose_out_timebase(OutputFilterPriv *ofp, AVFrame *frame)
// apply -enc_time_base // apply -enc_time_base
if (ofp->enc_timebase.num == ENC_TIME_BASE_DEMUX && if (ofp->enc_timebase.num == ENC_TIME_BASE_DEMUX &&
(fd->dec.tb.num <= 0 || fd->dec.tb.den <= 0)) { (fd->dec.tb.num <= 0 || fd->dec.tb.den <= 0)) {
av_log(ofilter->ost, AV_LOG_ERROR, av_log(ofp, AV_LOG_ERROR,
"Demuxing timebase not available - cannot use it for encoding\n"); "Demuxing timebase not available - cannot use it for encoding\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -1956,7 +1987,7 @@ static int choose_out_timebase(OutputFilterPriv *ofp, AVFrame *frame)
if (fps->vsync_method == VSYNC_CFR || fps->vsync_method == VSYNC_VSCFR) { if (fps->vsync_method == VSYNC_CFR || fps->vsync_method == VSYNC_VSCFR) {
if (!fr.num && !fps->framerate_max.num) { if (!fr.num && !fps->framerate_max.num) {
fr = (AVRational){25, 1}; fr = (AVRational){25, 1};
av_log(ofilter->ost, AV_LOG_WARNING, av_log(ofp, AV_LOG_WARNING,
"No information " "No information "
"about the input framerate is available. Falling " "about the input framerate is available. Falling "
"back to a default value of 25fps. Use the -r option " "back to a default value of 25fps. Use the -r option "
@ -2039,7 +2070,6 @@ static void video_sync_process(OutputFilterPriv *ofp, AVFrame *frame,
int64_t *nb_frames, int64_t *nb_frames_prev) int64_t *nb_frames, int64_t *nb_frames_prev)
{ {
OutputFilter *ofilter = &ofp->ofilter; OutputFilter *ofilter = &ofp->ofilter;
OutputStream *ost = ofilter->ost;
FPSConvContext *fps = &ofp->fps; FPSConvContext *fps = &ofp->fps;
double delta0, delta, sync_ipts, duration; double delta0, delta, sync_ipts, duration;
@ -2078,9 +2108,9 @@ static void video_sync_process(OutputFilterPriv *ofp, AVFrame *frame,
#endif #endif
) { ) {
if (delta0 < -0.6) { if (delta0 < -0.6) {
av_log(ost, AV_LOG_VERBOSE, "Past duration %f too large\n", -delta0); av_log(ofp, AV_LOG_VERBOSE, "Past duration %f too large\n", -delta0);
} else } else
av_log(ost, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0); av_log(ofp, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
sync_ipts = ofp->next_pts; sync_ipts = ofp->next_pts;
duration += delta0; duration += delta0;
delta0 = 0; delta0 = 0;
@ -2089,7 +2119,7 @@ static void video_sync_process(OutputFilterPriv *ofp, AVFrame *frame,
switch (fps->vsync_method) { switch (fps->vsync_method) {
case VSYNC_VSCFR: case VSYNC_VSCFR:
if (fps->frame_number == 0 && delta0 >= 0.5) { if (fps->frame_number == 0 && delta0 >= 0.5) {
av_log(ost, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0)); av_log(ofp, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
delta = duration; delta = duration;
delta0 = 0; delta0 = 0;
ofp->next_pts = llrint(sync_ipts); ofp->next_pts = llrint(sync_ipts);
@ -2133,23 +2163,23 @@ finish:
if (*nb_frames_prev == 0 && fps->last_dropped) { if (*nb_frames_prev == 0 && fps->last_dropped) {
atomic_fetch_add(&ofilter->nb_frames_drop, 1); atomic_fetch_add(&ofilter->nb_frames_drop, 1);
av_log(ost, AV_LOG_VERBOSE, av_log(ofp, AV_LOG_VERBOSE,
"*** dropping frame %"PRId64" at ts %"PRId64"\n", "*** dropping frame %"PRId64" at ts %"PRId64"\n",
fps->frame_number, fps->last_frame->pts); fps->frame_number, fps->last_frame->pts);
} }
if (*nb_frames > (*nb_frames_prev && fps->last_dropped) + (*nb_frames > *nb_frames_prev)) { if (*nb_frames > (*nb_frames_prev && fps->last_dropped) + (*nb_frames > *nb_frames_prev)) {
uint64_t nb_frames_dup; uint64_t nb_frames_dup;
if (*nb_frames > dts_error_threshold * 30) { if (*nb_frames > dts_error_threshold * 30) {
av_log(ost, AV_LOG_ERROR, "%"PRId64" frame duplication too large, skipping\n", *nb_frames - 1); av_log(ofp, AV_LOG_ERROR, "%"PRId64" frame duplication too large, skipping\n", *nb_frames - 1);
atomic_fetch_add(&ofilter->nb_frames_drop, 1); atomic_fetch_add(&ofilter->nb_frames_drop, 1);
*nb_frames = 0; *nb_frames = 0;
return; return;
} }
nb_frames_dup = atomic_fetch_add(&ofilter->nb_frames_dup, nb_frames_dup = atomic_fetch_add(&ofilter->nb_frames_dup,
*nb_frames - (*nb_frames_prev && fps->last_dropped) - (*nb_frames > *nb_frames_prev)); *nb_frames - (*nb_frames_prev && fps->last_dropped) - (*nb_frames > *nb_frames_prev));
av_log(ost, AV_LOG_VERBOSE, "*** %"PRId64" dup!\n", *nb_frames - 1); av_log(ofp, AV_LOG_VERBOSE, "*** %"PRId64" dup!\n", *nb_frames - 1);
if (nb_frames_dup > fps->dup_warning) { if (nb_frames_dup > fps->dup_warning) {
av_log(ost, AV_LOG_WARNING, "More than %"PRIu64" frames duplicated\n", fps->dup_warning); av_log(ofp, AV_LOG_WARNING, "More than %"PRIu64" frames duplicated\n", fps->dup_warning);
fps->dup_warning *= 10; fps->dup_warning *= 10;
} }
} }
@ -2191,7 +2221,7 @@ static int close_output(OutputFilterPriv *ofp, FilterGraphThread *fgt)
av_assert0(!frame->buf[0]); av_assert0(!frame->buf[0]);
av_log(ofp->ofilter.ost, AV_LOG_WARNING, av_log(ofp, AV_LOG_WARNING,
"No filtered frames for output stream, trying to " "No filtered frames for output stream, trying to "
"initialize anyway.\n"); "initialize anyway.\n");
@ -2308,7 +2338,7 @@ static int fg_output_step(OutputFilterPriv *ofp, FilterGraphThread *fgt,
} else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) { } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
return 1; return 1;
} else if (ret < 0) { } else if (ret < 0) {
av_log(fgp, AV_LOG_WARNING, av_log(ofp, AV_LOG_WARNING,
"Error in retrieving a frame from the filtergraph: %s\n", "Error in retrieving a frame from the filtergraph: %s\n",
av_err2str(ret)); av_err2str(ret));
return ret; return ret;
@ -2322,7 +2352,7 @@ static int fg_output_step(OutputFilterPriv *ofp, FilterGraphThread *fgt,
frame->time_base = av_buffersink_get_time_base(filter); frame->time_base = av_buffersink_get_time_base(filter);
if (debug_ts) if (debug_ts)
av_log(fgp, AV_LOG_INFO, "filter_raw -> pts:%s pts_time:%s time_base:%d/%d\n", av_log(ofp, AV_LOG_INFO, "filter_raw -> pts:%s pts_time:%s time_base:%d/%d\n",
av_ts2str(frame->pts), av_ts2timestr(frame->pts, &frame->time_base), av_ts2str(frame->pts), av_ts2timestr(frame->pts, &frame->time_base),
frame->time_base.num, frame->time_base.den); frame->time_base.num, frame->time_base.den);
@ -2330,7 +2360,7 @@ static int fg_output_step(OutputFilterPriv *ofp, FilterGraphThread *fgt,
if (!ofp->tb_out_locked) { if (!ofp->tb_out_locked) {
ret = choose_out_timebase(ofp, frame); ret = choose_out_timebase(ofp, frame);
if (ret < 0) { if (ret < 0) {
av_log(ost, AV_LOG_ERROR, "Could not choose an output time base\n"); av_log(ofp, AV_LOG_ERROR, "Could not choose an output time base\n");
av_frame_unref(frame); av_frame_unref(frame);
return ret; return ret;
} }

Write Preview
Loading…
Cancel
Save