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