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, channels, sample_rate, width, height;
168  uint64_t layout;
169 
170  if (!data || sd->size < 4)
171  goto fail;
172 
173  flags = AV_RL32(data);
174  data += 4;
175  size -= 4;
176 
178  if (size < 4)
179  goto fail;
180  channels = AV_RL32(data);
181  data += 4;
182  size -= 4;
183  av_log(ctx, AV_LOG_INFO, "channel count %"PRIu32", ", channels);
184  }
186  if (size < 8)
187  goto fail;
188  layout = AV_RL64(data);
189  data += 8;
190  size -= 8;
192  "channel layout: %s, ", av_get_channel_name(layout));
193  }
195  if (size < 4)
196  goto fail;
198  data += 4;
199  size -= 4;
200  av_log(ctx, AV_LOG_INFO, "sample_rate %"PRIu32", ", sample_rate);
201  }
203  if (size < 8)
204  goto fail;
205  width = AV_RL32(data);
206  data += 4;
207  size -= 4;
208  height = AV_RL32(data);
209  data += 4;
210  size -= 4;
211  av_log(ctx, AV_LOG_INFO, "width %"PRIu32" height %"PRIu32, width, height);
212  }
213 
214  return;
215 fail:
216  av_log(ctx, AV_LOG_ERROR, "unknown param\n");
217 }
218 
219 /* replaygain side data*/
220 static void print_gain(void *ctx, const char *str, int32_t gain)
221 {
222  av_log(ctx, AV_LOG_INFO, "%s - ", str);
223  if (gain == INT32_MIN)
224  av_log(ctx, AV_LOG_INFO, "unknown");
225  else
226  av_log(ctx, AV_LOG_INFO, "%f", gain / 100000.0f);
227  av_log(ctx, AV_LOG_INFO, ", ");
228 }
229 
230 static void print_peak(void *ctx, const char *str, uint32_t peak)
231 {
232  av_log(ctx, AV_LOG_INFO, "%s - ", str);
233  if (!peak)
234  av_log(ctx, AV_LOG_INFO, "unknown");
235  else
236  av_log(ctx, AV_LOG_INFO, "%f", (float) peak / UINT32_MAX);
237  av_log(ctx, AV_LOG_INFO, ", ");
238 }
239 
240 static void dump_replaygain(void *ctx, const AVPacketSideData *sd)
241 {
242  const AVReplayGain *rg;
243 
244  if (sd->size < sizeof(*rg)) {
245  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
246  return;
247  }
248  rg = (const AVReplayGain *)sd->data;
249 
250  print_gain(ctx, "track gain", rg->track_gain);
251  print_peak(ctx, "track peak", rg->track_peak);
252  print_gain(ctx, "album gain", rg->album_gain);
253  print_peak(ctx, "album peak", rg->album_peak);
254 }
255 
256 static void dump_stereo3d(void *ctx, const AVPacketSideData *sd)
257 {
258  const AVStereo3D *stereo;
259 
260  if (sd->size < sizeof(*stereo)) {
261  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
262  return;
263  }
264 
265  stereo = (const AVStereo3D *)sd->data;
266 
267  av_log(ctx, AV_LOG_INFO, "%s", av_stereo3d_type_name(stereo->type));
268 
269  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
270  av_log(ctx, AV_LOG_INFO, " (inverted)");
271 }
272 
273 static void dump_audioservicetype(void *ctx, const AVPacketSideData *sd)
274 {
275  const enum AVAudioServiceType *ast = (const enum AVAudioServiceType *)sd->data;
276 
277  if (sd->size < sizeof(*ast)) {
278  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
279  return;
280  }
281 
282  switch (*ast) {
284  av_log(ctx, AV_LOG_INFO, "main");
285  break;
287  av_log(ctx, AV_LOG_INFO, "effects");
288  break;
290  av_log(ctx, AV_LOG_INFO, "visually impaired");
291  break;
293  av_log(ctx, AV_LOG_INFO, "hearing impaired");
294  break;
296  av_log(ctx, AV_LOG_INFO, "dialogue");
297  break;
299  av_log(ctx, AV_LOG_INFO, "commentary");
300  break;
302  av_log(ctx, AV_LOG_INFO, "emergency");
303  break;
305  av_log(ctx, AV_LOG_INFO, "voice over");
306  break;
308  av_log(ctx, AV_LOG_INFO, "karaoke");
309  break;
310  default:
311  av_log(ctx, AV_LOG_WARNING, "unknown");
312  break;
313  }
314 }
315 
316 static void dump_cpb(void *ctx, const AVPacketSideData *sd)
317 {
318  const AVCPBProperties *cpb = (const AVCPBProperties *)sd->data;
319 
320  if (sd->size < sizeof(*cpb)) {
321  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
322  return;
323  }
324 
326  "bitrate max/min/avg: %"PRId64"/%"PRId64"/%"PRId64" buffer size: %"PRId64" ",
327  cpb->max_bitrate, cpb->min_bitrate, cpb->avg_bitrate,
328  cpb->buffer_size);
329  if (cpb->vbv_delay == UINT64_MAX)
330  av_log(ctx, AV_LOG_INFO, "vbv_delay: N/A");
331  else
332  av_log(ctx, AV_LOG_INFO, "vbv_delay: %"PRIu64"", cpb->vbv_delay);
333 }
334 
336 {
337  const AVMasteringDisplayMetadata *metadata =
338  (const AVMasteringDisplayMetadata *)sd->data;
339  av_log(ctx, AV_LOG_INFO, "Mastering Display Metadata, "
340  "has_primaries:%d has_luminance:%d "
341  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
342  "min_luminance=%f, max_luminance=%f",
343  metadata->has_primaries, metadata->has_luminance,
344  av_q2d(metadata->display_primaries[0][0]),
345  av_q2d(metadata->display_primaries[0][1]),
346  av_q2d(metadata->display_primaries[1][0]),
347  av_q2d(metadata->display_primaries[1][1]),
348  av_q2d(metadata->display_primaries[2][0]),
349  av_q2d(metadata->display_primaries[2][1]),
350  av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]),
351  av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
352 }
353 
354 static void dump_content_light_metadata(void *ctx, const AVPacketSideData *sd)
355 {
356  const AVContentLightMetadata *metadata =
357  (const AVContentLightMetadata *)sd->data;
358  av_log(ctx, AV_LOG_INFO, "Content Light Level Metadata, "
359  "MaxCLL=%d, MaxFALL=%d",
360  metadata->MaxCLL, metadata->MaxFALL);
361 }
362 
363 static void dump_spherical(void *ctx, const AVCodecParameters *par,
364  const AVPacketSideData *sd)
365 {
366  const AVSphericalMapping *spherical = (const AVSphericalMapping *)sd->data;
367  double yaw, pitch, roll;
368 
369  if (sd->size < sizeof(*spherical)) {
370  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
371  return;
372  }
373 
375 
376  yaw = ((double)spherical->yaw) / (1 << 16);
377  pitch = ((double)spherical->pitch) / (1 << 16);
378  roll = ((double)spherical->roll) / (1 << 16);
379  av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
380 
381  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
382  size_t l, t, r, b;
383  av_spherical_tile_bounds(spherical, par->width, par->height,
384  &l, &t, &r, &b);
387  l, t, r, b);
388  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
389  av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
390  }
391 }
392 
393 static void dump_dovi_conf(void *ctx, const AVPacketSideData *sd)
394 {
397 
398  av_log(ctx, AV_LOG_INFO, "version: %d.%d, profile: %d, level: %d, "
399  "rpu flag: %d, el flag: %d, bl flag: %d, compatibility id: %d",
400  dovi->dv_version_major, dovi->dv_version_minor,
401  dovi->dv_profile, dovi->dv_level,
402  dovi->rpu_present_flag,
403  dovi->el_present_flag,
404  dovi->bl_present_flag,
406 }
407 
408 static void dump_s12m_timecode(void *ctx, const AVStream *st, const AVPacketSideData *sd)
409 {
410  const uint32_t *tc = (const uint32_t *)sd->data;
411 
412  if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
413  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
414  return;
415  }
416 
417  for (int j = 1; j <= tc[0]; j++) {
418  char tcbuf[AV_TIMECODE_STR_SIZE];
420  av_log(ctx, AV_LOG_INFO, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
421  }
422 }
423 
424 static void dump_sidedata(void *ctx, const AVStream *st, const char *indent)
425 {
426  int i;
427 
428  if (st->nb_side_data)
429  av_log(ctx, AV_LOG_INFO, "%sSide data:\n", indent);
430 
431  for (i = 0; i < st->nb_side_data; i++) {
432  const AVPacketSideData *sd = &st->side_data[i];
433  av_log(ctx, AV_LOG_INFO, "%s ", indent);
434 
435  switch (sd->type) {
436  case AV_PKT_DATA_PALETTE:
437  av_log(ctx, AV_LOG_INFO, "palette");
438  break;
440  av_log(ctx, AV_LOG_INFO, "new extradata");
441  break;
443  av_log(ctx, AV_LOG_INFO, "paramchange: ");
444  dump_paramchange(ctx, sd);
445  break;
447  av_log(ctx, AV_LOG_INFO, "H.263 macroblock info");
448  break;
450  av_log(ctx, AV_LOG_INFO, "replaygain: ");
451  dump_replaygain(ctx, sd);
452  break;
454  av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
455  av_display_rotation_get((const int32_t *)sd->data));
456  break;
458  av_log(ctx, AV_LOG_INFO, "stereo3d: ");
459  dump_stereo3d(ctx, sd);
460  break;
462  av_log(ctx, AV_LOG_INFO, "audio service type: ");
464  break;
466  av_log(ctx, AV_LOG_INFO, "quality factor: %"PRId32", pict_type: %c",
467  AV_RL32(sd->data), av_get_picture_type_char(sd->data[4]));
468  break;
470  av_log(ctx, AV_LOG_INFO, "cpb: ");
471  dump_cpb(ctx, sd);
472  break;
475  break;
477  av_log(ctx, AV_LOG_INFO, "spherical: ");
478  dump_spherical(ctx, st->codecpar, sd);
479  break;
482  break;
484  av_log(ctx, AV_LOG_INFO, "ICC Profile");
485  break;
487  av_log(ctx, AV_LOG_INFO, "DOVI configuration record: ");
488  dump_dovi_conf(ctx, sd);
489  break;
491  av_log(ctx, AV_LOG_INFO, "SMPTE ST 12-1:2014: ");
492  dump_s12m_timecode(ctx, st, sd);
493  break;
494  default:
495  av_log(ctx, AV_LOG_INFO, "unknown side data type %d "
496  "(%"SIZE_SPECIFIER" bytes)", sd->type, sd->size);
497  break;
498  }
499 
500  av_log(ctx, AV_LOG_INFO, "\n");
501  }
502 }
503 
504 /* "user interface" functions */
505 static void dump_stream_format(const AVFormatContext *ic, int i,
506  int index, int is_output)
507 {
508  char buf[256];
509  int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
510  const AVStream *st = ic->streams[i];
511  const FFStream *const sti = cffstream(st);
512  const AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
513  const char *separator = ic->dump_separator;
514  AVCodecContext *avctx;
515  int ret;
516 
517  avctx = avcodec_alloc_context3(NULL);
518  if (!avctx)
519  return;
520 
522  if (ret < 0) {
523  avcodec_free_context(&avctx);
524  return;
525  }
526 
527  // Fields which are missing from AVCodecParameters need to be taken from the AVCodecContext
528  avctx->properties = sti->avctx->properties;
529  avctx->codec = sti->avctx->codec;
530  avctx->qmin = sti->avctx->qmin;
531  avctx->qmax = sti->avctx->qmax;
532  avctx->coded_width = sti->avctx->coded_width;
533  avctx->coded_height = sti->avctx->coded_height;
534 
535  if (separator)
536  av_opt_set(avctx, "dump_separator", separator, 0);
537  avcodec_string(buf, sizeof(buf), avctx, is_output);
538  avcodec_free_context(&avctx);
539 
540  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
541 
542  /* the pid is an important information, so we display it */
543  /* XXX: add a generic system */
544  if (flags & AVFMT_SHOW_IDS)
545  av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
546  if (lang)
547  av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
548  av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", sti->codec_info_nb_frames,
549  st->time_base.num, st->time_base.den);
550  av_log(NULL, AV_LOG_INFO, ": %s", buf);
551 
552  if (st->sample_aspect_ratio.num &&
554  AVRational display_aspect_ratio;
555  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
556  st->codecpar->width * (int64_t)st->sample_aspect_ratio.num,
557  st->codecpar->height * (int64_t)st->sample_aspect_ratio.den,
558  1024 * 1024);
559  av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
561  display_aspect_ratio.num, display_aspect_ratio.den);
562  }
563 
564  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
565  int fps = st->avg_frame_rate.den && st->avg_frame_rate.num;
566  int tbr = st->r_frame_rate.den && st->r_frame_rate.num;
567  int tbn = st->time_base.den && st->time_base.num;
568 
569  if (fps || tbr || tbn)
570  av_log(NULL, AV_LOG_INFO, "%s", separator);
571 
572  if (fps)
573  print_fps(av_q2d(st->avg_frame_rate), tbr || tbn ? "fps, " : "fps");
574  if (tbr)
575  print_fps(av_q2d(st->r_frame_rate), tbn ? "tbr, " : "tbr");
576  if (tbn)
577  print_fps(1 / av_q2d(st->time_base), "tbn");
578  }
579 
581  av_log(NULL, AV_LOG_INFO, " (default)");
583  av_log(NULL, AV_LOG_INFO, " (dub)");
585  av_log(NULL, AV_LOG_INFO, " (original)");
587  av_log(NULL, AV_LOG_INFO, " (comment)");
589  av_log(NULL, AV_LOG_INFO, " (lyrics)");
591  av_log(NULL, AV_LOG_INFO, " (karaoke)");
593  av_log(NULL, AV_LOG_INFO, " (forced)");
595  av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
597  av_log(NULL, AV_LOG_INFO, " (visual impaired)");
599  av_log(NULL, AV_LOG_INFO, " (clean effects)");
601  av_log(NULL, AV_LOG_INFO, " (attached pic)");
603  av_log(NULL, AV_LOG_INFO, " (timed thumbnails)");
605  av_log(NULL, AV_LOG_INFO, " (captions)");
607  av_log(NULL, AV_LOG_INFO, " (descriptions)");
609  av_log(NULL, AV_LOG_INFO, " (metadata)");
611  av_log(NULL, AV_LOG_INFO, " (dependent)");
613  av_log(NULL, AV_LOG_INFO, " (still image)");
614  av_log(NULL, AV_LOG_INFO, "\n");
615 
616  dump_metadata(NULL, st->metadata, " ");
617 
618  dump_sidedata(NULL, st, " ");
619 }
620 
622  const char *url, int is_output)
623 {
624  int i;
625  uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
626  if (ic->nb_streams && !printed)
627  return;
628 
629  av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
630  is_output ? "Output" : "Input",
631  index,
632  is_output ? ic->oformat->name : ic->iformat->name,
633  is_output ? "to" : "from", url);
634  dump_metadata(NULL, ic->metadata, " ");
635 
636  if (!is_output) {
637  av_log(NULL, AV_LOG_INFO, " Duration: ");
638  if (ic->duration != AV_NOPTS_VALUE) {
639  int64_t hours, mins, secs, us;
640  int64_t duration = ic->duration + (ic->duration <= INT64_MAX - 5000 ? 5000 : 0);
641  secs = duration / AV_TIME_BASE;
643  mins = secs / 60;
644  secs %= 60;
645  hours = mins / 60;
646  mins %= 60;
647  av_log(NULL, AV_LOG_INFO, "%02"PRId64":%02"PRId64":%02"PRId64".%02"PRId64"", hours, mins, secs,
648  (100 * us) / AV_TIME_BASE);
649  } else {
650  av_log(NULL, AV_LOG_INFO, "N/A");
651  }
652  if (ic->start_time != AV_NOPTS_VALUE) {
653  int secs, us;
654  av_log(NULL, AV_LOG_INFO, ", start: ");
655  secs = llabs(ic->start_time / AV_TIME_BASE);
656  us = llabs(ic->start_time % AV_TIME_BASE);
657  av_log(NULL, AV_LOG_INFO, "%s%d.%06d",
658  ic->start_time >= 0 ? "" : "-",
659  secs,
660  (int) av_rescale(us, 1000000, AV_TIME_BASE));
661  }
662  av_log(NULL, AV_LOG_INFO, ", bitrate: ");
663  if (ic->bit_rate)
664  av_log(NULL, AV_LOG_INFO, "%"PRId64" kb/s", ic->bit_rate / 1000);
665  else
666  av_log(NULL, AV_LOG_INFO, "N/A");
667  av_log(NULL, AV_LOG_INFO, "\n");
668  }
669 
670  if (ic->nb_chapters)
671  av_log(NULL, AV_LOG_INFO, " Chapters:\n");
672  for (i = 0; i < ic->nb_chapters; i++) {
673  const AVChapter *ch = ic->chapters[i];
674  av_log(NULL, AV_LOG_INFO, " Chapter #%d:%d: ", index, i);
676  "start %f, ", ch->start * av_q2d(ch->time_base));
678  "end %f\n", ch->end * av_q2d(ch->time_base));
679 
680  dump_metadata(NULL, ch->metadata, " ");
681  }
682 
683  if (ic->nb_programs) {
684  int j, k, total = 0;
685  for (j = 0; j < ic->nb_programs; j++) {
686  const AVProgram *program = ic->programs[j];
687  const AVDictionaryEntry *name = av_dict_get(program->metadata,
688  "name", NULL, 0);
689  av_log(NULL, AV_LOG_INFO, " Program %d %s\n", program->id,
690  name ? name->value : "");
691  dump_metadata(NULL, program->metadata, " ");
692  for (k = 0; k < program->nb_stream_indexes; k++) {
693  dump_stream_format(ic, program->stream_index[k],
694  index, is_output);
695  printed[program->stream_index[k]] = 1;
696  }
697  total += program->nb_stream_indexes;
698  }
699  if (total < ic->nb_streams)
700  av_log(NULL, AV_LOG_INFO, " No Program\n");
701  }
702 
703  for (i = 0; i < ic->nb_streams; i++)
704  if (!printed[i])
705  dump_stream_format(ic, i, index, is_output);
706 
707  av_free(printed);
708 }
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
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:204
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:496
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1072
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:56
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:465
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:1327
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
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:72
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:827
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:519
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:408
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:804
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:26
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1177
index
fg index
Definition: ffmpeg_filter.c:168
AVPacketSideData
Definition: packet.h:314
AVPacket::data
uint8_t * data
Definition: packet.h:373
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:393
b
#define b
Definition: input.c:40
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:46
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:924
spherical.h
AVChapter::start
int64_t start
Definition: avformat.h:1071
data
const char data[16]
Definition: mxf.c:143
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:449
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1278
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
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:316
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
Definition: packet.h:448
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:434
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:228
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1165
replaygain.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
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:316
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
fail
#define fail()
Definition: checkasm.h:127
timecode.h
dump_audioservicetype
static void dump_audioservicetype(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:273
AV_DISPOSITION_STILL_IMAGE
#define AV_DISPOSITION_STILL_IMAGE
still images in video stream (still_picture_flag=1 in mpegts)
Definition: avformat.h:841
AVChapter
Definition: avformat.h:1068
AV_DISPOSITION_FORCED
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:816
AVFormatContext::dump_separator
uint8_t * dump_separator
dump format separator.
Definition: avformat.h:1633
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:832
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:571
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
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:108
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:468
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:99
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1218
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:819
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:1338
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:621
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:120
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:450
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:141
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1071
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:114
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1277
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:643
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1121
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1328
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:126
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:274
av_get_channel_name
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
Definition: channel_layout.c:249
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:315
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:54
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:408
channels
channels
Definition: aptx.h:33
nb_streams
static int nb_streams
Definition: ffprobe.c:289
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
f
#define f(width, name)
Definition: cbs_vp9.c:255
AVDOVIDecoderConfigurationRecord::dv_version_major
uint8_t dv_version_major
Definition: dovi_meta.h:52
print_peak
static void print_peak(void *ctx, const char *str, uint32_t peak)
Definition: dump.c:230
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:335
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1109
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1004
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:880
NULL
#define NULL
Definition: coverity.c:32
AVDOVIDecoderConfigurationRecord::dv_level
uint8_t dv_level
Definition: dovi_meta.h:55
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:59
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:156
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:220
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:317
AV_DISPOSITION_COMMENT
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:807
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:915
dump_content_light_metadata
static void dump_content_light_metadata(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:354
AV_DISPOSITION_METADATA
#define AV_DISPOSITION_METADATA
Definition: avformat.h:839
AV_AUDIO_SERVICE_TYPE_EMERGENCY
@ AV_AUDIO_SERVICE_TYPE_EMERGENCY
Definition: defs.h:64
AV_DISPOSITION_ORIGINAL
#define AV_DISPOSITION_ORIGINAL
Definition: avformat.h:806
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:1165
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:515
dump_stereo3d
static void dump_stereo3d(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:256
AV_DISPOSITION_CAPTIONS
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:837
dump_spherical
static void dump_spherical(void *ctx, const AVCodecParameters *par, const AVPacketSideData *sd)
Definition: dump.c:363
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
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:374
FFStream
Definition: internal.h:191
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:505
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
Definition: avformat.h:805
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:93
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:913
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:817
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
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:235
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
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:953
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:83
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:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
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:136
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1822
AVCodecParameters::height
int height
Definition: codec_par.h:127
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:147
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
Definition: avformat.h:809
dump_sidedata
static void dump_sidedata(void *ctx, const AVStream *st, const char *indent)
Definition: dump.c:424
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:263
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1033
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:145
AV_DISPOSITION_DEPENDENT
#define AV_DISPOSITION_DEPENDENT
dependent audio stream (mix_type=0 in mpegts)
Definition: avformat.h:840
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:128
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVStream::disposition
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:904
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:818
tag
uint32_t tag
Definition: movenc.c:1595
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:864
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:857
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:283
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:1128
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:957
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:291
AV_DISPOSITION_DESCRIPTIONS
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:838
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:193
AVCodecContext
main external API structure.
Definition: avcodec.h:383
channel_layout.h
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
Definition: packet.h:447
FFStream::avctx
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:218
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:657
dump_replaygain
static void dump_replaygain(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:240
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1158
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:55
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVDOVIDecoderConfigurationRecord::bl_present_flag
uint8_t bl_present_flag
Definition: dovi_meta.h:58
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:993
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:56
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:57
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:1211
AVPacket::stream_index
int stream_index
Definition: packet.h:375
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
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:571
tc
#define tc
Definition: regdef.h:69
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:53
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mastering_display_metadata.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
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:350
d
d
Definition: ffmpeg_filter.c:156
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:132
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:83
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1201
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:57
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:1070
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:34
AV_DISPOSITION_LYRICS
#define AV_DISPOSITION_LYRICS
Definition: avformat.h:808
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:51
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