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