From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by master.gitmailbox.com (Postfix) with ESMTPS id 4982A4B336 for ; Sat, 1 Mar 2025 10:03:51 +0000 (UTC) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 6C3ED68E094; Sat, 1 Mar 2025 12:02:48 +0200 (EET) Received: from mail-pl1-f178.google.com (mail-pl1-f178.google.com [209.85.214.178]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 60B3168E090 for ; Sat, 1 Mar 2025 12:02:47 +0200 (EET) Received: by mail-pl1-f178.google.com with SMTP id d9443c01a7336-22185cddbffso70075895ad.1; Sat, 01 Mar 2025 02:02:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1740823365; x=1741428165; darn=ffmpeg.org; h=cc:to:mime-version:content-transfer-encoding:fcc:subject:date :references:in-reply-to:message-id:from:from:to:cc:subject:date :message-id:reply-to; bh=57+1cQI3VvrsVzK6UBt2ALN82xHv2H/eni1/nuTOfUk=; b=N1fSOTS8DcFTTfUBBAE0BHLsMoiy6xzv9pbGHdKolGx1hxkbXOSRked6U9o1LJ8UJO TGinv5dwb22MWoN5ki0gCDA8pvaIOM+Dnhyxxdovo+5zBlCRezpU2F3lY5tiBIkhAe6h Q+qA0vDlS/8ZWQQxPJPHY15yb2GvtFi64EI99Csp8m8Mmqidjy8u8fNHUyBkmvtTKW2e l36kkJba9uC7JLw8cMjV5Ip9jCQDAGCr+xhzF9cArbTJ/GdvlaMlSuIJl/vNCTj8UiJc PMfo57UF09l0QLLdoEHccHKupfgVdFfaoCRtbag0fE/KxWQCU5Yx/u8L9reMHIBbU+k5 cLpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1740823365; x=1741428165; h=cc:to:mime-version:content-transfer-encoding:fcc:subject:date :references:in-reply-to:message-id:from:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=57+1cQI3VvrsVzK6UBt2ALN82xHv2H/eni1/nuTOfUk=; b=CMfWWkety+Fl/avl6qL3s3csN3Pex3CVoijcUnguN4ZR6JbcdSYIb4fNwh6/b01TQH thyf9z6yJJpK21VJMLhe83VcC8nXaTJdUjOKK5rXCuZsgHc+8Q2RqsEDaZ85vYsg/Dox 1OpvwaFVS6YI+rlC6iLG9Bfa+4DaVjIKOxB8m+Qz1+YgdsaoDCrIxxl5sAiWd6973gJt TyRQafYECJEv/gV6MwgbIgpI9F+v2CIdtdoxImGi79rSdDkgoHerhJ+bqDgH582G996M mqitFjv3zqvE3Gy7tshgoBaNnZdnqEaEt/KNLKpF/RxHsal7bFDbRVEqW+Vf0TjwVRex JrFg== X-Forwarded-Encrypted: i=1; AJvYcCX9aRNemYaovZ6K16wMU3fJ7guBUHBqQizMbmUsjzdMd9XsABoz8K/Ov8gGcYkadDlOIP9a+tkBB+fVPiwNTotfU+T26ybCe7M=@ffmpeg.org X-Gm-Message-State: AOJu0YyA1QCPai3EnqWAqJ4y8RkzPT99hHI84eSXkQcmT6HsYOHcFF6x qtmrx4qEK5VCLiGJCTNK4gbVZkwEomJ/zg+t00p4w/SMKU8ntoMXpdWobg== X-Gm-Gg: ASbGncuslmvdnvuko6xNl0KcKPIrqP0Uk1REYQD9UuzS4JU1peKfhqe+0BUlK3DxDaH qIHPoZq7uMXnX++vPoAGO6LnHVBYcuwSldXTv5ZNlM4vxbNiERyagCCx4pmn1sSreM+d3nKi7lE 39r96xjvIPd5QijptLHDnTSU6V8pApu0TndJfPzB2qVE1mqaEIhIYrO6PhnOR0drdZS8zAWtz9S mw7o0Bw83USoKygESsyqKYE7q6iGqfOBPPJWX3A55/nIwjOtLIlw4Uq6aWhpKAyMvPns34yLHgE iifYaVDEE4K9NmQj0nkFKXHmh4pK7YlbFir8pDsLzNJa/Z4rIpR0LCdyjPr1BE4= X-Google-Smtp-Source: AGHT+IFcTHvllXztfDyPbQyRdcFDtS8nLPQMNEJz6csuPZhBWxG19i/r3JxwAHXRETt4YaZW+QmRDw== X-Received: by 2002:a05:6a20:d491:b0:1ee:cfaa:f17d with SMTP id adf61e73a8af0-1f2f3cdda30mr11473762637.4.1740823365391; Sat, 01 Mar 2025 02:02:45 -0800 (PST) Received: from [127.0.0.1] (master.gitmailbox.com. [34.83.118.50]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-734b18cfb66sm3060479b3a.116.2025.03.01.02.02.44 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Sat, 01 Mar 2025 02:02:45 -0800 (PST) From: softworkz X-Google-Original-From: softworkz Message-Id: <9d76b4df1b3bd39f5fe35e2bb38a9ea39a75583b.1740823324.git.ffmpegagent@gmail.com> In-Reply-To: References: Date: Sat, 01 Mar 2025 10:02:03 +0000 Fcc: Sent MIME-Version: 1.0 To: ffmpeg-devel@ffmpeg.org Subject: [FFmpeg-devel] [PATCH v3 6/7] fftools/ffmpeg_graphprint: Add options for filtergraph printing X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Soft Works , softworkz , Andreas Rheinhardt Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" Archived-At: List-Archive: List-Post: From: softworkz The key benefits are: - Different to other graph printing methods, this is outputting: - all graphs with runtime state (including auto-inserted filters) - each graph with its inputs and outputs - all filters with their in- and output pads - all connections between all input- and output pads - for each connection: - the runtime-negotiated format and media type - the hw context - if video hw context, both: hw pixfmt + sw pixfmt - Output can either be printed to stdout or written to specified file - Output is machine-readable - Use the same output implementation as ffprobe, supporting multiple formats Signed-off-by: softworkz --- fftools/Makefile | 11 + fftools/ffmpeg.h | 3 + fftools/ffmpeg_graphprint.c | 474 ++++++++++++++++++++++++++++++++++++ fftools/ffmpeg_graphprint.h | 79 ++++++ fftools/ffmpeg_opt.c | 12 + 5 files changed, 579 insertions(+) create mode 100644 fftools/ffmpeg_graphprint.c create mode 100644 fftools/ffmpeg_graphprint.h diff --git a/fftools/Makefile b/fftools/Makefile index 664b73b161..03cdbd4b6e 100644 --- a/fftools/Makefile +++ b/fftools/Makefile @@ -19,8 +19,19 @@ OBJS-ffmpeg += \ fftools/ffmpeg_mux_init.o \ fftools/ffmpeg_opt.o \ fftools/ffmpeg_sched.o \ + fftools/ffmpeg_graphprint.o \ fftools/sync_queue.o \ fftools/thread_queue.o \ + fftools/textformat/avtextformat.o \ + fftools/textformat/tf_compact.o \ + fftools/textformat/tf_default.o \ + fftools/textformat/tf_flat.o \ + fftools/textformat/tf_ini.o \ + fftools/textformat/tf_json.o \ + fftools/textformat/tf_xml.o \ + fftools/textformat/tw_avio.o \ + fftools/textformat/tw_buffer.o \ + fftools/textformat/tw_stdout.o \ OBJS-ffprobe += \ fftools/textformat/avtextformat.o \ diff --git a/fftools/ffmpeg.h b/fftools/ffmpeg.h index 86a3e10c6b..9880236162 100644 --- a/fftools/ffmpeg.h +++ b/fftools/ffmpeg.h @@ -715,6 +715,9 @@ extern float max_error_rate; extern char *filter_nbthreads; extern int filter_complex_nbthreads; extern int vstats_version; +extern int print_graphs; +extern char* print_graphs_file; +extern char* print_graphs_format; extern int auto_conversion_filters; extern const AVIOInterruptCB int_cb; diff --git a/fftools/ffmpeg_graphprint.c b/fftools/ffmpeg_graphprint.c new file mode 100644 index 0000000000..b374c92743 --- /dev/null +++ b/fftools/ffmpeg_graphprint.c @@ -0,0 +1,474 @@ +/* + * Copyright (c) 2018 - softworkz + * + * 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 + */ + +/** + * @file + * output writers for filtergraph details + */ + +#include "config.h" + +#include + +#include "ffmpeg_graphprint.h" +#include "ffmpeg_filter.h" + +#include "libavutil/avassert.h" +#include "libavutil/avstring.h" +#include "libavutil/pixdesc.h" +#include "libavutil/dict.h" +#include "libavutil/common.h" +#include "libavfilter/avfilter.h" +#include "libavutil/buffer.h" +#include "libavutil/hwcontext.h" +#include "textformat/avtextformat.h" + +/* Text Format API Shortcuts */ +#define print_int(k, v) avtext_print_integer(w, k, v) +#define print_q(k, v, s) avtext_print_rational(w, k, v, s) +#define print_str(k, v) avtext_print_string(w, k, v, 0) + +static void print_hwdevicecontext(AVTextFormatContext *w, const AVHWDeviceContext *hw_device_context) +{ + avtext_print_section_header(w, NULL, SECTION_ID_HWDEViCECONTEXT); + + print_int("HasHwDeviceContext", 1); + print_str("DeviceType", av_hwdevice_get_type_name(hw_device_context->type)); + + avtext_print_section_footer(w); // SECTION_ID_HWDEViCECONTEXT +} + +static void print_hwframescontext(AVTextFormatContext *w, const AVHWFramesContext *hw_frames_context) +{ + const AVPixFmtDescriptor* pixdescHw; + const AVPixFmtDescriptor* pixdescSw; + + avtext_print_section_header(w, NULL, SECTION_ID_HWFRAMESCONTEXT); + + print_int("HasHwFramesContext", 1); + + pixdescHw = av_pix_fmt_desc_get(hw_frames_context->format); + if (pixdescHw) { + print_str("HwPixelFormat", pixdescHw->name); + print_str("HwPixelFormatAlias", pixdescHw->alias); + } + + pixdescSw = av_pix_fmt_desc_get(hw_frames_context->sw_format); + if (pixdescSw) { + print_str("SwPixelFormat", pixdescSw->name); + print_str("SwPixelFormatAlias", pixdescSw->alias); + } + + print_int("Width", hw_frames_context->width); + print_int("Height", hw_frames_context->height); + + print_hwdevicecontext(w, hw_frames_context->device_ctx); + + avtext_print_section_footer(w); // SECTION_ID_HWFRAMESCONTEXT +} + +static void print_link(AVTextFormatContext *w, AVFilterLink *link) +{ + char layoutString[64]; + + switch (link->type) { + case AVMEDIA_TYPE_VIDEO: + print_str("Format", av_x_if_null(av_get_pix_fmt_name(link->format), "?")); + print_int("Width", link->w); + print_int("Height", link->h); + print_q("SAR", link->sample_aspect_ratio, ':'); + print_q("TimeBase", link->time_base, '/'); + break; + + ////case AVMEDIA_TYPE_SUBTITLE: + //// print_str("Format", av_x_if_null(av_get_subtitle_fmt_name(link->format), "?")); + //// print_int("Width", link->w); + //// print_int("Height", link->h); + //// print_q("TimeBase", link->time_base, '/'); + //// break; + + case AVMEDIA_TYPE_AUDIO: + av_channel_layout_describe(&link->ch_layout, layoutString, sizeof(layoutString)); + print_str("ChannelString", layoutString); + print_int("Channels", link->ch_layout.nb_channels); + ////print_int("ChannelLayout", link->ch_layout); + print_int("SampleRate", link->sample_rate); + break; + } + + AVBufferRef *hw_frames_ctx = avfilter_link_get_hw_frames_ctx(link); + + if (hw_frames_ctx && hw_frames_ctx->buffer) { + print_hwframescontext(w, (AVHWFramesContext *)hw_frames_ctx->data); + } +} + +static void print_filter(AVTextFormatContext *w, const AVFilterContext* filter) +{ + avtext_print_section_header(w, NULL, SECTION_ID_FILTER); + + print_str("Name", filter->name); + + if (filter->filter) { + print_str("Name2", filter->filter->name); + print_str("Description", filter->filter->description); + } + + if (filter->hw_device_ctx) { + AVHWDeviceContext* decCtx = (AVHWDeviceContext*)filter->hw_device_ctx->data; + print_hwdevicecontext(w, decCtx); + } + + avtext_print_section_header(w, NULL, SECTION_ID_INPUTS); + + for (unsigned i = 0; i < filter->nb_inputs; i++) { + AVFilterLink *link = filter->inputs[i]; + avtext_print_section_header(w, NULL, SECTION_ID_INPUT); + + print_str("SourceName", link->src->name); + print_str("SourcePadName", avfilter_pad_get_name(link->srcpad, 0)); + print_str("DestPadName", avfilter_pad_get_name(link->dstpad, 0)); + + print_link(w, link); + + avtext_print_section_footer(w); // SECTION_ID_INPUT + } + + avtext_print_section_footer(w); // SECTION_ID_INPUTS + + avtext_print_section_header(w, NULL, SECTION_ID_OUTPUTS); + + for (unsigned i = 0; i < filter->nb_outputs; i++) { + AVFilterLink *link = filter->outputs[i]; + avtext_print_section_header(w, NULL, SECTION_ID_OUTPUT); + + print_str("DestName", link->dst->name); + print_str("DestPadName", avfilter_pad_get_name(link->dstpad, 0)); + print_str("SourceName", link->src->name); + + print_link(w, link); + + avtext_print_section_footer(w); // SECTION_ID_OUTPUT + } + + avtext_print_section_footer(w); // SECTION_ID_OUTPUTS + + avtext_print_section_footer(w); // SECTION_ID_FILTER +} + +static void init_sections(void) +{ + for (unsigned i = 0; i < FF_ARRAY_ELEMS(sections); i++) + sections[i].show_all_entries = 1; +} + +static void print_filtergraph_single(AVTextFormatContext *w, FilterGraph* fg, AVFilterGraph *graph) +{ + char layoutString[64]; + FilterGraphPriv *fgp = fgp_from_fg(fg); + + print_int("GraphIndex", fg->index); + print_str("Description", fgp->graph_desc); + + avtext_print_section_header(w, NULL, SECTION_ID_INPUTS); + + for (int i = 0; i < fg->nb_inputs; i++) { + InputFilterPriv* ifilter = ifp_from_ifilter(fg->inputs[i]); + enum AVMediaType mediaType = ifilter->type; + + avtext_print_section_header(w, NULL, SECTION_ID_INPUT); + + print_str("Name1", (char*)ifilter->ifilter.name); + + if (ifilter->filter) { + print_str("Name2", ifilter->filter->name); + print_str("Name3", ifilter->filter->filter->name); + print_str("Description", ifilter->filter->filter->description); + } + + print_str("MediaType", av_get_media_type_string(mediaType)); + print_int("MediaTypeId", mediaType); + + switch (ifilter->type) { + case AVMEDIA_TYPE_VIDEO: + case AVMEDIA_TYPE_SUBTITLE: + print_str("Format", av_x_if_null(av_get_pix_fmt_name(ifilter->format), "?")); + print_int("Width", ifilter->width); + print_int("Height", ifilter->height); + print_q("SAR", ifilter->sample_aspect_ratio, ':'); + break; + case AVMEDIA_TYPE_AUDIO: + + av_channel_layout_describe(&ifilter->ch_layout, layoutString, sizeof(layoutString)); + print_str("ChannelString", layoutString); + print_int("SampleRate", ifilter->sample_rate); + break; + case AVMEDIA_TYPE_ATTACHMENT: + case AVMEDIA_TYPE_DATA: + break; + } + + if (ifilter->hw_frames_ctx) + print_hwframescontext(w, (AVHWFramesContext*)ifilter->hw_frames_ctx->data); + else if (ifilter->filter && ifilter->filter->hw_device_ctx) { + AVHWDeviceContext* devCtx = (AVHWDeviceContext*)ifilter->filter->hw_device_ctx->data; + print_hwdevicecontext(w, devCtx); + } + + avtext_print_section_footer(w); // SECTION_ID_INPUT + } + + avtext_print_section_footer(w); // SECTION_ID_INPUTS + + + avtext_print_section_header(w, NULL, SECTION_ID_OUTPUTS); + + for (int i = 0; i < fg->nb_outputs; i++) { + OutputFilterPriv *ofilter = ofp_from_ofilter(fg->outputs[i]); + enum AVMediaType mediaType = AVMEDIA_TYPE_UNKNOWN; + + avtext_print_section_header(w, NULL, SECTION_ID_OUTPUT); + print_str("Name1", ofilter->name); + + if (ofilter->filter) { + print_str("Name2", ofilter->filter->name); + print_str("Name3", ofilter->filter->filter->name); + print_str("Description", ofilter->filter->filter->description); + + if (ofilter->filter->nb_inputs > 0) + mediaType = ofilter->filter->inputs[0]->type; + } + + print_str("MediaType", av_get_media_type_string(mediaType)); + print_int("MediaTypeId", mediaType); + + switch (ofilter->ofilter.type) { + case AVMEDIA_TYPE_VIDEO: + case AVMEDIA_TYPE_SUBTITLE: + print_str("Format", av_x_if_null(av_get_pix_fmt_name(ofilter->format), "?")); + print_int("Width", ofilter->width); + print_int("Height", ofilter->height); + break; + case AVMEDIA_TYPE_AUDIO: + + av_channel_layout_describe(&ofilter->ch_layout, layoutString, sizeof(layoutString)); + print_str("ChannelString", layoutString); + print_int("SampleRate", ofilter->sample_rate); + break; + case AVMEDIA_TYPE_ATTACHMENT: + case AVMEDIA_TYPE_DATA: + break; + } + + if (ofilter->filter && ofilter->filter->hw_device_ctx) { + AVHWDeviceContext* devCtx = (AVHWDeviceContext*)ofilter->filter->hw_device_ctx->data; + print_hwdevicecontext(w, devCtx); + } + + avtext_print_section_footer(w); // SECTION_ID_OUTPUT + } + + avtext_print_section_footer(w); // SECTION_ID_OUTPUTS + + + avtext_print_section_header(w, NULL, SECTION_ID_FILTERS); + + if (graph) { + for (unsigned i = 0; i < graph->nb_filters; i++) { + AVFilterContext *filter = graph->filters[i]; + avtext_print_section_header(w, NULL, SECTION_ID_FILTER); + + print_filter(w, filter); + + avtext_print_section_footer(w); // SECTION_ID_FILTER + } + } + + avtext_print_section_footer(w); // SECTION_ID_FILTERS +} + +int print_filtergraph(FilterGraph *fg, AVFilterGraph *graph) +{ + const AVTextFormatter *text_formatter; + AVTextFormatContext *tctx; + AVTextWriterContext *wctx; + char *w_name, *w_args; + int ret; + FilterGraphPriv *fgp = fgp_from_fg(fg); + AVBPrint *target_buf = &fgp->graph_print_buf; + + init_sections(); + + if (target_buf->len) + av_bprint_finalize(target_buf, NULL); + + av_bprint_init(target_buf, 0, AV_BPRINT_SIZE_UNLIMITED); + + if (!print_graphs_format) + print_graphs_format = av_strdup("default"); + if (!print_graphs_format) + return AVERROR(ENOMEM); + + w_name = av_strtok(print_graphs_format, "=", &w_args); + if (!w_name) { + av_log(NULL, AV_LOG_ERROR, "No name specified for the filter graph output format\n"); + return AVERROR(EINVAL); + } + + text_formatter = avtext_get_formatter_by_name(w_name); + if (text_formatter == NULL) { + av_log(NULL, AV_LOG_ERROR, "Unknown filter graph output format with name '%s'\n", w_name); + return AVERROR(EINVAL); + } + + ret = avtextwriter_create_buffer(&wctx, target_buf); + if (ret < 0) { + av_log(NULL, AV_LOG_ERROR, "avtextwriter_create_buffer failed. Error code %d\n", ret); + return AVERROR(EINVAL); + } + + if ((ret = avtext_context_open(&tctx, text_formatter, wctx, w_args, sections, FF_ARRAY_ELEMS(sections), 0, 0, 0, 0, -1, NULL)) >= 0) { + avtext_print_section_header(tctx, NULL, SECTION_ID_ROOT); + avtext_print_section_header(tctx, NULL, SECTION_ID_FILTERGRAPHS); + avtext_print_section_header(tctx, NULL, SECTION_ID_FILTERGRAPH); + + av_bprint_clear(target_buf); + + print_filtergraph_single(tctx, fg, graph); + + avtext_context_close(&tctx); + avtextwriter_context_close(&wctx); + } else + return ret; + + return 0; +} + +int print_filtergraphs(FilterGraph **graphs, int nb_graphs, OutputFile **ofiles, int nb_ofiles) +{ + const AVTextFormatter *text_formatter; + AVTextFormatContext *tctx; + AVTextWriterContext *wctx; + AVBPrint target_buf; + char *buf, *w_name, *w_args; + int ret; + + init_sections(); + + if (!print_graphs_format) + print_graphs_format = av_strdup("default"); + if (!print_graphs_format) { + return AVERROR(ENOMEM); + } + + w_name = av_strtok(print_graphs_format, "=", &buf); + if (!w_name) { + av_log(NULL, AV_LOG_ERROR, "No name specified for the filter graph output format\n"); + return AVERROR(EINVAL); + } + w_args = buf; + + text_formatter = avtext_get_formatter_by_name(w_name); + if (text_formatter == NULL) { + av_log(NULL, AV_LOG_ERROR, "Unknown filter graph output format with name '%s'\n", w_name); + return AVERROR(EINVAL); + } + + av_bprint_init(&target_buf, 0, AV_BPRINT_SIZE_UNLIMITED); + + ret = avtextwriter_create_buffer(&wctx, &target_buf); + if (ret < 0) { + av_log(NULL, AV_LOG_ERROR, "avtextwriter_create_buffer failed. Error code %d\n", ret); + return AVERROR(EINVAL); + } + + if ((ret = avtext_context_open(&tctx, text_formatter, wctx, w_args, sections, FF_ARRAY_ELEMS(sections), 0, 0, 0, 0, -1, NULL)) >= 0) { + avtext_print_section_header(tctx, NULL, SECTION_ID_ROOT); + + avtext_print_section_header(tctx, NULL, SECTION_ID_FILTERGRAPHS); + + for (int i = 0; i < nb_graphs; i++) { + + FilterGraphPriv *fgp = fgp_from_fg(graphs[i]); + AVBPrint *graph_buf = &fgp->graph_print_buf; + + if (graph_buf->len > 0) { + avtext_print_section_header(tctx, NULL, SECTION_ID_FILTERGRAPH); + + av_bprint_append_data(&target_buf, graph_buf->str, graph_buf->len); + av_bprint_finalize(graph_buf, NULL); + + avtext_print_section_footer(tctx); // SECTION_ID_FILTERGRAPH + } + } + + for (int n = 0; n < nb_ofiles; n++) { + OutputFile *of = ofiles[n]; + + for (int i = 0; i < of->nb_streams; i++) { + OutputStream *ost = of->streams[i]; + + if (ost->fg_simple) { + FilterGraphPriv *fgp = fgp_from_fg(ost->fg_simple); + AVBPrint *graph_buf = &fgp->graph_print_buf; + + if (graph_buf->len > 0) { + avtext_print_section_header(tctx, NULL, SECTION_ID_FILTERGRAPH); + + av_bprint_append_data(&target_buf, graph_buf->str, graph_buf->len); + av_bprint_finalize(graph_buf, NULL); + + avtext_print_section_footer(tctx); // SECTION_ID_FILTERGRAPH + } + } + } + } + + avtext_print_section_footer(tctx); // SECTION_ID_FILTERGRAPHS + avtext_print_section_footer(tctx); // SECTION_ID_ROOT + + if (print_graphs_file) { + AVIOContext *avio = NULL; + + ret = avio_open2(&avio, print_graphs_file, AVIO_FLAG_WRITE, NULL, NULL); + if (ret < 0) { + av_log(NULL, AV_LOG_ERROR, "Failed to open graph output file, \"%s\": %s\n", + print_graphs_file, av_err2str(ret)); + return ret; + } + + avio_write(avio, (const unsigned char*)target_buf.str, FFMIN(target_buf.len, target_buf.size - 1)); + avio_flush(avio); + + if ((ret = avio_closep(&avio)) < 0) + av_log(NULL, AV_LOG_ERROR, "Error closing graph output file, loss of information possible: %s\n", av_err2str(ret)); + } + + if (print_graphs) { + printf("%s", target_buf.str); + av_log(NULL, AV_LOG_INFO, "%s %c", target_buf.str, '\n'); + } + + avtext_context_close(&tctx); + avtextwriter_context_close(&wctx); + } + + return 0; +} diff --git a/fftools/ffmpeg_graphprint.h b/fftools/ffmpeg_graphprint.h new file mode 100644 index 0000000000..5c2635765c --- /dev/null +++ b/fftools/ffmpeg_graphprint.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2018 - softworkz + * + * 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 + */ + +#ifndef FFTOOLS_FFMPEG_GRAPHPRINT_H +#define FFTOOLS_FFMPEG_GRAPHPRINT_H + +#include + +#include "config.h" +#include "ffmpeg.h" +#include "libavutil/avutil.h" +#include "libavutil/bprint.h" +#include "textformat/avtextformat.h" + +typedef enum { + SECTION_ID_ROOT, + SECTION_ID_PROGRAM_VERSION, + SECTION_ID_FILTERGRAPHS, + SECTION_ID_FILTERGRAPH, + SECTION_ID_INPUTS, + SECTION_ID_INPUT, + SECTION_ID_OUTPUTS, + SECTION_ID_OUTPUT, + SECTION_ID_FILTERS, + SECTION_ID_FILTER, + SECTION_ID_HWDEViCECONTEXT, + SECTION_ID_HWFRAMESCONTEXT, + SECTION_ID_ERROR, + SECTION_ID_LOG, + SECTION_ID_LOGS, + +} SectionID; + +static struct AVTextFormatSection sections[] = { + [SECTION_ID_ROOT] = { SECTION_ID_ROOT, "GraphDescription", AV_TEXTFORMAT_SECTION_FLAG_IS_WRAPPER, + { SECTION_ID_ERROR, SECTION_ID_PROGRAM_VERSION, SECTION_ID_FILTERGRAPHS, SECTION_ID_LOGS, -1} }, + [SECTION_ID_PROGRAM_VERSION] = { SECTION_ID_PROGRAM_VERSION, "ProgramVersion", 0, { -1 } }, + + [SECTION_ID_FILTERGRAPHS] = { SECTION_ID_FILTERGRAPHS, "Graphs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FILTERGRAPH, -1 } }, + [SECTION_ID_FILTERGRAPH] = { SECTION_ID_FILTERGRAPH, "Graph", 0, { SECTION_ID_INPUTS, SECTION_ID_OUTPUTS, SECTION_ID_FILTERS, -1 }, }, + + [SECTION_ID_INPUTS] = { SECTION_ID_INPUTS, "Inputs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_INPUT, SECTION_ID_ERROR, -1 } }, + [SECTION_ID_INPUT] = { SECTION_ID_INPUT, "Input", 0, { SECTION_ID_HWFRAMESCONTEXT, SECTION_ID_ERROR, -1 }, }, + + [SECTION_ID_OUTPUTS] = { SECTION_ID_OUTPUTS, "Outputs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_OUTPUT, SECTION_ID_ERROR, -1 } }, + [SECTION_ID_OUTPUT] = { SECTION_ID_OUTPUT, "Output", 0, { SECTION_ID_HWFRAMESCONTEXT, SECTION_ID_ERROR, -1 }, }, + + [SECTION_ID_FILTERS] = { SECTION_ID_FILTERS, "Filters", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FILTER, SECTION_ID_ERROR, -1 } }, + [SECTION_ID_FILTER] = { SECTION_ID_FILTER, "Filter", 0, { SECTION_ID_HWDEViCECONTEXT, SECTION_ID_ERROR, -1 }, }, + + [SECTION_ID_HWDEViCECONTEXT] = { SECTION_ID_HWDEViCECONTEXT, "HwDeviceContext", 0, { SECTION_ID_ERROR, -1 }, }, + [SECTION_ID_HWFRAMESCONTEXT] = { SECTION_ID_HWFRAMESCONTEXT, "HwFramesContext", 0, { SECTION_ID_ERROR, -1 }, }, + + [SECTION_ID_ERROR] = { SECTION_ID_ERROR, "Error", 0, { -1 } }, + [SECTION_ID_LOGS] = { SECTION_ID_LOGS, "Log", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_LOG, -1 } }, + [SECTION_ID_LOG] = { SECTION_ID_LOG, "LogEntry", 0, { -1 }, }, +}; + +int print_filtergraphs(FilterGraph **graphs, int nb_graphs, OutputFile **output_files, int nb_output_files); +int print_filtergraph(FilterGraph *fg, AVFilterGraph *graph); + +#endif /* FFTOOLS_FFMPEG_GRAPHPRINT_H */ diff --git a/fftools/ffmpeg_opt.c b/fftools/ffmpeg_opt.c index 27a9fc9e42..f63d253f53 100644 --- a/fftools/ffmpeg_opt.c +++ b/fftools/ffmpeg_opt.c @@ -75,6 +75,9 @@ float max_error_rate = 2.0/3; char *filter_nbthreads; int filter_complex_nbthreads = 0; int vstats_version = 2; +int print_graphs = 0; +char* print_graphs_file = NULL; +char* print_graphs_format = NULL; int auto_conversion_filters = 1; int64_t stats_period = 500000; @@ -1733,6 +1736,15 @@ const OptionDef options[] = { { .func_arg = opt_filter_complex_script }, "deprecated, use -/filter_complex instead", "filename" }, #endif + { "print_graphs", OPT_TYPE_BOOL, 0, + { &print_graphs }, + "prints filtergraph details to stderr" }, + { "print_graphs_file", OPT_TYPE_STRING, 0, + { &print_graphs_file }, + "writes graph details to a file", "filename" }, + { "print_graphs_format", OPT_TYPE_STRING, 0, + { &print_graphs_format }, + "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" }, { "auto_conversion_filters", OPT_TYPE_BOOL, OPT_EXPERT, { &auto_conversion_filters }, "enable automatic conversion filters globally" }, -- ffmpeg-codebot _______________________________________________ ffmpeg-devel mailing list ffmpeg-devel@ffmpeg.org https://ffmpeg.org/mailman/listinfo/ffmpeg-devel To unsubscribe, visit link above, or email ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".