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 <inttypes.h>
26 
27 #include "libavutil/bswap.h"
28 #include "libavutil/adler32.h"
29 #include "libavutil/display.h"
30 #include "libavutil/dovi_meta.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/internal.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/pixdesc.h"
38 #include "libavutil/spherical.h"
39 #include "libavutil/stereo3d.h"
40 #include "libavutil/timestamp.h"
41 #include "libavutil/timecode.h"
45 #include "libavutil/uuid.h"
46 
47 #include "avfilter.h"
48 #include "internal.h"
49 #include "video.h"
50 
51 typedef struct ShowInfoContext {
52  const AVClass *class;
55 
56 #define OFFSET(x) offsetof(ShowInfoContext, x)
57 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
58 
59 static const AVOption showinfo_options[] = {
60  { "checksum", "calculate checksums", OFFSET(calculate_checksums), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, VF },
61  { NULL }
62 };
63 
64 AVFILTER_DEFINE_CLASS(showinfo);
65 
67 {
68  const AVSphericalMapping *spherical = (const AVSphericalMapping *)sd->data;
69  double yaw, pitch, roll;
70 
71  av_log(ctx, AV_LOG_INFO, "spherical information: ");
72  if (sd->size < sizeof(*spherical)) {
73  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
74  return;
75  }
76 
77  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR)
78  av_log(ctx, AV_LOG_INFO, "equirectangular ");
79  else if (spherical->projection == AV_SPHERICAL_CUBEMAP)
80  av_log(ctx, AV_LOG_INFO, "cubemap ");
81  else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE)
82  av_log(ctx, AV_LOG_INFO, "tiled equirectangular ");
83  else {
84  av_log(ctx, AV_LOG_WARNING, "unknown\n");
85  return;
86  }
87 
88  yaw = ((double)spherical->yaw) / (1 << 16);
89  pitch = ((double)spherical->pitch) / (1 << 16);
90  roll = ((double)spherical->roll) / (1 << 16);
91  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
92 
94  size_t l, t, r, b;
95  av_spherical_tile_bounds(spherical, frame->width, frame->height,
96  &l, &t, &r, &b);
99  l, t, r, b);
100  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
101  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
102  }
103 }
104 
106 {
107  const AVStereo3D *stereo;
108 
109  av_log(ctx, AV_LOG_INFO, "stereoscopic information: ");
110  if (sd->size < sizeof(*stereo)) {
111  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
112  return;
113  }
114 
115  stereo = (const AVStereo3D *)sd->data;
116 
117  av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
118 
119  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
120  av_log(ctx, AV_LOG_INFO, " (inverted)");
121 }
122 
124 {
125  const uint32_t *tc = (const uint32_t *)sd->data;
126 
127  if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
128  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
129  return;
130  }
131 
132  for (int j = 1; j <= tc[0]; j++) {
133  char tcbuf[AV_TIMECODE_STR_SIZE];
134  av_timecode_make_smpte_tc_string2(tcbuf, frame_rate, tc[j], 0, 0);
135  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
136  }
137 }
138 
139 static void dump_roi(AVFilterContext *ctx, const AVFrameSideData *sd)
140 {
141  int nb_rois;
142  const AVRegionOfInterest *roi;
143  uint32_t roi_size;
144 
145  roi = (const AVRegionOfInterest *)sd->data;
146  roi_size = roi->self_size;
147  if (!roi_size || sd->size % roi_size != 0) {
148  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
149  return;
150  }
151  nb_rois = sd->size / roi_size;
152 
153  av_log(ctx, AV_LOG_INFO, "Regions Of Interest(ROI) information:\n");
154  for (int i = 0; i < nb_rois; i++) {
155  roi = (const AVRegionOfInterest *)(sd->data + roi_size * i);
156  av_log(ctx, AV_LOG_INFO, "index: %d, region: (%d, %d) -> (%d, %d), qp offset: %d/%d.\n",
157  i, roi->left, roi->top, roi->right, roi->bottom, roi->qoffset.num, roi->qoffset.den);
158  }
159 }
160 
162 {
163  int nb_bboxes;
165  const AVDetectionBBox *bbox;
166 
167  header = (const AVDetectionBBoxHeader *)sd->data;
168  nb_bboxes = header->nb_bboxes;
169  av_log(ctx, AV_LOG_INFO, "detection bounding boxes:\n");
170  av_log(ctx, AV_LOG_INFO, "source: %s\n", header->source);
171 
172  for (int i = 0; i < nb_bboxes; i++) {
173  bbox = av_get_detection_bbox(header, i);
174  av_log(ctx, AV_LOG_INFO, "index: %d,\tregion: (%d, %d) -> (%d, %d), label: %s, confidence: %d/%d.\n",
175  i, bbox->x, bbox->y, bbox->x + bbox->w, bbox->y + bbox->h,
177  if (bbox->classify_count > 0) {
178  for (int j = 0; j < bbox->classify_count; j++) {
179  av_log(ctx, AV_LOG_INFO, "\t\tclassify: label: %s, confidence: %d/%d.\n",
180  bbox->classify_labels[j], bbox->classify_confidences[j].num, bbox->classify_confidences[j].den);
181  }
182  }
183  }
184 }
185 
187 {
188  const AVMasteringDisplayMetadata *mastering_display;
189 
190  av_log(ctx, AV_LOG_INFO, "mastering display: ");
191  if (sd->size < sizeof(*mastering_display)) {
192  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
193  return;
194  }
195 
196  mastering_display = (const AVMasteringDisplayMetadata *)sd->data;
197 
198  av_log(ctx, AV_LOG_INFO, "has_primaries:%d has_luminance:%d "
199  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
200  "min_luminance=%f, max_luminance=%f",
201  mastering_display->has_primaries, mastering_display->has_luminance,
202  av_q2d(mastering_display->display_primaries[0][0]),
203  av_q2d(mastering_display->display_primaries[0][1]),
204  av_q2d(mastering_display->display_primaries[1][0]),
205  av_q2d(mastering_display->display_primaries[1][1]),
206  av_q2d(mastering_display->display_primaries[2][0]),
207  av_q2d(mastering_display->display_primaries[2][1]),
208  av_q2d(mastering_display->white_point[0]), av_q2d(mastering_display->white_point[1]),
209  av_q2d(mastering_display->min_luminance), av_q2d(mastering_display->max_luminance));
210 }
211 
213 {
214  AVDynamicHDRPlus *hdr_plus;
215 
216  av_log(ctx, AV_LOG_INFO, "HDR10+ metadata: ");
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),",
231  av_log(ctx, AV_LOG_INFO, "window_lower_right_corner: (%5.4f,%5.4f), ",
234  av_log(ctx, AV_LOG_INFO, "window_upper_left_corner: (%5.4f, %5.4f), ",
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, ",
244  av_log(ctx, AV_LOG_INFO, "semimajor_axis_external_ellipse: %d, ",
246  av_log(ctx, AV_LOG_INFO, "semiminor_axis_external_ellipse: %d, ",
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, ",
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",
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)",
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",
294  }
295  av_log(ctx, AV_LOG_INFO, "}");
296  }
297 
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",
305  }
306  av_log(ctx, AV_LOG_INFO, ")");
307  }
308  av_log(ctx, AV_LOG_INFO, "}");
309  }
310 }
311 
313 {
314  AVDynamicHDRVivid *hdr_vivid;
315 
316  av_log(ctx, AV_LOG_INFO, "HDR Vivid metadata: ");
317  if (sd->size < sizeof(*hdr_vivid)) {
318  av_log(ctx, AV_LOG_ERROR, "invalid hdr vivid data\n");
319  return;
320  }
321 
322  hdr_vivid = (AVDynamicHDRVivid *)sd->data;
323  av_log(ctx, AV_LOG_INFO, "system_start_code: %d, ", hdr_vivid->system_start_code);
324  av_log(ctx, AV_LOG_INFO, "num_windows: %d, ", hdr_vivid->num_windows);
325  for (int w = 0; w < hdr_vivid->num_windows; w++) {
326  const AVHDRVividColorTransformParams *params = &hdr_vivid->params[w];
327 
328  av_log(ctx, AV_LOG_INFO, "minimum_maxrgb[%d]: %.4f, ", w, av_q2d(params->minimum_maxrgb));
329  av_log(ctx, AV_LOG_INFO, "average_maxrgb[%d]: %.4f, ", w, av_q2d(params->average_maxrgb));
330  av_log(ctx, AV_LOG_INFO, "variance_maxrgb[%d]:%.4f, ", w, av_q2d(params->variance_maxrgb));
331  av_log(ctx, AV_LOG_INFO, "maximum_maxrgb[%d]: %.4f, ", w, av_q2d(params->maximum_maxrgb));
332  }
333 
334  for (int w = 0; w < hdr_vivid->num_windows; w++) {
335  const AVHDRVividColorTransformParams *params = &hdr_vivid->params[w];
336 
337  av_log(ctx, AV_LOG_INFO, "tone_mapping_mode_flag[%d]: %d, ", w, params->tone_mapping_mode_flag);
338  av_log(ctx, AV_LOG_INFO, "tone_mapping_param_num[%d]: %d, ", w, params->tone_mapping_param_num);
339  if (params->tone_mapping_mode_flag) {
340  for (int i = 0; i < params->tone_mapping_param_num; i++) {
341  const AVHDRVividColorToneMappingParams *tm_params = &params->tm_params[i];
342 
343  av_log(ctx, AV_LOG_INFO, "targeted_system_display_maximum_luminance[%d][%d]: %.4f, ",
345  av_log(ctx, AV_LOG_INFO, "base_enable_flag[%d][%d]: %d, ",
346  w, i, tm_params->base_enable_flag);
347  if (tm_params->base_enable_flag) {
348  av_log(ctx, AV_LOG_INFO, "base_param_m_p[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_p));
349  av_log(ctx, AV_LOG_INFO, "base_param_m_m[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_m));
350  av_log(ctx, AV_LOG_INFO, "base_param_m_a[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_a));
351  av_log(ctx, AV_LOG_INFO, "base_param_m_b[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_b));
352  av_log(ctx, AV_LOG_INFO, "base_param_m_n[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_m_n));
353  av_log(ctx, AV_LOG_INFO, "base_param_k1[%d][%d]: %d, ", w, i, tm_params->base_param_k1);
354  av_log(ctx, AV_LOG_INFO, "base_param_k2[%d][%d]: %d, ", w, i, tm_params->base_param_k2);
355  av_log(ctx, AV_LOG_INFO, "base_param_k3[%d][%d]: %d, ", w, i, tm_params->base_param_k3);
356  av_log(ctx, AV_LOG_INFO, "base_param_Delta_enable_mode[%d][%d]: %d, ", w, i,
357  tm_params->base_param_Delta_enable_mode);
358  av_log(ctx, AV_LOG_INFO, "base_param_Delta[%d][%d]: %.4f, ", w, i, av_q2d(tm_params->base_param_Delta));
359  }
360  av_log(ctx, AV_LOG_INFO, "3Spline_enable_flag[%d][%d]: %d, ",
361  w, i, tm_params->three_Spline_enable_flag);
362  if (tm_params->three_Spline_enable_flag) {
363  av_log(ctx, AV_LOG_INFO, "3Spline_TH_mode[%d][%d]: %d, ", w, i, tm_params->three_Spline_TH_mode);
364 
365  for (int j = 0; j < tm_params->three_Spline_num; j++) {
366  av_log(ctx, AV_LOG_INFO, "3Spline_TH_enable_MB[%d][%d][%d]: %.4f, ",
367  w, i, j, av_q2d(tm_params->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(tm_params->three_Spline_TH_enable));
370  av_log(ctx, AV_LOG_INFO, "3Spline_TH_Delta1[%d][%d][%d]: %.4f, ",
371  w, i, j, av_q2d(tm_params->three_Spline_TH_Delta1));
372  av_log(ctx, AV_LOG_INFO, "3Spline_TH_Delta2[%d][%d][%d]: %.4f, ",
373  w, i, j, av_q2d(tm_params->three_Spline_TH_Delta2));
374  av_log(ctx, AV_LOG_INFO, "3Spline_enable_Strength[%d][%d][%d]: %.4f, ",
375  w, i, j, av_q2d(tm_params->three_Spline_enable_Strength));
376  }
377  }
378  }
379  }
380 
381  av_log(ctx, AV_LOG_INFO, "color_saturation_mapping_flag[%d]: %d",
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 
396 {
397  const AVContentLightMetadata *metadata = (const AVContentLightMetadata *)sd->data;
398 
399  av_log(ctx, AV_LOG_INFO, "Content Light Level information: "
400  "MaxCLL=%d, MaxFALL=%d",
401  metadata->MaxCLL, metadata->MaxFALL);
402 }
403 
405 {
406  const AVVideoEncParams *par = (const AVVideoEncParams *)sd->data;
407  int plane, acdc;
408 
409  av_log(ctx, AV_LOG_INFO, "video encoding parameters: 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 
424 {
425  const uint8_t *user_data = sd->data;
426 
427  if (sd->size < AV_UUID_LEN) {
428  av_log(ctx, AV_LOG_ERROR, "invalid data(%"SIZE_SPECIFIER" < "
429  "UUID(%d-bytes))\n", sd->size, AV_UUID_LEN);
430  return;
431  }
432 
433  av_log(ctx, AV_LOG_INFO, "User Data Unregistered:\n");
435 
436  av_log(ctx, AV_LOG_INFO, "User Data=");
437  for (size_t i = 16; i < sd->size; i++)
438  av_log(ctx, AV_LOG_INFO, "%02x", user_data[i]);
439  av_log(ctx, AV_LOG_INFO, "\n");
440 }
441 
443 {
444  const AVFilmGrainParams *fgp = (const AVFilmGrainParams *)sd->data;
445  const char *const film_grain_type_names[] = {
446  [AV_FILM_GRAIN_PARAMS_NONE] = "none",
447  [AV_FILM_GRAIN_PARAMS_AV1] = "av1",
448  [AV_FILM_GRAIN_PARAMS_H274] = "h274",
449  };
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, "film grain parameters: type %s; ", film_grain_type_names[fgp->type]);
457  av_log(ctx, AV_LOG_INFO, "seed=%"PRIu64"; ", fgp->seed);
458 
459  switch (fgp->type) {
462  return;
464  const AVFilmGrainH274Params *h274 = &fgp->codec.h274;
465  const char *color_range_str = av_color_range_name(h274->color_range);
466  const char *color_primaries_str = av_color_primaries_name(h274->color_primaries);
467  const char *color_trc_str = av_color_transfer_name(h274->color_trc);
468  const char *colorspace_str = av_color_space_name(h274->color_space);
469 
470  av_log(ctx, AV_LOG_INFO, "model_id=%d; ", h274->model_id);
471  av_log(ctx, AV_LOG_INFO, "bit_depth_luma=%d; ", h274->bit_depth_luma);
472  av_log(ctx, AV_LOG_INFO, "bit_depth_chroma=%d; ", h274->bit_depth_chroma);
473  av_log(ctx, AV_LOG_INFO, "color_range=%s; ", color_range_str ? color_range_str : "unknown");
474  av_log(ctx, AV_LOG_INFO, "color_primaries=%s; ", color_primaries_str ? color_primaries_str : "unknown");
475  av_log(ctx, AV_LOG_INFO, "color_trc=%s; ", color_trc_str ? color_trc_str : "unknown");
476  av_log(ctx, AV_LOG_INFO, "color_space=%s; ", colorspace_str ? colorspace_str : "unknown");
477  av_log(ctx, AV_LOG_INFO, "blending_mode_id=%d; ", h274->blending_mode_id);
478  av_log(ctx, AV_LOG_INFO, "log2_scale_factor=%d; ", h274->log2_scale_factor);
479 
480  for (int c = 0; c < 3; c++)
481  if (h274->component_model_present[c] && (h274->num_model_values[c] > 6 ||
482  h274->num_intensity_intervals[c] < 1 ||
483  h274->num_intensity_intervals[c] > 256)) {
484  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
485  return;
486  }
487 
488  for (int c = 0; c < 3; c++) {
489  if (!h274->component_model_present[c])
490  continue;
491 
492  av_log(ctx, AV_LOG_INFO, "num_intensity_intervals[%d]=%u; ", c, h274->num_intensity_intervals[c]);
493  av_log(ctx, AV_LOG_INFO, "num_model_values[%d]=%u; ", c, h274->num_model_values[c]);
494  for (int i = 0; i < h274->num_intensity_intervals[c]; i++) {
495  av_log(ctx, AV_LOG_INFO, "intensity_interval_lower_bound[%d][%d]=%u; ",
496  c, i, h274->intensity_interval_lower_bound[c][i]);
497  av_log(ctx, AV_LOG_INFO, "intensity_interval_upper_bound[%d][%d]=%u; ",
498  c, i, h274->intensity_interval_upper_bound[c][i]);
499  for (int j = 0; j < h274->num_model_values[c]; j++)
500  av_log(ctx, AV_LOG_INFO, "comp_model_value[%d][%d][%d]=%d; ",
501  c, i, j, h274->comp_model_value[c][i][j]);
502  }
503  }
504  break;
505  }
506  }
507 }
508 
510 {
511  const AVDOVIMetadata *dovi = (AVDOVIMetadata *) sd->data;
512  const AVDOVIRpuDataHeader *hdr = av_dovi_get_header(dovi);
513  const AVDOVIDataMapping *mapping = av_dovi_get_mapping(dovi);
515 
516  av_log(ctx, AV_LOG_INFO, "Dolby Vision Metadata:\n");
517  av_log(ctx, AV_LOG_INFO, " rpu_type=%"PRIu8"; ", hdr->rpu_type);
518  av_log(ctx, AV_LOG_INFO, "rpu_format=%"PRIu16"; ", hdr->rpu_format);
519  av_log(ctx, AV_LOG_INFO, "vdr_rpu_profile=%"PRIu8"; ", hdr->vdr_rpu_profile);
520  av_log(ctx, AV_LOG_INFO, "vdr_rpu_level=%"PRIu8"; ", hdr->vdr_rpu_level);
521  av_log(ctx, AV_LOG_INFO, "chroma_resampling_explicit_filter_flag=%"PRIu8"; ", hdr->chroma_resampling_explicit_filter_flag);
522  av_log(ctx, AV_LOG_INFO, "coef_data_type=%"PRIu8"; ", hdr->coef_data_type);
523  av_log(ctx, AV_LOG_INFO, "coef_log2_denom=%"PRIu8"; ", hdr->coef_log2_denom);
524  av_log(ctx, AV_LOG_INFO, "vdr_rpu_normalized_idc=%"PRIu8"; ", hdr->vdr_rpu_normalized_idc);
525  av_log(ctx, AV_LOG_INFO, "bl_video_full_range_flag=%"PRIu8"; ", hdr->bl_video_full_range_flag);
526  av_log(ctx, AV_LOG_INFO, "bl_bit_depth=%"PRIu8"; ", hdr->bl_bit_depth);
527  av_log(ctx, AV_LOG_INFO, "el_bit_depth=%"PRIu8"; ", hdr->el_bit_depth);
528  av_log(ctx, AV_LOG_INFO, "vdr_bit_depth=%"PRIu8"; ", hdr->vdr_bit_depth);
529  av_log(ctx, AV_LOG_INFO, "spatial_resampling_filter_flag=%"PRIu8"; ", hdr->spatial_resampling_filter_flag);
530  av_log(ctx, AV_LOG_INFO, "el_spatial_resampling_filter_flag=%"PRIu8"; ", hdr->el_spatial_resampling_filter_flag);
531  av_log(ctx, AV_LOG_INFO, "disable_residual_flag=%"PRIu8"\n", hdr->disable_residual_flag);
532 
533  av_log(ctx, AV_LOG_INFO, " data mapping: ");
534  av_log(ctx, AV_LOG_INFO, "vdr_rpu_id=%"PRIu8"; ", mapping->vdr_rpu_id);
535  av_log(ctx, AV_LOG_INFO, "mapping_color_space=%"PRIu8"; ", mapping->mapping_color_space);
536  av_log(ctx, AV_LOG_INFO, "mapping_chroma_format_idc=%"PRIu8"; ", mapping->mapping_chroma_format_idc);
537  av_log(ctx, AV_LOG_INFO, "nlq_method_idc=%d; ", (int) mapping->nlq_method_idc);
538  av_log(ctx, AV_LOG_INFO, "num_x_partitions=%"PRIu32"; ", mapping->num_x_partitions);
539  av_log(ctx, AV_LOG_INFO, "num_y_partitions=%"PRIu32"\n", mapping->num_y_partitions);
540 
541  for (int c = 0; c < 3; c++) {
542  const AVDOVIReshapingCurve *curve = &mapping->curves[c];
543  const AVDOVINLQParams *nlq = &mapping->nlq[c];
544  av_log(ctx, AV_LOG_INFO, " channel %d: ", c);
545  av_log(ctx, AV_LOG_INFO, "pivots={ ");
546  for (int i = 0; i < curve->num_pivots; i++)
547  av_log(ctx, AV_LOG_INFO, "%"PRIu16" ", curve->pivots[i]);
548  av_log(ctx, AV_LOG_INFO, "}; mapping_idc={ ");
549  for (int i = 0; i < curve->num_pivots - 1; i++)
550  av_log(ctx, AV_LOG_INFO, "%d ", (int) curve->mapping_idc[i]);
551  av_log(ctx, AV_LOG_INFO, "}; poly_order={ ");
552  for (int i = 0; i < curve->num_pivots - 1; i++)
553  av_log(ctx, AV_LOG_INFO, "%"PRIu8" ", curve->poly_order[i]);
554  av_log(ctx, AV_LOG_INFO, "}; poly_coef={ ");
555  for (int i = 0; i < curve->num_pivots - 1; i++) {
556  av_log(ctx, AV_LOG_INFO, "{%"PRIi64", %"PRIi64", %"PRIi64"} ",
557  curve->poly_coef[i][0],
558  curve->poly_coef[i][1],
559  curve->poly_coef[i][2]);
560  }
561 
562  av_log(ctx, AV_LOG_INFO, "}; mmr_order={ ");
563  for (int i = 0; i < curve->num_pivots - 1; i++)
564  av_log(ctx, AV_LOG_INFO, "%"PRIu8" ", curve->mmr_order[i]);
565  av_log(ctx, AV_LOG_INFO, "}; mmr_constant={ ");
566  for (int i = 0; i < curve->num_pivots - 1; i++)
567  av_log(ctx, AV_LOG_INFO, "%"PRIi64" ", curve->mmr_constant[i]);
568  av_log(ctx, AV_LOG_INFO, "}; mmr_coef={ ");
569  for (int i = 0; i < curve->num_pivots - 1; i++) {
570  av_log(ctx, AV_LOG_INFO, "{");
571  for (int j = 0; j < curve->mmr_order[i]; j++) {
572  for (int k = 0; k < 7; k++)
573  av_log(ctx, AV_LOG_INFO, "%"PRIi64" ", curve->mmr_coef[i][j][k]);
574  }
575  av_log(ctx, AV_LOG_INFO, "} ");
576  }
577 
578  av_log(ctx, AV_LOG_INFO, "}; nlq_offset=%"PRIu16"; ", nlq->nlq_offset);
579  av_log(ctx, AV_LOG_INFO, "vdr_in_max=%"PRIu64"; ", nlq->vdr_in_max);
580  switch (mapping->nlq_method_idc) {
582  av_log(ctx, AV_LOG_INFO, "linear_deadzone_slope=%"PRIu64"; ", nlq->linear_deadzone_slope);
583  av_log(ctx, AV_LOG_INFO, "linear_deadzone_threshold=%"PRIu64"\n", nlq->linear_deadzone_threshold);
584  break;
585  }
586  }
587 
588  av_log(ctx, AV_LOG_INFO, " color metadata: ");
589  av_log(ctx, AV_LOG_INFO, "dm_metadata_id=%"PRIu8"; ", color->dm_metadata_id);
590  av_log(ctx, AV_LOG_INFO, "scene_refresh_flag=%"PRIu8"; ", color->scene_refresh_flag);
591  av_log(ctx, AV_LOG_INFO, "ycc_to_rgb_matrix={ ");
592  for (int i = 0; i < 9; i++)
593  av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->ycc_to_rgb_matrix[i]));
594  av_log(ctx, AV_LOG_INFO, "}; ycc_to_rgb_offset={ ");
595  for (int i = 0; i < 3; i++)
596  av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->ycc_to_rgb_offset[i]));
597  av_log(ctx, AV_LOG_INFO, "}; rgb_to_lms_matrix={ ");
598  for (int i = 0; i < 9; i++)
599  av_log(ctx, AV_LOG_INFO, "%f ", av_q2d(color->rgb_to_lms_matrix[i]));
600  av_log(ctx, AV_LOG_INFO, "}; signal_eotf=%"PRIu16"; ", color->signal_eotf);
601  av_log(ctx, AV_LOG_INFO, "signal_eotf_param0=%"PRIu16"; ", color->signal_eotf_param0);
602  av_log(ctx, AV_LOG_INFO, "signal_eotf_param1=%"PRIu16"; ", color->signal_eotf_param1);
603  av_log(ctx, AV_LOG_INFO, "signal_eotf_param2=%"PRIu32"; ", color->signal_eotf_param2);
604  av_log(ctx, AV_LOG_INFO, "signal_bit_depth=%"PRIu8"; ", color->signal_bit_depth);
605  av_log(ctx, AV_LOG_INFO, "signal_color_space=%"PRIu8"; ", color->signal_color_space);
606  av_log(ctx, AV_LOG_INFO, "signal_chroma_format=%"PRIu8"; ", color->signal_chroma_format);
607  av_log(ctx, AV_LOG_INFO, "signal_full_range_flag=%"PRIu8"; ", color->signal_full_range_flag);
608  av_log(ctx, AV_LOG_INFO, "source_min_pq=%"PRIu16"; ", color->source_min_pq);
609  av_log(ctx, AV_LOG_INFO, "source_max_pq=%"PRIu16"; ", color->source_max_pq);
610  av_log(ctx, AV_LOG_INFO, "source_diagonal=%"PRIu16"; ", color->source_diagonal);
611 }
612 
614 {
615  const char *color_range_str = av_color_range_name(frame->color_range);
616  const char *colorspace_str = av_color_space_name(frame->colorspace);
617  const char *color_primaries_str = av_color_primaries_name(frame->color_primaries);
618  const char *color_trc_str = av_color_transfer_name(frame->color_trc);
619 
620  if (!color_range_str || frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
621  av_log(ctx, AV_LOG_INFO, "color_range:unknown");
622  } else {
623  av_log(ctx, AV_LOG_INFO, "color_range:%s", color_range_str);
624  }
625 
626  if (!colorspace_str || frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
627  av_log(ctx, AV_LOG_INFO, " color_space:unknown");
628  } else {
629  av_log(ctx, AV_LOG_INFO, " color_space:%s", colorspace_str);
630  }
631 
632  if (!color_primaries_str || frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
633  av_log(ctx, AV_LOG_INFO, " color_primaries:unknown");
634  } else {
635  av_log(ctx, AV_LOG_INFO, " color_primaries:%s", color_primaries_str);
636  }
637 
638  if (!color_trc_str || frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
639  av_log(ctx, AV_LOG_INFO, " color_trc:unknown");
640  } else {
641  av_log(ctx, AV_LOG_INFO, " color_trc:%s", color_trc_str);
642  }
643  av_log(ctx, AV_LOG_INFO, "\n");
644 }
645 
646 static void update_sample_stats_8(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
647 {
648  int i;
649 
650  for (i = 0; i < len; i++) {
651  *sum += src[i];
652  *sum2 += src[i] * src[i];
653  }
654 }
655 
656 static void update_sample_stats_16(int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
657 {
658  const uint16_t *src1 = (const uint16_t *)src;
659  int i;
660 
661  for (i = 0; i < len / 2; i++) {
662  if ((HAVE_BIGENDIAN && !be) || (!HAVE_BIGENDIAN && be)) {
663  *sum += av_bswap16(src1[i]);
664  *sum2 += (uint32_t)av_bswap16(src1[i]) * (uint32_t)av_bswap16(src1[i]);
665  } else {
666  *sum += src1[i];
667  *sum2 += (uint32_t)src1[i] * (uint32_t)src1[i];
668  }
669  }
670 }
671 
672 static void update_sample_stats(int depth, int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
673 {
674  if (depth <= 8)
675  update_sample_stats_8(src, len, sum, sum2);
676  else
677  update_sample_stats_16(be, src, len, sum, sum2);
678 }
679 
681 {
682  AVFilterContext *ctx = inlink->dst;
683  ShowInfoContext *s = ctx->priv;
685  uint32_t plane_checksum[4] = {0}, checksum = 0;
686  int64_t sum[4] = {0}, sum2[4] = {0};
687  int32_t pixelcount[4] = {0};
688  int bitdepth = desc->comp[0].depth;
689  int be = desc->flags & AV_PIX_FMT_FLAG_BE;
690  int i, plane, vsub = desc->log2_chroma_h;
691 
692  for (plane = 0; plane < 4 && s->calculate_checksums && frame->data[plane] && frame->linesize[plane]; plane++) {
693  uint8_t *data = frame->data[plane];
694  int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
695  int linesize = av_image_get_linesize(frame->format, frame->width, plane);
696  int width = linesize >> (bitdepth > 8);
697 
698  if (linesize < 0)
699  return linesize;
700 
701  for (i = 0; i < h; i++) {
702  plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
703  checksum = av_adler32_update(checksum, data, linesize);
704 
705  update_sample_stats(bitdepth, be, data, linesize, sum+plane, sum2+plane);
706  pixelcount[plane] += width;
707  data += frame->linesize[plane];
708  }
709  }
710 
712  "n:%4"PRId64" pts:%7s pts_time:%-7s duration:%7"PRId64
713  " duration_time:%-7s pos:%9"PRId64" "
714  "fmt:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c ",
715  inlink->frame_count_out,
716  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base),
717  frame->duration, av_ts2timestr(frame->duration, &inlink->time_base),
718  frame->pkt_pos,
719  desc->name,
720  frame->sample_aspect_ratio.num, frame->sample_aspect_ratio.den,
721  frame->width, frame->height,
722  !frame->interlaced_frame ? 'P' : /* Progressive */
723  frame->top_field_first ? 'T' : 'B', /* Top / Bottom */
724  frame->key_frame,
725  av_get_picture_type_char(frame->pict_type));
726 
727  if (s->calculate_checksums) {
729  "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
730  checksum, plane_checksum[0]);
731 
732  for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
733  av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
734  av_log(ctx, AV_LOG_INFO, "] mean:[");
735  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
736  av_log(ctx, AV_LOG_INFO, "%s%"PRId64,
737  plane ? " ":"",
738  (sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
739  av_log(ctx, AV_LOG_INFO, "] stdev:[");
740  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
741  av_log(ctx, AV_LOG_INFO, "%s%3.1f",
742  plane ? " ":"",
743  sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
744  av_log(ctx, AV_LOG_INFO, "]");
745  }
746  av_log(ctx, AV_LOG_INFO, "\n");
747 
748  for (i = 0; i < frame->nb_side_data; i++) {
749  AVFrameSideData *sd = frame->side_data[i];
750 
751  av_log(ctx, AV_LOG_INFO, " side data - ");
752  switch (sd->type) {
754  av_log(ctx, AV_LOG_INFO, "pan/scan");
755  break;
757  av_log(ctx, AV_LOG_INFO, "A/53 closed captions "
758  "(%"SIZE_SPECIFIER" bytes)", sd->size);
759  break;
761  dump_spherical(ctx, frame, sd);
762  break;
764  dump_stereo3d(ctx, sd);
765  break;
767  dump_s12m_timecode(ctx, inlink->frame_rate, sd);
768  break;
769  }
771  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
773  break;
774  case AV_FRAME_DATA_AFD:
775  av_log(ctx, AV_LOG_INFO, "afd: value of %"PRIu8, sd->data[0]);
776  break;
778  dump_roi(ctx, sd);
779  break;
782  break;
785  break;
788  break;
791  break;
794  break;
796  char tcbuf[AV_TIMECODE_STR_SIZE];
797  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
798  av_log(ctx, AV_LOG_INFO, "GOP timecode - %s", tcbuf);
799  break;
800  }
803  break;
806  break;
809  break;
811  dump_dovi_metadata(ctx, sd);
812  break;
813  default:
814  av_log(ctx, AV_LOG_WARNING, "unknown side data type %d "
815  "(%"SIZE_SPECIFIER" bytes)\n", sd->type, sd->size);
816  break;
817  }
818 
819  av_log(ctx, AV_LOG_INFO, "\n");
820  }
821 
823 
824  return ff_filter_frame(inlink->dst->outputs[0], frame);
825 }
826 
828 {
829 
830  av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
831  is_out ? "out" : "in",
833  link->frame_rate.num, link->frame_rate.den);
834 
835  return 0;
836 }
837 
839 {
840  AVFilterContext *ctx = link->dst;
841  return config_props(ctx, link, 0);
842 }
843 
845 {
846  AVFilterContext *ctx = link->src;
847  return config_props(ctx, link, 1);
848 }
849 
851  {
852  .name = "default",
853  .type = AVMEDIA_TYPE_VIDEO,
854  .filter_frame = filter_frame,
855  .config_props = config_props_in,
856  },
857 };
858 
860  {
861  .name = "default",
862  .type = AVMEDIA_TYPE_VIDEO,
863  .config_props = config_props_out,
864  },
865 };
866 
868  .name = "showinfo",
869  .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
872  .priv_size = sizeof(ShowInfoContext),
873  .priv_class = &showinfo_class,
875 };
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:199
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:161
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:146
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
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:91
dump_spherical
static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, const AVFrameSideData *sd)
Definition: vf_showinfo.c:66
r
const char * r
Definition: vf_curves.c:126
opt.h
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:82
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:111
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:42
color
Definition: vf_paletteuse.c:601
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:672
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
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1009
AVFilmGrainH274Params::color_space
enum AVColorSpace color_space
Definition: film_grain_params.h:152
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:2858
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
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:123
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:204
config_props_out
static int config_props_out(AVFilterLink *link)
Definition: vf_showinfo.c:844
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
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:184
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:160
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:211
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:102
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
avfilter_vf_showinfo_inputs
static const AVFilterPad avfilter_vf_showinfo_inputs[]
Definition: vf_showinfo.c:850
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:192
AVDOVIReshapingCurve::mmr_coef
int64_t mmr_coef[AV_DOVI_MAX_PIECES][3][7]
Definition: dovi_meta.h:114
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:37
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:561
spherical.h
data
const char data[16]
Definition: mxf.c:146
AVDOVIReshapingCurve::mapping_idc
enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:107
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
AVFilmGrainH274Params::color_range
enum AVColorRange color_range
Definition: film_grain_params.h:149
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
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:175
AVDOVIDataMapping::mapping_color_space
uint8_t mapping_color_space
Definition: dovi_meta.h:141
AVDOVIRpuDataHeader
Dolby Vision RPU data header.
Definition: dovi_meta.h:76
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:228
dump_color_property
static void dump_color_property(AVFilterContext *ctx, AVFrame *frame)
Definition: vf_showinfo.c:613
AVDetectionBBox::y
int y
Definition: detection_bbox.h:32
AV_SPHERICAL_EQUIRECTANGULAR
@ AV_SPHERICAL_EQUIRECTANGULAR
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:52
video.h
OFFSET
#define OFFSET(x)
Definition: vf_showinfo.c:56
hdr_dynamic_vivid_metadata.h
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
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:117
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:3234
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:216
timecode.h
AVDynamicHDRVivid::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_vivid_metadata.h:259
dump_s12m_timecode
static void dump_s12m_timecode(AVFilterContext *ctx, AVRational frame_rate, const AVFrameSideData *sd)
Definition: vf_showinfo.c:123
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:49
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
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:194
AVFilmGrainH274Params::bit_depth_luma
int bit_depth_luma
Specifies the bit depth used for the luma component.
Definition: film_grain_params.h:142
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:234
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:838
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:250
width
#define width
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_showinfo.c:680
AVDOVIMetadata
Combined struct representing a combination of header, mapping and color metadata, for attaching to fr...
Definition: dovi_meta.h:197
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:256
AVDOVIReshapingCurve::mmr_order
uint8_t mmr_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:112
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:50
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:266
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:57
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:48
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:509
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:205
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:536
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:190
av_dovi_get_header
static av_always_inline AVDOVIRpuDataHeader * av_dovi_get_header(const AVDOVIMetadata *data)
Definition: dovi_meta.h:208
dump_mastering_display
static void dump_mastering_display(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:186
AVDOVIReshapingCurve::poly_order
uint8_t poly_order[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:109
AV_FRAME_DATA_DYNAMIC_HDR_VIVID
@ AV_FRAME_DATA_DYNAMIC_HDR_VIVID
HDR Vivid dynamic metadata associated with a video frame.
Definition: frame.h:211
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:182
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:131
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:3174
config_props
static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
Definition: vf_showinfo.c:827
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:867
AVHDRVividColorTransformParams::color_saturation_gain
AVRational color_saturation_gain[8]
Indicates the color correction strength parameter.
Definition: hdr_dynamic_vivid_metadata.h:235
AVHDRVividColorToneMappingParams::three_Spline_TH_enable_MB
AVRational three_Spline_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:136
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:139
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:255
AVDynamicHDRVivid
This struct represents dynamic metadata for color volume transform - CUVA 005.1:2021 standard.
Definition: hdr_dynamic_vivid_metadata.h:249
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:222
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:3192
adler32.h
ShowInfoContext::calculate_checksums
int calculate_checksums
Definition: vf_showinfo.c:53
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:132
dump_video_enc_params
static void dump_video_enc_params(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:404
dump_sei_unregistered_metadata
static void dump_sei_unregistered_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:423
AVDOVIReshapingCurve::mmr_constant
int64_t mmr_constant[AV_DOVI_MAX_PIECES]
Definition: dovi_meta.h:113
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:205
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:627
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
AV_UUID_LEN
#define AV_UUID_LEN
Definition: uuid.h:57
AVHDRVividColorToneMappingParams::three_Spline_TH_enable
AVRational three_Spline_TH_enable
3Spline_TH_enable of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:143
AVHDRVividColorToneMappingParams::three_Spline_enable_Strength
AVRational three_Spline_enable_Strength
3Spline_enable_Strength of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:164
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:76
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:212
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:115
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:53
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:170
AV_DOVI_NLQ_LINEAR_DZ
@ AV_DOVI_NLQ_LINEAR_DZ
Definition: dovi_meta.h:119
AVDynamicHDRPlus::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_metadata.h:259
uuid.h
showinfo_options
static const AVOption showinfo_options[]
Definition: vf_showinfo.c:59
AVHDRVividColorTransformParams::average_maxrgb
AVRational average_maxrgb
Indicates the average brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:185
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:447
AVFrameSideData::data
uint8_t * data
Definition: frame.h:233
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:216
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:67
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:84
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:178
AVDOVIReshapingCurve::poly_coef
int64_t poly_coef[AV_DOVI_MAX_PIECES][3]
Definition: dovi_meta.h:110
av_bswap16
#define av_bswap16
Definition: bswap.h:31
AVRegionOfInterest::right
int right
Definition: frame.h:268
dump_sei_film_grain_params_metadata
static void dump_sei_film_grain_params_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:442
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:164
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:656
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:267
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:124
dump_content_light_metadata
static void dump_content_light_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:395
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:265
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:37
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:176
display.h
AVDOVIDataMapping::num_y_partitions
uint32_t num_y_partitions
Definition: dovi_meta.h:148
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:172
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:55
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:590
AVDOVINLQParams
Coefficients of the non-linear inverse quantization.
Definition: dovi_meta.h:126
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:104
AVFilmGrainH274Params::color_primaries
enum AVColorPrimaries color_primaries
Definition: film_grain_params.h:150
avfilter_vf_showinfo_outputs
static const AVFilterPad avfilter_vf_showinfo_outputs[]
Definition: vf_showinfo.c:859
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:188
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:143
AVDOVINLQParams::linear_deadzone_slope
uint64_t linear_deadzone_slope
Definition: dovi_meta.h:130
AVFilter
Filter definition.
Definition: avfilter.h:171
AVDOVIReshapingCurve
Definition: dovi_meta.h:104
bswap.h
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:125
AVHDRVividColorToneMappingParams::three_Spline_TH_mode
int three_Spline_TH_mode
The mode of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:129
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:123
AVDOVINLQParams::vdr_in_max
uint64_t vdr_in_max
Definition: dovi_meta.h:128
AVDetectionBBox::h
int h
Definition: detection_bbox.h:34
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:177
dump_stereo3d
static void dump_stereo3d(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:105
dovi_meta.h
AVHDRVividColorTransformParams::minimum_maxrgb
AVRational minimum_maxrgb
Indicates the minimum brightness of the displayed content.
Definition: hdr_dynamic_vivid_metadata.h:178
AVDetectionBBox::detect_confidence
AVRational detect_confidence
Definition: detection_bbox.h:42
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:150
AVDOVIReshapingCurve::num_pivots
uint8_t num_pivots
Definition: dovi_meta.h:105
av_dovi_get_color
static av_always_inline AVDOVIColorMetadata * av_dovi_get_color(const AVDOVIMetadata *data)
Definition: dovi_meta.h:220
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:77
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:63
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
AVDOVIDataMapping::mapping_chroma_format_idc
uint8_t mapping_chroma_format_idc
Definition: dovi_meta.h:142
AVHDRVividColorToneMappingParams::three_Spline_TH_Delta1
AVRational three_Spline_TH_Delta1
3Spline_TH_Delta1 of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:150
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
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:646
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
ShowInfoContext
Definition: vf_showinfo.c:51
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:143
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:232
AVDOVIColorMetadata
Dolby Vision RPU colorspace metadata parameters.
Definition: dovi_meta.h:157
AVFilmGrainH274Params::log2_scale_factor
int log2_scale_factor
Specifies a scale factor used in the film grain characterization equations.
Definition: film_grain_params.h:165
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:31
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:182
AVFilterContext
An instance of a filter.
Definition: avfilter.h:415
tc
#define tc
Definition: regdef.h:69
desc
const char * desc
Definition: libsvtav1.c:83
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:214
AVFilmGrainH274Params::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: film_grain_params.h:151
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:231
AVDynamicHDRVivid::params
AVHDRVividColorTransformParams params[3]
The color transform parameters for every processing window.
Definition: hdr_dynamic_vivid_metadata.h:264
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:312
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AVDOVIReshapingCurve::pivots
uint16_t pivots[AV_DOVI_MAX_PIECES+1]
Definition: dovi_meta.h:106
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
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
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:127
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVDOVIDataMapping::vdr_rpu_id
uint8_t vdr_rpu_id
Definition: dovi_meta.h:140
AVDynamicHDRVivid::system_start_code
uint8_t system_start_code
The system start code.
Definition: hdr_dynamic_vivid_metadata.h:253
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVFilmGrainH274Params::bit_depth_chroma
int bit_depth_chroma
Specifies the bit depth used for the chroma components.
Definition: film_grain_params.h:147
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:99
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:58
h
h
Definition: vp9dsp_template.c:2038
AVHDRVividColorToneMappingParams::three_Spline_TH_Delta2
AVRational three_Spline_TH_Delta2
3Spline_TH_Delta2 of three Spline.
Definition: hdr_dynamic_vivid_metadata.h:157
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:173
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::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:49
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:292
AVDOVIDataMapping::nlq
AVDOVINLQParams nlq[3]
Definition: dovi_meta.h:149
AVDOVIDataMapping
Dolby Vision RPU data mapping parameters.
Definition: dovi_meta.h:139
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:78
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3213
detection_bbox.h
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:122
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:70
AV_FRAME_DATA_DETECTION_BBOXES
@ AV_FRAME_DATA_DETECTION_BBOXES
Bounding boxes for object detection and classification, as described by AVDetectionBBoxHeader.
Definition: frame.h:190
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:56
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:147
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