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 
25 #include "libavutil/avstring.h"
27 #include "libavutil/display.h"
28 #include "libavutil/iamf.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/log.h"
33 #include "libavutil/dovi_meta.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/mem.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/replaygain.h"
38 #include "libavutil/spherical.h"
39 #include "libavutil/stereo3d.h"
40 #include "libavutil/timecode.h"
41 
42 #include "libavcodec/avcodec.h"
43 
44 #include "avformat.h"
45 #include "internal.h"
46 
47 #define HEXDUMP_PRINT(...) \
48  do { \
49  if (!f) \
50  av_log(avcl, level, __VA_ARGS__); \
51  else \
52  fprintf(f, __VA_ARGS__); \
53  } while (0)
54 
55 static void hex_dump_internal(void *avcl, FILE *f, int level,
56  const uint8_t *buf, int size)
57 {
58  int len, i, j, c;
59 
60  for (i = 0; i < size; i += 16) {
61  len = size - i;
62  if (len > 16)
63  len = 16;
64  HEXDUMP_PRINT("%08x ", i);
65  for (j = 0; j < 16; j++) {
66  if (j < len)
67  HEXDUMP_PRINT(" %02x", buf[i + j]);
68  else
69  HEXDUMP_PRINT(" ");
70  }
71  HEXDUMP_PRINT(" ");
72  for (j = 0; j < len; j++) {
73  c = buf[i + j];
74  if (c < ' ' || c > '~')
75  c = '.';
76  HEXDUMP_PRINT("%c", c);
77  }
78  HEXDUMP_PRINT("\n");
79  }
80 }
81 
82 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
83 {
84  hex_dump_internal(NULL, f, 0, buf, size);
85 }
86 
87 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
88 {
89  hex_dump_internal(avcl, NULL, level, buf, size);
90 }
91 
92 static void pkt_dump_internal(void *avcl, FILE *f, int level, const AVPacket *pkt,
93  int dump_payload, AVRational time_base)
94 {
95  HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
96  HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
97  HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
98  /* DTS is _always_ valid after av_read_frame() */
99  HEXDUMP_PRINT(" dts=");
100  if (pkt->dts == AV_NOPTS_VALUE)
101  HEXDUMP_PRINT("N/A");
102  else
103  HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
104  /* PTS may not be known if B-frames are present. */
105  HEXDUMP_PRINT(" pts=");
106  if (pkt->pts == AV_NOPTS_VALUE)
107  HEXDUMP_PRINT("N/A");
108  else
109  HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
110  HEXDUMP_PRINT("\n");
111  HEXDUMP_PRINT(" size=%d\n", pkt->size);
112  if (dump_payload)
113  hex_dump_internal(avcl, f, level, pkt->data, pkt->size);
114 }
115 
116 void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st)
117 {
118  pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
119 }
120 
121 void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
122  const AVStream *st)
123 {
124  pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
125 }
126 
127 
128 static void print_fps(double d, const char *postfix, int log_level)
129 {
130  uint64_t v = lrintf(d * 100);
131  if (!v)
132  av_log(NULL, log_level, "%1.4f %s", d, postfix);
133  else if (v % 100)
134  av_log(NULL, log_level, "%3.2f %s", d, postfix);
135  else if (v % (100 * 1000))
136  av_log(NULL, log_level, "%1.0f %s", d, postfix);
137  else
138  av_log(NULL, log_level, "%1.0fk %s", d / 1000, postfix);
139 }
140 
141 static void dump_dictionary(void *ctx, const AVDictionary *m,
142  const char *name, const char *indent,
143  int log_level)
144 {
145  const AVDictionaryEntry *tag = NULL;
146 
147  if (!m)
148  return;
149 
150  av_log(ctx, log_level, "%s%s:\n", indent, name);
151  while ((tag = av_dict_iterate(m, tag)))
152  if (strcmp("language", tag->key)) {
153  const char *p = tag->value;
154  av_log(ctx, log_level,
155  "%s %-16s: ", indent, tag->key);
156  while (*p) {
157  size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
158  av_log(ctx, log_level, "%.*s", (int)(FFMIN(255, len)), p);
159  p += len;
160  if (*p == 0xd) av_log(ctx, log_level, " ");
161  if (*p == 0xa) av_log(ctx, log_level, "\n%s %-16s: ", indent, "");
162  if (*p) p++;
163  }
164  av_log(ctx, log_level, "\n");
165  }
166 }
167 
168 static void dump_metadata(void *ctx, const AVDictionary *m, const char *indent,
169  int log_level)
170 {
171  if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0)))
172  dump_dictionary(ctx, m, "Metadata", indent, log_level);
173 }
174 
175 /* param change side data*/
176 static void dump_paramchange(void *ctx, const AVPacketSideData *sd, int log_level)
177 {
178  int size = sd->size;
179  const uint8_t *data = sd->data;
180  uint32_t flags, sample_rate, width, height;
181 
182  if (!data || sd->size < 4)
183  goto fail;
184 
185  flags = AV_RL32(data);
186  data += 4;
187  size -= 4;
188 
190  if (size < 4)
191  goto fail;
192  sample_rate = AV_RL32(data);
193  data += 4;
194  size -= 4;
195  av_log(ctx, log_level, "sample_rate %"PRIu32", ", sample_rate);
196  }
198  if (size < 8)
199  goto fail;
200  width = AV_RL32(data);
201  data += 4;
202  size -= 4;
203  height = AV_RL32(data);
204  data += 4;
205  size -= 4;
206  av_log(ctx, log_level, "width %"PRIu32" height %"PRIu32, width, height);
207  }
208 
209  return;
210 fail:
211  av_log(ctx, AV_LOG_ERROR, "unknown param\n");
212 }
213 
214 /* replaygain side data*/
215 static void print_gain(void *ctx, const char *str, int32_t gain, int log_level)
216 {
217  av_log(ctx, log_level, "%s - ", str);
218  if (gain == INT32_MIN)
219  av_log(ctx, log_level, "unknown");
220  else
221  av_log(ctx, log_level, "%f", gain / 100000.0f);
222  av_log(ctx, log_level, ", ");
223 }
224 
225 static void print_peak(void *ctx, const char *str, uint32_t peak, int log_level)
226 {
227  av_log(ctx, log_level, "%s - ", str);
228  if (!peak)
229  av_log(ctx, log_level, "unknown");
230  else
231  av_log(ctx, log_level, "%f", (float) peak / UINT32_MAX);
232  av_log(ctx, log_level, ", ");
233 }
234 
235 static void dump_replaygain(void *ctx, const AVPacketSideData *sd, int log_level)
236 {
237  const AVReplayGain *rg;
238 
239  if (sd->size < sizeof(*rg)) {
240  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
241  return;
242  }
243  rg = (const AVReplayGain *)sd->data;
244 
245  print_gain(ctx, "track gain", rg->track_gain, log_level);
246  print_peak(ctx, "track peak", rg->track_peak, log_level);
247  print_gain(ctx, "album gain", rg->album_gain, log_level);
248  print_peak(ctx, "album peak", rg->album_peak, log_level);
249 }
250 
251 static void dump_stereo3d(void *ctx, const AVPacketSideData *sd, int log_level)
252 {
253  const AVStereo3D *stereo;
254 
255  if (sd->size < sizeof(*stereo)) {
256  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
257  return;
258  }
259 
260  stereo = (const AVStereo3D *)sd->data;
261 
262  av_log(ctx, log_level, "%s, view: %s, primary eye: %s",
265  if (stereo->baseline)
266  av_log(ctx, log_level, ", baseline: %"PRIu32"", stereo->baseline);
268  av_log(ctx, log_level, ", horizontal_disparity_adjustment: %0.4f",
271  av_log(ctx, log_level, ", horizontal_field_of_view: %0.3f", av_q2d(stereo->horizontal_field_of_view));
272 
273  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
274  av_log(ctx, log_level, " (inverted)");
275 }
276 
277 static void dump_audioservicetype(void *ctx, const AVPacketSideData *sd, int log_level)
278 {
279  const enum AVAudioServiceType *ast = (const enum AVAudioServiceType *)sd->data;
280 
281  if (sd->size < sizeof(*ast)) {
282  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
283  return;
284  }
285 
286  switch (*ast) {
288  av_log(ctx, log_level, "main");
289  break;
291  av_log(ctx, log_level, "effects");
292  break;
294  av_log(ctx, log_level, "visually impaired");
295  break;
297  av_log(ctx, log_level, "hearing impaired");
298  break;
300  av_log(ctx, log_level, "dialogue");
301  break;
303  av_log(ctx, log_level, "commentary");
304  break;
306  av_log(ctx, log_level, "emergency");
307  break;
309  av_log(ctx, log_level, "voice over");
310  break;
312  av_log(ctx, log_level, "karaoke");
313  break;
314  default:
315  av_log(ctx, AV_LOG_WARNING, "unknown");
316  break;
317  }
318 }
319 
320 static void dump_cpb(void *ctx, const AVPacketSideData *sd, int log_level)
321 {
322  const AVCPBProperties *cpb = (const AVCPBProperties *)sd->data;
323 
324  if (sd->size < sizeof(*cpb)) {
325  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
326  return;
327  }
328 
329  av_log(ctx, log_level,
330  "bitrate max/min/avg: %"PRId64"/%"PRId64"/%"PRId64" buffer size: %"PRId64" ",
331  cpb->max_bitrate, cpb->min_bitrate, cpb->avg_bitrate,
332  cpb->buffer_size);
333  if (cpb->vbv_delay == UINT64_MAX)
334  av_log(ctx, log_level, "vbv_delay: N/A");
335  else
336  av_log(ctx, log_level, "vbv_delay: %"PRIu64"", cpb->vbv_delay);
337 }
338 
340  int log_level)
341 {
342  const AVMasteringDisplayMetadata *metadata =
343  (const AVMasteringDisplayMetadata *)sd->data;
344  av_log(ctx, log_level, "Mastering Display Metadata, "
345  "has_primaries:%d has_luminance:%d "
346  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
347  "min_luminance=%f, max_luminance=%f",
348  metadata->has_primaries, metadata->has_luminance,
349  av_q2d(metadata->display_primaries[0][0]),
350  av_q2d(metadata->display_primaries[0][1]),
351  av_q2d(metadata->display_primaries[1][0]),
352  av_q2d(metadata->display_primaries[1][1]),
353  av_q2d(metadata->display_primaries[2][0]),
354  av_q2d(metadata->display_primaries[2][1]),
355  av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]),
356  av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
357 }
358 
359 static void dump_content_light_metadata(void *ctx, const AVPacketSideData *sd,
360  int log_level)
361 {
362  const AVContentLightMetadata *metadata =
363  (const AVContentLightMetadata *)sd->data;
364  av_log(ctx, log_level, "Content Light Level Metadata, "
365  "MaxCLL=%d, MaxFALL=%d",
366  metadata->MaxCLL, metadata->MaxFALL);
367 }
368 
370 {
371  const AVAmbientViewingEnvironment *ambient =
372  (const AVAmbientViewingEnvironment *)sd->data;
373  av_log(ctx, AV_LOG_INFO, "Ambient Viewing Environment, "
374  "ambient_illuminance=%f, ambient_light_x=%f, ambient_light_y=%f",
375  av_q2d(ambient->ambient_illuminance),
376  av_q2d(ambient->ambient_light_x),
377  av_q2d(ambient->ambient_light_y));
378 }
379 
380 static void dump_spherical(void *ctx, int w, int h,
381  const AVPacketSideData *sd, int log_level)
382 {
383  const AVSphericalMapping *spherical = (const AVSphericalMapping *)sd->data;
384  double yaw, pitch, roll;
385 
386  if (sd->size < sizeof(*spherical)) {
387  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
388  return;
389  }
390 
391  av_log(ctx, log_level, "%s ", av_spherical_projection_name(spherical->projection));
392 
393  if (spherical->yaw || spherical->pitch || spherical->roll) {
394  yaw = ((double)spherical->yaw) / (1 << 16);
395  pitch = ((double)spherical->pitch) / (1 << 16);
396  roll = ((double)spherical->roll) / (1 << 16);
397  av_log(ctx, log_level, "(%f/%f/%f) ", yaw, pitch, roll);
398  }
399 
400  if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
401  size_t l, t, r, b;
402  av_spherical_tile_bounds(spherical, w, h,
403  &l, &t, &r, &b);
404  av_log(ctx, log_level,
406  l, t, r, b);
407  } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
408  av_log(ctx, log_level, "[pad %"PRIu32"] ", spherical->padding);
409  }
410 }
411 
412 static void dump_dovi_conf(void *ctx, const AVPacketSideData *sd,
413  int log_level)
414 {
417 
418  av_log(ctx, log_level, "version: %d.%d, profile: %d, level: %d, "
419  "rpu flag: %d, el flag: %d, bl flag: %d, compatibility id: %d, "
420  "compression: %d",
421  dovi->dv_version_major, dovi->dv_version_minor,
422  dovi->dv_profile, dovi->dv_level,
423  dovi->rpu_present_flag,
424  dovi->el_present_flag,
425  dovi->bl_present_flag,
427  dovi->dv_md_compression);
428 }
429 
430 static void dump_s12m_timecode(void *ctx, AVRational avg_frame_rate, const AVPacketSideData *sd,
431  int log_level)
432 {
433  const uint32_t *tc = (const uint32_t *)sd->data;
434 
435  if ((sd->size != sizeof(uint32_t) * 4) || (tc[0] > 3)) {
436  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
437  return;
438  }
439 
440  for (int j = 1; j <= tc[0]; j++) {
441  char tcbuf[AV_TIMECODE_STR_SIZE];
442  av_timecode_make_smpte_tc_string2(tcbuf, avg_frame_rate, tc[j], 0, 0);
443  av_log(ctx, log_level, "timecode - %s%s", tcbuf, j != tc[0] ? ", " : "");
444  }
445 }
446 
447 static void dump_cropping(void *ctx, const AVPacketSideData *sd)
448 {
449  uint32_t top, bottom, left, right;
450 
451  if (sd->size < sizeof(uint32_t) * 4) {
452  av_log(ctx, AV_LOG_ERROR, "invalid data\n");
453  return;
454  }
455 
456  top = AV_RL32(sd->data + 0);
457  bottom = AV_RL32(sd->data + 4);
458  left = AV_RL32(sd->data + 8);
459  right = AV_RL32(sd->data + 12);
460 
461  av_log(ctx, AV_LOG_INFO, "%d/%d/%d/%d", left, right, top, bottom);
462 }
463 
464 static void dump_sidedata(void *ctx, const AVPacketSideData *side_data, int nb_side_data,
465  int w, int h, AVRational avg_frame_rate,
466  const char *indent, int log_level)
467 {
468  int i;
469 
470  if (nb_side_data)
471  av_log(ctx, log_level, "%sSide data:\n", indent);
472 
473  for (i = 0; i < nb_side_data; i++) {
474  const AVPacketSideData *sd = &side_data[i];
475  av_log(ctx, log_level, "%s ", indent);
476 
477  switch (sd->type) {
478  case AV_PKT_DATA_PALETTE:
479  av_log(ctx, log_level, "palette");
480  break;
482  av_log(ctx, log_level, "new extradata");
483  break;
485  av_log(ctx, log_level, "paramchange: ");
486  dump_paramchange(ctx, sd, log_level);
487  break;
489  av_log(ctx, log_level, "H.263 macroblock info");
490  break;
492  av_log(ctx, log_level, "replaygain: ");
493  dump_replaygain(ctx, sd, log_level);
494  break;
496  av_log(ctx, log_level, "displaymatrix: rotation of %.2f degrees",
497  av_display_rotation_get((const int32_t *)sd->data));
498  break;
500  av_log(ctx, log_level, "stereo3d: ");
501  dump_stereo3d(ctx, sd, log_level);
502  break;
504  av_log(ctx, log_level, "audio service type: ");
505  dump_audioservicetype(ctx, sd, log_level);
506  break;
508  av_log(ctx, log_level, "quality factor: %"PRId32", pict_type: %c",
509  AV_RL32(sd->data), av_get_picture_type_char(sd->data[4]));
510  break;
512  av_log(ctx, log_level, "cpb: ");
513  dump_cpb(ctx, sd, log_level);
514  break;
516  dump_mastering_display_metadata(ctx, sd, log_level);
517  break;
519  av_log(ctx, log_level, "spherical: ");
520  dump_spherical(ctx, w, h, sd, log_level);
521  break;
523  dump_content_light_metadata(ctx, sd, log_level);
524  break;
526  av_log(ctx, log_level, "ICC Profile");
527  break;
529  av_log(ctx, log_level, "DOVI configuration record: ");
530  dump_dovi_conf(ctx, sd, log_level);
531  break;
533  av_log(ctx, log_level, "SMPTE ST 12-1:2014: ");
534  dump_s12m_timecode(ctx, avg_frame_rate, sd, log_level);
535  break;
538  break;
540  av_log(ctx, AV_LOG_INFO, "Frame cropping: ");
541  dump_cropping(ctx, sd);
542  break;
543  default:
544  av_log(ctx, log_level, "unknown side data type %d "
545  "(%"SIZE_SPECIFIER" bytes)", sd->type, sd->size);
546  break;
547  }
548 
549  av_log(ctx, log_level, "\n");
550  }
551 }
552 
553 static void dump_disposition(int disposition, int log_level)
554 {
555  if (disposition & AV_DISPOSITION_DEFAULT)
556  av_log(NULL, log_level, " (default)");
557  if (disposition & AV_DISPOSITION_DUB)
558  av_log(NULL, log_level, " (dub)");
559  if (disposition & AV_DISPOSITION_ORIGINAL)
560  av_log(NULL, log_level, " (original)");
561  if (disposition & AV_DISPOSITION_COMMENT)
562  av_log(NULL, log_level, " (comment)");
563  if (disposition & AV_DISPOSITION_LYRICS)
564  av_log(NULL, log_level, " (lyrics)");
565  if (disposition & AV_DISPOSITION_KARAOKE)
566  av_log(NULL, log_level, " (karaoke)");
567  if (disposition & AV_DISPOSITION_FORCED)
568  av_log(NULL, log_level, " (forced)");
569  if (disposition & AV_DISPOSITION_HEARING_IMPAIRED)
570  av_log(NULL, log_level, " (hearing impaired)");
571  if (disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
572  av_log(NULL, log_level, " (visual impaired)");
573  if (disposition & AV_DISPOSITION_CLEAN_EFFECTS)
574  av_log(NULL, log_level, " (clean effects)");
575  if (disposition & AV_DISPOSITION_ATTACHED_PIC)
576  av_log(NULL, log_level, " (attached pic)");
577  if (disposition & AV_DISPOSITION_TIMED_THUMBNAILS)
578  av_log(NULL, log_level, " (timed thumbnails)");
579  if (disposition & AV_DISPOSITION_CAPTIONS)
580  av_log(NULL, log_level, " (captions)");
581  if (disposition & AV_DISPOSITION_DESCRIPTIONS)
582  av_log(NULL, log_level, " (descriptions)");
583  if (disposition & AV_DISPOSITION_METADATA)
584  av_log(NULL, log_level, " (metadata)");
585  if (disposition & AV_DISPOSITION_DEPENDENT)
586  av_log(NULL, log_level, " (dependent)");
587  if (disposition & AV_DISPOSITION_STILL_IMAGE)
588  av_log(NULL, log_level, " (still image)");
589  if (disposition & AV_DISPOSITION_NON_DIEGETIC)
590  av_log(NULL, log_level, " (non-diegetic)");
591  if (disposition & AV_DISPOSITION_MULTILAYER)
592  av_log(NULL, log_level, " (multilayer)");
593 }
594 
595 /* "user interface" functions */
596 static void dump_stream_format(const AVFormatContext *ic, int i,
597  int group_index, int index, int is_output,
598  int log_level)
599 {
600  char buf[256];
601  int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
602  const AVStream *st = ic->streams[i];
603  const FFStream *const sti = cffstream(st);
604  const AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
605  const char *separator = ic->dump_separator;
606  const char *group_indent = group_index >= 0 ? " " : "";
607  const char *extra_indent = group_index >= 0 ? " " : " ";
608  AVCodecContext *avctx;
609  int ret;
610 
611  avctx = avcodec_alloc_context3(NULL);
612  if (!avctx)
613  return;
614 
616  if (ret < 0) {
617  avcodec_free_context(&avctx);
618  return;
619  }
620 
621  // Fields which are missing from AVCodecParameters need to be taken from the AVCodecContext
622  if (sti->avctx) {
623  avctx->properties = sti->avctx->properties;
624  avctx->codec = sti->avctx->codec;
625  avctx->qmin = sti->avctx->qmin;
626  avctx->qmax = sti->avctx->qmax;
627  avctx->coded_width = sti->avctx->coded_width;
628  avctx->coded_height = sti->avctx->coded_height;
629  }
630 
631  if (separator)
632  av_opt_set(avctx, "dump_separator", separator, 0);
633  avcodec_string(buf, sizeof(buf), avctx, is_output);
634  avcodec_free_context(&avctx);
635 
636  av_log(NULL, log_level, "%s Stream #%d", group_indent, index);
637  av_log(NULL, log_level, ":%d", i);
638 
639  /* the pid is an important information, so we display it */
640  /* XXX: add a generic system */
641  if (flags & AVFMT_SHOW_IDS)
642  av_log(NULL, log_level, "[0x%x]", st->id);
643  if (lang)
644  av_log(NULL, log_level, "(%s)", lang->value);
645  av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", sti->codec_info_nb_frames,
646  st->time_base.num, st->time_base.den);
647  av_log(NULL, log_level, ": %s", buf);
648 
649  if (st->sample_aspect_ratio.num &&
651  AVRational display_aspect_ratio;
652  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
655  1024 * 1024);
656  av_log(NULL, log_level, ", SAR %d:%d DAR %d:%d",
658  display_aspect_ratio.num, display_aspect_ratio.den);
659  }
660 
661  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
662  int fps = st->avg_frame_rate.den && st->avg_frame_rate.num;
663  int tbr = st->r_frame_rate.den && st->r_frame_rate.num;
664  int tbn = st->time_base.den && st->time_base.num;
665 
666  if (fps || tbr || tbn)
667  av_log(NULL, log_level, "%s", separator);
668 
669  if (fps)
670  print_fps(av_q2d(st->avg_frame_rate), tbr || tbn ? "fps, " : "fps", log_level);
671  if (tbr)
672  print_fps(av_q2d(st->r_frame_rate), tbn ? "tbr, " : "tbr", log_level);
673  if (tbn)
674  print_fps(1 / av_q2d(st->time_base), "tbn", log_level);
675  }
676 
677  dump_disposition(st->disposition, log_level);
678  av_log(NULL, log_level, "\n");
679 
680  dump_metadata(NULL, st->metadata, extra_indent, log_level);
681 
683  st->codecpar->width, st->codecpar->height, st->avg_frame_rate,
684  extra_indent, log_level);
685 }
686 
687 static void dump_stream_group(const AVFormatContext *ic, uint8_t *printed,
688  int i, int index, int is_output)
689 {
690  const AVStreamGroup *stg = ic->stream_groups[i];
691  int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
692  char buf[512];
693  int ret;
694 
695  av_log(NULL, AV_LOG_INFO, " Stream group #%d:%d", index, i);
696  if (flags & AVFMT_SHOW_IDS)
697  av_log(NULL, AV_LOG_INFO, "[0x%"PRIx64"]", stg->id);
698  av_log(NULL, AV_LOG_INFO, ":");
699 
700  switch (stg->type) {
702  const AVIAMFAudioElement *audio_element = stg->params.iamf_audio_element;
703  av_log(NULL, AV_LOG_INFO, " IAMF Audio Element:");
705  av_log(NULL, AV_LOG_INFO, "\n");
706  dump_metadata(NULL, stg->metadata, " ", AV_LOG_INFO);
707  for (int j = 0; j < audio_element->nb_layers; j++) {
708  const AVIAMFLayer *layer = audio_element->layers[j];
709  int channel_count = layer->ch_layout.nb_channels;
710  av_log(NULL, AV_LOG_INFO, " Layer %d:", j);
711  ret = av_channel_layout_describe(&layer->ch_layout, buf, sizeof(buf));
712  if (ret >= 0)
713  av_log(NULL, AV_LOG_INFO, " %s", buf);
714  av_log(NULL, AV_LOG_INFO, "\n");
715  for (int k = 0; channel_count > 0 && k < stg->nb_streams; k++) {
716  AVStream *st = stg->streams[k];
717  dump_stream_format(ic, st->index, i, index, is_output, AV_LOG_VERBOSE);
718  printed[st->index] = 1;
719  channel_count -= st->codecpar->ch_layout.nb_channels;
720  }
721  }
722  break;
723  }
725  const AVIAMFMixPresentation *mix_presentation = stg->params.iamf_mix_presentation;
726  av_log(NULL, AV_LOG_INFO, " IAMF Mix Presentation:");
728  av_log(NULL, AV_LOG_INFO, "\n");
729  dump_metadata(NULL, stg->metadata, " ", AV_LOG_INFO);
730  dump_dictionary(NULL, mix_presentation->annotations, "Annotations", " ", AV_LOG_INFO);
731  for (int j = 0; j < mix_presentation->nb_submixes; j++) {
732  AVIAMFSubmix *sub_mix = mix_presentation->submixes[j];
733  av_log(NULL, AV_LOG_INFO, " Submix %d:\n", j);
734  for (int k = 0; k < sub_mix->nb_elements; k++) {
735  const AVIAMFSubmixElement *submix_element = sub_mix->elements[k];
736  const AVStreamGroup *audio_element = NULL;
737  for (int l = 0; l < ic->nb_stream_groups; l++)
739  ic->stream_groups[l]->id == submix_element->audio_element_id) {
740  audio_element = ic->stream_groups[l];
741  break;
742  }
743  if (audio_element) {
744  av_log(NULL, AV_LOG_INFO, " IAMF Audio Element #%d:%d",
745  index, audio_element->index);
746  if (flags & AVFMT_SHOW_IDS)
747  av_log(NULL, AV_LOG_INFO, "[0x%"PRIx64"]", audio_element->id);
748  av_log(NULL, AV_LOG_INFO, "\n");
749  dump_dictionary(NULL, submix_element->annotations, "Annotations", " ", AV_LOG_INFO);
750  }
751  }
752  for (int k = 0; k < sub_mix->nb_layouts; k++) {
753  const AVIAMFSubmixLayout *submix_layout = sub_mix->layouts[k];
754  av_log(NULL, AV_LOG_INFO, " Layout #%d:", k);
755  if (submix_layout->layout_type == 2) {
756  ret = av_channel_layout_describe(&submix_layout->sound_system, buf, sizeof(buf));
757  if (ret >= 0)
758  av_log(NULL, AV_LOG_INFO, " %s", buf);
759  } else if (submix_layout->layout_type == 3)
760  av_log(NULL, AV_LOG_INFO, " Binaural");
761  av_log(NULL, AV_LOG_INFO, "\n");
762  }
763  }
764  break;
765  }
767  const AVStreamGroupTileGrid *tile_grid = stg->params.tile_grid;
769  const char *ptr = NULL;
770  av_log(NULL, AV_LOG_INFO, " Tile Grid:");
771  if (avctx && stg->nb_streams && !avcodec_parameters_to_context(avctx, stg->streams[0]->codecpar)) {
772  avctx->width = tile_grid->width;
773  avctx->height = tile_grid->height;
774  avctx->coded_width = tile_grid->coded_width;
775  avctx->coded_height = tile_grid->coded_height;
776  if (ic->dump_separator)
777  av_opt_set(avctx, "dump_separator", ic->dump_separator, 0);
778  buf[0] = 0;
779  avcodec_string(buf, sizeof(buf), avctx, is_output);
780  ptr = av_stristr(buf, " ");
781  }
782  avcodec_free_context(&avctx);
783  if (ptr)
784  av_log(NULL, AV_LOG_INFO, "%s", ptr);
786  av_log(NULL, AV_LOG_INFO, "\n");
787  dump_metadata(NULL, stg->metadata, " ", AV_LOG_INFO);
788  dump_sidedata(NULL, tile_grid->coded_side_data, tile_grid->nb_coded_side_data,
789  tile_grid->width, tile_grid->height, (AVRational) {0,1},
790  " ", AV_LOG_INFO);
791  for (int i = 0; i < tile_grid->nb_tiles; i++) {
792  const AVStream *st = stg->streams[tile_grid->offsets[i].idx];
793  dump_stream_format(ic, st->index, i, index, is_output, AV_LOG_VERBOSE);
794  printed[st->index] = 1;
795  }
796  for (int i = 0; i < stg->nb_streams; i++) {
797  const AVStream *st = stg->streams[i];
798  if (!printed[st->index]) {
799  dump_stream_format(ic, st->index, i, index, is_output, AV_LOG_INFO);
800  printed[st->index] = 1;
801  }
802  }
803  break;
804  }
806  const AVStreamGroupLCEVC *lcevc = stg->params.lcevc;
808  const char *ptr = NULL;
809  av_log(NULL, AV_LOG_INFO, " LCEVC:");
810  if (avctx && stg->nb_streams && !avcodec_parameters_to_context(avctx, stg->streams[0]->codecpar)) {
811  avctx->width = lcevc->width;
812  avctx->height = lcevc->height;
813  avctx->coded_width = lcevc->width;
814  avctx->coded_height = lcevc->height;
815  if (ic->dump_separator)
816  av_opt_set(avctx, "dump_separator", ic->dump_separator, 0);
817  buf[0] = 0;
818  avcodec_string(buf, sizeof(buf), avctx, is_output);
819  ptr = av_stristr(buf, " ");
820  }
821  avcodec_free_context(&avctx);
822  if (ptr)
823  av_log(NULL, AV_LOG_INFO, "%s", ptr);
824  av_log(NULL, AV_LOG_INFO, "\n");
825  for (int i = 0; i < stg->nb_streams; i++) {
826  const AVStream *st = stg->streams[i];
827  dump_stream_format(ic, st->index, i, index, is_output, AV_LOG_VERBOSE);
828  printed[st->index] = 1;
829  }
830  break;
831  }
832  default:
833  break;
834  }
835 }
836 
838  const char *url, int is_output)
839 {
840  int i;
841  uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
842  if (ic->nb_streams && !printed)
843  return;
844 
845  av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
846  is_output ? "Output" : "Input",
847  index,
848  is_output ? ic->oformat->name : ic->iformat->name,
849  is_output ? "to" : "from", url);
851 
852  if (!is_output) {
853  av_log(NULL, AV_LOG_INFO, " Duration: ");
854  if (ic->duration != AV_NOPTS_VALUE) {
855  int64_t hours, mins, secs, us;
856  int64_t duration = ic->duration + (ic->duration <= INT64_MAX - 5000 ? 5000 : 0);
857  secs = duration / AV_TIME_BASE;
859  mins = secs / 60;
860  secs %= 60;
861  hours = mins / 60;
862  mins %= 60;
863  av_log(NULL, AV_LOG_INFO, "%02"PRId64":%02"PRId64":%02"PRId64".%02"PRId64"", hours, mins, secs,
864  (100 * us) / AV_TIME_BASE);
865  } else {
866  av_log(NULL, AV_LOG_INFO, "N/A");
867  }
868  if (ic->start_time != AV_NOPTS_VALUE) {
869  int secs, us;
870  av_log(NULL, AV_LOG_INFO, ", start: ");
871  secs = llabs(ic->start_time / AV_TIME_BASE);
872  us = llabs(ic->start_time % AV_TIME_BASE);
873  av_log(NULL, AV_LOG_INFO, "%s%d.%06d",
874  ic->start_time >= 0 ? "" : "-",
875  secs,
876  (int) av_rescale(us, 1000000, AV_TIME_BASE));
877  }
878  av_log(NULL, AV_LOG_INFO, ", bitrate: ");
879  if (ic->bit_rate)
880  av_log(NULL, AV_LOG_INFO, "%"PRId64" kb/s", ic->bit_rate / 1000);
881  else
882  av_log(NULL, AV_LOG_INFO, "N/A");
883  av_log(NULL, AV_LOG_INFO, "\n");
884  }
885 
886  if (ic->nb_chapters)
887  av_log(NULL, AV_LOG_INFO, " Chapters:\n");
888  for (i = 0; i < ic->nb_chapters; i++) {
889  const AVChapter *ch = ic->chapters[i];
890  av_log(NULL, AV_LOG_INFO, " Chapter #%d:%d: ", index, i);
892  "start %f, ", ch->start * av_q2d(ch->time_base));
894  "end %f\n", ch->end * av_q2d(ch->time_base));
895 
897  }
898 
899  if (ic->nb_programs) {
900  int j, k, total = 0;
901  for (j = 0; j < ic->nb_programs; j++) {
902  const AVProgram *program = ic->programs[j];
903  const AVDictionaryEntry *name = av_dict_get(program->metadata,
904  "name", NULL, 0);
905  av_log(NULL, AV_LOG_INFO, " Program %d %s\n", program->id,
906  name ? name->value : "");
907  dump_metadata(NULL, program->metadata, " ", AV_LOG_INFO);
908  for (k = 0; k < program->nb_stream_indexes; k++) {
909  dump_stream_format(ic, program->stream_index[k],
910  -1, index, is_output, AV_LOG_INFO);
911  printed[program->stream_index[k]] = 1;
912  }
913  total += program->nb_stream_indexes;
914  }
915  if (total < ic->nb_streams)
916  av_log(NULL, AV_LOG_INFO, " No Program\n");
917  }
918 
919  for (i = 0; i < ic->nb_stream_groups; i++)
920  dump_stream_group(ic, printed, i, index, is_output);
921 
922  for (i = 0; i < ic->nb_streams; i++)
923  if (!printed[i])
924  dump_stream_format(ic, i, -1, index, is_output, AV_LOG_INFO);
925 
926  av_free(printed);
927 }
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
iamf.h
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:105
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:116
AVStreamGroup::params
union AVStreamGroup::@365 params
Group type-specific parameters.
AVIAMFSubmix::elements
AVIAMFSubmixElement ** elements
Array of submix elements.
Definition: iamf.h:561
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVIAMFAudioElement::nb_layers
unsigned int nb_layers
Number of layers, or channel groups, in the Audio Element.
Definition: iamf.h:368
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
AVFormatContext::stream_groups
AVStreamGroup ** stream_groups
A list of all stream groups in the file.
Definition: avformat.h:1387
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_dovi_conf
static void dump_dovi_conf(void *ctx, const AVPacketSideData *sd, int log_level)
Definition: dump.c:412
level
uint8_t level
Definition: svq3.c:205
AVStreamGroup::id
int64_t id
Group type-specific group ID.
Definition: avformat.h:1153
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
AVIAMFSubmix::layouts
AVIAMFSubmixLayout ** layouts
Array of submix layouts.
Definition: iamf.h:576
AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: packet.h:327
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1263
r
const char * r
Definition: vf_curves.c:127
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVStreamGroup::tile_grid
struct AVStreamGroupTileGrid * tile_grid
Definition: avformat.h:1169
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:477
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:98
AV_STREAM_GROUP_PARAMS_LCEVC
@ AV_STREAM_GROUP_PARAMS_LCEVC
Definition: avformat.h:1128
AV_PKT_DATA_QUALITY_STATS
@ AV_PKT_DATA_QUALITY_STATS
This side data contains quality related information from the encoder.
Definition: packet.h:129
AV_PKT_DATA_FRAME_CROPPING
@ AV_PKT_DATA_FRAME_CROPPING
The number of pixels to discard from the top/bottom/left/right border of the decoded frame to obtain ...
Definition: packet.h:340
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1400
AVAmbientViewingEnvironment
Ambient viewing environment metadata as defined by H.274.
Definition: ambient_viewing_environment.h:36
av_stristr
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle.
Definition: avstring.c:58
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
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:674
AVIAMFAudioElement::layers
AVIAMFLayer ** layers
Definition: iamf.h:359
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:39
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:219
dump_stereo3d
static void dump_stereo3d(void *ctx, const AVPacketSideData *sd, int log_level)
Definition: dump.c:251
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:513
hex_dump_internal
static void hex_dump_internal(void *avcl, FILE *f, int level, const uint8_t *buf, int size)
Definition: dump.c:55
int64_t
long long int64_t
Definition: coverity.c:34
AVIAMFMixPresentation::nb_submixes
unsigned int nb_submixes
Number of submixes in the presentation.
Definition: iamf.h:625
AVStreamGroup::disposition
int disposition
Stream group disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1211
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:621
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1368
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:539
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:40
AVAmbientViewingEnvironment::ambient_light_x
AVRational ambient_light_x
Normalized x chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
Definition: ambient_viewing_environment.h:47
b
#define b
Definition: input.c:41
AVReplayGain::album_gain
int32_t album_gain
Same as track_gain, but for the whole album.
Definition: replaygain.h:43
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:837
spherical.h
AVChapter::start
int64_t start
Definition: avformat.h:1262
data
const char data[16]
Definition: mxf.c:149
AV_AUDIO_SERVICE_TYPE_VOICE_OVER
@ AV_AUDIO_SERVICE_TYPE_VOICE_OVER
Definition: defs.h:232
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:288
dump_disposition
static void dump_disposition(int disposition, int log_level)
Definition: dump.c:553
AVIAMFSubmixLayout::layout_type
enum AVIAMFSubmixLayoutType layout_type
Definition: iamf.h:513
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:616
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1501
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
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:68
AVStereo3D::baseline
uint32_t baseline
The distance between the centres of the lenses of the camera system, in micrometers.
Definition: stereo3d.h:228
mathematics.h
AVDictionary
Definition: dict.c:34
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:363
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1273
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
replaygain.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
print_fps
static void print_fps(double d, const char *postfix, int log_level)
Definition: dump.c:128
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
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:280
AVStereo3D::horizontal_field_of_view
AVRational horizontal_field_of_view
Horizontal field of view, in degrees.
Definition: stereo3d.h:239
dump_cropping
static void dump_cropping(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:447
print_gain
static void print_gain(void *ctx, const char *str, int32_t gain, int log_level)
Definition: dump.c:215
AVPacketSideData::size
size_t size
Definition: packet.h:392
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:96
dump_mastering_display_metadata
static void dump_mastering_display_metadata(void *ctx, const AVPacketSideData *sd, int log_level)
Definition: dump.c:339
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:460
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
fail
#define fail()
Definition: checkasm.h:188
AVStreamGroupTileGrid
AVStreamGroupTileGrid holds information on how to combine several independent images on a single canv...
Definition: avformat.h:987
timecode.h
AVIAMFSubmixLayout
Submix layout as defined in section 3.7.6 of IAMF.
Definition: iamf.h:510
AVDOVIDecoderConfigurationRecord::dv_md_compression
uint8_t dv_md_compression
Definition: dovi_meta.h:64
AVStreamGroupTileGrid::coded_width
int coded_width
Width of the canvas.
Definition: avformat.h:1002
AV_DISPOSITION_STILL_IMAGE
#define AV_DISPOSITION_STILL_IMAGE
The video stream contains still images.
Definition: avformat.h:713
FFStream::avctx
struct AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:160
AVChapter
Definition: avformat.h:1259
dump_cpb
static void dump_cpb(void *ctx, const AVPacketSideData *sd, int log_level)
Definition: dump.c:320
AV_DISPOSITION_FORCED
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:654
dump_content_light_metadata
static void dump_content_light_metadata(void *ctx, const AVPacketSideData *sd, int log_level)
Definition: dump.c:359
AVFormatContext::dump_separator
uint8_t * dump_separator
dump format separator.
Definition: avformat.h:1881
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:679
AVStreamGroupTileGrid::coded_height
int coded_height
Width of the canvas.
Definition: avformat.h:1008
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:639
AVStreamGroupLCEVC
AVStreamGroupLCEVC is meant to define the relation between video streams and a data stream containing...
Definition: avformat.h:1106
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:263
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:827
AVAmbientViewingEnvironment::ambient_illuminance
AVRational ambient_illuminance
Environmental illuminance of the ambient viewing environment in lux.
Definition: ambient_viewing_environment.h:40
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_stereo3d_view_name
const char * av_stereo3d_view_name(unsigned int view)
Provide a human-readable name of a given stereo3d view.
Definition: stereo3d.c:113
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1442
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
The audio stream contains music and sound effects without voice.
Definition: avformat.h:666
AVIAMFSubmixElement::annotations
AVDictionary * annotations
A dictionary of strings describing the submix in different languages.
Definition: iamf.h:490
dump_ambient_viewing_environment_metadata
static void dump_ambient_viewing_environment_metadata(void *ctx, const AVPacketSideData *sd)
Definition: dump.c:369
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:69
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1535
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:837
duration
int64_t duration
Definition: movenc.c:65
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:62
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:648
dump_audioservicetype
static void dump_audioservicetype(void *ctx, const AVPacketSideData *sd, int log_level)
Definition: dump.c:277
AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
@ AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
Definition: avformat.h:1126
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:617
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:1262
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
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:144
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1500
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1312
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1401
dump_replaygain
static void dump_replaygain(void *ctx, const AVPacketSideData *sd, int log_level)
Definition: dump.c:235
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AVStreamGroup::index
unsigned int index
Group index in AVFormatContext.
Definition: avformat.h:1145
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:58
ctx
AVFormatContext * ctx
Definition: movenc.c:49
dump_metadata
static void dump_metadata(void *ctx, const AVDictionary *m, const char *indent, int log_level)
Definition: dump.c:168
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:331
AVIAMFLayer::ch_layout
AVChannelLayout ch_layout
Definition: iamf.h:297
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:111
nb_streams
static int nb_streams
Definition: ffprobe.c:384
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
Definition: defs.h:228
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
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:271
AVDOVIDecoderConfigurationRecord::dv_version_major
uint8_t dv_version_major
Definition: dovi_meta.h:56
dump_paramchange
static void dump_paramchange(void *ctx, const AVPacketSideData *sd, int log_level)
Definition: dump.c:176
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:212
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
internal.h
AVStreamGroupLCEVC::height
int height
Height of the final image for presentation.
Definition: avformat.h:1120
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
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:787
NULL
#define NULL
Definition: coverity.c:32
AVDOVIDecoderConfigurationRecord::dv_level
uint8_t dv_level
Definition: dovi_meta.h:59
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:63
AVStreamGroupTileGrid::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the grid.
Definition: avformat.h:1090
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
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:393
AV_DISPOSITION_COMMENT
#define AV_DISPOSITION_COMMENT
The stream is a commentary track.
Definition: avformat.h:639
AVStereo3D::horizontal_disparity_adjustment
AVRational horizontal_disparity_adjustment
Relative shift of the left and right images, which changes the zero parallax plane.
Definition: stereo3d.h:234
AVIAMFLayer
A layer defining a Channel Layout in the Audio Element.
Definition: iamf.h:294
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
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:703
dump_sidedata
static void dump_sidedata(void *ctx, const AVPacketSideData *side_data, int nb_side_data, int w, int h, AVRational avg_frame_rate, const char *indent, int log_level)
Definition: dump.c:464
double
double
Definition: af_crystalizer.c:132
AV_AUDIO_SERVICE_TYPE_EMERGENCY
@ AV_AUDIO_SERVICE_TYPE_EMERGENCY
Definition: defs.h:231
AV_DISPOSITION_ORIGINAL
#define AV_DISPOSITION_ORIGINAL
The stream is in original language.
Definition: avformat.h:635
AV_DISPOSITION_MULTILAYER
#define AV_DISPOSITION_MULTILAYER
The video stream contains multiple layers, e.g.
Definition: avformat.h:718
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
dump_dictionary
static void dump_dictionary(void *ctx, const AVDictionary *m, const char *name, const char *indent, int log_level)
Definition: dump.c:141
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:232
index
int index
Definition: gxfenc.c:90
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:224
AVIAMFSubmixElement::audio_element_id
unsigned int audio_element_id
The id of the Audio Element this submix element references.
Definition: iamf.h:452
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:225
AVIAMFSubmix
Submix layout as defined in section 3.7 of IAMF.
Definition: iamf.h:552
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1356
AVStereo3D::primary_eye
enum AVStereo3DPrimaryEye primary_eye
Which eye is the primary eye when rendering in 2D.
Definition: stereo3d.h:222
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:529
AV_STREAM_GROUP_PARAMS_TILE_GRID
@ AV_STREAM_GROUP_PARAMS_TILE_GRID
Definition: avformat.h:1127
AV_DISPOSITION_CAPTIONS
#define AV_DISPOSITION_CAPTIONS
The subtitle stream contains captions, providing a transcription and possibly a translation of audio.
Definition: avformat.h:692
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:67
dump_s12m_timecode
static void dump_s12m_timecode(void *ctx, AVRational avg_frame_rate, const AVPacketSideData *sd, int log_level)
Definition: dump.c:430
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:61
AVPacket::size
int size
Definition: packet.h:540
height
#define height
Definition: dsp.h:85
FFStream
Definition: internal.h:132
av_stereo3d_primary_eye_name
const char * av_stereo3d_primary_eye_name(unsigned int eye)
Provide a human-readable name of a given stereo3d primary eye.
Definition: stereo3d.c:133
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVStreamGroup::iamf_audio_element
struct AVIAMFAudioElement * iamf_audio_element
Definition: avformat.h:1167
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:629
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:281
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:826
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:658
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:194
AVIAMFAudioElement
Information on how to combine one or more audio streams, as defined in section 3.6 of IAMF.
Definition: iamf.h:356
AVStreamGroupTileGrid::nb_tiles
unsigned int nb_tiles
Amount of tiles in the grid.
Definition: avformat.h:995
AVStreamGroup::lcevc
struct AVStreamGroupLCEVC * lcevc
Definition: avformat.h:1170
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:286
AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
@ AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
Definition: avformat.h:1125
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:194
AVStreamGroup::streams
AVStream ** streams
A list of streams in the group.
Definition: avformat.h:1201
dump_stream_format
static void dump_stream_format(const AVFormatContext *ic, int i, int group_index, int index, int is_output, int log_level)
Definition: dump.c:596
AVStreamGroup::iamf_mix_presentation
struct AVIAMFMixPresentation * iamf_mix_presentation
Definition: avformat.h:1168
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
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:301
AVStreamGroupTileGrid::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: avformat.h:1095
HEXDUMP_PRINT
#define HEXDUMP_PRINT(...)
Definition: dump.c:47
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:142
AVStreamGroupTileGrid::width
int width
Width of the final image for presentation.
Definition: avformat.h:1072
AVSphericalMapping::roll
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:140
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:90
log.h
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
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:139
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1806
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
display.h
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:271
AVIAMFMixPresentation
Information on how to render and mix one or more AVIAMFAudioElement to generate the final audio outpu...
Definition: iamf.h:609
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:276
AV_DISPOSITION_KARAOKE
#define AV_DISPOSITION_KARAOKE
The stream contains karaoke audio.
Definition: avformat.h:647
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
Definition: defs.h:227
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:256
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1224
AV_DISPOSITION_DEPENDENT
#define AV_DISPOSITION_DEPENDENT
The stream is intended to be mixed with another stream before presentation.
Definition: avformat.h:709
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
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
ambient_viewing_environment.h
avcodec.h
AVStreamGroupTileGrid::offsets
struct AVStreamGroupTileGrid::@364 * offsets
An nb_tiles sized array of offsets in pixels from the topleft edge of the canvas, indicating where ea...
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVIAMFSubmix::nb_layouts
unsigned int nb_layouts
Number of layouts in the submix.
Definition: iamf.h:583
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:817
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:662
tag
uint32_t tag
Definition: movenc.c:1876
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
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:87
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1319
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:292
AVSphericalMapping::pitch
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:139
AVStreamGroup::metadata
AVDictionary * metadata
Metadata that applies to the whole group.
Definition: avformat.h:1181
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
avformat.h
dovi_meta.h
AV_AUDIO_SERVICE_TYPE_KARAOKE
@ AV_AUDIO_SERVICE_TYPE_KARAOKE
Definition: defs.h:233
AV_DISPOSITION_DESCRIPTIONS
#define AV_DISPOSITION_DESCRIPTIONS
The subtitle stream contains a textual description of the video content.
Definition: avformat.h:698
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
AVStreamGroup
Definition: avformat.h:1134
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
AVStreamGroup::nb_streams
unsigned int nb_streams
Number of elements in AVStreamGroup.streams.
Definition: avformat.h:1188
channel_layout.h
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1266
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVDOVIDecoderConfigurationRecord::bl_present_flag
uint8_t bl_present_flag
Definition: dovi_meta.h:62
AV_AUDIO_SERVICE_TYPE_COMMENTARY
@ AV_AUDIO_SERVICE_TYPE_COMMENTARY
Definition: defs.h:230
AVIAMFSubmixLayout::sound_system
AVChannelLayout sound_system
Channel layout matching one of Sound Systems A to J of ITU-2051-3, plus 7.1.2ch and 3....
Definition: iamf.h:521
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:914
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:60
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:61
AVStreamGroupLCEVC::width
int width
Width of the final stream for presentation.
Definition: avformat.h:1116
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:1435
AVPacket::stream_index
int stream_index
Definition: packet.h:541
dump_spherical
static void dump_spherical(void *ctx, int w, int h, const AVPacketSideData *sd, int log_level)
Definition: dump.c:380
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:92
AVReplayGain
ReplayGain information (see http://wiki.hydrogenaudio.org/index.php?title=ReplayGain_1....
Definition: replaygain.h:29
AVIAMFSubmix::nb_elements
unsigned int nb_elements
Number of elements in the submix.
Definition: iamf.h:568
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:639
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:117
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:57
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AVStreamGroup::type
enum AVStreamGroupParamsType type
Group type.
Definition: avformat.h:1161
mastering_display_metadata.h
print_peak
static void print_peak(void *ctx, const char *str, uint32_t peak, int log_level)
Definition: dump.c:225
AVIAMFMixPresentation::annotations
AVDictionary * annotations
A dictionary of strings describing the mix in different languages.
Definition: iamf.h:637
AVFormatContext::nb_stream_groups
unsigned int nb_stream_groups
Number of elements in AVFormatContext.stream_groups.
Definition: avformat.h:1375
AVStreamGroupTileGrid::height
int height
Height of the final image for presentation.
Definition: avformat.h:1082
AVStereo3D::view
enum AVStereo3DView view
Determines which views are packed.
Definition: stereo3d.h:217
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AV_AUDIO_SERVICE_TYPE_EFFECTS
@ AV_AUDIO_SERVICE_TYPE_EFFECTS
Definition: defs.h:226
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
int32_t
int32_t
Definition: audioconvert.c:56
AVIAMFSubmixElement
Submix element as defined in section 3.7 of IAMF.
Definition: iamf.h:446
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:1425
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:93
h
h
Definition: vp9dsp_template.c:2070
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:121
AV_AUDIO_SERVICE_TYPE_DIALOGUE
@ AV_AUDIO_SERVICE_TYPE_DIALOGUE
Definition: defs.h:229
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
width
#define width
Definition: dsp.h:85
AVAmbientViewingEnvironment::ambient_light_y
AVRational ambient_light_y
Normalized y chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
Definition: ambient_viewing_environment.h:54
AVStreamGroupTileGrid::idx
unsigned int idx
Index of the stream in the group this tile references.
Definition: avformat.h:1026
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1261
AVIAMFMixPresentation::submixes
AVIAMFSubmix ** submixes
Array of submixes.
Definition: iamf.h:618
dump_stream_group
static void dump_stream_group(const AVFormatContext *ic, uint8_t *printed, int i, int index, int is_output)
Definition: dump.c:687
AV_AUDIO_SERVICE_TYPE_MAIN
@ AV_AUDIO_SERVICE_TYPE_MAIN
Definition: defs.h:225
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:94
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:138
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:643
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:55
AV_DISPOSITION_NON_DIEGETIC
#define AV_DISPOSITION_NON_DIEGETIC
The stream is intended to be mixed with a spatial audio track.
Definition: avformat.h:686
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:82