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