FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2011 Stefano Sabatini
3			* This file is part of FFmpeg.
4			*
5			* FFmpeg is free software; you can redistribute it and/or
6			* modify it under the terms of the GNU Lesser General Public
7			* License as published by the Free Software Foundation; either
8			* version 2.1 of the License, or (at your option) any later version.
9			*
10			* FFmpeg is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13			* Lesser General Public License for more details.
14			*
15			* You should have received a copy of the GNU Lesser General Public
16			* License along with FFmpeg; if not, write to the Free Software
17			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18			*/
19
20			/**
21			* @file
22			* filter for showing textual video frame information
23			*/
24
25			#include <ctype.h>
26			#include <inttypes.h>
27
28			#include "libavutil/bswap.h"
29			#include "libavutil/adler32.h"
30			#include "libavutil/display.h"
31			#include "libavutil/dovi_meta.h"
32			#include "libavutil/imgutils.h"
33			#include "libavutil/internal.h"
34			#include "libavutil/film_grain_params.h"
35			#include "libavutil/gain_map.h"
36			#include "libavutil/hdr_dynamic_metadata.h"
37			#include "libavutil/hdr_dynamic_vivid_metadata.h"
38			#include "libavutil/opt.h"
39			#include "libavutil/pixdesc.h"
40			#include "libavutil/spherical.h"
41			#include "libavutil/stereo3d.h"
42			#include "libavutil/tdrdi.h"
43			#include "libavutil/timestamp.h"
44			#include "libavutil/timecode.h"
45			#include "libavutil/mastering_display_metadata.h"
46			#include "libavutil/video_enc_params.h"
47			#include "libavutil/detection_bbox.h"
48			#include "libavutil/ambient_viewing_environment.h"
49			#include "libavutil/uuid.h"
50
51			#include "avfilter.h"
52			#include "filters.h"
53			#include "video.h"
54
55			typedef struct ShowInfoContext {
56			const AVClass *class;
57			int calculate_checksums;
58			int udu_sei_as_ascii;
59			} ShowInfoContext;
60
61			#define OFFSET(x) offsetof(ShowInfoContext, x)
62			#define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
63
64			static const AVOption showinfo_options[] = {
65			{ "checksum", "calculate checksums", OFFSET(calculate_checksums), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, VF },
66			{ "udu_sei_as_ascii", "try to print user data unregistered SEI as ascii character when possible",
67			OFFSET(udu_sei_as_ascii), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VF },
68			{ NULL }
69			};
70
71			AVFILTER_DEFINE_CLASS(showinfo);
72
73		✗	static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, const AVFrameSideData *sd)
74			{
75		✗	const AVSphericalMapping *spherical = (const AVSphericalMapping *)sd->data;
76			double yaw, pitch, roll;
77
78		✗	av_log(ctx, AV_LOG_INFO, "%s ", av_spherical_projection_name(spherical->projection));
79
80		✗	if (spherical->yaw || spherical->pitch || spherical->roll) {
81		✗	yaw = ((double)spherical->yaw) / (1 << 16);
82		✗	pitch = ((double)spherical->pitch) / (1 << 16);
83		✗	roll = ((double)spherical->roll) / (1 << 16);
84		✗	av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
85			}
86
87		✗	if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
88			size_t l, t, r, b;
89		✗	av_spherical_tile_bounds(spherical, frame->width, frame->height,
90			&l, &t, &r, &b);
91		✗	av_log(ctx, AV_LOG_INFO, "[%zu, %zu, %zu, %zu] ",
92			l, t, r, b);
93		✗	} else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
94		✗	av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
95			}
96		✗	}
97
98		✗	static void dump_stereo3d(AVFilterContext *ctx, const AVFrameSideData *sd)
99			{
100		✗	const AVStereo3D *stereo = (const AVStereo3D *)sd->data;
101
102		✗	av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
103
104		✗	if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
105		✗	av_log(ctx, AV_LOG_INFO, " (inverted)");
106
107		✗	av_log(ctx, AV_LOG_INFO, ", view - %s, primary_eye - %s", av_stereo3d_view_name(stereo->view),
108		✗	av_stereo3d_primary_eye_name(stereo->primary_eye));
109		✗	if (stereo->baseline)
110		✗	av_log(ctx, AV_LOG_INFO, ", baseline: %"PRIu32"", stereo->baseline);
111		✗	if (stereo->horizontal_disparity_adjustment.num && stereo->horizontal_disparity_adjustment.den)
112		✗	av_log(ctx, AV_LOG_INFO, ", horizontal_disparity_adjustment: %0.4f",
113			av_q2d(stereo->horizontal_disparity_adjustment));
114		✗	if (stereo->horizontal_field_of_view.num && stereo->horizontal_field_of_view.den)
115		✗	av_log(ctx, AV_LOG_INFO, ", horizontal_field_of_view: %0.3f", av_q2d(stereo->horizontal_field_of_view));
116		✗	}
117
118		✗	static void dump_s12m_timecode(AVFilterContext *ctx, AVFilterLink *inlink, const AVFrameSideData *sd)
119			{
120		✗	FilterLink *l = ff_filter_link(inlink);
121		✗	const uint32_t *tc = (const uint32_t *)sd->data;
122
123		✗	if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
124		✗	av_log(ctx, AV_LOG_ERROR, "invalid data\n");
125		✗	return;
126			}
127
128		✗	for (int j = 1; j <= tc[0]; j++) {
129			char tcbuf[AV_TIMECODE_STR_SIZE];
130		✗	av_timecode_make_smpte_tc_string2(tcbuf, l->frame_rate, tc[j], 0, 0);
131		✗	av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
132			}
133			}
134
135		✗	static void dump_roi(AVFilterContext *ctx, const AVFrameSideData *sd)
136			{
137			int nb_rois;
138			const AVRegionOfInterest *roi;
139			uint32_t roi_size;
140
141		✗	roi = (const AVRegionOfInterest *)sd->data;
142		✗	roi_size = roi->self_size;
143		✗	if (!roi_size || sd->size % roi_size != 0) {
144		✗	av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
145		✗	return;
146			}
147		✗	nb_rois = sd->size / roi_size;
148
149		✗	for (int i = 0; i < nb_rois; i++) {
150		✗	roi = (const AVRegionOfInterest *)(sd->data + roi_size * i);
151		✗	av_log(ctx, AV_LOG_INFO, "index: %d, region: (%d, %d) -> (%d, %d), qp offset: %d/%d.\n",
152		✗	i, roi->left, roi->top, roi->right, roi->bottom, roi->qoffset.num, roi->qoffset.den);
153			}
154			}
155
156		✗	static void dump_tdrdi(AVFilterContext *ctx, const AVFrameSideData *sd)
157			{
158		✗	const AV3DReferenceDisplaysInfo *tdrdi = (const AV3DReferenceDisplaysInfo *)sd->data;
159
160
161		✗	av_log(ctx, AV_LOG_INFO, "number of reference displays: %u", tdrdi->num_ref_displays);
162		✗	}
163
164		✗	static void dump_detection_bbox(AVFilterContext *ctx, const AVFrameSideData *sd)
165			{
166			int nb_bboxes;
167			const AVDetectionBBoxHeader *header;
168			const AVDetectionBBox *bbox;
169
170		✗	header = (const AVDetectionBBoxHeader *)sd->data;
171		✗	nb_bboxes = header->nb_bboxes;
172		✗	av_log(ctx, AV_LOG_INFO, "source: %s\n", header->source);
173
174		✗	for (int i = 0; i < nb_bboxes; i++) {
175		✗	bbox = av_get_detection_bbox(header, i);
176		✗	av_log(ctx, AV_LOG_INFO, "index: %d,\tregion: (%d, %d) -> (%d, %d), label: %s, confidence: %d/%d.\n",
177		✗	i, bbox->x, bbox->y, bbox->x + bbox->w, bbox->y + bbox->h,
178		✗	bbox->detect_label, bbox->detect_confidence.num, bbox->detect_confidence.den);
179		✗	if (bbox->classify_count > 0) {
180		✗	for (int j = 0; j < bbox->classify_count; j++) {
181		✗	av_log(ctx, AV_LOG_INFO, "\t\tclassify: label: %s, confidence: %d/%d.\n",
182		✗	bbox->classify_labels[j], bbox->classify_confidences[j].num, bbox->classify_confidences[j].den);
183			}
184			}
185			}
186		✗	}
187
188		✗	static void dump_mastering_display(AVFilterContext *ctx, const AVFrameSideData *sd)
189			{
190			const AVMasteringDisplayMetadata *mastering_display;
191
192		✗	if (sd->size < sizeof(*mastering_display)) {
193		✗	av_log(ctx, AV_LOG_ERROR, "invalid data\n");
194		✗	return;
195			}
196
197		✗	mastering_display = (const AVMasteringDisplayMetadata *)sd->data;
198
199		✗	av_log(ctx, AV_LOG_INFO, "has_primaries:%d has_luminance:%d "
200			"r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
201			"min_luminance=%f, max_luminance=%f",
202		✗	mastering_display->has_primaries, mastering_display->has_luminance,
203			av_q2d(mastering_display->display_primaries[0][0]),
204			av_q2d(mastering_display->display_primaries[0][1]),
205			av_q2d(mastering_display->display_primaries[1][0]),
206			av_q2d(mastering_display->display_primaries[1][1]),
207			av_q2d(mastering_display->display_primaries[2][0]),
208			av_q2d(mastering_display->display_primaries[2][1]),
209			av_q2d(mastering_display->white_point[0]), av_q2d(mastering_display->white_point[1]),
210			av_q2d(mastering_display->min_luminance), av_q2d(mastering_display->max_luminance));
211			}
212
213		✗	static void dump_dynamic_hdr_plus(AVFilterContext *ctx, AVFrameSideData *sd)
214			{
215			AVDynamicHDRPlus *hdr_plus;
216
217		✗	if (sd->size < sizeof(*hdr_plus)) {
218		✗	av_log(ctx, AV_LOG_ERROR, "invalid data\n");
219		✗	return;
220			}
221
222		✗	hdr_plus = (AVDynamicHDRPlus *)sd->data;
223		✗	av_log(ctx, AV_LOG_INFO, "application version: %d, ", hdr_plus->application_version);
224		✗	av_log(ctx, AV_LOG_INFO, "num_windows: %d, ", hdr_plus->num_windows);
225		✗	for (int w = 1; w < hdr_plus->num_windows; w++) {
226		✗	AVHDRPlusColorTransformParams *params = &hdr_plus->params[w];
227		✗	av_log(ctx, AV_LOG_INFO, w > 1 ? ", window %d { " : "window %d { ", w);
228		✗	av_log(ctx, AV_LOG_INFO, "window_upper_left_corner: (%5.4f,%5.4f),",
229			av_q2d(params->window_upper_left_corner_x),
230			av_q2d(params->window_upper_left_corner_y));
231		✗	av_log(ctx, AV_LOG_INFO, "window_lower_right_corner: (%5.4f,%5.4f), ",
232			av_q2d(params->window_lower_right_corner_x),
233			av_q2d(params->window_lower_right_corner_y));
234		✗	av_log(ctx, AV_LOG_INFO, "window_upper_left_corner: (%5.4f, %5.4f), ",
235			av_q2d(params->window_upper_left_corner_x),
236			av_q2d(params->window_upper_left_corner_y));
237		✗	av_log(ctx, AV_LOG_INFO, "center_of_ellipse_x: (%d,%d), ",
238		✗	params->center_of_ellipse_x,
239		✗	params->center_of_ellipse_y);
240		✗	av_log(ctx, AV_LOG_INFO, "rotation_angle: %d, ",
241		✗	params->rotation_angle);
242		✗	av_log(ctx, AV_LOG_INFO, "semimajor_axis_internal_ellipse: %d, ",
243		✗	params->semimajor_axis_internal_ellipse);
244		✗	av_log(ctx, AV_LOG_INFO, "semimajor_axis_external_ellipse: %d, ",
245		✗	params->semimajor_axis_external_ellipse);
246		✗	av_log(ctx, AV_LOG_INFO, "semiminor_axis_external_ellipse: %d, ",
247		✗	params->semiminor_axis_external_ellipse);
248		✗	av_log(ctx, AV_LOG_INFO, "overlap_process_option: %d}",
249		✗	params->overlap_process_option);
250			}
251		✗	av_log(ctx, AV_LOG_INFO, "targeted_system_display_maximum_luminance: %9.4f, ",
252			av_q2d(hdr_plus->targeted_system_display_maximum_luminance));
253		✗	if (hdr_plus->targeted_system_display_actual_peak_luminance_flag) {
254		✗	av_log(ctx, AV_LOG_INFO, "targeted_system_display_actual_peak_luminance: {");
255		✗	for (int i = 0; i < hdr_plus->num_rows_targeted_system_display_actual_peak_luminance; i++) {
256		✗	av_log(ctx, AV_LOG_INFO, "(");
257		✗	for (int j = 0; j < hdr_plus->num_cols_targeted_system_display_actual_peak_luminance; j++) {
258		✗	av_log(ctx, AV_LOG_INFO, i ? ",%5.4f" : "%5.4f",
259			av_q2d(hdr_plus->targeted_system_display_actual_peak_luminance[i][j]));
260			}
261		✗	av_log(ctx, AV_LOG_INFO, ")");
262			}
263		✗	av_log(ctx, AV_LOG_INFO, "}, ");
264			}
265
266		✗	for (int w = 0; w < hdr_plus->num_windows; w++) {
267		✗	AVHDRPlusColorTransformParams *params = &hdr_plus->params[w];
268		✗	av_log(ctx, AV_LOG_INFO, "window %d {maxscl: {", w);
269		✗	for (int i = 0; i < 3; i++) {
270		✗	av_log(ctx, AV_LOG_INFO, i ? ",%5.4f" : "%5.4f",av_q2d(params->maxscl[i]));
271			}
272		✗	av_log(ctx, AV_LOG_INFO, "}, average_maxrgb: %5.4f, ",
273			av_q2d(params->average_maxrgb));
274		✗	av_log(ctx, AV_LOG_INFO, "distribution_maxrgb: {");
275		✗	for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {
276		✗	av_log(ctx, AV_LOG_INFO, "(%d,%5.4f)",
277		✗	params->distribution_maxrgb[i].percentage,
278			av_q2d(params->distribution_maxrgb[i].percentile));
279			}
280		✗	av_log(ctx, AV_LOG_INFO, "}, fraction_bright_pixels: %5.4f",
281			av_q2d(params->fraction_bright_pixels));
282		✗	if (params->tone_mapping_flag) {
283		✗	av_log(ctx, AV_LOG_INFO, ", knee_point: (%5.4f,%5.4f), ", av_q2d(params->knee_point_x), av_q2d(params->knee_point_y));
284		✗	av_log(ctx, AV_LOG_INFO, "bezier_curve_anchors: {");
285		✗	for (int i = 0; i < params->num_bezier_curve_anchors; i++) {
286		✗	av_log(ctx, AV_LOG_INFO, i ? ",%5.4f" : "%5.4f",
287			av_q2d(params->bezier_curve_anchors[i]));
288			}
289		✗	av_log(ctx, AV_LOG_INFO, "}");
290			}
291		✗	if (params->color_saturation_mapping_flag) {
292		✗	av_log(ctx, AV_LOG_INFO, ", color_saturation_weight: %5.4f",
293			av_q2d(params->color_saturation_weight));
294			}
295		✗	av_log(ctx, AV_LOG_INFO, "}");
296			}
297
298		✗	if (hdr_plus->mastering_display_actual_peak_luminance_flag) {
299		✗	av_log(ctx, AV_LOG_INFO, ", mastering_display_actual_peak_luminance: {");
300		✗	for (int i = 0; i < hdr_plus->num_rows_mastering_display_actual_peak_luminance; i++) {
301		✗	av_log(ctx, AV_LOG_INFO, "(");
302		✗	for (int j = 0; j < hdr_plus->num_cols_mastering_display_actual_peak_luminance; j++) {
303		✗	av_log(ctx, AV_LOG_INFO, i ? ",%5.4f" : "%5.4f",
304			av_q2d(hdr_plus->mastering_display_actual_peak_luminance[i][j]));
305			}
306		✗	av_log(ctx, AV_LOG_INFO, ")");
307			}
308		✗	av_log(ctx, AV_LOG_INFO, "}");
309			}
310			}
311
312		✗	static void dump_dynamic_hdr_vivid(AVFilterContext *ctx, AVFrameSideData *sd)
313			{
314			AVDynamicHDRVivid *hdr_vivid;
315
316		✗	if (sd->size < sizeof(*hdr_vivid)) {
317		✗	av_log(ctx, AV_LOG_ERROR, "invalid hdr vivid data\n");
318		✗	return;
319			}
320
321		✗	hdr_vivid = (AVDynamicHDRVivid *)sd->data;
322		✗	av_log(ctx, AV_LOG_INFO, "system_start_code: %d, ", hdr_vivid->system_start_code);
323		✗	av_log(ctx, AV_LOG_INFO, "num_windows: %d, ", hdr_vivid->num_windows);
324		✗	for (int w = 0; w < hdr_vivid->num_windows; w++) {
325		✗	const AVHDRVividColorTransformParams *params = &hdr_vivid->params[w];
326
327		✗	av_log(ctx, AV_LOG_INFO, "minimum_maxrgb[%d]: %.4f, ", w, av_q2d(params->minimum_maxrgb));
328		✗	av_log(ctx, AV_LOG_INFO, "average_maxrgb[%d]: %.4f, ", w, av_q2d(params->average_maxrgb));
329		✗	av_log(ctx, AV_LOG_INFO, "variance_maxrgb[%d]:%.4f, ", w, av_q2d(params->variance_maxrgb));
330		✗	av_log(ctx, AV_LOG_INFO, "maximum_maxrgb[%d]: %.4f, ", w, av_q2d(params->maximum_maxrgb));
331			}
332
333		✗	for (int w = 0; w < hdr_vivid->num_windows; w++) {
334		✗	const AVHDRVividColorTransformParams *params = &hdr_vivid->params[w];
335
336		✗	av_log(ctx, AV_LOG_INFO, "tone_mapping_mode_flag[%d]: %d, ", w, params->tone_mapping_mode_flag);
337		✗	av_log(ctx, AV_LOG_INFO, "tone_mapping_param_num[%d]: %d, ", w, params->tone_mapping_param_num);
338		✗	if (params->tone_mapping_mode_flag) {
339		✗	for (int i = 0; i < params->tone_mapping_param_num; i++) {
340		✗	const AVHDRVividColorToneMappingParams *tm_params = &params->tm_params[i];
341
342		✗	av_log(ctx, AV_LOG_INFO, "targeted_system_display_maximum_luminance[%d][%d]: %.4f, ",
343			w, i, av_q2d(tm_params->targeted_system_display_maximum_luminance));
344		✗	av_log(ctx, AV_LOG_INFO, "base_enable_flag[%d][%d]: %d, ",
345		✗	w, i, tm_params->base_enable_flag);
346		✗	if (tm_params->base_enable_flag) {
347		✗	av_log(ctx, AV_LOG_INFO, "base_param_m_p[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_p));
348		✗	av_log(ctx, AV_LOG_INFO, "base_param_m_m[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_m));
349		✗	av_log(ctx, AV_LOG_INFO, "base_param_m_a[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_a));
350		✗	av_log(ctx, AV_LOG_INFO, "base_param_m_b[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_b));
351		✗	av_log(ctx, AV_LOG_INFO, "base_param_m_n[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_n));
352		✗	av_log(ctx, AV_LOG_INFO, "base_param_k1[%d][%d]: %d, ", w, i, tm_params->base_param_k1);
353		✗	av_log(ctx, AV_LOG_INFO, "base_param_k2[%d][%d]: %d, ", w, i, tm_params->base_param_k2);
354		✗	av_log(ctx, AV_LOG_INFO, "base_param_k3[%d][%d]: %d, ", w, i, tm_params->base_param_k3);
355		✗	av_log(ctx, AV_LOG_INFO, "base_param_Delta_enable_mode[%d][%d]: %d, ", w, i,
356		✗	tm_params->base_param_Delta_enable_mode);
357		✗	av_log(ctx, AV_LOG_INFO, "base_param_Delta[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_Delta));
358			}
359		✗	av_log(ctx, AV_LOG_INFO, "3Spline_enable_flag[%d][%d]: %d, ",
360		✗	w, i, tm_params->three_Spline_enable_flag);
361		✗	if (tm_params->three_Spline_enable_flag) {
362		✗	for (int j = 0; j < tm_params->three_Spline_num; j++) {
363		✗	const AVHDRVivid3SplineParams *three_spline = &tm_params->three_spline[j];
364		✗	av_log(ctx, AV_LOG_INFO, "3Spline_TH_mode[%d][%d]: %d, ", w, i, three_spline->th_mode);
365		✗	if (three_spline->th_mode == 0 || three_spline->th_mode == 2)
366		✗	av_log(ctx, AV_LOG_INFO, "3Spline_TH_enable_MB[%d][%d][%d]: %.4f, ",
367			w, i, j, av_q2d(three_spline->th_enable_mb));
368		✗	av_log(ctx, AV_LOG_INFO, "3Spline_TH_enable[%d][%d][%d]: %.4f, ",
369			w, i, j, av_q2d(three_spline->th_enable));
370		✗	av_log(ctx, AV_LOG_INFO, "3Spline_TH_Delta1[%d][%d][%d]: %.4f, ",
371			w, i, j, av_q2d(three_spline->th_delta1));
372		✗	av_log(ctx, AV_LOG_INFO, "3Spline_TH_Delta2[%d][%d][%d]: %.4f, ",
373			w, i, j, av_q2d(three_spline->th_delta2));
374		✗	av_log(ctx, AV_LOG_INFO, "3Spline_enable_Strength[%d][%d][%d]: %.4f, ",
375			w, i, j, av_q2d(three_spline->enable_strength));
376			}
377			}
378			}
379			}
380
381		✗	av_log(ctx, AV_LOG_INFO, "color_saturation_mapping_flag[%d]: %d",
382		✗	w, params->color_saturation_mapping_flag);
383		✗	if (params->color_saturation_mapping_flag) {
384		✗	av_log(ctx, AV_LOG_INFO, ", color_saturation_num[%d]: %d",
385		✗	w, params->color_saturation_num);
386		✗	for (int i = 0; i < params->color_saturation_num; i++) {
387		✗	av_log(ctx, AV_LOG_INFO, ", color_saturation_gain[%d][%d]: %.4f",
388			w, i, av_q2d(params->color_saturation_gain[i]));
389			}
390			}
391			}
392			}
393
394
395		✗	static void dump_content_light_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
396			{
397		✗	const AVContentLightMetadata *metadata = (const AVContentLightMetadata *)sd->data;
398
399		✗	av_log(ctx, AV_LOG_INFO,
400			"MaxCLL=%d, MaxFALL=%d",
401		✗	metadata->MaxCLL, metadata->MaxFALL);
402		✗	}
403
404		✗	static void dump_video_enc_params(AVFilterContext *ctx, const AVFrameSideData *sd)
405			{
406		✗	const AVVideoEncParams *par = (const AVVideoEncParams *)sd->data;
407			int plane, acdc;
408
409		✗	av_log(ctx, AV_LOG_INFO, "type %d; ", par->type);
410		✗	if (par->qp)
411		✗	av_log(ctx, AV_LOG_INFO, "qp=%d; ", par->qp);
412		✗	for (plane = 0; plane < FF_ARRAY_ELEMS(par->delta_qp); plane++)
413		✗	for (acdc = 0; acdc < FF_ARRAY_ELEMS(par->delta_qp[plane]); acdc++) {
414		✗	int delta_qp = par->delta_qp[plane][acdc];
415		✗	if (delta_qp)
416		✗	av_log(ctx, AV_LOG_INFO, "delta_qp[%d][%d]=%d; ",
417			plane, acdc, delta_qp);
418			}
419		✗	if (par->nb_blocks)
420		✗	av_log(ctx, AV_LOG_INFO, "%u blocks; ", par->nb_blocks);
421		✗	}
422
423		✗	static void dump_sei_unregistered_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
424			{
425		✗	const uint8_t *user_data = sd->data;
426		✗	ShowInfoContext *s = ctx->priv;
427
428		✗	if (sd->size < AV_UUID_LEN) {
429		✗	av_log(ctx, AV_LOG_ERROR, "invalid data (%zu < UUID(%d-bytes))\n",
430		✗	sd->size, AV_UUID_LEN);
431		✗	return;
432			}
433
434		✗	av_log(ctx, AV_LOG_INFO, "UUID=" AV_PRI_UUID "\n", AV_UUID_ARG(user_data));
435
436		✗	av_log(ctx, AV_LOG_INFO, "User Data=");
437		✗	for (size_t i = 16; i < sd->size; i++) {
438		✗	const char *format = "%02x";
439
440		✗	if (s->udu_sei_as_ascii)
441		✗	format = isprint(user_data[i]) ? "%c" : "\\x%02x";
442		✗	av_log(ctx, AV_LOG_INFO, format, user_data[i]);
443			}
444		✗	av_log(ctx, AV_LOG_INFO, "\n");
445			}
446
447		✗	static void dump_sei_film_grain_params_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
448			{
449		✗	const AVFilmGrainParams *fgp = (const AVFilmGrainParams *)sd->data;
450		✗	const char *const film_grain_type_names[] = {
451			[AV_FILM_GRAIN_PARAMS_NONE] = "none",
452			[AV_FILM_GRAIN_PARAMS_AV1] = "av1",
453			[AV_FILM_GRAIN_PARAMS_H274] = "h274",
454			};
455
456		✗	const char *color_range_str = av_color_range_name(fgp->color_range);
457		✗	const char *color_primaries_str = av_color_primaries_name(fgp->color_primaries);
458		✗	const char *color_trc_str = av_color_transfer_name(fgp->color_trc);
459		✗	const char *colorspace_str = av_color_space_name(fgp->color_space);
460
461		✗	if (fgp->type >= FF_ARRAY_ELEMS(film_grain_type_names)) {
462		✗	av_log(ctx, AV_LOG_ERROR, "invalid data\n");
463		✗	return;
464			}
465
466		✗	av_log(ctx, AV_LOG_INFO, "type %s; ", film_grain_type_names[fgp->type]);
467		✗	av_log(ctx, AV_LOG_INFO, "seed=%"PRIu64"; ", fgp->seed);
468		✗	av_log(ctx, AV_LOG_INFO, "width=%d; ", fgp->width);
469		✗	av_log(ctx, AV_LOG_INFO, "height=%d; ", fgp->height);
470		✗	av_log(ctx, AV_LOG_INFO, "subsampling_x=%d; ", fgp->subsampling_x);
471		✗	av_log(ctx, AV_LOG_INFO, "subsampling_y=%d; ", fgp->subsampling_y);
472		✗	av_log(ctx, AV_LOG_INFO, "color_range=%s; ", color_range_str ? color_range_str : "unknown");
473		✗	av_log(ctx, AV_LOG_INFO, "color_primaries=%s; ", color_primaries_str ? color_primaries_str : "unknown");
474		✗	av_log(ctx, AV_LOG_INFO, "color_trc=%s; ", color_trc_str ? color_trc_str : "unknown");
475		✗	av_log(ctx, AV_LOG_INFO, "color_space=%s; ", colorspace_str ? colorspace_str : "unknown");
476		✗	av_log(ctx, AV_LOG_INFO, "bit_depth_luma=%d; ", fgp->bit_depth_luma);
477		✗	av_log(ctx, AV_LOG_INFO, "bit_depth_chroma=%d; ", fgp->bit_depth_chroma);
478
479		✗	switch (fgp->type) {
480		✗	case AV_FILM_GRAIN_PARAMS_NONE:
481		✗	break;
482		✗	case AV_FILM_GRAIN_PARAMS_AV1: {
483		✗	const AVFilmGrainAOMParams *aom = &fgp->codec.aom;
484		✗	const int num_ar_coeffs_y = 2 * aom->ar_coeff_lag * (aom->ar_coeff_lag + 1);
485		✗	const int num_ar_coeffs_uv = num_ar_coeffs_y + !!aom->num_y_points;
486		✗	av_log(ctx, AV_LOG_INFO, "y_points={ ");
487		✗	for (int i = 0; i < aom->num_y_points; i++)
488		✗	av_log(ctx, AV_LOG_INFO, "(%d,%d) ", aom->y_points[i][0], aom->y_points[i][1]);
489		✗	av_log(ctx, AV_LOG_INFO, "}; chroma_scaling_from_luma=%d; ", aom->chroma_scaling_from_luma);
490		✗	for (int uv = 0; uv < 2; uv++) {
491		✗	av_log(ctx, AV_LOG_INFO, "uv_points[%d]={ ", uv);
492		✗	for (int i = 0; i < aom->num_uv_points[uv]; i++)
493		✗	av_log(ctx, AV_LOG_INFO, "(%d,%d) ", aom->uv_points[uv][i][0], aom->uv_points[uv][i][1]);
494		✗	av_log(ctx, AV_LOG_INFO, "}; ");
495			}
496		✗	av_log(ctx, AV_LOG_INFO, "scaling_shift=%d; ", aom->scaling_shift);
497		✗	av_log(ctx, AV_LOG_INFO, "ar_coeff_lag=%d; ", aom->ar_coeff_lag);
498		✗	if (num_ar_coeffs_y) {
499		✗	av_log(ctx, AV_LOG_INFO, "ar_coeffs_y={ ");
500		✗	for (int i = 0; i < num_ar_coeffs_y; i++)
501		✗	av_log(ctx, AV_LOG_INFO, "%d ", aom->ar_coeffs_y[i]);
502		✗	av_log(ctx, AV_LOG_INFO, "}; ");
503			}
504		✗	for (int uv = 0; num_ar_coeffs_uv && uv < 2; uv++) {
505		✗	av_log(ctx, AV_LOG_INFO, "ar_coeffs_uv[%d]={ ", uv);
506		✗	for (int i = 0; i < num_ar_coeffs_uv; i++)
507		✗	av_log(ctx, AV_LOG_INFO, "%d ", aom->ar_coeffs_uv[uv][i]);
508		✗	av_log(ctx, AV_LOG_INFO, "}; ");
509			}
510		✗	av_log(ctx, AV_LOG_INFO, "ar_coeff_shift=%d; ", aom->ar_coeff_shift);
511		✗	av_log(ctx, AV_LOG_INFO, "grain_scale_shift=%d; ", aom->grain_scale_shift);
512		✗	for (int uv = 0; uv < 2; uv++) {
513		✗	av_log(ctx, AV_LOG_INFO, "uv_mult[%d] = %d; ", uv, aom->uv_mult[uv]);
514		✗	av_log(ctx, AV_LOG_INFO, "uv_mult_luma[%d] = %d; ", uv, aom->uv_mult_luma[uv]);
515		✗	av_log(ctx, AV_LOG_INFO, "uv_offset[%d] = %d; ", uv, aom->uv_offset[uv]);
516			}
517		✗	av_log(ctx, AV_LOG_INFO, "overlap_flag=%d; ", aom->overlap_flag);
518		✗	av_log(ctx, AV_LOG_INFO, "limit_output_range=%d; ", aom->limit_output_range);
519		✗	break;
520			}
521		✗	case AV_FILM_GRAIN_PARAMS_H274: {
522		✗	const AVFilmGrainH274Params *h274 = &fgp->codec.h274;
523		✗	av_log(ctx, AV_LOG_INFO, "model_id=%d; ", h274->model_id);
524		✗	av_log(ctx, AV_LOG_INFO, "blending_mode_id=%d; ", h274->blending_mode_id);
525		✗	av_log(ctx, AV_LOG_INFO, "log2_scale_factor=%d; ", h274->log2_scale_factor);
526
527		✗	for (int c = 0; c < 3; c++)
528		✗	if (h274->component_model_present[c] && (h274->num_model_values[c] > 6 ||
529		✗	h274->num_intensity_intervals[c] < 1 ||
530		✗	h274->num_intensity_intervals[c] > 256)) {
531		✗	av_log(ctx, AV_LOG_ERROR, "invalid data\n");
532		✗	return;
533			}
534
535		✗	for (int c = 0; c < 3; c++) {
536		✗	if (!h274->component_model_present[c])
537		✗	continue;
538
539		✗	av_log(ctx, AV_LOG_INFO, "num_intensity_intervals[%d]=%u; ", c, h274->num_intensity_intervals[c]);
540		✗	av_log(ctx, AV_LOG_INFO, "num_model_values[%d]=%u; ", c, h274->num_model_values[c]);
541		✗	for (int i = 0; i < h274->num_intensity_intervals[c]; i++) {
542		✗	av_log(ctx, AV_LOG_INFO, "intensity_interval_lower_bound[%d][%d]=%u; ",
543		✗	c, i, h274->intensity_interval_lower_bound[c][i]);
544		✗	av_log(ctx, AV_LOG_INFO, "intensity_interval_upper_bound[%d][%d]=%u; ",
545		✗	c, i, h274->intensity_interval_upper_bound[c][i]);
546		✗	for (int j = 0; j < h274->num_model_values[c]; j++)
547		✗	av_log(ctx, AV_LOG_INFO, "comp_model_value[%d][%d][%d]=%d; ",
548		✗	c, i, j, h274->comp_model_value[c][i][j]);
549			}
550			}
551		✗	break;
552			}
553			}
554			}
555
556		✗	static void dump_dovi_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
557			{
558		✗	const AVDOVIMetadata *dovi = (AVDOVIMetadata *) sd->data;
559		✗	const AVDOVIRpuDataHeader *hdr = av_dovi_get_header(dovi);
560		✗	const AVDOVIDataMapping *mapping = av_dovi_get_mapping(dovi);
561		✗	const AVDOVIColorMetadata *color = av_dovi_get_color(dovi);
562
563		✗	av_log(ctx, AV_LOG_INFO, " rpu_type=%"PRIu8"; ", hdr->rpu_type);
564		✗	av_log(ctx, AV_LOG_INFO, "rpu_format=%"PRIu16"; ", hdr->rpu_format);
565		✗	av_log(ctx, AV_LOG_INFO, "vdr_rpu_profile=%"PRIu8"; ", hdr->vdr_rpu_profile);
566		✗	av_log(ctx, AV_LOG_INFO, "vdr_rpu_level=%"PRIu8"; ", hdr->vdr_rpu_level);
567		✗	av_log(ctx, AV_LOG_INFO, "chroma_resampling_explicit_filter_flag=%"PRIu8"; ", hdr->chroma_resampling_explicit_filter_flag);
568		✗	av_log(ctx, AV_LOG_INFO, "coef_data_type=%"PRIu8"; ", hdr->coef_data_type);
569		✗	av_log(ctx, AV_LOG_INFO, "coef_log2_denom=%"PRIu8"; ", hdr->coef_log2_denom);
570		✗	av_log(ctx, AV_LOG_INFO, "vdr_rpu_normalized_idc=%"PRIu8"; ", hdr->vdr_rpu_normalized_idc);
571		✗	av_log(ctx, AV_LOG_INFO, "bl_video_full_range_flag=%"PRIu8"; ", hdr->bl_video_full_range_flag);
572		✗	av_log(ctx, AV_LOG_INFO, "bl_bit_depth=%"PRIu8"; ", hdr->bl_bit_depth);
573		✗	av_log(ctx, AV_LOG_INFO, "el_bit_depth=%"PRIu8"; ", hdr->el_bit_depth);
574		✗	av_log(ctx, AV_LOG_INFO, "vdr_bit_depth=%"PRIu8"; ", hdr->vdr_bit_depth);
575		✗	av_log(ctx, AV_LOG_INFO, "spatial_resampling_filter_flag=%"PRIu8"; ", hdr->spatial_resampling_filter_flag);
576		✗	av_log(ctx, AV_LOG_INFO, "el_spatial_resampling_filter_flag=%"PRIu8"; ", hdr->el_spatial_resampling_filter_flag);
577		✗	av_log(ctx, AV_LOG_INFO, "disable_residual_flag=%"PRIu8"\n", hdr->disable_residual_flag);
578
579		✗	av_log(ctx, AV_LOG_INFO, " data mapping: ");
580		✗	av_log(ctx, AV_LOG_INFO, "vdr_rpu_id=%"PRIu8"; ", mapping->vdr_rpu_id);
581		✗	av_log(ctx, AV_LOG_INFO, "mapping_color_space=%"PRIu8"; ", mapping->mapping_color_space);
582		✗	av_log(ctx, AV_LOG_INFO, "mapping_chroma_format_idc=%"PRIu8"; ", mapping->mapping_chroma_format_idc);
583		✗	av_log(ctx, AV_LOG_INFO, "nlq_method_idc=%d; ", (int) mapping->nlq_method_idc);
584		✗	av_log(ctx, AV_LOG_INFO, "num_x_partitions=%"PRIu32"; ", mapping->num_x_partitions);
585		✗	av_log(ctx, AV_LOG_INFO, "num_y_partitions=%"PRIu32"\n", mapping->num_y_partitions);
586
587		✗	for (int c = 0; c < 3; c++) {
588		✗	const AVDOVIReshapingCurve *curve = &mapping->curves[c];
589		✗	const AVDOVINLQParams *nlq = &mapping->nlq[c];
590		✗	av_log(ctx, AV_LOG_INFO, " channel %d: ", c);
591		✗	av_log(ctx, AV_LOG_INFO, "pivots={ ");
592		✗	for (int i = 0; i < curve->num_pivots; i++)
593		✗	av_log(ctx, AV_LOG_INFO, "%"PRIu16" ", curve->pivots[i]);
594		✗	av_log(ctx, AV_LOG_INFO, "}; mapping_idc={ ");
595		✗	for (int i = 0; i < curve->num_pivots - 1; i++)
596		✗	av_log(ctx, AV_LOG_INFO, "%d ", (int) curve->mapping_idc[i]);
597		✗	av_log(ctx, AV_LOG_INFO, "}; poly_order={ ");
598		✗	for (int i = 0; i < curve->num_pivots - 1; i++)
599		✗	av_log(ctx, AV_LOG_INFO, "%"PRIu8" ", curve->poly_order[i]);
600		✗	av_log(ctx, AV_LOG_INFO, "}; poly_coef={ ");
601		✗	for (int i = 0; i < curve->num_pivots - 1; i++) {
602		✗	av_log(ctx, AV_LOG_INFO, "{%"PRIi64", %"PRIi64", %"PRIi64"} ",
603		✗	curve->poly_coef[i][0],
604		✗	curve->poly_coef[i][1],
605		✗	curve->poly_coef[i][2]);
606			}
607
608		✗	av_log(ctx, AV_LOG_INFO, "}; mmr_order={ ");
609		✗	for (int i = 0; i < curve->num_pivots - 1; i++)
610		✗	av_log(ctx, AV_LOG_INFO, "%"PRIu8" ", curve->mmr_order[i]);
611		✗	av_log(ctx, AV_LOG_INFO, "}; mmr_constant={ ");
612		✗	for (int i = 0; i < curve->num_pivots - 1; i++)
613		✗	av_log(ctx, AV_LOG_INFO, "%"PRIi64" ", curve->mmr_constant[i]);
614		✗	av_log(ctx, AV_LOG_INFO, "}; mmr_coef={ ");
615		✗	for (int i = 0; i < curve->num_pivots - 1; i++) {
616		✗	av_log(ctx, AV_LOG_INFO, "{");
617		✗	for (int j = 0; j < curve->mmr_order[i]; j++) {
618		✗	for (int k = 0; k < 7; k++)
619		✗	av_log(ctx, AV_LOG_INFO, "%"PRIi64" ", curve->mmr_coef[i][j][k]);
620			}
621		✗	av_log(ctx, AV_LOG_INFO, "} ");
622			}
623
624		✗	av_log(ctx, AV_LOG_INFO, "}; nlq_offset=%"PRIu16"; ", nlq->nlq_offset);
625		✗	av_log(ctx, AV_LOG_INFO, "vdr_in_max=%"PRIu64"; ", nlq->vdr_in_max);
626		✗	switch (mapping->nlq_method_idc) {
627		✗	case AV_DOVI_NLQ_LINEAR_DZ:
628		✗	av_log(ctx, AV_LOG_INFO, "linear_deadzone_slope=%"PRIu64"; ", nlq->linear_deadzone_slope);
629		✗	av_log(ctx, AV_LOG_INFO, "linear_deadzone_threshold=%"PRIu64"\n", nlq->linear_deadzone_threshold);
630		✗	break;
631			}
632			}
633
634		✗	av_log(ctx, AV_LOG_INFO, " color metadata: ");
635		✗	av_log(ctx, AV_LOG_INFO, "dm_metadata_id=%"PRIu8"; ", color->dm_metadata_id);
636		✗	av_log(ctx, AV_LOG_INFO, "scene_refresh_flag=%"PRIu8"; ", color->scene_refresh_flag);
637		✗	av_log(ctx, AV_LOG_INFO, "ycc_to_rgb_matrix={ ");
638		✗	for (int i = 0; i < 9; i++)
639		✗	av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->ycc_to_rgb_matrix[i]));
640		✗	av_log(ctx, AV_LOG_INFO, "}; ycc_to_rgb_offset={ ");
641		✗	for (int i = 0; i < 3; i++)
642		✗	av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->ycc_to_rgb_offset[i]));
643		✗	av_log(ctx, AV_LOG_INFO, "}; rgb_to_lms_matrix={ ");
644		✗	for (int i = 0; i < 9; i++)
645		✗	av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->rgb_to_lms_matrix[i]));
646		✗	av_log(ctx, AV_LOG_INFO, "}; signal_eotf=%"PRIu16"; ", color->signal_eotf);
647		✗	av_log(ctx, AV_LOG_INFO, "signal_eotf_param0=%"PRIu16"; ", color->signal_eotf_param0);
648		✗	av_log(ctx, AV_LOG_INFO, "signal_eotf_param1=%"PRIu16"; ", color->signal_eotf_param1);
649		✗	av_log(ctx, AV_LOG_INFO, "signal_eotf_param2=%"PRIu32"; ", color->signal_eotf_param2);
650		✗	av_log(ctx, AV_LOG_INFO, "signal_bit_depth=%"PRIu8"; ", color->signal_bit_depth);
651		✗	av_log(ctx, AV_LOG_INFO, "signal_color_space=%"PRIu8"; ", color->signal_color_space);
652		✗	av_log(ctx, AV_LOG_INFO, "signal_chroma_format=%"PRIu8"; ", color->signal_chroma_format);
653		✗	av_log(ctx, AV_LOG_INFO, "signal_full_range_flag=%"PRIu8"; ", color->signal_full_range_flag);
654		✗	av_log(ctx, AV_LOG_INFO, "source_min_pq=%"PRIu16"; ", color->source_min_pq);
655		✗	av_log(ctx, AV_LOG_INFO, "source_max_pq=%"PRIu16"; ", color->source_max_pq);
656		✗	av_log(ctx, AV_LOG_INFO, "source_diagonal=%"PRIu16"; ", color->source_diagonal);
657		✗	}
658
659		✗	static void dump_gain_map_params(AVFilterContext *ctx, const AVFrameSideData *sd)
660			{
661		✗	const AVGainMapParams *p = (const AVGainMapParams *) sd->data;
662		✗	av_log(ctx, AV_LOG_INFO, "version=%d, nb_channels=%d, use_base_color_space=%d, "
663			"base_hdr_headroom=%f, alternate_hdr_headroom=%f, channels={ ",
664		✗	p->version, p->nb_channels, p->use_base_color_space,
665			av_q2d(p->base_hdr_headroom), av_q2d(p->alternate_hdr_headroom));
666
667		✗	if (!(p->nb_channels == 1 || p->nb_channels == 3)) {
668		✗	av_log(ctx, AV_LOG_ERROR, "invalid data }");
669		✗	return;
670			}
671
672		✗	for (int c = 0; c < p->nb_channels; c++) {
673		✗	const struct AVGainMapChannel *ch = &p->channels[c];
674		✗	av_log(ctx, AV_LOG_INFO,
675			"{ gain_map_min=%f, gain_map_max=%f, gamma=%f, "
676			"base_offset=%f, alternate_offset=%f } ",
677			av_q2d(ch->gain_map_min), av_q2d(ch->gain_map_max),
678			av_q2d(ch->gamma), av_q2d(ch->base_offset),
679			av_q2d(ch->alternate_offset));
680			}
681
682		✗	av_log(ctx, AV_LOG_INFO, "}");
683			}
684
685		✗	static void dump_ambient_viewing_environment(AVFilterContext *ctx, const AVFrameSideData *sd)
686			{
687		✗	const AVAmbientViewingEnvironment *ambient_viewing_environment =
688			(const AVAmbientViewingEnvironment *)sd->data;
689
690		✗	av_log(ctx, AV_LOG_INFO, "ambient_illuminance=%f, ambient_light_x=%f, ambient_light_y=%f",
691			av_q2d(ambient_viewing_environment->ambient_illuminance),
692			av_q2d(ambient_viewing_environment->ambient_light_x),
693			av_q2d(ambient_viewing_environment->ambient_light_y));
694		✗	}
695
696		✗	static void dump_color_property(AVFilterContext *ctx, AVFrame *frame)
697			{
698		✗	const char *color_range_str = av_color_range_name(frame->color_range);
699		✗	const char *colorspace_str = av_color_space_name(frame->colorspace);
700		✗	const char *color_primaries_str = av_color_primaries_name(frame->color_primaries);
701		✗	const char *color_trc_str = av_color_transfer_name(frame->color_trc);
702
703		✗	if (!color_range_str || frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
704		✗	av_log(ctx, AV_LOG_INFO, "color_range:unknown");
705			} else {
706		✗	av_log(ctx, AV_LOG_INFO, "color_range:%s", color_range_str);
707			}
708
709		✗	if (!colorspace_str || frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
710		✗	av_log(ctx, AV_LOG_INFO, " color_space:unknown");
711			} else {
712		✗	av_log(ctx, AV_LOG_INFO, " color_space:%s", colorspace_str);
713			}
714
715		✗	if (!color_primaries_str || frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
716		✗	av_log(ctx, AV_LOG_INFO, " color_primaries:unknown");
717			} else {
718		✗	av_log(ctx, AV_LOG_INFO, " color_primaries:%s", color_primaries_str);
719			}
720
721		✗	if (!color_trc_str || frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
722		✗	av_log(ctx, AV_LOG_INFO, " color_trc:unknown");
723			} else {
724		✗	av_log(ctx, AV_LOG_INFO, " color_trc:%s", color_trc_str);
725			}
726		✗	av_log(ctx, AV_LOG_INFO, "\n");
727		✗	}
728
729		✗	static void update_sample_stats_8(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
730			{
731			int i;
732
733		✗	for (i = 0; i < len; i++) {
734		✗	*sum += src[i];
735		✗	*sum2 += src[i] * src[i];
736			}
737		✗	}
738
739		✗	static void update_sample_stats_16(int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
740			{
741		✗	const uint16_t *src1 = (const uint16_t *)src;
742			int i;
743
744		✗	for (i = 0; i < len / 2; i++) {
745		✗	if ((HAVE_BIGENDIAN && !be) || (!HAVE_BIGENDIAN && be)) {
746		✗	*sum += av_bswap16(src1[i]);
747		✗	*sum2 += (uint32_t)av_bswap16(src1[i]) * (uint32_t)av_bswap16(src1[i]);
748			} else {
749		✗	*sum += src1[i];
750		✗	*sum2 += (uint32_t)src1[i] * (uint32_t)src1[i];
751			}
752			}
753		✗	}
754
755		✗	static void update_sample_stats(int depth, int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
756			{
757		✗	if (depth <= 8)
758		✗	update_sample_stats_8(src, len, sum, sum2);
759			else
760		✗	update_sample_stats_16(be, src, len, sum, sum2);
761		✗	}
762
763		✗	static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
764			{
765		✗	FilterLink *inl = ff_filter_link(inlink);
766		✗	AVFilterContext *ctx = inlink->dst;
767		✗	ShowInfoContext *s = ctx->priv;
768		✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
769		✗	uint32_t plane_checksum[4] = {0}, checksum = 0;
770		✗	int64_t sum[4] = {0}, sum2[4] = {0};
771		✗	int32_t pixelcount[4] = {0};
772		✗	int bitdepth = desc->comp[0].depth;
773		✗	int be = desc->flags & AV_PIX_FMT_FLAG_BE;
774		✗	int i, plane, vsub = desc->log2_chroma_h;
775
776		✗	for (plane = 0; plane < 4 && s->calculate_checksums && frame->data[plane] && frame->linesize[plane]; plane++) {
777		✗	uint8_t *data = frame->data[plane];
778		✗	int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
779		✗	int linesize = av_image_get_linesize(frame->format, frame->width, plane);
780		✗	int width = linesize >> (bitdepth > 8);
781
782		✗	if (linesize < 0)
783		✗	return linesize;
784
785		✗	for (i = 0; i < h; i++) {
786		✗	plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
787		✗	checksum = av_adler32_update(checksum, data, linesize);
788
789		✗	update_sample_stats(bitdepth, be, data, linesize, sum+plane, sum2+plane);
790		✗	pixelcount[plane] += width;
791		✗	data += frame->linesize[plane];
792			}
793			}
794
795		✗	av_log(ctx, AV_LOG_INFO,
796			"n:%4"PRId64" pts:%7s pts_time:%-7s duration:%7"PRId64
797			" duration_time:%-7s "
798			"fmt:%s cl:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c ",
799			inl->frame_count_out,
800		✗	av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base),
801		✗	frame->duration, av_ts2timestr(frame->duration, &inlink->time_base),
802		✗	desc->name, av_chroma_location_name(frame->chroma_location),
803			frame->sample_aspect_ratio.num, frame->sample_aspect_ratio.den,
804			frame->width, frame->height,
805		✗	!(frame->flags & AV_FRAME_FLAG_INTERLACED) ? 'P' : /* Progressive */
806		✗	(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 'T' : 'B', /* Top / Bottom */
807		✗	!!(frame->flags & AV_FRAME_FLAG_KEY),
808		✗	av_get_picture_type_char(frame->pict_type));
809
810		✗	if (s->calculate_checksums) {
811		✗	av_log(ctx, AV_LOG_INFO,
812			"checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
813			checksum, plane_checksum[0]);
814
815		✗	for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
816		✗	av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
817		✗	av_log(ctx, AV_LOG_INFO, "] mean:[");
818		✗	for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
819		✗	av_log(ctx, AV_LOG_INFO, "%s%"PRId64,
820			plane ? " ":"",
821		✗	(sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
822		✗	av_log(ctx, AV_LOG_INFO, "] stdev:[");
823		✗	for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
824		✗	av_log(ctx, AV_LOG_INFO, "%s%3.1f",
825			plane ? " ":"",
826		✗	sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
827		✗	av_log(ctx, AV_LOG_INFO, "]");
828			}
829		✗	av_log(ctx, AV_LOG_INFO, "\n");
830
831		✗	for (i = 0; i < frame->nb_side_data; i++) {
832		✗	AVFrameSideData *sd = frame->side_data[i];
833		✗	const char *name = av_frame_side_data_name(sd->type);
834
835		✗	av_log(ctx, AV_LOG_INFO, " side data - ");
836		✗	if (name)
837		✗	av_log(ctx, AV_LOG_INFO, "%s: ", name);
838		✗	switch (sd->type) {
839		✗	case AV_FRAME_DATA_SPHERICAL:
840		✗	dump_spherical(ctx, frame, sd);
841		✗	break;
842		✗	case AV_FRAME_DATA_STEREO3D:
843		✗	dump_stereo3d(ctx, sd);
844		✗	break;
845		✗	case AV_FRAME_DATA_S12M_TIMECODE: {
846		✗	dump_s12m_timecode(ctx, inlink, sd);
847		✗	break;
848			}
849		✗	case AV_FRAME_DATA_DISPLAYMATRIX:
850		✗	av_log(ctx, AV_LOG_INFO, "rotation of %.2f degrees",
851		✗	av_display_rotation_get((int32_t *)sd->data));
852		✗	break;
853		✗	case AV_FRAME_DATA_AFD:
854		✗	av_log(ctx, AV_LOG_INFO, "value of %"PRIu8, sd->data[0]);
855		✗	break;
856		✗	case AV_FRAME_DATA_REGIONS_OF_INTEREST:
857		✗	dump_roi(ctx, sd);
858		✗	break;
859		✗	case AV_FRAME_DATA_DETECTION_BBOXES:
860		✗	dump_detection_bbox(ctx, sd);
861		✗	break;
862		✗	case AV_FRAME_DATA_MASTERING_DISPLAY_METADATA:
863		✗	dump_mastering_display(ctx, sd);
864		✗	break;
865		✗	case AV_FRAME_DATA_DYNAMIC_HDR_PLUS:
866		✗	dump_dynamic_hdr_plus(ctx, sd);
867		✗	break;
868		✗	case AV_FRAME_DATA_DYNAMIC_HDR_VIVID:
869		✗	dump_dynamic_hdr_vivid(ctx, sd);
870		✗	break;
871		✗	case AV_FRAME_DATA_CONTENT_LIGHT_LEVEL:
872		✗	dump_content_light_metadata(ctx, sd);
873		✗	break;
874		✗	case AV_FRAME_DATA_GOP_TIMECODE: {
875			char tcbuf[AV_TIMECODE_STR_SIZE];
876		✗	av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
877		✗	av_log(ctx, AV_LOG_INFO, "%s", tcbuf);
878		✗	break;
879			}
880		✗	case AV_FRAME_DATA_VIDEO_ENC_PARAMS:
881		✗	dump_video_enc_params(ctx, sd);
882		✗	break;
883		✗	case AV_FRAME_DATA_SEI_UNREGISTERED:
884		✗	dump_sei_unregistered_metadata(ctx, sd);
885		✗	break;
886		✗	case AV_FRAME_DATA_FILM_GRAIN_PARAMS:
887		✗	dump_sei_film_grain_params_metadata(ctx, sd);
888		✗	break;
889		✗	case AV_FRAME_DATA_DOVI_METADATA:
890		✗	dump_dovi_metadata(ctx, sd);
891		✗	break;
892		✗	case AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT:
893		✗	dump_ambient_viewing_environment(ctx, sd);
894		✗	break;
895		✗	case AV_FRAME_DATA_GAIN_MAP_PARAMS:
896		✗	dump_gain_map_params(ctx, sd);
897		✗	break;
898		✗	case AV_FRAME_DATA_VIEW_ID:
899		✗	av_log(ctx, AV_LOG_INFO, "view id: %d\n", *(int*)sd->data);
900		✗	break;
901		✗	case AV_FRAME_DATA_3D_REFERENCE_DISPLAYS:
902		✗	dump_tdrdi(ctx, sd);
903		✗	break;
904		✗	default:
905		✗	if (name)
906		✗	av_log(ctx, AV_LOG_INFO, "(%zu bytes)", sd->size);
907			else
908		✗	av_log(ctx, AV_LOG_WARNING, "unknown side data type %d "
909		✗	"(%zu bytes)", sd->type, sd->size);
910		✗	break;
911			}
912
913		✗	av_log(ctx, AV_LOG_INFO, "\n");
914			}
915
916		✗	dump_color_property(ctx, frame);
917
918		✗	if (desc->flags & AV_PIX_FMT_FLAG_ALPHA) {
919		✗	const char *alpha_mode_str = av_alpha_mode_name(frame->alpha_mode);
920		✗	if (!alpha_mode_str || frame->alpha_mode == AVALPHA_MODE_UNSPECIFIED)
921		✗	av_log(ctx, AV_LOG_INFO, "alpha_mode:unspecified\n");
922			else
923		✗	av_log(ctx, AV_LOG_INFO, "alpha_mode:%s\n", alpha_mode_str);
924			}
925
926		✗	return ff_filter_frame(inlink->dst->outputs[0], frame);
927			}
928
929		✗	static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
930			{
931		✗	FilterLink *l = ff_filter_link(link);
932
933		✗	av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
934			is_out ? "out" : "in",
935			link->time_base.num, link->time_base.den,
936			l->frame_rate.num, l->frame_rate.den);
937
938		✗	return 0;
939			}
940
941		✗	static int config_props_in(AVFilterLink *link)
942			{
943		✗	AVFilterContext *ctx = link->dst;
944		✗	return config_props(ctx, link, 0);
945			}
946
947		✗	static int config_props_out(AVFilterLink *link)
948			{
949		✗	AVFilterContext *ctx = link->src;
950		✗	return config_props(ctx, link, 1);
951			}
952
953			static const AVFilterPad avfilter_vf_showinfo_inputs[] = {
954			{
955			.name = "default",
956			.type = AVMEDIA_TYPE_VIDEO,
957			.filter_frame = filter_frame,
958			.config_props = config_props_in,
959			},
960			};
961
962			static const AVFilterPad avfilter_vf_showinfo_outputs[] = {
963			{
964			.name = "default",
965			.type = AVMEDIA_TYPE_VIDEO,
966			.config_props = config_props_out,
967			},
968			};
969
970			const FFFilter ff_vf_showinfo = {
971			.p.name = "showinfo",
972			.p.description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
973			.p.priv_class = &showinfo_class,
974			.p.flags = AVFILTER_FLAG_METADATA_ONLY,
975			FILTER_INPUTS(avfilter_vf_showinfo_inputs),
976			FILTER_OUTPUTS(avfilter_vf_showinfo_outputs),
977			.priv_size = sizeof(ShowInfoContext),
978			};
979