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 "avformat_internal.h"
22 #include "avio_internal.h"
23 #include "demux.h"
24 #include "internal.h"
25 
26 #include "libavcodec/avcodec.h"
27 #include "libavcodec/codec_par.h"
28 
29 #include "libavutil/avassert.h"
30 #include "libavutil/iamf.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/intmath.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/opt.h"
35 
36 /**
37  * @file
38  * Options definition for AVFormatContext.
39  */
40 
41 FF_DISABLE_DEPRECATION_WARNINGS
42 #include "options_table.h"
43 FF_ENABLE_DEPRECATION_WARNINGS
44 
45  static const char* format_to_name(void* ptr)
46 {
47  AVFormatContext* fc = (AVFormatContext*) ptr;
48  if(fc->iformat) return fc->iformat->name;
49  else if(fc->oformat) return fc->oformat->name;
50  else return fc->av_class->class_name;
51 }
52 
53  static void *format_child_next(void *obj, void *prev)
54 {
55  AVFormatContext *s = obj;
56  if (!prev && s->priv_data &&
57  ((s->iformat && s->iformat->priv_class) ||
58  s->oformat && s->oformat->priv_class))
59  return s->priv_data;
60  if (s->pb && s->pb->av_class && prev != s->pb)
61  return s->pb;
62  return NULL;
63 }
64 
65 enum {
66   CHILD_CLASS_ITER_AVIO = 0,
67   CHILD_CLASS_ITER_MUX,
68   CHILD_CLASS_ITER_DEMUX,
69   CHILD_CLASS_ITER_DONE,
70 
71 };
72 
73  #define ITER_STATE_SHIFT 16
74 
75  static const AVClass *format_child_class_iterate(void **iter)
76 {
77  // we use the low 16 bits of iter as the value to be passed to
78  // av_(de)muxer_iterate()
79  void *val = (void*)(((uintptr_t)*iter) & ((1 << ITER_STATE_SHIFT) - 1));
80  unsigned int state = ((uintptr_t)*iter) >> ITER_STATE_SHIFT;
81  const AVClass *ret = NULL;
82 
83  if (state == CHILD_CLASS_ITER_AVIO) {
84  ret = &ff_avio_class;
85  state++;
86  goto finish;
87  }
88 
89  if (state == CHILD_CLASS_ITER_MUX) {
90  const AVOutputFormat *ofmt;
91 
92  while ((ofmt = av_muxer_iterate(&val))) {
93  ret = ofmt->priv_class;
94  if (ret)
95  goto finish;
96  }
97 
98  val = NULL;
99  state++;
100  }
101 
102  if (state == CHILD_CLASS_ITER_DEMUX) {
103  const AVInputFormat *ifmt;
104 
105  while ((ifmt = av_demuxer_iterate(&val))) {
106  ret = ifmt->priv_class;
107  if (ret)
108  goto finish;
109  }
110  val = NULL;
111  state++;
112  }
113 
114 finish:
115  // make sure none av_(de)muxer_iterate does not set the high bits of val
116  av_assert0(!((uintptr_t)val >> ITER_STATE_SHIFT));
117  *iter = (void*)((uintptr_t)val | (state << ITER_STATE_SHIFT));
118  return ret;
119 }
120 
121  static AVClassCategory get_category(void *ptr)
122 {
123  AVFormatContext* s = ptr;
124  if(s->iformat) return AV_CLASS_CATEGORY_DEMUXER;
125  else return AV_CLASS_CATEGORY_MUXER;
126 }
127 
128  static const AVClass av_format_context_class = {
129  .class_name = "AVFormatContext",
130  .item_name = format_to_name,
131  .option = avformat_options,
132  .version = LIBAVUTIL_VERSION_INT,
133  .child_next = format_child_next,
134  .child_class_iterate = format_child_class_iterate,
135  .category = AV_CLASS_CATEGORY_MUXER,
136  .get_category = get_category,
137 };
138 
139  static int io_open_default(AVFormatContext *s, AVIOContext **pb,
140  const char *url, int flags, AVDictionary **options)
141 {
142  int loglevel;
143 
144  if (!strcmp(url, s->url) ||
145  s->iformat && !strcmp(s->iformat->name, "image2") ||
146  s->oformat && !strcmp(s->oformat->name, "image2")
147  ) {
148  loglevel = AV_LOG_DEBUG;
149  } else
150  loglevel = AV_LOG_INFO;
151 
152  av_log(s, loglevel, "Opening \'%s\' for %s\n", url, flags & AVIO_FLAG_WRITE ? "writing" : "reading");
153 
154  return ffio_open_whitelist(pb, url, flags, &s->interrupt_callback, options, s->protocol_whitelist, s->protocol_blacklist);
155 }
156 
157  static int io_close2_default(AVFormatContext *s, AVIOContext *pb)
158 {
159  return avio_close(pb);
160 }
161 
162  AVFormatContext *avformat_alloc_context(void)
163 {
164  FormatContextInternal *fci;
165  FFFormatContext *si;
166  AVFormatContext *s;
167 
168  fci = av_mallocz(sizeof(*fci));
169  if (!fci)
170  return NULL;
171 
172  si = &fci->fc;
173  s = &si->pub;
174  s->av_class = &av_format_context_class;
175  s->io_open = io_open_default;
176  s->io_close2= io_close2_default;
177 
178  av_opt_set_defaults(s);
179 
180  si->pkt = av_packet_alloc();
181  si->parse_pkt = av_packet_alloc();
182  if (!si->pkt || !si->parse_pkt) {
183  avformat_free_context(s);
184  return NULL;
185  }
186 
187  return s;
188 }
189 
190  const AVClass *avformat_get_class(void)
191 {
192  return &av_format_context_class;
193 }
194 
195  #define DISPOSITION_OPT(ctx) \
196  { "disposition", NULL, offsetof(ctx, disposition), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, \
197  .flags = AV_OPT_FLAG_ENCODING_PARAM, .unit = "disposition" }, \
198  { "default", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT }, .unit = "disposition" }, \
199  { "dub", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB }, .unit = "disposition" }, \
200  { "original", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL }, .unit = "disposition" }, \
201  { "comment", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT }, .unit = "disposition" }, \
202  { "lyrics", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS }, .unit = "disposition" }, \
203  { "karaoke", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE }, .unit = "disposition" }, \
204  { "forced", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED }, .unit = "disposition" }, \
205  { "hearing_impaired", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED }, .unit = "disposition" }, \
206  { "visual_impaired", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED }, .unit = "disposition" }, \
207  { "clean_effects", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS }, .unit = "disposition" }, \
208  { "attached_pic", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ATTACHED_PIC }, .unit = "disposition" }, \
209  { "timed_thumbnails", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_TIMED_THUMBNAILS }, .unit = "disposition" }, \
210  { "non_diegetic", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_NON_DIEGETIC }, .unit = "disposition" }, \
211  { "captions", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS }, .unit = "disposition" }, \
212  { "descriptions", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS }, .unit = "disposition" }, \
213  { "metadata", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA }, .unit = "disposition" }, \
214  { "dependent", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEPENDENT }, .unit = "disposition" }, \
215  { "still_image", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_STILL_IMAGE }, .unit = "disposition" }, \
216  { "multilayer", .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_MULTILAYER }, .unit = "disposition" }
217 
218  static const AVOption stream_options[] = {
219  DISPOSITION_OPT(AVStream),
220  { "discard", NULL, offsetof(AVStream, discard), AV_OPT_TYPE_INT, { .i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX,
221  .flags = AV_OPT_FLAG_DECODING_PARAM, .unit = "avdiscard" },
222  { "none", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONE }, .unit = "avdiscard" },
223  { "default", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_DEFAULT }, .unit = "avdiscard" },
224  { "noref", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONREF }, .unit = "avdiscard" },
225  { "bidir", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_BIDIR }, .unit = "avdiscard" },
226  { "nointra", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONINTRA }, .unit = "avdiscard" },
227  { "nokey", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONKEY }, .unit = "avdiscard" },
228  { "all", .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_ALL }, .unit = "avdiscard" },
229  { NULL }
230 };
231 
232  static const AVClass stream_class = {
233  .class_name = "AVStream",
234  .item_name = av_default_item_name,
235  .version = LIBAVUTIL_VERSION_INT,
236  .option = stream_options,
237 };
238 
239  const AVClass *av_stream_get_class(void)
240 {
241  return &stream_class;
242 }
243 
244  AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
245 {
246  FFStream *sti;
247  AVStream *st;
248  AVStream **streams;
249 
250  if (s->nb_streams >= s->max_streams) {
251  av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter"
252  " (%d), see the documentation if you wish to increase it\n",
253  s->max_streams);
254  return NULL;
255  }
256  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
257  if (!streams)
258  return NULL;
259  s->streams = streams;
260 
261  sti = av_mallocz(sizeof(*sti));
262  if (!sti)
263  return NULL;
264  st = &sti->pub;
265 
266  st->av_class = &stream_class;
267  st->codecpar = avcodec_parameters_alloc();
268  if (!st->codecpar)
269  goto fail;
270 
271  sti->fmtctx = s;
272 
273  if (s->iformat) {
274  sti->avctx = avcodec_alloc_context3(NULL);
275  if (!sti->avctx)
276  goto fail;
277 
278  sti->info = av_mallocz(sizeof(*sti->info));
279  if (!sti->info)
280  goto fail;
281 
282 #if FF_API_R_FRAME_RATE
283  sti->info->last_dts = AV_NOPTS_VALUE;
284 #endif
285  sti->info->fps_first_dts = AV_NOPTS_VALUE;
286  sti->info->fps_last_dts = AV_NOPTS_VALUE;
287 
288  /* default pts setting is MPEG-like */
289  avpriv_set_pts_info(st, 33, 1, 90000);
290  /* we set the current DTS to 0 so that formats without any timestamps
291  * but durations get some timestamps, formats with some unknown
292  * timestamps have their first few packets buffered and the
293  * timestamps corrected before they are returned to the user */
294  sti->cur_dts = RELATIVE_TS_BASE;
295  } else {
296  sti->cur_dts = AV_NOPTS_VALUE;
297  }
298 
299  st->index = s->nb_streams;
300  st->start_time = AV_NOPTS_VALUE;
301  st->duration = AV_NOPTS_VALUE;
302  sti->first_dts = AV_NOPTS_VALUE;
303  sti->probe_packets = s->max_probe_packets;
304  sti->pts_wrap_reference = AV_NOPTS_VALUE;
305  sti->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
306 
307  sti->last_IP_pts = AV_NOPTS_VALUE;
308  sti->last_dts_for_order_check = AV_NOPTS_VALUE;
309  for (int i = 0; i < MAX_REORDER_DELAY + 1; i++)
310  sti->pts_buffer[i] = AV_NOPTS_VALUE;
311 
312  st->sample_aspect_ratio = (AVRational) { 0, 1 };
313 #if FF_API_INTERNAL_TIMING
314  sti->transferred_mux_tb = (AVRational) { 0, 1 };;
315 #endif
316 
317  sti->need_context_update = 1;
318 
319  s->streams[s->nb_streams++] = st;
320  return st;
321 fail:
322  ff_free_stream(&st);
323  return NULL;
324 }
325 
326  #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
327 #define OFFSET(x) offsetof(AVStreamGroupTileGrid, x)
328  static const AVOption tile_grid_options[] = {
329  { "grid_size", "size of the output canvas", OFFSET(coded_width),
330  AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
331  { "output_size", "size of valid pixels in output image meant for presentation", OFFSET(width),
332  AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
333  { "background_color", "set a background color for unused pixels",
334  OFFSET(background), AV_OPT_TYPE_COLOR, { .str = "black"}, 0, 0, FLAGS },
335  { "horizontal_offset", NULL, OFFSET(horizontal_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
336  { "vertical_offset", NULL, OFFSET(vertical_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
337  { NULL },
338 };
339 #undef OFFSET
340 
341  static const AVClass tile_grid_class = {
342  .class_name = "AVStreamGroupTileGrid",
343  .version = LIBAVUTIL_VERSION_INT,
344  .option = tile_grid_options,
345 };
346 
347  #define OFFSET(x) offsetof(AVStreamGroupLCEVC, x)
348  static const AVOption lcevc_options[] = {
349  { "video_size", "size of video after LCEVC enhancement has been applied", OFFSET(width),
350  AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
351  { NULL },
352 };
353 #undef OFFSET
354 
355  static const AVClass lcevc_class = {
356  .class_name = "AVStreamGroupLCEVC",
357  .version = LIBAVUTIL_VERSION_INT,
358  .option = lcevc_options,
359 };
360 
361  static void *stream_group_child_next(void *obj, void *prev)
362 {
363  AVStreamGroup *stg = obj;
364  if (!prev) {
365  switch(stg->type) {
366  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
367  return stg->params.iamf_audio_element;
368  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
369  return stg->params.iamf_mix_presentation;
370  case AV_STREAM_GROUP_PARAMS_TILE_GRID:
371  return stg->params.tile_grid;
372  case AV_STREAM_GROUP_PARAMS_LCEVC:
373  return stg->params.lcevc;
374  default:
375  break;
376  }
377  }
378  return NULL;
379 }
380 
381 #undef FLAGS
382 
383  static const AVClass *stream_group_child_iterate(void **opaque)
384 {
385  uintptr_t i = (uintptr_t)*opaque;
386  const AVClass *ret = NULL;
387 
388  switch(i) {
389  case AV_STREAM_GROUP_PARAMS_NONE:
390  i++;
391  // fall-through
392  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
393  ret = av_iamf_audio_element_get_class();
394  break;
395  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
396  ret = av_iamf_mix_presentation_get_class();
397  break;
398  case AV_STREAM_GROUP_PARAMS_TILE_GRID:
399  ret = &tile_grid_class;
400  break;
401  case AV_STREAM_GROUP_PARAMS_LCEVC:
402  ret = &lcevc_class;
403  break;
404  default:
405  break;
406  }
407 
408  if (ret)
409  *opaque = (void*)(i + 1);
410  return ret;
411 }
412 
413  static const AVOption stream_group_options[] = {
414  DISPOSITION_OPT(AVStreamGroup),
415  {"id", "Set group id", offsetof(AVStreamGroup, id), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
416  { NULL }
417 };
418 
419  static const AVClass stream_group_class = {
420  .class_name = "AVStreamGroup",
421  .item_name = av_default_item_name,
422  .version = LIBAVUTIL_VERSION_INT,
423  .option = stream_group_options,
424  .child_next = stream_group_child_next,
425  .child_class_iterate = stream_group_child_iterate,
426 };
427 
428  const AVClass *av_stream_group_get_class(void)
429 {
430  return &stream_group_class;
431 }
432 
433  AVStreamGroup *avformat_stream_group_create(AVFormatContext *s,
434  enum AVStreamGroupParamsType type,
435  AVDictionary **options)
436 {
437  AVStreamGroup **stream_groups;
438  AVStreamGroup *stg;
439  FFStreamGroup *stgi;
440 
441  stream_groups = av_realloc_array(s->stream_groups, s->nb_stream_groups + 1,
442  sizeof(*stream_groups));
443  if (!stream_groups)
444  return NULL;
445  s->stream_groups = stream_groups;
446 
447  stgi = av_mallocz(sizeof(*stgi));
448  if (!stgi)
449  return NULL;
450  stg = &stgi->pub;
451 
452  stg->av_class = &stream_group_class;
453  av_opt_set_defaults(stg);
454  stg->type = type;
455  switch (type) {
456  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
457  stg->params.iamf_audio_element = av_iamf_audio_element_alloc();
458  if (!stg->params.iamf_audio_element)
459  goto fail;
460  break;
461  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
462  stg->params.iamf_mix_presentation = av_iamf_mix_presentation_alloc();
463  if (!stg->params.iamf_mix_presentation)
464  goto fail;
465  break;
466  case AV_STREAM_GROUP_PARAMS_TILE_GRID:
467  stg->params.tile_grid = av_mallocz(sizeof(*stg->params.tile_grid));
468  if (!stg->params.tile_grid)
469  goto fail;
470  stg->params.tile_grid->av_class = &tile_grid_class;
471  av_opt_set_defaults(stg->params.tile_grid);
472  break;
473  case AV_STREAM_GROUP_PARAMS_LCEVC:
474  stg->params.lcevc = av_mallocz(sizeof(*stg->params.lcevc));
475  if (!stg->params.lcevc)
476  goto fail;
477  stg->params.lcevc->av_class = &lcevc_class;
478  av_opt_set_defaults(stg->params.lcevc);
479  break;
480  default:
481  goto fail;
482  }
483 
484  if (options) {
485  if (av_opt_set_dict2(stg, options, AV_OPT_SEARCH_CHILDREN))
486  goto fail;
487  }
488 
489  stgi->fmtctx = s;
490  stg->index = s->nb_stream_groups;
491 
492  s->stream_groups[s->nb_stream_groups++] = stg;
493 
494  return stg;
495 fail:
496  ff_free_stream_group(&stg);
497  return NULL;
498 }
499 
500  static int stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
501 {
502  AVStream **streams = av_realloc_array(stg->streams, stg->nb_streams + 1,
503  sizeof(*stg->streams));
504  if (!streams)
505  return AVERROR(ENOMEM);
506 
507  stg->streams = streams;
508  stg->streams[stg->nb_streams++] = st;
509 
510  return 0;
511 }
512 
513  int avformat_stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
514 {
515  const FFStreamGroup *stgi = cffstreamgroup(stg);
516  const FFStream *sti = cffstream(st);
517 
518  if (stgi->fmtctx != sti->fmtctx)
519  return AVERROR(EINVAL);
520 
521  for (int i = 0; i < stg->nb_streams; i++)
522  if (stg->streams[i]->index == st->index)
523  return AVERROR(EEXIST);
524 
525  return stream_group_add_stream(stg, st);
526 }
527 
528  static int option_is_disposition(const AVOption *opt)
529 {
530  return opt->type == AV_OPT_TYPE_CONST &&
531  opt->unit && !strcmp(opt->unit, "disposition");
532 }
533 
534  int av_disposition_from_string(const char *disp)
535 {
536  for (const AVOption *opt = stream_options; opt->name; opt++)
537  if (option_is_disposition(opt) && !strcmp(disp, opt->name))
538  return opt->default_val.i64;
539  return AVERROR(EINVAL);
540 }
541 
542  const char *av_disposition_to_string(int disposition)
543 {
544  int val;
545 
546  if (disposition <= 0)
547  return NULL;
548 
549  val = 1 << ff_ctz(disposition);
550  for (const AVOption *opt = stream_options; opt->name; opt++)
551  if (option_is_disposition(opt) && opt->default_val.i64 == val)
552  return opt->name;
553 
554  return NULL;
555 }
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
flags
const SwsFlags flags[]
Definition: swscale.c:61
FFStreamInfo::fps_last_dts
int64_t fps_last_dts
Definition: demux.h:173
iamf.h
AVCodec
AVCodec.
Definition: codec.h:172
AVStreamGroupParamsType
AVStreamGroupParamsType
Definition: avformat.h:1087
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:472
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:1678
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:1133
DISPOSITION_OPT
#define DISPOSITION_OPT(ctx)
Definition: options.c:195
AV_STREAM_GROUP_PARAMS_LCEVC
@ AV_STREAM_GROUP_PARAMS_LCEVC
Definition: avformat.h:1092
ITER_STATE_SHIFT
#define ITER_STATE_SHIFT
Definition: options.c:73
FFStream::first_dts
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: internal.h:337
ff_ctz
#define ff_ctz
Definition: intmath.h:105
stream_group_add_stream
static int stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
Definition: options.c:500
FFStream::last_IP_pts
int64_t last_IP_pts
Definition: internal.h:305
format_child_class_iterate
static const AVClass * format_child_class_iterate(void **iter)
Definition: options.c:75
FLAGS
#define FLAGS
Definition: options.c:326
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:190
AVOption
AVOption.
Definition: opt.h:429
lcevc_options
static const AVOption lcevc_options[]
Definition: options.c:348
AVDictionary
Definition: dict.c:32
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:352
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:287
av_disposition_to_string
const char * av_disposition_to_string(int disposition)
Definition: options.c:542
stream_group_class
static const AVClass stream_group_class
Definition: options.c:419
FormatContextInternal
Definition: avformat_internal.h:33
ff_free_stream_group
void ff_free_stream_group(AVStreamGroup **pstg)
Frees a stream group without modifying the corresponding AVFormatContext.
Definition: avformat.c:76
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:777
finish
static void finish(void)
Definition: movenc.c:374
AVStreamGroup::av_class
const AVClass * av_class
A class for AVOptions.
Definition: avformat.h:1102
fail
#define fail()
Definition: checkasm.h:207
FFStreamInfo::fps_first_dts
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: demux.h:171
FFStream::avctx
struct AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:156
AVDISCARD_NONE
@ AVDISCARD_NONE
discard nothing
Definition: defs.h:226
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:428
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:803
AV_PTS_WRAP_IGNORE
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:733
AVStreamGroupTileGrid::av_class
const AVClass * av_class
Definition: avformat.h:952
state
static struct @542 state
stream_group_child_next
static void * stream_group_child_next(void *obj, void *prev)
Definition: options.c:361
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
AVInputFormat
Definition: avformat.h:544
CHILD_CLASS_ITER_MUX
@ CHILD_CLASS_ITER_MUX
Definition: options.c:67
AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
@ AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
Definition: avformat.h:1090
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:355
FFStreamInfo::last_dts
int64_t last_dts
Definition: demux.h:150
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:494
FFStreamGroup::fmtctx
AVFormatContext * fmtctx
Definition: avformat_internal.h:127
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:41
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:1109
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
RELATIVE_TS_BASE
#define RELATIVE_TS_BASE
Definition: avformat_internal.h:105
AVDISCARD_BIDIR
@ AVDISCARD_BIDIR
discard all bidirectional frames
Definition: defs.h:229
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Definition: options.c:244
AV_CLASS_CATEGORY_DEMUXER
@ AV_CLASS_CATEGORY_DEMUXER
Definition: log.h:33
FFFormatContext
Definition: internal.h:64
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:232
AVFormatContext
Format I/O context.
Definition: avformat.h:1264
FFStream::pub
AVStream pub
The public context.
Definition: internal.h:132
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
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:241
options
Definition: swscale.c:43
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:534
FormatContextInternal::fc
FFFormatContext fc
Definition: avformat_internal.h:34
stream_group_options
static const AVOption stream_group_options[]
Definition: options.c:413
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:45
stream_group_child_iterate
static const AVClass * stream_group_child_iterate(void **opaque)
Definition: options.c:383
av_disposition_from_string
int av_disposition_from_string(const char *disp)
Definition: options.c:534
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:513
AV_STREAM_GROUP_PARAMS_TILE_GRID
@ AV_STREAM_GROUP_PARAMS_TILE_GRID
Definition: avformat.h:1091
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:231
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:104
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:162
AVDISCARD_DEFAULT
@ AVDISCARD_DEFAULT
discard useless packets like 0 size packets in avi
Definition: defs.h:227
FFStream
Definition: internal.h:128
ff_free_stream
void ff_free_stream(AVStream **pst)
Frees a stream without modifying the corresponding AVFormatContext.
Definition: avformat.c:45
CHILD_CLASS_ITER_DEMUX
@ CHILD_CLASS_ITER_DEMUX
Definition: options.c:68
AVClass::category
AVClassCategory category
Category used for visualization (like color).
Definition: log.h:133
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
AVStreamGroup::params
union AVStreamGroup::@421 params
Group type-specific parameters.
AVStreamGroup::iamf_audio_element
struct AVIAMFAudioElement * iamf_audio_element
Definition: avformat.h:1131
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:613
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:822
FFStream::pts_wrap_behavior
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: internal.h:267
AVStreamGroup::lcevc
struct AVStreamGroupLCEVC * lcevc
Definition: avformat.h:1134
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
@ AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
Definition: avformat.h:1089
FFStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:311
AVStreamGroup::streams
AVStream ** streams
A list of streams in the group.
Definition: avformat.h:1165
AVStreamGroup::iamf_mix_presentation
struct AVIAMFMixPresentation * iamf_mix_presentation
Definition: avformat.h:1132
avformat_internal.h
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
av_iamf_audio_element_get_class
const AVClass * av_iamf_audio_element_get_class(void)
Definition: iamf.c:317
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:57
get_category
static AVClassCategory get_category(void *ptr)
Definition: options.c:121
OFFSET
#define OFFSET(x)
Definition: options.c:347
AVClassCategory
AVClassCategory
Definition: log.h:28
AV_STREAM_GROUP_PARAMS_NONE
@ AV_STREAM_GROUP_PARAMS_NONE
Definition: avformat.h:1088
AVDISCARD_NONINTRA
@ AVDISCARD_NONINTRA
discard all non intra frames
Definition: defs.h:230
AVOutputFormat
Definition: avformat.h:505
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:341
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:1962
internal.h
io_close2_default
static int io_close2_default(AVFormatContext *s, AVIOContext *pb)
Definition: options.c:157
AVStream::av_class
const AVClass * av_class
A class for AVOptions.
Definition: avformat.h:748
stream_class
static const AVClass stream_class
Definition: options.c:232
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:282
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
CHILD_CLASS_ITER_DONE
@ CHILD_CLASS_ITER_DONE
Definition: options.c:69
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
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:81
avformat.h
FFStreamGroup::pub
AVStreamGroup pub
The public context.
Definition: avformat_internal.h:125
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:1098
format_child_next
static void * format_child_next(void *obj, void *prev)
Definition: options.c:53
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:750
av_muxer_iterate
const AVOutputFormat * av_muxer_iterate(void **opaque)
Iterate over all registered muxers.
Definition: allformats.c:592
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:1152
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:141
stream_options
static const AVOption stream_options[]
Definition: options.c:218
FFStream::info
struct FFStreamInfo * info
Stream information used internally by avformat_find_stream_info()
Definition: internal.h:182
io_open_default
static int io_open_default(AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
Definition: options.c:139
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:1125
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:111
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:433
codec_par.h
CHILD_CLASS_ITER_AVIO
@ CHILD_CLASS_ITER_AVIO
Definition: options.c:66
FFStream::cur_dts
int64_t cur_dts
Definition: internal.h:338
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:173
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: avio.c:617
options_table.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FFStream::fmtctx
AVFormatContext * fmtctx
Definition: internal.h:134
tile_grid_options
static const AVOption tile_grid_options[]
Definition: options.c:328
FFStreamGroup
Definition: avformat_internal.h:121
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:793
width
#define width
Definition: dsp.h:89
av_stream_get_class
const AVClass * av_stream_get_class(void)
Get the AVClass for AVStream.
Definition: options.c:239
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:228
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:1071
option_is_disposition
static int option_is_disposition(const AVOption *opt)
Definition: options.c:528
FFStream::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: internal.h:255
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:574
MAX_REORDER_DELAY
#define MAX_REORDER_DELAY
Definition: hw_base_encode.h:28
cffstreamgroup
static const av_always_inline FFStreamGroup * cffstreamgroup(const AVStreamGroup *stg)
Definition: avformat_internal.h:135
av_format_context_class
static const AVClass av_format_context_class
Definition: options.c:128
intmath.h
Generated on Tue Nov 18 2025 19:22:36 for FFmpeg by   doxygen 1.8.17

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