FFmpeg  4.2.2
utils.c
Go to the documentation of this file.
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdarg.h>
23 #include <stdint.h>
24 
25 #include "config.h"
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/thread.h"
36 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
39 
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
43 
44 #include "audiointerleave.h"
45 #include "avformat.h"
46 #include "avio_internal.h"
47 #include "id3v2.h"
48 #include "internal.h"
49 #include "metadata.h"
50 #if CONFIG_NETWORK
51 #include "network.h"
52 #endif
53 #include "riff.h"
54 #include "url.h"
55 
56 #include "libavutil/ffversion.h"
57 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
58 
60 
61 /**
62  * @file
63  * various utility functions for use within FFmpeg
64  */
65 
66 unsigned avformat_version(void)
67 {
70 }
71 
72 const char *avformat_configuration(void)
73 {
74  return FFMPEG_CONFIGURATION;
75 }
76 
77 const char *avformat_license(void)
78 {
79 #define LICENSE_PREFIX "libavformat license: "
80  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
81 }
82 
84 {
85  return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
86 }
87 
89 {
90  return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
91 }
92 
93 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
94 
95 static int is_relative(int64_t ts) {
96  return ts > (RELATIVE_TS_BASE - (1LL<<48));
97 }
98 
99 /**
100  * Wrap a given time stamp, if there is an indication for an overflow
101  *
102  * @param st stream
103  * @param timestamp the time stamp to wrap
104  * @return resulting time stamp
105  */
106 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
107 {
109  st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
111  timestamp < st->pts_wrap_reference)
112  return timestamp + (1ULL << st->pts_wrap_bits);
113  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
114  timestamp >= st->pts_wrap_reference)
115  return timestamp - (1ULL << st->pts_wrap_bits);
116  }
117  return timestamp;
118 }
119 
120 #if FF_API_FORMAT_GET_SET
121 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
122 #if FF_API_LAVF_FFSERVER
124 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
126 #endif
129 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
131 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
132 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
134 #if FF_API_OLD_OPEN_CALLBACKS
138 #endif
139 #endif
140 
141 int64_t av_stream_get_end_pts(const AVStream *st)
142 {
143  if (st->internal->priv_pts) {
144  return st->internal->priv_pts->val;
145  } else
146  return AV_NOPTS_VALUE;
147 }
148 
150 {
151  return st->parser;
152 }
153 
155 {
156  int i;
158  for (i = 0; i < s->nb_streams; i++) {
159  AVStream *st = s->streams[i];
160  st->inject_global_side_data = 1;
161  }
162 }
163 
165 {
166  av_assert0(!dst->codec_whitelist &&
167  !dst->format_whitelist &&
168  !dst->protocol_whitelist &&
169  !dst->protocol_blacklist);
170  dst-> codec_whitelist = av_strdup(src->codec_whitelist);
174  if ( (src-> codec_whitelist && !dst-> codec_whitelist)
175  || (src-> format_whitelist && !dst-> format_whitelist)
176  || (src->protocol_whitelist && !dst->protocol_whitelist)
177  || (src->protocol_blacklist && !dst->protocol_blacklist)) {
178  av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
179  return AVERROR(ENOMEM);
180  }
181  return 0;
182 }
183 
185 {
186 #if FF_API_LAVF_AVCTX
188  if (st->codec->codec)
189  return st->codec->codec;
191 #endif
192 
193  switch (st->codecpar->codec_type) {
194  case AVMEDIA_TYPE_VIDEO:
195  if (s->video_codec) return s->video_codec;
196  break;
197  case AVMEDIA_TYPE_AUDIO:
198  if (s->audio_codec) return s->audio_codec;
199  break;
201  if (s->subtitle_codec) return s->subtitle_codec;
202  break;
203  }
204 
205  return avcodec_find_decoder(codec_id);
206 }
207 
209 {
210  const AVCodec *codec;
211 
212 #if CONFIG_H264_DECODER
213  /* Other parts of the code assume this decoder to be used for h264,
214  * so force it if possible. */
215  if (codec_id == AV_CODEC_ID_H264)
216  return avcodec_find_decoder_by_name("h264");
217 #endif
218 
219  codec = find_decoder(s, st, codec_id);
220  if (!codec)
221  return NULL;
222 
224  const AVCodec *probe_codec = NULL;
225  while (probe_codec = av_codec_next(probe_codec)) {
226  if (probe_codec->id == codec_id &&
227  av_codec_is_decoder(probe_codec) &&
229  return probe_codec;
230  }
231  }
232  }
233 
234  return codec;
235 }
236 
237 #if FF_API_FORMAT_GET_SET
238 int av_format_get_probe_score(const AVFormatContext *s)
239 {
240  return s->probe_score;
241 }
242 #endif
243 
244 /* an arbitrarily chosen "sane" max packet size -- 50M */
245 #define SANE_CHUNK_SIZE (50000000)
246 
248 {
249  if (s->maxsize>= 0) {
250  int64_t remaining= s->maxsize - avio_tell(s);
251  if (remaining < size) {
252  int64_t newsize = avio_size(s);
253  if (!s->maxsize || s->maxsize<newsize)
254  s->maxsize = newsize - !newsize;
255  remaining= s->maxsize - avio_tell(s);
256  remaining= FFMAX(remaining, 0);
257  }
258 
259  if (s->maxsize>= 0 && remaining+1 < size) {
260  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
261  size = remaining+1;
262  }
263  }
264  return size;
265 }
266 
267 /* Read the data in sane-sized chunks and append to pkt.
268  * Return the number of bytes read or an error. */
270 {
271  int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
272  int orig_size = pkt->size;
273  int ret;
274 
275  do {
276  int prev_size = pkt->size;
277  int read_size;
278 
279  /* When the caller requests a lot of data, limit it to the amount
280  * left in file or SANE_CHUNK_SIZE when it is not known. */
281  read_size = size;
282  if (read_size > SANE_CHUNK_SIZE/10) {
283  read_size = ffio_limit(s, read_size);
284  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
285  if (s->maxsize < 0)
286  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
287  }
288 
289  ret = av_grow_packet(pkt, read_size);
290  if (ret < 0)
291  break;
292 
293  ret = avio_read(s, pkt->data + prev_size, read_size);
294  if (ret != read_size) {
295  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
296  break;
297  }
298 
299  size -= read_size;
300  } while (size > 0);
301  if (size > 0)
302  pkt->flags |= AV_PKT_FLAG_CORRUPT;
303 
304  pkt->pos = orig_pos;
305  if (!pkt->size)
306  av_packet_unref(pkt);
307  return pkt->size > orig_size ? pkt->size - orig_size : ret;
308 }
309 
311 {
312  av_init_packet(pkt);
313  pkt->data = NULL;
314  pkt->size = 0;
315  pkt->pos = avio_tell(s);
316 
317  return append_packet_chunked(s, pkt, size);
318 }
319 
321 {
322  if (!pkt->size)
323  return av_get_packet(s, pkt, size);
324  return append_packet_chunked(s, pkt, size);
325 }
326 
327 int av_filename_number_test(const char *filename)
328 {
329  char buf[1024];
330  return filename &&
331  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
332 }
333 
335  AVProbeData *pd)
336 {
337  static const struct {
338  const char *name;
339  enum AVCodecID id;
340  enum AVMediaType type;
341  } fmt_id_type[] = {
343  { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
344  { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
345  { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
347  { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
348  { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
350  { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
351  { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
352  { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
353  { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
354  { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
355  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
356  { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
357  { 0 }
358  };
359  int score;
360  const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
361 
362  if (fmt) {
363  int i;
364  av_log(s, AV_LOG_DEBUG,
365  "Probe with size=%d, packets=%d detected %s with score=%d\n",
367  fmt->name, score);
368  for (i = 0; fmt_id_type[i].name; i++) {
369  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
370  if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
371  st->codecpar->sample_rate)
372  continue;
373  if (st->request_probe > score &&
374  st->codecpar->codec_id != fmt_id_type[i].id)
375  continue;
376  st->codecpar->codec_id = fmt_id_type[i].id;
377  st->codecpar->codec_type = fmt_id_type[i].type;
378  st->internal->need_context_update = 1;
379 #if FF_API_LAVF_AVCTX
381  st->codec->codec_type = st->codecpar->codec_type;
382  st->codec->codec_id = st->codecpar->codec_id;
384 #endif
385  return score;
386  }
387  }
388  }
389  return 0;
390 }
391 
392 /************************************************************/
393 /* input media file */
394 
396  int err;
397 
398  if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
399  av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
400  return AVERROR(EINVAL);
401  }
402 
403  if (ic->iformat->read_header) {
404  err = ic->iformat->read_header(ic);
405  if (err < 0)
406  return err;
407  }
408 
409  if (ic->pb && !ic->internal->data_offset)
410  ic->internal->data_offset = avio_tell(ic->pb);
411 
412  return 0;
413 }
414 
415 /* Open input file and probe the format if necessary. */
416 static int init_input(AVFormatContext *s, const char *filename,
418 {
419  int ret;
420  AVProbeData pd = { filename, NULL, 0 };
421  int score = AVPROBE_SCORE_RETRY;
422 
423  if (s->pb) {
425  if (!s->iformat)
426  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
427  s, 0, s->format_probesize);
428  else if (s->iformat->flags & AVFMT_NOFILE)
429  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
430  "will be ignored with AVFMT_NOFILE format.\n");
431  return 0;
432  }
433 
434  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
435  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
436  return score;
437 
438  if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
439  return ret;
440 
441  if (s->iformat)
442  return 0;
443  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
444  s, 0, s->format_probesize);
445 }
446 
447 int ff_packet_list_put(AVPacketList **packet_buffer,
448  AVPacketList **plast_pktl,
449  AVPacket *pkt, int flags)
450 {
451  AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
452  int ret;
453 
454  if (!pktl)
455  return AVERROR(ENOMEM);
456 
457  if (flags & FF_PACKETLIST_FLAG_REF_PACKET) {
458  if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
459  av_free(pktl);
460  return ret;
461  }
462  } else {
463  // TODO: Adapt callers in this file so the line below can use
464  // av_packet_move_ref() to effectively move the reference
465  // to the list.
466  pktl->pkt = *pkt;
467  }
468 
469  if (*packet_buffer)
470  (*plast_pktl)->next = pktl;
471  else
472  *packet_buffer = pktl;
473 
474  /* Add the packet in the buffered packet list. */
475  *plast_pktl = pktl;
476  return 0;
477 }
478 
480 {
481  int i, ret;
482  for (i = 0; i < s->nb_streams; i++)
484  s->streams[i]->discard < AVDISCARD_ALL) {
485  if (s->streams[i]->attached_pic.size <= 0) {
487  "Attached picture on stream %d has invalid size, "
488  "ignoring\n", i);
489  continue;
490  }
491 
494  &s->streams[i]->attached_pic,
496  if (ret < 0)
497  return ret;
498  }
499  return 0;
500 }
501 
503 {
504  int i, ret;
505  for (i = 0; i < s->nb_streams; i++) {
506  AVStream *st = s->streams[i];
507 
508  if (!st->internal->need_context_update)
509  continue;
510 
511  /* close parser, because it depends on the codec */
512  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
513  av_parser_close(st->parser);
514  st->parser = NULL;
515  }
516 
517  /* update internal codec context, for the parser */
519  if (ret < 0)
520  return ret;
521 
522 #if FF_API_LAVF_AVCTX
524  /* update deprecated public codec context */
525  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
526  if (ret < 0)
527  return ret;
529 #endif
530 
531  st->internal->need_context_update = 0;
532  }
533  return 0;
534 }
535 
536 
537 int avformat_open_input(AVFormatContext **ps, const char *filename,
539 {
540  AVFormatContext *s = *ps;
541  int i, ret = 0;
542  AVDictionary *tmp = NULL;
543  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
544 
545  if (!s && !(s = avformat_alloc_context()))
546  return AVERROR(ENOMEM);
547  if (!s->av_class) {
548  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
549  return AVERROR(EINVAL);
550  }
551  if (fmt)
552  s->iformat = fmt;
553 
554  if (options)
555  av_dict_copy(&tmp, *options, 0);
556 
557  if (s->pb) // must be before any goto fail
559 
560  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
561  goto fail;
562 
563  if (!(s->url = av_strdup(filename ? filename : ""))) {
564  ret = AVERROR(ENOMEM);
565  goto fail;
566  }
567 
568 #if FF_API_FORMAT_FILENAME
570  av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
572 #endif
573  if ((ret = init_input(s, filename, &tmp)) < 0)
574  goto fail;
575  s->probe_score = ret;
576 
577  if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
579  if (!s->protocol_whitelist) {
580  ret = AVERROR(ENOMEM);
581  goto fail;
582  }
583  }
584 
585  if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
587  if (!s->protocol_blacklist) {
588  ret = AVERROR(ENOMEM);
589  goto fail;
590  }
591  }
592 
593  if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
594  av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
595  ret = AVERROR(EINVAL);
596  goto fail;
597  }
598 
600 
601  /* Check filename in case an image number is expected. */
602  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
603  if (!av_filename_number_test(filename)) {
604  ret = AVERROR(EINVAL);
605  goto fail;
606  }
607  }
608 
610 
611  /* Allocate private data. */
612  if (s->iformat->priv_data_size > 0) {
613  if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
614  ret = AVERROR(ENOMEM);
615  goto fail;
616  }
617  if (s->iformat->priv_class) {
618  *(const AVClass **) s->priv_data = s->iformat->priv_class;
620  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
621  goto fail;
622  }
623  }
624 
625  /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
626  if (s->pb)
627  ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
628 
629 
630  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
631  if ((ret = s->iformat->read_header(s)) < 0)
632  goto fail;
633 
634  if (!s->metadata) {
635  s->metadata = s->internal->id3v2_meta;
636  s->internal->id3v2_meta = NULL;
637  } else if (s->internal->id3v2_meta) {
638  int level = AV_LOG_WARNING;
640  level = AV_LOG_ERROR;
641  av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
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") || !strcmp(s->iformat->name, "wav")) {
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 st:%d (%d)\n",
1406  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
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  const AVInputFormat *avif = s->iformat;
2167  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2168  int64_t ts_min, ts_max, ts;
2169  int index;
2170  int64_t ret;
2171  AVStream *st;
2172 
2173  if (stream_index < 0)
2174  return -1;
2175 
2176  av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2177 
2178  ts_max =
2179  ts_min = AV_NOPTS_VALUE;
2180  pos_limit = -1; // GCC falsely says it may be uninitialized.
2181 
2182  st = s->streams[stream_index];
2183  if (st->index_entries) {
2184  AVIndexEntry *e;
2185 
2186  /* FIXME: Whole function must be checked for non-keyframe entries in
2187  * index case, especially read_timestamp(). */
2188  index = av_index_search_timestamp(st, target_ts,
2189  flags | AVSEEK_FLAG_BACKWARD);
2190  index = FFMAX(index, 0);
2191  e = &st->index_entries[index];
2192 
2193  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2194  pos_min = e->pos;
2195  ts_min = e->timestamp;
2196  av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2197  pos_min, av_ts2str(ts_min));
2198  } else {
2199  av_assert1(index == 0);
2200  }
2201 
2202  index = av_index_search_timestamp(st, target_ts,
2203  flags & ~AVSEEK_FLAG_BACKWARD);
2204  av_assert0(index < st->nb_index_entries);
2205  if (index >= 0) {
2206  e = &st->index_entries[index];
2207  av_assert1(e->timestamp >= target_ts);
2208  pos_max = e->pos;
2209  ts_max = e->timestamp;
2210  pos_limit = pos_max - e->min_distance;
2211  av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2212  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2213  }
2214  }
2215 
2216  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2217  ts_min, ts_max, flags, &ts, avif->read_timestamp);
2218  if (pos < 0)
2219  return -1;
2220 
2221  /* do the seek */
2222  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2223  return ret;
2224 
2226  ff_update_cur_dts(s, st, ts);
2227 
2228  return 0;
2229 }
2230 
2231 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2232  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2233 {
2234  int64_t step = 1024;
2235  int64_t limit, ts_max;
2236  int64_t filesize = avio_size(s->pb);
2237  int64_t pos_max = filesize - 1;
2238  do {
2239  limit = pos_max;
2240  pos_max = FFMAX(0, (pos_max) - step);
2241  ts_max = ff_read_timestamp(s, stream_index,
2242  &pos_max, limit, read_timestamp);
2243  step += step;
2244  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2245  if (ts_max == AV_NOPTS_VALUE)
2246  return -1;
2247 
2248  for (;;) {
2249  int64_t tmp_pos = pos_max + 1;
2250  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2251  &tmp_pos, INT64_MAX, read_timestamp);
2252  if (tmp_ts == AV_NOPTS_VALUE)
2253  break;
2254  av_assert0(tmp_pos > pos_max);
2255  ts_max = tmp_ts;
2256  pos_max = tmp_pos;
2257  if (tmp_pos >= filesize)
2258  break;
2259  }
2260 
2261  if (ts)
2262  *ts = ts_max;
2263  if (pos)
2264  *pos = pos_max;
2265 
2266  return 0;
2267 }
2268 
2269 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2270  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2271  int64_t ts_min, int64_t ts_max,
2272  int flags, int64_t *ts_ret,
2273  int64_t (*read_timestamp)(struct AVFormatContext *, int,
2274  int64_t *, int64_t))
2275 {
2276  int64_t pos, ts;
2277  int64_t start_pos;
2278  int no_change;
2279  int ret;
2280 
2281  av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2282 
2283  if (ts_min == AV_NOPTS_VALUE) {
2284  pos_min = s->internal->data_offset;
2285  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2286  if (ts_min == AV_NOPTS_VALUE)
2287  return -1;
2288  }
2289 
2290  if (ts_min >= target_ts) {
2291  *ts_ret = ts_min;
2292  return pos_min;
2293  }
2294 
2295  if (ts_max == AV_NOPTS_VALUE) {
2296  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2297  return ret;
2298  pos_limit = pos_max;
2299  }
2300 
2301  if (ts_max <= target_ts) {
2302  *ts_ret = ts_max;
2303  return pos_max;
2304  }
2305 
2306  av_assert0(ts_min < ts_max);
2307 
2308  no_change = 0;
2309  while (pos_min < pos_limit) {
2310  av_log(s, AV_LOG_TRACE,
2311  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2312  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2313  av_assert0(pos_limit <= pos_max);
2314 
2315  if (no_change == 0) {
2316  int64_t approximate_keyframe_distance = pos_max - pos_limit;
2317  // interpolate position (better than dichotomy)
2318  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2319  ts_max - ts_min) +
2320  pos_min - approximate_keyframe_distance;
2321  } else if (no_change == 1) {
2322  // bisection if interpolation did not change min / max pos last time
2323  pos = (pos_min + pos_limit) >> 1;
2324  } else {
2325  /* linear search if bisection failed, can only happen if there
2326  * are very few or no keyframes between min/max */
2327  pos = pos_min;
2328  }
2329  if (pos <= pos_min)
2330  pos = pos_min + 1;
2331  else if (pos > pos_limit)
2332  pos = pos_limit;
2333  start_pos = pos;
2334 
2335  // May pass pos_limit instead of -1.
2336  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2337  if (pos == pos_max)
2338  no_change++;
2339  else
2340  no_change = 0;
2341  av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2342  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2343  pos_min, pos, pos_max,
2344  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2345  pos_limit, start_pos, no_change);
2346  if (ts == AV_NOPTS_VALUE) {
2347  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2348  return -1;
2349  }
2350  if (target_ts <= ts) {
2351  pos_limit = start_pos - 1;
2352  pos_max = pos;
2353  ts_max = ts;
2354  }
2355  if (target_ts >= ts) {
2356  pos_min = pos;
2357  ts_min = ts;
2358  }
2359  }
2360 
2361  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2362  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2363 #if 0
2364  pos_min = pos;
2365  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2366  pos_min++;
2367  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2368  av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2369  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2370 #endif
2371  *ts_ret = ts;
2372  return pos;
2373 }
2374 
2375 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2376  int64_t pos, int flags)
2377 {
2378  int64_t pos_min, pos_max;
2379 
2380  pos_min = s->internal->data_offset;
2381  pos_max = avio_size(s->pb) - 1;
2382 
2383  if (pos < pos_min)
2384  pos = pos_min;
2385  else if (pos > pos_max)
2386  pos = pos_max;
2387 
2388  avio_seek(s->pb, pos, SEEK_SET);
2389 
2390  s->io_repositioned = 1;
2391 
2392  return 0;
2393 }
2394 
2395 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2396  int64_t timestamp, int flags)
2397 {
2398  int index;
2399  int64_t ret;
2400  AVStream *st;
2401  AVIndexEntry *ie;
2402 
2403  st = s->streams[stream_index];
2404 
2405  index = av_index_search_timestamp(st, timestamp, flags);
2406 
2407  if (index < 0 && st->nb_index_entries &&
2408  timestamp < st->index_entries[0].timestamp)
2409  return -1;
2410 
2411  if (index < 0 || index == st->nb_index_entries - 1) {
2412  AVPacket pkt;
2413  int nonkey = 0;
2414 
2415  if (st->nb_index_entries) {
2417  ie = &st->index_entries[st->nb_index_entries - 1];
2418  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2419  return ret;
2420  ff_update_cur_dts(s, st, ie->timestamp);
2421  } else {
2422  if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2423  return ret;
2424  }
2425  for (;;) {
2426  int read_status;
2427  do {
2428  read_status = av_read_frame(s, &pkt);
2429  } while (read_status == AVERROR(EAGAIN));
2430  if (read_status < 0)
2431  break;
2432  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2433  if (pkt.flags & AV_PKT_FLAG_KEY) {
2434  av_packet_unref(&pkt);
2435  break;
2436  }
2437  if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2438  av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
2439  av_packet_unref(&pkt);
2440  break;
2441  }
2442  }
2443  av_packet_unref(&pkt);
2444  }
2445  index = av_index_search_timestamp(st, timestamp, flags);
2446  }
2447  if (index < 0)
2448  return -1;
2449 
2451  if (s->iformat->read_seek)
2452  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2453  return 0;
2454  ie = &st->index_entries[index];
2455  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2456  return ret;
2457  ff_update_cur_dts(s, st, ie->timestamp);
2458 
2459  return 0;
2460 }
2461 
2462 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2463  int64_t timestamp, int flags)
2464 {
2465  int ret;
2466  AVStream *st;
2467 
2468  if (flags & AVSEEK_FLAG_BYTE) {
2469  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2470  return -1;
2472  return seek_frame_byte(s, stream_index, timestamp, flags);
2473  }
2474 
2475  if (stream_index < 0) {
2476  stream_index = av_find_default_stream_index(s);
2477  if (stream_index < 0)
2478  return -1;
2479 
2480  st = s->streams[stream_index];
2481  /* timestamp for default must be expressed in AV_TIME_BASE units */
2482  timestamp = av_rescale(timestamp, st->time_base.den,
2483  AV_TIME_BASE * (int64_t) st->time_base.num);
2484  }
2485 
2486  /* first, we try the format specific seek */
2487  if (s->iformat->read_seek) {
2489  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2490  } else
2491  ret = -1;
2492  if (ret >= 0)
2493  return 0;
2494 
2495  if (s->iformat->read_timestamp &&
2496  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2498  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2499  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2501  return seek_frame_generic(s, stream_index, timestamp, flags);
2502  } else
2503  return -1;
2504 }
2505 
2506 int av_seek_frame(AVFormatContext *s, int stream_index,
2507  int64_t timestamp, int flags)
2508 {
2509  int ret;
2510 
2511  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2512  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2513  if ((flags & AVSEEK_FLAG_BACKWARD))
2514  max_ts = timestamp;
2515  else
2516  min_ts = timestamp;
2517  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2518  flags & ~AVSEEK_FLAG_BACKWARD);
2519  }
2520 
2521  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2522 
2523  if (ret >= 0)
2525 
2526  return ret;
2527 }
2528 
2529 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2530  int64_t ts, int64_t max_ts, int flags)
2531 {
2532  if (min_ts > ts || max_ts < ts)
2533  return -1;
2534  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2535  return AVERROR(EINVAL);
2536 
2537  if (s->seek2any>0)
2538  flags |= AVSEEK_FLAG_ANY;
2539  flags &= ~AVSEEK_FLAG_BACKWARD;
2540 
2541  if (s->iformat->read_seek2) {
2542  int ret;
2544 
2545  if (stream_index == -1 && s->nb_streams == 1) {
2546  AVRational time_base = s->streams[0]->time_base;
2547  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2548  min_ts = av_rescale_rnd(min_ts, time_base.den,
2549  time_base.num * (int64_t)AV_TIME_BASE,
2551  max_ts = av_rescale_rnd(max_ts, time_base.den,
2552  time_base.num * (int64_t)AV_TIME_BASE,
2554  stream_index = 0;
2555  }
2556 
2557  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2558  ts, max_ts, flags);
2559 
2560  if (ret >= 0)
2562  return ret;
2563  }
2564 
2565  if (s->iformat->read_timestamp) {
2566  // try to seek via read_timestamp()
2567  }
2568 
2569  // Fall back on old API if new is not implemented but old is.
2570  // Note the old API has somewhat different semantics.
2571  if (s->iformat->read_seek || 1) {
2572  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2573  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2574  if (ret<0 && ts != min_ts && max_ts != ts) {
2575  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2576  if (ret >= 0)
2577  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2578  }
2579  return ret;
2580  }
2581 
2582  // try some generic seek like seek_frame_generic() but with new ts semantics
2583  return -1; //unreachable
2584 }
2585 
2587 {
2589  return 0;
2590 }
2591 
2592 /*******************************************************/
2593 
2594 /**
2595  * Return TRUE if the stream has accurate duration in any stream.
2596  *
2597  * @return TRUE if the stream has accurate duration for at least one component.
2598  */
2600 {
2601  int i;
2602  AVStream *st;
2603 
2604  for (i = 0; i < ic->nb_streams; i++) {
2605  st = ic->streams[i];
2606  if (st->duration != AV_NOPTS_VALUE)
2607  return 1;
2608  }
2609  if (ic->duration != AV_NOPTS_VALUE)
2610  return 1;
2611  return 0;
2612 }
2613 
2614 /**
2615  * Estimate the stream timings from the one of each components.
2616  *
2617  * Also computes the global bitrate if possible.
2618  */
2620 {
2621  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2622  int64_t duration, duration1, duration_text, filesize;
2623  int i;
2624  AVProgram *p;
2625 
2626  start_time = INT64_MAX;
2627  start_time_text = INT64_MAX;
2628  end_time = INT64_MIN;
2629  end_time_text = INT64_MIN;
2630  duration = INT64_MIN;
2631  duration_text = INT64_MIN;
2632 
2633  for (i = 0; i < ic->nb_streams; i++) {
2634  AVStream *st = ic->streams[i];
2635  int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2637  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2638  start_time1 = av_rescale_q(st->start_time, st->time_base,
2639  AV_TIME_BASE_Q);
2640  if (is_text)
2641  start_time_text = FFMIN(start_time_text, start_time1);
2642  else
2643  start_time = FFMIN(start_time, start_time1);
2644  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2647  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2648  end_time1 += start_time1;
2649  if (is_text)
2650  end_time_text = FFMAX(end_time_text, end_time1);
2651  else
2652  end_time = FFMAX(end_time, end_time1);
2653  }
2654  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2655  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2656  p->start_time = start_time1;
2657  if (p->end_time < end_time1)
2658  p->end_time = end_time1;
2659  }
2660  }
2661  if (st->duration != AV_NOPTS_VALUE) {
2662  duration1 = av_rescale_q(st->duration, st->time_base,
2663  AV_TIME_BASE_Q);
2664  if (is_text)
2665  duration_text = FFMAX(duration_text, duration1);
2666  else
2667  duration = FFMAX(duration, duration1);
2668  }
2669  }
2670  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2671  start_time = start_time_text;
2672  else if (start_time > start_time_text)
2673  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2674 
2675  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2676  end_time = end_time_text;
2677  else if (end_time < end_time_text)
2678  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2679 
2680  if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2681  duration = duration_text;
2682  else if (duration < duration_text)
2683  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2684 
2685  if (start_time != INT64_MAX) {
2686  ic->start_time = start_time;
2687  if (end_time != INT64_MIN) {
2688  if (ic->nb_programs > 1) {
2689  for (i = 0; i < ic->nb_programs; i++) {
2690  p = ic->programs[i];
2691  if (p->start_time != AV_NOPTS_VALUE &&
2692  p->end_time > p->start_time &&
2693  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2694  duration = FFMAX(duration, p->end_time - p->start_time);
2695  }
2696  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2697  duration = FFMAX(duration, end_time - start_time);
2698  }
2699  }
2700  }
2701  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2702  ic->duration = duration;
2703  }
2704  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2705  /* compute the bitrate */
2706  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2707  (double) ic->duration;
2708  if (bitrate >= 0 && bitrate <= INT64_MAX)
2709  ic->bit_rate = bitrate;
2710  }
2711 }
2712 
2714 {
2715  int i;
2716  AVStream *st;
2717 
2719  for (i = 0; i < ic->nb_streams; i++) {
2720  st = ic->streams[i];
2721  if (st->start_time == AV_NOPTS_VALUE) {
2722  if (ic->start_time != AV_NOPTS_VALUE)
2724  st->time_base);
2725  if (ic->duration != AV_NOPTS_VALUE)
2727  st->time_base);
2728  }
2729  }
2730 }
2731 
2733 {
2734  int64_t filesize, duration;
2735  int i, show_warning = 0;
2736  AVStream *st;
2737 
2738  /* if bit_rate is already set, we believe it */
2739  if (ic->bit_rate <= 0) {
2740  int64_t bit_rate = 0;
2741  for (i = 0; i < ic->nb_streams; i++) {
2742  st = ic->streams[i];
2743  if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2744  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2745  if (st->codecpar->bit_rate > 0) {
2746  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2747  bit_rate = 0;
2748  break;
2749  }
2750  bit_rate += st->codecpar->bit_rate;
2751  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2752  // If we have a videostream with packets but without a bitrate
2753  // then consider the sum not known
2754  bit_rate = 0;
2755  break;
2756  }
2757  }
2758  ic->bit_rate = bit_rate;
2759  }
2760 
2761  /* if duration is already set, we believe it */
2762  if (ic->duration == AV_NOPTS_VALUE &&
2763  ic->bit_rate != 0) {
2764  filesize = ic->pb ? avio_size(ic->pb) : 0;
2765  if (filesize > ic->internal->data_offset) {
2766  filesize -= ic->internal->data_offset;
2767  for (i = 0; i < ic->nb_streams; i++) {
2768  st = ic->streams[i];
2769  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2770  && st->duration == AV_NOPTS_VALUE) {
2771  duration = av_rescale(8 * filesize, st->time_base.den,
2772  ic->bit_rate *
2773  (int64_t) st->time_base.num);
2774  st->duration = duration;
2775  show_warning = 1;
2776  }
2777  }
2778  }
2779  }
2780  if (show_warning)
2781  av_log(ic, AV_LOG_WARNING,
2782  "Estimating duration from bitrate, this may be inaccurate\n");
2783 }
2784 
2785 #define DURATION_MAX_READ_SIZE 250000LL
2786 #define DURATION_MAX_RETRY 6
2787 
2788 /* only usable for MPEG-PS streams */
2789 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2790 {
2791  AVPacket pkt1, *pkt = &pkt1;
2792  AVStream *st;
2793  int num, den, read_size, i, ret;
2794  int found_duration = 0;
2795  int is_end;
2796  int64_t filesize, offset, duration;
2797  int retry = 0;
2798 
2799  /* flush packet queue */
2800  flush_packet_queue(ic);
2801 
2802  for (i = 0; i < ic->nb_streams; i++) {
2803  st = ic->streams[i];
2804  if (st->start_time == AV_NOPTS_VALUE &&
2805  st->first_dts == AV_NOPTS_VALUE &&
2807  av_log(ic, AV_LOG_WARNING,
2808  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2809 
2810  if (st->parser) {
2811  av_parser_close(st->parser);
2812  st->parser = NULL;
2813  }
2814  }
2815 
2817  av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2818  goto skip_duration_calc;
2819  }
2820 
2821  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2822  /* estimate the end time (duration) */
2823  /* XXX: may need to support wrapping */
2824  filesize = ic->pb ? avio_size(ic->pb) : 0;
2825  do {
2826  is_end = found_duration;
2827  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2828  if (offset < 0)
2829  offset = 0;
2830 
2831  avio_seek(ic->pb, offset, SEEK_SET);
2832  read_size = 0;
2833  for (;;) {
2834  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2835  break;
2836 
2837  do {
2838  ret = ff_read_packet(ic, pkt);
2839  } while (ret == AVERROR(EAGAIN));
2840  if (ret != 0)
2841  break;
2842  read_size += pkt->size;
2843  st = ic->streams[pkt->stream_index];
2844  if (pkt->pts != AV_NOPTS_VALUE &&
2845  (st->start_time != AV_NOPTS_VALUE ||
2846  st->first_dts != AV_NOPTS_VALUE)) {
2847  if (pkt->duration == 0) {
2848  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2849  if (den && num) {
2850  pkt->duration = av_rescale_rnd(1,
2851  num * (int64_t) st->time_base.den,
2852  den * (int64_t) st->time_base.num,
2853  AV_ROUND_DOWN);
2854  }
2855  }
2856  duration = pkt->pts + pkt->duration;
2857  found_duration = 1;
2858  if (st->start_time != AV_NOPTS_VALUE)
2859  duration -= st->start_time;
2860  else
2861  duration -= st->first_dts;
2862  if (duration > 0) {
2863  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2864  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2865  st->duration = duration;
2866  st->info->last_duration = duration;
2867  }
2868  }
2869  av_packet_unref(pkt);
2870  }
2871 
2872  /* check if all audio/video streams have valid duration */
2873  if (!is_end) {
2874  is_end = 1;
2875  for (i = 0; i < ic->nb_streams; i++) {
2876  st = ic->streams[i];
2877  switch (st->codecpar->codec_type) {
2878  case AVMEDIA_TYPE_VIDEO:
2879  case AVMEDIA_TYPE_AUDIO:
2880  if (st->duration == AV_NOPTS_VALUE)
2881  is_end = 0;
2882  }
2883  }
2884  }
2885  } while (!is_end &&
2886  offset &&
2887  ++retry <= DURATION_MAX_RETRY);
2888 
2889  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2890 
2891  /* warn about audio/video streams which duration could not be estimated */
2892  for (i = 0; i < ic->nb_streams; i++) {
2893  st = ic->streams[i];
2894  if (st->duration == AV_NOPTS_VALUE) {
2895  switch (st->codecpar->codec_type) {
2896  case AVMEDIA_TYPE_VIDEO:
2897  case AVMEDIA_TYPE_AUDIO:
2898  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2899  av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2900  } else
2901  av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2902  }
2903  }
2904  }
2905 skip_duration_calc:
2907 
2908  avio_seek(ic->pb, old_offset, SEEK_SET);
2909  for (i = 0; i < ic->nb_streams; i++) {
2910  int j;
2911 
2912  st = ic->streams[i];
2913  st->cur_dts = st->first_dts;
2916  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2917  st->pts_buffer[j] = AV_NOPTS_VALUE;
2918  }
2919 }
2920 
2921 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2922 {
2923  int64_t file_size;
2924 
2925  /* get the file size, if possible */
2926  if (ic->iformat->flags & AVFMT_NOFILE) {
2927  file_size = 0;
2928  } else {
2929  file_size = avio_size(ic->pb);
2930  file_size = FFMAX(0, file_size);
2931  }
2932 
2933  if ((!strcmp(ic->iformat->name, "mpeg") ||
2934  !strcmp(ic->iformat->name, "mpegts")) &&
2935  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2936  /* get accurate estimate from the PTSes */
2937  estimate_timings_from_pts(ic, old_offset);
2939  } else if (has_duration(ic)) {
2940  /* at least one component has timings - we use them for all
2941  * the components */
2944  } else {
2945  /* less precise: use bitrate info */
2948  }
2950 
2951  {
2952  int i;
2953  AVStream av_unused *st;
2954  for (i = 0; i < ic->nb_streams; i++) {
2955  st = ic->streams[i];
2956  if (st->time_base.den)
2957  av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2958  (double) st->start_time * av_q2d(st->time_base),
2959  (double) st->duration * av_q2d(st->time_base));
2960  }
2961  av_log(ic, AV_LOG_TRACE,
2962  "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2963  (double) ic->start_time / AV_TIME_BASE,
2964  (double) ic->duration / AV_TIME_BASE,
2965  (int64_t)ic->bit_rate / 1000);
2966  }
2967 }
2968 
2969 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2970 {
2971  AVCodecContext *avctx = st->internal->avctx;
2972 
2973 #define FAIL(errmsg) do { \
2974  if (errmsg_ptr) \
2975  *errmsg_ptr = errmsg; \
2976  return 0; \
2977  } while (0)
2978 
2979  if ( avctx->codec_id == AV_CODEC_ID_NONE
2980  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2981  FAIL("unknown codec");
2982  switch (avctx->codec_type) {
2983  case AVMEDIA_TYPE_AUDIO:
2984  if (!avctx->frame_size && determinable_frame_size(avctx))
2985  FAIL("unspecified frame size");
2986  if (st->info->found_decoder >= 0 &&
2987  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2988  FAIL("unspecified sample format");
2989  if (!avctx->sample_rate)
2990  FAIL("unspecified sample rate");
2991  if (!avctx->channels)
2992  FAIL("unspecified number of channels");
2993  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2994  FAIL("no decodable DTS frames");
2995  break;
2996  case AVMEDIA_TYPE_VIDEO:
2997  if (!avctx->width)
2998  FAIL("unspecified size");
2999  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3000  FAIL("unspecified pixel format");
3003  FAIL("no frame in rv30/40 and no sar");
3004  break;
3005  case AVMEDIA_TYPE_SUBTITLE:
3006  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3007  FAIL("unspecified size");
3008  break;
3009  case AVMEDIA_TYPE_DATA:
3010  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3011  }
3012 
3013  return 1;
3014 }
3015 
3016 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3019 {
3020  AVCodecContext *avctx = st->internal->avctx;
3021  const AVCodec *codec;
3022  int got_picture = 1, ret = 0;
3024  AVSubtitle subtitle;
3025  AVPacket pkt = *avpkt;
3026  int do_skip_frame = 0;
3027  enum AVDiscard skip_frame;
3028 
3029  if (!frame)
3030  return AVERROR(ENOMEM);
3031 
3032  if (!avcodec_is_open(avctx) &&
3033  st->info->found_decoder <= 0 &&
3034  (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3035  AVDictionary *thread_opt = NULL;
3036 
3037  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3038 
3039  if (!codec) {
3040  st->info->found_decoder = -st->codecpar->codec_id;
3041  ret = -1;
3042  goto fail;
3043  }
3044 
3045  /* Force thread count to 1 since the H.264 decoder will not extract
3046  * SPS and PPS to extradata during multi-threaded decoding. */
3047  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3048  if (s->codec_whitelist)
3049  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3050  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3051  if (!options)
3052  av_dict_free(&thread_opt);
3053  if (ret < 0) {
3054  st->info->found_decoder = -avctx->codec_id;
3055  goto fail;
3056  }
3057  st->info->found_decoder = 1;
3058  } else if (!st->info->found_decoder)
3059  st->info->found_decoder = 1;
3060 
3061  if (st->info->found_decoder < 0) {
3062  ret = -1;
3063  goto fail;
3064  }
3065 
3067  do_skip_frame = 1;
3068  skip_frame = avctx->skip_frame;
3069  avctx->skip_frame = AVDISCARD_ALL;
3070  }
3071 
3072  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3073  ret >= 0 &&
3075  (!st->codec_info_nb_frames &&
3077  got_picture = 0;
3078  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3079  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3080  ret = avcodec_send_packet(avctx, &pkt);
3081  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3082  break;
3083  if (ret >= 0)
3084  pkt.size = 0;
3085  ret = avcodec_receive_frame(avctx, frame);
3086  if (ret >= 0)
3087  got_picture = 1;
3088  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3089  ret = 0;
3090  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3091  ret = avcodec_decode_subtitle2(avctx, &subtitle,
3092  &got_picture, &pkt);
3093  if (ret >= 0)
3094  pkt.size = 0;
3095  }
3096  if (ret >= 0) {
3097  if (got_picture)
3098  st->nb_decoded_frames++;
3099  ret = got_picture;
3100  }
3101  }
3102 
3103  if (!pkt.data && !got_picture)
3104  ret = -1;
3105 
3106 fail:
3107  if (do_skip_frame) {
3108  avctx->skip_frame = skip_frame;
3109  }
3110 
3111  av_frame_free(&frame);
3112  return ret;
3113 }
3114 
3115 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3116 {
3117  while (tags->id != AV_CODEC_ID_NONE) {
3118  if (tags->id == id)
3119  return tags->tag;
3120  tags++;
3121  }
3122  return 0;
3123 }
3124 
3125 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3126 {
3127  int i;
3128  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3129  if (tag == tags[i].tag)
3130  return tags[i].id;
3131  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3132  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3133  return tags[i].id;
3134  return AV_CODEC_ID_NONE;
3135 }
3136 
3137 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3138 {
3139  if (bps <= 0 || bps > 64)
3140  return AV_CODEC_ID_NONE;
3141 
3142  if (flt) {
3143  switch (bps) {
3144  case 32:
3146  case 64:
3148  default:
3149  return AV_CODEC_ID_NONE;
3150  }
3151  } else {
3152  bps += 7;
3153  bps >>= 3;
3154  if (sflags & (1 << (bps - 1))) {
3155  switch (bps) {
3156  case 1:
3157  return AV_CODEC_ID_PCM_S8;
3158  case 2:
3160  case 3:
3162  case 4:
3164  case 8:
3166  default:
3167  return AV_CODEC_ID_NONE;
3168  }
3169  } else {
3170  switch (bps) {
3171  case 1:
3172  return AV_CODEC_ID_PCM_U8;
3173  case 2:
3175  case 3:
3177  case 4:
3179  default:
3180  return AV_CODEC_ID_NONE;
3181  }
3182  }
3183  }
3184 }
3185 
3186 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3187 {
3188  unsigned int tag;
3189  if (!av_codec_get_tag2(tags, id, &tag))
3190  return 0;
3191  return tag;
3192 }
3193 
3194 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3195  unsigned int *tag)
3196 {
3197  int i;
3198  for (i = 0; tags && tags[i]; i++) {
3199  const AVCodecTag *codec_tags = tags[i];
3200  while (codec_tags->id != AV_CODEC_ID_NONE) {
3201  if (codec_tags->id == id) {
3202  *tag = codec_tags->tag;
3203  return 1;
3204  }
3205  codec_tags++;
3206  }
3207  }
3208  return 0;
3209 }
3210 
3211 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3212 {
3213  int i;
3214  for (i = 0; tags && tags[i]; i++) {
3215  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3216  if (id != AV_CODEC_ID_NONE)
3217  return id;
3218  }
3219  return AV_CODEC_ID_NONE;
3220 }
3221 
3223 {
3224  unsigned int i, j;
3225  int64_t max_time = 0;
3226 
3227  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3228  max_time = s->duration +
3229  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3230 
3231  for (i = 0; i < s->nb_chapters; i++)
3232  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3233  AVChapter *ch = s->chapters[i];
3234  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3235  ch->time_base)
3236  : INT64_MAX;
3237 
3238  for (j = 0; j < s->nb_chapters; j++) {
3239  AVChapter *ch1 = s->chapters[j];
3240  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3241  ch->time_base);
3242  if (j != i && next_start > ch->start && next_start < end)
3243  end = next_start;
3244  }
3245  ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3246  }
3247 }
3248 
3249 static int get_std_framerate(int i)
3250 {
3251  if (i < 30*12)
3252  return (i + 1) * 1001;
3253  i -= 30*12;
3254 
3255  if (i < 30)
3256  return (i + 31) * 1001 * 12;
3257  i -= 30;
3258 
3259  if (i < 3)
3260  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3261 
3262  i -= 3;
3263 
3264  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3265 }
3266 
3267 /* Is the time base unreliable?
3268  * This is a heuristic to balance between quick acceptance of the values in
3269  * the headers vs. some extra checks.
3270  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3271  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3272  * And there are "variable" fps files this needs to detect as well. */
3274 {
3275  if (c->time_base.den >= 101LL * c->time_base.num ||
3276  c->time_base.den < 5LL * c->time_base.num ||
3277  // c->codec_tag == AV_RL32("DIVX") ||
3278  // c->codec_tag == AV_RL32("XVID") ||
3279  c->codec_tag == AV_RL32("mp4v") ||
3281  c->codec_id == AV_CODEC_ID_GIF ||
3282  c->codec_id == AV_CODEC_ID_HEVC ||
3283  c->codec_id == AV_CODEC_ID_H264)
3284  return 1;
3285  return 0;
3286 }
3287 
3289 {
3290  av_freep(&par->extradata);
3291  par->extradata_size = 0;
3292 
3293  if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3294  return AVERROR(EINVAL);
3295 
3297  if (!par->extradata)
3298  return AVERROR(ENOMEM);
3299 
3300  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3301  par->extradata_size = size;
3302 
3303  return 0;
3304 }
3305 
3307 {
3308  int ret = ff_alloc_extradata(par, size);
3309  if (ret < 0)
3310  return ret;
3311  ret = avio_read(pb, par->extradata, size);
3312  if (ret != size) {
3313  av_freep(&par->extradata);
3314  par->extradata_size = 0;
3315  av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3316  return ret < 0 ? ret : AVERROR_INVALIDDATA;
3317  }
3318 
3319  return ret;
3320 }
3321 
3322 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3323 {
3324  int i, j;
3325  int64_t last = st->info->last_dts;
3326 
3327  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3328  && ts - (uint64_t)last < INT64_MAX) {
3329  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3330  int64_t duration = ts - last;
3331 
3332  if (!st->info->duration_error)
3333  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3334  if (!st->info->duration_error)
3335  return AVERROR(ENOMEM);
3336 
3337 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3338 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3339  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3340  if (st->info->duration_error[0][1][i] < 1e10) {
3341  int framerate = get_std_framerate(i);
3342  double sdts = dts*framerate/(1001*12);
3343  for (j= 0; j<2; j++) {
3344  int64_t ticks = llrint(sdts+j*0.5);
3345  double error= sdts - ticks + j*0.5;
3346  st->info->duration_error[j][0][i] += error;
3347  st->info->duration_error[j][1][i] += error*error;
3348  }
3349  }
3350  }
3351  if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3352  st->info->duration_count++;
3354  }
3355 
3356  if (st->info->duration_count % 10 == 0) {
3357  int n = st->info->duration_count;
3358  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3359  if (st->info->duration_error[0][1][i] < 1e10) {
3360  double a0 = st->info->duration_error[0][0][i] / n;
3361  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3362  double a1 = st->info->duration_error[1][0][i] / n;
3363  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3364  if (error0 > 0.04 && error1 > 0.04) {
3365  st->info->duration_error[0][1][i] = 2e10;
3366  st->info->duration_error[1][1][i] = 2e10;
3367  }
3368  }
3369  }
3370  }
3371 
3372  // ignore the first 4 values, they might have some random jitter
3373  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3374  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3375  }
3376  if (ts != AV_NOPTS_VALUE)
3377  st->info->last_dts = ts;
3378 
3379  return 0;
3380 }
3381 
3383 {
3384  int i, j;
3385 
3386  for (i = 0; i < ic->nb_streams; i++) {
3387  AVStream *st = ic->streams[i];
3388 
3390  continue;
3391  // the check for tb_unreliable() is not completely correct, since this is not about handling
3392  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3393  // ipmovie.c produces.
3394  if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3395  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3396  if (st->info->duration_count>1 && !st->r_frame_rate.num
3397  && tb_unreliable(st->internal->avctx)) {
3398  int num = 0;
3399  double best_error= 0.01;
3400  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3401 
3402  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3403  int k;
3404 
3405  if (st->info->codec_info_duration &&
3406  st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3407  continue;
3408  if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3409  continue;
3410 
3411  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3412  continue;
3413 
3414  for (k= 0; k<2; k++) {
3415  int n = st->info->duration_count;
3416  double a= st->info->duration_error[k][0][j] / n;
3417  double error= st->info->duration_error[k][1][j]/n - a*a;
3418 
3419  if (error < best_error && best_error> 0.000000001) {
3420  best_error= error;
3421  num = get_std_framerate(j);
3422  }
3423  if (error < 0.02)
3424  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3425  }
3426  }
3427  // do not increase frame rate by more than 1 % in order to match a standard rate.
3428  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3429  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3430  }
3431  if ( !st->avg_frame_rate.num
3432  && st->r_frame_rate.num && st->info->rfps_duration_sum
3433  && st->info->codec_info_duration <= 0
3434  && st->info->duration_count > 2
3435  && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3436  ) {
3437  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3438  st->avg_frame_rate = st->r_frame_rate;
3439  }
3440 
3441  av_freep(&st->info->duration_error);
3442  st->info->last_dts = AV_NOPTS_VALUE;
3443  st->info->duration_count = 0;
3444  st->info->rfps_duration_sum = 0;
3445  }
3446 }
3447 
3449 {
3450  const AVBitStreamFilter *f;
3451 
3452  f = av_bsf_get_by_name("extract_extradata");
3453  if (!f)
3454  return 0;
3455 
3456  if (f->codec_ids) {
3457  const enum AVCodecID *ids;
3458  for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3459  if (*ids == st->codecpar->codec_id)
3460  return 1;
3461  }
3462 
3463  return 0;
3464 }
3465 
3467 {
3468  AVStreamInternal *sti = st->internal;
3469  const AVBitStreamFilter *f;
3470  int ret;
3471 
3472  f = av_bsf_get_by_name("extract_extradata");
3473  if (!f)
3474  goto finish;
3475 
3476  /* check that the codec id is supported */
3477  ret = extract_extradata_check(st);
3478  if (!ret)
3479  goto finish;
3480 
3482  if (!sti->extract_extradata.pkt)
3483  return AVERROR(ENOMEM);
3484 
3485  ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3486  if (ret < 0)
3487  goto fail;
3488 
3490  st->codecpar);
3491  if (ret < 0)
3492  goto fail;
3493 
3495 
3496  ret = av_bsf_init(sti->extract_extradata.bsf);
3497  if (ret < 0)
3498  goto fail;
3499 
3500 finish:
3501  sti->extract_extradata.inited = 1;
3502 
3503  return 0;
3504 fail:
3507  return ret;
3508 }
3509 
3511 {
3512  AVStreamInternal *sti = st->internal;
3513  AVPacket *pkt_ref;
3514  int ret;
3515 
3516  if (!sti->extract_extradata.inited) {
3517  ret = extract_extradata_init(st);
3518  if (ret < 0)
3519  return ret;
3520  }
3521 
3522  if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3523  return 0;
3524 
3525  pkt_ref = sti->extract_extradata.pkt;
3526  ret = av_packet_ref(pkt_ref, pkt);
3527  if (ret < 0)
3528  return ret;
3529 
3530  ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3531  if (ret < 0) {
3532  av_packet_unref(pkt_ref);
3533  return ret;
3534  }
3535 
3536  while (ret >= 0 && !sti->avctx->extradata) {
3537  int extradata_size;
3538  uint8_t *extradata;
3539 
3540  ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3541  if (ret < 0) {
3542  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3543  return ret;
3544  continue;
3545  }
3546 
3548  &extradata_size);
3549 
3550  if (extradata) {
3551  av_assert0(!sti->avctx->extradata);
3552  if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3553  sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3554  if (!sti->avctx->extradata) {
3555  av_packet_unref(pkt_ref);
3556  return AVERROR(ENOMEM);
3557  }
3558  memcpy(sti->avctx->extradata, extradata, extradata_size);
3559  sti->avctx->extradata_size = extradata_size;
3560  }
3561  av_packet_unref(pkt_ref);
3562  }
3563 
3564  return 0;
3565 }
3566 
3568 {
3569  int i, count = 0, ret = 0, j;
3570  int64_t read_size;
3571  AVStream *st;
3572  AVCodecContext *avctx;
3573  AVPacket pkt1, *pkt;
3574  int64_t old_offset = avio_tell(ic->pb);
3575  // new streams might appear, no options for those
3576  int orig_nb_streams = ic->nb_streams;
3577  int flush_codecs;
3578  int64_t max_analyze_duration = ic->max_analyze_duration;
3579  int64_t max_stream_analyze_duration;
3580  int64_t max_subtitle_analyze_duration;
3581  int64_t probesize = ic->probesize;
3582  int eof_reached = 0;
3583  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3584 
3585  flush_codecs = probesize > 0;
3586 
3587  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3588 
3589  max_stream_analyze_duration = max_analyze_duration;
3590  max_subtitle_analyze_duration = max_analyze_duration;
3591  if (!max_analyze_duration) {
3592  max_stream_analyze_duration =
3593  max_analyze_duration = 5*AV_TIME_BASE;
3594  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3595  if (!strcmp(ic->iformat->name, "flv"))
3596  max_stream_analyze_duration = 90*AV_TIME_BASE;
3597  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3598  max_stream_analyze_duration = 7*AV_TIME_BASE;
3599  }
3600 
3601  if (ic->pb)
3602  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3603  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3604 
3605  for (i = 0; i < ic->nb_streams; i++) {
3606  const AVCodec *codec;
3607  AVDictionary *thread_opt = NULL;
3608  st = ic->streams[i];
3609  avctx = st->internal->avctx;
3610 
3611  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3613 /* if (!st->time_base.num)
3614  st->time_base = */
3615  if (!avctx->time_base.num)
3616  avctx->time_base = st->time_base;
3617  }
3618 
3619  /* check if the caller has overridden the codec id */
3620 #if FF_API_LAVF_AVCTX
3622  if (st->codec->codec_id != st->internal->orig_codec_id) {
3623  st->codecpar->codec_id = st->codec->codec_id;
3624  st->codecpar->codec_type = st->codec->codec_type;
3625  st->internal->orig_codec_id = st->codec->codec_id;
3626  }
3628 #endif
3629  // only for the split stuff
3630  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3631  st->parser = av_parser_init(st->codecpar->codec_id);
3632  if (st->parser) {
3633  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3635  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3637  }
3638  } else if (st->need_parsing) {
3639  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3640  "%s, packets or times may be invalid.\n",
3642  }
3643  }
3644 
3645  if (st->codecpar->codec_id != st->internal->orig_codec_id)
3647 
3648  ret = avcodec_parameters_to_context(avctx, st->codecpar);
3649  if (ret < 0)
3650  goto find_stream_info_err;
3651  if (st->request_probe <= 0)
3652  st->internal->avctx_inited = 1;
3653 
3654  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3655 
3656  /* Force thread count to 1 since the H.264 decoder will not extract
3657  * SPS and PPS to extradata during multi-threaded decoding. */
3658  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3659 
3660  if (ic->codec_whitelist)
3661  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3662 
3663  /* Ensure that subtitle_header is properly set. */
3665  && codec && !avctx->codec) {
3666  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3667  av_log(ic, AV_LOG_WARNING,
3668  "Failed to open codec in %s\n",__FUNCTION__);
3669  }
3670 
3671  // Try to just open decoders, in case this is enough to get parameters.
3672  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3673  if (codec && !avctx->codec)
3674  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3675  av_log(ic, AV_LOG_WARNING,
3676  "Failed to open codec in %s\n",__FUNCTION__);
3677  }
3678  if (!options)
3679  av_dict_free(&thread_opt);
3680  }
3681 
3682  for (i = 0; i < ic->nb_streams; i++) {
3683 #if FF_API_R_FRAME_RATE
3685 #endif
3688  }
3689 
3690  read_size = 0;
3691  for (;;) {
3692  int analyzed_all_streams;
3694  ret = AVERROR_EXIT;
3695  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3696  break;
3697  }
3698 
3699  /* check if one codec still needs to be handled */
3700  for (i = 0; i < ic->nb_streams; i++) {
3701  int fps_analyze_framecount = 20;
3702  int count;
3703 
3704  st = ic->streams[i];
3705  if (!has_codec_parameters(st, NULL))
3706  break;
3707  /* If the timebase is coarse (like the usual millisecond precision
3708  * of mkv), we need to analyze more frames to reliably arrive at
3709  * the correct fps. */
3710  if (av_q2d(st->time_base) > 0.0005)
3711  fps_analyze_framecount *= 2;
3712  if (!tb_unreliable(st->internal->avctx))
3713  fps_analyze_framecount = 0;
3714  if (ic->fps_probe_size >= 0)
3715  fps_analyze_framecount = ic->fps_probe_size;
3717  fps_analyze_framecount = 0;
3718  /* variable fps and no guess at the real fps */
3719  count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3721  st->info->duration_count;
3722  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3724  if (count < fps_analyze_framecount)
3725  break;
3726  }
3727  // Look at the first 3 frames if there is evidence of frame delay
3728  // but the decoder delay is not set.
3729  if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3730  break;
3731  if (!st->internal->avctx->extradata &&
3733  st->internal->extract_extradata.bsf) &&
3735  break;
3736  if (st->first_dts == AV_NOPTS_VALUE &&
3737  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3741  break;
3742  }
3743  analyzed_all_streams = 0;
3744  if (!missing_streams || !*missing_streams)
3745  if (i == ic->nb_streams) {
3746  analyzed_all_streams = 1;
3747  /* NOTE: If the format has no header, then we need to read some
3748  * packets to get most of the streams, so we cannot stop here. */
3749  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3750  /* If we found the info for all the codecs, we can stop. */
3751  ret = count;
3752  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3753  flush_codecs = 0;
3754  break;
3755  }
3756  }
3757  /* We did not get all the codec info, but we read too much data. */
3758  if (read_size >= probesize) {
3759  ret = count;
3760  av_log(ic, AV_LOG_DEBUG,
3761  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3762  for (i = 0; i < ic->nb_streams; i++)
3763  if (!ic->streams[i]->r_frame_rate.num &&
3764  ic->streams[i]->info->duration_count <= 1 &&
3766  strcmp(ic->iformat->name, "image2"))
3767  av_log(ic, AV_LOG_WARNING,
3768  "Stream #%d: not enough frames to estimate rate; "
3769  "consider increasing probesize\n", i);
3770  break;
3771  }
3772 
3773  /* NOTE: A new stream can be added there if no header in file
3774  * (AVFMTCTX_NOHEADER). */
3775  ret = read_frame_internal(ic, &pkt1);
3776  if (ret == AVERROR(EAGAIN))
3777  continue;
3778 
3779  if (ret < 0) {
3780  /* EOF or error*/
3781  eof_reached = 1;
3782  break;
3783  }
3784 
3785  pkt = &pkt1;
3786 
3787  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3790  pkt, 0);
3791  if (ret < 0)
3792  goto find_stream_info_err;
3793  }
3794 
3795  st = ic->streams[pkt->stream_index];
3797  read_size += pkt->size;
3798 
3799  avctx = st->internal->avctx;
3800  if (!st->internal->avctx_inited) {
3801  ret = avcodec_parameters_to_context(avctx, st->codecpar);
3802  if (ret < 0)
3803  goto find_stream_info_err;
3804  st->internal->avctx_inited = 1;
3805  }
3806 
3807  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3808  /* check for non-increasing dts */
3809  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3810  st->info->fps_last_dts >= pkt->dts) {
3811  av_log(ic, AV_LOG_DEBUG,
3812  "Non-increasing DTS in stream %d: packet %d with DTS "
3813  "%"PRId64", packet %d with DTS %"PRId64"\n",
3814  st->index, st->info->fps_last_dts_idx,
3816  pkt->dts);
3817  st->info->fps_first_dts =
3819  }
3820  /* Check for a discontinuity in dts. If the difference in dts
3821  * is more than 1000 times the average packet duration in the
3822  * sequence, we treat it as a discontinuity. */
3823  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3825  (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3826  (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3827  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3828  av_log(ic, AV_LOG_WARNING,
3829  "DTS discontinuity in stream %d: packet %d with DTS "
3830  "%"PRId64", packet %d with DTS %"PRId64"\n",
3831  st->index, st->info->fps_last_dts_idx,
3833  pkt->dts);
3834  st->info->fps_first_dts =
3836  }
3837 
3838  /* update stored dts values */
3839  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3840  st->info->fps_first_dts = pkt->dts;
3842  }
3843  st->info->fps_last_dts = pkt->dts;
3845  }
3846  if (st->codec_info_nb_frames>1) {
3847  int64_t t = 0;
3848  int64_t limit;
3849 
3850  if (st->time_base.den > 0)
3852  if (st->avg_frame_rate.num > 0)
3854 
3855  if ( t == 0
3856  && st->codec_info_nb_frames>30
3857  && st->info->fps_first_dts != AV_NOPTS_VALUE
3858  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3860 
3861  if (analyzed_all_streams) limit = max_analyze_duration;
3862  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3863  else limit = max_stream_analyze_duration;
3864 
3865  if (t >= limit) {
3866  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3867  limit,
3868  t, pkt->stream_index);
3869  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3870  av_packet_unref(pkt);
3871  break;
3872  }
3873  if (pkt->duration) {
3874  if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3875  st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3876  } else
3877  st->info->codec_info_duration += pkt->duration;
3878  st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3879  }
3880  }
3881  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3882 #if FF_API_R_FRAME_RATE
3883  ff_rfps_add_frame(ic, st, pkt->dts);
3884 #endif
3885  if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3886  st->info->frame_delay_evidence = 1;
3887  }
3888  if (!st->internal->avctx->extradata) {
3889  ret = extract_extradata(st, pkt);
3890  if (ret < 0)
3891  goto find_stream_info_err;
3892  }
3893 
3894  /* If still no information, we try to open the codec and to
3895  * decompress the frame. We try to avoid that in most cases as
3896  * it takes longer and uses more memory. For MPEG-4, we need to
3897  * decompress for QuickTime.
3898  *
3899  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3900  * least one frame of codec data, this makes sure the codec initializes
3901  * the channel configuration and does not only trust the values from
3902  * the container. */
3903  try_decode_frame(ic, st, pkt,
3904  (options && i < orig_nb_streams) ? &options[i] : NULL);
3905 
3906  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3907  av_packet_unref(pkt);
3908 
3909  st->codec_info_nb_frames++;
3910  count++;
3911  }
3912 
3913  if (eof_reached) {
3914  int stream_index;
3915  for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3916  st = ic->streams[stream_index];
3917  avctx = st->internal->avctx;
3918  if (!has_codec_parameters(st, NULL)) {
3919  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3920  if (codec && !avctx->codec) {
3921  AVDictionary *opts = NULL;
3922  if (ic->codec_whitelist)
3923  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3924  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3925  av_log(ic, AV_LOG_WARNING,
3926  "Failed to open codec in %s\n",__FUNCTION__);
3927  av_dict_free(&opts);
3928  }
3929  }
3930 
3931  // EOF already reached while reading the stream above.
3932  // So continue with reoordering DTS with whatever delay we have.
3934  update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3935  }
3936  }
3937  }
3938 
3939  if (flush_codecs) {
3940  AVPacket empty_pkt = { 0 };
3941  int err = 0;
3942  av_init_packet(&empty_pkt);
3943 
3944  for (i = 0; i < ic->nb_streams; i++) {
3945 
3946  st = ic->streams[i];
3947 
3948  /* flush the decoders */
3949  if (st->info->found_decoder == 1) {
3950  do {
3951  err = try_decode_frame(ic, st, &empty_pkt,
3952  (options && i < orig_nb_streams)
3953  ? &options[i] : NULL);
3954  } while (err > 0 && !has_codec_parameters(st, NULL));
3955 
3956  if (err < 0) {
3957  av_log(ic, AV_LOG_INFO,
3958  "decoding for stream %d failed\n", st->index);
3959  }
3960  }
3961  }
3962  }
3963 
3964  ff_rfps_calculate(ic);
3965 
3966  for (i = 0; i < ic->nb_streams; i++) {
3967  st = ic->streams[i];
3968  avctx = st->internal->avctx;
3969  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3970  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3971  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3973  avctx->codec_tag= tag;
3974  }
3975 
3976  /* estimate average framerate if not set by demuxer */
3977  if (st->info->codec_info_duration_fields &&
3978  !st->avg_frame_rate.num &&
3979  st->info->codec_info_duration) {
3980  int best_fps = 0;
3981  double best_error = 0.01;
3982  AVRational codec_frame_rate = avctx->framerate;
3983 
3984  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3985  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3986  st->info->codec_info_duration < 0)
3987  continue;
3989  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3990  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3991 
3992  /* Round guessed framerate to a "standard" framerate if it's
3993  * within 1% of the original estimate. */
3994  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3995  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3996  double error = fabs(av_q2d(st->avg_frame_rate) /
3997  av_q2d(std_fps) - 1);
3998 
3999  if (error < best_error) {
4000  best_error = error;
4001  best_fps = std_fps.num;
4002  }
4003 
4004  if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4005  error = fabs(av_q2d(codec_frame_rate) /
4006  av_q2d(std_fps) - 1);
4007  if (error < best_error) {
4008  best_error = error;
4009  best_fps = std_fps.num;
4010  }
4011  }
4012  }
4013  if (best_fps)
4015  best_fps, 12 * 1001, INT_MAX);
4016  }
4017 
4018  if (!st->r_frame_rate.num) {
4019  if ( avctx->time_base.den * (int64_t) st->time_base.num
4020  <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
4022  avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4023  } else {
4024  st->r_frame_rate.num = st->time_base.den;
4025  st->r_frame_rate.den = st->time_base.num;
4026  }
4027  }
4029  AVRational hw_ratio = { avctx->height, avctx->width };
4031  hw_ratio);
4032  }
4033  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4034  if (!avctx->bits_per_coded_sample)
4035  avctx->bits_per_coded_sample =
4037  // set stream disposition based on audio service type
4038  switch (avctx->audio_service_type) {
4041  break;
4044  break;
4047  break;
4050  break;
4053  break;
4054  }
4055  }
4056  }
4057 
4058  if (probesize)
4059  estimate_timings(ic, old_offset);
4060 
4061  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4062 
4063  if (ret >= 0 && ic->nb_streams)
4064  /* We could not have all the codec parameters before EOF. */
4065  ret = -1;
4066  for (i = 0; i < ic->nb_streams; i++) {
4067  const char *errmsg;
4068  st = ic->streams[i];
4069 
4070  /* if no packet was ever seen, update context now for has_codec_parameters */
4071  if (!st->internal->avctx_inited) {
4072  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4074  st->codecpar->format = st->internal->avctx->sample_fmt;
4076  if (ret < 0)
4077  goto find_stream_info_err;
4078  }
4079  if (!has_codec_parameters(st, &errmsg)) {
4080  char buf[256];
4081  avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4082  av_log(ic, AV_LOG_WARNING,
4083  "Could not find codec parameters for stream %d (%s): %s\n"
4084  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4085  i, buf, errmsg);
4086  } else {
4087  ret = 0;
4088  }
4089  }
4090 
4092 
4093  /* update the stream parameters from the internal codec contexts */
4094  for (i = 0; i < ic->nb_streams; i++) {
4095  st = ic->streams[i];
4096 
4097  if (st->internal->avctx_inited) {
4098  int orig_w = st->codecpar->width;
4099  int orig_h = st->codecpar->height;
4101  if (ret < 0)
4102  goto find_stream_info_err;
4103 #if FF_API_LOWRES
4104  // The decoder might reduce the video size by the lowres factor.
4105  if (st->internal->avctx->lowres && orig_w) {
4106  st->codecpar->width = orig_w;
4107  st->codecpar->height = orig_h;
4108  }
4109 #endif
4110  }
4111 
4112 #if FF_API_LAVF_AVCTX
4114  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4115  if (ret < 0)
4116  goto find_stream_info_err;
4117 
4118 #if FF_API_LOWRES
4119  // The old API (AVStream.codec) "requires" the resolution to be adjusted
4120  // by the lowres factor.
4121  if (st->internal->avctx->lowres && st->internal->avctx->width) {
4122  st->codec->lowres = st->internal->avctx->lowres;
4123  st->codec->width = st->internal->avctx->width;
4124  st->codec->height = st->internal->avctx->height;
4125  }
4126 #endif
4127 
4128  if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4129  st->codec->time_base = st->internal->avctx->time_base;
4130  st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4131  }
4132  st->codec->framerate = st->avg_frame_rate;
4133 
4134  if (st->internal->avctx->subtitle_header) {
4135  st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4136  if (!st->codec->subtitle_header)
4137  goto find_stream_info_err;
4138  st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4139  memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4140  st->codec->subtitle_header_size);
4141  }
4142 
4143  // Fields unavailable in AVCodecParameters
4144  st->codec->coded_width = st->internal->avctx->coded_width;
4145  st->codec->coded_height = st->internal->avctx->coded_height;
4146  st->codec->properties = st->internal->avctx->properties;
4148 #endif
4149 
4150  st->internal->avctx_inited = 0;
4151  }
4152 
4153 find_stream_info_err:
4154  for (i = 0; i < ic->nb_streams; i++) {
4155  st = ic->streams[i];
4156  if (st->info)
4157  av_freep(&st->info->duration_error);
4158  avcodec_close(ic->streams[i]->internal->avctx);
4159  av_freep(&ic->streams[i]->info);
4162  }
4163  if (ic->pb)
4164  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4165  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4166  return ret;
4167 }
4168 
4170 {
4171  int i, j;
4172 
4173  for (i = 0; i < ic->nb_programs; i++) {
4174  if (ic->programs[i] == last) {
4175  last = NULL;
4176  } else {
4177  if (!last)
4178  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4179  if (ic->programs[i]->stream_index[j] == s)
4180  return ic->programs[i];
4181  }
4182  }
4183  return NULL;
4184 }
4185 
4187  int wanted_stream_nb, int related_stream,
4188  AVCodec **decoder_ret, int flags)
4189 {
4190  int i, nb_streams = ic->nb_streams;
4191  int ret = AVERROR_STREAM_NOT_FOUND;
4192  int best_count = -1, best_multiframe = -1, best_disposition = -1;
4193  int count, multiframe, disposition;
4194  int64_t best_bitrate = -1;
4195  int64_t bitrate;
4196  unsigned *program = NULL;
4197  const AVCodec *decoder = NULL, *best_decoder = NULL;
4198 
4199  if (related_stream >= 0 && wanted_stream_nb < 0) {
4200  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4201  if (p) {
4202  program = p->stream_index;
4203  nb_streams = p->nb_stream_indexes;
4204  }
4205  }
4206  for (i = 0; i < nb_streams; i++) {
4207  int real_stream_index = program ? program[i] : i;
4208  AVStream *st = ic->streams[real_stream_index];
4209  AVCodecParameters *par = st->codecpar;
4210  if (par->codec_type != type)
4211  continue;
4212  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4213  continue;
4214  if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4215  continue;
4216  if (decoder_ret) {
4217  decoder = find_decoder(ic, st, par->codec_id);
4218  if (!decoder) {
4219  if (ret < 0)
4221  continue;
4222  }
4223  }
4225  + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4226  count = st->codec_info_nb_frames;
4227  bitrate = par->bit_rate;
4228  multiframe = FFMIN(5, count);
4229  if ((best_disposition > disposition) ||
4230  (best_disposition == disposition && best_multiframe > multiframe) ||
4231  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4232  (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4233  continue;
4234  best_disposition = disposition;
4235  best_count = count;
4236  best_bitrate = bitrate;
4237  best_multiframe = multiframe;
4238  ret = real_stream_index;
4239  best_decoder = decoder;
4240  if (program && i == nb_streams - 1 && ret < 0) {
4241  program = NULL;
4242  nb_streams = ic->nb_streams;
4243  /* no related stream found, try again with everything */
4244  i = 0;
4245  }
4246  }
4247  if (decoder_ret)
4248  *decoder_ret = (AVCodec*)best_decoder;
4249  return ret;
4250 }
4251 
4252 /*******************************************************/
4253 
4255 {
4256  if (s->iformat->read_play)
4257  return s->iformat->read_play(s);
4258  if (s->pb)
4259  return avio_pause(s->pb, 0);
4260  return AVERROR(ENOSYS);
4261 }
4262 
4264 {
4265  if (s->iformat->read_pause)
4266  return s->iformat->read_pause(s);
4267  if (s->pb)
4268  return avio_pause(s->pb, 1);
4269  return AVERROR(ENOSYS);
4270 }
4271 
4273 {
4274  int ret, i;
4275 
4276  dst->id = src->id;
4277  dst->time_base = src->time_base;
4278  dst->nb_frames = src->nb_frames;
4279  dst->disposition = src->disposition;
4281  dst->avg_frame_rate = src->avg_frame_rate;
4282  dst->r_frame_rate = src->r_frame_rate;
4283 
4284  av_dict_free(&dst->metadata);
4285  ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4286  if (ret < 0)
4287  return ret;
4288 
4289  ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4290  if (ret < 0)
4291  return ret;
4292 
4293  /* Free existing side data*/
4294  for (i = 0; i < dst->nb_side_data; i++)
4295  av_free(dst->side_data[i].data);
4296  av_freep(&dst->side_data);
4297  dst->nb_side_data = 0;
4298 
4299  /* Copy side data if present */
4300  if (src->nb_side_data) {
4302  sizeof(AVPacketSideData));
4303  if (!dst->side_data)
4304  return AVERROR(ENOMEM);
4305  dst->nb_side_data = src->nb_side_data;
4306 
4307  for (i = 0; i < src->nb_side_data; i++) {
4308  uint8_t *data = av_memdup(src->side_data[i].data,
4309  src->side_data[i].size);
4310  if (!data)
4311  return AVERROR(ENOMEM);
4312  dst->side_data[i].type = src->side_data[i].type;
4313  dst->side_data[i].size = src->side_data[i].size;
4314  dst->side_data[i].data = data;
4315  }
4316  }
4317 
4318 #if FF_API_LAVF_FFSERVER
4320  av_freep(&dst->recommended_encoder_configuration);
4321  if (src->recommended_encoder_configuration) {
4322  const char *conf_str = src->recommended_encoder_configuration;
4323  dst->recommended_encoder_configuration = av_strdup(conf_str);
4324  if (!dst->recommended_encoder_configuration)
4325  return AVERROR(ENOMEM);
4326  }
4328 #endif
4329 
4330  return 0;
4331 }
4332 
4333 static void free_stream(AVStream **pst)
4334 {
4335  AVStream *st = *pst;
4336  int i;
4337 
4338  if (!st)
4339  return;
4340 
4341  for (i = 0; i < st->nb_side_data; i++)
4342  av_freep(&st->side_data[i].data);
4343  av_freep(&st->side_data);
4344 
4345  if (st->parser)
4346  av_parser_close(st->parser);
4347 
4348  if (st->attached_pic.data)
4350 
4351  if (st->internal) {
4353  for (i = 0; i < st->internal->nb_bsfcs; i++) {
4354  av_bsf_free(&st->internal->bsfcs[i]);
4355  av_freep(&st->internal->bsfcs);
4356  }
4357  av_freep(&st->internal->priv_pts);
4360  }
4361  av_freep(&st->internal);
4362 
4363  av_dict_free(&st->metadata);
4365  av_freep(&st->probe_data.buf);
4366  av_freep(&st->index_entries);
4367 #if FF_API_LAVF_AVCTX
4369  avcodec_free_context(&st->codec);
4371 #endif
4372  av_freep(&st->priv_data);
4373  if (st->info)
4374  av_freep(&st->info->duration_error);
4375  av_freep(&st->info);
4376 #if FF_API_LAVF_FFSERVER
4378  av_freep(&st->recommended_encoder_configuration);
4380 #endif
4381 
4382  av_freep(pst);
4383 }
4384 
4386 {
4387  av_assert0(s->nb_streams>0);
4388  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4389 
4390  free_stream(&s->streams[ --s->nb_streams ]);
4391 }
4392 
4394 {
4395  int i;
4396 
4397  if (!s)
4398  return;
4399 
4400  av_opt_free(s);
4401  if (s->iformat && s->iformat->priv_class && s->priv_data)
4402  av_opt_free(s->priv_data);
4403  if (s->oformat && s->oformat->priv_class && s->priv_data)
4404  av_opt_free(s->priv_data);
4405 
4406  for (i = s->nb_streams - 1; i >= 0; i--)
4407  ff_free_stream(s, s->streams[i]);
4408 
4409 
4410  for (i = s->nb_programs - 1; i >= 0; i--) {
4411  av_dict_free(&s->programs[i]->metadata);
4412  av_freep(&s->programs[i]->stream_index);
4413  av_freep(&s->programs[i]);
4414  }
4415  av_freep(&s->programs);
4416  av_freep(&s->priv_data);
4417  while (s->nb_chapters--) {
4419  av_freep(&s->chapters[s->nb_chapters]);
4420  }
4421  av_freep(&s->chapters);
4422  av_dict_free(&s->metadata);
4424  av_freep(&s->streams);
4425  flush_packet_queue(s);
4426  av_freep(&s->internal);
4427  av_freep(&s->url);
4428  av_free(s);
4429 }
4430 
4432 {
4433  AVFormatContext *s;
4434  AVIOContext *pb;
4435 
4436  if (!ps || !*ps)
4437  return;
4438 
4439  s = *ps;
4440  pb = s->pb;
4441 
4442  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4443  (s->flags & AVFMT_FLAG_CUSTOM_IO))
4444  pb = NULL;
4445 
4446  flush_packet_queue(s);
4447 
4448  if (s->iformat)
4449  if (s->iformat->read_close)
4450  s->iformat->read_close(s);
4451 
4453 
4454  *ps = NULL;
4455 
4456  avio_close(pb);
4457 }
4458 
4460 {
4461  AVStream *st;
4462  int i;
4463  AVStream **streams;
4464 
4465  if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4466  if (s->max_streams < INT_MAX/sizeof(*streams))
4467  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);
4468  return NULL;
4469  }
4470  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4471  if (!streams)
4472  return NULL;
4473  s->streams = streams;
4474 
4475  st = av_mallocz(sizeof(AVStream));
4476  if (!st)
4477  return NULL;
4478  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4479  av_free(st);
4480  return NULL;
4481  }
4482  st->info->last_dts = AV_NOPTS_VALUE;
4483 
4484 #if FF_API_LAVF_AVCTX
4486  st->codec = avcodec_alloc_context3(c);
4487  if (!st->codec) {
4488  av_free(st->info);
4489  av_free(st);
4490  return NULL;
4491  }
4493 #endif
4494 
4495  st->internal = av_mallocz(sizeof(*st->internal));
4496  if (!st->internal)
4497  goto fail;
4498 
4500  if (!st->codecpar)
4501  goto fail;
4502 
4504  if (!st->internal->avctx)
4505  goto fail;
4506 
4507  if (s->iformat) {
4508 #if FF_API_LAVF_AVCTX
4510  /* no default bitrate if decoding */
4511  st->codec->bit_rate = 0;
4513 #endif
4514 
4515  /* default pts setting is MPEG-like */
4516  avpriv_set_pts_info(st, 33, 1, 90000);
4517  /* we set the current DTS to 0 so that formats without any timestamps
4518  * but durations get some timestamps, formats with some unknown
4519  * timestamps have their first few packets buffered and the
4520  * timestamps corrected before they are returned to the user */
4521  st->cur_dts = RELATIVE_TS_BASE;
4522  } else {
4523  st->cur_dts = AV_NOPTS_VALUE;
4524  }
4525 
4526  st->index = s->nb_streams;
4527  st->start_time = AV_NOPTS_VALUE;
4528  st->duration = AV_NOPTS_VALUE;
4529  st->first_dts = AV_NOPTS_VALUE;
4533 
4536  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4537  st->pts_buffer[i] = AV_NOPTS_VALUE;
4538 
4539  st->sample_aspect_ratio = (AVRational) { 0, 1 };
4540 
4541 #if FF_API_R_FRAME_RATE
4542  st->info->last_dts = AV_NOPTS_VALUE;
4543 #endif
4546 
4548 
4549  st->internal->need_context_update = 1;
4550 
4551  s->streams[s->nb_streams++] = st;
4552  return st;
4553 fail:
4554  free_stream(&st);
4555  return NULL;
4556 }
4557 
4559 {
4560  AVProgram *program = NULL;
4561  int i;
4562 
4563  av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4564 
4565  for (i = 0; i < ac->nb_programs; i++)
4566  if (ac->programs[i]->id == id)
4567  program = ac->programs[i];
4568 
4569  if (!program) {
4570  program = av_mallocz(sizeof(AVProgram));
4571  if (!program)
4572  return NULL;
4573  dynarray_add(&ac->programs, &ac->nb_programs, program);
4574  program->discard = AVDISCARD_NONE;
4575  program->pmt_version = -1;
4576  }
4577  program->id = id;
4580 
4581  program->start_time =
4582  program->end_time = AV_NOPTS_VALUE;
4583 
4584  return program;
4585 }
4586 
4588  int64_t start, int64_t end, const char *title)
4589 {
4590  AVChapter *chapter = NULL;
4591  int i;
4592 
4593  if (end != AV_NOPTS_VALUE && start > end) {
4594  av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4595  return NULL;
4596  }
4597 
4598  for (i = 0; i < s->nb_chapters; i++)
4599  if (s->chapters[i]->id == id)
4600  chapter = s->chapters[i];
4601 
4602  if (!chapter) {
4603  chapter = av_mallocz(sizeof(AVChapter));
4604  if (!chapter)
4605  return NULL;
4606  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4607  }
4608  av_dict_set(&chapter->metadata, "title", title, 0);
4609  chapter->id = id;
4610  chapter->time_base = time_base;
4611  chapter->start = start;
4612  chapter->end = end;
4613 
4614  return chapter;
4615 }
4616 
4617 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4618 {
4619  int i, j;
4620  AVProgram *program = NULL;
4621  void *tmp;
4622 
4623  if (idx >= ac->nb_streams) {
4624  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4625  return;
4626  }
4627 
4628  for (i = 0; i < ac->nb_programs; i++) {
4629  if (ac->programs[i]->id != progid)
4630  continue;
4631  program = ac->programs[i];
4632  for (j = 0; j < program->nb_stream_indexes; j++)
4633  if (program->stream_index[j] == idx)
4634  return;
4635 
4636  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4637  if (!tmp)
4638  return;
4639  program->stream_index = tmp;
4640  program->stream_index[program->nb_stream_indexes++] = idx;
4641  return;
4642  }
4643 }
4644 
4645 uint64_t ff_ntp_time(void)
4646 {
4647  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4648 }
4649 
4650 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4651 {
4652  uint64_t ntp_ts, frac_part, sec;
4653  uint32_t usec;
4654 
4655  //current ntp time in seconds and micro seconds
4656  sec = ntp_time_us / 1000000;
4657  usec = ntp_time_us % 1000000;
4658 
4659  //encoding in ntp timestamp format
4660  frac_part = usec * 0xFFFFFFFFULL;
4661  frac_part /= 1000000;
4662 
4663  if (sec > 0xFFFFFFFFULL)
4664  av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4665 
4666  ntp_ts = sec << 32;
4667  ntp_ts |= frac_part;
4668 
4669  return ntp_ts;
4670 }
4671 
4672 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4673 {
4674  const char *p;
4675  char *q, buf1[20], c;
4676  int nd, len, percentd_found;
4677 
4678  q = buf;
4679  p = path;
4680  percentd_found = 0;
4681  for (;;) {
4682  c = *p++;
4683  if (c == '\0')
4684  break;
4685  if (c == '%') {
4686  do {
4687  nd = 0;
4688  while (av_isdigit(*p))
4689  nd = nd * 10 + *p++ - '0';
4690  c = *p++;
4691  } while (av_isdigit(c));
4692 
4693  switch (c) {
4694  case '%':
4695  goto addchar;
4696  case 'd':
4697  if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4698  goto fail;
4699  percentd_found = 1;
4700  if (number < 0)
4701  nd += 1;
4702  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4703  len = strlen(buf1);
4704  if ((q - buf + len) > buf_size - 1)
4705  goto fail;
4706  memcpy(q, buf1, len);
4707  q += len;
4708  break;
4709  default:
4710  goto fail;
4711  }
4712  } else {
4713 addchar:
4714  if ((q - buf) < buf_size - 1)
4715  *q++ = c;
4716  }
4717  }
4718  if (!percentd_found)
4719  goto fail;
4720  *q = '\0';
4721  return 0;
4722 fail:
4723  *q = '\0';
4724  return -1;
4725 }
4726 
4727 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4728 {
4729  return av_get_frame_filename2(buf, buf_size, path, number, 0);
4730 }
4731 
4732 void av_url_split(char *proto, int proto_size,
4733  char *authorization, int authorization_size,
4734  char *hostname, int hostname_size,
4735  int *port_ptr, char *path, int path_size, const char *url)
4736 {
4737  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4738 
4739  if (port_ptr)
4740  *port_ptr = -1;
4741  if (proto_size > 0)
4742  proto[0] = 0;
4743  if (authorization_size > 0)
4744  authorization[0] = 0;
4745  if (hostname_size > 0)
4746  hostname[0] = 0;
4747  if (path_size > 0)
4748  path[0] = 0;
4749 
4750  /* parse protocol */
4751  if ((p = strchr(url, ':'))) {
4752  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4753  p++; /* skip ':' */
4754  if (*p == '/')
4755  p++;
4756  if (*p == '/')
4757  p++;
4758  } else {
4759  /* no protocol means plain filename */
4760  av_strlcpy(path, url, path_size);
4761  return;
4762  }
4763 
4764  /* separate path from hostname */
4765  ls = strchr(p, '/');
4766  ls2 = strchr(p, '?');
4767  if (!ls)
4768  ls = ls2;
4769  else if (ls && ls2)
4770  ls = FFMIN(ls, ls2);
4771  if (ls)
4772  av_strlcpy(path, ls, path_size);
4773  else
4774  ls = &p[strlen(p)]; // XXX
4775 
4776  /* the rest is hostname, use that to parse auth/port */
4777  if (ls != p) {
4778  /* authorization (user[:pass]@hostname) */
4779  at2 = p;
4780  while ((at = strchr(p, '@')) && at < ls) {
4781  av_strlcpy(authorization, at2,
4782  FFMIN(authorization_size, at + 1 - at2));
4783  p = at + 1; /* skip '@' */
4784  }
4785 
4786  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4787  /* [host]:port */
4788  av_strlcpy(hostname, p + 1,
4789  FFMIN(hostname_size, brk - p));
4790  if (brk[1] == ':' && port_ptr)
4791  *port_ptr = atoi(brk + 2);
4792  } else if ((col = strchr(p, ':')) && col < ls) {
4793  av_strlcpy(hostname, p,
4794  FFMIN(col + 1 - p, hostname_size));
4795  if (port_ptr)
4796  *port_ptr = atoi(col + 1);
4797  } else
4798  av_strlcpy(hostname, p,
4799  FFMIN(ls + 1 - p, hostname_size));
4800  }
4801 }
4802 
4803 int ff_mkdir_p(const char *path)
4804 {
4805  int ret = 0;
4806  char *temp = av_strdup(path);
4807  char *pos = temp;
4808  char tmp_ch = '\0';
4809 
4810  if (!path || !temp) {
4811  return -1;
4812  }
4813 
4814  if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4815  pos++;
4816  } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4817  pos += 2;
4818  }
4819 
4820  for ( ; *pos != '\0'; ++pos) {
4821  if (*pos == '/' || *pos == '\\') {
4822  tmp_ch = *pos;
4823  *pos = '\0';
4824  ret = mkdir(temp, 0755);
4825  *pos = tmp_ch;
4826  }
4827  }
4828 
4829  if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4830  ret = mkdir(temp, 0755);
4831  }
4832 
4833  av_free(temp);
4834  return ret;
4835 }
4836 
4837 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4838 {
4839  int i;
4840  static const char hex_table_uc[16] = { '0', '1', '2', '3',
4841  '4', '5', '6', '7',
4842  '8', '9', 'A', 'B',
4843  'C', 'D', 'E', 'F' };
4844  static const char hex_table_lc[16] = { '0', '1', '2', '3',
4845  '4', '5', '6', '7',
4846  '8', '9', 'a', 'b',
4847  'c', 'd', 'e', 'f' };
4848  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4849 
4850  for (i = 0; i < s; i++) {
4851  buff[i * 2] = hex_table[src[i] >> 4];
4852  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4853  }
4854 
4855  return buff;
4856 }
4857 
4858 int ff_hex_to_data(uint8_t *data, const char *p)
4859 {
4860  int c, len, v;
4861 
4862  len = 0;
4863  v = 1;
4864  for (;;) {
4865  p += strspn(p, SPACE_CHARS);
4866  if (*p == '\0')
4867  break;
4868  c = av_toupper((unsigned char) *p++);
4869  if (c >= '0' && c <= '9')
4870  c = c - '0';
4871  else if (c >= 'A' && c <= 'F')
4872  c = c - 'A' + 10;
4873  else
4874  break;
4875  v = (v << 4) | c;
4876  if (v & 0x100) {
4877  if (data)
4878  data[len] = v;
4879  len++;
4880  v = 1;
4881  }
4882  }
4883  return len;
4884 }
4885 
4886 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4887  unsigned int pts_num, unsigned int pts_den)
4888 {
4889  AVRational new_tb;
4890  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4891  if (new_tb.num != pts_num)
4893  "st:%d removing common factor %d from timebase\n",
4894  s->index, pts_num / new_tb.num);
4895  } else
4897  "st:%d has too large timebase, reducing\n", s->index);
4898 
4899  if (new_tb.num <= 0 || new_tb.den <= 0) {
4901  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4902  new_tb.num, new_tb.den,
4903  s->index);
4904  return;
4905  }
4906  s->time_base = new_tb;
4907 #if FF_API_LAVF_AVCTX
4909  s->codec->pkt_timebase = new_tb;
4911 #endif
4912  s->internal->avctx->pkt_timebase = new_tb;
4913  s->pts_wrap_bits = pts_wrap_bits;
4914 }
4915 
4916 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4917  void *context)
4918 {
4919  const char *ptr = str;
4920 
4921  /* Parse key=value pairs. */
4922  for (;;) {
4923  const char *key;
4924  char *dest = NULL, *dest_end;
4925  int key_len, dest_len = 0;
4926 
4927  /* Skip whitespace and potential commas. */
4928  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4929  ptr++;
4930  if (!*ptr)
4931  break;
4932 
4933  key = ptr;
4934 
4935  if (!(ptr = strchr(key, '=')))
4936  break;
4937  ptr++;
4938  key_len = ptr - key;
4939 
4940  callback_get_buf(context, key, key_len, &dest, &dest_len);
4941  dest_end = dest + dest_len - 1;
4942 
4943  if (*ptr == '\"') {
4944  ptr++;
4945  while (*ptr && *ptr != '\"') {
4946  if (*ptr == '\\') {
4947  if (!ptr[1])
4948  break;
4949  if (dest && dest < dest_end)
4950  *dest++ = ptr[1];
4951  ptr += 2;
4952  } else {
4953  if (dest && dest < dest_end)
4954  *dest++ = *ptr;
4955  ptr++;
4956  }
4957  }
4958  if (*ptr == '\"')
4959  ptr++;
4960  } else {
4961  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4962  if (dest && dest < dest_end)
4963  *dest++ = *ptr;
4964  }
4965  if (dest)
4966  *dest = 0;
4967  }
4968 }
4969 
4971 {
4972  int i;
4973  for (i = 0; i < s->nb_streams; i++)
4974  if (s->streams[i]->id == id)
4975  return i;
4976  return -1;
4977 }
4978 
4980  int std_compliance)
4981 {
4982  if (ofmt) {
4983  unsigned int codec_tag;
4984  if (ofmt->query_codec)
4985  return ofmt->query_codec(codec_id, std_compliance);
4986  else if (ofmt->codec_tag)
4987  return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4988  else if (codec_id == ofmt->video_codec ||
4989  codec_id == ofmt->audio_codec ||
4990  codec_id == ofmt->subtitle_codec ||
4991  codec_id == ofmt->data_codec)
4992  return 1;
4993  }
4994  return AVERROR_PATCHWELCOME;
4995 }
4996 
4998 {
4999 #if CONFIG_NETWORK
5000  int ret;
5001  if ((ret = ff_network_init()) < 0)
5002  return ret;
5003  if ((ret = ff_tls_init()) < 0)
5004  return ret;
5005 #endif
5006  return 0;
5007 }
5008 
5010 {
5011 #if CONFIG_NETWORK
5012  ff_network_close();
5013  ff_tls_deinit();
5014 #endif
5015  return 0;
5016 }
5017 
5019  uint64_t channel_layout, int32_t sample_rate,
5021 {
5022  uint32_t flags = 0;
5023  int size = 4;
5024  uint8_t *data;
5025  if (!pkt)
5026  return AVERROR(EINVAL);
5027  if (channels) {
5028  size += 4;
5030  }
5031  if (channel_layout) {
5032  size += 8;
5034  }
5035  if (sample_rate) {
5036  size += 4;
5038  }
5039  if (width || height) {
5040  size += 8;
5042  }
5044  if (!data)
5045  return AVERROR(ENOMEM);
5046  bytestream_put_le32(&data, flags);
5047  if (channels)
5048  bytestream_put_le32(&data, channels);
5049  if (channel_layout)
5050  bytestream_put_le64(&data, channel_layout);
5051  if (sample_rate)
5052  bytestream_put_le32(&data, sample_rate);
5053  if (width || height) {
5054  bytestream_put_le32(&data, width);
5055  bytestream_put_le32(&data, height);
5056  }
5057  return 0;
5058 }
5059 
5061 {
5062  AVRational undef = {0, 1};
5063  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5064  AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5065  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5066 
5067  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5068  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5069  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5070  stream_sample_aspect_ratio = undef;
5071 
5072  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5073  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5074  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5075  frame_sample_aspect_ratio = undef;
5076 
5077  if (stream_sample_aspect_ratio.num)
5078  return stream_sample_aspect_ratio;
5079  else
5080  return frame_sample_aspect_ratio;
5081 }
5082 
5084 {
5085  AVRational fr = st->r_frame_rate;
5086  AVRational codec_fr = st->internal->avctx->framerate;
5087  AVRational avg_fr = st->avg_frame_rate;
5088 
5089  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5090  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5091  fr = avg_fr;
5092  }
5093 
5094 
5095  if (st->internal->avctx->ticks_per_frame > 1) {
5096  if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5097  (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))
5098  fr = codec_fr;
5099  }
5100 
5101  return fr;
5102 }
5103 
5104 /**
5105  * Matches a stream specifier (but ignores requested index).
5106  *
5107  * @param indexptr set to point to the requested stream index if there is one
5108  *
5109  * @return <0 on error
5110  * 0 if st is NOT a matching stream
5111  * >0 if st is a matching stream
5112  */
5114  const char *spec, const char **indexptr, AVProgram **p)
5115 {
5116  int match = 1; /* Stores if the specifier matches so far. */
5117  while (*spec) {
5118  if (*spec <= '9' && *spec >= '0') { /* opt:index */
5119  if (indexptr)
5120  *indexptr = spec;
5121  return match;
5122  } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5123  *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5124  enum AVMediaType type;
5125  int nopic = 0;
5126 
5127  switch (*spec++) {
5128  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5129  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5130  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5131  case 'd': type = AVMEDIA_TYPE_DATA; break;
5132  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5133  case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5134  default: av_assert0(0);
5135  }
5136  if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5137  return AVERROR(EINVAL);
5138 
5139 #if FF_API_LAVF_AVCTX
5141  if (type != st->codecpar->codec_type
5142  && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5143  match = 0;
5145 #else
5146  if (type != st->codecpar->codec_type)
5147  match = 0;
5148 #endif
5149  if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5150  match = 0;
5151  } else if (*spec == 'p' && *(spec + 1) == ':') {
5152  int prog_id, i, j;
5153  int found = 0;
5154  char *endptr;
5155  spec += 2;
5156  prog_id = strtol(spec, &endptr, 0);
5157  /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5158  if (spec == endptr || (*endptr && *endptr++ != ':'))
5159  return AVERROR(EINVAL);
5160  spec = endptr;
5161  if (match) {
5162  for (i = 0; i < s->nb_programs; i++) {
5163  if (s->programs[i]->id != prog_id)
5164  continue;
5165 
5166  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5167  if (st->index == s->programs[i]->stream_index[j]) {
5168  found = 1;
5169  if (p)
5170  *p = s->programs[i];
5171  i = s->nb_programs;
5172  break;
5173  }
5174  }
5175  }
5176  }
5177  if (!found)
5178  match = 0;
5179  } else if (*spec == '#' ||
5180  (*spec == 'i' && *(spec + 1) == ':')) {
5181  int stream_id;
5182  char *endptr;
5183  spec += 1 + (*spec == 'i');
5184  stream_id = strtol(spec, &endptr, 0);
5185  if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5186  return AVERROR(EINVAL);
5187  return match && (stream_id == st->id);
5188  } else if (*spec == 'm' && *(spec + 1) == ':') {
5190  char *key, *val;
5191  int ret;
5192 
5193  if (match) {
5194  spec += 2;
5195  val = strchr(spec, ':');
5196 
5197  key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5198  if (!key)
5199  return AVERROR(ENOMEM);
5200 
5201  tag = av_dict_get(st->metadata, key, NULL, 0);
5202  if (tag) {
5203  if (!val || !strcmp(tag->value, val + 1))
5204  ret = 1;
5205  else
5206  ret = 0;
5207  } else
5208  ret = 0;
5209 
5210  av_freep(&key);
5211  }
5212  return match && ret;
5213  } else if (*spec == 'u' && *(spec + 1) == '\0') {
5214  AVCodecParameters *par = st->codecpar;
5215 #if FF_API_LAVF_AVCTX
5217  AVCodecContext *codec = st->codec;
5219 #endif
5220  int val;
5221  switch (par->codec_type) {
5222  case AVMEDIA_TYPE_AUDIO:
5223  val = par->sample_rate && par->channels;
5224 #if FF_API_LAVF_AVCTX
5225  val = val || (codec->sample_rate && codec->channels);
5226 #endif
5227  if (par->format == AV_SAMPLE_FMT_NONE
5229  && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5230 #endif
5231  )
5232  return 0;
5233  break;
5234  case AVMEDIA_TYPE_VIDEO:
5235  val = par->width && par->height;
5236 #if FF_API_LAVF_AVCTX
5237  val = val || (codec->width && codec->height);
5238 #endif
5239  if (par->format == AV_PIX_FMT_NONE
5241  && codec->pix_fmt == AV_PIX_FMT_NONE
5242 #endif
5243  )
5244  return 0;
5245  break;
5246  case AVMEDIA_TYPE_UNKNOWN:
5247  val = 0;
5248  break;
5249  default:
5250  val = 1;
5251  break;
5252  }
5253 #if FF_API_LAVF_AVCTX
5254  return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5255 #else
5256  return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5257 #endif
5258  } else {
5259  return AVERROR(EINVAL);
5260  }
5261  }
5262 
5263  return match;
5264 }
5265 
5266 
5268  const char *spec)
5269 {
5270  int ret, index;
5271  char *endptr;
5272  const char *indexptr = NULL;
5273  AVProgram *p = NULL;
5274  int nb_streams;
5275 
5276  ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5277  if (ret < 0)
5278  goto error;
5279 
5280  if (!indexptr)
5281  return ret;
5282 
5283  index = strtol(indexptr, &endptr, 0);
5284  if (*endptr) { /* We can't have anything after the requested index. */
5285  ret = AVERROR(EINVAL);
5286  goto error;
5287  }
5288 
5289  /* This is not really needed but saves us a loop for simple stream index specifiers. */
5290  if (spec == indexptr)
5291  return (index == st->index);
5292 
5293  /* If we requested a matching stream index, we have to ensure st is that. */
5294  nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5295  for (int i = 0; i < nb_streams && index >= 0; i++) {
5296  AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5297  ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5298  if (ret < 0)
5299  goto error;
5300  if (ret > 0 && index-- == 0 && st == candidate)
5301  return 1;
5302  }
5303  return 0;
5304 
5305 error:
5306  if (ret == AVERROR(EINVAL))
5307  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5308  return ret;
5309 }
5310 
5312 {
5313  static const uint8_t avci100_1080p_extradata[] = {
5314  // SPS
5315  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5316  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5317  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5318  0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5319  0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5320  0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5321  0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5322  0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5323  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5324  // PPS
5325  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5326  0xd0
5327  };
5328  static const uint8_t avci100_1080i_extradata[] = {
5329  // SPS
5330  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5331  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5332  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5333  0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5334  0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5335  0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5336  0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5337  0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5338  0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5339  0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5340  0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5341  // PPS
5342  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5343  0xd0
5344  };
5345  static const uint8_t avci50_1080p_extradata[] = {
5346  // SPS
5347  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5348  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5349  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5350  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5351  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5352  0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5353  0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5354  0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5355  0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5356  // PPS
5357  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5358  0x11
5359  };
5360  static const uint8_t avci50_1080i_extradata[] = {
5361  // SPS
5362  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5363  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5364  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5365  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5366  0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5367  0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5368  0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5369  0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5370  0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5371  0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5372  0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5373  // PPS
5374  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5375  0x11
5376  };
5377  static const uint8_t avci100_720p_extradata[] = {
5378  // SPS
5379  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5380  0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5381  0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5382  0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5383  0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5384  0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5385  0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5386  0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5387  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5388  0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5389  // PPS
5390  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5391  0x11
5392  };
5393  static const uint8_t avci50_720p_extradata[] = {
5394  // SPS
5395  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5396  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5397  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5398  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5399  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5400  0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5401  0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5402  0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5403  0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5404  // PPS
5405  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5406  0x11
5407  };
5408 
5409  const uint8_t *data = NULL;
5410  int size = 0;
5411 
5412  if (st->codecpar->width == 1920) {
5414  data = avci100_1080p_extradata;
5415  size = sizeof(avci100_1080p_extradata);
5416  } else {
5417  data = avci100_1080i_extradata;
5418  size = sizeof(avci100_1080i_extradata);
5419  }
5420  } else if (st->codecpar->width == 1440) {
5422  data = avci50_1080p_extradata;
5423  size = sizeof(avci50_1080p_extradata);
5424  } else {
5425  data = avci50_1080i_extradata;
5426  size = sizeof(avci50_1080i_extradata);
5427  }
5428  } else if (st->codecpar->width == 1280) {
5429  data = avci100_720p_extradata;
5430  size = sizeof(avci100_720p_extradata);
5431  } else if (st->codecpar->width == 960) {
5432  data = avci50_720p_extradata;
5433  size = sizeof(avci50_720p_extradata);
5434  }
5435 
5436  if (!size)
5437  return 0;
5438 
5439  av_freep(&st->codecpar->extradata);
5440  if (ff_alloc_extradata(st->codecpar, size))
5441  return AVERROR(ENOMEM);
5442  memcpy(st->codecpar->extradata, data, size);
5443 
5444  return 0;
5445 }
5446 
5448  enum AVPacketSideDataType type, int *size)
5449 {
5450  int i;
5451 
5452  for (i = 0; i < st->nb_side_data; i++) {
5453  if (st->side_data[i].type == type) {
5454  if (size)
5455  *size = st->side_data[i].size;
5456  return st->side_data[i].data;
5457  }
5458  }
5459  return NULL;
5460 }
5461 
5463  uint8_t *data, size_t size)
5464 {
5465  AVPacketSideData *sd, *tmp;
5466  int i;
5467 
5468  for (i = 0; i < st->nb_side_data; i++) {
5469  sd = &st->side_data[i];
5470 
5471  if (sd->type == type) {
5472  av_freep(&sd->data);
5473  sd->data = data;
5474  sd->size = size;
5475  return 0;
5476  }
5477  }
5478 
5479  if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5480  return AVERROR(ERANGE);
5481 
5482  tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5483  if (!tmp) {
5484  return AVERROR(ENOMEM);
5485  }
5486 
5487  st->side_data = tmp;
5488  st->nb_side_data++;
5489 
5490  sd = &st->side_data[st->nb_side_data - 1];
5491  sd->type = type;
5492  sd->data = data;
5493  sd->size = size;
5494 
5495  return 0;
5496 }
5497 
5499  int size)
5500 {
5501  int ret;
5502  uint8_t *data = av_malloc(size);
5503 
5504  if (!data)
5505  return NULL;
5506 
5507  ret = av_stream_add_side_data(st, type, data, size);
5508  if (ret < 0) {
5509  av_freep(&data);
5510  return NULL;
5511  }
5512 
5513  return data;
5514 }
5515 
5516 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5517 {
5518  int ret;
5519  const AVBitStreamFilter *bsf;
5520  AVBSFContext *bsfc;
5521  AVCodecParameters *in_par;
5522 
5523  if (!(bsf = av_bsf_get_by_name(name))) {
5524  av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5525  return AVERROR_BSF_NOT_FOUND;
5526  }
5527 
5528  if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5529  return ret;
5530 
5531  if (st->internal->nb_bsfcs) {
5532  in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5533  bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5534  } else {
5535  in_par = st->codecpar;
5536  bsfc->time_base_in = st->time_base;
5537  }
5538 
5539  if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5540  av_bsf_free(&bsfc);
5541  return ret;
5542  }
5543 
5544  if (args && bsfc->filter->priv_class) {
5545  const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5546  const char * shorthand[2] = {NULL};
5547 
5548  if (opt)
5549  shorthand[0] = opt->name;
5550 
5551  if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5552  av_bsf_free(&bsfc);
5553  return ret;
5554  }
5555  }
5556 
5557  if ((ret = av_bsf_init(bsfc)) < 0) {
5558  av_bsf_free(&bsfc);
5559  return ret;
5560  }
5561 
5562  if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5563  av_bsf_free(&bsfc);
5564  return ret;
5565  }
5566 
5568  "Automatically inserted bitstream filter '%s'; args='%s'\n",
5569  name, args ? args : "");
5570  return 1;
5571 }
5572 
5573 #if FF_API_OLD_BSF
5575 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5577 {
5578  int ret = 0;
5579  while (bsfc) {
5580  AVPacket new_pkt = *pkt;
5581  int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5582  &new_pkt.data, &new_pkt.size,
5583  pkt->data, pkt->size,
5584  pkt->flags & AV_PKT_FLAG_KEY);
5585  if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5586  av_packet_unref(pkt);
5587  memset(pkt, 0, sizeof(*pkt));
5588  return 0;
5589  }
5590  if(a == 0 && new_pkt.data != pkt->data) {
5591  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
5592  if (t) {
5593  memcpy(t, new_pkt.data, new_pkt.size);
5594  memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5595  new_pkt.data = t;
5596  new_pkt.buf = NULL;
5597  a = 1;
5598  } else {
5599  a = AVERROR(ENOMEM);
5600  }
5601  }
5602  if (a > 0) {
5603  new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5605  if (new_pkt.buf) {
5606  pkt->side_data = NULL;
5607  pkt->side_data_elems = 0;
5608  av_packet_unref(pkt);
5609  } else {
5610  av_freep(&new_pkt.data);
5611  a = AVERROR(ENOMEM);
5612  }
5613  }
5614  if (a < 0) {
5615  av_log(codec, AV_LOG_ERROR,
5616  "Failed to open bitstream filter %s for stream %d with codec %s",
5617  bsfc->filter->name, pkt->stream_index,
5618  codec->codec ? codec->codec->name : "copy");
5619  ret = a;
5620  break;
5621  }
5622  *pkt = new_pkt;
5623 
5624  bsfc = bsfc->next;
5625  }
5626  return ret;
5627 }
5629 #endif
5630 
5632 {
5633  if (!s->oformat)
5634  return AVERROR(EINVAL);
5635 
5636  if (!(s->oformat->flags & AVFMT_NOFILE))
5637  return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5638  return 0;
5639 }
5640 
5642 {
5643  if (*pb)
5644  s->io_close(s, *pb);
5645  *pb = NULL;
5646 }
5647 
5648 int ff_is_http_proto(char *filename) {
5649  const char *proto = avio_find_protocol_name(filename);
5650  return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5651 }
5652 
5653 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5654 {
5655  AVDictionaryEntry *entry;
5656  int64_t parsed_timestamp;
5657  int ret;
5658  if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5659  if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5660  *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5661  return 1;
5662  } else {
5663  av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5664  return ret;
5665  }
5666  }
5667  return 0;
5668 }
5669 
5671 {
5672  int64_t timestamp;
5673  int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5674  if (ret == 1)
5675  return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5676  return ret;
5677 }
5678 
5679 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5680 {
5681  uint8_t *side_data;
5682  int size;
5683 
5684  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5685  if (side_data) {
5686  if (size != AVPALETTE_SIZE) {
5687  av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5688  return AVERROR_INVALIDDATA;
5689  }
5690  memcpy(palette, side_data, AVPALETTE_SIZE);
5691  return 1;
5692  }
5693 
5694  if (ret == CONTAINS_PAL) {
5695  int i;
5696  for (i = 0; i < AVPALETTE_COUNT; i++)
5697  palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5698  return 1;
5699  }
5700 
5701  return 0;
5702 }
5703 
5705 {
5706  int ret;
5707  char *str;
5708 
5709  ret = av_bprint_finalize(buf, &str);
5710  if (ret < 0)
5711  return ret;
5712  if (!av_bprint_is_complete(buf)) {
5713  av_free(str);
5714  return AVERROR(ENOMEM);
5715  }
5716 
5717  par->extradata = str;
5718  /* Note: the string is NUL terminated (so extradata can be read as a
5719  * string), but the ending character is not accounted in the size (in
5720  * binary formats you are likely not supposed to mux that character). When
5721  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5722  * zeros. */
5723  par->extradata_size = buf->len;
5724  return 0;
5725 }
5726 
5728  AVStream *ost, const AVStream *ist,
5730 {
5731  //TODO: use [io]st->internal->avctx
5732  const AVCodecContext *dec_ctx = ist->codec;
5733  AVCodecContext *enc_ctx = ost->codec;
5734 
5735  enc_ctx->time_base = ist->time_base;
5736  /*
5737  * Avi is a special case here because it supports variable fps but
5738  * having the fps and timebase differe significantly adds quite some
5739  * overhead
5740  */
5741  if (!strcmp(ofmt->name, "avi")) {
5742 #if FF_API_R_FRAME_RATE
5743  if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5744  && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5745  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5746  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5747  && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5748  || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5749  enc_ctx->time_base.num = ist->r_frame_rate.den;
5750  enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5751  enc_ctx->ticks_per_frame = 2;
5752  } else
5753 #endif
5754  if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5755  && av_q2d(ist->time_base) < 1.0/500
5756  || copy_tb == AVFMT_TBCF_DECODER) {
5757  enc_ctx->time_base = dec_ctx->time_base;
5758  enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5759  enc_ctx->time_base.den *= 2;
5760  enc_ctx->ticks_per_frame = 2;
5761  }
5762  } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5763  && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5764  if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5765  && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5766  && av_q2d(ist->time_base) < 1.0/500
5767  || copy_tb == AVFMT_TBCF_DECODER) {
5768  enc_ctx->time_base = dec_ctx->time_base;
5769  enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5770  }
5771  }
5772 
5773  if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5774  && dec_ctx->time_base.num < dec_ctx->time_base.den
5775  && dec_ctx->time_base.num > 0
5776  && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5777  enc_ctx->time_base = dec_ctx->time_base;
5778  }
5779 
5780  if (ost->avg_frame_rate.num)
5781  enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5782 
5783  av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5784  enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5785 
5786  return 0;
5787 }
5788 
5790 {
5791  // See avformat_transfer_internal_stream_timing_info() TODO.
5792 #if FF_API_LAVF_AVCTX
5794  return st->codec->time_base;
5796 #else
5797  return st->internal->avctx->time_base;
5798 #endif
5799 }
5800 
5802 {
5803  av_assert0(url);
5804  av_freep(&s->url);
5805  s->url = url;
5806 #if FF_API_FORMAT_FILENAME
5808  av_strlcpy(s->filename, url, sizeof(s->filename));
5810 #endif
5811 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1587
const char * name
Definition: avisynth_c.h:867
#define AVINDEX_DISCARD_FRAME
Definition: avformat.h:818
unsigned int max_index_size
Maximum amount of memory in bytes to use for the index of each stream.
Definition: avformat.h:1568
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:4732
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2511
int64_t probesize
Maximum size of the data read from input for determining the input container format.
Definition: avformat.h:1524
static void free_stream(AVStream **pst)
Definition: utils.c:4333
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1940
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1007
void av_bsf_free(AVBSFContext **ctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:35
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: avformat.h:1083
#define NULL
Definition: coverity.c:32
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4587
const struct AVCodec * codec
Definition: avcodec.h:1574
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:141
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:802
AVRational framerate
Definition: avcodec.h:3105
const char const char void * val
Definition: avisynth_c.h:863
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: avcodec.h:750
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4038
static void fill_all_stream_timings(AVFormatContext *ic)
Definition: utils.c:2713
#define AVFMT_NOBINSEARCH
Format does not allow to fall back on binary search via read_timestamp.
Definition: avformat.h:473
int64_t duration_gcd
Definition: avformat.h:1046
int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
Retrieves the palette from a packet, either from side data, or appended to the video data in the pack...
Definition: utils.c:5679
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: avcodec.h:5831
static void update_initial_durations(AVFormatContext *s, AVStream *st, int stream_index, int duration)
Definition: utils.c:1172
AVProbeData probe_data
Definition: avformat.h:1106
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5797
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
#define AV_PTS_WRAP_ADD_OFFSET
add the format specific offset on wrap detection
Definition: avformat.h:871
static int shift(int a, int b)
Definition: sonic.c:82
AVPacketSideDataType
Definition: avcodec.h:1184
enum AVCodecID id
Definition: internal.h:45
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
static const char * format[]
Definition: af_aiir.c:338
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.h:206
int size
int av_demuxer_open(AVFormatContext *ic)
Definition: utils.c:395
struct AVPacketList * raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
Definition: internal.h:90
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1636
AVOption.
Definition: opt.h:246
FFFrac * priv_pts
Definition: internal.h:194
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c: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:1753
static int get_std_framerate(int i)
Definition: utils.c:3249
const char * fmt
Definition: avisynth_c.h:861
static int update_stream_avctx(AVFormatContext *s)
Definition: utils.c:502
enum AVDurationEstimationMethod duration_estimation_method
The duration field can be estimated through various ways, and this field can be used to know how the ...
Definition: avformat.h:1745
int64_t start_skip_samples
If not 0, the number of samples that should be skipped from the start of the stream (the samples are ...
Definition: avformat.h:1158
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1615
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1497
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:101
else temp
Definition: vf_mcdeint.c:256
AVCodec * av_codec_next(const AVCodec *c)
If c is NULL, returns the first registered codec, if c is non-NULL, returns the next registered codec...
Definition: allcodecs.c:838
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Perform a binary search using av_index_search_timestamp() and AVInputFormat.read_timestamp().
Definition: utils.c:2163
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: avformat.h:1108
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
int64_t pos
Definition: avformat.h:810
int probe_packets
Number of packets to buffer for codec probing.
Definition: avformat.h:1091
#define NTP_OFFSET_US
Definition: internal.h:245
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2513
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:4033
int64_t data_offset
offset of the first packet
Definition: internal.h:82
int width
Dimensions of the decoded video intended for presentation.
Definition: avcodec.h:5255
#define a0
Definition: regdef.h:46
AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio...
Definition: utils.c:5060
enum AVCodecID video_codec
default video codec
Definition: avformat.h:516
channels
Definition: aptx.c:30
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1305
enum AVCodecID codec_id
Definition: qsv.c:72
int64_t first_discard_sample
If not 0, the first audio sample that should be discarded from the stream.
Definition: avformat.h:1166
attribute_deprecated int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe)
int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
Utility function to open IO stream of output format.
Definition: utils.c:5631
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: avcodec.h:5772
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: avformat.h:1190
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int num
Numerator.
Definition: rational.h:59
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition: utils.c:2048
The bitstream filter state.
Definition: avcodec.h:5763
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:155
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1478
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
const char * b
Definition: vf_curves.c:116
void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
Wipe the list and unref all the packets in it.
Definition: utils.c: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:1737
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2709
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
#define AVIO_FLAG_READ
read-only
Definition: avio.h:654
int prefer_codec_framerate
Definition: internal.h:146
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:460
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1110
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.h:222
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1811
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
int(* read_close)(struct AVFormatContext *)
Close the stream.
Definition: avformat.h:736
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: utils.c:5801
#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:4970
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1480
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:223
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:872
void ff_network_close(void)
Definition: network.c:116
struct AVStreamInternal::@261 extract_extradata
int event_flags
Flags for the user to detect events happening on the file.
Definition: avformat.h:1673
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:839
int avformat_open_input(AVFormatContext **ps, const char *filename, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:537
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:496
#define a1
Definition: regdef.h:47
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1029
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
Definition: utils.c:2732
int ff_tls_init(void)
Definition: network.c:31
void * priv_data
Definition: avformat.h:896
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: avcodec.h:1033
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:841
const char * key
int duration
Duration of the current frame.
Definition: avcodec.h:5230
discard all
Definition: avcodec.h:811
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:983
int pmt_version
Definition: avformat.h:1286
static AVPacket pkt
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf, void *context)
Parse a string with comma-separated key=value pairs.
Definition: utils.c:4916
int priv_data_size
Size of private data so that it can be allocated in the wrapper.
Definition: avformat.h:705
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1407
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1070
AVDictionary * metadata
Definition: avformat.h:1319
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:707
int64_t maxsize
max filesize, used to limit allocations This field is internal to libavformat and access from outside...
Definition: avio.h:266
static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
Definition: utils.c:1570
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5784
#define src
Definition: vp8dsp.c:254
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails...
Definition: utils.c:5653
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header. ...
Definition: id3v2.c:1143
#define sample
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1556
AVCodec.
Definition: avcodec.h:3481
int framerate
Definition: h264_levels.c:65
static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
Wrap a given time stamp, if there is an indication for an overflow.
Definition: utils.c:106
static void force_codec_ids(AVFormatContext *s, AVStream *st)
Definition: utils.c:693
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:135
static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
Definition: utils.c: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:1218
#define AV_DISPOSITION_KARAOKE
Definition: avformat.h:831
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1688
Undefined.
Definition: avutil.h:273
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:99
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:2290
Format I/O context.
Definition: avformat.h:1358
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:3040
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264dec.c:60
AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
Definition: utils.c:5083
unsigned int nb_stream_indexes
Definition: avformat.h:1280
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:82
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1506
#define AVFMT_FLAG_NOPARSE
Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no...
Definition: avformat.h:1495
int64_t cur_dts
Definition: avformat.h:1084
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
internal metadata API header see avformat.h or the public API!
Public dictionary API.
const char * name
Definition: opt.h:247
#define DURATION_MAX_READ_SIZE
Definition: utils.c:2785
int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
Definition: dict.c:258
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:212
#define AVFMT_FLAG_DISCARD_CORRUPT
Discard frames marked corrupted.
Definition: avformat.h:1498
static int64_t start_time
Definition: ffplay.c:331
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:62
int64_t(* read_timestamp)(struct AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)
Get the next timestamp in stream[stream_index].time_base units.
Definition: avformat.h:753
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:524
uint8_t
Round toward +infinity.
Definition: mathematics.h:83
static int nb_streams
Definition: ffprobe.c:280
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4023
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
int ff_network_init(void)
Definition: network.c:58
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1302
int(* query_codec)(enum AVCodecID id, int std_compliance)
Test if the given codec can be stored in this container.
Definition: avformat.h:579
AVOptions.
int subtitle_header_size
Definition: avcodec.h:3051
static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: utils.c: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:1183
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:668
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2019
timestamp utils, mostly useful for debugging/logging purposes
unsigned avformat_version(void)
Return the LIBAVFORMAT_VERSION_INT constant.
Definition: utils.c:66
const char * avformat_license(void)
Return the libavformat license.
Definition: utils.c:77
int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt, AVStream *ost, const AVStream *ist, enum AVTimebaseSource copy_tb)
Transfer internal timing information from one stream to another.
Definition: utils.c:5727
unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt)
Return a value representing the fourCC code associated to the pixel format pix_fmt, or 0 if no associated fourCC code can be found.
Definition: raw.c:304
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AVPacket pkt
Definition: avformat.h:2025
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
#define f(width, name)
Definition: cbs_vp9.c:255
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int id
unique ID to identify the chapter
Definition: avformat.h:1316
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
int id
Format-specific stream ID.
Definition: avformat.h:888
enum AVStreamParseType need_parsing
Definition: avformat.h:1099
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c: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:5267
int duration_count
Definition: avformat.h:1047
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1490
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:987
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4459
uint8_t * av_stream_get_side_data(const AVStream *st, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5447
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data)...
Definition: internal.h:657
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
Definition: utils.c:334
static const AVCodec * find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:208
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2115
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5670
#define FF_PACKETLIST_FLAG_REF_PACKET
Create a new reference for the packet instead of transferring the ownership of the existing one to th...
Definition: internal.h:757
static AVFrame * frame
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
int inject_global_side_data
Internal data to inject global side data.
Definition: avformat.h:1225
const char * avformat_configuration(void)
Return the libavformat build-time configuration.
Definition: utils.c:72
int64_t bytes_read
Bytes read statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:279
const char data[16]
Definition: mxf.c:91
const char * name
Definition: avcodec.h:5813
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:679
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
static void finish(void)
Definition: movenc.c:345
int64_t last_duration
Definition: avformat.h:1061
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
#define DURATION_MAX_RETRY
Definition: utils.c:2786
uint8_t * data
Definition: avcodec.h:1477
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: utils.c:4558
char * protocol_whitelist
&#39;,&#39; separated list of allowed protocols.
Definition: avformat.h:1918
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:3382
uint32_t tag
Definition: movenc.c:1496
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:4997
int(* read_play)(struct AVFormatContext *)
Start/resume playing - only meaningful if using a network-based format (RTSP).
Definition: avformat.h:760
int fps_probe_size
The number of frames used for determining the framerate in avformat_find_stream_info().
Definition: avformat.h:1618
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int ff_is_http_proto(char *filename)
Utility function to check if the file uses http or https protocol.
Definition: utils.c:5648
uint8_t * data
Definition: avcodec.h:1421
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2804
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:294
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2789
struct AVPacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:78
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1278
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
int raw_packet_buffer_remaining_size
Definition: internal.h:101
enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
Select a PCM codec based on the given parameters.
Definition: utils.c:3137
struct AVBitStreamFilterContext * next
Definition: avcodec.h:5742
unsigned int * stream_index
Definition: avformat.h:1279
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1544
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:804
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4059
#define av_log(a,...)
int64_t rfps_duration_sum
Definition: avformat.h:1048
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:647
Duration estimated from bitrate (less accurate)
Definition: avformat.h:1339
unsigned int correct_ts_overflow
Correct single timestamp overflows.
Definition: avformat.h:1759
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:608
#define FF_API_LAVF_AVCTX
Definition: version.h:65
int64_t start_time
Definition: avformat.h:1295
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3986
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
static int determinable_frame_size(AVCodecContext *avctx)
Definition: utils.c:932
void av_format_inject_global_side_data(AVFormatContext *s)
This function will cause global side data to be injected in the next packet of each stream as well as...
Definition: utils.c:154
int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: utils.c:2231
static void update_dts_from_pts(AVFormatContext *s, int stream_index, AVPacketList *pkt_buffer)
Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts of the packets in a wind...
Definition: utils.c:1094
void av_buffer_default_free(void *opaque, uint8_t *data)
Default free callback, which calls av_free() on the buffer data.
Definition: buffer.c:62
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:831
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:4186
av_cold int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:1100
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:549
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:3119
#define AVINDEX_KEYFRAME
Definition: avformat.h:817
AVRational av_stream_get_codec_timebase(const AVStream *st)
Get the internal codec timebase from a stream.
Definition: utils.c:5789
int avctx_inited
1 if avctx has been initialized with the values from the codec parameters
Definition: internal.h:176
enum AVCodecID id
Definition: avcodec.h:3495
#define AVPROBE_SCORE_STREAM_RETRY
Definition: avformat.h:454
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
Definition: utils.c:4169
ff_const59 AVInputFormat * av_probe_input_format2(ff_const59 AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:205
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1680
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: utils.c:1918
int format_probesize
number of bytes to read maximally to identify format.
Definition: avformat.h:1789
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2040
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1533
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1855
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
#define AVMutex
Definition: thread.h:151
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1190
int nb_decoded_frames
Number of internally decoded frames, used internally in libavformat, do not access its lifetime diffe...
Definition: avformat.h:1179
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:5218
void * av_opt_ptr(const AVClass *class, void *obj, const char *name)
Gets a pointer to the requested field in a struct.
Definition: opt.c:1673
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2148
char * ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
Definition: utils.c:4837
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:1298
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: avcodec.h:1216
#define AVERROR(e)
Definition: error.h:43
int ffio_set_buf_size(AVIOContext *s, int buf_size)
Definition: aviobuf.c:1080
#define SANE_CHUNK_SIZE
Definition: utils.c:245
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1493
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
enum AVCodecID * codec_ids
A list of codec ids supported by the filter, terminated by AV_CODEC_ID_NONE.
Definition: avcodec.h:5820
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1813
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:811
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1183
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1370
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1898
char * url
input or output URL.
Definition: avformat.h:1454
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:740
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:443
int capabilities
Codec capabilities.
Definition: avcodec.h:3500
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int nb_programs
Definition: avformat.h:1537
int last_IP_duration
Definition: avformat.h:1086
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
Definition: utils.c:4254
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1274
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:565
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1460
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1127
AVChapter ** chapters
Definition: avformat.h:1588
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: avcodec.h:5803
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
const char * protocol_whitelist
&#39;,&#39; separated list of allowed protocols.
Definition: avio.h:309
enum AVPacketSideDataType type
Definition: avcodec.h:1423
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
int av_match_name(const char *name, const char *names)
Match instances of a name in a comma-separated list of names.
Definition: avstring.c:344
int side_data_elems
Definition: avcodec.h:1489
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:28
#define AV_FRAME_FILENAME_FLAGS_MULTIPLE
Allow multiple d.
Definition: avformat.h:2905
int skip_estimate_duration_from_pts
Skip duration calcuation in estimate_timings_from_pts.
Definition: avformat.h:1967
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet. ...
Definition: avformat.h:1149
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:283
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1275
#define FFMAX(a, b)
Definition: common.h:94
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: utils.c:2029
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:1746
struct AVCodecParserContext * av_stream_get_parser(const AVStream *st)
Definition: utils.c:149
int64_t val
Definition: internal.h:62
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
Definition: avformat.h:823
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:120
const char * protocol_blacklist
&#39;,&#39; separated list of disallowed protocols.
Definition: avio.h:314
AVPacket * pkt
Definition: internal.h:185
const char av_format_ffversion[]
Definition: utils.c:57
AVCodec * audio_codec
Forced audio codec.
Definition: avformat.h:1835
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:156
#define AVFMT_FLAG_PRIV_OPT
Enable use of private options by delaying codec open (this could be made default once all code is con...
Definition: avformat.h:1511
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3257
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2276
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
int seek_count
seek statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:285
Only parse headers, do not repack.
Definition: avformat.h:801
char * format_whitelist
&#39;,&#39; separated list of allowed demuxers.
Definition: avformat.h:1805
static int genpts
Definition: ffplay.c:334
static AVPacket flush_pkt
Definition: ffplay.c:363
static int extract_extradata_init(AVStream *st)
Definition: utils.c:3466
int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
Test if the given container can store a codec.
Definition: utils.c:4979
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1496
int ff_add_index_entry(AVIndexEntry **index_entries, int *nb_index_entries, unsigned int *index_entries_allocated_size, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Internal version of av_add_index_entry.
Definition: utils.c:1980
static float distance(float x, float y, int band)
struct AVStream::@247 * info
Stream information used internally by avformat_find_stream_info()
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:732
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:449
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4886
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
Definition: utils.c:416
static AVPacketList * get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
Definition: utils.c:1039
common internal API header
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:253
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
AVDictionary * opts
Definition: movenc.c:50
AVBSFContext ** bsfcs
bitstream filters to run on stream
Definition: internal.h:161
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: avformat.h:1066
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
Definition: utils.c:4263
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:5704
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: avformat.h:1207
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:96
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1550
int(* av_format_control_message)(struct AVFormatContext *s, int type, void *data, size_t data_size)
Callback used by devices to communicate with application.
Definition: avformat.h:1326
void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
Definition: utils.c: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:5462
void(* ff_parse_key_val_cb)(void *context, const char *key, int key_len, char **dest, int *dest_len)
Callback function type for ff_parse_key_value.
Definition: internal.h:366
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:156
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:556
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:120
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:36
static const chunk_decoder decoder[8]
Definition: dfa.c:330
int max_streams
The maximum number of streams.
Definition: avformat.h:1960
int width
picture width / height.
Definition: avcodec.h:1738
#define RELATIVE_TS_BASE
Definition: utils.c:93
int64_t offset
byte offset from starting packet start
Definition: avcodec.h:5148
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: avcodec.h:5809
int av_find_default_stream_index(AVFormatContext *s)
Definition: utils.c:1880
#define FAIL(errmsg)
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: utils.c:4617
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:663
int frame_delay_evidence
Definition: avformat.h:1052
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:186
const char AVS_Value args
Definition: avisynth_c.h:872
const char * name
Definition: avformat.h:505
Duration estimated from a stream with a known duration.
Definition: avformat.h:1338
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
int32_t
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:224
uint8_t dts_ordered
Definition: avformat.h:1219
static int seek_frame_generic(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c:2395
ff_const59 AVInputFormat * av_probe_input_format3(ff_const59 AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:128
int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Perform a binary search using read_timestamp().
Definition: utils.c: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:1674
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5641
#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:4272
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2705
int n
Definition: avisynth_c.h:760
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVDictionary * metadata
Definition: avformat.h:945
uint8_t * av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type, int size)
Allocate new information from stream.
Definition: utils.c:5498
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1697
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:453
int probe_score
format probing score.
Definition: avformat.h:1782
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don&#39;t avio_close() it.
Definition: avformat.h:1497
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
Opaque data information usually sparse.
Definition: avutil.h:205
int64_t skip_initial_bytes
Skip initial bytes when opening stream.
Definition: avformat.h:1752
int(* AVOpenCallback)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Definition: avformat.h:1329
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:533
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:467
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
if(ret< 0)
Definition: vf_mcdeint.c:279
int buffer_size
Maximum buffer size.
Definition: avio.h:227
int(* read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: avformat.h:774
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
static void error(const char *err)
int64_t max_analyze_duration
Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().
Definition: avformat.h:1532
void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: utils.c:1953
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:849
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1166
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:4727
#define av_log2
Definition: intmath.h:83
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
Read data and append it to the current content of the AVPacket.
Definition: utils.c:320
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1377
uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1]
Definition: avformat.h:1213
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3288
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:840
#define CONTAINS_PAL
Definition: internal.h:703
int(* read_pause)(struct AVFormatContext *)
Pause playing - only meaningful if using a network-based format (RTSP).
Definition: avformat.h:766
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
Stream structure.
Definition: avformat.h:881
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:467
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1318
int avformat_queue_attached_pictures(AVFormatContext *s)
Definition: utils.c:479
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:677
static const AVCodec * find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:184
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:5009
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2245
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
uint8_t dts_misordered
Definition: avformat.h:1220
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1199
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:826
#define FF_FDEBUG_TS
Definition: avformat.h:1642
#define LIBAVFORMAT_VERSION_INT
Definition: version.h:38
sample_rate
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int64_t pts_reorder_error[MAX_REORDER_DELAY+1]
Internal data to generate dts from pts.
Definition: avformat.h:1212
int frame_size
Definition: mxfenc.c:2215
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
int64_t end_time
Definition: avformat.h:1296
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1238
enum AVMediaType codec_type
Definition: avcodec.h:1573
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c: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:1641
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
Definition: options.c:171
enum AVCodecID codec_id
Definition: avcodec.h:1575
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
Definition: utils.c:269
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1603
int av_probe_input_buffer2(AVIOContext *pb, ff_const59 AVInputFormat **fmt, const char *url, void *logctx, unsigned int offset, unsigned int max_probe_size)
Probe a bytestream to determine the input format.
Definition: format.c:222
int sample_rate
samples per second
Definition: avcodec.h:2225
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
Definition: utils.c:3186
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:530
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in &#39;pkt&#39;.
Definition: avformat.h:730
main external API structure.
Definition: avcodec.h:1565
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:890
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
int io_repositioned
IO repositioned flag.
Definition: avformat.h:1819
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:327
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:383
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1590
static int extract_extradata_check(AVStream *st)
Definition: utils.c:3448
#define AVFMT_NOGENSEARCH
Format does not allow to fall back on generic search.
Definition: avformat.h:474
void(* io_close)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
Definition: avformat.h:1946
int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
Return in &#39;buf&#39; the path with &#39;d&#39; replaced by a number.
Definition: utils.c:4672
int pts_wrap_behavior
behavior on wrap detection
Definition: avformat.h:1299
void * buf
Definition: avisynth_c.h:766
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: avformat.h:1049
int extradata_size
Definition: avcodec.h:1667
int ff_lock_avformat(void)
Definition: utils.c:83
#define llrint(x)
Definition: libm.h:394
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int nb_index_entries
Definition: avformat.h:1112
int coded_height
Definition: avcodec.h:1753
enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
Definition: utils.c: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:4858
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:231
static int extract_extradata(AVStream *st, AVPacket *pkt)
Definition: utils.c:3510
int index
Definition: gxfenc.c:89
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:468
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:517
#define SPACE_CHARS
Definition: internal.h:354
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: utils.c:2058
int64_t last_dts
Definition: avformat.h:1045
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: avformat.h:1232
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1300
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:4645
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2512
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar) ...
Definition: internal.h:192
cl_device_type type
const AVClass * av_class
A class for logging and AVOptions.
Definition: avformat.h:1363
AVMediaType
Definition: avutil.h:199
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5311
int short_seek_threshold
Threshold to favor readahead over seek.
Definition: avio.h:304
int64_t fps_last_dts
Definition: avformat.h:1068
#define RAW_PACKET_BUFFER_SIZE
Remaining size available for raw_packet_buffer, in bytes.
Definition: internal.h:100
static int seek_frame_internal(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c: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:548
#define snprintf
Definition: snprintf.h:34
int found_decoder
0 -> decoder has not been searched for yet.
Definition: avformat.h:1059
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4393
int inject_global_side_data
Definition: internal.h:119
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1737
misc parsing utilities
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1768
AVTimebaseSource
Definition: avformat.h:3072
static int has_duration(AVFormatContext *ic)
Return TRUE if the stream has accurate duration in any stream.
Definition: utils.c: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:1228
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:5164
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:716
int seek2any
Force seeking to any (also non key) frames.
Definition: avformat.h:1766
full parsing and repack of the first frame only, only implemented for H.264 currently ...
Definition: avformat.h:803
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:473
AVDictionary * metadata
Definition: avformat.h:1281
int64_t codec_info_duration
Definition: avformat.h:1050
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:918
int fps_first_dts_idx
Definition: avformat.h:1067
uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
Get the NTP time stamp formatted as per the RFC-5905.
Definition: utils.c:4650
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1463
uint8_t level
Definition: svq3.c:207
Duration accurately estimated from PTSes.
Definition: avformat.h:1337
#define LICENSE_PREFIX
int ff_mkdir_p(const char *path)
Automatically create sub-directories.
Definition: utils.c:4803
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 match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec, const char **indexptr, AVProgram **p)
Matches a stream specifier (but ignores requested index).
Definition: utils.c:5113
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:1318
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:930
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
#define PARSER_FLAG_ONCE
Definition: avcodec.h:5143
int sample_rate
Audio only.
Definition: avcodec.h:4067
enum AVMediaType type
Definition: avcodec.h:718
static int is_relative(int64_t ts)
Definition: utils.c:95
int64_t bitrate
Definition: h264_levels.c:131
static int tb_unreliable(AVCodecContext *c)
Definition: utils.c: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:1488
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:1506
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1558
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: avcodec.h:1516
const OptionDef options[]
Definition: ffmpeg_opt.c:3364
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
struct AVPacketList * next
Definition: avformat.h:2026
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: avformat.h:1202
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
enum AVCodecID data_codec
default data codec
Definition: avformat.h:614
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3567
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:920
int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc)
Add a value to a timestamp.
Definition: mathematics.c:191
AVCodec * video_codec
Forced video codec.
Definition: avformat.h:1827
static double c[64]
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1625
static AVCodecContext * dec_ctx
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:934
enum AVCodecID orig_codec_id
Definition: internal.h:178
int(* read_seek)(struct AVFormatContext *, int stream_index, int64_t timestamp, int flags)
Seek to a given timestamp relative to the frames in stream component stream_index.
Definition: avformat.h:746
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
int pts_wrap_bits
number of bits in pts (used for wrapping control)
Definition: avformat.h:1073
Bi-dir predicted.
Definition: avutil.h:276
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:4385
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:1317
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:5142
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:109
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:3227
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:932
int den
Denominator.
Definition: rational.h:60
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: avcodec.h:1510
unsigned bps
Definition: movenc.c:1497
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
Definition: utils.c:4431
#define FFMPEG_CONFIGURATION
Definition: config.h:4
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:870
int64_t codec_info_duration_fields
Definition: avformat.h:1051
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1206
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:108
unsigned int index_entries_allocated_size
Definition: avformat.h:1113
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:52
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: avformat.h:1144
int64_t frame_offset
Definition: avcodec.h:5111
static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
Parse a packet, add all split parts to parse_queue.
Definition: utils.c:1438
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:470
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c: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:1889
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:475
void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
Definition: id3v2.c:1115
char * value
Definition: dict.h:87
AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1843
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: avformat.h:719
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
#define FFMPEG_VERSION
Definition: ffversion.h:4
int len
int channels
number of audio channels
Definition: avcodec.h:2226
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:515
char * codec_whitelist
&#39;,&#39; separated list of allowed decoders.
Definition: avformat.h:1797
struct AVCodecParserContext * parser
Definition: avformat.h:1100
int format
The format of the coded data, corresponds to enum AVPixelFormat for video and for enum AVSampleFormat...
Definition: avcodec.h:5272
void * priv_data
Format private data.
Definition: avformat.h:1386
int codec_info_nb_frames
Number of frames that have been demuxed during avformat_find_stream_info()
Definition: avformat.h:1096
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:51
const struct PixelFormatTag * avpriv_get_raw_pix_fmt_tags(void)
Definition: raw.c:299
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: avcodec.h:1063
#define AVERROR_STREAM_NOT_FOUND
Stream not found.
Definition: error.h:65
static void flush_packet_queue(AVFormatContext *s)
Definition: utils.c:1866
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:829
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
AVDiscard
Definition: avcodec.h:802
int channels
Audio only.
Definition: avcodec.h:4063
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:172
#define av_uninit(x)
Definition: attributes.h:148
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
const struct AVBitStreamFilter * filter
Definition: avcodec.h:5740
static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags)
Definition: utils.c: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:1953
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:5126
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1473
int avformat_flush(AVFormatContext *s)
Discard all internally buffered data.
Definition: utils.c:2586
int64_t last_IP_pts
Definition: avformat.h:1085
void ff_tls_deinit(void)
Definition: network.c:46
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:164
#define av_freep(p)
void INT64 INT64 count
Definition: avisynth_c.h:766
void INT64 start
Definition: avisynth_c.h:766
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
unbuffered private I/O API
static void compute_chapters_end(AVFormatContext *s)
Definition: utils.c:3222
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
int copy_tb
Definition: ffmpeg_opt.c: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:1069
int stream_index
Definition: avcodec.h:1479
int ff_unlock_avformat(void)
Definition: utils.c:88
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
AVBSFContext * bsf
Definition: internal.h:184
static AVMutex avformat_mutex
Definition: utils.c:59
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5516
#define MKTAG(a, b, c, d)
Definition: common.h:366
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:936
int ff_add_param_change(AVPacket *pkt, int32_t channels, uint64_t channel_layout, int32_t sample_rate, int32_t width, int32_t height)
Add side data to a packet for changing parameters to the given values.
Definition: utils.c:5018
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1005
int ffio_limit(AVIOContext *s, int size)
Definition: utils.c:247
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1139
#define MAX_PROBE_PACKETS
Definition: internal.h:36
enum AVCodecID id
int use_wallclock_as_timestamps
forces the use of wallclock timestamps as pts/dts of packets This has undefined results in the presen...
Definition: avformat.h:1730
This structure stores compressed data.
Definition: avcodec.h:1454
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: aviobuf.c:1208
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5791
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:5157
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:449
#define AVFMT_FLAG_NOFILLIN
Do not infer any values from other values, just return what is stored in the container.
Definition: avformat.h:1494
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
Definition: mem.c:263
#define MAX_STD_TIMEBASES
Definition: avformat.h:1040
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:963
int64_t av_stream_get_end_pts(const AVStream *st)
Returns the pts of the last muxed packet + its duration.
Definition: utils.c:141
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:310
#define av_unused
Definition: attributes.h:125
AVProgram ** programs
Definition: avformat.h:1538
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:5146
#define AVFMT_NEEDNUMBER
Needs &#39;d&#39; in filename.
Definition: avformat.h:464
discard nothing
Definition: avcodec.h:805
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
struct AVPacketList * raw_packet_buffer_end
Definition: internal.h:91
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
Compare the remainders of two integer operands divided by a common divisor.
Definition: mathematics.c:160
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:191
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:3050
static uint8_t tmp[11]
Definition: aes_ctr.c:26