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"
37 
38 #include "avfilter.h"
39 #include "internal.h"
40 #include "video.h"
41 
42 typedef struct ShowInfoContext {
43  const AVClass *class;
46 
47 #define OFFSET(x) offsetof(ShowInfoContext, x)
48 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
49 
50 static const AVOption showinfo_options[] = {
51  { "checksum", "calculate checksums", OFFSET(calculate_checksums), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, VF },
52  { NULL }
53 };
54 
55 AVFILTER_DEFINE_CLASS(showinfo);
56 
58 {
59  AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
60  double yaw, pitch, roll;
61 
62  av_log(ctx, AV_LOG_INFO, "spherical information: ");
63  if (sd->size < sizeof(*spherical)) {
64  av_log(ctx, AV_LOG_INFO, "invalid data");
65  return;
66  }
67 
68  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR)
69  av_log(ctx, AV_LOG_INFO, "equirectangular ");
70  else if (spherical->projection == AV_SPHERICAL_CUBEMAP)
71  av_log(ctx, AV_LOG_INFO, "cubemap ");
72  else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE)
73  av_log(ctx, AV_LOG_INFO, "tiled equirectangular ");
74  else {
75  av_log(ctx, AV_LOG_WARNING, "unknown");
76  return;
77  }
78 
79  yaw = ((double)spherical->yaw) / (1 << 16);
80  pitch = ((double)spherical->pitch) / (1 << 16);
81  roll = ((double)spherical->roll) / (1 << 16);
82  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
83 
85  size_t l, t, r, b;
86  av_spherical_tile_bounds(spherical, frame->width, frame->height,
87  &l, &t, &r, &b);
88  av_log(ctx, AV_LOG_INFO,
90  l, t, r, b);
91  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
92  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
93  }
94 }
95 
97 {
98  AVStereo3D *stereo;
99 
100  av_log(ctx, AV_LOG_INFO, "stereoscopic information: ");
101  if (sd->size < sizeof(*stereo)) {
102  av_log(ctx, AV_LOG_INFO, "invalid data");
103  return;
104  }
105 
106  stereo = (AVStereo3D *)sd->data;
107 
108  av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
109 
110  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
111  av_log(ctx, AV_LOG_INFO, " (inverted)");
112 }
113 
115 {
116  const char *color_range_str = av_color_range_name(frame->color_range);
117  const char *colorspace_str = av_color_space_name(frame->colorspace);
118  const char *color_primaries_str = av_color_primaries_name(frame->color_primaries);
119  const char *color_trc_str = av_color_transfer_name(frame->color_trc);
120 
121  if (!color_range_str || frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
122  av_log(ctx, AV_LOG_INFO, "color_range:unknown");
123  } else {
124  av_log(ctx, AV_LOG_INFO, "color_range:%s", color_range_str);
125  }
126 
127  if (!colorspace_str || frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
128  av_log(ctx, AV_LOG_INFO, " color_space:unknown");
129  } else {
130  av_log(ctx, AV_LOG_INFO, " color_space:%s", colorspace_str);
131  }
132 
133  if (!color_primaries_str || frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
134  av_log(ctx, AV_LOG_INFO, " color_primaries:unknown");
135  } else {
136  av_log(ctx, AV_LOG_INFO, " color_primaries:%s", color_primaries_str);
137  }
138 
139  if (!color_trc_str || frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
140  av_log(ctx, AV_LOG_INFO, " color_trc:unknown");
141  } else {
142  av_log(ctx, AV_LOG_INFO, " color_trc:%s", color_trc_str);
143  }
144  av_log(ctx, AV_LOG_INFO, "\n");
145 }
146 
147 static void update_sample_stats(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
148 {
149  int i;
150 
151  for (i = 0; i < len; i++) {
152  *sum += src[i];
153  *sum2 += src[i] * src[i];
154  }
155 }
156 
158 {
159  AVFilterContext *ctx = inlink->dst;
160  ShowInfoContext *s = ctx->priv;
162  uint32_t plane_checksum[4] = {0}, checksum = 0;
163  int64_t sum[4] = {0}, sum2[4] = {0};
164  int32_t pixelcount[4] = {0};
165  int i, plane, vsub = desc->log2_chroma_h;
166 
167  for (plane = 0; plane < 4 && s->calculate_checksums && frame->data[plane] && frame->linesize[plane]; plane++) {
168  uint8_t *data = frame->data[plane];
169  int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
170  int linesize = av_image_get_linesize(frame->format, frame->width, plane);
171 
172  if (linesize < 0)
173  return linesize;
174 
175  for (i = 0; i < h; i++) {
176  plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
177  checksum = av_adler32_update(checksum, data, linesize);
178 
179  update_sample_stats(data, linesize, sum+plane, sum2+plane);
180  pixelcount[plane] += linesize;
181  data += frame->linesize[plane];
182  }
183  }
184 
185  av_log(ctx, AV_LOG_INFO,
186  "n:%4"PRId64" pts:%7s pts_time:%-7s pos:%9"PRId64" "
187  "fmt:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c ",
188  inlink->frame_count_out,
189  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base), frame->pkt_pos,
190  desc->name,
192  frame->width, frame->height,
193  !frame->interlaced_frame ? 'P' : /* Progressive */
194  frame->top_field_first ? 'T' : 'B', /* Top / Bottom */
195  frame->key_frame,
197 
198  if (s->calculate_checksums) {
199  av_log(ctx, AV_LOG_INFO,
200  "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
201  checksum, plane_checksum[0]);
202 
203  for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
204  av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
205  av_log(ctx, AV_LOG_INFO, "] mean:[");
206  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
207  av_log(ctx, AV_LOG_INFO, "%"PRId64" ", (sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
208  av_log(ctx, AV_LOG_INFO, "\b] stdev:[");
209  for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
210  av_log(ctx, AV_LOG_INFO, "%3.1f ",
211  sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
212  av_log(ctx, AV_LOG_INFO, "\b]");
213  }
214  av_log(ctx, AV_LOG_INFO, "\n");
215 
216  for (i = 0; i < frame->nb_side_data; i++) {
217  AVFrameSideData *sd = frame->side_data[i];
218 
219  av_log(ctx, AV_LOG_INFO, " side data - ");
220  switch (sd->type) {
222  av_log(ctx, AV_LOG_INFO, "pan/scan");
223  break;
225  av_log(ctx, AV_LOG_INFO, "A/53 closed captions (%d bytes)", sd->size);
226  break;
228  dump_spherical(ctx, frame, sd);
229  break;
231  dump_stereo3d(ctx, sd);
232  break;
234  uint32_t *tc = (uint32_t*)sd->data;
235  for (int j = 1; j <= tc[0]; j++) {
236  char tcbuf[AV_TIMECODE_STR_SIZE];
237  av_timecode_make_smpte_tc_string(tcbuf, tc[j], 0);
238  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
239  }
240  break;
241  }
243  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
245  break;
246  case AV_FRAME_DATA_AFD:
247  av_log(ctx, AV_LOG_INFO, "afd: value of %"PRIu8, sd->data[0]);
248  break;
249  default:
250  av_log(ctx, AV_LOG_WARNING, "unknown side data type %d (%d bytes)",
251  sd->type, sd->size);
252  break;
253  }
254 
255  av_log(ctx, AV_LOG_INFO, "\n");
256  }
257 
258  dump_color_property(ctx, frame);
259 
260  return ff_filter_frame(inlink->dst->outputs[0], frame);
261 }
262 
264 {
265 
266  av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
267  is_out ? "out" : "in",
268  link->time_base.num, link->time_base.den,
269  link->frame_rate.num, link->frame_rate.den);
270 
271  return 0;
272 }
273 
275 {
276  AVFilterContext *ctx = link->dst;
277  return config_props(ctx, link, 0);
278 }
279 
281 {
282  AVFilterContext *ctx = link->src;
283  return config_props(ctx, link, 1);
284 }
285 
287  {
288  .name = "default",
289  .type = AVMEDIA_TYPE_VIDEO,
290  .filter_frame = filter_frame,
291  .config_props = config_props_in,
292  },
293  { NULL }
294 };
295 
297  {
298  .name = "default",
299  .type = AVMEDIA_TYPE_VIDEO,
300  .config_props = config_props_out,
301  },
302  { NULL }
303 };
304 
306  .name = "showinfo",
307  .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
308  .inputs = avfilter_vf_showinfo_inputs,
309  .outputs = avfilter_vf_showinfo_outputs,
310  .priv_size = sizeof(ShowInfoContext),
311  .priv_class = &showinfo_class,
312 };
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:280
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
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:268
static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, AVFrameSideData *sd)
Definition: vf_showinfo.c:57
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:539
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
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:47
#define tc
Definition: regdef.h:69
int calculate_checksums
Definition: vf_showinfo.c:44
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:56
#define src
Definition: vp8dsp.c:254
static const AVFilterPad avfilter_vf_showinfo_inputs[]
Definition: vf_showinfo.c:286
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_showinfo.c:157
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2915
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:1080
uint8_t
static void dump_color_property(AVFilterContext *ctx, AVFrame *frame)
Definition: vf_showinfo.c:114
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:274
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:361
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
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:415
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:480
AVFrameSideData ** side_data
Definition: frame.h:479
#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)
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
int width
Definition: frame.h:326
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:512
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:147
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:523
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:351
static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
Definition: vf_showinfo.c:263
Spherical video.
static const AVOption showinfo_options[]
Definition: vf_showinfo.c:50
static void dump_stereo3d(AVFilterContext *ctx, AVFrameSideData *sd)
Definition: vf_showinfo.c:96
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define VF
Definition: vf_showinfo.c:48
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
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
static volatile int checksum
Definition: adler32.c:30
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:341
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:299
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:356
uint8_t * data
Definition: frame.h:203
static const AVFilterPad avfilter_vf_showinfo_outputs[]
Definition: vf_showinfo.c:296
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
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
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:282
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.
int den
Denominator.
Definition: rational.h:60
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:420
#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
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:346
enum AVColorPrimaries color_primaries
Definition: frame.h:514
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:326
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:516
internal API functions
Stereoscopic 3d metadata.
Definition: frame.h:63
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:305