FFmpeg  2.6.3
 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 4
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 < 7)
2828  return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2829 
2830  i -= 7;
2831 
2832  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2833 }
2834 
2835 /* Is the time base unreliable?
2836  * This is a heuristic to balance between quick acceptance of the values in
2837  * the headers vs. some extra checks.
2838  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2839  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2840  * And there are "variable" fps files this needs to detect as well. */
2842 {
2843  if (c->time_base.den >= 101LL * c->time_base.num ||
2844  c->time_base.den < 5LL * c->time_base.num ||
2845  // c->codec_tag == AV_RL32("DIVX") ||
2846  // c->codec_tag == AV_RL32("XVID") ||
2847  c->codec_tag == AV_RL32("mp4v") ||
2849  c->codec_id == AV_CODEC_ID_GIF ||
2850  c->codec_id == AV_CODEC_ID_H264)
2851  return 1;
2852  return 0;
2853 }
2854 
2856 {
2857  int ret;
2858 
2860  avctx->extradata = NULL;
2861  avctx->extradata_size = 0;
2862  return AVERROR(EINVAL);
2863  }
2865  if (avctx->extradata) {
2866  memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2867  avctx->extradata_size = size;
2868  ret = 0;
2869  } else {
2870  avctx->extradata_size = 0;
2871  ret = AVERROR(ENOMEM);
2872  }
2873  return ret;
2874 }
2875 
2877 {
2878  int ret = ff_alloc_extradata(avctx, size);
2879  if (ret < 0)
2880  return ret;
2881  ret = avio_read(pb, avctx->extradata, size);
2882  if (ret != size) {
2883  av_freep(&avctx->extradata);
2884  avctx->extradata_size = 0;
2885  av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2886  return ret < 0 ? ret : AVERROR_INVALIDDATA;
2887  }
2888 
2889  return ret;
2890 }
2891 
2892 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2893 {
2894  int i, j;
2895  int64_t last = st->info->last_dts;
2896 
2897  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2898  && ts - (uint64_t)last < INT64_MAX) {
2899  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2900  int64_t duration = ts - last;
2901 
2902  if (!st->info->duration_error)
2903  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2904  if (!st->info->duration_error)
2905  return AVERROR(ENOMEM);
2906 
2907 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2908 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2909  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2910  if (st->info->duration_error[0][1][i] < 1e10) {
2911  int framerate = get_std_framerate(i);
2912  double sdts = dts*framerate/(1001*12);
2913  for (j= 0; j<2; j++) {
2914  int64_t ticks = llrint(sdts+j*0.5);
2915  double error= sdts - ticks + j*0.5;
2916  st->info->duration_error[j][0][i] += error;
2917  st->info->duration_error[j][1][i] += error*error;
2918  }
2919  }
2920  }
2921  st->info->duration_count++;
2923 
2924  if (st->info->duration_count % 10 == 0) {
2925  int n = st->info->duration_count;
2926  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2927  if (st->info->duration_error[0][1][i] < 1e10) {
2928  double a0 = st->info->duration_error[0][0][i] / n;
2929  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2930  double a1 = st->info->duration_error[1][0][i] / n;
2931  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2932  if (error0 > 0.04 && error1 > 0.04) {
2933  st->info->duration_error[0][1][i] = 2e10;
2934  st->info->duration_error[1][1][i] = 2e10;
2935  }
2936  }
2937  }
2938  }
2939 
2940  // ignore the first 4 values, they might have some random jitter
2941  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2942  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2943  }
2944  if (ts != AV_NOPTS_VALUE)
2945  st->info->last_dts = ts;
2946 
2947  return 0;
2948 }
2949 
2951 {
2952  int i, j;
2953 
2954  for (i = 0; i < ic->nb_streams; i++) {
2955  AVStream *st = ic->streams[i];
2956 
2957  if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2958  continue;
2959  // the check for tb_unreliable() is not completely correct, since this is not about handling
2960  // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2961  // ipmovie.c produces.
2962  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)
2963  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);
2964  if (st->info->duration_count>1 && !st->r_frame_rate.num
2965  && tb_unreliable(st->codec)) {
2966  int num = 0;
2967  double best_error= 0.01;
2968  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2969 
2970  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2971  int k;
2972 
2973  if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2974  continue;
2975  if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2976  continue;
2977 
2978  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2979  continue;
2980 
2981  for (k= 0; k<2; k++) {
2982  int n = st->info->duration_count;
2983  double a= st->info->duration_error[k][0][j] / n;
2984  double error= st->info->duration_error[k][1][j]/n - a*a;
2985 
2986  if (error < best_error && best_error> 0.000000001) {
2987  best_error= error;
2988  num = get_std_framerate(j);
2989  }
2990  if (error < 0.02)
2991  av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2992  }
2993  }
2994  // do not increase frame rate by more than 1 % in order to match a standard rate.
2995  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2996  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2997  }
2998  if ( !st->avg_frame_rate.num
2999  && st->r_frame_rate.num && st->info->rfps_duration_sum
3000  && st->info->codec_info_duration <= 0
3001  && st->info->duration_count > 2
3002  && 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
3003  ) {
3004  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3005  st->avg_frame_rate = st->r_frame_rate;
3006  }
3007 
3008  av_freep(&st->info->duration_error);
3009  st->info->last_dts = AV_NOPTS_VALUE;
3010  st->info->duration_count = 0;
3011  st->info->rfps_duration_sum = 0;
3012  }
3013 }
3014 
3016 {
3017  int i, count, ret = 0, j;
3018  int64_t read_size;
3019  AVStream *st;
3020  AVPacket pkt1, *pkt;
3021  int64_t old_offset = avio_tell(ic->pb);
3022  // new streams might appear, no options for those
3023  int orig_nb_streams = ic->nb_streams;
3024  int flush_codecs;
3025  int64_t max_analyze_duration = ic->max_analyze_duration2;
3026  int64_t max_stream_analyze_duration;
3027  int64_t probesize = ic->probesize2;
3028 
3029  if (!max_analyze_duration)
3030  max_analyze_duration = ic->max_analyze_duration;
3031  if (ic->probesize)
3032  probesize = ic->probesize;
3033  flush_codecs = probesize > 0;
3034 
3035  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3036 
3037  max_stream_analyze_duration = max_analyze_duration;
3038  if (!max_analyze_duration) {
3039  max_stream_analyze_duration =
3040  max_analyze_duration = 5*AV_TIME_BASE;
3041  if (!strcmp(ic->iformat->name, "flv"))
3042  max_stream_analyze_duration = 30*AV_TIME_BASE;
3043  }
3044 
3045  if (ic->pb)
3046  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3047  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3048 
3049  for (i = 0; i < ic->nb_streams; i++) {
3050  const AVCodec *codec;
3051  AVDictionary *thread_opt = NULL;
3052  st = ic->streams[i];
3053 
3054  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3056 /* if (!st->time_base.num)
3057  st->time_base = */
3058  if (!st->codec->time_base.num)
3059  st->codec->time_base = st->time_base;
3060  }
3061  // only for the split stuff
3062  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3063  st->parser = av_parser_init(st->codec->codec_id);
3064  if (st->parser) {
3065  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3067  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3069  }
3070  } else if (st->need_parsing) {
3071  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3072  "%s, packets or times may be invalid.\n",
3074  }
3075  }
3076  codec = find_decoder(ic, st, st->codec->codec_id);
3077 
3078  /* Force thread count to 1 since the H.264 decoder will not extract
3079  * SPS and PPS to extradata during multi-threaded decoding. */
3080  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3081 
3082  if (ic->codec_whitelist)
3083  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3084 
3085  /* Ensure that subtitle_header is properly set. */
3087  && codec && !st->codec->codec) {
3088  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3089  av_log(ic, AV_LOG_WARNING,
3090  "Failed to open codec in av_find_stream_info\n");
3091  }
3092 
3093  // Try to just open decoders, in case this is enough to get parameters.
3094  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3095  if (codec && !st->codec->codec)
3096  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3097  av_log(ic, AV_LOG_WARNING,
3098  "Failed to open codec in av_find_stream_info\n");
3099  }
3100  if (!options)
3101  av_dict_free(&thread_opt);
3102  }
3103 
3104  for (i = 0; i < ic->nb_streams; i++) {
3105 #if FF_API_R_FRAME_RATE
3106  ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3107 #endif
3110  }
3111 
3112  count = 0;
3113  read_size = 0;
3114  for (;;) {
3115  int analyzed_all_streams;
3117  ret = AVERROR_EXIT;
3118  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3119  break;
3120  }
3121 
3122  /* check if one codec still needs to be handled */
3123  for (i = 0; i < ic->nb_streams; i++) {
3124  int fps_analyze_framecount = 20;
3125 
3126  st = ic->streams[i];
3127  if (!has_codec_parameters(st, NULL))
3128  break;
3129  /* If the timebase is coarse (like the usual millisecond precision
3130  * of mkv), we need to analyze more frames to reliably arrive at
3131  * the correct fps. */
3132  if (av_q2d(st->time_base) > 0.0005)
3133  fps_analyze_framecount *= 2;
3134  if (!tb_unreliable(st->codec))
3135  fps_analyze_framecount = 0;
3136  if (ic->fps_probe_size >= 0)
3137  fps_analyze_framecount = ic->fps_probe_size;
3139  fps_analyze_framecount = 0;
3140  /* variable fps and no guess at the real fps */
3141  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3142  st->info->duration_count < fps_analyze_framecount &&
3144  break;
3145  if (st->parser && st->parser->parser->split &&
3146  !st->codec->extradata)
3147  break;
3148  if (st->first_dts == AV_NOPTS_VALUE &&
3149  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3150  st->codec_info_nb_frames < ic->max_ts_probe &&
3151  (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3153  break;
3154  }
3155  analyzed_all_streams = 0;
3156  if (i == ic->nb_streams) {
3157  analyzed_all_streams = 1;
3158  /* NOTE: If the format has no header, then we need to read some
3159  * packets to get most of the streams, so we cannot stop here. */
3160  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3161  /* If we found the info for all the codecs, we can stop. */
3162  ret = count;
3163  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3164  flush_codecs = 0;
3165  break;
3166  }
3167  }
3168  /* We did not get all the codec info, but we read too much data. */
3169  if (read_size >= probesize) {
3170  ret = count;
3171  av_log(ic, AV_LOG_DEBUG,
3172  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3173  for (i = 0; i < ic->nb_streams; i++)
3174  if (!ic->streams[i]->r_frame_rate.num &&
3175  ic->streams[i]->info->duration_count <= 1 &&
3177  strcmp(ic->iformat->name, "image2"))
3178  av_log(ic, AV_LOG_WARNING,
3179  "Stream #%d: not enough frames to estimate rate; "
3180  "consider increasing probesize\n", i);
3181  break;
3182  }
3183 
3184  /* NOTE: A new stream can be added there if no header in file
3185  * (AVFMTCTX_NOHEADER). */
3186  ret = read_frame_internal(ic, &pkt1);
3187  if (ret == AVERROR(EAGAIN))
3188  continue;
3189 
3190  if (ret < 0) {
3191  /* EOF or error*/
3192  break;
3193  }
3194 
3195  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3197  &ic->internal->packet_buffer_end);
3198  {
3199  pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3200  &ic->internal->packet_buffer_end);
3201  if (!pkt) {
3202  ret = AVERROR(ENOMEM);
3203  goto find_stream_info_err;
3204  }
3205  if ((ret = av_dup_packet(pkt)) < 0)
3206  goto find_stream_info_err;
3207  }
3208 
3209  st = ic->streams[pkt->stream_index];
3211  read_size += pkt->size;
3212 
3213  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3214  /* check for non-increasing dts */
3215  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3216  st->info->fps_last_dts >= pkt->dts) {
3217  av_log(ic, AV_LOG_DEBUG,
3218  "Non-increasing DTS in stream %d: packet %d with DTS "
3219  "%"PRId64", packet %d with DTS %"PRId64"\n",
3220  st->index, st->info->fps_last_dts_idx,
3222  pkt->dts);
3223  st->info->fps_first_dts =
3225  }
3226  /* Check for a discontinuity in dts. If the difference in dts
3227  * is more than 1000 times the average packet duration in the
3228  * sequence, we treat it as a discontinuity. */
3229  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3231  (pkt->dts - st->info->fps_last_dts) / 1000 >
3232  (st->info->fps_last_dts - st->info->fps_first_dts) /
3233  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3234  av_log(ic, AV_LOG_WARNING,
3235  "DTS discontinuity in stream %d: packet %d with DTS "
3236  "%"PRId64", packet %d with DTS %"PRId64"\n",
3237  st->index, st->info->fps_last_dts_idx,
3239  pkt->dts);
3240  st->info->fps_first_dts =
3242  }
3243 
3244  /* update stored dts values */
3245  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3246  st->info->fps_first_dts = pkt->dts;
3248  }
3249  st->info->fps_last_dts = pkt->dts;
3251  }
3252  if (st->codec_info_nb_frames>1) {
3253  int64_t t = 0;
3254 
3255  if (st->time_base.den > 0)
3257  if (st->avg_frame_rate.num > 0)
3259 
3260  if ( t == 0
3261  && st->codec_info_nb_frames>30
3262  && st->info->fps_first_dts != AV_NOPTS_VALUE
3263  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3265 
3266  if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3267  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3268  max_analyze_duration,
3269  t);
3270  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3271  av_packet_unref(pkt);
3272  break;
3273  }
3274  if (pkt->duration) {
3275  st->info->codec_info_duration += pkt->duration;
3276  st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3277  }
3278  }
3279 #if FF_API_R_FRAME_RATE
3280  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3281  ff_rfps_add_frame(ic, st, pkt->dts);
3282 #endif
3283  if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3284  int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3285  if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3286  if (ff_alloc_extradata(st->codec, i))
3287  return AVERROR(ENOMEM);
3288  memcpy(st->codec->extradata, pkt->data,
3289  st->codec->extradata_size);
3290  }
3291  }
3292 
3293  /* If still no information, we try to open the codec and to
3294  * decompress the frame. We try to avoid that in most cases as
3295  * it takes longer and uses more memory. For MPEG-4, we need to
3296  * decompress for QuickTime.
3297  *
3298  * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3299  * least one frame of codec data, this makes sure the codec initializes
3300  * the channel configuration and does not only trust the values from
3301  * the container. */
3302  try_decode_frame(ic, st, pkt,
3303  (options && i < orig_nb_streams) ? &options[i] : NULL);
3304 
3305  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3306  av_packet_unref(pkt);
3307 
3308  st->codec_info_nb_frames++;
3309  count++;
3310  }
3311 
3312  if (flush_codecs) {
3313  AVPacket empty_pkt = { 0 };
3314  int err = 0;
3315  av_init_packet(&empty_pkt);
3316 
3317  for (i = 0; i < ic->nb_streams; i++) {
3318 
3319  st = ic->streams[i];
3320 
3321  /* flush the decoders */
3322  if (st->info->found_decoder == 1) {
3323  do {
3324  err = try_decode_frame(ic, st, &empty_pkt,
3325  (options && i < orig_nb_streams)
3326  ? &options[i] : NULL);
3327  } while (err > 0 && !has_codec_parameters(st, NULL));
3328 
3329  if (err < 0) {
3330  av_log(ic, AV_LOG_INFO,
3331  "decoding for stream %d failed\n", st->index);
3332  }
3333  }
3334  }
3335  }
3336 
3337  // close codecs which were opened in try_decode_frame()
3338  for (i = 0; i < ic->nb_streams; i++) {
3339  st = ic->streams[i];
3340  avcodec_close(st->codec);
3341  }
3342 
3343  ff_rfps_calculate(ic);
3344 
3345  for (i = 0; i < ic->nb_streams; i++) {
3346  st = ic->streams[i];
3347  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3351  st->codec->codec_tag= tag;
3352  }
3353 
3354  /* estimate average framerate if not set by demuxer */
3355  if (st->info->codec_info_duration_fields &&
3356  !st->avg_frame_rate.num &&
3357  st->info->codec_info_duration) {
3358  int best_fps = 0;
3359  double best_error = 0.01;
3360 
3361  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3362  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3363  st->info->codec_info_duration < 0)
3364  continue;
3366  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3367  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3368 
3369  /* Round guessed framerate to a "standard" framerate if it's
3370  * within 1% of the original estimate. */
3371  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3372  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3373  double error = fabs(av_q2d(st->avg_frame_rate) /
3374  av_q2d(std_fps) - 1);
3375 
3376  if (error < best_error) {
3377  best_error = error;
3378  best_fps = std_fps.num;
3379  }
3380  }
3381  if (best_fps)
3383  best_fps, 12 * 1001, INT_MAX);
3384  }
3385 
3386  if (!st->r_frame_rate.num) {
3387  if ( st->codec->time_base.den * (int64_t) st->time_base.num
3388  <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3389  st->r_frame_rate.num = st->codec->time_base.den;
3391  } else {
3392  st->r_frame_rate.num = st->time_base.den;
3393  st->r_frame_rate.den = st->time_base.num;
3394  }
3395  }
3397  AVRational hw_ratio = { st->codec->height, st->codec->width };
3399  hw_ratio);
3400  }
3401  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3402  if (!st->codec->bits_per_coded_sample)
3405  // set stream disposition based on audio service type
3406  switch (st->codec->audio_service_type) {
3409  break;
3412  break;
3415  break;
3418  break;
3421  break;
3422  }
3423  }
3424  }
3425 
3426  if (probesize)
3427  estimate_timings(ic, old_offset);
3428 
3429  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3430 
3431  if (ret >= 0 && ic->nb_streams)
3432  /* We could not have all the codec parameters before EOF. */
3433  ret = -1;
3434  for (i = 0; i < ic->nb_streams; i++) {
3435  const char *errmsg;
3436  st = ic->streams[i];
3437  if (!has_codec_parameters(st, &errmsg)) {
3438  char buf[256];
3439  avcodec_string(buf, sizeof(buf), st->codec, 0);
3440  av_log(ic, AV_LOG_WARNING,
3441  "Could not find codec parameters for stream %d (%s): %s\n"
3442  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3443  i, buf, errmsg);
3444  } else {
3445  ret = 0;
3446  }
3447  }
3448 
3450 
3451 find_stream_info_err:
3452  for (i = 0; i < ic->nb_streams; i++) {
3453  st = ic->streams[i];
3454  if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3455  ic->streams[i]->codec->thread_count = 0;
3456  if (st->info)
3457  av_freep(&st->info->duration_error);
3458  av_freep(&ic->streams[i]->info);
3459  }
3460  if (ic->pb)
3461  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3462  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3463  return ret;
3464 }
3465 
3467 {
3468  int i, j;
3469 
3470  for (i = 0; i < ic->nb_programs; i++) {
3471  if (ic->programs[i] == last) {
3472  last = NULL;
3473  } else {
3474  if (!last)
3475  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3476  if (ic->programs[i]->stream_index[j] == s)
3477  return ic->programs[i];
3478  }
3479  }
3480  return NULL;
3481 }
3482 
3484  int wanted_stream_nb, int related_stream,
3485  AVCodec **decoder_ret, int flags)
3486 {
3487  int i, nb_streams = ic->nb_streams;
3488  int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3489  unsigned *program = NULL;
3490  const AVCodec *decoder = NULL, *best_decoder = NULL;
3491 
3492  if (related_stream >= 0 && wanted_stream_nb < 0) {
3493  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3494  if (p) {
3495  program = p->stream_index;
3496  nb_streams = p->nb_stream_indexes;
3497  }
3498  }
3499  for (i = 0; i < nb_streams; i++) {
3500  int real_stream_index = program ? program[i] : i;
3501  AVStream *st = ic->streams[real_stream_index];
3502  AVCodecContext *avctx = st->codec;
3503  if (avctx->codec_type != type)
3504  continue;
3505  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3506  continue;
3507  if (wanted_stream_nb != real_stream_index &&
3510  continue;
3511  if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3512  continue;
3513  if (decoder_ret) {
3514  decoder = find_decoder(ic, st, st->codec->codec_id);
3515  if (!decoder) {
3516  if (ret < 0)
3518  continue;
3519  }
3520  }
3522  bitrate = avctx->bit_rate;
3523  if (!bitrate)
3524  bitrate = avctx->rc_max_rate;
3525  multiframe = FFMIN(5, count);
3526  if ((best_multiframe > multiframe) ||
3527  (best_multiframe == multiframe && best_bitrate > bitrate) ||
3528  (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3529  continue;
3530  best_count = count;
3531  best_bitrate = bitrate;
3532  best_multiframe = multiframe;
3533  ret = real_stream_index;
3534  best_decoder = decoder;
3535  if (program && i == nb_streams - 1 && ret < 0) {
3536  program = NULL;
3537  nb_streams = ic->nb_streams;
3538  /* no related stream found, try again with everything */
3539  i = 0;
3540  }
3541  }
3542  if (decoder_ret)
3543  *decoder_ret = (AVCodec*)best_decoder;
3544  return ret;
3545 }
3546 
3547 /*******************************************************/
3548 
3550 {
3551  if (s->iformat->read_play)
3552  return s->iformat->read_play(s);
3553  if (s->pb)
3554  return avio_pause(s->pb, 0);
3555  return AVERROR(ENOSYS);
3556 }
3557 
3559 {
3560  if (s->iformat->read_pause)
3561  return s->iformat->read_pause(s);
3562  if (s->pb)
3563  return avio_pause(s->pb, 1);
3564  return AVERROR(ENOSYS);
3565 }
3566 
3568  int j;
3569  av_assert0(s->nb_streams>0);
3570  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3571 
3572  for (j = 0; j < st->nb_side_data; j++)
3573  av_freep(&st->side_data[j].data);
3574  av_freep(&st->side_data);
3575  st->nb_side_data = 0;
3576 
3577  if (st->parser) {
3578  av_parser_close(st->parser);
3579  }
3580  if (st->attached_pic.data)
3582  av_dict_free(&st->metadata);
3583  av_freep(&st->probe_data.buf);
3584  av_freep(&st->index_entries);
3585  av_freep(&st->codec->extradata);
3587  av_freep(&st->codec);
3588  av_freep(&st->priv_data);
3589  if (st->info)
3590  av_freep(&st->info->duration_error);
3591  av_freep(&st->info);
3593  av_freep(&s->streams[ --s->nb_streams ]);
3594 }
3595 
3597 {
3598  int i;
3599 
3600  if (!s)
3601  return;
3602 
3603  av_opt_free(s);
3604  if (s->iformat && s->iformat->priv_class && s->priv_data)
3605  av_opt_free(s->priv_data);
3606  if (s->oformat && s->oformat->priv_class && s->priv_data)
3607  av_opt_free(s->priv_data);
3608 
3609  for (i = s->nb_streams - 1; i >= 0; i--) {
3610  ff_free_stream(s, s->streams[i]);
3611  }
3612  for (i = s->nb_programs - 1; i >= 0; i--) {
3613  av_dict_free(&s->programs[i]->metadata);
3614  av_freep(&s->programs[i]->stream_index);
3615  av_freep(&s->programs[i]);
3616  }
3617  av_freep(&s->programs);
3618  av_freep(&s->priv_data);
3619  while (s->nb_chapters--) {
3621  av_freep(&s->chapters[s->nb_chapters]);
3622  }
3623  av_freep(&s->chapters);
3624  av_dict_free(&s->metadata);
3625  av_freep(&s->streams);
3626  av_freep(&s->internal);
3627  flush_packet_queue(s);
3628  av_free(s);
3629 }
3630 
3632 {
3633  AVFormatContext *s;
3634  AVIOContext *pb;
3635 
3636  if (!ps || !*ps)
3637  return;
3638 
3639  s = *ps;
3640  pb = s->pb;
3641 
3642  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3643  (s->flags & AVFMT_FLAG_CUSTOM_IO))
3644  pb = NULL;
3645 
3646  flush_packet_queue(s);
3647 
3648  if (s->iformat)
3649  if (s->iformat->read_close)
3650  s->iformat->read_close(s);
3651 
3653 
3654  *ps = NULL;
3655 
3656  avio_close(pb);
3657 }
3658 
3660 {
3661  AVStream *st;
3662  int i;
3663  AVStream **streams;
3664 
3665  if (s->nb_streams >= INT_MAX/sizeof(*streams))
3666  return NULL;
3667  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3668  if (!streams)
3669  return NULL;
3670  s->streams = streams;
3671 
3672  st = av_mallocz(sizeof(AVStream));
3673  if (!st)
3674  return NULL;
3675  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3676  av_free(st);
3677  return NULL;
3678  }
3679  st->info->last_dts = AV_NOPTS_VALUE;
3680 
3681  st->codec = avcodec_alloc_context3(c);
3682  if (!st->codec) {
3683  av_free(st->info);
3684  av_free(st);
3685  return NULL;
3686  }
3687  if (s->iformat) {
3688  /* no default bitrate if decoding */
3689  st->codec->bit_rate = 0;
3690 
3691  /* default pts setting is MPEG-like */
3692  avpriv_set_pts_info(st, 33, 1, 90000);
3693  }
3694 
3695  st->index = s->nb_streams;
3696  st->start_time = AV_NOPTS_VALUE;
3697  st->duration = AV_NOPTS_VALUE;
3698  /* we set the current DTS to 0 so that formats without any timestamps
3699  * but durations get some timestamps, formats with some unknown
3700  * timestamps have their first few packets buffered and the
3701  * timestamps corrected before they are returned to the user */
3702  st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3703  st->first_dts = AV_NOPTS_VALUE;
3707 
3710  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3711  st->pts_buffer[i] = AV_NOPTS_VALUE;
3712 
3713  st->sample_aspect_ratio = (AVRational) { 0, 1 };
3714 
3715 #if FF_API_R_FRAME_RATE
3716  st->info->last_dts = AV_NOPTS_VALUE;
3717 #endif
3720 
3722 
3723  s->streams[s->nb_streams++] = st;
3724  return st;
3725 }
3726 
3728 {
3729  AVProgram *program = NULL;
3730  int i;
3731 
3732  av_dlog(ac, "new_program: id=0x%04x\n", id);
3733 
3734  for (i = 0; i < ac->nb_programs; i++)
3735  if (ac->programs[i]->id == id)
3736  program = ac->programs[i];
3737 
3738  if (!program) {
3739  program = av_mallocz(sizeof(AVProgram));
3740  if (!program)
3741  return NULL;
3742  dynarray_add(&ac->programs, &ac->nb_programs, program);
3743  program->discard = AVDISCARD_NONE;
3744  }
3745  program->id = id;
3748 
3749  program->start_time =
3750  program->end_time = AV_NOPTS_VALUE;
3751 
3752  return program;
3753 }
3754 
3756  int64_t start, int64_t end, const char *title)
3757 {
3758  AVChapter *chapter = NULL;
3759  int i;
3760 
3761  if (end != AV_NOPTS_VALUE && start > end) {
3762  av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3763  return NULL;
3764  }
3765 
3766  for (i = 0; i < s->nb_chapters; i++)
3767  if (s->chapters[i]->id == id)
3768  chapter = s->chapters[i];
3769 
3770  if (!chapter) {
3771  chapter = av_mallocz(sizeof(AVChapter));
3772  if (!chapter)
3773  return NULL;
3774  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3775  }
3776  av_dict_set(&chapter->metadata, "title", title, 0);
3777  chapter->id = id;
3778  chapter->time_base = time_base;
3779  chapter->start = start;
3780  chapter->end = end;
3781 
3782  return chapter;
3783 }
3784 
3785 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3786 {
3787  int i, j;
3788  AVProgram *program = NULL;
3789  void *tmp;
3790 
3791  if (idx >= ac->nb_streams) {
3792  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3793  return;
3794  }
3795 
3796  for (i = 0; i < ac->nb_programs; i++) {
3797  if (ac->programs[i]->id != progid)
3798  continue;
3799  program = ac->programs[i];
3800  for (j = 0; j < program->nb_stream_indexes; j++)
3801  if (program->stream_index[j] == idx)
3802  return;
3803 
3804  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3805  if (!tmp)
3806  return;
3807  program->stream_index = tmp;
3808  program->stream_index[program->nb_stream_indexes++] = idx;
3809  return;
3810  }
3811 }
3812 
3813 uint64_t ff_ntp_time(void)
3814 {
3815  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3816 }
3817 
3818 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3819 {
3820  const char *p;
3821  char *q, buf1[20], c;
3822  int nd, len, percentd_found;
3823 
3824  q = buf;
3825  p = path;
3826  percentd_found = 0;
3827  for (;;) {
3828  c = *p++;
3829  if (c == '\0')
3830  break;
3831  if (c == '%') {
3832  do {
3833  nd = 0;
3834  while (av_isdigit(*p))
3835  nd = nd * 10 + *p++ - '0';
3836  c = *p++;
3837  } while (av_isdigit(c));
3838 
3839  switch (c) {
3840  case '%':
3841  goto addchar;
3842  case 'd':
3843  if (percentd_found)
3844  goto fail;
3845  percentd_found = 1;
3846  if (number < 0)
3847  nd += 1;
3848  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3849  len = strlen(buf1);
3850  if ((q - buf + len) > buf_size - 1)
3851  goto fail;
3852  memcpy(q, buf1, len);
3853  q += len;
3854  break;
3855  default:
3856  goto fail;
3857  }
3858  } else {
3859 addchar:
3860  if ((q - buf) < buf_size - 1)
3861  *q++ = c;
3862  }
3863  }
3864  if (!percentd_found)
3865  goto fail;
3866  *q = '\0';
3867  return 0;
3868 fail:
3869  *q = '\0';
3870  return -1;
3871 }
3872 
3873 void av_url_split(char *proto, int proto_size,
3874  char *authorization, int authorization_size,
3875  char *hostname, int hostname_size,
3876  int *port_ptr, char *path, int path_size, const char *url)
3877 {
3878  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3879 
3880  if (port_ptr)
3881  *port_ptr = -1;
3882  if (proto_size > 0)
3883  proto[0] = 0;
3884  if (authorization_size > 0)
3885  authorization[0] = 0;
3886  if (hostname_size > 0)
3887  hostname[0] = 0;
3888  if (path_size > 0)
3889  path[0] = 0;
3890 
3891  /* parse protocol */
3892  if ((p = strchr(url, ':'))) {
3893  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3894  p++; /* skip ':' */
3895  if (*p == '/')
3896  p++;
3897  if (*p == '/')
3898  p++;
3899  } else {
3900  /* no protocol means plain filename */
3901  av_strlcpy(path, url, path_size);
3902  return;
3903  }
3904 
3905  /* separate path from hostname */
3906  ls = strchr(p, '/');
3907  ls2 = strchr(p, '?');
3908  if (!ls)
3909  ls = ls2;
3910  else if (ls && ls2)
3911  ls = FFMIN(ls, ls2);
3912  if (ls)
3913  av_strlcpy(path, ls, path_size);
3914  else
3915  ls = &p[strlen(p)]; // XXX
3916 
3917  /* the rest is hostname, use that to parse auth/port */
3918  if (ls != p) {
3919  /* authorization (user[:pass]@hostname) */
3920  at2 = p;
3921  while ((at = strchr(p, '@')) && at < ls) {
3922  av_strlcpy(authorization, at2,
3923  FFMIN(authorization_size, at + 1 - at2));
3924  p = at + 1; /* skip '@' */
3925  }
3926 
3927  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3928  /* [host]:port */
3929  av_strlcpy(hostname, p + 1,
3930  FFMIN(hostname_size, brk - p));
3931  if (brk[1] == ':' && port_ptr)
3932  *port_ptr = atoi(brk + 2);
3933  } else if ((col = strchr(p, ':')) && col < ls) {
3934  av_strlcpy(hostname, p,
3935  FFMIN(col + 1 - p, hostname_size));
3936  if (port_ptr)
3937  *port_ptr = atoi(col + 1);
3938  } else
3939  av_strlcpy(hostname, p,
3940  FFMIN(ls + 1 - p, hostname_size));
3941  }
3942 }
3943 
3944 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3945 {
3946  int i;
3947  static const char hex_table_uc[16] = { '0', '1', '2', '3',
3948  '4', '5', '6', '7',
3949  '8', '9', 'A', 'B',
3950  'C', 'D', 'E', 'F' };
3951  static const char hex_table_lc[16] = { '0', '1', '2', '3',
3952  '4', '5', '6', '7',
3953  '8', '9', 'a', 'b',
3954  'c', 'd', 'e', 'f' };
3955  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3956 
3957  for (i = 0; i < s; i++) {
3958  buff[i * 2] = hex_table[src[i] >> 4];
3959  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3960  }
3961 
3962  return buff;
3963 }
3964 
3965 int ff_hex_to_data(uint8_t *data, const char *p)
3966 {
3967  int c, len, v;
3968 
3969  len = 0;
3970  v = 1;
3971  for (;;) {
3972  p += strspn(p, SPACE_CHARS);
3973  if (*p == '\0')
3974  break;
3975  c = av_toupper((unsigned char) *p++);
3976  if (c >= '0' && c <= '9')
3977  c = c - '0';
3978  else if (c >= 'A' && c <= 'F')
3979  c = c - 'A' + 10;
3980  else
3981  break;
3982  v = (v << 4) | c;
3983  if (v & 0x100) {
3984  if (data)
3985  data[len] = v;
3986  len++;
3987  v = 1;
3988  }
3989  }
3990  return len;
3991 }
3992 
3993 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3994  unsigned int pts_num, unsigned int pts_den)
3995 {
3996  AVRational new_tb;
3997  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3998  if (new_tb.num != pts_num)
4000  "st:%d removing common factor %d from timebase\n",
4001  s->index, pts_num / new_tb.num);
4002  } else
4004  "st:%d has too large timebase, reducing\n", s->index);
4005 
4006  if (new_tb.num <= 0 || new_tb.den <= 0) {
4008  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4009  new_tb.num, new_tb.den,
4010  s->index);
4011  return;
4012  }
4013  s->time_base = new_tb;
4014  av_codec_set_pkt_timebase(s->codec, new_tb);
4015  s->pts_wrap_bits = pts_wrap_bits;
4016 }
4017 
4018 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4019  void *context)
4020 {
4021  const char *ptr = str;
4022 
4023  /* Parse key=value pairs. */
4024  for (;;) {
4025  const char *key;
4026  char *dest = NULL, *dest_end;
4027  int key_len, dest_len = 0;
4028 
4029  /* Skip whitespace and potential commas. */
4030  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4031  ptr++;
4032  if (!*ptr)
4033  break;
4034 
4035  key = ptr;
4036 
4037  if (!(ptr = strchr(key, '=')))
4038  break;
4039  ptr++;
4040  key_len = ptr - key;
4041 
4042  callback_get_buf(context, key, key_len, &dest, &dest_len);
4043  dest_end = dest + dest_len - 1;
4044 
4045  if (*ptr == '\"') {
4046  ptr++;
4047  while (*ptr && *ptr != '\"') {
4048  if (*ptr == '\\') {
4049  if (!ptr[1])
4050  break;
4051  if (dest && dest < dest_end)
4052  *dest++ = ptr[1];
4053  ptr += 2;
4054  } else {
4055  if (dest && dest < dest_end)
4056  *dest++ = *ptr;
4057  ptr++;
4058  }
4059  }
4060  if (*ptr == '\"')
4061  ptr++;
4062  } else {
4063  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4064  if (dest && dest < dest_end)
4065  *dest++ = *ptr;
4066  }
4067  if (dest)
4068  *dest = 0;
4069  }
4070 }
4071 
4073 {
4074  int i;
4075  for (i = 0; i < s->nb_streams; i++)
4076  if (s->streams[i]->id == id)
4077  return i;
4078  return -1;
4079 }
4080 
4081 int64_t ff_iso8601_to_unix_time(const char *datestr)
4082 {
4083  struct tm time1 = { 0 }, time2 = { 0 };
4084  char *ret1, *ret2;
4085  ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4086  ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4087  if (ret2 && !ret1)
4088  return av_timegm(&time2);
4089  else
4090  return av_timegm(&time1);
4091 }
4092 
4094  int std_compliance)
4095 {
4096  if (ofmt) {
4097  if (ofmt->query_codec)
4098  return ofmt->query_codec(codec_id, std_compliance);
4099  else if (ofmt->codec_tag)
4100  return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4101  else if (codec_id == ofmt->video_codec ||
4102  codec_id == ofmt->audio_codec ||
4103  codec_id == ofmt->subtitle_codec)
4104  return 1;
4105  }
4106  return AVERROR_PATCHWELCOME;
4107 }
4108 
4110 {
4111 #if CONFIG_NETWORK
4112  int ret;
4114  if ((ret = ff_network_init()) < 0)
4115  return ret;
4116  if ((ret = ff_tls_init()) < 0)
4117  return ret;
4118 #endif
4119  return 0;
4120 }
4121 
4123 {
4124 #if CONFIG_NETWORK
4125  ff_network_close();
4126  ff_tls_deinit();
4128 #endif
4129  return 0;
4130 }
4131 
4133  uint64_t channel_layout, int32_t sample_rate,
4135 {
4136  uint32_t flags = 0;
4137  int size = 4;
4138  uint8_t *data;
4139  if (!pkt)
4140  return AVERROR(EINVAL);
4141  if (channels) {
4142  size += 4;
4144  }
4145  if (channel_layout) {
4146  size += 8;
4148  }
4149  if (sample_rate) {
4150  size += 4;
4152  }
4153  if (width || height) {
4154  size += 8;
4156  }
4158  if (!data)
4159  return AVERROR(ENOMEM);
4160  bytestream_put_le32(&data, flags);
4161  if (channels)
4162  bytestream_put_le32(&data, channels);
4163  if (channel_layout)
4164  bytestream_put_le64(&data, channel_layout);
4165  if (sample_rate)
4166  bytestream_put_le32(&data, sample_rate);
4167  if (width || height) {
4168  bytestream_put_le32(&data, width);
4169  bytestream_put_le32(&data, height);
4170  }
4171  return 0;
4172 }
4173 
4175 {
4176  AVRational undef = {0, 1};
4177  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4178  AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4179  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4180 
4181  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4182  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4183  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4184  stream_sample_aspect_ratio = undef;
4185 
4186  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4187  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4188  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4189  frame_sample_aspect_ratio = undef;
4190 
4191  if (stream_sample_aspect_ratio.num)
4192  return stream_sample_aspect_ratio;
4193  else
4194  return frame_sample_aspect_ratio;
4195 }
4196 
4198 {
4199  AVRational fr = st->r_frame_rate;
4200  AVRational codec_fr = st->codec->framerate;
4201  AVRational avg_fr = st->avg_frame_rate;
4202 
4203  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4204  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4205  fr = avg_fr;
4206  }
4207 
4208 
4209  if (st->codec->ticks_per_frame > 1) {
4210  if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4211  (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))
4212  fr = codec_fr;
4213  }
4214 
4215  return fr;
4216 }
4217 
4219  const char *spec)
4220 {
4221  if (*spec <= '9' && *spec >= '0') /* opt:index */
4222  return strtol(spec, NULL, 0) == st->index;
4223  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4224  *spec == 't') { /* opt:[vasdt] */
4225  enum AVMediaType type;
4226 
4227  switch (*spec++) {
4228  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4229  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4230  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4231  case 'd': type = AVMEDIA_TYPE_DATA; break;
4232  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4233  default: av_assert0(0);
4234  }
4235  if (type != st->codec->codec_type)
4236  return 0;
4237  if (*spec++ == ':') { /* possibly followed by :index */
4238  int i, index = strtol(spec, NULL, 0);
4239  for (i = 0; i < s->nb_streams; i++)
4240  if (s->streams[i]->codec->codec_type == type && index-- == 0)
4241  return i == st->index;
4242  return 0;
4243  }
4244  return 1;
4245  } else if (*spec == 'p' && *(spec + 1) == ':') {
4246  int prog_id, i, j;
4247  char *endptr;
4248  spec += 2;
4249  prog_id = strtol(spec, &endptr, 0);
4250  for (i = 0; i < s->nb_programs; i++) {
4251  if (s->programs[i]->id != prog_id)
4252  continue;
4253 
4254  if (*endptr++ == ':') {
4255  int stream_idx = strtol(endptr, NULL, 0);
4256  return stream_idx >= 0 &&
4257  stream_idx < s->programs[i]->nb_stream_indexes &&
4258  st->index == s->programs[i]->stream_index[stream_idx];
4259  }
4260 
4261  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4262  if (st->index == s->programs[i]->stream_index[j])
4263  return 1;
4264  }
4265  return 0;
4266  } else if (*spec == '#' ||
4267  (*spec == 'i' && *(spec + 1) == ':')) {
4268  int stream_id;
4269  char *endptr;
4270  spec += 1 + (*spec == 'i');
4271  stream_id = strtol(spec, &endptr, 0);
4272  if (!*endptr)
4273  return stream_id == st->id;
4274  } else if (*spec == 'm' && *(spec + 1) == ':') {
4276  char *key, *val;
4277  int ret;
4278 
4279  spec += 2;
4280  val = strchr(spec, ':');
4281 
4282  key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4283  if (!key)
4284  return AVERROR(ENOMEM);
4285 
4286  tag = av_dict_get(st->metadata, key, NULL, 0);
4287  if (tag) {
4288  if (!val || !strcmp(tag->value, val + 1))
4289  ret = 1;
4290  else
4291  ret = 0;
4292  } else
4293  ret = 0;
4294 
4295  av_freep(&key);
4296  return ret;
4297  } else if (!*spec) /* empty specifier, matches everything */
4298  return 1;
4299 
4300  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4301  return AVERROR(EINVAL);
4302 }
4303 
4305 {
4306  static const uint8_t avci100_1080p_extradata[] = {
4307  // SPS
4308  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4309  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4310  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4311  0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4312  0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4313  0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4314  0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4315  0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4316  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4317  // PPS
4318  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4319  0xd0
4320  };
4321  static const uint8_t avci100_1080i_extradata[] = {
4322  // SPS
4323  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4324  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4325  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4326  0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4327  0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4328  0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4329  0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4330  0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4331  0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4332  0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4333  0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4334  // PPS
4335  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4336  0xd0
4337  };
4338  static const uint8_t avci50_1080p_extradata[] = {
4339  // SPS
4340  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4341  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4342  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4343  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4344  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4345  0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4346  0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4347  0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4348  0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4349  // PPS
4350  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4351  0x11
4352  };
4353  static const uint8_t avci50_1080i_extradata[] = {
4354  // SPS
4355  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4356  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4357  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4358  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4359  0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4360  0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4361  0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4362  0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4363  0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4364  0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4365  0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4366  // PPS
4367  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4368  0x11
4369  };
4370  static const uint8_t avci100_720p_extradata[] = {
4371  // SPS
4372  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4373  0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4374  0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4375  0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4376  0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4377  0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4378  0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4379  0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4380  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4381  0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4382  // PPS
4383  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4384  0x11
4385  };
4386  static const uint8_t avci50_720p_extradata[] = {
4387  // SPS
4388  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4389  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4390  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4391  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4392  0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4393  0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4394  0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4395  0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4396  0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4397  // PPS
4398  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4399  0x11
4400  };
4401 
4402  const uint8_t *data = NULL;
4403  int size = 0;
4404 
4405  if (st->codec->width == 1920) {
4406  if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4407  data = avci100_1080p_extradata;
4408  size = sizeof(avci100_1080p_extradata);
4409  } else {
4410  data = avci100_1080i_extradata;
4411  size = sizeof(avci100_1080i_extradata);
4412  }
4413  } else if (st->codec->width == 1440) {
4414  if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4415  data = avci50_1080p_extradata;
4416  size = sizeof(avci50_1080p_extradata);
4417  } else {
4418  data = avci50_1080i_extradata;
4419  size = sizeof(avci50_1080i_extradata);
4420  }
4421  } else if (st->codec->width == 1280) {
4422  data = avci100_720p_extradata;
4423  size = sizeof(avci100_720p_extradata);
4424  } else if (st->codec->width == 960) {
4425  data = avci50_720p_extradata;
4426  size = sizeof(avci50_720p_extradata);
4427  }
4428 
4429  if (!size)
4430  return 0;
4431 
4432  av_freep(&st->codec->extradata);
4433  if (ff_alloc_extradata(st->codec, size))
4434  return AVERROR(ENOMEM);
4435  memcpy(st->codec->extradata, data, size);
4436 
4437  return 0;
4438 }
4439 
4441  int *size)
4442 {
4443  int i;
4444 
4445  for (i = 0; i < st->nb_side_data; i++) {
4446  if (st->side_data[i].type == type) {
4447  if (size)
4448  *size = st->side_data[i].size;
4449  return st->side_data[i].data;
4450  }
4451  }
4452  return NULL;
4453 }
4454 
4456  int size)
4457 {
4458  AVPacketSideData *sd, *tmp;
4459  int i;
4460  uint8_t *data = av_malloc(size);
4461 
4462  if (!data)
4463  return NULL;
4464 
4465  for (i = 0; i < st->nb_side_data; i++) {
4466  sd = &st->side_data[i];
4467 
4468  if (sd->type == type) {
4469  av_freep(&sd->data);
4470  sd->data = data;
4471  sd->size = size;
4472  return sd->data;
4473  }
4474  }
4475 
4476  tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4477  if (!tmp) {
4478  av_freep(&data);
4479  return NULL;
4480  }
4481 
4482  st->side_data = tmp;
4483  st->nb_side_data++;
4484 
4485  sd = &st->side_data[st->nb_side_data - 1];
4486  sd->type = type;
4487  sd->data = data;
4488  sd->size = size;
4489  return data;
4490 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1412
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:1393
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:3873
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2188
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:971
#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:3755
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:729
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:431
int64_t duration_gcd
Definition: avformat.h:935
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:995
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:785
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:280
char * recommended_encoder_configuration
String containing paris of key and values describing recommended encoder configuration.
Definition: avformat.h:1118
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:680
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1461
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:1570
#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:4455
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1185
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
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:103
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:997
int64_t pos
Definition: avformat.h:737
int probe_packets
Definition: avformat.h:980
#define NTP_OFFSET_US
Definition: internal.h:146
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2190
int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)
Probe a bytestream to determine the input format.
Definition: format.c:239
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:4174
enum AVCodecID video_codec
default video codec
Definition: avformat.h:477
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:1052
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:1076
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:867
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:796
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:1562
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:415
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:999
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1636
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:4072
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:4440
#define AV_PTS_WRAP_SUB_OFFSET
subtract the format specific offset on wrap detection
Definition: avformat.h:786
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:1498
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:763
#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:815
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:765
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:907
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:4018
int priv_data_size
Size of private data so that it can be allocated in the wrapper.
Definition: avformat.h:632
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1263
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: utils.c:2713
AVDictionary * metadata
Definition: avformat.h:1183
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:248
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:1381
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:1104
#define AV_DISPOSITION_KARAOKE
Definition: avformat.h:755
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:1214
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:4197
unsigned int nb_stream_indexes
Definition: avformat.h:1154
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:1331
int64_t cur_dts
Definition: avformat.h:972
#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:1334
int(* read_close)(struct AVFormatContext *)
Close the stream.
Definition: avformat.h:663
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:1346
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:1175
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:595
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:1767
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
int id
unique ID to identify the chapter
Definition: avformat.h:1180
int id
Format-specific stream ID.
Definition: avformat.h:802
enum AVStreamParseType need_parsing
Definition: avformat.h:988
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:4218
int duration_count
Definition: avformat.h:936
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1326
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:911
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:2876
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:3659
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:1282
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:1111
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:996
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:606
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:949
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1325
#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:3727
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: avformat.h:646
int64_t probesize2
Maximum size of the data read from input for determining the input container format.
Definition: avformat.h:1718
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:2950
uint32_t tag
Definition: movenc.c:1332
int avformat_network_init(void)
Do global initialization of network components.
Definition: utils.c:4109
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:1443
#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
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:1152
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:1153
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1369
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:731
#define av_log(a,...)
int64_t rfps_duration_sum
Definition: avformat.h:937
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:535
unsigned m
Definition: audioconvert.c:187
Duration estimated from bitrate (less accurate)
Definition: avformat.h:1201
unsigned int correct_ts_overflow
Correct single timestamp overflows.
Definition: avformat.h:1584
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1233
static const AVCodec * find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
Definition: utils.c:149
int64_t start_time
Definition: avformat.h:1168
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:140
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:3483
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:2826
#define AVINDEX_KEYFRAME
Definition: avformat.h:744
#define AVPROBE_SCORE_STREAM_RETRY
Definition: avformat.h:409
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
Definition: utils.c:3466
int max_ts_probe
Maximum number of packets to read while waiting for the first timestamp.
Definition: avformat.h:1505
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:1614
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:3295
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1423
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:1065
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:2336
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:3944
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:1171
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:1329
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:3648
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:738
int(* query_codec)(enum AVCodecID id, int std_compliance)
Test if the given codec can be stored in this container.
Definition: avformat.h:531
#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:919
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:3752
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:1362
int last_IP_duration
Definition: avformat.h:974
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
Definition: utils.c:3549
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:1413
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:1044
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:878
#define PARSER_FLAG_ONCE
Definition: avcodec.h:4267
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1149
#define FFMAX(a, b)
Definition: common.h:64
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:747
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:1660
#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:1345
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:728
char * format_whitelist
',' separated list of allowed demuxers.
Definition: avformat.h:1630
static int genpts
Definition: ffplay.c:322
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:814
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:4093
int av_packet_merge_side_data(AVPacket *pkt)
Definition: avpacket.c:341
#define AVFMT_FLAG_NOBUFFER
Do not buffer frames when possible.
Definition: avformat.h:1332
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:404
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:3993
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:403
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:1270
int64_t fps_first_dts
Those are used for average framerate estimation.
Definition: avformat.h:954
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
Definition: utils.c:3558
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:132
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:1290
#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:127
int update_initial_durations_done
Internal data to prevent doing update_initial_durations() twice.
Definition: avformat.h:1093
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:247
#define FFMIN(a, b)
Definition: common.h:66
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1375
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:1200
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:1105
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:1499
#define FFABS(a)
Definition: common.h:61
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:2482
#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:869
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:408
int probe_score
format probing score.
Definition: avformat.h:1607
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1333
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:1577
int(* read_pause)(struct AVFormatContext *)
Pause playing - only meaningful if using a network-based format (RTSP).
Definition: avformat.h:693
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:494
#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:1124
unsigned int probesize
Definition: avformat.h:1351
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:772
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:2953
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:3818
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:1099
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:764
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
Stream structure.
Definition: avformat.h:795
#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:425
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1182
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:979
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:4122
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2003
uint8_t dts_misordered
Definition: avformat.h:1106
#define FF_FDEBUG_TS
Definition: avformat.h:1467
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:1098
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:1169
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:673
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:463
int debug
Flags to enable debugging.
Definition: avformat.h:1466
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:1478
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:1256
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:491
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:2934
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:527
int io_repositioned
IO repositioned flag.
Definition: avformat.h:1644
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:1357
#define AVFMT_NOGENSEARCH
Format does not allow to fall back on generic search.
Definition: avformat.h:432
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in 'pkt'.
Definition: avformat.h:657
int pts_wrap_behavior
behavior on wrap detection
Definition: avformat.h:1172
void * buf
Definition: avisynth_c.h:595
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: avformat.h:938
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:1001
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:3965
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:426
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:478
#define SPACE_CHARS
Definition: internal.h:211
rational number numerator/denominator
Definition: rational.h:43
int64_t last_dts
Definition: avformat.h:934
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: avformat.h:1125
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:3813
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2189
const AVClass * av_class
A class for logging and AVOptions.
Definition: avformat.h:1219
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:902
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:4304
int64_t fps_last_dts
Definition: avformat.h:956
#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:4081
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:1325
#define snprintf
Definition: snprintf.h:34
int found_decoder
0 -> decoder has not been searched for yet.
Definition: avformat.h:947
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:3596
int inject_global_side_data
Definition: internal.h:99
This structure contains the data a format has to probe a file.
Definition: avformat.h:401
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:3313
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:957
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:1591
full parsing and repack of the first frame only, only implemented for H.264 currently ...
Definition: avformat.h:730
AVDictionary * metadata
Definition: avformat.h:1155
int64_t codec_info_duration
Definition: avformat.h:939
static int64_t pts
Global timestamp for the audio frames.
int fps_first_dts_idx
Definition: avformat.h:955
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:1299
Duration accurately estimated from PTSes.
Definition: avformat.h:1199
#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:1182
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:854
static int is_relative(int64_t ts)
Definition: utils.c:81
static int tb_unreliable(AVCodecContext *c)
Definition: utils.c:2841
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:1768
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: utils.c:3785
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: avformat.h:1088
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:418
int(* read_play)(struct AVFormatContext *)
Start/resume playing - only meaningful if using a network-based format (RTSP).
Definition: avformat.h:687
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:3015
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:847
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:189
AVCodec * video_codec
Forced video codec.
Definition: avformat.h:1652
static double c[64]
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:858
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:1190
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:961
Bi-dir predicted.
Definition: avutil.h:269
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:3567
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
add frame for rfps calculation.
Definition: utils.c:2892
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1181
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:111
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:1226
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:1710
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
Definition: utils.c:3631
#define FFMPEG_CONFIGURATION
Definition: config.h:4
#define AV_PTS_WRAP_IGNORE
Options for behavior on timestamp wrap detection.
Definition: avformat.h:784
int64_t codec_info_duration_fields
Definition: avformat.h:940
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:2993
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:1002
#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:1039
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:433
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:2855
AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1668
#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:476
#define av_log2
Definition: intmath.h:105
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avformat.h:1622
struct AVCodecParserContext * parser
Definition: avformat.h:989
void * priv_data
Format private data.
Definition: avformat.h:1242
int codec_info_nb_frames
Number of frames that have been demuxed during av_find_stream_info()
Definition: avformat.h:985
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
static void flush_packet_queue(AVFormatContext *s)
Definition: utils.c:1563
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:753
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:1316
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:1309
int avformat_flush(AVFormatContext *s)
Discard all internally buffered data.
Definition: utils.c:2210
int64_t last_IP_pts
Definition: avformat.h:973
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:701
#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:581
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:324
unbuffered private I/O API
static void compute_chapters_end(AVFormatContext *s)
Definition: utils.c:2797
#define FFSWAP(type, a, b)
Definition: common.h:69
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:299
int fps_last_dts_idx
Definition: avformat.h:957
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:837
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:860
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:4132
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1015
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:1034
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:1555
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:937
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:1330
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:932
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:887
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:1363
struct AVStream::@136 * info
#define AVFMT_NEEDNUMBER
Needs 'd' in filename.
Definition: avformat.h:419
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:158
const char * name
Definition: opengl_enc.c:103
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2949