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