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/imgutils.h"
31 #include "libavutil/internal.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/spherical.h"
36 #include "libavutil/stereo3d.h"
37 #include "libavutil/timestamp.h"
38 #include "libavutil/timecode.h"
42 
43 #include "avfilter.h"
44 #include "internal.h"
45 #include "video.h"
46 
47 typedef struct ShowInfoContext {
48  const AVClass *class;
51 
52 #define OFFSET(x) offsetof(ShowInfoContext, x)
53 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
54 
55 static const AVOption showinfo_options[] = {
56  { "checksum", "calculate checksums", OFFSET(calculate_checksums), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, VF },
57  { NULL }
58 };
59 
60 AVFILTER_DEFINE_CLASS(showinfo);
61 
63 {
64  const AVSphericalMapping *spherical = (const AVSphericalMapping *)sd->data;
65  double yaw, pitch, roll;
66 
67  av_log(ctx, AV_LOG_INFO, "spherical information: ");
68  if (sd->size < sizeof(*spherical)) {
69  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
70  return;
71  }
72 
73  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR)
74  av_log(ctx, AV_LOG_INFO, "equirectangular ");
75  else if (spherical->projection == AV_SPHERICAL_CUBEMAP)
76  av_log(ctx, AV_LOG_INFO, "cubemap ");
77  else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE)
78  av_log(ctx, AV_LOG_INFO, "tiled equirectangular ");
79  else {
80  av_log(ctx, AV_LOG_WARNING, "unknown\n");
81  return;
82  }
83 
84  yaw = ((double)spherical->yaw) / (1 << 16);
85  pitch = ((double)spherical->pitch) / (1 << 16);
86  roll = ((double)spherical->roll) / (1 << 16);
87  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
88 
90  size_t l, t, r, b;
91  av_spherical_tile_bounds(spherical, frame->width, frame->height,
92  &l, &t, &r, &b);
95  l, t, r, b);
96  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
97  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
98  }
99 }
100 
102 {
103  const AVStereo3D *stereo;
104 
105  av_log(ctx, AV_LOG_INFO, "stereoscopic information: ");
106  if (sd->size < sizeof(*stereo)) {
107  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
108  return;
109  }
110 
111  stereo = (const AVStereo3D *)sd->data;
112 
113  av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
114 
115  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
116  av_log(ctx, AV_LOG_INFO, " (inverted)");
117 }
118 
120 {
121  const uint32_t *tc = (const uint32_t *)sd->data;
122 
123  if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
124  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
125  return;
126  }
127 
128  for (int j = 1; j <= tc[0]; j++) {
129  char tcbuf[AV_TIMECODE_STR_SIZE];
130  av_timecode_make_smpte_tc_string2(tcbuf, frame_rate, tc[j], 0, 0);
131  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
132  }
133 }
134 
135 static void dump_roi(AVFilterContext *ctx, const AVFrameSideData *sd)
136 {
137  int nb_rois;
138  const AVRegionOfInterest *roi;
139  uint32_t roi_size;
140 
141  roi = (const AVRegionOfInterest *)sd->data;
142  roi_size = roi->self_size;
143  if (!roi_size || sd->size % roi_size != 0) {
144  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
145  return;
146  }
147  nb_rois = sd->size / roi_size;
148 
149  av_log(ctx, AV_LOG_INFO, "Regions Of Interest(RoI) information: ");
150  for (int i = 0; i < nb_rois; i++) {
151  roi = (const AVRegionOfInterest *)(sd->data + roi_size * i);
152  av_log(ctx, AV_LOG_INFO, "index: %d, region: (%d, %d)/(%d, %d), qp offset: %d/%d.\n",
153  i, roi->left, roi->top, roi->right, roi->bottom, roi->qoffset.num, roi->qoffset.den);
154  }
155 }
156 
158 {
159  int nb_bboxes;
161  const AVDetectionBBox *bbox;
162 
163  header = (const AVDetectionBBoxHeader *)sd->data;
164  nb_bboxes = header->nb_bboxes;
165  av_log(ctx, AV_LOG_INFO, "detection bounding boxes:\n");
166  av_log(ctx, AV_LOG_INFO, "source: %s\n", header->source);
167 
168  for (int i = 0; i < nb_bboxes; i++) {
169  bbox = av_get_detection_bbox(header, i);
170  av_log(ctx, AV_LOG_INFO, "index: %d,\tregion: (%d, %d) -> (%d, %d), label: %s, confidence: %d/%d.\n",
171  i, bbox->x, bbox->y, bbox->x + bbox->w, bbox->y + bbox->h,
173  if (bbox->classify_count > 0) {
174  for (int j = 0; j < bbox->classify_count; j++) {
175  av_log(ctx, AV_LOG_INFO, "\t\tclassify: label: %s, confidence: %d/%d.\n",
176  bbox->classify_labels[j], bbox->classify_confidences[j].num, bbox->classify_confidences[j].den);
177  }
178  }
179  }
180 }
181 
183 {
184  const AVMasteringDisplayMetadata *mastering_display;
185 
186  av_log(ctx, AV_LOG_INFO, "mastering display: ");
187  if (sd->size < sizeof(*mastering_display)) {
188  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
189  return;
190  }
191 
192  mastering_display = (const AVMasteringDisplayMetadata *)sd->data;
193 
194  av_log(ctx, AV_LOG_INFO, "has_primaries:%d has_luminance:%d "
195  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
196  "min_luminance=%f, max_luminance=%f",
197  mastering_display->has_primaries, mastering_display->has_luminance,
198  av_q2d(mastering_display->display_primaries[0][0]),
199  av_q2d(mastering_display->display_primaries[0][1]),
200  av_q2d(mastering_display->display_primaries[1][0]),
201  av_q2d(mastering_display->display_primaries[1][1]),
202  av_q2d(mastering_display->display_primaries[2][0]),
203  av_q2d(mastering_display->display_primaries[2][1]),
204  av_q2d(mastering_display->white_point[0]), av_q2d(mastering_display->white_point[1]),
205  av_q2d(mastering_display->min_luminance), av_q2d(mastering_display->max_luminance));
206 }
207 
209 {
210  AVDynamicHDRPlus *hdr_plus;
211 
212  av_log(ctx, AV_LOG_INFO, "HDR10+ metadata: ");
213  if (sd->size < sizeof(*hdr_plus)) {
214  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
215  return;
216  }
217 
218  hdr_plus = (AVDynamicHDRPlus *)sd->data;
219  av_log(ctx, AV_LOG_INFO, "application version: %d, ", hdr_plus->application_version);
220  av_log(ctx, AV_LOG_INFO, "num_windows: %d, ", hdr_plus->num_windows);
221  for (int w = 1; w < hdr_plus->num_windows; w++) {
222  AVHDRPlusColorTransformParams *params = &hdr_plus->params[w];
223  av_log(ctx, AV_LOG_INFO, "window %d { ", w);
224  av_log(ctx, AV_LOG_INFO, "window_upper_left_corner: (%5.4f,%5.4f),",
227  av_log(ctx, AV_LOG_INFO, "window_lower_right_corner: (%5.4f,%5.4f), ",
230  av_log(ctx, AV_LOG_INFO, "window_upper_left_corner: (%5.4f, %5.4f), ",
233  av_log(ctx, AV_LOG_INFO, "center_of_ellipse_x: (%d,%d), ",
234  params->center_of_ellipse_x,
235  params->center_of_ellipse_y);
236  av_log(ctx, AV_LOG_INFO, "rotation_angle: %d, ",
237  params->rotation_angle);
238  av_log(ctx, AV_LOG_INFO, "semimajor_axis_internal_ellipse: %d, ",
240  av_log(ctx, AV_LOG_INFO, "semimajor_axis_external_ellipse: %d, ",
242  av_log(ctx, AV_LOG_INFO, "semiminor_axis_external_ellipse: %d, ",
244  av_log(ctx, AV_LOG_INFO, "overlap_process_option: %d}, ",
245  params->overlap_process_option);
246  }
247  av_log(ctx, AV_LOG_INFO, "targeted_system_display_maximum_luminance: %9.4f, ",
250  av_log(ctx, AV_LOG_INFO, "targeted_system_display_actual_peak_luminance: {");
251  for (int i = 0; i < hdr_plus->num_rows_targeted_system_display_actual_peak_luminance; i++) {
252  av_log(ctx, AV_LOG_INFO, "(");
253  for (int j = 0; j < hdr_plus->num_cols_targeted_system_display_actual_peak_luminance; j++) {
254  av_log(ctx, AV_LOG_INFO, "%5.4f,",
256  }
257  av_log(ctx, AV_LOG_INFO, ")");
258  }
259  av_log(ctx, AV_LOG_INFO, "}, ");
260  }
261 
262  for (int w = 0; w < hdr_plus->num_windows; w++) {
263  AVHDRPlusColorTransformParams *params = &hdr_plus->params[w];
264  av_log(ctx, AV_LOG_INFO, "window %d {maxscl: {", w);
265  for (int i = 0; i < 3; i++) {
266  av_log(ctx, AV_LOG_INFO, "%5.4f,",av_q2d(params->maxscl[i]));
267  }
268  av_log(ctx, AV_LOG_INFO, "} average_maxrgb: %5.4f, ",
269  av_q2d(params->average_maxrgb));
270  av_log(ctx, AV_LOG_INFO, "distribution_maxrgb: {");
271  for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {
272  av_log(ctx, AV_LOG_INFO, "(%d,%5.4f)",
275  }
276  av_log(ctx, AV_LOG_INFO, "} fraction_bright_pixels: %5.4f, ",
277  av_q2d(params->fraction_bright_pixels));
278  if (params->tone_mapping_flag) {
279  av_log(ctx, AV_LOG_INFO, "knee_point: (%5.4f,%5.4f), ", av_q2d(params->knee_point_x), av_q2d(params->knee_point_y));
280  av_log(ctx, AV_LOG_INFO, "bezier_curve_anchors: {");
281  for (int i = 0; i < params->num_bezier_curve_anchors; i++) {
282  av_log(ctx, AV_LOG_INFO, "%5.4f,",
283  av_q2d(params->bezier_curve_anchors[i]));
284  }
285  av_log(ctx, AV_LOG_INFO, "} ");
286  }
287  if (params->color_saturation_mapping_flag) {
288  av_log(ctx, AV_LOG_INFO, "color_saturation_weight: %5.4f",
290  }
291  av_log(ctx, AV_LOG_INFO, "} ");
292  }
293 
295  av_log(ctx, AV_LOG_INFO, "mastering_display_actual_peak_luminance: {");
296  for (int i = 0; i < hdr_plus->num_rows_mastering_display_actual_peak_luminance; i++) {
297  av_log(ctx, AV_LOG_INFO, "(");
298  for (int j = 0; j < hdr_plus->num_cols_mastering_display_actual_peak_luminance; j++) {
299  av_log(ctx, AV_LOG_INFO, " %5.4f,",
301  }
302  av_log(ctx, AV_LOG_INFO, ")");
303  }
304  av_log(ctx, AV_LOG_INFO, "} ");
305  }
306 }
307 
309 {
310  const AVContentLightMetadata *metadata = (const AVContentLightMetadata *)sd->data;
311 
312  av_log(ctx, AV_LOG_INFO, "Content Light Level information: "
313  "MaxCLL=%d, MaxFALL=%d",
314  metadata->MaxCLL, metadata->MaxFALL);
315 }
316 
318 {
319  const AVVideoEncParams *par = (const AVVideoEncParams *)sd->data;
320  int plane, acdc;
321 
322  av_log(ctx, AV_LOG_INFO, "video encoding parameters: type %d; ", par->type);
323  if (par->qp)
324  av_log(ctx, AV_LOG_INFO, "qp=%d; ", par->qp);
325  for (plane = 0; plane < FF_ARRAY_ELEMS(par->delta_qp); plane++)
326  for (acdc = 0; acdc < FF_ARRAY_ELEMS(par->delta_qp[plane]); acdc++) {
327  int delta_qp = par->delta_qp[plane][acdc];
328  if (delta_qp)
329  av_log(ctx, AV_LOG_INFO, "delta_qp[%d][%d]=%d; ",
330  plane, acdc, delta_qp);
331  }
332  if (par->nb_blocks)
333  av_log(ctx, AV_LOG_INFO, "%u blocks; ", par->nb_blocks);
334 }
335 
337 {
338  const int uuid_size = 16;
339  const uint8_t *user_data = sd->data;
340  int i;
341 
342  if (sd->size < uuid_size) {
343  av_log(ctx, AV_LOG_ERROR, "invalid data(%"SIZE_SPECIFIER" < "
344  "UUID(%d-bytes))\n", sd->size, uuid_size);
345  return;
346  }
347 
348  av_log(ctx, AV_LOG_INFO, "User Data Unregistered:\n");
349  av_log(ctx, AV_LOG_INFO, "UUID=");
350  for (i = 0; i < uuid_size; i++) {
351  av_log(ctx, AV_LOG_INFO, "%02x", user_data[i]);
352  if (i == 3 || i == 5 || i == 7 || i == 9)
353  av_log(ctx, AV_LOG_INFO, "-");
354  }
355  av_log(ctx, AV_LOG_INFO, "\n");
356 
357  av_log(ctx, AV_LOG_INFO, "User Data=");
358  for (; i < sd->size; i++) {
359  av_log(ctx, AV_LOG_INFO, "%02x", user_data[i]);
360  }
361  av_log(ctx, AV_LOG_INFO, "\n");
362 }
363 
365 {
366  const char *color_range_str = av_color_range_name(frame->color_range);
367  const char *colorspace_str = av_color_space_name(frame->colorspace);
368  const char *color_primaries_str = av_color_primaries_name(frame->color_primaries);
369  const char *color_trc_str = av_color_transfer_name(frame->color_trc);
370 
371  if (!color_range_str || frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
372  av_log(ctx, AV_LOG_INFO, "color_range:unknown");
373  } else {
374  av_log(ctx, AV_LOG_INFO, "color_range:%s", color_range_str);
375  }
376 
377  if (!colorspace_str || frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
378  av_log(ctx, AV_LOG_INFO, " color_space:unknown");
379  } else {
380  av_log(ctx, AV_LOG_INFO, " color_space:%s", colorspace_str);
381  }
382 
383  if (!color_primaries_str || frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
384  av_log(ctx, AV_LOG_INFO, " color_primaries:unknown");
385  } else {
386  av_log(ctx, AV_LOG_INFO, " color_primaries:%s", color_primaries_str);
387  }
388 
389  if (!color_trc_str || frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
390  av_log(ctx, AV_LOG_INFO, " color_trc:unknown");
391  } else {
392  av_log(ctx, AV_LOG_INFO, " color_trc:%s", color_trc_str);
393  }
394  av_log(ctx, AV_LOG_INFO, "\n");
395 }
396 
397 static void update_sample_stats_8(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
398 {
399  int i;
400 
401  for (i = 0; i < len; i++) {
402  *sum += src[i];
403  *sum2 += src[i] * src[i];
404  }
405 }
406 
407 static void update_sample_stats_16(int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
408 {
409  const uint16_t *src1 = (const uint16_t *)src;
410  int i;
411 
412  for (i = 0; i < len / 2; i++) {
413  if ((HAVE_BIGENDIAN && !be) || (!HAVE_BIGENDIAN && be)) {
414  *sum += av_bswap16(src1[i]);
415  *sum2 += (uint32_t)av_bswap16(src1[i]) * (uint32_t)av_bswap16(src1[i]);
416  } else {
417  *sum += src1[i];
418  *sum2 += (uint32_t)src1[i] * (uint32_t)src1[i];
419  }
420  }
421 }
422 
423 static void update_sample_stats(int depth, int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
424 {
425  if (depth <= 8)
426  update_sample_stats_8(src, len, sum, sum2);
427  else
428  update_sample_stats_16(be, src, len, sum, sum2);
429 }
430 
432 {
433  AVFilterContext *ctx = inlink->dst;
434  ShowInfoContext *s = ctx->priv;
436  uint32_t plane_checksum[4] = {0}, checksum = 0;
437  int64_t sum[4] = {0}, sum2[4] = {0};
438  int32_t pixelcount[4] = {0};
439  int bitdepth = desc->comp[0].depth;
440  int be = desc->flags & AV_PIX_FMT_FLAG_BE;
441  int i, plane, vsub = desc->log2_chroma_h;
442 
443  for (plane = 0; plane < 4 && s->calculate_checksums && frame->data[plane] && frame->linesize[plane]; plane++) {
444  uint8_t *data = frame->data[plane];
445  int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
446  int linesize = av_image_get_linesize(frame->format, frame->width, plane);
447  int width = linesize >> (bitdepth > 8);
448 
449  if (linesize < 0)
450  return linesize;
451 
452  for (i = 0; i < h; i++) {
453  plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
454  checksum = av_adler32_update(checksum, data, linesize);
455 
456  update_sample_stats(bitdepth, be, data, linesize, sum+plane, sum2+plane);
457  pixelcount[plane] += width;
458  data += frame->linesize[plane];
459  }
460  }
461 
463  "n:%4"PRId64" pts:%7s pts_time:%-7s pos:%9"PRId64" "
464  "fmt:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c ",
465  inlink->frame_count_out,
466  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base), frame->pkt_pos,
467  desc->name,
468  frame->sample_aspect_ratio.num, frame->sample_aspect_ratio.den,
469  frame->width, frame->height,
470  !frame->interlaced_frame ? 'P' : /* Progressive */
471  frame->top_field_first ? 'T' : 'B', /* Top / Bottom */
472  frame->key_frame,
473  av_get_picture_type_char(frame->pict_type));
474 
475  if (s->calculate_checksums) {
477  "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
478  checksum, plane_checksum[0]);
479 
480  for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
481  av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
482  av_log(ctx, AV_LOG_INFO, "] mean:[");
483  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
484  av_log(ctx, AV_LOG_INFO, "%"PRId64" ", (sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
485  av_log(ctx, AV_LOG_INFO, "\b] stdev:[");
486  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
487  av_log(ctx, AV_LOG_INFO, "%3.1f ",
488  sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
489  av_log(ctx, AV_LOG_INFO, "\b]");
490  }
491  av_log(ctx, AV_LOG_INFO, "\n");
492 
493  for (i = 0; i < frame->nb_side_data; i++) {
494  AVFrameSideData *sd = frame->side_data[i];
495 
496  av_log(ctx, AV_LOG_INFO, " side data - ");
497  switch (sd->type) {
499  av_log(ctx, AV_LOG_INFO, "pan/scan");
500  break;
502  av_log(ctx, AV_LOG_INFO, "A/53 closed captions "
503  "(%"SIZE_SPECIFIER" bytes)", sd->size);
504  break;
506  dump_spherical(ctx, frame, sd);
507  break;
509  dump_stereo3d(ctx, sd);
510  break;
512  dump_s12m_timecode(ctx, inlink->frame_rate, sd);
513  break;
514  }
516  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
518  break;
519  case AV_FRAME_DATA_AFD:
520  av_log(ctx, AV_LOG_INFO, "afd: value of %"PRIu8, sd->data[0]);
521  break;
523  dump_roi(ctx, sd);
524  break;
527  break;
530  break;
533  break;
536  break;
538  char tcbuf[AV_TIMECODE_STR_SIZE];
539  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
540  av_log(ctx, AV_LOG_INFO, "GOP timecode - %s", tcbuf);
541  break;
542  }
545  break;
548  break;
549  default:
550  av_log(ctx, AV_LOG_WARNING, "unknown side data type %d "
551  "(%"SIZE_SPECIFIER" bytes)\n", sd->type, sd->size);
552  break;
553  }
554 
555  av_log(ctx, AV_LOG_INFO, "\n");
556  }
557 
559 
560  return ff_filter_frame(inlink->dst->outputs[0], frame);
561 }
562 
564 {
565 
566  av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
567  is_out ? "out" : "in",
568  link->time_base.num, link->time_base.den,
569  link->frame_rate.num, link->frame_rate.den);
570 
571  return 0;
572 }
573 
575 {
576  AVFilterContext *ctx = link->dst;
577  return config_props(ctx, link, 0);
578 }
579 
581 {
582  AVFilterContext *ctx = link->src;
583  return config_props(ctx, link, 1);
584 }
585 
587  {
588  .name = "default",
589  .type = AVMEDIA_TYPE_VIDEO,
590  .filter_frame = filter_frame,
591  .config_props = config_props_in,
592  },
593  { NULL }
594 };
595 
597  {
598  .name = "default",
599  .type = AVMEDIA_TYPE_VIDEO,
600  .config_props = config_props_out,
601  },
602  { NULL }
603 };
604 
606  .name = "showinfo",
607  .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
608  .inputs = avfilter_vf_showinfo_inputs,
609  .outputs = avfilter_vf_showinfo_outputs,
610  .priv_size = sizeof(ShowInfoContext),
611  .priv_class = &showinfo_class,
612 };
AVVideoEncParams::qp
int32_t qp
Base quantisation parameter for the frame.
Definition: video_enc_params.h:103
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:157
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:187
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
dump_spherical
static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, const AVFrameSideData *sd)
Definition: vf_showinfo.c:62
r
const char * r
Definition: vf_curves.c:116
opt.h
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
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:423
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:978
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2541
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
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
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
config_props_out
static int config_props_out(AVFilterLink *link)
Definition: vf_showinfo.c:580
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
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
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:151
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:303
avfilter_vf_showinfo_inputs
static const AVFilterPad avfilter_vf_showinfo_inputs[]
Definition: vf_showinfo.c:586
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:39
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:248
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:476
spherical.h
data
const char data[16]
Definition: mxf.c:142
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:84
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:72
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:149
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
dump_color_property
static void dump_color_property(AVFilterContext *ctx, AVFrame *frame)
Definition: vf_showinfo.c:364
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:56
video.h
OFFSET
#define OFFSET(x)
Definition: vf_showinfo.c:52
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
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2929
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
timecode.h
dump_s12m_timecode
static void dump_s12m_timecode(AVFilterContext *ctx, AVRational frame_rate, const AVFrameSideData *sd)
Definition: vf_showinfo.c:119
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:54
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_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:181
AVFrameSideData::size
size_t size
Definition: frame.h:212
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:574
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:228
width
#define width
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_showinfo.c:431
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:257
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:58
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:244
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:53
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
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:451
dump_mastering_display
static void dump_mastering_display(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:182
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:185
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
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2869
config_props
static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
Definition: vf_showinfo.c:563
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:130
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
ff_vf_showinfo
const AVFilter ff_vf_showinfo
Definition: vf_showinfo.c:605
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:135
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:233
src
#define src
Definition: vp8dsp.c:255
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:119
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2887
adler32.h
ShowInfoContext::calculate_checksums
int calculate_checksums
Definition: vf_showinfo.c:49
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
dump_video_enc_params
static void dump_video_enc_params(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:317
dump_sei_unregistered_metadata
static void dump_sei_unregistered_metadata(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:336
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
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:89
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:542
AV_FRAME_DATA_SEI_UNREGISTERED
@ AV_FRAME_DATA_SEI_UNREGISTERED
User data unregistered metadata associated with a video frame.
Definition: frame.h:177
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_SPHERICAL_CUBEMAP
@ AV_SPHERICAL_CUBEMAP
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
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:208
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:117
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:52
AVDetectionBBox::w
int w
Definition: detection_bbox.h:33
AVDynamicHDRPlus::num_windows
uint8_t num_windows
The number of processing windows.
Definition: hdr_dynamic_metadata.h:259
showinfo_options
static const AVOption showinfo_options[]
Definition: vf_showinfo.c:55
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
AVFrameSideData::data
uint8_t * data
Definition: frame.h:211
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
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:182
av_bswap16
#define av_bswap16
Definition: bswap.h:31
AVRegionOfInterest::right
int right
Definition: frame.h:246
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
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:407
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
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_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:88
src1
#define src1
Definition: h264pred.c:140
AVRegionOfInterest::left
int left
Definition: frame.h:245
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:136
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:128
i
int i
Definition: input.c:407
dump_content_light_metadata
static void dump_content_light_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:308
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:136
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:243
internal.h
display.h
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:63
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:117
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
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:60
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:505
avfilter_vf_showinfo_outputs
static const AVFilterPad avfilter_vf_showinfo_outputs[]
Definition: vf_showinfo.c:596
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
AVFilter
Filter definition.
Definition: avfilter.h:145
bswap.h
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:124
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:127
AVDetectionBBox::h
int h
Definition: detection_bbox.h:34
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
dump_stereo3d
static void dump_stereo3d(AVFilterContext *ctx, const AVFrameSideData *sd)
Definition: vf_showinfo.c:101
checksum
static volatile int checksum
Definition: adler32.c:30
AVDetectionBBox::detect_confidence
AVRational detect_confidence
Definition: detection_bbox.h:42
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:193
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:158
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:165
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:397
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:169
AVRational::den
int den
Denominator.
Definition: rational.h:60
avfilter.h
ShowInfoContext
Definition: vf_showinfo.c:47
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
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:210
hdr_dynamic_metadata.h
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
AVFilterContext
An instance of a filter.
Definition: avfilter.h:333
tc
#define tc
Definition: regdef.h:69
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
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:209
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:70
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
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:164
imgutils.h
timestamp.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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
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:57
h
h
Definition: vp9dsp_template.c:2038
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:176
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:270
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:82
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2908
detection_bbox.h
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
AV_FRAME_DATA_DETECTION_BBOXES
@ AV_FRAME_DATA_DETECTION_BBOXES
Bounding boxes for object detection and classification, as described by AVDetectionBBoxHeader.
Definition: frame.h:189
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
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:34