FFmpeg
dump.c
Go to the documentation of this file.
1 /*
2  * Various pretty-printing functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdio.h>
23 #include <stdint.h>
24 
26 #include "libavutil/display.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/log.h"
30 #include "libavutil/dovi_meta.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/replaygain.h"
35 #include "libavutil/spherical.h"
36 #include "libavutil/stereo3d.h"
37 #include "libavutil/timecode.h"
38 
39 #include "avformat.h"
40 #include "internal.h"
41 
42 #define HEXDUMP_PRINT(...) \
43  do { \
44  if (!f) \
45  av_log(avcl, level, __VA_ARGS__); \
46  else \
47  fprintf(f, __VA_ARGS__); \
48  } while (0)
49 
50 static void hex_dump_internal(void *avcl, FILE *f, int level,
51  const uint8_t *buf, int size)
52 {
53  int len, i, j, c;
54 
55  for (i = 0; i < size; i += 16) {
56  len = size - i;
57  if (len > 16)
58  len = 16;
59  HEXDUMP_PRINT("%08x ", i);
60  for (j = 0; j < 16; j++) {
61  if (j < len)
62  HEXDUMP_PRINT(" %02x", buf[i + j]);
63  else
64  HEXDUMP_PRINT(" ");
65  }
66  HEXDUMP_PRINT(" ");
67  for (j = 0; j < len; j++) {
68  c = buf[i + j];
69  if (c < ' ' || c > '~')
70  c = '.';
71  HEXDUMP_PRINT("%c", c);
72  }
73  HEXDUMP_PRINT("\n");
74  }
75 }
76 
77 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
78 {
79  hex_dump_internal(NULL, f, 0, buf, size);
80 }
81 
82 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
83 {
84  hex_dump_internal(avcl, NULL, level, buf, size);
85 }
86 
87 static void pkt_dump_internal(void *avcl, FILE *f, int level, const AVPacket *pkt,
88  int dump_payload, AVRational time_base)
89 {
90  HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
91  HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
92  HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
93  /* DTS is _always_ valid after av_read_frame() */
94  HEXDUMP_PRINT(" dts=");
95  if (pkt->dts == AV_NOPTS_VALUE)
96  HEXDUMP_PRINT("N/A");
97  else
98  HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
99  /* PTS may not be known if B-frames are present. */
100  HEXDUMP_PRINT(" pts=");
101  if (pkt->pts == AV_NOPTS_VALUE)
102  HEXDUMP_PRINT("N/A");
103  else
104  HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
105  HEXDUMP_PRINT("\n");
106  HEXDUMP_PRINT(" size=%d\n", pkt->size);
107  if (dump_payload)
108  hex_dump_internal(avcl, f, level, pkt->data, pkt->size);
109 }
110 
111 void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st)
112 {
113  pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
114 }
115 
116 void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
117  const AVStream *st)
118 {
119  pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
120 }
121 
122 
123 static void print_fps(double d, const char *postfix)
124 {
125  uint64_t v = lrintf(d * 100);
126  if (!v)
127  av_log(NULL, AV_LOG_INFO, "%1.4f %s", d, postfix);
128  else if (v % 100)
129  av_log(NULL, AV_LOG_INFO, "%3.2f %s", d, postfix);
130  else if (v % (100 * 1000))
131  av_log(NULL, AV_LOG_INFO, "%1.0f %s", d, postfix);
132  else
133  av_log(NULL, AV_LOG_INFO, "%1.0fk %s", d / 1000, postfix);
134 }
135 
136 static void dump_metadata(void *ctx, const AVDictionary *m, const char *indent)
137 {
138  if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
139  const AVDictionaryEntry *tag = NULL;
140 
141  av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
142  while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
143  if (strcmp("language", tag->key)) {
144  const char *p = tag->value;
146  "%s %-16s: ", indent, tag->key);
147  while (*p) {
148  char tmp[256];
149  size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
150  av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
151  av_log(ctx, AV_LOG_INFO, "%s", tmp);
152  p += len;
153  if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
154  if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
155  if (*p) p++;
156  }
157  av_log(ctx, AV_LOG_INFO, "\n");
158  }
159  }
160 }
161 
162 /* param change side data*/
163 static void dump_paramchange(void *ctx, const AVPacketSideData *sd)
164 {
165  int size = sd->size;
166  const uint8_t *data = sd->data;
167  uint32_t flags, sample_rate, width, height;
168 #if FF_API_OLD_CHANNEL_LAYOUT
169  uint32_t channels;
170  uint64_t layout;
171 #endif
172 
173  if (!data || sd->size < 4)
174  goto fail;
175 
176  flags = AV_RL32(data);
177  data += 4;
178  size -= 4;
179 
180 #if FF_API_OLD_CHANNEL_LAYOUT
182  if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
183  if (size < 4)
184  goto fail;
185  channels = AV_RL32(data);
186  data += 4;
187  size -= 4;
188  av_log(ctx, AV_LOG_INFO, "channel count %"PRIu32", ", channels);
189  }
190  if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
191  if (size < 8)
192  goto fail;
193  layout = AV_RL64(data);
194  data += 8;
195  size -= 8;
197  "channel layout: %s, ", av_get_channel_name(layout));
198  }
200 #endif /* FF_API_OLD_CHANNEL_LAYOUT */
202  if (size < 4)
203  goto fail;
205  data += 4;
206  size -= 4;
207  av_log(ctx, AV_LOG_INFO, "sample_rate %"PRIu32", ", sample_rate);
208  }
210  if (size < 8)
211  goto fail;
212  width = AV_RL32(data);
213  data += 4;
214  size -= 4;
215  height = AV_RL32(data);
216  data += 4;
217  size -= 4;
218  av_log(ctx, AV_LOG_INFO, "width %"PRIu32" height %"PRIu32, width, height);
219  }
220 
221  return;
222 fail:
223  av_log(ctx, AV_LOG_ERROR, "unknown param\n");
224 }
225 
226 /* replaygain side data*/
227 static void print_gain(void *ctx, const char *str, int32_t gain)
228 {
229  av_log(ctx, AV_LOG_INFO, "%s - ", str);
230  if (gain == INT32_MIN)
231  av_log(ctx, AV_LOG_INFO, "unknown");
232  else
233  av_log(ctx, AV_LOG_INFO, "%f", gain / 100000.0f);
234  av_log(ctx, AV_LOG_INFO, ", ");
235 }
236 
237 static void print_peak(void *ctx, const char *str, uint32_t peak)
238 {
239  av_log(ctx, AV_LOG_INFO, "%s - ", str);
240  if (!peak)
241  av_log(ctx, AV_LOG_INFO, "unknown");
242  else
243  av_log(ctx, AV_LOG_INFO, "%f", (float) peak / UINT32_MAX);
244  av_log(ctx, AV_LOG_INFO, ", ");
245 }
246 
247 static void dump_replaygain(void *ctx, const AVPacketSideData *sd)
248 {
249  const AVReplayGain *rg;
250 
251  if (sd->size < sizeof(*rg)) {
252  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
253  return;
254  }
255  rg = (const AVReplayGain *)sd->data;
256 
257  print_gain(ctx, "track gain", rg->track_gain);
258  print_peak(ctx, "track peak", rg->track_peak);
259  print_gain(ctx, "album gain", rg->album_gain);
260  print_peak(ctx, "album peak", rg->album_peak);
261 }
262 
263 static void dump_stereo3d(void *ctx, const AVPacketSideData *sd)
264 {
265  const AVStereo3D *stereo;
266 
267  if (sd->size < sizeof(*stereo)) {
268  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
269  return;
270  }
271 
272  stereo = (const AVStereo3D *)sd->data;
273 
274  av_log(ctx, AV_LOG_INFO, "%s", av_stereo3d_type_name(stereo->type));
275 
276  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
277  av_log(ctx, AV_LOG_INFO, " (inverted)");
278 }
279 
280 static void dump_audioservicetype(void *ctx, const AVPacketSideData *sd)
281 {
282  const enum AVAudioServiceType *ast = (const enum AVAudioServiceType *)sd->data;
283 
284  if (sd->size < sizeof(*ast)) {
285  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
286  return;
287  }
288 
289  switch (*ast) {
291  av_log(ctx, AV_LOG_INFO, "main");
292  break;
294  av_log(ctx, AV_LOG_INFO, "effects");
295  break;
297  av_log(ctx, AV_LOG_INFO, "visually impaired");
298  break;
300  av_log(ctx, AV_LOG_INFO, "hearing impaired");
301  break;
303  av_log(ctx, AV_LOG_INFO, "dialogue");
304  break;
306  av_log(ctx, AV_LOG_INFO, "commentary");
307  break;
309  av_log(ctx, AV_LOG_INFO, "emergency");
310  break;
312  av_log(ctx, AV_LOG_INFO, "voice over");
313  break;
315  av_log(ctx, AV_LOG_INFO, "karaoke");
316  break;
317  default:
318  av_log(ctx, AV_LOG_WARNING, "unknown");
319  break;
320  }
321 }
322 
323 static void dump_cpb(void *ctx, const AVPacketSideData *sd)
324 {
325  const AVCPBProperties *cpb = (const AVCPBProperties *)sd->data;
326 
327  if (sd->size < sizeof(*cpb)) {
328  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
329  return;
330  }
331 
333  "bitrate max/min/avg: %"PRId64"/%"PRId64"/%"PRId64" buffer size: %"PRId64" ",
334  cpb->max_bitrate, cpb->min_bitrate, cpb->avg_bitrate,
335  cpb->buffer_size);
336  if (cpb->vbv_delay == UINT64_MAX)
337  av_log(ctx, AV_LOG_INFO, "vbv_delay: N/A");
338  else
339  av_log(ctx, AV_LOG_INFO, "vbv_delay: %"PRIu64"", cpb->vbv_delay);
340 }
341 
343 {
344  const AVMasteringDisplayMetadata *metadata =
345  (const AVMasteringDisplayMetadata *)sd->data;
346  av_log(ctx, AV_LOG_INFO, "Mastering Display Metadata, "
347  "has_primaries:%d has_luminance:%d "
348  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
349  "min_luminance=%f, max_luminance=%f",
350  metadata->has_primaries, metadata->has_luminance,
351  av_q2d(metadata->display_primaries[0][0]),
352  av_q2d(metadata->display_primaries[0][1]),
353  av_q2d(metadata->display_primaries[1][0]),
354  av_q2d(metadata->display_primaries[1][1]),
355  av_q2d(metadata->display_primaries[2][0]),
356  av_q2d(metadata->display_primaries[2][1]),
357  av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]),
358  av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
359 }
360 
361 static void dump_content_light_metadata(void *ctx, const AVPacketSideData *sd)
362 {
363  const AVContentLightMetadata *metadata =
364  (const AVContentLightMetadata *)sd->data;
365  av_log(ctx, AV_LOG_INFO, "Content Light Level Metadata, "
366  "MaxCLL=%d, MaxFALL=%d",
367  metadata->MaxCLL, metadata->MaxFALL);
368 }
369 
370 static void dump_spherical(void *ctx, const AVCodecParameters *par,
371  const AVPacketSideData *sd)
372 {
373  const AVSphericalMapping *spherical = (const AVSphericalMapping *)sd->data;
374  double yaw, pitch, roll;
375 
376  if (sd->size < sizeof(*spherical)) {
377  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
378  return;
379  }
380 
382 
383  yaw = ((double)spherical->yaw) / (1 << 16);
384  pitch = ((double)spherical->pitch) / (1 << 16);
385  roll = ((double)spherical->roll) / (1 << 16);
386  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
387 
388  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
389  size_t l, t, r, b;
390  av_spherical_tile_bounds(spherical, par->width, par->height,
391  &l, &t, &r, &b);
394  l, t, r, b);
395  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
396  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
397  }
398 }
399 
400 static void dump_dovi_conf(void *ctx, const AVPacketSideData *sd)
401 {
404 
405  av_log(ctx, AV_LOG_INFO, "version: %d.%d, profile: %d, level: %d, "
406  "rpu flag: %d, el flag: %d, bl flag: %d, compatibility id: %d",
407  dovi->dv_version_major, dovi->dv_version_minor,
408  dovi->dv_profile, dovi->dv_level,
409  dovi->rpu_present_flag,
410  dovi->el_present_flag,
411  dovi->bl_present_flag,
413 }
414 
415 static void dump_s12m_timecode(void *ctx, const AVStream *st, const AVPacketSideData *sd)
416 {
417  const uint32_t *tc = (const uint32_t *)sd->data;
418 
419  if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
420  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
421  return;
422  }
423 
424  for (int j = 1; j <= tc[0]; j++) {
425  char tcbuf[AV_TIMECODE_STR_SIZE];
427  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
428  }
429 }
430 
431 static void dump_sidedata(void *ctx, const AVStream *st, const char *indent)
432 {
433  int i;
434 
435  if (st->nb_side_data)
436  av_log(ctx, AV_LOG_INFO, "%sSide data:\n", indent);
437 
438  for (i = 0; i < st->nb_side_data; i++) {
439  const AVPacketSideData *sd = &st->side_data[i];
440  av_log(ctx, AV_LOG_INFO, "%s ", indent);
441 
442  switch (sd->type) {
443  case AV_PKT_DATA_PALETTE:
444  av_log(ctx, AV_LOG_INFO, "palette");
445  break;
447  av_log(ctx, AV_LOG_INFO, "new extradata");
448  break;
450  av_log(ctx, AV_LOG_INFO, "paramchange: ");
451  dump_paramchange(ctx, sd);
452  break;
454  av_log(ctx, AV_LOG_INFO, "H.263 macroblock info");
455  break;
457  av_log(ctx, AV_LOG_INFO, "replaygain: ");
458  dump_replaygain(ctx, sd);
459  break;
461  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
462  av_display_rotation_get((const int32_t *)sd->data));
463  break;
465  av_log(ctx, AV_LOG_INFO, "stereo3d: ");
466  dump_stereo3d(ctx, sd);
467  break;
469  av_log(ctx, AV_LOG_INFO, "audio service type: ");
471  break;
473  av_log(ctx, AV_LOG_INFO, "quality factor: %"PRId32", pict_type: %c",
474  AV_RL32(sd->data), av_get_picture_type_char(sd->data[4]));
475  break;
477  av_log(ctx, AV_LOG_INFO, "cpb: ");
478  dump_cpb(ctx, sd);
479  break;
482  break;
484  av_log(ctx, AV_LOG_INFO, "spherical: ");
485  dump_spherical(ctx, st->codecpar, sd);
486  break;
489  break;
491  av_log(ctx, AV_LOG_INFO, "ICC Profile");
492  break;
494  av_log(ctx, AV_LOG_INFO, "DOVI configuration record: ");
495  dump_dovi_conf(ctx, sd);
496  break;
498  av_log(ctx, AV_LOG_INFO, "SMPTE ST 12-1:2014: ");
499  dump_s12m_timecode(ctx, st, sd);
500  break;
501  default:
502  av_log(ctx, AV_LOG_INFO, "unknown side data type %d "
503  "(%"SIZE_SPECIFIER" bytes)", sd->type, sd->size);
504  break;
505  }
506 
507  av_log(ctx, AV_LOG_INFO, "\n");
508  }
509 }
510 
511 /* "user interface" functions */
512 static void dump_stream_format(const AVFormatContext *ic, int i,
513  int index, int is_output)
514 {
515  char buf[256];
516  int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
517  const AVStream *st = ic->streams[i];
518  const FFStream *const sti = cffstream(st);
519  const AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
520  const char *separator = ic->dump_separator;
521  AVCodecContext *avctx;
522  int ret;
523 
524  avctx = avcodec_alloc_context3(NULL);
525  if (!avctx)
526  return;
527 
529  if (ret < 0) {
530  avcodec_free_context(&avctx);
531  return;
532  }
533 
534  // Fields which are missing from AVCodecParameters need to be taken from the AVCodecContext
535  avctx->properties = sti->avctx->properties;
536  avctx->codec = sti->avctx->codec;
537  avctx->qmin = sti->avctx->qmin;
538  avctx->qmax = sti->avctx->qmax;
539  avctx->coded_width = sti->avctx->coded_width;
540  avctx->coded_height = sti->avctx->coded_height;
541 
542  if (separator)
543  av_opt_set(avctx, "dump_separator", separator, 0);
544  avcodec_string(buf, sizeof(buf), avctx, is_output);
545  avcodec_free_context(&avctx);
546 
547  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
548 
549  /* the pid is an important information, so we display it */
550  /* XXX: add a generic system */
551  if (flags & AVFMT_SHOW_IDS)
552  av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
553  if (lang)
554  av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
555  av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", sti->codec_info_nb_frames,
556  st->time_base.num, st->time_base.den);
557  av_log(NULL, AV_LOG_INFO, ": %s", buf);
558 
559  if (st->sample_aspect_ratio.num &&
561  AVRational display_aspect_ratio;
562  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
563  st->codecpar->width * (int64_t)st->sample_aspect_ratio.num,
564  st->codecpar->height * (int64_t)st->sample_aspect_ratio.den,
565  1024 * 1024);
566  av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
568  display_aspect_ratio.num, display_aspect_ratio.den);
569  }
570 
571  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
572  int fps = st->avg_frame_rate.den && st->avg_frame_rate.num;
573  int tbr = st->r_frame_rate.den && st->r_frame_rate.num;
574  int tbn = st->time_base.den && st->time_base.num;
575 
576  if (fps || tbr || tbn)
577  av_log(NULL, AV_LOG_INFO, "%s", separator);
578 
579  if (fps)
580  print_fps(av_q2d(st->avg_frame_rate), tbr || tbn ? "fps, " : "fps");
581  if (tbr)
582  print_fps(av_q2d(st->r_frame_rate), tbn ? "tbr, " : "tbr");
583  if (tbn)
584  print_fps(1 / av_q2d(st->time_base), "tbn");
585  }
586 
588  av_log(NULL, AV_LOG_INFO, " (default)");
590  av_log(NULL, AV_LOG_INFO, " (dub)");
592  av_log(NULL, AV_LOG_INFO, " (original)");
594  av_log(NULL, AV_LOG_INFO, " (comment)");
596  av_log(NULL, AV_LOG_INFO, " (lyrics)");
598  av_log(NULL, AV_LOG_INFO, " (karaoke)");
600  av_log(NULL, AV_LOG_INFO, " (forced)");
602  av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
604  av_log(NULL, AV_LOG_INFO, " (visual impaired)");
606  av_log(NULL, AV_LOG_INFO, " (clean effects)");
608  av_log(NULL, AV_LOG_INFO, " (attached pic)");
610  av_log(NULL, AV_LOG_INFO, " (timed thumbnails)");
612  av_log(NULL, AV_LOG_INFO, " (captions)");
614  av_log(NULL, AV_LOG_INFO, " (descriptions)");
616  av_log(NULL, AV_LOG_INFO, " (metadata)");
618  av_log(NULL, AV_LOG_INFO, " (dependent)");
620  av_log(NULL, AV_LOG_INFO, " (still image)");
622  av_log(NULL, AV_LOG_INFO, " (non-diegetic)");
623  av_log(NULL, AV_LOG_INFO, "\n");
624 
625  dump_metadata(NULL, st->metadata, " ");
626 
627  dump_sidedata(NULL, st, " ");
628 }
629 
631  const char *url, int is_output)
632 {
633  int i;
634  uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
635  if (ic->nb_streams && !printed)
636  return;
637 
638  av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
639  is_output ? "Output" : "Input",
640  index,
641  is_output ? ic->oformat->name : ic->iformat->name,
642  is_output ? "to" : "from", url);
643  dump_metadata(NULL, ic->metadata, " ");
644 
645  if (!is_output) {
646  av_log(NULL, AV_LOG_INFO, " Duration: ");
647  if (ic->duration != AV_NOPTS_VALUE) {
648  int64_t hours, mins, secs, us;
649  int64_t duration = ic->duration + (ic->duration <= INT64_MAX - 5000 ? 5000 : 0);
650  secs = duration / AV_TIME_BASE;
652  mins = secs / 60;
653  secs %= 60;
654  hours = mins / 60;
655  mins %= 60;
656  av_log(NULL, AV_LOG_INFO, "%02"PRId64":%02"PRId64":%02"PRId64".%02"PRId64"", hours, mins, secs,
657  (100 * us) / AV_TIME_BASE);
658  } else {
659  av_log(NULL, AV_LOG_INFO, "N/A");
660  }
661  if (ic->start_time != AV_NOPTS_VALUE) {
662  int secs, us;
663  av_log(NULL, AV_LOG_INFO, ", start: ");
664  secs = llabs(ic->start_time / AV_TIME_BASE);
665  us = llabs(ic->start_time % AV_TIME_BASE);
666  av_log(NULL, AV_LOG_INFO, "%s%d.%06d",
667  ic->start_time >= 0 ? "" : "-",
668  secs,
669  (int) av_rescale(us, 1000000, AV_TIME_BASE));
670  }
671  av_log(NULL, AV_LOG_INFO, ", bitrate: ");
672  if (ic->bit_rate)
673  av_log(NULL, AV_LOG_INFO, "%"PRId64" kb/s", ic->bit_rate / 1000);
674  else
675  av_log(NULL, AV_LOG_INFO, "N/A");
676  av_log(NULL, AV_LOG_INFO, "\n");
677  }
678 
679  if (ic->nb_chapters)
680  av_log(NULL, AV_LOG_INFO, " Chapters:\n");
681  for (i = 0; i < ic->nb_chapters; i++) {
682  const AVChapter *ch = ic->chapters[i];
683  av_log(NULL, AV_LOG_INFO, " Chapter #%d:%d: ", index, i);
685  "start %f, ", ch->start * av_q2d(ch->time_base));
687  "end %f\n", ch->end * av_q2d(ch->time_base));
688 
689  dump_metadata(NULL, ch->metadata, " ");
690  }
691 
692  if (ic->nb_programs) {
693  int j, k, total = 0;
694  for (j = 0; j < ic->nb_programs; j++) {
695  const AVProgram *program = ic->programs[j];
696  const AVDictionaryEntry *name = av_dict_get(program->metadata,
697  "name", NULL, 0);
698  av_log(NULL, AV_LOG_INFO, " Program %d %s\n", program->id,
699  name ? name->value : "");
700  dump_metadata(NULL, program->metadata, " ");
701  for (k = 0; k < program->nb_stream_indexes; k++) {
702  dump_stream_format(ic, program->stream_index[k],
703  index, is_output);
704  printed[program->stream_index[k]] = 1;
705  }
706  total += program->nb_stream_indexes;
707  }
708  if (total < ic->nb_streams)
709  av_log(NULL, AV_LOG_INFO, " No Program\n");
710  }
711 
712  for (i = 0; i < ic->nb_streams; i++)
713  if (!printed[i])
714  dump_stream_format(ic, i, index, is_output);
715 
716  av_free(printed);
717 }
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
av_pkt_dump2
void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st)
Send a nice dump of a packet to the specified file stream.
Definition: dump.c:111
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
name
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 vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
dump_paramchange
static void dump_paramchange(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:163
level
uint8_t level
Definition: svq3.c:206
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1176
r
const char * r
Definition: vf_curves.c:116
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:479
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1431
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:53
AV_PKT_DATA_PARAM_CHANGE
@ AV_PKT_DATA_PARAM_CHANGE
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:73
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:879
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:35
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:514
hex_dump_internal
static void hex_dump_internal(void *avcl, FILE *f, int level, const uint8_t *buf, int size)
Definition: dump.c:50
dump_s12m_timecode
static void dump_s12m_timecode(void *ctx, const AVStream *st, const AVPacketSideData *sd)
Definition: dump.c:415
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
The stream should be chosen by default among other streams of the same type, unless the user has expl...
Definition: avformat.h:826
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1281
AVPacketSideData
Definition: packet.h:315
AVPacket::data
uint8_t * data
Definition: packet.h:374
av_spherical_tile_bounds
void av_spherical_tile_bounds(const AVSphericalMapping *map, size_t width, size_t height, size_t *left, size_t *top, size_t *right, size_t *bottom)
Convert the bounding fields from an AVSphericalVideo from 0.32 fixed point to pixels.
Definition: spherical.c:37
dump_dovi_conf
static void dump_dovi_conf(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:400
b
#define b
Definition: input.c:34
AVReplayGain::album_gain
int32_t album_gain
Same as track_gain, but for the whole album.
Definition: replaygain.h:43
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:1028
spherical.h
AVChapter::start
int64_t start
Definition: avformat.h:1175
data
const char data[16]
Definition: mxf.c:146
AV_AUDIO_SERVICE_TYPE_VOICE_OVER
@ AV_AUDIO_SERVICE_TYPE_VOICE_OVER
Definition: defs.h:65
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:68
print_fps
static void print_fps(double d, const char *postfix)
Definition: dump.c:123
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:458
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1382
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AV_SPHERICAL_EQUIRECTANGULAR_TILE
@ AV_SPHERICAL_EQUIRECTANGULAR_TILE
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:72
mathematics.h
AVDictionary
Definition: dict.c:30
dump_cpb
static void dump_cpb(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:323
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:412
AV_PKT_DATA_SPHERICAL
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:229
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1194
replaygain.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
sample_rate
sample_rate
Definition: ffmpeg_filter.c:155
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
AVPacketSideData::size
size_t size
Definition: packet.h:317
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:407
fail
#define fail()
Definition: checkasm.h:131
timecode.h
dump_audioservicetype
static void dump_audioservicetype(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:280
AV_DISPOSITION_STILL_IMAGE
#define AV_DISPOSITION_STILL_IMAGE
The video stream contains still images.
Definition: avformat.h:918
AVChapter
Definition: avformat.h:1172
AV_DISPOSITION_FORCED
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:859
AVFormatContext::dump_separator
uint8_t * dump_separator
dump format separator.
Definition: avformat.h:1738
AV_DISPOSITION_TIMED_THUMBNAILS
#define AV_DISPOSITION_TIMED_THUMBNAILS
The stream is sparse, and contains thumbnail images, often corresponding to chapter markers.
Definition: avformat.h:884
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:586
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:276
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:109
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:487
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_PKT_DATA_REPLAYGAIN
@ AV_PKT_DATA_REPLAYGAIN
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:100
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1322
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
The audio stream contains music and sound effects without voice.
Definition: avformat.h:871
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1442
av_dump_format
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate,...
Definition: dump.c:630
duration
int64_t duration
Definition: movenc.c:64
AV_PKT_DATA_AUDIO_SERVICE_TYPE
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:121
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:459
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1175
width
#define width
stereo3d.h
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
intreadwrite.h
AV_PKT_DATA_STEREO3D
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:115
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:137
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1381
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1225
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1432
dump_metadata
static void dump_metadata(void *ctx, const AVDictionary *m, const char *indent)
Definition: dump.c:136
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:127
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AV_PKT_DATA_ICC_PROFILE
@ AV_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
Definition: packet.h:275
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:316
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:55
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FFStream::codec_info_nb_frames
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: internal.h:386
channels
channels
Definition: aptx.h:32
nb_streams
static int nb_streams
Definition: ffprobe.c:307
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
Definition: defs.h:61
AVReplayGain::track_peak
uint32_t track_peak
Peak track amplitude, with 100000 representing full scale (but values may overflow).
Definition: replaygain.h:39
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:104
AVDOVIDecoderConfigurationRecord::dv_version_major
uint8_t dv_version_major
Definition: dovi_meta.h:53
print_peak
static void print_peak(void *ctx, const char *str, uint32_t peak)
Definition: dump.c:237
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
dump_mastering_display_metadata
static void dump_mastering_display_metadata(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:342
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:978
NULL
#define NULL
Definition: coverity.c:32
AVDOVIDecoderConfigurationRecord::dv_level
uint8_t dv_level
Definition: dovi_meta.h:56
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:60
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:164
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
print_gain
static void print_gain(void *ctx, const char *str, int32_t gain)
Definition: dump.c:227
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:318
AV_DISPOSITION_COMMENT
#define AV_DISPOSITION_COMMENT
The stream is a commentary track.
Definition: avformat.h:844
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:1019
dump_content_light_metadata
static void dump_content_light_metadata(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:361
AV_DISPOSITION_METADATA
#define AV_DISPOSITION_METADATA
The subtitle stream contains time-aligned metadata that is not intended to be directly presented to t...
Definition: avformat.h:908
double
double
Definition: af_crystalizer.c:132
AV_AUDIO_SERVICE_TYPE_EMERGENCY
@ AV_AUDIO_SERVICE_TYPE_EMERGENCY
Definition: defs.h:64
AV_DISPOSITION_ORIGINAL
#define AV_DISPOSITION_ORIGINAL
The stream is in original language.
Definition: avformat.h:840
av_get_channel_name
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
Definition: channel_layout.c:341
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVAudioServiceType
AVAudioServiceType
Definition: defs.h:57
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1269
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:529
dump_stereo3d
static void dump_stereo3d(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:263
AV_DISPOSITION_CAPTIONS
#define AV_DISPOSITION_CAPTIONS
The subtitle stream contains captions, providing a transcription and possibly a translation of audio.
Definition: avformat.h:897
dump_spherical
static void dump_spherical(void *ctx, const AVCodecParameters *par, const AVPacketSideData *sd)
Definition: dump.c:370
av_spherical_projection_name
const char * av_spherical_projection_name(enum AVSphericalProjection projection)
Provide a human-readable name of a given AVSphericalProjection.
Definition: spherical.c:61
f
f
Definition: af_crystalizer.c:122
AV_SPHERICAL_CUBEMAP
@ AV_SPHERICAL_CUBEMAP
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
AVPacket::size
int size
Definition: packet.h:375
FFStream
Definition: internal.h:197
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
dump_stream_format
static void dump_stream_format(const AVFormatContext *ic, int i, int index, int is_output)
Definition: dump.c:512
AVReplayGain::track_gain
int32_t track_gain
Track replay gain in microbels (divide by 100000 to get the value in dB).
Definition: replaygain.h:34
AV_DISPOSITION_DUB
#define AV_DISPOSITION_DUB
The stream is not in original language.
Definition: avformat.h:834
AV_PKT_DATA_H263_MB_INFO
@ AV_PKT_DATA_H263_MB_INFO
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
Definition: packet.h:94
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:114
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:1017
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:863
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
height
#define height
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:119
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVStream::side_data
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:1057
layout
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 layout
Definition: filter_design.txt:18
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
AVCPBProperties::vbv_delay
uint64_t vbv_delay
The delay between the time the packet this structure is associated with is received and the time when...
Definition: defs.h:134
HEXDUMP_PRINT
#define HEXDUMP_PRINT(...)
Definition: dump.c:42
AVSphericalMapping::roll
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
log.h
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:138
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1853
AVCodecParameters::height
int height
Definition: codec_par.h:128
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: codec_par.c:182
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
display.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:109
AV_DISPOSITION_KARAOKE
#define AV_DISPOSITION_KARAOKE
The stream contains karaoke audio.
Definition: avformat.h:852
dump_sidedata
static void dump_sidedata(void *ctx, const AVStream *st, const char *indent)
Definition: dump.c:431
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
Definition: defs.h:60
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1137
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:146
AV_DISPOSITION_DEPENDENT
#define AV_DISPOSITION_DEPENDENT
The audio stream is intended to be mixed with another stream before presentation.
Definition: avformat.h:914
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
len
int len
Definition: vorbis_enc_data.h:426
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1008
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:867
tag
uint32_t tag
Definition: movenc.c:1646
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:962
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
AV_PKT_DATA_DOVI_CONF
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h:284
av_hex_dump_log
void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
Send a nice hexadecimal dump of a buffer to the log.
Definition: dump.c:82
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1232
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:125
AVSphericalMapping::pitch
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
AVStream::nb_side_data
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:1061
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
avformat.h
dovi_meta.h
AV_AUDIO_SERVICE_TYPE_KARAOKE
@ AV_AUDIO_SERVICE_TYPE_KARAOKE
Definition: defs.h:66
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:292
AV_DISPOSITION_DESCRIPTIONS
#define AV_DISPOSITION_DESCRIPTIONS
The subtitle stream contains a textual description of the video content.
Definition: avformat.h:903
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:195
AVCodecContext
main external API structure.
Definition: avcodec.h:398
channel_layout.h
FFStream::avctx
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:224
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:675
dump_replaygain
static void dump_replaygain(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:247
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1187
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVDOVIDecoderConfigurationRecord::bl_present_flag
uint8_t bl_present_flag
Definition: dovi_meta.h:59
AV_AUDIO_SERVICE_TYPE_COMMENTARY
@ AV_AUDIO_SERVICE_TYPE_COMMENTARY
Definition: defs.h:63
AVReplayGain::album_peak
uint32_t album_peak
Same as track_peak, but for the whole album,.
Definition: replaygain.h:47
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1097
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:57
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:58
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1315
AVPacket::stream_index
int stream_index
Definition: packet.h:376
pkt_dump_internal
static void pkt_dump_internal(void *avcl, FILE *f, int level, const AVPacket *pkt, int dump_payload, AVRational time_base)
Definition: dump.c:87
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AVReplayGain
ReplayGain information (see http://wiki.hydrogenaudio.org/index.php?title=ReplayGain_1....
Definition: replaygain.h:29
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:586
tc
#define tc
Definition: regdef.h:69
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:54
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mastering_display_metadata.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:79
AV_AUDIO_SERVICE_TYPE_EFFECTS
@ AV_AUDIO_SERVICE_TYPE_EFFECTS
Definition: defs.h:59
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AVPacket
This structure stores compressed data.
Definition: packet.h:351
d
d
Definition: ffmpeg_filter.c:155
int32_t
int32_t
Definition: audioconvert.c:56
convert_header.str
string str
Definition: convert_header.py:20
AV_PKT_DATA_QUALITY_STATS
@ AV_PKT_DATA_QUALITY_STATS
This side data contains quality related information from the encoder.
Definition: packet.h:133
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:86
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1305
av_stereo3d_type_name
const char * av_stereo3d_type_name(unsigned int type)
Provide a human-readable name of a given stereo3d type.
Definition: stereo3d.c:58
av_pkt_dump_log2
void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload, const AVStream *st)
Send a nice dump of a packet to the log.
Definition: dump.c:116
AV_AUDIO_SERVICE_TYPE_DIALOGUE
@ AV_AUDIO_SERVICE_TYPE_DIALOGUE
Definition: defs.h:62
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:176
AVDictionaryEntry::value
char * value
Definition: dict.h:81
avstring.h
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1174
AV_AUDIO_SERVICE_TYPE_MAIN
@ AV_AUDIO_SERVICE_TYPE_MAIN
Definition: defs.h:58
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:82
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
av_display_rotation_get
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:35
AV_DISPOSITION_LYRICS
#define AV_DISPOSITION_LYRICS
The stream contains song lyrics.
Definition: avformat.h:848
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:52
AV_DISPOSITION_NON_DIEGETIC
#define AV_DISPOSITION_NON_DIEGETIC
The stream is intended to be mixed with a spatial audio track.
Definition: avformat.h:891
av_hex_dump
void av_hex_dump(FILE *f, const uint8_t *buf, int size)
Send a nice hexadecimal dump of a buffer to the specified file stream.
Definition: dump.c:77