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"
39 
40 #include "avfilter.h"
41 #include "internal.h"
42 #include "video.h"
43 
44 typedef struct ShowInfoContext {
45  const AVClass *class;
48 
49 #define OFFSET(x) offsetof(ShowInfoContext, x)
50 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
51 
52 static const AVOption showinfo_options[] = {
53  { "checksum", "calculate checksums", OFFSET(calculate_checksums), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, VF },
54  { NULL }
55 };
56 
57 AVFILTER_DEFINE_CLASS(showinfo);
58 
60 {
61  AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
62  double yaw, pitch, roll;
63 
64  av_log(ctx, AV_LOG_INFO, "spherical information: ");
65  if (sd->size < sizeof(*spherical)) {
66  av_log(ctx, AV_LOG_ERROR, "invalid data");
67  return;
68  }
69 
70  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR)
71  av_log(ctx, AV_LOG_INFO, "equirectangular ");
72  else if (spherical->projection == AV_SPHERICAL_CUBEMAP)
73  av_log(ctx, AV_LOG_INFO, "cubemap ");
74  else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE)
75  av_log(ctx, AV_LOG_INFO, "tiled equirectangular ");
76  else {
77  av_log(ctx, AV_LOG_WARNING, "unknown");
78  return;
79  }
80 
81  yaw = ((double)spherical->yaw) / (1 << 16);
82  pitch = ((double)spherical->pitch) / (1 << 16);
83  roll = ((double)spherical->roll) / (1 << 16);
84  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
85 
87  size_t l, t, r, b;
88  av_spherical_tile_bounds(spherical, frame->width, frame->height,
89  &l, &t, &r, &b);
90  av_log(ctx, AV_LOG_INFO,
92  l, t, r, b);
93  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
94  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
95  }
96 }
97 
99 {
100  AVStereo3D *stereo;
101 
102  av_log(ctx, AV_LOG_INFO, "stereoscopic information: ");
103  if (sd->size < sizeof(*stereo)) {
104  av_log(ctx, AV_LOG_ERROR, "invalid data");
105  return;
106  }
107 
108  stereo = (AVStereo3D *)sd->data;
109 
110  av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
111 
112  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
113  av_log(ctx, AV_LOG_INFO, " (inverted)");
114 }
115 
117 {
118  int nb_rois;
119  const AVRegionOfInterest *roi;
120  uint32_t roi_size;
121 
122  roi = (const AVRegionOfInterest *)sd->data;
123  roi_size = roi->self_size;
124  if (!roi_size || sd->size % roi_size != 0) {
125  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.");
126  return;
127  }
128  nb_rois = sd->size / roi_size;
129 
130  av_log(ctx, AV_LOG_INFO, "Regions Of Interest(RoI) information: ");
131  for (int i = 0; i < nb_rois; i++) {
132  roi = (const AVRegionOfInterest *)(sd->data + roi_size * i);
133  av_log(ctx, AV_LOG_INFO, "index: %d, region: (%d, %d)/(%d, %d), qp offset: %d/%d.\n",
134  i, roi->left, roi->top, roi->right, roi->bottom, roi->qoffset.num, roi->qoffset.den);
135  }
136 }
137 
139 {
140  AVMasteringDisplayMetadata *mastering_display;
141 
142  av_log(ctx, AV_LOG_INFO, "mastering display: ");
143  if (sd->size < sizeof(*mastering_display)) {
144  av_log(ctx, AV_LOG_ERROR, "invalid data");
145  return;
146  }
147 
148  mastering_display = (AVMasteringDisplayMetadata *)sd->data;
149 
150  av_log(ctx, AV_LOG_INFO, "has_primaries:%d has_luminance:%d "
151  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
152  "min_luminance=%f, max_luminance=%f",
153  mastering_display->has_primaries, mastering_display->has_luminance,
154  av_q2d(mastering_display->display_primaries[0][0]),
155  av_q2d(mastering_display->display_primaries[0][1]),
156  av_q2d(mastering_display->display_primaries[1][0]),
157  av_q2d(mastering_display->display_primaries[1][1]),
158  av_q2d(mastering_display->display_primaries[2][0]),
159  av_q2d(mastering_display->display_primaries[2][1]),
160  av_q2d(mastering_display->white_point[0]), av_q2d(mastering_display->white_point[1]),
161  av_q2d(mastering_display->min_luminance), av_q2d(mastering_display->max_luminance));
162 }
163 
165 {
167 
168  av_log(ctx, AV_LOG_INFO, "Content Light Level information: "
169  "MaxCLL=%d, MaxFALL=%d",
170  metadata->MaxCLL, metadata->MaxFALL);
171 }
172 
174 {
175  const char *color_range_str = av_color_range_name(frame->color_range);
176  const char *colorspace_str = av_color_space_name(frame->colorspace);
177  const char *color_primaries_str = av_color_primaries_name(frame->color_primaries);
178  const char *color_trc_str = av_color_transfer_name(frame->color_trc);
179 
180  if (!color_range_str || frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
181  av_log(ctx, AV_LOG_INFO, "color_range:unknown");
182  } else {
183  av_log(ctx, AV_LOG_INFO, "color_range:%s", color_range_str);
184  }
185 
186  if (!colorspace_str || frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
187  av_log(ctx, AV_LOG_INFO, " color_space:unknown");
188  } else {
189  av_log(ctx, AV_LOG_INFO, " color_space:%s", colorspace_str);
190  }
191 
192  if (!color_primaries_str || frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
193  av_log(ctx, AV_LOG_INFO, " color_primaries:unknown");
194  } else {
195  av_log(ctx, AV_LOG_INFO, " color_primaries:%s", color_primaries_str);
196  }
197 
198  if (!color_trc_str || frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
199  av_log(ctx, AV_LOG_INFO, " color_trc:unknown");
200  } else {
201  av_log(ctx, AV_LOG_INFO, " color_trc:%s", color_trc_str);
202  }
203  av_log(ctx, AV_LOG_INFO, "\n");
204 }
205 
206 static void update_sample_stats_8(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
207 {
208  int i;
209 
210  for (i = 0; i < len; i++) {
211  *sum += src[i];
212  *sum2 += src[i] * src[i];
213  }
214 }
215 
216 static void update_sample_stats_16(int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
217 {
218  const uint16_t *src1 = (const uint16_t *)src;
219  int i;
220 
221  for (i = 0; i < len / 2; i++) {
222  if ((HAVE_BIGENDIAN && !be) || (!HAVE_BIGENDIAN && be)) {
223  *sum += av_bswap16(src1[i]);
224  *sum2 += (uint32_t)av_bswap16(src1[i]) * (uint32_t)av_bswap16(src1[i]);
225  } else {
226  *sum += src1[i];
227  *sum2 += (uint32_t)src1[i] * (uint32_t)src1[i];
228  }
229  }
230 }
231 
232 static void update_sample_stats(int depth, int be, const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
233 {
234  if (depth <= 8)
235  update_sample_stats_8(src, len, sum, sum2);
236  else
237  update_sample_stats_16(be, src, len, sum, sum2);
238 }
239 
241 {
242  AVFilterContext *ctx = inlink->dst;
243  ShowInfoContext *s = ctx->priv;
245  uint32_t plane_checksum[4] = {0}, checksum = 0;
246  int64_t sum[4] = {0}, sum2[4] = {0};
247  int32_t pixelcount[4] = {0};
248  int bitdepth = desc->comp[0].depth;
249  int be = desc->flags & AV_PIX_FMT_FLAG_BE;
250  int i, plane, vsub = desc->log2_chroma_h;
251 
252  for (plane = 0; plane < 4 && s->calculate_checksums && frame->data[plane] && frame->linesize[plane]; plane++) {
253  uint8_t *data = frame->data[plane];
254  int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
255  int linesize = av_image_get_linesize(frame->format, frame->width, plane);
256  int width = linesize >> (bitdepth > 8);
257 
258  if (linesize < 0)
259  return linesize;
260 
261  for (i = 0; i < h; i++) {
262  plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
263  checksum = av_adler32_update(checksum, data, linesize);
264 
265  update_sample_stats(bitdepth, be, data, linesize, sum+plane, sum2+plane);
266  pixelcount[plane] += width;
267  data += frame->linesize[plane];
268  }
269  }
270 
271  av_log(ctx, AV_LOG_INFO,
272  "n:%4"PRId64" pts:%7s pts_time:%-7s pos:%9"PRId64" "
273  "fmt:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c ",
274  inlink->frame_count_out,
275  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base), frame->pkt_pos,
276  desc->name,
278  frame->width, frame->height,
279  !frame->interlaced_frame ? 'P' : /* Progressive */
280  frame->top_field_first ? 'T' : 'B', /* Top / Bottom */
281  frame->key_frame,
283 
284  if (s->calculate_checksums) {
285  av_log(ctx, AV_LOG_INFO,
286  "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
287  checksum, plane_checksum[0]);
288 
289  for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
290  av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
291  av_log(ctx, AV_LOG_INFO, "] mean:[");
292  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
293  av_log(ctx, AV_LOG_INFO, "%"PRId64" ", (sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
294  av_log(ctx, AV_LOG_INFO, "\b] stdev:[");
295  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
296  av_log(ctx, AV_LOG_INFO, "%3.1f ",
297  sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
298  av_log(ctx, AV_LOG_INFO, "\b]");
299  }
300  av_log(ctx, AV_LOG_INFO, "\n");
301 
302  for (i = 0; i < frame->nb_side_data; i++) {
303  AVFrameSideData *sd = frame->side_data[i];
304 
305  av_log(ctx, AV_LOG_INFO, " side data - ");
306  switch (sd->type) {
308  av_log(ctx, AV_LOG_INFO, "pan/scan");
309  break;
311  av_log(ctx, AV_LOG_INFO, "A/53 closed captions (%d bytes)", sd->size);
312  break;
314  dump_spherical(ctx, frame, sd);
315  break;
317  dump_stereo3d(ctx, sd);
318  break;
320  uint32_t *tc = (uint32_t*)sd->data;
321  int m = FFMIN(tc[0],3);
322  if (sd->size != 16) {
323  av_log(ctx, AV_LOG_ERROR, "invalid data");
324  break;
325  }
326  for (int j = 1; j <= m; j++) {
327  char tcbuf[AV_TIMECODE_STR_SIZE];
328  av_timecode_make_smpte_tc_string(tcbuf, tc[j], 0);
329  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != m ? ", " : "");
330  }
331  break;
332  }
334  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
336  break;
337  case AV_FRAME_DATA_AFD:
338  av_log(ctx, AV_LOG_INFO, "afd: value of %"PRIu8, sd->data[0]);
339  break;
341  dump_roi(ctx, sd);
342  break;
344  dump_mastering_display(ctx, sd);
345  break;
348  break;
350  char tcbuf[AV_TIMECODE_STR_SIZE];
351  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
352  av_log(ctx, AV_LOG_INFO, "GOP timecode - %s", tcbuf);
353  break;
354  }
355  default:
356  av_log(ctx, AV_LOG_WARNING, "unknown side data type %d (%d bytes)",
357  sd->type, sd->size);
358  break;
359  }
360 
361  av_log(ctx, AV_LOG_INFO, "\n");
362  }
363 
364  dump_color_property(ctx, frame);
365 
366  return ff_filter_frame(inlink->dst->outputs[0], frame);
367 }
368 
370 {
371 
372  av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
373  is_out ? "out" : "in",
374  link->time_base.num, link->time_base.den,
375  link->frame_rate.num, link->frame_rate.den);
376 
377  return 0;
378 }
379 
381 {
382  AVFilterContext *ctx = link->dst;
383  return config_props(ctx, link, 0);
384 }
385 
387 {
388  AVFilterContext *ctx = link->src;
389  return config_props(ctx, link, 1);
390 }
391 
393  {
394  .name = "default",
395  .type = AVMEDIA_TYPE_VIDEO,
396  .filter_frame = filter_frame,
397  .config_props = config_props_in,
398  },
399  { NULL }
400 };
401 
403  {
404  .name = "default",
405  .type = AVMEDIA_TYPE_VIDEO,
406  .config_props = config_props_out,
407  },
408  { NULL }
409 };
410 
412  .name = "showinfo",
413  .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
414  .inputs = avfilter_vf_showinfo_inputs,
415  .outputs = avfilter_vf_showinfo_outputs,
416  .priv_size = sizeof(ShowInfoContext),
417  .priv_class = &showinfo_class,
418 };
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:386
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
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:235
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, AVFrameSideData *sd)
Definition: vf_showinfo.c:59
unsigned MaxCLL
Max content light level (cd/m^2).
AVOption.
Definition: opt.h:246
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:566
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
Main libavfilter public API header.
const char * desc
Definition: nvenc.c:68
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:49
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:130
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:232
#define tc
Definition: regdef.h:69
int calculate_checksums
Definition: vf_showinfo.c:46
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:392
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_showinfo.c:240
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2942
AVRational qoffset
Quantisation offset.
Definition: frame.h:262
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:1075
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:173
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:380
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2875
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:388
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:52
Structure to hold side data for an AVFrame.
Definition: frame.h:201
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:442
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:225
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:507
AVFrameSideData ** side_data
Definition: frame.h:506
#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).
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:186
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:539
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:550
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:2894
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:216
#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:378
static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
Definition: vf_showinfo.c:369
Spherical video.
#define FFMIN(a, b)
Definition: common.h:96
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
#define width
static const AVOption showinfo_options[]
Definition: vf_showinfo.c:52
static void dump_stereo3d(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:98
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define VF
Definition: vf_showinfo.c:50
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:220
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
static volatile int checksum
Definition: adler32.c:30
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:368
#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:187
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:326
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
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:383
uint8_t * data
Definition: frame.h:203
static const AVFilterPad avfilter_vf_showinfo_outputs[]
Definition: vf_showinfo.c:402
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:116
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
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:118
enum AVFrameSideDataType type
Definition: frame.h:202
#define SIZE_SPECIFIER
Definition: internal.h:262
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
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:2918
Stereoscopic video.
static void dump_content_light_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:164
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:447
#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:138
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
enum AVColorPrimaries color_primaries
Definition: frame.h:541
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:353
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:543
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:206
#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:411