FFmpeg: libavformat/options.c Source File

FFmpeg
options.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 #include "avformat.h"
21 #include "avio_internal.h"
22 #include "demux.h"
23 #include "internal.h"
24 
25 #include "libavcodec/avcodec.h"
26 #include "libavcodec/codec_par.h"
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/iamf.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/intmath.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/opt.h"
34 
35 /**
36  * @file
37  * Options definition for AVFormatContext.
38  */
39 
40 FF_DISABLE_DEPRECATION_WARNINGS
41 #include "options_table.h"
42 FF_ENABLE_DEPRECATION_WARNINGS
43 
44  static const char* format_to_name(void* ptr)
45 {
46  AVFormatContext* fc = (AVFormatContext*) ptr;
47  if(fc->iformat) return fc->iformat->name;
48  else if(fc->oformat) return fc->oformat->name;
49  else return fc->av_class->class_name;
50 }
51 
52  static void *format_child_next(void *obj, void *prev)
53 {
54  AVFormatContext *s = obj;
55  if (!prev && s->priv_data &&
56  ((s->iformat && s->iformat->priv_class) ||
57  s->oformat && s->oformat->priv_class))
58  return s->priv_data;
59  if (s->pb && s->pb->av_class && prev != s->pb)
60  return s->pb;
61  return NULL;
62 }
63 
64 enum {
65   CHILD_CLASS_ITER_AVIO = 0,
66   CHILD_CLASS_ITER_MUX,
67   CHILD_CLASS_ITER_DEMUX,
68   CHILD_CLASS_ITER_DONE,
69 
70 };
71 
72  #define ITER_STATE_SHIFT 16
73 
74  static const AVClass *format_child_class_iterate(void **iter)
75 {
76  // we use the low 16 bits of iter as the value to be passed to
77  // av_(de)muxer_iterate()
78  void *val = (void*)(((uintptr_t)*iter) & ((1 << ITER_STATE_SHIFT) - 1));
79  unsigned int state = ((uintptr_t)*iter) >> ITER_STATE_SHIFT;
80  const AVClass *ret = NULL;
81 
82  if (state == CHILD_CLASS_ITER_AVIO) {
83  ret = &ff_avio_class;
84  state++;
85  goto finish;
86  }
87 
88  if (state == CHILD_CLASS_ITER_MUX) {
89  const AVOutputFormat *ofmt;
90 
91  while ((ofmt = av_muxer_iterate(&val))) {
92  ret = ofmt->priv_class;
93  if (ret)
94  goto finish;
95  }
96 
97  val = NULL;
98  state++;
99  }
100 
101  if (state == CHILD_CLASS_ITER_DEMUX) {
102  const AVInputFormat *ifmt;
103 
104  while ((ifmt = av_demuxer_iterate(&val))) {
105  ret = ifmt->priv_class;
106  if (ret)
107  goto finish;
108  }
109  val = NULL;
110  state++;
111  }
112 
113 finish:
114  // make sure none av_(de)muxer_iterate does not set the high bits of val
115  av_assert0(!((uintptr_t)val >> ITER_STATE_SHIFT));
116  *iter = (void*)((uintptr_t)val | (state << ITER_STATE_SHIFT));
117  return ret;
118 }
119 
120  static AVClassCategory get_category(void *ptr)
121 {
122  AVFormatContext* s = ptr;
123  if(s->iformat) return AV_CLASS_CATEGORY_DEMUXER;
124  else return AV_CLASS_CATEGORY_MUXER;
125 }
126 
127  static const AVClass av_format_context_class = {
128  .class_name = "AVFormatContext",
129  .item_name = format_to_name,
130  .option = avformat_options,
131  .version = LIBAVUTIL_VERSION_INT,
132  .child_next = format_child_next,
133  .child_class_iterate = format_child_class_iterate,
134  .category = AV_CLASS_CATEGORY_MUXER,
135  .get_category = get_category,
136 };
137 
138  static int io_open_default(AVFormatContext *s, AVIOContext **pb,
139  const char *url, int flags, AVDictionary **options)
140 {
141  int loglevel;
142 
143  if (!strcmp(url, s->url) ||
144  s->iformat && !strcmp(s->iformat->name, "image2") ||
145  s->oformat && !strcmp(s->oformat->name, "image2")
146  ) {
147  loglevel = AV_LOG_DEBUG;
148  } else
149  loglevel = AV_LOG_INFO;
150 
151  av_log(s, loglevel, "Opening \'%s\' for %s\n", url, flags & AVIO_FLAG_WRITE ? "writing" : "reading");
152 
153  return ffio_open_whitelist(pb, url, flags, &s->interrupt_callback, options, s->protocol_whitelist, s->protocol_blacklist);
154 }
155 
156  static int io_close2_default(AVFormatContext *s, AVIOContext *pb)
157 {
158  return avio_close(pb);
159 }
160 
161  AVFormatContext *avformat_alloc_context(void)
162 {
163  FFFormatContext *const si = av_mallocz(sizeof(*si));
164  AVFormatContext *s;
165 
166  if (!si)
167  return NULL;
168 
169  s = &si->pub;
170  s->av_class = &av_format_context_class;
171  s->io_open = io_open_default;
172  s->io_close2= io_close2_default;
173 
174  av_opt_set_defaults(s);
175 
176  si->pkt = av_packet_alloc();
177  si->parse_pkt = av_packet_alloc();
178  if (!si->pkt || !si->parse_pkt) {
179  avformat_free_context(s);
180  return NULL;
181  }
182 
183 #if FF_API_LAVF_SHORTEST
184  si->shortest_end = AV_NOPTS_VALUE;
185 #endif
186 
187  return s;
188 }
189 
190 #if FF_API_GET_DUR_ESTIMATE_METHOD
191 enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method(const AVFormatContext* ctx)
192 {
193  return ctx->duration_estimation_method;
194 }
195 #endif
196 
197  const AVClass *avformat_get_class(void)
198 {
199  return &av_format_context_class;
200 }
201 
202  #define DISPOSITION_OPT(ctx) \
203  { "disposition", NULL, offsetof(ctx, disposition), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, \
204  .flags = AV_OPT_FLAG_ENCODING_PARAM, .unit = "disposition" }, \
205  { "default", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT }, .unit = "disposition" }, \
206  { "dub", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB }, .unit = "disposition" }, \
207  { "original", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL }, .unit = "disposition" }, \
208  { "comment", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT }, .unit = "disposition" }, \
209  { "lyrics", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS }, .unit = "disposition" }, \
210  { "karaoke", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE }, .unit = "disposition" }, \
211  { "forced", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED }, .unit = "disposition" }, \
212  { "hearing_impaired", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED }, .unit = "disposition" }, \
213  { "visual_impaired", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED }, .unit = "disposition" }, \
214  { "clean_effects", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS }, .unit = "disposition" }, \
215  { "attached_pic", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ATTACHED_PIC }, .unit = "disposition" }, \
216  { "timed_thumbnails", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_TIMED_THUMBNAILS }, .unit = "disposition" }, \
217  { "non_diegetic", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_NON_DIEGETIC }, .unit = "disposition" }, \
218  { "captions", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS }, .unit = "disposition" }, \
219  { "descriptions", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS }, .unit = "disposition" }, \
220  { "metadata", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA }, .unit = "disposition" }, \
221  { "dependent", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEPENDENT }, .unit = "disposition" }, \
222  { "still_image", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_STILL_IMAGE }, .unit = "disposition" }, \
223  { "multilayer", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_MULTILAYER }, .unit = "disposition" }
224 
225  static const AVOption stream_options[] = {
226  DISPOSITION_OPT(AVStream),
227  { "discard", NULL, offsetof(AVStream, discard), AV_OPT_TYPE_INT, { .i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX,
228  .flags = AV_OPT_FLAG_DECODING_PARAM, .unit = "avdiscard" },
229  { "none", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONE }, .unit = "avdiscard" },
230  { "default", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_DEFAULT }, .unit = "avdiscard" },
231  { "noref", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONREF }, .unit = "avdiscard" },
232  { "bidir", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_BIDIR }, .unit = "avdiscard" },
233  { "nointra", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONINTRA }, .unit = "avdiscard" },
234  { "nokey", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONKEY }, .unit = "avdiscard" },
235  { "all", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_ALL }, .unit = "avdiscard" },
236  { NULL }
237 };
238 
239  static const AVClass stream_class = {
240  .class_name = "AVStream",
241  .item_name = av_default_item_name,
242  .version = LIBAVUTIL_VERSION_INT,
243  .option = stream_options,
244 };
245 
246  const AVClass *av_stream_get_class(void)
247 {
248  return &stream_class;
249 }
250 
251  AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
252 {
253  FFFormatContext *const si = ffformatcontext(s);
254  FFStream *sti;
255  AVStream *st;
256  AVStream **streams;
257 
258  if (s->nb_streams >= s->max_streams) {
259  av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter"
260  " (%d), see the documentation if you wish to increase it\n",
261  s->max_streams);
262  return NULL;
263  }
264  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
265  if (!streams)
266  return NULL;
267  s->streams = streams;
268 
269  sti = av_mallocz(sizeof(*sti));
270  if (!sti)
271  return NULL;
272  st = &sti->pub;
273 
274  st->av_class = &stream_class;
275  st->codecpar = avcodec_parameters_alloc();
276  if (!st->codecpar)
277  goto fail;
278 
279  sti->fmtctx = s;
280 
281  if (s->iformat) {
282  sti->avctx = avcodec_alloc_context3(NULL);
283  if (!sti->avctx)
284  goto fail;
285 
286  sti->info = av_mallocz(sizeof(*sti->info));
287  if (!sti->info)
288  goto fail;
289 
290 #if FF_API_R_FRAME_RATE
291  sti->info->last_dts = AV_NOPTS_VALUE;
292 #endif
293  sti->info->fps_first_dts = AV_NOPTS_VALUE;
294  sti->info->fps_last_dts = AV_NOPTS_VALUE;
295 
296  /* default pts setting is MPEG-like */
297  avpriv_set_pts_info(st, 33, 1, 90000);
298  /* we set the current DTS to 0 so that formats without any timestamps
299  * but durations get some timestamps, formats with some unknown
300  * timestamps have their first few packets buffered and the
301  * timestamps corrected before they are returned to the user */
302  sti->cur_dts = RELATIVE_TS_BASE;
303  } else {
304  sti->cur_dts = AV_NOPTS_VALUE;
305  }
306 
307  st->index = s->nb_streams;
308  st->start_time = AV_NOPTS_VALUE;
309  st->duration = AV_NOPTS_VALUE;
310  sti->first_dts = AV_NOPTS_VALUE;
311  sti->probe_packets = s->max_probe_packets;
312  sti->pts_wrap_reference = AV_NOPTS_VALUE;
313  sti->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
314 
315  sti->last_IP_pts = AV_NOPTS_VALUE;
316  sti->last_dts_for_order_check = AV_NOPTS_VALUE;
317  for (int i = 0; i < MAX_REORDER_DELAY + 1; i++)
318  sti->pts_buffer[i] = AV_NOPTS_VALUE;
319 
320  st->sample_aspect_ratio = (AVRational) { 0, 1 };
321 #if FF_API_INTERNAL_TIMING
322  sti->transferred_mux_tb = (AVRational) { 0, 1 };;
323 #endif
324 
325 #if FF_API_AVSTREAM_SIDE_DATA
326  sti->inject_global_side_data = si->inject_global_side_data;
327 #endif
328 
329  sti->need_context_update = 1;
330 
331  s->streams[s->nb_streams++] = st;
332  return st;
333 fail:
334  ff_free_stream(&st);
335  return NULL;
336 }
337 
338  #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
339 #define OFFSET(x) offsetof(AVStreamGroupTileGrid, x)
340  static const AVOption tile_grid_options[] = {
341  { "grid_size", "size of the output canvas", OFFSET(coded_width),
342  AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
343  { "output_size", "size of valid pixels in output image meant for presentation", OFFSET(width),
344  AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
345  { "background_color", "set a background color for unused pixels",
346  OFFSET(background), AV_OPT_TYPE_COLOR, { .str = "black"}, 0, 0, FLAGS },
347  { "horizontal_offset", NULL, OFFSET(horizontal_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
348  { "vertical_offset", NULL, OFFSET(vertical_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
349  { NULL },
350 };
351 #undef OFFSET
352 
353  static const AVClass tile_grid_class = {
354  .class_name = "AVStreamGroupTileGrid",
355  .version = LIBAVUTIL_VERSION_INT,
356  .option = tile_grid_options,
357 };
358 
359  #define OFFSET(x) offsetof(AVStreamGroupLCEVC, x)
360  static const AVOption lcevc_options[] = {
361  { "video_size", "size of video after LCEVC enhancement has been applied", OFFSET(width),
362  AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
363  { NULL },
364 };
365 #undef OFFSET
366 
367  static const AVClass lcevc_class = {
368  .class_name = "AVStreamGroupLCEVC",
369  .version = LIBAVUTIL_VERSION_INT,
370  .option = lcevc_options,
371 };
372 
373  static void *stream_group_child_next(void *obj, void *prev)
374 {
375  AVStreamGroup *stg = obj;
376  if (!prev) {
377  switch(stg->type) {
378  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
379  return stg->params.iamf_audio_element;
380  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
381  return stg->params.iamf_mix_presentation;
382  case AV_STREAM_GROUP_PARAMS_TILE_GRID:
383  return stg->params.tile_grid;
384  case AV_STREAM_GROUP_PARAMS_LCEVC:
385  return stg->params.lcevc;
386  default:
387  break;
388  }
389  }
390  return NULL;
391 }
392 
393 #undef FLAGS
394 
395  static const AVClass *stream_group_child_iterate(void **opaque)
396 {
397  uintptr_t i = (uintptr_t)*opaque;
398  const AVClass *ret = NULL;
399 
400  switch(i) {
401  case AV_STREAM_GROUP_PARAMS_NONE:
402  i++;
403  // fall-through
404  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
405  ret = av_iamf_audio_element_get_class();
406  break;
407  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
408  ret = av_iamf_mix_presentation_get_class();
409  break;
410  case AV_STREAM_GROUP_PARAMS_TILE_GRID:
411  ret = &tile_grid_class;
412  break;
413  case AV_STREAM_GROUP_PARAMS_LCEVC:
414  ret = &lcevc_class;
415  break;
416  default:
417  break;
418  }
419 
420  if (ret)
421  *opaque = (void*)(i + 1);
422  return ret;
423 }
424 
425  static const AVOption stream_group_options[] = {
426  DISPOSITION_OPT(AVStreamGroup),
427  {"id", "Set group id", offsetof(AVStreamGroup, id), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
428  { NULL }
429 };
430 
431  static const AVClass stream_group_class = {
432  .class_name = "AVStreamGroup",
433  .item_name = av_default_item_name,
434  .version = LIBAVUTIL_VERSION_INT,
435  .option = stream_group_options,
436  .child_next = stream_group_child_next,
437  .child_class_iterate = stream_group_child_iterate,
438 };
439 
440  const AVClass *av_stream_group_get_class(void)
441 {
442  return &stream_group_class;
443 }
444 
445  AVStreamGroup *avformat_stream_group_create(AVFormatContext *s,
446  enum AVStreamGroupParamsType type,
447  AVDictionary **options)
448 {
449  AVStreamGroup **stream_groups;
450  AVStreamGroup *stg;
451  FFStreamGroup *stgi;
452 
453  stream_groups = av_realloc_array(s->stream_groups, s->nb_stream_groups + 1,
454  sizeof(*stream_groups));
455  if (!stream_groups)
456  return NULL;
457  s->stream_groups = stream_groups;
458 
459  stgi = av_mallocz(sizeof(*stgi));
460  if (!stgi)
461  return NULL;
462  stg = &stgi->pub;
463 
464  stg->av_class = &stream_group_class;
465  av_opt_set_defaults(stg);
466  stg->type = type;
467  switch (type) {
468  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
469  stg->params.iamf_audio_element = av_iamf_audio_element_alloc();
470  if (!stg->params.iamf_audio_element)
471  goto fail;
472  break;
473  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
474  stg->params.iamf_mix_presentation = av_iamf_mix_presentation_alloc();
475  if (!stg->params.iamf_mix_presentation)
476  goto fail;
477  break;
478  case AV_STREAM_GROUP_PARAMS_TILE_GRID:
479  stg->params.tile_grid = av_mallocz(sizeof(*stg->params.tile_grid));
480  if (!stg->params.tile_grid)
481  goto fail;
482  stg->params.tile_grid->av_class = &tile_grid_class;
483  av_opt_set_defaults(stg->params.tile_grid);
484  break;
485  case AV_STREAM_GROUP_PARAMS_LCEVC:
486  stg->params.lcevc = av_mallocz(sizeof(*stg->params.lcevc));
487  if (!stg->params.lcevc)
488  goto fail;
489  stg->params.lcevc->av_class = &lcevc_class;
490  av_opt_set_defaults(stg->params.lcevc);
491  break;
492  default:
493  goto fail;
494  }
495 
496  if (options) {
497  if (av_opt_set_dict2(stg, options, AV_OPT_SEARCH_CHILDREN))
498  goto fail;
499  }
500 
501  stgi->fmtctx = s;
502  stg->index = s->nb_stream_groups;
503 
504  s->stream_groups[s->nb_stream_groups++] = stg;
505 
506  return stg;
507 fail:
508  ff_free_stream_group(&stg);
509  return NULL;
510 }
511 
512  static int stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
513 {
514  AVStream **streams = av_realloc_array(stg->streams, stg->nb_streams + 1,
515  sizeof(*stg->streams));
516  if (!streams)
517  return AVERROR(ENOMEM);
518 
519  stg->streams = streams;
520  stg->streams[stg->nb_streams++] = st;
521 
522  return 0;
523 }
524 
525  int avformat_stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
526 {
527  const FFStreamGroup *stgi = cffstreamgroup(stg);
528  const FFStream *sti = cffstream(st);
529 
530  if (stgi->fmtctx != sti->fmtctx)
531  return AVERROR(EINVAL);
532 
533  for (int i = 0; i < stg->nb_streams; i++)
534  if (stg->streams[i]->index == st->index)
535  return AVERROR(EEXIST);
536 
537  return stream_group_add_stream(stg, st);
538 }
539 
540  static int option_is_disposition(const AVOption *opt)
541 {
542  return opt->type == AV_OPT_TYPE_CONST &&
543  opt->unit && !strcmp(opt->unit, "disposition");
544 }
545 
546  int av_disposition_from_string(const char *disp)
547 {
548  for (const AVOption *opt = stream_options; opt->name; opt++)
549  if (option_is_disposition(opt) && !strcmp(disp, opt->name))
550  return opt->default_val.i64;
551  return AVERROR(EINVAL);
552 }
553 
554  const char *av_disposition_to_string(int disposition)
555 {
556  int val;
557 
558  if (disposition <= 0)
559  return NULL;
560 
561  val = 1 << ff_ctz(disposition);
562  for (const AVOption *opt = stream_options; opt->name; opt++)
563  if (option_is_disposition(opt) && opt->default_val.i64 == val)
564  return opt->name;
565 
566  return NULL;
567 }
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
FFStreamInfo::fps_last_dts
int64_t fps_last_dts
Definition: demux.h:163
iamf.h
AVCodec
AVCodec.
Definition: codec.h:187
AVStreamGroupParamsType
AVStreamGroupParamsType
Definition: avformat.h:1110
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
ffio_open_whitelist
int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist)
Definition: avio.c:471
AVStreamGroup::params
union AVStreamGroup::@363 params
Group type-specific parameters.
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1644
AVERROR
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVStreamGroup::tile_grid
struct AVStreamGroupTileGrid * tile_grid
Definition: avformat.h:1156
DISPOSITION_OPT
#define DISPOSITION_OPT(ctx)
Definition: options.c:202
AV_STREAM_GROUP_PARAMS_LCEVC
@ AV_STREAM_GROUP_PARAMS_LCEVC
Definition: avformat.h:1115
ITER_STATE_SHIFT
#define ITER_STATE_SHIFT
Definition: options.c:72
FFStream::first_dts
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: internal.h:409
ff_ctz
#define ff_ctz
Definition: intmath.h:107
stream_group_add_stream
static int stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
Definition: options.c:512
FFStream::last_IP_pts
int64_t last_IP_pts
Definition: internal.h:377
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
format_child_class_iterate
static const AVClass * format_child_class_iterate(void **iter)
Definition: options.c:74
FLAGS
#define FLAGS
Definition: options.c:338
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:197
AVOption
AVOption.
Definition: opt.h:429
AVFormatContext::duration_estimation_method
enum AVDurationEstimationMethod duration_estimation_method
The duration field can be estimated through various ways, and this field can be used to know how the ...
Definition: avformat.h:1718
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:472
lcevc_options
static const AVOption lcevc_options[]
Definition: options.c:360
AVDictionary
Definition: dict.c:34
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:424
FFStream::last_dts_for_order_check
int64_t last_dts_for_order_check
Internal data to analyze DTS and detect faulty mpeg streams.
Definition: internal.h:352
av_disposition_to_string
const char * av_disposition_to_string(int disposition)
Definition: options.c:554
stream_group_class
static const AVClass stream_group_class
Definition: options.c:431
ff_free_stream_group
void ff_free_stream_group(AVStreamGroup **pstg)
Frees a stream group without modifying the corresponding AVFormatContext.
Definition: avformat.c:83
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:860
finish
static void finish(void)
Definition: movenc.c:374
AVStreamGroup::av_class
const AVClass * av_class
A class for AVOptions.
Definition: avformat.h:1125
fail
#define fail()
Definition: checkasm.h:188
FFStreamInfo::fps_first_dts
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: demux.h:161
FFStream::avctx
struct AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:221
AVDISCARD_NONE
@ AVDISCARD_NONE
discard nothing
Definition: defs.h:215
val
static double val(void *priv, double ch)
Definition: aeval.c:77
av_iamf_audio_element_alloc
AVIAMFAudioElement * av_iamf_audio_element_alloc(void)
Allocates a AVIAMFAudioElement, and initializes its fields with default values.
Definition: iamf.c:322
av_stream_group_get_class
const AVClass * av_stream_group_get_class(void)
Get the AVClass for AVStreamGroup.
Definition: options.c:440
type
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 type
Definition: writing_filters.txt:86
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:807
AV_PTS_WRAP_IGNORE
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:737
AVStreamGroupTileGrid::av_class
const AVClass * av_class
Definition: avformat.h:988
stream_group_child_next
static void * stream_group_child_next(void *obj, void *prev)
Definition: options.c:373
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:548
AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
@ AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
Definition: avformat.h:1113
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
s
#define s(width, name)
Definition: cbs_vp9.c:198
lcevc_class
static const AVClass lcevc_class
Definition: options.c:367
FFStreamInfo::last_dts
int64_t last_dts
Definition: demux.h:140
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
RELATIVE_TS_BASE
#define RELATIVE_TS_BASE
Definition: demux.h:173
FFStreamGroup::fmtctx
AVFormatContext * fmtctx
Definition: internal.h:435
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Underlying C type is int64_t.
Definition: opt.h:263
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
AVStreamGroup::index
unsigned int index
Group index in AVFormatContext.
Definition: avformat.h:1132
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AVDISCARD_BIDIR
@ AVDISCARD_BIDIR
discard all bidirectional frames
Definition: defs.h:218
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Definition: options.c:251
CHILD_CLASS_ITER_DONE
@ CHILD_CLASS_ITER_DONE
Definition: options.c:68
AV_CLASS_CATEGORY_DEMUXER
@ AV_CLASS_CATEGORY_DEMUXER
Definition: log.h:33
CHILD_CLASS_ITER_DEMUX
@ CHILD_CLASS_ITER_DEMUX
Definition: options.c:67
FFFormatContext
Definition: internal.h:64
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFormatContext
Format I/O context.
Definition: avformat.h:1287
FFStream::pub
AVStream pub
The public context.
Definition: internal.h:197
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
avformat_options
static const AVOption avformat_options[]
Definition: options_table.h:36
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Underlying C type is uint8_t[4].
Definition: opt.h:323
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
Definition: opt.h:303
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVDurationEstimationMethod
AVDurationEstimationMethod
The duration of a video can be estimated through various ways, and this enum can be used to know how ...
Definition: avformat.h:1267
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:538
CHILD_CLASS_ITER_MUX
@ CHILD_CLASS_ITER_MUX
Definition: options.c:66
stream_group_options
static const AVOption stream_group_options[]
Definition: options.c:425
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
Definition: opt.h:352
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
format_to_name
FF_DISABLE_DEPRECATION_WARNINGS static const FF_ENABLE_DEPRECATION_WARNINGS char * format_to_name(void *ptr)
Definition: options.c:44
stream_group_child_iterate
static const AVClass * stream_group_child_iterate(void **opaque)
Definition: options.c:395
av_disposition_from_string
int av_disposition_from_string(const char *disp)
Definition: options.c:546
avformat_stream_group_add_stream
int avformat_stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
Add an already allocated stream to a stream group.
Definition: options.c:525
AV_STREAM_GROUP_PARAMS_TILE_GRID
@ AV_STREAM_GROUP_PARAMS_TILE_GRID
Definition: avformat.h:1114
options
const OptionDef options[]
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:220
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
FFFormatContext::parse_pkt
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
Definition: internal.h:127
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:161
AVDISCARD_DEFAULT
@ AVDISCARD_DEFAULT
discard useless packets like 0 size packets in avi
Definition: defs.h:216
FFStream
Definition: internal.h:193
ff_free_stream
void ff_free_stream(AVStream **pst)
Frees a stream without modifying the corresponding AVFormatContext.
Definition: avformat.c:44
AVClass::category
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:114
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:1154
av_iamf_mix_presentation_alloc
AVIAMFMixPresentation * av_iamf_mix_presentation_alloc(void)
Allocates a AVIAMFMixPresentation, and initializes its fields with default values.
Definition: iamf.c:520
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:606
AVOption::name
const char * name
Definition: opt.h:430
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:826
FFStream::pts_wrap_behavior
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: internal.h:332
AVStreamGroup::lcevc
struct AVStreamGroupLCEVC * lcevc
Definition: avformat.h:1157
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
cffstreamgroup
static const av_always_inline FFStreamGroup * cffstreamgroup(const AVStreamGroup *stg)
Definition: internal.h:444
AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
@ AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
Definition: avformat.h:1112
FFStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:383
AVStreamGroup::streams
AVStream ** streams
A list of streams in the group.
Definition: avformat.h:1188
AVStreamGroup::iamf_mix_presentation
struct AVIAMFMixPresentation * iamf_mix_presentation
Definition: avformat.h:1155
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
av_iamf_audio_element_get_class
const AVClass * av_iamf_audio_element_get_class(void)
Definition: iamf.c:317
CHILD_CLASS_ITER_AVIO
@ CHILD_CLASS_ITER_AVIO
Definition: options.c:65
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
get_category
static AVClassCategory get_category(void *ptr)
Definition: options.c:120
OFFSET
#define OFFSET(x)
Definition: options.c:359
AVClassCategory
AVClassCategory
Definition: log.h:28
AV_STREAM_GROUP_PARAMS_NONE
@ AV_STREAM_GROUP_PARAMS_NONE
Definition: avformat.h:1111
AVDISCARD_NONINTRA
@ AVDISCARD_NONINTRA
discard all non intra frames
Definition: defs.h:219
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
tile_grid_class
static const AVClass tile_grid_class
Definition: options.c:353
avio_internal.h
av_opt_set_dict2
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1928
internal.h
io_close2_default
static int io_close2_default(AVFormatContext *s, AVIOContext *pb)
Definition: options.c:156
AVStream::av_class
const AVClass * av_class
A class for AVOptions.
Definition: avformat.h:752
stream_class
static const AVClass stream_class
Definition: options.c:239
ff_avio_class
const AVClass ff_avio_class
Definition: avio.c:98
FFStream::pts_buffer
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: internal.h:347
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
demux.h
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
avformat.h
FFStreamGroup::pub
AVStreamGroup pub
The public context.
Definition: internal.h:433
AVOption::type
enum AVOptionType type
Definition: opt.h:445
av_iamf_mix_presentation_get_class
const AVClass * av_iamf_mix_presentation_get_class(void)
Definition: iamf.c:515
AVStreamGroup
Definition: avformat.h:1121
format_child_next
static void * format_child_next(void *obj, void *prev)
Definition: options.c:52
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:585
AV_CLASS_CATEGORY_MUXER
@ AV_CLASS_CATEGORY_MUXER
Definition: log.h:32
AVStreamGroup::nb_streams
unsigned int nb_streams
Number of elements in AVStreamGroup.streams.
Definition: avformat.h:1175
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:145
stream_options
static const AVOption stream_options[]
Definition: options.c:225
FFStream::info
struct FFStreamInfo * info
Stream information used internally by avformat_find_stream_info()
Definition: internal.h:247
io_open_default
static int io_open_default(AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
Definition: options.c:138
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:356
mem.h
AVStreamGroup::type
enum AVStreamGroupParamsType type
Group type.
Definition: avformat.h:1148
AVOption::unit
const char * unit
The logical unit to which the option belongs.
Definition: opt.h:479
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:134
avformat_stream_group_create
AVStreamGroup * avformat_stream_group_create(AVFormatContext *s, enum AVStreamGroupParamsType type, AVDictionary **options)
Add a new empty stream group to a media file.
Definition: options.c:445
codec_par.h
state
static struct @454 state
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:410
FFStream::need_context_update
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
Definition: internal.h:238
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: avio.c:616
options_table.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FFStream::fmtctx
AVFormatContext * fmtctx
Definition: internal.h:199
tile_grid_options
static const AVOption tile_grid_options[]
Definition: options.c:340
FFStreamGroup
Definition: internal.h:429
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:797
width
#define width
Definition: dsp.h:85
av_stream_get_class
const AVClass * av_stream_get_class(void)
Get the AVClass for AVStream.
Definition: options.c:246
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:217
FFFormatContext::pub
AVFormatContext pub
The public context.
Definition: internal.h:68
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
AVStreamGroupLCEVC::av_class
const AVClass * av_class
Definition: avformat.h:1094
option_is_disposition
static int option_is_disposition(const AVOption *opt)
Definition: options.c:540
FFStream::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: internal.h:320
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:578
MAX_REORDER_DELAY
#define MAX_REORDER_DELAY
Definition: hw_base_encode.h:28
av_format_context_class
static const AVClass av_format_context_class
Definition: options.c:127
intmath.h
Generated on Fri Aug 22 2025 13:58:44 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /