FFmpeg  3.3.8
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)
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  st->last_IP_duration = pkt->duration;
1327  st->last_IP_pts = pkt->pts;
1328  /* Cannot compute PTS if not present (we can compute it only
1329  * by knowing the future. */
1330  } else if (pkt->pts != AV_NOPTS_VALUE ||
1331  pkt->dts != AV_NOPTS_VALUE ||
1332  pkt->duration ) {
1333 
1334  /* presentation is not delayed : PTS and DTS are the same */
1335  if (pkt->pts == AV_NOPTS_VALUE)
1336  pkt->pts = pkt->dts;
1338  pkt->pts, pkt);
1339  if (pkt->pts == AV_NOPTS_VALUE)
1340  pkt->pts = st->cur_dts;
1341  pkt->dts = pkt->pts;
1342  if (pkt->pts != AV_NOPTS_VALUE)
1343  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1344  }
1345  }
1346 
1347  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1348  st->pts_buffer[0] = pkt->pts;
1349  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1350  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1351 
1353  pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1354  }
1355  // We skipped it above so we try here.
1356  if (!onein_oneout)
1357  // This should happen on the first packet
1358  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1359  if (pkt->dts > st->cur_dts)
1360  st->cur_dts = pkt->dts;
1361 
1362  if (s->debug & FF_FDEBUG_TS)
1363  av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1364  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1365 
1366  /* update flags */
1367  if (is_intra_only(st->codecpar->codec_id))
1368  pkt->flags |= AV_PKT_FLAG_KEY;
1369 #if FF_API_CONVERGENCE_DURATION
1371  if (pc)
1374 #endif
1375 }
1376 
1377 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1378 {
1379  while (*pkt_buf) {
1380  AVPacketList *pktl = *pkt_buf;
1381  *pkt_buf = pktl->next;
1382  av_packet_unref(&pktl->pkt);
1383  av_freep(&pktl);
1384  }
1385  *pkt_buf_end = NULL;
1386 }
1387 
1388 /**
1389  * Parse a packet, add all split parts to parse_queue.
1390  *
1391  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1392  */
1393 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1394 {
1395  AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1396  AVStream *st = s->streams[stream_index];
1397  uint8_t *data = pkt ? pkt->data : NULL;
1398  int size = pkt ? pkt->size : 0;
1399  int ret = 0, got_output = 0;
1400 
1401  if (!pkt) {
1403  pkt = &flush_pkt;
1404  got_output = 1;
1405  } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1406  // preserve 0-size sync packets
1408  }
1409 
1410  while (size > 0 || (pkt == &flush_pkt && got_output)) {
1411  int len;
1412  int64_t next_pts = pkt->pts;
1413  int64_t next_dts = pkt->dts;
1414 
1415  av_init_packet(&out_pkt);
1416  len = av_parser_parse2(st->parser, st->internal->avctx,
1417  &out_pkt.data, &out_pkt.size, data, size,
1418  pkt->pts, pkt->dts, pkt->pos);
1419 
1420  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1421  pkt->pos = -1;
1422  /* increment read pointer */
1423  data += len;
1424  size -= len;
1425 
1426  got_output = !!out_pkt.size;
1427 
1428  if (!out_pkt.size)
1429  continue;
1430 
1431  if (pkt->side_data) {
1432  out_pkt.side_data = pkt->side_data;
1433  out_pkt.side_data_elems = pkt->side_data_elems;
1434  pkt->side_data = NULL;
1435  pkt->side_data_elems = 0;
1436  }
1437 
1438  /* set the duration */
1439  out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1441  if (st->internal->avctx->sample_rate > 0) {
1442  out_pkt.duration =
1444  (AVRational) { 1, st->internal->avctx->sample_rate },
1445  st->time_base,
1446  AV_ROUND_DOWN);
1447  }
1448  }
1449 
1450  out_pkt.stream_index = st->index;
1451  out_pkt.pts = st->parser->pts;
1452  out_pkt.dts = st->parser->dts;
1453  out_pkt.pos = st->parser->pos;
1454 
1456  out_pkt.pos = st->parser->frame_offset;
1457 
1458  if (st->parser->key_frame == 1 ||
1459  (st->parser->key_frame == -1 &&
1461  out_pkt.flags |= AV_PKT_FLAG_KEY;
1462 
1463  if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1464  out_pkt.flags |= AV_PKT_FLAG_KEY;
1465 
1466  compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1467 
1468  ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1469  &s->internal->parse_queue_end, 1);
1470  av_packet_unref(&out_pkt);
1471  if (ret < 0)
1472  goto fail;
1473  }
1474 
1475  /* end of the stream => close and free the parser */
1476  if (pkt == &flush_pkt) {
1477  av_parser_close(st->parser);
1478  st->parser = NULL;
1479  }
1480 
1481 fail:
1482  av_packet_unref(pkt);
1483  return ret;
1484 }
1485 
1486 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1487  AVPacketList **pkt_buffer_end,
1488  AVPacket *pkt)
1489 {
1490  AVPacketList *pktl;
1491  av_assert0(*pkt_buffer);
1492  pktl = *pkt_buffer;
1493  *pkt = pktl->pkt;
1494  *pkt_buffer = pktl->next;
1495  if (!pktl->next)
1496  *pkt_buffer_end = NULL;
1497  av_freep(&pktl);
1498  return 0;
1499 }
1500 
1501 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1502 {
1503  return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1504 }
1505 
1507 {
1508  int ret = 0, i, got_packet = 0;
1509  AVDictionary *metadata = NULL;
1510 
1511  av_init_packet(pkt);
1512 
1513  while (!got_packet && !s->internal->parse_queue) {
1514  AVStream *st;
1515  AVPacket cur_pkt;
1516 
1517  /* read next packet */
1518  ret = ff_read_packet(s, &cur_pkt);
1519  if (ret < 0) {
1520  if (ret == AVERROR(EAGAIN))
1521  return ret;
1522  /* flush the parsers */
1523  for (i = 0; i < s->nb_streams; i++) {
1524  st = s->streams[i];
1525  if (st->parser && st->need_parsing)
1526  parse_packet(s, NULL, st->index);
1527  }
1528  /* all remaining packets are now in parse_queue =>
1529  * really terminate parsing */
1530  break;
1531  }
1532  ret = 0;
1533  st = s->streams[cur_pkt.stream_index];
1534 
1535  /* update context if required */
1536  if (st->internal->need_context_update) {
1537  if (avcodec_is_open(st->internal->avctx)) {
1538  av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1540  st->info->found_decoder = 0;
1541  }
1542 
1543  /* close parser, because it depends on the codec */
1544  if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1545  av_parser_close(st->parser);
1546  st->parser = NULL;
1547  }
1548 
1550  if (ret < 0)
1551  return ret;
1552 
1553 #if FF_API_LAVF_AVCTX
1555  /* update deprecated public codec context */
1556  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1557  if (ret < 0)
1558  return ret;
1560 #endif
1561 
1562  st->internal->need_context_update = 0;
1563  }
1564 
1565  if (cur_pkt.pts != AV_NOPTS_VALUE &&
1566  cur_pkt.dts != AV_NOPTS_VALUE &&
1567  cur_pkt.pts < cur_pkt.dts) {
1569  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1570  cur_pkt.stream_index,
1571  av_ts2str(cur_pkt.pts),
1572  av_ts2str(cur_pkt.dts),
1573  cur_pkt.size);
1574  }
1575  if (s->debug & FF_FDEBUG_TS)
1576  av_log(s, AV_LOG_DEBUG,
1577  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1578  cur_pkt.stream_index,
1579  av_ts2str(cur_pkt.pts),
1580  av_ts2str(cur_pkt.dts),
1581  cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1582 
1583  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1584  st->parser = av_parser_init(st->codecpar->codec_id);
1585  if (!st->parser) {
1586  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1587  "%s, packets or times may be invalid.\n",
1589  /* no parser available: just output the raw packets */
1591  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1593  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1594  st->parser->flags |= PARSER_FLAG_ONCE;
1595  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1597  }
1598 
1599  if (!st->need_parsing || !st->parser) {
1600  /* no parsing needed: we just output the packet as is */
1601  *pkt = cur_pkt;
1603  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1604  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1605  ff_reduce_index(s, st->index);
1606  av_add_index_entry(st, pkt->pos, pkt->dts,
1607  0, 0, AVINDEX_KEYFRAME);
1608  }
1609  got_packet = 1;
1610  } else if (st->discard < AVDISCARD_ALL) {
1611  if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1612  return ret;
1614  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1615  st->codecpar->channels = st->internal->avctx->channels;
1617  st->codecpar->codec_id = st->internal->avctx->codec_id;
1618  } else {
1619  /* free packet */
1620  av_packet_unref(&cur_pkt);
1621  }
1622  if (pkt->flags & AV_PKT_FLAG_KEY)
1623  st->skip_to_keyframe = 0;
1624  if (st->skip_to_keyframe) {
1625  av_packet_unref(&cur_pkt);
1626  if (got_packet) {
1627  *pkt = cur_pkt;
1628  }
1629  got_packet = 0;
1630  }
1631  }
1632 
1633  if (!got_packet && s->internal->parse_queue)
1635 
1636  if (ret >= 0) {
1637  AVStream *st = s->streams[pkt->stream_index];
1638  int discard_padding = 0;
1639  if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1640  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1641  int64_t sample = ts_to_samples(st, pts);
1642  int duration = ts_to_samples(st, pkt->duration);
1643  int64_t end_sample = sample + duration;
1644  if (duration > 0 && end_sample >= st->first_discard_sample &&
1645  sample < st->last_discard_sample)
1646  discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1647  }
1648  if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1649  st->skip_samples = st->start_skip_samples;
1650  if (st->skip_samples || discard_padding) {
1652  if (p) {
1653  AV_WL32(p, st->skip_samples);
1654  AV_WL32(p + 4, discard_padding);
1655  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1656  }
1657  st->skip_samples = 0;
1658  }
1659 
1660  if (st->inject_global_side_data) {
1661  for (i = 0; i < st->nb_side_data; i++) {
1662  AVPacketSideData *src_sd = &st->side_data[i];
1663  uint8_t *dst_data;
1664 
1665  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1666  continue;
1667 
1668  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1669  if (!dst_data) {
1670  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1671  continue;
1672  }
1673 
1674  memcpy(dst_data, src_sd->data, src_sd->size);
1675  }
1676  st->inject_global_side_data = 0;
1677  }
1678 
1679 #if FF_API_LAVF_MERGE_SD
1681  if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1684 #endif
1685  }
1686 
1687  av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1688  if (metadata) {
1690  av_dict_copy(&s->metadata, metadata, 0);
1691  av_dict_free(&metadata);
1693  }
1694 
1695 #if FF_API_LAVF_AVCTX
1697 #endif
1698 
1699  if (s->debug & FF_FDEBUG_TS)
1700  av_log(s, AV_LOG_DEBUG,
1701  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1702  "size=%d, duration=%"PRId64", flags=%d\n",
1703  pkt->stream_index,
1704  av_ts2str(pkt->pts),
1705  av_ts2str(pkt->dts),
1706  pkt->size, pkt->duration, pkt->flags);
1707 
1708  return ret;
1709 }
1710 
1712 {
1713  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1714  int eof = 0;
1715  int ret;
1716  AVStream *st;
1717 
1718  if (!genpts) {
1719  ret = s->internal->packet_buffer
1721  &s->internal->packet_buffer_end, pkt)
1722  : read_frame_internal(s, pkt);
1723  if (ret < 0)
1724  return ret;
1725  goto return_packet;
1726  }
1727 
1728  for (;;) {
1729  AVPacketList *pktl = s->internal->packet_buffer;
1730 
1731  if (pktl) {
1732  AVPacket *next_pkt = &pktl->pkt;
1733 
1734  if (next_pkt->dts != AV_NOPTS_VALUE) {
1735  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1736  // last dts seen for this stream. if any of packets following
1737  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1738  int64_t last_dts = next_pkt->dts;
1739  av_assert2(wrap_bits <= 64);
1740  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1741  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1742  av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1743  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1744  // not B-frame
1745  next_pkt->pts = pktl->pkt.dts;
1746  }
1747  if (last_dts != AV_NOPTS_VALUE) {
1748  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1749  last_dts = pktl->pkt.dts;
1750  }
1751  }
1752  pktl = pktl->next;
1753  }
1754  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1755  // Fixing the last reference frame had none pts issue (For MXF etc).
1756  // We only do this when
1757  // 1. eof.
1758  // 2. we are not able to resolve a pts value for current packet.
1759  // 3. the packets for this stream at the end of the files had valid dts.
1760  next_pkt->pts = last_dts + next_pkt->duration;
1761  }
1762  pktl = s->internal->packet_buffer;
1763  }
1764 
1765  /* read packet from packet buffer, if there is data */
1766  st = s->streams[next_pkt->stream_index];
1767  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1768  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1770  &s->internal->packet_buffer_end, pkt);
1771  goto return_packet;
1772  }
1773  }
1774 
1775  ret = read_frame_internal(s, pkt);
1776  if (ret < 0) {
1777  if (pktl && ret != AVERROR(EAGAIN)) {
1778  eof = 1;
1779  continue;
1780  } else
1781  return ret;
1782  }
1783 
1784  ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1785  &s->internal->packet_buffer_end, 1);
1786  av_packet_unref(pkt);
1787  if (ret < 0)
1788  return ret;
1789  }
1790 
1791 return_packet:
1792 
1793  st = s->streams[pkt->stream_index];
1794  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1795  ff_reduce_index(s, st->index);
1796  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1797  }
1798 
1799  if (is_relative(pkt->dts))
1800  pkt->dts -= RELATIVE_TS_BASE;
1801  if (is_relative(pkt->pts))
1802  pkt->pts -= RELATIVE_TS_BASE;
1803 
1804  return ret;
1805 }
1806 
1807 /* XXX: suppress the packet queue */
1809 {
1810  if (!s->internal)
1811  return;
1815 
1817 }
1818 
1819 /*******************************************************/
1820 /* seek support */
1821 
1823 {
1824  int i;
1825  AVStream *st;
1826  int best_stream = 0;
1827  int best_score = INT_MIN;
1828 
1829  if (s->nb_streams <= 0)
1830  return -1;
1831  for (i = 0; i < s->nb_streams; i++) {
1832  int score = 0;
1833  st = s->streams[i];
1834  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1836  score -= 400;
1837  if (st->codecpar->width && st->codecpar->height)
1838  score += 50;
1839  score+= 25;
1840  }
1841  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1842  if (st->codecpar->sample_rate)
1843  score += 50;
1844  }
1845  if (st->codec_info_nb_frames)
1846  score += 12;
1847 
1848  if (st->discard != AVDISCARD_ALL)
1849  score += 200;
1850 
1851  if (score > best_score) {
1852  best_score = score;
1853  best_stream = i;
1854  }
1855  }
1856  return best_stream;
1857 }
1858 
1859 /** Flush the frame reader. */
1861 {
1862  AVStream *st;
1863  int i, j;
1864 
1865  flush_packet_queue(s);
1866 
1867  /* Reset read state for each stream. */
1868  for (i = 0; i < s->nb_streams; i++) {
1869  st = s->streams[i];
1870 
1871  if (st->parser) {
1872  av_parser_close(st->parser);
1873  st->parser = NULL;
1874  }
1877  if (st->first_dts == AV_NOPTS_VALUE)
1878  st->cur_dts = RELATIVE_TS_BASE;
1879  else
1880  /* We set the current DTS to an unspecified origin. */
1881  st->cur_dts = AV_NOPTS_VALUE;
1882 
1884 
1885  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1886  st->pts_buffer[j] = AV_NOPTS_VALUE;
1887 
1889  st->inject_global_side_data = 1;
1890 
1891  st->skip_samples = 0;
1892  }
1893 }
1894 
1895 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1896 {
1897  int i;
1898 
1899  for (i = 0; i < s->nb_streams; i++) {
1900  AVStream *st = s->streams[i];
1901 
1902  st->cur_dts =
1903  av_rescale(timestamp,
1904  st->time_base.den * (int64_t) ref_st->time_base.num,
1905  st->time_base.num * (int64_t) ref_st->time_base.den);
1906  }
1907 }
1908 
1909 void ff_reduce_index(AVFormatContext *s, int stream_index)
1910 {
1911  AVStream *st = s->streams[stream_index];
1912  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1913 
1914  if ((unsigned) st->nb_index_entries >= max_entries) {
1915  int i;
1916  for (i = 0; 2 * i < st->nb_index_entries; i++)
1917  st->index_entries[i] = st->index_entries[2 * i];
1918  st->nb_index_entries = i;
1919  }
1920 }
1921 
1922 int ff_add_index_entry(AVIndexEntry **index_entries,
1923  int *nb_index_entries,
1924  unsigned int *index_entries_allocated_size,
1925  int64_t pos, int64_t timestamp,
1926  int size, int distance, int flags)
1927 {
1928  AVIndexEntry *entries, *ie;
1929  int index;
1930 
1931  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1932  return -1;
1933 
1934  if (timestamp == AV_NOPTS_VALUE)
1935  return AVERROR(EINVAL);
1936 
1937  if (size < 0 || size > 0x3FFFFFFF)
1938  return AVERROR(EINVAL);
1939 
1940  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1941  timestamp -= RELATIVE_TS_BASE;
1942 
1943  entries = av_fast_realloc(*index_entries,
1944  index_entries_allocated_size,
1945  (*nb_index_entries + 1) *
1946  sizeof(AVIndexEntry));
1947  if (!entries)
1948  return -1;
1949 
1950  *index_entries = entries;
1951 
1952  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1953  timestamp, AVSEEK_FLAG_ANY);
1954 
1955  if (index < 0) {
1956  index = (*nb_index_entries)++;
1957  ie = &entries[index];
1958  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1959  } else {
1960  ie = &entries[index];
1961  if (ie->timestamp != timestamp) {
1962  if (ie->timestamp <= timestamp)
1963  return -1;
1964  memmove(entries + index + 1, entries + index,
1965  sizeof(AVIndexEntry) * (*nb_index_entries - index));
1966  (*nb_index_entries)++;
1967  } else if (ie->pos == pos && distance < ie->min_distance)
1968  // do not reduce the distance
1969  distance = ie->min_distance;
1970  }
1971 
1972  ie->pos = pos;
1973  ie->timestamp = timestamp;
1974  ie->min_distance = distance;
1975  ie->size = size;
1976  ie->flags = flags;
1977 
1978  return index;
1979 }
1980 
1981 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1982  int size, int distance, int flags)
1983 {
1984  timestamp = wrap_timestamp(st, timestamp);
1986  &st->index_entries_allocated_size, pos,
1987  timestamp, size, distance, flags);
1988 }
1989 
1990 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1991  int64_t wanted_timestamp, int flags)
1992 {
1993  int a, b, m;
1994  int64_t timestamp;
1995 
1996  a = -1;
1997  b = nb_entries;
1998 
1999  // Optimize appending index entries at the end.
2000  if (b && entries[b - 1].timestamp < wanted_timestamp)
2001  a = b - 1;
2002 
2003  while (b - a > 1) {
2004  m = (a + b) >> 1;
2005 
2006  // Search for the next non-discarded packet.
2007  while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2008  m++;
2009  if (m == b && entries[m].timestamp >= wanted_timestamp) {
2010  m = b - 1;
2011  break;
2012  }
2013  }
2014 
2015  timestamp = entries[m].timestamp;
2016  if (timestamp >= wanted_timestamp)
2017  b = m;
2018  if (timestamp <= wanted_timestamp)
2019  a = m;
2020  }
2021  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2022 
2023  if (!(flags & AVSEEK_FLAG_ANY))
2024  while (m >= 0 && m < nb_entries &&
2025  !(entries[m].flags & AVINDEX_KEYFRAME))
2026  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2027 
2028  if (m == nb_entries)
2029  return -1;
2030  return m;
2031 }
2032 
2033 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2034 {
2035  int ist1, ist2;
2036  int64_t pos_delta = 0;
2037  int64_t skip = 0;
2038  //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2039  const char *proto = avio_find_protocol_name(s->filename);
2040 
2041  if (!proto) {
2042  av_log(s, AV_LOG_INFO,
2043  "Protocol name not provided, cannot determine if input is local or "
2044  "a network protocol, buffers and access patterns cannot be configured "
2045  "optimally without knowing the protocol\n");
2046  }
2047 
2048  if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2049  return;
2050 
2051  for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2052  AVStream *st1 = s->streams[ist1];
2053  for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2054  AVStream *st2 = s->streams[ist2];
2055  int i1, i2;
2056 
2057  if (ist1 == ist2)
2058  continue;
2059 
2060  for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2061  AVIndexEntry *e1 = &st1->index_entries[i1];
2062  int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2063 
2064  skip = FFMAX(skip, e1->size);
2065  for (; i2 < st2->nb_index_entries; i2++) {
2066  AVIndexEntry *e2 = &st2->index_entries[i2];
2067  int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2068  if (e2_pts - e1_pts < time_tolerance)
2069  continue;
2070  pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2071  break;
2072  }
2073  }
2074  }
2075  }
2076 
2077  pos_delta *= 2;
2078  /* XXX This could be adjusted depending on protocol*/
2079  if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2080  av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2081  ffio_set_buf_size(s->pb, pos_delta);
2082  s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2083  }
2084 
2085  if (skip < (1<<23)) {
2087  }
2088 }
2089 
2090 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2091 {
2093  wanted_timestamp, flags);
2094 }
2095 
2096 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2097  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2098 {
2099  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2100  if (stream_index >= 0)
2101  ts = wrap_timestamp(s->streams[stream_index], ts);
2102  return ts;
2103 }
2104 
2105 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2106  int64_t target_ts, int flags)
2107 {
2108  AVInputFormat *avif = s->iformat;
2109  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2110  int64_t ts_min, ts_max, ts;
2111  int index;
2112  int64_t ret;
2113  AVStream *st;
2114 
2115  if (stream_index < 0)
2116  return -1;
2117 
2118  av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2119 
2120  ts_max =
2121  ts_min = AV_NOPTS_VALUE;
2122  pos_limit = -1; // GCC falsely says it may be uninitialized.
2123 
2124  st = s->streams[stream_index];
2125  if (st->index_entries) {
2126  AVIndexEntry *e;
2127 
2128  /* FIXME: Whole function must be checked for non-keyframe entries in
2129  * index case, especially read_timestamp(). */
2130  index = av_index_search_timestamp(st, target_ts,
2131  flags | AVSEEK_FLAG_BACKWARD);
2132  index = FFMAX(index, 0);
2133  e = &st->index_entries[index];
2134 
2135  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2136  pos_min = e->pos;
2137  ts_min = e->timestamp;
2138  av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2139  pos_min, av_ts2str(ts_min));
2140  } else {
2141  av_assert1(index == 0);
2142  }
2143 
2144  index = av_index_search_timestamp(st, target_ts,
2145  flags & ~AVSEEK_FLAG_BACKWARD);
2146  av_assert0(index < st->nb_index_entries);
2147  if (index >= 0) {
2148  e = &st->index_entries[index];
2149  av_assert1(e->timestamp >= target_ts);
2150  pos_max = e->pos;
2151  ts_max = e->timestamp;
2152  pos_limit = pos_max - e->min_distance;
2153  av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2154  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2155  }
2156  }
2157 
2158  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2159  ts_min, ts_max, flags, &ts, avif->read_timestamp);
2160  if (pos < 0)
2161  return -1;
2162 
2163  /* do the seek */
2164  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2165  return ret;
2166 
2168  ff_update_cur_dts(s, st, ts);
2169 
2170  return 0;
2171 }
2172 
2173 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2174  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2175 {
2176  int64_t step = 1024;
2177  int64_t limit, ts_max;
2178  int64_t filesize = avio_size(s->pb);
2179  int64_t pos_max = filesize - 1;
2180  do {
2181  limit = pos_max;
2182  pos_max = FFMAX(0, (pos_max) - step);
2183  ts_max = ff_read_timestamp(s, stream_index,
2184  &pos_max, limit, read_timestamp);
2185  step += step;
2186  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2187  if (ts_max == AV_NOPTS_VALUE)
2188  return -1;
2189 
2190  for (;;) {
2191  int64_t tmp_pos = pos_max + 1;
2192  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2193  &tmp_pos, INT64_MAX, read_timestamp);
2194  if (tmp_ts == AV_NOPTS_VALUE)
2195  break;
2196  av_assert0(tmp_pos > pos_max);
2197  ts_max = tmp_ts;
2198  pos_max = tmp_pos;
2199  if (tmp_pos >= filesize)
2200  break;
2201  }
2202 
2203  if (ts)
2204  *ts = ts_max;
2205  if (pos)
2206  *pos = pos_max;
2207 
2208  return 0;
2209 }
2210 
2211 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2212  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2213  int64_t ts_min, int64_t ts_max,
2214  int flags, int64_t *ts_ret,
2215  int64_t (*read_timestamp)(struct AVFormatContext *, int,
2216  int64_t *, int64_t))
2217 {
2218  int64_t pos, ts;
2219  int64_t start_pos;
2220  int no_change;
2221  int ret;
2222 
2223  av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2224 
2225  if (ts_min == AV_NOPTS_VALUE) {
2226  pos_min = s->internal->data_offset;
2227  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2228  if (ts_min == AV_NOPTS_VALUE)
2229  return -1;
2230  }
2231 
2232  if (ts_min >= target_ts) {
2233  *ts_ret = ts_min;
2234  return pos_min;
2235  }
2236 
2237  if (ts_max == AV_NOPTS_VALUE) {
2238  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2239  return ret;
2240  pos_limit = pos_max;
2241  }
2242 
2243  if (ts_max <= target_ts) {
2244  *ts_ret = ts_max;
2245  return pos_max;
2246  }
2247 
2248  av_assert0(ts_min < ts_max);
2249 
2250  no_change = 0;
2251  while (pos_min < pos_limit) {
2252  av_log(s, AV_LOG_TRACE,
2253  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2254  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2255  av_assert0(pos_limit <= pos_max);
2256 
2257  if (no_change == 0) {
2258  int64_t approximate_keyframe_distance = pos_max - pos_limit;
2259  // interpolate position (better than dichotomy)
2260  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2261  ts_max - ts_min) +
2262  pos_min - approximate_keyframe_distance;
2263  } else if (no_change == 1) {
2264  // bisection if interpolation did not change min / max pos last time
2265  pos = (pos_min + pos_limit) >> 1;
2266  } else {
2267  /* linear search if bisection failed, can only happen if there
2268  * are very few or no keyframes between min/max */
2269  pos = pos_min;
2270  }
2271  if (pos <= pos_min)
2272  pos = pos_min + 1;
2273  else if (pos > pos_limit)
2274  pos = pos_limit;
2275  start_pos = pos;
2276 
2277  // May pass pos_limit instead of -1.
2278  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2279  if (pos == pos_max)
2280  no_change++;
2281  else
2282  no_change = 0;
2283  av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2284  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2285  pos_min, pos, pos_max,
2286  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2287  pos_limit, start_pos, no_change);
2288  if (ts == AV_NOPTS_VALUE) {
2289  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2290  return -1;
2291  }
2292  if (target_ts <= ts) {
2293  pos_limit = start_pos - 1;
2294  pos_max = pos;
2295  ts_max = ts;
2296  }
2297  if (target_ts >= ts) {
2298  pos_min = pos;
2299  ts_min = ts;
2300  }
2301  }
2302 
2303  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2304  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2305 #if 0
2306  pos_min = pos;
2307  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2308  pos_min++;
2309  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2310  av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2311  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2312 #endif
2313  *ts_ret = ts;
2314  return pos;
2315 }
2316 
2317 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2318  int64_t pos, int flags)
2319 {
2320  int64_t pos_min, pos_max;
2321 
2322  pos_min = s->internal->data_offset;
2323  pos_max = avio_size(s->pb) - 1;
2324 
2325  if (pos < pos_min)
2326  pos = pos_min;
2327  else if (pos > pos_max)
2328  pos = pos_max;
2329 
2330  avio_seek(s->pb, pos, SEEK_SET);
2331 
2332  s->io_repositioned = 1;
2333 
2334  return 0;
2335 }
2336 
2337 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2338  int64_t timestamp, int flags)
2339 {
2340  int index;
2341  int64_t ret;
2342  AVStream *st;
2343  AVIndexEntry *ie;
2344 
2345  st = s->streams[stream_index];
2346 
2347  index = av_index_search_timestamp(st, timestamp, flags);
2348 
2349  if (index < 0 && st->nb_index_entries &&
2350  timestamp < st->index_entries[0].timestamp)
2351  return -1;
2352 
2353  if (index < 0 || index == st->nb_index_entries - 1) {
2354  AVPacket pkt;
2355  int nonkey = 0;
2356 
2357  if (st->nb_index_entries) {
2359  ie = &st->index_entries[st->nb_index_entries - 1];
2360  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2361  return ret;
2362  ff_update_cur_dts(s, st, ie->timestamp);
2363  } else {
2364  if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2365  return ret;
2366  }
2367  for (;;) {
2368  int read_status;
2369  do {
2370  read_status = av_read_frame(s, &pkt);
2371  } while (read_status == AVERROR(EAGAIN));
2372  if (read_status < 0)
2373  break;
2374  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2375  if (pkt.flags & AV_PKT_FLAG_KEY) {
2376  av_packet_unref(&pkt);
2377  break;
2378  }
2379  if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2380  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);
2381  av_packet_unref(&pkt);
2382  break;
2383  }
2384  }
2385  av_packet_unref(&pkt);
2386  }
2387  index = av_index_search_timestamp(st, timestamp, flags);
2388  }
2389  if (index < 0)
2390  return -1;
2391 
2393  if (s->iformat->read_seek)
2394  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2395  return 0;
2396  ie = &st->index_entries[index];
2397  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2398  return ret;
2399  ff_update_cur_dts(s, st, ie->timestamp);
2400 
2401  return 0;
2402 }
2403 
2404 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2405  int64_t timestamp, int flags)
2406 {
2407  int ret;
2408  AVStream *st;
2409 
2410  if (flags & AVSEEK_FLAG_BYTE) {
2411  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2412  return -1;
2414  return seek_frame_byte(s, stream_index, timestamp, flags);
2415  }
2416 
2417  if (stream_index < 0) {
2418  stream_index = av_find_default_stream_index(s);
2419  if (stream_index < 0)
2420  return -1;
2421 
2422  st = s->streams[stream_index];
2423  /* timestamp for default must be expressed in AV_TIME_BASE units */
2424  timestamp = av_rescale(timestamp, st->time_base.den,
2425  AV_TIME_BASE * (int64_t) st->time_base.num);
2426  }
2427 
2428  /* first, we try the format specific seek */
2429  if (s->iformat->read_seek) {
2431  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2432  } else
2433  ret = -1;
2434  if (ret >= 0)
2435  return 0;
2436 
2437  if (s->iformat->read_timestamp &&
2438  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2440  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2441  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2443  return seek_frame_generic(s, stream_index, timestamp, flags);
2444  } else
2445  return -1;
2446 }
2447 
2448 int av_seek_frame(AVFormatContext *s, int stream_index,
2449  int64_t timestamp, int flags)
2450 {
2451  int ret;
2452 
2453  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2454  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2455  if ((flags & AVSEEK_FLAG_BACKWARD))
2456  max_ts = timestamp;
2457  else
2458  min_ts = timestamp;
2459  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2460  flags & ~AVSEEK_FLAG_BACKWARD);
2461  }
2462 
2463  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2464 
2465  if (ret >= 0)
2467 
2468  return ret;
2469 }
2470 
2471 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2472  int64_t ts, int64_t max_ts, int flags)
2473 {
2474  if (min_ts > ts || max_ts < ts)
2475  return -1;
2476  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2477  return AVERROR(EINVAL);
2478 
2479  if (s->seek2any>0)
2480  flags |= AVSEEK_FLAG_ANY;
2481  flags &= ~AVSEEK_FLAG_BACKWARD;
2482 
2483  if (s->iformat->read_seek2) {
2484  int ret;
2486 
2487  if (stream_index == -1 && s->nb_streams == 1) {
2488  AVRational time_base = s->streams[0]->time_base;
2489  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2490  min_ts = av_rescale_rnd(min_ts, time_base.den,
2491  time_base.num * (int64_t)AV_TIME_BASE,
2493  max_ts = av_rescale_rnd(max_ts, time_base.den,
2494  time_base.num * (int64_t)AV_TIME_BASE,
2496  stream_index = 0;
2497  }
2498 
2499  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2500  ts, max_ts, flags);
2501 
2502  if (ret >= 0)
2504  return ret;
2505  }
2506 
2507  if (s->iformat->read_timestamp) {
2508  // try to seek via read_timestamp()
2509  }
2510 
2511  // Fall back on old API if new is not implemented but old is.
2512  // Note the old API has somewhat different semantics.
2513  if (s->iformat->read_seek || 1) {
2514  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2515  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2516  if (ret<0 && ts != min_ts && max_ts != ts) {
2517  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2518  if (ret >= 0)
2519  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2520  }
2521  return ret;
2522  }
2523 
2524  // try some generic seek like seek_frame_generic() but with new ts semantics
2525  return -1; //unreachable
2526 }
2527 
2529 {
2531  return 0;
2532 }
2533 
2534 /*******************************************************/
2535 
2536 /**
2537  * Return TRUE if the stream has accurate duration in any stream.
2538  *
2539  * @return TRUE if the stream has accurate duration for at least one component.
2540  */
2542 {
2543  int i;
2544  AVStream *st;
2545 
2546  for (i = 0; i < ic->nb_streams; i++) {
2547  st = ic->streams[i];
2548  if (st->duration != AV_NOPTS_VALUE)
2549  return 1;
2550  }
2551  if (ic->duration != AV_NOPTS_VALUE)
2552  return 1;
2553  return 0;
2554 }
2555 
2556 /**
2557  * Estimate the stream timings from the one of each components.
2558  *
2559  * Also computes the global bitrate if possible.
2560  */
2562 {
2563  int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2564  int64_t duration, duration1, filesize;
2565  int i;
2566  AVStream *st;
2567  AVProgram *p;
2568 
2569  start_time = INT64_MAX;
2570  start_time_text = INT64_MAX;
2571  end_time = INT64_MIN;
2572  end_time_text = INT64_MIN;
2573  duration = INT64_MIN;
2574  for (i = 0; i < ic->nb_streams; i++) {
2575  st = ic->streams[i];
2576  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2577  start_time1 = av_rescale_q(st->start_time, st->time_base,
2578  AV_TIME_BASE_Q);
2580  if (start_time1 < start_time_text)
2581  start_time_text = start_time1;
2582  } else
2583  start_time = FFMIN(start_time, start_time1);
2584  end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2587  if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2588  end_time1 += start_time1;
2590  end_time_text = FFMAX(end_time_text, end_time1);
2591  else
2592  end_time = FFMAX(end_time, end_time1);
2593  }
2594  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2595  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2596  p->start_time = start_time1;
2597  if (p->end_time < end_time1)
2598  p->end_time = end_time1;
2599  }
2600  }
2601  if (st->duration != AV_NOPTS_VALUE) {
2602  duration1 = av_rescale_q(st->duration, st->time_base,
2603  AV_TIME_BASE_Q);
2604  duration = FFMAX(duration, duration1);
2605  }
2606  }
2607  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2608  start_time = start_time_text;
2609  else if (start_time > start_time_text)
2610  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2611 
2612  if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE)) {
2613  end_time = end_time_text;
2614  } else if (end_time < end_time_text) {
2615  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2616  }
2617 
2618  if (start_time != INT64_MAX) {
2619  ic->start_time = start_time;
2620  if (end_time != INT64_MIN) {
2621  if (ic->nb_programs > 1) {
2622  for (i = 0; i < ic->nb_programs; i++) {
2623  p = ic->programs[i];
2624  if (p->start_time != AV_NOPTS_VALUE &&
2625  p->end_time > p->start_time &&
2626  p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2627  duration = FFMAX(duration, p->end_time - p->start_time);
2628  }
2629  } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2630  duration = FFMAX(duration, end_time - start_time);
2631  }
2632  }
2633  }
2634  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2635  ic->duration = duration;
2636  }
2637  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2638  /* compute the bitrate */
2639  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2640  (double) ic->duration;
2641  if (bitrate >= 0 && bitrate <= INT64_MAX)
2642  ic->bit_rate = bitrate;
2643  }
2644 }
2645 
2647 {
2648  int i;
2649  AVStream *st;
2650 
2652  for (i = 0; i < ic->nb_streams; i++) {
2653  st = ic->streams[i];
2654  if (st->start_time == AV_NOPTS_VALUE) {
2655  if (ic->start_time != AV_NOPTS_VALUE)
2657  st->time_base);
2658  if (ic->duration != AV_NOPTS_VALUE)
2660  st->time_base);
2661  }
2662  }
2663 }
2664 
2666 {
2667  int64_t filesize, duration;
2668  int i, show_warning = 0;
2669  AVStream *st;
2670 
2671  /* if bit_rate is already set, we believe it */
2672  if (ic->bit_rate <= 0) {
2673  int64_t bit_rate = 0;
2674  for (i = 0; i < ic->nb_streams; i++) {
2675  st = ic->streams[i];
2676  if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2677  st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2678  if (st->codecpar->bit_rate > 0) {
2679  if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2680  bit_rate = 0;
2681  break;
2682  }
2683  bit_rate += st->codecpar->bit_rate;
2684  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2685  // If we have a videostream with packets but without a bitrate
2686  // then consider the sum not known
2687  bit_rate = 0;
2688  break;
2689  }
2690  }
2691  ic->bit_rate = bit_rate;
2692  }
2693 
2694  /* if duration is already set, we believe it */
2695  if (ic->duration == AV_NOPTS_VALUE &&
2696  ic->bit_rate != 0) {
2697  filesize = ic->pb ? avio_size(ic->pb) : 0;
2698  if (filesize > ic->internal->data_offset) {
2699  filesize -= ic->internal->data_offset;
2700  for (i = 0; i < ic->nb_streams; i++) {
2701  st = ic->streams[i];
2702  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2703  && st->duration == AV_NOPTS_VALUE) {
2704  duration = av_rescale(8 * filesize, st->time_base.den,
2705  ic->bit_rate *
2706  (int64_t) st->time_base.num);
2707  st->duration = duration;
2708  show_warning = 1;
2709  }
2710  }
2711  }
2712  }
2713  if (show_warning)
2714  av_log(ic, AV_LOG_WARNING,
2715  "Estimating duration from bitrate, this may be inaccurate\n");
2716 }
2717 
2718 #define DURATION_MAX_READ_SIZE 250000LL
2719 #define DURATION_MAX_RETRY 6
2720 
2721 /* only usable for MPEG-PS streams */
2722 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2723 {
2724  AVPacket pkt1, *pkt = &pkt1;
2725  AVStream *st;
2726  int num, den, read_size, i, ret;
2727  int found_duration = 0;
2728  int is_end;
2729  int64_t filesize, offset, duration;
2730  int retry = 0;
2731 
2732  /* flush packet queue */
2733  flush_packet_queue(ic);
2734 
2735  for (i = 0; i < ic->nb_streams; i++) {
2736  st = ic->streams[i];
2737  if (st->start_time == AV_NOPTS_VALUE &&
2738  st->first_dts == AV_NOPTS_VALUE &&
2740  av_log(ic, AV_LOG_WARNING,
2741  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2742 
2743  if (st->parser) {
2744  av_parser_close(st->parser);
2745  st->parser = NULL;
2746  }
2747  }
2748 
2749  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2750  /* estimate the end time (duration) */
2751  /* XXX: may need to support wrapping */
2752  filesize = ic->pb ? avio_size(ic->pb) : 0;
2753  do {
2754  is_end = found_duration;
2755  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2756  if (offset < 0)
2757  offset = 0;
2758 
2759  avio_seek(ic->pb, offset, SEEK_SET);
2760  read_size = 0;
2761  for (;;) {
2762  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2763  break;
2764 
2765  do {
2766  ret = ff_read_packet(ic, pkt);
2767  } while (ret == AVERROR(EAGAIN));
2768  if (ret != 0)
2769  break;
2770  read_size += pkt->size;
2771  st = ic->streams[pkt->stream_index];
2772  if (pkt->pts != AV_NOPTS_VALUE &&
2773  (st->start_time != AV_NOPTS_VALUE ||
2774  st->first_dts != AV_NOPTS_VALUE)) {
2775  if (pkt->duration == 0) {
2776  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2777  if (den && num) {
2778  pkt->duration = av_rescale_rnd(1,
2779  num * (int64_t) st->time_base.den,
2780  den * (int64_t) st->time_base.num,
2781  AV_ROUND_DOWN);
2782  }
2783  }
2784  duration = pkt->pts + pkt->duration;
2785  found_duration = 1;
2786  if (st->start_time != AV_NOPTS_VALUE)
2787  duration -= st->start_time;
2788  else
2789  duration -= st->first_dts;
2790  if (duration > 0) {
2791  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2792  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2793  st->duration = duration;
2794  st->info->last_duration = duration;
2795  }
2796  }
2797  av_packet_unref(pkt);
2798  }
2799 
2800  /* check if all audio/video streams have valid duration */
2801  if (!is_end) {
2802  is_end = 1;
2803  for (i = 0; i < ic->nb_streams; i++) {
2804  st = ic->streams[i];
2805  switch (st->codecpar->codec_type) {
2806  case AVMEDIA_TYPE_VIDEO:
2807  case AVMEDIA_TYPE_AUDIO:
2808  if (st->duration == AV_NOPTS_VALUE)
2809  is_end = 0;
2810  }
2811  }
2812  }
2813  } while (!is_end &&
2814  offset &&
2815  ++retry <= DURATION_MAX_RETRY);
2816 
2817  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2818 
2819  /* warn about audio/video streams which duration could not be estimated */
2820  for (i = 0; i < ic->nb_streams; i++) {
2821  st = ic->streams[i];
2822  if (st->duration == AV_NOPTS_VALUE) {
2823  switch (st->codecpar->codec_type) {
2824  case AVMEDIA_TYPE_VIDEO:
2825  case AVMEDIA_TYPE_AUDIO:
2826  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2827  av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2828  } else
2829  av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2830  }
2831  }
2832  }
2834 
2835  avio_seek(ic->pb, old_offset, SEEK_SET);
2836  for (i = 0; i < ic->nb_streams; i++) {
2837  int j;
2838 
2839  st = ic->streams[i];
2840  st->cur_dts = st->first_dts;
2843  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2844  st->pts_buffer[j] = AV_NOPTS_VALUE;
2845  }
2846 }
2847 
2848 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2849 {
2850  int64_t file_size;
2851 
2852  /* get the file size, if possible */
2853  if (ic->iformat->flags & AVFMT_NOFILE) {
2854  file_size = 0;
2855  } else {
2856  file_size = avio_size(ic->pb);
2857  file_size = FFMAX(0, file_size);
2858  }
2859 
2860  if ((!strcmp(ic->iformat->name, "mpeg") ||
2861  !strcmp(ic->iformat->name, "mpegts")) &&
2862  file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2863  /* get accurate estimate from the PTSes */
2864  estimate_timings_from_pts(ic, old_offset);
2866  } else if (has_duration(ic)) {
2867  /* at least one component has timings - we use them for all
2868  * the components */
2871  } else {
2872  /* less precise: use bitrate info */
2875  }
2877 
2878  {
2879  int i;
2880  AVStream av_unused *st;
2881  for (i = 0; i < ic->nb_streams; i++) {
2882  st = ic->streams[i];
2883  av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2884  (double) st->start_time * av_q2d(st->time_base),
2885  (double) st->duration * av_q2d(st->time_base));
2886  }
2887  av_log(ic, AV_LOG_TRACE,
2888  "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2889  (double) ic->start_time / AV_TIME_BASE,
2890  (double) ic->duration / AV_TIME_BASE,
2891  (int64_t)ic->bit_rate / 1000);
2892  }
2893 }
2894 
2895 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2896 {
2897  AVCodecContext *avctx = st->internal->avctx;
2898 
2899 #define FAIL(errmsg) do { \
2900  if (errmsg_ptr) \
2901  *errmsg_ptr = errmsg; \
2902  return 0; \
2903  } while (0)
2904 
2905  if ( avctx->codec_id == AV_CODEC_ID_NONE
2906  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2907  FAIL("unknown codec");
2908  switch (avctx->codec_type) {
2909  case AVMEDIA_TYPE_AUDIO:
2910  if (!avctx->frame_size && determinable_frame_size(avctx))
2911  FAIL("unspecified frame size");
2912  if (st->info->found_decoder >= 0 &&
2913  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2914  FAIL("unspecified sample format");
2915  if (!avctx->sample_rate)
2916  FAIL("unspecified sample rate");
2917  if (!avctx->channels)
2918  FAIL("unspecified number of channels");
2919  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2920  FAIL("no decodable DTS frames");
2921  break;
2922  case AVMEDIA_TYPE_VIDEO:
2923  if (!avctx->width)
2924  FAIL("unspecified size");
2925  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2926  FAIL("unspecified pixel format");
2929  FAIL("no frame in rv30/40 and no sar");
2930  break;
2931  case AVMEDIA_TYPE_SUBTITLE:
2932  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2933  FAIL("unspecified size");
2934  break;
2935  case AVMEDIA_TYPE_DATA:
2936  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2937  }
2938 
2939  return 1;
2940 }
2941 
2942 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2945 {
2946  AVCodecContext *avctx = st->internal->avctx;
2947  const AVCodec *codec;
2948  int got_picture = 1, ret = 0;
2950  AVSubtitle subtitle;
2951  AVPacket pkt = *avpkt;
2952  int do_skip_frame = 0;
2953  enum AVDiscard skip_frame;
2954 
2955  if (!frame)
2956  return AVERROR(ENOMEM);
2957 
2958  if (!avcodec_is_open(avctx) &&
2959  st->info->found_decoder <= 0 &&
2960  (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2961  AVDictionary *thread_opt = NULL;
2962 
2963  codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2964 
2965  if (!codec) {
2966  st->info->found_decoder = -st->codecpar->codec_id;
2967  ret = -1;
2968  goto fail;
2969  }
2970 
2971  /* Force thread count to 1 since the H.264 decoder will not extract
2972  * SPS and PPS to extradata during multi-threaded decoding. */
2973  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2974  if (s->codec_whitelist)
2975  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2976  ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2977  if (!options)
2978  av_dict_free(&thread_opt);
2979  if (ret < 0) {
2980  st->info->found_decoder = -avctx->codec_id;
2981  goto fail;
2982  }
2983  st->info->found_decoder = 1;
2984  } else if (!st->info->found_decoder)
2985  st->info->found_decoder = 1;
2986 
2987  if (st->info->found_decoder < 0) {
2988  ret = -1;
2989  goto fail;
2990  }
2991 
2993  do_skip_frame = 1;
2994  skip_frame = avctx->skip_frame;
2995  avctx->skip_frame = AVDISCARD_ALL;
2996  }
2997 
2998  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2999  ret >= 0 &&
3001  (!st->codec_info_nb_frames &&
3003  got_picture = 0;
3004  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3005  avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3006  ret = avcodec_send_packet(avctx, &pkt);
3007  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3008  break;
3009  if (ret >= 0)
3010  pkt.size = 0;
3011  ret = avcodec_receive_frame(avctx, frame);
3012  if (ret >= 0)
3013  got_picture = 1;
3014  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3015  ret = 0;
3016  } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3017  ret = avcodec_decode_subtitle2(avctx, &subtitle,
3018  &got_picture, &pkt);
3019  if (ret >= 0)
3020  pkt.size = 0;
3021  }
3022  if (ret >= 0) {
3023  if (got_picture)
3024  st->nb_decoded_frames++;
3025  ret = got_picture;
3026  }
3027  }
3028 
3029  if (!pkt.data && !got_picture)
3030  ret = -1;
3031 
3032 fail:
3033  if (do_skip_frame) {
3034  avctx->skip_frame = skip_frame;
3035  }
3036 
3037  av_frame_free(&frame);
3038  return ret;
3039 }
3040 
3041 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3042 {
3043  while (tags->id != AV_CODEC_ID_NONE) {
3044  if (tags->id == id)
3045  return tags->tag;
3046  tags++;
3047  }
3048  return 0;
3049 }
3050 
3051 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3052 {
3053  int i;
3054  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3055  if (tag == tags[i].tag)
3056  return tags[i].id;
3057  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3058  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3059  return tags[i].id;
3060  return AV_CODEC_ID_NONE;
3061 }
3062 
3063 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3064 {
3065  if (bps <= 0 || bps > 64)
3066  return AV_CODEC_ID_NONE;
3067 
3068  if (flt) {
3069  switch (bps) {
3070  case 32:
3072  case 64:
3074  default:
3075  return AV_CODEC_ID_NONE;
3076  }
3077  } else {
3078  bps += 7;
3079  bps >>= 3;
3080  if (sflags & (1 << (bps - 1))) {
3081  switch (bps) {
3082  case 1:
3083  return AV_CODEC_ID_PCM_S8;
3084  case 2:
3086  case 3:
3088  case 4:
3090  case 8:
3092  default:
3093  return AV_CODEC_ID_NONE;
3094  }
3095  } else {
3096  switch (bps) {
3097  case 1:
3098  return AV_CODEC_ID_PCM_U8;
3099  case 2:
3101  case 3:
3103  case 4:
3105  default:
3106  return AV_CODEC_ID_NONE;
3107  }
3108  }
3109  }
3110 }
3111 
3112 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3113 {
3114  unsigned int tag;
3115  if (!av_codec_get_tag2(tags, id, &tag))
3116  return 0;
3117  return tag;
3118 }
3119 
3120 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3121  unsigned int *tag)
3122 {
3123  int i;
3124  for (i = 0; tags && tags[i]; i++) {
3125  const AVCodecTag *codec_tags = tags[i];
3126  while (codec_tags->id != AV_CODEC_ID_NONE) {
3127  if (codec_tags->id == id) {
3128  *tag = codec_tags->tag;
3129  return 1;
3130  }
3131  codec_tags++;
3132  }
3133  }
3134  return 0;
3135 }
3136 
3137 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3138 {
3139  int i;
3140  for (i = 0; tags && tags[i]; i++) {
3141  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3142  if (id != AV_CODEC_ID_NONE)
3143  return id;
3144  }
3145  return AV_CODEC_ID_NONE;
3146 }
3147 
3149 {
3150  unsigned int i, j;
3151  int64_t max_time = 0;
3152 
3153  if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3154  max_time = s->duration +
3155  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3156 
3157  for (i = 0; i < s->nb_chapters; i++)
3158  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3159  AVChapter *ch = s->chapters[i];
3160  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3161  ch->time_base)
3162  : INT64_MAX;
3163 
3164  for (j = 0; j < s->nb_chapters; j++) {
3165  AVChapter *ch1 = s->chapters[j];
3166  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3167  ch->time_base);
3168  if (j != i && next_start > ch->start && next_start < end)
3169  end = next_start;
3170  }
3171  ch->end = (end == INT64_MAX) ? ch->start : end;
3172  }
3173 }
3174 
3175 static int get_std_framerate(int i)
3176 {
3177  if (i < 30*12)
3178  return (i + 1) * 1001;
3179  i -= 30*12;
3180 
3181  if (i < 30)
3182  return (i + 31) * 1001 * 12;
3183  i -= 30;
3184 
3185  if (i < 3)
3186  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3187 
3188  i -= 3;
3189 
3190  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3191 }
3192 
3193 /* Is the time base unreliable?
3194  * This is a heuristic to balance between quick acceptance of the values in
3195  * the headers vs. some extra checks.
3196  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3197  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3198  * And there are "variable" fps files this needs to detect as well. */
3200 {
3201  if (c->time_base.den >= 101LL * c->time_base.num ||
3202  c->time_base.den < 5LL * c->time_base.num ||
3203  // c->codec_tag == AV_RL32("DIVX") ||
3204  // c->codec_tag == AV_RL32("XVID") ||
3205  c->codec_tag == AV_RL32("mp4v") ||
3207  c->codec_id == AV_CODEC_ID_GIF ||
3208  c->codec_id == AV_CODEC_ID_HEVC ||
3209  c->codec_id == AV_CODEC_ID_H264)
3210  return 1;
3211  return 0;
3212 }
3213 
3215 {
3216  int ret;
3217 
3218  if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3219  par->extradata = NULL;
3220  par->extradata_size = 0;
3221  return AVERROR(EINVAL);
3222  }
3224  if (par->extradata) {
3225  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3226  par->extradata_size = size;
3227  ret = 0;
3228  } else {
3229  par->extradata_size = 0;
3230  ret = AVERROR(ENOMEM);
3231  }
3232  return ret;
3233 }
3234 
3236 {
3237  int ret = ff_alloc_extradata(par, size);
3238  if (ret < 0)
3239  return ret;
3240  ret = avio_read(pb, par->extradata, size);
3241  if (ret != size) {
3242  av_freep(&par->extradata);
3243  par->extradata_size = 0;
3244  av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3245  return ret < 0 ? ret : AVERROR_INVALIDDATA;
3246  }
3247 
3248  return ret;
3249 }
3250 
3251 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3252 {
3253  int i, j;
3254  int64_t last = st->info->last_dts;
3255 
3256  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3257  && ts - (uint64_t)last < INT64_MAX) {
3258  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3259  int64_t duration = ts - last;
3260 
3261  if (!st->info->duration_error)
3262  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3263  if (!st->info->duration_error)
3264  return AVERROR(ENOMEM);
3265 
3266 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3267 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3268  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3269  if (st->info->duration_error[0][1][i] < 1e10) {
3270  int framerate = get_std_framerate(i);
3271  double sdts = dts*framerate/(1001*12);
3272  for (j= 0; j<2; j++) {
3273  int64_t ticks = llrint(sdts+j*0.5);
3274  double error= sdts - ticks + j*0.5;
3275  st->info->duration_error[j][0][i] += error;
3276  st->info->duration_error[j][1][i] += error*error;
3277  }
3278  }
3279  }
3280  st->info->duration_count++;
3282 
3283  if (st->info->duration_count % 10 == 0) {
3284  int n = st->info->duration_count;
3285  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3286  if (st->info->duration_error[0][1][i] < 1e10) {
3287  double a0 = st->info->duration_error[0][0][i] / n;
3288  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3289  double a1 = st->info->duration_error[1][0][i] / n;
3290  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3291  if (error0 > 0.04 && error1 > 0.04) {
3292  st->info->duration_error[0][1][i] = 2e10;
3293  st->info->duration_error[1][1][i] = 2e10;
3294  }
3295  }
3296  }
3297  }
3298 
3299  // ignore the first 4 values, they might have some random jitter
3300  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3301  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3302  }
3303  if (ts != AV_NOPTS_VALUE)
3304  st->info->last_dts = ts;
3305 
3306  return 0;
3307 }
3308 
3310 {
3311  int i, j;
3312 
3313  for (i = 0; i < ic->nb_streams; i++) {
3314  AVStream *st = ic->streams[i];
3315 
3317  continue;
3318  // the check for tb_unreliable() is not completely correct, since this is not about handling
3319  // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3320  // ipmovie.c produces.
3321  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)
3322  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);
3323  if (st->info->duration_count>1 && !st->r_frame_rate.num
3324  && tb_unreliable(st->internal->avctx)) {
3325  int num = 0;
3326  double best_error= 0.01;
3327  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3328 
3329  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3330  int k;
3331 
3332  if (st->info->codec_info_duration &&
3333  st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3334  continue;
3335  if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3336  continue;
3337 
3338  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3339  continue;
3340 
3341  for (k= 0; k<2; k++) {
3342  int n = st->info->duration_count;
3343  double a= st->info->duration_error[k][0][j] / n;
3344  double error= st->info->duration_error[k][1][j]/n - a*a;
3345 
3346  if (error < best_error && best_error> 0.000000001) {
3347  best_error= error;
3348  num = get_std_framerate(j);
3349  }
3350  if (error < 0.02)
3351  av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3352  }
3353  }
3354  // do not increase frame rate by more than 1 % in order to match a standard rate.
3355  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3356  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3357  }
3358  if ( !st->avg_frame_rate.num
3359  && st->r_frame_rate.num && st->info->rfps_duration_sum
3360  && st->info->codec_info_duration <= 0
3361  && st->info->duration_count > 2
3362  && 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
3363  ) {
3364  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3365  st->avg_frame_rate = st->r_frame_rate;
3366  }
3367 
3368  av_freep(&st->info->duration_error);
3369  st->info->last_dts = AV_NOPTS_VALUE;
3370  st->info->duration_count = 0;
3371  st->info->rfps_duration_sum = 0;
3372  }
3373 }
3374 
3376 {
3377  int i, count = 0, ret = 0, j;
3378  int64_t read_size;
3379  AVStream *st;
3380  AVCodecContext *avctx;
3381  AVPacket pkt1, *pkt;
3382  int64_t old_offset = avio_tell(ic->pb);
3383  // new streams might appear, no options for those
3384  int orig_nb_streams = ic->nb_streams;
3385  int flush_codecs;
3386  int64_t max_analyze_duration = ic->max_analyze_duration;
3387  int64_t max_stream_analyze_duration;
3388  int64_t max_subtitle_analyze_duration;
3389  int64_t probesize = ic->probesize;
3390  int eof_reached = 0;
3391  int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3392 
3393  flush_codecs = probesize > 0;
3394 
3395  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3396 
3397  max_stream_analyze_duration = max_analyze_duration;
3398  max_subtitle_analyze_duration = max_analyze_duration;
3399  if (!max_analyze_duration) {
3400  max_stream_analyze_duration =
3401  max_analyze_duration = 5*AV_TIME_BASE;
3402  max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3403  if (!strcmp(ic->iformat->name, "flv"))
3404  max_stream_analyze_duration = 90*AV_TIME_BASE;
3405  if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3406  max_stream_analyze_duration = 7*AV_TIME_BASE;
3407  }
3408 
3409  if (ic->pb)
3410  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3411  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3412 
3413  for (i = 0; i < ic->nb_streams; i++) {
3414  const AVCodec *codec;
3415  AVDictionary *thread_opt = NULL;
3416  st = ic->streams[i];
3417  avctx = st->internal->avctx;
3418 
3419  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3421 /* if (!st->time_base.num)
3422  st->time_base = */
3423  if (!avctx->time_base.num)
3424  avctx->time_base = st->time_base;
3425  }
3426 
3427  /* check if the caller has overridden the codec id */
3428 #if FF_API_LAVF_AVCTX
3430  if (st->codec->codec_id != st->internal->orig_codec_id) {
3431  st->codecpar->codec_id = st->codec->codec_id;
3432  st->codecpar->codec_type = st->codec->codec_type;
3433  st->internal->orig_codec_id = st->codec->codec_id;
3434  }
3436 #endif
3437  // only for the split stuff
3438  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3439  st->parser = av_parser_init(st->codecpar->codec_id);
3440  if (st->parser) {
3441  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3443  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3445  }
3446  } else if (st->need_parsing) {
3447  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3448  "%s, packets or times may be invalid.\n",
3450  }
3451  }
3452 
3453  if (st->codecpar->codec_id != st->internal->orig_codec_id)
3455 
3456  ret = avcodec_parameters_to_context(avctx, st->codecpar);
3457  if (ret < 0)
3458  goto find_stream_info_err;
3459  if (st->request_probe <= 0)
3460  st->internal->avctx_inited = 1;
3461 
3462  codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3463 
3464  /* Force thread count to 1 since the H.264 decoder will not extract
3465  * SPS and PPS to extradata during multi-threaded decoding. */
3466  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3467 
3468  if (ic->codec_whitelist)
3469  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3470 
3471  /* Ensure that subtitle_header is properly set. */
3473  && codec && !avctx->codec) {
3474  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3475  av_log(ic, AV_LOG_WARNING,
3476  "Failed to open codec in %s\n",__FUNCTION__);
3477  }
3478 
3479  // Try to just open decoders, in case this is enough to get parameters.
3480  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3481  if (codec && !avctx->codec)
3482  if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3483  av_log(ic, AV_LOG_WARNING,
3484  "Failed to open codec in %s\n",__FUNCTION__);
3485  }
3486  if (!options)
3487  av_dict_free(&thread_opt);
3488  }
3489 
3490  for (i = 0; i < ic->nb_streams; i++) {
3491 #if FF_API_R_FRAME_RATE
3492  ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3493 #endif
3496  }
3497 
3498  read_size = 0;
3499  for (;;) {
3500  int analyzed_all_streams;
3502  ret = AVERROR_EXIT;
3503  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3504  break;
3505  }
3506 
3507  /* check if one codec still needs to be handled */
3508  for (i = 0; i < ic->nb_streams; i++) {
3509  int fps_analyze_framecount = 20;
3510 
3511  st = ic->streams[i];
3512  if (!has_codec_parameters(st, NULL))
3513  break;
3514  /* If the timebase is coarse (like the usual millisecond precision
3515  * of mkv), we need to analyze more frames to reliably arrive at
3516  * the correct fps. */
3517  if (av_q2d(st->time_base) > 0.0005)
3518  fps_analyze_framecount *= 2;
3519  if (!tb_unreliable(st->internal->avctx))
3520  fps_analyze_framecount = 0;
3521  if (ic->fps_probe_size >= 0)
3522  fps_analyze_framecount = ic->fps_probe_size;
3524  fps_analyze_framecount = 0;
3525  /* variable fps and no guess at the real fps */
3526  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3528  int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3530  st->info->duration_count;
3531  if (count < fps_analyze_framecount)
3532  break;
3533  }
3534  if (st->parser && st->parser->parser->split &&
3535  !st->internal->avctx->extradata)
3536  break;
3537  if (st->first_dts == AV_NOPTS_VALUE &&
3538  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3542  break;
3543  }
3544  analyzed_all_streams = 0;
3545  if (!missing_streams || !*missing_streams)
3546  if (i == ic->nb_streams) {
3547  analyzed_all_streams = 1;
3548  /* NOTE: If the format has no header, then we need to read some
3549  * packets to get most of the streams, so we cannot stop here. */
3550  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3551  /* If we found the info for all the codecs, we can stop. */
3552  ret = count;
3553  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3554  flush_codecs = 0;
3555  break;
3556  }
3557  }
3558  /* We did not get all the codec info, but we read too much data. */
3559  if (read_size >= probesize) {
3560  ret = count;
3561  av_log(ic, AV_LOG_DEBUG,
3562  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3563  for (i = 0; i < ic->nb_streams; i++)
3564  if (!ic->streams[i]->r_frame_rate.num &&
3565  ic->streams[i]->info->duration_count <= 1 &&
3567  strcmp(ic->iformat->name, "image2"))
3568  av_log(ic, AV_LOG_WARNING,
3569  "Stream #%d: not enough frames to estimate rate; "
3570  "consider increasing probesize\n", i);
3571  break;
3572  }
3573 
3574  /* NOTE: A new stream can be added there if no header in file
3575  * (AVFMTCTX_NOHEADER). */
3576  ret = read_frame_internal(ic, &pkt1);
3577  if (ret == AVERROR(EAGAIN))
3578  continue;
3579 
3580  if (ret < 0) {
3581  /* EOF or error*/
3582  eof_reached = 1;
3583  break;
3584  }
3585 
3586  pkt = &pkt1;
3587 
3588  if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3589  ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3590  &ic->internal->packet_buffer_end, 0);
3591  if (ret < 0)
3592  goto find_stream_info_err;
3593  }
3594 
3595  st = ic->streams[pkt->stream_index];
3597  read_size += pkt->size;
3598 
3599  avctx = st->internal->avctx;
3600  if (!st->internal->avctx_inited) {
3601  ret = avcodec_parameters_to_context(avctx, st->codecpar);
3602  if (ret < 0)
3603  goto find_stream_info_err;
3604  st->internal->avctx_inited = 1;
3605  }
3606 
3607  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3608  /* check for non-increasing dts */
3609  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3610  st->info->fps_last_dts >= pkt->dts) {
3611  av_log(ic, AV_LOG_DEBUG,
3612  "Non-increasing DTS in stream %d: packet %d with DTS "
3613  "%"PRId64", packet %d with DTS %"PRId64"\n",
3614  st->index, st->info->fps_last_dts_idx,
3616  pkt->dts);
3617  st->info->fps_first_dts =
3619  }
3620  /* Check for a discontinuity in dts. If the difference in dts
3621  * is more than 1000 times the average packet duration in the
3622  * sequence, we treat it as a discontinuity. */
3623  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3625  (pkt->dts - st->info->fps_last_dts) / 1000 >
3626  (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3627  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3628  av_log(ic, AV_LOG_WARNING,
3629  "DTS discontinuity in stream %d: packet %d with DTS "
3630  "%"PRId64", packet %d with DTS %"PRId64"\n",
3631  st->index, st->info->fps_last_dts_idx,
3633  pkt->dts);
3634  st->info->fps_first_dts =
3636  }
3637 
3638  /* update stored dts values */
3639  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3640  st->info->fps_first_dts = pkt->dts;
3642  }
3643  st->info->fps_last_dts = pkt->dts;
3645  }
3646  if (st->codec_info_nb_frames>1) {
3647  int64_t t = 0;
3648  int64_t limit;
3649 
3650  if (st->time_base.den > 0)
3652  if (st->avg_frame_rate.num > 0)
3654 
3655  if ( t == 0
3656  && st->codec_info_nb_frames>30
3657  && st->info->fps_first_dts != AV_NOPTS_VALUE
3658  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3660 
3661  if (analyzed_all_streams) limit = max_analyze_duration;
3662  else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3663  else limit = max_stream_analyze_duration;
3664 
3665  if (t >= limit) {
3666  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3667  limit,
3668  t, pkt->stream_index);
3669  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3670  av_packet_unref(pkt);
3671  break;
3672  }
3673  if (pkt->duration) {
3674  if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3675  st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3676  } else
3677  st->info->codec_info_duration += pkt->duration;
3678  st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3679  }
3680  }
3681 #if FF_API_R_FRAME_RATE
3683  ff_rfps_add_frame(ic, st, pkt->dts);
3684 #endif
3685  if (st->parser && st->parser->parser->split && !avctx->extradata) {
3686  int i = st->parser->parser->split(avctx, pkt->data, pkt->size);
3687  if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3688  avctx->extradata_size = i;
3689  avctx->extradata = av_mallocz(avctx->extradata_size +
3691  if (!avctx->extradata)
3692  return AVERROR(ENOMEM);
3693  memcpy(avctx->extradata, pkt->data,
3694  avctx->extradata_size);
3695  }
3696  }
3697 
3698  /* If still no information, we try to open the codec and to
3699  * decompress the frame. We try to avoid that in most cases as
3700  * it takes longer and uses more memory. For MPEG-4, we need to
3701  * decompress for QuickTime.
3702  *
3703  * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3704  * least one frame of codec data, this makes sure the codec initializes
3705  * the channel configuration and does not only trust the values from
3706  * the container. */
3707  try_decode_frame(ic, st, pkt,
3708  (options && i < orig_nb_streams) ? &options[i] : NULL);
3709 
3710  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3711  av_packet_unref(pkt);
3712 
3713  st->codec_info_nb_frames++;
3714  count++;
3715  }
3716 
3717  if (eof_reached) {
3718  int stream_index;
3719  for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3720  st = ic->streams[stream_index];
3721  avctx = st->internal->avctx;
3722  if (!has_codec_parameters(st, NULL)) {
3723  const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3724  if (codec && !avctx->codec) {
3725  AVDictionary *opts = NULL;
3726  if (ic->codec_whitelist)
3727  av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3728  if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3729  av_log(ic, AV_LOG_WARNING,
3730  "Failed to open codec in %s\n",__FUNCTION__);
3731  av_dict_free(&opts);
3732  }
3733  }
3734 
3735  // EOF already reached while reading the stream above.
3736  // So continue with reoordering DTS with whatever delay we have.
3738  update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3739  }
3740  }
3741  }
3742 
3743  if (flush_codecs) {
3744  AVPacket empty_pkt = { 0 };
3745  int err = 0;
3746  av_init_packet(&empty_pkt);
3747 
3748  for (i = 0; i < ic->nb_streams; i++) {
3749 
3750  st = ic->streams[i];
3751 
3752  /* flush the decoders */
3753  if (st->info->found_decoder == 1) {
3754  do {
3755  err = try_decode_frame(ic, st, &empty_pkt,
3756  (options && i < orig_nb_streams)
3757  ? &options[i] : NULL);
3758  } while (err > 0 && !has_codec_parameters(st, NULL));
3759 
3760  if (err < 0) {
3761  av_log(ic, AV_LOG_INFO,
3762  "decoding for stream %d failed\n", st->index);
3763  }
3764  }
3765  }
3766  }
3767 
3768  ff_rfps_calculate(ic);
3769 
3770  for (i = 0; i < ic->nb_streams; i++) {
3771  st = ic->streams[i];
3772  avctx = st->internal->avctx;
3773  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3774  if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3775  uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3777  avctx->codec_tag= tag;
3778  }
3779 
3780  /* estimate average framerate if not set by demuxer */
3781  if (st->info->codec_info_duration_fields &&
3782  !st->avg_frame_rate.num &&
3783  st->info->codec_info_duration) {
3784  int best_fps = 0;
3785  double best_error = 0.01;
3786 
3787  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3788  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3789  st->info->codec_info_duration < 0)
3790  continue;
3792  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3793  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3794 
3795  /* Round guessed framerate to a "standard" framerate if it's
3796  * within 1% of the original estimate. */
3797  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3798  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3799  double error = fabs(av_q2d(st->avg_frame_rate) /
3800  av_q2d(std_fps) - 1);
3801 
3802  if (error < best_error) {
3803  best_error = error;
3804  best_fps = std_fps.num;
3805  }
3806  }
3807  if (best_fps)
3809  best_fps, 12 * 1001, INT_MAX);
3810  }
3811 
3812  if (!st->r_frame_rate.num) {
3813  if ( avctx->time_base.den * (int64_t) st->time_base.num
3814  <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3815  st->r_frame_rate.num = avctx->time_base.den;
3816  st->r_frame_rate.den = avctx->time_base.num * avctx->ticks_per_frame;
3817  } else {
3818  st->r_frame_rate.num = st->time_base.den;
3819  st->r_frame_rate.den = st->time_base.num;
3820  }
3821  }
3823  AVRational hw_ratio = { avctx->height, avctx->width };
3825  hw_ratio);
3826  }
3827  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3828  if (!avctx->bits_per_coded_sample)
3829  avctx->bits_per_coded_sample =
3831  // set stream disposition based on audio service type
3832  switch (avctx->audio_service_type) {
3835  break;
3838  break;
3841  break;
3844  break;
3847  break;
3848  }
3849  }
3850  }
3851 
3852  if (probesize)
3853  estimate_timings(ic, old_offset);
3854 
3855  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3856 
3857  if (ret >= 0 && ic->nb_streams)
3858  /* We could not have all the codec parameters before EOF. */
3859  ret = -1;
3860  for (i = 0; i < ic->nb_streams; i++) {
3861  const char *errmsg;
3862  st = ic->streams[i];
3863 
3864  /* if no packet was ever seen, update context now for has_codec_parameters */
3865  if (!st->internal->avctx_inited) {
3866  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3868  st->codecpar->format = st->internal->avctx->sample_fmt;
3870  if (ret < 0)
3871  goto find_stream_info_err;
3872  }
3873  if (!has_codec_parameters(st, &errmsg)) {
3874  char buf[256];
3875  avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
3876  av_log(ic, AV_LOG_WARNING,
3877  "Could not find codec parameters for stream %d (%s): %s\n"
3878  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3879  i, buf, errmsg);
3880  } else {
3881  ret = 0;
3882  }
3883  }
3884 
3886 
3887  /* update the stream parameters from the internal codec contexts */
3888  for (i = 0; i < ic->nb_streams; i++) {
3889  st = ic->streams[i];
3890 
3891  if (st->internal->avctx_inited) {
3892  int orig_w = st->codecpar->width;
3893  int orig_h = st->codecpar->height;
3895  if (ret < 0)
3896  goto find_stream_info_err;
3897  // The decoder might reduce the video size by the lowres factor.
3898  if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
3899  st->codecpar->width = orig_w;
3900  st->codecpar->height = orig_h;
3901  }
3902  }
3903 
3904 #if FF_API_LAVF_AVCTX
3906  ret = avcodec_parameters_to_context(st->codec, st->codecpar);
3907  if (ret < 0)
3908  goto find_stream_info_err;
3909 
3910  // The old API (AVStream.codec) "requires" the resolution to be adjusted
3911  // by the lowres factor.
3912  if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
3914  st->codec->width = st->internal->avctx->width;
3915  st->codec->height = st->internal->avctx->height;
3916  }
3917 
3918  if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
3919  st->codec->time_base = st->internal->avctx->time_base;
3920  st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
3921  }
3922  st->codec->framerate = st->avg_frame_rate;
3923 
3924  if (st->internal->avctx->subtitle_header) {
3925  st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
3926  if (!st->codec->subtitle_header)
3927  goto find_stream_info_err;
3928  st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
3929  memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
3930  st->codec->subtitle_header_size);
3931  }
3932 
3933  // Fields unavailable in AVCodecParameters
3934  st->codec->coded_width = st->internal->avctx->coded_width;
3935  st->codec->coded_height = st->internal->avctx->coded_height;
3936  st->codec->properties = st->internal->avctx->properties;
3938 #endif
3939 
3940  st->internal->avctx_inited = 0;
3941  }
3942 
3943 find_stream_info_err:
3944  for (i = 0; i < ic->nb_streams; i++) {
3945  st = ic->streams[i];
3946  if (st->info)
3947  av_freep(&st->info->duration_error);
3948  avcodec_close(ic->streams[i]->internal->avctx);
3949  av_freep(&ic->streams[i]->info);
3950  }
3951  if (ic->pb)
3952  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3953  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3954  return ret;
3955 }
3956 
3958 {
3959  int i, j;
3960 
3961  for (i = 0; i < ic->nb_programs; i++) {
3962  if (ic->programs[i] == last) {
3963  last = NULL;
3964  } else {
3965  if (!last)
3966  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3967  if (ic->programs[i]->stream_index[j] == s)
3968  return ic->programs[i];
3969  }
3970  }
3971  return NULL;
3972 }
3973 
3975  int wanted_stream_nb, int related_stream,
3976  AVCodec **decoder_ret, int flags)
3977 {
3978  int i, nb_streams = ic->nb_streams;
3979  int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3980  unsigned *program = NULL;
3981  const AVCodec *decoder = NULL, *best_decoder = NULL;
3982 
3983  if (related_stream >= 0 && wanted_stream_nb < 0) {
3984  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3985  if (p) {
3986  program = p->stream_index;
3987  nb_streams = p->nb_stream_indexes;
3988  }
3989  }
3990  for (i = 0; i < nb_streams; i++) {
3991  int real_stream_index = program ? program[i] : i;
3992  AVStream *st = ic->streams[real_stream_index];
3993  AVCodecParameters *par = st->codecpar;
3994  if (par->codec_type != type)
3995  continue;
3996  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3997  continue;
3998  if (wanted_stream_nb != real_stream_index &&
4001  continue;
4002  if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4003  continue;
4004  if (decoder_ret) {
4005  decoder = find_decoder(ic, st, par->codec_id);
4006  if (!decoder) {
4007  if (ret < 0)
4009  continue;
4010  }
4011  }
4013  bitrate = par->bit_rate;
4014  multiframe = FFMIN(5, count);
4015  if ((best_multiframe > multiframe) ||
4016  (best_multiframe == multiframe && best_bitrate > bitrate) ||
4017  (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4018  continue;
4019  best_count = count;
4020  best_bitrate = bitrate;
4021  best_multiframe = multiframe;
4022  ret = real_stream_index;
4023  best_decoder = decoder;
4024  if (program && i == nb_streams - 1 && ret < 0) {
4025  program = NULL;
4026  nb_streams = ic->nb_streams;
4027  /* no related stream found, try again with everything */
4028  i = 0;
4029  }
4030  }
4031  if (decoder_ret)
4032  *decoder_ret = (AVCodec*)best_decoder;
4033  return ret;
4034 }
4035 
4036 /*******************************************************/
4037 
4039 {
4040  if (s->iformat->read_play)
4041  return s->iformat->read_play(s);
4042  if (s->pb)
4043  return avio_pause(s->pb, 0);
4044  return AVERROR(ENOSYS);
4045 }
4046 
4048 {
4049  if (s->iformat->read_pause)
4050  return s->iformat->read_pause(s);
4051  if (s->pb)
4052  return avio_pause(s->pb, 1);
4053  return AVERROR(ENOSYS);
4054 }
4055 
4057 {
4058  int ret, i;
4059 
4060  dst->id = src->id;
4061  dst->time_base = src->time_base;
4062  dst->nb_frames = src->nb_frames;
4063  dst->disposition = src->disposition;
4065  dst->avg_frame_rate = src->avg_frame_rate;
4066  dst->r_frame_rate = src->r_frame_rate;
4067 
4068  av_dict_free(&dst->metadata);
4069  ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4070  if (ret < 0)
4071  return ret;
4072 
4073  ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4074  if (ret < 0)
4075  return ret;
4076 
4077  /* Free existing side data*/
4078  for (i = 0; i < dst->nb_side_data; i++)
4079  av_free(dst->side_data[i].data);
4080  av_freep(&dst->side_data);
4081  dst->nb_side_data = 0;
4082 
4083  /* Copy side data if present */
4084  if (src->nb_side_data) {
4086  sizeof(AVPacketSideData));
4087  if (!dst->side_data)
4088  return AVERROR(ENOMEM);
4089  dst->nb_side_data = src->nb_side_data;
4090 
4091  for (i = 0; i < src->nb_side_data; i++) {
4092  uint8_t *data = av_memdup(src->side_data[i].data,
4093  src->side_data[i].size);
4094  if (!data)
4095  return AVERROR(ENOMEM);
4096  dst->side_data[i].type = src->side_data[i].type;
4097  dst->side_data[i].size = src->side_data[i].size;
4098  dst->side_data[i].data = data;
4099  }
4100  }
4101 
4104  const char *conf_str = src->recommended_encoder_configuration;
4107  return AVERROR(ENOMEM);
4108  }
4109 
4110  return 0;
4111 }
4112 
4113 static void free_stream(AVStream **pst)
4114 {
4115  AVStream *st = *pst;
4116  int i;
4117 
4118  if (!st)
4119  return;
4120 
4121  for (i = 0; i < st->nb_side_data; i++)
4122  av_freep(&st->side_data[i].data);
4123  av_freep(&st->side_data);
4124 
4125  if (st->parser)
4126  av_parser_close(st->parser);
4127 
4128  if (st->attached_pic.data)
4130 
4131  if (st->internal) {
4133  for (i = 0; i < st->internal->nb_bsfcs; i++) {
4134  av_bsf_free(&st->internal->bsfcs[i]);
4135  av_freep(&st->internal->bsfcs);
4136  }
4137  }
4138  av_freep(&st->internal);
4139 
4140  av_dict_free(&st->metadata);
4142  av_freep(&st->probe_data.buf);
4143  av_freep(&st->index_entries);
4144 #if FF_API_LAVF_AVCTX
4146  avcodec_free_context(&st->codec);
4148 #endif
4149  av_freep(&st->priv_data);
4150  if (st->info)
4151  av_freep(&st->info->duration_error);
4152  av_freep(&st->info);
4154  av_freep(&st->priv_pts);
4155 
4156  av_freep(pst);
4157 }
4158 
4160 {
4161  av_assert0(s->nb_streams>0);
4162  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4163 
4164  free_stream(&s->streams[ --s->nb_streams ]);
4165 }
4166 
4168 {
4169  int i;
4170 
4171  if (!s)
4172  return;
4173 
4174  av_opt_free(s);
4175  if (s->iformat && s->iformat->priv_class && s->priv_data)
4176  av_opt_free(s->priv_data);
4177  if (s->oformat && s->oformat->priv_class && s->priv_data)
4178  av_opt_free(s->priv_data);
4179 
4180  for (i = s->nb_streams - 1; i >= 0; i--)
4181  ff_free_stream(s, s->streams[i]);
4182 
4183 
4184  for (i = s->nb_programs - 1; i >= 0; i--) {
4185  av_dict_free(&s->programs[i]->metadata);
4186  av_freep(&s->programs[i]->stream_index);
4187  av_freep(&s->programs[i]);
4188  }
4189  av_freep(&s->programs);
4190  av_freep(&s->priv_data);
4191  while (s->nb_chapters--) {
4193  av_freep(&s->chapters[s->nb_chapters]);
4194  }
4195  av_freep(&s->chapters);
4196  av_dict_free(&s->metadata);
4198  av_freep(&s->streams);
4199  flush_packet_queue(s);
4200  av_freep(&s->internal);
4201  av_free(s);
4202 }
4203 
4205 {
4206  AVFormatContext *s;
4207  AVIOContext *pb;
4208 
4209  if (!ps || !*ps)
4210  return;
4211 
4212  s = *ps;
4213  pb = s->pb;
4214 
4215  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4216  (s->flags & AVFMT_FLAG_CUSTOM_IO))
4217  pb = NULL;
4218 
4219  flush_packet_queue(s);
4220 
4221  if (s->iformat)
4222  if (s->iformat->read_close)
4223  s->iformat->read_close(s);
4224 
4226 
4227  *ps = NULL;
4228 
4229  avio_close(pb);
4230 }
4231 
4233 {
4234  AVStream *st;
4235  int i;
4236  AVStream **streams;
4237 
4238  if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4239  if (s->max_streams < INT_MAX/sizeof(*streams))
4240  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);
4241  return NULL;
4242  }
4243  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4244  if (!streams)
4245  return NULL;
4246  s->streams = streams;
4247 
4248  st = av_mallocz(sizeof(AVStream));
4249  if (!st)
4250  return NULL;
4251  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4252  av_free(st);
4253  return NULL;
4254  }
4255  st->info->last_dts = AV_NOPTS_VALUE;
4256 
4257 #if FF_API_LAVF_AVCTX
4259  st->codec = avcodec_alloc_context3(c);
4260  if (!st->codec) {
4261  av_free(st->info);
4262  av_free(st);
4263  return NULL;
4264  }
4266 #endif
4267 
4268  st->internal = av_mallocz(sizeof(*st->internal));
4269  if (!st->internal)
4270  goto fail;
4271 
4273  if (!st->codecpar)
4274  goto fail;
4275 
4277  if (!st->internal->avctx)
4278  goto fail;
4279 
4280  if (s->iformat) {
4281 #if FF_API_LAVF_AVCTX
4283  /* no default bitrate if decoding */
4284  st->codec->bit_rate = 0;
4286 #endif
4287 
4288  /* default pts setting is MPEG-like */
4289  avpriv_set_pts_info(st, 33, 1, 90000);
4290  /* we set the current DTS to 0 so that formats without any timestamps
4291  * but durations get some timestamps, formats with some unknown
4292  * timestamps have their first few packets buffered and the
4293  * timestamps corrected before they are returned to the user */
4294  st->cur_dts = RELATIVE_TS_BASE;
4295  } else {
4296  st->cur_dts = AV_NOPTS_VALUE;
4297  }
4298 
4299  st->index = s->nb_streams;
4300  st->start_time = AV_NOPTS_VALUE;
4301  st->duration = AV_NOPTS_VALUE;
4302  st->first_dts = AV_NOPTS_VALUE;
4306 
4309  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4310  st->pts_buffer[i] = AV_NOPTS_VALUE;
4311 
4312  st->sample_aspect_ratio = (AVRational) { 0, 1 };
4313 
4314 #if FF_API_R_FRAME_RATE
4315  st->info->last_dts = AV_NOPTS_VALUE;
4316 #endif
4319 
4321 
4322  st->internal->need_context_update = 1;
4323 
4324  s->streams[s->nb_streams++] = st;
4325  return st;
4326 fail:
4327  free_stream(&st);
4328  return NULL;
4329 }
4330 
4332 {
4333  AVProgram *program = NULL;
4334  int i;
4335 
4336  av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4337 
4338  for (i = 0; i < ac->nb_programs; i++)
4339  if (ac->programs[i]->id == id)
4340  program = ac->programs[i];
4341 
4342  if (!program) {
4343  program = av_mallocz(sizeof(AVProgram));
4344  if (!program)
4345  return NULL;
4346  dynarray_add(&ac->programs, &ac->nb_programs, program);
4347  program->discard = AVDISCARD_NONE;
4348  }
4349  program->id = id;
4352 
4353  program->start_time =
4354  program->end_time = AV_NOPTS_VALUE;
4355 
4356  return program;
4357 }
4358 
4360  int64_t start, int64_t end, const char *title)
4361 {
4362  AVChapter *chapter = NULL;
4363  int i;
4364 
4365  if (end != AV_NOPTS_VALUE && start > end) {
4366  av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4367  return NULL;
4368  }
4369 
4370  for (i = 0; i < s->nb_chapters; i++)
4371  if (s->chapters[i]->id == id)
4372  chapter = s->chapters[i];
4373 
4374  if (!chapter) {
4375  chapter = av_mallocz(sizeof(AVChapter));
4376  if (!chapter)
4377  return NULL;
4378  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4379  }
4380  av_dict_set(&chapter->metadata, "title", title, 0);
4381  chapter->id = id;
4382  chapter->time_base = time_base;
4383  chapter->start = start;
4384  chapter->end = end;
4385 
4386  return chapter;
4387 }
4388 
4389 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4390 {
4391  int i, j;
4392  AVProgram *program = NULL;
4393  void *tmp;
4394 
4395  if (idx >= ac->nb_streams) {
4396  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4397  return;
4398  }
4399 
4400  for (i = 0; i < ac->nb_programs; i++) {
4401  if (ac->programs[i]->id != progid)
4402  continue;
4403  program = ac->programs[i];
4404  for (j = 0; j < program->nb_stream_indexes; j++)
4405  if (program->stream_index[j] == idx)
4406  return;
4407 
4408  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4409  if (!tmp)
4410  return;
4411  program->stream_index = tmp;
4412  program->stream_index[program->nb_stream_indexes++] = idx;
4413  return;
4414  }
4415 }
4416 
4417 uint64_t ff_ntp_time(void)
4418 {
4419  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4420 }
4421 
4422 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4423 {
4424  const char *p;
4425  char *q, buf1[20], c;
4426  int nd, len, percentd_found;
4427 
4428  q = buf;
4429  p = path;
4430  percentd_found = 0;
4431  for (;;) {
4432  c = *p++;
4433  if (c == '\0')
4434  break;
4435  if (c == '%') {
4436  do {
4437  nd = 0;
4438  while (av_isdigit(*p))
4439  nd = nd * 10 + *p++ - '0';
4440  c = *p++;
4441  } while (av_isdigit(c));
4442 
4443  switch (c) {
4444  case '%':
4445  goto addchar;
4446  case 'd':
4447  if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4448  goto fail;
4449  percentd_found = 1;
4450  if (number < 0)
4451  nd += 1;
4452  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4453  len = strlen(buf1);
4454  if ((q - buf + len) > buf_size - 1)
4455  goto fail;
4456  memcpy(q, buf1, len);
4457  q += len;
4458  break;
4459  default:
4460  goto fail;
4461  }
4462  } else {
4463 addchar:
4464  if ((q - buf) < buf_size - 1)
4465  *q++ = c;
4466  }
4467  }
4468  if (!percentd_found)
4469  goto fail;
4470  *q = '\0';
4471  return 0;
4472 fail:
4473  *q = '\0';
4474  return -1;
4475 }
4476 
4477 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4478 {
4479  return av_get_frame_filename2(buf, buf_size, path, number, 0);
4480 }
4481 
4482 void av_url_split(char *proto, int proto_size,
4483  char *authorization, int authorization_size,
4484  char *hostname, int hostname_size,
4485  int *port_ptr, char *path, int path_size, const char *url)
4486 {
4487  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4488 
4489  if (port_ptr)
4490  *port_ptr = -1;
4491  if (proto_size > 0)
4492  proto[0] = 0;
4493  if (authorization_size > 0)
4494  authorization[0] = 0;
4495  if (hostname_size > 0)
4496  hostname[0] = 0;
4497  if (path_size > 0)
4498  path[0] = 0;
4499 
4500  /* parse protocol */
4501  if ((p = strchr(url, ':'))) {
4502  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4503  p++; /* skip ':' */
4504  if (*p == '/')
4505  p++;
4506  if (*p == '/')
4507  p++;
4508  } else {
4509  /* no protocol means plain filename */
4510  av_strlcpy(path, url, path_size);
4511  return;
4512  }
4513 
4514  /* separate path from hostname */
4515  ls = strchr(p, '/');
4516  ls2 = strchr(p, '?');
4517  if (!ls)
4518  ls = ls2;
4519  else if (ls && ls2)
4520  ls = FFMIN(ls, ls2);
4521  if (ls)
4522  av_strlcpy(path, ls, path_size);
4523  else
4524  ls = &p[strlen(p)]; // XXX
4525 
4526  /* the rest is hostname, use that to parse auth/port */
4527  if (ls != p) {
4528  /* authorization (user[:pass]@hostname) */
4529  at2 = p;
4530  while ((at = strchr(p, '@')) && at < ls) {
4531  av_strlcpy(authorization, at2,
4532  FFMIN(authorization_size, at + 1 - at2));
4533  p = at + 1; /* skip '@' */
4534  }
4535 
4536  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4537  /* [host]:port */
4538  av_strlcpy(hostname, p + 1,
4539  FFMIN(hostname_size, brk - p));
4540  if (brk[1] == ':' && port_ptr)
4541  *port_ptr = atoi(brk + 2);
4542  } else if ((col = strchr(p, ':')) && col < ls) {
4543  av_strlcpy(hostname, p,
4544  FFMIN(col + 1 - p, hostname_size));
4545  if (port_ptr)
4546  *port_ptr = atoi(col + 1);
4547  } else
4548  av_strlcpy(hostname, p,
4549  FFMIN(ls + 1 - p, hostname_size));
4550  }
4551 }
4552 
4553 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4554 {
4555  int i;
4556  static const char hex_table_uc[16] = { '0', '1', '2', '3',
4557  '4', '5', '6', '7',
4558  '8', '9', 'A', 'B',
4559  'C', 'D', 'E', 'F' };
4560  static const char hex_table_lc[16] = { '0', '1', '2', '3',
4561  '4', '5', '6', '7',
4562  '8', '9', 'a', 'b',
4563  'c', 'd', 'e', 'f' };
4564  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4565 
4566  for (i = 0; i < s; i++) {
4567  buff[i * 2] = hex_table[src[i] >> 4];
4568  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4569  }
4570 
4571  return buff;
4572 }
4573 
4574 int ff_hex_to_data(uint8_t *data, const char *p)
4575 {
4576  int c, len, v;
4577 
4578  len = 0;
4579  v = 1;
4580  for (;;) {
4581  p += strspn(p, SPACE_CHARS);
4582  if (*p == '\0')
4583  break;
4584  c = av_toupper((unsigned char) *p++);
4585  if (c >= '0' && c <= '9')
4586  c = c - '0';
4587  else if (c >= 'A' && c <= 'F')
4588  c = c - 'A' + 10;
4589  else
4590  break;
4591  v = (v << 4) | c;
4592  if (v & 0x100) {
4593  if (data)
4594  data[len] = v;
4595  len++;
4596  v = 1;
4597  }
4598  }
4599  return len;
4600 }
4601 
4602 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4603  unsigned int pts_num, unsigned int pts_den)
4604 {
4605  AVRational new_tb;
4606  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4607  if (new_tb.num != pts_num)
4609  "st:%d removing common factor %d from timebase\n",
4610  s->index, pts_num / new_tb.num);
4611  } else
4613  "st:%d has too large timebase, reducing\n", s->index);
4614 
4615  if (new_tb.num <= 0 || new_tb.den <= 0) {
4617  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4618  new_tb.num, new_tb.den,
4619  s->index);
4620  return;
4621  }
4622  s->time_base = new_tb;
4623 #if FF_API_LAVF_AVCTX
4625  av_codec_set_pkt_timebase(s->codec, new_tb);
4627 #endif
4629  s->pts_wrap_bits = pts_wrap_bits;
4630 }
4631 
4632 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4633  void *context)
4634 {
4635  const char *ptr = str;
4636 
4637  /* Parse key=value pairs. */
4638  for (;;) {
4639  const char *key;
4640  char *dest = NULL, *dest_end;
4641  int key_len, dest_len = 0;
4642 
4643  /* Skip whitespace and potential commas. */
4644  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4645  ptr++;
4646  if (!*ptr)
4647  break;
4648 
4649  key = ptr;
4650 
4651  if (!(ptr = strchr(key, '=')))
4652  break;
4653  ptr++;
4654  key_len = ptr - key;
4655 
4656  callback_get_buf(context, key, key_len, &dest, &dest_len);
4657  dest_end = dest + dest_len - 1;
4658 
4659  if (*ptr == '\"') {
4660  ptr++;
4661  while (*ptr && *ptr != '\"') {
4662  if (*ptr == '\\') {
4663  if (!ptr[1])
4664  break;
4665  if (dest && dest < dest_end)
4666  *dest++ = ptr[1];
4667  ptr += 2;
4668  } else {
4669  if (dest && dest < dest_end)
4670  *dest++ = *ptr;
4671  ptr++;
4672  }
4673  }
4674  if (*ptr == '\"')
4675  ptr++;
4676  } else {
4677  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4678  if (dest && dest < dest_end)
4679  *dest++ = *ptr;
4680  }
4681  if (dest)
4682  *dest = 0;
4683  }
4684 }
4685 
4687 {
4688  int i;
4689  for (i = 0; i < s->nb_streams; i++)
4690  if (s->streams[i]->id == id)
4691  return i;
4692  return -1;
4693 }
4694 
4696  int std_compliance)
4697 {
4698  if (ofmt) {
4699  unsigned int codec_tag;
4700  if (ofmt->query_codec)
4701  return ofmt->query_codec(codec_id, std_compliance);
4702  else if (ofmt->codec_tag)
4703  return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4704  else if (codec_id == ofmt->video_codec ||
4705  codec_id == ofmt->audio_codec ||
4706  codec_id == ofmt->subtitle_codec ||
4707  codec_id == ofmt->data_codec)
4708  return 1;
4709  }
4710  return AVERROR_PATCHWELCOME;
4711 }
4712 
4714 {
4715 #if CONFIG_NETWORK
4716  int ret;
4718  if ((ret = ff_network_init()) < 0)
4719  return ret;
4720  if ((ret = ff_tls_init()) < 0)
4721  return ret;
4722 #endif
4723  return 0;
4724 }
4725 
4727 {
4728 #if CONFIG_NETWORK
4729  ff_network_close();
4730  ff_tls_deinit();
4732 #endif
4733  return 0;
4734 }
4735 
4737  uint64_t channel_layout, int32_t sample_rate,
4739 {
4740  uint32_t flags = 0;
4741  int size = 4;
4742  uint8_t *data;
4743  if (!pkt)
4744  return AVERROR(EINVAL);
4745  if (channels) {
4746  size += 4;
4748  }
4749  if (channel_layout) {
4750  size += 8;
4752  }
4753  if (sample_rate) {
4754  size += 4;
4756  }
4757  if (width || height) {
4758  size += 8;
4760  }
4762  if (!data)
4763  return AVERROR(ENOMEM);
4764  bytestream_put_le32(&data, flags);
4765  if (channels)
4766  bytestream_put_le32(&data, channels);
4767  if (channel_layout)
4768  bytestream_put_le64(&data, channel_layout);
4769  if (sample_rate)
4770  bytestream_put_le32(&data, sample_rate);
4771  if (width || height) {
4772  bytestream_put_le32(&data, width);
4773  bytestream_put_le32(&data, height);
4774  }
4775  return 0;
4776 }
4777 
4779 {
4780  AVRational undef = {0, 1};
4781  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4782  AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4783  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4784 
4785  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4786  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4787  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4788  stream_sample_aspect_ratio = undef;
4789 
4790  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4791  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4792  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4793  frame_sample_aspect_ratio = undef;
4794 
4795  if (stream_sample_aspect_ratio.num)
4796  return stream_sample_aspect_ratio;
4797  else
4798  return frame_sample_aspect_ratio;
4799 }
4800 
4802 {
4803  AVRational fr = st->r_frame_rate;
4804  AVRational codec_fr = st->internal->avctx->framerate;
4805  AVRational avg_fr = st->avg_frame_rate;
4806 
4807  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4808  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4809  fr = avg_fr;
4810  }
4811 
4812 
4813  if (st->internal->avctx->ticks_per_frame > 1) {
4814  if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4815  (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))
4816  fr = codec_fr;
4817  }
4818 
4819  return fr;
4820 }
4821 
4823  const char *spec)
4824 {
4825  if (*spec <= '9' && *spec >= '0') /* opt:index */
4826  return strtol(spec, NULL, 0) == st->index;
4827  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4828  *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4829  enum AVMediaType type;
4830  int nopic = 0;
4831 
4832  switch (*spec++) {
4833  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4834  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4835  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4836  case 'd': type = AVMEDIA_TYPE_DATA; break;
4837  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4838  case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4839  default: av_assert0(0);
4840  }
4841 #if FF_API_LAVF_AVCTX
4843  if (type != st->codecpar->codec_type
4844  && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4845  return 0;
4847 #else
4848  if (type != st->codecpar->codec_type)
4849  return 0;
4850 #endif
4851  if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4852  return 0;
4853  if (*spec++ == ':') { /* possibly followed by :index */
4854  int i, index = strtol(spec, NULL, 0);
4855  for (i = 0; i < s->nb_streams; i++) {
4856 #if FF_API_LAVF_AVCTX
4858  if ((s->streams[i]->codecpar->codec_type == type
4859  || s->streams[i]->codec->codec_type == type
4860  ) &&
4861  !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4862  index-- == 0)
4863  return i == st->index;
4865 #else
4866  if ((s->streams[i]->codecpar->codec_type == type) &&
4867  !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4868  index-- == 0)
4869  return i == st->index;
4870 #endif
4871  }
4872  return 0;
4873  }
4874  return 1;
4875  } else if (*spec == 'p' && *(spec + 1) == ':') {
4876  int prog_id, i, j;
4877  char *endptr;
4878  spec += 2;
4879  prog_id = strtol(spec, &endptr, 0);
4880  for (i = 0; i < s->nb_programs; i++) {
4881  if (s->programs[i]->id != prog_id)
4882  continue;
4883 
4884  if (*endptr++ == ':') {
4885  int stream_idx = strtol(endptr, NULL, 0);
4886  return stream_idx >= 0 &&
4887  stream_idx < s->programs[i]->nb_stream_indexes &&
4888  st->index == s->programs[i]->stream_index[stream_idx];
4889  }
4890 
4891  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4892  if (st->index == s->programs[i]->stream_index[j])
4893  return 1;
4894  }
4895  return 0;
4896  } else if (*spec == '#' ||
4897  (*spec == 'i' && *(spec + 1) == ':')) {
4898  int stream_id;
4899  char *endptr;
4900  spec += 1 + (*spec == 'i');
4901  stream_id = strtol(spec, &endptr, 0);
4902  if (!*endptr)
4903  return stream_id == st->id;
4904  } else if (*spec == 'm' && *(spec + 1) == ':') {
4906  char *key, *val;
4907  int ret;
4908 
4909  spec += 2;
4910  val = strchr(spec, ':');
4911 
4912  key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4913  if (!key)
4914  return AVERROR(ENOMEM);
4915 
4916  tag = av_dict_get(st->metadata, key, NULL, 0);
4917  if (tag) {
4918  if (!val || !strcmp(tag->value, val + 1))
4919  ret = 1;
4920  else
4921  ret = 0;
4922  } else
4923  ret = 0;
4924 
4925  av_freep(&key);
4926  return ret;
4927  } else if (*spec == 'u') {
4928  AVCodecParameters *par = st->codecpar;
4929 #if FF_API_LAVF_AVCTX
4931  AVCodecContext *codec = st->codec;
4933 #endif
4934  int val;
4935  switch (par->codec_type) {
4936  case AVMEDIA_TYPE_AUDIO:
4937  val = par->sample_rate && par->channels;
4938 #if FF_API_LAVF_AVCTX
4939  val = val || (codec->sample_rate && codec->channels);
4940 #endif
4941  if (par->format == AV_SAMPLE_FMT_NONE
4943  && codec->sample_fmt == AV_SAMPLE_FMT_NONE
4944 #endif
4945  )
4946  return 0;
4947  break;
4948  case AVMEDIA_TYPE_VIDEO:
4949  val = par->width && par->height;
4950 #if FF_API_LAVF_AVCTX
4951  val = val || (codec->width && codec->height);
4952 #endif
4953  if (par->format == AV_PIX_FMT_NONE
4955  && codec->pix_fmt == AV_PIX_FMT_NONE
4956 #endif
4957  )
4958  return 0;
4959  break;
4960  case AVMEDIA_TYPE_UNKNOWN:
4961  val = 0;
4962  break;
4963  default:
4964  val = 1;
4965  break;
4966  }
4967 #if FF_API_LAVF_AVCTX
4968  return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
4969 #else
4970  return par->codec_id != AV_CODEC_ID_NONE && val != 0;
4971 #endif
4972  } else if (!*spec) /* empty specifier, matches everything */
4973  return 1;
4974 
4975  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4976  return AVERROR(EINVAL);
4977 }
4978 
4980 {
4981  static const uint8_t avci100_1080p_extradata[] = {
4982  // SPS
4983  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4984  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4985  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4986  0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4987  0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4988  0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4989  0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4990  0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4991  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4992  // PPS
4993  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4994  0xd0
4995  };
4996  static const uint8_t avci100_1080i_extradata[] = {
4997  // SPS
4998  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4999  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5000  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5001  0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5002  0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5003  0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5004  0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5005  0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5006  0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5007  0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5008  0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5009  // PPS
5010  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5011  0xd0
5012  };
5013  static const uint8_t avci50_1080p_extradata[] = {
5014  // SPS
5015  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5016  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5017  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5018  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5019  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5020  0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5021  0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5022  0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5023  0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5024  // PPS
5025  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5026  0x11
5027  };
5028  static const uint8_t avci50_1080i_extradata[] = {
5029  // SPS
5030  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5031  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5032  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5033  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5034  0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5035  0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5036  0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5037  0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5038  0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5039  0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5040  0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5041  // PPS
5042  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5043  0x11
5044  };
5045  static const uint8_t avci100_720p_extradata[] = {
5046  // SPS
5047  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5048  0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5049  0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5050  0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5051  0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5052  0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5053  0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5054  0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5055  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5056  0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5057  // PPS
5058  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5059  0x11
5060  };
5061  static const uint8_t avci50_720p_extradata[] = {
5062  // SPS
5063  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5064  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5065  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5066  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5067  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5068  0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5069  0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5070  0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5071  0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5072  // PPS
5073  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5074  0x11
5075  };
5076 
5077  const uint8_t *data = NULL;
5078  int size = 0;
5079 
5080  if (st->codecpar->width == 1920) {
5082  data = avci100_1080p_extradata;
5083  size = sizeof(avci100_1080p_extradata);
5084  } else {
5085  data = avci100_1080i_extradata;
5086  size = sizeof(avci100_1080i_extradata);
5087  }
5088  } else if (st->codecpar->width == 1440) {
5090  data = avci50_1080p_extradata;
5091  size = sizeof(avci50_1080p_extradata);
5092  } else {
5093  data = avci50_1080i_extradata;
5094  size = sizeof(avci50_1080i_extradata);
5095  }
5096  } else if (st->codecpar->width == 1280) {
5097  data = avci100_720p_extradata;
5098  size = sizeof(avci100_720p_extradata);
5099  } else if (st->codecpar->width == 960) {
5100  data = avci50_720p_extradata;
5101  size = sizeof(avci50_720p_extradata);
5102  }
5103 
5104  if (!size)
5105  return 0;
5106 
5107  av_freep(&st->codecpar->extradata);
5108  if (ff_alloc_extradata(st->codecpar, size))
5109  return AVERROR(ENOMEM);
5110  memcpy(st->codecpar->extradata, data, size);
5111 
5112  return 0;
5113 }
5114 
5115 #if FF_API_NOCONST_GET_SIDE_DATA
5117  enum AVPacketSideDataType type, int *size)
5118 #else
5120  enum AVPacketSideDataType type, int *size)
5121 #endif
5122 {
5123  int i;
5124 
5125  for (i = 0; i < st->nb_side_data; i++) {
5126  if (st->side_data[i].type == type) {
5127  if (size)
5128  *size = st->side_data[i].size;
5129  return st->side_data[i].data;
5130  }
5131  }
5132  return NULL;
5133 }
5134 
5136  uint8_t *data, size_t size)
5137 {
5138  AVPacketSideData *sd, *tmp;
5139  int i;
5140 
5141  for (i = 0; i < st->nb_side_data; i++) {
5142  sd = &st->side_data[i];
5143 
5144  if (sd->type == type) {
5145  av_freep(&sd->data);
5146  sd->data = data;
5147  sd->size = size;
5148  return 0;
5149  }
5150  }
5151 
5152  if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5153  return AVERROR(ERANGE);
5154 
5155  tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5156  if (!tmp) {
5157  return AVERROR(ENOMEM);
5158  }
5159 
5160  st->side_data = tmp;
5161  st->nb_side_data++;
5162 
5163  sd = &st->side_data[st->nb_side_data - 1];
5164  sd->type = type;
5165  sd->data = data;
5166  sd->size = size;
5167 
5168  return 0;
5169 }
5170 
5172  int size)
5173 {
5174  int ret;
5175  uint8_t *data = av_malloc(size);
5176 
5177  if (!data)
5178  return NULL;
5179 
5180  ret = av_stream_add_side_data(st, type, data, size);
5181  if (ret < 0) {
5182  av_freep(&data);
5183  return NULL;
5184  }
5185 
5186  return data;
5187 }
5188 
5189 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5190 {
5191  int ret;
5192  const AVBitStreamFilter *bsf;
5193  AVBSFContext *bsfc;
5194  AVCodecParameters *in_par;
5195 
5196  if (!(bsf = av_bsf_get_by_name(name))) {
5197  av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5198  return AVERROR_BSF_NOT_FOUND;
5199  }
5200 
5201  if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5202  return ret;
5203 
5204  if (st->internal->nb_bsfcs) {
5205  in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5206  bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5207  } else {
5208  in_par = st->codecpar;
5209  bsfc->time_base_in = st->time_base;
5210  }
5211 
5212  if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5213  av_bsf_free(&bsfc);
5214  return ret;
5215  }
5216 
5217  if (args && bsfc->filter->priv_class) {
5218  const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5219  const char * shorthand[2] = {NULL};
5220 
5221  if (opt)
5222  shorthand[0] = opt->name;
5223 
5224  if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5225  av_bsf_free(&bsfc);
5226  return ret;
5227  }
5228  }
5229 
5230  if ((ret = av_bsf_init(bsfc)) < 0) {
5231  av_bsf_free(&bsfc);
5232  return ret;
5233  }
5234 
5235  if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5236  av_bsf_free(&bsfc);
5237  return ret;
5238  }
5239 
5241  "Automatically inserted bitstream filter '%s'; args='%s'\n",
5242  name, args ? args : "");
5243  return 1;
5244 }
5245 
5246 #if FF_API_OLD_BSF
5248 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5250 {
5251  int ret = 0;
5252  while (bsfc) {
5253  AVPacket new_pkt = *pkt;
5254  int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5255  &new_pkt.data, &new_pkt.size,
5256  pkt->data, pkt->size,
5257  pkt->flags & AV_PKT_FLAG_KEY);
5258  if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5259  av_packet_unref(pkt);
5260  memset(pkt, 0, sizeof(*pkt));
5261  return 0;
5262  }
5263  if(a == 0 && new_pkt.data != pkt->data) {
5264  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
5265  if (t) {
5266  memcpy(t, new_pkt.data, new_pkt.size);
5267  memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5268  new_pkt.data = t;
5269  new_pkt.buf = NULL;
5270  a = 1;
5271  } else {
5272  a = AVERROR(ENOMEM);
5273  }
5274  }
5275  if (a > 0) {
5276  new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5278  if (new_pkt.buf) {
5279  pkt->side_data = NULL;
5280  pkt->side_data_elems = 0;
5281  av_packet_unref(pkt);
5282  } else {
5283  av_freep(&new_pkt.data);
5284  a = AVERROR(ENOMEM);
5285  }
5286  }
5287  if (a < 0) {
5288  av_log(codec, AV_LOG_ERROR,
5289  "Failed to open bitstream filter %s for stream %d with codec %s",
5290  bsfc->filter->name, pkt->stream_index,
5291  codec->codec ? codec->codec->name : "copy");
5292  ret = a;
5293  break;
5294  }
5295  *pkt = new_pkt;
5296 
5297  bsfc = bsfc->next;
5298  }
5299  return ret;
5300 }
5302 #endif
5303 
5305 {
5306  if (!s->oformat)
5307  return AVERROR(EINVAL);
5308 
5309  if (!(s->oformat->flags & AVFMT_NOFILE))
5310  return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5311  return 0;
5312 }
5313 
5315 {
5316  if (*pb)
5317  s->io_close(s, *pb);
5318  *pb = NULL;
5319 }
5320 
5321 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5322 {
5323  AVDictionaryEntry *entry;
5324  int64_t parsed_timestamp;
5325  int ret;
5326  if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5327  if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5328  *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5329  return 1;
5330  } else {
5331  av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5332  return ret;
5333  }
5334  }
5335  return 0;
5336 }
5337 
5339 {
5340  int64_t timestamp;
5341  int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5342  if (ret == 1)
5343  return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5344  return ret;
5345 }
5346 
5347 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5348 {
5349  uint8_t *side_data;
5350  int size;
5351 
5352  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5353  if (side_data) {
5354  if (size != AVPALETTE_SIZE) {
5355  av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5356  return AVERROR_INVALIDDATA;
5357  }
5358  memcpy(palette, side_data, AVPALETTE_SIZE);
5359  return 1;
5360  }
5361 
5362  if (ret == CONTAINS_PAL) {
5363  int i;
5364  for (i = 0; i < AVPALETTE_COUNT; i++)
5365  palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5366  return 1;
5367  }
5368 
5369  return 0;
5370 }
5371 
5373 {
5374  int ret;
5375  char *str;
5376 
5377  ret = av_bprint_finalize(buf, &str);
5378  if (ret < 0)
5379  return ret;
5380  if (!av_bprint_is_complete(buf)) {
5381  av_free(str);
5382  return AVERROR(ENOMEM);
5383  }
5384 
5385  par->extradata = str;
5386  /* Note: the string is NUL terminated (so extradata can be read as a
5387  * string), but the ending character is not accounted in the size (in
5388  * binary formats you are likely not supposed to mux that character). When
5389  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5390  * zeros. */
5391  par->extradata_size = buf->len;
5392  return 0;
5393 }
5394 
5396  AVStream *ost, const AVStream *ist,
5398 {
5399  //TODO: use [io]st->internal->avctx
5400  const AVCodecContext *dec_ctx = ist->codec;
5401  AVCodecContext *enc_ctx = ost->codec;
5402 
5403  enc_ctx->time_base = ist->time_base;
5404  /*
5405  * Avi is a special case here because it supports variable fps but
5406  * having the fps and timebase differe significantly adds quite some
5407  * overhead
5408  */
5409  if (!strcmp(ofmt->name, "avi")) {
5410 #if FF_API_R_FRAME_RATE
5411  if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5412  && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5413  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5414  && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5415  && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5416  || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5417  enc_ctx->time_base.num = ist->r_frame_rate.den;
5418  enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5419  enc_ctx->ticks_per_frame = 2;
5420  } else
5421 #endif
5422  if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5423  && av_q2d(ist->time_base) < 1.0/500
5424  || copy_tb == AVFMT_TBCF_DECODER) {
5425  enc_ctx->time_base = dec_ctx->time_base;
5426  enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5427  enc_ctx->time_base.den *= 2;
5428  enc_ctx->ticks_per_frame = 2;
5429  }
5430  } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5431  && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5432  if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5433  && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5434  && av_q2d(ist->time_base) < 1.0/500
5435  || copy_tb == AVFMT_TBCF_DECODER) {
5436  enc_ctx->time_base = dec_ctx->time_base;
5437  enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5438  }
5439  }
5440 
5441  if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5442  && dec_ctx->time_base.num < dec_ctx->time_base.den
5443  && dec_ctx->time_base.num > 0
5444  && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5445  enc_ctx->time_base = dec_ctx->time_base;
5446  }
5447 
5448  if (ost->avg_frame_rate.num)
5449  enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5450 
5451  av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5452  enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5453 
5454  return 0;
5455 }
5456 
5458 {
5459  // See avformat_transfer_internal_stream_timing_info() TODO.
5460 #if FF_API_LAVF_AVCTX
5462  return st->codec->time_base;
5464 #else
5465  return st->internal->avctx->time_base;
5466 #endif
5467 }
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:4482
#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:4113
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:4359
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:2646
#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:5347
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:1981
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:2096
static void update_stream_timings(AVFormatContext *ic)
Estimate the stream timings from the one of each components.
Definition: utils.c:2561
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:3175
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:2105
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:4778
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:5304
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:1990
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:2722
#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:4686
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:2665
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:4632
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:1506
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:5321
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:2895
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:2848
#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:4801
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:2718
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:5395
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:3051
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:4822
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:4232
uint8_t * av_stream_get_side_data(const AVStream *st, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5119
#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:5338
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:2719
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:4331
char * protocol_whitelist
&#39;,&#39; separated list of allowed protocols.
Definition: avformat.h:1887
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:3309
uint32_t tag
Definition: movenc.c:1418
int avformat_network_init(void)
Do global initialization of network components.
Definition: utils.c:4713
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:3063
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:1377
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:2173
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:3974
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:5457
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:3957
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:1860
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:2090
char * ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
Definition: utils.c:4553
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:1909
int av_codec_get_tag2(const AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)
Definition: utils.c:3120
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:4038
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:4695
#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:1922
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:4602
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:4047
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:5372
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:2033
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:5135
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:1822
#define FAIL(errmsg)
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: utils.c:4389
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:2337
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:2211
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:5314
#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:4056
#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:5171
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:1895
#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:4477
#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:3214
#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:4726
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:3041
struct AVStream::@196 * info
static int64_t ts_to_samples(AVStream *st, int64_t ts)
Definition: utils.c:1501
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:3112
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:4422
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:3137
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:4574
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:4417
#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:4979
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:2404
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:4167
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:1711
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:2541
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:2471
static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
Definition: utils.c:2943
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:2448
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:3199
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:3375
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:4159
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: utils.c:3251
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:4204
#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:1393
#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:1486
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:3235
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:1808
#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:2317
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:2528
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:3148
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:5189
#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:4736
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