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 
41 #define HEXDUMP_PRINT(...) \
42  do { \
43  if (!f) \
44  av_log(avcl, level, __VA_ARGS__); \
45  else \
46  fprintf(f, __VA_ARGS__); \
47  } while (0)
48 
49 static void hex_dump_internal(void *avcl, FILE *f, int level,
50  const uint8_t *buf, int size)
51 {
52  int len, i, j, c;
53 
54  for (i = 0; i < size; i += 16) {
55  len = size - i;
56  if (len > 16)
57  len = 16;
58  HEXDUMP_PRINT("%08x ", i);
59  for (j = 0; j < 16; j++) {
60  if (j < len)
61  HEXDUMP_PRINT(" %02x", buf[i + j]);
62  else
63  HEXDUMP_PRINT(" ");
64  }
65  HEXDUMP_PRINT(" ");
66  for (j = 0; j < len; j++) {
67  c = buf[i + j];
68  if (c < ' ' || c > '~')
69  c = '.';
70  HEXDUMP_PRINT("%c", c);
71  }
72  HEXDUMP_PRINT("\n");
73  }
74 }
75 
76 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
77 {
78  hex_dump_internal(NULL, f, 0, buf, size);
79 }
80 
81 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
82 {
83  hex_dump_internal(avcl, NULL, level, buf, size);
84 }
85 
86 static void pkt_dump_internal(void *avcl, FILE *f, int level, const AVPacket *pkt,
87  int dump_payload, AVRational time_base)
88 {
89  HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
90  HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
91  HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
92  /* DTS is _always_ valid after av_read_frame() */
93  HEXDUMP_PRINT(" dts=");
94  if (pkt->dts == AV_NOPTS_VALUE)
95  HEXDUMP_PRINT("N/A");
96  else
97  HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
98  /* PTS may not be known if B-frames are present. */
99  HEXDUMP_PRINT(" pts=");
100  if (pkt->pts == AV_NOPTS_VALUE)
101  HEXDUMP_PRINT("N/A");
102  else
103  HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
104  HEXDUMP_PRINT("\n");
105  HEXDUMP_PRINT(" size=%d\n", pkt->size);
106  if (dump_payload)
107  hex_dump_internal(avcl, f, level, pkt->data, pkt->size);
108 }
109 
110 void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st)
111 {
112  pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
113 }
114 
115 void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
116  const AVStream *st)
117 {
118  pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
119 }
120 
121 
122 static void print_fps(double d, const char *postfix)
123 {
124  uint64_t v = lrintf(d * 100);
125  if (!v)
126  av_log(NULL, AV_LOG_INFO, "%1.4f %s", d, postfix);
127  else if (v % 100)
128  av_log(NULL, AV_LOG_INFO, "%3.2f %s", d, postfix);
129  else if (v % (100 * 1000))
130  av_log(NULL, AV_LOG_INFO, "%1.0f %s", d, postfix);
131  else
132  av_log(NULL, AV_LOG_INFO, "%1.0fk %s", d / 1000, postfix);
133 }
134 
135 static void dump_metadata(void *ctx, const AVDictionary *m, const char *indent)
136 {
137  if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
138  const AVDictionaryEntry *tag = NULL;
139 
140  av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
141  while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
142  if (strcmp("language", tag->key)) {
143  const char *p = tag->value;
144  av_log(ctx, AV_LOG_INFO,
145  "%s %-16s: ", indent, tag->key);
146  while (*p) {
147  char tmp[256];
148  size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
149  av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
150  av_log(ctx, AV_LOG_INFO, "%s", tmp);
151  p += len;
152  if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
153  if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
154  if (*p) p++;
155  }
156  av_log(ctx, AV_LOG_INFO, "\n");
157  }
158  }
159 }
160 
161 /* param change side data*/
162 static void dump_paramchange(void *ctx, const AVPacketSideData *sd)
163 {
164  int size = sd->size;
165  const uint8_t *data = sd->data;
166  uint32_t flags, channels, sample_rate, width, height;
167  uint64_t layout;
168 
169  if (!data || sd->size < 4)
170  goto fail;
171 
172  flags = AV_RL32(data);
173  data += 4;
174  size -= 4;
175 
177  if (size < 4)
178  goto fail;
179  channels = AV_RL32(data);
180  data += 4;
181  size -= 4;
182  av_log(ctx, AV_LOG_INFO, "channel count %"PRIu32", ", channels);
183  }
185  if (size < 8)
186  goto fail;
187  layout = AV_RL64(data);
188  data += 8;
189  size -= 8;
190  av_log(ctx, AV_LOG_INFO,
191  "channel layout: %s, ", av_get_channel_name(layout));
192  }
194  if (size < 4)
195  goto fail;
196  sample_rate = AV_RL32(data);
197  data += 4;
198  size -= 4;
199  av_log(ctx, AV_LOG_INFO, "sample_rate %"PRIu32", ", sample_rate);
200  }
202  if (size < 8)
203  goto fail;
204  width = AV_RL32(data);
205  data += 4;
206  size -= 4;
207  height = AV_RL32(data);
208  data += 4;
209  size -= 4;
210  av_log(ctx, AV_LOG_INFO, "width %"PRIu32" height %"PRIu32, width, height);
211  }
212 
213  return;
214 fail:
215  av_log(ctx, AV_LOG_ERROR, "unknown param\n");
216 }
217 
218 /* replaygain side data*/
219 static void print_gain(void *ctx, const char *str, int32_t gain)
220 {
221  av_log(ctx, AV_LOG_INFO, "%s - ", str);
222  if (gain == INT32_MIN)
223  av_log(ctx, AV_LOG_INFO, "unknown");
224  else
225  av_log(ctx, AV_LOG_INFO, "%f", gain / 100000.0f);
226  av_log(ctx, AV_LOG_INFO, ", ");
227 }
228 
229 static void print_peak(void *ctx, const char *str, uint32_t peak)
230 {
231  av_log(ctx, AV_LOG_INFO, "%s - ", str);
232  if (!peak)
233  av_log(ctx, AV_LOG_INFO, "unknown");
234  else
235  av_log(ctx, AV_LOG_INFO, "%f", (float) peak / UINT32_MAX);
236  av_log(ctx, AV_LOG_INFO, ", ");
237 }
238 
239 static void dump_replaygain(void *ctx, const AVPacketSideData *sd)
240 {
241  const AVReplayGain *rg;
242 
243  if (sd->size < sizeof(*rg)) {
244  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
245  return;
246  }
247  rg = (const AVReplayGain *)sd->data;
248 
249  print_gain(ctx, "track gain", rg->track_gain);
250  print_peak(ctx, "track peak", rg->track_peak);
251  print_gain(ctx, "album gain", rg->album_gain);
252  print_peak(ctx, "album peak", rg->album_peak);
253 }
254 
255 static void dump_stereo3d(void *ctx, const AVPacketSideData *sd)
256 {
257  const AVStereo3D *stereo;
258 
259  if (sd->size < sizeof(*stereo)) {
260  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
261  return;
262  }
263 
264  stereo = (const AVStereo3D *)sd->data;
265 
266  av_log(ctx, AV_LOG_INFO, "%s", av_stereo3d_type_name(stereo->type));
267 
268  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
269  av_log(ctx, AV_LOG_INFO, " (inverted)");
270 }
271 
272 static void dump_audioservicetype(void *ctx, const AVPacketSideData *sd)
273 {
274  const enum AVAudioServiceType *ast = (const enum AVAudioServiceType *)sd->data;
275 
276  if (sd->size < sizeof(*ast)) {
277  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
278  return;
279  }
280 
281  switch (*ast) {
283  av_log(ctx, AV_LOG_INFO, "main");
284  break;
286  av_log(ctx, AV_LOG_INFO, "effects");
287  break;
289  av_log(ctx, AV_LOG_INFO, "visually impaired");
290  break;
292  av_log(ctx, AV_LOG_INFO, "hearing impaired");
293  break;
295  av_log(ctx, AV_LOG_INFO, "dialogue");
296  break;
298  av_log(ctx, AV_LOG_INFO, "commentary");
299  break;
301  av_log(ctx, AV_LOG_INFO, "emergency");
302  break;
304  av_log(ctx, AV_LOG_INFO, "voice over");
305  break;
307  av_log(ctx, AV_LOG_INFO, "karaoke");
308  break;
309  default:
310  av_log(ctx, AV_LOG_WARNING, "unknown");
311  break;
312  }
313 }
314 
315 static void dump_cpb(void *ctx, const AVPacketSideData *sd)
316 {
317  const AVCPBProperties *cpb = (const AVCPBProperties *)sd->data;
318 
319  if (sd->size < sizeof(*cpb)) {
320  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
321  return;
322  }
323 
324  av_log(ctx, AV_LOG_INFO,
326  "bitrate max/min/avg: %d/%d/%d buffer size: %d ",
327 #else
328  "bitrate max/min/avg: %"PRId64"/%"PRId64"/%"PRId64" buffer size: %d ",
329 #endif
330  cpb->max_bitrate, cpb->min_bitrate, cpb->avg_bitrate,
331  cpb->buffer_size);
332  if (cpb->vbv_delay == UINT64_MAX)
333  av_log(ctx, AV_LOG_INFO, "vbv_delay: N/A");
334  else
335  av_log(ctx, AV_LOG_INFO, "vbv_delay: %"PRIu64"", cpb->vbv_delay);
336 }
337 
339 {
340  const AVMasteringDisplayMetadata *metadata =
341  (const AVMasteringDisplayMetadata *)sd->data;
342  av_log(ctx, AV_LOG_INFO, "Mastering Display Metadata, "
343  "has_primaries:%d has_luminance:%d "
344  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
345  "min_luminance=%f, max_luminance=%f",
346  metadata->has_primaries, metadata->has_luminance,
347  av_q2d(metadata->display_primaries[0][0]),
348  av_q2d(metadata->display_primaries[0][1]),
349  av_q2d(metadata->display_primaries[1][0]),
350  av_q2d(metadata->display_primaries[1][1]),
351  av_q2d(metadata->display_primaries[2][0]),
352  av_q2d(metadata->display_primaries[2][1]),
353  av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]),
354  av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
355 }
356 
357 static void dump_content_light_metadata(void *ctx, const AVPacketSideData *sd)
358 {
359  const AVContentLightMetadata *metadata =
360  (const AVContentLightMetadata *)sd->data;
361  av_log(ctx, AV_LOG_INFO, "Content Light Level Metadata, "
362  "MaxCLL=%d, MaxFALL=%d",
363  metadata->MaxCLL, metadata->MaxFALL);
364 }
365 
366 static void dump_spherical(void *ctx, const AVCodecParameters *par,
367  const AVPacketSideData *sd)
368 {
369  const AVSphericalMapping *spherical = (const AVSphericalMapping *)sd->data;
370  double yaw, pitch, roll;
371 
372  if (sd->size < sizeof(*spherical)) {
373  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
374  return;
375  }
376 
377  av_log(ctx, AV_LOG_INFO, "%s ", av_spherical_projection_name(spherical->projection));
378 
379  yaw = ((double)spherical->yaw) / (1 << 16);
380  pitch = ((double)spherical->pitch) / (1 << 16);
381  roll = ((double)spherical->roll) / (1 << 16);
382  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
383 
384  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
385  size_t l, t, r, b;
386  av_spherical_tile_bounds(spherical, par->width, par->height,
387  &l, &t, &r, &b);
388  av_log(ctx, AV_LOG_INFO,
390  l, t, r, b);
391  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
392  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
393  }
394 }
395 
396 static void dump_dovi_conf(void *ctx, const AVPacketSideData *sd)
397 {
400 
401  av_log(ctx, AV_LOG_INFO, "version: %d.%d, profile: %d, level: %d, "
402  "rpu flag: %d, el flag: %d, bl flag: %d, compatibility id: %d",
403  dovi->dv_version_major, dovi->dv_version_minor,
404  dovi->dv_profile, dovi->dv_level,
405  dovi->rpu_present_flag,
406  dovi->el_present_flag,
407  dovi->bl_present_flag,
409 }
410 
411 static void dump_s12m_timecode(void *ctx, const AVStream *st, const AVPacketSideData *sd)
412 {
413  const uint32_t *tc = (const uint32_t *)sd->data;
414 
415  if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
416  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
417  return;
418  }
419 
420  for (int j = 1; j <= tc[0]; j++) {
421  char tcbuf[AV_TIMECODE_STR_SIZE];
422  av_timecode_make_smpte_tc_string2(tcbuf, st->avg_frame_rate, tc[j], 0, 0);
423  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
424  }
425 }
426 
427 static void dump_sidedata(void *ctx, const AVStream *st, const char *indent)
428 {
429  int i;
430 
431  if (st->nb_side_data)
432  av_log(ctx, AV_LOG_INFO, "%sSide data:\n", indent);
433 
434  for (i = 0; i < st->nb_side_data; i++) {
435  const AVPacketSideData *sd = &st->side_data[i];
436  av_log(ctx, AV_LOG_INFO, "%s ", indent);
437 
438  switch (sd->type) {
439  case AV_PKT_DATA_PALETTE:
440  av_log(ctx, AV_LOG_INFO, "palette");
441  break;
443  av_log(ctx, AV_LOG_INFO, "new extradata");
444  break;
446  av_log(ctx, AV_LOG_INFO, "paramchange: ");
447  dump_paramchange(ctx, sd);
448  break;
450  av_log(ctx, AV_LOG_INFO, "H.263 macroblock info");
451  break;
453  av_log(ctx, AV_LOG_INFO, "replaygain: ");
454  dump_replaygain(ctx, sd);
455  break;
457  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
458  av_display_rotation_get((const int32_t *)sd->data));
459  break;
461  av_log(ctx, AV_LOG_INFO, "stereo3d: ");
462  dump_stereo3d(ctx, sd);
463  break;
465  av_log(ctx, AV_LOG_INFO, "audio service type: ");
466  dump_audioservicetype(ctx, sd);
467  break;
469  av_log(ctx, AV_LOG_INFO, "quality factor: %"PRId32", pict_type: %c",
470  AV_RL32(sd->data), av_get_picture_type_char(sd->data[4]));
471  break;
473  av_log(ctx, AV_LOG_INFO, "cpb: ");
474  dump_cpb(ctx, sd);
475  break;
478  break;
480  av_log(ctx, AV_LOG_INFO, "spherical: ");
481  dump_spherical(ctx, st->codecpar, sd);
482  break;
485  break;
487  av_log(ctx, AV_LOG_INFO, "ICC Profile");
488  break;
490  av_log(ctx, AV_LOG_INFO, "DOVI configuration record: ");
491  dump_dovi_conf(ctx, sd);
492  break;
494  av_log(ctx, AV_LOG_INFO, "SMPTE ST 12-1:2014: ");
495  dump_s12m_timecode(ctx, st, sd);
496  break;
497  default:
498  av_log(ctx, AV_LOG_INFO,
499  "unknown side data type %d (%d bytes)", sd->type, sd->size);
500  break;
501  }
502 
503  av_log(ctx, AV_LOG_INFO, "\n");
504  }
505 }
506 
507 /* "user interface" functions */
508 static void dump_stream_format(const AVFormatContext *ic, int i,
509  int index, int is_output)
510 {
511  char buf[256];
512  int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
513  const AVStream *st = ic->streams[i];
514  const AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
515  const char *separator = ic->dump_separator;
516  AVCodecContext *avctx;
517  int ret;
518 
519  avctx = avcodec_alloc_context3(NULL);
520  if (!avctx)
521  return;
522 
523  ret = avcodec_parameters_to_context(avctx, st->codecpar);
524  if (ret < 0) {
525  avcodec_free_context(&avctx);
526  return;
527  }
528 
529 #if FF_API_LAVF_AVCTX
531  // Fields which are missing from AVCodecParameters need to be taken from the AVCodecContext
532  avctx->properties = st->codec->properties;
533  avctx->codec = st->codec->codec;
534  avctx->qmin = st->codec->qmin;
535  avctx->qmax = st->codec->qmax;
536  avctx->coded_width = st->codec->coded_width;
537  avctx->coded_height = st->codec->coded_height;
539 #endif
540 
541  if (separator)
542  av_opt_set(avctx, "dump_separator", separator, 0);
543  avcodec_string(buf, sizeof(buf), avctx, is_output);
544  avcodec_free_context(&avctx);
545 
546  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
547 
548  /* the pid is an important information, so we display it */
549  /* XXX: add a generic system */
550  if (flags & AVFMT_SHOW_IDS)
551  av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
552  if (lang)
553  av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
554  av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
555  st->time_base.num, st->time_base.den);
556  av_log(NULL, AV_LOG_INFO, ": %s", buf);
557 
558  if (st->sample_aspect_ratio.num &&
560  AVRational display_aspect_ratio;
561  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
562  st->codecpar->width * (int64_t)st->sample_aspect_ratio.num,
563  st->codecpar->height * (int64_t)st->sample_aspect_ratio.den,
564  1024 * 1024);
565  av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
567  display_aspect_ratio.num, display_aspect_ratio.den);
568  }
569 
570  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
571  int fps = st->avg_frame_rate.den && st->avg_frame_rate.num;
572  int tbr = st->r_frame_rate.den && st->r_frame_rate.num;
573  int tbn = st->time_base.den && st->time_base.num;
574 #if FF_API_LAVF_AVCTX
576  int tbc = st->codec->time_base.den && st->codec->time_base.num;
578 #else
579  int tbc = 0;
580 #endif
581 
582  if (fps || tbr || tbn || tbc)
583  av_log(NULL, AV_LOG_INFO, "%s", separator);
584 
585  if (fps)
586  print_fps(av_q2d(st->avg_frame_rate), tbr || tbn || tbc ? "fps, " : "fps");
587  if (tbr)
588  print_fps(av_q2d(st->r_frame_rate), tbn || tbc ? "tbr, " : "tbr");
589  if (tbn)
590  print_fps(1 / av_q2d(st->time_base), tbc ? "tbn, " : "tbn");
591 #if FF_API_LAVF_AVCTX
593  if (tbc)
594  print_fps(1 / av_q2d(st->codec->time_base), "tbc");
596 #endif
597  }
598 
600  av_log(NULL, AV_LOG_INFO, " (default)");
602  av_log(NULL, AV_LOG_INFO, " (dub)");
604  av_log(NULL, AV_LOG_INFO, " (original)");
606  av_log(NULL, AV_LOG_INFO, " (comment)");
608  av_log(NULL, AV_LOG_INFO, " (lyrics)");
610  av_log(NULL, AV_LOG_INFO, " (karaoke)");
612  av_log(NULL, AV_LOG_INFO, " (forced)");
614  av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
616  av_log(NULL, AV_LOG_INFO, " (visual impaired)");
618  av_log(NULL, AV_LOG_INFO, " (clean effects)");
620  av_log(NULL, AV_LOG_INFO, " (attached pic)");
622  av_log(NULL, AV_LOG_INFO, " (timed thumbnails)");
624  av_log(NULL, AV_LOG_INFO, " (captions)");
626  av_log(NULL, AV_LOG_INFO, " (descriptions)");
628  av_log(NULL, AV_LOG_INFO, " (metadata)");
630  av_log(NULL, AV_LOG_INFO, " (dependent)");
632  av_log(NULL, AV_LOG_INFO, " (still image)");
633  av_log(NULL, AV_LOG_INFO, "\n");
634 
635  dump_metadata(NULL, st->metadata, " ");
636 
637  dump_sidedata(NULL, st, " ");
638 }
639 
641  const char *url, int is_output)
642 {
643  int i;
644  uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
645  if (ic->nb_streams && !printed)
646  return;
647 
648  av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
649  is_output ? "Output" : "Input",
650  index,
651  is_output ? ic->oformat->name : ic->iformat->name,
652  is_output ? "to" : "from", url);
653  dump_metadata(NULL, ic->metadata, " ");
654 
655  if (!is_output) {
656  av_log(NULL, AV_LOG_INFO, " Duration: ");
657  if (ic->duration != AV_NOPTS_VALUE) {
658  int64_t hours, mins, secs, us;
659  int64_t duration = ic->duration + (ic->duration <= INT64_MAX - 5000 ? 5000 : 0);
660  secs = duration / AV_TIME_BASE;
661  us = duration % AV_TIME_BASE;
662  mins = secs / 60;
663  secs %= 60;
664  hours = mins / 60;
665  mins %= 60;
666  av_log(NULL, AV_LOG_INFO, "%02"PRId64":%02"PRId64":%02"PRId64".%02"PRId64"", hours, mins, secs,
667  (100 * us) / AV_TIME_BASE);
668  } else {
669  av_log(NULL, AV_LOG_INFO, "N/A");
670  }
671  if (ic->start_time != AV_NOPTS_VALUE) {
672  int secs, us;
673  av_log(NULL, AV_LOG_INFO, ", start: ");
674  secs = llabs(ic->start_time / AV_TIME_BASE);
675  us = llabs(ic->start_time % AV_TIME_BASE);
676  av_log(NULL, AV_LOG_INFO, "%s%d.%06d",
677  ic->start_time >= 0 ? "" : "-",
678  secs,
679  (int) av_rescale(us, 1000000, AV_TIME_BASE));
680  }
681  av_log(NULL, AV_LOG_INFO, ", bitrate: ");
682  if (ic->bit_rate)
683  av_log(NULL, AV_LOG_INFO, "%"PRId64" kb/s", ic->bit_rate / 1000);
684  else
685  av_log(NULL, AV_LOG_INFO, "N/A");
686  av_log(NULL, AV_LOG_INFO, "\n");
687  }
688 
689  for (i = 0; i < ic->nb_chapters; i++) {
690  const AVChapter *ch = ic->chapters[i];
691  av_log(NULL, AV_LOG_INFO, " Chapter #%d:%d: ", index, i);
693  "start %f, ", ch->start * av_q2d(ch->time_base));
695  "end %f\n", ch->end * av_q2d(ch->time_base));
696 
697  dump_metadata(NULL, ch->metadata, " ");
698  }
699 
700  if (ic->nb_programs) {
701  int j, k, total = 0;
702  for (j = 0; j < ic->nb_programs; j++) {
703  const AVProgram *program = ic->programs[j];
704  const AVDictionaryEntry *name = av_dict_get(program->metadata,
705  "name", NULL, 0);
706  av_log(NULL, AV_LOG_INFO, " Program %d %s\n", program->id,
707  name ? name->value : "");
708  dump_metadata(NULL, program->metadata, " ");
709  for (k = 0; k < program->nb_stream_indexes; k++) {
710  dump_stream_format(ic, program->stream_index[k],
711  index, is_output);
712  printed[program->stream_index[k]] = 1;
713  }
714  total += program->nb_stream_indexes;
715  }
716  if (total < ic->nb_streams)
717  av_log(NULL, AV_LOG_INFO, " No Program\n");
718  }
719 
720  for (i = 0; i < ic->nb_streams; i++)
721  if (!printed[i])
722  dump_stream_format(ic, i, index, is_output);
723 
724  av_free(printed);
725 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1468
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
#define AV_DISPOSITION_METADATA
Definition: avformat.h:862
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:540
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:110
unsigned MaxCLL
Max content light level (cd/m^2).
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:719
static void dump_sidedata(void *ctx, const AVStream *st, const char *indent)
Definition: dump.c:427
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
static void dump_paramchange(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:162
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:459
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:114
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.
static void dump_stream_format(const AVFormatContext *ic, int i, int index, int is_output)
Definition: dump.c:508
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:942
uint8_t * dump_separator
dump format separator.
Definition: avformat.h:1776
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:35
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:276
#define AV_DISPOSITION_DUB
Definition: avformat.h:826
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1361
static void dump_mastering_display_metadata(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:338
#define tc
Definition: regdef.h:69
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:838
DOVI configuration.
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:840
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:982
static AVPacket pkt
AVDictionary * metadata
Definition: avformat.h:1200
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
Definition: packet.h:93
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:468
uint32_t track_peak
Peak track amplitude, with 100000 representing full scale (but values may overflow).
Definition: replaygain.h:39
#define AV_DISPOSITION_KARAOKE
Definition: avformat.h:830
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:460
Format I/O context.
Definition: avformat.h:1239
static void pkt_dump_internal(void *avcl, FILE *f, int level, const AVPacket *pkt, int dump_payload, AVRational time_base)
Definition: dump.c:86
uint64_t vbv_delay
The delay between the time the packet this structure is associated with is received and the time when...
Definition: avcodec.h:495
unsigned int nb_stream_indexes
Definition: avformat.h:1161
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:519
uint8_t
static int nb_streams
Definition: ffprobe.c:282
int width
Video only.
Definition: codec_par.h:126
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:666
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
static void dump_stereo3d(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:255
#define f(width, name)
Definition: cbs_vp9.c:255
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
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
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:108
int id
Format-specific stream ID.
Definition: avformat.h:887
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
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:986
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1307
int64_t duration
Definition: movenc.c:63
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2152
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:115
const char * av_stereo3d_type_name(unsigned int type)
Provide a human-readable name of a given stereo3d type.
Definition: stereo3d.c:57
#define height
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
#define AV_DISPOSITION_DEPENDENT
dependent audio stream (mix_type=0 in mpegts)
Definition: avformat.h:863
uint8_t * data
Definition: packet.h:363
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
uint32_t tag
Definition: movenc.c:1597
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
#define lrintf(x)
Definition: libm_mips.h:70
static void dump_audioservicetype(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:272
uint8_t * data
Definition: packet.h:307
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:486
ptrdiff_t size
Definition: opengl_enc.c:100
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
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
channels
Definition: aptx.h:33
unsigned int * stream_index
Definition: avformat.h:1160
int32_t album_gain
Same as track_gain, but for the whole album.
Definition: replaygain.h:43
#define av_log(a,...)
static void print_fps(double d, const char *postfix)
Definition: dump.c:122
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:860
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
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, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:640
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2 dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3 Tags are stored in struct AVDOVIDecoderConfigurationRecord.
Definition: packet.h:283
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1479
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: packet.h:46
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:76
AVAudioServiceType
Definition: avcodec.h:239
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:72
int qmax
maximum quantizer
Definition: avcodec.h:1380
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1...
Definition: packet.h:274
Display matrix.
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1251
const char * r
Definition: vf_curves.c:114
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
unsigned int nb_programs
Definition: avformat.h:1418
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVChapter ** chapters
Definition: avformat.h:1469
enum AVPacketSideDataType type
Definition: packet.h:309
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:953
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1156
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
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:83
#define fail()
Definition: checkasm.h:123
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
#define AV_DISPOSITION_LYRICS
Definition: avformat.h:829
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:837
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1295
#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
audio channel layout utility functions
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
Spherical video.
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:96
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:172
This side data contains quality related information from the encoder.
Definition: packet.h:132
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
#define width
#define HEXDUMP_PRINT(...)
Definition: dump.c:41
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:3
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:228
const char * name
Definition: avformat.h:500
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
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:139
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
AVDictionary * metadata
Definition: avformat.h:944
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:848
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1258
if(ret)
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:839
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
Stream structure.
Definition: avformat.h:880
static void dump_s12m_timecode(void *ctx, const AVStream *st, const AVPacketSideData *sd)
Definition: dump.c:411
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1199
Content light level (based on CTA-861.3).
Definition: packet.h:235
static void dump_metadata(void *ctx, const AVDictionary *m, const char *indent)
Definition: dump.c:135
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:453
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:825
sample_rate
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:861
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:187
Timecode helpers header.
main external API structure.
Definition: avcodec.h:531
int qmin
minimum quantizer
Definition: avcodec.h:1373
static void dump_cpb(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:315
static void dump_content_light_metadata(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:357
int coded_height
Definition: avcodec.h:719
int index
Definition: gxfenc.c:89
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Mastering display metadata capable of representing the color volume of the display used to master the...
#define AV_DISPOSITION_TIMED_THUMBNAILS
The stream is sparse, and contains thumbnail images, often corresponding to chapter markers...
Definition: avformat.h:853
static void hex_dump_internal(void *avcl, FILE *f, int level, const uint8_t *buf, int size)
Definition: dump.c:49
This structure describes how to handle spherical videos, outlining information about projection...
Definition: spherical.h:82
static void dump_spherical(void *ctx, const AVCodecParameters *par, const AVPacketSideData *sd)
Definition: dump.c:366
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
static void dump_replaygain(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:239
AVDictionary * metadata
Definition: avformat.h:1162
#define SIZE_SPECIFIER
Definition: internal.h:229
#define flags(name, subs,...)
Definition: cbs_av1.c:560
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:99
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1344
uint8_t level
Definition: svq3.c:205
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:291
int64_t start
Definition: avformat.h:1199
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
Main libavformat public API header.
static void print_peak(void *ctx, const char *str, uint32_t peak)
Definition: dump.c:229
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define FF_API_UNSANITIZED_BITRATES
Definition: version.h:136
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
static void print_gain(void *ctx, const char *str, int32_t gain)
Definition: dump.c:219
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:933
#define AV_DISPOSITION_STILL_IMAGE
still images in video stream (still_picture_flag=1 in mpegts)
Definition: avformat.h:864
Stereoscopic video.
static void dump_dovi_conf(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:396
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1198
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2196
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1246
uint32_t album_peak
Same as track_peak, but for the whole album,.
Definition: replaygain.h:47
#define av_free(p)
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int len
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:477
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: avformat.h:1085
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:145
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:828
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1354
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:652
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
int32_t track_gain
Track replay gain in microbels (divide by 100000 to get the value in dB).
Definition: replaygain.h:34
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
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:81
int stream_index
Definition: packet.h:365
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:909
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1022
ReplayGain information (see http://wiki.hydrogenaudio.org/index.php?title=ReplayGain_1.0_specification).
Definition: replaygain.h:29
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
unsigned MaxFALL
Max average light level per frame (cd/m^2).
This structure stores compressed data.
Definition: packet.h:340
const char * av_spherical_projection_name(enum AVSphericalProjection projection)
Provide a human-readable name of a given AVSphericalProjection.
Definition: spherical.c:60
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
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
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVProgram ** programs
Definition: avformat.h:1419
#define AV_DISPOSITION_ORIGINAL
Definition: avformat.h:827
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
const char * name
Definition: opengl_enc.c:102
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:120
static uint8_t tmp[11]
Definition: aes_ctr.c:26