FFmpeg  4.3
utils.c
Go to the documentation of this file.
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdint.h>
23 
24 #include "config.h"
25 
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/parseutils.h"
33 #include "libavutil/pixfmt.h"
34 #include "libavutil/thread.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
37 
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/raw.h"
41 
42 #include "avformat.h"
43 #include "avio_internal.h"
44 #include "id3v2.h"
45 #include "internal.h"
46 #if CONFIG_NETWORK
47 #include "network.h"
48 #endif
49 #include "url.h"
50 
51 #include "libavutil/ffversion.h"
52 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
53 
55 
56 /**
57  * @file
58  * various utility functions for use within FFmpeg
59  */
60 
61 unsigned avformat_version(void)
62 {
65 }
66 
67 const char *avformat_configuration(void)
68 {
69  return FFMPEG_CONFIGURATION;
70 }
71 
72 const char *avformat_license(void)
73 {
74 #define LICENSE_PREFIX "libavformat license: "
75  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
76 }
77 
79 {
80  return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
81 }
82 
84 {
85  return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
86 }
87 
88 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
89 
90 static int is_relative(int64_t ts) {
91  return ts > (RELATIVE_TS_BASE - (1LL<<48));
92 }
93 
94 /**
95  * Wrap a given time stamp, if there is an indication for an overflow
96  *
97  * @param st stream
98  * @param timestamp the time stamp to wrap
99  * @return resulting time stamp
100  */
101 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
102 {
104  st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
106  timestamp < st->pts_wrap_reference)
107  return timestamp + (1ULL << st->pts_wrap_bits);
108  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
109  timestamp >= st->pts_wrap_reference)
110  return timestamp - (1ULL << st->pts_wrap_bits);
111  }
112  return timestamp;
113 }
114 
115 #if FF_API_FORMAT_GET_SET
116 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
117 #if FF_API_LAVF_FFSERVER
119 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
121 #endif
124 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
126 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
127 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
129 #if FF_API_OLD_OPEN_CALLBACKS
133 #endif
134 #endif
135 
136 int64_t av_stream_get_end_pts(const AVStream *st)
137 {
138  if (st->internal->priv_pts) {
139  return st->internal->priv_pts->val;
140  } else
141  return AV_NOPTS_VALUE;
142 }
143 
145 {
146  return st->parser;
147 }
148 
150 {
151  int i;
152  s->internal->inject_global_side_data = 1;
153  for (i = 0; i < s->nb_streams; i++) {
154  AVStream *st = s->streams[i];
155  st->inject_global_side_data = 1;
156  }
157 }
158 
160 {
161  av_assert0(!dst->codec_whitelist &&
162  !dst->format_whitelist &&
163  !dst->protocol_whitelist &&
164  !dst->protocol_blacklist);
165  dst-> codec_whitelist = av_strdup(src->codec_whitelist);
166  dst->format_whitelist = av_strdup(src->format_whitelist);
167  dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
168  dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
169  if ( (src-> codec_whitelist && !dst-> codec_whitelist)
170  || (src-> format_whitelist && !dst-> format_whitelist)
171  || (src->protocol_whitelist && !dst->protocol_whitelist)
172  || (src->protocol_blacklist && !dst->protocol_blacklist)) {
173  av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
174  return AVERROR(ENOMEM);
175  }
176  return 0;
177 }
178 
180 {
181 #if FF_API_LAVF_AVCTX
183  if (st->codec->codec)
184  return st->codec->codec;
186 #endif
187 
188  switch (st->codecpar->codec_type) {
189  case AVMEDIA_TYPE_VIDEO:
190  if (s->video_codec) return s->video_codec;
191  break;
192  case AVMEDIA_TYPE_AUDIO:
193  if (s->audio_codec) return s->audio_codec;
194  break;
196  if (s->subtitle_codec) return s->subtitle_codec;
197  break;
198  }
199 
201 }
202 
204 {
205  const AVCodec *codec;
206 
207 #if CONFIG_H264_DECODER
208  /* Other parts of the code assume this decoder to be used for h264,
209  * so force it if possible. */
210  if (codec_id == AV_CODEC_ID_H264)
211  return avcodec_find_decoder_by_name("h264");
212 #endif
213 
214  codec = find_decoder(s, st, codec_id);
215  if (!codec)
216  return NULL;
217 
219  const AVCodec *probe_codec = NULL;
220  void *iter = NULL;
221  while ((probe_codec = av_codec_iterate(&iter))) {
222  if (probe_codec->id == codec->id &&
225  return probe_codec;
226  }
227  }
228  }
229 
230  return codec;
231 }
232 
233 #if FF_API_FORMAT_GET_SET
234 int av_format_get_probe_score(const AVFormatContext *s)
235 {
236  return s->probe_score;
237 }
238 #endif
239 
240 /* an arbitrarily chosen "sane" max packet size -- 50M */
241 #define SANE_CHUNK_SIZE (50000000)
242 
244 {
245  if (s->maxsize>= 0) {
246  int64_t remaining= s->maxsize - avio_tell(s);
247  if (remaining < size) {
248  int64_t newsize = avio_size(s);
249  if (!s->maxsize || s->maxsize<newsize)
250  s->maxsize = newsize - !newsize;
251  remaining= s->maxsize - avio_tell(s);
252  remaining= FFMAX(remaining, 0);
253  }
254 
255  if (s->maxsize>= 0 && remaining+1 < size) {
256  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
257  size = remaining+1;
258  }
259  }
260  return size;
261 }
262 
263 /* Read the data in sane-sized chunks and append to pkt.
264  * Return the number of bytes read or an error. */
266 {
267  int orig_size = pkt->size;
268  int ret;
269 
270  do {
271  int prev_size = pkt->size;
272  int read_size;
273 
274  /* When the caller requests a lot of data, limit it to the amount
275  * left in file or SANE_CHUNK_SIZE when it is not known. */
276  read_size = size;
277  if (read_size > SANE_CHUNK_SIZE/10) {
278  read_size = ffio_limit(s, read_size);
279  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
280  if (s->maxsize < 0)
281  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
282  }
283 
284  ret = av_grow_packet(pkt, read_size);
285  if (ret < 0)
286  break;
287 
288  ret = avio_read(s, pkt->data + prev_size, read_size);
289  if (ret != read_size) {
290  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
291  break;
292  }
293 
294  size -= read_size;
295  } while (size > 0);
296  if (size > 0)
298 
299  if (!pkt->size)
301  return pkt->size > orig_size ? pkt->size - orig_size : ret;
302 }
303 
305 {
307  pkt->data = NULL;
308  pkt->size = 0;
309  pkt->pos = avio_tell(s);
310 
311  return append_packet_chunked(s, pkt, size);
312 }
313 
315 {
316  if (!pkt->size)
317  return av_get_packet(s, pkt, size);
318  return append_packet_chunked(s, pkt, size);
319 }
320 
321 int av_filename_number_test(const char *filename)
322 {
323  char buf[1024];
324  return filename &&
325  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
326 }
327 
329  AVProbeData *pd)
330 {
331  static const struct {
332  const char *name;
333  enum AVCodecID id;
334  enum AVMediaType type;
335  } fmt_id_type[] = {
347  { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
349  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
350  { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
351  { 0 }
352  };
353  int score;
354  const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
355 
356  if (fmt) {
357  int i;
359  "Probe with size=%d, packets=%d detected %s with score=%d\n",
360  pd->buf_size, s->max_probe_packets - st->probe_packets,
361  fmt->name, score);
362  for (i = 0; fmt_id_type[i].name; i++) {
363  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
364  if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
365  st->codecpar->sample_rate)
366  continue;
367  if (st->request_probe > score &&
368  st->codecpar->codec_id != fmt_id_type[i].id)
369  continue;
370  st->codecpar->codec_id = fmt_id_type[i].id;
371  st->codecpar->codec_type = fmt_id_type[i].type;
372  st->internal->need_context_update = 1;
373 #if FF_API_LAVF_AVCTX
375  st->codec->codec_type = st->codecpar->codec_type;
376  st->codec->codec_id = st->codecpar->codec_id;
378 #endif
379  return score;
380  }
381  }
382  }
383  return 0;
384 }
385 
386 /************************************************************/
387 /* input media file */
388 
390  int err;
391 
392  if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
393  av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
394  return AVERROR(EINVAL);
395  }
396 
397  if (ic->iformat->read_header) {
398  err = ic->iformat->read_header(ic);
399  if (err < 0)
400  return err;
401  }
402 
403  if (ic->pb && !ic->internal->data_offset)
404  ic->internal->data_offset = avio_tell(ic->pb);
405 
406  return 0;
407 }
408 
409 /* Open input file and probe the format if necessary. */
410 static int init_input(AVFormatContext *s, const char *filename,
412 {
413  int ret;
414  AVProbeData pd = { filename, NULL, 0 };
415  int score = AVPROBE_SCORE_RETRY;
416 
417  if (s->pb) {
418  s->flags |= AVFMT_FLAG_CUSTOM_IO;
419  if (!s->iformat)
420  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
421  s, 0, s->format_probesize);
422  else if (s->iformat->flags & AVFMT_NOFILE)
423  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
424  "will be ignored with AVFMT_NOFILE format.\n");
425  return 0;
426  }
427 
428  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
429  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
430  return score;
431 
432  if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
433  return ret;
434 
435  if (s->iformat)
436  return 0;
437  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
438  s, 0, s->format_probesize);
439 }
440 
441 int ff_packet_list_put(AVPacketList **packet_buffer,
442  AVPacketList **plast_pktl,
443  AVPacket *pkt, int flags)
444 {
445  AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
446  int ret;
447 
448  if (!pktl)
449  return AVERROR(ENOMEM);
450 
452  if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
453  av_free(pktl);
454  return ret;
455  }
456  } else {
458  if (ret < 0) {
459  av_free(pktl);
460  return ret;
461  }
462  av_packet_move_ref(&pktl->pkt, pkt);
463  }
464 
465  if (*packet_buffer)
466  (*plast_pktl)->next = pktl;
467  else
468  *packet_buffer = pktl;
469 
470  /* Add the packet in the buffered packet list. */
471  *plast_pktl = pktl;
472  return 0;
473 }
474 
476 {
477  int i, ret;
478  for (i = 0; i < s->nb_streams; i++)
479  if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
480  s->streams[i]->discard < AVDISCARD_ALL) {
481  if (s->streams[i]->attached_pic.size <= 0) {
483  "Attached picture on stream %d has invalid size, "
484  "ignoring\n", i);
485  continue;
486  }
487 
488  ret = ff_packet_list_put(&s->internal->raw_packet_buffer,
489  &s->internal->raw_packet_buffer_end,
490  &s->streams[i]->attached_pic,
492  if (ret < 0)
493  return ret;
494  }
495  return 0;
496 }
497 
499 {
500  int i, ret;
501  for (i = 0; i < s->nb_streams; i++) {
502  AVStream *st = s->streams[i];
503 
504  if (!st->internal->need_context_update)
505  continue;
506 
507  /* close parser, because it depends on the codec */
508  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
509  av_parser_close(st->parser);
510  st->parser = NULL;
511  }
512 
513  /* update internal codec context, for the parser */
515  if (ret < 0)
516  return ret;
517 
518 #if FF_API_LAVF_AVCTX
520  /* update deprecated public codec context */
521  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
522  if (ret < 0)
523  return ret;
525 #endif
526 
527  st->internal->need_context_update = 0;
528  }
529  return 0;
530 }
531 
532 
533 int avformat_open_input(AVFormatContext **ps, const char *filename,
535 {
536  AVFormatContext *s = *ps;
537  int i, ret = 0;
538  AVDictionary *tmp = NULL;
539  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
540 
541  if (!s && !(s = avformat_alloc_context()))
542  return AVERROR(ENOMEM);
543  if (!s->av_class) {
544  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
545  return AVERROR(EINVAL);
546  }
547  if (fmt)
548  s->iformat = fmt;
549 
550  if (options)
551  av_dict_copy(&tmp, *options, 0);
552 
553  if (s->pb) // must be before any goto fail
554  s->flags |= AVFMT_FLAG_CUSTOM_IO;
555 
556  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
557  goto fail;
558 
559  if (!(s->url = av_strdup(filename ? filename : ""))) {
560  ret = AVERROR(ENOMEM);
561  goto fail;
562  }
563 
564 #if FF_API_FORMAT_FILENAME
566  av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
568 #endif
569  if ((ret = init_input(s, filename, &tmp)) < 0)
570  goto fail;
571  s->probe_score = ret;
572 
573  if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
574  s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
575  if (!s->protocol_whitelist) {
576  ret = AVERROR(ENOMEM);
577  goto fail;
578  }
579  }
580 
581  if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
582  s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
583  if (!s->protocol_blacklist) {
584  ret = AVERROR(ENOMEM);
585  goto fail;
586  }
587  }
588 
589  if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
590  av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
591  ret = AVERROR(EINVAL);
592  goto fail;
593  }
594 
595  avio_skip(s->pb, s->skip_initial_bytes);
596 
597  /* Check filename in case an image number is expected. */
598  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
599  if (!av_filename_number_test(filename)) {
600  ret = AVERROR(EINVAL);
601  goto fail;
602  }
603  }
604 
605  s->duration = s->start_time = AV_NOPTS_VALUE;
606 
607  /* Allocate private data. */
608  if (s->iformat->priv_data_size > 0) {
609  if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
610  ret = AVERROR(ENOMEM);
611  goto fail;
612  }
613  if (s->iformat->priv_class) {
614  *(const AVClass **) s->priv_data = s->iformat->priv_class;
615  av_opt_set_defaults(s->priv_data);
616  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
617  goto fail;
618  }
619  }
620 
621  /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
622  if (s->pb)
623  ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
624 
625 
626  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
627  if ((ret = s->iformat->read_header(s)) < 0)
628  goto fail;
629 
630  if (!s->metadata) {
631  s->metadata = s->internal->id3v2_meta;
632  s->internal->id3v2_meta = NULL;
633  } else if (s->internal->id3v2_meta) {
634  av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
635  av_dict_free(&s->internal->id3v2_meta);
636  }
637 
638  if (id3v2_extra_meta) {
639  if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
640  !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
641  if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
642  goto close;
643  if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
644  goto close;
645  if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
646  goto close;
647  } else
648  av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
649  }
650  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
651 
653  goto close;
654 
655  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
656  s->internal->data_offset = avio_tell(s->pb);
657 
658  s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
659 
661 
662  for (i = 0; i < s->nb_streams; i++)
663  s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
664 
665  if (options) {
667  *options = tmp;
668  }
669  *ps = s;
670  return 0;
671 
672 close:
673  if (s->iformat->read_close)
674  s->iformat->read_close(s);
675 fail:
676  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
677  av_dict_free(&tmp);
678  if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
679  avio_closep(&s->pb);
681  *ps = NULL;
682  return ret;
683 }
684 
685 /*******************************************************/
686 
688 {
689  switch (st->codecpar->codec_type) {
690  case AVMEDIA_TYPE_VIDEO:
691  if (s->video_codec_id)
692  st->codecpar->codec_id = s->video_codec_id;
693  break;
694  case AVMEDIA_TYPE_AUDIO:
695  if (s->audio_codec_id)
696  st->codecpar->codec_id = s->audio_codec_id;
697  break;
699  if (s->subtitle_codec_id)
700  st->codecpar->codec_id = s->subtitle_codec_id;
701  break;
702  case AVMEDIA_TYPE_DATA:
703  if (s->data_codec_id)
704  st->codecpar->codec_id = s->data_codec_id;
705  break;
706  }
707 }
708 
710 {
711  if (st->request_probe>0) {
712  AVProbeData *pd = &st->probe_data;
713  int end;
714  av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
715  --st->probe_packets;
716 
717  if (pkt) {
719  if (!new_buf) {
721  "Failed to reallocate probe buffer for stream %d\n",
722  st->index);
723  goto no_packet;
724  }
725  pd->buf = new_buf;
726  memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
727  pd->buf_size += pkt->size;
728  memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
729  } else {
730 no_packet:
731  st->probe_packets = 0;
732  if (!pd->buf_size) {
734  "nothing to probe for stream %d\n", st->index);
735  }
736  }
737 
738  end= s->internal->raw_packet_buffer_remaining_size <= 0
739  || st->probe_packets<= 0;
740 
741  if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
742  int score = set_codec_from_probe_data(s, st, pd);
744  || end) {
745  pd->buf_size = 0;
746  av_freep(&pd->buf);
747  st->request_probe = -1;
748  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
749  av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
750  } else
751  av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
752  }
753  force_codec_ids(s, st);
754  }
755  }
756  return 0;
757 }
758 
759 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
760 {
761  int64_t ref = pkt->dts;
762  int i, pts_wrap_behavior;
763  int64_t pts_wrap_reference;
764  AVProgram *first_program;
765 
766  if (ref == AV_NOPTS_VALUE)
767  ref = pkt->pts;
768  if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
769  return 0;
770  ref &= (1LL << st->pts_wrap_bits)-1;
771 
772  // reference time stamp should be 60 s before first time stamp
773  pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
774  // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
775  pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
776  (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
778 
779  first_program = av_find_program_from_stream(s, NULL, stream_index);
780 
781  if (!first_program) {
782  int default_stream_index = av_find_default_stream_index(s);
783  if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
784  for (i = 0; i < s->nb_streams; i++) {
786  continue;
787  s->streams[i]->pts_wrap_reference = pts_wrap_reference;
788  s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
789  }
790  }
791  else {
792  st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
793  st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
794  }
795  }
796  else {
797  AVProgram *program = first_program;
798  while (program) {
799  if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
800  pts_wrap_reference = program->pts_wrap_reference;
801  pts_wrap_behavior = program->pts_wrap_behavior;
802  break;
803  }
804  program = av_find_program_from_stream(s, program, stream_index);
805  }
806 
807  // update every program with differing pts_wrap_reference
808  program = first_program;
809  while (program) {
810  if (program->pts_wrap_reference != pts_wrap_reference) {
811  for (i = 0; i<program->nb_stream_indexes; i++) {
812  s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
813  s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
814  }
815 
816  program->pts_wrap_reference = pts_wrap_reference;
817  program->pts_wrap_behavior = pts_wrap_behavior;
818  }
819  program = av_find_program_from_stream(s, program, stream_index);
820  }
821  }
822  return 1;
823 }
824 
826 {
827  int ret, i, err;
828  AVStream *st;
829 
830  pkt->data = NULL;
831  pkt->size = 0;
833 
834  for (;;) {
835  AVPacketList *pktl = s->internal->raw_packet_buffer;
836  const AVPacket *pkt1;
837 
838  if (pktl) {
839  st = s->streams[pktl->pkt.stream_index];
840  if (s->internal->raw_packet_buffer_remaining_size <= 0)
841  if ((err = probe_codec(s, st, NULL)) < 0)
842  return err;
843  if (st->request_probe <= 0) {
844  ff_packet_list_get(&s->internal->raw_packet_buffer,
845  &s->internal->raw_packet_buffer_end, pkt);
846  s->internal->raw_packet_buffer_remaining_size += pkt->size;
847  return 0;
848  }
849  }
850 
851  ret = s->iformat->read_packet(s, pkt);
852  if (ret < 0) {
854 
855  /* Some demuxers return FFERROR_REDO when they consume
856  data and discard it (ignored streams, junk, extradata).
857  We must re-call the demuxer to get the real packet. */
858  if (ret == FFERROR_REDO)
859  continue;
860  if (!pktl || ret == AVERROR(EAGAIN))
861  return ret;
862  for (i = 0; i < s->nb_streams; i++) {
863  st = s->streams[i];
864  if (st->probe_packets || st->request_probe > 0)
865  if ((err = probe_codec(s, st, NULL)) < 0)
866  return err;
867  av_assert0(st->request_probe <= 0);
868  }
869  continue;
870  }
871 
873  if (err < 0) {
875  return err;
876  }
877 
878  if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
880  "Packet corrupt (stream = %d, dts = %s)",
882  if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
883  av_log(s, AV_LOG_WARNING, ", dropping it.\n");
885  continue;
886  }
887  av_log(s, AV_LOG_WARNING, ".\n");
888  }
889 
890  av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
891  "Invalid stream index.\n");
892 
893  st = s->streams[pkt->stream_index];
894 
896  // correct first time stamps to negative values
897  if (!is_relative(st->first_dts))
898  st->first_dts = wrap_timestamp(st, st->first_dts);
899  if (!is_relative(st->start_time))
900  st->start_time = wrap_timestamp(st, st->start_time);
901  if (!is_relative(st->cur_dts))
902  st->cur_dts = wrap_timestamp(st, st->cur_dts);
903  }
904 
905  pkt->dts = wrap_timestamp(st, pkt->dts);
906  pkt->pts = wrap_timestamp(st, pkt->pts);
907 
908  force_codec_ids(s, st);
909 
910  /* TODO: audio: time filter; video: frame reordering (pts != dts) */
911  if (s->use_wallclock_as_timestamps)
913 
914  if (!pktl && st->request_probe <= 0)
915  return ret;
916 
917  err = ff_packet_list_put(&s->internal->raw_packet_buffer,
918  &s->internal->raw_packet_buffer_end,
919  pkt, 0);
920  if (err < 0) {
922  return err;
923  }
924  pkt1 = &s->internal->raw_packet_buffer_end->pkt;
925  s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
926 
927  if ((err = probe_codec(s, st, pkt1)) < 0)
928  return err;
929  }
930 }
931 
932 
933 /**********************************************************/
934 
936 {
937  switch(avctx->codec_id) {
938  case AV_CODEC_ID_MP1:
939  case AV_CODEC_ID_MP2:
940  case AV_CODEC_ID_MP3:
941  case AV_CODEC_ID_CODEC2:
942  return 1;
943  }
944 
945  return 0;
946 }
947 
948 /**
949  * Return the frame duration in seconds. Return 0 if not available.
950  */
951 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
953 {
954  AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
955  av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
956  int frame_size, sample_rate;
957 
958 #if FF_API_LAVF_AVCTX
960  if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
961  codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
963 #endif
964 
965  *pnum = 0;
966  *pden = 0;
967  switch (st->codecpar->codec_type) {
968  case AVMEDIA_TYPE_VIDEO:
969  if (st->r_frame_rate.num && !pc && s->iformat) {
970  *pnum = st->r_frame_rate.den;
971  *pden = st->r_frame_rate.num;
972  } else if (st->time_base.num * 1000LL > st->time_base.den) {
973  *pnum = st->time_base.num;
974  *pden = st->time_base.den;
975  } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
977  av_reduce(pnum, pden,
978  codec_framerate.den,
979  codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
980  INT_MAX);
981 
982  if (pc && pc->repeat_pict) {
983  av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
984  av_reduce(pnum, pden,
985  (*pnum) * (1LL + pc->repeat_pict),
986  (*pden),
987  INT_MAX);
988  }
989  /* If this codec can be interlaced or progressive then we need
990  * a parser to compute duration of a packet. Thus if we have
991  * no parser in such case leave duration undefined. */
992  if (st->internal->avctx->ticks_per_frame > 1 && !pc)
993  *pnum = *pden = 0;
994  }
995  break;
996  case AVMEDIA_TYPE_AUDIO:
997  if (st->internal->avctx_inited) {
1000  } else {
1003  }
1004  if (frame_size <= 0 || sample_rate <= 0)
1005  break;
1006  *pnum = frame_size;
1007  *pden = sample_rate;
1008  break;
1009  default:
1010  break;
1011  }
1012 }
1013 
1015 {
1017  if (!d)
1018  return 0;
1019  if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1021  return 0;
1022  return 1;
1023 }
1024 
1026 {
1027  if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1028  if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1029  return 1;
1030 #if CONFIG_H264_DECODER
1031  if (st->internal->avctx->has_b_frames &&
1033  return 1;
1034 #endif
1035  if (st->internal->avctx->has_b_frames<3)
1036  return st->nb_decoded_frames >= 7;
1037  else if (st->internal->avctx->has_b_frames<4)
1038  return st->nb_decoded_frames >= 18;
1039  else
1040  return st->nb_decoded_frames >= 20;
1041 }
1042 
1044 {
1045  if (pktl->next)
1046  return pktl->next;
1047  if (pktl == s->internal->packet_buffer_end)
1048  return s->internal->parse_queue;
1049  return NULL;
1050 }
1051 
1052 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1053  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1055 
1056  if(!onein_oneout) {
1057  int delay = st->internal->avctx->has_b_frames;
1058  int i;
1059 
1060  if (dts == AV_NOPTS_VALUE) {
1061  int64_t best_score = INT64_MAX;
1062  for (i = 0; i<delay; i++) {
1063  if (st->pts_reorder_error_count[i]) {
1064  int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1065  if (score < best_score) {
1066  best_score = score;
1067  dts = pts_buffer[i];
1068  }
1069  }
1070  }
1071  } else {
1072  for (i = 0; i<delay; i++) {
1073  if (pts_buffer[i] != AV_NOPTS_VALUE) {
1074  int64_t diff = FFABS(pts_buffer[i] - dts)
1075  + (uint64_t)st->pts_reorder_error[i];
1076  diff = FFMAX(diff, st->pts_reorder_error[i]);
1077  st->pts_reorder_error[i] = diff;
1078  st->pts_reorder_error_count[i]++;
1079  if (st->pts_reorder_error_count[i] > 250) {
1080  st->pts_reorder_error[i] >>= 1;
1081  st->pts_reorder_error_count[i] >>= 1;
1082  }
1083  }
1084  }
1085  }
1086  }
1087 
1088  if (dts == AV_NOPTS_VALUE)
1089  dts = pts_buffer[0];
1090 
1091  return dts;
1092 }
1093 
1094 /**
1095  * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1096  * of the packets in a window.
1097  */
1098 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1099  AVPacketList *pkt_buffer)
1100 {
1101  AVStream *st = s->streams[stream_index];
1102  int delay = st->internal->avctx->has_b_frames;
1103  int i;
1104 
1105  int64_t pts_buffer[MAX_REORDER_DELAY+1];
1106 
1107  for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1108  pts_buffer[i] = AV_NOPTS_VALUE;
1109 
1110  for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1111  if (pkt_buffer->pkt.stream_index != stream_index)
1112  continue;
1113 
1114  if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1115  pts_buffer[0] = pkt_buffer->pkt.pts;
1116  for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1117  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1118 
1119  pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1120  }
1121  }
1122 }
1123 
1124 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1125  int64_t dts, int64_t pts, AVPacket *pkt)
1126 {
1127  AVStream *st = s->streams[stream_index];
1128  AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1129  AVPacketList *pktl_it;
1130 
1131  uint64_t shift;
1132 
1133  if (st->first_dts != AV_NOPTS_VALUE ||
1134  dts == AV_NOPTS_VALUE ||
1135  st->cur_dts == AV_NOPTS_VALUE ||
1136  st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1137  is_relative(dts))
1138  return;
1139 
1140  st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1141  st->cur_dts = dts;
1142  shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1143 
1144  if (is_relative(pts))
1145  pts += shift;
1146 
1147  for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1148  if (pktl_it->pkt.stream_index != stream_index)
1149  continue;
1150  if (is_relative(pktl_it->pkt.pts))
1151  pktl_it->pkt.pts += shift;
1152 
1153  if (is_relative(pktl_it->pkt.dts))
1154  pktl_it->pkt.dts += shift;
1155 
1156  if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1157  st->start_time = pktl_it->pkt.pts;
1159  st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1160  }
1161  }
1162 
1164  update_dts_from_pts(s, stream_index, pktl);
1165  }
1166 
1167  if (st->start_time == AV_NOPTS_VALUE) {
1169  st->start_time = pts;
1170  }
1172  st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1173  }
1174 }
1175 
1177  int stream_index, int64_t duration)
1178 {
1179  AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1180  int64_t cur_dts = RELATIVE_TS_BASE;
1181 
1182  if (st->first_dts != AV_NOPTS_VALUE) {
1184  return;
1186  cur_dts = st->first_dts;
1187  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1188  if (pktl->pkt.stream_index == stream_index) {
1189  if (pktl->pkt.pts != pktl->pkt.dts ||
1190  pktl->pkt.dts != AV_NOPTS_VALUE ||
1191  pktl->pkt.duration)
1192  break;
1193  cur_dts -= duration;
1194  }
1195  }
1196  if (pktl && pktl->pkt.dts != st->first_dts) {
1197  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1198  av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1199  return;
1200  }
1201  if (!pktl) {
1202  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1203  return;
1204  }
1205  pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1206  st->first_dts = cur_dts;
1207  } else if (st->cur_dts != RELATIVE_TS_BASE)
1208  return;
1209 
1210  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1211  if (pktl->pkt.stream_index != stream_index)
1212  continue;
1213  if ((pktl->pkt.pts == pktl->pkt.dts ||
1214  pktl->pkt.pts == AV_NOPTS_VALUE) &&
1215  (pktl->pkt.dts == AV_NOPTS_VALUE ||
1216  pktl->pkt.dts == st->first_dts ||
1217  pktl->pkt.dts == RELATIVE_TS_BASE) &&
1218  !pktl->pkt.duration) {
1219  pktl->pkt.dts = cur_dts;
1220  if (!st->internal->avctx->has_b_frames)
1221  pktl->pkt.pts = cur_dts;
1222 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1223  pktl->pkt.duration = duration;
1224  } else
1225  break;
1226  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1227  }
1228  if (!pktl)
1229  st->cur_dts = cur_dts;
1230 }
1231 
1234  int64_t next_dts, int64_t next_pts)
1235 {
1236  int num, den, presentation_delayed, delay, i;
1237  int64_t offset;
1239  int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1241 
1242  if (s->flags & AVFMT_FLAG_NOFILLIN)
1243  return;
1244 
1246  if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1247  if (st->last_dts_for_order_check <= pkt->dts) {
1248  st->dts_ordered++;
1249  } else {
1251  "DTS %"PRIi64" < %"PRIi64" out of order\n",
1252  pkt->dts,
1254  st->dts_misordered++;
1255  }
1256  if (st->dts_ordered + st->dts_misordered > 250) {
1257  st->dts_ordered >>= 1;
1258  st->dts_misordered >>= 1;
1259  }
1260  }
1261 
1263  if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1264  pkt->dts = AV_NOPTS_VALUE;
1265  }
1266 
1267  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1268  pkt->dts = AV_NOPTS_VALUE;
1269 
1270  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1271  && !st->internal->avctx->has_b_frames)
1272  //FIXME Set low_delay = 0 when has_b_frames = 1
1273  st->internal->avctx->has_b_frames = 1;
1274 
1275  /* do we have a video B-frame ? */
1276  delay = st->internal->avctx->has_b_frames;
1277  presentation_delayed = 0;
1278 
1279  /* XXX: need has_b_frame, but cannot get it if the codec is
1280  * not initialized */
1281  if (delay &&
1282  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1283  presentation_delayed = 1;
1284 
1285  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1286  st->pts_wrap_bits < 63 &&
1287  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1288  if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1289  pkt->dts -= 1LL << st->pts_wrap_bits;
1290  } else
1291  pkt->pts += 1LL << st->pts_wrap_bits;
1292  }
1293 
1294  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1295  * We take the conservative approach and discard both.
1296  * Note: If this is misbehaving for an H.264 file, then possibly
1297  * presentation_delayed is not set correctly. */
1298  if (delay == 1 && pkt->dts == pkt->pts &&
1299  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1300  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1301  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1302  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1303  pkt->dts = AV_NOPTS_VALUE;
1304  }
1305 
1307  if (pkt->duration <= 0) {
1308  ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1309  if (den && num) {
1310  duration = (AVRational) {num, den};
1312  num * (int64_t) st->time_base.den,
1313  den * (int64_t) st->time_base.num,
1314  AV_ROUND_DOWN);
1315  }
1316  }
1317 
1318  if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1320 
1321  /* Correct timestamps with byte offset if demuxers only have timestamps
1322  * on packet boundaries */
1323  if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1324  /* this will estimate bitrate based on this frame's duration and size */
1326  if (pkt->pts != AV_NOPTS_VALUE)
1327  pkt->pts += offset;
1328  if (pkt->dts != AV_NOPTS_VALUE)
1329  pkt->dts += offset;
1330  }
1331 
1332  /* This may be redundant, but it should not hurt. */
1333  if (pkt->dts != AV_NOPTS_VALUE &&
1334  pkt->pts != AV_NOPTS_VALUE &&
1335  pkt->pts > pkt->dts)
1336  presentation_delayed = 1;
1337 
1338  if (s->debug & FF_FDEBUG_TS)
1340  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1341  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1342  pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1343 
1344  /* Interpolate PTS and DTS if they are not present. We skip H264
1345  * currently because delay and has_b_frames are not reliably set. */
1346  if ((delay == 0 || (delay == 1 && pc)) &&
1347  onein_oneout) {
1348  if (presentation_delayed) {
1349  /* DTS = decompression timestamp */
1350  /* PTS = presentation timestamp */
1351  if (pkt->dts == AV_NOPTS_VALUE)
1352  pkt->dts = st->last_IP_pts;
1354  if (pkt->dts == AV_NOPTS_VALUE)
1355  pkt->dts = st->cur_dts;
1356 
1357  /* This is tricky: the dts must be incremented by the duration
1358  * of the frame we are displaying, i.e. the last I- or P-frame. */
1359  if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1360  st->last_IP_duration = pkt->duration;
1361  if (pkt->dts != AV_NOPTS_VALUE)
1362  st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1363  if (pkt->dts != AV_NOPTS_VALUE &&
1364  pkt->pts == AV_NOPTS_VALUE &&
1365  st->last_IP_duration > 0 &&
1366  ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1367  next_dts != next_pts &&
1368  next_pts != AV_NOPTS_VALUE)
1369  pkt->pts = next_dts;
1370 
1371  if ((uint64_t)pkt->duration <= INT32_MAX)
1372  st->last_IP_duration = pkt->duration;
1373  st->last_IP_pts = pkt->pts;
1374  /* Cannot compute PTS if not present (we can compute it only
1375  * by knowing the future. */
1376  } else if (pkt->pts != AV_NOPTS_VALUE ||
1377  pkt->dts != AV_NOPTS_VALUE ||
1378  pkt->duration > 0 ) {
1379 
1380  /* presentation is not delayed : PTS and DTS are the same */
1381  if (pkt->pts == AV_NOPTS_VALUE)
1382  pkt->pts = pkt->dts;
1384  pkt->pts, pkt);
1385  if (pkt->pts == AV_NOPTS_VALUE)
1386  pkt->pts = st->cur_dts;
1387  pkt->dts = pkt->pts;
1388  if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1389  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1390  }
1391  }
1392 
1393  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1394  st->pts_buffer[0] = pkt->pts;
1395  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1396  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1397 
1400  }
1401  // We skipped it above so we try here.
1402  if (!onein_oneout)
1403  // This should happen on the first packet
1405  if (pkt->dts > st->cur_dts)
1406  st->cur_dts = pkt->dts;
1407 
1408  if (s->debug & FF_FDEBUG_TS)
1409  av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1410  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1411 
1412  /* update flags */
1415 #if FF_API_CONVERGENCE_DURATION
1417  if (pc)
1418  pkt->convergence_duration = pc->convergence_duration;
1420 #endif
1421 }
1422 
1423 void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1424 {
1425  AVPacketList *tmp = *pkt_buf;
1426 
1427  while (tmp) {
1428  AVPacketList *pktl = tmp;
1429  tmp = pktl->next;
1430  av_packet_unref(&pktl->pkt);
1431  av_freep(&pktl);
1432  }
1433  *pkt_buf = NULL;
1434  *pkt_buf_end = NULL;
1435 }
1436 
1437 /**
1438  * Parse a packet, add all split parts to parse_queue.
1439  *
1440  * @param pkt Packet to parse; must not be NULL.
1441  * @param flush Indicates whether to flush. If set, pkt must be blank.
1442  */
1444  int stream_index, int flush)
1445 {
1446  AVPacket out_pkt;
1447  AVStream *st = s->streams[stream_index];
1448  uint8_t *data = pkt->data;
1449  int size = pkt->size;
1450  int ret = 0, got_output = flush;
1451 
1452  if (size || flush) {
1453  av_init_packet(&out_pkt);
1454  } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1455  // preserve 0-size sync packets
1457  }
1458 
1459  while (size > 0 || (flush && got_output)) {
1460  int len;
1461  int64_t next_pts = pkt->pts;
1462  int64_t next_dts = pkt->dts;
1463 
1465  &out_pkt.data, &out_pkt.size, data, size,
1466  pkt->pts, pkt->dts, pkt->pos);
1467 
1468  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1469  pkt->pos = -1;
1470  /* increment read pointer */
1471  data += len;
1472  size -= len;
1473 
1474  got_output = !!out_pkt.size;
1475 
1476  if (!out_pkt.size)
1477  continue;
1478 
1479  if (pkt->buf && out_pkt.data == pkt->data) {
1480  /* reference pkt->buf only when out_pkt.data is guaranteed to point
1481  * to data in it and not in the parser's internal buffer. */
1482  /* XXX: Ensure this is the case with all parsers when st->parser->flags
1483  * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1484  out_pkt.buf = av_buffer_ref(pkt->buf);
1485  if (!out_pkt.buf) {
1486  ret = AVERROR(ENOMEM);
1487  goto fail;
1488  }
1489  } else {
1490  ret = av_packet_make_refcounted(&out_pkt);
1491  if (ret < 0)
1492  goto fail;
1493  }
1494 
1495  if (pkt->side_data) {
1496  out_pkt.side_data = pkt->side_data;
1497  out_pkt.side_data_elems = pkt->side_data_elems;
1498  pkt->side_data = NULL;
1499  pkt->side_data_elems = 0;
1500  }
1501 
1502  /* set the duration */
1503  out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1505  if (st->internal->avctx->sample_rate > 0) {
1506  out_pkt.duration =
1508  (AVRational) { 1, st->internal->avctx->sample_rate },
1509  st->time_base,
1510  AV_ROUND_DOWN);
1511  }
1512  }
1513 
1514  out_pkt.stream_index = st->index;
1515  out_pkt.pts = st->parser->pts;
1516  out_pkt.dts = st->parser->dts;
1517  out_pkt.pos = st->parser->pos;
1518  out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1519 
1521  out_pkt.pos = st->parser->frame_offset;
1522 
1523  if (st->parser->key_frame == 1 ||
1524  (st->parser->key_frame == -1 &&
1526  out_pkt.flags |= AV_PKT_FLAG_KEY;
1527 
1529  out_pkt.flags |= AV_PKT_FLAG_KEY;
1530 
1531  compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1532 
1533  ret = ff_packet_list_put(&s->internal->parse_queue,
1534  &s->internal->parse_queue_end,
1535  &out_pkt, 0);
1536  if (ret < 0) {
1537  av_packet_unref(&out_pkt);
1538  goto fail;
1539  }
1540  }
1541 
1542  /* end of the stream => close and free the parser */
1543  if (flush) {
1544  av_parser_close(st->parser);
1545  st->parser = NULL;
1546  }
1547 
1548 fail:
1550  return ret;
1551 }
1552 
1554  AVPacketList **pkt_buffer_end,
1555  AVPacket *pkt)
1556 {
1557  AVPacketList *pktl;
1558  av_assert0(*pkt_buffer);
1559  pktl = *pkt_buffer;
1560  *pkt = pktl->pkt;
1561  *pkt_buffer = pktl->next;
1562  if (!pktl->next)
1563  *pkt_buffer_end = NULL;
1564  av_freep(&pktl);
1565  return 0;
1566 }
1567 
1568 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1569 {
1570  return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1571 }
1572 
1574 {
1575  int ret, i, got_packet = 0;
1576  AVDictionary *metadata = NULL;
1577 
1578  while (!got_packet && !s->internal->parse_queue) {
1579  AVStream *st;
1580 
1581  /* read next packet */
1582  ret = ff_read_packet(s, pkt);
1583  if (ret < 0) {
1584  if (ret == AVERROR(EAGAIN))
1585  return ret;
1586  /* flush the parsers */
1587  for (i = 0; i < s->nb_streams; i++) {
1588  st = s->streams[i];
1589  if (st->parser && st->need_parsing)
1590  parse_packet(s, pkt, st->index, 1);
1591  }
1592  /* all remaining packets are now in parse_queue =>
1593  * really terminate parsing */
1594  break;
1595  }
1596  ret = 0;
1597  st = s->streams[pkt->stream_index];
1598 
1599  /* update context if required */
1600  if (st->internal->need_context_update) {
1601  if (avcodec_is_open(st->internal->avctx)) {
1602  av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1604  st->info->found_decoder = 0;
1605  }
1606 
1607  /* close parser, because it depends on the codec */
1608  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1609  av_parser_close(st->parser);
1610  st->parser = NULL;
1611  }
1612 
1614  if (ret < 0) {
1616  return ret;
1617  }
1618 
1619 #if FF_API_LAVF_AVCTX
1621  /* update deprecated public codec context */
1622  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1623  if (ret < 0) {
1625  return ret;
1626  }
1628 #endif
1629 
1630  st->internal->need_context_update = 0;
1631  }
1632 
1633  if (pkt->pts != AV_NOPTS_VALUE &&
1634  pkt->dts != AV_NOPTS_VALUE &&
1635  pkt->pts < pkt->dts) {
1637  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1638  pkt->stream_index,
1639  av_ts2str(pkt->pts),
1640  av_ts2str(pkt->dts),
1641  pkt->size);
1642  }
1643  if (s->debug & FF_FDEBUG_TS)
1645  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1646  pkt->stream_index,
1647  av_ts2str(pkt->pts),
1648  av_ts2str(pkt->dts),
1649  pkt->size, pkt->duration, pkt->flags);
1650 
1651  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1652  st->parser = av_parser_init(st->codecpar->codec_id);
1653  if (!st->parser) {
1654  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1655  "%s, packets or times may be invalid.\n",
1657  /* no parser available: just output the raw packets */
1659  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1661  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1662  st->parser->flags |= PARSER_FLAG_ONCE;
1663  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1665  }
1666 
1667  if (!st->need_parsing || !st->parser) {
1668  /* no parsing needed: we just output the packet as is */
1670  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1672  ff_reduce_index(s, st->index);
1673  av_add_index_entry(st, pkt->pos, pkt->dts,
1674  0, 0, AVINDEX_KEYFRAME);
1675  }
1676  got_packet = 1;
1677  } else if (st->discard < AVDISCARD_ALL) {
1678  if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1679  return ret;
1681  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1682  st->codecpar->channels = st->internal->avctx->channels;
1684  st->codecpar->codec_id = st->internal->avctx->codec_id;
1685  } else {
1686  /* free packet */
1688  }
1689  if (pkt->flags & AV_PKT_FLAG_KEY)
1690  st->skip_to_keyframe = 0;
1691  if (st->skip_to_keyframe) {
1693  got_packet = 0;
1694  }
1695  }
1696 
1697  if (!got_packet && s->internal->parse_queue)
1698  ret = ff_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1699 
1700  if (ret >= 0) {
1701  AVStream *st = s->streams[pkt->stream_index];
1702  int discard_padding = 0;
1703  if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1704  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1705  int64_t sample = ts_to_samples(st, pts);
1706  int duration = ts_to_samples(st, pkt->duration);
1707  int64_t end_sample = sample + duration;
1708  if (duration > 0 && end_sample >= st->first_discard_sample &&
1709  sample < st->last_discard_sample)
1710  discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1711  }
1712  if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1713  st->skip_samples = st->start_skip_samples;
1714  if (st->skip_samples || discard_padding) {
1716  if (p) {
1717  AV_WL32(p, st->skip_samples);
1718  AV_WL32(p + 4, discard_padding);
1719  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1720  }
1721  st->skip_samples = 0;
1722  }
1723 
1724  if (st->inject_global_side_data) {
1725  for (i = 0; i < st->nb_side_data; i++) {
1726  AVPacketSideData *src_sd = &st->side_data[i];
1727  uint8_t *dst_data;
1728 
1729  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1730  continue;
1731 
1732  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1733  if (!dst_data) {
1734  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1735  continue;
1736  }
1737 
1738  memcpy(dst_data, src_sd->data, src_sd->size);
1739  }
1740  st->inject_global_side_data = 0;
1741  }
1742  }
1743 
1744  av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1745  if (metadata) {
1746  s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1747  av_dict_copy(&s->metadata, metadata, 0);
1748  av_dict_free(&metadata);
1750  }
1751 
1752 #if FF_API_LAVF_AVCTX
1754 #endif
1755 
1756  if (s->debug & FF_FDEBUG_TS)
1758  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1759  "size=%d, duration=%"PRId64", flags=%d\n",
1760  pkt->stream_index,
1761  av_ts2str(pkt->pts),
1762  av_ts2str(pkt->dts),
1763  pkt->size, pkt->duration, pkt->flags);
1764 
1765  /* A demuxer might have returned EOF because of an IO error, let's
1766  * propagate this back to the user. */
1767  if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1768  ret = s->pb->error;
1769 
1770  return ret;
1771 }
1772 
1774 {
1775  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1776  int eof = 0;
1777  int ret;
1778  AVStream *st;
1779 
1780  if (!genpts) {
1781  ret = s->internal->packet_buffer
1782  ? ff_packet_list_get(&s->internal->packet_buffer,
1783  &s->internal->packet_buffer_end, pkt)
1785  if (ret < 0)
1786  return ret;
1787  goto return_packet;
1788  }
1789 
1790  for (;;) {
1791  AVPacketList *pktl = s->internal->packet_buffer;
1792 
1793  if (pktl) {
1794  AVPacket *next_pkt = &pktl->pkt;
1795 
1796  if (next_pkt->dts != AV_NOPTS_VALUE) {
1797  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1798  // last dts seen for this stream. if any of packets following
1799  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1800  int64_t last_dts = next_pkt->dts;
1801  av_assert2(wrap_bits <= 64);
1802  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1803  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1804  av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1805  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1806  // not B-frame
1807  next_pkt->pts = pktl->pkt.dts;
1808  }
1809  if (last_dts != AV_NOPTS_VALUE) {
1810  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1811  last_dts = pktl->pkt.dts;
1812  }
1813  }
1814  pktl = pktl->next;
1815  }
1816  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1817  // Fixing the last reference frame had none pts issue (For MXF etc).
1818  // We only do this when
1819  // 1. eof.
1820  // 2. we are not able to resolve a pts value for current packet.
1821  // 3. the packets for this stream at the end of the files had valid dts.
1822  next_pkt->pts = last_dts + next_pkt->duration;
1823  }
1824  pktl = s->internal->packet_buffer;
1825  }
1826 
1827  /* read packet from packet buffer, if there is data */
1828  st = s->streams[next_pkt->stream_index];
1829  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1830  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1831  ret = ff_packet_list_get(&s->internal->packet_buffer,
1832  &s->internal->packet_buffer_end, pkt);
1833  goto return_packet;
1834  }
1835  }
1836 
1838  if (ret < 0) {
1839  if (pktl && ret != AVERROR(EAGAIN)) {
1840  eof = 1;
1841  continue;
1842  } else
1843  return ret;
1844  }
1845 
1846  ret = ff_packet_list_put(&s->internal->packet_buffer,
1847  &s->internal->packet_buffer_end,
1848  pkt, 0);
1849  if (ret < 0) {
1851  return ret;
1852  }
1853  }
1854 
1855 return_packet:
1856 
1857  st = s->streams[pkt->stream_index];
1858  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1859  ff_reduce_index(s, st->index);
1861  }
1862 
1863  if (is_relative(pkt->dts))
1864  pkt->dts -= RELATIVE_TS_BASE;
1865  if (is_relative(pkt->pts))
1866  pkt->pts -= RELATIVE_TS_BASE;
1867 
1868  return ret;
1869 }
1870 
1871 /* XXX: suppress the packet queue */
1873 {
1874  if (!s->internal)
1875  return;
1876  ff_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1877  ff_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1878  ff_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1879 
1880  s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1881 }
1882 
1883 /*******************************************************/
1884 /* seek support */
1885 
1887 {
1888  int i;
1889  AVStream *st;
1890  int best_stream = 0;
1891  int best_score = INT_MIN;
1892 
1893  if (s->nb_streams <= 0)
1894  return -1;
1895  for (i = 0; i < s->nb_streams; i++) {
1896  int score = 0;
1897  st = s->streams[i];
1898  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1900  score -= 400;
1901  if (st->codecpar->width && st->codecpar->height)
1902  score += 50;
1903  score+= 25;
1904  }
1905  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1906  if (st->codecpar->sample_rate)
1907  score += 50;
1908  }
1909  if (st->codec_info_nb_frames)
1910  score += 12;
1911 
1912  if (st->discard != AVDISCARD_ALL)
1913  score += 200;
1914 
1915  if (score > best_score) {
1916  best_score = score;
1917  best_stream = i;
1918  }
1919  }
1920  return best_stream;
1921 }
1922 
1923 /** Flush the frame reader. */
1925 {
1926  AVStream *st;
1927  int i, j;
1928 
1930 
1931  /* Reset read state for each stream. */
1932  for (i = 0; i < s->nb_streams; i++) {
1933  st = s->streams[i];
1934 
1935  if (st->parser) {
1936  av_parser_close(st->parser);
1937  st->parser = NULL;
1938  }
1941  if (st->first_dts == AV_NOPTS_VALUE)
1942  st->cur_dts = RELATIVE_TS_BASE;
1943  else
1944  /* We set the current DTS to an unspecified origin. */
1945  st->cur_dts = AV_NOPTS_VALUE;
1946 
1947  st->probe_packets = s->max_probe_packets;
1948 
1949  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1950  st->pts_buffer[j] = AV_NOPTS_VALUE;
1951 
1952  if (s->internal->inject_global_side_data)
1953  st->inject_global_side_data = 1;
1954 
1955  st->skip_samples = 0;
1956  }
1957 }
1958 
1959 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1960 {
1961  int i;
1962 
1963  for (i = 0; i < s->nb_streams; i++) {
1964  AVStream *st = s->streams[i];
1965 
1966  st->cur_dts =
1967  av_rescale(timestamp,
1968  st->time_base.den * (int64_t) ref_st->time_base.num,
1969  st->time_base.num * (int64_t) ref_st->time_base.den);
1970  }
1971 }
1972 
1973 void ff_reduce_index(AVFormatContext *s, int stream_index)
1974 {
1975  AVStream *st = s->streams[stream_index];
1976  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1977 
1978  if ((unsigned) st->nb_index_entries >= max_entries) {
1979  int i;
1980  for (i = 0; 2 * i < st->nb_index_entries; i++)
1981  st->index_entries[i] = st->index_entries[2 * i];
1982  st->nb_index_entries = i;
1983  }
1984 }
1985 
1986 int ff_add_index_entry(AVIndexEntry **index_entries,
1987  int *nb_index_entries,
1988  unsigned int *index_entries_allocated_size,
1989  int64_t pos, int64_t timestamp,
1990  int size, int distance, int flags)
1991 {
1992  AVIndexEntry *entries, *ie;
1993  int index;
1994 
1995  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1996  return -1;
1997 
1998  if (timestamp == AV_NOPTS_VALUE)
1999  return AVERROR(EINVAL);
2000 
2001  if (size < 0 || size > 0x3FFFFFFF)
2002  return AVERROR(EINVAL);
2003 
2004  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
2005  timestamp -= RELATIVE_TS_BASE;
2006 
2007  entries = av_fast_realloc(*index_entries,
2008  index_entries_allocated_size,
2009  (*nb_index_entries + 1) *
2010  sizeof(AVIndexEntry));
2011  if (!entries)
2012  return -1;
2013 
2014  *index_entries = entries;
2015 
2016  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
2017  timestamp, AVSEEK_FLAG_ANY);
2018 
2019  if (index < 0) {
2020  index = (*nb_index_entries)++;
2021  ie = &entries[index];
2022  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
2023  } else {
2024  ie = &entries[index];
2025  if (ie->timestamp != timestamp) {
2026  if (ie->timestamp <= timestamp)
2027  return -1;
2028  memmove(entries + index + 1, entries + index,
2029  sizeof(AVIndexEntry) * (*nb_index_entries - index));
2030  (*nb_index_entries)++;
2031  } else if (ie->pos == pos && distance < ie->min_distance)
2032  // do not reduce the distance
2033  distance = ie->min_distance;
2034  }
2035 
2036  ie->pos = pos;
2037  ie->timestamp = timestamp;
2038  ie->min_distance = distance;
2039  ie->size = size;
2040  ie->flags = flags;
2041 
2042  return index;
2043 }
2044 
2045 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2046  int size, int distance, int flags)
2047 {
2048  timestamp = wrap_timestamp(st, timestamp);
2051  timestamp, size, distance, flags);
2052 }
2053 
2054 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2055  int64_t wanted_timestamp, int flags)
2056 {
2057  int a, b, m;
2058  int64_t timestamp;
2059 
2060  a = -1;
2061  b = nb_entries;
2062 
2063  // Optimize appending index entries at the end.
2064  if (b && entries[b - 1].timestamp < wanted_timestamp)
2065  a = b - 1;
2066 
2067  while (b - a > 1) {
2068  m = (a + b) >> 1;
2069 
2070  // Search for the next non-discarded packet.
2071  while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2072  m++;
2073  if (m == b && entries[m].timestamp >= wanted_timestamp) {
2074  m = b - 1;
2075  break;
2076  }
2077  }
2078 
2079  timestamp = entries[m].timestamp;
2080  if (timestamp >= wanted_timestamp)
2081  b = m;
2082  if (timestamp <= wanted_timestamp)
2083  a = m;
2084  }
2085  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2086 
2087  if (!(flags & AVSEEK_FLAG_ANY))
2088  while (m >= 0 && m < nb_entries &&
2089  !(entries[m].flags & AVINDEX_KEYFRAME))
2090  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2091 
2092  if (m == nb_entries)
2093  return -1;
2094  return m;
2095 }
2096 
2097 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2098 {
2099  int ist1, ist2;
2100  int64_t pos_delta = 0;
2101  int64_t skip = 0;
2102  //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2103  const char *proto = avio_find_protocol_name(s->url);
2104 
2105  av_assert0(time_tolerance >= 0);
2106 
2107  if (!proto) {
2108  av_log(s, AV_LOG_INFO,
2109  "Protocol name not provided, cannot determine if input is local or "
2110  "a network protocol, buffers and access patterns cannot be configured "
2111  "optimally without knowing the protocol\n");
2112  }
2113 
2114  if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2115  return;
2116 
2117  for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2118  AVStream *st1 = s->streams[ist1];
2119  for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2120  AVStream *st2 = s->streams[ist2];
2121  int i1, i2;
2122 
2123  if (ist1 == ist2)
2124  continue;
2125 
2126  for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2127  AVIndexEntry *e1 = &st1->index_entries[i1];
2128  int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2129 
2130  skip = FFMAX(skip, e1->size);
2131  for (; i2 < st2->nb_index_entries; i2++) {
2132  AVIndexEntry *e2 = &st2->index_entries[i2];
2133  int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2134  if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2135  continue;
2136  pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2137  break;
2138  }
2139  }
2140  }
2141  }
2142 
2143  pos_delta *= 2;
2144  /* XXX This could be adjusted depending on protocol*/
2145  if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2146  av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2147 
2148  /* realloc the buffer and the original data will be retained */
2149  if (ffio_realloc_buf(s->pb, pos_delta)) {
2150  av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2151  return;
2152  }
2153 
2154  s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2155  }
2156 
2157  if (skip < (1<<23)) {
2158  s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2159  }
2160 }
2161 
2162 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2163 {
2165  wanted_timestamp, flags);
2166 }
2167 
2168 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2169  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2170 {
2171  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2172  if (stream_index >= 0)
2173  ts = wrap_timestamp(s->streams[stream_index], ts);
2174  return ts;
2175 }
2176 
2177 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2178  int64_t target_ts, int flags)
2179 {
2180  const AVInputFormat *avif = s->iformat;
2181  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2182  int64_t ts_min, ts_max, ts;
2183  int index;
2184  int64_t ret;
2185  AVStream *st;
2186 
2187  if (stream_index < 0)
2188  return -1;
2189 
2190  av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2191 
2192  ts_max =
2193  ts_min = AV_NOPTS_VALUE;
2194  pos_limit = -1; // GCC falsely says it may be uninitialized.
2195 
2196  st = s->streams[stream_index];
2197  if (st->index_entries) {
2198  AVIndexEntry *e;
2199 
2200  /* FIXME: Whole function must be checked for non-keyframe entries in
2201  * index case, especially read_timestamp(). */
2202  index = av_index_search_timestamp(st, target_ts,
2204  index = FFMAX(index, 0);
2205  e = &st->index_entries[index];
2206 
2207  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2208  pos_min = e->pos;
2209  ts_min = e->timestamp;
2210  av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2211  pos_min, av_ts2str(ts_min));
2212  } else {
2213  av_assert1(index == 0);
2214  }
2215 
2216  index = av_index_search_timestamp(st, target_ts,
2218  av_assert0(index < st->nb_index_entries);
2219  if (index >= 0) {
2220  e = &st->index_entries[index];
2221  av_assert1(e->timestamp >= target_ts);
2222  pos_max = e->pos;
2223  ts_max = e->timestamp;
2224  pos_limit = pos_max - e->min_distance;
2225  av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2226  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2227  }
2228  }
2229 
2230  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2231  ts_min, ts_max, flags, &ts, avif->read_timestamp);
2232  if (pos < 0)
2233  return -1;
2234 
2235  /* do the seek */
2236  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2237  return ret;
2238 
2240  ff_update_cur_dts(s, st, ts);
2241 
2242  return 0;
2243 }
2244 
2245 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2246  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2247 {
2248  int64_t step = 1024;
2249  int64_t limit, ts_max;
2250  int64_t filesize = avio_size(s->pb);
2251  int64_t pos_max = filesize - 1;
2252  do {
2253  limit = pos_max;
2254  pos_max = FFMAX(0, (pos_max) - step);
2255  ts_max = ff_read_timestamp(s, stream_index,
2256  &pos_max, limit, read_timestamp);
2257  step += step;
2258  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2259  if (ts_max == AV_NOPTS_VALUE)
2260  return -1;
2261 
2262  for (;;) {
2263  int64_t tmp_pos = pos_max + 1;
2264  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2265  &tmp_pos, INT64_MAX, read_timestamp);
2266  if (tmp_ts == AV_NOPTS_VALUE)
2267  break;
2268  av_assert0(tmp_pos > pos_max);
2269  ts_max = tmp_ts;
2270  pos_max = tmp_pos;
2271  if (tmp_pos >= filesize)
2272  break;
2273  }
2274 
2275  if (ts)
2276  *ts = ts_max;
2277  if (pos)
2278  *pos = pos_max;
2279 
2280  return 0;
2281 }
2282 
2283 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2284  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2285  int64_t ts_min, int64_t ts_max,
2286  int flags, int64_t *ts_ret,
2287  int64_t (*read_timestamp)(struct AVFormatContext *, int,
2288  int64_t *, int64_t))
2289 {
2290  int64_t pos, ts;
2291  int64_t start_pos;
2292  int no_change;
2293  int ret;
2294 
2295  av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2296 
2297  if (ts_min == AV_NOPTS_VALUE) {
2298  pos_min = s->internal->data_offset;
2299  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2300  if (ts_min == AV_NOPTS_VALUE)
2301  return -1;
2302  }
2303 
2304  if (ts_min >= target_ts) {
2305  *ts_ret = ts_min;
2306  return pos_min;
2307  }
2308 
2309  if (ts_max == AV_NOPTS_VALUE) {
2310  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2311  return ret;
2312  pos_limit = pos_max;
2313  }
2314 
2315  if (ts_max <= target_ts) {
2316  *ts_ret = ts_max;
2317  return pos_max;
2318  }
2319 
2320  av_assert0(ts_min < ts_max);
2321 
2322  no_change = 0;
2323  while (pos_min < pos_limit) {
2325  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2326  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2327  av_assert0(pos_limit <= pos_max);
2328 
2329  if (no_change == 0) {
2330  int64_t approximate_keyframe_distance = pos_max - pos_limit;
2331  // interpolate position (better than dichotomy)
2332  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2333  ts_max - ts_min) +
2334  pos_min - approximate_keyframe_distance;
2335  } else if (no_change == 1) {
2336  // bisection if interpolation did not change min / max pos last time
2337  pos = (pos_min + pos_limit) >> 1;
2338  } else {
2339  /* linear search if bisection failed, can only happen if there
2340  * are very few or no keyframes between min/max */
2341  pos = pos_min;
2342  }
2343  if (pos <= pos_min)
2344  pos = pos_min + 1;
2345  else if (pos > pos_limit)
2346  pos = pos_limit;
2347  start_pos = pos;
2348 
2349  // May pass pos_limit instead of -1.
2350  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2351  if (pos == pos_max)
2352  no_change++;
2353  else
2354  no_change = 0;
2355  av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2356  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2357  pos_min, pos, pos_max,
2358  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2359  pos_limit, start_pos, no_change);
2360  if (ts == AV_NOPTS_VALUE) {
2361  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2362  return -1;
2363  }
2364  if (target_ts <= ts) {
2365  pos_limit = start_pos - 1;
2366  pos_max = pos;
2367  ts_max = ts;
2368  }
2369  if (target_ts >= ts) {
2370  pos_min = pos;
2371  ts_min = ts;
2372  }
2373  }
2374 
2375  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2376  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2377 #if 0
2378  pos_min = pos;
2379  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2380  pos_min++;
2381  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2382  av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2383  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2384 #endif
2385  *ts_ret = ts;
2386  return pos;
2387 }
2388 
2389 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2390  int64_t pos, int flags)
2391 {
2392  int64_t pos_min, pos_max;
2393 
2394  pos_min = s->internal->data_offset;
2395  pos_max = avio_size(s->pb) - 1;
2396 
2397  if (pos < pos_min)
2398  pos = pos_min;
2399  else if (pos > pos_max)
2400  pos = pos_max;
2401 
2402  avio_seek(s->pb, pos, SEEK_SET);
2403 
2404  s->io_repositioned = 1;
2405 
2406  return 0;
2407 }
2408 
2409 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2410  int64_t timestamp, int flags)
2411 {
2412  int index;
2413  int64_t ret;
2414  AVStream *st;
2415  AVIndexEntry *ie;
2416 
2417  st = s->streams[stream_index];
2418 
2419  index = av_index_search_timestamp(st, timestamp, flags);
2420 
2421  if (index < 0 && st->nb_index_entries &&
2422  timestamp < st->index_entries[0].timestamp)
2423  return -1;
2424 
2425  if (index < 0 || index == st->nb_index_entries - 1) {
2426  AVPacket pkt;
2427  int nonkey = 0;
2428 
2429  if (st->nb_index_entries) {
2431  ie = &st->index_entries[st->nb_index_entries - 1];
2432  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2433  return ret;
2434  ff_update_cur_dts(s, st, ie->timestamp);
2435  } else {
2436  if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2437  return ret;
2438  }
2439  for (;;) {
2440  int read_status;
2441  do {
2442  read_status = av_read_frame(s, &pkt);
2443  } while (read_status == AVERROR(EAGAIN));
2444  if (read_status < 0)
2445  break;
2446  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2447  if (pkt.flags & AV_PKT_FLAG_KEY) {
2448  av_packet_unref(&pkt);
2449  break;
2450  }
2451  if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2452  av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
2453  av_packet_unref(&pkt);
2454  break;
2455  }
2456  }
2457  av_packet_unref(&pkt);
2458  }
2459  index = av_index_search_timestamp(st, timestamp, flags);
2460  }
2461  if (index < 0)
2462  return -1;
2463 
2465  if (s->iformat->read_seek)
2466  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2467  return 0;
2468  ie = &st->index_entries[index];
2469  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2470  return ret;
2471  ff_update_cur_dts(s, st, ie->timestamp);
2472 
2473  return 0;
2474 }
2475 
2476 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2477  int64_t timestamp, int flags)
2478 {
2479  int ret;
2480  AVStream *st;
2481 
2482  if (flags & AVSEEK_FLAG_BYTE) {
2483  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2484  return -1;
2486  return seek_frame_byte(s, stream_index, timestamp, flags);
2487  }
2488 
2489  if (stream_index < 0) {
2490  stream_index = av_find_default_stream_index(s);
2491  if (stream_index < 0)
2492  return -1;
2493 
2494  st = s->streams[stream_index];
2495  /* timestamp for default must be expressed in AV_TIME_BASE units */
2496  timestamp = av_rescale(timestamp, st->time_base.den,
2497  AV_TIME_BASE * (int64_t) st->time_base.num);
2498  }
2499 
2500  /* first, we try the format specific seek */
2501  if (s->iformat->read_seek) {
2503  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2504  } else
2505  ret = -1;
2506  if (ret >= 0)
2507  return 0;
2508 
2509  if (s->iformat->read_timestamp &&
2510  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2512  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2513  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2515  return seek_frame_generic(s, stream_index, timestamp, flags);
2516  } else
2517  return -1;
2518 }
2519 
2520 int av_seek_frame(AVFormatContext *s, int stream_index,
2521  int64_t timestamp, int flags)
2522 {
2523  int ret;
2524 
2525  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2526  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2527  if ((flags & AVSEEK_FLAG_BACKWARD))
2528  max_ts = timestamp;
2529  else
2530  min_ts = timestamp;
2531  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2533  }
2534 
2535  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2536 
2537  if (ret >= 0)
2539 
2540  return ret;
2541 }
2542 
2543 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2544  int64_t ts, int64_t max_ts, int flags)
2545 {
2546  if (min_ts > ts || max_ts < ts)
2547  return -1;
2548  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2549  return AVERROR(EINVAL);
2550 
2551  if (s->seek2any>0)
2554 
2555  if (s->iformat->read_seek2) {
2556  int ret;
2558 
2559  if (stream_index == -1 && s->nb_streams == 1) {
2560  AVRational time_base = s->streams[0]->time_base;
2561  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2562  min_ts = av_rescale_rnd(min_ts, time_base.den,
2563  time_base.num * (int64_t)AV_TIME_BASE,
2565  max_ts = av_rescale_rnd(max_ts, time_base.den,
2566  time_base.num * (int64_t)AV_TIME_BASE,
2568  stream_index = 0;
2569  }
2570 
2571  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2572  ts, max_ts, flags);
2573 
2574  if (ret >= 0)
2576  return ret;
2577  }
2578 
2579  if (s->iformat->read_timestamp) {
2580  // try to seek via read_timestamp()
2581  }
2582 
2583  // Fall back on old API if new is not implemented but old is.
2584  // Note the old API has somewhat different semantics.
2585  if (s->iformat->read_seek || 1) {
2586  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2587  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2588  if (ret<0 && ts != min_ts && max_ts != ts) {
2589  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2590  if (ret >= 0)
2591  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2592  }
2593  return ret;
2594  }
2595 
2596  // try some generic seek like seek_frame_generic() but with new ts semantics
2597  return -1; //unreachable
2598 }
2599 
2601 {
2603  return 0;
2604 }
2605 
2606 /*******************************************************/
2607 
2608 /**
2609  * Return TRUE if the stream has accurate duration in any stream.
2610  *
2611  * @return TRUE if the stream has accurate duration for at least one component.
2612  */
2614 {
2615  int i;
2616  AVStream *st;
2617 
2618  for (i = 0; i < ic->nb_streams; i++) {
2619  st = ic->streams[i];
2620  if (st->duration != AV_NOPTS_VALUE)
2621  return 1;
2622  }
2623  if (ic->duration != AV_NOPTS_VALUE)
2624  return 1;
2625  return 0;
2626 }
2627 
2628 /**
2629  * Estimate the stream timings from the one of each components.
2630  *
2631  * Also computes the global bitrate if possible.
2632  */
2634 {
2635  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2636  int64_t duration, duration1, duration_text, filesize;
2637  int i;
2638  AVProgram *p;
2639 
2640  start_time = INT64_MAX;
2641  start_time_text = INT64_MAX;
2642  end_time = INT64_MIN;
2643  end_time_text = INT64_MIN;
2644  duration = INT64_MIN;
2645  duration_text = INT64_MIN;
2646 
2647  for (i = 0; i < ic->nb_streams; i++) {
2648  AVStream *st = ic->streams[i];
2649  int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2651  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2652  start_time1 = av_rescale_q(st->start_time, st->time_base,
2653  AV_TIME_BASE_Q);
2654  if (is_text)
2655  start_time_text = FFMIN(start_time_text, start_time1);
2656  else
2657  start_time = FFMIN(start_time, start_time1);
2658  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2661  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2662  end_time1 += start_time1;
2663  if (is_text)
2664  end_time_text = FFMAX(end_time_text, end_time1);
2665  else
2666  end_time = FFMAX(end_time, end_time1);
2667  }
2668  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2669  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2670  p->start_time = start_time1;
2671  if (p->end_time < end_time1)
2672  p->end_time = end_time1;
2673  }
2674  }
2675  if (st->duration != AV_NOPTS_VALUE) {
2676  duration1 = av_rescale_q(st->duration, st->time_base,
2677  AV_TIME_BASE_Q);
2678  if (is_text)
2679  duration_text = FFMAX(duration_text, duration1);
2680  else
2681  duration = FFMAX(duration, duration1);
2682  }
2683  }
2684  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2685  start_time = start_time_text;
2686  else if (start_time > start_time_text)
2687  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2688 
2689  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2690  end_time = end_time_text;
2691  else if (end_time < end_time_text)
2692  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2693 
2694  if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2695  duration = duration_text;
2696  else if (duration < duration_text)
2697  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2698 
2699  if (start_time != INT64_MAX) {
2700  ic->start_time = start_time;
2701  if (end_time != INT64_MIN) {
2702  if (ic->nb_programs > 1) {
2703  for (i = 0; i < ic->nb_programs; i++) {
2704  p = ic->programs[i];
2705  if (p->start_time != AV_NOPTS_VALUE &&
2706  p->end_time > p->start_time &&
2707  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2709  }
2710  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2711  duration = FFMAX(duration, end_time - start_time);
2712  }
2713  }
2714  }
2715  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2716  ic->duration = duration;
2717  }
2718  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2719  /* compute the bitrate */
2720  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2721  (double) ic->duration;
2722  if (bitrate >= 0 && bitrate <= INT64_MAX)
2723  ic->bit_rate = bitrate;
2724  }
2725 }
2726 
2728 {
2729  int i;
2730  AVStream *st;
2731 
2733  for (i = 0; i < ic->nb_streams; i++) {
2734  st = ic->streams[i];
2735  if (st->start_time == AV_NOPTS_VALUE) {
2736  if (ic->start_time != AV_NOPTS_VALUE)
2738  st->time_base);
2739  if (ic->duration != AV_NOPTS_VALUE)
2741  st->time_base);
2742  }
2743  }
2744 }
2745 
2747 {
2748  int64_t filesize, duration;
2749  int i, show_warning = 0;
2750  AVStream *st;
2751 
2752  /* if bit_rate is already set, we believe it */
2753  if (ic->bit_rate <= 0) {
2754  int64_t bit_rate = 0;
2755  for (i = 0; i < ic->nb_streams; i++) {
2756  st = ic->streams[i];
2757  if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2758  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2759  if (st->codecpar->bit_rate > 0) {
2760  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2761  bit_rate = 0;
2762  break;
2763  }
2764  bit_rate += st->codecpar->bit_rate;
2765  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2766  // If we have a videostream with packets but without a bitrate
2767  // then consider the sum not known
2768  bit_rate = 0;
2769  break;
2770  }
2771  }
2772  ic->bit_rate = bit_rate;
2773  }
2774 
2775  /* if duration is already set, we believe it */
2776  if (ic->duration == AV_NOPTS_VALUE &&
2777  ic->bit_rate != 0) {
2778  filesize = ic->pb ? avio_size(ic->pb) : 0;
2779  if (filesize > ic->internal->data_offset) {
2780  filesize -= ic->internal->data_offset;
2781  for (i = 0; i < ic->nb_streams; i++) {
2782  st = ic->streams[i];
2783  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2784  && st->duration == AV_NOPTS_VALUE) {
2785  duration = av_rescale(8 * filesize, st->time_base.den,
2786  ic->bit_rate *
2787  (int64_t) st->time_base.num);
2788  st->duration = duration;
2789  show_warning = 1;
2790  }
2791  }
2792  }
2793  }
2794  if (show_warning)
2795  av_log(ic, AV_LOG_WARNING,
2796  "Estimating duration from bitrate, this may be inaccurate\n");
2797 }
2798 
2799 #define DURATION_MAX_READ_SIZE 250000LL
2800 #define DURATION_MAX_RETRY 6
2801 
2802 /* only usable for MPEG-PS streams */
2803 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2804 {
2805  AVPacket pkt1, *pkt = &pkt1;
2806  AVStream *st;
2807  int num, den, read_size, i, ret;
2808  int found_duration = 0;
2809  int is_end;
2810  int64_t filesize, offset, duration;
2811  int retry = 0;
2812 
2813  /* flush packet queue */
2814  flush_packet_queue(ic);
2815 
2816  for (i = 0; i < ic->nb_streams; i++) {
2817  st = ic->streams[i];
2818  if (st->start_time == AV_NOPTS_VALUE &&
2819  st->first_dts == AV_NOPTS_VALUE &&
2821  av_log(ic, AV_LOG_WARNING,
2822  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2823 
2824  if (st->parser) {
2825  av_parser_close(st->parser);
2826  st->parser = NULL;
2827  }
2828  }
2829 
2831  av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2832  goto skip_duration_calc;
2833  }
2834 
2835  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2836  /* estimate the end time (duration) */
2837  /* XXX: may need to support wrapping */
2838  filesize = ic->pb ? avio_size(ic->pb) : 0;
2839  do {
2840  is_end = found_duration;
2841  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2842  if (offset < 0)
2843  offset = 0;
2844 
2845  avio_seek(ic->pb, offset, SEEK_SET);
2846  read_size = 0;
2847  for (;;) {
2848  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2849  break;
2850 
2851  do {
2852  ret = ff_read_packet(ic, pkt);
2853  } while (ret == AVERROR(EAGAIN));
2854  if (ret != 0)
2855  break;
2856  read_size += pkt->size;
2857  st = ic->streams[pkt->stream_index];
2858  if (pkt->pts != AV_NOPTS_VALUE &&
2859  (st->start_time != AV_NOPTS_VALUE ||
2860  st->first_dts != AV_NOPTS_VALUE)) {
2861  if (pkt->duration == 0) {
2862  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2863  if (den && num) {
2865  num * (int64_t) st->time_base.den,
2866  den * (int64_t) st->time_base.num,
2867  AV_ROUND_DOWN);
2868  }
2869  }
2870  duration = pkt->pts + pkt->duration;
2871  found_duration = 1;
2872  if (st->start_time != AV_NOPTS_VALUE)
2873  duration -= st->start_time;
2874  else
2875  duration -= st->first_dts;
2876  if (duration > 0) {
2877  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2878  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2879  st->duration = duration;
2880  st->info->last_duration = duration;
2881  }
2882  }
2884  }
2885 
2886  /* check if all audio/video streams have valid duration */
2887  if (!is_end) {
2888  is_end = 1;
2889  for (i = 0; i < ic->nb_streams; i++) {
2890  st = ic->streams[i];
2891  switch (st->codecpar->codec_type) {
2892  case AVMEDIA_TYPE_VIDEO:
2893  case AVMEDIA_TYPE_AUDIO:
2894  if (st->duration == AV_NOPTS_VALUE)
2895  is_end = 0;
2896  }
2897  }
2898  }
2899  } while (!is_end &&
2900  offset &&
2901  ++retry <= DURATION_MAX_RETRY);
2902 
2903  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2904 
2905  /* warn about audio/video streams which duration could not be estimated */
2906  for (i = 0; i < ic->nb_streams; i++) {
2907  st = ic->streams[i];
2908  if (st->duration == AV_NOPTS_VALUE) {
2909  switch (st->codecpar->codec_type) {
2910  case AVMEDIA_TYPE_VIDEO:
2911  case AVMEDIA_TYPE_AUDIO:
2912  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2913  av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2914  } else
2915  av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2916  }
2917  }
2918  }
2919 skip_duration_calc:
2921 
2922  avio_seek(ic->pb, old_offset, SEEK_SET);
2923  for (i = 0; i < ic->nb_streams; i++) {
2924  int j;
2925 
2926  st = ic->streams[i];
2927  st->cur_dts = st->first_dts;
2930  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2931  st->pts_buffer[j] = AV_NOPTS_VALUE;
2932  }
2933 }
2934 
2935 /* 1:1 map to AVDurationEstimationMethod */
2936 static const char *duration_name[] = {
2937  [AVFMT_DURATION_FROM_PTS] = "pts",
2938  [AVFMT_DURATION_FROM_STREAM] = "stream",
2939  [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2940 };
2941 
2943 {
2944  return duration_name[method];
2945 }
2946 
2947 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2948 {
2949  int64_t file_size;
2950 
2951  /* get the file size, if possible */
2952  if (ic->iformat->flags & AVFMT_NOFILE) {
2953  file_size = 0;
2954  } else {
2955  file_size = avio_size(ic->pb);
2956  file_size = FFMAX(0, file_size);
2957  }
2958 
2959  if ((!strcmp(ic->iformat->name, "mpeg") ||
2960  !strcmp(ic->iformat->name, "mpegts")) &&
2961  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2962  /* get accurate estimate from the PTSes */
2963  estimate_timings_from_pts(ic, old_offset);
2965  } else if (has_duration(ic)) {
2966  /* at least one component has timings - we use them for all
2967  * the components */
2969  /* nut demuxer estimate the duration from PTS */
2970  if(!strcmp(ic->iformat->name, "nut"))
2972  else
2974  } else {
2975  /* less precise: use bitrate info */
2978  }
2980 
2981  {
2982  int i;
2983  AVStream av_unused *st;
2984  for (i = 0; i < ic->nb_streams; i++) {
2985  st = ic->streams[i];
2986  if (st->time_base.den)
2987  av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2988  av_ts2timestr(st->start_time, &st->time_base),
2989  av_ts2timestr(st->duration, &st->time_base));
2990  }
2991  av_log(ic, AV_LOG_TRACE,
2992  "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2996  (int64_t)ic->bit_rate / 1000);
2997  }
2998 }
2999 
3000 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
3001 {
3002  AVCodecContext *avctx = st->internal->avctx;
3003 
3004 #define FAIL(errmsg) do { \
3005  if (errmsg_ptr) \
3006  *errmsg_ptr = errmsg; \
3007  return 0; \
3008  } while (0)
3009 
3010  if ( avctx->codec_id == AV_CODEC_ID_NONE
3011  && avctx->codec_type != AVMEDIA_TYPE_DATA)
3012  FAIL("unknown codec");
3013  switch (avctx->codec_type) {
3014  case AVMEDIA_TYPE_AUDIO:
3015  if (!avctx->frame_size && determinable_frame_size(avctx))
3016  FAIL("unspecified frame size");
3017  if (st->info->found_decoder >= 0 &&
3018  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
3019  FAIL("unspecified sample format");
3020  if (!avctx->sample_rate)
3021  FAIL("unspecified sample rate");
3022  if (!avctx->channels)
3023  FAIL("unspecified number of channels");
3024  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
3025  FAIL("no decodable DTS frames");
3026  break;
3027  case AVMEDIA_TYPE_VIDEO:
3028  if (!avctx->width)
3029  FAIL("unspecified size");
3030  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3031  FAIL("unspecified pixel format");
3034  FAIL("no frame in rv30/40 and no sar");
3035  break;
3036  case AVMEDIA_TYPE_SUBTITLE:
3037  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3038  FAIL("unspecified size");
3039  break;
3040  case AVMEDIA_TYPE_DATA:
3041  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3042  }
3043 
3044  return 1;
3045 }
3046 
3047 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3049  const AVPacket *avpkt, AVDictionary **options)
3050 {
3051  AVCodecContext *avctx = st->internal->avctx;
3052  const AVCodec *codec;
3053  int got_picture = 1, ret = 0;
3055  AVSubtitle subtitle;
3056  AVPacket pkt = *avpkt;
3057  int do_skip_frame = 0;
3058  enum AVDiscard skip_frame;
3059 
3060  if (!frame)
3061  return AVERROR(ENOMEM);
3062 
3063  if (!avcodec_is_open(avctx) &&
3064  st->info->found_decoder <= 0 &&
3065  (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3066  AVDictionary *thread_opt = NULL;
3067 
3068  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3069 
3070  if (!codec) {
3071  st->info->found_decoder = -st->codecpar->codec_id;
3072  ret = -1;
3073  goto fail;
3074  }
3075 
3076  /* Force thread count to 1 since the H.264 decoder will not extract
3077  * SPS and PPS to extradata during multi-threaded decoding. */
3078  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3079  if (s->codec_whitelist)
3080  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3081  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3082  if (!options)
3083  av_dict_free(&thread_opt);
3084  if (ret < 0) {
3085  st->info->found_decoder = -avctx->codec_id;
3086  goto fail;
3087  }
3088  st->info->found_decoder = 1;
3089  } else if (!st->info->found_decoder)
3090  st->info->found_decoder = 1;
3091 
3092  if (st->info->found_decoder < 0) {
3093  ret = -1;
3094  goto fail;
3095  }
3096 
3098  do_skip_frame = 1;
3099  skip_frame = avctx->skip_frame;
3100  avctx->skip_frame = AVDISCARD_ALL;
3101  }
3102 
3103  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3104  ret >= 0 &&
3106  (!st->codec_info_nb_frames &&
3108  got_picture = 0;
3109  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3110  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3111  ret = avcodec_send_packet(avctx, &pkt);
3112  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3113  break;
3114  if (ret >= 0)
3115  pkt.size = 0;
3116  ret = avcodec_receive_frame(avctx, frame);
3117  if (ret >= 0)
3118  got_picture = 1;
3119  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3120  ret = 0;
3121  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3122  ret = avcodec_decode_subtitle2(avctx, &subtitle,
3123  &got_picture, &pkt);
3124  if (got_picture)
3125  avsubtitle_free(&subtitle);
3126  if (ret >= 0)
3127  pkt.size = 0;
3128  }
3129  if (ret >= 0) {
3130  if (got_picture)
3131  st->nb_decoded_frames++;
3132  ret = got_picture;
3133  }
3134  }
3135 
3136  if (!pkt.data && !got_picture)
3137  ret = -1;
3138 
3139 fail:
3140  if (do_skip_frame) {
3141  avctx->skip_frame = skip_frame;
3142  }
3143 
3144  av_frame_free(&frame);
3145  return ret;
3146 }
3147 
3148 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3149 {
3150  while (tags->id != AV_CODEC_ID_NONE) {
3151  if (tags->id == id)
3152  return tags->tag;
3153  tags++;
3154  }
3155  return 0;
3156 }
3157 
3158 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3159 {
3160  int i;
3161  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3162  if (tag == tags[i].tag)
3163  return tags[i].id;
3164  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3165  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3166  return tags[i].id;
3167  return AV_CODEC_ID_NONE;
3168 }
3169 
3170 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3171 {
3172  if (bps <= 0 || bps > 64)
3173  return AV_CODEC_ID_NONE;
3174 
3175  if (flt) {
3176  switch (bps) {
3177  case 32:
3179  case 64:
3181  default:
3182  return AV_CODEC_ID_NONE;
3183  }
3184  } else {
3185  bps += 7;
3186  bps >>= 3;
3187  if (sflags & (1 << (bps - 1))) {
3188  switch (bps) {
3189  case 1:
3190  return AV_CODEC_ID_PCM_S8;
3191  case 2:
3193  case 3:
3195  case 4:
3197  case 8:
3199  default:
3200  return AV_CODEC_ID_NONE;
3201  }
3202  } else {
3203  switch (bps) {
3204  case 1:
3205  return AV_CODEC_ID_PCM_U8;
3206  case 2:
3208  case 3:
3210  case 4:
3212  default:
3213  return AV_CODEC_ID_NONE;
3214  }
3215  }
3216  }
3217 }
3218 
3219 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3220 {
3221  unsigned int tag;
3222  if (!av_codec_get_tag2(tags, id, &tag))
3223  return 0;
3224  return tag;
3225 }
3226 
3227 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3228  unsigned int *tag)
3229 {
3230  int i;
3231  for (i = 0; tags && tags[i]; i++) {
3232  const AVCodecTag *codec_tags = tags[i];
3233  while (codec_tags->id != AV_CODEC_ID_NONE) {
3234  if (codec_tags->id == id) {
3235  *tag = codec_tags->tag;
3236  return 1;
3237  }
3238  codec_tags++;
3239  }
3240  }
3241  return 0;
3242 }
3243 
3244 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3245 {
3246  int i;
3247  for (i = 0; tags && tags[i]; i++) {
3248  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3249  if (id != AV_CODEC_ID_NONE)
3250  return id;
3251  }
3252  return AV_CODEC_ID_NONE;
3253 }
3254 
3256 {
3257  unsigned int i, j;
3258  int64_t max_time = 0;
3259 
3260  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3261  max_time = s->duration +
3262  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3263 
3264  for (i = 0; i < s->nb_chapters; i++)
3265  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3266  AVChapter *ch = s->chapters[i];
3267  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3268  ch->time_base)
3269  : INT64_MAX;
3270 
3271  for (j = 0; j < s->nb_chapters; j++) {
3272  AVChapter *ch1 = s->chapters[j];
3273  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3274  ch->time_base);
3275  if (j != i && next_start > ch->start && next_start < end)
3276  end = next_start;
3277  }
3278  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3279  }
3280 }
3281 
3282 static int get_std_framerate(int i)
3283 {
3284  if (i < 30*12)
3285  return (i + 1) * 1001;
3286  i -= 30*12;
3287 
3288  if (i < 30)
3289  return (i + 31) * 1001 * 12;
3290  i -= 30;
3291 
3292  if (i < 3)
3293  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3294 
3295  i -= 3;
3296 
3297  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3298 }
3299 
3300 /* Is the time base unreliable?
3301  * This is a heuristic to balance between quick acceptance of the values in
3302  * the headers vs. some extra checks.
3303  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3304  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3305  * And there are "variable" fps files this needs to detect as well. */
3307 {
3308  if (c->time_base.den >= 101LL * c->time_base.num ||
3309  c->time_base.den < 5LL * c->time_base.num ||
3310  // c->codec_tag == AV_RL32("DIVX") ||
3311  // c->codec_tag == AV_RL32("XVID") ||
3312  c->codec_tag == AV_RL32("mp4v") ||
3313  c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3314  c->codec_id == AV_CODEC_ID_GIF ||
3315  c->codec_id == AV_CODEC_ID_HEVC ||
3316  c->codec_id == AV_CODEC_ID_H264)
3317  return 1;
3318  return 0;
3319 }
3320 
3322 {
3323  av_freep(&par->extradata);
3324  par->extradata_size = 0;
3325 
3326  if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3327  return AVERROR(EINVAL);
3328 
3330  if (!par->extradata)
3331  return AVERROR(ENOMEM);
3332 
3333  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3334  par->extradata_size = size;
3335 
3336  return 0;
3337 }
3338 
3340 {
3341  int ret = ff_alloc_extradata(par, size);
3342  if (ret < 0)
3343  return ret;
3344  ret = avio_read(pb, par->extradata, size);
3345  if (ret != size) {
3346  av_freep(&par->extradata);
3347  par->extradata_size = 0;
3348  av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3349  return ret < 0 ? ret : AVERROR_INVALIDDATA;
3350  }
3351 
3352  return ret;
3353 }
3354 
3355 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3356 {
3357  int i, j;
3358  int64_t last = st->info->last_dts;
3359 
3360  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3361  && ts - (uint64_t)last < INT64_MAX) {
3362  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3363  int64_t duration = ts - last;
3364 
3365  if (!st->info->duration_error)
3366  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3367  if (!st->info->duration_error)
3368  return AVERROR(ENOMEM);
3369 
3370 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3371 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3372  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3373  if (st->info->duration_error[0][1][i] < 1e10) {
3374  int framerate = get_std_framerate(i);
3375  double sdts = dts*framerate/(1001*12);
3376  for (j= 0; j<2; j++) {
3377  int64_t ticks = llrint(sdts+j*0.5);
3378  double error= sdts - ticks + j*0.5;
3379  st->info->duration_error[j][0][i] += error;
3380  st->info->duration_error[j][1][i] += error*error;
3381  }
3382  }
3383  }
3384  if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3385  st->info->duration_count++;
3387  }
3388 
3389  if (st->info->duration_count % 10 == 0) {
3390  int n = st->info->duration_count;
3391  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3392  if (st->info->duration_error[0][1][i] < 1e10) {
3393  double a0 = st->info->duration_error[0][0][i] / n;
3394  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3395  double a1 = st->info->duration_error[1][0][i] / n;
3396  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3397  if (error0 > 0.04 && error1 > 0.04) {
3398  st->info->duration_error[0][1][i] = 2e10;
3399  st->info->duration_error[1][1][i] = 2e10;
3400  }
3401  }
3402  }
3403  }
3404 
3405  // ignore the first 4 values, they might have some random jitter
3406  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3408  }
3409  if (ts != AV_NOPTS_VALUE)
3410  st->info->last_dts = ts;
3411 
3412  return 0;
3413 }
3414 
3416 {
3417  int i, j;
3418 
3419  for (i = 0; i < ic->nb_streams; i++) {
3420  AVStream *st = ic->streams[i];
3421 
3423  continue;
3424  // the check for tb_unreliable() is not completely correct, since this is not about handling
3425  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3426  // ipmovie.c produces.
3427  if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3428  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3429  if (st->info->duration_count>1 && !st->r_frame_rate.num
3430  && tb_unreliable(st->internal->avctx)) {
3431  int num = 0;
3432  double best_error= 0.01;
3433  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3434 
3435  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3436  int k;
3437 
3438  if (st->info->codec_info_duration &&
3439  st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3440  continue;
3441  if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3442  continue;
3443 
3444  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3445  continue;
3446 
3447  for (k= 0; k<2; k++) {
3448  int n = st->info->duration_count;
3449  double a= st->info->duration_error[k][0][j] / n;
3450  double error= st->info->duration_error[k][1][j]/n - a*a;
3451 
3452  if (error < best_error && best_error> 0.000000001) {
3453  best_error= error;
3454  num = get_std_framerate(j);
3455  }
3456  if (error < 0.02)
3457  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3458  }
3459  }
3460  // do not increase frame rate by more than 1 % in order to match a standard rate.
3461  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3462  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3463  }
3464  if ( !st->avg_frame_rate.num
3465  && st->r_frame_rate.num && st->info->rfps_duration_sum
3466  && st->info->codec_info_duration <= 0
3467  && st->info->duration_count > 2
3468  && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3469  ) {
3470  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3471  st->avg_frame_rate = st->r_frame_rate;
3472  }
3473 
3474  av_freep(&st->info->duration_error);
3475  st->info->last_dts = AV_NOPTS_VALUE;
3476  st->info->duration_count = 0;
3477  st->info->rfps_duration_sum = 0;
3478  }
3479 }
3480 
3482 {
3483  const AVBitStreamFilter *f;
3484 
3485  f = av_bsf_get_by_name("extract_extradata");
3486  if (!f)
3487  return 0;
3488 
3489  if (f->codec_ids) {
3490  const enum AVCodecID *ids;
3491  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3492  if (*ids == st->codecpar->codec_id)
3493  return 1;
3494  }
3495 
3496  return 0;
3497 }
3498 
3500 {
3501  AVStreamInternal *sti = st->internal;
3502  const AVBitStreamFilter *f;
3503  int ret;
3504 
3505  f = av_bsf_get_by_name("extract_extradata");
3506  if (!f)
3507  goto finish;
3508 
3509  /* check that the codec id is supported */
3511  if (!ret)
3512  goto finish;
3513 
3515  if (!sti->extract_extradata.pkt)
3516  return AVERROR(ENOMEM);
3517 
3519  if (ret < 0)
3520  goto fail;
3521 
3523  st->codecpar);
3524  if (ret < 0)
3525  goto fail;
3526 
3528 
3530  if (ret < 0)
3531  goto fail;
3532 
3533 finish:
3534  sti->extract_extradata.inited = 1;
3535 
3536  return 0;
3537 fail:
3540  return ret;
3541 }
3542 
3543 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3544 {
3545  AVStreamInternal *sti = st->internal;
3546  AVPacket *pkt_ref;
3547  int ret;
3548 
3549  if (!sti->extract_extradata.inited) {
3551  if (ret < 0)
3552  return ret;
3553  }
3554 
3555  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3556  return 0;
3557 
3558  pkt_ref = sti->extract_extradata.pkt;
3559  ret = av_packet_ref(pkt_ref, pkt);
3560  if (ret < 0)
3561  return ret;
3562 
3563  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3564  if (ret < 0) {
3565  av_packet_unref(pkt_ref);
3566  return ret;
3567  }
3568 
3569  while (ret >= 0 && !sti->avctx->extradata) {
3570  int extradata_size;
3571  uint8_t *extradata;
3572 
3574  if (ret < 0) {
3575  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3576  return ret;
3577  continue;
3578  }
3579 
3581  &extradata_size);
3582 
3583  if (extradata) {
3584  av_assert0(!sti->avctx->extradata);
3585  if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3586  sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3587  if (!sti->avctx->extradata) {
3588  av_packet_unref(pkt_ref);
3589  return AVERROR(ENOMEM);
3590  }
3591  memcpy(sti->avctx->extradata, extradata, extradata_size);
3592  sti->avctx->extradata_size = extradata_size;
3593  }
3594  av_packet_unref(pkt_ref);
3595  }
3596 
3597  return 0;
3598 }
3599 
3601 {
3602  int i;
3603 
3604  for (i = 0; i < avctx->nb_coded_side_data; i++) {
3605  const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3606  uint8_t *dst_data;
3607  dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3608  if (!dst_data)
3609  return AVERROR(ENOMEM);
3610  memcpy(dst_data, sd_src->data, sd_src->size);
3611  }
3612  return 0;
3613 }
3614 
3616 {
3617  int i, count = 0, ret = 0, j;
3618  int64_t read_size;
3619  AVStream *st;
3620  AVCodecContext *avctx;
3621  AVPacket pkt1;
3622  int64_t old_offset = avio_tell(ic->pb);
3623  // new streams might appear, no options for those
3624  int orig_nb_streams = ic->nb_streams;
3625  int flush_codecs;
3626  int64_t max_analyze_duration = ic->max_analyze_duration;
3627  int64_t max_stream_analyze_duration;
3628  int64_t max_subtitle_analyze_duration;
3629  int64_t probesize = ic->probesize;
3630  int eof_reached = 0;
3631  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3632 
3633  flush_codecs = probesize > 0;
3634 
3635  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3636 
3637  max_stream_analyze_duration = max_analyze_duration;
3638  max_subtitle_analyze_duration = max_analyze_duration;
3639  if (!max_analyze_duration) {
3640  max_stream_analyze_duration =
3641  max_analyze_duration = 5*AV_TIME_BASE;
3642  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3643  if (!strcmp(ic->iformat->name, "flv"))
3644  max_stream_analyze_duration = 90*AV_TIME_BASE;
3645  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3646  max_stream_analyze_duration = 7*AV_TIME_BASE;
3647  }
3648 
3649  if (ic->pb)
3650  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3651  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3652 
3653  for (i = 0; i < ic->nb_streams; i++) {
3654  const AVCodec *codec;
3655  AVDictionary *thread_opt = NULL;
3656  st = ic->streams[i];
3657  avctx = st->internal->avctx;
3658 
3659  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3661 /* if (!st->time_base.num)
3662  st->time_base = */
3663  if (!avctx->time_base.num)
3664  avctx->time_base = st->time_base;
3665  }
3666 
3667  /* check if the caller has overridden the codec id */
3668 #if FF_API_LAVF_AVCTX
3670  if (st->codec->codec_id != st->internal->orig_codec_id) {
3671  st->codecpar->codec_id = st->codec->codec_id;
3672  st->codecpar->codec_type = st->codec->codec_type;
3673  st->internal->orig_codec_id = st->codec->codec_id;
3674  }
3676 #endif
3677  // only for the split stuff
3678  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3679  st->parser = av_parser_init(st->codecpar->codec_id);
3680  if (st->parser) {
3681  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3683  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3685  }
3686  } else if (st->need_parsing) {
3687  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3688  "%s, packets or times may be invalid.\n",
3690  }
3691  }
3692 
3693  if (st->codecpar->codec_id != st->internal->orig_codec_id)
3695 
3697  if (ret < 0)
3698  goto find_stream_info_err;
3699  if (st->request_probe <= 0)
3700  st->internal->avctx_inited = 1;
3701 
3702  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3703 
3704  /* Force thread count to 1 since the H.264 decoder will not extract
3705  * SPS and PPS to extradata during multi-threaded decoding. */
3706  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3707 
3708  if (ic->codec_whitelist)
3709  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3710 
3711  /* Ensure that subtitle_header is properly set. */
3713  && codec && !avctx->codec) {
3714  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3715  av_log(ic, AV_LOG_WARNING,
3716  "Failed to open codec in %s\n",__FUNCTION__);
3717  }
3718 
3719  // Try to just open decoders, in case this is enough to get parameters.
3720  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3721  if (codec && !avctx->codec)
3722  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3723  av_log(ic, AV_LOG_WARNING,
3724  "Failed to open codec in %s\n",__FUNCTION__);
3725  }
3726  if (!options)
3727  av_dict_free(&thread_opt);
3728  }
3729 
3730  for (i = 0; i < ic->nb_streams; i++) {
3731 #if FF_API_R_FRAME_RATE
3733 #endif
3736  }
3737 
3738  read_size = 0;
3739  for (;;) {
3740  const AVPacket *pkt;
3741  int analyzed_all_streams;
3743  ret = AVERROR_EXIT;
3744  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3745  break;
3746  }
3747 
3748  /* check if one codec still needs to be handled */
3749  for (i = 0; i < ic->nb_streams; i++) {
3750  int fps_analyze_framecount = 20;
3751  int count;
3752 
3753  st = ic->streams[i];
3754  if (!has_codec_parameters(st, NULL))
3755  break;
3756  /* If the timebase is coarse (like the usual millisecond precision
3757  * of mkv), we need to analyze more frames to reliably arrive at
3758  * the correct fps. */
3759  if (av_q2d(st->time_base) > 0.0005)
3760  fps_analyze_framecount *= 2;
3761  if (!tb_unreliable(st->internal->avctx))
3762  fps_analyze_framecount = 0;
3763  if (ic->fps_probe_size >= 0)
3764  fps_analyze_framecount = ic->fps_probe_size;
3766  fps_analyze_framecount = 0;
3767  /* variable fps and no guess at the real fps */
3768  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3770  st->info->duration_count;
3771  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3773  if (count < fps_analyze_framecount)
3774  break;
3775  }
3776  // Look at the first 3 frames if there is evidence of frame delay
3777  // but the decoder delay is not set.
3778  if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3779  break;
3780  if (!st->internal->avctx->extradata &&
3782  st->internal->extract_extradata.bsf) &&
3784  break;
3785  if (st->first_dts == AV_NOPTS_VALUE &&
3786  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3790  break;
3791  }
3792  analyzed_all_streams = 0;
3793  if (!missing_streams || !*missing_streams)
3794  if (i == ic->nb_streams) {
3795  analyzed_all_streams = 1;
3796  /* NOTE: If the format has no header, then we need to read some
3797  * packets to get most of the streams, so we cannot stop here. */
3798  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3799  /* If we found the info for all the codecs, we can stop. */
3800  ret = count;
3801  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3802  flush_codecs = 0;
3803  break;
3804  }
3805  }
3806  /* We did not get all the codec info, but we read too much data. */
3807  if (read_size >= probesize) {
3808  ret = count;
3809  av_log(ic, AV_LOG_DEBUG,
3810  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3811  for (i = 0; i < ic->nb_streams; i++)
3812  if (!ic->streams[i]->r_frame_rate.num &&
3813  ic->streams[i]->info->duration_count <= 1 &&
3815  strcmp(ic->iformat->name, "image2"))
3816  av_log(ic, AV_LOG_WARNING,
3817  "Stream #%d: not enough frames to estimate rate; "
3818  "consider increasing probesize\n", i);
3819  break;
3820  }
3821 
3822  /* NOTE: A new stream can be added there if no header in file
3823  * (AVFMTCTX_NOHEADER). */
3824  ret = read_frame_internal(ic, &pkt1);
3825  if (ret == AVERROR(EAGAIN))
3826  continue;
3827 
3828  if (ret < 0) {
3829  /* EOF or error*/
3830  eof_reached = 1;
3831  break;
3832  }
3833 
3834  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3837  &pkt1, 0);
3838  if (ret < 0)
3839  goto unref_then_goto_end;
3840 
3841  pkt = &ic->internal->packet_buffer_end->pkt;
3842  } else {
3843  pkt = &pkt1;
3844  }
3845 
3846  st = ic->streams[pkt->stream_index];
3848  read_size += pkt->size;
3849 
3850  avctx = st->internal->avctx;
3851  if (!st->internal->avctx_inited) {
3853  if (ret < 0)
3854  goto unref_then_goto_end;
3855  st->internal->avctx_inited = 1;
3856  }
3857 
3858  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3859  /* check for non-increasing dts */
3860  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3861  st->info->fps_last_dts >= pkt->dts) {
3862  av_log(ic, AV_LOG_DEBUG,
3863  "Non-increasing DTS in stream %d: packet %d with DTS "
3864  "%"PRId64", packet %d with DTS %"PRId64"\n",
3865  st->index, st->info->fps_last_dts_idx,
3867  pkt->dts);
3868  st->info->fps_first_dts =
3870  }
3871  /* Check for a discontinuity in dts. If the difference in dts
3872  * is more than 1000 times the average packet duration in the
3873  * sequence, we treat it as a discontinuity. */
3874  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3876  (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3877  (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3878  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3879  av_log(ic, AV_LOG_WARNING,
3880  "DTS discontinuity in stream %d: packet %d with DTS "
3881  "%"PRId64", packet %d with DTS %"PRId64"\n",
3882  st->index, st->info->fps_last_dts_idx,
3884  pkt->dts);
3885  st->info->fps_first_dts =
3887  }
3888 
3889  /* update stored dts values */
3890  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3891  st->info->fps_first_dts = pkt->dts;
3893  }
3894  st->info->fps_last_dts = pkt->dts;
3896  }
3897  if (st->codec_info_nb_frames>1) {
3898  int64_t t = 0;
3899  int64_t limit;
3900 
3901  if (st->time_base.den > 0)
3903  if (st->avg_frame_rate.num > 0)
3905 
3906  if ( t == 0
3907  && st->codec_info_nb_frames>30
3908  && st->info->fps_first_dts != AV_NOPTS_VALUE
3909  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3911 
3912  if (analyzed_all_streams) limit = max_analyze_duration;
3913  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3914  else limit = max_stream_analyze_duration;
3915 
3916  if (t >= limit) {
3917  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3918  limit,
3919  t, pkt->stream_index);
3920  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3921  av_packet_unref(&pkt1);
3922  break;
3923  }
3924  if (pkt->duration) {
3925  if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3927  } else
3929  st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3930  }
3931  }
3932  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3933 #if FF_API_R_FRAME_RATE
3934  ff_rfps_add_frame(ic, st, pkt->dts);
3935 #endif
3936  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3937  st->info->frame_delay_evidence = 1;
3938  }
3939  if (!st->internal->avctx->extradata) {
3940  ret = extract_extradata(st, pkt);
3941  if (ret < 0)
3942  goto unref_then_goto_end;
3943  }
3944 
3945  /* If still no information, we try to open the codec and to
3946  * decompress the frame. We try to avoid that in most cases as
3947  * it takes longer and uses more memory. For MPEG-4, we need to
3948  * decompress for QuickTime.
3949  *
3950  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3951  * least one frame of codec data, this makes sure the codec initializes
3952  * the channel configuration and does not only trust the values from
3953  * the container. */
3954  try_decode_frame(ic, st, pkt,
3955  (options && i < orig_nb_streams) ? &options[i] : NULL);
3956 
3957  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3958  av_packet_unref(&pkt1);
3959 
3960  st->codec_info_nb_frames++;
3961  count++;
3962  }
3963 
3964  if (eof_reached) {
3965  int stream_index;
3966  for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3967  st = ic->streams[stream_index];
3968  avctx = st->internal->avctx;
3969  if (!has_codec_parameters(st, NULL)) {
3970  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3971  if (codec && !avctx->codec) {
3972  AVDictionary *opts = NULL;
3973  if (ic->codec_whitelist)
3974  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3975  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3976  av_log(ic, AV_LOG_WARNING,
3977  "Failed to open codec in %s\n",__FUNCTION__);
3978  av_dict_free(&opts);
3979  }
3980  }
3981 
3982  // EOF already reached while reading the stream above.
3983  // So continue with reoordering DTS with whatever delay we have.
3985  update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3986  }
3987  }
3988  }
3989 
3990  if (flush_codecs) {
3991  AVPacket empty_pkt = { 0 };
3992  int err = 0;
3993  av_init_packet(&empty_pkt);
3994 
3995  for (i = 0; i < ic->nb_streams; i++) {
3996 
3997  st = ic->streams[i];
3998 
3999  /* flush the decoders */
4000  if (st->info->found_decoder == 1) {
4001  do {
4002  err = try_decode_frame(ic, st, &empty_pkt,
4003  (options && i < orig_nb_streams)
4004  ? &options[i] : NULL);
4005  } while (err > 0 && !has_codec_parameters(st, NULL));
4006 
4007  if (err < 0) {
4008  av_log(ic, AV_LOG_INFO,
4009  "decoding for stream %d failed\n", st->index);
4010  }
4011  }
4012  }
4013  }
4014 
4015  ff_rfps_calculate(ic);
4016 
4017  for (i = 0; i < ic->nb_streams; i++) {
4018  st = ic->streams[i];
4019  avctx = st->internal->avctx;
4020  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4021  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4022  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4024  avctx->codec_tag= tag;
4025  }
4026 
4027  /* estimate average framerate if not set by demuxer */
4028  if (st->info->codec_info_duration_fields &&
4029  !st->avg_frame_rate.num &&
4030  st->info->codec_info_duration) {
4031  int best_fps = 0;
4032  double best_error = 0.01;
4033  AVRational codec_frame_rate = avctx->framerate;
4034 
4035  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4036  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4037  st->info->codec_info_duration < 0)
4038  continue;
4040  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4041  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4042 
4043  /* Round guessed framerate to a "standard" framerate if it's
4044  * within 1% of the original estimate. */
4045  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4046  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4047  double error = fabs(av_q2d(st->avg_frame_rate) /
4048  av_q2d(std_fps) - 1);
4049 
4050  if (error < best_error) {
4051  best_error = error;
4052  best_fps = std_fps.num;
4053  }
4054 
4055  if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4056  error = fabs(av_q2d(codec_frame_rate) /
4057  av_q2d(std_fps) - 1);
4058  if (error < best_error) {
4059  best_error = error;
4060  best_fps = std_fps.num;
4061  }
4062  }
4063  }
4064  if (best_fps)
4066  best_fps, 12 * 1001, INT_MAX);
4067  }
4068 
4069  if (!st->r_frame_rate.num) {
4070  if ( avctx->time_base.den * (int64_t) st->time_base.num
4071  <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4073  avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4074  } else {
4075  st->r_frame_rate.num = st->time_base.den;
4076  st->r_frame_rate.den = st->time_base.num;
4077  }
4078  }
4080  AVRational hw_ratio = { avctx->height, avctx->width };
4082  hw_ratio);
4083  }
4084  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4085  if (!avctx->bits_per_coded_sample)
4086  avctx->bits_per_coded_sample =
4088  // set stream disposition based on audio service type
4089  switch (avctx->audio_service_type) {
4092  break;
4095  break;
4098  break;
4101  break;
4104  break;
4105  }
4106  }
4107  }
4108 
4109  if (probesize)
4110  estimate_timings(ic, old_offset);
4111 
4112  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4113 
4114  if (ret >= 0 && ic->nb_streams)
4115  /* We could not have all the codec parameters before EOF. */
4116  ret = -1;
4117  for (i = 0; i < ic->nb_streams; i++) {
4118  const char *errmsg;
4119  st = ic->streams[i];
4120 
4121  /* if no packet was ever seen, update context now for has_codec_parameters */
4122  if (!st->internal->avctx_inited) {
4123  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4125  st->codecpar->format = st->internal->avctx->sample_fmt;
4127  if (ret < 0)
4128  goto find_stream_info_err;
4129  }
4130  if (!has_codec_parameters(st, &errmsg)) {
4131  char buf[256];
4132  avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4133  av_log(ic, AV_LOG_WARNING,
4134  "Could not find codec parameters for stream %d (%s): %s\n"
4135  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4136  i, buf, errmsg);
4137  } else {
4138  ret = 0;
4139  }
4140  }
4141 
4143 
4144  /* update the stream parameters from the internal codec contexts */
4145  for (i = 0; i < ic->nb_streams; i++) {
4146  st = ic->streams[i];
4147 
4148  if (st->internal->avctx_inited) {
4149  int orig_w = st->codecpar->width;
4150  int orig_h = st->codecpar->height;
4152  if (ret < 0)
4153  goto find_stream_info_err;
4154  ret = add_coded_side_data(st, st->internal->avctx);
4155  if (ret < 0)
4156  goto find_stream_info_err;
4157 #if FF_API_LOWRES
4158  // The decoder might reduce the video size by the lowres factor.
4159  if (st->internal->avctx->lowres && orig_w) {
4160  st->codecpar->width = orig_w;
4161  st->codecpar->height = orig_h;
4162  }
4163 #endif
4164  }
4165 
4166 #if FF_API_LAVF_AVCTX
4168  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4169  if (ret < 0)
4170  goto find_stream_info_err;
4171 
4172 #if FF_API_LOWRES
4173  // The old API (AVStream.codec) "requires" the resolution to be adjusted
4174  // by the lowres factor.
4175  if (st->internal->avctx->lowres && st->internal->avctx->width) {
4176  st->codec->lowres = st->internal->avctx->lowres;
4177  st->codec->width = st->internal->avctx->width;
4178  st->codec->height = st->internal->avctx->height;
4179  }
4180 #endif
4181 
4182  if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4183  st->codec->time_base = st->internal->avctx->time_base;
4184  st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4185  }
4186  st->codec->framerate = st->avg_frame_rate;
4187 
4188  if (st->internal->avctx->subtitle_header) {
4189  st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4190  if (!st->codec->subtitle_header)
4191  goto find_stream_info_err;
4192  st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4193  memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4194  st->codec->subtitle_header_size);
4195  }
4196 
4197  // Fields unavailable in AVCodecParameters
4198  st->codec->coded_width = st->internal->avctx->coded_width;
4199  st->codec->coded_height = st->internal->avctx->coded_height;
4200  st->codec->properties = st->internal->avctx->properties;
4202 #endif
4203 
4204  st->internal->avctx_inited = 0;
4205  }
4206 
4207 find_stream_info_err:
4208  for (i = 0; i < ic->nb_streams; i++) {
4209  st = ic->streams[i];
4210  if (st->info)
4211  av_freep(&st->info->duration_error);
4213  av_freep(&ic->streams[i]->info);
4216  }
4217  if (ic->pb)
4218  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4219  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4220  return ret;
4221 
4222 unref_then_goto_end:
4223  av_packet_unref(&pkt1);
4224  goto find_stream_info_err;
4225 }
4226 
4228 {
4229  int i, j;
4230 
4231  for (i = 0; i < ic->nb_programs; i++) {
4232  if (ic->programs[i] == last) {
4233  last = NULL;
4234  } else {
4235  if (!last)
4236  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4237  if (ic->programs[i]->stream_index[j] == s)
4238  return ic->programs[i];
4239  }
4240  }
4241  return NULL;
4242 }
4243 
4245  int wanted_stream_nb, int related_stream,
4246  AVCodec **decoder_ret, int flags)
4247 {
4248  int i, nb_streams = ic->nb_streams;
4250  int best_count = -1, best_multiframe = -1, best_disposition = -1;
4251  int count, multiframe, disposition;
4252  int64_t best_bitrate = -1;
4253  int64_t bitrate;
4254  unsigned *program = NULL;
4255  const AVCodec *decoder = NULL, *best_decoder = NULL;
4256 
4257  if (related_stream >= 0 && wanted_stream_nb < 0) {
4258  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4259  if (p) {
4260  program = p->stream_index;
4262  }
4263  }
4264  for (i = 0; i < nb_streams; i++) {
4265  int real_stream_index = program ? program[i] : i;
4266  AVStream *st = ic->streams[real_stream_index];
4267  AVCodecParameters *par = st->codecpar;
4268  if (par->codec_type != type)
4269  continue;
4270  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4271  continue;
4272  if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4273  continue;
4274  if (decoder_ret) {
4275  decoder = find_decoder(ic, st, par->codec_id);
4276  if (!decoder) {
4277  if (ret < 0)
4279  continue;
4280  }
4281  }
4283  + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4284  count = st->codec_info_nb_frames;
4285  bitrate = par->bit_rate;
4286  multiframe = FFMIN(5, count);
4287  if ((best_disposition > disposition) ||
4288  (best_disposition == disposition && best_multiframe > multiframe) ||
4289  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4290  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4291  continue;
4292  best_disposition = disposition;
4293  best_count = count;
4294  best_bitrate = bitrate;
4295  best_multiframe = multiframe;
4296  ret = real_stream_index;
4297  best_decoder = decoder;
4298  if (program && i == nb_streams - 1 && ret < 0) {
4299  program = NULL;
4300  nb_streams = ic->nb_streams;
4301  /* no related stream found, try again with everything */
4302  i = 0;
4303  }
4304  }
4305  if (decoder_ret)
4306  *decoder_ret = (AVCodec*)best_decoder;
4307  return ret;
4308 }
4309 
4310 /*******************************************************/
4311 
4313 {
4314  if (s->iformat->read_play)
4315  return s->iformat->read_play(s);
4316  if (s->pb)
4317  return avio_pause(s->pb, 0);
4318  return AVERROR(ENOSYS);
4319 }
4320 
4322 {
4323  if (s->iformat->read_pause)
4324  return s->iformat->read_pause(s);
4325  if (s->pb)
4326  return avio_pause(s->pb, 1);
4327  return AVERROR(ENOSYS);
4328 }
4329 
4331 {
4332  int ret, i;
4333 
4334  dst->id = src->id;
4335  dst->time_base = src->time_base;
4336  dst->nb_frames = src->nb_frames;
4337  dst->disposition = src->disposition;
4338  dst->sample_aspect_ratio = src->sample_aspect_ratio;
4339  dst->avg_frame_rate = src->avg_frame_rate;
4340  dst->r_frame_rate = src->r_frame_rate;
4341 
4342  av_dict_free(&dst->metadata);
4343  ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4344  if (ret < 0)
4345  return ret;
4346 
4347  ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4348  if (ret < 0)
4349  return ret;
4350 
4351  /* Free existing side data*/
4352  for (i = 0; i < dst->nb_side_data; i++)
4353  av_free(dst->side_data[i].data);
4354  av_freep(&dst->side_data);
4355  dst->nb_side_data = 0;
4356 
4357  /* Copy side data if present */
4358  if (src->nb_side_data) {
4359  dst->side_data = av_mallocz_array(src->nb_side_data,
4360  sizeof(AVPacketSideData));
4361  if (!dst->side_data)
4362  return AVERROR(ENOMEM);
4363  dst->nb_side_data = src->nb_side_data;
4364 
4365  for (i = 0; i < src->nb_side_data; i++) {
4366  uint8_t *data = av_memdup(src->side_data[i].data,
4367  src->side_data[i].size);
4368  if (!data)
4369  return AVERROR(ENOMEM);
4370  dst->side_data[i].type = src->side_data[i].type;
4371  dst->side_data[i].size = src->side_data[i].size;
4372  dst->side_data[i].data = data;
4373  }
4374  }
4375 
4376 #if FF_API_LAVF_FFSERVER
4378  av_freep(&dst->recommended_encoder_configuration);
4379  if (src->recommended_encoder_configuration) {
4380  const char *conf_str = src->recommended_encoder_configuration;
4381  dst->recommended_encoder_configuration = av_strdup(conf_str);
4382  if (!dst->recommended_encoder_configuration)
4383  return AVERROR(ENOMEM);
4384  }
4386 #endif
4387 
4388  return 0;
4389 }
4390 
4391 static void free_stream(AVStream **pst)
4392 {
4393  AVStream *st = *pst;
4394  int i;
4395 
4396  if (!st)
4397  return;
4398 
4399  for (i = 0; i < st->nb_side_data; i++)
4400  av_freep(&st->side_data[i].data);
4401  av_freep(&st->side_data);
4402 
4403  if (st->parser)
4404  av_parser_close(st->parser);
4405 
4406  if (st->attached_pic.data)
4408 
4409  if (st->internal) {
4411  av_bsf_free(&st->internal->bsfc);
4412  av_freep(&st->internal->priv_pts);
4415  }
4416  av_freep(&st->internal);
4417 
4418  av_dict_free(&st->metadata);
4420  av_freep(&st->probe_data.buf);
4421  av_freep(&st->index_entries);
4422 #if FF_API_LAVF_AVCTX
4424  avcodec_free_context(&st->codec);
4426 #endif
4427  av_freep(&st->priv_data);
4428  if (st->info)
4429  av_freep(&st->info->duration_error);
4430  av_freep(&st->info);
4431 #if FF_API_LAVF_FFSERVER
4433  av_freep(&st->recommended_encoder_configuration);
4435 #endif
4436 
4437  av_freep(pst);
4438 }
4439 
4441 {
4442  av_assert0(s->nb_streams>0);
4443  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4444 
4445  free_stream(&s->streams[ --s->nb_streams ]);
4446 }
4447 
4449 {
4450  int i;
4451 
4452  if (!s)
4453  return;
4454 
4455  if (s->oformat && s->oformat->deinit && s->internal->initialized)
4456  s->oformat->deinit(s);
4457 
4458  av_opt_free(s);
4459  if (s->iformat && s->iformat->priv_class && s->priv_data)
4460  av_opt_free(s->priv_data);
4461  if (s->oformat && s->oformat->priv_class && s->priv_data)
4462  av_opt_free(s->priv_data);
4463 
4464  for (i = 0; i < s->nb_streams; i++)
4465  free_stream(&s->streams[i]);
4466  s->nb_streams = 0;
4467 
4468  for (i = 0; i < s->nb_programs; i++) {
4469  av_dict_free(&s->programs[i]->metadata);
4470  av_freep(&s->programs[i]->stream_index);
4471  av_freep(&s->programs[i]);
4472  }
4473  s->nb_programs = 0;
4474 
4475  av_freep(&s->programs);
4476  av_freep(&s->priv_data);
4477  while (s->nb_chapters--) {
4478  av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4479  av_freep(&s->chapters[s->nb_chapters]);
4480  }
4481  av_freep(&s->chapters);
4482  av_dict_free(&s->metadata);
4483  av_dict_free(&s->internal->id3v2_meta);
4484  av_freep(&s->streams);
4486  av_freep(&s->internal);
4487  av_freep(&s->url);
4488  av_free(s);
4489 }
4490 
4492 {
4493  AVFormatContext *s;
4494  AVIOContext *pb;
4495 
4496  if (!ps || !*ps)
4497  return;
4498 
4499  s = *ps;
4500  pb = s->pb;
4501 
4502  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4503  (s->flags & AVFMT_FLAG_CUSTOM_IO))
4504  pb = NULL;
4505 
4507 
4508  if (s->iformat)
4509  if (s->iformat->read_close)
4510  s->iformat->read_close(s);
4511 
4513 
4514  *ps = NULL;
4515 
4516  avio_close(pb);
4517 }
4518 
4520 {
4521  AVStream *st;
4522  int i;
4523  AVStream **streams;
4524 
4525  if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4526  if (s->max_streams < INT_MAX/sizeof(*streams))
4527  av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4528  return NULL;
4529  }
4530  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4531  if (!streams)
4532  return NULL;
4533  s->streams = streams;
4534 
4535  st = av_mallocz(sizeof(AVStream));
4536  if (!st)
4537  return NULL;
4538  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4539  av_free(st);
4540  return NULL;
4541  }
4542  st->info->last_dts = AV_NOPTS_VALUE;
4543 
4544 #if FF_API_LAVF_AVCTX
4546  st->codec = avcodec_alloc_context3(c);
4547  if (!st->codec) {
4548  av_free(st->info);
4549  av_free(st);
4550  return NULL;
4551  }
4553 #endif
4554 
4555  st->internal = av_mallocz(sizeof(*st->internal));
4556  if (!st->internal)
4557  goto fail;
4558 
4560  if (!st->codecpar)
4561  goto fail;
4562 
4564  if (!st->internal->avctx)
4565  goto fail;
4566 
4567  if (s->iformat) {
4568 #if FF_API_LAVF_AVCTX
4570  /* no default bitrate if decoding */
4571  st->codec->bit_rate = 0;
4573 #endif
4574 
4575  /* default pts setting is MPEG-like */
4576  avpriv_set_pts_info(st, 33, 1, 90000);
4577  /* we set the current DTS to 0 so that formats without any timestamps
4578  * but durations get some timestamps, formats with some unknown
4579  * timestamps have their first few packets buffered and the
4580  * timestamps corrected before they are returned to the user */
4581  st->cur_dts = RELATIVE_TS_BASE;
4582  } else {
4583  st->cur_dts = AV_NOPTS_VALUE;
4584  }
4585 
4586  st->index = s->nb_streams;
4587  st->start_time = AV_NOPTS_VALUE;
4588  st->duration = AV_NOPTS_VALUE;
4589  st->first_dts = AV_NOPTS_VALUE;
4590  st->probe_packets = s->max_probe_packets;
4593 
4596  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4597  st->pts_buffer[i] = AV_NOPTS_VALUE;
4598 
4599  st->sample_aspect_ratio = (AVRational) { 0, 1 };
4600 
4601 #if FF_API_R_FRAME_RATE
4602  st->info->last_dts = AV_NOPTS_VALUE;
4603 #endif
4606 
4607  st->inject_global_side_data = s->internal->inject_global_side_data;
4608 
4609  st->internal->need_context_update = 1;
4610 
4611  s->streams[s->nb_streams++] = st;
4612  return st;
4613 fail:
4614  free_stream(&st);
4615  return NULL;
4616 }
4617 
4619 {
4620  AVProgram *program = NULL;
4621  int i;
4622 
4623  av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4624 
4625  for (i = 0; i < ac->nb_programs; i++)
4626  if (ac->programs[i]->id == id)
4627  program = ac->programs[i];
4628 
4629  if (!program) {
4630  program = av_mallocz(sizeof(AVProgram));
4631  if (!program)
4632  return NULL;
4634  program->discard = AVDISCARD_NONE;
4635  program->pmt_version = -1;
4636  }
4637  program->id = id;
4638  program->pts_wrap_reference = AV_NOPTS_VALUE;
4639  program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4640 
4641  program->start_time =
4642  program->end_time = AV_NOPTS_VALUE;
4643 
4644  return program;
4645 }
4646 
4648  int64_t start, int64_t end, const char *title)
4649 {
4650  AVChapter *chapter = NULL;
4651  int i;
4652 
4653  if (end != AV_NOPTS_VALUE && start > end) {
4654  av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4655  return NULL;
4656  }
4657 
4658  for (i = 0; i < s->nb_chapters; i++)
4659  if (s->chapters[i]->id == id)
4660  chapter = s->chapters[i];
4661 
4662  if (!chapter) {
4663  chapter = av_mallocz(sizeof(AVChapter));
4664  if (!chapter)
4665  return NULL;
4666  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4667  }
4668  av_dict_set(&chapter->metadata, "title", title, 0);
4669  chapter->id = id;
4670  chapter->time_base = time_base;
4671  chapter->start = start;
4672  chapter->end = end;
4673 
4674  return chapter;
4675 }
4676 
4677 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4678 {
4679  int i, j;
4680  AVProgram *program = NULL;
4681  void *tmp;
4682 
4683  if (idx >= ac->nb_streams) {
4684  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4685  return;
4686  }
4687 
4688  for (i = 0; i < ac->nb_programs; i++) {
4689  if (ac->programs[i]->id != progid)
4690  continue;
4691  program = ac->programs[i];
4692  for (j = 0; j < program->nb_stream_indexes; j++)
4693  if (program->stream_index[j] == idx)
4694  return;
4695 
4696  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4697  if (!tmp)
4698  return;
4699  program->stream_index = tmp;
4700  program->stream_index[program->nb_stream_indexes++] = idx;
4701  return;
4702  }
4703 }
4704 
4705 uint64_t ff_ntp_time(void)
4706 {
4707  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4708 }
4709 
4710 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4711 {
4712  uint64_t ntp_ts, frac_part, sec;
4713  uint32_t usec;
4714 
4715  //current ntp time in seconds and micro seconds
4716  sec = ntp_time_us / 1000000;
4717  usec = ntp_time_us % 1000000;
4718 
4719  //encoding in ntp timestamp format
4720  frac_part = usec * 0xFFFFFFFFULL;
4721  frac_part /= 1000000;
4722 
4723  if (sec > 0xFFFFFFFFULL)
4724  av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4725 
4726  ntp_ts = sec << 32;
4727  ntp_ts |= frac_part;
4728 
4729  return ntp_ts;
4730 }
4731 
4732 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4733 {
4734  const char *p;
4735  char *q, buf1[20], c;
4736  int nd, len, percentd_found;
4737 
4738  q = buf;
4739  p = path;
4740  percentd_found = 0;
4741  for (;;) {
4742  c = *p++;
4743  if (c == '\0')
4744  break;
4745  if (c == '%') {
4746  do {
4747  nd = 0;
4748  while (av_isdigit(*p))
4749  nd = nd * 10 + *p++ - '0';
4750  c = *p++;
4751  } while (av_isdigit(c));
4752 
4753  switch (c) {
4754  case '%':
4755  goto addchar;
4756  case 'd':
4757  if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4758  goto fail;
4759  percentd_found = 1;
4760  if (number < 0)
4761  nd += 1;
4762  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4763  len = strlen(buf1);
4764  if ((q - buf + len) > buf_size - 1)
4765  goto fail;
4766  memcpy(q, buf1, len);
4767  q += len;
4768  break;
4769  default:
4770  goto fail;
4771  }
4772  } else {
4773 addchar:
4774  if ((q - buf) < buf_size - 1)
4775  *q++ = c;
4776  }
4777  }
4778  if (!percentd_found)
4779  goto fail;
4780  *q = '\0';
4781  return 0;
4782 fail:
4783  *q = '\0';
4784  return -1;
4785 }
4786 
4787 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4788 {
4789  return av_get_frame_filename2(buf, buf_size, path, number, 0);
4790 }
4791 
4792 void av_url_split(char *proto, int proto_size,
4793  char *authorization, int authorization_size,
4794  char *hostname, int hostname_size,
4795  int *port_ptr, char *path, int path_size, const char *url)
4796 {
4797  const char *p, *ls, *at, *at2, *col, *brk;
4798 
4799  if (port_ptr)
4800  *port_ptr = -1;
4801  if (proto_size > 0)
4802  proto[0] = 0;
4803  if (authorization_size > 0)
4804  authorization[0] = 0;
4805  if (hostname_size > 0)
4806  hostname[0] = 0;
4807  if (path_size > 0)
4808  path[0] = 0;
4809 
4810  /* parse protocol */
4811  if ((p = strchr(url, ':'))) {
4812  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4813  p++; /* skip ':' */
4814  if (*p == '/')
4815  p++;
4816  if (*p == '/')
4817  p++;
4818  } else {
4819  /* no protocol means plain filename */
4820  av_strlcpy(path, url, path_size);
4821  return;
4822  }
4823 
4824  /* separate path from hostname */
4825  ls = p + strcspn(p, "/?#");
4826  av_strlcpy(path, ls, path_size);
4827 
4828  /* the rest is hostname, use that to parse auth/port */
4829  if (ls != p) {
4830  /* authorization (user[:pass]@hostname) */
4831  at2 = p;
4832  while ((at = strchr(p, '@')) && at < ls) {
4833  av_strlcpy(authorization, at2,
4834  FFMIN(authorization_size, at + 1 - at2));
4835  p = at + 1; /* skip '@' */
4836  }
4837 
4838  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4839  /* [host]:port */
4840  av_strlcpy(hostname, p + 1,
4841  FFMIN(hostname_size, brk - p));
4842  if (brk[1] == ':' && port_ptr)
4843  *port_ptr = atoi(brk + 2);
4844  } else if ((col = strchr(p, ':')) && col < ls) {
4845  av_strlcpy(hostname, p,
4846  FFMIN(col + 1 - p, hostname_size));
4847  if (port_ptr)
4848  *port_ptr = atoi(col + 1);
4849  } else
4850  av_strlcpy(hostname, p,
4851  FFMIN(ls + 1 - p, hostname_size));
4852  }
4853 }
4854 
4855 int ff_mkdir_p(const char *path)
4856 {
4857  int ret = 0;
4858  char *temp = av_strdup(path);
4859  char *pos = temp;
4860  char tmp_ch = '\0';
4861 
4862  if (!path || !temp) {
4863  return -1;
4864  }
4865 
4866  if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4867  pos++;
4868  } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4869  pos += 2;
4870  }
4871 
4872  for ( ; *pos != '\0'; ++pos) {
4873  if (*pos == '/' || *pos == '\\') {
4874  tmp_ch = *pos;
4875  *pos = '\0';
4876  ret = mkdir(temp, 0755);
4877  *pos = tmp_ch;
4878  }
4879  }
4880 
4881  if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4882  ret = mkdir(temp, 0755);
4883  }
4884 
4885  av_free(temp);
4886  return ret;
4887 }
4888 
4889 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4890 {
4891  int i;
4892  static const char hex_table_uc[16] = { '0', '1', '2', '3',
4893  '4', '5', '6', '7',
4894  '8', '9', 'A', 'B',
4895  'C', 'D', 'E', 'F' };
4896  static const char hex_table_lc[16] = { '0', '1', '2', '3',
4897  '4', '5', '6', '7',
4898  '8', '9', 'a', 'b',
4899  'c', 'd', 'e', 'f' };
4900  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4901 
4902  for (i = 0; i < s; i++) {
4903  buff[i * 2] = hex_table[src[i] >> 4];
4904  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4905  }
4906 
4907  return buff;
4908 }
4909 
4910 int ff_hex_to_data(uint8_t *data, const char *p)
4911 {
4912  int c, len, v;
4913 
4914  len = 0;
4915  v = 1;
4916  for (;;) {
4917  p += strspn(p, SPACE_CHARS);
4918  if (*p == '\0')
4919  break;
4920  c = av_toupper((unsigned char) *p++);
4921  if (c >= '0' && c <= '9')
4922  c = c - '0';
4923  else if (c >= 'A' && c <= 'F')
4924  c = c - 'A' + 10;
4925  else
4926  break;
4927  v = (v << 4) | c;
4928  if (v & 0x100) {
4929  if (data)
4930  data[len] = v;
4931  len++;
4932  v = 1;
4933  }
4934  }
4935  return len;
4936 }
4937 
4938 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4939  unsigned int pts_num, unsigned int pts_den)
4940 {
4941  AVRational new_tb;
4942  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4943  if (new_tb.num != pts_num)
4945  "st:%d removing common factor %d from timebase\n",
4946  s->index, pts_num / new_tb.num);
4947  } else
4949  "st:%d has too large timebase, reducing\n", s->index);
4950 
4951  if (new_tb.num <= 0 || new_tb.den <= 0) {
4953  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4954  new_tb.num, new_tb.den,
4955  s->index);
4956  return;
4957  }
4958  s->time_base = new_tb;
4959 #if FF_API_LAVF_AVCTX
4961  s->codec->pkt_timebase = new_tb;
4963 #endif
4964  s->internal->avctx->pkt_timebase = new_tb;
4965  s->pts_wrap_bits = pts_wrap_bits;
4966 }
4967 
4968 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4969  void *context)
4970 {
4971  const char *ptr = str;
4972 
4973  /* Parse key=value pairs. */
4974  for (;;) {
4975  const char *key;
4976  char *dest = NULL, *dest_end;
4977  int key_len, dest_len = 0;
4978 
4979  /* Skip whitespace and potential commas. */
4980  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4981  ptr++;
4982  if (!*ptr)
4983  break;
4984 
4985  key = ptr;
4986 
4987  if (!(ptr = strchr(key, '=')))
4988  break;
4989  ptr++;
4990  key_len = ptr - key;
4991 
4992  callback_get_buf(context, key, key_len, &dest, &dest_len);
4993  dest_end = dest + dest_len - 1;
4994 
4995  if (*ptr == '\"') {
4996  ptr++;
4997  while (*ptr && *ptr != '\"') {
4998  if (*ptr == '\\') {
4999  if (!ptr[1])
5000  break;
5001  if (dest && dest < dest_end)
5002  *dest++ = ptr[1];
5003  ptr += 2;
5004  } else {
5005  if (dest && dest < dest_end)
5006  *dest++ = *ptr;
5007  ptr++;
5008  }
5009  }
5010  if (*ptr == '\"')
5011  ptr++;
5012  } else {
5013  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5014  if (dest && dest < dest_end)
5015  *dest++ = *ptr;
5016  }
5017  if (dest)
5018  *dest = 0;
5019  }
5020 }
5021 
5023 {
5024  int i;
5025  for (i = 0; i < s->nb_streams; i++)
5026  if (s->streams[i]->id == id)
5027  return i;
5028  return -1;
5029 }
5030 
5032  int std_compliance)
5033 {
5034  if (ofmt) {
5035  unsigned int codec_tag;
5036  if (ofmt->query_codec)
5037  return ofmt->query_codec(codec_id, std_compliance);
5038  else if (ofmt->codec_tag)
5039  return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5040  else if (codec_id == ofmt->video_codec ||
5041  codec_id == ofmt->audio_codec ||
5042  codec_id == ofmt->subtitle_codec ||
5043  codec_id == ofmt->data_codec)
5044  return 1;
5045  }
5046  return AVERROR_PATCHWELCOME;
5047 }
5048 
5050 {
5051 #if CONFIG_NETWORK
5052  int ret;
5053  if ((ret = ff_network_init()) < 0)
5054  return ret;
5055  if ((ret = ff_tls_init()) < 0)
5056  return ret;
5057 #endif
5058  return 0;
5059 }
5060 
5062 {
5063 #if CONFIG_NETWORK
5064  ff_network_close();
5065  ff_tls_deinit();
5066 #endif
5067  return 0;
5068 }
5069 
5071  uint64_t channel_layout, int32_t sample_rate,
5073 {
5074  uint32_t flags = 0;
5075  int size = 4;
5076  uint8_t *data;
5077  if (!pkt)
5078  return AVERROR(EINVAL);
5079  if (channels) {
5080  size += 4;
5082  }
5083  if (channel_layout) {
5084  size += 8;
5086  }
5087  if (sample_rate) {
5088  size += 4;
5090  }
5091  if (width || height) {
5092  size += 8;
5094  }
5096  if (!data)
5097  return AVERROR(ENOMEM);
5098  bytestream_put_le32(&data, flags);
5099  if (channels)
5100  bytestream_put_le32(&data, channels);
5101  if (channel_layout)
5102  bytestream_put_le64(&data, channel_layout);
5103  if (sample_rate)
5104  bytestream_put_le32(&data, sample_rate);
5105  if (width || height) {
5106  bytestream_put_le32(&data, width);
5107  bytestream_put_le32(&data, height);
5108  }
5109  return 0;
5110 }
5111 
5113 {
5114  AVRational undef = {0, 1};
5115  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5116  AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5117  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5118 
5119  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5120  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5121  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5122  stream_sample_aspect_ratio = undef;
5123 
5124  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5125  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5126  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5127  frame_sample_aspect_ratio = undef;
5128 
5129  if (stream_sample_aspect_ratio.num)
5130  return stream_sample_aspect_ratio;
5131  else
5132  return frame_sample_aspect_ratio;
5133 }
5134 
5136 {
5137  AVRational fr = st->r_frame_rate;
5138  AVRational codec_fr = st->internal->avctx->framerate;
5139  AVRational avg_fr = st->avg_frame_rate;
5140 
5141  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5142  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5143  fr = avg_fr;
5144  }
5145 
5146 
5147  if (st->internal->avctx->ticks_per_frame > 1) {
5148  if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5149  (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))
5150  fr = codec_fr;
5151  }
5152 
5153  return fr;
5154 }
5155 
5156 /**
5157  * Matches a stream specifier (but ignores requested index).
5158  *
5159  * @param indexptr set to point to the requested stream index if there is one
5160  *
5161  * @return <0 on error
5162  * 0 if st is NOT a matching stream
5163  * >0 if st is a matching stream
5164  */
5166  const char *spec, const char **indexptr, AVProgram **p)
5167 {
5168  int match = 1; /* Stores if the specifier matches so far. */
5169  while (*spec) {
5170  if (*spec <= '9' && *spec >= '0') { /* opt:index */
5171  if (indexptr)
5172  *indexptr = spec;
5173  return match;
5174  } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5175  *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5176  enum AVMediaType type;
5177  int nopic = 0;
5178 
5179  switch (*spec++) {
5180  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5181  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5182  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5183  case 'd': type = AVMEDIA_TYPE_DATA; break;
5184  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5185  case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5186  default: av_assert0(0);
5187  }
5188  if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5189  return AVERROR(EINVAL);
5190 
5191 #if FF_API_LAVF_AVCTX
5193  if (type != st->codecpar->codec_type
5194  && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5195  match = 0;
5197 #else
5198  if (type != st->codecpar->codec_type)
5199  match = 0;
5200 #endif
5201  if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5202  match = 0;
5203  } else if (*spec == 'p' && *(spec + 1) == ':') {
5204  int prog_id, i, j;
5205  int found = 0;
5206  char *endptr;
5207  spec += 2;
5208  prog_id = strtol(spec, &endptr, 0);
5209  /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5210  if (spec == endptr || (*endptr && *endptr++ != ':'))
5211  return AVERROR(EINVAL);
5212  spec = endptr;
5213  if (match) {
5214  for (i = 0; i < s->nb_programs; i++) {
5215  if (s->programs[i]->id != prog_id)
5216  continue;
5217 
5218  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5219  if (st->index == s->programs[i]->stream_index[j]) {
5220  found = 1;
5221  if (p)
5222  *p = s->programs[i];
5223  i = s->nb_programs;
5224  break;
5225  }
5226  }
5227  }
5228  }
5229  if (!found)
5230  match = 0;
5231  } else if (*spec == '#' ||
5232  (*spec == 'i' && *(spec + 1) == ':')) {
5233  int stream_id;
5234  char *endptr;
5235  spec += 1 + (*spec == 'i');
5236  stream_id = strtol(spec, &endptr, 0);
5237  if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5238  return AVERROR(EINVAL);
5239  return match && (stream_id == st->id);
5240  } else if (*spec == 'm' && *(spec + 1) == ':') {
5242  char *key, *val;
5243  int ret;
5244 
5245  if (match) {
5246  spec += 2;
5247  val = strchr(spec, ':');
5248 
5249  key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5250  if (!key)
5251  return AVERROR(ENOMEM);
5252 
5253  tag = av_dict_get(st->metadata, key, NULL, 0);
5254  if (tag) {
5255  if (!val || !strcmp(tag->value, val + 1))
5256  ret = 1;
5257  else
5258  ret = 0;
5259  } else
5260  ret = 0;
5261 
5262  av_freep(&key);
5263  }
5264  return match && ret;
5265  } else if (*spec == 'u' && *(spec + 1) == '\0') {
5266  AVCodecParameters *par = st->codecpar;
5267 #if FF_API_LAVF_AVCTX
5269  AVCodecContext *codec = st->codec;
5271 #endif
5272  int val;
5273  switch (par->codec_type) {
5274  case AVMEDIA_TYPE_AUDIO:
5275  val = par->sample_rate && par->channels;
5276 #if FF_API_LAVF_AVCTX
5277  val = val || (codec->sample_rate && codec->channels);
5278 #endif
5279  if (par->format == AV_SAMPLE_FMT_NONE
5281  && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5282 #endif
5283  )
5284  return 0;
5285  break;
5286  case AVMEDIA_TYPE_VIDEO:
5287  val = par->width && par->height;
5288 #if FF_API_LAVF_AVCTX
5289  val = val || (codec->width && codec->height);
5290 #endif
5291  if (par->format == AV_PIX_FMT_NONE
5293  && codec->pix_fmt == AV_PIX_FMT_NONE
5294 #endif
5295  )
5296  return 0;
5297  break;
5298  case AVMEDIA_TYPE_UNKNOWN:
5299  val = 0;
5300  break;
5301  default:
5302  val = 1;
5303  break;
5304  }
5305 #if FF_API_LAVF_AVCTX
5306  return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5307 #else
5308  return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5309 #endif
5310  } else {
5311  return AVERROR(EINVAL);
5312  }
5313  }
5314 
5315  return match;
5316 }
5317 
5318 
5320  const char *spec)
5321 {
5322  int ret, index;
5323  char *endptr;
5324  const char *indexptr = NULL;
5325  AVProgram *p = NULL;
5326  int nb_streams;
5327 
5328  ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5329  if (ret < 0)
5330  goto error;
5331 
5332  if (!indexptr)
5333  return ret;
5334 
5335  index = strtol(indexptr, &endptr, 0);
5336  if (*endptr) { /* We can't have anything after the requested index. */
5337  ret = AVERROR(EINVAL);
5338  goto error;
5339  }
5340 
5341  /* This is not really needed but saves us a loop for simple stream index specifiers. */
5342  if (spec == indexptr)
5343  return (index == st->index);
5344 
5345  /* If we requested a matching stream index, we have to ensure st is that. */
5346  nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5347  for (int i = 0; i < nb_streams && index >= 0; i++) {
5348  AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5349  ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5350  if (ret < 0)
5351  goto error;
5352  if (ret > 0 && index-- == 0 && st == candidate)
5353  return 1;
5354  }
5355  return 0;
5356 
5357 error:
5358  if (ret == AVERROR(EINVAL))
5359  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5360  return ret;
5361 }
5362 
5364 {
5365  static const uint8_t avci100_1080p_extradata[] = {
5366  // SPS
5367  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5368  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5369  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5370  0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5371  0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5372  0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5373  0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5374  0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5375  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5376  // PPS
5377  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5378  0xd0
5379  };
5380  static const uint8_t avci100_1080i_extradata[] = {
5381  // SPS
5382  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5383  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5384  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5385  0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5386  0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5387  0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5388  0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5389  0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5390  0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5391  0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5392  0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5393  // PPS
5394  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5395  0xd0
5396  };
5397  static const uint8_t avci50_1080p_extradata[] = {
5398  // SPS
5399  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5400  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5401  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5402  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5403  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5404  0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5405  0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5406  0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5407  0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5408  // PPS
5409  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5410  0x11
5411  };
5412  static const uint8_t avci50_1080i_extradata[] = {
5413  // SPS
5414  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5415  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5416  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5417  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5418  0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5419  0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5420  0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5421  0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5422  0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5423  0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5424  0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5425  // PPS
5426  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5427  0x11
5428  };
5429  static const uint8_t avci100_720p_extradata[] = {
5430  // SPS
5431  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5432  0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5433  0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5434  0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5435  0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5436  0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5437  0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5438  0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5439  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5440  0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5441  // PPS
5442  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5443  0x11
5444  };
5445  static const uint8_t avci50_720p_extradata[] = {
5446  // SPS
5447  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5448  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5449  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5450  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5451  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5452  0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5453  0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5454  0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5455  0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5456  // PPS
5457  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5458  0x11
5459  };
5460 
5461  const uint8_t *data = NULL;
5462  int ret, size = 0;
5463 
5464  if (st->codecpar->width == 1920) {
5466  data = avci100_1080p_extradata;
5467  size = sizeof(avci100_1080p_extradata);
5468  } else {
5469  data = avci100_1080i_extradata;
5470  size = sizeof(avci100_1080i_extradata);
5471  }
5472  } else if (st->codecpar->width == 1440) {
5474  data = avci50_1080p_extradata;
5475  size = sizeof(avci50_1080p_extradata);
5476  } else {
5477  data = avci50_1080i_extradata;
5478  size = sizeof(avci50_1080i_extradata);
5479  }
5480  } else if (st->codecpar->width == 1280) {
5481  data = avci100_720p_extradata;
5482  size = sizeof(avci100_720p_extradata);
5483  } else if (st->codecpar->width == 960) {
5484  data = avci50_720p_extradata;
5485  size = sizeof(avci50_720p_extradata);
5486  }
5487 
5488  if (!size)
5489  return 0;
5490 
5491  if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5492  return ret;
5493  memcpy(st->codecpar->extradata, data, size);
5494 
5495  return 0;
5496 }
5497 
5499  enum AVPacketSideDataType type, int *size)
5500 {
5501  int i;
5502 
5503  for (i = 0; i < st->nb_side_data; i++) {
5504  if (st->side_data[i].type == type) {
5505  if (size)
5506  *size = st->side_data[i].size;
5507  return st->side_data[i].data;
5508  }
5509  }
5510  if (size)
5511  *size = 0;
5512  return NULL;
5513 }
5514 
5516  uint8_t *data, size_t size)
5517 {
5518  AVPacketSideData *sd, *tmp;
5519  int i;
5520 
5521  for (i = 0; i < st->nb_side_data; i++) {
5522  sd = &st->side_data[i];
5523 
5524  if (sd->type == type) {
5525  av_freep(&sd->data);
5526  sd->data = data;
5527  sd->size = size;
5528  return 0;
5529  }
5530  }
5531 
5532  if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5533  return AVERROR(ERANGE);
5534 
5535  tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5536  if (!tmp) {
5537  return AVERROR(ENOMEM);
5538  }
5539 
5540  st->side_data = tmp;
5541  st->nb_side_data++;
5542 
5543  sd = &st->side_data[st->nb_side_data - 1];
5544  sd->type = type;
5545  sd->data = data;
5546  sd->size = size;
5547 
5548  return 0;
5549 }
5550 
5552  int size)
5553 {
5554  int ret;
5555  uint8_t *data = av_malloc(size);
5556 
5557  if (!data)
5558  return NULL;
5559 
5561  if (ret < 0) {
5562  av_freep(&data);
5563  return NULL;
5564  }
5565 
5566  return data;
5567 }
5568 
5569 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5570 {
5571  int ret;
5572  const AVBitStreamFilter *bsf;
5573  AVBSFContext *bsfc;
5574 
5575  av_assert0(!st->internal->bsfc);
5576 
5577  if (!(bsf = av_bsf_get_by_name(name))) {
5578  av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5579  return AVERROR_BSF_NOT_FOUND;
5580  }
5581 
5582  if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5583  return ret;
5584 
5585  bsfc->time_base_in = st->time_base;
5586  if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5587  av_bsf_free(&bsfc);
5588  return ret;
5589  }
5590 
5591  if (args && bsfc->filter->priv_class) {
5592  const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5593  const char * shorthand[2] = {NULL};
5594 
5595  if (opt)
5596  shorthand[0] = opt->name;
5597 
5598  if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5599  av_bsf_free(&bsfc);
5600  return ret;
5601  }
5602  }
5603 
5604  if ((ret = av_bsf_init(bsfc)) < 0) {
5605  av_bsf_free(&bsfc);
5606  return ret;
5607  }
5608 
5609  st->internal->bsfc = bsfc;
5610 
5612  "Automatically inserted bitstream filter '%s'; args='%s'\n",
5613  name, args ? args : "");
5614  return 1;
5615 }
5616 
5617 #if FF_API_OLD_BSF
5619 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5621 {
5622  int ret = 0;
5623  while (bsfc) {
5624  AVPacket new_pkt = *pkt;
5625  int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5626  &new_pkt.data, &new_pkt.size,
5627  pkt->data, pkt->size,
5629  if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5631  memset(pkt, 0, sizeof(*pkt));
5632  return 0;
5633  }
5634  if(a == 0 && new_pkt.data != pkt->data) {
5635  uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
5636  if (t) {
5637  memcpy(t, new_pkt.data, new_pkt.size);
5638  memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5639  new_pkt.data = t;
5640  new_pkt.buf = NULL;
5641  a = 1;
5642  } else {
5643  a = AVERROR(ENOMEM);
5644  }
5645  }
5646  if (a > 0) {
5647  new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5649  if (new_pkt.buf) {
5650  pkt->side_data = NULL;
5651  pkt->side_data_elems = 0;
5653  } else {
5654  av_freep(&new_pkt.data);
5655  a = AVERROR(ENOMEM);
5656  }
5657  }
5658  if (a < 0) {
5659  av_log(codec, AV_LOG_ERROR,
5660  "Failed to open bitstream filter %s for stream %d with codec %s",
5661  bsfc->filter->name, pkt->stream_index,
5662  codec->codec ? codec->codec->name : "copy");
5663  ret = a;
5664  break;
5665  }
5666  *pkt = new_pkt;
5667 
5668  bsfc = bsfc->next;
5669  }
5670  return ret;
5671 }
5673 #endif
5674 
5676 {
5677  if (!s->oformat)
5678  return AVERROR(EINVAL);
5679 
5680  if (!(s->oformat->flags & AVFMT_NOFILE))
5681  return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5682  return 0;
5683 }
5684 
5686 {
5687  if (*pb)
5688  s->io_close(s, *pb);
5689  *pb = NULL;
5690 }
5691 
5692 int ff_is_http_proto(char *filename) {
5693  const char *proto = avio_find_protocol_name(filename);
5694  return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5695 }
5696 
5697 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5698 {
5699  AVDictionaryEntry *entry;
5700  int64_t parsed_timestamp;
5701  int ret;
5702  if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5703  if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5704  *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5705  return 1;
5706  } else {
5707  av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5708  return ret;
5709  }
5710  }
5711  return 0;
5712 }
5713 
5715 {
5716  int64_t timestamp;
5717  int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5718  if (ret == 1)
5719  return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5720  return ret;
5721 }
5722 
5723 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5724 {
5725  uint8_t *side_data;
5726  int size;
5727 
5729  if (side_data) {
5730  if (size != AVPALETTE_SIZE) {
5731  av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5732  return AVERROR_INVALIDDATA;
5733  }
5734  memcpy(palette, side_data, AVPALETTE_SIZE);
5735  return 1;
5736  }
5737 
5738  if (ret == CONTAINS_PAL) {
5739  int i;
5740  for (i = 0; i < AVPALETTE_COUNT; i++)
5741  palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5742  return 1;
5743  }
5744 
5745  return 0;
5746 }
5747 
5749 {
5750  int ret;
5751  char *str;
5752 
5753  ret = av_bprint_finalize(buf, &str);
5754  if (ret < 0)
5755  return ret;
5756  if (!av_bprint_is_complete(buf)) {
5757  av_free(str);
5758  return AVERROR(ENOMEM);
5759  }
5760 
5761  par->extradata = str;
5762  /* Note: the string is NUL terminated (so extradata can be read as a
5763  * string), but the ending character is not accounted in the size (in
5764  * binary formats you are likely not supposed to mux that character). When
5765  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5766  * zeros. */
5767  par->extradata_size = buf->len;
5768  return 0;
5769 }
5770 
5772  AVStream *ost, const AVStream *ist,
5774 {
5775  //TODO: use [io]st->internal->avctx
5776  const AVCodecContext *dec_ctx = ist->codec;
5777  AVCodecContext *enc_ctx = ost->codec;
5778 
5779  enc_ctx->time_base = ist->time_base;
5780  /*
5781  * Avi is a special case here because it supports variable fps but
5782  * having the fps and timebase differe significantly adds quite some
5783  * overhead
5784  */
5785  if (!strcmp(ofmt->name, "avi")) {
5786 #if FF_API_R_FRAME_RATE
5787  if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5788  && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5789  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5790  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5791  && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5792  || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5793  enc_ctx->time_base.num = ist->r_frame_rate.den;
5794  enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5795  enc_ctx->ticks_per_frame = 2;
5796  } else
5797 #endif
5799  && av_q2d(ist->time_base) < 1.0/500
5800  || copy_tb == AVFMT_TBCF_DECODER) {
5801  enc_ctx->time_base = dec_ctx->time_base;
5802  enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5803  enc_ctx->time_base.den *= 2;
5804  enc_ctx->ticks_per_frame = 2;
5805  }
5806  } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5807  && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5810  && av_q2d(ist->time_base) < 1.0/500
5811  || copy_tb == AVFMT_TBCF_DECODER) {
5812  enc_ctx->time_base = dec_ctx->time_base;
5813  enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5814  }
5815  }
5816 
5817  if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5819  && dec_ctx->time_base.num > 0
5820  && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5821  enc_ctx->time_base = dec_ctx->time_base;
5822  }
5823 
5824  if (ost->avg_frame_rate.num)
5825  enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5826 
5827  av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5828  enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5829 
5830  return 0;
5831 }
5832 
5834 {
5835  // See avformat_transfer_internal_stream_timing_info() TODO.
5836 #if FF_API_LAVF_AVCTX
5838  return st->codec->time_base;
5840 #else
5841  return st->internal->avctx->time_base;
5842 #endif
5843 }
5844 
5846 {
5847  av_assert0(url);
5848  av_freep(&s->url);
5849  s->url = url;
5850 #if FF_API_FORMAT_FILENAME
5852  av_strlcpy(s->filename, url, sizeof(s->filename));
5854 #endif
5855 }
AVStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1094
AVStream::start_skip_samples
int64_t start_skip_samples
If not 0, the number of samples that should be skipped from the start of the stream (the samples are ...
Definition: avformat.h:1141
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:29
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:301
AVStreamInternal::priv_pts
FFFrac * priv_pts
Definition: internal.h:193
AVSubtitle
Definition: avcodec.h:2694
avcodec_close
av_cold int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:1121
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
av_opt_get_dict_val
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1031
AVChapter::id
int id
unique ID to identify the chapter
Definition: avformat.h:1293
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
be
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 be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
AVCodec
AVCodec.
Definition: codec.h:190
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3158
DURATION_MAX_RETRY
#define DURATION_MAX_RETRY
Definition: utils.c:2800
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVFMT_FLAG_DISCARD_CORRUPT
#define AVFMT_FLAG_DISCARD_CORRUPT
Discard frames marked corrupted.
Definition: avformat.h:1475
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:321
ff_data_to_hex
char * ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
Definition: utils.c:4889
SPACE_CHARS
#define SPACE_CHARS
Definition: internal.h:343
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
AVCodecParserContext::convergence_duration
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:3409
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
AVFMT_NO_BYTE_SEEK
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:470
av_format_control_message
int(* av_format_control_message)(struct AVFormatContext *s, int type, void *data, size_t data_size)
Callback used by devices to communicate with application.
Definition: avformat.h:1303
AVCodecParserContext::pts
int64_t pts
Definition: avcodec.h:3372
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:413
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
is_relative
static int is_relative(int64_t ts)
Definition: utils.c:90
AVFMT_DURATION_FROM_BITRATE
@ AVFMT_DURATION_FROM_BITRATE
Duration estimated from bitrate (less accurate)
Definition: avformat.h:1316
AVFMT_FLAG_PRIV_OPT
#define AVFMT_FLAG_PRIV_OPT
Enable use of private options by delaying codec open (this could be made default once all code is con...
Definition: avformat.h:1488
LIBAVFORMAT_VERSION_INT
#define LIBAVFORMAT_VERSION_INT
Definition: version.h:38
ffio_realloc_buf
int ffio_realloc_buf(AVIOContext *s, int buf_size)
Reallocate a given buffer for AVIOContext.
Definition: aviobuf.c:1027
AVOutputFormat::name
const char * name
Definition: avformat.h:491
AVStream::fps_last_dts
int64_t fps_last_dts
Definition: avformat.h:1052
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1296
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4519
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
avpriv_get_raw_pix_fmt_tags
const struct PixelFormatTag * avpriv_get_raw_pix_fmt_tags(void)
Definition: raw.c:299
ff_lock_avformat
int ff_lock_avformat(void)
Definition: utils.c:78
AVCodecContext::audio_service_type
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1251
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
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:1357
ff_rfps_calculate
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:3415
av_codec_get_tag2
int av_codec_get_tag2(const AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)
Definition: utils.c:3227
AVProgram::nb_stream_indexes
unsigned int nb_stream_indexes
Definition: avformat.h:1262
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1619
av_add_stable
int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc)
Add a value to a timestamp.
Definition: mathematics.c:191
ff_mkdir_p
int ff_mkdir_p(const char *path)
Automatically create sub-directories.
Definition: utils.c:4855
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1147
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: internal.h:633
AVCodecParserContext::pict_type
int pict_type
Definition: avcodec.h:3361
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1186
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
ff_is_http_proto
int ff_is_http_proto(char *filename)
Utility function to check if the file uses http or https protocol.
Definition: utils.c:5692
AVStreamInternal::avctx
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:169
ff_ntp_time
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:4705
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
AV_PKT_DATA_PARAM_CHANGE
@ AV_PKT_DATA_PARAM_CHANGE
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:72
AVIOContext::seek_count
int seek_count
seek statistic This field is internal to libavformat and access from outside is not allowed.
Definition: avio.h:285
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
av_opt_ptr
void * av_opt_ptr(const AVClass *class, void *obj, const char *name)
Gets a pointer to the requested field in a struct.
Definition: opt.c:1725
thread.h
AVStream::priv_data
void * priv_data
Definition: avformat.h:880
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:465
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
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:833
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:920
ff_rfps_add_frame
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: utils.c:3355
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: utils.c:4227
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
avcodec_parameters_from_context
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: utils.c:2082
av_bitstream_filter_filter
attribute_deprecated int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe)
Definition: bitstream_filter.c:97
AV_PKT_FLAG_DISCARD
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:395
AVFormatContext::protocol_blacklist
char * protocol_blacklist
',' separated list of disallowed protocols.
Definition: avformat.h:1930
AVFMT_TBCF_DECODER
@ AVFMT_TBCF_DECODER
Definition: avformat.h:3059
AVCodecParserContext::duration
int duration
Duration of the current frame.
Definition: avcodec.h:3475
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1224
av_stream_get_parser
struct AVCodecParserContext * av_stream_get_parser(const AVStream *st)
Definition: utils.c:144
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1832
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVCodecTag::id
enum AVCodecID id
Definition: internal.h:43
AVBitStreamFilter::name
const char * name
Definition: bsf.h:99
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:2201
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:111
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
ff_find_last_ts
int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: utils.c:2245
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:62
AVPacketList::next
struct AVPacketList * next
Definition: avformat.h:2010
av_unused
#define av_unused
Definition: attributes.h:131
av_isspace
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.h:222
AVStream::probe_data
AVProbeData probe_data
Definition: avformat.h:1090
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:810
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:144
id3v2.h
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVFMT_TBCF_AUTO
@ AVFMT_TBCF_AUTO
Definition: avformat.h:3058
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1403
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
AVPacketSideData
Definition: packet.h:298
ff_read_frame_flush
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: utils.c:1924
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:209
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:978
internal.h
AVStream::dts_misordered
uint8_t dts_misordered
Definition: avformat.h:1202
AVPacket::data
uint8_t * data
Definition: packet.h:355
AV_CODEC_ID_DVB_TELETEXT
@ AV_CODEC_ID_DVB_TELETEXT
Definition: codec_id.h:515
av_get_frame_filename2
int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
Return in 'buf' the path with 'd' replaced by a number.
Definition: utils.c:4732
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1220
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:46
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:938
AVChapter::start
int64_t start
Definition: avformat.h:1295
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1474
data
const char data[16]
Definition: mxf.c:91
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:315
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:1722
AVStream::cur_dts
int64_t cur_dts
Definition: avformat.h:1068
AVSEEK_FLAG_BYTE
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2497
compute_pkt_fields
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt, int64_t next_dts, int64_t next_pts)
Definition: utils.c:1232
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2014
AVBitStreamFilterContext::filter
const struct AVBitStreamFilter * filter
Definition: avcodec.h:3977
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:412
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
LICENSE_PREFIX
#define LICENSE_PREFIX
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
LIBAVFORMAT_VERSION_MICRO
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:36
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1515
AVINDEX_DISCARD_FRAME
#define AVINDEX_DISCARD_FRAME
Definition: avformat.h:804
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:373
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
mathematics.h
AVDictionary
Definition: dict.c:30
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
ff_network_close
void ff_network_close(void)
Definition: network.c:116
AVFormatContext::probesize
int64_t probesize
Maximum size of the data read from input for determining the input container format.
Definition: avformat.h:1501
AVStream::skip_to_keyframe
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: avformat.h:1127
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
Definition: packet.h:411
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1773
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1917
RELATIVE_TS_BASE
#define RELATIVE_TS_BASE
Definition: utils.c:88
AVStreamInternal::bsfc
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:159
AVFMT_NOBINSEARCH
#define AVFMT_NOBINSEARCH
Format does not allow to fall back on binary search via read_timestamp.
Definition: avformat.h:468
AVFormatInternal::packet_buffer
struct AVPacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:76
AV_CODEC_ID_HDMV_PGS_SUBTITLE
@ AV_CODEC_ID_HDMV_PGS_SUBTITLE
Definition: codec_id.h:514
compute_chapters_end
static void compute_chapters_end(AVFormatContext *s)
Definition: utils.c:3255
ff_id3v2_parse_chapters
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1170
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1788
av_get_frame_filename
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:4787
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
ost
static AVStream * ost
Definition: vaapi_transcode.c:45
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:454
extract_extradata_init
static int extract_extradata_init(AVStream *st)
Definition: utils.c:3499
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
sample_rate
sample_rate
Definition: ffmpeg_filter.c:192
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:64
AVBSFContext
The bitstream filter state.
Definition: bsf.h:49
FFMPEG_CONFIGURATION
#define FFMPEG_CONFIGURATION
Definition: config.h:4
AVIndexEntry
Definition: avformat.h:795
ff_network_init
int ff_network_init(void)
Definition: network.c:58
ff_tls_init
int ff_tls_init(void)
Definition: network.c:31
AVOutputFormat::subtitle_codec
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:503
av_demuxer_open
int av_demuxer_open(AVFormatContext *ic)
Definition: utils.c:389
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
update_wrap_reference
static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
Definition: utils.c:759
ff_const59
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning.
Definition: avformat.h:535
AVStream::last_dts
int64_t last_dts
Definition: avformat.h:1029
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:803
avcodec_pix_fmt_to_codec_tag
unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt)
Return a value representing the fourCC code associated to the pixel format pix_fmt,...
Definition: raw.c:304
ff_free_stream
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:4440
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:83
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
genpts
static int genpts
Definition: ffplay.c:335
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:321
AV_CODEC_ID_PCM_S64LE
@ AV_CODEC_ID_PCM_S64LE
Definition: codec_id.h:333
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:285
ff_format_io_close
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5685
ff_mutex_unlock
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:169
avformat_queue_attached_pictures
int avformat_queue_attached_pictures(AVFormatContext *s)
Definition: utils.c:475
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2069
framerate
int framerate
Definition: h264_levels.c:65
avformat_close_input
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
Definition: utils.c:4491
ff_stream_encode_params_copy
int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
Copy encoding parameters from source to destination stream.
Definition: utils.c:4330
AVCodecParserContext::offset
int64_t offset
byte offset from starting packet start
Definition: avcodec.h:3393
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1613
avcodec_find_decoder_by_name
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:947
AVStream::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: avformat.h:1172
AVCodecParserContext::key_frame
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:3402
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:330
finish
static void finish(void)
Definition: movenc.c:345
AVFormatContext::iformat
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1347
av_stream_get_end_pts
int64_t av_stream_get_end_pts(const AVStream *st)
Returns the pts of the last muxed packet + its duration.
Definition: utils.c:136
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:535
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:302
add_coded_side_data
static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
Definition: utils.c:3600
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2004
fail
#define fail()
Definition: checkasm.h:123
AVSEEK_FLAG_ANY
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2498
find_decoder
static const AVCodec * find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:179
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:103
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:2045
AVSTREAM_PARSE_FULL_ONCE
@ AVSTREAM_PARSE_FULL_ONCE
full parsing and repack of the first frame only, only implemented for H.264 currently
Definition: avformat.h:789
MAKE_ACCESSORS
#define MAKE_ACCESSORS(str, name, type, field)
Definition: internal.h:91
AVFormatInternal::prefer_codec_framerate
int prefer_codec_framerate
Definition: internal.h:144
avformat_version
unsigned avformat_version(void)
Return the LIBAVFORMAT_VERSION_INT constant.
Definition: utils.c:61
ff_configure_buffers_for_index
void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
Definition: utils.c:2097
AVStream::codec_info_duration
int64_t codec_info_duration
Definition: avformat.h:1034
free_stream
static void free_stream(AVStream **pst)
Definition: utils.c:4391
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
AVDISCARD_NONE
@ AVDISCARD_NONE
discard nothing
Definition: avcodec.h:230
select_from_pts_buffer
static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts)
Definition: utils.c:1052
AVChapter
Definition: avformat.h:1292
AVFormatInternal::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:80
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:463
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AVFMT_DURATION_FROM_PTS
@ AVFMT_DURATION_FROM_PTS
Duration accurately estimated from PTSes.
Definition: avformat.h:1314
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
dynarray_add
#define dynarray_add(tab, nb_ptr, elem)
Definition: internal.h:197
AVPROBE_PADDING_SIZE
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:455
av_parser_init
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
pts
static int64_t pts
Definition: transcode_aac.c:647
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:714
AVBitStreamFilterContext::next
struct AVBitStreamFilterContext * next
Definition: avcodec.h:3979
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
av_new_program
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: utils.c:4618
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:411
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:914
AV_PTS_WRAP_IGNORE
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:854
ff_check_interrupt
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:663
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
AVCodecParserContext::dts
int64_t dts
Definition: avcodec.h:3373
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_get_packet_palette
int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
Retrieves the palette from a packet, either from side data, or appended to the video data in the pack...
Definition: utils.c:5723
avformat_network_init
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:5049
try_decode_frame
static int try_decode_frame(AVFormatContext *s, AVStream *st, const AVPacket *avpkt, AVDictionary **options)
Definition: utils.c:3048
AVStream::attached_pic
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:947
AVStream::last_IP_duration
int last_IP_duration
Definition: avformat.h:1070
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1102
raw.h
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:509
a1
#define a1
Definition: regdef.h:47
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1457
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:825
AVFormatContext::max_ts_probe
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1657
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:305
avassert.h
AVFormatContext::format_whitelist
char * format_whitelist
',' separated list of allowed demuxers.
Definition: avformat.h:1782
av_codec_get_tag
unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
Definition: utils.c:3219
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: utils.c:5112
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
ff_update_cur_dts
void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: utils.c:1959
AVStream::pts_wrap_behavior
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: avformat.h:1184
ff_packet_list_get
int ff_packet_list_get(AVPacketList **pkt_buffer, AVPacketList **pkt_buffer_end, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: utils.c:1553
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:98
AVInputFormat
Definition: avformat.h:636
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:389
ff_add_param_change
int ff_add_param_change(AVPacket *pkt, int32_t channels, uint64_t channel_layout, int32_t sample_rate, int32_t width, int32_t height)
Add side data to a packet for changing parameters to the given values.
Definition: utils.c:5070
RAW_PACKET_BUFFER_SIZE
#define RAW_PACKET_BUFFER_SIZE
Remaining size available for raw_packet_buffer, in bytes.
Definition: internal.h:98
AVCodecTag
Definition: internal.h:42
ID3v2ExtraMeta
Definition: id3v2.h:84
AVFormatContext::ctx_flags
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1384
AVOutputFormat::data_codec
enum AVCodecID data_codec
default data codec
Definition: avformat.h:601
AVStream::first_dts
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: avformat.h:1067
avpriv_find_pix_fmt
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:467
AVProgram::id
int id
Definition: avformat.h:1258
duration
int64_t duration
Definition: movenc.c:63
av_stream_new_side_data
uint8_t * av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type, int size)
Allocate new information from stream.
Definition: utils.c:5551
AVMutex
#define AVMutex
Definition: thread.h:164
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1655
avformat_query_codec
int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
Test if the given container can store a codec.
Definition: utils.c:5031
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:816
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:413
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:157
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:478
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1295
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
AVStream::duration_count
int duration_count
Definition: avformat.h:1031
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVStream::codec_info_duration_fields
int64_t codec_info_duration_fields
Definition: avformat.h:1035
av_seek_frame
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: utils.c:2520
ff_packet_list_free
void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
Wipe the list and unref all the packets in it.
Definition: utils.c:1423
height
static int height
Definition: utils.c:158
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1466
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:136
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1514
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:641
av_append_packet
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
Read data and append it to the current content of the AVPacket.
Definition: utils.c:314
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
Definition: avcodec.h:242
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
frame_size
int frame_size
Definition: mxfenc.c:2139
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:658
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:410
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AVIndexEntry::size
int size
Definition: avformat.h:806
AVStream::duration_error
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: avformat.h:1033
ts_to_samples
static int64_t ts_to_samples(AVStream *st, int64_t ts)
Definition: utils.c:1568
AVOpenCallback
int(* AVOpenCallback)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Definition: avformat.h:1306
av_opt_set_dict_val
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:725
av_buffer_default_free
void av_buffer_default_free(void *opaque, uint8_t *data)
Default free callback, which calls av_free() on the buffer data.
Definition: buffer.c:62
avpriv_h264_has_num_reorder_frames
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264dec.c:61
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:649
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2064
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:797
AVOutputFormat::audio_codec
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:501
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVCodecDescriptor::type
enum AVMediaType type
Definition: codec_desc.h:40
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
ff_find_stream_index
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:5022
av_read_play
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
Definition: utils.c:4312
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AVPacketSideData::data
uint8_t * data
Definition: packet.h:299
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:1083
channels
channels
Definition: aptx.h:33
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:89
AVStream::parser
struct AVCodecParserContext * parser
Definition: avformat.h:1084
avformat_flush
int avformat_flush(AVFormatContext *s)
Discard all internally buffered data.
Definition: utils.c:2600
nb_streams
static int nb_streams
Definition: ffprobe.c: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:237
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:304
AVOutputFormat::codec_tag
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:516
AVIndexEntry::min_distance
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
Definition: avformat.h:807
AV_CODEC_ID_CODEC2
@ AV_CODEC_ID_CODEC2
Definition: codec_id.h:477
AVStreamInternal::pkt
AVPacket * pkt
Definition: internal.h:182
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AVProgram::start_time
int64_t start_time
Definition: avformat.h:1277
key
const char * key
Definition: hwcontext_opencl.c:168
ff_read_timestamp
static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: utils.c:2168
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
ff_hex_to_data
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:4910
AVStream::first_discard_sample
int64_t first_discard_sample
If not 0, the first audio sample that should be discarded from the stream.
Definition: avformat.h:1149
AVStream::last_duration
int64_t last_duration
Definition: avformat.h:1045
AVStreamInternal::avctx_inited
int avctx_inited
1 if avctx has been initialized with the values from the codec parameters
Definition: internal.h:173
AVFMT_NEEDNUMBER
#define AVFMT_NEEDNUMBER
Needs 'd' in filename.
Definition: avformat.h:459
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:536
int32_t
int32_t
Definition: audio_convert.c:194
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
match_stream_specifier
static int match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec, const char **indexptr, AVProgram **p)
Matches a stream specifier (but ignores requested index).
Definition: utils.c:5165
AVFormatContext::max_analyze_duration
int64_t max_analyze_duration
Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().
Definition: avformat.h:1509
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
AVFMT_FLAG_NOPARSE
#define AVFMT_FLAG_NOPARSE
Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no...
Definition: avformat.h:1472
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
parse_packet
static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index, int flush)
Parse a packet, add all split parts to parse_queue.
Definition: utils.c:1443
AVCodecParserContext::repeat_pict
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:3371
ch
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
AVStream::update_initial_durations_done
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: avformat.h:1189
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
opts
AVDictionary * opts
Definition: movenc.c:50
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:338
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
ff_format_output_open
int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
Utility function to open IO stream of output format.
Definition: utils.c:5675
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2496
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
extract_extradata
static int extract_extradata(AVStream *st, const AVPacket *pkt)
Definition: utils.c:3543
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:894
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
NULL
#define NULL
Definition: coverity.c:32
av_match_list
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:449
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1284
AV_CODEC_ID_PCM_U24BE
@ AV_CODEC_ID_PCM_U24BE
Definition: codec_id.h:316
ff_index_search_timestamp
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition: utils.c:2054
duration_estimate_name
static const char * duration_estimate_name(enum AVDurationEstimationMethod method)
Definition: utils.c:2942
AVFormatContext::fps_probe_size
int fps_probe_size
The number of frames used for determining the framerate in avformat_find_stream_info().
Definition: avformat.h:1595
estimate_timings_from_pts
static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
Definition: utils.c:2803
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:172
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVFMT_DURATION_FROM_STREAM
@ AVFMT_DURATION_FROM_STREAM
Duration estimated from a stream with a known duration.
Definition: avformat.h:1315
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:312
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:2202
AVFormatContext::protocol_whitelist
char * protocol_whitelist
',' separated list of allowed protocols.
Definition: avformat.h:1895
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:301
AV_DISPOSITION_COMMENT
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:813
av_stream_add_side_data
int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as stream side data.
Definition: utils.c:5515
av_opt_set_from_string
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1558
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AVSTREAM_PARSE_NONE
@ AVSTREAM_PARSE_NONE
Definition: avformat.h:785
seek_frame_internal
static int seek_frame_internal(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c:2476
AVIndexEntry::flags
int flags
Definition: avformat.h:805
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
ff_id3v2_parse_apic
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header.
Definition: id3v2.c:1130
AVCodecContext::subtitle_header_size
int subtitle_header_size
Definition: avcodec.h:2015
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1377
src
#define src
Definition: vp8dsp.c:254
AVERROR_BSF_NOT_FOUND
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:49
AV_CODEC_ID_PCM_S64BE
@ AV_CODEC_ID_PCM_S64BE
Definition: codec_id.h:334
parseutils.h
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:1313
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1261
AVBitStreamFilter::priv_class
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions.
Definition: bsf.h:117
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:929
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
has_duration
static int has_duration(AVFormatContext *ic)
Return TRUE if the stream has accurate duration in any stream.
Definition: utils.c:2613
avio_pause
int avio_pause(AVIOContext *h, int pause)
Pause and resume playing - only meaningful if using a network streaming protocol (e....
Definition: aviobuf.c:1202
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1610
ff_parse_key_value
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf, void *context)
Parse a string with comma-separated key=value pairs.
Definition: utils.c:4968
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:548
AVCodecParserContext::flags
int flags
Definition: avcodec.h:3386
time.h
ff_get_formatted_ntp_time
uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
Get the NTP time stamp formatted as per the RFC-5905.
Definition: utils.c:4710
AVFormatContext::skip_estimate_duration_from_pts
int skip_estimate_duration_from_pts
Skip duration calcuation in estimate_timings_from_pts.
Definition: avformat.h:1944
AVStream::pts_reorder_error
int64_t pts_reorder_error[MAX_REORDER_DELAY+1]
Internal data to generate dts from pts.
Definition: avformat.h:1194
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: avpacket.c:614
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:663
force_codec_ids
static void force_codec_ids(AVFormatContext *s, AVStream *st)
Definition: utils.c:687
AVStream::duration_gcd
int64_t duration_gcd
Definition: avformat.h:1030
index
int index
Definition: gxfenc.c:89
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
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
ff_get_extradata
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c:3339
AV_CODEC_ID_CDGRAPHICS
@ AV_CODEC_ID_CDGRAPHICS
Definition: codec_id.h:181
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2043
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:916
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:450
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AV_AUDIO_SERVICE_TYPE_KARAOKE
@ AV_AUDIO_SERVICE_TYPE_KARAOKE
Definition: avcodec.h:248
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1391
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:102
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:412
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:510
AVFMT_FLAG_NOFILLIN
#define AVFMT_FLAG_NOFILLIN
Do not infer any values from other values, just return what is stored in the container.
Definition: avformat.h:1471
av_strncasecmp
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:223
set_codec_from_probe_data
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
Definition: utils.c:328
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:649
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:99
has_codec_parameters
static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
Definition: utils.c:3000
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1765
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1552
options
const OptionDef options[]
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3615
ff_standardize_creation_time
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5714
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
tb_unreliable
static int tb_unreliable(AVCodecContext *c)
Definition: utils.c:3306
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:313
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:76
AVMediaType
AVMediaType
Definition: avutil.h:199
AVCodecParserContext::frame_offset
int64_t frame_offset
Definition: avcodec.h:3356
AV_PTS_WRAP_SUB_OFFSET
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:856
AVPacket::size
int size
Definition: packet.h:356
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: utils.c:5319
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:332
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
seek_frame_byte
static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags)
Definition: utils.c:2389
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
AVStream::nb_index_entries
int nb_index_entries
Definition: avformat.h:1096
FFFrac::val
int64_t val
Definition: internal.h:60
av_stream_get_side_data
uint8_t * av_stream_get_side_data(const AVStream *st, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5498
AVProgram::end_time
int64_t end_time
Definition: avformat.h:1278
AVStreamInternal::inited
int inited
Definition: internal.h:183
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:159
start_time
static int64_t start_time
Definition: ffplay.c:332
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
bps
unsigned bps
Definition: movenc.c:1533
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:414
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
ffversion.h
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
sample
#define sample
Definition: flacdsp_template.c:44
AV_MUTEX_INITIALIZER
#define AV_MUTEX_INITIALIZER
Definition: thread.h:165
ff_get_pcm_codec_id
enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
Select a PCM codec based on the given parameters.
Definition: utils.c:3170
AVStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: avformat.h:1075
size
int size
Definition: twinvq_data.h:11134
avpriv_codec_get_cap_skip_frame_fill_param
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:496
AVStream::pts_buffer
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: avformat.h:1092
ID3v2_DEFAULT_MAGIC
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
copy_tb
int copy_tb
Definition: ffmpeg_opt.c:162
avformat_seek_file
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: utils.c:2543
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
NTP_OFFSET_US
#define NTP_OFFSET_US
Definition: internal.h:244
duration_name
static const char * duration_name[]
Definition: utils.c:2936
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: utils.c:5135
av_stream_get_codec_timebase
AVRational av_stream_get_codec_timebase(const AVStream *st)
Get the internal codec timebase from a stream.
Definition: utils.c:5833
AV_PTS_WRAP_ADD_OFFSET
#define AV_PTS_WRAP_ADD_OFFSET
add the format specific offset on wrap detection
Definition: avformat.h:855
ff_is_intra_only
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:1014
determinable_frame_size
static int determinable_frame_size(AVCodecContext *avctx)
Definition: utils.c:935
ffio_limit
int ffio_limit(AVIOContext *s, int size)
Definition: utils.c:243
AVFMT_FLAG_IGNDTS
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1470
av_probe_input_buffer2
int av_probe_input_buffer2(AVIOContext *pb, ff_const59 AVInputFormat **fmt, const char *url, void *logctx, unsigned int offset, unsigned int max_probe_size)
Probe a bytestream to determine the input format.
Definition: format.c:222
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
AVTimebaseSource
AVTimebaseSource
Definition: avformat.h:3057
FF_PACKETLIST_FLAG_REF_PACKET
#define FF_PACKETLIST_FLAG_REF_PACKET
Create a new reference for the packet instead of transferring the ownership of the existing one to th...
Definition: internal.h:733
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:273
AVOption::name
const char * name
Definition: opt.h:247
AVStream::dts_ordered
uint8_t dts_ordered
Definition: avformat.h:1201
ff_unlock_avformat
int ff_unlock_avformat(void)
Definition: utils.c:83
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:927
ff_stream_add_bitstream_filter
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5569
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:823
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:558
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:354
av_isdigit
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.h:206
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
AVPacketSideData::size
int size
Definition: packet.h:300
AV_CODEC_ID_RV30
@ AV_CODEC_ID_RV30
Definition: codec_id.h:117
av_format_inject_global_side_data
void av_format_inject_global_side_data(AVFormatContext *s)
This function will cause global side data to be injected in the next packet of each stream as well as...
Definition: utils.c:149
offset
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 offset
Definition: writing_filters.txt:86
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:40
update_dts_from_pts
static void update_dts_from_pts(AVFormatContext *s, int stream_index, AVPacketList *pkt_buffer)
Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts of the packets in a wind...
Definition: utils.c:1098
AVStream::fps_last_dts_idx
int fps_last_dts_idx
Definition: avformat.h:1053
ff_mutex_lock
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:168
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:671
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
AVStreamInternal::extract_extradata
struct AVStreamInternal::@256 extract_extradata
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:53
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:203
bitrate
int64_t bitrate
Definition: h264_levels.c:131
avpriv_new_chapter
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4647
a0
#define a0
Definition: regdef.h:46
flush_packet_queue
static void flush_packet_queue(AVFormatContext *s)
Definition: utils.c:1872
av_log2
#define av_log2
Definition: intmath.h:83
AV_FRAME_FILENAME_FLAGS_MULTIPLE
#define AV_FRAME_FILENAME_FLAGS_MULTIPLE
Allow multiple d.
Definition: avformat.h:2890
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
AVStream::side_data
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:967
AVCodec::id
enum AVCodecID id
Definition: codec.h:204
SANE_CHUNK_SIZE
#define SANE_CHUNK_SIZE
Definition: utils.c:241
AV_CODEC_ID_GIF
@ AV_CODEC_ID_GIF
Definition: codec_id.h:146
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1184
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1750
AVStream::pts_reorder_error_count
uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1]
Definition: avformat.h:1195
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:586
avio_closep
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: aviobuf.c:1170
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AVIOContext::bytes_read
int64_t bytes_read
Bytes read statistic This field is internal to libavformat and access from outside is not allowed.
Definition: avio.h:279
AVFMT_FLAG_NOBUFFER
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1473
AV_CODEC_ID_RV40
@ AV_CODEC_ID_RV40
Definition: codec_id.h:118
update_initial_timestamps
static void update_initial_timestamps(AVFormatContext *s, int stream_index, int64_t dts, int64_t pts, AVPacket *pkt)
Definition: utils.c:1124
AVCodecParserContext::pos
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:3463
AVStreamInternal
Definition: internal.h:147
fill_all_stream_timings
static void fill_all_stream_timings(AVFormatContext *ic)
Definition: utils.c:2727
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:3387
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:223
AVOutputFormat
Definition: avformat.h:490
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
avio_internal.h
update_stream_timings
static void update_stream_timings(AVFormatContext *ic)
Estimate the stream timings from the one of each components.
Definition: utils.c:2633
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2191
width
static int width
Definition: utils.c:158
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *filename, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:533
AVStream::nb_decoded_frames
int nb_decoded_frames
Number of internally decoded frames, used internally in libavformat, do not access its lifetime diffe...
Definition: avformat.h:1162
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
ff_read_packet
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:825
AVStream::last_dts_for_order_check
int64_t last_dts_for_order_check
Internal data to analyze DTS and detect faulty mpeg streams.
Definition: avformat.h:1200
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:127
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2139
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
Definition: avcodec.h:243
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
ff_id3v2_read_dict
void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
Definition: id3v2.c:1102
AV_AUDIO_SERVICE_TYPE_EFFECTS
@ AV_AUDIO_SERVICE_TYPE_EFFECTS
Definition: avcodec.h:241
update_stream_avctx
static int update_stream_avctx(AVFormatContext *s)
Definition: utils.c:498
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVFormatContext::codec_whitelist
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avformat.h:1774
ff_add_index_entry
int ff_add_index_entry(AVIndexEntry **index_entries, int *nb_index_entries, unsigned int *index_entries_allocated_size, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Internal version of av_add_index_entry.
Definition: utils.c:1986
avformat_mutex
static AVMutex avformat_mutex
Definition: utils.c:54
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:82
AV_CODEC_ID_PCM_F64BE
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:323
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
AV_DISPOSITION_KARAOKE
#define AV_DISPOSITION_KARAOKE
Definition: avformat.h:815
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:231
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
av_url_split
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:4792
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:310
url.h
uint8_t
uint8_t
Definition: audio_convert.c:194
av_find_default_stream_index
int av_find_default_stream_index(AVFormatContext *s)
Definition: utils.c:1886
AVPROBE_SCORE_RETRY
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:448
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1756
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1257
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:156
av_read_pause
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
Definition: utils.c:4321
len
int len
Definition: vorbis_enc_data.h:452
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:137
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:304
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
av_opt_next
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
update_initial_durations
static void update_initial_durations(AVFormatContext *s, AVStream *st, int stream_index, int64_t duration)
Definition: utils.c:1176
init_input
static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
Definition: utils.c:410
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:832
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
AVCodecParserContext
Definition: avcodec.h:3353
AVStream::skip_samples
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet.
Definition: avformat.h:1132
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:70
ff_tls_deinit
void ff_tls_deinit(void)
Definition: network.c:46
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
AVStream::disposition
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:918
AVFMT_FLAG_GENPTS
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1467
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:824
ff_reduce_index
void ff_reduce_index(AVFormatContext *s, int stream_index)
Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...
Definition: utils.c:1973
tag
uint32_t tag
Definition: movenc.c:1532
av_compare_mod
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
Compare the remainders of two integer operands divided by a common divisor.
Definition: mathematics.c:160
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:872
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:865
AVPacketList::pkt
AVPacket pkt
Definition: avformat.h:2009
pixfmt.h
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
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
MAX_STD_TIMEBASES
#define MAX_STD_TIMEBASES
Definition: avformat.h:1024
FAIL
#define FAIL(errmsg)
avcodec_find_decoder
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:919
AVStream::nb_side_data
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:971
ff_bprint_to_codecpar_extradata
int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:5748
lowercase
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in lowercase
Definition: writing_filters.txt:89
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:787
pos
unsigned int pos
Definition: spdifenc.c:410
avformat.h
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:366
network.h
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
get_std_framerate
static int get_std_framerate(int i)
Definition: utils.c:3282
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:197
AV_AUDIO_SERVICE_TYPE_COMMENTARY
@ AV_AUDIO_SERVICE_TYPE_COMMENTARY
Definition: avcodec.h:245
estimate_timings_from_bit_rate
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
Definition: utils.c:2746
AVStream::inject_global_side_data
int inject_global_side_data
Internal data to inject global side data.
Definition: avformat.h:1207
avformat_network_deinit
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:5061
av_program_add_stream_index
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: utils.c:4677
ff_gen_search
int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Perform a binary search using read_timestamp().
Definition: utils.c:2283
wrap_timestamp
static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
Wrap a given time stamp, if there is an indication for an overflow.
Definition: utils.c:101
AVCodecContext
main external API structure.
Definition: avcodec.h:526
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:866
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: utils.c:5771
AVStream::found_decoder
int found_decoder
0 -> decoder has not been searched for yet.
Definition: avformat.h:1043
AVStream::info
struct AVStream::@240 * info
Stream information used internally by avformat_find_stream_info()
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
Definition: packet.h:410
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AV_RL32
#define AV_RL32
Definition: intreadwrite.h:146
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
AVBitStreamFilter
Definition: bsf.h:98
AVERROR_STREAM_NOT_FOUND
#define AVERROR_STREAM_NOT_FOUND
Stream not found.
Definition: error.h:65
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:655
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
AVRational::den
int den
Denominator.
Definition: rational.h:60
ff_seek_frame_binary
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Perform a binary search using av_index_search_timestamp() and AVInputFormat.read_timestamp().
Definition: utils.c:2177
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
config.h
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:350
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4448
AVFMT_NOGENSEARCH
#define AVFMT_NOGENSEARCH
Format does not allow to fall back on generic search.
Definition: avformat.h:469
AVStream::display_aspect_ratio
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: avformat.h:1214
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
ff_parse_key_val_cb
void(* ff_parse_key_val_cb)(void *context, const char *key, int key_len, char **dest, int *dest_len)
Callback function type for ff_parse_key_value.
Definition: internal.h:355
ff_compute_frame_duration
void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt)
Return the frame duration in seconds.
Definition: utils.c:951
av_format_ffversion
const char av_format_ffversion[]
Definition: utils.c:52
estimate_timings
static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
Definition: utils.c:2947
PARSER_FLAG_USE_CODEC_TS
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:3391
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:311
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVOutputFormat::video_codec
enum AVCodecID video_codec
default video codec
Definition: avformat.h:502
temp
else temp
Definition: vf_mcdeint.c:256
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:989
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4938
FFMPEG_VERSION
#define FFMPEG_VERSION
Definition: ffversion.h:4
has_decode_delay_been_guessed
static int has_decode_delay_been_guessed(AVStream *st)
Definition: utils.c:1025
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:796
get_next_pkt
static AVPacketList * get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
Definition: utils.c:1043
av_get_audio_frame_duration2
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:1765
AVSTREAM_PARSE_FULL_RAW
@ AVSTREAM_PARSE_FULL_RAW
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:790
AVStream::rfps_duration_sum
int64_t rfps_duration_sum
Definition: avformat.h:1032
AVStream::frame_delay_evidence
int frame_delay_evidence
Definition: avformat.h:1036
AVStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1122
av_probe_input_format2
ff_const59 AVInputFormat * av_probe_input_format2(ff_const59 AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:205
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1450
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVPacket::stream_index
int stream_index
Definition: packet.h:357
AVPROBE_SCORE_STREAM_RETRY
#define AVPROBE_SCORE_STREAM_RETRY
Definition: avformat.h:449
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
DURATION_MAX_READ_SIZE
#define DURATION_MAX_READ_SIZE
Definition: utils.c:2799
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
ff_format_set_url
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: utils.c:5845
avformat_license
const char * avformat_license(void)
Return the libavformat license.
Definition: utils.c:72
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
shift
static int shift(int a, int b)
Definition: sonic.c:82
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
AVBSFContext::filter
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:58
AVERROR_DECODER_NOT_FOUND
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:52
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:534
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_parser_parse2
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:120
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:309
AVStreamInternal::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:189
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3148
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:306
MAX_REORDER_DELAY
@ MAX_REORDER_DELAY
Definition: vaapi_encode.h:44
seek_frame_generic
static int seek_frame_generic(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c:2409
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
llrint
#define llrint(x)
Definition: libm.h:394
AVCodecParameters::format
int format
Definition: codec_par.h:84
AVStreamInternal::orig_codec_id
enum AVCodecID orig_codec_id
Definition: internal.h:175
avformat_configuration
const char * avformat_configuration(void)
Return the libavformat build-time configuration.
Definition: utils.c:67
AVStream::fps_first_dts_idx
int fps_first_dts_idx
Definition: avformat.h:1051
probe_codec
static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: utils.c:709
read_frame_internal
static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
Definition: utils.c:1573
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:324
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:81
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:551
FF_MAX_EXTRADATA_SIZE
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:223
AV_ROUND_PASS_MINMAX
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:108
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVStreamInternal::bsf
AVBSFContext * bsf
Definition: internal.h:181
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: utils.c:2053
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
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:217
find_probe_decoder
static const AVCodec * find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:203
ff_id3v2_free_extra_meta
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1114
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:375
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
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:40
avio_find_protocol_name
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:472
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
extract_extradata_check
static int extract_extradata_check(AVStream *st)
Definition: utils.c:3481
bytestream.h
convert_header.str
string str
Definition: convert_header.py:20
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:234
AVFormatInternal::packet_buffer_end
struct AVPacketList * packet_buffer_end
Definition: internal.h:77
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:303
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:564
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:322
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
AVInputFormat::read_timestamp
int64_t(* read_timestamp)(struct AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)
Get the next timestamp in stream[stream_index].time_base units.
Definition: avformat.h:739
CONTAINS_PAL
#define CONTAINS_PAL
Definition: internal.h:679
ff_id3v2_parse_priv
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1261
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FFMPEG_LICENSE
#define FFMPEG_LICENSE
Definition: config.h:5
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1440
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:459
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:132
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ff_parse_creation_time_metadata
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails.
Definition: utils.c:5697
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
ff_packet_list_put
int ff_packet_list_put(AVPacketList **packet_buffer, AVPacketList **plast_pktl, AVPacket *pkt, int flags)
Append an AVPacket to the list.
Definition: utils.c:441
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
AVBitStreamFilterContext
Definition: avcodec.h:3975
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3394
AVDictionaryEntry::value
char * value
Definition: dict.h:83
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:904
PARSER_FLAG_ONCE
#define PARSER_FLAG_ONCE
Definition: avcodec.h:3388
AV_CODEC_ID_APTX
@ AV_CODEC_ID_APTX
Definition: codec_id.h:496
avstring.h
AVSTREAM_PARSE_TIMESTAMPS
@ AVSTREAM_PARSE_TIMESTAMPS
full parsing and interpolation of timestamps for frames not starting on a packet boundary
Definition: avformat.h:788
av_codec_get_id
enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
Definition: utils.c:3244
AVOutputFormat::query_codec
int(* query_codec)(enum AVCodecID id, int std_compliance)
Test if the given codec can be stored in this container.
Definition: avformat.h:566
AVDiscard
AVDiscard
Definition: avcodec.h:227
av_strndup
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
Definition: mem.c:265
AVStream::pts_wrap_bits
int pts_wrap_bits
number of bits in pts (used for wrapping control)
Definition: avformat.h:1057
AVInputFormat::read_header
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: avformat.h:706
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1294
AVCodecTag::tag
unsigned int tag
Definition: internal.h:44
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
AVStream::codec_info_nb_frames
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: avformat.h:1080
snprintf
#define snprintf
Definition: snprintf.h:34
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:452
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1363
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:3321
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:314
avpriv_dict_set_timestamp
int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
Definition: dict.c:258
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
av_probe_input_format3
ff_const59 AVInputFormat * av_probe_input_format3(ff_const59 AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:128
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:91
AVStream::index_entries_allocated_size
unsigned int index_entries_allocated_size
Definition: avformat.h:1097
AVFMT_EVENT_FLAG_METADATA_UPDATED
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
The call resulted in updated metadata.
Definition: avformat.h:1651
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:666
AVStream::fps_first_dts
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: avformat.h:1050
dec_ctx
static AVCodecContext * dec_ctx
Definition: filtering_audio.c:43
FF_API_LAVF_AVCTX
#define FF_API_LAVF_AVCTX
Definition: version.h:65
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:367
av_parser_close
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:224
AVPacketList
Definition: avformat.h:2008
ff_generate_avci_extradata
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5363
av_init_packet
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2162
av_find_best_stream
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:4244
append_packet_chunked
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
Definition: utils.c:265
AVStream::last_IP_pts
int64_t last_IP_pts
Definition: avformat.h:1069