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 struct 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_int(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 init_sections(void)
474			{
475		✗	for (unsigned i = 0; i < FF_ARRAY_ELEMS(sections); i++)
476		✗	sections[i].show_all_entries = 1;
477		✗	}
478
479		✗	static void print_filtergraph_single(GraphPrintContext *gpc, FilterGraph *fg, AVFilterGraph *graph)
480			{
481		✗	AVTextFormatContext *tfc = gpc->tfc;
482		✗	AVDictionary *input_map = NULL;
483		✗	AVDictionary *output_map = NULL;
484
485		✗	print_int("graph_index", fg->index);
486		✗	print_fmt("name", "Graph %d.%d", gpc->id_prefix_num, fg->index);
487		✗	print_fmt("id", "Graph_%d_%d", gpc->id_prefix_num, fg->index);
488		✗	print_str("description", fg->graph_desc);
489
490		✗	print_section_header_id(gpc, SECTION_ID_GRAPH_INPUTS, "Input_File", 0);
491
492		✗	for (int i = 0; i < fg->nb_inputs; i++) {
493		✗	InputFilter *ifilter = fg->inputs[i];
494		✗	enum AVMediaType media_type = ifilter->type;
495
496		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_GRAPH_INPUT);
497
498		✗	print_int("input_index", ifilter->index);
499
500		✗	if (ifilter->linklabel)
501		✗	print_str("link_label", (const char*)ifilter->linklabel);
502
503		✗	if (ifilter->filter) {
504		✗	print_id("filter_id", ifilter->filter->name);
505		✗	print_str("filter_name", ifilter->filter->filter->name);
506			}
507
508		✗	if (ifilter->linklabel && ifilter->filter)
509		✗	av_dict_set(&input_map, ifilter->filter->name, (const char *)ifilter->linklabel, 0);
510		✗	else if (ifilter->input_name && ifilter->filter)
511		✗	av_dict_set(&input_map, ifilter->filter->name, (const char *)ifilter->input_name, 0);
512
513		✗	print_str("media_type", av_get_media_type_string(media_type));
514
515		✗	avtext_print_section_footer(tfc); // SECTION_ID_GRAPH_INPUT
516			}
517
518		✗	avtext_print_section_footer(tfc); // SECTION_ID_GRAPH_INPUTS
519
520		✗	print_section_header_id(gpc, SECTION_ID_GRAPH_OUTPUTS, "Output_File", 0);
521
522		✗	for (int i = 0; i < fg->nb_outputs; i++) {
523		✗	OutputFilter *ofilter = fg->outputs[i];
524
525		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_GRAPH_OUTPUT);
526
527		✗	print_int("output_index", ofilter->index);
528
529		✗	print_str("name", ofilter->output_name);
530
531		✗	if (fg->outputs[i]->linklabel)
532		✗	print_str("link_label", (const char*)fg->outputs[i]->linklabel);
533
534		✗	if (ofilter->filter) {
535		✗	print_id("filter_id", ofilter->filter->name);
536		✗	print_str("filter_name", ofilter->filter->filter->name);
537			}
538
539		✗	if (ofilter->output_name && ofilter->filter)
540		✗	av_dict_set(&output_map, ofilter->filter->name, ofilter->output_name, 0);
541
542
543		✗	print_str("media_type", av_get_media_type_string(ofilter->type));
544
545		✗	avtext_print_section_footer(tfc); // SECTION_ID_GRAPH_OUTPUT
546			}
547
548		✗	avtext_print_section_footer(tfc); // SECTION_ID_GRAPH_OUTPUTS
549
550		✗	if (graph) {
551		✗	AVTextFormatSectionContext sec_ctx = { 0 };
552
553		✗	sec_ctx.context_id = av_asprintf("Graph_%d_%d", gpc->id_prefix_num, fg->index);
554
555		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_FILTERS);
556
557		✗	if (gpc->is_diagram) {
558		✗	print_fmt("name", "Graph %d.%d", gpc->id_prefix_num, fg->index);
559		✗	print_str("description", fg->graph_desc);
560		✗	print_str("id", sec_ctx.context_id);
561			}
562
563		✗	av_freep(&sec_ctx.context_id);
564
565		✗	for (unsigned i = 0; i < graph->nb_filters; i++) {
566		✗	AVFilterContext *filter = graph->filters[i];
567
568		✗	if (gpc->skip_buffer_filters) {
569		✗	if (av_dict_get(input_map, filter->name, NULL, 0))
570		✗	continue;
571		✗	if (av_dict_get(output_map, filter->name, NULL, 0))
572		✗	continue;
573			}
574
575		✗	sec_ctx.context_id = filter->name;
576
577		✗	print_filter(gpc, filter, input_map, output_map);
578			}
579
580		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERS
581			}
582
583			// Clean up dictionaries
584		✗	av_dict_free(&input_map);
585		✗	av_dict_free(&output_map);
586		✗	}
587
588		✗	static int print_streams(GraphPrintContext *gpc, InputFile **ifiles, int nb_ifiles, OutputFile **ofiles, int nb_ofiles)
589			{
590		✗	AVTextFormatContext *tfc = gpc->tfc;
591			AVBPrint buf;
592		✗	AVTextFormatSectionContext sec_ctx = { 0 };
593
594		✗	av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
595
596		✗	print_section_header_id(gpc, SECTION_ID_INPUTFILES, "Inputs", 0);
597
598		✗	for (int n = nb_ifiles - 1; n >= 0; n--) {
599		✗	InputFile *ifi = ifiles[n];
600		✗	AVFormatContext *fc = ifi->ctx;
601
602		✗	sec_ctx.context_id = av_asprintf("Input_%d", n);
603		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_INPUTFILE);
604		✗	av_freep(&sec_ctx.context_id);
605
606		✗	print_fmt("index", "%d", ifi->index);
607
608		✗	if (fc) {
609		✗	print_str("demuxer_name", fc->iformat->name);
610		✗	if (fc->url) {
611		✗	char *extension = get_extension(fc->url);
612		✗	if (extension) {
613		✗	print_str("file_extension", extension);
614		✗	av_freep(&extension);
615			}
616		✗	print_str("url", fc->url);
617			}
618			}
619
620		✗	sec_ctx.context_id = av_asprintf("InputStreams_%d", n);
621
622		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_INPUTSTREAMS);
623
624		✗	av_freep(&sec_ctx.context_id);
625
626		✗	for (int i = 0; i < ifi->nb_streams; i++) {
627		✗	InputStream *ist = ifi->streams[i];
628			const AVCodecDescriptor *codec_desc;
629
630		✗	if (!ist || !ist->par)
631		✗	continue;
632
633		✗	codec_desc = avcodec_descriptor_get(ist->par->codec_id);
634
635		✗	sec_ctx.context_id = av_asprintf("r_in_%d_%d", n, i);
636
637		✗	sec_ctx.context_type = av_get_media_type_string(ist->par->codec_type);
638
639		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_INPUTSTREAM);
640		✗	av_freep(&sec_ctx.context_id);
641		✗	sec_ctx.context_type = NULL;
642
643		✗	av_bprint_clear(&buf);
644
645		✗	print_fmt("id", "r_in_%d_%d", n, i);
646
647		✗	if (codec_desc && codec_desc->name) {
648			////av_bprintf(&buf, "%s", upcase_string(char_buf, sizeof(char_buf), codec_desc->long_name));
649		✗	av_bprintf(&buf, "%s", codec_desc->long_name);
650		✗	} else if (ist->dec) {
651			char char_buf[256];
652		✗	av_bprintf(&buf, "%s", upcase_string(char_buf, sizeof(char_buf), ist->dec->name));
653		✗	} else if (ist->par->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
654		✗	av_bprintf(&buf, "%s", "Attachment");
655		✗	} else if (ist->par->codec_type == AVMEDIA_TYPE_DATA) {
656		✗	av_bprintf(&buf, "%s", "Data");
657			}
658
659		✗	print_fmt("name", "%s", buf.str);
660		✗	print_fmt("index", "%d", ist->index);
661
662		✗	if (ist->dec)
663		✗	print_str_opt("media_type", av_get_media_type_string(ist->par->codec_type));
664
665		✗	avtext_print_section_footer(tfc); // SECTION_ID_INPUTSTREAM
666			}
667
668		✗	avtext_print_section_footer(tfc); // SECTION_ID_INPUTSTREAMS
669		✗	avtext_print_section_footer(tfc); // SECTION_ID_INPUTFILE
670			}
671
672		✗	avtext_print_section_footer(tfc); // SECTION_ID_INPUTFILES
673
674
675		✗	print_section_header_id(gpc, SECTION_ID_DECODERS, "Decoders", 0);
676
677		✗	for (int n = 0; n < nb_ifiles; n++) {
678		✗	InputFile *ifi = ifiles[n];
679
680		✗	for (int i = 0; i < ifi->nb_streams; i++) {
681		✗	InputStream *ist = ifi->streams[i];
682
683		✗	if (!ist->decoder)
684		✗	continue;
685
686		✗	sec_ctx.context_id = av_asprintf("in_%d_%d", n, i);
687		✗	sec_ctx.context_type = av_get_media_type_string(ist->par->codec_type);
688		✗	sec_ctx.context_flags = 2;
689
690		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_DECODER);
691		✗	av_freep(&sec_ctx.context_id);
692		✗	sec_ctx.context_type = NULL;
693		✗	sec_ctx.context_flags = 0;
694
695		✗	av_bprint_clear(&buf);
696
697		✗	print_fmt("source_id", "r_in_%d_%d", n, i);
698		✗	print_fmt("id", "in_%d_%d", n, i);
699
700			////av_bprintf(&buf, "%s", upcase_string(char_buf, sizeof(char_buf), ist->dec->name));
701		✗	print_fmt("name", "%s", ist->dec->name);
702
703		✗	print_str_opt("media_type", av_get_media_type_string(ist->par->codec_type));
704
705		✗	avtext_print_section_footer(tfc); // SECTION_ID_DECODER
706			}
707			}
708
709		✗	avtext_print_section_footer(tfc); // SECTION_ID_DECODERS
710
711
712		✗	print_section_header_id(gpc, SECTION_ID_ENCODERS, "Encoders", 0);
713
714		✗	for (int n = 0; n < nb_ofiles; n++) {
715		✗	OutputFile *of = ofiles[n];
716
717		✗	for (int i = 0; i < of->nb_streams; i++) {
718		✗	OutputStream *ost = of->streams[i];
719			////const AVCodecDescriptor *codec_desc;
720
721		✗	if (!ost || !ost->st || !ost->st->codecpar || !ost->enc)
722		✗	continue;
723
724			////codec_desc = avcodec_descriptor_get(ost->st->codecpar->codec_id);
725
726		✗	sec_ctx.context_id = av_asprintf("out__%d_%d", n, i);
727		✗	sec_ctx.context_type = av_get_media_type_string(ost->type);
728		✗	sec_ctx.context_flags = 2;
729
730		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_ENCODER);
731		✗	av_freep(&sec_ctx.context_id);
732		✗	sec_ctx.context_type = NULL;
733		✗	sec_ctx.context_flags = 0;
734
735		✗	av_bprint_clear(&buf);
736
737		✗	print_fmt("id", "out__%d_%d", n, i);
738		✗	print_fmt("dest_id", "r_out__%d_%d", n, i);
739
740		✗	print_fmt("name", "%s", ost->enc->enc_ctx->av_class->item_name(ost->enc->enc_ctx));
741
742		✗	print_str_opt("media_type", av_get_media_type_string(ost->type));
743
744		✗	avtext_print_section_footer(tfc); // SECTION_ID_ENCODER
745			}
746			}
747
748		✗	avtext_print_section_footer(tfc); // SECTION_ID_ENCODERS
749
750
751		✗	print_section_header_id(gpc, SECTION_ID_OUTPUTFILES, "Outputs", 0);
752
753		✗	for (int n = nb_ofiles - 1; n >= 0; n--) {
754		✗	OutputFile *of = ofiles[n];
755		✗	Muxer *muxer = (Muxer *)of;
756
757		✗	if (!muxer->fc)
758		✗	continue;
759
760		✗	sec_ctx.context_id = av_asprintf("Output_%d", n);
761
762		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_OUTPUTFILE);
763
764		✗	av_freep(&sec_ctx.context_id);
765
766			////print_str_opt("index", av_get_media_type_string(of->index));
767		✗	print_fmt("index", "%d", of->index);
768			////print_str("url", of->url);
769		✗	print_str("muxer_name", muxer->fc->oformat->name);
770		✗	if (of->url) {
771		✗	char *extension = get_extension(of->url);
772		✗	if (extension) {
773		✗	print_str("file_extension", extension);
774		✗	av_freep(&extension);
775			}
776		✗	print_str("url", of->url);
777			}
778
779		✗	sec_ctx.context_id = av_asprintf("OutputStreams_%d", n);
780
781		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_OUTPUTSTREAMS);
782
783		✗	av_freep(&sec_ctx.context_id);
784
785		✗	for (int i = 0; i < of->nb_streams; i++) {
786		✗	OutputStream *ost = of->streams[i];
787		✗	const AVCodecDescriptor *codec_desc = avcodec_descriptor_get(ost->st->codecpar->codec_id);
788
789		✗	sec_ctx.context_id = av_asprintf("r_out__%d_%d", n, i);
790		✗	sec_ctx.context_type = av_get_media_type_string(ost->type);
791		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_OUTPUTSTREAM);
792		✗	av_freep(&sec_ctx.context_id);
793		✗	sec_ctx.context_type = NULL;
794
795		✗	av_bprint_clear(&buf);
796
797		✗	print_fmt("id", "r_out__%d_%d", n, i);
798
799		✗	if (codec_desc && codec_desc->name) {
800		✗	av_bprintf(&buf, "%s", codec_desc->long_name);
801			} else {
802		✗	av_bprintf(&buf, "%s", "unknown");
803			}
804
805		✗	print_fmt("name", "%s", buf.str);
806		✗	print_fmt("index", "%d", ost->index);
807
808		✗	print_str_opt("media_type", av_get_media_type_string(ost->type));
809
810		✗	avtext_print_section_footer(tfc); // SECTION_ID_OUTPUTSTREAM
811			}
812
813		✗	avtext_print_section_footer(tfc); // SECTION_ID_OUTPUTSTREAMS
814		✗	avtext_print_section_footer(tfc); // SECTION_ID_OUTPUTFILE
815			}
816
817		✗	avtext_print_section_footer(tfc); // SECTION_ID_OUTPUTFILES
818
819
820		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_STREAMLINKS);
821
822		✗	for (int n = 0; n < nb_ofiles; n++) {
823		✗	OutputFile *of = ofiles[n];
824
825		✗	for (int i = 0; i < of->nb_streams; i++) {
826		✗	OutputStream *ost = of->streams[i];
827
828		✗	if (ost->ist && !ost->filter) {
829		✗	sec_ctx.context_type = av_get_media_type_string(ost->type);
830		✗	avtext_print_section_header(tfc, &sec_ctx, SECTION_ID_STREAMLINK);
831		✗	sec_ctx.context_type = NULL;
832
833		✗	if (ost->enc) {
834		✗	print_fmt("dest_stream_id", "out__%d_%d", n, i);
835		✗	print_fmt("source_stream_id", "in_%d_%d", ost->ist->file->index, ost->ist->index);
836		✗	print_str("operation", "Transcode");
837			} else {
838		✗	print_fmt("dest_stream_id", "r_out__%d_%d", n, i);
839		✗	print_fmt("source_stream_id", "r_in_%d_%d", ost->ist->file->index, ost->ist->index);
840		✗	print_str("operation", "Stream Copy");
841			}
842
843		✗	print_str_opt("media_type", av_get_media_type_string(ost->type));
844
845		✗	avtext_print_section_footer(tfc); // SECTION_ID_STREAMLINK
846			}
847			}
848			}
849
850		✗	avtext_print_section_footer(tfc); // SECTION_ID_STREAMLINKS
851
852		✗	av_bprint_finalize(&buf, NULL);
853		✗	return 0;
854			}
855
856
857		✗	static void uninit_graphprint(GraphPrintContext *gpc)
858			{
859		✗	if (gpc->tfc)
860		✗	avtext_context_close(&gpc->tfc);
861
862		✗	if (gpc->wctx)
863		✗	avtextwriter_context_close(&gpc->wctx);
864
865			// Finalize the print buffer if it was initialized
866		✗	av_bprint_finalize(&gpc->pbuf, NULL);
867
868		✗	av_freep(&gpc);
869		✗	}
870
871		✗	static int init_graphprint(GraphPrintContext **pgpc, AVBPrint *target_buf)
872			{
873			const AVTextFormatter *text_formatter;
874		✗	AVTextFormatContext *tfc = NULL;
875		✗	AVTextWriterContext *wctx = NULL;
876		✗	GraphPrintContext *gpc = NULL;
877			int ret;
878
879		✗	init_sections();
880		✗	*pgpc = NULL;
881
882		✗	av_bprint_init(target_buf, 0, AV_BPRINT_SIZE_UNLIMITED);
883
884		✗	const char *w_name = print_graphs_format ? print_graphs_format : "json";
885
886		✗	text_formatter = avtext_get_formatter_by_name(w_name);
887		✗	if (!text_formatter) {
888		✗	av_log(NULL, AV_LOG_ERROR, "Unknown filter graph output format with name '%s'\n", w_name);
889		✗	ret = AVERROR(EINVAL);
890		✗	goto fail;
891			}
892
893		✗	ret = avtextwriter_create_buffer(&wctx, target_buf);
894		✗	if (ret < 0) {
895		✗	av_log(NULL, AV_LOG_ERROR, "avtextwriter_create_buffer failed. Error code %d\n", ret);
896		✗	ret = AVERROR(EINVAL);
897		✗	goto fail;
898			}
899
900		✗	AVTextFormatOptions tf_options = { .show_optional_fields = -1 };
901		✗	const char *w_args = print_graphs_format ? strchr(print_graphs_format, '=') : NULL;
902		✗	if (w_args)
903		✗	++w_args; // consume '='
904		✗	ret = avtext_context_open(&tfc, text_formatter, wctx, w_args, sections, FF_ARRAY_ELEMS(sections), tf_options, NULL);
905		✗	if (ret < 0) {
906		✗	goto fail;
907			}
908
909		✗	gpc = av_mallocz(sizeof(GraphPrintContext));
910		✗	if (!gpc) {
911		✗	ret = AVERROR(ENOMEM);
912		✗	goto fail;
913			}
914
915		✗	gpc->wctx = wctx;
916		✗	gpc->tfc = tfc;
917		✗	av_bprint_init(&gpc->pbuf, 0, AV_BPRINT_SIZE_UNLIMITED);
918
919		✗	gpc->id_prefix_num = atomic_fetch_add(&prefix_num, 1);
920		✗	gpc->is_diagram = !!(tfc->formatter->flags & AV_TEXTFORMAT_FLAG_IS_DIAGRAM_FORMATTER);
921		✗	if (gpc->is_diagram) {
922		✗	tfc->show_value_unit = 1;
923		✗	tfc->show_optional_fields = -1;
924		✗	gpc->opt_flags = AV_TEXTFORMAT_PRINT_STRING_OPTIONAL;
925		✗	gpc->skip_buffer_filters = 1;
926			////} else {
927			//// gpc->opt_flags = AV_TEXTFORMAT_PRINT_STRING_OPTIONAL;
928			}
929
930		✗	if (!strcmp(text_formatter->name, "mermaid") || !strcmp(text_formatter->name, "mermaidhtml")) {
931		✗	gpc->diagram_config.diagram_css = ff_resman_get_string(FF_RESOURCE_GRAPH_CSS);
932
933		✗	if (!strcmp(text_formatter->name, "mermaidhtml"))
934		✗	gpc->diagram_config.html_template = ff_resman_get_string(FF_RESOURCE_GRAPH_HTML);
935
936		✗	av_diagram_init(tfc, &gpc->diagram_config);
937			}
938
939		✗	*pgpc = gpc;
940
941		✗	return 0;
942
943		✗	fail:
944		✗	if (tfc)
945		✗	avtext_context_close(&tfc);
946		✗	if (wctx && !tfc) // Only free wctx if tfc didn't take ownership of it
947		✗	avtextwriter_context_close(&wctx);
948		✗	av_freep(&gpc);
949
950		✗	return ret;
951			}
952
953
954		✗	int print_filtergraph(FilterGraph *fg, AVFilterGraph *graph)
955			{
956		✗	GraphPrintContext *gpc = NULL;
957			AVTextFormatContext *tfc;
958		✗	AVBPrint *target_buf = &fg->graph_print_buf;
959			int ret;
960
961		✗	if (!fg) {
962		✗	av_log(NULL, AV_LOG_ERROR, "Invalid filter graph provided\n");
963		✗	return AVERROR(EINVAL);
964			}
965
966		✗	if (target_buf->len)
967		✗	av_bprint_finalize(target_buf, NULL);
968
969		✗	ret = init_graphprint(&gpc, target_buf);
970		✗	if (ret)
971		✗	return ret;
972
973		✗	if (!gpc) {
974		✗	av_log(NULL, AV_LOG_ERROR, "Failed to initialize graph print context\n");
975		✗	return AVERROR(ENOMEM);
976			}
977
978		✗	tfc = gpc->tfc;
979
980			// Due to the threading model each graph needs to print itself into a buffer
981			// from its own thread. The actual printing happens short before cleanup in ffmpeg.c
982			// where all graphs are assembled together. To make this work, we need to put the
983			// formatting context into the same state like it would be when printing all at once,
984			// so here we print the section headers and clear the buffer to get into the right state.
985		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_ROOT);
986		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPHS);
987		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPH);
988
989		✗	av_bprint_clear(target_buf);
990
991		✗	print_filtergraph_single(gpc, fg, graph);
992
993		✗	if (gpc->is_diagram) {
994		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPH
995		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPHS
996			}
997
998		✗	uninit_graphprint(gpc);
999
1000		✗	return 0;
1001			}
1002
1003		✗	static int print_filtergraphs_priv(FilterGraph **graphs, int nb_graphs, InputFile **ifiles, int nb_ifiles, OutputFile **ofiles, int nb_ofiles)
1004			{
1005		✗	GraphPrintContext *gpc = NULL;
1006			AVTextFormatContext *tfc;
1007			AVBPrint target_buf;
1008			int ret;
1009
1010		✗	ret = init_graphprint(&gpc, &target_buf);
1011		✗	if (ret)
1012		✗	goto cleanup;
1013
1014		✗	if (!gpc) {
1015		✗	ret = AVERROR(ENOMEM);
1016		✗	goto cleanup;
1017			}
1018
1019		✗	tfc = gpc->tfc;
1020
1021		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_ROOT);
1022		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPHS);
1023
1024		✗	for (int i = 0; i < nb_graphs; i++) {
1025		✗	AVBPrint *graph_buf = &graphs[i]->graph_print_buf;
1026
1027		✗	if (graph_buf->len > 0) {
1028		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPH);
1029		✗	av_bprint_append_data(&target_buf, graph_buf->str, graph_buf->len);
1030		✗	av_bprint_finalize(graph_buf, NULL);
1031		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPH
1032			}
1033			}
1034
1035		✗	for (int n = 0; n < nb_ofiles; n++) {
1036		✗	OutputFile *of = ofiles[n];
1037
1038		✗	for (int i = 0; i < of->nb_streams; i++) {
1039		✗	OutputStream *ost = of->streams[i];
1040
1041		✗	if (ost->fg_simple) {
1042		✗	AVBPrint *graph_buf = &ost->fg_simple->graph_print_buf;
1043
1044		✗	if (graph_buf->len > 0) {
1045		✗	avtext_print_section_header(tfc, NULL, SECTION_ID_FILTERGRAPH);
1046		✗	av_bprint_append_data(&target_buf, graph_buf->str, graph_buf->len);
1047		✗	av_bprint_finalize(graph_buf, NULL);
1048		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPH
1049			}
1050			}
1051			}
1052			}
1053
1054		✗	avtext_print_section_footer(tfc); // SECTION_ID_FILTERGRAPHS
1055
1056		✗	print_streams(gpc, ifiles, nb_ifiles, ofiles, nb_ofiles);
1057
1058		✗	avtext_print_section_footer(tfc); // SECTION_ID_ROOT
1059
1060		✗	if (print_graphs_file) {
1061		✗	AVIOContext *avio = NULL;
1062
1063		✗	if (!strcmp(print_graphs_file, "-")) {
1064		✗	printf("%s", target_buf.str);
1065			} else {
1066		✗	ret = avio_open2(&avio, print_graphs_file, AVIO_FLAG_WRITE, NULL, NULL);
1067		✗	if (ret < 0) {
1068		✗	av_log(NULL, AV_LOG_ERROR, "Failed to open graph output file, \"%s\": %s\n", print_graphs_file, av_err2str(ret));
1069		✗	goto cleanup;
1070			}
1071
1072		✗	avio_write(avio, (const unsigned char *)target_buf.str, FFMIN(target_buf.len, target_buf.size - 1));
1073
1074		✗	if ((ret = avio_closep(&avio)) < 0)
1075		✗	av_log(NULL, AV_LOG_ERROR, "Error closing graph output file, loss of information possible: %s\n", av_err2str(ret));
1076			}
1077			}
1078
1079		✗	if (print_graphs)
1080		✗	av_log(NULL, AV_LOG_INFO, "%s %c", target_buf.str, '\n');
1081
1082		✗	cleanup:
1083			// Properly clean up resources
1084		✗	if (gpc)
1085		✗	uninit_graphprint(gpc);
1086
1087			// Ensure the target buffer is properly finalized
1088		✗	av_bprint_finalize(&target_buf, NULL);
1089
1090		✗	return ret;
1091			}
1092
1093		✗	int print_filtergraphs(FilterGraph **graphs, int nb_graphs, InputFile **ifiles, int nb_ifiles, OutputFile **ofiles, int nb_ofiles)
1094			{
1095		✗	int ret = print_filtergraphs_priv(graphs, nb_graphs, ifiles, nb_ifiles, ofiles, nb_ofiles);
1096		✗	ff_resman_uninit();
1097		✗	return ret;
1098			}
1099