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