FFmpeg  4.0.3
utils.c
Go to the documentation of this file.
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdarg.h>
23 #include <stdint.h>
24 
25 #include "config.h"
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/thread.h"
36 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
39 
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
43 
44 #include "audiointerleave.h"
45 #include "avformat.h"
46 #include "avio_internal.h"
47 #include "id3v2.h"
48 #include "internal.h"
49 #include "metadata.h"
50 #if CONFIG_NETWORK
51 #include "network.h"
52 #endif
53 #include "riff.h"
54 #include "url.h"
55 
56 #include "libavutil/ffversion.h"
57 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
58 
60 
61 /**
62  * @file
63  * various utility functions for use within FFmpeg
64  */
65 
66 unsigned avformat_version(void)
67 {
70 }
71 
72 const char *avformat_configuration(void)
73 {
74  return FFMPEG_CONFIGURATION;
75 }
76 
77 const char *avformat_license(void)
78 {
79 #define LICENSE_PREFIX "libavformat license: "
80  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
81 }
82 
84 {
85  return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
86 }
87 
89 {
90  return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
91 }
92 
93 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
94 
95 static int is_relative(int64_t ts) {
96  return ts > (RELATIVE_TS_BASE - (1LL<<48));
97 }
98 
99 /**
100  * Wrap a given time stamp, if there is an indication for an overflow
101  *
102  * @param st stream
103  * @param timestamp the time stamp to wrap
104  * @return resulting time stamp
105  */
106 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
107 {
109  st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
111  timestamp < st->pts_wrap_reference)
112  return timestamp + (1ULL << st->pts_wrap_bits);
113  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
114  timestamp >= st->pts_wrap_reference)
115  return timestamp - (1ULL << st->pts_wrap_bits);
116  }
117  return timestamp;
118 }
119 
120 #if FF_API_FORMAT_GET_SET
121 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
122 #if FF_API_LAVF_FFSERVER
124 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
126 #endif
129 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
131 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
132 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
134 #if FF_API_OLD_OPEN_CALLBACKS
138 #endif
139 #endif
140 
141 int64_t av_stream_get_end_pts(const AVStream *st)
142 {
143  if (st->internal->priv_pts) {
144  return st->internal->priv_pts->val;
145  } else
146  return AV_NOPTS_VALUE;
147 }
148 
150 {
151  return st->parser;
152 }
153 
155 {
156  int i;
158  for (i = 0; i < s->nb_streams; i++) {
159  AVStream *st = s->streams[i];
160  st->inject_global_side_data = 1;
161  }
162 }
163 
165 {
166  av_assert0(!dst->codec_whitelist &&
167  !dst->format_whitelist &&
168  !dst->protocol_whitelist &&
169  !dst->protocol_blacklist);
170  dst-> codec_whitelist = av_strdup(src->codec_whitelist);
174  if ( (src-> codec_whitelist && !dst-> codec_whitelist)
175  || (src-> format_whitelist && !dst-> format_whitelist)
176  || (src->protocol_whitelist && !dst->protocol_whitelist)
177  || (src->protocol_blacklist && !dst->protocol_blacklist)) {
178  av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
179  return AVERROR(ENOMEM);
180  }
181  return 0;
182 }
183 
185 {
186 #if FF_API_LAVF_AVCTX
188  if (st->codec->codec)
189  return st->codec->codec;
191 #endif
192 
193  switch (st->codecpar->codec_type) {
194  case AVMEDIA_TYPE_VIDEO:
195  if (s->video_codec) return s->video_codec;
196  break;
197  case AVMEDIA_TYPE_AUDIO:
198  if (s->audio_codec) return s->audio_codec;
199  break;
201  if (s->subtitle_codec) return s->subtitle_codec;
202  break;
203  }
204 
205  return avcodec_find_decoder(codec_id);
206 }
207 
209 {
210  const AVCodec *codec;
211 
212 #if CONFIG_H264_DECODER
213  /* Other parts of the code assume this decoder to be used for h264,
214  * so force it if possible. */
215  if (codec_id == AV_CODEC_ID_H264)
216  return avcodec_find_decoder_by_name("h264");
217 #endif
218 
219  codec = find_decoder(s, st, codec_id);
220  if (!codec)
221  return NULL;
222 
224  const AVCodec *probe_codec = NULL;
225  while (probe_codec = av_codec_next(probe_codec)) {
226  if (probe_codec->id == codec_id &&
227  av_codec_is_decoder(probe_codec) &&
229  return probe_codec;
230  }
231  }
232  }
233 
234  return codec;
235 }
236 
237 #if FF_API_FORMAT_GET_SET
238 int av_format_get_probe_score(const AVFormatContext *s)
239 {
240  return s->probe_score;
241 }
242 #endif
243 
244 /* an arbitrarily chosen "sane" max packet size -- 50M */
245 #define SANE_CHUNK_SIZE (50000000)
246 
248 {
249  if (s->maxsize>= 0) {
250  int64_t remaining= s->maxsize - avio_tell(s);
251  if (remaining < size) {
252  int64_t newsize = avio_size(s);
253  if (!s->maxsize || s->maxsize<newsize)
254  s->maxsize = newsize - !newsize;
255  remaining= s->maxsize - avio_tell(s);
256  remaining= FFMAX(remaining, 0);
257  }
258 
259  if (s->maxsize>= 0 && remaining+1 < size) {
260  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
261  size = remaining+1;
262  }
263  }
264  return size;
265 }
266 
267 /* Read the data in sane-sized chunks and append to pkt.
268  * Return the number of bytes read or an error. */
270 {
271  int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
272  int orig_size = pkt->size;
273  int ret;
274 
275  do {
276  int prev_size = pkt->size;
277  int read_size;
278 
279  /* When the caller requests a lot of data, limit it to the amount
280  * left in file or SANE_CHUNK_SIZE when it is not known. */
281  read_size = size;
282  if (read_size > SANE_CHUNK_SIZE/10) {
283  read_size = ffio_limit(s, read_size);
284  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
285  if (s->maxsize < 0)
286  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
287  }
288 
289  ret = av_grow_packet(pkt, read_size);
290  if (ret < 0)
291  break;
292 
293  ret = avio_read(s, pkt->data + prev_size, read_size);
294  if (ret != read_size) {
295  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
296  break;
297  }
298 
299  size -= read_size;
300  } while (size > 0);
301  if (size > 0)
302  pkt->flags |= AV_PKT_FLAG_CORRUPT;
303 
304  pkt->pos = orig_pos;
305  if (!pkt->size)
306  av_packet_unref(pkt);
307  return pkt->size > orig_size ? pkt->size - orig_size : ret;
308 }
309 
311 {
312  av_init_packet(pkt);
313  pkt->data = NULL;
314  pkt->size = 0;
315  pkt->pos = avio_tell(s);
316 
317  return append_packet_chunked(s, pkt, size);
318 }
319 
321 {
322  if (!pkt->size)
323  return av_get_packet(s, pkt, size);
324  return append_packet_chunked(s, pkt, size);
325 }
326 
327 int av_filename_number_test(const char *filename)
328 {
329  char buf[1024];
330  return filename &&
331  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
332 }
333 
335  AVProbeData *pd)
336 {
337  static const struct {
338  const char *name;
339  enum AVCodecID id;
340  enum AVMediaType type;
341  } fmt_id_type[] = {
343  { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
344  { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
345  { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
347  { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
348  { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
350  { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
351  { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
352  { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
353  { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
354  { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
355  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
356  { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
357  { 0 }
358  };
359  int score;
360  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_TRACE,
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_TRACE, "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 */
1409  if (is_intra_only(st->codecpar->codec_id))
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 - 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 
2816  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2817  /* estimate the end time (duration) */
2818  /* XXX: may need to support wrapping */
2819  filesize = ic->pb ? avio_size(ic->pb) : 0;
2820  do {
2821  is_end = found_duration;
2822  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2823  if (offset < 0)
2824  offset = 0;
2825 
2826  avio_seek(ic->pb, offset, SEEK_SET);
2827  read_size = 0;
2828  for (;;) {
2829  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2830  break;
2831 
2832  do {
2833  ret = ff_read_packet(ic, pkt);
2834  } while (ret == AVERROR(EAGAIN));
2835  if (ret != 0)
2836  break;
2837  read_size += pkt->size;
2838  st = ic->streams[pkt->stream_index];
2839  if (pkt->pts != AV_NOPTS_VALUE &&
2840  (st->start_time != AV_NOPTS_VALUE ||
2841  st->first_dts != AV_NOPTS_VALUE)) {
2842  if (pkt->duration == 0) {
2843  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2844  if (den && num) {
2845  pkt->duration = av_rescale_rnd(1,
2846  num * (int64_t) st->time_base.den,
2847  den * (int64_t) st->time_base.num,
2848  AV_ROUND_DOWN);
2849  }
2850  }
2851  duration = pkt->pts + pkt->duration;
2852  found_duration = 1;
2853  if (st->start_time != AV_NOPTS_VALUE)
2854  duration -= st->start_time;
2855  else
2856  duration -= st->first_dts;
2857  if (duration > 0) {
2858  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2859  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2860  st->duration = duration;
2861  st->info->last_duration = duration;
2862  }
2863  }
2864  av_packet_unref(pkt);
2865  }
2866 
2867  /* check if all audio/video streams have valid duration */
2868  if (!is_end) {
2869  is_end = 1;
2870  for (i = 0; i < ic->nb_streams; i++) {
2871  st = ic->streams[i];
2872  switch (st->codecpar->codec_type) {
2873  case AVMEDIA_TYPE_VIDEO:
2874  case AVMEDIA_TYPE_AUDIO:
2875  if (st->duration == AV_NOPTS_VALUE)
2876  is_end = 0;
2877  }
2878  }
2879  }
2880  } while (!is_end &&
2881  offset &&
2882  ++retry <= DURATION_MAX_RETRY);
2883 
2884  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2885 
2886  /* warn about audio/video streams which duration could not be estimated */
2887  for (i = 0; i < ic->nb_streams; i++) {
2888  st = ic->streams[i];
2889  if (st->duration == AV_NOPTS_VALUE) {
2890  switch (st->codecpar->codec_type) {
2891  case AVMEDIA_TYPE_VIDEO:
2892  case AVMEDIA_TYPE_AUDIO:
2893  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2894  av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2895  } else
2896  av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2897  }
2898  }
2899  }
2901 
2902  avio_seek(ic->pb, old_offset, SEEK_SET);
2903  for (i = 0; i < ic->nb_streams; i++) {
2904  int j;
2905 
2906  st = ic->streams[i];
2907  st->cur_dts = st->first_dts;
2910  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2911  st->pts_buffer[j] = AV_NOPTS_VALUE;
2912  }
2913 }
2914 
2915 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2916 {
2917  int64_t file_size;
2918 
2919  /* get the file size, if possible */
2920  if (ic->iformat->flags & AVFMT_NOFILE) {
2921  file_size = 0;
2922  } else {
2923  file_size = avio_size(ic->pb);
2924  file_size = FFMAX(0, file_size);
2925  }
2926 
2927  if ((!strcmp(ic->iformat->name, "mpeg") ||
2928  !strcmp(ic->iformat->name, "mpegts")) &&
2929  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2930  /* get accurate estimate from the PTSes */
2931  estimate_timings_from_pts(ic, old_offset);
2933  } else if (has_duration(ic)) {
2934  /* at least one component has timings - we use them for all
2935  * the components */
2938  } else {
2939  /* less precise: use bitrate info */
2942  }
2944 
2945  {
2946  int i;
2947  AVStream av_unused *st;
2948  for (i = 0; i < ic->nb_streams; i++) {
2949  st = ic->streams[i];
2950  av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2951  (double) st->start_time * av_q2d(st->time_base),
2952  (double) st->duration * av_q2d(st->time_base));
2953  }
2954  av_log(ic, AV_LOG_TRACE,
2955  "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2956  (double) ic->start_time / AV_TIME_BASE,
2957  (double) ic->duration / AV_TIME_BASE,
2958  (int64_t)ic->bit_rate / 1000);
2959  }
2960 }
2961 
2962 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2963 {
2964  AVCodecContext *avctx = st->internal->avctx;
2965 
2966 #define FAIL(errmsg) do { \
2967  if (errmsg_ptr) \
2968  *errmsg_ptr = errmsg; \
2969  return 0; \
2970  } while (0)
2971 
2972  if ( avctx->codec_id == AV_CODEC_ID_NONE
2973  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2974  FAIL("unknown codec");
2975  switch (avctx->codec_type) {
2976  case AVMEDIA_TYPE_AUDIO:
2977  if (!avctx->frame_size && determinable_frame_size(avctx))
2978  FAIL("unspecified frame size");
2979  if (st->info->found_decoder >= 0 &&
2980  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2981  FAIL("unspecified sample format");
2982  if (!avctx->sample_rate)
2983  FAIL("unspecified sample rate");
2984  if (!avctx->channels)
2985  FAIL("unspecified number of channels");
2986  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2987  FAIL("no decodable DTS frames");
2988  break;
2989  case AVMEDIA_TYPE_VIDEO:
2990  if (!avctx->width)
2991  FAIL("unspecified size");
2992  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2993  FAIL("unspecified pixel format");
2996  FAIL("no frame in rv30/40 and no sar");
2997  break;
2998  case AVMEDIA_TYPE_SUBTITLE:
2999  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3000  FAIL("unspecified size");
3001  break;
3002  case AVMEDIA_TYPE_DATA:
3003  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3004  }
3005 
3006  return 1;
3007 }
3008 
3009 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3012 {
3013  AVCodecContext *avctx = st->internal->avctx;
3014  const AVCodec *codec;
3015  int got_picture = 1, ret = 0;
3017  AVSubtitle subtitle;
3018  AVPacket pkt = *avpkt;
3019  int do_skip_frame = 0;
3020  enum AVDiscard skip_frame;
3021 
3022  if (!frame)
3023  return AVERROR(ENOMEM);
3024 
3025  if (!avcodec_is_open(avctx) &&
3026  st->info->found_decoder <= 0 &&
3027  (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3028  AVDictionary *thread_opt = NULL;
3029 
3030  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3031 
3032  if (!codec) {
3033  st->info->found_decoder = -st->codecpar->codec_id;
3034  ret = -1;
3035  goto fail;
3036  }
3037 
3038  /* Force thread count to 1 since the H.264 decoder will not extract
3039  * SPS and PPS to extradata during multi-threaded decoding. */
3040  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3041  if (s->codec_whitelist)
3042  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3043  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3044  if (!options)
3045  av_dict_free(&thread_opt);
3046  if (ret < 0) {
3047  st->info->found_decoder = -avctx->codec_id;
3048  goto fail;
3049  }
3050  st->info->found_decoder = 1;
3051  } else if (!st->info->found_decoder)
3052  st->info->found_decoder = 1;
3053 
3054  if (st->info->found_decoder < 0) {
3055  ret = -1;
3056  goto fail;
3057  }
3058 
3060  do_skip_frame = 1;
3061  skip_frame = avctx->skip_frame;
3062  avctx->skip_frame = AVDISCARD_ALL;
3063  }
3064 
3065  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3066  ret >= 0 &&
3068  (!st->codec_info_nb_frames &&
3070  got_picture = 0;
3071  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3072  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3073  ret = avcodec_send_packet(avctx, &pkt);
3074  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3075  break;
3076  if (ret >= 0)
3077  pkt.size = 0;
3078  ret = avcodec_receive_frame(avctx, frame);
3079  if (ret >= 0)
3080  got_picture = 1;
3081  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3082  ret = 0;
3083  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3084  ret = avcodec_decode_subtitle2(avctx, &subtitle,
3085  &got_picture, &pkt);
3086  if (ret >= 0)
3087  pkt.size = 0;
3088  }
3089  if (ret >= 0) {
3090  if (got_picture)
3091  st->nb_decoded_frames++;
3092  ret = got_picture;
3093  }
3094  }
3095 
3096  if (!pkt.data && !got_picture)
3097  ret = -1;
3098 
3099 fail:
3100  if (do_skip_frame) {
3101  avctx->skip_frame = skip_frame;
3102  }
3103 
3104  av_frame_free(&frame);
3105  return ret;
3106 }
3107 
3108 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3109 {
3110  while (tags->id != AV_CODEC_ID_NONE) {
3111  if (tags->id == id)
3112  return tags->tag;
3113  tags++;
3114  }
3115  return 0;
3116 }
3117 
3118 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3119 {
3120  int i;
3121  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3122  if (tag == tags[i].tag)
3123  return tags[i].id;
3124  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3125  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3126  return tags[i].id;
3127  return AV_CODEC_ID_NONE;
3128 }
3129 
3130 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3131 {
3132  if (bps <= 0 || bps > 64)
3133  return AV_CODEC_ID_NONE;
3134 
3135  if (flt) {
3136  switch (bps) {
3137  case 32:
3139  case 64:
3141  default:
3142  return AV_CODEC_ID_NONE;
3143  }
3144  } else {
3145  bps += 7;
3146  bps >>= 3;
3147  if (sflags & (1 << (bps - 1))) {
3148  switch (bps) {
3149  case 1:
3150  return AV_CODEC_ID_PCM_S8;
3151  case 2:
3153  case 3:
3155  case 4:
3157  case 8:
3159  default:
3160  return AV_CODEC_ID_NONE;
3161  }
3162  } else {
3163  switch (bps) {
3164  case 1:
3165  return AV_CODEC_ID_PCM_U8;
3166  case 2:
3168  case 3:
3170  case 4:
3172  default:
3173  return AV_CODEC_ID_NONE;
3174  }
3175  }
3176  }
3177 }
3178 
3179 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3180 {
3181  unsigned int tag;
3182  if (!av_codec_get_tag2(tags, id, &tag))
3183  return 0;
3184  return tag;
3185 }
3186 
3187 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3188  unsigned int *tag)
3189 {
3190  int i;
3191  for (i = 0; tags && tags[i]; i++) {
3192  const AVCodecTag *codec_tags = tags[i];
3193  while (codec_tags->id != AV_CODEC_ID_NONE) {
3194  if (codec_tags->id == id) {
3195  *tag = codec_tags->tag;
3196  return 1;
3197  }
3198  codec_tags++;
3199  }
3200  }
3201  return 0;
3202 }
3203 
3204 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3205 {
3206  int i;
3207  for (i = 0; tags && tags[i]; i++) {
3208  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3209  if (id != AV_CODEC_ID_NONE)
3210  return id;
3211  }
3212  return AV_CODEC_ID_NONE;
3213 }
3214 
3216 {
3217  unsigned int i, j;
3218  int64_t max_time = 0;
3219 
3220  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3221  max_time = s->duration +
3222  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3223 
3224  for (i = 0; i < s->nb_chapters; i++)
3225  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3226  AVChapter *ch = s->chapters[i];
3227  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3228  ch->time_base)
3229  : INT64_MAX;
3230 
3231  for (j = 0; j < s->nb_chapters; j++) {
3232  AVChapter *ch1 = s->chapters[j];
3233  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3234  ch->time_base);
3235  if (j != i && next_start > ch->start && next_start < end)
3236  end = next_start;
3237  }
3238  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3239  }
3240 }
3241 
3242 static int get_std_framerate(int i)
3243 {
3244  if (i < 30*12)
3245  return (i + 1) * 1001;
3246  i -= 30*12;
3247 
3248  if (i < 30)
3249  return (i + 31) * 1001 * 12;
3250  i -= 30;
3251 
3252  if (i < 3)
3253  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3254 
3255  i -= 3;
3256 
3257  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3258 }
3259 
3260 /* Is the time base unreliable?
3261  * This is a heuristic to balance between quick acceptance of the values in
3262  * the headers vs. some extra checks.
3263  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3264  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3265  * And there are "variable" fps files this needs to detect as well. */
3267 {
3268  if (c->time_base.den >= 101LL * c->time_base.num ||
3269  c->time_base.den < 5LL * c->time_base.num ||
3270  // c->codec_tag == AV_RL32("DIVX") ||
3271  // c->codec_tag == AV_RL32("XVID") ||
3272  c->codec_tag == AV_RL32("mp4v") ||
3274  c->codec_id == AV_CODEC_ID_GIF ||
3275  c->codec_id == AV_CODEC_ID_HEVC ||
3276  c->codec_id == AV_CODEC_ID_H264)
3277  return 1;
3278  return 0;
3279 }
3280 
3282 {
3283  av_freep(&par->extradata);
3284  par->extradata_size = 0;
3285 
3286  if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3287  return AVERROR(EINVAL);
3288 
3290  if (!par->extradata)
3291  return AVERROR(ENOMEM);
3292 
3293  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3294  par->extradata_size = size;
3295 
3296  return 0;
3297 }
3298 
3300 {
3301  int ret = ff_alloc_extradata(par, size);
3302  if (ret < 0)
3303  return ret;
3304  ret = avio_read(pb, par->extradata, size);
3305  if (ret != size) {
3306  av_freep(&par->extradata);
3307  par->extradata_size = 0;
3308  av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3309  return ret < 0 ? ret : AVERROR_INVALIDDATA;
3310  }
3311 
3312  return ret;
3313 }
3314 
3315 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3316 {
3317  int i, j;
3318  int64_t last = st->info->last_dts;
3319 
3320  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3321  && ts - (uint64_t)last < INT64_MAX) {
3322  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3323  int64_t duration = ts - last;
3324 
3325  if (!st->info->duration_error)
3326  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3327  if (!st->info->duration_error)
3328  return AVERROR(ENOMEM);
3329 
3330 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3331 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3332  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3333  if (st->info->duration_error[0][1][i] < 1e10) {
3334  int framerate = get_std_framerate(i);
3335  double sdts = dts*framerate/(1001*12);
3336  for (j= 0; j<2; j++) {
3337  int64_t ticks = llrint(sdts+j*0.5);
3338  double error= sdts - ticks + j*0.5;
3339  st->info->duration_error[j][0][i] += error;
3340  st->info->duration_error[j][1][i] += error*error;
3341  }
3342  }
3343  }
3344  st->info->duration_count++;
3346 
3347  if (st->info->duration_count % 10 == 0) {
3348  int n = st->info->duration_count;
3349  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3350  if (st->info->duration_error[0][1][i] < 1e10) {
3351  double a0 = st->info->duration_error[0][0][i] / n;
3352  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3353  double a1 = st->info->duration_error[1][0][i] / n;
3354  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3355  if (error0 > 0.04 && error1 > 0.04) {
3356  st->info->duration_error[0][1][i] = 2e10;
3357  st->info->duration_error[1][1][i] = 2e10;
3358  }
3359  }
3360  }
3361  }
3362 
3363  // ignore the first 4 values, they might have some random jitter
3364  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3365  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3366  }
3367  if (ts != AV_NOPTS_VALUE)
3368  st->info->last_dts = ts;
3369 
3370  return 0;
3371 }
3372 
3374 {
3375  int i, j;
3376 
3377  for (i = 0; i < ic->nb_streams; i++) {
3378  AVStream *st = ic->streams[i];
3379 
3381  continue;
3382  // the check for tb_unreliable() is not completely correct, since this is not about handling
3383  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3384  // ipmovie.c produces.
3385  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)
3386  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);
3387  if (st->info->duration_count>1 && !st->r_frame_rate.num
3388  && tb_unreliable(st->internal->avctx)) {
3389  int num = 0;
3390  double best_error= 0.01;
3391  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3392 
3393  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3394  int k;
3395 
3396  if (st->info->codec_info_duration &&
3397  st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3398  continue;
3399  if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3400  continue;
3401 
3402  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3403  continue;
3404 
3405  for (k= 0; k<2; k++) {
3406  int n = st->info->duration_count;
3407  double a= st->info->duration_error[k][0][j] / n;
3408  double error= st->info->duration_error[k][1][j]/n - a*a;
3409 
3410  if (error < best_error && best_error> 0.000000001) {
3411  best_error= error;
3412  num = get_std_framerate(j);
3413  }
3414  if (error < 0.02)
3415  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3416  }
3417  }
3418  // do not increase frame rate by more than 1 % in order to match a standard rate.
3419  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3420  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3421  }
3422  if ( !st->avg_frame_rate.num
3423  && st->r_frame_rate.num && st->info->rfps_duration_sum
3424  && st->info->codec_info_duration <= 0
3425  && st->info->duration_count > 2
3426  && 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
3427  ) {
3428  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3429  st->avg_frame_rate = st->r_frame_rate;
3430  }
3431 
3432  av_freep(&st->info->duration_error);
3433  st->info->last_dts = AV_NOPTS_VALUE;
3434  st->info->duration_count = 0;
3435  st->info->rfps_duration_sum = 0;
3436  }
3437 }
3438 
3440 {
3441  const AVBitStreamFilter *f;
3442 
3443  f = av_bsf_get_by_name("extract_extradata");
3444  if (!f)
3445  return 0;
3446 
3447  if (f->codec_ids) {
3448  const enum AVCodecID *ids;
3449  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3450  if (*ids == st->codecpar->codec_id)
3451  return 1;
3452  }
3453 
3454  return 0;
3455 }
3456 
3458 {
3459  AVStreamInternal *i = st->internal;
3460  const AVBitStreamFilter *f;
3461  int ret;
3462 
3463  f = av_bsf_get_by_name("extract_extradata");
3464  if (!f)
3465  goto finish;
3466 
3467  /* check that the codec id is supported */
3468  ret = extract_extradata_check(st);
3469  if (!ret)
3470  goto finish;
3471 
3473  if (!i->extract_extradata.pkt)
3474  return AVERROR(ENOMEM);
3475 
3476  ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3477  if (ret < 0)
3478  goto fail;
3479 
3481  st->codecpar);
3482  if (ret < 0)
3483  goto fail;
3484 
3486 
3487  /* if init fails here, we assume extracting extradata is just not
3488  * supported for this codec, so we return success */
3489  ret = av_bsf_init(i->extract_extradata.bsf);
3490  if (ret < 0) {
3492  ret = 0;
3493  }
3494 
3495 finish:
3496  i->extract_extradata.inited = 1;
3497 
3498  return 0;
3499 fail:
3502  return ret;
3503 }
3504 
3506 {
3507  AVStreamInternal *i = st->internal;
3508  AVPacket *pkt_ref;
3509  int ret;
3510 
3511  if (!i->extract_extradata.inited) {
3512  ret = extract_extradata_init(st);
3513  if (ret < 0)
3514  return ret;
3515  }
3516 
3518  return 0;
3519 
3520  pkt_ref = i->extract_extradata.pkt;
3521  ret = av_packet_ref(pkt_ref, pkt);
3522  if (ret < 0)
3523  return ret;
3524 
3525  ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3526  if (ret < 0) {
3527  av_packet_unref(pkt_ref);
3528  return ret;
3529  }
3530 
3531  while (ret >= 0 && !i->avctx->extradata) {
3532  int extradata_size;
3533  uint8_t *extradata;
3534 
3535  ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3536  if (ret < 0) {
3537  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3538  return ret;
3539  continue;
3540  }
3541 
3543  &extradata_size);
3544 
3545  if (extradata) {
3546  av_assert0(!i->avctx->extradata);
3547  if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3548  i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3549  if (!i->avctx->extradata) {
3550  av_packet_unref(pkt_ref);
3551  return AVERROR(ENOMEM);
3552  }
3553  memcpy(i->avctx->extradata, extradata, extradata_size);
3554  i->avctx->extradata_size = extradata_size;
3555  }
3556  av_packet_unref(pkt_ref);
3557  }
3558 
3559  return 0;
3560 }
3561 
3563 {
3564  int i, count = 0, ret = 0, j;
3565  int64_t read_size;
3566  AVStream *st;
3567  AVCodecContext *avctx;
3568  AVPacket pkt1, *pkt;
3569  int64_t old_offset = avio_tell(ic->pb);
3570  // new streams might appear, no options for those
3571  int orig_nb_streams = ic->nb_streams;
3572  int flush_codecs;
3573  int64_t max_analyze_duration = ic->max_analyze_duration;
3574  int64_t max_stream_analyze_duration;
3575  int64_t max_subtitle_analyze_duration;
3576  int64_t probesize = ic->probesize;
3577  int eof_reached = 0;
3578  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3579 
3580  flush_codecs = probesize > 0;
3581 
3582  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3583 
3584  max_stream_analyze_duration = max_analyze_duration;
3585  max_subtitle_analyze_duration = max_analyze_duration;
3586  if (!max_analyze_duration) {
3587  max_stream_analyze_duration =
3588  max_analyze_duration = 5*AV_TIME_BASE;
3589  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3590  if (!strcmp(ic->iformat->name, "flv"))
3591  max_stream_analyze_duration = 90*AV_TIME_BASE;
3592  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3593  max_stream_analyze_duration = 7*AV_TIME_BASE;
3594  }
3595 
3596  if (ic->pb)
3597  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3598  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3599 
3600  for (i = 0; i < ic->nb_streams; i++) {
3601  const AVCodec *codec;
3602  AVDictionary *thread_opt = NULL;
3603  st = ic->streams[i];
3604  avctx = st->internal->avctx;
3605 
3606  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3608 /* if (!st->time_base.num)
3609  st->time_base = */
3610  if (!avctx->time_base.num)
3611  avctx->time_base = st->time_base;
3612  }
3613 
3614  /* check if the caller has overridden the codec id */
3615 #if FF_API_LAVF_AVCTX
3617  if (st->codec->codec_id != st->internal->orig_codec_id) {
3618  st->codecpar->codec_id = st->codec->codec_id;
3619  st->codecpar->codec_type = st->codec->codec_type;
3620  st->internal->orig_codec_id = st->codec->codec_id;
3621  }
3623 #endif
3624  // only for the split stuff
3625  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3626  st->parser = av_parser_init(st->codecpar->codec_id);
3627  if (st->parser) {
3628  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3630  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3632  }
3633  } else if (st->need_parsing) {
3634  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3635  "%s, packets or times may be invalid.\n",
3637  }
3638  }
3639 
3640  if (st->codecpar->codec_id != st->internal->orig_codec_id)
3642 
3643  ret = avcodec_parameters_to_context(avctx, st->codecpar);
3644  if (ret < 0)
3645  goto find_stream_info_err;
3646  if (st->request_probe <= 0)
3647  st->internal->avctx_inited = 1;
3648 
3649  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3650 
3651  /* Force thread count to 1 since the H.264 decoder will not extract
3652  * SPS and PPS to extradata during multi-threaded decoding. */
3653  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3654 
3655  if (ic->codec_whitelist)
3656  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3657 
3658  /* Ensure that subtitle_header is properly set. */
3660  && codec && !avctx->codec) {
3661  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3662  av_log(ic, AV_LOG_WARNING,
3663  "Failed to open codec in %s\n",__FUNCTION__);
3664  }
3665 
3666  // Try to just open decoders, in case this is enough to get parameters.
3667  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3668  if (codec && !avctx->codec)
3669  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3670  av_log(ic, AV_LOG_WARNING,
3671  "Failed to open codec in %s\n",__FUNCTION__);
3672  }
3673  if (!options)
3674  av_dict_free(&thread_opt);
3675  }
3676 
3677  for (i = 0; i < ic->nb_streams; i++) {
3678 #if FF_API_R_FRAME_RATE
3679  ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3680 #endif
3683  }
3684 
3685  read_size = 0;
3686  for (;;) {
3687  int analyzed_all_streams;
3689  ret = AVERROR_EXIT;
3690  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3691  break;
3692  }
3693 
3694  /* check if one codec still needs to be handled */
3695  for (i = 0; i < ic->nb_streams; i++) {
3696  int fps_analyze_framecount = 20;
3697  int count;
3698 
3699  st = ic->streams[i];
3700  if (!has_codec_parameters(st, NULL))
3701  break;
3702  /* If the timebase is coarse (like the usual millisecond precision
3703  * of mkv), we need to analyze more frames to reliably arrive at
3704  * the correct fps. */
3705  if (av_q2d(st->time_base) > 0.0005)
3706  fps_analyze_framecount *= 2;
3707  if (!tb_unreliable(st->internal->avctx))
3708  fps_analyze_framecount = 0;
3709  if (ic->fps_probe_size >= 0)
3710  fps_analyze_framecount = ic->fps_probe_size;
3712  fps_analyze_framecount = 0;
3713  /* variable fps and no guess at the real fps */
3714  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3716  st->info->duration_count;
3717  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3719  if (count < fps_analyze_framecount)
3720  break;
3721  }
3722  // Look at the first 3 frames if there is evidence of frame delay
3723  // but the decoder delay is not set.
3724  if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3725  break;
3726  if (!st->internal->avctx->extradata &&
3728  st->internal->extract_extradata.bsf) &&
3730  break;
3731  if (st->first_dts == AV_NOPTS_VALUE &&
3732  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3736  break;
3737  }
3738  analyzed_all_streams = 0;
3739  if (!missing_streams || !*missing_streams)
3740  if (i == ic->nb_streams) {
3741  analyzed_all_streams = 1;
3742  /* NOTE: If the format has no header, then we need to read some
3743  * packets to get most of the streams, so we cannot stop here. */
3744  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3745  /* If we found the info for all the codecs, we can stop. */
3746  ret = count;
3747  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3748  flush_codecs = 0;
3749  break;
3750  }
3751  }
3752  /* We did not get all the codec info, but we read too much data. */
3753  if (read_size >= probesize) {
3754  ret = count;
3755  av_log(ic, AV_LOG_DEBUG,
3756  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3757  for (i = 0; i < ic->nb_streams; i++)
3758  if (!ic->streams[i]->r_frame_rate.num &&
3759  ic->streams[i]->info->duration_count <= 1 &&
3761  strcmp(ic->iformat->name, "image2"))
3762  av_log(ic, AV_LOG_WARNING,
3763  "Stream #%d: not enough frames to estimate rate; "
3764  "consider increasing probesize\n", i);
3765  break;
3766  }
3767 
3768  /* NOTE: A new stream can be added there if no header in file
3769  * (AVFMTCTX_NOHEADER). */
3770  ret = read_frame_internal(ic, &pkt1);
3771  if (ret == AVERROR(EAGAIN))
3772  continue;
3773 
3774  if (ret < 0) {
3775  /* EOF or error*/
3776  eof_reached = 1;
3777  break;
3778  }
3779 
3780  pkt = &pkt1;
3781 
3782  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3785  pkt, 0);
3786  if (ret < 0)
3787  goto find_stream_info_err;
3788  }
3789 
3790  st = ic->streams[pkt->stream_index];
3792  read_size += pkt->size;
3793 
3794  avctx = st->internal->avctx;
3795  if (!st->internal->avctx_inited) {
3796  ret = avcodec_parameters_to_context(avctx, st->codecpar);
3797  if (ret < 0)
3798  goto find_stream_info_err;
3799  st->internal->avctx_inited = 1;
3800  }
3801 
3802  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3803  /* check for non-increasing dts */
3804  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3805  st->info->fps_last_dts >= pkt->dts) {
3806  av_log(ic, AV_LOG_DEBUG,
3807  "Non-increasing DTS in stream %d: packet %d with DTS "
3808  "%"PRId64", packet %d with DTS %"PRId64"\n",
3809  st->index, st->info->fps_last_dts_idx,
3811  pkt->dts);
3812  st->info->fps_first_dts =
3814  }
3815  /* Check for a discontinuity in dts. If the difference in dts
3816  * is more than 1000 times the average packet duration in the
3817  * sequence, we treat it as a discontinuity. */
3818  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3820  (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3821  (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3822  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3823  av_log(ic, AV_LOG_WARNING,
3824  "DTS discontinuity in stream %d: packet %d with DTS "
3825  "%"PRId64", packet %d with DTS %"PRId64"\n",
3826  st->index, st->info->fps_last_dts_idx,
3828  pkt->dts);
3829  st->info->fps_first_dts =
3831  }
3832 
3833  /* update stored dts values */
3834  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3835  st->info->fps_first_dts = pkt->dts;
3837  }
3838  st->info->fps_last_dts = pkt->dts;
3840  }
3841  if (st->codec_info_nb_frames>1) {
3842  int64_t t = 0;
3843  int64_t limit;
3844 
3845  if (st->time_base.den > 0)
3847  if (st->avg_frame_rate.num > 0)
3849 
3850  if ( t == 0
3851  && st->codec_info_nb_frames>30
3852  && st->info->fps_first_dts != AV_NOPTS_VALUE
3853  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3855 
3856  if (analyzed_all_streams) limit = max_analyze_duration;
3857  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3858  else limit = max_stream_analyze_duration;
3859 
3860  if (t >= limit) {
3861  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3862  limit,
3863  t, pkt->stream_index);
3864  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3865  av_packet_unref(pkt);
3866  break;
3867  }
3868  if (pkt->duration) {
3869  if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3870  st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3871  } else
3872  st->info->codec_info_duration += pkt->duration;
3873  st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3874  }
3875  }
3876  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3877 #if FF_API_R_FRAME_RATE
3878  ff_rfps_add_frame(ic, st, pkt->dts);
3879 #endif
3880  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3881  st->info->frame_delay_evidence = 1;
3882  }
3883  if (!st->internal->avctx->extradata) {
3884  ret = extract_extradata(st, pkt);
3885  if (ret < 0)
3886  goto find_stream_info_err;
3887  }
3888 
3889  /* If still no information, we try to open the codec and to
3890  * decompress the frame. We try to avoid that in most cases as
3891  * it takes longer and uses more memory. For MPEG-4, we need to
3892  * decompress for QuickTime.
3893  *
3894  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3895  * least one frame of codec data, this makes sure the codec initializes
3896  * the channel configuration and does not only trust the values from
3897  * the container. */
3898  try_decode_frame(ic, st, pkt,
3899  (options && i < orig_nb_streams) ? &options[i] : NULL);
3900 
3901  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3902  av_packet_unref(pkt);
3903 
3904  st->codec_info_nb_frames++;
3905  count++;
3906  }
3907 
3908  if (eof_reached) {
3909  int stream_index;
3910  for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3911  st = ic->streams[stream_index];
3912  avctx = st->internal->avctx;
3913  if (!has_codec_parameters(st, NULL)) {
3914  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3915  if (codec && !avctx->codec) {
3916  AVDictionary *opts = NULL;
3917  if (ic->codec_whitelist)
3918  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3919  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3920  av_log(ic, AV_LOG_WARNING,
3921  "Failed to open codec in %s\n",__FUNCTION__);
3922  av_dict_free(&opts);
3923  }
3924  }
3925 
3926  // EOF already reached while reading the stream above.
3927  // So continue with reoordering DTS with whatever delay we have.
3929  update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3930  }
3931  }
3932  }
3933 
3934  if (flush_codecs) {
3935  AVPacket empty_pkt = { 0 };
3936  int err = 0;
3937  av_init_packet(&empty_pkt);
3938 
3939  for (i = 0; i < ic->nb_streams; i++) {
3940 
3941  st = ic->streams[i];
3942 
3943  /* flush the decoders */
3944  if (st->info->found_decoder == 1) {
3945  do {
3946  err = try_decode_frame(ic, st, &empty_pkt,
3947  (options && i < orig_nb_streams)
3948  ? &options[i] : NULL);
3949  } while (err > 0 && !has_codec_parameters(st, NULL));
3950 
3951  if (err < 0) {
3952  av_log(ic, AV_LOG_INFO,
3953  "decoding for stream %d failed\n", st->index);
3954  }
3955  }
3956  }
3957  }
3958 
3959  ff_rfps_calculate(ic);
3960 
3961  for (i = 0; i < ic->nb_streams; i++) {
3962  st = ic->streams[i];
3963  avctx = st->internal->avctx;
3964  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3965  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3966  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3968  avctx->codec_tag= tag;
3969  }
3970 
3971  /* estimate average framerate if not set by demuxer */
3972  if (st->info->codec_info_duration_fields &&
3973  !st->avg_frame_rate.num &&
3974  st->info->codec_info_duration) {
3975  int best_fps = 0;
3976  double best_error = 0.01;
3977  AVRational codec_frame_rate = avctx->framerate;
3978 
3979  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3980  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3981  st->info->codec_info_duration < 0)
3982  continue;
3984  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3985  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3986 
3987  /* Round guessed framerate to a "standard" framerate if it's
3988  * within 1% of the original estimate. */
3989  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3990  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3991  double error = fabs(av_q2d(st->avg_frame_rate) /
3992  av_q2d(std_fps) - 1);
3993 
3994  if (error < best_error) {
3995  best_error = error;
3996  best_fps = std_fps.num;
3997  }
3998 
3999  if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4000  error = fabs(av_q2d(codec_frame_rate) /
4001  av_q2d(std_fps) - 1);
4002  if (error < best_error) {
4003  best_error = error;
4004  best_fps = std_fps.num;
4005  }
4006  }
4007  }
4008  if (best_fps)
4010  best_fps, 12 * 1001, INT_MAX);
4011  }
4012 
4013  if (!st->r_frame_rate.num) {
4014  if ( avctx->time_base.den * (int64_t) st->time_base.num
4015  <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
4017  avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4018  } else {
4019  st->r_frame_rate.num = st->time_base.den;
4020  st->r_frame_rate.den = st->time_base.num;
4021  }
4022  }
4024  AVRational hw_ratio = { avctx->height, avctx->width };
4026  hw_ratio);
4027  }
4028  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4029  if (!avctx->bits_per_coded_sample)
4030  avctx->bits_per_coded_sample =
4032  // set stream disposition based on audio service type
4033  switch (avctx->audio_service_type) {
4036  break;
4039  break;
4042  break;
4045  break;
4048  break;
4049  }
4050  }
4051  }
4052 
4053  if (probesize)
4054  estimate_timings(ic, old_offset);
4055 
4056  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4057 
4058  if (ret >= 0 && ic->nb_streams)
4059  /* We could not have all the codec parameters before EOF. */
4060  ret = -1;
4061  for (i = 0; i < ic->nb_streams; i++) {
4062  const char *errmsg;
4063  st = ic->streams[i];
4064 
4065  /* if no packet was ever seen, update context now for has_codec_parameters */
4066  if (!st->internal->avctx_inited) {
4067  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4069  st->codecpar->format = st->internal->avctx->sample_fmt;
4071  if (ret < 0)
4072  goto find_stream_info_err;
4073  }
4074  if (!has_codec_parameters(st, &errmsg)) {
4075  char buf[256];
4076  avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4077  av_log(ic, AV_LOG_WARNING,
4078  "Could not find codec parameters for stream %d (%s): %s\n"
4079  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4080  i, buf, errmsg);
4081  } else {
4082  ret = 0;
4083  }
4084  }
4085 
4087 
4088  /* update the stream parameters from the internal codec contexts */
4089  for (i = 0; i < ic->nb_streams; i++) {
4090  st = ic->streams[i];
4091 
4092  if (st->internal->avctx_inited) {
4093  int orig_w = st->codecpar->width;
4094  int orig_h = st->codecpar->height;
4096  if (ret < 0)
4097  goto find_stream_info_err;
4098 #if FF_API_LOWRES
4099  // The decoder might reduce the video size by the lowres factor.
4100  if (st->internal->avctx->lowres && orig_w) {
4101  st->codecpar->width = orig_w;
4102  st->codecpar->height = orig_h;
4103  }
4104 #endif
4105  }
4106 
4107 #if FF_API_LAVF_AVCTX
4109  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4110  if (ret < 0)
4111  goto find_stream_info_err;
4112 
4113 #if FF_API_LOWRES
4114  // The old API (AVStream.codec) "requires" the resolution to be adjusted
4115  // by the lowres factor.
4116  if (st->internal->avctx->lowres && st->internal->avctx->width) {
4117  st->codec->lowres = st->internal->avctx->lowres;
4118  st->codec->width = st->internal->avctx->width;
4119  st->codec->height = st->internal->avctx->height;
4120  }
4121 #endif
4122 
4123  if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4124  st->codec->time_base = st->internal->avctx->time_base;
4125  st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4126  }
4127  st->codec->framerate = st->avg_frame_rate;
4128 
4129  if (st->internal->avctx->subtitle_header) {
4130  st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4131  if (!st->codec->subtitle_header)
4132  goto find_stream_info_err;
4133  st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4134  memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4135  st->codec->subtitle_header_size);
4136  }
4137 
4138  // Fields unavailable in AVCodecParameters
4139  st->codec->coded_width = st->internal->avctx->coded_width;
4140  st->codec->coded_height = st->internal->avctx->coded_height;
4141  st->codec->properties = st->internal->avctx->properties;
4143 #endif
4144 
4145  st->internal->avctx_inited = 0;
4146  }
4147 
4148 find_stream_info_err:
4149  for (i = 0; i < ic->nb_streams; i++) {
4150  st = ic->streams[i];
4151  if (st->info)
4152  av_freep(&st->info->duration_error);
4153  avcodec_close(ic->streams[i]->internal->avctx);
4154  av_freep(&ic->streams[i]->info);
4157  }
4158  if (ic->pb)
4159  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4160  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4161  return ret;
4162 }
4163 
4165 {
4166  int i, j;
4167 
4168  for (i = 0; i < ic->nb_programs; i++) {
4169  if (ic->programs[i] == last) {
4170  last = NULL;
4171  } else {
4172  if (!last)
4173  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4174  if (ic->programs[i]->stream_index[j] == s)
4175  return ic->programs[i];
4176  }
4177  }
4178  return NULL;
4179 }
4180 
4182  int wanted_stream_nb, int related_stream,
4183  AVCodec **decoder_ret, int flags)
4184 {
4185  int i, nb_streams = ic->nb_streams;
4186  int ret = AVERROR_STREAM_NOT_FOUND;
4187  int best_count = -1, best_multiframe = -1, best_disposition = -1;
4188  int count, multiframe, disposition;
4189  int64_t best_bitrate = -1;
4190  int64_t bitrate;
4191  unsigned *program = NULL;
4192  const AVCodec *decoder = NULL, *best_decoder = NULL;
4193 
4194  if (related_stream >= 0 && wanted_stream_nb < 0) {
4195  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4196  if (p) {
4197  program = p->stream_index;
4198  nb_streams = p->nb_stream_indexes;
4199  }
4200  }
4201  for (i = 0; i < nb_streams; i++) {
4202  int real_stream_index = program ? program[i] : i;
4203  AVStream *st = ic->streams[real_stream_index];
4204  AVCodecParameters *par = st->codecpar;
4205  if (par->codec_type != type)
4206  continue;
4207  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4208  continue;
4209  if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4210  continue;
4211  if (decoder_ret) {
4212  decoder = find_decoder(ic, st, par->codec_id);
4213  if (!decoder) {
4214  if (ret < 0)
4216  continue;
4217  }
4218  }
4220  count = st->codec_info_nb_frames;
4221  bitrate = par->bit_rate;
4222  multiframe = FFMIN(5, count);
4223  if ((best_disposition > disposition) ||
4224  (best_disposition == disposition && best_multiframe > multiframe) ||
4225  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4226  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4227  continue;
4228  best_disposition = disposition;
4229  best_count = count;
4230  best_bitrate = bitrate;
4231  best_multiframe = multiframe;
4232  ret = real_stream_index;
4233  best_decoder = decoder;
4234  if (program && i == nb_streams - 1 && ret < 0) {
4235  program = NULL;
4236  nb_streams = ic->nb_streams;
4237  /* no related stream found, try again with everything */
4238  i = 0;
4239  }
4240  }
4241  if (decoder_ret)
4242  *decoder_ret = (AVCodec*)best_decoder;
4243  return ret;
4244 }
4245 
4246 /*******************************************************/
4247 
4249 {
4250  if (s->iformat->read_play)
4251  return s->iformat->read_play(s);
4252  if (s->pb)
4253  return avio_pause(s->pb, 0);
4254  return AVERROR(ENOSYS);
4255 }
4256 
4258 {
4259  if (s->iformat->read_pause)
4260  return s->iformat->read_pause(s);
4261  if (s->pb)
4262  return avio_pause(s->pb, 1);
4263  return AVERROR(ENOSYS);
4264 }
4265 
4267 {
4268  int ret, i;
4269 
4270  dst->id = src->id;
4271  dst->time_base = src->time_base;
4272  dst->nb_frames = src->nb_frames;
4273  dst->disposition = src->disposition;
4275  dst->avg_frame_rate = src->avg_frame_rate;
4276  dst->r_frame_rate = src->r_frame_rate;
4277 
4278  av_dict_free(&dst->metadata);
4279  ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4280  if (ret < 0)
4281  return ret;
4282 
4283  ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4284  if (ret < 0)
4285  return ret;
4286 
4287  /* Free existing side data*/
4288  for (i = 0; i < dst->nb_side_data; i++)
4289  av_free(dst->side_data[i].data);
4290  av_freep(&dst->side_data);
4291  dst->nb_side_data = 0;
4292 
4293  /* Copy side data if present */
4294  if (src->nb_side_data) {
4296  sizeof(AVPacketSideData));
4297  if (!dst->side_data)
4298  return AVERROR(ENOMEM);
4299  dst->nb_side_data = src->nb_side_data;
4300 
4301  for (i = 0; i < src->nb_side_data; i++) {
4302  uint8_t *data = av_memdup(src->side_data[i].data,
4303  src->side_data[i].size);
4304  if (!data)
4305  return AVERROR(ENOMEM);
4306  dst->side_data[i].type = src->side_data[i].type;
4307  dst->side_data[i].size = src->side_data[i].size;
4308  dst->side_data[i].data = data;
4309  }
4310  }
4311 
4312 #if FF_API_LAVF_FFSERVER
4314  av_freep(&dst->recommended_encoder_configuration);
4315  if (src->recommended_encoder_configuration) {
4316  const char *conf_str = src->recommended_encoder_configuration;
4317  dst->recommended_encoder_configuration = av_strdup(conf_str);
4318  if (!dst->recommended_encoder_configuration)
4319  return AVERROR(ENOMEM);
4320  }
4322 #endif
4323 
4324  return 0;
4325 }
4326 
4327 static void free_stream(AVStream **pst)
4328 {
4329  AVStream *st = *pst;
4330  int i;
4331 
4332  if (!st)
4333  return;
4334 
4335  for (i = 0; i < st->nb_side_data; i++)
4336  av_freep(&st->side_data[i].data);
4337  av_freep(&st->side_data);
4338 
4339  if (st->parser)
4340  av_parser_close(st->parser);
4341 
4342  if (st->attached_pic.data)
4344 
4345  if (st->internal) {
4347  for (i = 0; i < st->internal->nb_bsfcs; i++) {
4348  av_bsf_free(&st->internal->bsfcs[i]);
4349  av_freep(&st->internal->bsfcs);
4350  }
4351  av_freep(&st->internal->priv_pts);
4354  }
4355  av_freep(&st->internal);
4356 
4357  av_dict_free(&st->metadata);
4359  av_freep(&st->probe_data.buf);
4360  av_freep(&st->index_entries);
4361 #if FF_API_LAVF_AVCTX
4363  avcodec_free_context(&st->codec);
4365 #endif
4366  av_freep(&st->priv_data);
4367  if (st->info)
4368  av_freep(&st->info->duration_error);
4369  av_freep(&st->info);
4370 #if FF_API_LAVF_FFSERVER
4372  av_freep(&st->recommended_encoder_configuration);
4374 #endif
4375 
4376  av_freep(pst);
4377 }
4378 
4380 {
4381  av_assert0(s->nb_streams>0);
4382  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4383 
4384  free_stream(&s->streams[ --s->nb_streams ]);
4385 }
4386 
4388 {
4389  int i;
4390 
4391  if (!s)
4392  return;
4393 
4394  av_opt_free(s);
4395  if (s->iformat && s->iformat->priv_class && s->priv_data)
4396  av_opt_free(s->priv_data);
4397  if (s->oformat && s->oformat->priv_class && s->priv_data)
4398  av_opt_free(s->priv_data);
4399 
4400  for (i = s->nb_streams - 1; i >= 0; i--)
4401  ff_free_stream(s, s->streams[i]);
4402 
4403 
4404  for (i = s->nb_programs - 1; i >= 0; i--) {
4405  av_dict_free(&s->programs[i]->metadata);
4406  av_freep(&s->programs[i]->stream_index);
4407  av_freep(&s->programs[i]);
4408  }
4409  av_freep(&s->programs);
4410  av_freep(&s->priv_data);
4411  while (s->nb_chapters--) {
4413  av_freep(&s->chapters[s->nb_chapters]);
4414  }
4415  av_freep(&s->chapters);
4416  av_dict_free(&s->metadata);
4418  av_freep(&s->streams);
4419  flush_packet_queue(s);
4420  av_freep(&s->internal);
4421  av_freep(&s->url);
4422  av_free(s);
4423 }
4424 
4426 {
4427  AVFormatContext *s;
4428  AVIOContext *pb;
4429 
4430  if (!ps || !*ps)
4431  return;
4432 
4433  s = *ps;
4434  pb = s->pb;
4435 
4436  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4437  (s->flags & AVFMT_FLAG_CUSTOM_IO))
4438  pb = NULL;
4439 
4440  flush_packet_queue(s);
4441 
4442  if (s->iformat)
4443  if (s->iformat->read_close)
4444  s->iformat->read_close(s);
4445 
4447 
4448  *ps = NULL;
4449 
4450  avio_close(pb);
4451 }
4452 
4454 {
4455  AVStream *st;
4456  int i;
4457  AVStream **streams;
4458 
4459  if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4460  if (s->max_streams < INT_MAX/sizeof(*streams))
4461  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);
4462  return NULL;
4463  }
4464  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4465  if (!streams)
4466  return NULL;
4467  s->streams = streams;
4468 
4469  st = av_mallocz(sizeof(AVStream));
4470  if (!st)
4471  return NULL;
4472  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4473  av_free(st);
4474  return NULL;
4475  }
4476  st->info->last_dts = AV_NOPTS_VALUE;
4477 
4478 #if FF_API_LAVF_AVCTX
4480  st->codec = avcodec_alloc_context3(c);
4481  if (!st->codec) {
4482  av_free(st->info);
4483  av_free(st);
4484  return NULL;
4485  }
4487 #endif
4488 
4489  st->internal = av_mallocz(sizeof(*st->internal));
4490  if (!st->internal)
4491  goto fail;
4492 
4494  if (!st->codecpar)
4495  goto fail;
4496 
4498  if (!st->internal->avctx)
4499  goto fail;
4500 
4501  if (s->iformat) {
4502 #if FF_API_LAVF_AVCTX
4504  /* no default bitrate if decoding */
4505  st->codec->bit_rate = 0;
4507 #endif
4508 
4509  /* default pts setting is MPEG-like */
4510  avpriv_set_pts_info(st, 33, 1, 90000);
4511  /* we set the current DTS to 0 so that formats without any timestamps
4512  * but durations get some timestamps, formats with some unknown
4513  * timestamps have their first few packets buffered and the
4514  * timestamps corrected before they are returned to the user */
4515  st->cur_dts = RELATIVE_TS_BASE;
4516  } else {
4517  st->cur_dts = AV_NOPTS_VALUE;
4518  }
4519 
4520  st->index = s->nb_streams;
4521  st->start_time = AV_NOPTS_VALUE;
4522  st->duration = AV_NOPTS_VALUE;
4523  st->first_dts = AV_NOPTS_VALUE;
4527 
4530  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4531  st->pts_buffer[i] = AV_NOPTS_VALUE;
4532 
4533  st->sample_aspect_ratio = (AVRational) { 0, 1 };
4534 
4535 #if FF_API_R_FRAME_RATE
4536  st->info->last_dts = AV_NOPTS_VALUE;
4537 #endif
4540 
4542 
4543  st->internal->need_context_update = 1;
4544 
4545  s->streams[s->nb_streams++] = st;
4546  return st;
4547 fail:
4548  free_stream(&st);
4549  return NULL;
4550 }
4551 
4553 {
4554  AVProgram *program = NULL;
4555  int i;
4556 
4557  av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4558 
4559  for (i = 0; i < ac->nb_programs; i++)
4560  if (ac->programs[i]->id == id)
4561  program = ac->programs[i];
4562 
4563  if (!program) {
4564  program = av_mallocz(sizeof(AVProgram));
4565  if (!program)
4566  return NULL;
4567  dynarray_add(&ac->programs, &ac->nb_programs, program);
4568  program->discard = AVDISCARD_NONE;
4569  }
4570  program->id = id;
4573 
4574  program->start_time =
4575  program->end_time = AV_NOPTS_VALUE;
4576 
4577  return program;
4578 }
4579 
4581  int64_t start, int64_t end, const char *title)
4582 {
4583  AVChapter *chapter = NULL;
4584  int i;
4585 
4586  if (end != AV_NOPTS_VALUE && start > end) {
4587  av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4588  return NULL;
4589  }
4590 
4591  for (i = 0; i < s->nb_chapters; i++)
4592  if (s->chapters[i]->id == id)
4593  chapter = s->chapters[i];
4594 
4595  if (!chapter) {
4596  chapter = av_mallocz(sizeof(AVChapter));
4597  if (!chapter)
4598  return NULL;
4599  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4600  }
4601  av_dict_set(&chapter->metadata, "title", title, 0);
4602  chapter->id = id;
4603  chapter->time_base = time_base;
4604  chapter->start = start;
4605  chapter->end = end;
4606 
4607  return chapter;
4608 }
4609 
4610 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4611 {
4612  int i, j;
4613  AVProgram *program = NULL;
4614  void *tmp;
4615 
4616  if (idx >= ac->nb_streams) {
4617  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4618  return;
4619  }
4620 
4621  for (i = 0; i < ac->nb_programs; i++) {
4622  if (ac->programs[i]->id != progid)
4623  continue;
4624  program = ac->programs[i];
4625  for (j = 0; j < program->nb_stream_indexes; j++)
4626  if (program->stream_index[j] == idx)
4627  return;
4628 
4629  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4630  if (!tmp)
4631  return;
4632  program->stream_index = tmp;
4633  program->stream_index[program->nb_stream_indexes++] = idx;
4634  return;
4635  }
4636 }
4637 
4638 uint64_t ff_ntp_time(void)
4639 {
4640  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4641 }
4642 
4643 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4644 {
4645  const char *p;
4646  char *q, buf1[20], c;
4647  int nd, len, percentd_found;
4648 
4649  q = buf;
4650  p = path;
4651  percentd_found = 0;
4652  for (;;) {
4653  c = *p++;
4654  if (c == '\0')
4655  break;
4656  if (c == '%') {
4657  do {
4658  nd = 0;
4659  while (av_isdigit(*p))
4660  nd = nd * 10 + *p++ - '0';
4661  c = *p++;
4662  } while (av_isdigit(c));
4663 
4664  switch (c) {
4665  case '%':
4666  goto addchar;
4667  case 'd':
4668  if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4669  goto fail;
4670  percentd_found = 1;
4671  if (number < 0)
4672  nd += 1;
4673  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4674  len = strlen(buf1);
4675  if ((q - buf + len) > buf_size - 1)
4676  goto fail;
4677  memcpy(q, buf1, len);
4678  q += len;
4679  break;
4680  default:
4681  goto fail;
4682  }
4683  } else {
4684 addchar:
4685  if ((q - buf) < buf_size - 1)
4686  *q++ = c;
4687  }
4688  }
4689  if (!percentd_found)
4690  goto fail;
4691  *q = '\0';
4692  return 0;
4693 fail:
4694  *q = '\0';
4695  return -1;
4696 }
4697 
4698 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4699 {
4700  return av_get_frame_filename2(buf, buf_size, path, number, 0);
4701 }
4702 
4703 void av_url_split(char *proto, int proto_size,
4704  char *authorization, int authorization_size,
4705  char *hostname, int hostname_size,
4706  int *port_ptr, char *path, int path_size, const char *url)
4707 {
4708  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4709 
4710  if (port_ptr)
4711  *port_ptr = -1;
4712  if (proto_size > 0)
4713  proto[0] = 0;
4714  if (authorization_size > 0)
4715  authorization[0] = 0;
4716  if (hostname_size > 0)
4717  hostname[0] = 0;
4718  if (path_size > 0)
4719  path[0] = 0;
4720 
4721  /* parse protocol */
4722  if ((p = strchr(url, ':'))) {
4723  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4724  p++; /* skip ':' */
4725  if (*p == '/')
4726  p++;
4727  if (*p == '/')
4728  p++;
4729  } else {
4730  /* no protocol means plain filename */
4731  av_strlcpy(path, url, path_size);
4732  return;
4733  }
4734 
4735  /* separate path from hostname */
4736  ls = strchr(p, '/');
4737  ls2 = strchr(p, '?');
4738  if (!ls)
4739  ls = ls2;
4740  else if (ls && ls2)
4741  ls = FFMIN(ls, ls2);
4742  if (ls)
4743  av_strlcpy(path, ls, path_size);
4744  else
4745  ls = &p[strlen(p)]; // XXX
4746 
4747  /* the rest is hostname, use that to parse auth/port */
4748  if (ls != p) {
4749  /* authorization (user[:pass]@hostname) */
4750  at2 = p;
4751  while ((at = strchr(p, '@')) && at < ls) {
4752  av_strlcpy(authorization, at2,
4753  FFMIN(authorization_size, at + 1 - at2));
4754  p = at + 1; /* skip '@' */
4755  }
4756 
4757  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4758  /* [host]:port */
4759  av_strlcpy(hostname, p + 1,
4760  FFMIN(hostname_size, brk - p));
4761  if (brk[1] == ':' && port_ptr)
4762  *port_ptr = atoi(brk + 2);
4763  } else if ((col = strchr(p, ':')) && col < ls) {
4764  av_strlcpy(hostname, p,
4765  FFMIN(col + 1 - p, hostname_size));
4766  if (port_ptr)
4767  *port_ptr = atoi(col + 1);
4768  } else
4769  av_strlcpy(hostname, p,
4770  FFMIN(ls + 1 - p, hostname_size));
4771  }
4772 }
4773 
4774 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4775 {
4776  int i;
4777  static const char hex_table_uc[16] = { '0', '1', '2', '3',
4778  '4', '5', '6', '7',
4779  '8', '9', 'A', 'B',
4780  'C', 'D', 'E', 'F' };
4781  static const char hex_table_lc[16] = { '0', '1', '2', '3',
4782  '4', '5', '6', '7',
4783  '8', '9', 'a', 'b',
4784  'c', 'd', 'e', 'f' };
4785  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4786 
4787  for (i = 0; i < s; i++) {
4788  buff[i * 2] = hex_table[src[i] >> 4];
4789  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4790  }
4791 
4792  return buff;
4793 }
4794 
4795 int ff_hex_to_data(uint8_t *data, const char *p)
4796 {
4797  int c, len, v;
4798 
4799  len = 0;
4800  v = 1;
4801  for (;;) {
4802  p += strspn(p, SPACE_CHARS);
4803  if (*p == '\0')
4804  break;
4805  c = av_toupper((unsigned char) *p++);
4806  if (c >= '0' && c <= '9')
4807  c = c - '0';
4808  else if (c >= 'A' && c <= 'F')
4809  c = c - 'A' + 10;
4810  else
4811  break;
4812  v = (v << 4) | c;
4813  if (v & 0x100) {
4814  if (data)
4815  data[len] = v;
4816  len++;
4817  v = 1;
4818  }
4819  }
4820  return len;
4821 }
4822 
4823 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4824  unsigned int pts_num, unsigned int pts_den)
4825 {
4826  AVRational new_tb;
4827  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4828  if (new_tb.num != pts_num)
4830  "st:%d removing common factor %d from timebase\n",
4831  s->index, pts_num / new_tb.num);
4832  } else
4834  "st:%d has too large timebase, reducing\n", s->index);
4835 
4836  if (new_tb.num <= 0 || new_tb.den <= 0) {
4838  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4839  new_tb.num, new_tb.den,
4840  s->index);
4841  return;
4842  }
4843  s->time_base = new_tb;
4844 #if FF_API_LAVF_AVCTX
4846  s->codec->pkt_timebase = new_tb;
4848 #endif
4849  s->internal->avctx->pkt_timebase = new_tb;
4850  s->pts_wrap_bits = pts_wrap_bits;
4851 }
4852 
4853 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4854  void *context)
4855 {
4856  const char *ptr = str;
4857 
4858  /* Parse key=value pairs. */
4859  for (;;) {
4860  const char *key;
4861  char *dest = NULL, *dest_end;
4862  int key_len, dest_len = 0;
4863 
4864  /* Skip whitespace and potential commas. */
4865  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4866  ptr++;
4867  if (!*ptr)
4868  break;
4869 
4870  key = ptr;
4871 
4872  if (!(ptr = strchr(key, '=')))
4873  break;
4874  ptr++;
4875  key_len = ptr - key;
4876 
4877  callback_get_buf(context, key, key_len, &dest, &dest_len);
4878  dest_end = dest + dest_len - 1;
4879 
4880  if (*ptr == '\"') {
4881  ptr++;
4882  while (*ptr && *ptr != '\"') {
4883  if (*ptr == '\\') {
4884  if (!ptr[1])
4885  break;
4886  if (dest && dest < dest_end)
4887  *dest++ = ptr[1];
4888  ptr += 2;
4889  } else {
4890  if (dest && dest < dest_end)
4891  *dest++ = *ptr;
4892  ptr++;
4893  }
4894  }
4895  if (*ptr == '\"')
4896  ptr++;
4897  } else {
4898  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4899  if (dest && dest < dest_end)
4900  *dest++ = *ptr;
4901  }
4902  if (dest)
4903  *dest = 0;
4904  }
4905 }
4906 
4908 {
4909  int i;
4910  for (i = 0; i < s->nb_streams; i++)
4911  if (s->streams[i]->id == id)
4912  return i;
4913  return -1;
4914 }
4915 
4917  int std_compliance)
4918 {
4919  if (ofmt) {
4920  unsigned int codec_tag;
4921  if (ofmt->query_codec)
4922  return ofmt->query_codec(codec_id, std_compliance);
4923  else if (ofmt->codec_tag)
4924  return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4925  else if (codec_id == ofmt->video_codec ||
4926  codec_id == ofmt->audio_codec ||
4927  codec_id == ofmt->subtitle_codec ||
4928  codec_id == ofmt->data_codec)
4929  return 1;
4930  }
4931  return AVERROR_PATCHWELCOME;
4932 }
4933 
4935 {
4936 #if CONFIG_NETWORK
4937  int ret;
4938  if ((ret = ff_network_init()) < 0)
4939  return ret;
4940  if ((ret = ff_tls_init()) < 0)
4941  return ret;
4942 #endif
4943  return 0;
4944 }
4945 
4947 {
4948 #if CONFIG_NETWORK
4949  ff_network_close();
4950  ff_tls_deinit();
4951 #endif
4952  return 0;
4953 }
4954 
4956  uint64_t channel_layout, int32_t sample_rate,
4958 {
4959  uint32_t flags = 0;
4960  int size = 4;
4961  uint8_t *data;
4962  if (!pkt)
4963  return AVERROR(EINVAL);
4964  if (channels) {
4965  size += 4;
4967  }
4968  if (channel_layout) {
4969  size += 8;
4971  }
4972  if (sample_rate) {
4973  size += 4;
4975  }
4976  if (width || height) {
4977  size += 8;
4979  }
4981  if (!data)
4982  return AVERROR(ENOMEM);
4983  bytestream_put_le32(&data, flags);
4984  if (channels)
4985  bytestream_put_le32(&data, channels);
4986  if (channel_layout)
4987  bytestream_put_le64(&data, channel_layout);
4988  if (sample_rate)
4989  bytestream_put_le32(&data, sample_rate);
4990  if (width || height) {
4991  bytestream_put_le32(&data, width);
4992  bytestream_put_le32(&data, height);
4993  }
4994  return 0;
4995 }
4996 
4998 {
4999  AVRational undef = {0, 1};
5000  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5001  AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5002  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5003 
5004  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5005  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5006  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5007  stream_sample_aspect_ratio = undef;
5008 
5009  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5010  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5011  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5012  frame_sample_aspect_ratio = undef;
5013 
5014  if (stream_sample_aspect_ratio.num)
5015  return stream_sample_aspect_ratio;
5016  else
5017  return frame_sample_aspect_ratio;
5018 }
5019 
5021 {
5022  AVRational fr = st->r_frame_rate;
5023  AVRational codec_fr = st->internal->avctx->framerate;
5024  AVRational avg_fr = st->avg_frame_rate;
5025 
5026  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5027  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5028  fr = avg_fr;
5029  }
5030 
5031 
5032  if (st->internal->avctx->ticks_per_frame > 1) {
5033  if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5034  (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))
5035  fr = codec_fr;
5036  }
5037 
5038  return fr;
5039 }
5040 
5042  const char *spec)
5043 {
5044  if (*spec <= '9' && *spec >= '0') /* opt:index */
5045  return strtol(spec, NULL, 0) == st->index;
5046  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5047  *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5048  enum AVMediaType type;
5049  int nopic = 0;
5050 
5051  switch (*spec++) {
5052  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5053  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5054  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5055  case 'd': type = AVMEDIA_TYPE_DATA; break;
5056  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5057  case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5058  default: av_assert0(0);
5059  }
5060 #if FF_API_LAVF_AVCTX
5062  if (type != st->codecpar->codec_type
5063  && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5064  return 0;
5066 #else
5067  if (type != st->codecpar->codec_type)
5068  return 0;
5069 #endif
5070  if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5071  return 0;
5072  if (*spec++ == ':') { /* possibly followed by :index */
5073  int i, index = strtol(spec, NULL, 0);
5074  for (i = 0; i < s->nb_streams; i++) {
5075 #if FF_API_LAVF_AVCTX
5077  if ((s->streams[i]->codecpar->codec_type == type
5078  || s->streams[i]->codec->codec_type == type
5079  ) &&
5080  !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5081  index-- == 0)
5082  return i == st->index;
5084 #else
5085  if ((s->streams[i]->codecpar->codec_type == type) &&
5086  !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5087  index-- == 0)
5088  return i == st->index;
5089 #endif
5090  }
5091  return 0;
5092  }
5093  return 1;
5094  } else if (*spec == 'p' && *(spec + 1) == ':') {
5095  int prog_id, i, j;
5096  char *endptr;
5097  spec += 2;
5098  prog_id = strtol(spec, &endptr, 0);
5099  for (i = 0; i < s->nb_programs; i++) {
5100  if (s->programs[i]->id != prog_id)
5101  continue;
5102 
5103  if (*endptr++ == ':') { // p:<id>:....
5104  if ( *endptr == 'a' || *endptr == 'v' ||
5105  *endptr == 's' || *endptr == 'd') { // p:<id>:<st_type>[:<index>]
5106  enum AVMediaType type;
5107 
5108  switch (*endptr++) {
5109  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5110  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5111  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5112  case 'd': type = AVMEDIA_TYPE_DATA; break;
5113  default: av_assert0(0);
5114  }
5115  if (*endptr++ == ':') { // p:<id>:<st_type>:<index>
5116  int stream_idx = strtol(endptr, NULL, 0), type_counter = 0;
5117  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5118  int stream_index = s->programs[i]->stream_index[j];
5119  if (st->index == s->programs[i]->stream_index[j]) {
5120 #if FF_API_LAVF_AVCTX
5122  return type_counter == stream_idx &&
5123  (type == st->codecpar->codec_type ||
5124  type == st->codec->codec_type);
5126 #else
5127  return type_counter == stream_idx &&
5128  type == st->codecpar->codec_type;
5129 #endif
5130  }
5131 #if FF_API_LAVF_AVCTX
5133  if (type == s->streams[stream_index]->codecpar->codec_type ||
5134  type == s->streams[stream_index]->codec->codec_type)
5135  type_counter++;
5137 #else
5138  if (type == s->streams[stream_index]->codecpar->codec_type)
5139  type_counter++;
5140 #endif
5141  }
5142  return 0;
5143  } else { // p:<id>:<st_type>
5144  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5145  if (st->index == s->programs[i]->stream_index[j]) {
5146 #if FF_API_LAVF_AVCTX
5148  return type == st->codecpar->codec_type ||
5149  type == st->codec->codec_type;
5151 #else
5152  return type == st->codecpar->codec_type;
5153 #endif
5154  }
5155  return 0;
5156  }
5157 
5158  } else if ( *endptr == 'm') { // p:<id>:m:<metadata_spec>
5160  char *key, *val;
5161  int ret = 0;
5162 
5163  if (*(++endptr) != ':') {
5164  av_log(s, AV_LOG_ERROR, "Invalid stream specifier syntax, missing ':' sign after :m.\n");
5165  return AVERROR(EINVAL);
5166  }
5167 
5168  val = strchr(++endptr, ':');
5169  key = val ? av_strndup(endptr, val - endptr) : av_strdup(endptr);
5170  if (!key)
5171  return AVERROR(ENOMEM);
5172 
5173  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5174  if (st->index == s->programs[i]->stream_index[j]) {
5175  tag = av_dict_get(st->metadata, key, NULL, 0);
5176  if (tag && (!val || !strcmp(tag->value, val + 1)))
5177  ret = 1;
5178 
5179  break;
5180  }
5181 
5182  av_freep(&key);
5183  return ret;
5184 
5185  } else { // p:<id>:<index>
5186  int stream_idx = strtol(endptr, NULL, 0);
5187  return stream_idx >= 0 &&
5188  stream_idx < s->programs[i]->nb_stream_indexes &&
5189  st->index == s->programs[i]->stream_index[stream_idx];
5190  }
5191  }
5192 
5193  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5194  if (st->index == s->programs[i]->stream_index[j])
5195  return 1;
5196  }
5197  return 0;
5198  } else if (*spec == '#' ||
5199  (*spec == 'i' && *(spec + 1) == ':')) {
5200  int stream_id;
5201  char *endptr;
5202  spec += 1 + (*spec == 'i');
5203  stream_id = strtol(spec, &endptr, 0);
5204  if (!*endptr)
5205  return stream_id == st->id;
5206  } else if (*spec == 'm' && *(spec + 1) == ':') {
5208  char *key, *val;
5209  int ret;
5210 
5211  spec += 2;
5212  val = strchr(spec, ':');
5213 
5214  key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5215  if (!key)
5216  return AVERROR(ENOMEM);
5217 
5218  tag = av_dict_get(st->metadata, key, NULL, 0);
5219  if (tag) {
5220  if (!val || !strcmp(tag->value, val + 1))
5221  ret = 1;
5222  else
5223  ret = 0;
5224  } else
5225  ret = 0;
5226 
5227  av_freep(&key);
5228  return ret;
5229  } else if (*spec == 'u') {
5230  AVCodecParameters *par = st->codecpar;
5231 #if FF_API_LAVF_AVCTX
5233  AVCodecContext *codec = st->codec;
5235 #endif
5236  int val;
5237  switch (par->codec_type) {
5238  case AVMEDIA_TYPE_AUDIO:
5239  val = par->sample_rate && par->channels;
5240 #if FF_API_LAVF_AVCTX
5241  val = val || (codec->sample_rate && codec->channels);
5242 #endif
5243  if (par->format == AV_SAMPLE_FMT_NONE
5245  && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5246 #endif
5247  )
5248  return 0;
5249  break;
5250  case AVMEDIA_TYPE_VIDEO:
5251  val = par->width && par->height;
5252 #if FF_API_LAVF_AVCTX
5253  val = val || (codec->width && codec->height);
5254 #endif
5255  if (par->format == AV_PIX_FMT_NONE
5257  && codec->pix_fmt == AV_PIX_FMT_NONE
5258 #endif
5259  )
5260  return 0;
5261  break;
5262  case AVMEDIA_TYPE_UNKNOWN:
5263  val = 0;
5264  break;
5265  default:
5266  val = 1;
5267  break;
5268  }
5269 #if FF_API_LAVF_AVCTX
5270  return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5271 #else
5272  return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5273 #endif
5274  } else if (!*spec) /* empty specifier, matches everything */
5275  return 1;
5276 
5277  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5278  return AVERROR(EINVAL);
5279 }
5280 
5282 {
5283  static const uint8_t avci100_1080p_extradata[] = {
5284  // SPS
5285  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5286  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5287  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5288  0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5289  0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5290  0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5291  0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5292  0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5293  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5294  // PPS
5295  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5296  0xd0
5297  };
5298  static const uint8_t avci100_1080i_extradata[] = {
5299  // SPS
5300  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5301  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5302  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5303  0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5304  0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5305  0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5306  0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5307  0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5308  0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5309  0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5310  0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5311  // PPS
5312  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5313  0xd0
5314  };
5315  static const uint8_t avci50_1080p_extradata[] = {
5316  // SPS
5317  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5318  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5319  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5320  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5321  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5322  0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5323  0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5324  0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5325  0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5326  // PPS
5327  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5328  0x11
5329  };
5330  static const uint8_t avci50_1080i_extradata[] = {
5331  // SPS
5332  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5333  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5334  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5335  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5336  0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5337  0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5338  0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5339  0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5340  0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5341  0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5342  0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5343  // PPS
5344  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5345  0x11
5346  };
5347  static const uint8_t avci100_720p_extradata[] = {
5348  // SPS
5349  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5350  0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5351  0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5352  0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5353  0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5354  0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5355  0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5356  0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5357  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5358  0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5359  // PPS
5360  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5361  0x11
5362  };
5363  static const uint8_t avci50_720p_extradata[] = {
5364  // SPS
5365  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5366  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5367  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5368  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5369  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5370  0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5371  0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5372  0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5373  0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5374  // PPS
5375  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5376  0x11
5377  };
5378 
5379  const uint8_t *data = NULL;
5380  int size = 0;
5381 
5382  if (st->codecpar->width == 1920) {
5384  data = avci100_1080p_extradata;
5385  size = sizeof(avci100_1080p_extradata);
5386  } else {
5387  data = avci100_1080i_extradata;
5388  size = sizeof(avci100_1080i_extradata);
5389  }
5390  } else if (st->codecpar->width == 1440) {
5392  data = avci50_1080p_extradata;
5393  size = sizeof(avci50_1080p_extradata);
5394  } else {
5395  data = avci50_1080i_extradata;
5396  size = sizeof(avci50_1080i_extradata);
5397  }
5398  } else if (st->codecpar->width == 1280) {
5399  data = avci100_720p_extradata;
5400  size = sizeof(avci100_720p_extradata);
5401  } else if (st->codecpar->width == 960) {
5402  data = avci50_720p_extradata;
5403  size = sizeof(avci50_720p_extradata);
5404  }
5405 
5406  if (!size)
5407  return 0;
5408 
5409  av_freep(&st->codecpar->extradata);
5410  if (ff_alloc_extradata(st->codecpar, size))
5411  return AVERROR(ENOMEM);
5412  memcpy(st->codecpar->extradata, data, size);
5413 
5414  return 0;
5415 }
5416 
5418  enum AVPacketSideDataType type, int *size)
5419 {
5420  int i;
5421 
5422  for (i = 0; i < st->nb_side_data; i++) {
5423  if (st->side_data[i].type == type) {
5424  if (size)
5425  *size = st->side_data[i].size;
5426  return st->side_data[i].data;
5427  }
5428  }
5429  return NULL;
5430 }
5431 
5433  uint8_t *data, size_t size)
5434 {
5435  AVPacketSideData *sd, *tmp;
5436  int i;
5437 
5438  for (i = 0; i < st->nb_side_data; i++) {
5439  sd = &st->side_data[i];
5440 
5441  if (sd->type == type) {
5442  av_freep(&sd->data);
5443  sd->data = data;
5444  sd->size = size;
5445  return 0;
5446  }
5447  }
5448 
5449  if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5450  return AVERROR(ERANGE);
5451 
5452  tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5453  if (!tmp) {
5454  return AVERROR(ENOMEM);
5455  }
5456 
5457  st->side_data = tmp;
5458  st->nb_side_data++;
5459 
5460  sd = &st->side_data[st->nb_side_data - 1];
5461  sd->type = type;
5462  sd->data = data;
5463  sd->size = size;
5464 
5465  return 0;
5466 }
5467 
5469  int size)
5470 {
5471  int ret;
5472  uint8_t *data = av_malloc(size);
5473 
5474  if (!data)
5475  return NULL;
5476 
5477  ret = av_stream_add_side_data(st, type, data, size);
5478  if (ret < 0) {
5479  av_freep(&data);
5480  return NULL;
5481  }
5482 
5483  return data;
5484 }
5485 
5486 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5487 {
5488  int ret;
5489  const AVBitStreamFilter *bsf;
5490  AVBSFContext *bsfc;
5491  AVCodecParameters *in_par;
5492 
5493  if (!(bsf = av_bsf_get_by_name(name))) {
5494  av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5495  return AVERROR_BSF_NOT_FOUND;
5496  }
5497 
5498  if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5499  return ret;
5500 
5501  if (st->internal->nb_bsfcs) {
5502  in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5503  bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5504  } else {
5505  in_par = st->codecpar;
5506  bsfc->time_base_in = st->time_base;
5507  }
5508 
5509  if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5510  av_bsf_free(&bsfc);
5511  return ret;
5512  }
5513 
5514  if (args && bsfc->filter->priv_class) {
5515  const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5516  const char * shorthand[2] = {NULL};
5517 
5518  if (opt)
5519  shorthand[0] = opt->name;
5520 
5521  if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5522  av_bsf_free(&bsfc);
5523  return ret;
5524  }
5525  }
5526 
5527  if ((ret = av_bsf_init(bsfc)) < 0) {
5528  av_bsf_free(&bsfc);
5529  return ret;
5530  }
5531 
5532  if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5533  av_bsf_free(&bsfc);
5534  return ret;
5535  }
5536 
5538  "Automatically inserted bitstream filter '%s'; args='%s'\n",
5539  name, args ? args : "");
5540  return 1;
5541 }
5542 
5543 #if FF_API_OLD_BSF
5545 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5547 {
5548  int ret = 0;
5549  while (bsfc) {
5550  AVPacket new_pkt = *pkt;
5551  int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5552  &new_pkt.data, &new_pkt.size,
5553  pkt->data, pkt->size,
5554  pkt->flags & AV_PKT_FLAG_KEY);
5555  if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5556  av_packet_unref(pkt);
5557  memset(pkt, 0, sizeof(*pkt));
5558  return 0;
5559  }
5560  if(a == 0 && new_pkt.data != pkt->data) {
5561  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
5562  if (t) {
5563  memcpy(t, new_pkt.data, new_pkt.size);
5564  memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5565  new_pkt.data = t;
5566  new_pkt.buf = NULL;
5567  a = 1;
5568  } else {
5569  a = AVERROR(ENOMEM);
5570  }
5571  }
5572  if (a > 0) {
5573  new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5575  if (new_pkt.buf) {
5576  pkt->side_data = NULL;
5577  pkt->side_data_elems = 0;
5578  av_packet_unref(pkt);
5579  } else {
5580  av_freep(&new_pkt.data);
5581  a = AVERROR(ENOMEM);
5582  }
5583  }
5584  if (a < 0) {
5585  av_log(codec, AV_LOG_ERROR,
5586  "Failed to open bitstream filter %s for stream %d with codec %s",
5587  bsfc->filter->name, pkt->stream_index,
5588  codec->codec ? codec->codec->name : "copy");
5589  ret = a;
5590  break;
5591  }
5592  *pkt = new_pkt;
5593 
5594  bsfc = bsfc->next;
5595  }
5596  return ret;
5597 }
5599 #endif
5600 
5602 {
5603  if (!s->oformat)
5604  return AVERROR(EINVAL);
5605 
5606  if (!(s->oformat->flags & AVFMT_NOFILE))
5607  return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5608  return 0;
5609 }
5610 
5612 {
5613  if (*pb)
5614  s->io_close(s, *pb);
5615  *pb = NULL;
5616 }
5617 
5618 int ff_is_http_proto(char *filename) {
5619  const char *proto = avio_find_protocol_name(filename);
5620  return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5621 }
5622 
5623 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5624 {
5625  AVDictionaryEntry *entry;
5626  int64_t parsed_timestamp;
5627  int ret;
5628  if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5629  if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5630  *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5631  return 1;
5632  } else {
5633  av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5634  return ret;
5635  }
5636  }
5637  return 0;
5638 }
5639 
5641 {
5642  int64_t timestamp;
5643  int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5644  if (ret == 1)
5645  return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5646  return ret;
5647 }
5648 
5649 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5650 {
5651  uint8_t *side_data;
5652  int size;
5653 
5654  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5655  if (side_data) {
5656  if (size != AVPALETTE_SIZE) {
5657  av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5658  return AVERROR_INVALIDDATA;
5659  }
5660  memcpy(palette, side_data, AVPALETTE_SIZE);
5661  return 1;
5662  }
5663 
5664  if (ret == CONTAINS_PAL) {
5665  int i;
5666  for (i = 0; i < AVPALETTE_COUNT; i++)
5667  palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5668  return 1;
5669  }
5670 
5671  return 0;
5672 }
5673 
5675 {
5676  int ret;
5677  char *str;
5678 
5679  ret = av_bprint_finalize(buf, &str);
5680  if (ret < 0)
5681  return ret;
5682  if (!av_bprint_is_complete(buf)) {
5683  av_free(str);
5684  return AVERROR(ENOMEM);
5685  }
5686 
5687  par->extradata = str;
5688  /* Note: the string is NUL terminated (so extradata can be read as a
5689  * string), but the ending character is not accounted in the size (in
5690  * binary formats you are likely not supposed to mux that character). When
5691  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5692  * zeros. */
5693  par->extradata_size = buf->len;
5694  return 0;
5695 }
5696 
5698  AVStream *ost, const AVStream *ist,
5700 {
5701  //TODO: use [io]st->internal->avctx
5702  const AVCodecContext *dec_ctx = ist->codec;
5703  AVCodecContext *enc_ctx = ost->codec;
5704 
5705  enc_ctx->time_base = ist->time_base;
5706  /*
5707  * Avi is a special case here because it supports variable fps but
5708  * having the fps and timebase differe significantly adds quite some
5709  * overhead
5710  */
5711  if (!strcmp(ofmt->name, "avi")) {
5712 #if FF_API_R_FRAME_RATE
5713  if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5714  && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5715  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5716  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5717  && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5718  || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5719  enc_ctx->time_base.num = ist->r_frame_rate.den;
5720  enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5721  enc_ctx->ticks_per_frame = 2;
5722  } else
5723 #endif
5724  if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5725  && av_q2d(ist->time_base) < 1.0/500
5726  || copy_tb == AVFMT_TBCF_DECODER) {
5727  enc_ctx->time_base = dec_ctx->time_base;
5728  enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5729  enc_ctx->time_base.den *= 2;
5730  enc_ctx->ticks_per_frame = 2;
5731  }
5732  } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5733  && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5734  if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5735  && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5736  && av_q2d(ist->time_base) < 1.0/500
5737  || copy_tb == AVFMT_TBCF_DECODER) {
5738  enc_ctx->time_base = dec_ctx->time_base;
5739  enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5740  }
5741  }
5742 
5743  if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5744  && dec_ctx->time_base.num < dec_ctx->time_base.den
5745  && dec_ctx->time_base.num > 0
5746  && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5747  enc_ctx->time_base = dec_ctx->time_base;
5748  }
5749 
5750  if (ost->avg_frame_rate.num)
5751  enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5752 
5753  av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5754  enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5755 
5756  return 0;
5757 }
5758 
5760 {
5761  // See avformat_transfer_internal_stream_timing_info() TODO.
5762 #if FF_API_LAVF_AVCTX
5764  return st->codec->time_base;
5766 #else
5767  return st->internal->avctx->time_base;
5768 #endif
5769 }
5770 
5772 {
5773  av_assert0(url);
5774  av_freep(&s->url);
5775  s->url = url;
5776 #if FF_API_FORMAT_FILENAME
5778  av_strlcpy(s->filename, url, sizeof(s->filename));
5780 #endif
5781 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1569
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:1550
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:4703
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2486
int64_t probesize
Maximum size of the data read from input for determining the input container format.
Definition: avformat.h:1506
static void free_stream(AVStream **pst)
Definition: utils.c:4327
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:1922
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:994
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:1075
#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:4580
const struct AVCodec * codec
Definition: avcodec.h:1527
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:3040
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:733
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:3965
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:1038
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:5649
const char * s
Definition: avisynth_c.h:768
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:5755
static void update_initial_durations(AVFormatContext *s, AVStream *st, int stream_index, int duration)
Definition: utils.c:1172
AVProbeData probe_data
Definition: avformat.h:1098
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5721
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:863
static int shift(int a, int b)
Definition: sonic.c:82
AVPacketSideDataType
Definition: avcodec.h:1143
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:311
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:218
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1618
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:1705
static int get_std_framerate(int i)
Definition: utils.c:3242
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:1727
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:1143
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1568
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1450
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:101
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:810
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:1100
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:1083
#define NTP_OFFSET_US
Definition: internal.h:237
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2488
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:3960
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:5179
#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:4997
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:1292
int64_t first_discard_sample
If not 0, the first audio sample that should be discarded from the stream.
Definition: avformat.h:1151
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:5601
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3884
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: avcodec.h:5696
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: avformat.h:1175
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:935
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:5687
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:155
int index
stream index in AVFormatContext
Definition: avformat.h:874
int size
Definition: avcodec.h:1431
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:113
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:1719
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2657
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:1102
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:1793
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:5771
#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:4907
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1464
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1727
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:864
void ff_network_close(void)
Definition: network.c:115
int event_flags
Flags for the user to detect events happening on the file.
Definition: avformat.h:1655
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:832
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:486
#define a1
Definition: regdef.h:47
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1007
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
Definition: utils.c:2732
int ff_tls_init(void)
Definition: network.c:30
void * priv_data
Definition: avformat.h:888
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:1011
#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:5154
discard all
Definition: avcodec.h:794
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:975
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:4853
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:1391
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:998
AVDictionary * metadata
Definition: avformat.h:1303
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:697
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:5708
#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:5623
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header. ...
Definition: id3v2.c:1140
#define sample
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1538
AVCodec.
Definition: avcodec.h:3408
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:3876
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:134
static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
Definition: utils.c:2962
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:2915
#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:1203
#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:1640
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:2238
Format I/O context.
Definition: avformat.h:1342
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2975
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:5020
unsigned int nb_stream_indexes
Definition: avformat.h:1265
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:81
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1493
#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:1479
int64_t cur_dts
Definition: avformat.h:1076
#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:201
#define AVFMT_FLAG_DISCARD_CORRUPT
Discard frames marked corrupted.
Definition: avformat.h:1482
static int64_t start_time
Definition: ffplay.c:327
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:2181
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:3950
#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:57
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1286
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:2986
static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: utils.c:715
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1180
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:661
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:1982
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:5697
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:298
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AVPacket pkt
Definition: avformat.h:2000
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int id
unique ID to identify the chapter
Definition: avformat.h:1300
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1448
int id
Format-specific stream ID.
Definition: avformat.h:880
enum AVStreamParseType need_parsing
Definition: avformat.h:1091
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3118
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:5041
int duration_count
Definition: avformat.h:1039
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1474
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:979
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1618
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4453
uint8_t * av_stream_get_side_data(const AVStream *st, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5417
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data)...
Definition: internal.h:644
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:1410
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:2078
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5640
#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:744
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:1210
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:90
const char * name
Definition: avcodec.h:5737
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:1053
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1473
#define DURATION_MAX_RETRY
Definition: utils.c:2786
uint8_t * data
Definition: avcodec.h:1430
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:4552
char * protocol_whitelist
&#39;,&#39; separated list of allowed protocols.
Definition: avformat.h:1900
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:3373
uint32_t tag
Definition: movenc.c:1468
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:4934
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:1600
#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:5618
uint8_t * data
Definition: avcodec.h:1374
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2749
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:2734
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:1263
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:3130
struct AVBitStreamFilterContext * next
Definition: avcodec.h:5666
unsigned int * stream_index
Definition: avformat.h:1264
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1526
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:3986
#define av_log(a,...)
int64_t rfps_duration_sum
Definition: avformat.h:1040
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:648
Duration estimated from bitrate (less accurate)
Definition: avformat.h:1323
unsigned int correct_ts_overflow
Correct single timestamp overflows.
Definition: avformat.h:1741
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1361
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:601
#define FF_API_LAVF_AVCTX
Definition: version.h:65
int64_t start_time
Definition: avformat.h:1279
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3913
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1462
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:4181
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:1061
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:3054
#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:5759
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:3422
#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:4164
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1662
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:1771
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:2003
#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:1495
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1807
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1580
#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:1149
int nb_decoded_frames
Number of internally decoded frames, used internally in libavformat, do not access its lifetime diffe...
Definition: avformat.h:1164
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:5142
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:1660
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:4774
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:3187
#define MAKE_ACCESSORS(str, name, type, field)
Definition: internal.h:91
int64_t pts_wrap_reference
reference dts for wrap detection
Definition: avformat.h:1282
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: avcodec.h:1175
#define AVERROR(e)
Definition: error.h:43
int ffio_set_buf_size(AVIOContext *s, int buf_size)
Definition: aviobuf.c:1081
#define SANE_CHUNK_SIZE
Definition: utils.c:245
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1477
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:5744
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1776
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:1190
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1861
char * url
input or output URL.
Definition: avformat.h:1438
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:709
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:442
int capabilities
Codec capabilities.
Definition: avcodec.h:3427
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int nb_programs
Definition: avformat.h:1519
int last_IP_duration
Definition: avformat.h:1078
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
Definition: utils.c:4248
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:552
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3880
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1413
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1124
AVChapter ** chapters
Definition: avformat.h:1570
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:5727
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:1376
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:3415
int av_match_name(const char *name, const char *names)
Match instances of a name in a comma-separated list of names.
Definition: avstring.c:343
int side_data_elems
Definition: avcodec.h:1442
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:2880
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet. ...
Definition: avformat.h:1134
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:946
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1260
#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:1992
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:1709
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:116
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:1817
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:1493
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1436
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3135
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2224
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3902
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:1787
static int genpts
Definition: ffplay.c:330
static AVPacket flush_pkt
Definition: ffplay.c:358
static int extract_extradata_init(AVStream *st)
Definition: utils.c:3457
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:4916
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1480
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:715
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:4823
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:1398
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:1058
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
Definition: utils.c:4257
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:5674
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: avformat.h:1192
#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:1532
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:1310
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:5432
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:350
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:555
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:205
#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:1942
int width
picture width / height.
Definition: avcodec.h:1690
#define RELATIVE_TS_BASE
Definition: utils.c:93
int64_t offset
byte offset from starting packet start
Definition: avcodec.h:5072
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: avcodec.h:5733
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:4610
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:655
int frame_delay_evidence
Definition: avformat.h:1044
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:175
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:1322
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:309
uint8_t dts_ordered
Definition: avformat.h:1204
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:1656
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5611
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt)
Return the frame duration in seconds.
Definition: utils.c:948
static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
Definition: utils.c:765
int ff_packet_list_put(AVPacketList **packet_buffer, AVPacketList **plast_pktl, AVPacket *pkt, int flags)
Append an AVPacket to the list.
Definition: utils.c:447
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:464
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:49
#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:4266
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2653
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:937
uint8_t * av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type, int size)
Allocate new information from stream.
Definition: utils.c:5468
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1649
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:455
int probe_score
format probing score.
Definition: avformat.h:1764
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don&#39;t avio_close() it.
Definition: avformat.h:1481
enum AVCodecID codec_id
Definition: vaapi_decode.c:362
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
Opaque data information usually sparse.
Definition: avutil.h:205
int64_t skip_initial_bytes
Skip initial bytes when opening stream.
Definition: avformat.h:1734
int(* AVOpenCallback)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Definition: avformat.h:1313
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:535
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:457
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
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:1514
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:1127
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:4698
#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:1198
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:3281
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:833
#define CONTAINS_PAL
Definition: internal.h:690
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:873
#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:1302
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:642
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:4946
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2193
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
uint8_t dts_misordered
Definition: avformat.h:1205
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1158
#define FF_FDEBUG_TS
Definition: avformat.h:1624
#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:1197
int frame_size
Definition: mxfenc.c:1947
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:119
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
int64_t end_time
Definition: avformat.h:1280
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1223
enum AVMediaType codec_type
Definition: avcodec.h:1526
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3108
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:1623
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:1528
struct AVStreamInternal::@221 extract_extradata
#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:1590
int sample_rate
samples per second
Definition: avcodec.h:2173
AVIOContext * pb
I/O context.
Definition: avformat.h:1384
unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
Definition: utils.c:3179
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:1518
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:862
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:592
int io_repositioned
IO repositioned flag.
Definition: avformat.h:1801
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:306
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:1543
static int extract_extradata_check(AVStream *st)
Definition: utils.c:3439
#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:1928
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:4643
int pts_wrap_behavior
behavior on wrap detection
Definition: avformat.h:1283
void * buf
Definition: avisynth_c.h:690
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: avformat.h:1041
int extradata_size
Definition: avcodec.h:1619
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:1104
int coded_height
Definition: avcodec.h:1705
enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
Definition: utils.c:3204
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:4795
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:3505
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:338
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:2021
int64_t last_dts
Definition: avformat.h:1037
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: avformat.h:1217
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1259
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:4638
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2487
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:1347
AVMediaType
Definition: avutil.h:199
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5281
int short_seek_threshold
Threshold to favor readahead over seek.
Definition: avio.h:304
int64_t fps_last_dts
Definition: avformat.h:1060
#define RAW_PACKET_BUFFER_SIZE
Remaining size available for raw_packet_buffer, in bytes.
Definition: internal.h:100
static int seek_frame_internal(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c:2462
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:538
#define snprintf
Definition: snprintf.h:34
int found_decoder
0 -> decoder has not been searched for yet.
Definition: avformat.h:1051
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4387
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:1700
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:3047
static int has_duration(AVFormatContext *ic)
Return TRUE if the stream has accurate duration in any stream.
Definition: utils.c:2599
int avio_pause(AVIOContext *h, int pause)
Pause and resume playing - only meaningful if using a network streaming protocol (e.g.
Definition: aviobuf.c:1235
Round toward -infinity.
Definition: mathematics.h:82
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: utils.c:2529
static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
Definition: utils.c:3010
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:5088
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:699
int seek2any
Force seeking to any (also non key) frames.
Definition: avformat.h:1748
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:1266
int64_t codec_info_duration
Definition: avformat.h:1042
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:890
int fps_first_dts_idx
Definition: avformat.h:1059
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1447
uint8_t level
Definition: svq3.c:207
Duration accurately estimated from PTSes.
Definition: avformat.h:1321
#define LICENSE_PREFIX
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:1302
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
#define PARSER_FLAG_ONCE
Definition: avcodec.h:5067
int sample_rate
Audio only.
Definition: avcodec.h:3994
enum AVMediaType type
Definition: avcodec.h:701
static int is_relative(int64_t ts)
Definition: utils.c:95
static int tb_unreliable(AVCodecContext *c)
Definition: utils.c:3266
static AVStream * ost
Main libavformat public API header.
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: avcodec.h:1441
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:1459
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1545
#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:1469
const OptionDef options[]
Definition: ffmpeg_opt.c:3292
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
struct AVPacketList * next
Definition: avformat.h:2001
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:1187
#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:3562
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:912
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:1809
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:1607
static AVCodecContext * dec_ctx
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:926
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:1065
Bi-dir predicted.
Definition: avutil.h:276
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:4379
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: utils.c:3315
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1301
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:5066
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:3162
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:924
int den
Denominator.
Definition: rational.h:60
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: avcodec.h:1463
unsigned bps
Definition: movenc.c:1469
struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1354
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
Definition: utils.c:4425
#define FFMPEG_CONFIGURATION
Definition: config.h:4
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:862
int64_t codec_info_duration_fields
Definition: avformat.h:1043
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:773
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1167
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:1105
struct AVStream::@207 * info
Stream information used internally by avformat_find_stream_info()
#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:1129
int64_t frame_offset
Definition: avcodec.h:5035
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:3299
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:1871
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:477
void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
Definition: id3v2.c:1112
char * value
Definition: dict.h:87
AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1825
#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:2174
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:517
char * codec_whitelist
&#39;,&#39; separated list of allowed decoders.
Definition: avformat.h:1779
struct AVCodecParserContext * parser
Definition: avformat.h:1092
int format
The format of the coded data, corresponds to enum AVPixelFormat for video and for enum AVSampleFormat...
Definition: avcodec.h:5196
void * priv_data
Format private data.
Definition: avformat.h:1370
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: avformat.h:1088
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:293
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: avcodec.h:1041
#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:3898
AVDiscard
Definition: avcodec.h:785
int channels
Audio only.
Definition: avcodec.h:3990
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:1429
const struct AVBitStreamFilter * filter
Definition: avcodec.h:5664
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:1935
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:5050
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1457
int avformat_flush(AVFormatContext *s)
Discard all internally buffered data.
Definition: utils.c:2586
int64_t last_IP_pts
Definition: avformat.h:1077
void ff_tls_deinit(void)
Definition: network.c:45
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:3215
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1020
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:3888
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:1061
int stream_index
Definition: avcodec.h:1432
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:902
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:5486
#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:928
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:4955
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:997
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:1124
#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:1712
This structure stores compressed data.
Definition: avcodec.h:1407
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: aviobuf.c:1215
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5715
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:5081
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:1478
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:1032
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1423
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:955
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:1520
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:5070
#define AVFMT_NEEDNUMBER
Needs &#39;d&#39; in filename.
Definition: avformat.h:466
discard nothing
Definition: avcodec.h:788
#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:2985
static uint8_t tmp[11]
Definition: aes_ctr.c:26