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