FFmpeg  2.6.9
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
utils.c
Go to the documentation of this file.
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdarg.h>
23 #include <stdint.h>
24 
25 #include "config.h"
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
37 
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/raw.h"
41 
42 #include "audiointerleave.h"
43 #include "avformat.h"
44 #include "avio_internal.h"
45 #include "id3v2.h"
46 #include "internal.h"
47 #include "metadata.h"
48 #if CONFIG_NETWORK
49 #include "network.h"
50 #endif
51 #include "riff.h"
52 #include "url.h"
53 
54 #include "libavutil/ffversion.h"
55 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
56 
57 /**
58  * @file
59  * various utility functions for use within FFmpeg
60  */
61 
62 unsigned avformat_version(void)
63 {
66 }
67 
68 const char *avformat_configuration(void)
69 {
70  return FFMPEG_CONFIGURATION;
71 }
72 
73 const char *avformat_license(void)
74 {
75 #define LICENSE_PREFIX "libavformat license: "
76  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
77 }
78 
79 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
80 
81 static int is_relative(int64_t ts) {
82  return ts > (RELATIVE_TS_BASE - (1LL<<48));
83 }
84 
85 /**
86  * Wrap a given time stamp, if there is an indication for an overflow
87  *
88  * @param st stream
89  * @param timestamp the time stamp to wrap
90  * @return resulting time stamp
91  */
92 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
93 {
95  st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
97  timestamp < st->pts_wrap_reference)
98  return timestamp + (1ULL << st->pts_wrap_bits);
99  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
100  timestamp >= st->pts_wrap_reference)
101  return timestamp - (1ULL << st->pts_wrap_bits);
102  }
103  return timestamp;
104 }
105 
106 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
107 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
110 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
111 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
112 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
113 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
114 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
115 
116 int64_t av_stream_get_end_pts(const AVStream *st)
117 {
118  return st->pts.val;
119 }
120 
122 {
123  return st->parser;
124 }
125 
127 {
128  int i;
130  for (i = 0; i < s->nb_streams; i++) {
131  AVStream *st = s->streams[i];
132  st->inject_global_side_data = 1;
133  }
134 }
135 
137 {
139  dst-> codec_whitelist = av_strdup(src->codec_whitelist);
141  if ( (src-> codec_whitelist && !dst-> codec_whitelist)
142  || (src->format_whitelist && !dst->format_whitelist)) {
143  av_log(dst, AV_LOG_ERROR, "Failed to duplicate whitelist\n");
144  return AVERROR(ENOMEM);
145  }
146  return 0;
147 }
148 
150 {
151  if (st->codec->codec)
152  return st->codec->codec;
153 
154  switch (st->codec->codec_type) {
155  case AVMEDIA_TYPE_VIDEO:
156  if (s->video_codec) return s->video_codec;
157  break;
158  case AVMEDIA_TYPE_AUDIO:
159  if (s->audio_codec) return s->audio_codec;
160  break;
162  if (s->subtitle_codec) return s->subtitle_codec;
163  break;
164  }
165 
166  return avcodec_find_decoder(codec_id);
167 }
168 
170 {
171  return s->probe_score;
172 }
173 
174 /* an arbitrarily chosen "sane" max packet size -- 50M */
175 #define SANE_CHUNK_SIZE (50000000)
176 
178 {
179  if (s->maxsize>= 0) {
180  int64_t remaining= s->maxsize - avio_tell(s);
181  if (remaining < size) {
182  int64_t newsize = avio_size(s);
183  if (!s->maxsize || s->maxsize<newsize)
184  s->maxsize = newsize - !newsize;
185  remaining= s->maxsize - avio_tell(s);
186  remaining= FFMAX(remaining, 0);
187  }
188 
189  if (s->maxsize>= 0 && remaining+1 < size) {
190  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
191  size = remaining+1;
192  }
193  }
194  return size;
195 }
196 
197 /* Read the data in sane-sized chunks and append to pkt.
198  * Return the number of bytes read or an error. */
200 {
201  int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
202  int orig_size = pkt->size;
203  int ret;
204 
205  do {
206  int prev_size = pkt->size;
207  int read_size;
208 
209  /* When the caller requests a lot of data, limit it to the amount
210  * left in file or SANE_CHUNK_SIZE when it is not known. */
211  read_size = size;
212  if (read_size > SANE_CHUNK_SIZE/10) {
213  read_size = ffio_limit(s, read_size);
214  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
215  if (s->maxsize < 0)
216  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
217  }
218 
219  ret = av_grow_packet(pkt, read_size);
220  if (ret < 0)
221  break;
222 
223  ret = avio_read(s, pkt->data + prev_size, read_size);
224  if (ret != read_size) {
225  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
226  break;
227  }
228 
229  size -= read_size;
230  } while (size > 0);
231  if (size > 0)
232  pkt->flags |= AV_PKT_FLAG_CORRUPT;
233 
234  pkt->pos = orig_pos;
235  if (!pkt->size)
236  av_free_packet(pkt);
237  return pkt->size > orig_size ? pkt->size - orig_size : ret;
238 }
239 
241 {
242  av_init_packet(pkt);
243  pkt->data = NULL;
244  pkt->size = 0;
245  pkt->pos = avio_tell(s);
246 
247  return append_packet_chunked(s, pkt, size);
248 }
249 
251 {
252  if (!pkt->size)
253  return av_get_packet(s, pkt, size);
254  return append_packet_chunked(s, pkt, size);
255 }
256 
257 int av_filename_number_test(const char *filename)
258 {
259  char buf[1024];
260  return filename &&
261  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
262 }
263 
265  AVProbeData *pd)
266 {
267  static const struct {
268  const char *name;
269  enum AVCodecID id;
270  enum AVMediaType type;
271  } fmt_id_type[] = {
282  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
283  { 0 }
284  };
285  int score;
286  AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
287 
288  if (fmt && st->request_probe <= score) {
289  int i;
290  av_log(s, AV_LOG_DEBUG,
291  "Probe with size=%d, packets=%d detected %s with score=%d\n",
293  fmt->name, score);
294  for (i = 0; fmt_id_type[i].name; i++) {
295  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
296  st->codec->codec_id = fmt_id_type[i].id;
297  st->codec->codec_type = fmt_id_type[i].type;
298  return score;
299  }
300  }
301  }
302  return 0;
303 }
304 
305 /************************************************************/
306 /* input media file */
307 
309  int err;
310 
311  if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
312  av_log(ic, AV_LOG_ERROR, "Format not on whitelist\n");
313  return AVERROR(EINVAL);
314  }
315 
316  if (ic->iformat->read_header) {
317  err = ic->iformat->read_header(ic);
318  if (err < 0)
319  return err;
320  }
321 
322  if (ic->pb && !ic->internal->data_offset)
323  ic->internal->data_offset = avio_tell(ic->pb);
324 
325  return 0;
326 }
327 
328 /* Open input file and probe the format if necessary. */
329 static int init_input(AVFormatContext *s, const char *filename,
331 {
332  int ret;
333  AVProbeData pd = { filename, NULL, 0 };
334  int score = AVPROBE_SCORE_RETRY;
335 
336  if (s->pb) {
338  if (!s->iformat)
339  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
340  s, 0, s->format_probesize);
341  else if (s->iformat->flags & AVFMT_NOFILE)
342  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
343  "will be ignored with AVFMT_NOFILE format.\n");
344  return 0;
345  }
346 
347  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
348  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
349  return score;
350 
351  if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
352  &s->interrupt_callback, options)) < 0)
353  return ret;
354  if (s->iformat)
355  return 0;
356  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
357  s, 0, s->format_probesize);
358 }
359 
360 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
361  AVPacketList **plast_pktl)
362 {
363  AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
364  if (!pktl)
365  return NULL;
366 
367  if (*packet_buffer)
368  (*plast_pktl)->next = pktl;
369  else
370  *packet_buffer = pktl;
371 
372  /* Add the packet in the buffered packet list. */
373  *plast_pktl = pktl;
374  pktl->pkt = *pkt;
375  return &pktl->pkt;
376 }
377 
379 {
380  int i;
381  for (i = 0; i < s->nb_streams; i++)
383  s->streams[i]->discard < AVDISCARD_ALL) {
385  if (copy.size <= 0) {
387  "Attached picture on stream %d has invalid size, "
388  "ignoring\n", i);
389  continue;
390  }
391  copy.buf = av_buffer_ref(copy.buf);
392  if (!copy.buf)
393  return AVERROR(ENOMEM);
394 
397  }
398  return 0;
399 }
400 
401 int avformat_open_input(AVFormatContext **ps, const char *filename,
403 {
404  AVFormatContext *s = *ps;
405  int ret = 0;
406  AVDictionary *tmp = NULL;
407  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
408 
409  if (!s && !(s = avformat_alloc_context()))
410  return AVERROR(ENOMEM);
411  if (!s->av_class) {
412  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
413  return AVERROR(EINVAL);
414  }
415  if (fmt)
416  s->iformat = fmt;
417 
418  if (options)
419  av_dict_copy(&tmp, *options, 0);
420 
421  if (s->pb) // must be before any goto fail
423 
424  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
425  goto fail;
426 
427  if ((ret = init_input(s, filename, &tmp)) < 0)
428  goto fail;
429  s->probe_score = ret;
430 
431  if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
432  av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
433  ret = AVERROR(EINVAL);
434  goto fail;
435  }
436 
438 
439  /* Check filename in case an image number is expected. */
440  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
441  if (!av_filename_number_test(filename)) {
442  ret = AVERROR(EINVAL);
443  goto fail;
444  }
445  }
446 
448  av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
449 
450  /* Allocate private data. */
451  if (s->iformat->priv_data_size > 0) {
452  if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
453  ret = AVERROR(ENOMEM);
454  goto fail;
455  }
456  if (s->iformat->priv_class) {
457  *(const AVClass **) s->priv_data = s->iformat->priv_class;
459  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
460  goto fail;
461  }
462  }
463 
464  /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
465  if (s->pb)
466  ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
467 
468  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
469  if ((ret = s->iformat->read_header(s)) < 0)
470  goto fail;
471 
472  if (id3v2_extra_meta) {
473  if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
474  !strcmp(s->iformat->name, "tta")) {
475  if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
476  goto fail;
477  } else
478  av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
479  }
480  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
481 
482  if ((ret = avformat_queue_attached_pictures(s)) < 0)
483  goto fail;
484 
485  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
486  s->internal->data_offset = avio_tell(s->pb);
487 
489 
490  if (options) {
491  av_dict_free(options);
492  *options = tmp;
493  }
494  *ps = s;
495  return 0;
496 
497 fail:
498  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
499  av_dict_free(&tmp);
500  if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
501  avio_closep(&s->pb);
503  *ps = NULL;
504  return ret;
505 }
506 
507 /*******************************************************/
508 
510 {
511  switch (st->codec->codec_type) {
512  case AVMEDIA_TYPE_VIDEO:
513  if (s->video_codec_id)
514  st->codec->codec_id = s->video_codec_id;
515  break;
516  case AVMEDIA_TYPE_AUDIO:
517  if (s->audio_codec_id)
518  st->codec->codec_id = s->audio_codec_id;
519  break;
521  if (s->subtitle_codec_id)
522  st->codec->codec_id = s->subtitle_codec_id;
523  break;
524  }
525 }
526 
528 {
529  if (st->request_probe>0) {
530  AVProbeData *pd = &st->probe_data;
531  int end;
532  av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
533  --st->probe_packets;
534 
535  if (pkt) {
536  uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
537  if (!new_buf) {
539  "Failed to reallocate probe buffer for stream %d\n",
540  st->index);
541  goto no_packet;
542  }
543  pd->buf = new_buf;
544  memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
545  pd->buf_size += pkt->size;
546  memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
547  } else {
548 no_packet:
549  st->probe_packets = 0;
550  if (!pd->buf_size) {
552  "nothing to probe for stream %d\n", st->index);
553  }
554  }
555 
557  || st->probe_packets<= 0;
558 
559  if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
560  int score = set_codec_from_probe_data(s, st, pd);
562  || end) {
563  pd->buf_size = 0;
564  av_freep(&pd->buf);
565  st->request_probe = -1;
566  if (st->codec->codec_id != AV_CODEC_ID_NONE) {
567  av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
568  } else
569  av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
570  }
571  force_codec_ids(s, st);
572  }
573  }
574  return 0;
575 }
576 
577 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
578 {
579  int64_t ref = pkt->dts;
580  int i, pts_wrap_behavior;
581  int64_t pts_wrap_reference;
582  AVProgram *first_program;
583 
584  if (ref == AV_NOPTS_VALUE)
585  ref = pkt->pts;
586  if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
587  return 0;
588  ref &= (1LL << st->pts_wrap_bits)-1;
589 
590  // reference time stamp should be 60 s before first time stamp
591  pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
592  // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
593  pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
594  (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
596 
597  first_program = av_find_program_from_stream(s, NULL, stream_index);
598 
599  if (!first_program) {
600  int default_stream_index = av_find_default_stream_index(s);
601  if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
602  for (i = 0; i < s->nb_streams; i++) {
604  continue;
605  s->streams[i]->pts_wrap_reference = pts_wrap_reference;
606  s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
607  }
608  }
609  else {
610  st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
611  st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
612  }
613  }
614  else {
615  AVProgram *program = first_program;
616  while (program) {
617  if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
618  pts_wrap_reference = program->pts_wrap_reference;
619  pts_wrap_behavior = program->pts_wrap_behavior;
620  break;
621  }
622  program = av_find_program_from_stream(s, program, stream_index);
623  }
624 
625  // update every program with differing pts_wrap_reference
626  program = first_program;
627  while (program) {
628  if (program->pts_wrap_reference != pts_wrap_reference) {
629  for (i = 0; i<program->nb_stream_indexes; i++) {
630  s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
631  s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
632  }
633 
634  program->pts_wrap_reference = pts_wrap_reference;
635  program->pts_wrap_behavior = pts_wrap_behavior;
636  }
637  program = av_find_program_from_stream(s, program, stream_index);
638  }
639  }
640  return 1;
641 }
642 
644 {
645  int ret, i, err;
646  AVStream *st;
647 
648  for (;;) {
650 
651  if (pktl) {
652  *pkt = pktl->pkt;
653  st = s->streams[pkt->stream_index];
655  if ((err = probe_codec(s, st, NULL)) < 0)
656  return err;
657  if (st->request_probe <= 0) {
658  s->internal->raw_packet_buffer = pktl->next;
660  av_free(pktl);
661  return 0;
662  }
663  }
664 
665  pkt->data = NULL;
666  pkt->size = 0;
667  av_init_packet(pkt);
668  ret = s->iformat->read_packet(s, pkt);
669  if (ret < 0) {
670  if (!pktl || ret == AVERROR(EAGAIN))
671  return ret;
672  for (i = 0; i < s->nb_streams; i++) {
673  st = s->streams[i];
674  if (st->probe_packets)
675  if ((err = probe_codec(s, st, NULL)) < 0)
676  return err;
677  av_assert0(st->request_probe <= 0);
678  }
679  continue;
680  }
681 
682  if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
683  (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
685  "Dropped corrupted packet (stream = %d)\n",
686  pkt->stream_index);
687  av_free_packet(pkt);
688  continue;
689  }
690 
691  if (pkt->stream_index >= (unsigned)s->nb_streams) {
692  av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
693  continue;
694  }
695 
696  st = s->streams[pkt->stream_index];
697 
699  // correct first time stamps to negative values
700  if (!is_relative(st->first_dts))
701  st->first_dts = wrap_timestamp(st, st->first_dts);
702  if (!is_relative(st->start_time))
703  st->start_time = wrap_timestamp(st, st->start_time);
704  if (!is_relative(st->cur_dts))
705  st->cur_dts = wrap_timestamp(st, st->cur_dts);
706  }
707 
708  pkt->dts = wrap_timestamp(st, pkt->dts);
709  pkt->pts = wrap_timestamp(st, pkt->pts);
710 
711  force_codec_ids(s, st);
712 
713  /* TODO: audio: time filter; video: frame reordering (pts != dts) */
715  pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
716 
717  if (!pktl && st->request_probe <= 0)
718  return ret;
719 
723 
724  if ((err = probe_codec(s, st, pkt)) < 0)
725  return err;
726  }
727 }
728 
729 
730 /**********************************************************/
731 
733 {
734  if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
735  avctx->codec_id == AV_CODEC_ID_MP1 ||
736  avctx->codec_id == AV_CODEC_ID_MP2 ||
737  avctx->codec_id == AV_CODEC_ID_MP3/* ||
738  avctx->codec_id == AV_CODEC_ID_CELT*/)
739  return 1;
740  return 0;
741 }
742 
743 /**
744  * Return the frame duration in seconds. Return 0 if not available.
745  */
746 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
748 {
749  AVRational codec_framerate = s->iformat ? st->codec->framerate :
750  av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
751  int frame_size;
752 
753  *pnum = 0;
754  *pden = 0;
755  switch (st->codec->codec_type) {
756  case AVMEDIA_TYPE_VIDEO:
757  if (st->r_frame_rate.num && !pc && s->iformat) {
758  *pnum = st->r_frame_rate.den;
759  *pden = st->r_frame_rate.num;
760  } else if (st->time_base.num * 1000LL > st->time_base.den) {
761  *pnum = st->time_base.num;
762  *pden = st->time_base.den;
763  } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
765  av_reduce(pnum, pden,
766  codec_framerate.den,
767  codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
768  INT_MAX);
769 
770  if (pc && pc->repeat_pict) {
771  av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
772  av_reduce(pnum, pden,
773  (*pnum) * (1LL + pc->repeat_pict),
774  (*pden),
775  INT_MAX);
776  }
777  /* If this codec can be interlaced or progressive then we need
778  * a parser to compute duration of a packet. Thus if we have
779  * no parser in such case leave duration undefined. */
780  if (st->codec->ticks_per_frame > 1 && !pc)
781  *pnum = *pden = 0;
782  }
783  break;
784  case AVMEDIA_TYPE_AUDIO:
785  frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
786  if (frame_size <= 0 || st->codec->sample_rate <= 0)
787  break;
788  *pnum = frame_size;
789  *pden = st->codec->sample_rate;
790  break;
791  default:
792  break;
793  }
794 }
795 
796 static int is_intra_only(AVCodecContext *enc) {
797  const AVCodecDescriptor *desc;
798 
799  if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
800  return 1;
801 
802  desc = av_codec_get_codec_descriptor(enc);
803  if (!desc) {
804  desc = avcodec_descriptor_get(enc->codec_id);
806  }
807  if (desc)
808  return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
809  return 0;
810 }
811 
813 {
814  if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
815  if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
816  return 1;
817 #if CONFIG_H264_DECODER
818  if (st->codec->has_b_frames &&
820  return 1;
821 #endif
822  if (st->codec->has_b_frames<3)
823  return st->nb_decoded_frames >= 7;
824  else if (st->codec->has_b_frames<4)
825  return st->nb_decoded_frames >= 18;
826  else
827  return st->nb_decoded_frames >= 20;
828 }
829 
831 {
832  if (pktl->next)
833  return pktl->next;
834  if (pktl == s->internal->packet_buffer_end)
835  return s->internal->parse_queue;
836  return NULL;
837 }
838 
839 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
840  int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
842 
843  if(!onein_oneout) {
844  int delay = st->codec->has_b_frames;
845  int i;
846 
847  if (dts == AV_NOPTS_VALUE) {
848  int64_t best_score = INT64_MAX;
849  for (i = 0; i<delay; i++) {
850  if (st->pts_reorder_error_count[i]) {
851  int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
852  if (score < best_score) {
853  best_score = score;
854  dts = pts_buffer[i];
855  }
856  }
857  }
858  } else {
859  for (i = 0; i<delay; i++) {
860  if (pts_buffer[i] != AV_NOPTS_VALUE) {
861  int64_t diff = FFABS(pts_buffer[i] - dts)
862  + (uint64_t)st->pts_reorder_error[i];
863  diff = FFMAX(diff, st->pts_reorder_error[i]);
864  st->pts_reorder_error[i] = diff;
865  st->pts_reorder_error_count[i]++;
866  if (st->pts_reorder_error_count[i] > 250) {
867  st->pts_reorder_error[i] >>= 1;
868  st->pts_reorder_error_count[i] >>= 1;
869  }
870  }
871  }
872  }
873  }
874 
875  if (dts == AV_NOPTS_VALUE)
876  dts = pts_buffer[0];
877 
878  return dts;
879 }
880 
881 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
882  int64_t dts, int64_t pts, AVPacket *pkt)
883 {
884  AVStream *st = s->streams[stream_index];
886  int64_t pts_buffer[MAX_REORDER_DELAY+1];
887  int64_t shift;
888  int i, delay;
889 
890  if (st->first_dts != AV_NOPTS_VALUE ||
891  dts == AV_NOPTS_VALUE ||
892  st->cur_dts == AV_NOPTS_VALUE ||
893  is_relative(dts))
894  return;
895 
896  delay = st->codec->has_b_frames;
897  st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
898  st->cur_dts = dts;
899  shift = st->first_dts - RELATIVE_TS_BASE;
900 
901  for (i = 0; i<MAX_REORDER_DELAY+1; i++)
902  pts_buffer[i] = AV_NOPTS_VALUE;
903 
904  if (is_relative(pts))
905  pts += shift;
906 
907  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
908  if (pktl->pkt.stream_index != stream_index)
909  continue;
910  if (is_relative(pktl->pkt.pts))
911  pktl->pkt.pts += shift;
912 
913  if (is_relative(pktl->pkt.dts))
914  pktl->pkt.dts += shift;
915 
916  if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
917  st->start_time = pktl->pkt.pts;
918 
919  if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
920  pts_buffer[0] = pktl->pkt.pts;
921  for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
922  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
923 
924  pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
925  }
926  }
927 
928  if (st->start_time == AV_NOPTS_VALUE)
929  st->start_time = pts;
930 }
931 
933  int stream_index, int duration)
934 {
936  int64_t cur_dts = RELATIVE_TS_BASE;
937 
938  if (st->first_dts != AV_NOPTS_VALUE) {
940  return;
942  cur_dts = st->first_dts;
943  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
944  if (pktl->pkt.stream_index == stream_index) {
945  if (pktl->pkt.pts != pktl->pkt.dts ||
946  pktl->pkt.dts != AV_NOPTS_VALUE ||
947  pktl->pkt.duration)
948  break;
949  cur_dts -= duration;
950  }
951  }
952  if (pktl && pktl->pkt.dts != st->first_dts) {
953  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
954  av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
955  return;
956  }
957  if (!pktl) {
958  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
959  return;
960  }
962  st->first_dts = cur_dts;
963  } else if (st->cur_dts != RELATIVE_TS_BASE)
964  return;
965 
966  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
967  if (pktl->pkt.stream_index != stream_index)
968  continue;
969  if (pktl->pkt.pts == pktl->pkt.dts &&
970  (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
971  !pktl->pkt.duration) {
972  pktl->pkt.dts = cur_dts;
973  if (!st->codec->has_b_frames)
974  pktl->pkt.pts = cur_dts;
975 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
976  pktl->pkt.duration = duration;
977  } else
978  break;
979  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
980  }
981  if (!pktl)
982  st->cur_dts = cur_dts;
983 }
984 
987  int64_t next_dts, int64_t next_pts)
988 {
989  int num, den, presentation_delayed, delay, i;
990  int64_t offset;
992  int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
994 
995  if (s->flags & AVFMT_FLAG_NOFILLIN)
996  return;
997 
998  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
999  if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1000  if (st->last_dts_for_order_check <= pkt->dts) {
1001  st->dts_ordered++;
1002  } else {
1004  "DTS %"PRIi64" < %"PRIi64" out of order\n",
1005  pkt->dts,
1007  st->dts_misordered++;
1008  }
1009  if (st->dts_ordered + st->dts_misordered > 250) {
1010  st->dts_ordered >>= 1;
1011  st->dts_misordered >>= 1;
1012  }
1013  }
1014 
1015  st->last_dts_for_order_check = pkt->dts;
1016  if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1017  pkt->dts = AV_NOPTS_VALUE;
1018  }
1019 
1020  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1021  pkt->dts = AV_NOPTS_VALUE;
1022 
1023  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1024  && !st->codec->has_b_frames)
1025  //FIXME Set low_delay = 0 when has_b_frames = 1
1026  st->codec->has_b_frames = 1;
1027 
1028  /* do we have a video B-frame ? */
1029  delay = st->codec->has_b_frames;
1030  presentation_delayed = 0;
1031 
1032  /* XXX: need has_b_frame, but cannot get it if the codec is
1033  * not initialized */
1034  if (delay &&
1035  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1036  presentation_delayed = 1;
1037 
1038  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1039  st->pts_wrap_bits < 63 &&
1040  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1041  if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1042  pkt->dts -= 1LL << st->pts_wrap_bits;
1043  } else
1044  pkt->pts += 1LL << st->pts_wrap_bits;
1045  }
1046 
1047  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1048  * We take the conservative approach and discard both.
1049  * Note: If this is misbehaving for an H.264 file, then possibly
1050  * presentation_delayed is not set correctly. */
1051  if (delay == 1 && pkt->dts == pkt->pts &&
1052  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1053  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1054  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1055  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1056  pkt->dts = AV_NOPTS_VALUE;
1057  }
1058 
1059  duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1060  if (pkt->duration == 0) {
1061  ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1062  if (den && num) {
1063  duration = (AVRational) {num, den};
1064  pkt->duration = av_rescale_rnd(1,
1065  num * (int64_t) st->time_base.den,
1066  den * (int64_t) st->time_base.num,
1067  AV_ROUND_DOWN);
1068  }
1069  }
1070 
1071  if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1072  update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1073 
1074  /* Correct timestamps with byte offset if demuxers only have timestamps
1075  * on packet boundaries */
1076  if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1077  /* this will estimate bitrate based on this frame's duration and size */
1078  offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1079  if (pkt->pts != AV_NOPTS_VALUE)
1080  pkt->pts += offset;
1081  if (pkt->dts != AV_NOPTS_VALUE)
1082  pkt->dts += offset;
1083  }
1084 
1085  /* This may be redundant, but it should not hurt. */
1086  if (pkt->dts != AV_NOPTS_VALUE &&
1087  pkt->pts != AV_NOPTS_VALUE &&
1088  pkt->pts > pkt->dts)
1089  presentation_delayed = 1;
1090 
1091  av_dlog(NULL,
1092  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1093  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1094  pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1095  /* Interpolate PTS and DTS if they are not present. We skip H264
1096  * currently because delay and has_b_frames are not reliably set. */
1097  if ((delay == 0 || (delay == 1 && pc)) &&
1098  onein_oneout) {
1099  if (presentation_delayed) {
1100  /* DTS = decompression timestamp */
1101  /* PTS = presentation timestamp */
1102  if (pkt->dts == AV_NOPTS_VALUE)
1103  pkt->dts = st->last_IP_pts;
1104  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1105  if (pkt->dts == AV_NOPTS_VALUE)
1106  pkt->dts = st->cur_dts;
1107 
1108  /* This is tricky: the dts must be incremented by the duration
1109  * of the frame we are displaying, i.e. the last I- or P-frame. */
1110  if (st->last_IP_duration == 0)
1111  st->last_IP_duration = pkt->duration;
1112  if (pkt->dts != AV_NOPTS_VALUE)
1113  st->cur_dts = pkt->dts + st->last_IP_duration;
1114  if (pkt->dts != AV_NOPTS_VALUE &&
1115  pkt->pts == AV_NOPTS_VALUE &&
1116  st->last_IP_duration > 0 &&
1117  ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1118  next_dts != next_pts &&
1119  next_pts != AV_NOPTS_VALUE)
1120  pkt->pts = next_dts;
1121 
1122  st->last_IP_duration = pkt->duration;
1123  st->last_IP_pts = pkt->pts;
1124  /* Cannot compute PTS if not present (we can compute it only
1125  * by knowing the future. */
1126  } else if (pkt->pts != AV_NOPTS_VALUE ||
1127  pkt->dts != AV_NOPTS_VALUE ||
1128  pkt->duration ) {
1129 
1130  /* presentation is not delayed : PTS and DTS are the same */
1131  if (pkt->pts == AV_NOPTS_VALUE)
1132  pkt->pts = pkt->dts;
1134  pkt->pts, pkt);
1135  if (pkt->pts == AV_NOPTS_VALUE)
1136  pkt->pts = st->cur_dts;
1137  pkt->dts = pkt->pts;
1138  if (pkt->pts != AV_NOPTS_VALUE)
1139  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1140  }
1141  }
1142 
1143  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1144  st->pts_buffer[0] = pkt->pts;
1145  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1146  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1147 
1148  pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1149  }
1150  // We skipped it above so we try here.
1151  if (!onein_oneout)
1152  // This should happen on the first packet
1153  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1154  if (pkt->dts > st->cur_dts)
1155  st->cur_dts = pkt->dts;
1156 
1157  av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1158  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1159 
1160  /* update flags */
1161  if (is_intra_only(st->codec))
1162  pkt->flags |= AV_PKT_FLAG_KEY;
1163  if (pc)
1165 }
1166 
1167 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1168 {
1169  while (*pkt_buf) {
1170  AVPacketList *pktl = *pkt_buf;
1171  *pkt_buf = pktl->next;
1172  av_free_packet(&pktl->pkt);
1173  av_freep(&pktl);
1174  }
1175  *pkt_buf_end = NULL;
1176 }
1177 
1178 /**
1179  * Parse a packet, add all split parts to parse_queue.
1180  *
1181  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1182  */
1183 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1184 {
1185  AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1186  AVStream *st = s->streams[stream_index];
1187  uint8_t *data = pkt ? pkt->data : NULL;
1188  int size = pkt ? pkt->size : 0;
1189  int ret = 0, got_output = 0;
1190 
1191  if (!pkt) {
1193  pkt = &flush_pkt;
1194  got_output = 1;
1195  } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1196  // preserve 0-size sync packets
1198  }
1199 
1200  while (size > 0 || (pkt == &flush_pkt && got_output)) {
1201  int len;
1202  int64_t next_pts = pkt->pts;
1203  int64_t next_dts = pkt->dts;
1204 
1205  av_init_packet(&out_pkt);
1206  len = av_parser_parse2(st->parser, st->codec,
1207  &out_pkt.data, &out_pkt.size, data, size,
1208  pkt->pts, pkt->dts, pkt->pos);
1209 
1210  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1211  pkt->pos = -1;
1212  /* increment read pointer */
1213  data += len;
1214  size -= len;
1215 
1216  got_output = !!out_pkt.size;
1217 
1218  if (!out_pkt.size)
1219  continue;
1220 
1221  if (pkt->side_data) {
1222  out_pkt.side_data = pkt->side_data;
1223  out_pkt.side_data_elems = pkt->side_data_elems;
1224  pkt->side_data = NULL;
1225  pkt->side_data_elems = 0;
1226  }
1227 
1228  /* set the duration */
1229  out_pkt.duration = 0;
1230  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1231  if (st->codec->sample_rate > 0) {
1232  out_pkt.duration =
1234  (AVRational) { 1, st->codec->sample_rate },
1235  st->time_base,
1236  AV_ROUND_DOWN);
1237  }
1238  }
1239 
1240  out_pkt.stream_index = st->index;
1241  out_pkt.pts = st->parser->pts;
1242  out_pkt.dts = st->parser->dts;
1243  out_pkt.pos = st->parser->pos;
1244 
1246  out_pkt.pos = st->parser->frame_offset;
1247 
1248  if (st->parser->key_frame == 1 ||
1249  (st->parser->key_frame == -1 &&
1251  out_pkt.flags |= AV_PKT_FLAG_KEY;
1252 
1253  if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1254  out_pkt.flags |= AV_PKT_FLAG_KEY;
1255 
1256  compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1257 
1258  if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1259  out_pkt.buf = pkt->buf;
1260  pkt->buf = NULL;
1261 #if FF_API_DESTRUCT_PACKET
1263  out_pkt.destruct = pkt->destruct;
1264  pkt->destruct = NULL;
1266 #endif
1267  }
1268  if ((ret = av_dup_packet(&out_pkt)) < 0)
1269  goto fail;
1270 
1271  if (!add_to_pktbuf(&s->internal->parse_queue, &out_pkt, &s->internal->parse_queue_end)) {
1272  av_free_packet(&out_pkt);
1273  ret = AVERROR(ENOMEM);
1274  goto fail;
1275  }
1276  }
1277 
1278  /* end of the stream => close and free the parser */
1279  if (pkt == &flush_pkt) {
1280  av_parser_close(st->parser);
1281  st->parser = NULL;
1282  }
1283 
1284 fail:
1285  av_free_packet(pkt);
1286  return ret;
1287 }
1288 
1289 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1290  AVPacketList **pkt_buffer_end,
1291  AVPacket *pkt)
1292 {
1293  AVPacketList *pktl;
1294  av_assert0(*pkt_buffer);
1295  pktl = *pkt_buffer;
1296  *pkt = pktl->pkt;
1297  *pkt_buffer = pktl->next;
1298  if (!pktl->next)
1299  *pkt_buffer_end = NULL;
1300  av_freep(&pktl);
1301  return 0;
1302 }
1303 
1304 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1305 {
1306  return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1307 }
1308 
1310 {
1311  int ret = 0, i, got_packet = 0;
1312  AVDictionary *metadata = NULL;
1313 
1314  av_init_packet(pkt);
1315 
1316  while (!got_packet && !s->internal->parse_queue) {
1317  AVStream *st;
1318  AVPacket cur_pkt;
1319 
1320  /* read next packet */
1321  ret = ff_read_packet(s, &cur_pkt);
1322  if (ret < 0) {
1323  if (ret == AVERROR(EAGAIN))
1324  return ret;
1325  /* flush the parsers */
1326  for (i = 0; i < s->nb_streams; i++) {
1327  st = s->streams[i];
1328  if (st->parser && st->need_parsing)
1329  parse_packet(s, NULL, st->index);
1330  }
1331  /* all remaining packets are now in parse_queue =>
1332  * really terminate parsing */
1333  break;
1334  }
1335  ret = 0;
1336  st = s->streams[cur_pkt.stream_index];
1337 
1338  if (cur_pkt.pts != AV_NOPTS_VALUE &&
1339  cur_pkt.dts != AV_NOPTS_VALUE &&
1340  cur_pkt.pts < cur_pkt.dts) {
1342  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1343  cur_pkt.stream_index,
1344  av_ts2str(cur_pkt.pts),
1345  av_ts2str(cur_pkt.dts),
1346  cur_pkt.size);
1347  }
1348  if (s->debug & FF_FDEBUG_TS)
1349  av_log(s, AV_LOG_DEBUG,
1350  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1351  cur_pkt.stream_index,
1352  av_ts2str(cur_pkt.pts),
1353  av_ts2str(cur_pkt.dts),
1354  cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1355 
1356  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1357  st->parser = av_parser_init(st->codec->codec_id);
1358  if (!st->parser) {
1359  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1360  "%s, packets or times may be invalid.\n",
1362  /* no parser available: just output the raw packets */
1364  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1366  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1367  st->parser->flags |= PARSER_FLAG_ONCE;
1368  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1370  }
1371 
1372  if (!st->need_parsing || !st->parser) {
1373  /* no parsing needed: we just output the packet as is */
1374  *pkt = cur_pkt;
1376  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1377  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1378  ff_reduce_index(s, st->index);
1379  av_add_index_entry(st, pkt->pos, pkt->dts,
1380  0, 0, AVINDEX_KEYFRAME);
1381  }
1382  got_packet = 1;
1383  } else if (st->discard < AVDISCARD_ALL) {
1384  if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1385  return ret;
1386  } else {
1387  /* free packet */
1388  av_free_packet(&cur_pkt);
1389  }
1390  if (pkt->flags & AV_PKT_FLAG_KEY)
1391  st->skip_to_keyframe = 0;
1392  if (st->skip_to_keyframe) {
1393  av_free_packet(&cur_pkt);
1394  if (got_packet) {
1395  *pkt = cur_pkt;
1396  }
1397  got_packet = 0;
1398  }
1399  }
1400 
1401  if (!got_packet && s->internal->parse_queue)
1403 
1404  if (ret >= 0) {
1405  AVStream *st = s->streams[pkt->stream_index];
1406  int discard_padding = 0;
1407  if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1408  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1409  int64_t sample = ts_to_samples(st, pts);
1410  int duration = ts_to_samples(st, pkt->duration);
1411  int64_t end_sample = sample + duration;
1412  if (duration > 0 && end_sample >= st->first_discard_sample &&
1413  sample < st->last_discard_sample)
1414  discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1415  }
1416  if (st->skip_samples || discard_padding) {
1418  if (p) {
1419  AV_WL32(p, st->skip_samples);
1420  AV_WL32(p + 4, discard_padding);
1421  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1422  }
1423  st->skip_samples = 0;
1424  }
1425 
1426  if (st->inject_global_side_data) {
1427  for (i = 0; i < st->nb_side_data; i++) {
1428  AVPacketSideData *src_sd = &st->side_data[i];
1429  uint8_t *dst_data;
1430 
1431  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1432  continue;
1433 
1434  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1435  if (!dst_data) {
1436  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1437  continue;
1438  }
1439 
1440  memcpy(dst_data, src_sd->data, src_sd->size);
1441  }
1442  st->inject_global_side_data = 0;
1443  }
1444 
1445  if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1447  }
1448 
1449  av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1450  if (metadata) {
1452  av_dict_copy(&s->metadata, metadata, 0);
1453  av_dict_free(&metadata);
1455  }
1456 
1457  if (s->debug & FF_FDEBUG_TS)
1458  av_log(s, AV_LOG_DEBUG,
1459  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1460  "size=%d, duration=%d, flags=%d\n",
1461  pkt->stream_index,
1462  av_ts2str(pkt->pts),
1463  av_ts2str(pkt->dts),
1464  pkt->size, pkt->duration, pkt->flags);
1465 
1466  return ret;
1467 }
1468 
1470 {
1471  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1472  int eof = 0;
1473  int ret;
1474  AVStream *st;
1475 
1476  if (!genpts) {
1477  ret = s->internal->packet_buffer
1479  &s->internal->packet_buffer_end, pkt)
1480  : read_frame_internal(s, pkt);
1481  if (ret < 0)
1482  return ret;
1483  goto return_packet;
1484  }
1485 
1486  for (;;) {
1487  AVPacketList *pktl = s->internal->packet_buffer;
1488 
1489  if (pktl) {
1490  AVPacket *next_pkt = &pktl->pkt;
1491 
1492  if (next_pkt->dts != AV_NOPTS_VALUE) {
1493  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1494  // last dts seen for this stream. if any of packets following
1495  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1496  int64_t last_dts = next_pkt->dts;
1497  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1498  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1499  (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1500  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1501  // not B-frame
1502  next_pkt->pts = pktl->pkt.dts;
1503  }
1504  if (last_dts != AV_NOPTS_VALUE) {
1505  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1506  last_dts = pktl->pkt.dts;
1507  }
1508  }
1509  pktl = pktl->next;
1510  }
1511  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1512  // Fixing the last reference frame had none pts issue (For MXF etc).
1513  // We only do this when
1514  // 1. eof.
1515  // 2. we are not able to resolve a pts value for current packet.
1516  // 3. the packets for this stream at the end of the files had valid dts.
1517  next_pkt->pts = last_dts + next_pkt->duration;
1518  }
1519  pktl = s->internal->packet_buffer;
1520  }
1521 
1522  /* read packet from packet buffer, if there is data */
1523  st = s->streams[next_pkt->stream_index];
1524  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1525  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1527  &s->internal->packet_buffer_end, pkt);
1528  goto return_packet;
1529  }
1530  }
1531 
1532  ret = read_frame_internal(s, pkt);
1533  if (ret < 0) {
1534  if (pktl && ret != AVERROR(EAGAIN)) {
1535  eof = 1;
1536  continue;
1537  } else
1538  return ret;
1539  }
1540 
1542  &s->internal->packet_buffer_end)) < 0)
1543  return AVERROR(ENOMEM);
1544  }
1545 
1546 return_packet:
1547 
1548  st = s->streams[pkt->stream_index];
1549  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1550  ff_reduce_index(s, st->index);
1551  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1552  }
1553 
1554  if (is_relative(pkt->dts))
1555  pkt->dts -= RELATIVE_TS_BASE;
1556  if (is_relative(pkt->pts))
1557  pkt->pts -= RELATIVE_TS_BASE;
1558 
1559  return ret;
1560 }
1561 
1562 /* XXX: suppress the packet queue */
1564 {
1565  if (!s->internal)
1566  return;
1570 
1572 }
1573 
1574 /*******************************************************/
1575 /* seek support */
1576 
1578 {
1579  int i;
1580  AVStream *st;
1581  int best_stream = 0;
1582  int best_score = -1;
1583 
1584  if (s->nb_streams <= 0)
1585  return -1;
1586  for (i = 0; i < s->nb_streams; i++) {
1587  int score = 0;
1588  st = s->streams[i];
1589  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1591  if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1592  score += 25;
1593  else
1594  score += 100;
1595  }
1596  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1597  if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1598  score += 12;
1599  else
1600  score += 50;
1601  }
1602 
1603  if (st->discard != AVDISCARD_ALL)
1604  score += 200;
1605 
1606  if (score > best_score) {
1607  best_score = score;
1608  best_stream = i;
1609  }
1610  }
1611  return best_stream;
1612 }
1613 
1614 /** Flush the frame reader. */
1616 {
1617  AVStream *st;
1618  int i, j;
1619 
1620  flush_packet_queue(s);
1621 
1622  /* Reset read state for each stream. */
1623  for (i = 0; i < s->nb_streams; i++) {
1624  st = s->streams[i];
1625 
1626  if (st->parser) {
1627  av_parser_close(st->parser);
1628  st->parser = NULL;
1629  }
1632  if (st->first_dts == AV_NOPTS_VALUE)
1633  st->cur_dts = RELATIVE_TS_BASE;
1634  else
1635  /* We set the current DTS to an unspecified origin. */
1636  st->cur_dts = AV_NOPTS_VALUE;
1637 
1639 
1640  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1641  st->pts_buffer[j] = AV_NOPTS_VALUE;
1642 
1644  st->inject_global_side_data = 1;
1645  }
1646 }
1647 
1648 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1649 {
1650  int i;
1651 
1652  for (i = 0; i < s->nb_streams; i++) {
1653  AVStream *st = s->streams[i];
1654 
1655  st->cur_dts =
1656  av_rescale(timestamp,
1657  st->time_base.den * (int64_t) ref_st->time_base.num,
1658  st->time_base.num * (int64_t) ref_st->time_base.den);
1659  }
1660 }
1661 
1662 void ff_reduce_index(AVFormatContext *s, int stream_index)
1663 {
1664  AVStream *st = s->streams[stream_index];
1665  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1666 
1667  if ((unsigned) st->nb_index_entries >= max_entries) {
1668  int i;
1669  for (i = 0; 2 * i < st->nb_index_entries; i++)
1670  st->index_entries[i] = st->index_entries[2 * i];
1671  st->nb_index_entries = i;
1672  }
1673 }
1674 
1675 int ff_add_index_entry(AVIndexEntry **index_entries,
1676  int *nb_index_entries,
1677  unsigned int *index_entries_allocated_size,
1678  int64_t pos, int64_t timestamp,
1679  int size, int distance, int flags)
1680 {
1681  AVIndexEntry *entries, *ie;
1682  int index;
1683 
1684  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1685  return -1;
1686 
1687  if (timestamp == AV_NOPTS_VALUE)
1688  return AVERROR(EINVAL);
1689 
1690  if (size < 0 || size > 0x3FFFFFFF)
1691  return AVERROR(EINVAL);
1692 
1693  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1694  timestamp -= RELATIVE_TS_BASE;
1695 
1696  entries = av_fast_realloc(*index_entries,
1697  index_entries_allocated_size,
1698  (*nb_index_entries + 1) *
1699  sizeof(AVIndexEntry));
1700  if (!entries)
1701  return -1;
1702 
1703  *index_entries = entries;
1704 
1705  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1706  timestamp, AVSEEK_FLAG_ANY);
1707 
1708  if (index < 0) {
1709  index = (*nb_index_entries)++;
1710  ie = &entries[index];
1711  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1712  } else {
1713  ie = &entries[index];
1714  if (ie->timestamp != timestamp) {
1715  if (ie->timestamp <= timestamp)
1716  return -1;
1717  memmove(entries + index + 1, entries + index,
1718  sizeof(AVIndexEntry) * (*nb_index_entries - index));
1719  (*nb_index_entries)++;
1720  } else if (ie->pos == pos && distance < ie->min_distance)
1721  // do not reduce the distance
1722  distance = ie->min_distance;
1723  }
1724 
1725  ie->pos = pos;
1726  ie->timestamp = timestamp;
1727  ie->min_distance = distance;
1728  ie->size = size;
1729  ie->flags = flags;
1730 
1731  return index;
1732 }
1733 
1734 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1735  int size, int distance, int flags)
1736 {
1737  timestamp = wrap_timestamp(st, timestamp);
1739  &st->index_entries_allocated_size, pos,
1740  timestamp, size, distance, flags);
1741 }
1742 
1743 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1744  int64_t wanted_timestamp, int flags)
1745 {
1746  int a, b, m;
1747  int64_t timestamp;
1748 
1749  a = -1;
1750  b = nb_entries;
1751 
1752  // Optimize appending index entries at the end.
1753  if (b && entries[b - 1].timestamp < wanted_timestamp)
1754  a = b - 1;
1755 
1756  while (b - a > 1) {
1757  m = (a + b) >> 1;
1758  timestamp = entries[m].timestamp;
1759  if (timestamp >= wanted_timestamp)
1760  b = m;
1761  if (timestamp <= wanted_timestamp)
1762  a = m;
1763  }
1764  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1765 
1766  if (!(flags & AVSEEK_FLAG_ANY))
1767  while (m >= 0 && m < nb_entries &&
1768  !(entries[m].flags & AVINDEX_KEYFRAME))
1769  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1770 
1771  if (m == nb_entries)
1772  return -1;
1773  return m;
1774 }
1775 
1776 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1777 {
1779  wanted_timestamp, flags);
1780 }
1781 
1782 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1783  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1784 {
1785  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1786  if (stream_index >= 0)
1787  ts = wrap_timestamp(s->streams[stream_index], ts);
1788  return ts;
1789 }
1790 
1791 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1792  int64_t target_ts, int flags)
1793 {
1794  AVInputFormat *avif = s->iformat;
1795  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1796  int64_t ts_min, ts_max, ts;
1797  int index;
1798  int64_t ret;
1799  AVStream *st;
1800 
1801  if (stream_index < 0)
1802  return -1;
1803 
1804  av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1805 
1806  ts_max =
1807  ts_min = AV_NOPTS_VALUE;
1808  pos_limit = -1; // GCC falsely says it may be uninitialized.
1809 
1810  st = s->streams[stream_index];
1811  if (st->index_entries) {
1812  AVIndexEntry *e;
1813 
1814  /* FIXME: Whole function must be checked for non-keyframe entries in
1815  * index case, especially read_timestamp(). */
1816  index = av_index_search_timestamp(st, target_ts,
1817  flags | AVSEEK_FLAG_BACKWARD);
1818  index = FFMAX(index, 0);
1819  e = &st->index_entries[index];
1820 
1821  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1822  pos_min = e->pos;
1823  ts_min = e->timestamp;
1824  av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1825  pos_min, av_ts2str(ts_min));
1826  } else {
1827  av_assert1(index == 0);
1828  }
1829 
1830  index = av_index_search_timestamp(st, target_ts,
1831  flags & ~AVSEEK_FLAG_BACKWARD);
1832  av_assert0(index < st->nb_index_entries);
1833  if (index >= 0) {
1834  e = &st->index_entries[index];
1835  av_assert1(e->timestamp >= target_ts);
1836  pos_max = e->pos;
1837  ts_max = e->timestamp;
1838  pos_limit = pos_max - e->min_distance;
1839  av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1840  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1841  }
1842  }
1843 
1844  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1845  ts_min, ts_max, flags, &ts, avif->read_timestamp);
1846  if (pos < 0)
1847  return -1;
1848 
1849  /* do the seek */
1850  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1851  return ret;
1852 
1854  ff_update_cur_dts(s, st, ts);
1855 
1856  return 0;
1857 }
1858 
1859 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1860  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1861 {
1862  int64_t step = 1024;
1863  int64_t limit, ts_max;
1864  int64_t filesize = avio_size(s->pb);
1865  int64_t pos_max = filesize - 1;
1866  do {
1867  limit = pos_max;
1868  pos_max = FFMAX(0, (pos_max) - step);
1869  ts_max = ff_read_timestamp(s, stream_index,
1870  &pos_max, limit, read_timestamp);
1871  step += step;
1872  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1873  if (ts_max == AV_NOPTS_VALUE)
1874  return -1;
1875 
1876  for (;;) {
1877  int64_t tmp_pos = pos_max + 1;
1878  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1879  &tmp_pos, INT64_MAX, read_timestamp);
1880  if (tmp_ts == AV_NOPTS_VALUE)
1881  break;
1882  av_assert0(tmp_pos > pos_max);
1883  ts_max = tmp_ts;
1884  pos_max = tmp_pos;
1885  if (tmp_pos >= filesize)
1886  break;
1887  }
1888 
1889  if (ts)
1890  *ts = ts_max;
1891  if (pos)
1892  *pos = pos_max;
1893 
1894  return 0;
1895 }
1896 
1897 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1898  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1899  int64_t ts_min, int64_t ts_max,
1900  int flags, int64_t *ts_ret,
1901  int64_t (*read_timestamp)(struct AVFormatContext *, int,
1902  int64_t *, int64_t))
1903 {
1904  int64_t pos, ts;
1905  int64_t start_pos;
1906  int no_change;
1907  int ret;
1908 
1909  av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1910 
1911  if (ts_min == AV_NOPTS_VALUE) {
1912  pos_min = s->internal->data_offset;
1913  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1914  if (ts_min == AV_NOPTS_VALUE)
1915  return -1;
1916  }
1917 
1918  if (ts_min >= target_ts) {
1919  *ts_ret = ts_min;
1920  return pos_min;
1921  }
1922 
1923  if (ts_max == AV_NOPTS_VALUE) {
1924  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1925  return ret;
1926  pos_limit = pos_max;
1927  }
1928 
1929  if (ts_max <= target_ts) {
1930  *ts_ret = ts_max;
1931  return pos_max;
1932  }
1933 
1934  av_assert0(ts_min < ts_max);
1935 
1936  no_change = 0;
1937  while (pos_min < pos_limit) {
1938  av_dlog(s,
1939  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1940  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1941  av_assert0(pos_limit <= pos_max);
1942 
1943  if (no_change == 0) {
1944  int64_t approximate_keyframe_distance = pos_max - pos_limit;
1945  // interpolate position (better than dichotomy)
1946  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1947  ts_max - ts_min) +
1948  pos_min - approximate_keyframe_distance;
1949  } else if (no_change == 1) {
1950  // bisection if interpolation did not change min / max pos last time
1951  pos = (pos_min + pos_limit) >> 1;
1952  } else {
1953  /* linear search if bisection failed, can only happen if there
1954  * are very few or no keyframes between min/max */
1955  pos = pos_min;
1956  }
1957  if (pos <= pos_min)
1958  pos = pos_min + 1;
1959  else if (pos > pos_limit)
1960  pos = pos_limit;
1961  start_pos = pos;
1962 
1963  // May pass pos_limit instead of -1.
1964  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1965  if (pos == pos_max)
1966  no_change++;
1967  else
1968  no_change = 0;
1969  av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1970  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1971  pos_min, pos, pos_max,
1972  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1973  pos_limit, start_pos, no_change);
1974  if (ts == AV_NOPTS_VALUE) {
1975  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1976  return -1;
1977  }
1978  if (target_ts <= ts) {
1979  pos_limit = start_pos - 1;
1980  pos_max = pos;
1981  ts_max = ts;
1982  }
1983  if (target_ts >= ts) {
1984  pos_min = pos;
1985  ts_min = ts;
1986  }
1987  }
1988 
1989  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1990  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1991 #if 0
1992  pos_min = pos;
1993  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1994  pos_min++;
1995  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1996  av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1997  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1998 #endif
1999  *ts_ret = ts;
2000  return pos;
2001 }
2002 
2003 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2004  int64_t pos, int flags)
2005 {
2006  int64_t pos_min, pos_max;
2007 
2008  pos_min = s->internal->data_offset;
2009  pos_max = avio_size(s->pb) - 1;
2010 
2011  if (pos < pos_min)
2012  pos = pos_min;
2013  else if (pos > pos_max)
2014  pos = pos_max;
2015 
2016  avio_seek(s->pb, pos, SEEK_SET);
2017 
2018  s->io_repositioned = 1;
2019 
2020  return 0;
2021 }
2022 
2023 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2024  int64_t timestamp, int flags)
2025 {
2026  int index;
2027  int64_t ret;
2028  AVStream *st;
2029  AVIndexEntry *ie;
2030 
2031  st = s->streams[stream_index];
2032 
2033  index = av_index_search_timestamp(st, timestamp, flags);
2034 
2035  if (index < 0 && st->nb_index_entries &&
2036  timestamp < st->index_entries[0].timestamp)
2037  return -1;
2038 
2039  if (index < 0 || index == st->nb_index_entries - 1) {
2040  AVPacket pkt;
2041  int nonkey = 0;
2042 
2043  if (st->nb_index_entries) {
2045  ie = &st->index_entries[st->nb_index_entries - 1];
2046  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2047  return ret;
2048  ff_update_cur_dts(s, st, ie->timestamp);
2049  } else {
2050  if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2051  return ret;
2052  }
2053  for (;;) {
2054  int read_status;
2055  do {
2056  read_status = av_read_frame(s, &pkt);
2057  } while (read_status == AVERROR(EAGAIN));
2058  if (read_status < 0)
2059  break;
2060  av_free_packet(&pkt);
2061  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2062  if (pkt.flags & AV_PKT_FLAG_KEY)
2063  break;
2064  if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2065  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);
2066  break;
2067  }
2068  }
2069  }
2070  index = av_index_search_timestamp(st, timestamp, flags);
2071  }
2072  if (index < 0)
2073  return -1;
2074 
2076  if (s->iformat->read_seek)
2077  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2078  return 0;
2079  ie = &st->index_entries[index];
2080  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2081  return ret;
2082  ff_update_cur_dts(s, st, ie->timestamp);
2083 
2084  return 0;
2085 }
2086 
2087 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2088  int64_t timestamp, int flags)
2089 {
2090  int ret;
2091  AVStream *st;
2092 
2093  if (flags & AVSEEK_FLAG_BYTE) {
2094  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2095  return -1;
2097  return seek_frame_byte(s, stream_index, timestamp, flags);
2098  }
2099 
2100  if (stream_index < 0) {
2101  stream_index = av_find_default_stream_index(s);
2102  if (stream_index < 0)
2103  return -1;
2104 
2105  st = s->streams[stream_index];
2106  /* timestamp for default must be expressed in AV_TIME_BASE units */
2107  timestamp = av_rescale(timestamp, st->time_base.den,
2108  AV_TIME_BASE * (int64_t) st->time_base.num);
2109  }
2110 
2111  /* first, we try the format specific seek */
2112  if (s->iformat->read_seek) {
2114  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2115  } else
2116  ret = -1;
2117  if (ret >= 0)
2118  return 0;
2119 
2120  if (s->iformat->read_timestamp &&
2121  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2123  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2124  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2126  return seek_frame_generic(s, stream_index, timestamp, flags);
2127  } else
2128  return -1;
2129 }
2130 
2131 int av_seek_frame(AVFormatContext *s, int stream_index,
2132  int64_t timestamp, int flags)
2133 {
2134  int ret;
2135 
2136  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2137  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2138  if ((flags & AVSEEK_FLAG_BACKWARD))
2139  max_ts = timestamp;
2140  else
2141  min_ts = timestamp;
2142  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2143  flags & ~AVSEEK_FLAG_BACKWARD);
2144  }
2145 
2146  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2147 
2148  if (ret >= 0)
2150 
2151  return ret;
2152 }
2153 
2154 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2155  int64_t ts, int64_t max_ts, int flags)
2156 {
2157  if (min_ts > ts || max_ts < ts)
2158  return -1;
2159  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2160  return AVERROR(EINVAL);
2161 
2162  if (s->seek2any>0)
2163  flags |= AVSEEK_FLAG_ANY;
2164  flags &= ~AVSEEK_FLAG_BACKWARD;
2165 
2166  if (s->iformat->read_seek2) {
2167  int ret;
2169 
2170  if (stream_index == -1 && s->nb_streams == 1) {
2171  AVRational time_base = s->streams[0]->time_base;
2172  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2173  min_ts = av_rescale_rnd(min_ts, time_base.den,
2174  time_base.num * (int64_t)AV_TIME_BASE,
2176  max_ts = av_rescale_rnd(max_ts, time_base.den,
2177  time_base.num * (int64_t)AV_TIME_BASE,
2179  }
2180 
2181  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2182  ts, max_ts, flags);
2183 
2184  if (ret >= 0)
2186  return ret;
2187  }
2188 
2189  if (s->iformat->read_timestamp) {
2190  // try to seek via read_timestamp()
2191  }
2192 
2193  // Fall back on old API if new is not implemented but old is.
2194  // Note the old API has somewhat different semantics.
2195  if (s->iformat->read_seek || 1) {
2196  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2197  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2198  if (ret<0 && ts != min_ts && max_ts != ts) {
2199  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2200  if (ret >= 0)
2201  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2202  }
2203  return ret;
2204  }
2205 
2206  // try some generic seek like seek_frame_generic() but with new ts semantics
2207  return -1; //unreachable
2208 }
2209 
2211 {
2213  return 0;
2214 }
2215 
2216 /*******************************************************/
2217 
2218 /**
2219  * Return TRUE if the stream has accurate duration in any stream.
2220  *
2221  * @return TRUE if the stream has accurate duration for at least one component.
2222  */
2224 {
2225  int i;
2226  AVStream *st;
2227 
2228  for (i = 0; i < ic->nb_streams; i++) {
2229  st = ic->streams[i];
2230  if (st->duration != AV_NOPTS_VALUE)
2231  return 1;
2232  }
2233  if (ic->duration != AV_NOPTS_VALUE)
2234  return 1;
2235  return 0;
2236 }
2237 
2238 /**
2239  * Estimate the stream timings from the one of each components.
2240  *
2241  * Also computes the global bitrate if possible.
2242  */
2244 {
2245  int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2246  int64_t duration, duration1, filesize;
2247  int i;
2248  AVStream *st;
2249  AVProgram *p;
2250 
2251  start_time = INT64_MAX;
2252  start_time_text = INT64_MAX;
2253  end_time = INT64_MIN;
2254  duration = INT64_MIN;
2255  for (i = 0; i < ic->nb_streams; i++) {
2256  st = ic->streams[i];
2257  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2258  start_time1 = av_rescale_q(st->start_time, st->time_base,
2259  AV_TIME_BASE_Q);
2261  if (start_time1 < start_time_text)
2262  start_time_text = start_time1;
2263  } else
2264  start_time = FFMIN(start_time, start_time1);
2265  end_time1 = AV_NOPTS_VALUE;
2266  if (st->duration != AV_NOPTS_VALUE) {
2267  end_time1 = start_time1 +
2268  av_rescale_q(st->duration, st->time_base,
2269  AV_TIME_BASE_Q);
2270  end_time = FFMAX(end_time, end_time1);
2271  }
2272  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2273  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2274  p->start_time = start_time1;
2275  if (p->end_time < end_time1)
2276  p->end_time = end_time1;
2277  }
2278  }
2279  if (st->duration != AV_NOPTS_VALUE) {
2280  duration1 = av_rescale_q(st->duration, st->time_base,
2281  AV_TIME_BASE_Q);
2282  duration = FFMAX(duration, duration1);
2283  }
2284  }
2285  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2286  start_time = start_time_text;
2287  else if (start_time > start_time_text)
2288  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2289 
2290  if (start_time != INT64_MAX) {
2291  ic->start_time = start_time;
2292  if (end_time != INT64_MIN) {
2293  if (ic->nb_programs) {
2294  for (i = 0; i < ic->nb_programs; i++) {
2295  p = ic->programs[i];
2296  if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2297  duration = FFMAX(duration, p->end_time - p->start_time);
2298  }
2299  } else
2300  duration = FFMAX(duration, end_time - start_time);
2301  }
2302  }
2303  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2304  ic->duration = duration;
2305  }
2306  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2307  /* compute the bitrate */
2308  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2309  (double) ic->duration;
2310  if (bitrate >= 0 && bitrate <= INT_MAX)
2311  ic->bit_rate = bitrate;
2312  }
2313 }
2314 
2316 {
2317  int i;
2318  AVStream *st;
2319 
2321  for (i = 0; i < ic->nb_streams; i++) {
2322  st = ic->streams[i];
2323  if (st->start_time == AV_NOPTS_VALUE) {
2324  if (ic->start_time != AV_NOPTS_VALUE)
2326  st->time_base);
2327  if (ic->duration != AV_NOPTS_VALUE)
2329  st->time_base);
2330  }
2331  }
2332 }
2333 
2335 {
2336  int64_t filesize, duration;
2337  int i, show_warning = 0;
2338  AVStream *st;
2339 
2340  /* if bit_rate is already set, we believe it */
2341  if (ic->bit_rate <= 0) {
2342  int bit_rate = 0;
2343  for (i = 0; i < ic->nb_streams; i++) {
2344  st = ic->streams[i];
2345  if (st->codec->bit_rate > 0) {
2346  if (INT_MAX - st->codec->bit_rate < bit_rate) {
2347  bit_rate = 0;
2348  break;
2349  }
2350  bit_rate += st->codec->bit_rate;
2351  } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2352  // If we have a videostream with packets but without a bitrate
2353  // then consider the sum not known
2354  bit_rate = 0;
2355  break;
2356  }
2357  }
2358  ic->bit_rate = bit_rate;
2359  }
2360 
2361  /* if duration is already set, we believe it */
2362  if (ic->duration == AV_NOPTS_VALUE &&
2363  ic->bit_rate != 0) {
2364  filesize = ic->pb ? avio_size(ic->pb) : 0;
2365  if (filesize > ic->internal->data_offset) {
2366  filesize -= ic->internal->data_offset;
2367  for (i = 0; i < ic->nb_streams; i++) {
2368  st = ic->streams[i];
2369  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2370  && st->duration == AV_NOPTS_VALUE) {
2371  duration = av_rescale(8 * filesize, st->time_base.den,
2372  ic->bit_rate *
2373  (int64_t) st->time_base.num);
2374  st->duration = duration;
2375  show_warning = 1;
2376  }
2377  }
2378  }
2379  }
2380  if (show_warning)
2381  av_log(ic, AV_LOG_WARNING,
2382  "Estimating duration from bitrate, this may be inaccurate\n");
2383 }
2384 
2385 #define DURATION_MAX_READ_SIZE 250000LL
2386 #define DURATION_MAX_RETRY 6
2387 
2388 /* only usable for MPEG-PS streams */
2389 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2390 {
2391  AVPacket pkt1, *pkt = &pkt1;
2392  AVStream *st;
2393  int num, den, read_size, i, ret;
2394  int found_duration = 0;
2395  int is_end;
2396  int64_t filesize, offset, duration;
2397  int retry = 0;
2398 
2399  /* flush packet queue */
2400  flush_packet_queue(ic);
2401 
2402  for (i = 0; i < ic->nb_streams; i++) {
2403  st = ic->streams[i];
2404  if (st->start_time == AV_NOPTS_VALUE &&
2405  st->first_dts == AV_NOPTS_VALUE &&
2408  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2409 
2410  if (st->parser) {
2411  av_parser_close(st->parser);
2412  st->parser = NULL;
2413  }
2414  }
2415 
2416  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2417  /* estimate the end time (duration) */
2418  /* XXX: may need to support wrapping */
2419  filesize = ic->pb ? avio_size(ic->pb) : 0;
2420  do {
2421  is_end = found_duration;
2422  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2423  if (offset < 0)
2424  offset = 0;
2425 
2426  avio_seek(ic->pb, offset, SEEK_SET);
2427  read_size = 0;
2428  for (;;) {
2429  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2430  break;
2431 
2432  do {
2433  ret = ff_read_packet(ic, pkt);
2434  } while (ret == AVERROR(EAGAIN));
2435  if (ret != 0)
2436  break;
2437  read_size += pkt->size;
2438  st = ic->streams[pkt->stream_index];
2439  if (pkt->pts != AV_NOPTS_VALUE &&
2440  (st->start_time != AV_NOPTS_VALUE ||
2441  st->first_dts != AV_NOPTS_VALUE)) {
2442  if (pkt->duration == 0) {
2443  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2444  if (den && num) {
2445  pkt->duration = av_rescale_rnd(1,
2446  num * (int64_t) st->time_base.den,
2447  den * (int64_t) st->time_base.num,
2448  AV_ROUND_DOWN);
2449  }
2450  }
2451  duration = pkt->pts + pkt->duration;
2452  found_duration = 1;
2453  if (st->start_time != AV_NOPTS_VALUE)
2454  duration -= st->start_time;
2455  else
2456  duration -= st->first_dts;
2457  if (duration > 0) {
2458  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2459  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2460  st->duration = duration;
2461  st->info->last_duration = duration;
2462  }
2463  }
2464  av_free_packet(pkt);
2465  }
2466 
2467  /* check if all audio/video streams have valid duration */
2468  if (!is_end) {
2469  is_end = 1;
2470  for (i = 0; i < ic->nb_streams; i++) {
2471  st = ic->streams[i];
2472  switch (st->codec->codec_type) {
2473  case AVMEDIA_TYPE_VIDEO:
2474  case AVMEDIA_TYPE_AUDIO:
2475  if (st->duration == AV_NOPTS_VALUE)
2476  is_end = 0;
2477  }
2478  }
2479  }
2480  } while (!is_end &&
2481  offset &&
2482  ++retry <= DURATION_MAX_RETRY);
2483 
2484  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2485 
2486  /* warn about audio/video streams which duration could not be estimated */
2487  for (i = 0; i < ic->nb_streams; i++) {
2488  st = ic->streams[i];
2489  if (st->duration == AV_NOPTS_VALUE) {
2490  switch (st->codec->codec_type) {
2491  case AVMEDIA_TYPE_VIDEO:
2492  case AVMEDIA_TYPE_AUDIO:
2493  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2494  av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2495  } else
2496  av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2497  }
2498  }
2499  }
2501 
2502  avio_seek(ic->pb, old_offset, SEEK_SET);
2503  for (i = 0; i < ic->nb_streams; i++) {
2504  int j;
2505 
2506  st = ic->streams[i];
2507  st->cur_dts = st->first_dts;
2510  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2511  st->pts_buffer[j] = AV_NOPTS_VALUE;
2512  }
2513 }
2514 
2515 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2516 {
2517  int64_t file_size;
2518 
2519  /* get the file size, if possible */
2520  if (ic->iformat->flags & AVFMT_NOFILE) {
2521  file_size = 0;
2522  } else {
2523  file_size = avio_size(ic->pb);
2524  file_size = FFMAX(0, file_size);
2525  }
2526 
2527  if ((!strcmp(ic->iformat->name, "mpeg") ||
2528  !strcmp(ic->iformat->name, "mpegts")) &&
2529  file_size && ic->pb->seekable) {
2530  /* get accurate estimate from the PTSes */
2531  estimate_timings_from_pts(ic, old_offset);
2533  } else if (has_duration(ic)) {
2534  /* at least one component has timings - we use them for all
2535  * the components */
2538  } else {
2539  /* less precise: use bitrate info */
2542  }
2544 
2545  {
2546  int i;
2547  AVStream av_unused *st;
2548  for (i = 0; i < ic->nb_streams; i++) {
2549  st = ic->streams[i];
2550  av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2551  (double) st->start_time / AV_TIME_BASE,
2552  (double) st->duration / AV_TIME_BASE);
2553  }
2554  av_dlog(ic,
2555  "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2556  (double) ic->start_time / AV_TIME_BASE,
2557  (double) ic->duration / AV_TIME_BASE,
2558  ic->bit_rate / 1000);
2559  }
2560 }
2561 
2562 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2563 {
2564  AVCodecContext *avctx = st->codec;
2565 
2566 #define FAIL(errmsg) do { \
2567  if (errmsg_ptr) \
2568  *errmsg_ptr = errmsg; \
2569  return 0; \
2570  } while (0)
2571 
2572  if ( avctx->codec_id == AV_CODEC_ID_NONE
2573  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2574  FAIL("unknown codec");
2575  switch (avctx->codec_type) {
2576  case AVMEDIA_TYPE_AUDIO:
2577  if (!avctx->frame_size && determinable_frame_size(avctx))
2578  FAIL("unspecified frame size");
2579  if (st->info->found_decoder >= 0 &&
2580  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2581  FAIL("unspecified sample format");
2582  if (!avctx->sample_rate)
2583  FAIL("unspecified sample rate");
2584  if (!avctx->channels)
2585  FAIL("unspecified number of channels");
2586  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2587  FAIL("no decodable DTS frames");
2588  break;
2589  case AVMEDIA_TYPE_VIDEO:
2590  if (!avctx->width)
2591  FAIL("unspecified size");
2592  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2593  FAIL("unspecified pixel format");
2596  FAIL("no frame in rv30/40 and no sar");
2597  break;
2598  case AVMEDIA_TYPE_SUBTITLE:
2599  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2600  FAIL("unspecified size");
2601  break;
2602  case AVMEDIA_TYPE_DATA:
2603  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2604  }
2605 
2606  return 1;
2607 }
2608 
2609 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2612 {
2613  const AVCodec *codec;
2614  int got_picture = 1, ret = 0;
2616  AVSubtitle subtitle;
2617  AVPacket pkt = *avpkt;
2618 
2619  if (!frame)
2620  return AVERROR(ENOMEM);
2621 
2622  if (!avcodec_is_open(st->codec) &&
2623  st->info->found_decoder <= 0 &&
2624  (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2625  AVDictionary *thread_opt = NULL;
2626 
2627  codec = find_decoder(s, st, st->codec->codec_id);
2628 
2629  if (!codec) {
2630  st->info->found_decoder = -st->codec->codec_id;
2631  ret = -1;
2632  goto fail;
2633  }
2634 
2635  /* Force thread count to 1 since the H.264 decoder will not extract
2636  * SPS and PPS to extradata during multi-threaded decoding. */
2637  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2638  if (s->codec_whitelist)
2639  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2640  ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2641  if (!options)
2642  av_dict_free(&thread_opt);
2643  if (ret < 0) {
2644  st->info->found_decoder = -st->codec->codec_id;
2645  goto fail;
2646  }
2647  st->info->found_decoder = 1;
2648  } else if (!st->info->found_decoder)
2649  st->info->found_decoder = 1;
2650 
2651  if (st->info->found_decoder < 0) {
2652  ret = -1;
2653  goto fail;
2654  }
2655 
2656  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2657  ret >= 0 &&
2659  (!st->codec_info_nb_frames &&
2661  got_picture = 0;
2662  switch (st->codec->codec_type) {
2663  case AVMEDIA_TYPE_VIDEO:
2664  ret = avcodec_decode_video2(st->codec, frame,
2665  &got_picture, &pkt);
2666  break;
2667  case AVMEDIA_TYPE_AUDIO:
2668  ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2669  break;
2670  case AVMEDIA_TYPE_SUBTITLE:
2671  ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2672  &got_picture, &pkt);
2673  ret = pkt.size;
2674  break;
2675  default:
2676  break;
2677  }
2678  if (ret >= 0) {
2679  if (got_picture)
2680  st->nb_decoded_frames++;
2681  pkt.data += ret;
2682  pkt.size -= ret;
2683  ret = got_picture;
2684  }
2685  }
2686 
2687  if (!pkt.data && !got_picture)
2688  ret = -1;
2689 
2690 fail:
2691  av_frame_free(&frame);
2692  return ret;
2693 }
2694 
2695 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2696 {
2697  while (tags->id != AV_CODEC_ID_NONE) {
2698  if (tags->id == id)
2699  return tags->tag;
2700  tags++;
2701  }
2702  return 0;
2703 }
2704 
2705 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2706 {
2707  int i;
2708  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2709  if (tag == tags[i].tag)
2710  return tags[i].id;
2711  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2712  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2713  return tags[i].id;
2714  return AV_CODEC_ID_NONE;
2715 }
2716 
2717 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2718 {
2719  if (flt) {
2720  switch (bps) {
2721  case 32:
2723  case 64:
2725  default:
2726  return AV_CODEC_ID_NONE;
2727  }
2728  } else {
2729  bps += 7;
2730  bps >>= 3;
2731  if (sflags & (1 << (bps - 1))) {
2732  switch (bps) {
2733  case 1:
2734  return AV_CODEC_ID_PCM_S8;
2735  case 2:
2737  case 3:
2739  case 4:
2741  default:
2742  return AV_CODEC_ID_NONE;
2743  }
2744  } else {
2745  switch (bps) {
2746  case 1:
2747  return AV_CODEC_ID_PCM_U8;
2748  case 2:
2750  case 3:
2752  case 4:
2754  default:
2755  return AV_CODEC_ID_NONE;
2756  }
2757  }
2758  }
2759 }
2760 
2761 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2762 {
2763  unsigned int tag;
2764  if (!av_codec_get_tag2(tags, id, &tag))
2765  return 0;
2766  return tag;
2767 }
2768 
2769 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2770  unsigned int *tag)
2771 {
2772  int i;
2773  for (i = 0; tags && tags[i]; i++) {
2774  const AVCodecTag *codec_tags = tags[i];
2775  while (codec_tags->id != AV_CODEC_ID_NONE) {
2776  if (codec_tags->id == id) {
2777  *tag = codec_tags->tag;
2778  return 1;
2779  }
2780  codec_tags++;
2781  }
2782  }
2783  return 0;
2784 }
2785 
2786 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2787 {
2788  int i;
2789  for (i = 0; tags && tags[i]; i++) {
2790  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2791  if (id != AV_CODEC_ID_NONE)
2792  return id;
2793  }
2794  return AV_CODEC_ID_NONE;
2795 }
2796 
2798 {
2799  unsigned int i, j;
2800  int64_t max_time = s->duration +
2801  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2802 
2803  for (i = 0; i < s->nb_chapters; i++)
2804  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2805  AVChapter *ch = s->chapters[i];
2806  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2807  ch->time_base)
2808  : INT64_MAX;
2809 
2810  for (j = 0; j < s->nb_chapters; j++) {
2811  AVChapter *ch1 = s->chapters[j];
2812  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2813  ch->time_base);
2814  if (j != i && next_start > ch->start && next_start < end)
2815  end = next_start;
2816  }
2817  ch->end = (end == INT64_MAX) ? ch->start : end;
2818  }
2819 }
2820 
2821 static int get_std_framerate(int i)
2822 {
2823  if (i < 30*12)
2824  return (i + 1) * 1001;
2825  i -= 30*12;
2826 
2827  if (i < 30)
2828  return (i + 31) * 1001 * 12;
2829  i -= 30;
2830 
2831  if (i < 3)
2832  return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
2833 
2834  i -= 3;
2835 
2836  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2837 }
2838 
2839 /* Is the time base unreliable?
2840  * This is a heuristic to balance between quick acceptance of the values in
2841  * the headers vs. some extra checks.
2842  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2843  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2844  * And there are "variable" fps files this needs to detect as well. */
2846 {
2847  if (c->time_base.den >= 101LL * c->time_base.num ||
2848  c->time_base.den < 5LL * c->time_base.num ||
2849  // c->codec_tag == AV_RL32("DIVX") ||
2850  // c->codec_tag == AV_RL32("XVID") ||
2851  c->codec_tag == AV_RL32("mp4v") ||
2853  c->codec_id == AV_CODEC_ID_GIF ||
2854  c->codec_id == AV_CODEC_ID_H264)
2855  return 1;
2856  return 0;
2857 }
2858 
2860 {
2861  int ret;
2862 
2864  avctx->extradata = NULL;
2865  avctx->extradata_size = 0;
2866  return AVERROR(EINVAL);
2867  }
2869  if (avctx->extradata) {
2870  memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2871  avctx->extradata_size = size;
2872  ret = 0;
2873  } else {
2874  avctx->extradata_size = 0;
2875  ret = AVERROR(ENOMEM);
2876  }
2877  return ret;
2878 }
2879 
2881 {
2882  int ret = ff_alloc_extradata(avctx, size);
2883  if (ret < 0)
2884  return ret;
2885  ret = avio_read(pb, avctx->extradata, size);
2886  if (ret != size) {
2887  av_freep(&avctx->extradata);
2888  avctx->extradata_size = 0;
2889  av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2890  return ret < 0 ? ret : AVERROR_INVALIDDATA;
2891  }
2892 
2893  return ret;
2894 }
2895 
2896 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2897 {
2898  int i, j;
2899  int64_t last = st->info->last_dts;
2900 
2901  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2902  && ts - (uint64_t)last < INT64_MAX) {
2903  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2904  int64_t duration = ts - last;
2905 
2906  if (!st->info->duration_error)
2907  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2908  if (!st->info->duration_error)
2909  return AVERROR(ENOMEM);
2910 
2911 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2912 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2913  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2914  if (st->info->duration_error[0][1][i] < 1e10) {
2915  int framerate = get_std_framerate(i);
2916  double sdts = dts*framerate/(1001*12);
2917  for (j= 0; j<2; j++) {
2918  int64_t ticks = llrint(sdts+j*0.5);
2919  double error= sdts - ticks + j*0.5;
2920  st->info->duration_error[j][0][i] += error;
2921  st->info->duration_error[j][1][i] += error*error;
2922  }
2923  }
2924  }
2925  st->info->duration_count++;
2927 
2928  if (st->info->duration_count % 10 == 0) {
2929  int n = st->info->duration_count;
2930  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2931  if (st->info->duration_error[0][1][i] < 1e10) {
2932  double a0 = st->info->duration_error[0][0][i] / n;
2933  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2934  double a1 = st->info->duration_error[1][0][i] / n;
2935  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2936  if (error0 > 0.04 && error1 > 0.04) {
2937  st->info->duration_error[0][1][i] = 2e10;
2938  st->info->duration_error[1][1][i] = 2e10;
2939  }
2940  }
2941  }
2942  }
2943 
2944  // ignore the first 4 values, they might have some random jitter
2945  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2946  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2947  }
2948  if (ts != AV_NOPTS_VALUE)
2949  st->info->last_dts = ts;
2950 
2951  return 0;
2952 }
2953 
2955 {
2956  int i, j;
2957 
2958  for (i = 0; i < ic->nb_streams; i++) {
2959  AVStream *st = ic->streams[i];
2960 
2961  if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2962  continue;
2963  // the check for tb_unreliable() is not completely correct, since this is not about handling
2964  // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2965  // ipmovie.c produces.
2966  if (tb_unreliable(st->codec) && 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)
2967  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);
2968  if (st->info->duration_count>1 && !st->r_frame_rate.num
2969  && tb_unreliable(st->codec)) {
2970  int num = 0;
2971  double best_error= 0.01;
2972  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2973 
2974  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2975  int k;
2976 
2977  if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2978  continue;
2979  if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2980  continue;
2981 
2982  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2983  continue;
2984 
2985  for (k= 0; k<2; k++) {
2986  int n = st->info->duration_count;
2987  double a= st->info->duration_error[k][0][j] / n;
2988  double error= st->info->duration_error[k][1][j]/n - a*a;
2989 
2990  if (error < best_error && best_error> 0.000000001) {
2991  best_error= error;
2992  num = get_std_framerate(j);
2993  }
2994  if (error < 0.02)
2995  av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2996  }
2997  }
2998  // do not increase frame rate by more than 1 % in order to match a standard rate.
2999  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3000  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3001  }
3002  if ( !st->avg_frame_rate.num
3003  && st->r_frame_rate.num && st->info->rfps_duration_sum
3004  && st->info->codec_info_duration <= 0
3005  && st->info->duration_count > 2
3006  && 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
3007  ) {
3008  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3009  st->avg_frame_rate = st->r_frame_rate;
3010  }
3011 
3012  av_freep(&st->info->duration_error);
3013  st->info->last_dts = AV_NOPTS_VALUE;
3014  st->info->duration_count = 0;
3015  st->info->rfps_duration_sum = 0;
3016  }
3017 }
3018 
3020 {
3021  int i, count, ret = 0, j;
3022  int64_t read_size;
3023  AVStream *st;
3024  AVPacket pkt1, *pkt;
3025  int64_t old_offset = avio_tell(ic->pb);
3026  // new streams might appear, no options for those
3027  int orig_nb_streams = ic->nb_streams;
3028  int flush_codecs;
3029  int64_t max_analyze_duration = ic->max_analyze_duration2;
3030  int64_t max_stream_analyze_duration;
3031  int64_t probesize = ic->probesize2;
3032 
3033  if (!max_analyze_duration)
3034  max_analyze_duration = ic->max_analyze_duration;
3035  if (ic->probesize)
3036  probesize = ic->probesize;
3037  flush_codecs = probesize > 0;
3038 
3039  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3040 
3041  max_stream_analyze_duration = max_analyze_duration;
3042  if (!max_analyze_duration) {
3043  max_stream_analyze_duration =
3044  max_analyze_duration = 5*AV_TIME_BASE;
3045  if (!strcmp(ic->iformat->name, "flv"))
3046  max_stream_analyze_duration = 30*AV_TIME_BASE;
3047  }
3048 
3049  if (ic->pb)
3050  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3051  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3052 
3053  for (i = 0; i < ic->nb_streams; i++) {
3054  const AVCodec *codec;
3055  AVDictionary *thread_opt = NULL;
3056  st = ic->streams[i];
3057 
3058  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3060 /* if (!st->time_base.num)
3061  st->time_base = */
3062  if (!st->codec->time_base.num)
3063  st->codec->time_base = st->time_base;
3064  }
3065  // only for the split stuff
3066  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3067  st->parser = av_parser_init(st->codec->codec_id);
3068  if (st->parser) {
3069  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3071  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3073  }
3074  } else if (st->need_parsing) {
3075  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3076  "%s, packets or times may be invalid.\n",
3078  }
3079  }
3080  codec = find_decoder(ic, st, st->codec->codec_id);
3081 
3082  /* Force thread count to 1 since the H.264 decoder will not extract
3083  * SPS and PPS to extradata during multi-threaded decoding. */
3084  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3085 
3086  if (ic->codec_whitelist)
3087  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3088 
3089  /* Ensure that subtitle_header is properly set. */
3091  && codec && !st->codec->codec) {
3092  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3093  av_log(ic, AV_LOG_WARNING,
3094  "Failed to open codec in av_find_stream_info\n");
3095  }
3096 
3097  // Try to just open decoders, in case this is enough to get parameters.
3098  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3099  if (codec && !st->codec->codec)
3100  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3101  av_log(ic, AV_LOG_WARNING,
3102  "Failed to open codec in av_find_stream_info\n");
3103  }
3104  if (!options)
3105  av_dict_free(&thread_opt);
3106  }
3107 
3108  for (i = 0; i < ic->nb_streams; i++) {
3109 #if FF_API_R_FRAME_RATE
3110  ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3111 #endif
3114  }
3115 
3116  count = 0;
3117  read_size = 0;
3118  for (;;) {
3119  int analyzed_all_streams;
3121  ret = AVERROR_EXIT;
3122  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3123  break;
3124  }
3125 
3126  /* check if one codec still needs to be handled */
3127  for (i = 0; i < ic->nb_streams; i++) {
3128  int fps_analyze_framecount = 20;
3129 
3130  st = ic->streams[i];
3131  if (!has_codec_parameters(st, NULL))
3132  break;
3133  /* If the timebase is coarse (like the usual millisecond precision
3134  * of mkv), we need to analyze more frames to reliably arrive at
3135  * the correct fps. */
3136  if (av_q2d(st->time_base) > 0.0005)
3137  fps_analyze_framecount *= 2;
3138  if (!tb_unreliable(st->codec))
3139  fps_analyze_framecount = 0;
3140  if (ic->fps_probe_size >= 0)
3141  fps_analyze_framecount = ic->fps_probe_size;
3143  fps_analyze_framecount = 0;
3144  /* variable fps and no guess at the real fps */
3145  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3146  st->info->duration_count < fps_analyze_framecount &&
3148  break;
3149  if (st->parser && st->parser->parser->split &&
3150  !st->codec->extradata)
3151  break;
3152  if (st->first_dts == AV_NOPTS_VALUE &&
3153  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3154  st->codec_info_nb_frames < ic->max_ts_probe &&
3155  (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3157  break;
3158  }
3159  analyzed_all_streams = 0;
3160  if (i == ic->nb_streams) {
3161  analyzed_all_streams = 1;
3162  /* NOTE: If the format has no header, then we need to read some
3163  * packets to get most of the streams, so we cannot stop here. */
3164  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3165  /* If we found the info for all the codecs, we can stop. */
3166  ret = count;
3167  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3168  flush_codecs = 0;
3169  break;
3170  }
3171  }
3172  /* We did not get all the codec info, but we read too much data. */
3173  if (read_size >= probesize) {
3174  ret = count;
3175  av_log(ic, AV_LOG_DEBUG,
3176  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3177  for (i = 0; i < ic->nb_streams; i++)
3178  if (!ic->streams[i]->r_frame_rate.num &&
3179  ic->streams[i]->info->duration_count <= 1 &&
3181  strcmp(ic->iformat->name, "image2"))
3182  av_log(ic, AV_LOG_WARNING,
3183  "Stream #%d: not enough frames to estimate rate; "
3184  "consider increasing probesize\n", i);
3185  break;
3186  }
3187 
3188  /* NOTE: A new stream can be added there if no header in file
3189  * (AVFMTCTX_NOHEADER). */
3190  ret = read_frame_internal(ic, &pkt1);
3191  if (ret == AVERROR(EAGAIN))
3192  continue;
3193 
3194  if (ret < 0) {
3195  /* EOF or error*/
3196  break;
3197  }
3198 
3199  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3201  &ic->internal->packet_buffer_end);
3202  {
3203  pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3204  &ic->internal->packet_buffer_end);
3205  if (!pkt) {
3206  ret = AVERROR(ENOMEM);
3207  goto find_stream_info_err;
3208  }
3209  if ((ret = av_dup_packet(pkt)) < 0)
3210  goto find_stream_info_err;
3211  }
3212 
3213  st = ic->streams[pkt->stream_index];
3215  read_size += pkt->size;
3216 
3217  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3218  /* check for non-increasing dts */
3219  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3220  st->info->fps_last_dts >= pkt->dts) {
3221  av_log(ic, AV_LOG_DEBUG,
3222  "Non-increasing DTS in stream %d: packet %d with DTS "
3223  "%"PRId64", packet %d with DTS %"PRId64"\n",
3224  st->index, st->info->fps_last_dts_idx,
3226  pkt->dts);
3227  st->info->fps_first_dts =
3229  }
3230  /* Check for a discontinuity in dts. If the difference in dts
3231  * is more than 1000 times the average packet duration in the
3232  * sequence, we treat it as a discontinuity. */
3233  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3235  (pkt->dts - st->info->fps_last_dts) / 1000 >
3236  (st->info->fps_last_dts - st->info->fps_first_dts) /
3237  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3238  av_log(ic, AV_LOG_WARNING,
3239  "DTS discontinuity in stream %d: packet %d with DTS "
3240  "%"PRId64", packet %d with DTS %"PRId64"\n",
3241  st->index, st->info->fps_last_dts_idx,
3243  pkt->dts);
3244  st->info->fps_first_dts =
3246  }
3247 
3248  /* update stored dts values */
3249  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3250  st->info->fps_first_dts = pkt->dts;
3252  }
3253  st->info->fps_last_dts = pkt->dts;
3255  }
3256  if (st->codec_info_nb_frames>1) {
3257  int64_t t = 0;
3258 
3259  if (st->time_base.den > 0)
3261  if (st->avg_frame_rate.num > 0)
3263 
3264  if ( t == 0
3265  && st->codec_info_nb_frames>30
3266  && st->info->fps_first_dts != AV_NOPTS_VALUE
3267  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3269 
3270  if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3271  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3272  max_analyze_duration,
3273  t);
3274  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3275  av_packet_unref(pkt);
3276  break;
3277  }
3278  if (pkt->duration) {
3279  st->info->codec_info_duration += pkt->duration;
3280  st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3281  }
3282  }
3283 #if FF_API_R_FRAME_RATE
3284  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3285  ff_rfps_add_frame(ic, st, pkt->dts);
3286 #endif
3287  if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3288  int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3289  if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3290  if (ff_alloc_extradata(st->codec, i))
3291  return AVERROR(ENOMEM);
3292  memcpy(st->codec->extradata, pkt->data,
3293  st->codec->extradata_size);
3294  }
3295  }
3296 
3297  /* If still no information, we try to open the codec and to
3298  * decompress the frame. We try to avoid that in most cases as
3299  * it takes longer and uses more memory. For MPEG-4, we need to
3300  * decompress for QuickTime.
3301  *
3302  * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3303  * least one frame of codec data, this makes sure the codec initializes
3304  * the channel configuration and does not only trust the values from
3305  * the container. */
3306  try_decode_frame(ic, st, pkt,
3307  (options && i < orig_nb_streams) ? &options[i] : NULL);
3308 
3309  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3310  av_packet_unref(pkt);
3311 
3312  st->codec_info_nb_frames++;
3313  count++;
3314  }
3315 
3316  if (flush_codecs) {
3317  AVPacket empty_pkt = { 0 };
3318  int err = 0;
3319  av_init_packet(&empty_pkt);
3320 
3321  for (i = 0; i < ic->nb_streams; i++) {
3322 
3323  st = ic->streams[i];
3324 
3325  /* flush the decoders */
3326  if (st->info->found_decoder == 1) {
3327  do {
3328  err = try_decode_frame(ic, st, &empty_pkt,
3329  (options && i < orig_nb_streams)
3330  ? &options[i] : NULL);
3331  } while (err > 0 && !has_codec_parameters(st, NULL));
3332 
3333  if (err < 0) {
3334  av_log(ic, AV_LOG_INFO,
3335  "decoding for stream %d failed\n", st->index);
3336  }
3337  }
3338  }
3339  }
3340 
3341  // close codecs which were opened in try_decode_frame()
3342  for (i = 0; i < ic->nb_streams; i++) {
3343  st = ic->streams[i];
3344  avcodec_close(st->codec);
3345  }
3346 
3347  ff_rfps_calculate(ic);
3348 
3349  for (i = 0; i < ic->nb_streams; i++) {
3350  st = ic->streams[i];
3351  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3355  st->codec->codec_tag= tag;
3356  }
3357 
3358  /* estimate average framerate if not set by demuxer */
3359  if (st->info->codec_info_duration_fields &&
3360  !st->avg_frame_rate.num &&
3361  st->info->codec_info_duration) {
3362  int best_fps = 0;
3363  double best_error = 0.01;
3364 
3365  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3366  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3367  st->info->codec_info_duration < 0)
3368  continue;
3370  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3371  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3372 
3373  /* Round guessed framerate to a "standard" framerate if it's
3374  * within 1% of the original estimate. */
3375  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3376  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3377  double error = fabs(av_q2d(st->avg_frame_rate) /
3378  av_q2d(std_fps) - 1);
3379 
3380  if (error < best_error) {
3381  best_error = error;
3382  best_fps = std_fps.num;
3383  }
3384  }
3385  if (best_fps)
3387  best_fps, 12 * 1001, INT_MAX);
3388  }
3389 
3390  if (!st->r_frame_rate.num) {
3391  if ( st->codec->time_base.den * (int64_t) st->time_base.num
3392  <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3393  st->r_frame_rate.num = st->codec->time_base.den;
3395  } else {
3396  st->r_frame_rate.num = st->time_base.den;
3397  st->r_frame_rate.den = st->time_base.num;
3398  }
3399  }
3401  AVRational hw_ratio = { st->codec->height, st->codec->width };
3403  hw_ratio);
3404  }
3405  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3406  if (!st->codec->bits_per_coded_sample)
3409  // set stream disposition based on audio service type
3410  switch (st->codec->audio_service_type) {
3413  break;
3416  break;
3419  break;
3422  break;
3425  break;
3426  }
3427  }
3428  }
3429 
3430  if (probesize)
3431  estimate_timings(ic, old_offset);
3432 
3433  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3434 
3435  if (ret >= 0 && ic->nb_streams)
3436  /* We could not have all the codec parameters before EOF. */
3437  ret = -1;
3438  for (i = 0; i < ic->nb_streams; i++) {
3439  const char *errmsg;
3440  st = ic->streams[i];
3441  if (!has_codec_parameters(st, &errmsg)) {
3442  char buf[256];
3443  avcodec_string(buf, sizeof(buf), st->codec, 0);
3444  av_log(ic, AV_LOG_WARNING,
3445  "Could not find codec parameters for stream %d (%s): %s\n"
3446  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3447  i, buf, errmsg);
3448  } else {
3449  ret = 0;
3450  }
3451  }
3452 
3454 
3455 find_stream_info_err:
3456  for (i = 0; i < ic->nb_streams; i++) {
3457  st = ic->streams[i];
3458  if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3459  ic->streams[i]->codec->thread_count = 0;
3460  if (st->info)
3461  av_freep(&st->info->duration_error);
3462  av_freep(&ic->streams[i]->info);
3463  }
3464  if (ic->pb)
3465  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3466  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3467  return ret;
3468 }
3469 
3471 {
3472  int i, j;
3473 
3474  for (i = 0; i < ic->nb_programs; i++) {
3475  if (ic->programs[i] == last) {
3476  last = NULL;
3477  } else {
3478  if (!last)
3479  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3480  if (ic->programs[i]->stream_index[j] == s)
3481  return ic->programs[i];
3482  }
3483  }
3484  return NULL;
3485 }
3486 
3488  int wanted_stream_nb, int related_stream,
3489  AVCodec **decoder_ret, int flags)
3490 {
3491  int i, nb_streams = ic->nb_streams;
3492  int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3493  unsigned *program = NULL;
3494  const AVCodec *decoder = NULL, *best_decoder = NULL;
3495 
3496  if (related_stream >= 0 && wanted_stream_nb < 0) {
3497  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3498  if (p) {
3499  program = p->stream_index;
3500  nb_streams = p->nb_stream_indexes;
3501  }
3502  }
3503  for (i = 0; i < nb_streams; i++) {
3504  int real_stream_index = program ? program[i] : i;
3505  AVStream *st = ic->streams[real_stream_index];
3506  AVCodecContext *avctx = st->codec;
3507  if (avctx->codec_type != type)
3508  continue;
3509  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3510  continue;
3511  if (wanted_stream_nb != real_stream_index &&
3514  continue;
3515  if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3516  continue;
3517  if (decoder_ret) {
3518  decoder = find_decoder(ic, st, st->codec->codec_id);
3519  if (!decoder) {
3520  if (ret < 0)
3522  continue;
3523  }
3524  }
3526  bitrate = avctx->bit_rate;
3527  if (!bitrate)
3528  bitrate = avctx->rc_max_rate;
3529  multiframe = FFMIN(5, count);
3530  if ((best_multiframe > multiframe) ||
3531  (best_multiframe == multiframe && best_bitrate > bitrate) ||
3532  (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3533  continue;
3534  best_count = count;
3535  best_bitrate = bitrate;
3536  best_multiframe = multiframe;
3537  ret = real_stream_index;
3538  best_decoder = decoder;
3539  if (program && i == nb_streams - 1 && ret < 0) {
3540  program = NULL;
3541  nb_streams = ic->nb_streams;
3542  /* no related stream found, try again with everything */
3543  i = 0;
3544  }
3545  }
3546  if (decoder_ret)
3547  *decoder_ret = (AVCodec*)best_decoder;
3548  return ret;
3549 }
3550 
3551 /*******************************************************/
3552 
3554 {
3555  if (s->iformat->read_play)
3556  return s->iformat->read_play(s);
3557  if (s->pb)
3558  return avio_pause(s->pb, 0);
3559  return AVERROR(ENOSYS);
3560 }
3561 
3563 {
3564  if (s->iformat->read_pause)
3565  return s->iformat->read_pause(s);
3566  if (s->pb)
3567  return avio_pause(s->pb, 1);
3568  return AVERROR(ENOSYS);
3569 }
3570 
3572  int j;
3573  av_assert0(s->nb_streams>0);
3574  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3575 
3576  for (j = 0; j < st->nb_side_data; j++)
3577  av_freep(&st->side_data[j].data);
3578  av_freep(&st->side_data);
3579  st->nb_side_data = 0;
3580 
3581  if (st->parser) {
3582  av_parser_close(st->parser);
3583  }
3584  if (st->attached_pic.data)
3586  av_dict_free(&st->metadata);
3587  av_freep(&st->probe_data.buf);
3588  av_freep(&st->index_entries);
3589  av_freep(&st->codec->extradata);
3591  av_freep(&st->codec);
3592  av_freep(&st->priv_data);
3593  if (st->info)
3594  av_freep(&st->info->duration_error);
3595  av_freep(&st->info);
3597  av_freep(&s->streams[ --s->nb_streams ]);
3598 }
3599 
3601 {
3602  int i;
3603 
3604  if (!s)
3605  return;
3606 
3607  av_opt_free(s);
3608  if (s->iformat && s->iformat->priv_class && s->priv_data)
3609  av_opt_free(s->priv_data);
3610  if (s->oformat && s->oformat->priv_class && s->priv_data)
3611  av_opt_free(s->priv_data);
3612 
3613  for (i = s->nb_streams - 1; i >= 0; i--) {
3614  ff_free_stream(s, s->streams[i]);
3615  }
3616  for (i = s->nb_programs - 1; i >= 0; i--) {
3617  av_dict_free(&s->programs[i]->metadata);
3618  av_freep(&s->programs[i]->stream_index);
3619  av_freep(&s->programs[i]);
3620  }
3621  av_freep(&s->programs);
3622  av_freep(&s->priv_data);
3623  while (s->nb_chapters--) {
3625  av_freep(&s->chapters[s->nb_chapters]);
3626  }
3627  av_freep(&s->chapters);
3628  av_dict_free(&s->metadata);
3629  av_freep(&s->streams);
3630  av_freep(&s->internal);
3631  flush_packet_queue(s);
3632  av_free(s);
3633 }
3634 
3636 {
3637  AVFormatContext *s;
3638  AVIOContext *pb;
3639 
3640  if (!ps || !*ps)
3641  return;
3642 
3643  s = *ps;
3644  pb = s->pb;
3645 
3646  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3647  (s->flags & AVFMT_FLAG_CUSTOM_IO))
3648  pb = NULL;
3649 
3650  flush_packet_queue(s);
3651 
3652  if (s->iformat)
3653  if (s->iformat->read_close)
3654  s->iformat->read_close(s);
3655 
3657 
3658  *ps = NULL;
3659 
3660  avio_close(pb);
3661 }
3662 
3664 {
3665  AVStream *st;
3666  int i;
3667  AVStream **streams;
3668 
3669  if (s->nb_streams >= INT_MAX/sizeof(*streams))
3670  return NULL;
3671  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3672  if (!streams)
3673  return NULL;
3674  s->streams = streams;
3675 
3676  st = av_mallocz(sizeof(AVStream));
3677  if (!st)
3678  return NULL;
3679  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3680  av_free(st);
3681  return NULL;
3682  }
3683  st->info->last_dts = AV_NOPTS_VALUE;
3684 
3685  st->codec = avcodec_alloc_context3(c);
3686  if (!st->codec) {
3687  av_free(st->info);
3688  av_free(st);
3689  return NULL;
3690  }
3691  if (s->iformat) {
3692  /* no default bitrate if decoding */
3693  st->codec->bit_rate = 0;
3694 
3695  /* default pts setting is MPEG-like */
3696  avpriv_set_pts_info(st, 33, 1, 90000);
3697  }
3698 
3699  st->index = s->nb_streams;
3700  st->start_time = AV_NOPTS_VALUE;
3701  st->duration = AV_NOPTS_VALUE;
3702  /* we set the current DTS to 0 so that formats without any timestamps
3703  * but durations get some timestamps, formats with some unknown
3704  * timestamps have their first few packets buffered and the
3705  * timestamps corrected before they are returned to the user */
3706  st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3707  st->first_dts = AV_NOPTS_VALUE;
3711 
3714  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3715  st->pts_buffer[i] = AV_NOPTS_VALUE;
3716 
3717  st->sample_aspect_ratio = (AVRational) { 0, 1 };
3718 
3719 #if FF_API_R_FRAME_RATE
3720  st->info->last_dts = AV_NOPTS_VALUE;
3721 #endif
3724 
3726 
3727  s->streams[s->nb_streams++] = st;
3728  return st;
3729 }
3730 
3732 {
3733  AVProgram *program = NULL;
3734  int i;
3735 
3736  av_dlog(ac, "new_program: id=0x%04x\n", id);
3737 
3738  for (i = 0; i < ac->nb_programs; i++)
3739  if (ac->programs[i]->id == id)
3740  program = ac->programs[i];
3741 
3742  if (!program) {
3743  program = av_mallocz(sizeof(AVProgram));
3744  if (!program)
3745  return NULL;
3746  dynarray_add(&ac->programs, &ac->nb_programs, program);
3747  program->discard = AVDISCARD_NONE;
3748  }
3749  program->id = id;
3752 
3753  program->start_time =
3754  program->end_time = AV_NOPTS_VALUE;
3755 
3756  return program;
3757 }
3758 
3760  int64_t start, int64_t end, const char *title)
3761 {
3762  AVChapter *chapter = NULL;
3763  int i;
3764 
3765  if (end != AV_NOPTS_VALUE && start > end) {
3766  av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3767  return NULL;
3768  }
3769 
3770  for (i = 0; i < s->nb_chapters; i++)
3771  if (s->chapters[i]->id == id)
3772  chapter = s->chapters[i];
3773 
3774  if (!chapter) {
3775  chapter = av_mallocz(sizeof(AVChapter));
3776  if (!chapter)
3777  return NULL;
3778  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3779  }
3780  av_dict_set(&chapter->metadata, "title", title, 0);
3781  chapter->id = id;
3782  chapter->time_base = time_base;
3783  chapter->start = start;
3784  chapter->end = end;
3785 
3786  return chapter;
3787 }
3788 
3789 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3790 {
3791  int i, j;
3792  AVProgram *program = NULL;
3793  void *tmp;
3794 
3795  if (idx >= ac->nb_streams) {
3796  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3797  return;
3798  }
3799 
3800  for (i = 0; i < ac->nb_programs; i++) {
3801  if (ac->programs[i]->id != progid)
3802  continue;
3803  program = ac->programs[i];
3804  for (j = 0; j < program->nb_stream_indexes; j++)
3805  if (program->stream_index[j] == idx)
3806  return;
3807 
3808  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3809  if (!tmp)
3810  return;
3811  program->stream_index = tmp;
3812  program->stream_index[program->nb_stream_indexes++] = idx;
3813  return;
3814  }
3815 }
3816 
3817 uint64_t ff_ntp_time(void)
3818 {
3819  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3820 }
3821 
3822 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3823 {
3824  const char *p;
3825  char *q, buf1[20], c;
3826  int nd, len, percentd_found;
3827 
3828  q = buf;
3829  p = path;
3830  percentd_found = 0;
3831  for (;;) {
3832  c = *p++;
3833  if (c == '\0')
3834  break;
3835  if (c == '%') {
3836  do {
3837  nd = 0;
3838  while (av_isdigit(*p))
3839  nd = nd * 10 + *p++ - '0';
3840  c = *p++;
3841  } while (av_isdigit(c));
3842 
3843  switch (c) {
3844  case '%':
3845  goto addchar;
3846  case 'd':
3847  if (percentd_found)
3848  goto fail;
3849  percentd_found = 1;
3850  if (number < 0)
3851  nd += 1;
3852  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3853  len = strlen(buf1);
3854  if ((q - buf + len) > buf_size - 1)
3855  goto fail;
3856  memcpy(q, buf1, len);
3857  q += len;
3858  break;
3859  default:
3860  goto fail;
3861  }
3862  } else {
3863 addchar:
3864  if ((q - buf) < buf_size - 1)
3865  *q++ = c;
3866  }
3867  }
3868  if (!percentd_found)
3869  goto fail;
3870  *q = '\0';
3871  return 0;
3872 fail:
3873  *q = '\0';
3874  return -1;
3875 }
3876 
3877 void av_url_split(char *proto, int proto_size,
3878  char *authorization, int authorization_size,
3879  char *hostname, int hostname_size,
3880  int *port_ptr, char *path, int path_size, const char *url)
3881 {
3882  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3883 
3884  if (port_ptr)
3885  *port_ptr = -1;
3886  if (proto_size > 0)
3887  proto[0] = 0;
3888  if (authorization_size > 0)
3889  authorization[0] = 0;
3890  if (hostname_size > 0)
3891  hostname[0] = 0;
3892  if (path_size > 0)
3893  path[0] = 0;
3894 
3895  /* parse protocol */
3896  if ((p = strchr(url, ':'))) {
3897  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3898  p++; /* skip ':' */
3899  if (*p == '/')
3900  p++;
3901  if (*p == '/')
3902  p++;
3903  } else {
3904  /* no protocol means plain filename */
3905  av_strlcpy(path, url, path_size);
3906  return;
3907  }
3908 
3909  /* separate path from hostname */
3910  ls = strchr(p, '/');
3911  ls2 = strchr(p, '?');
3912  if (!ls)
3913  ls = ls2;
3914  else if (ls && ls2)
3915  ls = FFMIN(ls, ls2);
3916  if (ls)
3917  av_strlcpy(path, ls, path_size);
3918  else
3919  ls = &p[strlen(p)]; // XXX
3920 
3921  /* the rest is hostname, use that to parse auth/port */
3922  if (ls != p) {
3923  /* authorization (user[:pass]@hostname) */
3924  at2 = p;
3925  while ((at = strchr(p, '@')) && at < ls) {
3926  av_strlcpy(authorization, at2,
3927  FFMIN(authorization_size, at + 1 - at2));
3928  p = at + 1; /* skip '@' */
3929  }
3930 
3931  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3932  /* [host]:port */
3933  av_strlcpy(hostname, p + 1,
3934  FFMIN(hostname_size, brk - p));
3935  if (brk[1] == ':' && port_ptr)
3936  *port_ptr = atoi(brk + 2);
3937  } else if ((col = strchr(p, ':')) && col < ls) {
3938  av_strlcpy(hostname, p,
3939  FFMIN(col + 1 - p, hostname_size));
3940  if (port_ptr)
3941  *port_ptr = atoi(col + 1);
3942  } else
3943  av_strlcpy(hostname, p,
3944  FFMIN(ls + 1 - p, hostname_size));
3945  }
3946 }
3947 
3948 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3949 {
3950  int i;
3951  static const char hex_table_uc[16] = { '0', '1', '2', '3',
3952  '4', '5', '6', '7',
3953  '8', '9', 'A', 'B',
3954  'C', 'D', 'E', 'F' };
3955  static const char hex_table_lc[16] = { '0', '1', '2', '3',
3956  '4', '5', '6', '7',
3957  '8', '9', 'a', 'b',
3958  'c', 'd', 'e', 'f' };
3959  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3960 
3961  for (i = 0; i < s; i++) {
3962  buff[i * 2] = hex_table[src[i] >> 4];
3963  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3964  }
3965 
3966  return buff;
3967 }
3968 
3969 int ff_hex_to_data(uint8_t *data, const char *p)
3970 {
3971  int c, len, v;
3972 
3973  len = 0;
3974  v = 1;
3975  for (;;) {
3976  p += strspn(p, SPACE_CHARS);
3977  if (*p == '\0')
3978  break;
3979  c = av_toupper((unsigned char) *p++);
3980  if (c >= '0' && c <= '9')
3981  c = c - '0';
3982  else if (c >= 'A' && c <= 'F')
3983  c = c - 'A' + 10;
3984  else
3985  break;
3986  v = (v << 4) | c;
3987  if (v & 0x100) {
3988  if (data)
3989  data[len] = v;
3990  len++;
3991  v = 1;
3992  }
3993  }
3994  return len;
3995 }
3996 
3997 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3998  unsigned int pts_num, unsigned int pts_den)
3999 {
4000  AVRational new_tb;
4001  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4002  if (new_tb.num != pts_num)
4004  "st:%d removing common factor %d from timebase\n",
4005  s->index, pts_num / new_tb.num);
4006  } else
4008  "st:%d has too large timebase, reducing\n", s->index);
4009 
4010  if (new_tb.num <= 0 || new_tb.den <= 0) {
4012  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4013  new_tb.num, new_tb.den,
4014  s->index);
4015  return;
4016  }
4017  s->time_base = new_tb;
4018  av_codec_set_pkt_timebase(s->codec, new_tb);
4019  s->pts_wrap_bits = pts_wrap_bits;
4020 }
4021 
4022 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4023  void *context)
4024 {
4025  const char *ptr = str;
4026 
4027  /* Parse key=value pairs. */
4028  for (;;) {
4029  const char *key;
4030  char *dest = NULL, *dest_end;
4031  int key_len, dest_len = 0;
4032 
4033  /* Skip whitespace and potential commas. */
4034  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4035  ptr++;
4036  if (!*ptr)
4037  break;
4038 
4039  key = ptr;
4040 
4041  if (!(ptr = strchr(key, '=')))
4042  break;
4043  ptr++;
4044  key_len = ptr - key;
4045 
4046  callback_get_buf(context, key, key_len, &dest, &dest_len);
4047  dest_end = dest + dest_len - 1;
4048 
4049  if (*ptr == '\"') {
4050  ptr++;
4051  while (*ptr && *ptr != '\"') {
4052  if (*ptr == '\\') {
4053  if (!ptr[1])
4054  break;
4055  if (dest && dest < dest_end)
4056  *dest++ = ptr[1];
4057  ptr += 2;
4058  } else {
4059  if (dest && dest < dest_end)
4060  *dest++ = *ptr;
4061  ptr++;
4062  }
4063  }
4064  if (*ptr == '\"')
4065  ptr++;
4066  } else {
4067  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4068  if (dest && dest < dest_end)
4069  *dest++ = *ptr;
4070  }
4071  if (dest)
4072  *dest = 0;
4073  }
4074 }
4075 
4077 {
4078  int i;
4079  for (i = 0; i < s->nb_streams; i++)
4080  if (s->streams[i]->id == id)
4081  return i;
4082  return -1;
4083 }
4084 
4085 int64_t ff_iso8601_to_unix_time(const char *datestr)
4086 {
4087  struct tm time1 = { 0 }, time2 = { 0 };
4088  char *ret1, *ret2;
4089  ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4090  ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4091  if (ret2 && !ret1)
4092  return av_timegm(&time2);
4093  else
4094  return av_timegm(&time1);
4095 }
4096 
4098  int std_compliance)
4099 {
4100  if (ofmt) {
4101  if (ofmt->query_codec)
4102  return ofmt->query_codec(codec_id, std_compliance);
4103  else if (ofmt->codec_tag)
4104  return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4105  else if (codec_id == ofmt->video_codec ||
4106  codec_id == ofmt->audio_codec ||
4107  codec_id == ofmt->subtitle_codec)
4108  return 1;
4109  }
4110  return AVERROR_PATCHWELCOME;
4111 }
4112 
4114 {
4115 #if CONFIG_NETWORK
4116  int ret;
4118  if ((ret = ff_network_init()) < 0)
4119  return ret;
4120  if ((ret = ff_tls_init()) < 0)
4121  return ret;
4122 #endif
4123  return 0;
4124 }
4125 
4127 {
4128 #if CONFIG_NETWORK
4129  ff_network_close();
4130  ff_tls_deinit();
4132 #endif
4133  return 0;
4134 }
4135 
4137  uint64_t channel_layout, int32_t sample_rate,
4139 {
4140  uint32_t flags = 0;
4141  int size = 4;
4142  uint8_t *data;
4143  if (!pkt)
4144  return AVERROR(EINVAL);
4145  if (channels) {
4146  size += 4;
4148  }
4149  if (channel_layout) {
4150  size += 8;
4152  }
4153  if (sample_rate) {
4154  size += 4;
4156  }
4157  if (width || height) {
4158  size += 8;
4160  }
4162  if (!data)
4163  return AVERROR(ENOMEM);
4164  bytestream_put_le32(&data, flags);
4165  if (channels)
4166  bytestream_put_le32(&data, channels);
4167  if (channel_layout)
4168  bytestream_put_le64(&data, channel_layout);
4169  if (sample_rate)
4170  bytestream_put_le32(&data, sample_rate);
4171  if (width || height) {
4172  bytestream_put_le32(&data, width);
4173  bytestream_put_le32(&data, height);
4174  }
4175  return 0;
4176 }
4177 
4179 {
4180  AVRational undef = {0, 1};
4181  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4182  AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4183  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4184 
4185  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4186  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4187  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4188  stream_sample_aspect_ratio = undef;
4189 
4190  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4191  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4192  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4193  frame_sample_aspect_ratio = undef;
4194 
4195  if (stream_sample_aspect_ratio.num)
4196  return stream_sample_aspect_ratio;
4197  else
4198  return frame_sample_aspect_ratio;
4199 }
4200 
4202 {
4203  AVRational fr = st->r_frame_rate;
4204  AVRational codec_fr = st->codec->framerate;
4205  AVRational avg_fr = st->avg_frame_rate;
4206 
4207  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4208  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4209  fr = avg_fr;
4210  }
4211 
4212 
4213  if (st->codec->ticks_per_frame > 1) {
4214  if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4215  (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))
4216  fr = codec_fr;
4217  }
4218 
4219  return fr;
4220 }
4221 
4223  const char *spec)
4224 {
4225  if (*spec <= '9' && *spec >= '0') /* opt:index */
4226  return strtol(spec, NULL, 0) == st->index;
4227  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4228  *spec == 't') { /* opt:[vasdt] */
4229  enum AVMediaType type;
4230 
4231  switch (*spec++) {
4232  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4233  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4234  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4235  case 'd': type = AVMEDIA_TYPE_DATA; break;
4236  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4237  default: av_assert0(0);
4238  }
4239  if (type != st->codec->codec_type)
4240  return 0;
4241  if (*spec++ == ':') { /* possibly followed by :index */
4242  int i, index = strtol(spec, NULL, 0);
4243  for (i = 0; i < s->nb_streams; i++)
4244  if (s->streams[i]->codec->codec_type == type && index-- == 0)
4245  return i == st->index;
4246  return 0;
4247  }
4248  return 1;
4249  } else if (*spec == 'p' && *(spec + 1) == ':') {
4250  int prog_id, i, j;
4251  char *endptr;
4252  spec += 2;
4253  prog_id = strtol(spec, &endptr, 0);
4254  for (i = 0; i < s->nb_programs; i++) {
4255  if (s->programs[i]->id != prog_id)
4256  continue;
4257 
4258  if (*endptr++ == ':') {
4259  int stream_idx = strtol(endptr, NULL, 0);
4260  return stream_idx >= 0 &&
4261  stream_idx < s->programs[i]->nb_stream_indexes &&
4262  st->index == s->programs[i]->stream_index[stream_idx];
4263  }
4264 
4265  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4266  if (st->index == s->programs[i]->stream_index[j])
4267  return 1;
4268  }
4269  return 0;
4270  } else if (*spec == '#' ||
4271  (*spec == 'i' && *(spec + 1) == ':')) {
4272  int stream_id;
4273  char *endptr;
4274  spec += 1 + (*spec == 'i');
4275  stream_id = strtol(spec, &endptr, 0);
4276  if (!*endptr)
4277  return stream_id == st->id;
4278  } else if (*spec == 'm' && *(spec + 1) == ':') {
4280  char *key, *val;
4281  int ret;
4282 
4283  spec += 2;
4284  val = strchr(spec, ':');
4285 
4286  key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4287  if (!key)
4288  return AVERROR(ENOMEM);
4289 
4290  tag = av_dict_get(st->metadata, key, NULL, 0);
4291  if (tag) {
4292  if (!val || !strcmp(tag->value, val + 1))
4293  ret = 1;
4294  else
4295  ret = 0;
4296  } else
4297  ret = 0;
4298 
4299  av_freep(&key);
4300  return ret;
4301  } else if (!*spec) /* empty specifier, matches everything */
4302  return 1;
4303 
4304  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4305  return AVERROR(EINVAL);
4306 }
4307 
4309 {
4310  static const uint8_t avci100_1080p_extradata[] = {
4311  // SPS
4312  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4313  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4314  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4315  0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4316  0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4317  0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4318  0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4319  0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4320  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4321  // PPS
4322  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4323  0xd0
4324  };
4325  static const uint8_t avci100_1080i_extradata[] = {
4326  // SPS
4327  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4328  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4329  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4330  0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4331  0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4332  0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4333  0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4334  0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4335  0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4336  0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4337  0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4338  // PPS
4339  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4340  0xd0
4341  };
4342  static const uint8_t avci50_1080p_extradata[] = {
4343  // SPS
4344  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4345  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4346  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4347  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4348  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4349  0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4350  0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4351  0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4352  0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4353  // PPS
4354  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4355  0x11
4356  };
4357  static const uint8_t avci50_1080i_extradata[] = {
4358  // SPS
4359  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4360  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4361  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4362  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4363  0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4364  0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4365  0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4366  0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4367  0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4368  0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4369  0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4370  // PPS
4371  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4372  0x11
4373  };
4374  static const uint8_t avci100_720p_extradata[] = {
4375  // SPS
4376  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4377  0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4378  0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4379  0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4380  0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4381  0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4382  0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4383  0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4384  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4385  0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4386  // PPS
4387  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4388  0x11
4389  };
4390  static const uint8_t avci50_720p_extradata[] = {
4391  // SPS
4392  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4393  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4394  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4395  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4396  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4397  0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4398  0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4399  0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4400  0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4401  // PPS
4402  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4403  0x11
4404  };
4405 
4406  const uint8_t *data = NULL;
4407  int size = 0;
4408 
4409  if (st->codec->width == 1920) {
4410  if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4411  data = avci100_1080p_extradata;
4412  size = sizeof(avci100_1080p_extradata);
4413  } else {
4414  data = avci100_1080i_extradata;
4415  size = sizeof(avci100_1080i_extradata);
4416  }
4417  } else if (st->codec->width == 1440) {
4418  if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4419  data = avci50_1080p_extradata;
4420  size = sizeof(avci50_1080p_extradata);
4421  } else {
4422  data = avci50_1080i_extradata;
4423  size = sizeof(avci50_1080i_extradata);
4424  }
4425  } else if (st->codec->width == 1280) {
4426  data = avci100_720p_extradata;
4427  size = sizeof(avci100_720p_extradata);
4428  } else if (st->codec->width == 960) {
4429  data = avci50_720p_extradata;
4430  size = sizeof(avci50_720p_extradata);
4431  }
4432 
4433  if (!size)
4434  return 0;
4435 
4436  av_freep(&st->codec->extradata);
4437  if (ff_alloc_extradata(st->codec, size))
4438  return AVERROR(ENOMEM);
4439  memcpy(st->codec->extradata, data, size);
4440 
4441  return 0;
4442 }
4443 
4445  int *size)
4446 {
4447  int i;
4448 
4449  for (i = 0; i < st->nb_side_data; i++) {
4450  if (st->side_data[i].type == type) {
4451  if (size)
4452  *size = st->side_data[i].size;
4453  return st->side_data[i].data;
4454  }
4455  }
4456  return NULL;
4457 }
4458 
4460  int size)
4461 {
4462  AVPacketSideData *sd, *tmp;
4463  int i;
4464  uint8_t *data = av_malloc(size);
4465 
4466  if (!data)
4467  return NULL;
4468 
4469  for (i = 0; i < st->nb_side_data; i++) {
4470  sd = &st->side_data[i];
4471 
4472  if (sd->type == type) {
4473  av_freep(&sd->data);
4474  sd->data = data;
4475  sd->size = size;
4476  return sd->data;
4477  }
4478  }
4479 
4480  tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4481  if (!tmp) {
4482  av_freep(&data);
4483  return NULL;
4484  }
4485 
4486  st->side_data = tmp;
4487  st->nb_side_data++;
4488 
4489  sd = &st->side_data[st->nb_side_data - 1];
4490  sd->type = type;
4491  sd->data = data;
4492  sd->size = size;
4493  return data;
4494 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1424
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:532
unsigned int max_index_size
Maximum amount of memory in bytes to use for the index of each stream.
Definition: avformat.h:1405
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:3877
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2200
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:941
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: avformat.h:983
#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:3759
int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.c:289
const struct AVCodec * codec
Definition: avcodec.h:1248
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:741
AVRational framerate
Definition: avcodec.h:3015
const char const char void * val
Definition: avisynth_c.h:672
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: avcodec.h:588
static void fill_all_stream_timings(AVFormatContext *ic)
Definition: utils.c:2315
#define AVFMT_NOBINSEARCH
Format does not allow to fall back on binary search via read_timestamp.
Definition: avformat.h:443
int64_t duration_gcd
Definition: avformat.h:947
float v
const char * s
Definition: avisynth_c.h:669
Bytestream IO Context.
Definition: avio.h:68
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static void update_initial_durations(AVFormatContext *s, AVStream *st, int stream_index, int duration)
Definition: utils.c:932
AVProbeData probe_data
Definition: avformat.h:1007
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:281
#define AV_PTS_WRAP_ADD_OFFSET
add the format specific offset on wrap detection
Definition: avformat.h:797
static int shift(int a, int b)
Definition: sonic.c:82
AVPacketSideDataType
Definition: avcodec.h:975
enum AVCodecID id
Definition: internal.h:41
int av_demuxer_open(AVFormatContext *ic)
Definition: utils.c:308
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:281
char * recommended_encoder_configuration
String containing paris of key and values describing recommended encoder configuration.
Definition: avformat.h:1130
struct AVPacketList * raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
Definition: internal.h:74
This structure describes decoded (raw) audio or video data.
Definition: frame.h:163
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:692
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1473
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
void(* ff_parse_key_val_cb)(void *context, const char *key, int key_len, char **dest, int *dest_len)
Callback function type for ff_parse_key_value.
Definition: internal.h:223
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:1734
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:1782
static void update_stream_timings(AVFormatContext *ic)
Estimate the stream timings from the one of each components.
Definition: utils.c:2243
struct AVPacketList * parse_queue_end
Definition: internal.h:80
enum AVCodecID id
Definition: mxfenc.c:95
static int get_std_framerate(int i)
Definition: utils.c:2821
const char * fmt
Definition: avisynth_c.h:670
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:63
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:1582
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:181
uint8_t * ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type, int size)
Add new side data to a stream.
Definition: utils.c:4459
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1185
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:104
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:1791
int64_t pts_buffer[MAX_REORDER_DELAY+1]
Definition: avformat.h:1009
int64_t pos
Definition: avformat.h:749
int probe_packets
Definition: avformat.h:992
#define NTP_OFFSET_US
Definition: internal.h:146
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2202
int64_t data_offset
offset of the first packet
Definition: internal.h:66
#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:4178
enum AVCodecID video_codec
default video codec
Definition: avformat.h:489
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1177
int64_t first_discard_sample
If not 0, the first audio sample that should be discarded from the stream.
Definition: avformat.h:1064
static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
Wrap a given time stamp, if there is an indication for an overflow.
Definition: utils.c:92
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: avformat.h:1088
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:879
void av_codec_set_pkt_timebase(AVCodecContext *avctx, AVRational val)
int num
numerator
Definition: rational.h:44
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:1743
int index
stream index in AVFormatContext
Definition: avformat.h:808
int size
Definition: avcodec.h:1161
const char * b
Definition: vf_curves.c:109
static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
Definition: utils.c:2389
#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:1574
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:203
#define AVIO_FLAG_READ
read-only
Definition: avio.h:368
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:427
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1011
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1648
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1621
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:4076
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1442
uint8_t * av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:4444
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:798
void ff_network_close(void)
Definition: network.c:179
int event_flags
Flags for the user to detect events happening on the file.
Definition: avformat.h:1510
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:775
#define a1
Definition: regdef.h:47
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
Definition: utils.c:2334
int ff_tls_init(void)
Definition: network.c:69
void * priv_data
Definition: avformat.h:827
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:276
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:777
AVInputFormat * av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:169
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
int duration
Duration of the current frame.
Definition: avcodec.h:4365
discard all
Definition: avcodec.h:667
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:919
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:4022
int priv_data_size
Size of private data so that it can be allocated in the wrapper.
Definition: avformat.h:644
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1275
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: utils.c:2717
AVDictionary * metadata
Definition: avformat.h:1195
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:670
int64_t maxsize
max filesize, used to limit allocations This field is internal to libavformat and access from outside...
Definition: avio.h:123
int av_dup_packet(AVPacket *pkt)
Definition: avpacket.c:249
static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
Definition: utils.c:1309
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:1067
#define sample
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1393
AVCodec.
Definition: avcodec.h:3173
static void force_codec_ids(AVFormatContext *s, AVStream *st)
Definition: utils.c:509
static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
Definition: utils.c:2562
static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
Definition: utils.c:2515
#define FFMPEG_LICENSE
Definition: config.h:5
static int has_decode_delay_been_guessed(AVStream *st)
Definition: utils.c:812
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264.c:56
int64_t last_dts_for_order_check
Internal data to analyze DTS and detect faulty mpeg streams.
Definition: avformat.h:1116
#define AV_DISPOSITION_KARAOKE
Definition: avformat.h:767
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1367
Undefined.
Definition: avutil.h:266
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:2058
Format I/O context.
Definition: avformat.h:1226
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:4201
unsigned int nb_stream_indexes
Definition: avformat.h:1166
int ff_network_inited_globally
Definition: network.c:130
#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:1343
int64_t cur_dts
Definition: avformat.h:984
#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.
#define DURATION_MAX_READ_SIZE
Definition: utils.c:2385
#define AVFMT_FLAG_DISCARD_CORRUPT
Discard frames marked corrupted.
Definition: avformat.h:1346
int(* read_close)(struct AVFormatContext *)
Close the stream.
Definition: avformat.h:675
static int64_t start_time
Definition: ffplay.c:319
if()
Definition: avfilter.c:975
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1991
uint8_t
Round toward +infinity.
Definition: mathematics.h:74
static int nb_streams
Definition: ffprobe.c:216
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
Opaque data information usually continuous.
Definition: avutil.h:196
#define AVFMT_FLAG_KEEP_SIDE_DATA
Don't merge side data but keep it separate.
Definition: avformat.h:1358
int ff_network_init(void)
Definition: network.c:132
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1187
AVOptions.
static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: utils.c:527
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:607
int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.c:299
timestamp utils, mostly useful for debugging/logging purposes
unsigned avformat_version(void)
Return the LIBAVFORMAT_VERSION_INT constant.
Definition: utils.c:62
const char * avformat_license(void)
Return the libavformat license.
Definition: utils.c:73
attribute_deprecated void(* destruct)(struct AVPacket *)
Definition: avcodec.h:1181
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:232
AVPacket pkt
Definition: avformat.h:1779
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
int id
unique ID to identify the chapter
Definition: avformat.h:1192
int id
Format-specific stream ID.
Definition: avformat.h:814
enum AVStreamParseType need_parsing
Definition: avformat.h:1000
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:2705
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:4222
int duration_count
Definition: avformat.h:948
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1338
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:923
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1353
int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
Allocate extradata with additional FF_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c:2880
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:3663
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
Definition: utils.c:264
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1294
char * av_small_strptime(const char *p, const char *fmt, struct tm *dt)
Parse the input string p according to the format string fmt and store its results in the structure dt...
Definition: parseutils.c:464
static AVFrame * frame
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:107
int inject_global_side_data
Internal data to inject global side data.
Definition: avformat.h:1123
const char * avformat_configuration(void)
Return the libavformat build-time configuration.
Definition: utils.c:68
int64_t bytes_read
Bytes read statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:136
#define MAX_REORDER_DELAY
Definition: avformat.h:1008
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:618
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:80
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:39
int64_t last_duration
Definition: avformat.h:961
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1337
#define DURATION_MAX_RETRY
Definition: utils.c:2386
uint8_t * data
Definition: avcodec.h:1160
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: utils.c:3731
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: avformat.h:658
int64_t probesize2
Maximum size of the data read from input for determining the input container format.
Definition: avformat.h:1730
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:2954
uint32_t tag
Definition: movenc.c:1332
int avformat_network_init(void)
Do global initialization of network components.
Definition: utils.c:4113
char * av_strndup(const char *s, size_t len)
Duplicate a substring of the string s.
Definition: mem.c:277
int fps_probe_size
The number of frames used for determining the framerate in avformat_find_stream_info().
Definition: avformat.h:1455
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:191
uint8_t * data
Definition: avcodec.h:1110
static void copy(LZOContext *c, int cnt)
Copies bytes from input to output buffer with checking.
Definition: lzo.c:85
const AVCodecDescriptor * av_codec_get_codec_descriptor(const AVCodecContext *avctx)
ptrdiff_t size
Definition: opengl_enc.c:101
int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt, const char *url, void *logctx, unsigned int offset, unsigned int max_probe_size)
Probe a bytestream to determine the input format.
Definition: format.c:239
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:273
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2718
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:62
static int64_t duration
Definition: ffplay.c:320
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1164
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1178
int raw_packet_buffer_remaining_size
Definition: internal.h:85
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:2717
const OptionDef options[]
Definition: ffserver.c:3749
void av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:208
unsigned int * stream_index
Definition: avformat.h:1165
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1381
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:743
#define av_log(a,...)
int64_t rfps_duration_sum
Definition: avformat.h:949
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:537
unsigned m
Definition: audioconvert.c:187
Duration estimated from bitrate (less accurate)
Definition: avformat.h:1213
unsigned int correct_ts_overflow
Correct single timestamp overflows.
Definition: avformat.h:1596
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1245
static const AVCodec * find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:149
int64_t start_time
Definition: avformat.h:1180
static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
Definition: utils.c:1167
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1206
static int determinable_frame_size(AVCodecContext *avctx)
Definition: utils.c:732
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:126
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:1859
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:643
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:147
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:3487
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:2830
#define AVINDEX_KEYFRAME
Definition: avformat.h:756
#define AVPROBE_SCORE_STREAM_RETRY
Definition: avformat.h:421
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
Definition: utils.c:3470
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1517
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: utils.c:1615
int format_probesize
number of bytes to read maximally to identify format.
Definition: avformat.h:1626
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:102
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:175
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:3299
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1435
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1531
int nb_decoded_frames
Number of internally decoded frames, used internally in libavformat, do not access its lifetime diffe...
Definition: avformat.h:1077
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:4353
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: utils.c:2340
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:1776
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given block if it is not large enough, otherwise do nothing.
Definition: mem.c:478
char * ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
Definition: utils.c:3948
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:1662
int av_codec_get_tag2(const AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)
Definition: utils.c:2769
struct AVCodecParser * parser
Definition: avcodec.h:4234
#define MAKE_ACCESSORS(str, name, type, field)
Definition: internal.h:86
int64_t pts_wrap_reference
reference dts for wrap detection
Definition: avformat.h:1183
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: avcodec.h:994
#define AVERROR(e)
Definition: error.h:43
#define SANE_CHUNK_SIZE
Definition: utils.c:175
#define AVFMT_FLAG_IGNDTS
Ignore DTS on frames that contain both DTS & PTS.
Definition: avformat.h:1341
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:3652
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:750
int(* query_codec)(enum AVCodecID id, int std_compliance)
Test if the given codec can be stored in this container.
Definition: avformat.h:543
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:4266
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:924
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:3756
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:405
int64_t convergence_duration
Time difference in AVStream->time_base units from the pts of this packet to the point at which the ou...
Definition: avcodec.h:1204
int capabilities
Codec capabilities.
Definition: avcodec.h:3192
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:196
unsigned int nb_programs
Definition: avformat.h:1374
int last_IP_duration
Definition: avformat.h:986
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
Definition: utils.c:3553
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:194
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:419
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1143
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1051
AVChapter ** chapters
Definition: avformat.h:1425
int rc_max_rate
maximum bitrate
Definition: avcodec.h:2325
simple assert() macros that are a bit more flexible than ISO C assert().
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:4270
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
Definition: mathematics.c:55
enum AVPacketSideDataType type
Definition: avcodec.h:1112
int side_data_elems
Definition: avcodec.h:1172
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet. ...
Definition: avformat.h:1056
static int is_intra_only(AVCodecContext *enc)
Definition: utils.c:796
enum AVCodecID codec_id
Definition: mov_chan.c:433
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
GLsizei count
Definition: opengl_enc.c:109
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:890
#define PARSER_FLAG_ONCE
Definition: avcodec.h:4267
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1161
#define FFMAX(a, b)
Definition: common.h:79
struct AVCodecParserContext * av_stream_get_parser(const AVStream *st)
Definition: utils.c:121
AVInputFormat * av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:222
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
Definition: avformat.h:759
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
const char av_format_ffversion[]
Definition: utils.c:55
AVCodec * audio_codec
Forced audio codec.
Definition: avformat.h:1672
#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:1357
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1166
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:2877
int seek_count
seek statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:142
Only parse headers, do not repack.
Definition: avformat.h:740
char * format_whitelist
',' separated list of allowed demuxers.
Definition: avformat.h:1642
static int genpts
Definition: ffplay.c:322
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:826
static AVPacket flush_pkt
Definition: ffplay.c:349
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:4097
int av_packet_merge_side_data(AVPacket *pkt)
Definition: avpacket.c:342
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1344
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:1675
static float distance(float x, float y, int band)
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:574
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 buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:416
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:3997
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:415
static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
Definition: utils.c:329
static AVPacketList * get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
Definition: utils.c:830
common internal API header
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:628
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:171
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1282
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: avformat.h:966
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
Definition: utils.c:3562
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:139
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:117
int bit_rate
the average bitrate
Definition: avcodec.h:1303
#define dynarray_add(tab, nb_ptr, elem)
Definition: internal.h:105
char filename[1024]
input or output filename
Definition: avformat.h:1302
#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:134
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: avformat.h:1105
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:247
#define FFMIN(a, b)
Definition: common.h:81
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1387
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:985
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:147
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:602
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:131
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:34
static const chunk_decoder decoder[8]
Definition: dfa.c:327
ret
Definition: avfilter.c:974
int width
picture width / height.
Definition: avcodec.h:1412
#define RELATIVE_TS_BASE
Definition: utils.c:79
int64_t offset
byte offset from starting packet start
Definition: avcodec.h:4272
int av_find_default_stream_index(AVFormatContext *s)
Definition: utils.c:1577
#define FAIL(errmsg)
int64_t convergence_duration
Time difference in stream time base units from the pts of this packet to the point at which the outpu...
Definition: avcodec.h:4300
Duration estimated from a stream with a known duration.
Definition: avformat.h:1212
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:221
uint8_t dts_ordered
Definition: avformat.h:1117
static int seek_frame_generic(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c:2023
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:1897
static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts)
Definition: utils.c:839
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
The call resulted in updated metadata.
Definition: avformat.h:1511
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:68
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:746
static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
Definition: utils.c:577
int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: utils.c:2486
#define AV_RL32
Definition: intreadwrite.h:146
static AVPacket * add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt, AVPacketList **plast_pktl)
Definition: utils.c:360
int n
Definition: avisynth_c.h:589
AVDictionary * metadata
Definition: avformat.h:881
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1376
#define AVPROBE_SCORE_RETRY
Definition: avformat.h:420
int probe_score
format probing score.
Definition: avformat.h:1619
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1345
int av_format_get_probe_score(const AVFormatContext *s)
Definition: utils.c:169
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:193
Opaque data information usually sparse.
Definition: avutil.h:198
int64_t skip_initial_bytes
Skip initial bytes when opening stream.
Definition: avformat.h:1589
int(* read_pause)(struct AVFormatContext *)
Pause playing - only meaningful if using a network-based format (RTSP).
Definition: avformat.h:705
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:506
#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:1128
unsigned int probesize
Definition: avformat.h:1363
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:107
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:1648
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:784
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:2957
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2751
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Return in 'buf' the path with 'd' replaced by a number.
Definition: utils.c:3822
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:250
uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1]
Definition: avformat.h:1111
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:776
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
Stream structure.
Definition: avformat.h:807
#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:437
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1194
int avformat_queue_attached_pictures(AVFormatContext *s)
Definition: utils.c:378
#define MAX_PROBE_PACKETS
Number of packets to buffer for codec probing.
Definition: avformat.h:991
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:4126
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2003
uint8_t dts_misordered
Definition: avformat.h:1118
#define FF_FDEBUG_TS
Definition: avformat.h:1479
static int width
Definition: utils.c:158
#define LIBAVFORMAT_VERSION_INT
Definition: version.h:36
sample_rate
#define AV_LOG_INFO
Standard information.
Definition: log.h:186
int64_t pts_reorder_error[MAX_REORDER_DELAY+1]
Internal data to generate dts from pts.
Definition: avformat.h:1110
int frame_size
Definition: mxfenc.c:1618
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:50
AVS_Value src
Definition: avisynth_c.h:524
int64_t end_time
Definition: avformat.h:1181
enum AVMediaType codec_type
Definition: avcodec.h:1247
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:2695
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:685
static int64_t ts_to_samples(AVStream *st, int64_t ts)
Definition: utils.c:1304
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrup a blocking function associated with cb.
Definition: avio.c:470
int debug
Flags to enable debugging.
Definition: avformat.h:1478
enum AVCodecID codec_id
Definition: avcodec.h:1256
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:253
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
Definition: utils.c:199
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1479
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:265
int sample_rate
samples per second
Definition: avcodec.h:1983
AVIOContext * pb
I/O context.
Definition: avformat.h:1268
unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
Definition: utils.c:2761
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:503
main external API structure.
Definition: avcodec.h:1239
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:2938
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:530
int io_repositioned
IO repositioned flag.
Definition: avformat.h:1656
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:257
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:244
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1271
attribute_deprecated int max_analyze_duration
Definition: avformat.h:1369
#define AVFMT_NOGENSEARCH
Format does not allow to fall back on generic search.
Definition: avformat.h:444
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in 'pkt'.
Definition: avformat.h:669
int pts_wrap_behavior
behavior on wrap detection
Definition: avformat.h:1184
void * buf
Definition: avisynth_c.h:595
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: avformat.h:950
GLint GLenum type
Definition: opengl_enc.c:105
int extradata_size
Definition: avcodec.h:1354
#define llrint(x)
Definition: libm.h:112
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:69
int nb_index_entries
Definition: avformat.h:1013
enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
Definition: utils.c:2786
Describe the class of an AVClass context structure.
Definition: log.h:66
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:3969
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:221
int index
Definition: gxfenc.c:89
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:438
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:490
#define SPACE_CHARS
Definition: internal.h:211
rational number numerator/denominator
Definition: rational.h:43
int64_t last_dts
Definition: avformat.h:946
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: avformat.h:1137
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1053
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:3817
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2201
const AVClass * av_class
A class for logging and AVOptions.
Definition: avformat.h:1231
AVMediaType
Definition: avutil.h:192
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:907
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:4308
int64_t fps_last_dts
Definition: avformat.h:968
#define RAW_PACKET_BUFFER_SIZE
Remaining size available for raw_packet_buffer, in bytes.
Definition: internal.h:84
static int seek_frame_internal(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: utils.c:2087
int64_t ff_iso8601_to_unix_time(const char *datestr)
Convert a date string in ISO8601 format to Unix timestamp.
Definition: utils.c:4085
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:1329
#define snprintf
Definition: snprintf.h:34
int found_decoder
0 -> decoder has not been searched for yet.
Definition: avformat.h:959
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:3600
int inject_global_side_data
Definition: internal.h:99
This structure contains the data a format has to probe a file.
Definition: avformat.h:413
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:3317
misc parsing utilities
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1469
static int has_duration(AVFormatContext *ic)
Return TRUE if the stream has accurate duration in any stream.
Definition: utils.c:2223
int avio_pause(AVIOContext *h, int pause)
Pause and resume playing - only meaningful if using a network streaming protocol (e.g.
Definition: aviobuf.c:962
Round toward -infinity.
Definition: mathematics.h:73
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:2154
static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
Definition: utils.c:2610
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:558
int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:136
int seek2any
Force seeking to any (also non key) frames.
Definition: avformat.h:1603
full parsing and repack of the first frame only, only implemented for H.264 currently ...
Definition: avformat.h:742
AVDictionary * metadata
Definition: avformat.h:1167
int64_t codec_info_duration
Definition: avformat.h:951
static int64_t pts
Global timestamp for the audio frames.
int fps_first_dts_idx
Definition: avformat.h:967
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:133
static int flags
Definition: cpu.c:47
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1311
Duration accurately estimated from PTSes.
Definition: avformat.h:1211
#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:2131
unsigned int tag
Definition: internal.h:42
struct AVPacketList * parse_queue
Packets split by the parser get queued here.
Definition: internal.h:79
int64_t start
Definition: avformat.h:1194
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:866
static int is_relative(int64_t ts)
Definition: utils.c:81
static int tb_unreliable(AVCodecContext *c)
Definition: utils.c:2845
Main libavformat public API header.
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: avcodec.h:1171
int(* split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: avcodec.h:4421
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1434
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:79
common internal api header.
struct AVPacketList * next
Definition: avformat.h:1780
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: utils.c:3789
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: avformat.h:1100
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:430
int(* read_play)(struct AVFormatContext *)
Start/resume playing - only meaningful if using a network-based format (RTSP).
Definition: avformat.h:699
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:143
#define CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: avcodec.h:854
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3019
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:859
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:196
AVCodec * video_codec
Forced video codec.
Definition: avformat.h:1664
static double c[64]
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:870
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:1202
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:92
void av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc)
int pts_wrap_bits
number of bits in pts (used for wrapping control)
Definition: avformat.h:973
Bi-dir predicted.
Definition: avutil.h:269
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:3571
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: utils.c:2896
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1193
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:206
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:112
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:49
void ff_id3v2_read(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta, unsigned int max_search_size)
Read an ID3v2 tag, including supported extra metadata and chapters.
Definition: id3v2.c:1045
int den
denominator
Definition: rational.h:45
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: avcodec.h:1207
unsigned bps
Definition: movenc.c:1333
struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1238
int64_t max_analyze_duration2
Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().
Definition: avformat.h:1722
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
Definition: utils.c:3635
#define FFMPEG_CONFIGURATION
Definition: config.h:4
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:796
int64_t codec_info_duration_fields
Definition: avformat.h:952
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:2997
Flag to pass INT64_MIN/MAX through instead of rescaling, this avoids special cases for AV_NOPTS_VALUE...
Definition: mathematics.h:76
unsigned int index_entries_allocated_size
Definition: avformat.h:1014
#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:1051
int64_t frame_offset
Definition: avcodec.h:4235
static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
Parse a packet, add all split parts to parse_queue.
Definition: utils.c:1183
static int read_from_packet_buffer(AVPacketList **pkt_buffer, AVPacketList **pkt_buffer_end, AVPacket *pkt)
Definition: utils.c:1289
static av_always_inline int diff(const uint32_t a, const uint32_t b)
struct AVPacketList * packet_buffer_end
Definition: internal.h:63
#define av_free(p)
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:445
char * value
Definition: dict.h:88
int ff_alloc_extradata(AVCodecContext *avctx, int size)
Allocate extradata with additional FF_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:2859
AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1680
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
#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:3
int len
int channels
number of audio channels
Definition: avcodec.h:1984
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:488
#define av_log2
Definition: intmath.h:105
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avformat.h:1634
struct AVCodecParserContext * parser
Definition: avformat.h:1001
void * priv_data
Format private data.
Definition: avformat.h:1254
int codec_info_nb_frames
Number of frames that have been demuxed during av_find_stream_info()
Definition: avformat.h:997
const struct PixelFormatTag * avpriv_get_raw_pix_fmt_tags(void)
Definition: raw.c:227
#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:401
static void flush_packet_queue(AVFormatContext *s)
Definition: utils.c:1563
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:765
static int height
Definition: utils.c:158
#define av_uninit(x)
Definition: attributes.h:141
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1159
static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags)
Definition: utils.c:2003
int bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1328
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:4250
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1321
int avformat_flush(AVFormatContext *s)
Discard all internally buffered data.
Definition: utils.c:2210
int64_t last_IP_pts
Definition: avformat.h:985
void ff_tls_deinit(void)
Definition: network.c:107
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:713
#define av_freep(p)
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:1980
void INT64 start
Definition: avisynth_c.h:595
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:593
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:325
unbuffered private I/O API
static void compute_chapters_end(AVFormatContext *s)
Definition: utils.c:2797
#define FFSWAP(type, a, b)
Definition: common.h:84
static void update_initial_timestamps(AVFormatContext *s, int stream_index, int64_t dts, int64_t pts, AVPacket *pkt)
Definition: utils.c:881
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:300
int fps_last_dts_idx
Definition: avformat.h:969
int stream_index
Definition: avcodec.h:1162
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:849
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:872
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:4136
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1027
int ffio_limit(AVIOContext *s, int size)
Definition: utils.c:177
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1046
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:1567
This structure stores compressed data.
Definition: avcodec.h:1137
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:942
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:4281
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:368
#define AVFMT_FLAG_NOFILLIN
Do not infer any values from other values, just return what is stored in the container.
Definition: avformat.h:1342
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:250
#define MAX_STD_TIMEBASES
Stream information used internally by av_find_stream_info()
Definition: avformat.h:944
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1153
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:899
int64_t av_stream_get_end_pts(const AVStream *st)
Returns the pts of the last muxed packet + its duration.
Definition: utils.c:116
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:241
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:240
#define av_unused
Definition: attributes.h:118
AVProgram ** programs
Definition: avformat.h:1375
struct AVStream::@136 * info
#define AVFMT_NEEDNUMBER
Needs 'd' in filename.
Definition: avformat.h:431
discard nothing
Definition: avcodec.h:661
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
struct AVPacketList * raw_packet_buffer_end
Definition: internal.h:75
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
Compare 2 integers modulo mod.
Definition: mathematics.c:165
const char * name
Definition: opengl_enc.c:103
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2949