FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2018-2025 - softworkz
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			/**
22			* @file
23			* output writers for filtergraph details
24			*/
25
26			#include <string.h>
27			#include <stdatomic.h>
28
29			#include "graphprint.h"
30
31			#include "fftools/ffmpeg.h"
32			#include "fftools/ffmpeg_mux.h"
33
34			#include "libavutil/avassert.h"
35			#include "libavutil/avstring.h"
36			#include "libavutil/pixdesc.h"
37			#include "libavutil/dict.h"
38			#include "libavutil/common.h"
39			#include "libavfilter/avfilter.h"
40			#include "libavutil/buffer.h"
41			#include "libavutil/hwcontext.h"
42			#include "fftools/textformat/avtextformat.h"
43			#include "fftools/textformat/tf_mermaid.h"
44			#include "fftools/resources/resman.h"
45
46			typedef enum {
47			SECTION_ID_ROOT,
48			SECTION_ID_FILTERGRAPHS,
49			SECTION_ID_FILTERGRAPH,
50			SECTION_ID_GRAPH_INPUTS,
51			SECTION_ID_GRAPH_INPUT,
52			SECTION_ID_GRAPH_OUTPUTS,
53			SECTION_ID_GRAPH_OUTPUT,
54			SECTION_ID_FILTERS,
55			SECTION_ID_FILTER,
56			SECTION_ID_FILTER_INPUTS,
57			SECTION_ID_FILTER_INPUT,
58			SECTION_ID_FILTER_OUTPUTS,
59			SECTION_ID_FILTER_OUTPUT,
60			SECTION_ID_HWFRAMESCONTEXT,
61			SECTION_ID_INPUTFILES,
62			SECTION_ID_INPUTFILE,
63			SECTION_ID_INPUTSTREAMS,
64			SECTION_ID_INPUTSTREAM,
65			SECTION_ID_OUTPUTFILES,
66			SECTION_ID_OUTPUTFILE,
67			SECTION_ID_OUTPUTSTREAMS,
68			SECTION_ID_OUTPUTSTREAM,
69			SECTION_ID_STREAMLINKS,
70			SECTION_ID_STREAMLINK,
71			SECTION_ID_DECODERS,
72			SECTION_ID_DECODER,
73			SECTION_ID_ENCODERS,
74			SECTION_ID_ENCODER,
75			} SectionID;
76
77			static const AVTextFormatSection sections[] = {
78			[SECTION_ID_ROOT] = { SECTION_ID_ROOT, "root", AV_TEXTFORMAT_SECTION_FLAG_IS_WRAPPER, { SECTION_ID_FILTERGRAPHS, SECTION_ID_INPUTFILES, SECTION_ID_OUTPUTFILES, SECTION_ID_DECODERS, SECTION_ID_ENCODERS, SECTION_ID_STREAMLINKS, -1 } },
79
80			[SECTION_ID_FILTERGRAPHS] = { SECTION_ID_FILTERGRAPHS, "graphs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FILTERGRAPH, -1 } },
81			[SECTION_ID_FILTERGRAPH] = { SECTION_ID_FILTERGRAPH, "graph", AV_TEXTFORMAT_SECTION_FLAG_HAS_VARIABLE_FIELDS, { SECTION_ID_GRAPH_INPUTS, SECTION_ID_GRAPH_OUTPUTS, SECTION_ID_FILTERS, -1 }, .element_name = "graph_info" },
82
83			[SECTION_ID_GRAPH_INPUTS] = { SECTION_ID_GRAPH_INPUTS, "graph_inputs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_GRAPH_INPUT, -1 }, .id_key = "id" },
84			[SECTION_ID_GRAPH_INPUT] = { SECTION_ID_GRAPH_INPUT, "graph_input", 0, { -1 }, .id_key = "filter_id" },
85
86			[SECTION_ID_GRAPH_OUTPUTS] = { SECTION_ID_GRAPH_OUTPUTS, "graph_outputs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_GRAPH_OUTPUT, -1 }, .id_key = "id" },
87			[SECTION_ID_GRAPH_OUTPUT] = { SECTION_ID_GRAPH_OUTPUT, "graph_output", 0, { -1 }, .id_key = "filter_id" },
88
89			[SECTION_ID_FILTERS] = { SECTION_ID_FILTERS, "filters", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY | AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_FILTER, -1 }, .id_key = "graph_id" },
90			[SECTION_ID_FILTER] = { SECTION_ID_FILTER, "filter", AV_TEXTFORMAT_SECTION_FLAG_IS_SHAPE | AV_TEXTFORMAT_SECTION_PRINT_TAGS, { SECTION_ID_FILTER_INPUTS, SECTION_ID_FILTER_OUTPUTS, -1 }, .id_key = "filter_id" },
91
92			[SECTION_ID_FILTER_INPUTS] = { SECTION_ID_FILTER_INPUTS, "filter_inputs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FILTER_INPUT, -1 } },
93			[SECTION_ID_FILTER_INPUT] = { SECTION_ID_FILTER_INPUT, "filter_input", AV_TEXTFORMAT_SECTION_FLAG_HAS_LINKS, { SECTION_ID_HWFRAMESCONTEXT, -1 }, .id_key = "filter_id", .src_id_key = "source_filter_id", .dest_id_key = "filter_id" },
94
95			[SECTION_ID_FILTER_OUTPUTS] = { SECTION_ID_FILTER_OUTPUTS, "filter_outputs", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_FILTER_OUTPUT, -1 } },
96			[SECTION_ID_FILTER_OUTPUT] = { SECTION_ID_FILTER_OUTPUT, "filter_output", AV_TEXTFORMAT_SECTION_FLAG_HAS_LINKS, { SECTION_ID_HWFRAMESCONTEXT, -1 }, .id_key = "filter_id", .src_id_key = "filter_id", .dest_id_key = "dest_filter_id" },
97
98			[SECTION_ID_HWFRAMESCONTEXT] = { SECTION_ID_HWFRAMESCONTEXT, "hw_frames_context", 0, { -1 }, },
99
100			[SECTION_ID_INPUTFILES] = { SECTION_ID_INPUTFILES, "inputfiles", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY | AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_INPUTFILE, -1 }, .id_key = "id" },
101			[SECTION_ID_INPUTFILE] = { SECTION_ID_INPUTFILE, "inputfile", AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_INPUTSTREAMS, -1 }, .id_key = "id" },
102
103			[SECTION_ID_INPUTSTREAMS] = { SECTION_ID_INPUTSTREAMS, "inputstreams", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY | AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_INPUTSTREAM, -1 }, .id_key = "id" },
104			[SECTION_ID_INPUTSTREAM] = { SECTION_ID_INPUTSTREAM, "inputstream", AV_TEXTFORMAT_SECTION_FLAG_IS_SHAPE | AV_TEXTFORMAT_SECTION_PRINT_TAGS, { -1 }, .id_key = "id" },
105
106			[SECTION_ID_OUTPUTFILES] = { SECTION_ID_OUTPUTFILES, "outputfiles", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY | AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_OUTPUTFILE, -1 }, .id_key = "id" },
107			[SECTION_ID_OUTPUTFILE] = { SECTION_ID_OUTPUTFILE, "outputfile", AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_OUTPUTSTREAMS, -1 }, .id_key = "id" },
108
109			[SECTION_ID_OUTPUTSTREAMS] = { SECTION_ID_OUTPUTSTREAMS, "outputstreams", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY | AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_OUTPUTSTREAM, -1 }, .id_key = "id" },
110			[SECTION_ID_OUTPUTSTREAM] = { SECTION_ID_OUTPUTSTREAM, "outputstream", AV_TEXTFORMAT_SECTION_FLAG_IS_SHAPE | AV_TEXTFORMAT_SECTION_PRINT_TAGS, { -1 }, .id_key = "id", },
111
112			[SECTION_ID_STREAMLINKS] = { SECTION_ID_STREAMLINKS, "streamlinks", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAMLINK, -1 } },
113			[SECTION_ID_STREAMLINK] = { SECTION_ID_STREAMLINK, "streamlink", AV_TEXTFORMAT_SECTION_FLAG_HAS_LINKS, { -1 }, .src_id_key = "source_stream_id", .dest_id_key = "dest_stream_id" },
114
115			[SECTION_ID_DECODERS] = { SECTION_ID_DECODERS, "decoders", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY | AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_DECODER, -1 } },
116			[SECTION_ID_DECODER] = { SECTION_ID_DECODER, "decoder", AV_TEXTFORMAT_SECTION_FLAG_IS_SHAPE | AV_TEXTFORMAT_SECTION_PRINT_TAGS | AV_TEXTFORMAT_SECTION_FLAG_HAS_LINKS, { -1 }, .id_key = "id", .src_id_key = "source_id", .dest_id_key = "id" },
117
118			[SECTION_ID_ENCODERS] = { SECTION_ID_ENCODERS, "encoders", AV_TEXTFORMAT_SECTION_FLAG_IS_ARRAY | AV_TEXTFORMAT_SECTION_FLAG_IS_SUBGRAPH, { SECTION_ID_ENCODER, -1 } },
119			[SECTION_ID_ENCODER] = { SECTION_ID_ENCODER, "encoder", AV_TEXTFORMAT_SECTION_FLAG_IS_SHAPE | AV_TEXTFORMAT_SECTION_PRINT_TAGS | AV_TEXTFORMAT_SECTION_FLAG_HAS_LINKS, { -1 }, .id_key = "id", .src_id_key = "id", .dest_id_key = "dest_id" },
120			};
121
122			typedef struct GraphPrintContext {
123			AVTextFormatContext *tfc;
124			AVTextWriterContext *wctx;
125			AVDiagramConfig diagram_config;
126
127			int id_prefix_num;
128			int is_diagram;
129			int opt_flags;
130			int skip_buffer_filters;
131			AVBPrint pbuf;
132
133			} GraphPrintContext;
134
135			/* Text Format API Shortcuts */
136			#define print_id(k, v) print_sanizied_id(gpc, k, v, 0)
137			#define print_id_noprefix(k, v) print_sanizied_id(gpc, k, v, 1)
138			#define print_int(k, v) avtext_print_integer(tfc, k, v, 0)
139			#define print_int_opt(k, v) avtext_print_integer(tfc, k, v, gpc->opt_flags)
140			#define print_q(k, v, s) avtext_print_rational(tfc, k, v, s)
141			#define print_str(k, v) avtext_print_string(tfc, k, v, 0)
142			#define print_str_opt(k, v) avtext_print_string(tfc, k, v, gpc->opt_flags)
143			#define print_val(k, v, u) avtext_print_unit_integer(tfc, k, v, u)
144
145			#define print_fmt(k, f, ...) do { \
146			av_bprint_clear(&gpc->pbuf); \
147			av_bprintf(&gpc->pbuf, f, __VA_ARGS__); \
148			avtext_print_string(tfc, k, gpc->pbuf.str, 0); \
149			} while (0)
150
151			#define print_fmt_opt(k, f, ...) do { \
152			av_bprint_clear(&gpc->pbuf); \
153			av_bprintf(&gpc->pbuf, f, __VA_ARGS__); \
154			avtext_print_string(tfc, k, gpc->pbuf.str, gpc->opt_flags); \
155			} while (0)
156
157
158			static atomic_int prefix_num = 0;
159
160		✗	static inline char *upcase_string(char *dst, size_t dst_size, const char *src)
161			{
162			unsigned i;
163		✗	for (i = 0; src[i] && i < dst_size - 1; i++)
164		✗	dst[i] = (char)av_toupper(src[i]);
165		✗	dst[i] = 0;
166		✗	return dst;
167			}
168
169		✗	static char *get_extension(const char *url)
170			{
171		✗	const char *dot = NULL;
172		✗	const char *sep = NULL;
173			const char *end;
174
175		✗	if (!url)
176		✗	return NULL;
177
178			/* Stop at the first query ('?') or fragment ('#') delimiter so they
179			* are not considered part of the path. */
180		✗	end = strpbrk(url, "?#");
181		✗	if (!end)
182		✗	end = url + strlen(url);
183
184			/* Scan the path component only. */
185		✗	for (const char *p = url; p < end; p++) {
186		✗	if (*p == '.')
187		✗	dot = p;
188		✗	else if (*p == '/' || *p == '\\')
189		✗	sep = p;
190			}
191
192			/* Validate that we have a proper extension. */
193		✗	if (dot && dot != url && (!sep || dot > sep + 1) && (dot + 1) < end) {
194			/* Use FFmpeg helper to duplicate the substring. */
195		✗	return av_strndup(dot + 1, end - (dot + 1));
196			}
197
198		✗	return NULL;
199			}
200
201		✗	static void print_hwdevicecontext(const GraphPrintContext *gpc, const AVHWDeviceContext *hw_device_context)
202			{
203		✗	AVTextFormatContext *tfc = gpc->tfc;
204
205		✗	if (!hw_device_context)
206		✗	return;
207
208		✗	print_int_opt("has_hw_device_context", 1);
209		✗	print_str_opt("hw_device_type", av_hwdevice_get_type_name(hw_device_context->type));
210			}
211
212		✗	static void print_hwframescontext(const GraphPrintContext *gpc, const AVHWFramesContext *hw_frames_context)
213			{
214		✗	AVTextFormatContext *tfc = gpc->tfc;
215			const AVPixFmtDescriptor *pix_desc_hw;
216			const AVPixFmtDescriptor *pix_desc_sw;
217
218		✗	if (!hw_frames_context || !hw_frames_context->device_ctx)
219		✗	return;
220
221		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_HWFRAMESCONTEXT);
222
223		✗	print_int_opt("has_hw_frames_context", 1);
224		✗	print_str("hw_device_type", av_hwdevice_get_type_name(hw_frames_context->device_ctx->type));
225
226		✗	pix_desc_hw = av_pix_fmt_desc_get(hw_frames_context->format);
227		✗	if (pix_desc_hw) {
228		✗	print_str("hw_pixel_format", pix_desc_hw->name);
229		✗	if (pix_desc_hw->alias)
230		✗	print_str_opt("hw_pixel_format_alias", pix_desc_hw->alias);
231			}
232
233		✗	pix_desc_sw = av_pix_fmt_desc_get(hw_frames_context->sw_format);
234		✗	if (pix_desc_sw) {
235		✗	print_str("sw_pixel_format", pix_desc_sw->name);
236		✗	if (pix_desc_sw->alias)
237		✗	print_str_opt("sw_pixel_format_alias", pix_desc_sw->alias);
238			}
239
240		✗	print_int_opt("width", hw_frames_context->width);
241		✗	print_int_opt("height", hw_frames_context->height);
242		✗	print_int_opt("initial_pool_size", hw_frames_context->initial_pool_size);
243
244		✗	avtext_print_section_footer(tfc); // SECTION_ID_HWFRAMESCONTEXT
245			}
246
247		✗	static void print_link(GraphPrintContext *gpc, AVFilterLink *link)
248			{
249		✗	AVTextFormatContext *tfc = gpc->tfc;
250			AVBufferRef *hw_frames_ctx;
251			char layout_string[64];
252
253		✗	if (!link)
254		✗	return;
255
256		✗	hw_frames_ctx = avfilter_link_get_hw_frames_ctx(link);
257
258		✗	print_str_opt("media_type", av_get_media_type_string(link->type));
259
260		✗	switch (link->type) {
261		✗	case AVMEDIA_TYPE_VIDEO:
262
263		✗	if (hw_frames_ctx && hw_frames_ctx->data) {
264		✗	AVHWFramesContext * hwfctx = (AVHWFramesContext *)hw_frames_ctx->data;
265		✗	const AVPixFmtDescriptor *pix_desc_hw = av_pix_fmt_desc_get(hwfctx->format);
266		✗	const AVPixFmtDescriptor *pix_desc_sw = av_pix_fmt_desc_get(hwfctx->sw_format);
267		✗	if (pix_desc_hw && pix_desc_sw)
268		✗	print_fmt("format", "%s | %s", pix_desc_hw->name, pix_desc_sw->name);
269			} else {
270		✗	print_str("format", av_x_if_null(av_get_pix_fmt_name(link->format), "?"));
271			}
272
273		✗	if (link->w && link->h) {
274		✗	if (tfc->show_value_unit) {
275		✗	print_fmt("size", "%dx%d", link->w, link->h);
276			} else {
277		✗	print_int("width", link->w);
278		✗	print_int("height", link->h);
279			}
280			}
281
282		✗	print_q("sar", link->sample_aspect_ratio, ':');
283
284		✗	if (link->color_range != AVCOL_RANGE_UNSPECIFIED)
285		✗	print_str_opt("color_range", av_color_range_name(link->color_range));
286
287		✗	if (link->colorspace != AVCOL_SPC_UNSPECIFIED)
288		✗	print_str("color_space", av_color_space_name(link->colorspace));
289		✗	break;
290
291		✗	case AVMEDIA_TYPE_SUBTITLE:
292			////print_str("format", av_x_if_null(av_get_subtitle_fmt_name(link->format), "?"));
293
294		✗	if (link->w && link->h) {
295		✗	if (tfc->show_value_unit) {
296		✗	print_fmt("size", "%dx%d", link->w, link->h);
297			} else {
298		✗	print_int("width", link->w);
299		✗	print_int("height", link->h);
300			}
301			}
302
303		✗	break;
304
305		✗	case AVMEDIA_TYPE_AUDIO:
306		✗	av_channel_layout_describe(&link->ch_layout, layout_string, sizeof(layout_string));
307		✗	print_str("channel_layout", layout_string);
308		✗	print_val("channels", link->ch_layout.nb_channels, "ch");
309		✗	if (tfc->show_value_unit)
310		✗	print_fmt("sample_rate", "%d.1 kHz", link->sample_rate / 1000);
311			else
312		✗	print_val("sample_rate", link->sample_rate, "Hz");
313
314		✗	break;
315			}
316
317		✗	print_fmt_opt("sample_rate", "%d/%d", link->time_base.num, link->time_base.den);
318
319		✗	if (hw_frames_ctx && hw_frames_ctx->data)
320		✗	print_hwframescontext(gpc, (AVHWFramesContext *)hw_frames_ctx->data);
321		✗	av_buffer_unref(&hw_frames_ctx);
322			}
323
324		✗	static char sanitize_char(const char c)
325			{
326		✗	if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
327		✗	return c;
328		✗	return '_';
329			}
330
331		✗	static void print_sanizied_id(const GraphPrintContext *gpc, const char *key, const char *id_str, int skip_prefix)
332			{
333		✗	AVTextFormatContext *tfc = gpc->tfc;
334			AVBPrint buf;
335
336		✗	if (!key || !id_str)
337		✗	return;
338
339		✗	av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
340
341		✗	if (!skip_prefix)
342		✗	av_bprintf(&buf, "G%d_", gpc->id_prefix_num);
343
344			// sanizize section id
345		✗	for (const char *p = id_str; *p; p++)
346		✗	av_bprint_chars(&buf, sanitize_char(*p), 1);
347
348		✗	print_str(key, buf.str);
349
350		✗	av_bprint_finalize(&buf, NULL);
351			}
352
353		✗	static void print_section_header_id(const GraphPrintContext *gpc, int section_id, const char *id_str, int skip_prefix)
354			{
355		✗	AVTextFormatContext *tfc = gpc->tfc;
356		✗	AVTextFormatSectionContext sec_ctx = { 0 };
357			AVBPrint buf;
358
359		✗	if (!id_str)
360		✗	return;
361
362		✗	av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
363
364		✗	if (!skip_prefix)
365		✗	av_bprintf(&buf, "G%d_", gpc->id_prefix_num);
366
367			// sanizize section id
368		✗	for (const char *p = id_str; *p; p++)
369		✗	av_bprint_chars(&buf, sanitize_char(*p), 1);
370
371		✗	sec_ctx.context_id = buf.str;
372
373		✗	avtext_print_section_header(tfc, &sec_ctx, section_id);
374
375		✗	av_bprint_finalize(&buf, NULL);
376			}
377
378		✗	static const char *get_filterpad_name(const AVFilterPad *pad)
379			{
380		✗	return pad ? avfilter_pad_get_name(pad, 0) : "pad";
381			}
382
383		✗	static void print_filter(GraphPrintContext *gpc, const AVFilterContext *filter, AVDictionary *input_map, AVDictionary *output_map)
384			{
385		✗	AVTextFormatContext *tfc = gpc->tfc;
386		✗	AVTextFormatSectionContext sec_ctx = { 0 };
387
388		✗	print_section_header_id(gpc, SECTION_ID_FILTER, filter->name, 0);
389
390			////print_id("filter_id", filter->name);
391
392		✗	if (filter->filter) {
393		✗	print_str("filter_name", filter->filter->name);
394		✗	print_str_opt("description", filter->filter->description);
395		✗	print_int_opt("nb_inputs", filter->nb_inputs);
396		✗	print_int_opt("nb_outputs", filter->nb_outputs);
397			}
398
399		✗	if (filter->hw_device_ctx) {
400		✗	AVHWDeviceContext *device_context = (AVHWDeviceContext *)filter->hw_device_ctx->data;
401		✗	print_hwdevicecontext(gpc, device_context);
402		✗	if (filter->extra_hw_frames > 0)
403		✗	print_int("extra_hw_frames", filter->extra_hw_frames);
404			}
405
406		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTER_INPUTS);
407
408		✗	for (unsigned i = 0; i < filter->nb_inputs; i++) {
409			AVDictionaryEntry *dic_entry;
410		✗	AVFilterLink *link = filter->inputs[i];
411
412		✗	sec_ctx.context_type = av_get_media_type_string(link->type);
413		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_FILTER_INPUT);
414		✗	sec_ctx.context_type = NULL;
415
416		✗	print_int_opt("input_index", i);
417		✗	print_str_opt("pad_name", get_filterpad_name(link->dstpad));;
418
419		✗	dic_entry = av_dict_get(input_map, link->src->name, NULL, 0);
420		✗	if (dic_entry) {
421			char buf[256];
422		✗	(void)snprintf(buf, sizeof(buf), "in_%s", dic_entry->value);
423		✗	print_id_noprefix("source_filter_id", buf);
424			} else {
425		✗	print_id("source_filter_id", link->src->name);
426			}
427
428		✗	print_str_opt("source_pad_name", get_filterpad_name(link->srcpad));
429		✗	print_id("filter_id", filter->name);
430
431		✗	print_link(gpc, link);
432
433		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTER_INPUT
434			}
435
436		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTER_INPUTS
437
438		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTER_OUTPUTS);
439
440		✗	for (unsigned i = 0; i < filter->nb_outputs; i++) {
441			AVDictionaryEntry *dic_entry;
442		✗	AVFilterLink *link = filter->outputs[i];
443			char buf[256];
444
445		✗	sec_ctx.context_type = av_get_media_type_string(link->type);
446		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_FILTER_OUTPUT);
447		✗	sec_ctx.context_type = NULL;
448
449		✗	dic_entry = av_dict_get(output_map, link->dst->name, NULL, 0);
450		✗	if (dic_entry) {
451		✗	(void)snprintf(buf, sizeof(buf), "out_%s", dic_entry->value);
452		✗	print_id_noprefix("dest_filter_id", buf);
453			} else {
454		✗	print_id("dest_filter_id", link->dst->name);
455			}
456
457		✗	print_int_opt("output_index", i);
458		✗	print_str_opt("pad_name", get_filterpad_name(link->srcpad));
459			////print_id("dest_filter_id", link->dst->name);
460		✗	print_str_opt("dest_pad_name", get_filterpad_name(link->dstpad));
461		✗	print_id("filter_id", filter->name);
462
463		✗	print_link(gpc, link);
464
465		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTER_OUTPUT
466			}
467
468		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTER_OUTPUTS
469
470		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTER
471		✗	}
472
473		✗	static void print_filtergraph_single(GraphPrintContext *gpc, FilterGraph *fg, AVFilterGraph *graph)
474			{
475		✗	AVTextFormatContext *tfc = gpc->tfc;
476		✗	AVDictionary *input_map = NULL;
477		✗	AVDictionary *output_map = NULL;
478
479		✗	print_int("graph_index", fg->index);
480		✗	print_fmt("name", "Graph %d.%d", gpc->id_prefix_num, fg->index);
481		✗	print_fmt("id", "Graph_%d_%d", gpc->id_prefix_num, fg->index);
482		✗	print_str("description", fg->graph_desc);
483
484		✗	print_section_header_id(gpc, SECTION_ID_GRAPH_INPUTS, "Input_File", 0);
485
486		✗	for (int i = 0; i < fg->nb_inputs; i++) {
487		✗	InputFilter *ifilter = fg->inputs[i];
488		✗	enum AVMediaType media_type = ifilter->type;
489
490		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_GRAPH_INPUT);
491
492		✗	print_int("input_index", ifilter->index);
493
494		✗	if (ifilter->linklabel)
495		✗	print_str("link_label", (const char*)ifilter->linklabel);
496
497		✗	if (ifilter->filter) {
498		✗	print_id("filter_id", ifilter->filter->name);
499		✗	print_str("filter_name", ifilter->filter->filter->name);
500			}
501
502		✗	if (ifilter->linklabel && ifilter->filter)
503		✗	av_dict_set(&input_map, ifilter->filter->name, (const char *)ifilter->linklabel, 0);
504		✗	else if (ifilter->input_name && ifilter->filter)
505		✗	av_dict_set(&input_map, ifilter->filter->name, (const char *)ifilter->input_name, 0);
506
507		✗	print_str("media_type", av_get_media_type_string(media_type));
508
509		✗	avtext_print_section_footer(tfc); // SECTION_ID_GRAPH_INPUT
510			}
511
512		✗	avtext_print_section_footer(tfc); // SECTION_ID_GRAPH_INPUTS
513
514		✗	print_section_header_id(gpc, SECTION_ID_GRAPH_OUTPUTS, "Output_File", 0);
515
516		✗	for (int i = 0; i < fg->nb_outputs; i++) {
517		✗	OutputFilter *ofilter = fg->outputs[i];
518
519		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_GRAPH_OUTPUT);
520
521		✗	print_int("output_index", ofilter->index);
522
523		✗	print_str("name", ofilter->output_name);
524
525		✗	if (fg->outputs[i]->linklabel)
526		✗	print_str("link_label", (const char*)fg->outputs[i]->linklabel);
527
528		✗	if (ofilter->filter) {
529		✗	print_id("filter_id", ofilter->filter->name);
530		✗	print_str("filter_name", ofilter->filter->filter->name);
531			}
532
533		✗	if (ofilter->output_name && ofilter->filter)
534		✗	av_dict_set(&output_map, ofilter->filter->name, ofilter->output_name, 0);
535
536
537		✗	print_str("media_type", av_get_media_type_string(ofilter->type));
538
539		✗	avtext_print_section_footer(tfc); // SECTION_ID_GRAPH_OUTPUT
540			}
541
542		✗	avtext_print_section_footer(tfc); // SECTION_ID_GRAPH_OUTPUTS
543
544		✗	if (graph) {
545		✗	AVTextFormatSectionContext sec_ctx = { 0 };
546
547		✗	sec_ctx.context_id = av_asprintf("Graph_%d_%d", gpc->id_prefix_num, fg->index);
548
549		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_FILTERS);
550
551		✗	if (gpc->is_diagram) {
552		✗	print_fmt("name", "Graph %d.%d", gpc->id_prefix_num, fg->index);
553		✗	print_str("description", fg->graph_desc);
554		✗	print_str("id", sec_ctx.context_id);
555			}
556
557		✗	av_freep(&sec_ctx.context_id);
558
559		✗	for (unsigned i = 0; i < graph->nb_filters; i++) {
560		✗	AVFilterContext *filter = graph->filters[i];
561
562		✗	if (gpc->skip_buffer_filters) {
563		✗	if (av_dict_get(input_map, filter->name, NULL, 0))
564		✗	continue;
565		✗	if (av_dict_get(output_map, filter->name, NULL, 0))
566		✗	continue;
567			}
568
569		✗	sec_ctx.context_id = filter->name;
570
571		✗	print_filter(gpc, filter, input_map, output_map);
572			}
573
574		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERS
575			}
576
577			// Clean up dictionaries
578		✗	av_dict_free(&input_map);
579		✗	av_dict_free(&output_map);
580		✗	}
581
582		✗	static int print_streams(GraphPrintContext *gpc, InputFile **ifiles, int nb_ifiles, OutputFile **ofiles, int nb_ofiles)
583			{
584		✗	AVTextFormatContext *tfc = gpc->tfc;
585			AVBPrint buf;
586		✗	AVTextFormatSectionContext sec_ctx = { 0 };
587
588		✗	av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
589
590		✗	print_section_header_id(gpc, SECTION_ID_INPUTFILES, "Inputs", 0);
591
592		✗	for (int n = nb_ifiles - 1; n >= 0; n--) {
593		✗	InputFile *ifi = ifiles[n];
594		✗	AVFormatContext *fc = ifi->ctx;
595
596		✗	sec_ctx.context_id = av_asprintf("Input_%d", n);
597		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_INPUTFILE);
598		✗	av_freep(&sec_ctx.context_id);
599
600		✗	print_fmt("index", "%d", ifi->index);
601
602		✗	if (fc) {
603		✗	print_str("demuxer_name", fc->iformat->name);
604		✗	if (fc->url) {
605		✗	char *extension = get_extension(fc->url);
606		✗	if (extension) {
607		✗	print_str("file_extension", extension);
608		✗	av_freep(&extension);
609			}
610		✗	print_str("url", fc->url);
611			}
612			}
613
614		✗	sec_ctx.context_id = av_asprintf("InputStreams_%d", n);
615
616		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_INPUTSTREAMS);
617
618		✗	av_freep(&sec_ctx.context_id);
619
620		✗	for (int i = 0; i < ifi->nb_streams; i++) {
621		✗	InputStream *ist = ifi->streams[i];
622			const AVCodecDescriptor *codec_desc;
623
624		✗	if (!ist || !ist->par)
625		✗	continue;
626
627		✗	codec_desc = avcodec_descriptor_get(ist->par->codec_id);
628
629		✗	sec_ctx.context_id = av_asprintf("r_in_%d_%d", n, i);
630
631		✗	sec_ctx.context_type = av_get_media_type_string(ist->par->codec_type);
632
633		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_INPUTSTREAM);
634		✗	av_freep(&sec_ctx.context_id);
635		✗	sec_ctx.context_type = NULL;
636
637		✗	av_bprint_clear(&buf);
638
639		✗	print_fmt("id", "r_in_%d_%d", n, i);
640
641		✗	if (codec_desc && codec_desc->name) {
642			////av_bprintf(&buf, "%s", upcase_string(char_buf, sizeof(char_buf), codec_desc->long_name));
643		✗	av_bprintf(&buf, "%s", codec_desc->long_name);
644		✗	} else if (ist->dec) {
645			char char_buf[256];
646		✗	av_bprintf(&buf, "%s", upcase_string(char_buf, sizeof(char_buf), ist->dec->name));
647		✗	} else if (ist->par->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
648		✗	av_bprintf(&buf, "%s", "Attachment");
649		✗	} else if (ist->par->codec_type == AVMEDIA_TYPE_DATA) {
650		✗	av_bprintf(&buf, "%s", "Data");
651			}
652
653		✗	print_fmt("name", "%s", buf.str);
654		✗	print_fmt("index", "%d", ist->index);
655
656		✗	if (ist->dec)
657		✗	print_str_opt("media_type", av_get_media_type_string(ist->par->codec_type));
658
659		✗	avtext_print_section_footer(tfc); // SECTION_ID_INPUTSTREAM
660			}
661
662		✗	avtext_print_section_footer(tfc); // SECTION_ID_INPUTSTREAMS
663		✗	avtext_print_section_footer(tfc); // SECTION_ID_INPUTFILE
664			}
665
666		✗	avtext_print_section_footer(tfc); // SECTION_ID_INPUTFILES
667
668
669		✗	print_section_header_id(gpc, SECTION_ID_DECODERS, "Decoders", 0);
670
671		✗	for (int n = 0; n < nb_ifiles; n++) {
672		✗	InputFile *ifi = ifiles[n];
673
674		✗	for (int i = 0; i < ifi->nb_streams; i++) {
675		✗	InputStream *ist = ifi->streams[i];
676
677		✗	if (!ist->decoder)
678		✗	continue;
679
680		✗	sec_ctx.context_id = av_asprintf("in_%d_%d", n, i);
681		✗	sec_ctx.context_type = av_get_media_type_string(ist->par->codec_type);
682		✗	sec_ctx.context_flags = 2;
683
684		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_DECODER);
685		✗	av_freep(&sec_ctx.context_id);
686		✗	sec_ctx.context_type = NULL;
687		✗	sec_ctx.context_flags = 0;
688
689		✗	av_bprint_clear(&buf);
690
691		✗	print_fmt("source_id", "r_in_%d_%d", n, i);
692		✗	print_fmt("id", "in_%d_%d", n, i);
693
694			////av_bprintf(&buf, "%s", upcase_string(char_buf, sizeof(char_buf), ist->dec->name));
695		✗	print_fmt("name", "%s", ist->dec->name);
696
697		✗	print_str_opt("media_type", av_get_media_type_string(ist->par->codec_type));
698
699		✗	avtext_print_section_footer(tfc); // SECTION_ID_DECODER
700			}
701			}
702
703		✗	avtext_print_section_footer(tfc); // SECTION_ID_DECODERS
704
705
706		✗	print_section_header_id(gpc, SECTION_ID_ENCODERS, "Encoders", 0);
707
708		✗	for (int n = 0; n < nb_ofiles; n++) {
709		✗	OutputFile *of = ofiles[n];
710
711		✗	for (int i = 0; i < of->nb_streams; i++) {
712		✗	OutputStream *ost = of->streams[i];
713			////const AVCodecDescriptor *codec_desc;
714
715		✗	if (!ost || !ost->st || !ost->st->codecpar || !ost->enc)
716		✗	continue;
717
718			////codec_desc = avcodec_descriptor_get(ost->st->codecpar->codec_id);
719
720		✗	sec_ctx.context_id = av_asprintf("out__%d_%d", n, i);
721		✗	sec_ctx.context_type = av_get_media_type_string(ost->type);
722		✗	sec_ctx.context_flags = 2;
723
724		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_ENCODER);
725		✗	av_freep(&sec_ctx.context_id);
726		✗	sec_ctx.context_type = NULL;
727		✗	sec_ctx.context_flags = 0;
728
729		✗	av_bprint_clear(&buf);
730
731		✗	print_fmt("id", "out__%d_%d", n, i);
732		✗	print_fmt("dest_id", "r_out__%d_%d", n, i);
733
734		✗	print_fmt("name", "%s", ost->enc->enc_ctx->av_class->item_name(ost->enc->enc_ctx));
735
736		✗	print_str_opt("media_type", av_get_media_type_string(ost->type));
737
738		✗	avtext_print_section_footer(tfc); // SECTION_ID_ENCODER
739			}
740			}
741
742		✗	avtext_print_section_footer(tfc); // SECTION_ID_ENCODERS
743
744
745		✗	print_section_header_id(gpc, SECTION_ID_OUTPUTFILES, "Outputs", 0);
746
747		✗	for (int n = nb_ofiles - 1; n >= 0; n--) {
748		✗	OutputFile *of = ofiles[n];
749		✗	Muxer *muxer = (Muxer *)of;
750
751		✗	if (!muxer->fc)
752		✗	continue;
753
754		✗	sec_ctx.context_id = av_asprintf("Output_%d", n);
755
756		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_OUTPUTFILE);
757
758		✗	av_freep(&sec_ctx.context_id);
759
760			////print_str_opt("index", av_get_media_type_string(of->index));
761		✗	print_fmt("index", "%d", of->index);
762			////print_str("url", of->url);
763		✗	print_str("muxer_name", muxer->fc->oformat->name);
764		✗	if (of->url) {
765		✗	char *extension = get_extension(of->url);
766		✗	if (extension) {
767		✗	print_str("file_extension", extension);
768		✗	av_freep(&extension);
769			}
770		✗	print_str("url", of->url);
771			}
772
773		✗	sec_ctx.context_id = av_asprintf("OutputStreams_%d", n);
774
775		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_OUTPUTSTREAMS);
776
777		✗	av_freep(&sec_ctx.context_id);
778
779		✗	for (int i = 0; i < of->nb_streams; i++) {
780		✗	OutputStream *ost = of->streams[i];
781		✗	const AVCodecDescriptor *codec_desc = avcodec_descriptor_get(ost->st->codecpar->codec_id);
782
783		✗	sec_ctx.context_id = av_asprintf("r_out__%d_%d", n, i);
784		✗	sec_ctx.context_type = av_get_media_type_string(ost->type);
785		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_OUTPUTSTREAM);
786		✗	av_freep(&sec_ctx.context_id);
787		✗	sec_ctx.context_type = NULL;
788
789		✗	av_bprint_clear(&buf);
790
791		✗	print_fmt("id", "r_out__%d_%d", n, i);
792
793		✗	if (codec_desc && codec_desc->name) {
794		✗	av_bprintf(&buf, "%s", codec_desc->long_name);
795			} else {
796		✗	av_bprintf(&buf, "%s", "unknown");
797			}
798
799		✗	print_fmt("name", "%s", buf.str);
800		✗	print_fmt("index", "%d", ost->index);
801
802		✗	print_str_opt("media_type", av_get_media_type_string(ost->type));
803
804		✗	avtext_print_section_footer(tfc); // SECTION_ID_OUTPUTSTREAM
805			}
806
807		✗	avtext_print_section_footer(tfc); // SECTION_ID_OUTPUTSTREAMS
808		✗	avtext_print_section_footer(tfc); // SECTION_ID_OUTPUTFILE
809			}
810
811		✗	avtext_print_section_footer(tfc); // SECTION_ID_OUTPUTFILES
812
813
814		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_STREAMLINKS);
815
816		✗	for (int n = 0; n < nb_ofiles; n++) {
817		✗	OutputFile *of = ofiles[n];
818
819		✗	for (int i = 0; i < of->nb_streams; i++) {
820		✗	OutputStream *ost = of->streams[i];
821
822		✗	if (ost->ist && !ost->filter) {
823		✗	sec_ctx.context_type = av_get_media_type_string(ost->type);
824		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_STREAMLINK);
825		✗	sec_ctx.context_type = NULL;
826
827		✗	if (ost->enc) {
828		✗	print_fmt("dest_stream_id", "out__%d_%d", n, i);
829		✗	print_fmt("source_stream_id", "in_%d_%d", ost->ist->file->index, ost->ist->index);
830		✗	print_str("operation", "Transcode");
831			} else {
832		✗	print_fmt("dest_stream_id", "r_out__%d_%d", n, i);
833		✗	print_fmt("source_stream_id", "r_in_%d_%d", ost->ist->file->index, ost->ist->index);
834		✗	print_str("operation", "Stream Copy");
835			}
836
837		✗	print_str_opt("media_type", av_get_media_type_string(ost->type));
838
839		✗	avtext_print_section_footer(tfc); // SECTION_ID_STREAMLINK
840			}
841			}
842			}
843
844		✗	avtext_print_section_footer(tfc); // SECTION_ID_STREAMLINKS
845
846		✗	av_bprint_finalize(&buf, NULL);
847		✗	return 0;
848			}
849
850
851		✗	static void uninit_graphprint(GraphPrintContext *gpc)
852			{
853		✗	if (gpc->tfc)
854		✗	avtext_context_close(&gpc->tfc);
855
856		✗	if (gpc->wctx)
857		✗	avtextwriter_context_close(&gpc->wctx);
858
859			// Finalize the print buffer if it was initialized
860		✗	av_bprint_finalize(&gpc->pbuf, NULL);
861
862		✗	av_freep(&gpc);
863		✗	}
864
865		✗	static int init_graphprint(GraphPrintContext **pgpc, AVBPrint *target_buf)
866			{
867			const AVTextFormatter *text_formatter;
868		✗	AVTextFormatContext *tfc = NULL;
869		✗	AVTextWriterContext *wctx = NULL;
870		✗	GraphPrintContext *gpc = NULL;
871			int ret;
872
873		✗	*pgpc = NULL;
874
875		✗	av_bprint_init(target_buf, 0, AV_BPRINT_SIZE_UNLIMITED);
876
877		✗	const char *w_name = print_graphs_format ? print_graphs_format : "json";
878
879		✗	text_formatter = avtext_get_formatter_by_name(w_name);
880		✗	if (!text_formatter) {
881		✗	av_log(NULL, AV_LOG_ERROR, "Unknown filter graph output format with name '%s'\n", w_name);
882		✗	ret = AVERROR(EINVAL);
883		✗	goto fail;
884			}
885
886		✗	ret = avtextwriter_create_buffer(&wctx, target_buf);
887		✗	if (ret < 0) {
888		✗	av_log(NULL, AV_LOG_ERROR, "avtextwriter_create_buffer failed. Error code %d\n", ret);
889		✗	ret = AVERROR(EINVAL);
890		✗	goto fail;
891			}
892
893		✗	AVTextFormatOptions tf_options = { .show_optional_fields = -1 };
894		✗	const char *w_args = print_graphs_format ? strchr(print_graphs_format, '=') : NULL;
895		✗	if (w_args)
896		✗	++w_args; // consume '='
897		✗	ret = avtext_context_open(&tfc, text_formatter, wctx, w_args, sections, FF_ARRAY_ELEMS(sections), tf_options, NULL);
898		✗	if (ret < 0) {
899		✗	goto fail;
900			}
901
902		✗	gpc = av_mallocz(sizeof(GraphPrintContext));
903		✗	if (!gpc) {
904		✗	ret = AVERROR(ENOMEM);
905		✗	goto fail;
906			}
907
908		✗	gpc->wctx = wctx;
909		✗	gpc->tfc = tfc;
910		✗	av_bprint_init(&gpc->pbuf, 0, AV_BPRINT_SIZE_UNLIMITED);
911
912		✗	gpc->id_prefix_num = atomic_fetch_add(&prefix_num, 1);
913		✗	gpc->is_diagram = !!(tfc->formatter->flags & AV_TEXTFORMAT_FLAG_IS_DIAGRAM_FORMATTER);
914		✗	if (gpc->is_diagram) {
915		✗	tfc->show_value_unit = 1;
916		✗	tfc->show_optional_fields = -1;
917		✗	gpc->opt_flags = AV_TEXTFORMAT_PRINT_STRING_OPTIONAL;
918		✗	gpc->skip_buffer_filters = 1;
919			////} else {
920			//// gpc->opt_flags = AV_TEXTFORMAT_PRINT_STRING_OPTIONAL;
921			}
922
923		✗	if (!strcmp(text_formatter->name, "mermaid") || !strcmp(text_formatter->name, "mermaidhtml")) {
924		✗	gpc->diagram_config.diagram_css = ff_resman_get_string(FF_RESOURCE_GRAPH_CSS);
925
926		✗	if (!strcmp(text_formatter->name, "mermaidhtml"))
927		✗	gpc->diagram_config.html_template = ff_resman_get_string(FF_RESOURCE_GRAPH_HTML);
928
929		✗	av_diagram_init(tfc, &gpc->diagram_config);
930			}
931
932		✗	*pgpc = gpc;
933
934		✗	return 0;
935
936		✗	fail:
937		✗	if (tfc)
938		✗	avtext_context_close(&tfc);
939		✗	if (wctx && !tfc) // Only free wctx if tfc didn't take ownership of it
940		✗	avtextwriter_context_close(&wctx);
941		✗	av_freep(&gpc);
942
943		✗	return ret;
944			}
945
946
947		✗	int print_filtergraph(FilterGraph *fg, AVFilterGraph *graph)
948			{
949			av_assert2(fg);
950
951		✗	GraphPrintContext *gpc = NULL;
952			AVTextFormatContext *tfc;
953		✗	AVBPrint *target_buf = &fg->graph_print_buf;
954			int ret;
955
956		✗	if (target_buf->len)
957		✗	av_bprint_finalize(target_buf, NULL);
958
959		✗	ret = init_graphprint(&gpc, target_buf);
960		✗	if (ret)
961		✗	return ret;
962
963		✗	tfc = gpc->tfc;
964
965			// Due to the threading model each graph needs to print itself into a buffer
966			// from its own thread. The actual printing happens short before cleanup in ffmpeg.c
967			// where all graphs are assembled together. To make this work, we need to put the
968			// formatting context into the same state like it would be when printing all at once,
969			// so here we print the section headers and clear the buffer to get into the right state.
970		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_ROOT);
971		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPHS);
972		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPH);
973
974		✗	av_bprint_clear(target_buf);
975
976		✗	print_filtergraph_single(gpc, fg, graph);
977
978		✗	if (gpc->is_diagram) {
979		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPH
980		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPHS
981			}
982
983		✗	uninit_graphprint(gpc);
984
985		✗	return 0;
986			}
987
988		✗	static int print_filtergraphs_priv(FilterGraph **graphs, int nb_graphs, InputFile **ifiles, int nb_ifiles, OutputFile **ofiles, int nb_ofiles)
989			{
990		✗	GraphPrintContext *gpc = NULL;
991			AVTextFormatContext *tfc;
992			AVBPrint target_buf;
993			int ret;
994
995		✗	ret = init_graphprint(&gpc, &target_buf);
996		✗	if (ret)
997		✗	goto cleanup;
998
999		✗	tfc = gpc->tfc;
1000
1001		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_ROOT);
1002		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPHS);
1003
1004		✗	for (int i = 0; i < nb_graphs; i++) {
1005		✗	AVBPrint *graph_buf = &graphs[i]->graph_print_buf;
1006
1007		✗	if (graph_buf->len > 0) {
1008		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPH);
1009		✗	av_bprint_append_data(&target_buf, graph_buf->str, graph_buf->len);
1010		✗	av_bprint_finalize(graph_buf, NULL);
1011		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPH
1012			}
1013			}
1014
1015		✗	for (int n = 0; n < nb_ofiles; n++) {
1016		✗	OutputFile *of = ofiles[n];
1017
1018		✗	for (int i = 0; i < of->nb_streams; i++) {
1019		✗	OutputStream *ost = of->streams[i];
1020
1021		✗	if (ost->fg_simple) {
1022		✗	AVBPrint *graph_buf = &ost->fg_simple->graph_print_buf;
1023
1024		✗	if (graph_buf->len > 0) {
1025		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPH);
1026		✗	av_bprint_append_data(&target_buf, graph_buf->str, graph_buf->len);
1027		✗	av_bprint_finalize(graph_buf, NULL);
1028		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPH
1029			}
1030			}
1031			}
1032			}
1033
1034		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPHS
1035
1036		✗	print_streams(gpc, ifiles, nb_ifiles, ofiles, nb_ofiles);
1037
1038		✗	avtext_print_section_footer(tfc); // SECTION_ID_ROOT
1039
1040		✗	if (print_graphs_file) {
1041		✗	AVIOContext *avio = NULL;
1042
1043		✗	if (!strcmp(print_graphs_file, "-")) {
1044		✗	printf("%s", target_buf.str);
1045			} else {
1046		✗	ret = avio_open2(&avio, print_graphs_file, AVIO_FLAG_WRITE, NULL, NULL);
1047		✗	if (ret < 0) {
1048		✗	av_log(NULL, AV_LOG_ERROR, "Failed to open graph output file, \"%s\": %s\n", print_graphs_file, av_err2str(ret));
1049		✗	goto cleanup;
1050			}
1051
1052		✗	avio_write(avio, (const unsigned char *)target_buf.str, FFMIN(target_buf.len, target_buf.size - 1));
1053
1054		✗	if ((ret = avio_closep(&avio)) < 0)
1055		✗	av_log(NULL, AV_LOG_ERROR, "Error closing graph output file, loss of information possible: %s\n", av_err2str(ret));
1056			}
1057			}
1058
1059		✗	if (print_graphs)
1060		✗	av_log(NULL, AV_LOG_INFO, "%s %c", target_buf.str, '\n');
1061
1062		✗	cleanup:
1063			// Properly clean up resources
1064		✗	if (gpc)
1065		✗	uninit_graphprint(gpc);
1066
1067			// Ensure the target buffer is properly finalized
1068		✗	av_bprint_finalize(&target_buf, NULL);
1069
1070		✗	return ret;
1071			}
1072
1073		✗	int print_filtergraphs(FilterGraph **graphs, int nb_graphs, InputFile **ifiles, int nb_ifiles, OutputFile **ofiles, int nb_ofiles)
1074			{
1075		✗	int ret = print_filtergraphs_priv(graphs, nb_graphs, ifiles, nb_ifiles, ofiles, nb_ofiles);
1076		✗	ff_resman_uninit();
1077		✗	return ret;
1078			}
1079