FFmpeg
vf_showinfo.c
Go to the documentation of this file.
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/hdr_dynamic_metadata.h"
36 #include "libavutil/hdr_dynamic_vivid_metadata.h"
37 #include "libavutil/opt.h"
38 #include "libavutil/pixdesc.h"
39 #include "libavutil/spherical.h"
40 #include "libavutil/stereo3d.h"
41 #include "libavutil/timestamp.h"
42 #include "libavutil/timecode.h"
43 #include "libavutil/mastering_display_metadata.h"
44 #include "libavutil/video_enc_params.h"
45 #include "libavutil/detection_bbox.h"
46 #include "libavutil/ambient_viewing_environment.h"
47 #include "libavutil/uuid.h"
48 
49 #include "avfilter.h"
50 #include "internal.h"
51 #include "video.h"
52 
53 typedef struct ShowInfoContext {
54  const AVClass *class;
55  int calculate_checksums;
56  int udu_sei_as_ascii;
57 } ShowInfoContext;
58 
59 #define OFFSET(x) offsetof(ShowInfoContext, x)
60 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
61 
62 static const AVOption showinfo_options[] = {
63  { "checksum", "calculate checksums", OFFSET(calculate_checksums), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, VF },
64  { "udu_sei_as_ascii", "try to print user data unregistered SEI as ascii character when possible",
65  OFFSET(udu_sei_as_ascii), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VF },
66  { NULL }
67 };
68 
69 AVFILTER_DEFINE_CLASS(showinfo);
70 
71 static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, const AVFrameSideData *sd)
72 {
73  const AVSphericalMapping *spherical = (const AVSphericalMapping *)sd->data;
74  double yaw, pitch, roll;
75 
76  av_log(ctx, AV_LOG_INFO, "%s ", av_spherical_projection_name(spherical->projection));
77 
78  if (spherical->yaw || spherical->pitch || spherical->roll) {
79  yaw = ((double)spherical->yaw) / (1 << 16);
80  pitch = ((double)spherical->pitch) / (1 << 16);
81  roll = ((double)spherical->roll) / (1 << 16);
82  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
83  }
84 
85  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
86  size_t l, t, r, b;
87  av_spherical_tile_bounds(spherical, frame->width, frame->height,
88  &l, &t, &r, &b);
89  av_log(ctx, AV_LOG_INFO,
90  "[%"SIZE_SPECIFIER", %"SIZE_SPECIFIER", %"SIZE_SPECIFIER", %"SIZE_SPECIFIER"] ",
91  l, t, r, b);
92  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
93  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
94  }
95 }
96 
97 static void dump_stereo3d(AVFilterContext *ctx, const AVFrameSideData *sd)
98 {
99  const AVStereo3D *stereo = (const AVStereo3D *)sd->data;
100 
101  av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
102 
103  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
104  av_log(ctx, AV_LOG_INFO, " (inverted)");
105 
106  av_log(ctx, AV_LOG_INFO, ", view - %s, primary_eye - %s", av_stereo3d_view_name(stereo->view),
107  av_stereo3d_primary_eye_name(stereo->primary_eye));
108  if (stereo->baseline)
109  av_log(ctx, AV_LOG_INFO, ", baseline: %"PRIu32"", stereo->baseline);
110  if (stereo->horizontal_disparity_adjustment.num && stereo->horizontal_disparity_adjustment.den)
111  av_log(ctx, AV_LOG_INFO, ", horizontal_disparity_adjustment: %0.4f",
112  av_q2d(stereo->horizontal_disparity_adjustment));
113  if (stereo->horizontal_field_of_view.num && stereo->horizontal_field_of_view.den)
114  av_log(ctx, AV_LOG_INFO, ", horizontal_field_of_view: %0.3f", av_q2d(stereo->horizontal_field_of_view));
115 }
116 
117 static void dump_s12m_timecode(AVFilterContext *ctx, AVRational frame_rate, const AVFrameSideData *sd)
118 {
119  const uint32_t *tc = (const uint32_t *)sd->data;
120 
121  if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
122  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
123  return;
124  }
125 
126  for (int j = 1; j <= tc[0]; j++) {
127  char tcbuf[AV_TIMECODE_STR_SIZE];
128  av_timecode_make_smpte_tc_string2(tcbuf, frame_rate, tc[j], 0, 0);
129  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
130  }
131 }
132 
133 static void dump_roi(AVFilterContext *ctx, const AVFrameSideData *sd)
134 {
135  int nb_rois;
136  const AVRegionOfInterest *roi;
137  uint32_t roi_size;
138 
139  roi = (const AVRegionOfInterest *)sd->data;
140  roi_size = roi->self_size;
141  if (!roi_size || sd->size % roi_size != 0) {
142  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
143  return;
144  }
145  nb_rois = sd->size / roi_size;
146 
147  for (int i = 0; i < nb_rois; i++) {
148  roi = (const AVRegionOfInterest *)(sd->data + roi_size * i);
149  av_log(ctx, AV_LOG_INFO, "index: %d, region: (%d, %d) -> (%d, %d), qp offset: %d/%d.\n",
150  i, roi->left, roi->top, roi->right, roi->bottom, roi->qoffset.num, roi->qoffset.den);
151  }
152 }
153 
154 static void dump_detection_bbox(AVFilterContext *ctx, const AVFrameSideData *sd)
155 {
156  int nb_bboxes;
157  const AVDetectionBBoxHeader *header;
158  const AVDetectionBBox *bbox;
159 
160  header = (const AVDetectionBBoxHeader *)sd->data;
161  nb_bboxes = header->nb_bboxes;
162  av_log(ctx, AV_LOG_INFO, "source: %s\n", header->source);
163 
164  for (int i = 0; i < nb_bboxes; i++) {
165  bbox = av_get_detection_bbox(header, i);
166  av_log(ctx, AV_LOG_INFO, "index: %d,\tregion: (%d, %d) -> (%d, %d), label: %s, confidence: %d/%d.\n",
167  i, bbox->x, bbox->y, bbox->x + bbox->w, bbox->y + bbox->h,
168  bbox->detect_label, bbox->detect_confidence.num, bbox->detect_confidence.den);
169  if (bbox->classify_count > 0) {
170  for (int j = 0; j < bbox->classify_count; j++) {
171  av_log(ctx, AV_LOG_INFO, "\t\tclassify: label: %s, confidence: %d/%d.\n",
172  bbox->classify_labels[j], bbox->classify_confidences[j].num, bbox->classify_confidences[j].den);
173  }
174  }
175  }
176 }
177 
178 static void dump_mastering_display(AVFilterContext *ctx, const AVFrameSideData *sd)
179 {
180  const AVMasteringDisplayMetadata *mastering_display;
181 
182  if (sd->size < sizeof(*mastering_display)) {
183  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
184  return;
185  }
186 
187  mastering_display = (const AVMasteringDisplayMetadata *)sd->data;
188 
189  av_log(ctx, AV_LOG_INFO, "has_primaries:%d has_luminance:%d "
190  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
191  "min_luminance=%f, max_luminance=%f",
192  mastering_display->has_primaries, mastering_display->has_luminance,
193  av_q2d(mastering_display->display_primaries[0][0]),
194  av_q2d(mastering_display->display_primaries[0][1]),
195  av_q2d(mastering_display->display_primaries[1][0]),
196  av_q2d(mastering_display->display_primaries[1][1]),
197  av_q2d(mastering_display->display_primaries[2][0]),
198  av_q2d(mastering_display->display_primaries[2][1]),
199  av_q2d(mastering_display->white_point[0]), av_q2d(mastering_display->white_point[1]),
200  av_q2d(mastering_display->min_luminance), av_q2d(mastering_display->max_luminance));
201 }
202 
203 static void dump_dynamic_hdr_plus(AVFilterContext *ctx, AVFrameSideData *sd)
204 {
205  AVDynamicHDRPlus *hdr_plus;
206 
207  if (sd->size < sizeof(*hdr_plus)) {
208  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
209  return;
210  }
211 
212  hdr_plus = (AVDynamicHDRPlus *)sd->data;
213  av_log(ctx, AV_LOG_INFO, "application version: %d, ", hdr_plus->application_version);
214  av_log(ctx, AV_LOG_INFO, "num_windows: %d, ", hdr_plus->num_windows);
215  for (int w = 1; w < hdr_plus->num_windows; w++) {
216  AVHDRPlusColorTransformParams *params = &hdr_plus->params[w];
217  av_log(ctx, AV_LOG_INFO, w > 1 ? ", window %d { " : "window %d { ", w);
218  av_log(ctx, AV_LOG_INFO, "window_upper_left_corner: (%5.4f,%5.4f),",
219  av_q2d(params->window_upper_left_corner_x),
220  av_q2d(params->window_upper_left_corner_y));
221  av_log(ctx, AV_LOG_INFO, "window_lower_right_corner: (%5.4f,%5.4f), ",
222  av_q2d(params->window_lower_right_corner_x),
223  av_q2d(params->window_lower_right_corner_y));
224  av_log(ctx, AV_LOG_INFO, "window_upper_left_corner: (%5.4f, %5.4f), ",
225  av_q2d(params->window_upper_left_corner_x),
226  av_q2d(params->window_upper_left_corner_y));
227  av_log(ctx, AV_LOG_INFO, "center_of_ellipse_x: (%d,%d), ",
228  params->center_of_ellipse_x,
229  params->center_of_ellipse_y);
230  av_log(ctx, AV_LOG_INFO, "rotation_angle: %d, ",
231  params->rotation_angle);
232  av_log(ctx, AV_LOG_INFO, "semimajor_axis_internal_ellipse: %d, ",
233  params->semimajor_axis_internal_ellipse);
234  av_log(ctx, AV_LOG_INFO, "semimajor_axis_external_ellipse: %d, ",
235  params->semimajor_axis_external_ellipse);
236  av_log(ctx, AV_LOG_INFO, "semiminor_axis_external_ellipse: %d, ",
237  params->semiminor_axis_external_ellipse);
238  av_log(ctx, AV_LOG_INFO, "overlap_process_option: %d}",
239  params->overlap_process_option);
240  }
241  av_log(ctx, AV_LOG_INFO, "targeted_system_display_maximum_luminance: %9.4f, ",
242  av_q2d(hdr_plus->targeted_system_display_maximum_luminance));
243  if (hdr_plus->targeted_system_display_actual_peak_luminance_flag) {
244  av_log(ctx, AV_LOG_INFO, "targeted_system_display_actual_peak_luminance: {");
245  for (int i = 0; i < hdr_plus->num_rows_targeted_system_display_actual_peak_luminance; i++) {
246  av_log(ctx, AV_LOG_INFO, "(");
247  for (int j = 0; j < hdr_plus->num_cols_targeted_system_display_actual_peak_luminance; j++) {
248  av_log(ctx, AV_LOG_INFO, i ? ",%5.4f" : "%5.4f",
249  av_q2d(hdr_plus->targeted_system_display_actual_peak_luminance[i][j]));
250  }
251  av_log(ctx, AV_LOG_INFO, ")");
252  }
253  av_log(ctx, AV_LOG_INFO, "}, ");
254  }
255 
256  for (int w = 0; w < hdr_plus->num_windows; w++) {
257  AVHDRPlusColorTransformParams *params = &hdr_plus->params[w];
258  av_log(ctx, AV_LOG_INFO, "window %d {maxscl: {", w);
259  for (int i = 0; i < 3; i++) {
260  av_log(ctx, AV_LOG_INFO, i ? ",%5.4f" : "%5.4f",av_q2d(params->maxscl[i]));
261  }
262  av_log(ctx, AV_LOG_INFO, "}, average_maxrgb: %5.4f, ",
263  av_q2d(params->average_maxrgb));
264  av_log(ctx, AV_LOG_INFO, "distribution_maxrgb: {");
265  for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {
266  av_log(ctx, AV_LOG_INFO, "(%d,%5.4f)",
267  params->distribution_maxrgb[i].percentage,
268  av_q2d(params->distribution_maxrgb[i].percentile));
269  }
270  av_log(ctx, AV_LOG_INFO, "}, fraction_bright_pixels: %5.4f",
271  av_q2d(params->fraction_bright_pixels));
272  if (params->tone_mapping_flag) {
273  av_log(ctx, AV_LOG_INFO, ", knee_point: (%5.4f,%5.4f), ", av_q2d(params->knee_point_x), av_q2d(params->knee_point_y));
274  av_log(ctx, AV_LOG_INFO, "bezier_curve_anchors: {");
275  for (int i = 0; i < params->num_bezier_curve_anchors; i++) {
276  av_log(ctx, AV_LOG_INFO, i ? ",%5.4f" : "%5.4f",
277  av_q2d(params->bezier_curve_anchors[i]));
278  }
279  av_log(ctx, AV_LOG_INFO, "}");
280  }
281  if (params->color_saturation_mapping_flag) {
282  av_log(ctx, AV_LOG_INFO, ", color_saturation_weight: %5.4f",
283  av_q2d(params->color_saturation_weight));
284  }
285  av_log(ctx, AV_LOG_INFO, "}");
286  }
287 
288  if (hdr_plus->mastering_display_actual_peak_luminance_flag) {
289  av_log(ctx, AV_LOG_INFO, ", mastering_display_actual_peak_luminance: {");
290  for (int i = 0; i < hdr_plus->num_rows_mastering_display_actual_peak_luminance; i++) {
291  av_log(ctx, AV_LOG_INFO, "(");
292  for (int j = 0; j < hdr_plus->num_cols_mastering_display_actual_peak_luminance; j++) {
293  av_log(ctx, AV_LOG_INFO, i ? ",%5.4f" : "%5.4f",
294  av_q2d(hdr_plus->mastering_display_actual_peak_luminance[i][j]));
295  }
296  av_log(ctx, AV_LOG_INFO, ")");
297  }
298  av_log(ctx, AV_LOG_INFO, "}");
299  }
300 }
301 
302 static void dump_dynamic_hdr_vivid(AVFilterContext *ctx, AVFrameSideData *sd)
303 {
304  AVDynamicHDRVivid *hdr_vivid;
305 
306  if (sd->size < sizeof(*hdr_vivid)) {
307  av_log(ctx, AV_LOG_ERROR, "invalid hdr vivid data\n");
308  return;
309  }
310 
311  hdr_vivid = (AVDynamicHDRVivid *)sd->data;
312  av_log(ctx, AV_LOG_INFO, "system_start_code: %d, ", hdr_vivid->system_start_code);
313  av_log(ctx, AV_LOG_INFO, "num_windows: %d, ", hdr_vivid->num_windows);
314  for (int w = 0; w < hdr_vivid->num_windows; w++) {
315  const AVHDRVividColorTransformParams *params = &hdr_vivid->params[w];
316 
317  av_log(ctx, AV_LOG_INFO, "minimum_maxrgb[%d]: %.4f, ", w, av_q2d(params->minimum_maxrgb));
318  av_log(ctx, AV_LOG_INFO, "average_maxrgb[%d]: %.4f, ", w, av_q2d(params->average_maxrgb));
319  av_log(ctx, AV_LOG_INFO, "variance_maxrgb[%d]:%.4f, ", w, av_q2d(params->variance_maxrgb));
320  av_log(ctx, AV_LOG_INFO, "maximum_maxrgb[%d]: %.4f, ", w, av_q2d(params->maximum_maxrgb));
321  }
322 
323  for (int w = 0; w < hdr_vivid->num_windows; w++) {
324  const AVHDRVividColorTransformParams *params = &hdr_vivid->params[w];
325 
326  av_log(ctx, AV_LOG_INFO, "tone_mapping_mode_flag[%d]: %d, ", w, params->tone_mapping_mode_flag);
327  av_log(ctx, AV_LOG_INFO, "tone_mapping_param_num[%d]: %d, ", w, params->tone_mapping_param_num);
328  if (params->tone_mapping_mode_flag) {
329  for (int i = 0; i < params->tone_mapping_param_num; i++) {
330  const AVHDRVividColorToneMappingParams *tm_params = &params->tm_params[i];
331 
332  av_log(ctx, AV_LOG_INFO, "targeted_system_display_maximum_luminance[%d][%d]: %.4f, ",
333  w, i, av_q2d(tm_params->targeted_system_display_maximum_luminance));
334  av_log(ctx, AV_LOG_INFO, "base_enable_flag[%d][%d]: %d, ",
335  w, i, tm_params->base_enable_flag);
336  if (tm_params->base_enable_flag) {
337  av_log(ctx, AV_LOG_INFO, "base_param_m_p[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_p));
338  av_log(ctx, AV_LOG_INFO, "base_param_m_m[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_m));
339  av_log(ctx, AV_LOG_INFO, "base_param_m_a[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_a));
340  av_log(ctx, AV_LOG_INFO, "base_param_m_b[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_b));
341  av_log(ctx, AV_LOG_INFO, "base_param_m_n[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_n));
342  av_log(ctx, AV_LOG_INFO, "base_param_k1[%d][%d]: %d, ", w, i, tm_params->base_param_k1);
343  av_log(ctx, AV_LOG_INFO, "base_param_k2[%d][%d]: %d, ", w, i, tm_params->base_param_k2);
344  av_log(ctx, AV_LOG_INFO, "base_param_k3[%d][%d]: %d, ", w, i, tm_params->base_param_k3);
345  av_log(ctx, AV_LOG_INFO, "base_param_Delta_enable_mode[%d][%d]: %d, ", w, i,
346  tm_params->base_param_Delta_enable_mode);
347  av_log(ctx, AV_LOG_INFO, "base_param_Delta[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_Delta));
348  }
349  av_log(ctx, AV_LOG_INFO, "3Spline_enable_flag[%d][%d]: %d, ",
350  w, i, tm_params->three_Spline_enable_flag);
351  if (tm_params->three_Spline_enable_flag) {
352  for (int j = 0; j < tm_params->three_Spline_num; j++) {
353  const AVHDRVivid3SplineParams *three_spline = &tm_params->three_spline[j];
354  av_log(ctx, AV_LOG_INFO, "3Spline_TH_mode[%d][%d]: %d, ", w, i, three_spline->th_mode);
355  if (three_spline->th_mode == 0 || three_spline->th_mode == 2)
356  av_log(ctx, AV_LOG_INFO, "3Spline_TH_enable_MB[%d][%d][%d]: %.4f, ",
357  w, i, j, av_q2d(three_spline->th_enable_mb));
358  av_log(ctx, AV_LOG_INFO, "3Spline_TH_enable[%d][%d][%d]: %.4f, ",
359  w, i, j, av_q2d(three_spline->th_enable));
360  av_log(ctx, AV_LOG_INFO, "3Spline_TH_Delta1[%d][%d][%d]: %.4f, ",
361  w, i, j, av_q2d(three_spline->th_delta1));
362  av_log(ctx, AV_LOG_INFO, "3Spline_TH_Delta2[%d][%d][%d]: %.4f, ",
363  w, i, j, av_q2d(three_spline->th_delta2));
364  av_log(ctx, AV_LOG_INFO, "3Spline_enable_Strength[%d][%d][%d]: %.4f, ",
365  w, i, j, av_q2d(three_spline->enable_strength));
366  }
367  }
368  }
369  }
370 
371  av_log(ctx, AV_LOG_INFO, "color_saturation_mapping_flag[%d]: %d",
372  w, params->color_saturation_mapping_flag);
373  if (params->color_saturation_mapping_flag) {
374  av_log(ctx, AV_LOG_INFO, ", color_saturation_num[%d]: %d",
375  w, params->color_saturation_num);
376  for (int i = 0; i < params->color_saturation_num; i++) {
377  av_log(ctx, AV_LOG_INFO, ", color_saturation_gain[%d][%d]: %.4f",
378  w, i, av_q2d(params->color_saturation_gain[i]));
379  }
380  }
381  }
382 }
383 
384 
385 static void dump_content_light_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
386 {
387  const AVContentLightMetadata *metadata = (const AVContentLightMetadata *)sd->data;
388 
389  av_log(ctx, AV_LOG_INFO,
390  "MaxCLL=%d, MaxFALL=%d",
391  metadata->MaxCLL, metadata->MaxFALL);
392 }
393 
394 static void dump_video_enc_params(AVFilterContext *ctx, const AVFrameSideData *sd)
395 {
396  const AVVideoEncParams *par = (const AVVideoEncParams *)sd->data;
397  int plane, acdc;
398 
399  av_log(ctx, AV_LOG_INFO, "type %d; ", par->type);
400  if (par->qp)
401  av_log(ctx, AV_LOG_INFO, "qp=%d; ", par->qp);
402  for (plane = 0; plane < FF_ARRAY_ELEMS(par->delta_qp); plane++)
403  for (acdc = 0; acdc < FF_ARRAY_ELEMS(par->delta_qp[plane]); acdc++) {
404  int delta_qp = par->delta_qp[plane][acdc];
405  if (delta_qp)
406  av_log(ctx, AV_LOG_INFO, "delta_qp[%d][%d]=%d; ",
407  plane, acdc, delta_qp);
408  }
409  if (par->nb_blocks)
410  av_log(ctx, AV_LOG_INFO, "%u blocks; ", par->nb_blocks);
411 }
412 
413 static void dump_sei_unregistered_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
414 {
415  const uint8_t *user_data = sd->data;
416  ShowInfoContext *s = ctx->priv;
417 
418  if (sd->size < AV_UUID_LEN) {
419  av_log(ctx, AV_LOG_ERROR, "invalid data(%"SIZE_SPECIFIER" < "
420  "UUID(%d-bytes))\n", sd->size, AV_UUID_LEN);
421  return;
422  }
423 
424  av_log(ctx, AV_LOG_INFO, "UUID=" AV_PRI_UUID "\n", AV_UUID_ARG(user_data));
425 
426  av_log(ctx, AV_LOG_INFO, "User Data=");
427  for (size_t i = 16; i < sd->size; i++) {
428  const char *format = "%02x";
429 
430  if (s->udu_sei_as_ascii)
431  format = isprint(user_data[i]) ? "%c" : "\\x%02x";
432  av_log(ctx, AV_LOG_INFO, format, user_data[i]);
433  }
434  av_log(ctx, AV_LOG_INFO, "\n");
435 }
436 
437 static void dump_sei_film_grain_params_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
438 {
439  const AVFilmGrainParams *fgp = (const AVFilmGrainParams *)sd->data;
440  const char *const film_grain_type_names[] = {
441  [AV_FILM_GRAIN_PARAMS_NONE] = "none",
442  [AV_FILM_GRAIN_PARAMS_AV1] = "av1",
443  [AV_FILM_GRAIN_PARAMS_H274] = "h274",
444  };
445 
446  const char *color_range_str = av_color_range_name(fgp->color_range);
447  const char *color_primaries_str = av_color_primaries_name(fgp->color_primaries);
448  const char *color_trc_str = av_color_transfer_name(fgp->color_trc);
449  const char *colorspace_str = av_color_space_name(fgp->color_space);
450 
451  if (fgp->type >= FF_ARRAY_ELEMS(film_grain_type_names)) {
452  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
453  return;
454  }
455 
456  av_log(ctx, AV_LOG_INFO, "type %s; ", film_grain_type_names[fgp->type]);
457  av_log(ctx, AV_LOG_INFO, "seed=%"PRIu64"; ", fgp->seed);
458  av_log(ctx, AV_LOG_INFO, "width=%d; ", fgp->width);
459  av_log(ctx, AV_LOG_INFO, "height=%d; ", fgp->height);
460  av_log(ctx, AV_LOG_INFO, "subsampling_x=%d; ", fgp->subsampling_x);
461  av_log(ctx, AV_LOG_INFO, "subsampling_y=%d; ", fgp->subsampling_y);
462  av_log(ctx, AV_LOG_INFO, "color_range=%s; ", color_range_str ? color_range_str : "unknown");
463  av_log(ctx, AV_LOG_INFO, "color_primaries=%s; ", color_primaries_str ? color_primaries_str : "unknown");
464  av_log(ctx, AV_LOG_INFO, "color_trc=%s; ", color_trc_str ? color_trc_str : "unknown");
465  av_log(ctx, AV_LOG_INFO, "color_space=%s; ", colorspace_str ? colorspace_str : "unknown");
466  av_log(ctx, AV_LOG_INFO, "bit_depth_luma=%d; ", fgp->bit_depth_luma);
467  av_log(ctx, AV_LOG_INFO, "bit_depth_chroma=%d; ", fgp->bit_depth_chroma);
468 
469  switch (fgp->type) {
470  case AV_FILM_GRAIN_PARAMS_NONE:
471  break;
472  case AV_FILM_GRAIN_PARAMS_AV1: {
473  const AVFilmGrainAOMParams *aom = &fgp->codec.aom;
474  const int num_ar_coeffs_y = 2 * aom->ar_coeff_lag * (aom->ar_coeff_lag + 1);
475  const int num_ar_coeffs_uv = num_ar_coeffs_y + !!aom->num_y_points;
476  av_log(ctx, AV_LOG_INFO, "y_points={ ");
477  for (int i = 0; i < aom->num_y_points; i++)
478  av_log(ctx, AV_LOG_INFO, "(%d,%d) ", aom->y_points[i][0], aom->y_points[i][1]);
479  av_log(ctx, AV_LOG_INFO, "}; chroma_scaling_from_luma=%d; ", aom->chroma_scaling_from_luma);
480  for (int uv = 0; uv < 2; uv++) {
481  av_log(ctx, AV_LOG_INFO, "uv_points[%d]={ ", uv);
482  for (int i = 0; i < aom->num_uv_points[uv]; i++)
483  av_log(ctx, AV_LOG_INFO, "(%d,%d) ", aom->uv_points[uv][i][0], aom->uv_points[uv][i][1]);
484  av_log(ctx, AV_LOG_INFO, "}; ");
485  }
486  av_log(ctx, AV_LOG_INFO, "scaling_shift=%d; ", aom->scaling_shift);
487  av_log(ctx, AV_LOG_INFO, "ar_coeff_lag=%d; ", aom->ar_coeff_lag);
488  if (num_ar_coeffs_y) {
489  av_log(ctx, AV_LOG_INFO, "ar_coeffs_y={ ");
490  for (int i = 0; i < num_ar_coeffs_y; i++)
491  av_log(ctx, AV_LOG_INFO, "%d ", aom->ar_coeffs_y[i]);
492  av_log(ctx, AV_LOG_INFO, "}; ");
493  }
494  for (int uv = 0; num_ar_coeffs_uv && uv < 2; uv++) {
495  av_log(ctx, AV_LOG_INFO, "ar_coeffs_uv[%d]={ ", uv);
496  for (int i = 0; i < num_ar_coeffs_uv; i++)
497  av_log(ctx, AV_LOG_INFO, "%d ", aom->ar_coeffs_uv[uv][i]);
498  av_log(ctx, AV_LOG_INFO, "}; ");
499  }
500  av_log(ctx, AV_LOG_INFO, "ar_coeff_shift=%d; ", aom->ar_coeff_shift);
501  av_log(ctx, AV_LOG_INFO, "grain_scale_shift=%d; ", aom->grain_scale_shift);
502  for (int uv = 0; uv < 2; uv++) {
503  av_log(ctx, AV_LOG_INFO, "uv_mult[%d] = %d; ", uv, aom->uv_mult[uv]);
504  av_log(ctx, AV_LOG_INFO, "uv_mult_luma[%d] = %d; ", uv, aom->uv_mult_luma[uv]);
505  av_log(ctx, AV_LOG_INFO, "uv_offset[%d] = %d; ", uv, aom->uv_offset[uv]);
506  }
507  av_log(ctx, AV_LOG_INFO, "overlap_flag=%d; ", aom->overlap_flag);
508  av_log(ctx, AV_LOG_INFO, "limit_output_range=%d; ", aom->limit_output_range);
509  break;
510  }
511  case AV_FILM_GRAIN_PARAMS_H274: {
512  const AVFilmGrainH274Params *h274 = &fgp->codec.h274;
513  av_log(ctx, AV_LOG_INFO, "model_id=%d; ", h274->model_id);
514  av_log(ctx, AV_LOG_INFO, "blending_mode_id=%d; ", h274->blending_mode_id);
515  av_log(ctx, AV_LOG_INFO, "log2_scale_factor=%d; ", h274->log2_scale_factor);
516 
517  for (int c = 0; c < 3; c++)
518  if (h274->component_model_present[c] && (h274->num_model_values[c] > 6 ||
519  h274->num_intensity_intervals[c] < 1 ||
520  h274->num_intensity_intervals[c] > 256)) {
521  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
522  return;
523  }
524 
525  for (int c = 0; c < 3; c++) {
526  if (!h274->component_model_present[c])
527  continue;
528 
529  av_log(ctx, AV_LOG_INFO, "num_intensity_intervals[%d]=%u; ", c, h274->num_intensity_intervals[c]);
530  av_log(ctx, AV_LOG_INFO, "num_model_values[%d]=%u; ", c, h274->num_model_values[c]);
531  for (int i = 0; i < h274->num_intensity_intervals[c]; i++) {
532  av_log(ctx, AV_LOG_INFO, "intensity_interval_lower_bound[%d][%d]=%u; ",
533  c, i, h274->intensity_interval_lower_bound[c][i]);
534  av_log(ctx, AV_LOG_INFO, "intensity_interval_upper_bound[%d][%d]=%u; ",
535  c, i, h274->intensity_interval_upper_bound[c][i]);
536  for (int j = 0; j < h274->num_model_values[c]; j++)
537  av_log(ctx, AV_LOG_INFO, "comp_model_value[%d][%d][%d]=%d; ",
538  c, i, j, h274->comp_model_value[c][i][j]);
539  }
540  }
541  break;
542  }
543  }
544 }
545 
546 static void dump_dovi_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
547 {
548  const AVDOVIMetadata *dovi = (AVDOVIMetadata *) sd->data;
549  const AVDOVIRpuDataHeader *hdr = av_dovi_get_header(dovi);
550  const AVDOVIDataMapping *mapping = av_dovi_get_mapping(dovi);
551  const AVDOVIColorMetadata *color = av_dovi_get_color(dovi);
552 
553  av_log(ctx, AV_LOG_INFO, " rpu_type=%"PRIu8"; ", hdr->rpu_type);
554  av_log(ctx, AV_LOG_INFO, "rpu_format=%"PRIu16"; ", hdr->rpu_format);
555  av_log(ctx, AV_LOG_INFO, "vdr_rpu_profile=%"PRIu8"; ", hdr->vdr_rpu_profile);
556  av_log(ctx, AV_LOG_INFO, "vdr_rpu_level=%"PRIu8"; ", hdr->vdr_rpu_level);
557  av_log(ctx, AV_LOG_INFO, "chroma_resampling_explicit_filter_flag=%"PRIu8"; ", hdr->chroma_resampling_explicit_filter_flag);
558  av_log(ctx, AV_LOG_INFO, "coef_data_type=%"PRIu8"; ", hdr->coef_data_type);
559  av_log(ctx, AV_LOG_INFO, "coef_log2_denom=%"PRIu8"; ", hdr->coef_log2_denom);
560  av_log(ctx, AV_LOG_INFO, "vdr_rpu_normalized_idc=%"PRIu8"; ", hdr->vdr_rpu_normalized_idc);
561  av_log(ctx, AV_LOG_INFO, "bl_video_full_range_flag=%"PRIu8"; ", hdr->bl_video_full_range_flag);
562  av_log(ctx, AV_LOG_INFO, "bl_bit_depth=%"PRIu8"; ", hdr->bl_bit_depth);
563  av_log(ctx, AV_LOG_INFO, "el_bit_depth=%"PRIu8"; ", hdr->el_bit_depth);
564  av_log(ctx, AV_LOG_INFO, "vdr_bit_depth=%"PRIu8"; ", hdr->vdr_bit_depth);
565  av_log(ctx, AV_LOG_INFO, "spatial_resampling_filter_flag=%"PRIu8"; ", hdr->spatial_resampling_filter_flag);
566  av_log(ctx, AV_LOG_INFO, "el_spatial_resampling_filter_flag=%"PRIu8"; ", hdr->el_spatial_resampling_filter_flag);
567  av_log(ctx, AV_LOG_INFO, "disable_residual_flag=%"PRIu8"\n", hdr->disable_residual_flag);
568 
569  av_log(ctx, AV_LOG_INFO, " data mapping: ");
570  av_log(ctx, AV_LOG_INFO, "vdr_rpu_id=%"PRIu8"; ", mapping->vdr_rpu_id);
571  av_log(ctx, AV_LOG_INFO, "mapping_color_space=%"PRIu8"; ", mapping->mapping_color_space);
572  av_log(ctx, AV_LOG_INFO, "mapping_chroma_format_idc=%"PRIu8"; ", mapping->mapping_chroma_format_idc);
573  av_log(ctx, AV_LOG_INFO, "nlq_method_idc=%d; ", (int) mapping->nlq_method_idc);
574  av_log(ctx, AV_LOG_INFO, "num_x_partitions=%"PRIu32"; ", mapping->num_x_partitions);
575  av_log(ctx, AV_LOG_INFO, "num_y_partitions=%"PRIu32"\n", mapping->num_y_partitions);
576 
577  for (int c = 0; c < 3; c++) {
578  const AVDOVIReshapingCurve *curve = &mapping->curves[c];
579  const AVDOVINLQParams *nlq = &mapping->nlq[c];
580  av_log(ctx, AV_LOG_INFO, " channel %d: ", c);
581  av_log(ctx, AV_LOG_INFO, "pivots={ ");
582  for (int i = 0; i < curve->num_pivots; i++)
583  av_log(ctx, AV_LOG_INFO, "%"PRIu16" ", curve->pivots[i]);
584  av_log(ctx, AV_LOG_INFO, "}; mapping_idc={ ");
585  for (int i = 0; i < curve->num_pivots - 1; i++)
586  av_log(ctx, AV_LOG_INFO, "%d ", (int) curve->mapping_idc[i]);
587  av_log(ctx, AV_LOG_INFO, "}; poly_order={ ");
588  for (int i = 0; i < curve->num_pivots - 1; i++)
589  av_log(ctx, AV_LOG_INFO, "%"PRIu8" ", curve->poly_order[i]);
590  av_log(ctx, AV_LOG_INFO, "}; poly_coef={ ");
591  for (int i = 0; i < curve->num_pivots - 1; i++) {
592  av_log(ctx, AV_LOG_INFO, "{%"PRIi64", %"PRIi64", %"PRIi64"} ",
593  curve->poly_coef[i][0],
594  curve->poly_coef[i][1],
595  curve->poly_coef[i][2]);
596  }
597 
598  av_log(ctx, AV_LOG_INFO, "}; mmr_order={ ");
599  for (int i = 0; i < curve->num_pivots - 1; i++)
600  av_log(ctx, AV_LOG_INFO, "%"PRIu8" ", curve->mmr_order[i]);
601  av_log(ctx, AV_LOG_INFO, "}; mmr_constant={ ");
602  for (int i = 0; i < curve->num_pivots - 1; i++)
603  av_log(ctx, AV_LOG_INFO, "%"PRIi64" ", curve->mmr_constant[i]);
604  av_log(ctx, AV_LOG_INFO, "}; mmr_coef={ ");
605  for (int i = 0; i < curve->num_pivots - 1; i++) {
606  av_log(ctx, AV_LOG_INFO, "{");
607  for (int j = 0; j < curve->mmr_order[i]; j++) {
608  for (int k = 0; k < 7; k++)
609  av_log(ctx, AV_LOG_INFO, "%"PRIi64" ", curve->mmr_coef[i][j][k]);
610  }
611  av_log(ctx, AV_LOG_INFO, "} ");
612  }
613 
614  av_log(ctx, AV_LOG_INFO, "}; nlq_offset=%"PRIu16"; ", nlq->nlq_offset);
615  av_log(ctx, AV_LOG_INFO, "vdr_in_max=%"PRIu64"; ", nlq->vdr_in_max);
616  switch (mapping->nlq_method_idc) {
617  case AV_DOVI_NLQ_LINEAR_DZ:
618  av_log(ctx, AV_LOG_INFO, "linear_deadzone_slope=%"PRIu64"; ", nlq->linear_deadzone_slope);
619  av_log(ctx, AV_LOG_INFO, "linear_deadzone_threshold=%"PRIu64"\n", nlq->linear_deadzone_threshold);
620  break;
621  }
622  }
623 
624  av_log(ctx, AV_LOG_INFO, " color metadata: ");
625  av_log(ctx, AV_LOG_INFO, "dm_metadata_id=%"PRIu8"; ", color->dm_metadata_id);
626  av_log(ctx, AV_LOG_INFO, "scene_refresh_flag=%"PRIu8"; ", color->scene_refresh_flag);
627  av_log(ctx, AV_LOG_INFO, "ycc_to_rgb_matrix={ ");
628  for (int i = 0; i < 9; i++)
629  av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->ycc_to_rgb_matrix[i]));
630  av_log(ctx, AV_LOG_INFO, "}; ycc_to_rgb_offset={ ");
631  for (int i = 0; i < 3; i++)
632  av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->ycc_to_rgb_offset[i]));
633  av_log(ctx, AV_LOG_INFO, "}; rgb_to_lms_matrix={ ");
634  for (int i = 0; i < 9; i++)
635  av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->rgb_to_lms_matrix[i]));
636  av_log(ctx, AV_LOG_INFO, "}; signal_eotf=%"PRIu16"; ", color->signal_eotf);
637  av_log(ctx, AV_LOG_INFO, "signal_eotf_param0=%"PRIu16"; ", color->signal_eotf_param0);
638  av_log(ctx, AV_LOG_INFO, "signal_eotf_param1=%"PRIu16"; ", color->signal_eotf_param1);
639  av_log(ctx, AV_LOG_INFO, "signal_eotf_param2=%"PRIu32"; ", color->signal_eotf_param2);
640  av_log(ctx, AV_LOG_INFO, "signal_bit_depth=%"PRIu8"; ", color->signal_bit_depth);
641  av_log(ctx, AV_LOG_INFO, "signal_color_space=%"PRIu8"; ", color->signal_color_space);
642  av_log(ctx, AV_LOG_INFO, "signal_chroma_format=%"PRIu8"; ", color->signal_chroma_format);
643  av_log(ctx, AV_LOG_INFO, "signal_full_range_flag=%"PRIu8"; ", color->signal_full_range_flag);
644  av_log(ctx, AV_LOG_INFO, "source_min_pq=%"PRIu16"; ", color->source_min_pq);
645  av_log(ctx, AV_LOG_INFO, "source_max_pq=%"PRIu16"; ", color->source_max_pq);
646  av_log(ctx, AV_LOG_INFO, "source_diagonal=%"PRIu16"; ", color->source_diagonal);
647 }
648 
649 static void dump_ambient_viewing_environment(AVFilterContext *ctx, const AVFrameSideData *sd)
650 {
651  const AVAmbientViewingEnvironment *ambient_viewing_environment =
652  (const AVAmbientViewingEnvironment *)sd->data;
653 
654  av_log(ctx, AV_LOG_INFO, "ambient_illuminance=%f, ambient_light_x=%f, ambient_light_y=%f",
655  av_q2d(ambient_viewing_environment->ambient_illuminance),
656  av_q2d(ambient_viewing_environment->ambient_light_x),
657  av_q2d(ambient_viewing_environment->ambient_light_y));
658 }
659 
660 static void dump_color_property(AVFilterContext *ctx, AVFrame *frame)
661 {
662  const char *color_range_str = av_color_range_name(frame->color_range);
663  const char *colorspace_str = av_color_space_name(frame->colorspace);
664  const char *color_primaries_str = av_color_primaries_name(frame->color_primaries);
665  const char *color_trc_str = av_color_transfer_name(frame->color_trc);
666 
667  if (!color_range_str || frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
668  av_log(ctx, AV_LOG_INFO, "color_range:unknown");
669  } else {
670  av_log(ctx, AV_LOG_INFO, "color_range:%s", color_range_str);
671  }
672 
673  if (!colorspace_str || frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
674  av_log(ctx, AV_LOG_INFO, " color_space:unknown");
675  } else {
676  av_log(ctx, AV_LOG_INFO, " color_space:%s", colorspace_str);
677  }
678 
679  if (!color_primaries_str || frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
680  av_log(ctx, AV_LOG_INFO, " color_primaries:unknown");
681  } else {
682  av_log(ctx, AV_LOG_INFO, " color_primaries:%s", color_primaries_str);
683  }
684 
685  if (!color_trc_str || frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
686  av_log(ctx, AV_LOG_INFO, " color_trc:unknown");
687  } else {
688  av_log(ctx, AV_LOG_INFO, " color_trc:%s", color_trc_str);
689  }
690  av_log(ctx, AV_LOG_INFO, "\n");
691 }
692 
693 static void update_sample_stats_8(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
694 {
695  int i;
696 
697  for (i = 0; i < len; i++) {
698  *sum += src[i];
699  *sum2 += src[i] * src[i];
700  }
701 }
702 
703 static void update_sample_stats_16(int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
704 {
705  const uint16_t *src1 = (const uint16_t *)src;
706  int i;
707 
708  for (i = 0; i < len / 2; i++) {
709  if ((HAVE_BIGENDIAN && !be) || (!HAVE_BIGENDIAN && be)) {
710  *sum += av_bswap16(src1[i]);
711  *sum2 += (uint32_t)av_bswap16(src1[i]) * (uint32_t)av_bswap16(src1[i]);
712  } else {
713  *sum += src1[i];
714  *sum2 += (uint32_t)src1[i] * (uint32_t)src1[i];
715  }
716  }
717 }
718 
719 static void update_sample_stats(int depth, int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
720 {
721  if (depth <= 8)
722  update_sample_stats_8(src, len, sum, sum2);
723  else
724  update_sample_stats_16(be, src, len, sum, sum2);
725 }
726 
727 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
728 {
729  AVFilterContext *ctx = inlink->dst;
730  ShowInfoContext *s = ctx->priv;
731  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
732  uint32_t plane_checksum[4] = {0}, checksum = 0;
733  int64_t sum[4] = {0}, sum2[4] = {0};
734  int32_t pixelcount[4] = {0};
735  int bitdepth = desc->comp[0].depth;
736  int be = desc->flags & AV_PIX_FMT_FLAG_BE;
737  int i, plane, vsub = desc->log2_chroma_h;
738 
739  for (plane = 0; plane < 4 && s->calculate_checksums && frame->data[plane] && frame->linesize[plane]; plane++) {
740  uint8_t *data = frame->data[plane];
741  int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
742  int linesize = av_image_get_linesize(frame->format, frame->width, plane);
743  int width = linesize >> (bitdepth > 8);
744 
745  if (linesize < 0)
746  return linesize;
747 
748  for (i = 0; i < h; i++) {
749  plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
750  checksum = av_adler32_update(checksum, data, linesize);
751 
752  update_sample_stats(bitdepth, be, data, linesize, sum+plane, sum2+plane);
753  pixelcount[plane] += width;
754  data += frame->linesize[plane];
755  }
756  }
757 
758  av_log(ctx, AV_LOG_INFO,
759  "n:%4"PRId64" pts:%7s pts_time:%-7s duration:%7"PRId64
760  " duration_time:%-7s "
761  "fmt:%s cl:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c ",
762  inlink->frame_count_out,
763  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base),
764  frame->duration, av_ts2timestr(frame->duration, &inlink->time_base),
765  desc->name, av_chroma_location_name(frame->chroma_location),
766  frame->sample_aspect_ratio.num, frame->sample_aspect_ratio.den,
767  frame->width, frame->height,
768  !(frame->flags & AV_FRAME_FLAG_INTERLACED) ? 'P' : /* Progressive */
769  (frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 'T' : 'B', /* Top / Bottom */
770  !!(frame->flags & AV_FRAME_FLAG_KEY),
771  av_get_picture_type_char(frame->pict_type));
772 
773  if (s->calculate_checksums) {
774  av_log(ctx, AV_LOG_INFO,
775  "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
776  checksum, plane_checksum[0]);
777 
778  for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
779  av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
780  av_log(ctx, AV_LOG_INFO, "] mean:[");
781  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
782  av_log(ctx, AV_LOG_INFO, "%s%"PRId64,
783  plane ? " ":"",
784  (sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
785  av_log(ctx, AV_LOG_INFO, "] stdev:[");
786  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
787  av_log(ctx, AV_LOG_INFO, "%s%3.1f",
788  plane ? " ":"",
789  sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
790  av_log(ctx, AV_LOG_INFO, "]");
791  }
792  av_log(ctx, AV_LOG_INFO, "\n");
793 
794  for (i = 0; i < frame->nb_side_data; i++) {
795  AVFrameSideData *sd = frame->side_data[i];
796  const char *name = av_frame_side_data_name(sd->type);
797 
798  av_log(ctx, AV_LOG_INFO, " side data - ");
799  if (name)
800  av_log(ctx, AV_LOG_INFO, "%s: ", name);
801  switch (sd->type) {
802  case AV_FRAME_DATA_SPHERICAL:
803  dump_spherical(ctx, frame, sd);
804  break;
805  case AV_FRAME_DATA_STEREO3D:
806  dump_stereo3d(ctx, sd);
807  break;
808  case AV_FRAME_DATA_S12M_TIMECODE: {
809  dump_s12m_timecode(ctx, inlink->frame_rate, sd);
810  break;
811  }
812  case AV_FRAME_DATA_DISPLAYMATRIX:
813  av_log(ctx, AV_LOG_INFO, "rotation of %.2f degrees",
814  av_display_rotation_get((int32_t *)sd->data));
815  break;
816  case AV_FRAME_DATA_AFD:
817  av_log(ctx, AV_LOG_INFO, "value of %"PRIu8, sd->data[0]);
818  break;
819  case AV_FRAME_DATA_REGIONS_OF_INTEREST:
820  dump_roi(ctx, sd);
821  break;
822  case AV_FRAME_DATA_DETECTION_BBOXES:
823  dump_detection_bbox(ctx, sd);
824  break;
825  case AV_FRAME_DATA_MASTERING_DISPLAY_METADATA:
826  dump_mastering_display(ctx, sd);
827  break;
828  case AV_FRAME_DATA_DYNAMIC_HDR_PLUS:
829  dump_dynamic_hdr_plus(ctx, sd);
830  break;
831  case AV_FRAME_DATA_DYNAMIC_HDR_VIVID:
832  dump_dynamic_hdr_vivid(ctx, sd);
833  break;
834  case AV_FRAME_DATA_CONTENT_LIGHT_LEVEL:
835  dump_content_light_metadata(ctx, sd);
836  break;
837  case AV_FRAME_DATA_GOP_TIMECODE: {
838  char tcbuf[AV_TIMECODE_STR_SIZE];
839  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
840  av_log(ctx, AV_LOG_INFO, "%s", tcbuf);
841  break;
842  }
843  case AV_FRAME_DATA_VIDEO_ENC_PARAMS:
844  dump_video_enc_params(ctx, sd);
845  break;
846  case AV_FRAME_DATA_SEI_UNREGISTERED:
847  dump_sei_unregistered_metadata(ctx, sd);
848  break;
849  case AV_FRAME_DATA_FILM_GRAIN_PARAMS:
850  dump_sei_film_grain_params_metadata(ctx, sd);
851  break;
852  case AV_FRAME_DATA_DOVI_METADATA:
853  dump_dovi_metadata(ctx, sd);
854  break;
855  case AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT:
856  dump_ambient_viewing_environment(ctx, sd);
857  break;
858  default:
859  if (name)
860  av_log(ctx, AV_LOG_INFO,
861  "(%"SIZE_SPECIFIER" bytes)", sd->size);
862  else
863  av_log(ctx, AV_LOG_WARNING, "unknown side data type %d "
864  "(%"SIZE_SPECIFIER" bytes)", sd->type, sd->size);
865  break;
866  }
867 
868  av_log(ctx, AV_LOG_INFO, "\n");
869  }
870 
871  dump_color_property(ctx, frame);
872 
873  return ff_filter_frame(inlink->dst->outputs[0], frame);
874 }
875 
876 static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
877 {
878 
879  av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
880  is_out ? "out" : "in",
881  link->time_base.num, link->time_base.den,
882  link->frame_rate.num, link->frame_rate.den);
883 
884  return 0;
885 }
886 
887 static int config_props_in(AVFilterLink *link)
888 {
889  AVFilterContext *ctx = link->dst;
890  return config_props(ctx, link, 0);
891 }
892 
893 static int config_props_out(AVFilterLink *link)
894 {
895  AVFilterContext *ctx = link->src;
896  return config_props(ctx, link, 1);
897 }
898 
899 static const AVFilterPad avfilter_vf_showinfo_inputs[] = {
900  {
901  .name = "default",
902  .type = AVMEDIA_TYPE_VIDEO,
903  .filter_frame = filter_frame,
904  .config_props = config_props_in,
905  },
906 };
907 
908 static const AVFilterPad avfilter_vf_showinfo_outputs[] = {
909  {
910  .name = "default",
911  .type = AVMEDIA_TYPE_VIDEO,
912  .config_props = config_props_out,
913  },
914 };
915 
916 const AVFilter ff_vf_showinfo = {
917  .name = "showinfo",
918  .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
919  FILTER_INPUTS(avfilter_vf_showinfo_inputs),
920  FILTER_OUTPUTS(avfilter_vf_showinfo_outputs),
921  .priv_size = sizeof(ShowInfoContext),
922  .priv_class = &showinfo_class,
923  .flags = AVFILTER_FLAG_METADATA_ONLY,
924 };
AVVideoEncParams::qp
int32_t qp
Base quantisation parameter for the frame.
Definition: video_enc_params.h:103
AVHDRVividColorTransformParams::maximum_maxrgb
AVRational maximum_maxrgb
Indicates the maximum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:260
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
dump_detection_bbox
static void dump_detection_bbox(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:154
AVHDRPlusColorTransformParams::average_maxrgb
AVRational average_maxrgb
The average of linearized maxRGB values in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:164
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
AVDynamicHDRPlus::params
AVHDRPlusColorTransformParams params[3]
The color transform parameters for every processing window.
Definition: hdr_dynamic_metadata.h:264
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
AVDOVIDataMapping::nlq_method_idc
enum AVDOVINLQMethod nlq_method_idc
Definition: dovi_meta.h:150
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
AVHDRVividColorToneMappingParams::base_param_k2
int base_param_k2
indicates k2_0 in the base parameter, base_param_k2 <= 1: k2_0 = base_param_k2 base_param_k2 > 1: res...
Definition: hdr_dynamic_vivid_metadata.h:137
dump_spherical
static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, const AVFrameSideData *sd)
Definition: vf_showinfo.c:71
r
const char * r
Definition: vf_curves.c:127
opt.h
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:98
AVHDRVividColorToneMappingParams::base_param_Delta
AVRational base_param_Delta
base_param_Delta in the base parameter, in multiples of 1.0/127.
Definition: hdr_dynamic_vivid_metadata.h:157
AVHDRVividColorToneMappingParams::base_enable_flag
int base_enable_flag
This flag indicates that transfer the base paramter(for value of 1)
Definition: hdr_dynamic_vivid_metadata.h:88
color
Definition: vf_paletteuse.c:512
update_sample_stats
static void update_sample_stats(int depth, int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
Definition: vf_showinfo.c:719
AVHDRPlusColorTransformParams::rotation_angle
uint8_t rotation_angle
The clockwise rotation angle in degree of arc with respect to the positive direction of the x-axis of...
Definition: hdr_dynamic_metadata.h:118
AVHDRPlusPercentile::percentile
AVRational percentile
The linearized maxRGB value at a specific percentile in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:52
AVAmbientViewingEnvironment
Ambient viewing environment metadata as defined by H.274.
Definition: ambient_viewing_environment.h:36
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
AV_UUID_ARG
#define AV_UUID_ARG(x)
Definition: uuid.h:51
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
src1
const pixel * src1
Definition: h264pred_template.c:421
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
AVHDRVividColorToneMappingParams::three_Spline_num
int three_Spline_num
The number of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:169
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:208
config_props_out
static int config_props_out(AVFilterLink *link)
Definition: vf_showinfo.c:893
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
AVFilmGrainAOMParams::uv_points
uint8_t uv_points[2][10][2]
Definition: film_grain_params.h:63
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:188
AVHDRPlusColorTransformParams::semimajor_axis_external_ellipse
uint16_t semimajor_axis_external_ellipse
The semi-major axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:134
AVFilmGrainH274Params::blending_mode_id
int blending_mode_id
Specifies the blending mode used to blend the simulated film grain with the decoded images.
Definition: film_grain_params.h:182
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
AVHDRVividColorTransformParams::tone_mapping_param_num
int tone_mapping_param_num
The number of tone mapping param.
Definition: hdr_dynamic_vivid_metadata.h:272
AVHDRPlusColorTransformParams
Color transform parameters at a processing window in a dynamic metadata for SMPTE 2094-40.
Definition: hdr_dynamic_metadata.h:59
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
avfilter_vf_showinfo_inputs
static const AVFilterPad avfilter_vf_showinfo_inputs[]
Definition: vf_showinfo.c:899
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
AVHDRVividColorTransformParams::variance_maxrgb
AVRational variance_maxrgb
Indicates the variance brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:253
AVDOVIReshapingCurve::mmr_coef
int64_t mmr_coef[AV_DOVI_MAX_PIECES][3][7]
Definition: dovi_meta.h:118
AVDynamicHDRPlus::num_cols_targeted_system_display_actual_peak_luminance
uint8_t num_cols_targeted_system_display_actual_peak_luminance
The number of columns in the targeted_system_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:290
av_spherical_tile_bounds
void av_spherical_tile_bounds(const AVSphericalMapping *map, size_t width, size_t height, size_t *left, size_t *top, size_t *right, size_t *bottom)
Convert the bounding fields from an AVSphericalVideo from 0.32 fixed point to pixels.
Definition: spherical.c:40
AVAmbientViewingEnvironment::ambient_light_x
AVRational ambient_light_x
Normalized x chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
Definition: ambient_viewing_environment.h:47
AVHDRVivid3SplineParams::enable_strength
AVRational enable_strength
3Spline_enable_Strength of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:70
bitdepth
#define bitdepth
Definition: aom_film_grain_template.c:67
AVOption
AVOption.
Definition: opt.h:357
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
spherical.h
data
const char data[16]
Definition: mxf.c:148
AVDOVIReshapingCurve::mapping_idc
enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:111
AVHDRPlusColorTransformParams::tone_mapping_flag
uint8_t tone_mapping_flag
This flag indicates that the metadata for the tone mapping function in the processing window is prese...
Definition: hdr_dynamic_metadata.h:189
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:85
AV_SPHERICAL_EQUIRECTANGULAR_TILE
@ AV_SPHERICAL_EQUIRECTANGULAR_TILE
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:68
AVStereo3D::baseline
uint32_t baseline
The distance between the centres of the lenses of the camera system, in micrometers.
Definition: stereo3d.h:228
AVHDRVivid3SplineParams::th_mode
int th_mode
The mode of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:35
AVHDRPlusColorTransformParams::distribution_maxrgb
AVHDRPlusPercentile distribution_maxrgb[15]
The linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:176
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
AVDOVIDataMapping::mapping_color_space
uint8_t mapping_color_space
Definition: dovi_meta.h:145
AVDOVIRpuDataHeader
Dolby Vision RPU data header.
Definition: dovi_meta.h:78
AVHDRPlusColorTransformParams::knee_point_x
AVRational knee_point_x
The x coordinate of the separation point between the linear part and the curved part of the tone mapp...
Definition: hdr_dynamic_metadata.h:196
AVHDRVividColorTransformParams::color_saturation_num
int color_saturation_num
The number of color saturation param.
Definition: hdr_dynamic_vivid_metadata.h:289
dump_color_property
static void dump_color_property(AVFilterContext *ctx, AVFrame *frame)
Definition: vf_showinfo.c:660
AVDetectionBBox::y
int y
Definition: detection_bbox.h:32
video.h
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3362
OFFSET
#define OFFSET(x)
Definition: vf_showinfo.c:59
hdr_dynamic_vivid_metadata.h
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:638
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
AVStereo3D::horizontal_field_of_view
AVRational horizontal_field_of_view
Horizontal field of view, in degrees.
Definition: stereo3d.h:239
AVHDRPlusColorTransformParams::color_saturation_mapping_flag
uint8_t color_saturation_mapping_flag
This flag shall be equal to 0 in bitstreams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:222
AVHDRVividColorToneMappingParams::three_Spline_enable_flag
int three_Spline_enable_flag
indicates 3Spline_enable_flag in the base parameter, This flag indicates that transfer three Spline o...
Definition: hdr_dynamic_vivid_metadata.h:163
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:3341
AVDetectionBBox::detect_label
char detect_label[AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE]
Detect result with confidence.
Definition: detection_bbox.h:41
AVHDRPlusColorTransformParams::center_of_ellipse_x
uint16_t center_of_ellipse_x
The x coordinate of the center position of the concentric internal and external ellipses of the ellip...
Definition: hdr_dynamic_metadata.h:102
AVVideoEncParams::delta_qp
int32_t delta_qp[4][2]
Quantisation parameter offset from the base (per-frame) qp for a given plane (first index) and AC/DC ...
Definition: video_enc_params.h:109
AVHDRVividColorTransformParams::tm_params
AVHDRVividColorToneMappingParams tm_params[2]
The color tone mapping parameters.
Definition: hdr_dynamic_vivid_metadata.h:277
AVFilmGrainAOMParams::grain_scale_shift
int grain_scale_shift
Signals the down shift applied to the generated gaussian numbers during synthesis.
Definition: film_grain_params.h:99
AVHDRVivid3SplineParams::th_delta1
AVRational th_delta1
3Spline_TH_Delta1 of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:56
timecode.h
AVDynamicHDRVivid::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_vivid_metadata.h:320
dump_s12m_timecode
static void dump_s12m_timecode(AVFilterContext *ctx, AVRational frame_rate, const AVFrameSideData *sd)
Definition: vf_showinfo.c:117
AVFilmGrainAOMParams::limit_output_range
int limit_output_range
Signals to clip to limited color levels after film grain application.
Definition: film_grain_params.h:122
AVAmbientViewingEnvironment::ambient_illuminance
AVRational ambient_illuminance
Environmental illuminance of the ambient viewing environment in lux.
Definition: ambient_viewing_environment.h:40
AVFilmGrainAOMParams::num_y_points
int num_y_points
Number of points, and the scale and value for each point of the piecewise linear scaling function for...
Definition: film_grain_params.h:49
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVVideoEncParams
Video encoding parameters for a given frame.
Definition: video_enc_params.h:73
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(showinfo)
AVHDRPlusColorTransformParams::knee_point_y
AVRational knee_point_y
The y coordinate of the separation point between the linear part and the curved part of the tone mapp...
Definition: hdr_dynamic_metadata.h:203
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
AVFilmGrainAOMParams
This structure describes how to handle film grain synthesis for AOM codecs.
Definition: film_grain_params.h:44
AVHDRPlusColorTransformParams::num_bezier_curve_anchors
uint8_t num_bezier_curve_anchors
The number of the intermediate anchor parameters of the tone mapping function in the processing windo...
Definition: hdr_dynamic_metadata.h:209
av_stereo3d_view_name
const char * av_stereo3d_view_name(unsigned int view)
Provide a human-readable name of a given stereo3d view.
Definition: stereo3d.c:113
AVFilmGrainH274Params::intensity_interval_upper_bound
uint8_t intensity_interval_upper_bound[3][256]
Specifies the upper bound of each intensity interval for which the set of model values applies for th...
Definition: film_grain_params.h:216
av_get_detection_bbox
static av_always_inline AVDetectionBBox * av_get_detection_bbox(const AVDetectionBBoxHeader *header, unsigned int idx)
Definition: detection_bbox.h:84
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
film_grain_params.h
AVFrameSideData::size
size_t size
Definition: frame.h:253
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
config_props_in
static int config_props_in(AVFilterLink *link)
Definition: vf_showinfo.c:887
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:300
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
width
#define width
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_showinfo.c:727
AVDOVIMetadata
Combined struct representing a combination of header, mapping and color metadata, for attaching to fr...
Definition: dovi_meta.h:326
stereo3d.h
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVDOVIReshapingCurve::mmr_order
uint8_t mmr_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:116
AVHDRPlusColorTransformParams::semiminor_axis_external_ellipse
uint16_t semiminor_axis_external_ellipse
The semi-minor axis value of the external ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:141
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:316
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AVHDRPlusColorTransformParams::window_upper_left_corner_y
AVRational window_upper_left_corner_y
The relative y coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:76
AVDetectionBBox::classify_confidences
AVRational classify_confidences[AV_NUM_DETECTION_BBOX_CLASSIFY]
Definition: detection_bbox.h:53
AVHDRPlusColorTransformParams::window_lower_right_corner_x
AVRational window_lower_right_corner_x
The relative x coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:85
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AVDynamicHDRPlus::targeted_system_display_maximum_luminance
AVRational targeted_system_display_maximum_luminance
The nominal maximum display luminance of the targeted system display, in units of 0....
Definition: hdr_dynamic_metadata.h:271
VF
#define VF
Definition: vf_showinfo.c:60
AVDynamicHDRPlus::mastering_display_actual_peak_luminance_flag
uint8_t mastering_display_actual_peak_luminance_flag
This flag shall be equal to 0 in bitstreams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:303
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AVVideoEncParams::type
enum AVVideoEncParamsType type
Type of the parameters (the codec they are used with).
Definition: video_enc_params.h:95
dump_dovi_metadata
static void dump_dovi_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:546
AVFilmGrainH274Params::comp_model_value
int16_t comp_model_value[3][256][6]
Specifies the model values for the component for each intensity interval.
Definition: film_grain_params.h:227
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AV_FILM_GRAIN_PARAMS_NONE
@ AV_FILM_GRAIN_PARAMS_NONE
Definition: film_grain_params.h:25
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
av_dovi_get_header
static av_always_inline AVDOVIRpuDataHeader * av_dovi_get_header(const AVDOVIMetadata *data)
Definition: dovi_meta.h:344
dump_mastering_display
static void dump_mastering_display(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:178
AVDOVIReshapingCurve::poly_order
uint8_t poly_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:113
AV_FRAME_DATA_DYNAMIC_HDR_VIVID
@ AV_FRAME_DATA_DYNAMIC_HDR_VIVID
HDR Vivid dynamic metadata associated with a video frame.
Definition: frame.h:215
link
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
Definition: filter_design.txt:23
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:212
AVHDRPlusPercentile::percentage
uint8_t percentage
The percentage value corresponding to a specific percentile linearized RGB value in the processing wi...
Definition: hdr_dynamic_metadata.h:45
if
if(ret)
Definition: filter_design.txt:179
AVFilmGrainH274Params::model_id
int model_id
Specifies the film grain simulation mode.
Definition: film_grain_params.h:137
AVDOVINLQParams::linear_deadzone_threshold
uint64_t linear_deadzone_threshold
Definition: dovi_meta.h:135
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:3281
AVFilmGrainAOMParams::uv_mult_luma
int uv_mult_luma[2]
Definition: film_grain_params.h:106
config_props
static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
Definition: vf_showinfo.c:876
AVDynamicHDRPlus::application_version
uint8_t application_version
Application version in the application defining document in ST-2094 suite.
Definition: hdr_dynamic_metadata.h:253
AV_FRAME_DATA_SPHERICAL
@ AV_FRAME_DATA_SPHERICAL
The data represents the AVSphericalMapping structure defined in libavutil/spherical....
Definition: frame.h:131
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
ff_vf_showinfo
const AVFilter ff_vf_showinfo
Definition: vf_showinfo.c:916
AVHDRVividColorTransformParams::color_saturation_gain
AVRational color_saturation_gain[8]
Indicates the color correction strength parameter.
Definition: hdr_dynamic_vivid_metadata.h:296
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
dump_roi
static void dump_roi(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:133
AVDetectionBBox::classify_labels
char classify_labels[AV_NUM_DETECTION_BBOX_CLASSIFY][AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE]
Definition: detection_bbox.h:52
AVDetectionBBoxHeader
Definition: detection_bbox.h:56
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:305
AVStereo3D::horizontal_disparity_adjustment
AVRational horizontal_disparity_adjustment
Relative shift of the left and right images, which changes the zero parallax plane.
Definition: stereo3d.h:234
AVDynamicHDRVivid
This struct represents dynamic metadata for color volume transform - CUVA 005.1:2021 standard.
Definition: hdr_dynamic_vivid_metadata.h:310
dump_ambient_viewing_environment
static void dump_ambient_viewing_environment(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:649
AVHDRVividColorTransformParams::color_saturation_mapping_flag
int color_saturation_mapping_flag
This flag indicates that the metadata for the color saturation mapping in the processing window is pr...
Definition: hdr_dynamic_vivid_metadata.h:283
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:3299
adler32.h
ShowInfoContext::calculate_checksums
int calculate_checksums
Definition: vf_showinfo.c:55
AVHDRPlusColorTransformParams::fraction_bright_pixels
AVRational fraction_bright_pixels
The fraction of selected pixels in the image that contains the brightest pixel in the scene.
Definition: hdr_dynamic_metadata.h:183
double
double
Definition: af_crystalizer.c:131
dump_video_enc_params
static void dump_video_enc_params(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:394
dump_sei_unregistered_metadata
static void dump_sei_unregistered_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:413
AVDOVIReshapingCurve::mmr_constant
int64_t mmr_constant[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:117
AVHDRPlusColorTransformParams::color_saturation_weight
AVRational color_saturation_weight
The color saturation gain in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:229
AVHDRVividColorTransformParams::tone_mapping_mode_flag
int tone_mapping_mode_flag
This flag indicates that the metadata for the tone mapping function in the processing window is prese...
Definition: hdr_dynamic_vivid_metadata.h:266
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:90
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_FRAME_DATA_SEI_UNREGISTERED
@ AV_FRAME_DATA_SEI_UNREGISTERED
User data unregistered metadata associated with a video frame.
Definition: frame.h:178
av_adler32_update
AVAdler av_adler32_update(AVAdler adler, const uint8_t *buf, size_t len)
Calculate the Adler32 checksum of a buffer.
Definition: adler32.c:44
AVStereo3D::primary_eye
enum AVStereo3DPrimaryEye primary_eye
Which eye is the primary eye when rendering in 2D.
Definition: stereo3d.h:222
AVFilmGrainAOMParams::num_uv_points
int num_uv_points[2]
If chroma_scaling_from_luma is set to 0, signals the chroma scaling function parameters.
Definition: film_grain_params.h:62
AV_UUID_LEN
#define AV_UUID_LEN
Definition: uuid.h:57
av_spherical_projection_name
const char * av_spherical_projection_name(enum AVSphericalProjection projection)
Provide a human-readable name of a given AVSphericalProjection.
Definition: spherical.c:67
AV_SPHERICAL_CUBEMAP
@ AV_SPHERICAL_CUBEMAP
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:61
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:83
AVDynamicHDRPlus::num_rows_mastering_display_actual_peak_luminance
uint8_t num_rows_mastering_display_actual_peak_luminance
The number of rows in the mastering_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:309
dump_dynamic_hdr_plus
static void dump_dynamic_hdr_plus(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:203
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: frame.h:220
AVDetectionBBox::w
int w
Definition: detection_bbox.h:33
AVFilmGrainH274Params::component_model_present
int component_model_present[3]
Indicates if the modelling of film grain for a given component is present.
Definition: film_grain_params.h:192
AV_DOVI_NLQ_LINEAR_DZ
@ AV_DOVI_NLQ_LINEAR_DZ
Definition: dovi_meta.h:123
AVDynamicHDRPlus::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_metadata.h:259
av_stereo3d_primary_eye_name
const char * av_stereo3d_primary_eye_name(unsigned int eye)
Provide a human-readable name of a given stereo3d primary eye.
Definition: stereo3d.c:133
uuid.h
showinfo_options
static const AVOption showinfo_options[]
Definition: vf_showinfo.c:62
AVHDRVividColorTransformParams::average_maxrgb
AVRational average_maxrgb
Indicates the average brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:246
AVDynamicHDRPlus::mastering_display_actual_peak_luminance
AVRational mastering_display_actual_peak_luminance[25][25]
The normalized actual peak luminance of the mastering display used for mastering the image essence.
Definition: hdr_dynamic_metadata.h:322
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:501
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:238
user_data
static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)
Definition: cbs_mpeg2_syntax_template.c:59
AVVideoEncParams::nb_blocks
unsigned int nb_blocks
Number of blocks in the array.
Definition: video_enc_params.h:81
AVHDRPlusColorTransformParams::window_lower_right_corner_y
AVRational window_lower_right_corner_y
The relative y coordinate of the bottom right pixel of the processing window.
Definition: hdr_dynamic_metadata.h:94
header
static const uint8_t header[24]
Definition: sdr2.c:68
AVHDRVividColorToneMappingParams::base_param_k1
int base_param_k1
indicates k1_0 in the base parameter, base_param_k1 <= 1: k1_0 = base_param_k1 base_param_k1 > 1: res...
Definition: hdr_dynamic_vivid_metadata.h:130
AVDetectionBBox::classify_count
uint32_t classify_count
Definition: detection_bbox.h:51
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:194
AVDOVIReshapingCurve::poly_coef
int64_t poly_coef[AV_DOVI_MAX_PIECES][3]
Definition: dovi_meta.h:114
AVRegionOfInterest::right
int right
Definition: frame.h:318
dump_sei_film_grain_params_metadata
static void dump_sei_film_grain_params_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:437
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:194
AVFilmGrainAOMParams::ar_coeffs_y
int8_t ar_coeffs_y[24]
Luma auto-regression coefficients.
Definition: film_grain_params.h:80
update_sample_stats_16
static void update_sample_stats_16(int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
Definition: vf_showinfo.c:703
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVDynamicHDRPlus::num_rows_targeted_system_display_actual_peak_luminance
uint8_t num_rows_targeted_system_display_actual_peak_luminance
The number of rows in the targeted system_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:283
internal.h
AVHDRPlusColorTransformParams::window_upper_left_corner_x
AVRational window_upper_left_corner_x
The relative x coordinate of the top left pixel of the processing window.
Definition: hdr_dynamic_metadata.h:67
AV_PRI_UUID
#define AV_PRI_UUID
Definition: uuid.h:39
av_image_get_linesize
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
Compute the size of an image line with format pix_fmt and width width for the plane plane.
Definition: imgutils.c:76
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
AVRegionOfInterest::left
int left
Definition: frame.h:317
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
AVHDRPlusColorTransformParams::semimajor_axis_internal_ellipse
uint16_t semimajor_axis_internal_ellipse
The semi-major axis value of the internal ellipse of the elliptical pixel selector in amount of pixel...
Definition: hdr_dynamic_metadata.h:125
AVSphericalMapping::roll
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:140
dump_content_light_metadata
static void dump_content_light_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:385
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:138
AVFilmGrainH274Params
This structure describes how to handle film grain synthesis for codecs using the ITU-T H....
Definition: film_grain_params.h:132
AVRegionOfInterest::top
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Definition: frame.h:315
internal.h
AVHDRVividColorToneMappingParams::targeted_system_display_maximum_luminance
AVRational targeted_system_display_maximum_luminance
The nominal maximum display luminance of the targeted system display, in multiples of 1....
Definition: hdr_dynamic_vivid_metadata.h:83
AVFilmGrainH274Params::num_intensity_intervals
uint16_t num_intensity_intervals[3]
Specifies the number of intensity intervals for which a specific set of model values has been estimat...
Definition: film_grain_params.h:198
display.h
AVDOVIDataMapping::num_y_partitions
uint32_t num_y_partitions
Definition: dovi_meta.h:152
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
AVHDRPlusColorTransformParams::overlap_process_option
enum AVHDRPlusOverlapProcessOption overlap_process_option
Overlap process option indicates one of the two methods of combining rendered pixels in the processin...
Definition: hdr_dynamic_metadata.h:149
AVHDRVividColorTransformParams
Color transform parameters at a processing window in a dynamic metadata for CUVA 005....
Definition: hdr_dynamic_vivid_metadata.h:233
AVFilmGrainAOMParams::scaling_shift
int scaling_shift
Specifies the shift applied to the chroma components.
Definition: film_grain_params.h:69
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
AVDOVINLQParams
Coefficients of the non-linear inverse quantization.
Definition: dovi_meta.h:130
AVHDRVividColorToneMappingParams::base_param_Delta_enable_mode
int base_param_Delta_enable_mode
This flag indicates that delta mode of base paramter(for value of 1)
Definition: hdr_dynamic_vivid_metadata.h:150
ambient_viewing_environment.h
avfilter_vf_showinfo_outputs
static const AVFilterPad avfilter_vf_showinfo_outputs[]
Definition: vf_showinfo.c:908
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
AVFilmGrainH274Params::intensity_interval_lower_bound
uint8_t intensity_interval_lower_bound[3][256]
Specifies the lower ounds of each intensity interval for whichthe set of model values applies for the...
Definition: film_grain_params.h:210
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
AVDOVIDataMapping::curves
AVDOVIReshapingCurve curves[3]
Definition: dovi_meta.h:147
AVDOVINLQParams::linear_deadzone_slope
uint64_t linear_deadzone_slope
Definition: dovi_meta.h:134
AVFilter
Filter definition.
Definition: avfilter.h:166
AVDOVIReshapingCurve
Definition: dovi_meta.h:108
bswap.h
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:125
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVSphericalMapping::pitch
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:139
AVDOVINLQParams::vdr_in_max
uint64_t vdr_in_max
Definition: dovi_meta.h:132
ShowInfoContext::udu_sei_as_ascii
int udu_sei_as_ascii
Definition: vf_showinfo.c:56
AVDetectionBBox::h
int h
Definition: detection_bbox.h:34
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
dump_stereo3d
static void dump_stereo3d(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:97
AVHDRVivid3SplineParams
HDR Vivid three spline params.
Definition: hdr_dynamic_vivid_metadata.h:30
dovi_meta.h
AVHDRVividColorTransformParams::minimum_maxrgb
AVRational minimum_maxrgb
Indicates the minimum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:239
AVDetectionBBox::detect_confidence
AVRational detect_confidence
Definition: detection_bbox.h:42
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
AVDOVIReshapingCurve::num_pivots
uint8_t num_pivots
Definition: dovi_meta.h:109
av_dovi_get_color
static av_always_inline AVDOVIColorMetadata * av_dovi_get_color(const AVDOVIMetadata *data)
Definition: dovi_meta.h:356
AVHDRVividColorToneMappingParams::base_param_m_n
AVRational base_param_m_n
base_param_m_n in the base parameter, in multiples of 1.0/10.
Definition: hdr_dynamic_vivid_metadata.h:123
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:159
AVHDRVividColorToneMappingParams::base_param_m_a
AVRational base_param_m_a
base_param_m_a in the base parameter, in multiples of 1.0/1023.
Definition: hdr_dynamic_vivid_metadata.h:109
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition: timecode.c:167
AVFilmGrainAOMParams::ar_coeff_lag
int ar_coeff_lag
Specifies the auto-regression lag.
Definition: film_grain_params.h:74
AVDOVIDataMapping::mapping_chroma_format_idc
uint8_t mapping_chroma_format_idc
Definition: dovi_meta.h:146
AV_FILM_GRAIN_PARAMS_H274
@ AV_FILM_GRAIN_PARAMS_H274
The union is valid when interpreted as AVFilmGrainH274Params (codec.h274)
Definition: film_grain_params.h:35
AVDynamicHDRPlus::targeted_system_display_actual_peak_luminance_flag
uint8_t targeted_system_display_actual_peak_luminance_flag
This flag shall be equal to 0 in bit streams conforming to this version of this Specification.
Definition: hdr_dynamic_metadata.h:277
AVFilmGrainAOMParams::y_points
uint8_t y_points[14][2]
Definition: film_grain_params.h:50
AVFilmGrainAOMParams::uv_offset
int uv_offset[2]
Offset used for component scaling function.
Definition: film_grain_params.h:112
update_sample_stats_8
static void update_sample_stats_8(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
Definition: vf_showinfo.c:693
AV_FRAME_DATA_VIDEO_ENC_PARAMS
@ AV_FRAME_DATA_VIDEO_ENC_PARAMS
Encoding parameters for a video frame, as described by AVVideoEncParams.
Definition: frame.h:170
AVRational::den
int den
Denominator.
Definition: rational.h:60
avfilter.h
AVHDRVivid3SplineParams::th_enable
AVRational th_enable
3Spline_TH_enable of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:49
ShowInfoContext
Definition: vf_showinfo.c:53
AVHDRPlusColorTransformParams::num_distribution_maxrgb_percentiles
uint8_t num_distribution_maxrgb_percentiles
The number of linearized maxRGB values at given percentiles in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:170
AVHDRPlusColorTransformParams::maxscl
AVRational maxscl[3]
The maximum of the color components of linearized RGB values in the processing window in the scene.
Definition: hdr_dynamic_metadata.h:157
AVFILTER_FLAG_METADATA_ONLY
#define AVFILTER_FLAG_METADATA_ONLY
The filter is a "metadata" filter - it does not modify the frame data in any way.
Definition: avfilter.h:133
AVDetectionBBox::x
int x
Distance in pixels from the left/top edge of the frame, together with width and height,...
Definition: detection_bbox.h:31
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:251
AVDOVIColorMetadata
Dolby Vision RPU colorspace metadata parameters.
Definition: dovi_meta.h:162
AVFilmGrainH274Params::log2_scale_factor
int log2_scale_factor
Specifies a scale factor used in the film grain characterization equations.
Definition: film_grain_params.h:187
AVFilmGrainAOMParams::uv_mult
int uv_mult[2]
Specifies the luma/chroma multipliers for the index to the component scaling function.
Definition: film_grain_params.h:105
hdr_dynamic_metadata.h
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
AVHDRVividColorToneMappingParams
Color tone mapping parameters at a processing window in a dynamic metadata for CUVA 005....
Definition: hdr_dynamic_vivid_metadata.h:77
AVFilmGrainH274Params::num_model_values
uint8_t num_model_values[3]
Specifies the number of model values present for each intensity interval in which the film grain has ...
Definition: film_grain_params.h:204
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
AVFilmGrainAOMParams::overlap_flag
int overlap_flag
Signals whether to overlap film grain blocks.
Definition: film_grain_params.h:117
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVHDRPlusColorTransformParams::center_of_ellipse_y
uint16_t center_of_ellipse_y
The y coordinate of the center position of the concentric internal and external ellipses of the ellip...
Definition: hdr_dynamic_metadata.h:110
mastering_display_metadata.h
av_dovi_get_mapping
static av_always_inline AVDOVIDataMapping * av_dovi_get_mapping(const AVDOVIMetadata *data)
Definition: dovi_meta.h:350
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
AVDynamicHDRVivid::params
AVHDRVividColorTransformParams params[3]
The color transform parameters for every processing window.
Definition: hdr_dynamic_vivid_metadata.h:325
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
dump_dynamic_hdr_vivid
static void dump_dynamic_hdr_vivid(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:302
AVStereo3D::view
enum AVStereo3DView view
Determines which views are packed.
Definition: stereo3d.h:217
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVDOVIReshapingCurve::pivots
uint16_t pivots[AV_DOVI_MAX_PIECES+1]
Definition: dovi_meta.h:110
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVDynamicHDRPlus::targeted_system_display_actual_peak_luminance
AVRational targeted_system_display_actual_peak_luminance[25][25]
The normalized actual peak luminance of the targeted system display.
Definition: hdr_dynamic_metadata.h:297
av_frame_side_data_name
const char * av_frame_side_data_name(enum AVFrameSideDataType type)
Definition: frame.c:1026
int32_t
int32_t
Definition: audioconvert.c:56
AV_FRAME_DATA_REGIONS_OF_INTEREST
@ AV_FRAME_DATA_REGIONS_OF_INTEREST
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:165
imgutils.h
AVDOVINLQParams::nlq_offset
uint16_t nlq_offset
Definition: dovi_meta.h:131
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVDOVIDataMapping::vdr_rpu_id
uint8_t vdr_rpu_id
Definition: dovi_meta.h:144
AVDynamicHDRVivid::system_start_code
uint8_t system_start_code
The system start code.
Definition: hdr_dynamic_vivid_metadata.h:314
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVDetectionBBox
Definition: detection_bbox.h:26
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
AVHDRVividColorToneMappingParams::base_param_k3
int base_param_k3
indicates k3_0 in the base parameter, base_param_k3 == 1: k3_0 = base_param_k3 base_param_k3 == 2: k3...
Definition: hdr_dynamic_vivid_metadata.h:145
av_stereo3d_type_name
const char * av_stereo3d_type_name(unsigned int type)
Provide a human-readable name of a given stereo3d type.
Definition: stereo3d.c:93
h
h
Definition: vp9dsp_template.c:2038
AVHDRVivid3SplineParams::th_delta2
AVRational th_delta2
3Spline_TH_Delta2 of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:63
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
AVHDRVivid3SplineParams::th_enable_mb
AVRational th_enable_mb
three_Spline_TH_enable_MB is in the range of 0.0 to 1.0, inclusive and in multiples of 1....
Definition: hdr_dynamic_vivid_metadata.h:42
AVAmbientViewingEnvironment::ambient_light_y
AVRational ambient_light_y
Normalized y chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
Definition: ambient_viewing_environment.h:54
AVFilmGrainAOMParams::chroma_scaling_from_luma
int chroma_scaling_from_luma
Signals whether to derive the chroma scaling function from the luma.
Definition: film_grain_params.h:56
av_bswap16
#define av_bswap16
Definition: bswap.h:28
AV_FILM_GRAIN_PARAMS_AV1
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
Definition: film_grain_params.h:30
AVHDRVividColorToneMappingParams::three_spline
AVHDRVivid3SplineParams three_spline[2]
Definition: hdr_dynamic_vivid_metadata.h:225
AVHDRVividColorToneMappingParams::base_param_m_p
AVRational base_param_m_p
base_param_m_p in the base parameter, in multiples of 1.0/16383.
Definition: hdr_dynamic_vivid_metadata.h:95
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:342
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:153
AVDOVIDataMapping
Dolby Vision RPU data mapping parameters.
Definition: dovi_meta.h:143
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:94
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3320
detection_bbox.h
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:138
AVHDRVividColorToneMappingParams::base_param_m_b
AVRational base_param_m_b
base_param_m_b in the base parameter, in multiples of 1/1023.
Definition: hdr_dynamic_vivid_metadata.h:116
AV_FRAME_DATA_DETECTION_BBOXES
@ AV_FRAME_DATA_DETECTION_BBOXES
Bounding boxes for object detection and classification, as described by AVDetectionBBoxHeader.
Definition: frame.h:194
AVHDRVividColorToneMappingParams::base_param_m_m
AVRational base_param_m_m
base_param_m_m in the base parameter, in multiples of 1.0/10.
Definition: hdr_dynamic_vivid_metadata.h:102
AVHDRPlusColorTransformParams::bezier_curve_anchors
AVRational bezier_curve_anchors[15]
The intermediate anchor parameters of the tone mapping function in the processing window in the scene...
Definition: hdr_dynamic_metadata.h:216
video_enc_params.h
AVDynamicHDRPlus::num_cols_mastering_display_actual_peak_luminance
uint8_t num_cols_mastering_display_actual_peak_luminance
The number of columns in the mastering_display_actual_peak_luminance array.
Definition: hdr_dynamic_metadata.h:315
AVDOVIDataMapping::num_x_partitions
uint32_t num_x_partitions
Definition: dovi_meta.h:151
AVFilmGrainAOMParams::ar_coeff_shift
int ar_coeff_shift
Specifies the range of the auto-regressive coefficients.
Definition: film_grain_params.h:93
av_display_rotation_get
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:35
AVFilmGrainAOMParams::ar_coeffs_uv
int8_t ar_coeffs_uv[2][25]
Chroma auto-regression coefficients.
Definition: film_grain_params.h:86
Generated on Sun Jun 30 2024 19:22:35 for FFmpeg by   doxygen 1.8.17