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