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