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