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