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