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/adler32.h"
28 #include "libavutil/display.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/spherical.h"
34 #include "libavutil/stereo3d.h"
35 #include "libavutil/timestamp.h"
36 #include "libavutil/timecode.h"
38 
39 #include "avfilter.h"
40 #include "internal.h"
41 #include "video.h"
42 
43 typedef struct ShowInfoContext {
44  const AVClass *class;
47 
48 #define OFFSET(x) offsetof(ShowInfoContext, x)
49 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
50 
51 static const AVOption showinfo_options[] = {
52  { "checksum", "calculate checksums", OFFSET(calculate_checksums), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, VF },
53  { NULL }
54 };
55 
56 AVFILTER_DEFINE_CLASS(showinfo);
57 
59 {
60  AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
61  double yaw, pitch, roll;
62 
63  av_log(ctx, AV_LOG_INFO, "spherical information: ");
64  if (sd->size < sizeof(*spherical)) {
65  av_log(ctx, AV_LOG_ERROR, "invalid data");
66  return;
67  }
68 
69  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR)
70  av_log(ctx, AV_LOG_INFO, "equirectangular ");
71  else if (spherical->projection == AV_SPHERICAL_CUBEMAP)
72  av_log(ctx, AV_LOG_INFO, "cubemap ");
73  else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE)
74  av_log(ctx, AV_LOG_INFO, "tiled equirectangular ");
75  else {
76  av_log(ctx, AV_LOG_WARNING, "unknown");
77  return;
78  }
79 
80  yaw = ((double)spherical->yaw) / (1 << 16);
81  pitch = ((double)spherical->pitch) / (1 << 16);
82  roll = ((double)spherical->roll) / (1 << 16);
83  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
84 
86  size_t l, t, r, b;
87  av_spherical_tile_bounds(spherical, frame->width, frame->height,
88  &l, &t, &r, &b);
89  av_log(ctx, AV_LOG_INFO,
91  l, t, r, b);
92  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
93  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
94  }
95 }
96 
98 {
99  AVStereo3D *stereo;
100 
101  av_log(ctx, AV_LOG_INFO, "stereoscopic information: ");
102  if (sd->size < sizeof(*stereo)) {
103  av_log(ctx, AV_LOG_ERROR, "invalid data");
104  return;
105  }
106 
107  stereo = (AVStereo3D *)sd->data;
108 
109  av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
110 
111  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
112  av_log(ctx, AV_LOG_INFO, " (inverted)");
113 }
114 
116 {
117  int nb_rois;
118  const AVRegionOfInterest *roi;
119  uint32_t roi_size;
120 
121  roi = (const AVRegionOfInterest *)sd->data;
122  roi_size = roi->self_size;
123  if (!roi_size || sd->size % roi_size != 0) {
124  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.");
125  return;
126  }
127  nb_rois = sd->size / roi_size;
128 
129  av_log(ctx, AV_LOG_INFO, "Regions Of Interest(RoI) information: ");
130  for (int i = 0; i < nb_rois; i++) {
131  roi = (const AVRegionOfInterest *)(sd->data + roi_size * i);
132  av_log(ctx, AV_LOG_INFO, "index: %d, region: (%d, %d)/(%d, %d), qp offset: %d/%d.\n",
133  i, roi->left, roi->top, roi->right, roi->bottom, roi->qoffset.num, roi->qoffset.den);
134  }
135 }
136 
138 {
139  AVMasteringDisplayMetadata *mastering_display;
140 
141  av_log(ctx, AV_LOG_INFO, "mastering display: ");
142  if (sd->size < sizeof(*mastering_display)) {
143  av_log(ctx, AV_LOG_ERROR, "invalid data");
144  return;
145  }
146 
147  mastering_display = (AVMasteringDisplayMetadata *)sd->data;
148 
149  av_log(ctx, AV_LOG_INFO, "has_primaries:%d has_luminance:%d "
150  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
151  "min_luminance=%f, max_luminance=%f",
152  mastering_display->has_primaries, mastering_display->has_luminance,
153  av_q2d(mastering_display->display_primaries[0][0]),
154  av_q2d(mastering_display->display_primaries[0][1]),
155  av_q2d(mastering_display->display_primaries[1][0]),
156  av_q2d(mastering_display->display_primaries[1][1]),
157  av_q2d(mastering_display->display_primaries[2][0]),
158  av_q2d(mastering_display->display_primaries[2][1]),
159  av_q2d(mastering_display->white_point[0]), av_q2d(mastering_display->white_point[1]),
160  av_q2d(mastering_display->min_luminance), av_q2d(mastering_display->max_luminance));
161 }
162 
164 {
166 
167  av_log(ctx, AV_LOG_INFO, "Content Light Level information: "
168  "MaxCLL=%d, MaxFALL=%d",
169  metadata->MaxCLL, metadata->MaxFALL);
170 }
171 
173 {
174  const char *color_range_str = av_color_range_name(frame->color_range);
175  const char *colorspace_str = av_color_space_name(frame->colorspace);
176  const char *color_primaries_str = av_color_primaries_name(frame->color_primaries);
177  const char *color_trc_str = av_color_transfer_name(frame->color_trc);
178 
179  if (!color_range_str || frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
180  av_log(ctx, AV_LOG_INFO, "color_range:unknown");
181  } else {
182  av_log(ctx, AV_LOG_INFO, "color_range:%s", color_range_str);
183  }
184 
185  if (!colorspace_str || frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
186  av_log(ctx, AV_LOG_INFO, " color_space:unknown");
187  } else {
188  av_log(ctx, AV_LOG_INFO, " color_space:%s", colorspace_str);
189  }
190 
191  if (!color_primaries_str || frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
192  av_log(ctx, AV_LOG_INFO, " color_primaries:unknown");
193  } else {
194  av_log(ctx, AV_LOG_INFO, " color_primaries:%s", color_primaries_str);
195  }
196 
197  if (!color_trc_str || frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
198  av_log(ctx, AV_LOG_INFO, " color_trc:unknown");
199  } else {
200  av_log(ctx, AV_LOG_INFO, " color_trc:%s", color_trc_str);
201  }
202  av_log(ctx, AV_LOG_INFO, "\n");
203 }
204 
205 static void update_sample_stats(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
206 {
207  int i;
208 
209  for (i = 0; i < len; i++) {
210  *sum += src[i];
211  *sum2 += src[i] * src[i];
212  }
213 }
214 
216 {
217  AVFilterContext *ctx = inlink->dst;
218  ShowInfoContext *s = ctx->priv;
220  uint32_t plane_checksum[4] = {0}, checksum = 0;
221  int64_t sum[4] = {0}, sum2[4] = {0};
222  int32_t pixelcount[4] = {0};
223  int i, plane, vsub = desc->log2_chroma_h;
224 
225  for (plane = 0; plane < 4 && s->calculate_checksums && frame->data[plane] && frame->linesize[plane]; plane++) {
226  uint8_t *data = frame->data[plane];
227  int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
228  int linesize = av_image_get_linesize(frame->format, frame->width, plane);
229 
230  if (linesize < 0)
231  return linesize;
232 
233  for (i = 0; i < h; i++) {
234  plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
235  checksum = av_adler32_update(checksum, data, linesize);
236 
237  update_sample_stats(data, linesize, sum+plane, sum2+plane);
238  pixelcount[plane] += linesize;
239  data += frame->linesize[plane];
240  }
241  }
242 
243  av_log(ctx, AV_LOG_INFO,
244  "n:%4"PRId64" pts:%7s pts_time:%-7s pos:%9"PRId64" "
245  "fmt:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c ",
246  inlink->frame_count_out,
247  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base), frame->pkt_pos,
248  desc->name,
250  frame->width, frame->height,
251  !frame->interlaced_frame ? 'P' : /* Progressive */
252  frame->top_field_first ? 'T' : 'B', /* Top / Bottom */
253  frame->key_frame,
255 
256  if (s->calculate_checksums) {
257  av_log(ctx, AV_LOG_INFO,
258  "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
259  checksum, plane_checksum[0]);
260 
261  for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
262  av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
263  av_log(ctx, AV_LOG_INFO, "] mean:[");
264  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
265  av_log(ctx, AV_LOG_INFO, "%"PRId64" ", (sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
266  av_log(ctx, AV_LOG_INFO, "\b] stdev:[");
267  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
268  av_log(ctx, AV_LOG_INFO, "%3.1f ",
269  sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
270  av_log(ctx, AV_LOG_INFO, "\b]");
271  }
272  av_log(ctx, AV_LOG_INFO, "\n");
273 
274  for (i = 0; i < frame->nb_side_data; i++) {
275  AVFrameSideData *sd = frame->side_data[i];
276 
277  av_log(ctx, AV_LOG_INFO, " side data - ");
278  switch (sd->type) {
280  av_log(ctx, AV_LOG_INFO, "pan/scan");
281  break;
283  av_log(ctx, AV_LOG_INFO, "A/53 closed captions (%d bytes)", sd->size);
284  break;
286  dump_spherical(ctx, frame, sd);
287  break;
289  dump_stereo3d(ctx, sd);
290  break;
292  uint32_t *tc = (uint32_t*)sd->data;
293  for (int j = 1; j <= tc[0]; j++) {
294  char tcbuf[AV_TIMECODE_STR_SIZE];
295  av_timecode_make_smpte_tc_string(tcbuf, tc[j], 0);
296  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
297  }
298  break;
299  }
301  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
303  break;
304  case AV_FRAME_DATA_AFD:
305  av_log(ctx, AV_LOG_INFO, "afd: value of %"PRIu8, sd->data[0]);
306  break;
308  dump_roi(ctx, sd);
309  break;
311  dump_mastering_display(ctx, sd);
312  break;
315  break;
317  char tcbuf[AV_TIMECODE_STR_SIZE];
318  av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
319  av_log(ctx, AV_LOG_INFO, "GOP timecode - %s", tcbuf);
320  break;
321  }
322  default:
323  av_log(ctx, AV_LOG_WARNING, "unknown side data type %d (%d bytes)",
324  sd->type, sd->size);
325  break;
326  }
327 
328  av_log(ctx, AV_LOG_INFO, "\n");
329  }
330 
331  dump_color_property(ctx, frame);
332 
333  return ff_filter_frame(inlink->dst->outputs[0], frame);
334 }
335 
337 {
338 
339  av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
340  is_out ? "out" : "in",
341  link->time_base.num, link->time_base.den,
342  link->frame_rate.num, link->frame_rate.den);
343 
344  return 0;
345 }
346 
348 {
349  AVFilterContext *ctx = link->dst;
350  return config_props(ctx, link, 0);
351 }
352 
354 {
355  AVFilterContext *ctx = link->src;
356  return config_props(ctx, link, 1);
357 }
358 
360  {
361  .name = "default",
362  .type = AVMEDIA_TYPE_VIDEO,
363  .filter_frame = filter_frame,
364  .config_props = config_props_in,
365  },
366  { NULL }
367 };
368 
370  {
371  .name = "default",
372  .type = AVMEDIA_TYPE_VIDEO,
373  .config_props = config_props_out,
374  },
375  { NULL }
376 };
377 
379  .name = "showinfo",
380  .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
381  .inputs = avfilter_vf_showinfo_inputs,
382  .outputs = avfilter_vf_showinfo_outputs,
383  .priv_size = sizeof(ShowInfoContext),
384  .priv_class = &showinfo_class,
385 };
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
int plane
Definition: avisynth_c.h:384
#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:353
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:2522
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:58
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 OFFSET(x)
Definition: vf_showinfo.c:48
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
#define tc
Definition: regdef.h:69
int calculate_checksums
Definition: vf_showinfo.c:45
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.
#define src
Definition: vp8dsp.c:254
static const AVFilterPad avfilter_vf_showinfo_inputs[]
Definition: vf_showinfo.c:359
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_showinfo.c:215
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2915
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:1093
uint8_t
static void dump_color_property(AVFilterContext *ctx, AVFrame *frame)
Definition: vf_showinfo.c:172
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:347
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2848
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
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
static void update_sample_stats(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
Definition: vf_showinfo.c:205
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:2867
common internal API header
#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:336
Spherical video.
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
static const AVOption showinfo_options[]
Definition: vf_showinfo.c:51
static void dump_stereo3d(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:97
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define VF
Definition: vf_showinfo.c:49
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
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
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:369
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
static void dump_roi(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:115
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:2891
Stereoscopic video.
static void dump_content_light_metadata(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:163
int den
Denominator.
Definition: rational.h:60
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:137
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
Stereoscopic 3d metadata.
Definition: frame.h:63
unsigned MaxFALL
Max average light level per frame (cd/m^2).
for(j=16;j >0;--j)
#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:378