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"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/spherical.h"
35 #include "libavutil/stereo3d.h"
36 #include "libavutil/timestamp.h"
37 #include "libavutil/timecode.h"
40 
41 #include "avfilter.h"
42 #include "internal.h"
43 #include "video.h"
44 
45 typedef struct ShowInfoContext {
46  const AVClass *class;
49 
50 #define OFFSET(x) offsetof(ShowInfoContext, x)
51 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
52 
53 static const AVOption showinfo_options[] = {
54  { "checksum", "calculate checksums", OFFSET(calculate_checksums), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, VF },
55  { NULL }
56 };
57 
58 AVFILTER_DEFINE_CLASS(showinfo);
59 
61 {
62  AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
63  double yaw, pitch, roll;
64 
65  av_log(ctx, AV_LOG_INFO, "spherical information: ");
66  if (sd->size < sizeof(*spherical)) {
67  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
68  return;
69  }
70 
71  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR)
72  av_log(ctx, AV_LOG_INFO, "equirectangular ");
73  else if (spherical->projection == AV_SPHERICAL_CUBEMAP)
74  av_log(ctx, AV_LOG_INFO, "cubemap ");
75  else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE)
76  av_log(ctx, AV_LOG_INFO, "tiled equirectangular ");
77  else {
78  av_log(ctx, AV_LOG_WARNING, "unknown\n");
79  return;
80  }
81 
82  yaw = ((double)spherical->yaw) / (1 << 16);
83  pitch = ((double)spherical->pitch) / (1 << 16);
84  roll = ((double)spherical->roll) / (1 << 16);
85  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
86 
88  size_t l, t, r, b;
89  av_spherical_tile_bounds(spherical, frame->width, frame->height,
90  &l, &t, &r, &b);
91  av_log(ctx, AV_LOG_INFO,
93  l, t, r, b);
94  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
95  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
96  }
97 }
98 
100 {
101  AVStereo3D *stereo;
102 
103  av_log(ctx, AV_LOG_INFO, "stereoscopic information: ");
104  if (sd->size < sizeof(*stereo)) {
105  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
106  return;
107  }
108 
109  stereo = (AVStereo3D *)sd->data;
110 
111  av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
112 
113  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
114  av_log(ctx, AV_LOG_INFO, " (inverted)");
115 }
116 
118 {
119  const uint32_t *tc = (const uint32_t *)sd->data;
120 
121  if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
122  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
123  return;
124  }
125 
126  for (int j = 1; j <= tc[0]; j++) {
127  char tcbuf[AV_TIMECODE_STR_SIZE];
128  av_timecode_make_smpte_tc_string(tcbuf, tc[j], 0);
129  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
130  }
131 }
132 
134 {
135  int nb_rois;
136  const AVRegionOfInterest *roi;
137  uint32_t roi_size;
138 
139  roi = (const AVRegionOfInterest *)sd->data;
140  roi_size = roi->self_size;
141  if (!roi_size || sd->size % roi_size != 0) {
142  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
143  return;
144  }
145  nb_rois = sd->size / roi_size;
146 
147  av_log(ctx, AV_LOG_INFO, "Regions Of Interest(RoI) information: ");
148  for (int i = 0; i < nb_rois; i++) {
149  roi = (const AVRegionOfInterest *)(sd->data + roi_size * i);
150  av_log(ctx, AV_LOG_INFO, "index: %d, region: (%d, %d)/(%d, %d), qp offset: %d/%d.\n",
151  i, roi->left, roi->top, roi->right, roi->bottom, roi->qoffset.num, roi->qoffset.den);
152  }
153 }
154 
156 {
157  AVMasteringDisplayMetadata *mastering_display;
158 
159  av_log(ctx, AV_LOG_INFO, "mastering display: ");
160  if (sd->size < sizeof(*mastering_display)) {
161  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
162  return;
163  }
164 
165  mastering_display = (AVMasteringDisplayMetadata *)sd->data;
166 
167  av_log(ctx, AV_LOG_INFO, "has_primaries:%d has_luminance:%d "
168  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
169  "min_luminance=%f, max_luminance=%f",
170  mastering_display->has_primaries, mastering_display->has_luminance,
171  av_q2d(mastering_display->display_primaries[0][0]),
172  av_q2d(mastering_display->display_primaries[0][1]),
173  av_q2d(mastering_display->display_primaries[1][0]),
174  av_q2d(mastering_display->display_primaries[1][1]),
175  av_q2d(mastering_display->display_primaries[2][0]),
176  av_q2d(mastering_display->display_primaries[2][1]),
177  av_q2d(mastering_display->white_point[0]), av_q2d(mastering_display->white_point[1]),
178  av_q2d(mastering_display->min_luminance), av_q2d(mastering_display->max_luminance));
179 }
180 
182 {
184 
185  av_log(ctx, AV_LOG_INFO, "Content Light Level information: "
186  "MaxCLL=%d, MaxFALL=%d",
187  metadata->MaxCLL, metadata->MaxFALL);
188 }
189 
191 {
193  int plane, acdc;
194 
195  av_log(ctx, AV_LOG_INFO, "video encoding parameters: type %d; ", par->type);
196  if (par->qp)
197  av_log(ctx, AV_LOG_INFO, "qp=%d; ", par->qp);
198  for (plane = 0; plane < FF_ARRAY_ELEMS(par->delta_qp); plane++)
199  for (acdc = 0; acdc < FF_ARRAY_ELEMS(par->delta_qp[plane]); acdc++) {
200  int delta_qp = par->delta_qp[plane][acdc];
201  if (delta_qp)
202  av_log(ctx, AV_LOG_INFO, "delta_qp[%d][%d]=%d; ",
203  plane, acdc, delta_qp);
204  }
205  if (par->nb_blocks)
206  av_log(ctx, AV_LOG_INFO, "%u blocks; ", par->nb_blocks);
207 }
208 
210 {
211  const int uuid_size = 16;
212  uint8_t *user_data = sd->data;
213  int i;
214 
215  if (sd->size < uuid_size) {
216  av_log(ctx, AV_LOG_ERROR, "invalid data(%d < UUID(%d-bytes))\n", sd->size, uuid_size);
217  return;
218  }
219 
220  av_log(ctx, AV_LOG_INFO, "User Data Unregistered:\n");
221  av_log(ctx, AV_LOG_INFO, "UUID=");
222  for (i = 0; i < uuid_size; i++) {
223  av_log(ctx, AV_LOG_INFO, "%02x", user_data[i]);
224  if (i == 3 || i == 5 || i == 7 || i == 9)
225  av_log(ctx, AV_LOG_INFO, "-");
226  }
227  av_log(ctx, AV_LOG_INFO, "\n");
228 
229  av_log(ctx, AV_LOG_INFO, "User Data=");
230  for (; i < sd->size; i++) {
231  av_log(ctx, AV_LOG_INFO, "%02x", user_data[i]);
232  }
233  av_log(ctx, AV_LOG_INFO, "\n");
234 }
235 
237 {
238  const char *color_range_str = av_color_range_name(frame->color_range);
239  const char *colorspace_str = av_color_space_name(frame->colorspace);
240  const char *color_primaries_str = av_color_primaries_name(frame->color_primaries);
241  const char *color_trc_str = av_color_transfer_name(frame->color_trc);
242 
243  if (!color_range_str || frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
244  av_log(ctx, AV_LOG_INFO, "color_range:unknown");
245  } else {
246  av_log(ctx, AV_LOG_INFO, "color_range:%s", color_range_str);
247  }
248 
249  if (!colorspace_str || frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
250  av_log(ctx, AV_LOG_INFO, " color_space:unknown");
251  } else {
252  av_log(ctx, AV_LOG_INFO, " color_space:%s", colorspace_str);
253  }
254 
255  if (!color_primaries_str || frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
256  av_log(ctx, AV_LOG_INFO, " color_primaries:unknown");
257  } else {
258  av_log(ctx, AV_LOG_INFO, " color_primaries:%s", color_primaries_str);
259  }
260 
261  if (!color_trc_str || frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
262  av_log(ctx, AV_LOG_INFO, " color_trc:unknown");
263  } else {
264  av_log(ctx, AV_LOG_INFO, " color_trc:%s", color_trc_str);
265  }
266  av_log(ctx, AV_LOG_INFO, "\n");
267 }
268 
269 static void update_sample_stats_8(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
270 {
271  int i;
272 
273  for (i = 0; i < len; i++) {
274  *sum += src[i];
275  *sum2 += src[i] * src[i];
276  }
277 }
278 
279 static void update_sample_stats_16(int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
280 {
281  const uint16_t *src1 = (const uint16_t *)src;
282  int i;
283 
284  for (i = 0; i < len / 2; i++) {
285  if ((HAVE_BIGENDIAN && !be) || (!HAVE_BIGENDIAN && be)) {
286  *sum += av_bswap16(src1[i]);
287  *sum2 += (uint32_t)av_bswap16(src1[i]) * (uint32_t)av_bswap16(src1[i]);
288  } else {
289  *sum += src1[i];
290  *sum2 += (uint32_t)src1[i] * (uint32_t)src1[i];
291  }
292  }
293 }
294 
295 static void update_sample_stats(int depth, int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
296 {
297  if (depth <= 8)
298  update_sample_stats_8(src, len, sum, sum2);
299  else
300  update_sample_stats_16(be, src, len, sum, sum2);
301 }
302 
304 {
305  AVFilterContext *ctx = inlink->dst;
306  ShowInfoContext *s = ctx->priv;
308  uint32_t plane_checksum[4] = {0}, checksum = 0;
309  int64_t sum[4] = {0}, sum2[4] = {0};
310  int32_t pixelcount[4] = {0};
311  int bitdepth = desc->comp[0].depth;
312  int be = desc->flags & AV_PIX_FMT_FLAG_BE;
313  int i, plane, vsub = desc->log2_chroma_h;
314 
315  for (plane = 0; plane < 4 && s->calculate_checksums && frame->data[plane] && frame->linesize[plane]; plane++) {
316  uint8_t *data = frame->data[plane];
317  int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
318  int linesize = av_image_get_linesize(frame->format, frame->width, plane);
319  int width = linesize >> (bitdepth > 8);
320 
321  if (linesize < 0)
322  return linesize;
323 
324  for (i = 0; i < h; i++) {
325  plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
326  checksum = av_adler32_update(checksum, data, linesize);
327 
328  update_sample_stats(bitdepth, be, data, linesize, sum+plane, sum2+plane);
329  pixelcount[plane] += width;
330  data += frame->linesize[plane];
331  }
332  }
333 
334  av_log(ctx, AV_LOG_INFO,
335  "n:%4"PRId64" pts:%7s pts_time:%-7s pos:%9"PRId64" "
336  "fmt:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c ",
337  inlink->frame_count_out,
338  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base), frame->pkt_pos,
339  desc->name,
341  frame->width, frame->height,
342  !frame->interlaced_frame ? 'P' : /* Progressive */
343  frame->top_field_first ? 'T' : 'B', /* Top / Bottom */
344  frame->key_frame,
346 
347  if (s->calculate_checksums) {
348  av_log(ctx, AV_LOG_INFO,
349  "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
350  checksum, plane_checksum[0]);
351 
352  for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
353  av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
354  av_log(ctx, AV_LOG_INFO, "] mean:[");
355  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
356  av_log(ctx, AV_LOG_INFO, "%"PRId64" ", (sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
357  av_log(ctx, AV_LOG_INFO, "\b] stdev:[");
358  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
359  av_log(ctx, AV_LOG_INFO, "%3.1f ",
360  sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
361  av_log(ctx, AV_LOG_INFO, "\b]");
362  }
363  av_log(ctx, AV_LOG_INFO, "\n");
364 
365  for (i = 0; i < frame->nb_side_data; i++) {
366  AVFrameSideData *sd = frame->side_data[i];
367 
368  av_log(ctx, AV_LOG_INFO, " side data - ");
369  switch (sd->type) {
371  av_log(ctx, AV_LOG_INFO, "pan/scan");
372  break;
374  av_log(ctx, AV_LOG_INFO, "A/53 closed captions (%d bytes)", sd->size);
375  break;
377  dump_spherical(ctx, frame, sd);
378  break;
380  dump_stereo3d(ctx, sd);
381  break;
383  dump_s12m_timecode(ctx, sd);
384  break;
385  }
387  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
389  break;
390  case AV_FRAME_DATA_AFD:
391  av_log(ctx, AV_LOG_INFO, "afd: value of %"PRIu8, sd->data[0]);
392  break;
394  dump_roi(ctx, sd);
395  break;
397  dump_mastering_display(ctx, sd);
398  break;
401  break;
403  char tcbuf[AV_TIMECODE_STR_SIZE];
404  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
405  av_log(ctx, AV_LOG_INFO, "GOP timecode - %s", tcbuf);
406  break;
407  }
409  dump_video_enc_params(ctx, sd);
410  break;
413  break;
414  default:
415  av_log(ctx, AV_LOG_WARNING, "unknown side data type %d (%d bytes)\n",
416  sd->type, sd->size);
417  break;
418  }
419 
420  av_log(ctx, AV_LOG_INFO, "\n");
421  }
422 
423  dump_color_property(ctx, frame);
424 
425  return ff_filter_frame(inlink->dst->outputs[0], frame);
426 }
427 
429 {
430 
431  av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
432  is_out ? "out" : "in",
433  link->time_base.num, link->time_base.den,
434  link->frame_rate.num, link->frame_rate.den);
435 
436  return 0;
437 }
438 
440 {
441  AVFilterContext *ctx = link->dst;
442  return config_props(ctx, link, 0);
443 }
444 
446 {
447  AVFilterContext *ctx = link->src;
448  return config_props(ctx, link, 1);
449 }
450 
452  {
453  .name = "default",
454  .type = AVMEDIA_TYPE_VIDEO,
455  .filter_frame = filter_frame,
456  .config_props = config_props_in,
457  },
458  { NULL }
459 };
460 
462  {
463  .name = "default",
464  .type = AVMEDIA_TYPE_VIDEO,
465  .config_props = config_props_out,
466  },
467  { NULL }
468 };
469 
471  .name = "showinfo",
472  .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
473  .inputs = avfilter_vf_showinfo_inputs,
474  .outputs = avfilter_vf_showinfo_outputs,
475  .priv_size = sizeof(ShowInfoContext),
476  .priv_class = &showinfo_class,
477 };
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
#define NULL
Definition: coverity.c:32
static int config_props_out(AVFilterLink *link)
Definition: vf_showinfo.c:445
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
static void dump_s12m_timecode(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:117
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:248
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, AVFrameSideData *sd)
Definition: vf_showinfo.c:60
unsigned MaxCLL
Max content light level (cd/m^2).
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:579
int32_t qp
Base quantisation parameter for the frame.
const char * desc
Definition: libsvtav1.c:79
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
Main libavfilter public API header.
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection...
Definition: spherical.h:72
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Content light level (based on CTA-861.3).
Definition: frame.h:136
int num
Numerator.
Definition: rational.h:59
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
#define av_bswap16
Definition: bswap.h:31
#define OFFSET(x)
Definition: vf_showinfo.c:50
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:162
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:295
#define tc
Definition: regdef.h:69
int calculate_checksums
Definition: vf_showinfo.c:47
Mastering display metadata associated with a video frame.
Definition: frame.h:119
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:56
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
static const AVFilterPad avfilter_vf_showinfo_inputs[]
Definition: vf_showinfo.c:451
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_showinfo.c:303
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2966
AVRational qoffset
Quantisation offset.
Definition: frame.h:275
int32_t delta_qp[4][2]
Quantisation parameter offset from the base (per-frame) qp for a given plane (first index) and AC/DC ...
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1091
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
static void dump_color_property(AVFilterContext *ctx, AVFrame *frame)
Definition: vf_showinfo.c:236
AVOptions.
timestamp utils, mostly useful for debugging/logging purposes
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
static int config_props_in(AVFilterLink *link)
Definition: vf_showinfo.c:439
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2899
unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf, unsigned int len)
Calculate the Adler32 checksum of a buffer.
Definition: adler32.c:44
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:36
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:401
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:52
Structure to hold side data for an AVFrame.
Definition: frame.h:214
const char * av_stereo3d_type_name(unsigned int type)
Provide a human-readable name of a given stereo3d type.
Definition: stereo3d.c:57
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
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
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:455
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:238
The data represents the AVSphericalMapping structure defined in libavutil/spherical.h.
Definition: frame.h:130
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:89
int nb_side_data
Definition: frame.h:520
AVFrameSideData ** side_data
Definition: frame.h:519
#define av_log(a,...)
const char * name
Definition: pixdesc.h:82
A filter pad used for either input or output.
Definition: internal.h:54
#define src
Definition: vp8dsp.c:254
AVFILTER_DEFINE_CLASS(showinfo)
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
int width
Definition: frame.h:366
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
#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
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
Display matrix.
const char * r
Definition: vf_curves.c:114
void * priv
private data for use by the filter
Definition: avfilter.h:353
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:552
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:563
enum AVVideoEncParamsType type
Type of the parameters (the codec they are used with).
The GOP timecode in 25 bit timecode format.
Definition: frame.h:124
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2918
static void dump_sei_unregistered_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:209
common internal API header
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
static void update_sample_stats_16(int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
Definition: vf_showinfo.c:279
#define b
Definition: input.c:41
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
Definition: vf_showinfo.c:428
Spherical video.
Video encoding parameters for a given frame.
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
#define width
static const AVOption showinfo_options[]
Definition: vf_showinfo.c:53
static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)
static void dump_stereo3d(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:99
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define VF
Definition: vf_showinfo.c:51
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
#define s(width, name)
Definition: cbs_vp9.c:257
Structure describing a single Region Of Interest.
Definition: frame.h:233
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
static volatile int checksum
Definition: adler32.c:30
#define FF_ARRAY_ELEMS(a)
if(ret)
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
Public header for Adler-32 hash function implementation.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:381
#define src1
Definition: h264pred.c:139
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:84
Timecode helpers header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
User data unregistered metadata associated with a video frame.
Definition: frame.h:194
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
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:396
uint8_t * data
Definition: frame.h:216
static const AVFilterPad avfilter_vf_showinfo_outputs[]
Definition: vf_showinfo.c:461
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
Mastering display metadata capable of representing the color volume of the display used to master the...
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:181
byte swapping routines
static void dump_roi(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:133
const char * name
Filter name.
Definition: avfilter.h:148
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
This structure describes how to handle spherical videos, outlining information about projection...
Definition: spherical.h:82
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
unsigned int nb_blocks
Number of blocks in the array.
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
char * av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:150
enum AVFrameSideDataType type
Definition: frame.h:215
#define SIZE_SPECIFIER
Definition: internal.h:229
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
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
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2942
Stereoscopic video.
static void dump_content_light_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:181
int den
Denominator.
Definition: rational.h:60
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:128
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:460
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
int len
static void dump_mastering_display(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:155
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
enum AVColorPrimaries color_primaries
Definition: frame.h:554
Encoding parameters for a video frame, as described by AVVideoEncParams.
Definition: frame.h:186
An instance of a filter.
Definition: avfilter.h:338
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
int height
Definition: frame.h:366
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:556
static void dump_video_enc_params(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:190
internal API functions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
Stereoscopic 3d metadata.
Definition: frame.h:63
unsigned MaxFALL
Max average light level per frame (cd/m^2).
static void update_sample_stats_8(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
Definition: vf_showinfo.c:269
int i
Definition: input.c:407
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AVFilter ff_vf_showinfo
Definition: vf_showinfo.c:470