| /* |
| * ffmpeg filter configuration |
| * |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include <stdint.h> |
| |
| #include "ffmpeg.h" |
| |
| #include "libavfilter/avfilter.h" |
| #include "libavfilter/buffersink.h" |
| #include "libavfilter/buffersrc.h" |
| |
| #include "libavutil/avassert.h" |
| #include "libavutil/avstring.h" |
| #include "libavutil/bprint.h" |
| #include "libavutil/channel_layout.h" |
| #include "libavutil/mem.h" |
| #include "libavutil/opt.h" |
| #include "libavutil/pixdesc.h" |
| #include "libavutil/pixfmt.h" |
| #include "libavutil/samplefmt.h" |
| #include "libavutil/time.h" |
| #include "libavutil/timestamp.h" |
| |
| // FIXME private header, used for mid_pred() |
| #include "libavcodec/mathops.h" |
| |
| typedef struct FilterGraphPriv { |
| FilterGraph fg; |
| |
| // name used for logging |
| char log_name[32]; |
| |
| int is_simple; |
| // true when the filtergraph contains only meta filters |
| // that do not modify the frame data |
| int is_meta; |
| // source filters are present in the graph |
| int have_sources; |
| int disable_conversions; |
| |
| unsigned nb_outputs_done; |
| |
| const char *graph_desc; |
| |
| char *nb_threads; |
| |
| // frame for temporarily holding output from the filtergraph |
| AVFrame *frame; |
| // frame for sending output to the encoder |
| AVFrame *frame_enc; |
| |
| Scheduler *sch; |
| unsigned sch_idx; |
| } FilterGraphPriv; |
| |
| static FilterGraphPriv *fgp_from_fg(FilterGraph *fg) |
| { |
| return (FilterGraphPriv*)fg; |
| } |
| |
| static const FilterGraphPriv *cfgp_from_cfg(const FilterGraph *fg) |
| { |
| return (const FilterGraphPriv*)fg; |
| } |
| |
| // data that is local to the filter thread and not visible outside of it |
| typedef struct FilterGraphThread { |
| AVFilterGraph *graph; |
| |
| AVFrame *frame; |
| |
| // Temporary buffer for output frames, since on filtergraph reset |
| // we cannot send them to encoders immediately. |
| // The output index is stored in frame opaque. |
| AVFifo *frame_queue_out; |
| |
| // index of the next input to request from the scheduler |
| unsigned next_in; |
| // set to 1 after at least one frame passed through this output |
| int got_frame; |
| |
| // EOF status of each input/output, as received by the thread |
| uint8_t *eof_in; |
| uint8_t *eof_out; |
| } FilterGraphThread; |
| |
| typedef struct InputFilterPriv { |
| InputFilter ifilter; |
| |
| InputFilterOptions opts; |
| |
| int index; |
| |
| AVFilterContext *filter; |
| |
| // used to hold submitted input |
| AVFrame *frame; |
| |
| /* for filters that are not yet bound to an input stream, |
| * this stores the input linklabel, if any */ |
| uint8_t *linklabel; |
| |
| // filter data type |
| enum AVMediaType type; |
| // source data type: AVMEDIA_TYPE_SUBTITLE for sub2video, |
| // same as type otherwise |
| enum AVMediaType type_src; |
| |
| int eof; |
| int bound; |
| |
| // parameters configured for this input |
| int format; |
| |
| int width, height; |
| AVRational sample_aspect_ratio; |
| enum AVColorSpace color_space; |
| enum AVColorRange color_range; |
| |
| int sample_rate; |
| AVChannelLayout ch_layout; |
| |
| AVRational time_base; |
| |
| AVFifo *frame_queue; |
| |
| AVBufferRef *hw_frames_ctx; |
| |
| int displaymatrix_present; |
| int displaymatrix_applied; |
| int32_t displaymatrix[9]; |
| |
| struct { |
| AVFrame *frame; |
| |
| int64_t last_pts; |
| int64_t end_pts; |
| |
| ///< marks if sub2video_update should force an initialization |
| unsigned int initialize; |
| } sub2video; |
| } InputFilterPriv; |
| |
| static InputFilterPriv *ifp_from_ifilter(InputFilter *ifilter) |
| { |
| return (InputFilterPriv*)ifilter; |
| } |
| |
| typedef struct FPSConvContext { |
| AVFrame *last_frame; |
| /* number of frames emitted by the video-encoding sync code */ |
| int64_t frame_number; |
| /* history of nb_frames_prev, i.e. the number of times the |
| * previous frame was duplicated by vsync code in recent |
| * do_video_out() calls */ |
| int64_t frames_prev_hist[3]; |
| |
| uint64_t dup_warning; |
| |
| int last_dropped; |
| int dropped_keyframe; |
| |
| enum VideoSyncMethod vsync_method; |
| |
| AVRational framerate; |
| AVRational framerate_max; |
| const AVRational *framerate_supported; |
| int framerate_clip; |
| } FPSConvContext; |
| |
| typedef struct OutputFilterPriv { |
| OutputFilter ofilter; |
| |
| int index; |
| |
| void *log_parent; |
| char log_name[32]; |
| |
| char *name; |
| |
| AVFilterContext *filter; |
| |
| /* desired output stream properties */ |
| int format; |
| int width, height; |
| int sample_rate; |
| AVChannelLayout ch_layout; |
| |
| // time base in which the output is sent to our downstream |
| // does not need to match the filtersink's timebase |
| AVRational tb_out; |
| // at least one frame with the above timebase was sent |
| // to our downstream, so it cannot change anymore |
| int tb_out_locked; |
| |
| AVRational sample_aspect_ratio; |
| |
| AVDictionary *sws_opts; |
| AVDictionary *swr_opts; |
| |
| // those are only set if no format is specified and the encoder gives us multiple options |
| // They point directly to the relevant lists of the encoder. |
| const int *formats; |
| const AVChannelLayout *ch_layouts; |
| const int *sample_rates; |
| |
| AVRational enc_timebase; |
| int64_t trim_start_us; |
| int64_t trim_duration_us; |
| // offset for output timestamps, in AV_TIME_BASE_Q |
| int64_t ts_offset; |
| int64_t next_pts; |
| FPSConvContext fps; |
| |
| unsigned flags; |
| } OutputFilterPriv; |
| |
| static OutputFilterPriv *ofp_from_ofilter(OutputFilter *ofilter) |
| { |
| return (OutputFilterPriv*)ofilter; |
| } |
| |
| typedef struct FilterCommand { |
| char *target; |
| char *command; |
| char *arg; |
| |
| double time; |
| int all_filters; |
| } FilterCommand; |
| |
| static void filter_command_free(void *opaque, uint8_t *data) |
| { |
| FilterCommand *fc = (FilterCommand*)data; |
| |
| av_freep(&fc->target); |
| av_freep(&fc->command); |
| av_freep(&fc->arg); |
| |
| av_free(data); |
| } |
| |
| static int sub2video_get_blank_frame(InputFilterPriv *ifp) |
| { |
| AVFrame *frame = ifp->sub2video.frame; |
| int ret; |
| |
| av_frame_unref(frame); |
| |
| frame->width = ifp->width; |
| frame->height = ifp->height; |
| frame->format = ifp->format; |
| frame->colorspace = ifp->color_space; |
| frame->color_range = ifp->color_range; |
| |
| ret = av_frame_get_buffer(frame, 0); |
| if (ret < 0) |
| return ret; |
| |
| memset(frame->data[0], 0, frame->height * frame->linesize[0]); |
| |
| return 0; |
| } |
| |
| static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h, |
| AVSubtitleRect *r) |
| { |
| uint32_t *pal, *dst2; |
| uint8_t *src, *src2; |
| int x, y; |
| |
| if (r->type != SUBTITLE_BITMAP) { |
| av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n"); |
| return; |
| } |
| if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) { |
| av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle (%d %d %d %d) overflowing %d %d\n", |
| r->x, r->y, r->w, r->h, w, h |
| ); |
| return; |
| } |
| |
| dst += r->y * dst_linesize + r->x * 4; |
| src = r->data[0]; |
| pal = (uint32_t *)r->data[1]; |
| for (y = 0; y < r->h; y++) { |
| dst2 = (uint32_t *)dst; |
| src2 = src; |
| for (x = 0; x < r->w; x++) |
| *(dst2++) = pal[*(src2++)]; |
| dst += dst_linesize; |
| src += r->linesize[0]; |
| } |
| } |
| |
| static void sub2video_push_ref(InputFilterPriv *ifp, int64_t pts) |
| { |
| AVFrame *frame = ifp->sub2video.frame; |
| int ret; |
| |
| av_assert1(frame->data[0]); |
| ifp->sub2video.last_pts = frame->pts = pts; |
| ret = av_buffersrc_add_frame_flags(ifp->filter, frame, |
| AV_BUFFERSRC_FLAG_KEEP_REF | |
| AV_BUFFERSRC_FLAG_PUSH); |
| if (ret != AVERROR_EOF && ret < 0) |
| av_log(NULL, AV_LOG_WARNING, "Error while add the frame to buffer source(%s).\n", |
| av_err2str(ret)); |
| } |
| |
| static void sub2video_update(InputFilterPriv *ifp, int64_t heartbeat_pts, |
| const AVSubtitle *sub) |
| { |
| AVFrame *frame = ifp->sub2video.frame; |
| int8_t *dst; |
| int dst_linesize; |
| int num_rects; |
| int64_t pts, end_pts; |
| |
| if (sub) { |
| pts = av_rescale_q(sub->pts + sub->start_display_time * 1000LL, |
| AV_TIME_BASE_Q, ifp->time_base); |
| end_pts = av_rescale_q(sub->pts + sub->end_display_time * 1000LL, |
| AV_TIME_BASE_Q, ifp->time_base); |
| num_rects = sub->num_rects; |
| } else { |
| /* If we are initializing the system, utilize current heartbeat |
| PTS as the start time, and show until the following subpicture |
| is received. Otherwise, utilize the previous subpicture's end time |
| as the fall-back value. */ |
| pts = ifp->sub2video.initialize ? |
| heartbeat_pts : ifp->sub2video.end_pts; |
| end_pts = INT64_MAX; |
| num_rects = 0; |
| } |
| if (sub2video_get_blank_frame(ifp) < 0) { |
| av_log(NULL, AV_LOG_ERROR, |
| "Impossible to get a blank canvas.\n"); |
| return; |
| } |
| dst = frame->data [0]; |
| dst_linesize = frame->linesize[0]; |
| for (int i = 0; i < num_rects; i++) |
| sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]); |
| sub2video_push_ref(ifp, pts); |
| ifp->sub2video.end_pts = end_pts; |
| ifp->sub2video.initialize = 0; |
| } |
| |
| /* *dst may return be set to NULL (no pixel format found), a static string or a |
| * string backed by the bprint. Nothing has been written to the AVBPrint in case |
| * NULL is returned. The AVBPrint provided should be clean. */ |
| static int choose_pix_fmts(OutputFilter *ofilter, AVBPrint *bprint, |
| const char **dst) |
| { |
| OutputFilterPriv *ofp = ofp_from_ofilter(ofilter); |
| |
| *dst = NULL; |
| |
| if (ofp->flags & OFILTER_FLAG_DISABLE_CONVERT || ofp->format != AV_PIX_FMT_NONE) { |
| *dst = ofp->format == AV_PIX_FMT_NONE ? NULL : |
| av_get_pix_fmt_name(ofp->format); |
| } else if (ofp->formats) { |
| const enum AVPixelFormat *p = ofp->formats; |
| |
| for (; *p != AV_PIX_FMT_NONE; p++) { |
| const char *name = av_get_pix_fmt_name(*p); |
| av_bprintf(bprint, "%s%c", name, p[1] == AV_PIX_FMT_NONE ? '\0' : '|'); |
| } |
| if (!av_bprint_is_complete(bprint)) |
| return AVERROR(ENOMEM); |
| |
| *dst = bprint->str; |
| } |
| |
| return 0; |
| } |
| |
| /* Define a function for appending a list of allowed formats |
| * to an AVBPrint. If nonempty, the list will have a header. */ |
| #define DEF_CHOOSE_FORMAT(name, type, var, supported_list, none, printf_format, get_name) \ |
| static void choose_ ## name (OutputFilterPriv *ofp, AVBPrint *bprint) \ |
| { \ |
| if (ofp->var == none && !ofp->supported_list) \ |
| return; \ |
| av_bprintf(bprint, #name "="); \ |
| if (ofp->var != none) { \ |
| av_bprintf(bprint, printf_format, get_name(ofp->var)); \ |
| } else { \ |
| const type *p; \ |
| \ |
| for (p = ofp->supported_list; *p != none; p++) { \ |
| av_bprintf(bprint, printf_format "|", get_name(*p)); \ |
| } \ |
| if (bprint->len > 0) \ |
| bprint->str[--bprint->len] = '\0'; \ |
| } \ |
| av_bprint_chars(bprint, ':', 1); \ |
| } |
| |
| //DEF_CHOOSE_FORMAT(pix_fmts, enum AVPixelFormat, format, formats, AV_PIX_FMT_NONE, |
| // GET_PIX_FMT_NAME) |
| |
| DEF_CHOOSE_FORMAT(sample_fmts, enum AVSampleFormat, format, formats, |
| AV_SAMPLE_FMT_NONE, "%s", av_get_sample_fmt_name) |
| |
| DEF_CHOOSE_FORMAT(sample_rates, int, sample_rate, sample_rates, 0, |
| "%d", ) |
| |
| static void choose_channel_layouts(OutputFilterPriv *ofp, AVBPrint *bprint) |
| { |
| if (av_channel_layout_check(&ofp->ch_layout)) { |
| av_bprintf(bprint, "channel_layouts="); |
| av_channel_layout_describe_bprint(&ofp->ch_layout, bprint); |
| } else if (ofp->ch_layouts) { |
| const AVChannelLayout *p; |
| |
| av_bprintf(bprint, "channel_layouts="); |
| for (p = ofp->ch_layouts; p->nb_channels; p++) { |
| av_channel_layout_describe_bprint(p, bprint); |
| av_bprintf(bprint, "|"); |
| } |
| if (bprint->len > 0) |
| bprint->str[--bprint->len] = '\0'; |
| } else |
| return; |
| av_bprint_chars(bprint, ':', 1); |
| } |
| |
| static int read_binary(const char *path, uint8_t **data, int *len) |
| { |
| AVIOContext *io = NULL; |
| int64_t fsize; |
| int ret; |
| |
| *data = NULL; |
| *len = 0; |
| |
| ret = avio_open2(&io, path, AVIO_FLAG_READ, &int_cb, NULL); |
| if (ret < 0) { |
| av_log(NULL, AV_LOG_ERROR, "Cannot open file '%s': %s\n", |
| path, av_err2str(ret)); |
| return ret; |
| } |
| |
| fsize = avio_size(io); |
| if (fsize < 0 || fsize > INT_MAX) { |
| av_log(NULL, AV_LOG_ERROR, "Cannot obtain size of file %s\n", path); |
| ret = AVERROR(EIO); |
| goto fail; |
| } |
| |
| *data = av_malloc(fsize); |
| if (!*data) { |
| ret = AVERROR(ENOMEM); |
| goto fail; |
| } |
| |
| ret = avio_read(io, *data, fsize); |
| if (ret != fsize) { |
| av_log(NULL, AV_LOG_ERROR, "Error reading file %s\n", path); |
| ret = ret < 0 ? ret : AVERROR(EIO); |
| goto fail; |
| } |
| |
| *len = fsize; |
| |
| ret = 0; |
| fail: |
| avio_close(io); |
| if (ret < 0) { |
| av_freep(data); |
| *len = 0; |
| } |
| return ret; |
| } |
| |
| static int filter_opt_apply(AVFilterContext *f, const char *key, const char *val) |
| { |
| const AVOption *o = NULL; |
| int ret; |
| |
| ret = av_opt_set(f, key, val, AV_OPT_SEARCH_CHILDREN); |
| if (ret >= 0) |
| return 0; |
| |
| if (ret == AVERROR_OPTION_NOT_FOUND && key[0] == '/') |
| o = av_opt_find(f, key + 1, NULL, 0, AV_OPT_SEARCH_CHILDREN); |
| if (!o) |
| goto err_apply; |
| |
| // key is a valid option name prefixed with '/' |
| // interpret value as a path from which to load the actual option value |
| key++; |
| |
| if (o->type == AV_OPT_TYPE_BINARY) { |
| uint8_t *data; |
| int len; |
| |
| ret = read_binary(val, &data, &len); |
| if (ret < 0) |
| goto err_load; |
| |
| ret = av_opt_set_bin(f, key, data, len, AV_OPT_SEARCH_CHILDREN); |
| av_freep(&data); |
| } else { |
| char *data = file_read(val); |
| if (!data) { |
| ret = AVERROR(EIO); |
| goto err_load; |
| } |
| |
| ret = av_opt_set(f, key, data, AV_OPT_SEARCH_CHILDREN); |
| av_freep(&data); |
| } |
| if (ret < 0) |
| goto err_apply; |
| |
| return 0; |
| |
| err_apply: |
| av_log(NULL, AV_LOG_ERROR, |
| "Error applying option '%s' to filter '%s': %s\n", |
| key, f->filter->name, av_err2str(ret)); |
| return ret; |
| err_load: |
| av_log(NULL, AV_LOG_ERROR, |
| "Error loading value for option '%s' from file '%s'\n", |
| key, val); |
| return ret; |
| } |
| |
| static int graph_opts_apply(AVFilterGraphSegment *seg) |
| { |
| for (size_t i = 0; i < seg->nb_chains; i++) { |
| AVFilterChain *ch = seg->chains[i]; |
| |
| for (size_t j = 0; j < ch->nb_filters; j++) { |
| AVFilterParams *p = ch->filters[j]; |
| const AVDictionaryEntry *e = NULL; |
| |
| av_assert0(p->filter); |
| |
| while ((e = av_dict_iterate(p->opts, e))) { |
| int ret = filter_opt_apply(p->filter, e->key, e->value); |
| if (ret < 0) |
| return ret; |
| } |
| |
| av_dict_free(&p->opts); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int graph_parse(AVFilterGraph *graph, const char *desc, |
| AVFilterInOut **inputs, AVFilterInOut **outputs, |
| AVBufferRef *hw_device) |
| { |
| AVFilterGraphSegment *seg; |
| int ret; |
| |
| *inputs = NULL; |
| *outputs = NULL; |
| |
| ret = avfilter_graph_segment_parse(graph, desc, 0, &seg); |
| if (ret < 0) |
| return ret; |
| |
| ret = avfilter_graph_segment_create_filters(seg, 0); |
| if (ret < 0) |
| goto fail; |
| |
| if (hw_device) { |
| for (int i = 0; i < graph->nb_filters; i++) { |
| AVFilterContext *f = graph->filters[i]; |
| |
| if (!(f->filter->flags & AVFILTER_FLAG_HWDEVICE)) |
| continue; |
| f->hw_device_ctx = av_buffer_ref(hw_device); |
| if (!f->hw_device_ctx) { |
| ret = AVERROR(ENOMEM); |
| goto fail; |
| } |
| } |
| } |
| |
| ret = graph_opts_apply(seg); |
| if (ret < 0) |
| goto fail; |
| |
| ret = avfilter_graph_segment_apply(seg, 0, inputs, outputs); |
| |
| fail: |
| avfilter_graph_segment_free(&seg); |
| return ret; |
| } |
| |
| // Filters can be configured only if the formats of all inputs are known. |
| static int ifilter_has_all_input_formats(FilterGraph *fg) |
| { |
| for (int i = 0; i < fg->nb_inputs; i++) { |
| InputFilterPriv *ifp = ifp_from_ifilter(fg->inputs[i]); |
| if (ifp->format < 0) |
| return 0; |
| } |
| return 1; |
| } |
| |
| static int filter_thread(void *arg); |
| |
| static char *describe_filter_link(FilterGraph *fg, AVFilterInOut *inout, int in) |
| { |
| AVFilterContext *ctx = inout->filter_ctx; |
| AVFilterPad *pads = in ? ctx->input_pads : ctx->output_pads; |
| int nb_pads = in ? ctx->nb_inputs : ctx->nb_outputs; |
| |
| if (nb_pads > 1) |
| return av_strdup(ctx->filter->name); |
| return av_asprintf("%s:%s", ctx->filter->name, |
| avfilter_pad_get_name(pads, inout->pad_idx)); |
| } |
| |
| 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; |
| OutputFilter *ofilter; |
| |
| ofp = allocate_array_elem(&fg->outputs, sizeof(*ofp), &fg->nb_outputs); |
| if (!ofp) |
| return NULL; |
| |
| ofilter = &ofp->ofilter; |
| ofilter->class = &ofilter_class; |
| ofp->log_parent = fg; |
| ofilter->graph = fg; |
| ofilter->type = type; |
| ofp->format = -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; |
| } |
| |
| static int ifilter_bind_ist(InputFilter *ifilter, InputStream *ist) |
| { |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| FilterGraphPriv *fgp = fgp_from_fg(ifilter->graph); |
| int ret, dec_idx; |
| |
| av_assert0(!ifp->bound); |
| ifp->bound = 1; |
| |
| if (ifp->type != ist->par->codec_type && |
| !(ifp->type == AVMEDIA_TYPE_VIDEO && ist->par->codec_type == AVMEDIA_TYPE_SUBTITLE)) { |
| av_log(fgp, AV_LOG_ERROR, "Tried to connect %s stream to %s filtergraph input\n", |
| av_get_media_type_string(ist->par->codec_type), av_get_media_type_string(ifp->type)); |
| return AVERROR(EINVAL); |
| } |
| |
| ifp->type_src = ist->st->codecpar->codec_type; |
| |
| ifp->opts.fallback = av_frame_alloc(); |
| if (!ifp->opts.fallback) |
| return AVERROR(ENOMEM); |
| |
| dec_idx = ist_filter_add(ist, ifilter, filtergraph_is_simple(ifilter->graph), |
| &ifp->opts); |
| if (dec_idx < 0) |
| return dec_idx; |
| |
| ret = sch_connect(fgp->sch, SCH_DEC(dec_idx), |
| SCH_FILTER_IN(fgp->sch_idx, ifp->index)); |
| if (ret < 0) |
| return ret; |
| |
| if (ifp->type_src == AVMEDIA_TYPE_SUBTITLE) { |
| ifp->sub2video.frame = av_frame_alloc(); |
| if (!ifp->sub2video.frame) |
| return AVERROR(ENOMEM); |
| |
| ifp->width = ifp->opts.sub2video_width; |
| ifp->height = ifp->opts.sub2video_height; |
| |
| /* rectangles are AV_PIX_FMT_PAL8, but we have no guarantee that the |
| palettes for all rectangles are identical or compatible */ |
| ifp->format = AV_PIX_FMT_RGB32; |
| |
| ifp->time_base = AV_TIME_BASE_Q; |
| |
| av_log(fgp, AV_LOG_VERBOSE, "sub2video: using %dx%d canvas\n", |
| ifp->width, ifp->height); |
| } |
| |
| return 0; |
| } |
| |
| static int ifilter_bind_dec(InputFilterPriv *ifp, Decoder *dec) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(ifp->ifilter.graph); |
| int ret, dec_idx; |
| |
| av_assert0(!ifp->bound); |
| ifp->bound = 1; |
| |
| if (ifp->type != dec->type) { |
| av_log(fgp, AV_LOG_ERROR, "Tried to connect %s decoder to %s filtergraph input\n", |
| av_get_media_type_string(dec->type), av_get_media_type_string(ifp->type)); |
| return AVERROR(EINVAL); |
| } |
| |
| ifp->type_src = ifp->type; |
| |
| dec_idx = dec_filter_add(dec, &ifp->ifilter, &ifp->opts); |
| if (dec_idx < 0) |
| return dec_idx; |
| |
| ret = sch_connect(fgp->sch, SCH_DEC(dec_idx), |
| SCH_FILTER_IN(fgp->sch_idx, ifp->index)); |
| if (ret < 0) |
| return ret; |
| |
| return 0; |
| } |
| |
| static int set_channel_layout(OutputFilterPriv *f, const AVChannelLayout *layouts_allowed, |
| const AVChannelLayout *layout_requested) |
| { |
| int i, err; |
| |
| if (layout_requested->order != AV_CHANNEL_ORDER_UNSPEC) { |
| /* Pass the layout through for all orders but UNSPEC */ |
| err = av_channel_layout_copy(&f->ch_layout, layout_requested); |
| if (err < 0) |
| return err; |
| return 0; |
| } |
| |
| /* Requested layout is of order UNSPEC */ |
| if (!layouts_allowed) { |
| /* Use the default native layout for the requested amount of channels when the |
| encoder doesn't have a list of supported layouts */ |
| av_channel_layout_default(&f->ch_layout, layout_requested->nb_channels); |
| return 0; |
| } |
| /* Encoder has a list of supported layouts. Pick the first layout in it with the |
| same amount of channels as the requested layout */ |
| for (i = 0; layouts_allowed[i].nb_channels; i++) { |
| if (layouts_allowed[i].nb_channels == layout_requested->nb_channels) |
| break; |
| } |
| if (layouts_allowed[i].nb_channels) { |
| /* Use it if one is found */ |
| err = av_channel_layout_copy(&f->ch_layout, &layouts_allowed[i]); |
| if (err < 0) |
| return err; |
| return 0; |
| } |
| /* If no layout for the amount of channels requested was found, use the default |
| native layout for it. */ |
| av_channel_layout_default(&f->ch_layout, layout_requested->nb_channels); |
| |
| return 0; |
| } |
| |
| int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost, |
| unsigned sched_idx_enc, |
| const OutputFilterOptions *opts) |
| { |
| OutputFilterPriv *ofp = ofp_from_ofilter(ofilter); |
| FilterGraph *fg = ofilter->graph; |
| FilterGraphPriv *fgp = fgp_from_fg(fg); |
| int ret; |
| |
| av_assert0(!ofilter->bound); |
| av_assert0(ofilter->type == ost->type); |
| |
| ofilter->bound = 1; |
| av_freep(&ofilter->linklabel); |
| |
| ofp->flags = opts->flags; |
| ofp->ts_offset = opts->ts_offset; |
| ofp->enc_timebase = opts->output_tb; |
| |
| ofp->trim_start_us = opts->trim_start_us; |
| ofp->trim_duration_us = opts->trim_duration_us; |
| |
| ofp->name = av_strdup(opts->name); |
| if (!ofp->name) |
| return AVERROR(EINVAL); |
| |
| ret = av_dict_copy(&ofp->sws_opts, opts->sws_opts, 0); |
| if (ret < 0) |
| return ret; |
| |
| ret = av_dict_copy(&ofp->swr_opts, opts->swr_opts, 0); |
| if (ret < 0) |
| return ret; |
| |
| if (opts->flags & OFILTER_FLAG_AUDIO_24BIT) |
| av_dict_set(&ofp->swr_opts, "output_sample_bits", "24", 0); |
| |
| 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) { |
| case AVMEDIA_TYPE_VIDEO: |
| ofp->width = opts->width; |
| ofp->height = opts->height; |
| if (opts->format != AV_PIX_FMT_NONE) { |
| ofp->format = opts->format; |
| } else if (opts->pix_fmts) |
| ofp->formats = opts->pix_fmts; |
| else if (opts->enc) |
| ofp->formats = opts->enc->pix_fmts; |
| |
| fgp->disable_conversions |= !!(ofp->flags & OFILTER_FLAG_DISABLE_CONVERT); |
| |
| ofp->fps.last_frame = av_frame_alloc(); |
| if (!ofp->fps.last_frame) |
| return AVERROR(ENOMEM); |
| |
| ofp->fps.vsync_method = opts->vsync_method; |
| ofp->fps.framerate = ost->frame_rate; |
| ofp->fps.framerate_max = ost->max_frame_rate; |
| ofp->fps.framerate_supported = ost->force_fps || !opts->enc ? |
| NULL : opts->enc->supported_framerates; |
| |
| // reduce frame rate for mpeg4 to be within the spec limits |
| if (opts->enc && opts->enc->id == AV_CODEC_ID_MPEG4) |
| ofp->fps.framerate_clip = 65535; |
| |
| ofp->fps.dup_warning = 1000; |
| |
| break; |
| case AVMEDIA_TYPE_AUDIO: |
| if (opts->format != AV_SAMPLE_FMT_NONE) { |
| ofp->format = opts->format; |
| } else if (opts->enc) { |
| ofp->formats = opts->enc->sample_fmts; |
| } |
| if (opts->sample_rate) { |
| ofp->sample_rate = opts->sample_rate; |
| } else if (opts->enc) { |
| ofp->sample_rates = opts->enc->supported_samplerates; |
| } |
| if (opts->ch_layout.nb_channels) { |
| int ret = set_channel_layout(ofp, opts->enc ? opts->enc->ch_layouts : NULL, |
| &opts->ch_layout); |
| if (ret < 0) |
| return ret; |
| } else if (opts->enc) { |
| ofp->ch_layouts = opts->enc->ch_layouts; |
| } |
| break; |
| } |
| |
| ret = sch_connect(fgp->sch, SCH_FILTER_OUT(fgp->sch_idx, ofp->index), |
| SCH_ENC(sched_idx_enc)); |
| if (ret < 0) |
| return ret; |
| |
| return 0; |
| } |
| |
| static int ofilter_bind_ifilter(OutputFilter *ofilter, InputFilterPriv *ifp, |
| const OutputFilterOptions *opts) |
| { |
| OutputFilterPriv *ofp = ofp_from_ofilter(ofilter); |
| |
| av_assert0(!ofilter->bound); |
| av_assert0(ofilter->type == ifp->type); |
| |
| ofilter->bound = 1; |
| av_freep(&ofilter->linklabel); |
| |
| ofp->name = av_strdup(opts->name); |
| if (!ofp->name) |
| return AVERROR(EINVAL); |
| |
| av_strlcatf(ofp->log_name, sizeof(ofp->log_name), "->%s", ofp->name); |
| |
| return 0; |
| } |
| |
| static int ifilter_bind_fg(InputFilterPriv *ifp, FilterGraph *fg_src, int out_idx) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(ifp->ifilter.graph); |
| OutputFilter *ofilter_src = fg_src->outputs[out_idx]; |
| OutputFilterOptions opts; |
| char name[32]; |
| int ret; |
| |
| av_assert0(!ifp->bound); |
| ifp->bound = 1; |
| |
| if (ifp->type != ofilter_src->type) { |
| av_log(fgp, AV_LOG_ERROR, "Tried to connect %s output to %s input\n", |
| av_get_media_type_string(ofilter_src->type), |
| av_get_media_type_string(ifp->type)); |
| return AVERROR(EINVAL); |
| } |
| |
| ifp->type_src = ifp->type; |
| |
| memset(&opts, 0, sizeof(opts)); |
| |
| snprintf(name, sizeof(name), "fg:%d:%d", fgp->fg.index, ifp->index); |
| opts.name = name; |
| |
| ret = ofilter_bind_ifilter(ofilter_src, ifp, &opts); |
| if (ret < 0) |
| return ret; |
| |
| ret = sch_connect(fgp->sch, SCH_FILTER_OUT(fg_src->index, out_idx), |
| SCH_FILTER_IN(fgp->sch_idx, ifp->index)); |
| if (ret < 0) |
| return ret; |
| |
| return 0; |
| } |
| |
| static InputFilter *ifilter_alloc(FilterGraph *fg) |
| { |
| InputFilterPriv *ifp; |
| InputFilter *ifilter; |
| |
| ifp = allocate_array_elem(&fg->inputs, sizeof(*ifp), &fg->nb_inputs); |
| if (!ifp) |
| return NULL; |
| |
| ifilter = &ifp->ifilter; |
| ifilter->graph = fg; |
| |
| ifp->frame = av_frame_alloc(); |
| if (!ifp->frame) |
| return NULL; |
| |
| ifp->index = fg->nb_inputs - 1; |
| ifp->format = -1; |
| ifp->color_space = AVCOL_SPC_UNSPECIFIED; |
| ifp->color_range = AVCOL_RANGE_UNSPECIFIED; |
| |
| ifp->frame_queue = av_fifo_alloc2(8, sizeof(AVFrame*), AV_FIFO_FLAG_AUTO_GROW); |
| if (!ifp->frame_queue) |
| return NULL; |
| |
| return ifilter; |
| } |
| |
| void fg_free(FilterGraph **pfg) |
| { |
| FilterGraph *fg = *pfg; |
| FilterGraphPriv *fgp; |
| |
| if (!fg) |
| return; |
| fgp = fgp_from_fg(fg); |
| |
| for (int j = 0; j < fg->nb_inputs; j++) { |
| InputFilter *ifilter = fg->inputs[j]; |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| |
| if (ifp->frame_queue) { |
| AVFrame *frame; |
| while (av_fifo_read(ifp->frame_queue, &frame, 1) >= 0) |
| av_frame_free(&frame); |
| av_fifo_freep2(&ifp->frame_queue); |
| } |
| av_frame_free(&ifp->sub2video.frame); |
| |
| av_frame_free(&ifp->frame); |
| av_frame_free(&ifp->opts.fallback); |
| |
| av_buffer_unref(&ifp->hw_frames_ctx); |
| av_freep(&ifp->linklabel); |
| av_freep(&ifp->opts.name); |
| av_freep(&ifilter->name); |
| av_freep(&fg->inputs[j]); |
| } |
| av_freep(&fg->inputs); |
| for (int j = 0; j < fg->nb_outputs; j++) { |
| OutputFilter *ofilter = fg->outputs[j]; |
| OutputFilterPriv *ofp = ofp_from_ofilter(ofilter); |
| |
| av_frame_free(&ofp->fps.last_frame); |
| av_dict_free(&ofp->sws_opts); |
| av_dict_free(&ofp->swr_opts); |
| |
| av_freep(&ofilter->linklabel); |
| av_freep(&ofilter->name); |
| av_freep(&ofilter->apad); |
| av_freep(&ofp->name); |
| av_channel_layout_uninit(&ofp->ch_layout); |
| av_freep(&fg->outputs[j]); |
| } |
| av_freep(&fg->outputs); |
| av_freep(&fgp->graph_desc); |
| av_freep(&fgp->nb_threads); |
| |
| av_frame_free(&fgp->frame); |
| av_frame_free(&fgp->frame_enc); |
| |
| av_freep(pfg); |
| } |
| |
| static const char *fg_item_name(void *obj) |
| { |
| const FilterGraphPriv *fgp = obj; |
| |
| return fgp->log_name; |
| } |
| |
| static const AVClass fg_class = { |
| .class_name = "FilterGraph", |
| .version = LIBAVUTIL_VERSION_INT, |
| .item_name = fg_item_name, |
| .category = AV_CLASS_CATEGORY_FILTER, |
| }; |
| |
| int fg_create(FilterGraph **pfg, char *graph_desc, Scheduler *sch) |
| { |
| FilterGraphPriv *fgp; |
| FilterGraph *fg; |
| |
| AVFilterInOut *inputs, *outputs; |
| AVFilterGraph *graph; |
| int ret = 0; |
| |
| fgp = av_mallocz(sizeof(*fgp)); |
| if (!fgp) |
| return AVERROR(ENOMEM); |
| fg = &fgp->fg; |
| |
| if (pfg) { |
| *pfg = fg; |
| fg->index = -1; |
| } else { |
| ret = av_dynarray_add_nofree(&filtergraphs, &nb_filtergraphs, fgp); |
| if (ret < 0) { |
| av_freep(&fgp); |
| return ret; |
| } |
| |
| fg->index = nb_filtergraphs - 1; |
| } |
| |
| fg->class = &fg_class; |
| fgp->graph_desc = graph_desc; |
| fgp->disable_conversions = !auto_conversion_filters; |
| fgp->sch = sch; |
| |
| snprintf(fgp->log_name, sizeof(fgp->log_name), "fc#%d", fg->index); |
| |
| fgp->frame = av_frame_alloc(); |
| fgp->frame_enc = av_frame_alloc(); |
| if (!fgp->frame || !fgp->frame_enc) |
| return AVERROR(ENOMEM); |
| |
| /* this graph is only used for determining the kinds of inputs |
| * and outputs we have, and is discarded on exit from this function */ |
| graph = avfilter_graph_alloc(); |
| if (!graph) |
| return AVERROR(ENOMEM);; |
| graph->nb_threads = 1; |
| |
| ret = graph_parse(graph, fgp->graph_desc, &inputs, &outputs, NULL); |
| if (ret < 0) |
| goto fail; |
| |
| for (unsigned i = 0; i < graph->nb_filters; i++) { |
| const AVFilter *f = graph->filters[i]->filter; |
| if (!avfilter_filter_pad_count(f, 0) && |
| !(f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) { |
| fgp->have_sources = 1; |
| break; |
| } |
| } |
| |
| for (AVFilterInOut *cur = inputs; cur; cur = cur->next) { |
| InputFilter *const ifilter = ifilter_alloc(fg); |
| InputFilterPriv *ifp; |
| |
| if (!ifilter) { |
| ret = AVERROR(ENOMEM); |
| goto fail; |
| } |
| |
| ifp = ifp_from_ifilter(ifilter); |
| ifp->linklabel = cur->name; |
| cur->name = NULL; |
| |
| ifp->type = avfilter_pad_get_type(cur->filter_ctx->input_pads, |
| cur->pad_idx); |
| |
| if (ifp->type != AVMEDIA_TYPE_VIDEO && ifp->type != AVMEDIA_TYPE_AUDIO) { |
| av_log(fg, AV_LOG_FATAL, "Only video and audio filters supported " |
| "currently.\n"); |
| ret = AVERROR(ENOSYS); |
| goto fail; |
| } |
| |
| ifilter->name = describe_filter_link(fg, cur, 1); |
| if (!ifilter->name) { |
| ret = AVERROR(ENOMEM); |
| goto fail; |
| } |
| } |
| |
| for (AVFilterInOut *cur = outputs; cur; cur = cur->next) { |
| 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) { |
| ret = AVERROR(ENOMEM); |
| goto fail; |
| } |
| |
| ofilter->linklabel = cur->name; |
| cur->name = NULL; |
| |
| ofilter->name = describe_filter_link(fg, cur, 0); |
| if (!ofilter->name) { |
| ret = AVERROR(ENOMEM); |
| goto fail; |
| } |
| } |
| |
| if (!fg->nb_outputs) { |
| av_log(fg, AV_LOG_FATAL, "A filtergraph has zero outputs, this is not supported\n"); |
| ret = AVERROR(ENOSYS); |
| goto fail; |
| } |
| |
| ret = sch_add_filtergraph(sch, fg->nb_inputs, fg->nb_outputs, |
| filter_thread, fgp); |
| if (ret < 0) |
| goto fail; |
| fgp->sch_idx = ret; |
| |
| fail: |
| avfilter_inout_free(&inputs); |
| avfilter_inout_free(&outputs); |
| avfilter_graph_free(&graph); |
| |
| if (ret < 0) |
| return ret; |
| |
| return 0; |
| } |
| |
| int init_simple_filtergraph(InputStream *ist, OutputStream *ost, |
| char *graph_desc, |
| Scheduler *sch, unsigned sched_idx_enc, |
| const OutputFilterOptions *opts) |
| { |
| FilterGraph *fg; |
| FilterGraphPriv *fgp; |
| int ret; |
| |
| ret = fg_create(&fg, graph_desc, sch); |
| if (ret < 0) |
| return ret; |
| ost->fg_simple = fg; |
| fgp = fgp_from_fg(fg); |
| |
| fgp->is_simple = 1; |
| |
| snprintf(fgp->log_name, sizeof(fgp->log_name), "%cf%s", |
| av_get_media_type_string(ost->type)[0], opts->name); |
| |
| if (fg->nb_inputs != 1 || fg->nb_outputs != 1) { |
| av_log(fg, AV_LOG_ERROR, "Simple filtergraph '%s' was expected " |
| "to have exactly 1 input and 1 output. " |
| "However, it had %d input(s) and %d output(s). Please adjust, " |
| "or use a complex filtergraph (-filter_complex) instead.\n", |
| graph_desc, fg->nb_inputs, fg->nb_outputs); |
| return AVERROR(EINVAL); |
| } |
| if (fg->outputs[0]->type != ost->type) { |
| av_log(fg, AV_LOG_ERROR, "Filtergraph has a %s output, cannot connect " |
| "it to %s output stream\n", |
| av_get_media_type_string(fg->outputs[0]->type), |
| av_get_media_type_string(ost->type)); |
| return AVERROR(EINVAL); |
| } |
| |
| ost->filter = fg->outputs[0]; |
| |
| ret = ifilter_bind_ist(fg->inputs[0], ist); |
| if (ret < 0) |
| return ret; |
| |
| ret = ofilter_bind_ost(fg->outputs[0], ost, sched_idx_enc, opts); |
| if (ret < 0) |
| return ret; |
| |
| if (opts->nb_threads) { |
| av_freep(&fgp->nb_threads); |
| fgp->nb_threads = av_strdup(opts->nb_threads); |
| if (!fgp->nb_threads) |
| return AVERROR(ENOMEM); |
| } |
| |
| return 0; |
| } |
| |
| static int fg_complex_bind_input(FilterGraph *fg, InputFilter *ifilter) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(fg); |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| InputStream *ist = NULL; |
| enum AVMediaType type = ifp->type; |
| int i, ret; |
| |
| if (ifp->linklabel && !strncmp(ifp->linklabel, "dec:", 4)) { |
| // bind to a standalone decoder |
| int dec_idx; |
| |
| dec_idx = strtol(ifp->linklabel + 4, NULL, 0); |
| if (dec_idx < 0 || dec_idx >= nb_decoders) { |
| av_log(fg, AV_LOG_ERROR, "Invalid decoder index %d in filtergraph description %s\n", |
| dec_idx, fgp->graph_desc); |
| return AVERROR(EINVAL); |
| } |
| |
| ret = ifilter_bind_dec(ifp, decoders[dec_idx]); |
| if (ret < 0) |
| av_log(fg, AV_LOG_ERROR, "Error binding a decoder to filtergraph input %s\n", |
| ifilter->name); |
| return ret; |
| } else if (ifp->linklabel) { |
| AVFormatContext *s; |
| AVStream *st = NULL; |
| char *p; |
| int file_idx; |
| |
| // try finding an unbound filtergraph output with this label |
| for (int i = 0; i < nb_filtergraphs; i++) { |
| FilterGraph *fg_src = filtergraphs[i]; |
| |
| if (fg == fg_src) |
| continue; |
| |
| for (int j = 0; j < fg_src->nb_outputs; j++) { |
| OutputFilter *ofilter = fg_src->outputs[j]; |
| |
| if (!ofilter->bound && ofilter->linklabel && |
| !strcmp(ofilter->linklabel, ifp->linklabel)) { |
| av_log(fg, AV_LOG_VERBOSE, |
| "Binding input with label '%s' to filtergraph output %d:%d\n", |
| ifp->linklabel, i, j); |
| |
| ret = ifilter_bind_fg(ifp, fg_src, j); |
| if (ret < 0) |
| av_log(fg, AV_LOG_ERROR, "Error binding filtergraph input %s\n", |
| ifp->linklabel); |
| return ret; |
| } |
| } |
| } |
| |
| // bind to an explicitly specified demuxer stream |
| file_idx = strtol(ifp->linklabel, &p, 0); |
| if (file_idx < 0 || file_idx >= nb_input_files) { |
| av_log(fg, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n", |
| file_idx, fgp->graph_desc); |
| return AVERROR(EINVAL); |
| } |
| s = input_files[file_idx]->ctx; |
| |
| for (i = 0; i < s->nb_streams; i++) { |
| enum AVMediaType stream_type = s->streams[i]->codecpar->codec_type; |
| if (stream_type != type && |
| !(stream_type == AVMEDIA_TYPE_SUBTITLE && |
| type == AVMEDIA_TYPE_VIDEO /* sub2video hack */)) |
| continue; |
| if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) { |
| st = s->streams[i]; |
| break; |
| } |
| } |
| if (!st) { |
| av_log(fg, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s " |
| "matches no streams.\n", p, fgp->graph_desc); |
| return AVERROR(EINVAL); |
| } |
| ist = input_files[file_idx]->streams[st->index]; |
| |
| av_log(fg, AV_LOG_VERBOSE, |
| "Binding input with label '%s' to input stream %d:%d\n", |
| ifp->linklabel, ist->file->index, ist->index); |
| } else { |
| ist = ist_find_unused(type); |
| if (!ist) { |
| av_log(fg, AV_LOG_FATAL, "Cannot find a matching stream for " |
| "unlabeled input pad %s\n", ifilter->name); |
| return AVERROR(EINVAL); |
| } |
| |
| av_log(fg, AV_LOG_VERBOSE, |
| "Binding unlabeled input %d to input stream %d:%d\n", |
| ifp->index, ist->file->index, ist->index); |
| } |
| av_assert0(ist); |
| |
| ret = ifilter_bind_ist(ifilter, ist); |
| if (ret < 0) { |
| av_log(fg, AV_LOG_ERROR, |
| "Error binding an input stream to complex filtergraph input %s.\n", |
| ifilter->name); |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| static int bind_inputs(FilterGraph *fg) |
| { |
| // bind filtergraph inputs to input streams or other filtergraphs |
| for (int i = 0; i < fg->nb_inputs; i++) { |
| InputFilterPriv *ifp = ifp_from_ifilter(fg->inputs[i]); |
| int ret; |
| |
| if (ifp->bound) |
| continue; |
| |
| ret = fg_complex_bind_input(fg, &ifp->ifilter); |
| if (ret < 0) |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| int fg_finalise_bindings(void) |
| { |
| int ret; |
| |
| for (int i = 0; i < nb_filtergraphs; i++) { |
| ret = bind_inputs(filtergraphs[i]); |
| if (ret < 0) |
| return ret; |
| } |
| |
| // check that all outputs were bound |
| for (int i = 0; i < nb_filtergraphs; i++) { |
| FilterGraph *fg = filtergraphs[i]; |
| |
| for (int j = 0; j < fg->nb_outputs; j++) { |
| OutputFilter *output = fg->outputs[j]; |
| if (!output->bound) { |
| av_log(filtergraphs[j], AV_LOG_FATAL, |
| "Filter %s has an unconnected output\n", output->name); |
| return AVERROR(EINVAL); |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int insert_trim(int64_t start_time, int64_t duration, |
| AVFilterContext **last_filter, int *pad_idx, |
| const char *filter_name) |
| { |
| AVFilterGraph *graph = (*last_filter)->graph; |
| AVFilterContext *ctx; |
| const AVFilter *trim; |
| enum AVMediaType type = avfilter_pad_get_type((*last_filter)->output_pads, *pad_idx); |
| const char *name = (type == AVMEDIA_TYPE_VIDEO) ? "trim" : "atrim"; |
| int ret = 0; |
| |
| if (duration == INT64_MAX && start_time == AV_NOPTS_VALUE) |
| return 0; |
| |
| trim = avfilter_get_by_name(name); |
| if (!trim) { |
| av_log(NULL, AV_LOG_ERROR, "%s filter not present, cannot limit " |
| "recording time.\n", name); |
| return AVERROR_FILTER_NOT_FOUND; |
| } |
| |
| ctx = avfilter_graph_alloc_filter(graph, trim, filter_name); |
| if (!ctx) |
| return AVERROR(ENOMEM); |
| |
| if (duration != INT64_MAX) { |
| ret = av_opt_set_int(ctx, "durationi", duration, |
| AV_OPT_SEARCH_CHILDREN); |
| } |
| if (ret >= 0 && start_time != AV_NOPTS_VALUE) { |
| ret = av_opt_set_int(ctx, "starti", start_time, |
| AV_OPT_SEARCH_CHILDREN); |
| } |
| if (ret < 0) { |
| av_log(ctx, AV_LOG_ERROR, "Error configuring the %s filter", name); |
| return ret; |
| } |
| |
| ret = avfilter_init_str(ctx, NULL); |
| if (ret < 0) |
| return ret; |
| |
| ret = avfilter_link(*last_filter, *pad_idx, ctx, 0); |
| if (ret < 0) |
| return ret; |
| |
| *last_filter = ctx; |
| *pad_idx = 0; |
| return 0; |
| } |
| |
| static int insert_filter(AVFilterContext **last_filter, int *pad_idx, |
| const char *filter_name, const char *args) |
| { |
| AVFilterGraph *graph = (*last_filter)->graph; |
| AVFilterContext *ctx; |
| int ret; |
| |
| ret = avfilter_graph_create_filter(&ctx, |
| avfilter_get_by_name(filter_name), |
| filter_name, args, NULL, graph); |
| if (ret < 0) |
| return ret; |
| |
| ret = avfilter_link(*last_filter, *pad_idx, ctx, 0); |
| if (ret < 0) |
| return ret; |
| |
| *last_filter = ctx; |
| *pad_idx = 0; |
| return 0; |
| } |
| |
| static int configure_output_video_filter(FilterGraph *fg, AVFilterGraph *graph, |
| OutputFilter *ofilter, AVFilterInOut *out) |
| { |
| OutputFilterPriv *ofp = ofp_from_ofilter(ofilter); |
| AVFilterContext *last_filter = out->filter_ctx; |
| AVBPrint bprint; |
| int pad_idx = out->pad_idx; |
| int ret; |
| const char *pix_fmts; |
| char name[255]; |
| |
| snprintf(name, sizeof(name), "out_%s", ofp->name); |
| ret = avfilter_graph_create_filter(&ofp->filter, |
| avfilter_get_by_name("buffersink"), |
| name, NULL, NULL, graph); |
| |
| if (ret < 0) |
| return ret; |
| |
| if ((ofp->width || ofp->height) && (ofp->flags & OFILTER_FLAG_AUTOSCALE)) { |
| char args[255]; |
| AVFilterContext *filter; |
| const AVDictionaryEntry *e = NULL; |
| |
| snprintf(args, sizeof(args), "%d:%d", |
| ofp->width, ofp->height); |
| |
| while ((e = av_dict_iterate(ofp->sws_opts, e))) { |
| av_strlcatf(args, sizeof(args), ":%s=%s", e->key, e->value); |
| } |
| |
| snprintf(name, sizeof(name), "scaler_out_%s", ofp->name); |
| if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"), |
| name, args, NULL, graph)) < 0) |
| return ret; |
| if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0) |
| return ret; |
| |
| last_filter = filter; |
| pad_idx = 0; |
| } |
| |
| av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED); |
| ret = choose_pix_fmts(ofilter, &bprint, &pix_fmts); |
| if (ret < 0) |
| return ret; |
| |
| if (pix_fmts) { |
| AVFilterContext *filter; |
| |
| ret = avfilter_graph_create_filter(&filter, |
| avfilter_get_by_name("format"), |
| "format", pix_fmts, NULL, graph); |
| av_bprint_finalize(&bprint, NULL); |
| if (ret < 0) |
| return ret; |
| if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0) |
| return ret; |
| |
| last_filter = filter; |
| pad_idx = 0; |
| } |
| |
| snprintf(name, sizeof(name), "trim_out_%s", ofp->name); |
| ret = insert_trim(ofp->trim_start_us, ofp->trim_duration_us, |
| &last_filter, &pad_idx, name); |
| if (ret < 0) |
| return ret; |
| |
| |
| if ((ret = avfilter_link(last_filter, pad_idx, ofp->filter, 0)) < 0) |
| return ret; |
| |
| return 0; |
| } |
| |
| static int configure_output_audio_filter(FilterGraph *fg, AVFilterGraph *graph, |
| OutputFilter *ofilter, AVFilterInOut *out) |
| { |
| OutputFilterPriv *ofp = ofp_from_ofilter(ofilter); |
| AVFilterContext *last_filter = out->filter_ctx; |
| int pad_idx = out->pad_idx; |
| AVBPrint args; |
| char name[255]; |
| int ret; |
| |
| snprintf(name, sizeof(name), "out_%s", ofp->name); |
| ret = avfilter_graph_create_filter(&ofp->filter, |
| avfilter_get_by_name("abuffersink"), |
| name, NULL, NULL, graph); |
| if (ret < 0) |
| return ret; |
| if ((ret = av_opt_set_int(ofp->filter, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0) |
| return ret; |
| |
| #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \ |
| AVFilterContext *filt_ctx; \ |
| \ |
| av_log(ofilter, AV_LOG_INFO, opt_name " is forwarded to lavfi " \ |
| "similarly to -af " filter_name "=%s.\n", arg); \ |
| \ |
| ret = avfilter_graph_create_filter(&filt_ctx, \ |
| avfilter_get_by_name(filter_name), \ |
| filter_name, arg, NULL, graph); \ |
| if (ret < 0) \ |
| goto fail; \ |
| \ |
| ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0); \ |
| if (ret < 0) \ |
| goto fail; \ |
| \ |
| last_filter = filt_ctx; \ |
| pad_idx = 0; \ |
| } while (0) |
| av_bprint_init(&args, 0, AV_BPRINT_SIZE_UNLIMITED); |
| |
| choose_sample_fmts(ofp, &args); |
| choose_sample_rates(ofp, &args); |
| choose_channel_layouts(ofp, &args); |
| if (!av_bprint_is_complete(&args)) { |
| ret = AVERROR(ENOMEM); |
| goto fail; |
| } |
| if (args.len) { |
| AVFilterContext *format; |
| |
| snprintf(name, sizeof(name), "format_out_%s", ofp->name); |
| ret = avfilter_graph_create_filter(&format, |
| avfilter_get_by_name("aformat"), |
| name, args.str, NULL, graph); |
| if (ret < 0) |
| goto fail; |
| |
| ret = avfilter_link(last_filter, pad_idx, format, 0); |
| if (ret < 0) |
| goto fail; |
| |
| last_filter = format; |
| pad_idx = 0; |
| } |
| |
| if (ofilter->apad) |
| AUTO_INSERT_FILTER("-apad", "apad", ofilter->apad); |
| |
| snprintf(name, sizeof(name), "trim for output %s", ofp->name); |
| ret = insert_trim(ofp->trim_start_us, ofp->trim_duration_us, |
| &last_filter, &pad_idx, name); |
| if (ret < 0) |
| goto fail; |
| |
| if ((ret = avfilter_link(last_filter, pad_idx, ofp->filter, 0)) < 0) |
| goto fail; |
| fail: |
| av_bprint_finalize(&args, NULL); |
| |
| return ret; |
| } |
| |
| static int configure_output_filter(FilterGraph *fg, AVFilterGraph *graph, |
| OutputFilter *ofilter, AVFilterInOut *out) |
| { |
| switch (ofilter->type) { |
| case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, graph, ofilter, out); |
| case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, graph, ofilter, out); |
| default: av_assert0(0); return 0; |
| } |
| } |
| |
| static void sub2video_prepare(InputFilterPriv *ifp) |
| { |
| ifp->sub2video.last_pts = INT64_MIN; |
| ifp->sub2video.end_pts = INT64_MIN; |
| |
| /* sub2video structure has been (re-)initialized. |
| Mark it as such so that the system will be |
| initialized with the first received heartbeat. */ |
| ifp->sub2video.initialize = 1; |
| } |
| |
| static int configure_input_video_filter(FilterGraph *fg, AVFilterGraph *graph, |
| InputFilter *ifilter, AVFilterInOut *in) |
| { |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| |
| AVFilterContext *last_filter; |
| const AVFilter *buffer_filt = avfilter_get_by_name("buffer"); |
| const AVPixFmtDescriptor *desc; |
| AVRational fr = ifp->opts.framerate; |
| AVRational sar; |
| AVBPrint args; |
| char name[255]; |
| int ret, pad_idx = 0; |
| AVBufferSrcParameters *par = av_buffersrc_parameters_alloc(); |
| if (!par) |
| return AVERROR(ENOMEM); |
| |
| if (ifp->type_src == AVMEDIA_TYPE_SUBTITLE) |
| sub2video_prepare(ifp); |
| |
| sar = ifp->sample_aspect_ratio; |
| if(!sar.den) |
| sar = (AVRational){0,1}; |
| av_bprint_init(&args, 0, AV_BPRINT_SIZE_AUTOMATIC); |
| av_bprintf(&args, |
| "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:" |
| "pixel_aspect=%d/%d:colorspace=%d:range=%d", |
| ifp->width, ifp->height, ifp->format, |
| ifp->time_base.num, ifp->time_base.den, sar.num, sar.den, |
| ifp->color_space, ifp->color_range); |
| if (fr.num && fr.den) |
| av_bprintf(&args, ":frame_rate=%d/%d", fr.num, fr.den); |
| snprintf(name, sizeof(name), "graph %d input from stream %s", fg->index, |
| ifp->opts.name); |
| |
| |
| if ((ret = avfilter_graph_create_filter(&ifp->filter, buffer_filt, name, |
| args.str, NULL, graph)) < 0) |
| goto fail; |
| par->hw_frames_ctx = ifp->hw_frames_ctx; |
| ret = av_buffersrc_parameters_set(ifp->filter, par); |
| if (ret < 0) |
| goto fail; |
| av_freep(&par); |
| last_filter = ifp->filter; |
| |
| desc = av_pix_fmt_desc_get(ifp->format); |
| av_assert0(desc); |
| |
| // TODO: insert hwaccel enabled filters like transpose_vaapi into the graph |
| ifp->displaymatrix_applied = 0; |
| if ((ifp->opts.flags & IFILTER_FLAG_AUTOROTATE) && |
| !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL)) { |
| int32_t *displaymatrix = ifp->displaymatrix; |
| double theta; |
| |
| theta = get_rotation(displaymatrix); |
| |
| if (fabs(theta - 90) < 1.0) { |
| ret = insert_filter(&last_filter, &pad_idx, "transpose", |
| displaymatrix[3] > 0 ? "cclock_flip" : "clock"); |
| } else if (fabs(theta - 180) < 1.0) { |
| if (displaymatrix[0] < 0) { |
| ret = insert_filter(&last_filter, &pad_idx, "hflip", NULL); |
| if (ret < 0) |
| return ret; |
| } |
| if (displaymatrix[4] < 0) { |
| ret = insert_filter(&last_filter, &pad_idx, "vflip", NULL); |
| } |
| } else if (fabs(theta - 270) < 1.0) { |
| ret = insert_filter(&last_filter, &pad_idx, "transpose", |
| displaymatrix[3] < 0 ? "clock_flip" : "cclock"); |
| } else if (fabs(theta) > 1.0) { |
| char rotate_buf[64]; |
| snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta); |
| ret = insert_filter(&last_filter, &pad_idx, "rotate", rotate_buf); |
| } else if (fabs(theta) < 1.0) { |
| if (displaymatrix && displaymatrix[4] < 0) { |
| ret = insert_filter(&last_filter, &pad_idx, "vflip", NULL); |
| } |
| } |
| if (ret < 0) |
| return ret; |
| |
| ifp->displaymatrix_applied = 1; |
| } |
| |
| snprintf(name, sizeof(name), "trim_in_%s", ifp->opts.name); |
| ret = insert_trim(ifp->opts.trim_start_us, ifp->opts.trim_end_us, |
| &last_filter, &pad_idx, name); |
| if (ret < 0) |
| return ret; |
| |
| if ((ret = avfilter_link(last_filter, 0, in->filter_ctx, in->pad_idx)) < 0) |
| return ret; |
| return 0; |
| fail: |
| av_freep(&par); |
| |
| return ret; |
| } |
| |
| static int configure_input_audio_filter(FilterGraph *fg, AVFilterGraph *graph, |
| InputFilter *ifilter, AVFilterInOut *in) |
| { |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| AVFilterContext *last_filter; |
| const AVFilter *abuffer_filt = avfilter_get_by_name("abuffer"); |
| AVBPrint args; |
| char name[255]; |
| int ret, pad_idx = 0; |
| |
| av_bprint_init(&args, 0, AV_BPRINT_SIZE_AUTOMATIC); |
| av_bprintf(&args, "time_base=%d/%d:sample_rate=%d:sample_fmt=%s", |
| ifp->time_base.num, ifp->time_base.den, |
| ifp->sample_rate, |
| av_get_sample_fmt_name(ifp->format)); |
| if (av_channel_layout_check(&ifp->ch_layout) && |
| ifp->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) { |
| av_bprintf(&args, ":channel_layout="); |
| av_channel_layout_describe_bprint(&ifp->ch_layout, &args); |
| } else |
| av_bprintf(&args, ":channels=%d", ifp->ch_layout.nb_channels); |
| snprintf(name, sizeof(name), "graph_%d_in_%s", fg->index, ifp->opts.name); |
| |
| if ((ret = avfilter_graph_create_filter(&ifp->filter, abuffer_filt, |
| name, args.str, NULL, |
| graph)) < 0) |
| return ret; |
| last_filter = ifp->filter; |
| |
| snprintf(name, sizeof(name), "trim for input stream %s", ifp->opts.name); |
| ret = insert_trim(ifp->opts.trim_start_us, ifp->opts.trim_end_us, |
| &last_filter, &pad_idx, name); |
| if (ret < 0) |
| return ret; |
| |
| if ((ret = avfilter_link(last_filter, 0, in->filter_ctx, in->pad_idx)) < 0) |
| return ret; |
| |
| return 0; |
| } |
| |
| static int configure_input_filter(FilterGraph *fg, AVFilterGraph *graph, |
| InputFilter *ifilter, AVFilterInOut *in) |
| { |
| switch (ifp_from_ifilter(ifilter)->type) { |
| case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, graph, ifilter, in); |
| case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, graph, ifilter, in); |
| default: av_assert0(0); return 0; |
| } |
| } |
| |
| static void cleanup_filtergraph(FilterGraph *fg, FilterGraphThread *fgt) |
| { |
| for (int i = 0; i < fg->nb_outputs; i++) |
| ofp_from_ofilter(fg->outputs[i])->filter = NULL; |
| for (int i = 0; i < fg->nb_inputs; i++) |
| ifp_from_ifilter(fg->inputs[i])->filter = NULL; |
| avfilter_graph_free(&fgt->graph); |
| } |
| |
| static int filter_is_buffersrc(const AVFilterContext *f) |
| { |
| return f->nb_inputs == 0 && |
| (!strcmp(f->filter->name, "buffer") || |
| !strcmp(f->filter->name, "abuffer")); |
| } |
| |
| static int graph_is_meta(AVFilterGraph *graph) |
| { |
| for (unsigned i = 0; i < graph->nb_filters; i++) { |
| const AVFilterContext *f = graph->filters[i]; |
| |
| /* in addition to filters flagged as meta, also |
| * disregard sinks and buffersources (but not other sources, |
| * since they introduce data we are not aware of) |
| */ |
| if (!((f->filter->flags & AVFILTER_FLAG_METADATA_ONLY) || |
| f->nb_outputs == 0 || |
| filter_is_buffersrc(f))) |
| return 0; |
| } |
| return 1; |
| } |
| |
| static int sub2video_frame(InputFilter *ifilter, AVFrame *frame, int buffer); |
| |
| static int configure_filtergraph(FilterGraph *fg, FilterGraphThread *fgt) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(fg); |
| AVBufferRef *hw_device; |
| AVFilterInOut *inputs, *outputs, *cur; |
| int ret, i, simple = filtergraph_is_simple(fg); |
| int have_input_eof = 0; |
| const char *graph_desc = fgp->graph_desc; |
| |
| cleanup_filtergraph(fg, fgt); |
| fgt->graph = avfilter_graph_alloc(); |
| if (!fgt->graph) |
| return AVERROR(ENOMEM); |
| |
| if (simple) { |
| OutputFilterPriv *ofp = ofp_from_ofilter(fg->outputs[0]); |
| |
| if (filter_nbthreads) { |
| ret = av_opt_set(fgt->graph, "threads", filter_nbthreads, 0); |
| if (ret < 0) |
| goto fail; |
| } else if (fgp->nb_threads) { |
| ret = av_opt_set(fgt->graph, "threads", fgp->nb_threads, 0); |
| if (ret < 0) |
| return ret; |
| } |
| |
| if (av_dict_count(ofp->sws_opts)) { |
| ret = av_dict_get_string(ofp->sws_opts, |
| &fgt->graph->scale_sws_opts, |
| '=', ':'); |
| if (ret < 0) |
| goto fail; |
| } |
| |
| if (av_dict_count(ofp->swr_opts)) { |
| char *args; |
| ret = av_dict_get_string(ofp->swr_opts, &args, '=', ':'); |
| if (ret < 0) |
| goto fail; |
| av_opt_set(fgt->graph, "aresample_swr_opts", args, 0); |
| av_free(args); |
| } |
| } else { |
| fgt->graph->nb_threads = filter_complex_nbthreads; |
| } |
| |
| hw_device = hw_device_for_filter(); |
| |
| if ((ret = graph_parse(fgt->graph, graph_desc, &inputs, &outputs, hw_device)) < 0) |
| goto fail; |
| |
| for (cur = inputs, i = 0; cur; cur = cur->next, i++) |
| if ((ret = configure_input_filter(fg, fgt->graph, fg->inputs[i], cur)) < 0) { |
| avfilter_inout_free(&inputs); |
| avfilter_inout_free(&outputs); |
| goto fail; |
| } |
| avfilter_inout_free(&inputs); |
| |
| for (cur = outputs, i = 0; cur; cur = cur->next, i++) { |
| ret = configure_output_filter(fg, fgt->graph, fg->outputs[i], cur); |
| if (ret < 0) { |
| avfilter_inout_free(&outputs); |
| goto fail; |
| } |
| } |
| avfilter_inout_free(&outputs); |
| |
| if (fgp->disable_conversions) |
| avfilter_graph_set_auto_convert(fgt->graph, AVFILTER_AUTO_CONVERT_NONE); |
| if ((ret = avfilter_graph_config(fgt->graph, NULL)) < 0) |
| goto fail; |
| |
| fgp->is_meta = graph_is_meta(fgt->graph); |
| |
| /* limit the lists of allowed formats to the ones selected, to |
| * make sure they stay the same if the filtergraph is reconfigured later */ |
| for (int i = 0; i < fg->nb_outputs; i++) { |
| OutputFilter *ofilter = fg->outputs[i]; |
| OutputFilterPriv *ofp = ofp_from_ofilter(ofilter); |
| AVFilterContext *sink = ofp->filter; |
| |
| ofp->format = av_buffersink_get_format(sink); |
| |
| ofp->width = av_buffersink_get_w(sink); |
| ofp->height = av_buffersink_get_h(sink); |
| |
| // If the timing parameters are not locked yet, get the tentative values |
| // here but don't lock them. They will only be used if no output frames |
| // are ever produced. |
| if (!ofp->tb_out_locked) { |
| AVRational fr = av_buffersink_get_frame_rate(sink); |
| if (ofp->fps.framerate.num <= 0 && ofp->fps.framerate.den <= 0 && |
| fr.num > 0 && fr.den > 0) |
| ofp->fps.framerate = fr; |
| ofp->tb_out = av_buffersink_get_time_base(sink); |
| } |
| ofp->sample_aspect_ratio = av_buffersink_get_sample_aspect_ratio(sink); |
| |
| ofp->sample_rate = av_buffersink_get_sample_rate(sink); |
| av_channel_layout_uninit(&ofp->ch_layout); |
| ret = av_buffersink_get_ch_layout(sink, &ofp->ch_layout); |
| if (ret < 0) |
| goto fail; |
| } |
| |
| for (int i = 0; i < fg->nb_inputs; i++) { |
| InputFilterPriv *ifp = ifp_from_ifilter(fg->inputs[i]); |
| AVFrame *tmp; |
| while (av_fifo_read(ifp->frame_queue, &tmp, 1) >= 0) { |
| if (ifp->type_src == AVMEDIA_TYPE_SUBTITLE) { |
| sub2video_frame(&ifp->ifilter, tmp, !fgt->graph); |
| } else { |
| ret = av_buffersrc_add_frame(ifp->filter, tmp); |
| } |
| av_frame_free(&tmp); |
| if (ret < 0) |
| goto fail; |
| } |
| } |
| |
| /* send the EOFs for the finished inputs */ |
| for (int i = 0; i < fg->nb_inputs; i++) { |
| InputFilterPriv *ifp = ifp_from_ifilter(fg->inputs[i]); |
| if (fgt->eof_in[i]) { |
| ret = av_buffersrc_add_frame(ifp->filter, NULL); |
| if (ret < 0) |
| goto fail; |
| have_input_eof = 1; |
| } |
| } |
| |
| if (have_input_eof) { |
| // make sure the EOF propagates to the end of the graph |
| ret = avfilter_graph_request_oldest(fgt->graph); |
| if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) |
| goto fail; |
| } |
| |
| return 0; |
| fail: |
| cleanup_filtergraph(fg, fgt); |
| return ret; |
| } |
| |
| static int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame) |
| { |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| AVFrameSideData *sd; |
| int ret; |
| |
| ret = av_buffer_replace(&ifp->hw_frames_ctx, frame->hw_frames_ctx); |
| if (ret < 0) |
| return ret; |
| |
| ifp->time_base = (ifp->type == AVMEDIA_TYPE_AUDIO) ? (AVRational){ 1, frame->sample_rate } : |
| (ifp->opts.flags & IFILTER_FLAG_CFR) ? av_inv_q(ifp->opts.framerate) : |
| frame->time_base; |
| |
| ifp->format = frame->format; |
| |
| ifp->width = frame->width; |
| ifp->height = frame->height; |
| ifp->sample_aspect_ratio = frame->sample_aspect_ratio; |
| ifp->color_space = frame->colorspace; |
| ifp->color_range = frame->color_range; |
| |
| ifp->sample_rate = frame->sample_rate; |
| ret = av_channel_layout_copy(&ifp->ch_layout, &frame->ch_layout); |
| if (ret < 0) |
| return ret; |
| |
| sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DISPLAYMATRIX); |
| if (sd) |
| memcpy(ifp->displaymatrix, sd->data, sizeof(ifp->displaymatrix)); |
| ifp->displaymatrix_present = !!sd; |
| |
| return 0; |
| } |
| |
| int filtergraph_is_simple(const FilterGraph *fg) |
| { |
| const FilterGraphPriv *fgp = cfgp_from_cfg(fg); |
| return fgp->is_simple; |
| } |
| |
| static void send_command(FilterGraph *fg, AVFilterGraph *graph, |
| double time, const char *target, |
| const char *command, const char *arg, int all_filters) |
| { |
| int ret; |
| |
| if (!graph) |
| return; |
| |
| if (time < 0) { |
| char response[4096]; |
| ret = avfilter_graph_send_command(graph, target, command, arg, |
| response, sizeof(response), |
| all_filters ? 0 : AVFILTER_CMD_FLAG_ONE); |
| fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", |
| fg->index, ret, response); |
| } else if (!all_filters) { |
| fprintf(stderr, "Queuing commands only on filters supporting the specific command is unsupported\n"); |
| } else { |
| ret = avfilter_graph_queue_command(graph, target, command, arg, 0, time); |
| if (ret < 0) |
| fprintf(stderr, "Queuing command failed with error %s\n", av_err2str(ret)); |
| } |
| } |
| |
| static int choose_input(const FilterGraph *fg, const FilterGraphThread *fgt) |
| { |
| int nb_requests, nb_requests_max = -1; |
| int best_input = -1; |
| |
| for (int i = 0; i < fg->nb_inputs; i++) { |
| InputFilter *ifilter = fg->inputs[i]; |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| |
| if (fgt->eof_in[i]) |
| continue; |
| |
| nb_requests = av_buffersrc_get_nb_failed_requests(ifp->filter); |
| if (nb_requests > nb_requests_max) { |
| nb_requests_max = nb_requests; |
| best_input = i; |
| } |
| } |
| |
| av_assert0(best_input >= 0); |
| |
| return best_input; |
| } |
| |
| static int choose_out_timebase(OutputFilterPriv *ofp, AVFrame *frame) |
| { |
| OutputFilter *ofilter = &ofp->ofilter; |
| FPSConvContext *fps = &ofp->fps; |
| AVRational tb = (AVRational){ 0, 0 }; |
| AVRational fr; |
| const FrameData *fd; |
| |
| fd = frame_data_c(frame); |
| |
| // apply -enc_time_base |
| if (ofp->enc_timebase.num == ENC_TIME_BASE_DEMUX && |
| (fd->dec.tb.num <= 0 || fd->dec.tb.den <= 0)) { |
| av_log(ofp, AV_LOG_ERROR, |
| "Demuxing timebase not available - cannot use it for encoding\n"); |
| return AVERROR(EINVAL); |
| } |
| |
| switch (ofp->enc_timebase.num) { |
| case 0: break; |
| case ENC_TIME_BASE_DEMUX: tb = fd->dec.tb; break; |
| case ENC_TIME_BASE_FILTER: tb = frame->time_base; break; |
| default: tb = ofp->enc_timebase; break; |
| } |
| |
| if (ofilter->type == AVMEDIA_TYPE_AUDIO) { |
| tb = tb.num ? tb : (AVRational){ 1, frame->sample_rate }; |
| goto finish; |
| } |
| |
| fr = fps->framerate; |
| if (!fr.num) { |
| AVRational fr_sink = av_buffersink_get_frame_rate(ofp->filter); |
| if (fr_sink.num > 0 && fr_sink.den > 0) |
| fr = fr_sink; |
| } |
| |
| if (fps->vsync_method == VSYNC_CFR || fps->vsync_method == VSYNC_VSCFR) { |
| if (!fr.num && !fps->framerate_max.num) { |
| fr = (AVRational){25, 1}; |
| av_log(ofp, AV_LOG_WARNING, |
| "No information " |
| "about the input framerate is available. Falling " |
| "back to a default value of 25fps. Use the -r option " |
| "if you want a different framerate.\n"); |
| } |
| |
| if (fps->framerate_max.num && |
| (av_q2d(fr) > av_q2d(fps->framerate_max) || |
| !fr.den)) |
| fr = fps->framerate_max; |
| } |
| |
| if (fr.num > 0) { |
| if (fps->framerate_supported) { |
| int idx = av_find_nearest_q_idx(fr, fps->framerate_supported); |
| fr = fps->framerate_supported[idx]; |
| } |
| if (fps->framerate_clip) { |
| av_reduce(&fr.num, &fr.den, |
| fr.num, fr.den, fps->framerate_clip); |
| } |
| } |
| |
| if (!(tb.num > 0 && tb.den > 0)) |
| tb = av_inv_q(fr); |
| if (!(tb.num > 0 && tb.den > 0)) |
| tb = frame->time_base; |
| |
| fps->framerate = fr; |
| finish: |
| ofp->tb_out = tb; |
| ofp->tb_out_locked = 1; |
| |
| return 0; |
| } |
| |
| static double adjust_frame_pts_to_encoder_tb(AVFrame *frame, AVRational tb_dst, |
| int64_t start_time) |
| { |
| double float_pts = AV_NOPTS_VALUE; // this is identical to frame.pts but with higher precision |
| |
| AVRational tb = tb_dst; |
| AVRational filter_tb = frame->time_base; |
| const int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16); |
| |
| if (frame->pts == AV_NOPTS_VALUE) |
| goto early_exit; |
| |
| tb.den <<= extra_bits; |
| float_pts = av_rescale_q(frame->pts, filter_tb, tb) - |
| av_rescale_q(start_time, AV_TIME_BASE_Q, tb); |
| float_pts /= 1 << extra_bits; |
| // when float_pts is not exactly an integer, |
| // avoid exact midpoints to reduce the chance of rounding differences, this |
| // can be removed in case the fps code is changed to work with integers |
| if (float_pts != llrint(float_pts)) |
| float_pts += FFSIGN(float_pts) * 1.0 / (1<<17); |
| |
| frame->pts = av_rescale_q(frame->pts, filter_tb, tb_dst) - |
| av_rescale_q(start_time, AV_TIME_BASE_Q, tb_dst); |
| frame->time_base = tb_dst; |
| |
| early_exit: |
| |
| if (debug_ts) { |
| av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n", |
| frame ? av_ts2str(frame->pts) : "NULL", |
| av_ts2timestr(frame->pts, &tb_dst), |
| float_pts, tb_dst.num, tb_dst.den); |
| } |
| |
| return float_pts; |
| } |
| |
| /* Convert frame timestamps to the encoder timebase and decide how many times |
| * should this (and possibly previous) frame be repeated in order to conform to |
| * desired target framerate (if any). |
| */ |
| static void video_sync_process(OutputFilterPriv *ofp, AVFrame *frame, |
| int64_t *nb_frames, int64_t *nb_frames_prev) |
| { |
| OutputFilter *ofilter = &ofp->ofilter; |
| FPSConvContext *fps = &ofp->fps; |
| double delta0, delta, sync_ipts, duration; |
| |
| if (!frame) { |
| *nb_frames_prev = *nb_frames = mid_pred(fps->frames_prev_hist[0], |
| fps->frames_prev_hist[1], |
| fps->frames_prev_hist[2]); |
| |
| if (!*nb_frames && fps->last_dropped) { |
| atomic_fetch_add(&ofilter->nb_frames_drop, 1); |
| fps->last_dropped++; |
| } |
| |
| goto finish; |
| } |
| |
| duration = frame->duration * av_q2d(frame->time_base) / av_q2d(ofp->tb_out); |
| |
| sync_ipts = adjust_frame_pts_to_encoder_tb(frame, ofp->tb_out, ofp->ts_offset); |
| /* delta0 is the "drift" between the input frame and |
| * where it would fall in the output. */ |
| delta0 = sync_ipts - ofp->next_pts; |
| delta = delta0 + duration; |
| |
| // tracks the number of times the PREVIOUS frame should be duplicated, |
| // mostly for variable framerate (VFR) |
| *nb_frames_prev = 0; |
| /* by default, we output a single frame */ |
| *nb_frames = 1; |
| |
| if (delta0 < 0 && |
| delta > 0 && |
| fps->vsync_method != VSYNC_PASSTHROUGH |
| #if FFMPEG_OPT_VSYNC_DROP |
| && fps->vsync_method != VSYNC_DROP |
| #endif |
| ) { |
| if (delta0 < -0.6) { |
| av_log(ofp, AV_LOG_VERBOSE, "Past duration %f too large\n", -delta0); |
| } else |
| av_log(ofp, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0); |
| sync_ipts = ofp->next_pts; |
| duration += delta0; |
| delta0 = 0; |
| } |
| |
| switch (fps->vsync_method) { |
| case VSYNC_VSCFR: |
| if (fps->frame_number == 0 && delta0 >= 0.5) { |
| av_log(ofp, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0)); |
| delta = duration; |
| delta0 = 0; |
| ofp->next_pts = llrint(sync_ipts); |
| } |
| case VSYNC_CFR: |
| // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c |
| if (frame_drop_threshold && delta < frame_drop_threshold && fps->frame_number) { |
| *nb_frames = 0; |
| } else if (delta < -1.1) |
| *nb_frames = 0; |
| else if (delta > 1.1) { |
| *nb_frames = llrintf(delta); |
| if (delta0 > 1.1) |
| *nb_frames_prev = llrintf(delta0 - 0.6); |
| } |
| frame->duration = 1; |
| break; |
| case VSYNC_VFR: |
| if (delta <= -0.6) |
| *nb_frames = 0; |
| else if (delta > 0.6) |
| ofp->next_pts = llrint(sync_ipts); |
| frame->duration = llrint(duration); |
| break; |
| #if FFMPEG_OPT_VSYNC_DROP |
| case VSYNC_DROP: |
| #endif |
| case VSYNC_PASSTHROUGH: |
| ofp->next_pts = llrint(sync_ipts); |
| frame->duration = llrint(duration); |
| break; |
| default: |
| av_assert0(0); |
| } |
| |
| finish: |
| memmove(fps->frames_prev_hist + 1, |
| fps->frames_prev_hist, |
| sizeof(fps->frames_prev_hist[0]) * (FF_ARRAY_ELEMS(fps->frames_prev_hist) - 1)); |
| fps->frames_prev_hist[0] = *nb_frames_prev; |
| |
| if (*nb_frames_prev == 0 && fps->last_dropped) { |
| atomic_fetch_add(&ofilter->nb_frames_drop, 1); |
| av_log(ofp, AV_LOG_VERBOSE, |
| "*** dropping frame %"PRId64" at ts %"PRId64"\n", |
| fps->frame_number, fps->last_frame->pts); |
| } |
| if (*nb_frames > (*nb_frames_prev && fps->last_dropped) + (*nb_frames > *nb_frames_prev)) { |
| uint64_t nb_frames_dup; |
| if (*nb_frames > dts_error_threshold * 30) { |
| av_log(ofp, AV_LOG_ERROR, "%"PRId64" frame duplication too large, skipping\n", *nb_frames - 1); |
| atomic_fetch_add(&ofilter->nb_frames_drop, 1); |
| *nb_frames = 0; |
| return; |
| } |
| nb_frames_dup = atomic_fetch_add(&ofilter->nb_frames_dup, |
| *nb_frames - (*nb_frames_prev && fps->last_dropped) - (*nb_frames > *nb_frames_prev)); |
| av_log(ofp, AV_LOG_VERBOSE, "*** %"PRId64" dup!\n", *nb_frames - 1); |
| if (nb_frames_dup > fps->dup_warning) { |
| av_log(ofp, AV_LOG_WARNING, "More than %"PRIu64" frames duplicated\n", fps->dup_warning); |
| fps->dup_warning *= 10; |
| } |
| } |
| |
| fps->last_dropped = *nb_frames == *nb_frames_prev && frame; |
| fps->dropped_keyframe |= fps->last_dropped && (frame->flags & AV_FRAME_FLAG_KEY); |
| } |
| |
| static int close_output(OutputFilterPriv *ofp, FilterGraphThread *fgt) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(ofp->ofilter.graph); |
| int ret; |
| |
| // we are finished and no frames were ever seen at this output, |
| // at least initialize the encoder with a dummy frame |
| if (!fgt->got_frame) { |
| AVFrame *frame = fgt->frame; |
| FrameData *fd; |
| |
| frame->time_base = ofp->tb_out; |
| frame->format = ofp->format; |
| |
| frame->width = ofp->width; |
| frame->height = ofp->height; |
| frame->sample_aspect_ratio = ofp->sample_aspect_ratio; |
| |
| frame->sample_rate = ofp->sample_rate; |
| if (ofp->ch_layout.nb_channels) { |
| ret = av_channel_layout_copy(&frame->ch_layout, &ofp->ch_layout); |
| if (ret < 0) |
| return ret; |
| } |
| |
| fd = frame_data(frame); |
| if (!fd) |
| return AVERROR(ENOMEM); |
| |
| fd->frame_rate_filter = ofp->fps.framerate; |
| |
| av_assert0(!frame->buf[0]); |
| |
| av_log(ofp, AV_LOG_WARNING, |
| "No filtered frames for output stream, trying to " |
| "initialize anyway.\n"); |
| |
| ret = sch_filter_send(fgp->sch, fgp->sch_idx, ofp->index, frame); |
| if (ret < 0) { |
| av_frame_unref(frame); |
| return ret; |
| } |
| } |
| |
| fgt->eof_out[ofp->index] = 1; |
| |
| ret = sch_filter_send(fgp->sch, fgp->sch_idx, ofp->index, NULL); |
| return (ret == AVERROR_EOF) ? 0 : ret; |
| } |
| |
| static int fg_output_frame(OutputFilterPriv *ofp, FilterGraphThread *fgt, |
| AVFrame *frame) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(ofp->ofilter.graph); |
| AVFrame *frame_prev = ofp->fps.last_frame; |
| enum AVMediaType type = ofp->ofilter.type; |
| |
| int64_t nb_frames = !!frame, nb_frames_prev = 0; |
| |
| if (type == AVMEDIA_TYPE_VIDEO && (frame || fgt->got_frame)) |
| video_sync_process(ofp, frame, &nb_frames, &nb_frames_prev); |
| |
| for (int64_t i = 0; i < nb_frames; i++) { |
| AVFrame *frame_out; |
| int ret; |
| |
| if (type == AVMEDIA_TYPE_VIDEO) { |
| AVFrame *frame_in = (i < nb_frames_prev && frame_prev->buf[0]) ? |
| frame_prev : frame; |
| if (!frame_in) |
| break; |
| |
| frame_out = fgp->frame_enc; |
| ret = av_frame_ref(frame_out, frame_in); |
| if (ret < 0) |
| return ret; |
| |
| frame_out->pts = ofp->next_pts; |
| |
| if (ofp->fps.dropped_keyframe) { |
| frame_out->flags |= AV_FRAME_FLAG_KEY; |
| ofp->fps.dropped_keyframe = 0; |
| } |
| } else { |
| frame->pts = (frame->pts == AV_NOPTS_VALUE) ? ofp->next_pts : |
| av_rescale_q(frame->pts, frame->time_base, ofp->tb_out) - |
| av_rescale_q(ofp->ts_offset, AV_TIME_BASE_Q, ofp->tb_out); |
| |
| frame->time_base = ofp->tb_out; |
| frame->duration = av_rescale_q(frame->nb_samples, |
| (AVRational){ 1, frame->sample_rate }, |
| ofp->tb_out); |
| |
| ofp->next_pts = frame->pts + frame->duration; |
| |
| frame_out = frame; |
| } |
| |
| // send the frame to consumers |
| ret = sch_filter_send(fgp->sch, fgp->sch_idx, ofp->index, frame_out); |
| if (ret < 0) { |
| av_frame_unref(frame_out); |
| |
| if (!fgt->eof_out[ofp->index]) { |
| fgt->eof_out[ofp->index] = 1; |
| fgp->nb_outputs_done++; |
| } |
| |
| return ret == AVERROR_EOF ? 0 : ret; |
| } |
| |
| if (type == AVMEDIA_TYPE_VIDEO) { |
| ofp->fps.frame_number++; |
| ofp->next_pts++; |
| |
| if (i == nb_frames_prev && frame) |
| frame->flags &= ~AV_FRAME_FLAG_KEY; |
| } |
| |
| fgt->got_frame = 1; |
| } |
| |
| if (frame && frame_prev) { |
| av_frame_unref(frame_prev); |
| av_frame_move_ref(frame_prev, frame); |
| } |
| |
| if (!frame) |
| return close_output(ofp, fgt); |
| |
| return 0; |
| } |
| |
| static int fg_output_step(OutputFilterPriv *ofp, FilterGraphThread *fgt, |
| AVFrame *frame) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(ofp->ofilter.graph); |
| AVFilterContext *filter = ofp->filter; |
| FrameData *fd; |
| int ret; |
| |
| ret = av_buffersink_get_frame_flags(filter, frame, |
| AV_BUFFERSINK_FLAG_NO_REQUEST); |
| if (ret == AVERROR_EOF && !fgt->eof_out[ofp->index]) { |
| ret = fg_output_frame(ofp, fgt, NULL); |
| return (ret < 0) ? ret : 1; |
| } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) { |
| return 1; |
| } else if (ret < 0) { |
| av_log(ofp, AV_LOG_WARNING, |
| "Error in retrieving a frame from the filtergraph: %s\n", |
| av_err2str(ret)); |
| return ret; |
| } |
| |
| if (fgt->eof_out[ofp->index]) { |
| av_frame_unref(frame); |
| return 0; |
| } |
| |
| frame->time_base = av_buffersink_get_time_base(filter); |
| |
| if (debug_ts) |
| 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), |
| frame->time_base.num, frame->time_base.den); |
| |
| // Choose the output timebase the first time we get a frame. |
| if (!ofp->tb_out_locked) { |
| ret = choose_out_timebase(ofp, frame); |
| if (ret < 0) { |
| av_log(ofp, AV_LOG_ERROR, "Could not choose an output time base\n"); |
| av_frame_unref(frame); |
| return ret; |
| } |
| } |
| |
| fd = frame_data(frame); |
| if (!fd) { |
| av_frame_unref(frame); |
| return AVERROR(ENOMEM); |
| } |
| |
| fd->wallclock[LATENCY_PROBE_FILTER_POST] = av_gettime_relative(); |
| |
| // only use bits_per_raw_sample passed through from the decoder |
| // if the filtergraph did not touch the frame data |
| if (!fgp->is_meta) |
| fd->bits_per_raw_sample = 0; |
| |
| if (ofp->ofilter.type == AVMEDIA_TYPE_VIDEO) { |
| if (!frame->duration) { |
| AVRational fr = av_buffersink_get_frame_rate(filter); |
| if (fr.num > 0 && fr.den > 0) |
| frame->duration = av_rescale_q(1, av_inv_q(fr), frame->time_base); |
| } |
| |
| fd->frame_rate_filter = ofp->fps.framerate; |
| } |
| |
| ret = fg_output_frame(ofp, fgt, frame); |
| av_frame_unref(frame); |
| if (ret < 0) |
| return ret; |
| |
| return 0; |
| } |
| |
| /* retrieve all frames available at filtergraph outputs |
| * and send them to consumers */ |
| static int read_frames(FilterGraph *fg, FilterGraphThread *fgt, |
| AVFrame *frame) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(fg); |
| int did_step = 0; |
| |
| // graph not configured, just select the input to request |
| if (!fgt->graph) { |
| for (int i = 0; i < fg->nb_inputs; i++) { |
| InputFilterPriv *ifp = ifp_from_ifilter(fg->inputs[i]); |
| if (ifp->format < 0 && !fgt->eof_in[i]) { |
| fgt->next_in = i; |
| return 0; |
| } |
| } |
| |
| // This state - graph is not configured, but all inputs are either |
| // initialized or EOF - should be unreachable because sending EOF to a |
| // filter without even a fallback format should fail |
| av_assert0(0); |
| return AVERROR_BUG; |
| } |
| |
| while (fgp->nb_outputs_done < fg->nb_outputs) { |
| int ret; |
| |
| ret = avfilter_graph_request_oldest(fgt->graph); |
| if (ret == AVERROR(EAGAIN)) { |
| fgt->next_in = choose_input(fg, fgt); |
| break; |
| } else if (ret < 0) { |
| if (ret == AVERROR_EOF) |
| av_log(fg, AV_LOG_VERBOSE, "Filtergraph returned EOF, finishing\n"); |
| else |
| av_log(fg, AV_LOG_ERROR, |
| "Error requesting a frame from the filtergraph: %s\n", |
| av_err2str(ret)); |
| return ret; |
| } |
| fgt->next_in = fg->nb_inputs; |
| |
| // return after one iteration, so that scheduler can rate-control us |
| if (did_step && fgp->have_sources) |
| return 0; |
| |
| /* Reap all buffers present in the buffer sinks */ |
| for (int i = 0; i < fg->nb_outputs; i++) { |
| OutputFilterPriv *ofp = ofp_from_ofilter(fg->outputs[i]); |
| |
| ret = 0; |
| while (!ret) { |
| ret = fg_output_step(ofp, fgt, frame); |
| if (ret < 0) |
| return ret; |
| } |
| } |
| did_step = 1; |
| } |
| |
| return (fgp->nb_outputs_done == fg->nb_outputs) ? AVERROR_EOF : 0; |
| } |
| |
| static void sub2video_heartbeat(InputFilter *ifilter, int64_t pts, AVRational tb) |
| { |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| int64_t pts2; |
| |
| /* subtitles seem to be usually muxed ahead of other streams; |
| if not, subtracting a larger time here is necessary */ |
| pts2 = av_rescale_q(pts, tb, ifp->time_base) - 1; |
| |
| /* do not send the heartbeat frame if the subtitle is already ahead */ |
| if (pts2 <= ifp->sub2video.last_pts) |
| return; |
| |
| if (pts2 >= ifp->sub2video.end_pts || ifp->sub2video.initialize) |
| /* if we have hit the end of the current displayed subpicture, |
| or if we need to initialize the system, update the |
| overlayed subpicture and its start/end times */ |
| sub2video_update(ifp, pts2 + 1, NULL); |
| else |
| sub2video_push_ref(ifp, pts2); |
| } |
| |
| static int sub2video_frame(InputFilter *ifilter, AVFrame *frame, int buffer) |
| { |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| int ret; |
| |
| if (buffer) { |
| AVFrame *tmp; |
| |
| if (!frame) |
| return 0; |
| |
| tmp = av_frame_alloc(); |
| if (!tmp) |
| return AVERROR(ENOMEM); |
| |
| av_frame_move_ref(tmp, frame); |
| |
| ret = av_fifo_write(ifp->frame_queue, &tmp, 1); |
| if (ret < 0) { |
| av_frame_free(&tmp); |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| // heartbeat frame |
| if (frame && !frame->buf[0]) { |
| sub2video_heartbeat(ifilter, frame->pts, frame->time_base); |
| return 0; |
| } |
| |
| if (!frame) { |
| if (ifp->sub2video.end_pts < INT64_MAX) |
| sub2video_update(ifp, INT64_MAX, NULL); |
| |
| return av_buffersrc_add_frame(ifp->filter, NULL); |
| } |
| |
| ifp->width = frame->width ? frame->width : ifp->width; |
| ifp->height = frame->height ? frame->height : ifp->height; |
| |
| sub2video_update(ifp, INT64_MIN, (const AVSubtitle*)frame->buf[0]->data); |
| |
| return 0; |
| } |
| |
| static int send_eof(FilterGraphThread *fgt, InputFilter *ifilter, |
| int64_t pts, AVRational tb) |
| { |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| int ret; |
| |
| if (fgt->eof_in[ifp->index]) |
| return 0; |
| |
| fgt->eof_in[ifp->index] = 1; |
| |
| if (ifp->filter) { |
| pts = av_rescale_q_rnd(pts, tb, ifp->time_base, |
| AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX); |
| |
| ret = av_buffersrc_close(ifp->filter, pts, AV_BUFFERSRC_FLAG_PUSH); |
| if (ret < 0) |
| return ret; |
| } else { |
| if (ifp->format < 0) { |
| // the filtergraph was never configured, use the fallback parameters |
| ifp->format = ifp->opts.fallback->format; |
| ifp->sample_rate = ifp->opts.fallback->sample_rate; |
| ifp->width = ifp->opts.fallback->width; |
| ifp->height = ifp->opts.fallback->height; |
| ifp->sample_aspect_ratio = ifp->opts.fallback->sample_aspect_ratio; |
| ifp->color_space = ifp->opts.fallback->colorspace; |
| ifp->color_range = ifp->opts.fallback->color_range; |
| ifp->time_base = ifp->opts.fallback->time_base; |
| |
| ret = av_channel_layout_copy(&ifp->ch_layout, |
| &ifp->opts.fallback->ch_layout); |
| if (ret < 0) |
| return ret; |
| |
| if (ifilter_has_all_input_formats(ifilter->graph)) { |
| ret = configure_filtergraph(ifilter->graph, fgt); |
| if (ret < 0) { |
| av_log(NULL, AV_LOG_ERROR, "Error initializing filters!\n"); |
| return ret; |
| } |
| } |
| } |
| |
| if (ifp->format < 0) { |
| av_log(NULL, AV_LOG_ERROR, |
| "Cannot determine format of input %s after EOF\n", |
| ifp->opts.name); |
| return AVERROR_INVALIDDATA; |
| } |
| } |
| |
| return 0; |
| } |
| |
| enum ReinitReason { |
| VIDEO_CHANGED = (1 << 0), |
| AUDIO_CHANGED = (1 << 1), |
| MATRIX_CHANGED = (1 << 2), |
| HWACCEL_CHANGED = (1 << 3) |
| }; |
| |
| static const char *unknown_if_null(const char *str) |
| { |
| return str ? str : "unknown"; |
| } |
| |
| static int send_frame(FilterGraph *fg, FilterGraphThread *fgt, |
| InputFilter *ifilter, AVFrame *frame) |
| { |
| InputFilterPriv *ifp = ifp_from_ifilter(ifilter); |
| FrameData *fd; |
| AVFrameSideData *sd; |
| int need_reinit = 0, ret; |
| |
| /* determine if the parameters for this input changed */ |
| switch (ifp->type) { |
| case AVMEDIA_TYPE_AUDIO: |
| if (ifp->format != frame->format || |
| ifp->sample_rate != frame->sample_rate || |
| av_channel_layout_compare(&ifp->ch_layout, &frame->ch_layout)) |
| need_reinit |= AUDIO_CHANGED; |
| break; |
| case AVMEDIA_TYPE_VIDEO: |
| if (ifp->format != frame->format || |
| ifp->width != frame->width || |
| ifp->height != frame->height || |
| ifp->color_space != frame->colorspace || |
| ifp->color_range != frame->color_range) |
| need_reinit |= VIDEO_CHANGED; |
| break; |
| } |
| |
| if (sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DISPLAYMATRIX)) { |
| if (!ifp->displaymatrix_present || |
| memcmp(sd->data, ifp->displaymatrix, sizeof(ifp->displaymatrix))) |
| need_reinit |= MATRIX_CHANGED; |
| } else if (ifp->displaymatrix_present) |
| need_reinit |= MATRIX_CHANGED; |
| |
| if (!(ifp->opts.flags & IFILTER_FLAG_REINIT) && fgt->graph) |
| need_reinit = 0; |
| |
| if (!!ifp->hw_frames_ctx != !!frame->hw_frames_ctx || |
| (ifp->hw_frames_ctx && ifp->hw_frames_ctx->data != frame->hw_frames_ctx->data)) |
| need_reinit |= HWACCEL_CHANGED; |
| |
| if (need_reinit) { |
| ret = ifilter_parameters_from_frame(ifilter, frame); |
| if (ret < 0) |
| return ret; |
| } |
| |
| /* (re)init the graph if possible, otherwise buffer the frame and return */ |
| if (need_reinit || !fgt->graph) { |
| AVFrame *tmp = av_frame_alloc(); |
| |
| if (!tmp) |
| return AVERROR(ENOMEM); |
| |
| if (!ifilter_has_all_input_formats(fg)) { |
| av_frame_move_ref(tmp, frame); |
| |
| ret = av_fifo_write(ifp->frame_queue, &tmp, 1); |
| if (ret < 0) |
| av_frame_free(&tmp); |
| |
| return ret; |
| } |
| |
| ret = fgt->graph ? read_frames(fg, fgt, tmp) : 0; |
| av_frame_free(&tmp); |
| if (ret < 0) |
| return ret; |
| |
| if (fgt->graph) { |
| AVBPrint reason; |
| av_bprint_init(&reason, 0, AV_BPRINT_SIZE_AUTOMATIC); |
| if (need_reinit & AUDIO_CHANGED) { |
| const char *sample_format_name = av_get_sample_fmt_name(frame->format); |
| av_bprintf(&reason, "audio parameters changed to %d Hz, ", frame->sample_rate); |
| av_channel_layout_describe_bprint(&frame->ch_layout, &reason); |
| av_bprintf(&reason, ", %s, ", unknown_if_null(sample_format_name)); |
| } |
| if (need_reinit & VIDEO_CHANGED) { |
| const char *pixel_format_name = av_get_pix_fmt_name(frame->format); |
| const char *color_space_name = av_color_space_name(frame->colorspace); |
| const char *color_range_name = av_color_range_name(frame->color_range); |
| av_bprintf(&reason, "video parameters changed to %s(%s, %s), %dx%d, ", |
| unknown_if_null(pixel_format_name), unknown_if_null(color_range_name), |
| unknown_if_null(color_space_name), frame->width, frame->height); |
| } |
| if (need_reinit & MATRIX_CHANGED) |
| av_bprintf(&reason, "display matrix changed, "); |
| if (need_reinit & HWACCEL_CHANGED) |
| av_bprintf(&reason, "hwaccel changed, "); |
| if (reason.len > 1) |
| reason.str[reason.len - 2] = '\0'; // remove last comma |
| av_log(fg, AV_LOG_INFO, "Reconfiguring filter graph%s%s\n", reason.len ? " because " : "", reason.str); |
| } |
| |
| ret = configure_filtergraph(fg, fgt); |
| if (ret < 0) { |
| av_log(fg, AV_LOG_ERROR, "Error reinitializing filters!\n"); |
| return ret; |
| } |
| } |
| |
| frame->pts = av_rescale_q(frame->pts, frame->time_base, ifp->time_base); |
| frame->duration = av_rescale_q(frame->duration, frame->time_base, ifp->time_base); |
| frame->time_base = ifp->time_base; |
| |
| if (ifp->displaymatrix_applied) |
| av_frame_remove_side_data(frame, AV_FRAME_DATA_DISPLAYMATRIX); |
| |
| fd = frame_data(frame); |
| if (!fd) |
| return AVERROR(ENOMEM); |
| fd->wallclock[LATENCY_PROBE_FILTER_PRE] = av_gettime_relative(); |
| |
| ret = av_buffersrc_add_frame_flags(ifp->filter, frame, |
| AV_BUFFERSRC_FLAG_PUSH); |
| if (ret < 0) { |
| av_frame_unref(frame); |
| if (ret != AVERROR_EOF) |
| av_log(fg, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret)); |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| static void fg_thread_set_name(const FilterGraph *fg) |
| { |
| char name[16]; |
| if (filtergraph_is_simple(fg)) { |
| OutputFilterPriv *ofp = ofp_from_ofilter(fg->outputs[0]); |
| snprintf(name, sizeof(name), "%cf%s", |
| av_get_media_type_string(ofp->ofilter.type)[0], |
| ofp->name); |
| } else { |
| snprintf(name, sizeof(name), "fc%d", fg->index); |
| } |
| |
| ff_thread_setname(name); |
| } |
| |
| static void fg_thread_uninit(FilterGraphThread *fgt) |
| { |
| if (fgt->frame_queue_out) { |
| AVFrame *frame; |
| while (av_fifo_read(fgt->frame_queue_out, &frame, 1) >= 0) |
| av_frame_free(&frame); |
| av_fifo_freep2(&fgt->frame_queue_out); |
| } |
| |
| av_frame_free(&fgt->frame); |
| av_freep(&fgt->eof_in); |
| av_freep(&fgt->eof_out); |
| |
| avfilter_graph_free(&fgt->graph); |
| |
| memset(fgt, 0, sizeof(*fgt)); |
| } |
| |
| static int fg_thread_init(FilterGraphThread *fgt, const FilterGraph *fg) |
| { |
| memset(fgt, 0, sizeof(*fgt)); |
| |
| fgt->frame = av_frame_alloc(); |
| if (!fgt->frame) |
| goto fail; |
| |
| fgt->eof_in = av_calloc(fg->nb_inputs, sizeof(*fgt->eof_in)); |
| if (!fgt->eof_in) |
| goto fail; |
| |
| fgt->eof_out = av_calloc(fg->nb_outputs, sizeof(*fgt->eof_out)); |
| if (!fgt->eof_out) |
| goto fail; |
| |
| fgt->frame_queue_out = av_fifo_alloc2(1, sizeof(AVFrame*), AV_FIFO_FLAG_AUTO_GROW); |
| if (!fgt->frame_queue_out) |
| goto fail; |
| |
| return 0; |
| |
| fail: |
| fg_thread_uninit(fgt); |
| return AVERROR(ENOMEM); |
| } |
| |
| static int filter_thread(void *arg) |
| { |
| FilterGraphPriv *fgp = arg; |
| FilterGraph *fg = &fgp->fg; |
| |
| FilterGraphThread fgt; |
| int ret = 0, input_status = 0; |
| |
| ret = fg_thread_init(&fgt, fg); |
| if (ret < 0) |
| goto finish; |
| |
| fg_thread_set_name(fg); |
| |
| // if we have all input parameters the graph can now be configured |
| if (ifilter_has_all_input_formats(fg)) { |
| ret = configure_filtergraph(fg, &fgt); |
| if (ret < 0) { |
| av_log(fg, AV_LOG_ERROR, "Error configuring filter graph: %s\n", |
| av_err2str(ret)); |
| goto finish; |
| } |
| } |
| |
| while (1) { |
| InputFilter *ifilter; |
| InputFilterPriv *ifp; |
| enum FrameOpaque o; |
| unsigned input_idx = fgt.next_in; |
| |
| input_status = sch_filter_receive(fgp->sch, fgp->sch_idx, |
| &input_idx, fgt.frame); |
| if (input_status == AVERROR_EOF) { |
| av_log(fg, AV_LOG_VERBOSE, "Filtering thread received EOF\n"); |
| break; |
| } else if (input_status == AVERROR(EAGAIN)) { |
| // should only happen when we didn't request any input |
| av_assert0(input_idx == fg->nb_inputs); |
| goto read_frames; |
| } |
| av_assert0(input_status >= 0); |
| |
| o = (intptr_t)fgt.frame->opaque; |
| |
| o = (intptr_t)fgt.frame->opaque; |
| |
| // message on the control stream |
| if (input_idx == fg->nb_inputs) { |
| FilterCommand *fc; |
| |
| av_assert0(o == FRAME_OPAQUE_SEND_COMMAND && fgt.frame->buf[0]); |
| |
| fc = (FilterCommand*)fgt.frame->buf[0]->data; |
| send_command(fg, fgt.graph, fc->time, fc->target, fc->command, fc->arg, |
| fc->all_filters); |
| av_frame_unref(fgt.frame); |
| continue; |
| } |
| |
| // we received an input frame or EOF |
| ifilter = fg->inputs[input_idx]; |
| ifp = ifp_from_ifilter(ifilter); |
| |
| if (ifp->type_src == AVMEDIA_TYPE_SUBTITLE) { |
| int hb_frame = input_status >= 0 && o == FRAME_OPAQUE_SUB_HEARTBEAT; |
| ret = sub2video_frame(ifilter, (fgt.frame->buf[0] || hb_frame) ? fgt.frame : NULL, |
| !fgt.graph); |
| } else if (fgt.frame->buf[0]) { |
| ret = send_frame(fg, &fgt, ifilter, fgt.frame); |
| } else { |
| av_assert1(o == FRAME_OPAQUE_EOF); |
| ret = send_eof(&fgt, ifilter, fgt.frame->pts, fgt.frame->time_base); |
| } |
| av_frame_unref(fgt.frame); |
| if (ret == AVERROR_EOF) { |
| av_log(fg, AV_LOG_VERBOSE, "Input %u no longer accepts new data\n", |
| input_idx); |
| sch_filter_receive_finish(fgp->sch, fgp->sch_idx, input_idx); |
| continue; |
| } |
| if (ret < 0) |
| goto finish; |
| |
| read_frames: |
| // retrieve all newly avalable frames |
| ret = read_frames(fg, &fgt, fgt.frame); |
| if (ret == AVERROR_EOF) { |
| av_log(fg, AV_LOG_VERBOSE, "All consumers returned EOF\n"); |
| break; |
| } else if (ret < 0) { |
| av_log(fg, AV_LOG_ERROR, "Error sending frames to consumers: %s\n", |
| av_err2str(ret)); |
| goto finish; |
| } |
| } |
| |
| for (unsigned i = 0; i < fg->nb_outputs; i++) { |
| OutputFilterPriv *ofp = ofp_from_ofilter(fg->outputs[i]); |
| |
| if (fgt.eof_out[i] || !fgt.graph) |
| continue; |
| |
| ret = fg_output_frame(ofp, &fgt, NULL); |
| if (ret < 0) |
| goto finish; |
| } |
| |
| finish: |
| // EOF is normal termination |
| if (ret == AVERROR_EOF) |
| ret = 0; |
| |
| fg_thread_uninit(&fgt); |
| |
| return ret; |
| } |
| |
| void fg_send_command(FilterGraph *fg, double time, const char *target, |
| const char *command, const char *arg, int all_filters) |
| { |
| FilterGraphPriv *fgp = fgp_from_fg(fg); |
| AVBufferRef *buf; |
| FilterCommand *fc; |
| |
| fc = av_mallocz(sizeof(*fc)); |
| if (!fc) |
| return; |
| |
| buf = av_buffer_create((uint8_t*)fc, sizeof(*fc), filter_command_free, NULL, 0); |
| if (!buf) { |
| av_freep(&fc); |
| return; |
| } |
| |
| fc->target = av_strdup(target); |
| fc->command = av_strdup(command); |
| fc->arg = av_strdup(arg); |
| if (!fc->target || !fc->command || !fc->arg) { |
| av_buffer_unref(&buf); |
| return; |
| } |
| |
| fc->time = time; |
| fc->all_filters = all_filters; |
| |
| fgp->frame->buf[0] = buf; |
| fgp->frame->opaque = (void*)(intptr_t)FRAME_OPAQUE_SEND_COMMAND; |
| |
| sch_filter_command(fgp->sch, fgp->sch_idx, fgp->frame); |
| } |