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;
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);
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 
200  return avcodec_find_decoder(codec_id);
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 &&
223  av_codec_is_decoder(probe_codec) &&
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)
297  pkt->flags |= AV_PKT_FLAG_CORRUPT;
298 
299  if (!pkt->size)
300  av_packet_unref(pkt);
301  return pkt->size > orig_size ? pkt->size - orig_size : ret;
302 }
303 
305 {
306  av_init_packet(pkt);
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[] = {
337  { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
338  { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
339  { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
341  { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
342  { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
344  { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
345  { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
346  { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
347  { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
348  { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
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;
358  av_log(s, AV_LOG_DEBUG,
359  "Probe with size=%d, packets=%d detected %s with score=%d\n",
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) {
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 
451  if (flags & FF_PACKETLIST_FLAG_REF_PACKET) {
452  if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
453  av_free(pktl);
454  return ret;
455  }
456  } else {
457  ret = av_packet_make_refcounted(pkt);
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++)
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 
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
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) {
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) {
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 
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 
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;
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");
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 
652  if ((ret = avformat_queue_attached_pictures(s)) < 0)
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 
659 
661 
662  for (i = 0; i < s->nb_streams; i++)
664 
665  if (options) {
666  av_dict_free(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)
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 
709 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
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) {
718  uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
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 
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;
832  av_init_packet(pkt);
833 
834  for (;;) {
836  const AVPacket *pkt1;
837 
838  if (pktl) {
839  st = s->streams[pktl->pkt.stream_index];
841  if ((err = probe_codec(s, st, NULL)) < 0)
842  return err;
843  if (st->request_probe <= 0) {
845  &s->internal->raw_packet_buffer_end, pkt);
847  return 0;
848  }
849  }
850 
851  ret = s->iformat->read_packet(s, pkt);
852  if (ret < 0) {
853  av_packet_unref(pkt);
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 
872  err = av_packet_make_refcounted(pkt);
873  if (err < 0) {
874  av_packet_unref(pkt);
875  return err;
876  }
877 
878  if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
880  "Packet corrupt (stream = %d, dts = %s)",
881  pkt->stream_index, av_ts2str(pkt->dts));
883  av_log(s, AV_LOG_WARNING, ", dropping it.\n");
884  av_packet_unref(pkt);
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) */
912  pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
913 
914  if (!pktl && st->request_probe <= 0)
915  return ret;
916 
919  pkt, 0);
920  if (err < 0) {
921  av_packet_unref(pkt);
922  return err;
923  }
924  pkt1 = &s->internal->raw_packet_buffer_end->pkt;
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) {
998  frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
999  sample_rate = st->internal->avctx->sample_rate;
1000  } else {
1001  frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
1002  sample_rate = st->codecpar->sample_rate;
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];
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) {
1168  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
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 {
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  }
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 
1245  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
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 
1262  st->last_dts_for_order_check = pkt->dts;
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 
1306  duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
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};
1311  pkt->duration = av_rescale_rnd(1,
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))
1319  update_initial_durations(s, st, pkt->stream_index, pkt->duration);
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 */
1325  offset = av_rescale(pc->offset, pkt->duration, pkt->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)
1339  av_log(s, AV_LOG_DEBUG,
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;
1353  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
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 
1399  pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1400  }
1401  // We skipped it above so we try here.
1402  if (!onein_oneout)
1403  // This should happen on the first packet
1404  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
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 */
1414  pkt->flags |= AV_PKT_FLAG_KEY;
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 
1464  len = av_parser_parse2(st->parser, st->internal->avctx,
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 
1528  if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1529  out_pkt.flags |= AV_PKT_FLAG_KEY;
1530 
1531  compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1532 
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:
1549  av_packet_unref(pkt);
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) {
1615  av_packet_unref(pkt);
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) {
1624  av_packet_unref(pkt);
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)
1644  av_log(s, AV_LOG_DEBUG,
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) &&
1671  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
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 */
1687  av_packet_unref(pkt);
1688  }
1689  if (pkt->flags & AV_PKT_FLAG_KEY)
1690  st->skip_to_keyframe = 0;
1691  if (st->skip_to_keyframe) {
1692  av_packet_unref(pkt);
1693  got_packet = 0;
1694  }
1695  }
1696 
1697  if (!got_packet && s->internal->parse_queue)
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) {
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)
1757  av_log(s, AV_LOG_DEBUG,
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
1783  &s->internal->packet_buffer_end, pkt)
1784  : read_frame_internal(s, 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)) {
1832  &s->internal->packet_buffer_end, pkt);
1833  goto return_packet;
1834  }
1835  }
1836 
1837  ret = read_frame_internal(s, pkt);
1838  if (ret < 0) {
1839  if (pktl && ret != AVERROR(EAGAIN)) {
1840  eof = 1;
1841  continue;
1842  } else
1843  return ret;
1844  }
1845 
1848  pkt, 0);
1849  if (ret < 0) {
1850  av_packet_unref(pkt);
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);
1860  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
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;
1879 
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 
1929  flush_packet_queue(s);
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 
1948 
1949  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1950  st->pts_buffer[j] = AV_NOPTS_VALUE;
1951 
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);
2050  &st->index_entries_allocated_size, pos,
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)) {
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,
2203  flags | AVSEEK_FLAG_BACKWARD);
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,
2217  flags & ~AVSEEK_FLAG_BACKWARD);
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) {
2324  av_log(s, AV_LOG_TRACE,
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,
2532  flags & ~AVSEEK_FLAG_BACKWARD);
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)
2552  flags |= AVSEEK_FLAG_ANY;
2553  flags &= ~AVSEEK_FLAG_BACKWARD;
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)
2708  duration = FFMAX(duration, p->end_time - p->start_time);
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) {
2864  pkt->duration = av_rescale_rnd(1,
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  }
2883  av_packet_unref(pkt);
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") ||
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))
3407  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
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 */
3510  ret = extract_extradata_check(st);
3511  if (!ret)
3512  goto finish;
3513 
3515  if (!sti->extract_extradata.pkt)
3516  return AVERROR(ENOMEM);
3517 
3518  ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3519  if (ret < 0)
3520  goto fail;
3521 
3523  st->codecpar);
3524  if (ret < 0)
3525  goto fail;
3526 
3528 
3529  ret = av_bsf_init(sti->extract_extradata.bsf);
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) {
3550  ret = extract_extradata_init(st);
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 
3573  ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
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 
3696  ret = avcodec_parameters_to_context(avctx, st->codecpar);
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) {
3852  ret = avcodec_parameters_to_context(avctx, st->codecpar);
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) {
3926  st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3927  } else
3928  st->info->codec_info_duration += pkt->duration;
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);
4212  avcodec_close(ic->streams[i]->internal->avctx);
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;
4249  int ret = AVERROR_STREAM_NOT_FOUND;
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;
4261  nb_streams = p->nb_stream_indexes;
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;
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) {
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--) {
4479  av_freep(&s->chapters[s->nb_chapters]);
4480  }
4481  av_freep(&s->chapters);
4482  av_dict_free(&s->metadata);
4484  av_freep(&s->streams);
4485  flush_packet_queue(s);
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 
4506  flush_packet_queue(s);
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;
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 
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;
4633  dynarray_add(&ac->programs, &ac->nb_programs, program);
4634  program->discard = AVDISCARD_NONE;
4635  program->pmt_version = -1;
4636  }
4637  program->id = id;
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 
5560  ret = av_stream_add_side_data(st, type, data, size);
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,
5628  pkt->flags & AV_PKT_FLAG_KEY);
5629  if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5630  av_packet_unref(pkt);
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;
5652  av_packet_unref(pkt);
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 
5728  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
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
5798  if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
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")) {
5808  if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5809  && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
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"))
5818  && dec_ctx->time_base.num < dec_ctx->time_base.den
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 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1580
static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
Definition: utils.c:3600
#define AVINDEX_DISCARD_FRAME
Definition: avformat.h:813
unsigned int max_index_size
Maximum amount of memory in bytes to use for the index of each stream.
Definition: avformat.h:1561
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
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2512
int64_t probesize
Maximum size of the data read from input for determining the input container format.
Definition: avformat.h:1517
static void free_stream(AVStream **pst)
Definition: utils.c:4391
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1933
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1031
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: avformat.h:1078
#define NULL
Definition: coverity.c:32
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1261
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
const struct AVCodec * codec
Definition: avcodec.h:535
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:139
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:797
AVRational framerate
Definition: avcodec.h:2069
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
static void fill_all_stream_timings(AVFormatContext *ic)
Definition: utils.c:2727
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:159
#define AVFMT_NOBINSEARCH
Format does not allow to fall back on binary search via read_timestamp.
Definition: avformat.h:468
int64_t duration_gcd
Definition: avformat.h:1041
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
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: bsf.h:117
AVProbeData probe_data
Definition: avformat.h:1101
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
#define AV_PTS_WRAP_ADD_OFFSET
add the format specific offset on wrap detection
Definition: avformat.h:866
static int shift(int a, int b)
Definition: sonic.c:82
AVPacketSideDataType
Definition: packet.h:40
enum AVCodecID id
Definition: internal.h:43
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
static const char * format[]
Definition: af_aiir.c:339
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.h:206
int size
int av_demuxer_open(AVFormatContext *ic)
Definition: utils.c:389
struct AVPacketList * raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
Definition: internal.h:88
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
if(ret< 0)
Definition: vf_mcdeint.c:279
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1629
AVOption.
Definition: opt.h:246
FFFrac * priv_pts
Definition: internal.h:193
static void flush(AVCodecContext *avctx)
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
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
static void update_stream_timings(AVFormatContext *ic)
Estimate the stream timings from the one of each components.
Definition: utils.c:2633
struct AVPacketList * parse_queue_end
Definition: internal.h:94
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2064
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
static int get_std_framerate(int i)
Definition: utils.c:3282
static int update_stream_avctx(AVFormatContext *s)
Definition: utils.c:498
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:1738
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:1152
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
static int extract_extradata(AVStream *st, const AVPacket *pkt)
Definition: utils.c:3543
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:375
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:103
else temp
Definition: vf_mcdeint.c:256
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
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: avformat.h:1103
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
int64_t pos
Definition: avformat.h:805
int probe_packets
Number of packets to buffer for codec probing.
Definition: avformat.h:1086
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
#define NTP_OFFSET_US
Definition: internal.h:244
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2514
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
int64_t data_offset
offset of the first packet
Definition: internal.h:80
int width
Dimensions of the decoded video intended for presentation.
Definition: avcodec.h:3500
#define a0
Definition: regdef.h:46
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
enum AVCodecID video_codec
default video codec
Definition: avformat.h:511
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1357
int64_t first_discard_sample
If not 0, the first audio sample that should be discarded from the stream.
Definition: avformat.h:1160
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)
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
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:58
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: avformat.h:1183
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:938
int num
Numerator.
Definition: rational.h:59
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
The bitstream filter state.
Definition: bsf.h:49
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:168
int index
stream index in AVFormatContext
Definition: avformat.h:877
int size
Definition: packet.h:356
const char * b
Definition: vf_curves.c:116
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
static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
Definition: utils.c:2803
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
int avio_flags
avio flags, used to force AVIO_FLAG_DIRECT.
Definition: avformat.h:1730
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:99
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
int prefer_codec_framerate
Definition: internal.h:144
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:455
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1105
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.h:222
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1804
int(* read_close)(struct AVFormatContext *)
Close the stream.
Definition: avformat.h:731
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: utils.c:5845
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:5022
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1473
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:223
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:867
void ff_network_close(void)
Definition: network.c:116
int event_flags
Flags for the user to detect events happening on the file.
Definition: avformat.h:1666
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:834
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
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:496
#define a1
Definition: regdef.h:47
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:98
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
Definition: utils.c:2746
int ff_tls_init(void)
Definition: network.c:31
void * priv_data
Definition: avformat.h:891
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:102
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:836
const char * key
int duration
Duration of the current frame.
Definition: avcodec.h:3475
discard all
Definition: avcodec.h:236
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:978
int pmt_version
Definition: avformat.h:1279
static AVPacket pkt
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
static void error(const char *err)
int priv_data_size
Size of private data so that it can be allocated in the wrapper.
Definition: avformat.h:701
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1400
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:978
AVDictionary * metadata
Definition: avformat.h:1312
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:725
int64_t maxsize
max filesize, used to limit allocations This field is internal to libavformat and access from outside...
Definition: avio.h:266
static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
Definition: utils.c:1573
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:70
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
#define sample
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1549
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:832
AVCodec.
Definition: codec.h:190
int framerate
Definition: h264_levels.c:65
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
static void force_codec_ids(AVFormatContext *s, AVStream *st)
Definition: utils.c:687
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
Definition: utils.c:3000
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
Definition: utils.c:2947
#define FFMPEG_LICENSE
Definition: config.h:5
static int has_decode_delay_been_guessed(AVStream *st)
Definition: utils.c:1025
int64_t last_dts_for_order_check
Internal data to analyze DTS and detect faulty mpeg streams.
Definition: avformat.h:1211
#define AV_DISPOSITION_KARAOKE
Definition: avformat.h:826
int ffio_realloc_buf(AVIOContext *s, int buf_size)
Reallocate a given buffer for AVIOContext.
Definition: aviobuf.c:1027
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
Undefined.
Definition: avutil.h:273
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1251
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:947
Format I/O context.
Definition: avformat.h:1351
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2004
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264dec.c:61
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
unsigned int nb_stream_indexes
Definition: avformat.h:1273
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
#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:1488
int64_t cur_dts
Definition: avformat.h:1079
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
const char * name
Definition: opt.h:247
#define DURATION_MAX_READ_SIZE
Definition: utils.c:2799
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
#define AVFMT_FLAG_DISCARD_CORRUPT
Discard frames marked corrupted.
Definition: avformat.h:1491
static int64_t start_time
Definition: ffplay.c:332
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:64
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:748
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:519
uint8_t
Round toward +infinity.
Definition: mathematics.h:83
static int nb_streams
Definition: ffprobe.c:282
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: codec_par.h:126
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
int ff_network_init(void)
Definition: network.c:58
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1295
int(* query_codec)(enum AVCodecID id, int std_compliance)
Test if the given codec can be stored in this container.
Definition: avformat.h:575
AVOptions.
int subtitle_header_size
Definition: avcodec.h:2015
static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: utils.c:709
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:664
timestamp utils, mostly useful for debugging/logging purposes
unsigned avformat_version(void)
Return the LIBAVFORMAT_VERSION_INT constant.
Definition: utils.c:61
const char * avformat_license(void)
Return the libavformat license.
Definition: utils.c:72
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
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, or 0 if no associated fourCC code can be found.
Definition: raw.c:304
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AVPacket pkt
Definition: avformat.h:2025
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
#define f(width, name)
Definition: cbs_vp9.c:255
static const char * duration_name[]
Definition: utils.c:2936
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int id
unique ID to identify the chapter
Definition: avformat.h:1309
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:373
int id
Format-specific stream ID.
Definition: avformat.h:883
enum AVStreamParseType need_parsing
Definition: avformat.h:1094
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3158
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
int duration_count
Definition: avformat.h:1042
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2043
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1483
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:982
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
AVDurationEstimationMethod
The duration of a video can be estimated through various ways, and this enum can be used to know how ...
Definition: avformat.h:1329
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4519
uint8_t * av_stream_get_side_data(const AVStream *st, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5498
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data)...
Definition: internal.h:633
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
Definition: utils.c:328
static const AVCodec * find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:203
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
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
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5714
#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
static AVFrame * frame
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
int inject_global_side_data
Internal data to inject global side data.
Definition: avformat.h:1218
const char * avformat_configuration(void)
Return the libavformat build-time configuration.
Definition: utils.c:67
int64_t bytes_read
Bytes read statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:279
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
const char data[16]
Definition: mxf.c:91
const char * name
Definition: bsf.h:99
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:675
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
static void finish(void)
Definition: movenc.c:345
int64_t last_duration
Definition: avformat.h:1056
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1482
#define DURATION_MAX_RETRY
Definition: utils.c:2800
uint8_t * data
Definition: packet.h:355
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: utils.c:4618
char * protocol_whitelist
&#39;,&#39; separated list of allowed protocols.
Definition: avformat.h:1911
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:663
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:3415
uint32_t tag
Definition: movenc.c:1532
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:5049
int(* read_play)(struct AVFormatContext *)
Start/resume playing - only meaningful if using a network-based format (RTSP).
Definition: avformat.h:755
int fps_probe_size
The number of frames used for determining the framerate in avformat_find_stream_info().
Definition: avformat.h:1611
struct AVStreamInternal::@256 extract_extradata
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int ff_is_http_proto(char *filename)
Utility function to check if the file uses http or https protocol.
Definition: utils.c:5692
uint8_t * data
Definition: packet.h:299
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1765
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
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
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1750
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
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1271
channels
Definition: aptx.h:33
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:200
int raw_packet_buffer_remaining_size
Definition: internal.h:99
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
struct AVBitStreamFilterContext * next
Definition: avcodec.h:3979
unsigned int * stream_index
Definition: avformat.h:1272
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1537
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:799
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
int64_t rfps_duration_sum
Definition: avformat.h:1043
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
Duration estimated from bitrate (less accurate)
Definition: avformat.h:1332
unsigned int correct_ts_overflow
Correct single timestamp overflows.
Definition: avformat.h:1752
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
#define FF_API_LAVF_AVCTX
Definition: version.h:65
int64_t start_time
Definition: avformat.h:1288
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
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
static int determinable_frame_size(AVCodecContext *avctx)
Definition: utils.c:935
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
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
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
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
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:825
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
#define src
Definition: vp8dsp.c:254
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
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
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:544
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2083
#define AVINDEX_KEYFRAME
Definition: avformat.h:812
AVRational av_stream_get_codec_timebase(const AVStream *st)
Get the internal codec timebase from a stream.
Definition: utils.c:5833
int avctx_inited
1 if avctx has been initialized with the values from the codec parameters
Definition: internal.h:173
enum AVCodecID id
Definition: codec.h:204
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:91
#define AVPROBE_SCORE_STREAM_RETRY
Definition: avformat.h:449
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
static void update_initial_durations(AVFormatContext *s, AVStream *st, int stream_index, int64_t duration)
Definition: utils.c:1176
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
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1673
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: utils.c:1924
int format_probesize
number of bytes to read maximally to identify format.
Definition: avformat.h:1782
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1552
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:816
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1591
#define AVMutex
Definition: thread.h:164
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: packet.h:46
int nb_decoded_frames
Number of internally decoded frames, used internally in libavformat, do not access its lifetime diffe...
Definition: avformat.h:1173
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:3463
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
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2162
char * ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
Definition: utils.c:4889
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
int av_codec_get_tag2(const AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)
Definition: utils.c:3227
#define MAKE_ACCESSORS(str, name, type, field)
Definition: internal.h:91
int64_t pts_wrap_reference
reference dts for wrap detection
Definition: avformat.h:1291
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:72
#define AVERROR(e)
Definition: error.h:43
#define SANE_CHUNK_SIZE
Definition: utils.c:241
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1486
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
enum AVCodecID * codec_ids
A list of codec ids supported by the filter, terminated by AV_CODEC_ID_NONE.
Definition: bsf.h:106
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1832
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:806
#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
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1147
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1363
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1917
char * url
input or output URL.
Definition: avformat.h:1447
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:649
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:449
int capabilities
Codec capabilities.
Definition: codec.h:209
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int nb_programs
Definition: avformat.h:1530
int last_IP_duration
Definition: avformat.h:1081
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
Definition: utils.c:4312
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:411
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:338
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1114
AVChapter ** chapters
Definition: avformat.h:1581
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:89
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
const char * protocol_whitelist
&#39;,&#39; separated list of allowed protocols.
Definition: avio.h:309
enum AVPacketSideDataType type
Definition: packet.h:301
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:239
const char * name
Name of the codec implementation.
Definition: codec.h:197
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
int side_data_elems
Definition: packet.h:367
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
#define AV_FRAME_FILENAME_FLAGS_MULTIPLE
Allow multiple d.
Definition: avformat.h:2906
int skip_estimate_duration_from_pts
Skip duration calcuation in estimate_timings_from_pts.
Definition: avformat.h:1960
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet. ...
Definition: avformat.h:1143
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:287
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:949
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1268
#define FFMAX(a, b)
Definition: common.h:94
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
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
struct AVCodecParserContext * av_stream_get_parser(const AVStream *st)
Definition: utils.c:144
int64_t val
Definition: internal.h:60
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
Definition: avformat.h:818
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
#define fail()
Definition: checkasm.h:123
const char * protocol_blacklist
&#39;,&#39; separated list of disallowed protocols.
Definition: avio.h:314
AVPacket * pkt
Definition: internal.h:182
const char av_format_ffversion[]
Definition: utils.c:52
AVCodec * audio_codec
Forced audio codec.
Definition: avformat.h:1828
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:169
#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:1504
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:144
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int seek_count
seek statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:285
Only parse headers, do not repack.
Definition: avformat.h:796
char * format_whitelist
&#39;,&#39; separated list of allowed demuxers.
Definition: avformat.h:1798
static int genpts
Definition: ffplay.c:335
static int extract_extradata_init(AVStream *st)
Definition: utils.c:3499
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
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1489
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
static float distance(float x, float y, int band)
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
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
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
Definition: utils.c:410
static AVPacketList * get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
Definition: utils.c:1043
common internal API header
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:223
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
AVDictionary * opts
Definition: movenc.c:50
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: avformat.h:1061
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
Definition: utils.c:4321
const char * name
Definition: qsvenc.c:46
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
#define AV_MUTEX_INITIALIZER
Definition: thread.h:165
#define dynarray_add(tab, nb_ptr, elem)
Definition: internal.h:197
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
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
int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:5748
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: avformat.h:1200
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:96
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:2201
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1543
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:1319
void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
Definition: utils.c:2097
Raw Video Codec.
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
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
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
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:157
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:558
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
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:36
static const chunk_decoder decoder[8]
Definition: dfa.c:330
int max_streams
The maximum number of streams.
Definition: avformat.h:1953
int width
picture width / height.
Definition: avcodec.h:699
#define RELATIVE_TS_BASE
Definition: utils.c:88
int64_t offset
byte offset from starting packet start
Definition: avcodec.h:3393
int av_find_default_stream_index(AVFormatContext *s)
Definition: utils.c:1886
#define FAIL(errmsg)
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: utils.c:4677
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:671
int frame_delay_evidence
Definition: avformat.h:1047
const char * name
Definition: avformat.h:500
Duration estimated from a stream with a known duration.
Definition: avformat.h:1331
int32_t
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:224
uint8_t dts_ordered
Definition: avformat.h:1212
static int seek_frame_generic(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c:2409
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
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
static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts)
Definition: utils.c:1052
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
The call resulted in updated metadata.
Definition: avformat.h:1667
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5685
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
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
static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
Definition: utils.c:759
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
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:480
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:49
#define AV_RL32
Definition: intreadwrite.h:146
int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
Copy encoding parameters from source to destination stream.
Definition: utils.c:4330
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVDictionary * metadata
Definition: avformat.h:940
uint8_t * av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type, int size)
Allocate new information from stream.
Definition: utils.c:5551
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:658
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:448
int probe_score
format probing score.
Definition: avformat.h:1775
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don&#39;t avio_close() it.
Definition: avformat.h:1490
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
Opaque data information usually sparse.
Definition: avutil.h:205
int64_t skip_initial_bytes
Skip initial bytes when opening stream.
Definition: avformat.h:1745
int(* AVOpenCallback)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Definition: avformat.h:1322
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:528
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:467
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
int buffer_size
Maximum buffer size.
Definition: avio.h:227
int(* read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: avformat.h:769
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
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:1525
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
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:844
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:4787
#define av_log2
Definition: intmath.h:83
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
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1370
uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1]
Definition: avformat.h:1206
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
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:835
#define CONTAINS_PAL
Definition: internal.h:679
int(* read_pause)(struct AVFormatContext *)
Pause playing - only meaningful if using a network-based format (RTSP).
Definition: avformat.h:761
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
Stream structure.
Definition: avformat.h:876
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1311
int avformat_queue_attached_pictures(AVFormatContext *s)
Definition: utils.c:475
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:586
static const AVCodec * find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:179
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:5061
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
uint8_t dts_misordered
Definition: avformat.h:1213
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:821
#define FF_FDEBUG_TS
Definition: avformat.h:1635
#define LIBAVFORMAT_VERSION_INT
Definition: version.h:38
sample_rate
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int64_t pts_reorder_error[MAX_REORDER_DELAY+1]
Internal data to generate dts from pts.
Definition: avformat.h:1205
int frame_size
Definition: mxfenc.c:2139
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:197
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:255
int64_t end_time
Definition: avformat.h:1289
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1231
enum AVMediaType codec_type
Definition: avcodec.h:534
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3148
static int64_t ts_to_samples(AVStream *st, int64_t ts)
Definition: utils.c:1568
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:663
int debug
Flags to enable debugging.
Definition: avformat.h:1634
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
enum AVCodecID codec_id
Definition: avcodec.h:536
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
Definition: utils.c:265
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1655
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
int sample_rate
samples per second
Definition: avcodec.h:1186
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
Definition: utils.c:3219
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:525
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in &#39;pkt&#39;.
Definition: avformat.h:725
main external API structure.
Definition: avcodec.h:526
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
int io_repositioned
IO repositioned flag.
Definition: avformat.h:1812
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:321
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:223
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1102
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:388
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:551
static int extract_extradata_check(AVStream *st)
Definition: utils.c:3481
#define AVFMT_NOGENSEARCH
Format does not allow to fall back on generic search.
Definition: avformat.h:469
void(* io_close)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
Definition: avformat.h:1939
int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
Return in &#39;buf&#39; the path with &#39;d&#39; replaced by a number.
Definition: utils.c:4732
int pts_wrap_behavior
behavior on wrap detection
Definition: avformat.h:1292
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: avformat.h:1044
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
int extradata_size
Definition: avcodec.h:628
int ff_lock_avformat(void)
Definition: utils.c:78
#define llrint(x)
Definition: libm.h:394
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
int nb_index_entries
Definition: avformat.h:1107
int nb_coded_side_data
Definition: avcodec.h:2202
int coded_height
Definition: avcodec.h:714
enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
Definition: utils.c:3244
Describe the class of an AVClass context structure.
Definition: log.h:67
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
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:4910
int initialized
Whether or not avformat_init_output has already been called.
Definition: internal.h:129
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:231
int index
Definition: gxfenc.c:89
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:463
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:512
#define SPACE_CHARS
Definition: internal.h:343
Rational number (pair of numerator and denominator).
Definition: rational.h:58
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
int64_t last_dts
Definition: avformat.h:1040
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: avformat.h:1225
Recommmends skipping the specified number of samples.
Definition: packet.h:156
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:4705
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2513
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar) ...
Definition: internal.h:189
cl_device_type type
const AVClass * av_class
A class for logging and AVOptions.
Definition: avformat.h:1356
AVMediaType
Definition: avutil.h:199
int max_probe_packets
Maximum number of packets that can be probed.
Definition: avformat.h:1967
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5363
int short_seek_threshold
Threshold to favor readahead over seek.
Definition: avio.h:304
int64_t fps_last_dts
Definition: avformat.h:1063
#define RAW_PACKET_BUFFER_SIZE
Remaining size available for raw_packet_buffer, in bytes.
Definition: internal.h:98
static int seek_frame_internal(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c:2476
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
#define snprintf
Definition: snprintf.h:34
int found_decoder
0 -> decoder has not been searched for yet.
Definition: avformat.h:1054
struct AVStream::@240 * info
Stream information used internally by avformat_find_stream_info()
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4448
int inject_global_side_data
Definition: internal.h:117
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1756
misc parsing utilities
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1773
AVTimebaseSource
Definition: avformat.h:3073
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:919
static int has_duration(AVFormatContext *ic)
Return TRUE if the stream has accurate duration in any stream.
Definition: utils.c:2613
int avio_pause(AVIOContext *h, int pause)
Pause and resume playing - only meaningful if using a network streaming protocol (e.g.
Definition: aviobuf.c:1202
Round toward -infinity.
Definition: mathematics.h:82
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
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:3409
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: codec_desc.h:38
int seek2any
Force seeking to any (also non key) frames.
Definition: avformat.h:1759
full parsing and repack of the first frame only, only implemented for H.264 currently ...
Definition: avformat.h:798
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
AVDictionary * metadata
Definition: avformat.h:1274
int64_t codec_info_duration
Definition: avformat.h:1045
int fps_first_dts_idx
Definition: avformat.h:1062
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
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1456
Duration accurately estimated from PTSes.
Definition: avformat.h:1330
#define LICENSE_PREFIX
int ff_mkdir_p(const char *path)
Automatically create sub-directories.
Definition: utils.c:4855
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: utils.c:2520
unsigned int tag
Definition: internal.h:44
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
struct AVPacketList * parse_queue
Packets split by the parser get queued here.
Definition: internal.h:93
int64_t start
Definition: avformat.h:1311
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:925
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
#define PARSER_FLAG_ONCE
Definition: avcodec.h:3388
int sample_rate
Audio only.
Definition: codec_par.h:170
enum AVMediaType type
Definition: codec_desc.h:40
static int is_relative(int64_t ts)
Definition: utils.c:90
int64_t bitrate
Definition: h264_levels.c:131
static int tb_unreliable(AVCodecContext *c)
Definition: utils.c:3306
static AVStream * ost
Main libavformat public API header.
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:366
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1610
#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
const OptionDef options[]
Definition: ffmpeg_opt.c:3388
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
struct AVPacketList * next
Definition: avformat.h:2026
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: avformat.h:1195
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
enum AVCodecID data_codec
default data codec
Definition: avformat.h:610
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3615
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:915
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
AVCodec * video_codec
Forced video codec.
Definition: avformat.h:1820
static double c[64]
static const char * duration_estimate_name(enum AVDurationEstimationMethod method)
Definition: utils.c:2942
static AVCodecContext * dec_ctx
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:929
enum AVCodecID orig_codec_id
Definition: internal.h:175
int(* read_seek)(struct AVFormatContext *, int stream_index, int64_t timestamp, int flags)
Seek to a given timestamp relative to the frames in stream component stream_index.
Definition: avformat.h:741
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
int pts_wrap_bits
number of bits in pts (used for wrapping control)
Definition: avformat.h:1068
Bi-dir predicted.
Definition: avutil.h:276
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:4440
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: utils.c:3355
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1310
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:3387
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:111
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1184
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2191
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:927
int den
Denominator.
Definition: rational.h:60
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:389
unsigned bps
Definition: movenc.c:1533
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
Definition: utils.c:4491
#define FFMPEG_CONFIGURATION
Definition: config.h:4
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:865
int64_t codec_info_duration_fields
Definition: avformat.h:1046
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1224
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:108
unsigned int index_entries_allocated_size
Definition: avformat.h:1108
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:52
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: avformat.h:1138
int64_t frame_offset
Definition: avcodec.h:3356
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:465
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
static av_always_inline int diff(const uint32_t a, const uint32_t b)
struct AVPacketList * packet_buffer_end
Definition: internal.h:77
pixel format definitions
#define av_free(p)
enum AVCodecID data_codec_id
Forced Data codec_id.
Definition: avformat.h:1882
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:470
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
char * value
Definition: dict.h:87
AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1836
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: avformat.h:715
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
#define FFMPEG_VERSION
Definition: ffversion.h:4
int len
int channels
number of audio channels
Definition: avcodec.h:1187
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:510
char * codec_whitelist
&#39;,&#39; separated list of allowed decoders.
Definition: avformat.h:1790
struct AVCodecParserContext * parser
Definition: avformat.h:1095
int format
The format of the coded data, corresponds to enum AVPixelFormat for video and for enum AVSampleFormat...
Definition: avcodec.h:3517
void * priv_data
Format private data.
Definition: avformat.h:1379
void(* deinit)(struct AVFormatContext *)
Deinitialize format.
Definition: avformat.h:629
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: avformat.h:1091
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:53
const struct PixelFormatTag * avpriv_get_raw_pix_fmt_tags(void)
Definition: raw.c:299
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:132
#define AVERROR_STREAM_NOT_FOUND
Stream not found.
Definition: error.h:65
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3394
static void flush_packet_queue(AVFormatContext *s)
Definition: utils.c:1872
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:824
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
AVDiscard
Definition: avcodec.h:227
int channels
Audio only.
Definition: codec_par.h:166
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:169
#define av_uninit(x)
Definition: attributes.h:154
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:354
const struct AVBitStreamFilter * filter
Definition: avcodec.h:3977
static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags)
Definition: utils.c:2389
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
char * protocol_blacklist
&#39;,&#39; separated list of disallowed protocols.
Definition: avformat.h:1946
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:3371
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1466
int avformat_flush(AVFormatContext *s)
Discard all internally buffered data.
Definition: utils.c:2600
int64_t last_IP_pts
Definition: avformat.h:1080
void ff_tls_deinit(void)
Definition: network.c:46
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:159
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
unbuffered private I/O API
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
static void compute_chapters_end(AVFormatContext *s)
Definition: utils.c:3255
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
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
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
int ff_is_intra_only(enum AVCodecID id)
Definition: utils.c:1014
int copy_tb
Definition: ffmpeg_opt.c:162
#define FFSWAP(type, a, b)
Definition: common.h:99
static int try_decode_frame(AVFormatContext *s, AVStream *st, const AVPacket *avpkt, AVDictionary **options)
Definition: utils.c:3048
static void update_initial_timestamps(AVFormatContext *s, int stream_index, int64_t dts, int64_t pts, AVPacket *pkt)
Definition: utils.c:1124
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
int fps_last_dts_idx
Definition: avformat.h:1064
int stream_index
Definition: packet.h:357
int ff_unlock_avformat(void)
Definition: utils.c:83
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:905
AVBSFContext * bsf
Definition: internal.h:181
static AVMutex avformat_mutex
Definition: utils.c:54
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
#define MKTAG(a, b, c, d)
Definition: common.h:406
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:931
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
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1000
int ffio_limit(AVIOContext *s, int size)
Definition: utils.c:243
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1133
enum AVCodecID id
int use_wallclock_as_timestamps
forces the use of wallclock timestamps as pts/dts of packets This has undefined results in the presen...
Definition: avformat.h:1723
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:332
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
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:3402
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
#define AVFMT_FLAG_NOFILLIN
Do not infer any values from other values, just return what is stored in the container.
Definition: avformat.h:1487
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
Definition: mem.c:267
#define MAX_STD_TIMEBASES
Definition: avformat.h:1035
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:958
int64_t av_stream_get_end_pts(const AVStream *st)
Returns the pts of the last muxed packet + its duration.
Definition: utils.c:136
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
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
#define av_unused
Definition: attributes.h:131
AVProgram ** programs
Definition: avformat.h:1531
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:3391
#define AVFMT_NEEDNUMBER
Needs &#39;d&#39; in filename.
Definition: avformat.h:459
discard nothing
Definition: avcodec.h:230
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
struct AVPacketList * raw_packet_buffer_end
Definition: internal.h:89
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
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:192
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2014
static uint8_t tmp[11]
Definition: aes_ctr.c:26