FFmpeg
avformat.c
Go to the documentation of this file.
1 /*
2  * Various functions used by both muxers and demuxers
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 <math.h>
23 #include "libavutil/avassert.h"
24 #include "libavutil/avstring.h"
26 #include "libavutil/frame.h"
27 #include "libavutil/iamf.h"
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/mem.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixfmt.h"
32 #include "libavutil/samplefmt.h"
33 #include "libavcodec/avcodec.h"
34 #include "libavcodec/codec.h"
35 #include "libavcodec/bsf.h"
36 #include "libavcodec/codec_desc.h"
38 #include "avformat.h"
39 #include "avio.h"
40 #include "demux.h"
41 #include "mux.h"
42 #include "internal.h"
43 
45 {
46  AVStream *st = *pst;
47  FFStream *const sti = ffstream(st);
48 
49  if (!st)
50  return;
51 
52 #if FF_API_AVSTREAM_SIDE_DATA
54  for (int i = 0; i < st->nb_side_data; i++)
55  av_freep(&st->side_data[i].data);
56  av_freep(&st->side_data);
58 #endif
59 
60  if (st->attached_pic.data)
62 
63  av_parser_close(sti->parser);
65  av_bsf_free(&sti->bsfc);
66  av_freep(&sti->index_entries);
67  av_freep(&sti->probe_data.buf);
68 
70 
71  if (sti->info) {
73  av_freep(&sti->info);
74  }
75 
76  av_dict_free(&st->metadata);
78  av_freep(&st->priv_data);
79 
80  av_freep(pst);
81 }
82 
84 {
85  AVStreamGroup *stg = *pstg;
86 
87  if (!stg)
88  return;
89 
90  av_freep(&stg->streams);
91  av_dict_free(&stg->metadata);
92  av_freep(&stg->priv_data);
93  switch (stg->type) {
96  break;
97  }
100  break;
101  }
105  av_freep(&stg->params.tile_grid);
106  break;
107  default:
108  break;
109  }
110 
111  av_freep(pstg);
112 }
113 
115 {
116  av_assert0(s->nb_streams>0);
117  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
118 
119  ff_free_stream(&s->streams[ --s->nb_streams ]);
120 }
121 
123 {
124  av_assert0(s->nb_stream_groups > 0);
125  av_assert0(s->stream_groups[ s->nb_stream_groups - 1 ] == stg);
126 
127  ff_free_stream_group(&s->stream_groups[ --s->nb_stream_groups ]);
128 }
129 
130 /* XXX: suppress the packet queue */
132 {
133  FFFormatContext *const si = ffformatcontext(s);
137 
138  si->raw_packet_buffer_size = 0;
139 }
140 
142 {
143  FFFormatContext *si;
144 
145  if (!s)
146  return;
147  si = ffformatcontext(s);
148 
149  if (s->oformat && ffofmt(s->oformat)->deinit && si->initialized)
150  ffofmt(s->oformat)->deinit(s);
151 
152  av_opt_free(s);
153  if (s->iformat && s->iformat->priv_class && s->priv_data)
154  av_opt_free(s->priv_data);
155  if (s->oformat && s->oformat->priv_class && s->priv_data)
156  av_opt_free(s->priv_data);
157 
158  for (unsigned i = 0; i < s->nb_streams; i++)
159  ff_free_stream(&s->streams[i]);
160  for (unsigned i = 0; i < s->nb_stream_groups; i++)
161  ff_free_stream_group(&s->stream_groups[i]);
162  s->nb_stream_groups = 0;
163  s->nb_streams = 0;
164 
165  for (unsigned i = 0; i < s->nb_programs; i++) {
166  av_dict_free(&s->programs[i]->metadata);
167  av_freep(&s->programs[i]->stream_index);
168  av_freep(&s->programs[i]);
169  }
170  s->nb_programs = 0;
171 
172  av_freep(&s->programs);
173  av_freep(&s->priv_data);
174  while (s->nb_chapters--) {
175  av_dict_free(&s->chapters[s->nb_chapters]->metadata);
176  av_freep(&s->chapters[s->nb_chapters]);
177  }
178  av_freep(&s->chapters);
179  av_dict_free(&s->metadata);
180  av_dict_free(&si->id3v2_meta);
181  av_packet_free(&si->pkt);
183  av_freep(&s->streams);
184  av_freep(&s->stream_groups);
186  av_freep(&s->url);
187  av_free(s);
188 }
189 
190 #if FF_API_AVSTREAM_SIDE_DATA
192 uint8_t *av_stream_get_side_data(const AVStream *st,
193  enum AVPacketSideDataType type, size_t *size)
194 {
195  for (int i = 0; i < st->nb_side_data; i++) {
196  if (st->side_data[i].type == type) {
197  if (size)
198  *size = st->side_data[i].size;
199  return st->side_data[i].data;
200  }
201  }
202  if (size)
203  *size = 0;
204  return NULL;
205 }
206 
207 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
208  uint8_t *data, size_t size)
209 {
210  AVPacketSideData *sd, *tmp;
211 
212  for (int i = 0; i < st->nb_side_data; i++) {
213  sd = &st->side_data[i];
214 
215  if (sd->type == type) {
216  av_freep(&sd->data);
217  sd->data = data;
218  sd->size = size;
219  return 0;
220  }
221  }
222 
223  if (st->nb_side_data + 1U > FFMIN(INT_MAX, SIZE_MAX / sizeof(*tmp)))
224  return AVERROR(ERANGE);
225 
226  tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
227  if (!tmp) {
228  return AVERROR(ENOMEM);
229  }
230 
231  st->side_data = tmp;
232  st->nb_side_data++;
233 
234  sd = &st->side_data[st->nb_side_data - 1];
235  sd->type = type;
236  sd->data = data;
237  sd->size = size;
238 
239  return 0;
240 }
241 
242 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
243  size_t size)
244 {
245  int ret;
246  uint8_t *data = av_malloc(size);
247 
248  if (!data)
249  return NULL;
250 
251  ret = av_stream_add_side_data(st, type, data, size);
252  if (ret < 0) {
253  av_freep(&data);
254  return NULL;
255  }
256 
257  return data;
258 }
260 #endif
261 
262 /**
263  * Copy all stream parameters from source to destination stream, with the
264  * exception of the index field, which is usually set by avformat_new_stream().
265  *
266  * @param dst pointer to destination AVStream
267  * @param src pointer to source AVStream
268  * @return >=0 on success, AVERROR code on error
269  */
270 static int stream_params_copy(AVStream *dst, const AVStream *src)
271 {
272  int ret;
273 
274  dst->id = src->id;
275  dst->time_base = src->time_base;
276  dst->start_time = src->start_time;
277  dst->duration = src->duration;
278  dst->nb_frames = src->nb_frames;
279  dst->disposition = src->disposition;
280  dst->discard = src->discard;
281  dst->sample_aspect_ratio = src->sample_aspect_ratio;
282  dst->avg_frame_rate = src->avg_frame_rate;
283  dst->event_flags = src->event_flags;
284  dst->r_frame_rate = src->r_frame_rate;
285  dst->pts_wrap_bits = src->pts_wrap_bits;
286 
287  av_dict_free(&dst->metadata);
288  ret = av_dict_copy(&dst->metadata, src->metadata, 0);
289  if (ret < 0)
290  return ret;
291 
292  ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
293  if (ret < 0)
294  return ret;
295 
297  if (src->attached_pic.data) {
298  ret = av_packet_ref(&dst->attached_pic, &src->attached_pic);
299  if (ret < 0)
300  return ret;
301  }
302 
303  return 0;
304 }
305 
307 {
308  AVStream *st;
309  int ret;
310 
311  st = avformat_new_stream(dst_ctx, NULL);
312  if (!st)
313  return NULL;
314 
315  ret = stream_params_copy(st, src);
316  if (ret < 0) {
317  ff_remove_stream(dst_ctx, st);
318  return NULL;
319  }
320 
321  return st;
322 }
323 
325 {
326  switch(type) {
327  case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT: return "IAMF Audio Element";
328  case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION: return "IAMF Mix Presentation";
329  case AV_STREAM_GROUP_PARAMS_TILE_GRID: return "Tile Grid";
330  }
331  return NULL;
332 }
333 
335 {
337  int ret;
338 
339  av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
340 
341  for (unsigned i = 0; i < ac->nb_programs; i++)
342  if (ac->programs[i]->id == id)
343  program = ac->programs[i];
344 
345  if (!program) {
346  program = av_mallocz(sizeof(*program));
347  if (!program)
348  return NULL;
350  if (ret < 0) {
351  av_free(program);
352  return NULL;
353  }
354  program->discard = AVDISCARD_NONE;
355  program->pmt_version = -1;
356  program->id = id;
357  program->pts_wrap_reference = AV_NOPTS_VALUE;
358  program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
359  program->start_time =
360  program->end_time = AV_NOPTS_VALUE;
361  }
362  return program;
363 }
364 
365 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
366 {
368  void *tmp;
369 
370  if (idx >= ac->nb_streams) {
371  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
372  return;
373  }
374 
375  for (unsigned i = 0; i < ac->nb_programs; i++) {
376  if (ac->programs[i]->id != progid)
377  continue;
378  program = ac->programs[i];
379  for (unsigned j = 0; j < program->nb_stream_indexes; j++)
380  if (program->stream_index[j] == idx)
381  return;
382 
383  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
384  if (!tmp)
385  return;
386  program->stream_index = tmp;
387  program->stream_index[program->nb_stream_indexes++] = idx;
388  return;
389  }
390 }
391 
393 {
394  for (unsigned i = 0; i < ic->nb_programs; i++) {
395  if (ic->programs[i] == last) {
396  last = NULL;
397  } else {
398  if (!last)
399  for (unsigned j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
400  if (ic->programs[i]->stream_index[j] == s)
401  return ic->programs[i];
402  }
403  }
404  return NULL;
405 }
406 
408 {
409  int best_stream = 0;
410  int best_score = INT_MIN;
411 
412  if (s->nb_streams <= 0)
413  return -1;
414  for (unsigned i = 0; i < s->nb_streams; i++) {
415  const AVStream *const st = s->streams[i];
416  const FFStream *const sti = cffstream(st);
417  int score = 0;
418  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
420  score -= 400;
421  if (st->codecpar->width && st->codecpar->height)
422  score += 50;
423  score+= 25;
424  }
425  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
426  if (st->codecpar->sample_rate)
427  score += 50;
428  }
429  if (sti->codec_info_nb_frames)
430  score += 12;
431 
432  if (st->discard != AVDISCARD_ALL)
433  score += 200;
434 
435  if (score > best_score) {
436  best_score = score;
437  best_stream = i;
438  }
439  }
440  return best_stream;
441 }
442 
444  int wanted_stream_nb, int related_stream,
445  const AVCodec **decoder_ret, int flags)
446 {
447  int nb_streams = ic->nb_streams;
449  int best_count = -1, best_multiframe = -1, best_disposition = -1;
450  int count, multiframe, disposition;
451  int64_t best_bitrate = -1;
452  int64_t bitrate;
453  unsigned *program = NULL;
454  const AVCodec *decoder = NULL, *best_decoder = NULL;
455 
456  if (related_stream >= 0 && wanted_stream_nb < 0) {
457  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
458  if (p) {
459  program = p->stream_index;
461  }
462  }
463  for (unsigned i = 0; i < nb_streams; i++) {
464  int real_stream_index = program ? program[i] : i;
465  AVStream *st = ic->streams[real_stream_index];
466  AVCodecParameters *par = st->codecpar;
467  if (par->codec_type != type)
468  continue;
469  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
470  continue;
471  if (type == AVMEDIA_TYPE_AUDIO && !(par->ch_layout.nb_channels && par->sample_rate))
472  continue;
473  if (decoder_ret) {
474  decoder = ff_find_decoder(ic, st, par->codec_id);
475  if (!decoder) {
476  if (ret < 0)
478  continue;
479  }
480  }
482  + !! (st->disposition & AV_DISPOSITION_DEFAULT);
483  count = ffstream(st)->codec_info_nb_frames;
484  bitrate = par->bit_rate;
485  multiframe = FFMIN(5, count);
486  if ((best_disposition > disposition) ||
487  (best_disposition == disposition && best_multiframe > multiframe) ||
488  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
489  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
490  continue;
491  best_disposition = disposition;
492  best_count = count;
493  best_bitrate = bitrate;
494  best_multiframe = multiframe;
495  ret = real_stream_index;
496  best_decoder = decoder;
497  if (program && i == nb_streams - 1 && ret < 0) {
498  program = NULL;
499  nb_streams = ic->nb_streams;
500  /* no related stream found, try again with everything */
501  i = 0;
502  }
503  }
504  if (decoder_ret)
505  *decoder_ret = best_decoder;
506  return ret;
507 }
508 
509 /**
510  * Matches a stream specifier (but ignores requested index).
511  *
512  * @param indexptr set to point to the requested stream index if there is one
513  *
514  * @return <0 on error
515  * 0 if st is NOT a matching stream
516  * >0 if st is a matching stream
517  */
518 static int match_stream_specifier(const AVFormatContext *s, const AVStream *st,
519  const char *spec, const char **indexptr,
520  const AVStreamGroup **g, const AVProgram **p)
521 {
522  int match = 1; /* Stores if the specifier matches so far. */
523  while (*spec) {
524  if (*spec <= '9' && *spec >= '0') { /* opt:index */
525  if (indexptr)
526  *indexptr = spec;
527  return match;
528  } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
529  *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
530  enum AVMediaType type;
531  int nopic = 0;
532 
533  switch (*spec++) {
534  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
535  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
536  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
537  case 'd': type = AVMEDIA_TYPE_DATA; break;
538  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
539  case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
540  default: av_assert0(0);
541  }
542  if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
543  return AVERROR(EINVAL);
544 
545  if (type != st->codecpar->codec_type)
546  match = 0;
547  if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
548  match = 0;
549  } else if (*spec == 'g' && *(spec + 1) == ':') {
550  int64_t group_idx = -1, group_id = -1;
551  int found = 0;
552  char *endptr;
553  spec += 2;
554  if (*spec == '#' || (*spec == 'i' && *(spec + 1) == ':')) {
555  spec += 1 + (*spec == 'i');
556  group_id = strtol(spec, &endptr, 0);
557  if (spec == endptr || (*endptr && *endptr++ != ':'))
558  return AVERROR(EINVAL);
559  spec = endptr;
560  } else {
561  group_idx = strtol(spec, &endptr, 0);
562  /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
563  if (spec == endptr || (*endptr && *endptr++ != ':'))
564  return AVERROR(EINVAL);
565  spec = endptr;
566  }
567  if (match) {
568  if (group_id > 0) {
569  for (unsigned i = 0; i < s->nb_stream_groups; i++) {
570  if (group_id == s->stream_groups[i]->id) {
571  group_idx = i;
572  break;
573  }
574  }
575  }
576  if (group_idx < 0 || group_idx >= s->nb_stream_groups)
577  return AVERROR(EINVAL);
578  for (unsigned j = 0; j < s->stream_groups[group_idx]->nb_streams; j++) {
579  if (st->index == s->stream_groups[group_idx]->streams[j]->index) {
580  found = 1;
581  if (g)
582  *g = s->stream_groups[group_idx];
583  break;
584  }
585  }
586  }
587  if (!found)
588  match = 0;
589  } else if (*spec == 'p' && *(spec + 1) == ':') {
590  int prog_id;
591  int found = 0;
592  char *endptr;
593  spec += 2;
594  prog_id = strtol(spec, &endptr, 0);
595  /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
596  if (spec == endptr || (*endptr && *endptr++ != ':'))
597  return AVERROR(EINVAL);
598  spec = endptr;
599  if (match) {
600  for (unsigned i = 0; i < s->nb_programs; i++) {
601  if (s->programs[i]->id != prog_id)
602  continue;
603 
604  for (unsigned j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
605  if (st->index == s->programs[i]->stream_index[j]) {
606  found = 1;
607  if (p)
608  *p = s->programs[i];
609  i = s->nb_programs;
610  break;
611  }
612  }
613  }
614  }
615  if (!found)
616  match = 0;
617  } else if (*spec == '#' ||
618  (*spec == 'i' && *(spec + 1) == ':')) {
619  int stream_id;
620  char *endptr;
621  spec += 1 + (*spec == 'i');
622  stream_id = strtol(spec, &endptr, 0);
623  if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
624  return AVERROR(EINVAL);
625  return match && (stream_id == st->id);
626  } else if (*spec == 'm' && *(spec + 1) == ':') {
627  const AVDictionaryEntry *tag;
628  char *key, *val;
629  int ret;
630 
631  if (match) {
632  spec += 2;
633  val = strchr(spec, ':');
634 
635  key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
636  if (!key)
637  return AVERROR(ENOMEM);
638 
639  tag = av_dict_get(st->metadata, key, NULL, 0);
640  if (tag) {
641  if (!val || !strcmp(tag->value, val + 1))
642  ret = 1;
643  else
644  ret = 0;
645  } else
646  ret = 0;
647 
648  av_freep(&key);
649  }
650  return match && ret;
651  } else if (*spec == 'u' && *(spec + 1) == '\0') {
652  const AVCodecParameters *par = st->codecpar;
653  int val;
654  switch (par->codec_type) {
655  case AVMEDIA_TYPE_AUDIO:
656  val = par->sample_rate && par->ch_layout.nb_channels;
657  if (par->format == AV_SAMPLE_FMT_NONE)
658  return 0;
659  break;
660  case AVMEDIA_TYPE_VIDEO:
661  val = par->width && par->height;
662  if (par->format == AV_PIX_FMT_NONE)
663  return 0;
664  break;
666  val = 0;
667  break;
668  default:
669  val = 1;
670  break;
671  }
672  return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
673  } else {
674  return AVERROR(EINVAL);
675  }
676  }
677 
678  return match;
679 }
680 
682  const char *spec)
683 {
684  int ret, index;
685  char *endptr;
686  const char *indexptr = NULL;
687  const AVStreamGroup *g = NULL;
688  const AVProgram *p = NULL;
689  int nb_streams;
690 
691  ret = match_stream_specifier(s, st, spec, &indexptr, &g, &p);
692  if (ret < 0)
693  goto error;
694 
695  if (!indexptr)
696  return ret;
697 
698  index = strtol(indexptr, &endptr, 0);
699  if (*endptr) { /* We can't have anything after the requested index. */
700  ret = AVERROR(EINVAL);
701  goto error;
702  }
703 
704  /* This is not really needed but saves us a loop for simple stream index specifiers. */
705  if (spec == indexptr)
706  return (index == st->index);
707 
708  /* If we requested a matching stream index, we have to ensure st is that. */
709  nb_streams = g ? g->nb_streams : (p ? p->nb_stream_indexes : s->nb_streams);
710  for (int i = 0; i < nb_streams && index >= 0; i++) {
711  unsigned idx = g ? g->streams[i]->index : (p ? p->stream_index[i] : i);
712  const AVStream *candidate = s->streams[idx];
713  ret = match_stream_specifier(s, candidate, spec, NULL, NULL, NULL);
714  if (ret < 0)
715  goto error;
716  if (ret > 0 && index-- == 0 && st == candidate)
717  return 1;
718  }
719  return 0;
720 
721 error:
722  if (ret == AVERROR(EINVAL))
723  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
724  return ret;
725 }
726 
728 {
729  AVRational undef = {0, 1};
730  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
731  AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
732  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
733 
734  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
735  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
736  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
737  stream_sample_aspect_ratio = undef;
738 
739  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
740  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
741  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
742  frame_sample_aspect_ratio = undef;
743 
744  if (stream_sample_aspect_ratio.num)
745  return stream_sample_aspect_ratio;
746  else
747  return frame_sample_aspect_ratio;
748 }
749 
751 {
752  AVRational fr = st->r_frame_rate;
754  AVRational avg_fr = st->avg_frame_rate;
755 
756  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
757  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
758  fr = avg_fr;
759  }
760 
761  if (desc && (desc->props & AV_CODEC_PROP_FIELDS)) {
762  const AVCodecContext *const avctx = ffstream(st)->avctx;
763  AVRational codec_fr = avctx->framerate;
764 
765  if ( codec_fr.num > 0 && codec_fr.den > 0 &&
766  (fr.num == 0 || av_q2d(codec_fr) < av_q2d(fr)*0.7 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1))
767  fr = codec_fr;
768  }
769 
770  return fr;
771 }
772 
774  AVStream *ost, const AVStream *ist,
776 {
778  const AVCodecContext *const dec_ctx = cffstream(ist)->avctx;
779 
780  AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
781  AVRational dec_ctx_framerate = dec_ctx ? dec_ctx->framerate : (AVRational){ 0, 0 };
782  AVRational dec_ctx_tb = dec_ctx_framerate.num ? av_inv_q(av_mul_q(dec_ctx_framerate, mul))
783  : (ist->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ? (AVRational){0, 1}
784  : ist->time_base);
785  AVRational enc_tb = ist->time_base;
786 #if FF_API_TICKS_PER_FRAME
788  int ticks_per_frame = dec_ctx ? dec_ctx->ticks_per_frame : 1;
790 #endif
791 
792  /*
793  * Avi is a special case here because it supports variable fps but
794  * having the fps and timebase differe significantly adds quite some
795  * overhead
796  */
797  if (!strcmp(ofmt->name, "avi")) {
798 #if FF_API_R_FRAME_RATE
799  if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
800  && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
801  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
802  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx_tb)
803  && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx_tb) < 1.0/500
804  || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
805  enc_tb.num = ist->r_frame_rate.den;
806  enc_tb.den = 2*ist->r_frame_rate.num;
807  } else
808 #endif
809  if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx_framerate.num &&
810  av_q2d(av_inv_q(dec_ctx_framerate)) > 2*av_q2d(ist->time_base)
811  && av_q2d(ist->time_base) < 1.0/500
812  || (copy_tb == AVFMT_TBCF_DECODER &&
813  (dec_ctx_framerate.num || ist->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))) {
814  enc_tb = dec_ctx_tb;
815  enc_tb.den *= 2;
816 #if FF_API_TICKS_PER_FRAME
817  enc_tb.num *= ticks_per_frame;
818 #endif
819  }
820  } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
821  && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
822  if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx_framerate.num
823  && av_q2d(av_inv_q(dec_ctx_framerate)) > av_q2d(ist->time_base)
824  && av_q2d(ist->time_base) < 1.0/500
825  || (copy_tb == AVFMT_TBCF_DECODER &&
826  (dec_ctx_framerate.num || ist->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))) {
827  enc_tb = dec_ctx_tb;
828 #if FF_API_TICKS_PER_FRAME
829  enc_tb.num *= ticks_per_frame;
830 #endif
831  }
832  }
833 
834  if (ost->codecpar->codec_tag == AV_RL32("tmcd")
835  && dec_ctx_tb.num < dec_ctx_tb.den
836  && dec_ctx_tb.num > 0
837  && 121LL*dec_ctx_tb.num > dec_ctx_tb.den) {
838  enc_tb = dec_ctx_tb;
839  }
840 
841  av_reduce(&ffstream(ost)->transferred_mux_tb.num,
842  &ffstream(ost)->transferred_mux_tb.den,
843  enc_tb.num, enc_tb.den, INT_MAX);
844 
845  return 0;
846 }
847 
849 {
851 }
852 
853 void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits,
854  unsigned int pts_num, unsigned int pts_den)
855 {
856  FFStream *const sti = ffstream(st);
857  AVRational new_tb;
858  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
859  if (new_tb.num != pts_num)
861  "st:%d removing common factor %d from timebase\n",
862  st->index, pts_num / new_tb.num);
863  } else
865  "st:%d has too large timebase, reducing\n", st->index);
866 
867  if (new_tb.num <= 0 || new_tb.den <= 0) {
869  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
870  new_tb.num, new_tb.den,
871  st->index);
872  return;
873  }
874  st->time_base = new_tb;
875  if (sti->avctx)
876  sti->avctx->pkt_timebase = new_tb;
877  st->pts_wrap_bits = pts_wrap_bits;
878 }
879 
881  enum AVCodecID codec_id)
882 {
883  switch (st->codecpar->codec_type) {
884  case AVMEDIA_TYPE_VIDEO:
885  if (s->video_codec) return s->video_codec;
886  break;
887  case AVMEDIA_TYPE_AUDIO:
888  if (s->audio_codec) return s->audio_codec;
889  break;
891  if (s->subtitle_codec) return s->subtitle_codec;
892  break;
893  }
894 
896 }
897 
899 {
900 #define OFF(field) offsetof(AVFormatContext, field)
901  static const unsigned offsets[] = {
902  OFF(codec_whitelist), OFF(format_whitelist),
903  OFF(protocol_whitelist), OFF(protocol_blacklist),
904  };
905 #undef OFF
906  av_assert0(!dst->codec_whitelist &&
907  !dst->format_whitelist &&
908  !dst->protocol_whitelist &&
909  !dst->protocol_blacklist);
910  for (unsigned i = 0; i < FF_ARRAY_ELEMS(offsets); i++) {
911  const char *src_str = *(char *const*)((const char*)src + offsets[i]);
912 
913  if (src_str) {
914  char *dst_str = av_strdup(src_str);
915  if (!dst_str) {
916  av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
917  return AVERROR(ENOMEM);
918  }
919 
920  *(char **)((char*)dst + offsets[i]) = dst_str;
921  }
922  }
923  return 0;
924 }
925 
927 {
929  if (!d)
930  return 0;
931  if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
932  !(d->props & AV_CODEC_PROP_INTRA_ONLY))
933  return 0;
934  return 1;
935 }
936 
938 {
939  av_assert0(url);
940  av_freep(&s->url);
941  s->url = url;
942 }
943 
945 {
946  int ret = 0;
947  if (*pb)
948  ret = s->io_close2(s, *pb);
949  *pb = NULL;
950  return ret;
951 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
iamf.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
AVCodec
AVCodec.
Definition: codec.h:187
AVStreamGroupParamsType
AVStreamGroupParamsType
Definition: avformat.h:1080
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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
dec_ctx
static AVCodecContext * dec_ctx
Definition: decode_filter_audio.c:47
AVOutputFormat::name
const char * name
Definition: avformat.h:510
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
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:1125
AVProgram::nb_stream_indexes
unsigned int nb_stream_indexes
Definition: avformat.h:1184
av_find_best_stream
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, const AVCodec **decoder_ret, int flags)
Definition: avformat.c:443
FFStream::bsfc
struct AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:211
ff_find_decoder
const AVCodec * ff_find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: avformat.c:880
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
FFStream::bsf
struct AVBSFContext * bsf
Definition: internal.h:231
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVStream::priv_data
void * priv_data
Definition: avformat.h:768
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:482
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
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:814
av_find_program_from_stream
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
Definition: avformat.c:392
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
AVFormatContext::protocol_blacklist
char * protocol_blacklist
',' separated list of disallowed protocols.
Definition: avformat.h:1764
AVFMT_TBCF_DECODER
@ AVFMT_TBCF_DECODER
Definition: avformat.h:3045
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
AVFMT_TBCF_AUTO
@ AVFMT_TBCF_AUTO
Definition: avformat.h:3044
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:375
AVPacket::data
uint8_t * data
Definition: packet.h:524
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
data
const char data[16]
Definition: mxf.c:148
FFFormatContext::initialized
int initialized
Whether or not avformat_init_output has already been called.
Definition: internal.h:160
av_iamf_mix_presentation_free
void av_iamf_mix_presentation_free(AVIAMFMixPresentation **pmix_presentation)
Free an AVIAMFMixPresentation and all its contents.
Definition: iamf.c:534
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1456
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
cffstream
static const av_always_inline FFStream * cffstream(const AVStream *st)
Definition: internal.h:422
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
av_bsf_free
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:52
ost
static AVStream * ost
Definition: vaapi_transcode.c:42
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
FFStream::transferred_mux_tb
AVRational transferred_mux_tb
Definition: internal.h:414
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
FFStream::codec_desc
const struct AVCodecDescriptor * codec_desc
Definition: internal.h:412
OFF
#define OFF(field)
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
AVPacketSideData::size
size_t size
Definition: packet.h:377
ff_remove_stream
void ff_remove_stream(AVFormatContext *s, AVStream *st)
Remove a stream from its AVFormatContext and free it.
Definition: avformat.c:114
ff_free_stream_group
void ff_free_stream_group(AVStreamGroup **pstg)
Frees a stream group without modifying the corresponding AVFormatContext.
Definition: avformat.c:83
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:331
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:853
bsf.h
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
stream_params_copy
static int stream_params_copy(AVStream *dst, const AVStream *src)
Copy all stream parameters from source to destination stream, with the exception of the index field,...
Definition: avformat.c:270
avformat_stream_group_name
const char * avformat_stream_group_name(enum AVStreamGroupParamsType type)
Definition: avformat.c:324
samplefmt.h
av_iamf_audio_element_free
void av_iamf_audio_element_free(AVIAMFAudioElement **paudio_element)
Free an AVIAMFAudioElement and all its contents.
Definition: iamf.c:336
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1910
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:213
val
static double val(void *priv, double ch)
Definition: aeval.c:78
AVStreamGroup::params
union AVStreamGroup::@305 params
Group type-specific parameters.
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
av_new_program
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: avformat.c:334
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:802
AV_PTS_WRAP_IGNORE
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:732
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
codec.h
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVStream::attached_pic
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:841
avassert.h
AVFormatContext::format_whitelist
char * format_whitelist
',' separated list of allowed demuxers.
Definition: avformat.h:1750
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVProgram::id
int id
Definition: avformat.h:1180
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_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
@ AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
Definition: avformat.h:1083
FFFormatContext::parse_queue
PacketList parse_queue
Packets split by the parser get queued here.
Definition: internal.h:113
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:98
offsets
static const int offsets[]
Definition: hevc_pel.c:34
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
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:1455
bitrate
int64_t bitrate
Definition: av1_levels.c:47
g
const char * g
Definition: vf_curves.c:128
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
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
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:376
av_guess_sample_aspect_ratio
AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio.
Definition: avformat.c:727
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:392
ffofmt
static const FFOutputFormat * ffofmt(const AVOutputFormat *fmt)
Definition: mux.h:167
nb_streams
static int nb_streams
Definition: ffprobe.c:384
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:387
key
const char * key
Definition: hwcontext_opencl.c:189
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
FFFormatContext
Definition: internal.h:64
avpriv_packet_list_free
void avpriv_packet_list_free(PacketList *pkt_buf)
Wipe the list and unref all the packets in it.
Definition: packet.c:594
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
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:782
NULL
#define NULL
Definition: coverity.c:32
av_program_add_stream_index
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: avformat.c:365
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
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
AVFormatContext::protocol_whitelist
char * protocol_whitelist
',' separated list of allowed protocols.
Definition: avformat.h:1757
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: avformat.c:898
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:378
FFOutputFormat::deinit
void(* deinit)(AVFormatContext *)
Deinitialize format.
Definition: mux.h:154
FFStream::extract_extradata
struct FFStream::@325 extract_extradata
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1183
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:823
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: packet.c:435
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
index
int index
Definition: gxfenc.c:90
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:804
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:973
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1311
FFFormatContext::id3v2_meta
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:170
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:1084
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:544
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVMediaType
AVMediaType
Definition: avutil.h:199
avformat_match_stream_specifier
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
Definition: avformat.c:681
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
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
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:551
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
avio.h
copy_tb
int copy_tb
Definition: ffmpeg_opt.c:68
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_CODEC_PROP_FIELDS
#define AV_CODEC_PROP_FIELDS
Video codec supports separate coding of fields in interlaced frames.
Definition: codec_desc.h:97
AVStreamGroup::iamf_audio_element
struct AVIAMFAudioElement * iamf_audio_element
Definition: avformat.h:1123
AVStream::event_flags
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
Definition: avformat.h:886
av_stream_get_codec_timebase
AVRational av_stream_get_codec_timebase(const AVStream *st)
Get the internal codec timebase from a stream.
Definition: avformat.c:848
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: avformat.c:944
AVTimebaseSource
AVTimebaseSource
Definition: avformat.h:3043
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:821
frame.h
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:658
FFFormatContext::raw_packet_buffer_size
int raw_packet_buffer_size
Sum of the size of packets in raw_packet_buffer, in bytes.
Definition: internal.h:138
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
@ AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
Definition: avformat.h:1082
AVStreamGroup::streams
AVStream ** streams
A list of streams in the group.
Definition: avformat.h:1156
AVStreamGroup::iamf_mix_presentation
struct AVIAMFMixPresentation * iamf_mix_presentation
Definition: avformat.h:1124
FFStream::probe_data
AVProbeData probe_data
Definition: internal.h:370
FFStreamInfo::duration_error
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: demux.h:144
FFFormatContext::raw_packet_buffer
PacketList raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
Definition: internal.h:109
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: avformat.c:926
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecParameters::height
int height
Definition: codec_par.h:135
AVFormatContext::codec_whitelist
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avformat.h:1742
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_find_default_stream_index
int av_find_default_stream_index(AVFormatContext *s)
Definition: avformat.c:407
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:1179
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
demux.h
avcodec.h
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:812
match_stream_specifier
static int match_stream_specifier(const AVFormatContext *s, const AVStream *st, const char *spec, const char **indexptr, const AVStreamGroup **g, const AVProgram **p)
Matches a stream specifier (but ignores requested index).
Definition: avformat.c:518
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:1787
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:755
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
av_guess_frame_rate
AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
Definition: avformat.c:750
pixfmt.h
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVStreamGroup::metadata
AVDictionary * metadata
Metadata that applies to the whole group.
Definition: avformat.h:1136
avformat.h
id
enum AVCodecID id
Definition: dts2pts.c:365
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:315
AVStreamGroup
Definition: avformat.h:1090
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
avformat_transfer_internal_stream_timing_info
int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt, AVStream *ost, const AVStream *ist, enum AVTimebaseSource copy_tb)
Transfer internal timing information from one stream to another.
Definition: avformat.c:773
channel_layout.h
AVERROR_STREAM_NOT_FOUND
#define AVERROR_STREAM_NOT_FOUND
Stream not found.
Definition: error.h:67
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
ff_flush_packet_queue
void ff_flush_packet_queue(AVFormatContext *s)
Definition: avformat.c:131
ff_remove_stream_group
void ff_remove_stream_group(AVFormatContext *s, AVStreamGroup *stg)
Remove a stream group from its AVFormatContext and free it.
Definition: avformat.c:122
av_match_name
int av_match_name(const char *name, const char *names)
Match instances of a name in a comma-separated list of names.
Definition: avstring.c:345
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:141
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:576
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:41
FFStream::info
struct FFStreamInfo * info
Stream information used internally by avformat_find_stream_info()
Definition: internal.h:247
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:249
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVERROR_DECODER_NOT_FOUND
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:54
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AVStreamGroup::type
enum AVStreamGroupParamsType type
Group type.
Definition: avformat.h:1117
packet_internal.h
FFFormatContext::pkt
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
Definition: internal.h:134
AVCodecParameters::format
int format
Definition: codec_par.h:92
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVStreamGroupTileGrid::offsets
struct AVStreamGroupTileGrid::@304 * offsets
An nb_tiles sized array of offsets in pixels from the topleft edge of the canvas, indicating where ea...
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
ff_stream_clone
AVStream * ff_stream_clone(AVFormatContext *dst_ctx, const AVStream *src)
Create a new stream and copy to it all parameters from a source stream, with the exception of the ind...
Definition: avformat.c:306
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
d
d
Definition: ffmpeg_filter.c:424
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FFStream::parser
struct AVCodecParserContext * parser
Definition: internal.h:387
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3734
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:792
avstring.h
av_strndup
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
Definition: mem.c:284
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:918
codec_desc.h
AVStreamGroup::priv_data
void * priv_data
Definition: avformat.h:1096
ff_format_set_url
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: avformat.c:937
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:106
av_parser_close
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:193
mux.h