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