FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups 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 #undef NDEBUG
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdint.h>
26 
27 #include "config.h"
28 
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
39 
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
43 
44 #include "audiointerleave.h"
45 #include "avformat.h"
46 #include "avio_internal.h"
47 #include "id3v2.h"
48 #include "internal.h"
49 #include "metadata.h"
50 #if CONFIG_NETWORK
51 #include "network.h"
52 #endif
53 #include "riff.h"
54 #include "url.h"
55 
56 /**
57  * @file
58  * various utility functions for use within FFmpeg
59  */
60 
61 unsigned avformat_version(void)
62 {
65 }
66 
67 const char *avformat_configuration(void)
68 {
69  return FFMPEG_CONFIGURATION;
70 }
71 
72 const char *avformat_license(void)
73 {
74 #define LICENSE_PREFIX "libavformat license: "
75  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
76 }
77 
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
79 
80 static int is_relative(int64_t ts) {
81  return ts > (RELATIVE_TS_BASE - (1LL<<48));
82 }
83 
84 /**
85  * Wrap a given time stamp, if there is an indication for an overflow
86  *
87  * @param st stream
88  * @param timestamp the time stamp to wrap
89  * @return resulting time stamp
90  */
91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
92 {
94  st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
96  timestamp < st->pts_wrap_reference)
97  return timestamp + (1ULL << st->pts_wrap_bits);
98  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
99  timestamp >= st->pts_wrap_reference)
100  return timestamp - (1ULL << st->pts_wrap_bits);
101  }
102  return timestamp;
103 }
104 
105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
112 
113 int64_t av_stream_get_end_pts(const AVStream *st)
114 {
115  return st->pts.val;
116 }
117 
119 {
120  return st->parser;
121 }
122 
124 {
125  int i;
127  for (i = 0; i < s->nb_streams; i++) {
128  AVStream *st = s->streams[i];
129  st->inject_global_side_data = 1;
130  }
131 }
132 
134 {
135  if (st->codec->codec)
136  return st->codec->codec;
137 
138  switch (st->codec->codec_type) {
139  case AVMEDIA_TYPE_VIDEO:
140  if (s->video_codec) return s->video_codec;
141  break;
142  case AVMEDIA_TYPE_AUDIO:
143  if (s->audio_codec) return s->audio_codec;
144  break;
146  if (s->subtitle_codec) return s->subtitle_codec;
147  break;
148  }
149 
150  return avcodec_find_decoder(codec_id);
151 }
152 
154 {
155  return s->probe_score;
156 }
157 
158 /* an arbitrarily chosen "sane" max packet size -- 50M */
159 #define SANE_CHUNK_SIZE (50000000)
160 
162 {
163  if (s->maxsize>= 0) {
164  int64_t remaining= s->maxsize - avio_tell(s);
165  if (remaining < size) {
166  int64_t newsize = avio_size(s);
167  if (!s->maxsize || s->maxsize<newsize)
168  s->maxsize = newsize - !newsize;
169  remaining= s->maxsize - avio_tell(s);
170  remaining= FFMAX(remaining, 0);
171  }
172 
173  if (s->maxsize>= 0 && remaining+1 < size) {
174  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
175  size = remaining+1;
176  }
177  }
178  return size;
179 }
180 
181 /* Read the data in sane-sized chunks and append to pkt.
182  * Return the number of bytes read or an error. */
184 {
185  int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
186  int orig_size = pkt->size;
187  int ret;
188 
189  do {
190  int prev_size = pkt->size;
191  int read_size;
192 
193  /* When the caller requests a lot of data, limit it to the amount
194  * left in file or SANE_CHUNK_SIZE when it is not known. */
195  read_size = size;
196  if (read_size > SANE_CHUNK_SIZE/10) {
197  read_size = ffio_limit(s, read_size);
198  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
199  if (s->maxsize < 0)
200  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
201  }
202 
203  ret = av_grow_packet(pkt, read_size);
204  if (ret < 0)
205  break;
206 
207  ret = avio_read(s, pkt->data + prev_size, read_size);
208  if (ret != read_size) {
209  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
210  break;
211  }
212 
213  size -= read_size;
214  } while (size > 0);
215  if (size > 0)
216  pkt->flags |= AV_PKT_FLAG_CORRUPT;
217 
218  pkt->pos = orig_pos;
219  if (!pkt->size)
220  av_free_packet(pkt);
221  return pkt->size > orig_size ? pkt->size - orig_size : ret;
222 }
223 
225 {
226  av_init_packet(pkt);
227  pkt->data = NULL;
228  pkt->size = 0;
229  pkt->pos = avio_tell(s);
230 
231  return append_packet_chunked(s, pkt, size);
232 }
233 
235 {
236  if (!pkt->size)
237  return av_get_packet(s, pkt, size);
238  return append_packet_chunked(s, pkt, size);
239 }
240 
241 int av_filename_number_test(const char *filename)
242 {
243  char buf[1024];
244  return filename &&
245  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
246 }
247 
249  AVProbeData *pd)
250 {
251  static const struct {
252  const char *name;
253  enum AVCodecID id;
254  enum AVMediaType type;
255  } fmt_id_type[] = {
265  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
266  { 0 }
267  };
268  int score;
269  AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
270 
271  if (fmt && st->request_probe <= score) {
272  int i;
273  av_log(s, AV_LOG_DEBUG,
274  "Probe with size=%d, packets=%d detected %s with score=%d\n",
276  fmt->name, score);
277  for (i = 0; fmt_id_type[i].name; i++) {
278  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
279  st->codec->codec_id = fmt_id_type[i].id;
280  st->codec->codec_type = fmt_id_type[i].type;
281  return score;
282  }
283  }
284  }
285  return 0;
286 }
287 
288 /************************************************************/
289 /* input media file */
290 
292  int err;
293 
294  if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
295  av_log(ic, AV_LOG_ERROR, "Format not on whitelist\n");
296  return AVERROR(EINVAL);
297  }
298 
299  if (ic->iformat->read_header) {
300  err = ic->iformat->read_header(ic);
301  if (err < 0)
302  return err;
303  }
304 
305  if (ic->pb && !ic->data_offset)
306  ic->data_offset = avio_tell(ic->pb);
307 
308  return 0;
309 }
310 
311 /* Open input file and probe the format if necessary. */
312 static int init_input(AVFormatContext *s, const char *filename,
314 {
315  int ret;
316  AVProbeData pd = { filename, NULL, 0 };
317  int score = AVPROBE_SCORE_RETRY;
318 
319  if (s->pb) {
321  if (!s->iformat)
322  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
323  s, 0, s->format_probesize);
324  else if (s->iformat->flags & AVFMT_NOFILE)
325  av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
326  "will be ignored with AVFMT_NOFILE format.\n");
327  return 0;
328  }
329 
330  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
331  (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
332  return score;
333 
334  if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
335  &s->interrupt_callback, options)) < 0)
336  return ret;
337  if (s->iformat)
338  return 0;
339  return av_probe_input_buffer2(s->pb, &s->iformat, filename,
340  s, 0, s->format_probesize);
341 }
342 
343 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
344  AVPacketList **plast_pktl)
345 {
346  AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
347  if (!pktl)
348  return NULL;
349 
350  if (*packet_buffer)
351  (*plast_pktl)->next = pktl;
352  else
353  *packet_buffer = pktl;
354 
355  /* Add the packet in the buffered packet list. */
356  *plast_pktl = pktl;
357  pktl->pkt = *pkt;
358  return &pktl->pkt;
359 }
360 
362 {
363  int i;
364  for (i = 0; i < s->nb_streams; i++)
366  s->streams[i]->discard < AVDISCARD_ALL) {
368  if (copy.size <= 0) {
370  "Attached picture on stream %d has invalid size, "
371  "ignoring\n", i);
372  continue;
373  }
374  copy.buf = av_buffer_ref(copy.buf);
375  if (!copy.buf)
376  return AVERROR(ENOMEM);
377 
378  add_to_pktbuf(&s->raw_packet_buffer, &copy,
380  }
381  return 0;
382 }
383 
384 int avformat_open_input(AVFormatContext **ps, const char *filename,
386 {
387  AVFormatContext *s = *ps;
388  int ret = 0;
389  AVDictionary *tmp = NULL;
390  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
391 
392  if (!s && !(s = avformat_alloc_context()))
393  return AVERROR(ENOMEM);
394  if (!s->av_class) {
395  av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
396  return AVERROR(EINVAL);
397  }
398  if (fmt)
399  s->iformat = fmt;
400 
401  if (options)
402  av_dict_copy(&tmp, *options, 0);
403 
404  if ((ret = av_opt_set_dict(s, &tmp)) < 0)
405  goto fail;
406 
407  if ((ret = init_input(s, filename, &tmp)) < 0)
408  goto fail;
409  s->probe_score = ret;
410 
411  if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
412  av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
413  ret = AVERROR(EINVAL);
414  goto fail;
415  }
416 
418 
419  /* Check filename in case an image number is expected. */
420  if (s->iformat->flags & AVFMT_NEEDNUMBER) {
421  if (!av_filename_number_test(filename)) {
422  ret = AVERROR(EINVAL);
423  goto fail;
424  }
425  }
426 
428  av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
429 
430  /* Allocate private data. */
431  if (s->iformat->priv_data_size > 0) {
432  if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
433  ret = AVERROR(ENOMEM);
434  goto fail;
435  }
436  if (s->iformat->priv_class) {
437  *(const AVClass **) s->priv_data = s->iformat->priv_class;
439  if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
440  goto fail;
441  }
442  }
443 
444  /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
445  if (s->pb)
446  ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
447 
448  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
449  if ((ret = s->iformat->read_header(s)) < 0)
450  goto fail;
451 
452  if (id3v2_extra_meta) {
453  if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
454  !strcmp(s->iformat->name, "tta")) {
455  if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
456  goto fail;
457  } else
458  av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
459  }
460  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
461 
462  if ((ret = avformat_queue_attached_pictures(s)) < 0)
463  goto fail;
464 
465  if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
466  s->data_offset = avio_tell(s->pb);
467 
469 
470  if (options) {
471  av_dict_free(options);
472  *options = tmp;
473  }
474  *ps = s;
475  return 0;
476 
477 fail:
478  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
479  av_dict_free(&tmp);
480  if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
481  avio_close(s->pb);
483  *ps = NULL;
484  return ret;
485 }
486 
487 /*******************************************************/
488 
490 {
491  switch (st->codec->codec_type) {
492  case AVMEDIA_TYPE_VIDEO:
493  if (s->video_codec_id)
494  st->codec->codec_id = s->video_codec_id;
495  break;
496  case AVMEDIA_TYPE_AUDIO:
497  if (s->audio_codec_id)
498  st->codec->codec_id = s->audio_codec_id;
499  break;
501  if (s->subtitle_codec_id)
502  st->codec->codec_id = s->subtitle_codec_id;
503  break;
504  }
505 }
506 
508 {
509  if (st->request_probe>0) {
510  AVProbeData *pd = &st->probe_data;
511  int end;
512  av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
513  --st->probe_packets;
514 
515  if (pkt) {
516  uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
517  if (!new_buf) {
519  "Failed to reallocate probe buffer for stream %d\n",
520  st->index);
521  goto no_packet;
522  }
523  pd->buf = new_buf;
524  memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
525  pd->buf_size += pkt->size;
526  memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
527  } else {
528 no_packet:
529  st->probe_packets = 0;
530  if (!pd->buf_size) {
532  "nothing to probe for stream %d\n", st->index);
533  }
534  }
535 
537  || st->probe_packets<= 0;
538 
539  if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
540  int score = set_codec_from_probe_data(s, st, pd);
542  || end) {
543  pd->buf_size = 0;
544  av_freep(&pd->buf);
545  st->request_probe = -1;
546  if (st->codec->codec_id != AV_CODEC_ID_NONE) {
547  av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
548  } else
549  av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
550  }
551  force_codec_ids(s, st);
552  }
553  }
554  return 0;
555 }
556 
557 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
558 {
559  int64_t ref = pkt->dts;
560  int i, pts_wrap_behavior;
561  int64_t pts_wrap_reference;
562  AVProgram *first_program;
563 
564  if (ref == AV_NOPTS_VALUE)
565  ref = pkt->pts;
566  if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
567  return 0;
568  ref &= (1LL << st->pts_wrap_bits)-1;
569 
570  // reference time stamp should be 60 s before first time stamp
571  pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
572  // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
573  pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
574  (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
576 
577  first_program = av_find_program_from_stream(s, NULL, stream_index);
578 
579  if (!first_program) {
580  int default_stream_index = av_find_default_stream_index(s);
581  if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
582  for (i = 0; i < s->nb_streams; i++) {
583  s->streams[i]->pts_wrap_reference = pts_wrap_reference;
584  s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
585  }
586  }
587  else {
588  st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
589  st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
590  }
591  }
592  else {
593  AVProgram *program = first_program;
594  while (program) {
595  if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
596  pts_wrap_reference = program->pts_wrap_reference;
597  pts_wrap_behavior = program->pts_wrap_behavior;
598  break;
599  }
600  program = av_find_program_from_stream(s, program, stream_index);
601  }
602 
603  // update every program with differing pts_wrap_reference
604  program = first_program;
605  while (program) {
606  if (program->pts_wrap_reference != pts_wrap_reference) {
607  for (i = 0; i<program->nb_stream_indexes; i++) {
608  s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
609  s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
610  }
611 
612  program->pts_wrap_reference = pts_wrap_reference;
613  program->pts_wrap_behavior = pts_wrap_behavior;
614  }
615  program = av_find_program_from_stream(s, program, stream_index);
616  }
617  }
618  return 1;
619 }
620 
622 {
623  int ret, i, err;
624  AVStream *st;
625 
626  for (;;) {
627  AVPacketList *pktl = s->raw_packet_buffer;
628 
629  if (pktl) {
630  *pkt = pktl->pkt;
631  st = s->streams[pkt->stream_index];
633  if ((err = probe_codec(s, st, NULL)) < 0)
634  return err;
635  if (st->request_probe <= 0) {
636  s->raw_packet_buffer = pktl->next;
638  av_free(pktl);
639  return 0;
640  }
641  }
642 
643  pkt->data = NULL;
644  pkt->size = 0;
645  av_init_packet(pkt);
646  ret = s->iformat->read_packet(s, pkt);
647  if (ret < 0) {
648  if (!pktl || ret == AVERROR(EAGAIN))
649  return ret;
650  for (i = 0; i < s->nb_streams; i++) {
651  st = s->streams[i];
652  if (st->probe_packets)
653  if ((err = probe_codec(s, st, NULL)) < 0)
654  return err;
655  av_assert0(st->request_probe <= 0);
656  }
657  continue;
658  }
659 
660  if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
661  (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
663  "Dropped corrupted packet (stream = %d)\n",
664  pkt->stream_index);
665  av_free_packet(pkt);
666  continue;
667  }
668 
669  if (pkt->stream_index >= (unsigned)s->nb_streams) {
670  av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
671  continue;
672  }
673 
674  st = s->streams[pkt->stream_index];
675 
677  // correct first time stamps to negative values
678  if (!is_relative(st->first_dts))
679  st->first_dts = wrap_timestamp(st, st->first_dts);
680  if (!is_relative(st->start_time))
681  st->start_time = wrap_timestamp(st, st->start_time);
682  if (!is_relative(st->cur_dts))
683  st->cur_dts = wrap_timestamp(st, st->cur_dts);
684  }
685 
686  pkt->dts = wrap_timestamp(st, pkt->dts);
687  pkt->pts = wrap_timestamp(st, pkt->pts);
688 
689  force_codec_ids(s, st);
690 
691  /* TODO: audio: time filter; video: frame reordering (pts != dts) */
693  pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
694 
695  if (!pktl && st->request_probe <= 0)
696  return ret;
697 
700 
701  if ((err = probe_codec(s, st, pkt)) < 0)
702  return err;
703  }
704 }
705 
706 
707 /**********************************************************/
708 
710 {
711  if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
712  avctx->codec_id == AV_CODEC_ID_MP1 ||
713  avctx->codec_id == AV_CODEC_ID_MP2 ||
714  avctx->codec_id == AV_CODEC_ID_MP3/* ||
715  avctx->codec_id == AV_CODEC_ID_CELT*/)
716  return 1;
717  return 0;
718 }
719 
720 /**
721  * Return the frame duration in seconds. Return 0 if not available.
722  */
723 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
725 {
726  AVRational codec_framerate = s->iformat ? st->codec->framerate :
728  int frame_size;
729 
730  *pnum = 0;
731  *pden = 0;
732  switch (st->codec->codec_type) {
733  case AVMEDIA_TYPE_VIDEO:
734  if (st->r_frame_rate.num && !pc) {
735  *pnum = st->r_frame_rate.den;
736  *pden = st->r_frame_rate.num;
737  } else if (st->time_base.num * 1000LL > st->time_base.den) {
738  *pnum = st->time_base.num;
739  *pden = st->time_base.den;
740  } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
741  av_assert0(st->codec->ticks_per_frame);
742  av_reduce(pnum, pden,
743  codec_framerate.den,
744  codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
745  INT_MAX);
746 
747  if (pc && pc->repeat_pict) {
748  av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
749  av_reduce(pnum, pden,
750  (*pnum) * (1LL + pc->repeat_pict),
751  (*pden),
752  INT_MAX);
753  }
754  /* If this codec can be interlaced or progressive then we need
755  * a parser to compute duration of a packet. Thus if we have
756  * no parser in such case leave duration undefined. */
757  if (st->codec->ticks_per_frame > 1 && !pc)
758  *pnum = *pden = 0;
759  }
760  break;
761  case AVMEDIA_TYPE_AUDIO:
763  if (frame_size <= 0 || st->codec->sample_rate <= 0)
764  break;
765  *pnum = frame_size;
766  *pden = st->codec->sample_rate;
767  break;
768  default:
769  break;
770  }
771 }
772 
773 static int is_intra_only(AVCodecContext *enc) {
774  const AVCodecDescriptor *desc;
775 
776  if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
777  return 1;
778 
779  desc = av_codec_get_codec_descriptor(enc);
780  if (!desc) {
781  desc = avcodec_descriptor_get(enc->codec_id);
783  }
784  if (desc)
785  return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
786  return 0;
787 }
788 
790 {
791  if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
792  if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
793  return 1;
794 #if CONFIG_H264_DECODER
795  if (st->codec->has_b_frames &&
797  return 1;
798 #endif
799  if (st->codec->has_b_frames<3)
800  return st->nb_decoded_frames >= 7;
801  else if (st->codec->has_b_frames<4)
802  return st->nb_decoded_frames >= 18;
803  else
804  return st->nb_decoded_frames >= 20;
805 }
806 
808 {
809  if (pktl->next)
810  return pktl->next;
811  if (pktl == s->packet_buffer_end)
812  return s->parse_queue;
813  return NULL;
814 }
815 
816 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
817  int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
819 
820  if(!onein_oneout) {
821  int delay = st->codec->has_b_frames;
822  int i;
823 
824  if (dts == AV_NOPTS_VALUE) {
825  int64_t best_score = INT64_MAX;
826  for (i = 0; i<delay; i++) {
827  if (st->pts_reorder_error_count[i]) {
828  int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
829  if (score < best_score) {
830  best_score = score;
831  dts = pts_buffer[i];
832  }
833  }
834  }
835  } else {
836  for (i = 0; i<delay; i++) {
837  if (pts_buffer[i] != AV_NOPTS_VALUE) {
838  int64_t diff = FFABS(pts_buffer[i] - dts)
839  + (uint64_t)st->pts_reorder_error[i];
840  diff = FFMAX(diff, st->pts_reorder_error[i]);
841  st->pts_reorder_error[i] = diff;
842  st->pts_reorder_error_count[i]++;
843  if (st->pts_reorder_error_count[i] > 250) {
844  st->pts_reorder_error[i] >>= 1;
845  st->pts_reorder_error_count[i] >>= 1;
846  }
847  }
848  }
849  }
850  }
851 
852  if (dts == AV_NOPTS_VALUE)
853  dts = pts_buffer[0];
854 
855  return dts;
856 }
857 
858 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
859  int64_t dts, int64_t pts, AVPacket *pkt)
860 {
861  AVStream *st = s->streams[stream_index];
863  int64_t pts_buffer[MAX_REORDER_DELAY+1];
864  int64_t shift;
865  int i, delay;
866 
867  if (st->first_dts != AV_NOPTS_VALUE ||
868  dts == AV_NOPTS_VALUE ||
869  st->cur_dts == AV_NOPTS_VALUE ||
870  is_relative(dts))
871  return;
872 
873  delay = st->codec->has_b_frames;
874  st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
875  st->cur_dts = dts;
876  shift = st->first_dts - RELATIVE_TS_BASE;
877 
878  for (i = 0; i<MAX_REORDER_DELAY+1; i++)
879  pts_buffer[i] = AV_NOPTS_VALUE;
880 
881  if (is_relative(pts))
882  pts += shift;
883 
884  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
885  if (pktl->pkt.stream_index != stream_index)
886  continue;
887  if (is_relative(pktl->pkt.pts))
888  pktl->pkt.pts += shift;
889 
890  if (is_relative(pktl->pkt.dts))
891  pktl->pkt.dts += shift;
892 
893  if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
894  st->start_time = pktl->pkt.pts;
895 
896  if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
897  pts_buffer[0] = pktl->pkt.pts;
898  for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
899  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
900 
901  pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
902  }
903  }
904 
905  if (st->start_time == AV_NOPTS_VALUE)
906  st->start_time = pts;
907 }
908 
910  int stream_index, int duration)
911 {
913  int64_t cur_dts = RELATIVE_TS_BASE;
914 
915  if (st->first_dts != AV_NOPTS_VALUE) {
917  return;
919  cur_dts = st->first_dts;
920  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
921  if (pktl->pkt.stream_index == stream_index) {
922  if (pktl->pkt.pts != pktl->pkt.dts ||
923  pktl->pkt.dts != AV_NOPTS_VALUE ||
924  pktl->pkt.duration)
925  break;
926  cur_dts -= duration;
927  }
928  }
929  if (pktl && pktl->pkt.dts != st->first_dts) {
930  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
931  av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
932  return;
933  }
934  if (!pktl) {
935  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
936  return;
937  }
938  pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
939  st->first_dts = cur_dts;
940  } else if (st->cur_dts != RELATIVE_TS_BASE)
941  return;
942 
943  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
944  if (pktl->pkt.stream_index != stream_index)
945  continue;
946  if (pktl->pkt.pts == pktl->pkt.dts &&
947  (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
948  !pktl->pkt.duration) {
949  pktl->pkt.dts = cur_dts;
950  if (!st->codec->has_b_frames)
951  pktl->pkt.pts = cur_dts;
952 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
953  pktl->pkt.duration = duration;
954  } else
955  break;
956  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
957  }
958  if (!pktl)
959  st->cur_dts = cur_dts;
960 }
961 
964 {
965  int num, den, presentation_delayed, delay, i;
966  int64_t offset;
968  int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
970 
971  if (s->flags & AVFMT_FLAG_NOFILLIN)
972  return;
973 
974  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
975  if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
976  if (st->last_dts_for_order_check <= pkt->dts) {
977  st->dts_ordered++;
978  } else {
980  "DTS %"PRIi64" < %"PRIi64" out of order\n",
981  pkt->dts,
983  st->dts_misordered++;
984  }
985  if (st->dts_ordered + st->dts_misordered > 250) {
986  st->dts_ordered >>= 1;
987  st->dts_misordered >>= 1;
988  }
989  }
990 
991  st->last_dts_for_order_check = pkt->dts;
992  if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
993  pkt->dts = AV_NOPTS_VALUE;
994  }
995 
996  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
997  pkt->dts = AV_NOPTS_VALUE;
998 
999  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1000  && !st->codec->has_b_frames)
1001  //FIXME Set low_delay = 0 when has_b_frames = 1
1002  st->codec->has_b_frames = 1;
1003 
1004  /* do we have a video B-frame ? */
1005  delay = st->codec->has_b_frames;
1006  presentation_delayed = 0;
1007 
1008  /* XXX: need has_b_frame, but cannot get it if the codec is
1009  * not initialized */
1010  if (delay &&
1011  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1012  presentation_delayed = 1;
1013 
1014  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1015  st->pts_wrap_bits < 63 &&
1016  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1017  if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1018  pkt->dts -= 1LL << st->pts_wrap_bits;
1019  } else
1020  pkt->pts += 1LL << st->pts_wrap_bits;
1021  }
1022 
1023  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1024  * We take the conservative approach and discard both.
1025  * Note: If this is misbehaving for an H.264 file, then possibly
1026  * presentation_delayed is not set correctly. */
1027  if (delay == 1 && pkt->dts == pkt->pts &&
1028  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1029  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1030  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1031  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1032  pkt->dts = AV_NOPTS_VALUE;
1033  }
1034 
1035  duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1036  if (pkt->duration == 0) {
1037  ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1038  if (den && num) {
1039  duration = (AVRational) {num, den};
1040  pkt->duration = av_rescale_rnd(1,
1041  num * (int64_t) st->time_base.den,
1042  den * (int64_t) st->time_base.num,
1043  AV_ROUND_DOWN);
1044  }
1045  }
1046 
1047  if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1048  update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1049 
1050  /* Correct timestamps with byte offset if demuxers only have timestamps
1051  * on packet boundaries */
1052  if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1053  /* this will estimate bitrate based on this frame's duration and size */
1054  offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1055  if (pkt->pts != AV_NOPTS_VALUE)
1056  pkt->pts += offset;
1057  if (pkt->dts != AV_NOPTS_VALUE)
1058  pkt->dts += offset;
1059  }
1060 
1061  /* This may be redundant, but it should not hurt. */
1062  if (pkt->dts != AV_NOPTS_VALUE &&
1063  pkt->pts != AV_NOPTS_VALUE &&
1064  pkt->pts > pkt->dts)
1065  presentation_delayed = 1;
1066 
1067  av_dlog(NULL,
1068  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1069  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1070  pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1071  /* Interpolate PTS and DTS if they are not present. We skip H264
1072  * currently because delay and has_b_frames are not reliably set. */
1073  if ((delay == 0 || (delay == 1 && pc)) &&
1074  onein_oneout) {
1075  if (presentation_delayed) {
1076  /* DTS = decompression timestamp */
1077  /* PTS = presentation timestamp */
1078  if (pkt->dts == AV_NOPTS_VALUE)
1079  pkt->dts = st->last_IP_pts;
1080  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1081  if (pkt->dts == AV_NOPTS_VALUE)
1082  pkt->dts = st->cur_dts;
1083 
1084  /* This is tricky: the dts must be incremented by the duration
1085  * of the frame we are displaying, i.e. the last I- or P-frame. */
1086  if (st->last_IP_duration == 0)
1087  st->last_IP_duration = pkt->duration;
1088  if (pkt->dts != AV_NOPTS_VALUE)
1089  st->cur_dts = pkt->dts + st->last_IP_duration;
1090  st->last_IP_duration = pkt->duration;
1091  st->last_IP_pts = pkt->pts;
1092  /* Cannot compute PTS if not present (we can compute it only
1093  * by knowing the future. */
1094  } else if (pkt->pts != AV_NOPTS_VALUE ||
1095  pkt->dts != AV_NOPTS_VALUE ||
1096  pkt->duration ) {
1097 
1098  /* presentation is not delayed : PTS and DTS are the same */
1099  if (pkt->pts == AV_NOPTS_VALUE)
1100  pkt->pts = pkt->dts;
1102  pkt->pts, pkt);
1103  if (pkt->pts == AV_NOPTS_VALUE)
1104  pkt->pts = st->cur_dts;
1105  pkt->dts = pkt->pts;
1106  if (pkt->pts != AV_NOPTS_VALUE)
1107  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1108  }
1109  }
1110 
1111  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1112  st->pts_buffer[0] = pkt->pts;
1113  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1114  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1115 
1116  pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1117  }
1118  // We skipped it above so we try here.
1119  if (!onein_oneout)
1120  // This should happen on the first packet
1121  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1122  if (pkt->dts > st->cur_dts)
1123  st->cur_dts = pkt->dts;
1124 
1125  av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1126  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1127 
1128  /* update flags */
1129  if (is_intra_only(st->codec))
1130  pkt->flags |= AV_PKT_FLAG_KEY;
1131  if (pc)
1133 }
1134 
1135 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1136 {
1137  while (*pkt_buf) {
1138  AVPacketList *pktl = *pkt_buf;
1139  *pkt_buf = pktl->next;
1140  av_free_packet(&pktl->pkt);
1141  av_freep(&pktl);
1142  }
1143  *pkt_buf_end = NULL;
1144 }
1145 
1146 /**
1147  * Parse a packet, add all split parts to parse_queue.
1148  *
1149  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1150  */
1151 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1152 {
1153  AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1154  AVStream *st = s->streams[stream_index];
1155  uint8_t *data = pkt ? pkt->data : NULL;
1156  int size = pkt ? pkt->size : 0;
1157  int ret = 0, got_output = 0;
1158 
1159  if (!pkt) {
1161  pkt = &flush_pkt;
1162  got_output = 1;
1163  } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1164  // preserve 0-size sync packets
1165  compute_pkt_fields(s, st, st->parser, pkt);
1166  }
1167 
1168  while (size > 0 || (pkt == &flush_pkt && got_output)) {
1169  int len;
1170 
1171  av_init_packet(&out_pkt);
1172  len = av_parser_parse2(st->parser, st->codec,
1173  &out_pkt.data, &out_pkt.size, data, size,
1174  pkt->pts, pkt->dts, pkt->pos);
1175 
1176  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1177  pkt->pos = -1;
1178  /* increment read pointer */
1179  data += len;
1180  size -= len;
1181 
1182  got_output = !!out_pkt.size;
1183 
1184  if (!out_pkt.size)
1185  continue;
1186 
1187  if (pkt->side_data) {
1188  out_pkt.side_data = pkt->side_data;
1189  out_pkt.side_data_elems = pkt->side_data_elems;
1190  pkt->side_data = NULL;
1191  pkt->side_data_elems = 0;
1192  }
1193 
1194  /* set the duration */
1195  out_pkt.duration = 0;
1196  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1197  if (st->codec->sample_rate > 0) {
1198  out_pkt.duration =
1200  (AVRational) { 1, st->codec->sample_rate },
1201  st->time_base,
1202  AV_ROUND_DOWN);
1203  }
1204  }
1205 
1206  out_pkt.stream_index = st->index;
1207  out_pkt.pts = st->parser->pts;
1208  out_pkt.dts = st->parser->dts;
1209  out_pkt.pos = st->parser->pos;
1210 
1212  out_pkt.pos = st->parser->frame_offset;
1213 
1214  if (st->parser->key_frame == 1 ||
1215  (st->parser->key_frame == -1 &&
1217  out_pkt.flags |= AV_PKT_FLAG_KEY;
1218 
1219  if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1220  out_pkt.flags |= AV_PKT_FLAG_KEY;
1221 
1222  compute_pkt_fields(s, st, st->parser, &out_pkt);
1223 
1224  if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1225  out_pkt.buf = pkt->buf;
1226  pkt->buf = NULL;
1227 #if FF_API_DESTRUCT_PACKET
1229  out_pkt.destruct = pkt->destruct;
1230  pkt->destruct = NULL;
1232 #endif
1233  }
1234  if ((ret = av_dup_packet(&out_pkt)) < 0)
1235  goto fail;
1236 
1237  if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1238  av_free_packet(&out_pkt);
1239  ret = AVERROR(ENOMEM);
1240  goto fail;
1241  }
1242  }
1243 
1244  /* end of the stream => close and free the parser */
1245  if (pkt == &flush_pkt) {
1246  av_parser_close(st->parser);
1247  st->parser = NULL;
1248  }
1249 
1250 fail:
1252  return ret;
1253 }
1254 
1255 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1256  AVPacketList **pkt_buffer_end,
1257  AVPacket *pkt)
1258 {
1259  AVPacketList *pktl;
1260  av_assert0(*pkt_buffer);
1261  pktl = *pkt_buffer;
1262  *pkt = pktl->pkt;
1263  *pkt_buffer = pktl->next;
1264  if (!pktl->next)
1265  *pkt_buffer_end = NULL;
1266  av_freep(&pktl);
1267  return 0;
1268 }
1269 
1270 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1271 {
1272  return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1273 }
1274 
1276 {
1277  int ret = 0, i, got_packet = 0;
1278  AVDictionary *metadata = NULL;
1279 
1280  av_init_packet(pkt);
1281 
1282  while (!got_packet && !s->parse_queue) {
1283  AVStream *st;
1284  AVPacket cur_pkt;
1285 
1286  /* read next packet */
1287  ret = ff_read_packet(s, &cur_pkt);
1288  if (ret < 0) {
1289  if (ret == AVERROR(EAGAIN))
1290  return ret;
1291  /* flush the parsers */
1292  for (i = 0; i < s->nb_streams; i++) {
1293  st = s->streams[i];
1294  if (st->parser && st->need_parsing)
1295  parse_packet(s, NULL, st->index);
1296  }
1297  /* all remaining packets are now in parse_queue =>
1298  * really terminate parsing */
1299  break;
1300  }
1301  ret = 0;
1302  st = s->streams[cur_pkt.stream_index];
1303 
1304  if (cur_pkt.pts != AV_NOPTS_VALUE &&
1305  cur_pkt.dts != AV_NOPTS_VALUE &&
1306  cur_pkt.pts < cur_pkt.dts) {
1308  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1309  cur_pkt.stream_index,
1310  av_ts2str(cur_pkt.pts),
1311  av_ts2str(cur_pkt.dts),
1312  cur_pkt.size);
1313  }
1314  if (s->debug & FF_FDEBUG_TS)
1315  av_log(s, AV_LOG_DEBUG,
1316  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1317  cur_pkt.stream_index,
1318  av_ts2str(cur_pkt.pts),
1319  av_ts2str(cur_pkt.dts),
1320  cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1321 
1322  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1323  st->parser = av_parser_init(st->codec->codec_id);
1324  if (!st->parser) {
1325  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1326  "%s, packets or times may be invalid.\n",
1328  /* no parser available: just output the raw packets */
1330  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1332  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1333  st->parser->flags |= PARSER_FLAG_ONCE;
1334  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1336  }
1337 
1338  if (!st->need_parsing || !st->parser) {
1339  /* no parsing needed: we just output the packet as is */
1340  *pkt = cur_pkt;
1341  compute_pkt_fields(s, st, NULL, pkt);
1342  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1343  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1344  ff_reduce_index(s, st->index);
1345  av_add_index_entry(st, pkt->pos, pkt->dts,
1346  0, 0, AVINDEX_KEYFRAME);
1347  }
1348  got_packet = 1;
1349  } else if (st->discard < AVDISCARD_ALL) {
1350  if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1351  return ret;
1352  } else {
1353  /* free packet */
1354  av_free_packet(&cur_pkt);
1355  }
1356  if (pkt->flags & AV_PKT_FLAG_KEY)
1357  st->skip_to_keyframe = 0;
1358  if (st->skip_to_keyframe) {
1359  av_free_packet(&cur_pkt);
1360  if (got_packet) {
1361  *pkt = cur_pkt;
1362  }
1363  got_packet = 0;
1364  }
1365  }
1366 
1367  if (!got_packet && s->parse_queue)
1369 
1370  if (ret >= 0) {
1371  AVStream *st = s->streams[pkt->stream_index];
1372  int discard_padding = 0;
1373  if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1374  int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1375  int64_t sample = ts_to_samples(st, pts);
1376  int duration = ts_to_samples(st, pkt->duration);
1377  int64_t end_sample = sample + duration;
1378  if (duration > 0 && end_sample >= st->first_discard_sample &&
1379  sample < st->last_discard_sample)
1380  discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1381  }
1382  if (st->skip_samples || discard_padding) {
1384  if (p) {
1385  AV_WL32(p, st->skip_samples);
1386  AV_WL32(p + 4, discard_padding);
1387  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1388  }
1389  st->skip_samples = 0;
1390  }
1391 
1392  if (st->inject_global_side_data) {
1393  for (i = 0; i < st->nb_side_data; i++) {
1394  AVPacketSideData *src_sd = &st->side_data[i];
1395  uint8_t *dst_data;
1396 
1397  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1398  continue;
1399 
1400  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1401  if (!dst_data) {
1402  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1403  continue;
1404  }
1405 
1406  memcpy(dst_data, src_sd->data, src_sd->size);
1407  }
1408  st->inject_global_side_data = 0;
1409  }
1410 
1411  if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1413  }
1414 
1415  av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1416  if (metadata) {
1418  av_dict_copy(&s->metadata, metadata, 0);
1419  av_dict_free(&metadata);
1420  av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1421  }
1422 
1423  if (s->debug & FF_FDEBUG_TS)
1424  av_log(s, AV_LOG_DEBUG,
1425  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1426  "size=%d, duration=%d, flags=%d\n",
1427  pkt->stream_index,
1428  av_ts2str(pkt->pts),
1429  av_ts2str(pkt->dts),
1430  pkt->size, pkt->duration, pkt->flags);
1431 
1432  return ret;
1433 }
1434 
1436 {
1437  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1438  int eof = 0;
1439  int ret;
1440  AVStream *st;
1441 
1442  if (!genpts) {
1443  ret = s->packet_buffer
1445  &s->packet_buffer_end, pkt)
1446  : read_frame_internal(s, pkt);
1447  if (ret < 0)
1448  return ret;
1449  goto return_packet;
1450  }
1451 
1452  for (;;) {
1453  AVPacketList *pktl = s->packet_buffer;
1454 
1455  if (pktl) {
1456  AVPacket *next_pkt = &pktl->pkt;
1457 
1458  if (next_pkt->dts != AV_NOPTS_VALUE) {
1459  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1460  // last dts seen for this stream. if any of packets following
1461  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1462  int64_t last_dts = next_pkt->dts;
1463  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1464  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1465  (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1466  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1467  // not B-frame
1468  next_pkt->pts = pktl->pkt.dts;
1469  }
1470  if (last_dts != AV_NOPTS_VALUE) {
1471  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1472  last_dts = pktl->pkt.dts;
1473  }
1474  }
1475  pktl = pktl->next;
1476  }
1477  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1478  // Fixing the last reference frame had none pts issue (For MXF etc).
1479  // We only do this when
1480  // 1. eof.
1481  // 2. we are not able to resolve a pts value for current packet.
1482  // 3. the packets for this stream at the end of the files had valid dts.
1483  next_pkt->pts = last_dts + next_pkt->duration;
1484  }
1485  pktl = s->packet_buffer;
1486  }
1487 
1488  /* read packet from packet buffer, if there is data */
1489  st = s->streams[next_pkt->stream_index];
1490  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1491  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1493  &s->packet_buffer_end, pkt);
1494  goto return_packet;
1495  }
1496  }
1497 
1498  ret = read_frame_internal(s, pkt);
1499  if (ret < 0) {
1500  if (pktl && ret != AVERROR(EAGAIN)) {
1501  eof = 1;
1502  continue;
1503  } else
1504  return ret;
1505  }
1506 
1508  &s->packet_buffer_end)) < 0)
1509  return AVERROR(ENOMEM);
1510  }
1511 
1512 return_packet:
1513 
1514  st = s->streams[pkt->stream_index];
1515  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1516  ff_reduce_index(s, st->index);
1517  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1518  }
1519 
1520  if (is_relative(pkt->dts))
1521  pkt->dts -= RELATIVE_TS_BASE;
1522  if (is_relative(pkt->pts))
1523  pkt->pts -= RELATIVE_TS_BASE;
1524 
1525  return ret;
1526 }
1527 
1528 /* XXX: suppress the packet queue */
1530 {
1534 
1536 }
1537 
1538 /*******************************************************/
1539 /* seek support */
1540 
1542 {
1543  int i;
1544  AVStream *st;
1545  int best_stream = 0;
1546  int best_score = -1;
1547 
1548  if (s->nb_streams <= 0)
1549  return -1;
1550  for (i = 0; i < s->nb_streams; i++) {
1551  int score = 0;
1552  st = s->streams[i];
1553  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1555  if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1556  score += 25;
1557  else
1558  score += 100;
1559  }
1560  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1561  if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1562  score += 12;
1563  else
1564  score += 50;
1565  }
1566 
1567  if (score > best_score) {
1568  best_score = score;
1569  best_stream = i;
1570  }
1571  }
1572  return best_stream;
1573 }
1574 
1575 /** Flush the frame reader. */
1577 {
1578  AVStream *st;
1579  int i, j;
1580 
1581  flush_packet_queue(s);
1582 
1583  /* Reset read state for each stream. */
1584  for (i = 0; i < s->nb_streams; i++) {
1585  st = s->streams[i];
1586 
1587  if (st->parser) {
1588  av_parser_close(st->parser);
1589  st->parser = NULL;
1590  }
1593  if (st->first_dts == AV_NOPTS_VALUE)
1594  st->cur_dts = RELATIVE_TS_BASE;
1595  else
1596  /* We set the current DTS to an unspecified origin. */
1597  st->cur_dts = AV_NOPTS_VALUE;
1598 
1600 
1601  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1602  st->pts_buffer[j] = AV_NOPTS_VALUE;
1603 
1605  st->inject_global_side_data = 1;
1606  }
1607 }
1608 
1609 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1610 {
1611  int i;
1612 
1613  for (i = 0; i < s->nb_streams; i++) {
1614  AVStream *st = s->streams[i];
1615 
1616  st->cur_dts =
1617  av_rescale(timestamp,
1618  st->time_base.den * (int64_t) ref_st->time_base.num,
1619  st->time_base.num * (int64_t) ref_st->time_base.den);
1620  }
1621 }
1622 
1623 void ff_reduce_index(AVFormatContext *s, int stream_index)
1624 {
1625  AVStream *st = s->streams[stream_index];
1626  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1627 
1628  if ((unsigned) st->nb_index_entries >= max_entries) {
1629  int i;
1630  for (i = 0; 2 * i < st->nb_index_entries; i++)
1631  st->index_entries[i] = st->index_entries[2 * i];
1632  st->nb_index_entries = i;
1633  }
1634 }
1635 
1636 int ff_add_index_entry(AVIndexEntry **index_entries,
1637  int *nb_index_entries,
1638  unsigned int *index_entries_allocated_size,
1639  int64_t pos, int64_t timestamp,
1640  int size, int distance, int flags)
1641 {
1642  AVIndexEntry *entries, *ie;
1643  int index;
1644 
1645  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1646  return -1;
1647 
1648  if (timestamp == AV_NOPTS_VALUE)
1649  return AVERROR(EINVAL);
1650 
1651  if (size < 0 || size > 0x3FFFFFFF)
1652  return AVERROR(EINVAL);
1653 
1654  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1655  timestamp -= RELATIVE_TS_BASE;
1656 
1657  entries = av_fast_realloc(*index_entries,
1658  index_entries_allocated_size,
1659  (*nb_index_entries + 1) *
1660  sizeof(AVIndexEntry));
1661  if (!entries)
1662  return -1;
1663 
1664  *index_entries = entries;
1665 
1666  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1667  timestamp, AVSEEK_FLAG_ANY);
1668 
1669  if (index < 0) {
1670  index = (*nb_index_entries)++;
1671  ie = &entries[index];
1672  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1673  } else {
1674  ie = &entries[index];
1675  if (ie->timestamp != timestamp) {
1676  if (ie->timestamp <= timestamp)
1677  return -1;
1678  memmove(entries + index + 1, entries + index,
1679  sizeof(AVIndexEntry) * (*nb_index_entries - index));
1680  (*nb_index_entries)++;
1681  } else if (ie->pos == pos && distance < ie->min_distance)
1682  // do not reduce the distance
1683  distance = ie->min_distance;
1684  }
1685 
1686  ie->pos = pos;
1687  ie->timestamp = timestamp;
1688  ie->min_distance = distance;
1689  ie->size = size;
1690  ie->flags = flags;
1691 
1692  return index;
1693 }
1694 
1695 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1696  int size, int distance, int flags)
1697 {
1698  timestamp = wrap_timestamp(st, timestamp);
1700  &st->index_entries_allocated_size, pos,
1701  timestamp, size, distance, flags);
1702 }
1703 
1704 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1705  int64_t wanted_timestamp, int flags)
1706 {
1707  int a, b, m;
1708  int64_t timestamp;
1709 
1710  a = -1;
1711  b = nb_entries;
1712 
1713  // Optimize appending index entries at the end.
1714  if (b && entries[b - 1].timestamp < wanted_timestamp)
1715  a = b - 1;
1716 
1717  while (b - a > 1) {
1718  m = (a + b) >> 1;
1719  timestamp = entries[m].timestamp;
1720  if (timestamp >= wanted_timestamp)
1721  b = m;
1722  if (timestamp <= wanted_timestamp)
1723  a = m;
1724  }
1725  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1726 
1727  if (!(flags & AVSEEK_FLAG_ANY))
1728  while (m >= 0 && m < nb_entries &&
1729  !(entries[m].flags & AVINDEX_KEYFRAME))
1730  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1731 
1732  if (m == nb_entries)
1733  return -1;
1734  return m;
1735 }
1736 
1737 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1738 {
1740  wanted_timestamp, flags);
1741 }
1742 
1743 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1744  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1745 {
1746  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1747  if (stream_index >= 0)
1748  ts = wrap_timestamp(s->streams[stream_index], ts);
1749  return ts;
1750 }
1751 
1752 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1753  int64_t target_ts, int flags)
1754 {
1755  AVInputFormat *avif = s->iformat;
1756  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1757  int64_t ts_min, ts_max, ts;
1758  int index;
1759  int64_t ret;
1760  AVStream *st;
1761 
1762  if (stream_index < 0)
1763  return -1;
1764 
1765  av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1766 
1767  ts_max =
1768  ts_min = AV_NOPTS_VALUE;
1769  pos_limit = -1; // GCC falsely says it may be uninitialized.
1770 
1771  st = s->streams[stream_index];
1772  if (st->index_entries) {
1773  AVIndexEntry *e;
1774 
1775  /* FIXME: Whole function must be checked for non-keyframe entries in
1776  * index case, especially read_timestamp(). */
1777  index = av_index_search_timestamp(st, target_ts,
1778  flags | AVSEEK_FLAG_BACKWARD);
1779  index = FFMAX(index, 0);
1780  e = &st->index_entries[index];
1781 
1782  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1783  pos_min = e->pos;
1784  ts_min = e->timestamp;
1785  av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1786  pos_min, av_ts2str(ts_min));
1787  } else {
1788  av_assert1(index == 0);
1789  }
1790 
1791  index = av_index_search_timestamp(st, target_ts,
1792  flags & ~AVSEEK_FLAG_BACKWARD);
1793  av_assert0(index < st->nb_index_entries);
1794  if (index >= 0) {
1795  e = &st->index_entries[index];
1796  av_assert1(e->timestamp >= target_ts);
1797  pos_max = e->pos;
1798  ts_max = e->timestamp;
1799  pos_limit = pos_max - e->min_distance;
1800  av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1801  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1802  }
1803  }
1804 
1805  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1806  ts_min, ts_max, flags, &ts, avif->read_timestamp);
1807  if (pos < 0)
1808  return -1;
1809 
1810  /* do the seek */
1811  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1812  return ret;
1813 
1815  ff_update_cur_dts(s, st, ts);
1816 
1817  return 0;
1818 }
1819 
1820 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1821  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1822 {
1823  int64_t step = 1024;
1824  int64_t limit, ts_max;
1825  int64_t filesize = avio_size(s->pb);
1826  int64_t pos_max = filesize - 1;
1827  do {
1828  limit = pos_max;
1829  pos_max = FFMAX(0, (pos_max) - step);
1830  ts_max = ff_read_timestamp(s, stream_index,
1831  &pos_max, limit, read_timestamp);
1832  step += step;
1833  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1834  if (ts_max == AV_NOPTS_VALUE)
1835  return -1;
1836 
1837  for (;;) {
1838  int64_t tmp_pos = pos_max + 1;
1839  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1840  &tmp_pos, INT64_MAX, read_timestamp);
1841  if (tmp_ts == AV_NOPTS_VALUE)
1842  break;
1843  av_assert0(tmp_pos > pos_max);
1844  ts_max = tmp_ts;
1845  pos_max = tmp_pos;
1846  if (tmp_pos >= filesize)
1847  break;
1848  }
1849 
1850  if (ts)
1851  *ts = ts_max;
1852  if (pos)
1853  *pos = pos_max;
1854 
1855  return 0;
1856 }
1857 
1858 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1859  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1860  int64_t ts_min, int64_t ts_max,
1861  int flags, int64_t *ts_ret,
1862  int64_t (*read_timestamp)(struct AVFormatContext *, int,
1863  int64_t *, int64_t))
1864 {
1865  int64_t pos, ts;
1866  int64_t start_pos;
1867  int no_change;
1868  int ret;
1869 
1870  av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1871 
1872  if (ts_min == AV_NOPTS_VALUE) {
1873  pos_min = s->data_offset;
1874  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1875  if (ts_min == AV_NOPTS_VALUE)
1876  return -1;
1877  }
1878 
1879  if (ts_min >= target_ts) {
1880  *ts_ret = ts_min;
1881  return pos_min;
1882  }
1883 
1884  if (ts_max == AV_NOPTS_VALUE) {
1885  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1886  return ret;
1887  pos_limit = pos_max;
1888  }
1889 
1890  if (ts_max <= target_ts) {
1891  *ts_ret = ts_max;
1892  return pos_max;
1893  }
1894 
1895  if (ts_min > ts_max)
1896  return -1;
1897  else if (ts_min == ts_max)
1898  pos_limit = pos_min;
1899 
1900  no_change = 0;
1901  while (pos_min < pos_limit) {
1902  av_dlog(s,
1903  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1904  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1905  assert(pos_limit <= pos_max);
1906 
1907  if (no_change == 0) {
1908  int64_t approximate_keyframe_distance = pos_max - pos_limit;
1909  // interpolate position (better than dichotomy)
1910  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1911  ts_max - ts_min) +
1912  pos_min - approximate_keyframe_distance;
1913  } else if (no_change == 1) {
1914  // bisection if interpolation did not change min / max pos last time
1915  pos = (pos_min + pos_limit) >> 1;
1916  } else {
1917  /* linear search if bisection failed, can only happen if there
1918  * are very few or no keyframes between min/max */
1919  pos = pos_min;
1920  }
1921  if (pos <= pos_min)
1922  pos = pos_min + 1;
1923  else if (pos > pos_limit)
1924  pos = pos_limit;
1925  start_pos = pos;
1926 
1927  // May pass pos_limit instead of -1.
1928  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1929  if (pos == pos_max)
1930  no_change++;
1931  else
1932  no_change = 0;
1933  av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1934  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1935  pos_min, pos, pos_max,
1936  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1937  pos_limit, start_pos, no_change);
1938  if (ts == AV_NOPTS_VALUE) {
1939  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1940  return -1;
1941  }
1942  if (target_ts <= ts) {
1943  pos_limit = start_pos - 1;
1944  pos_max = pos;
1945  ts_max = ts;
1946  }
1947  if (target_ts >= ts) {
1948  pos_min = pos;
1949  ts_min = ts;
1950  }
1951  }
1952 
1953  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1954  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1955 #if 0
1956  pos_min = pos;
1957  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1958  pos_min++;
1959  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1960  av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1961  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1962 #endif
1963  *ts_ret = ts;
1964  return pos;
1965 }
1966 
1967 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1968  int64_t pos, int flags)
1969 {
1970  int64_t pos_min, pos_max;
1971 
1972  pos_min = s->data_offset;
1973  pos_max = avio_size(s->pb) - 1;
1974 
1975  if (pos < pos_min)
1976  pos = pos_min;
1977  else if (pos > pos_max)
1978  pos = pos_max;
1979 
1980  avio_seek(s->pb, pos, SEEK_SET);
1981 
1982  s->io_repositioned = 1;
1983 
1984  return 0;
1985 }
1986 
1987 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1988  int64_t timestamp, int flags)
1989 {
1990  int index;
1991  int64_t ret;
1992  AVStream *st;
1993  AVIndexEntry *ie;
1994 
1995  st = s->streams[stream_index];
1996 
1997  index = av_index_search_timestamp(st, timestamp, flags);
1998 
1999  if (index < 0 && st->nb_index_entries &&
2000  timestamp < st->index_entries[0].timestamp)
2001  return -1;
2002 
2003  if (index < 0 || index == st->nb_index_entries - 1) {
2004  AVPacket pkt;
2005  int nonkey = 0;
2006 
2007  if (st->nb_index_entries) {
2009  ie = &st->index_entries[st->nb_index_entries - 1];
2010  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2011  return ret;
2012  ff_update_cur_dts(s, st, ie->timestamp);
2013  } else {
2014  if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2015  return ret;
2016  }
2017  for (;;) {
2018  int read_status;
2019  do {
2020  read_status = av_read_frame(s, &pkt);
2021  } while (read_status == AVERROR(EAGAIN));
2022  if (read_status < 0)
2023  break;
2024  av_free_packet(&pkt);
2025  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2026  if (pkt.flags & AV_PKT_FLAG_KEY)
2027  break;
2028  if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2029  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);
2030  break;
2031  }
2032  }
2033  }
2034  index = av_index_search_timestamp(st, timestamp, flags);
2035  }
2036  if (index < 0)
2037  return -1;
2038 
2040  if (s->iformat->read_seek)
2041  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2042  return 0;
2043  ie = &st->index_entries[index];
2044  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2045  return ret;
2046  ff_update_cur_dts(s, st, ie->timestamp);
2047 
2048  return 0;
2049 }
2050 
2051 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2052  int64_t timestamp, int flags)
2053 {
2054  int ret;
2055  AVStream *st;
2056 
2057  if (flags & AVSEEK_FLAG_BYTE) {
2058  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2059  return -1;
2061  return seek_frame_byte(s, stream_index, timestamp, flags);
2062  }
2063 
2064  if (stream_index < 0) {
2065  stream_index = av_find_default_stream_index(s);
2066  if (stream_index < 0)
2067  return -1;
2068 
2069  st = s->streams[stream_index];
2070  /* timestamp for default must be expressed in AV_TIME_BASE units */
2071  timestamp = av_rescale(timestamp, st->time_base.den,
2072  AV_TIME_BASE * (int64_t) st->time_base.num);
2073  }
2074 
2075  /* first, we try the format specific seek */
2076  if (s->iformat->read_seek) {
2078  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2079  } else
2080  ret = -1;
2081  if (ret >= 0)
2082  return 0;
2083 
2084  if (s->iformat->read_timestamp &&
2085  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2087  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2088  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2090  return seek_frame_generic(s, stream_index, timestamp, flags);
2091  } else
2092  return -1;
2093 }
2094 
2095 int av_seek_frame(AVFormatContext *s, int stream_index,
2096  int64_t timestamp, int flags)
2097 {
2098  int ret;
2099 
2100  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2101  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2102  if ((flags & AVSEEK_FLAG_BACKWARD))
2103  max_ts = timestamp;
2104  else
2105  min_ts = timestamp;
2106  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2107  flags & ~AVSEEK_FLAG_BACKWARD);
2108  }
2109 
2110  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2111 
2112  if (ret >= 0)
2114 
2115  return ret;
2116 }
2117 
2118 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2119  int64_t ts, int64_t max_ts, int flags)
2120 {
2121  if (min_ts > ts || max_ts < ts)
2122  return -1;
2123  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2124  return AVERROR(EINVAL);
2125 
2126  if (s->seek2any>0)
2127  flags |= AVSEEK_FLAG_ANY;
2128  flags &= ~AVSEEK_FLAG_BACKWARD;
2129 
2130  if (s->iformat->read_seek2) {
2131  int ret;
2133 
2134  if (stream_index == -1 && s->nb_streams == 1) {
2135  AVRational time_base = s->streams[0]->time_base;
2136  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2137  min_ts = av_rescale_rnd(min_ts, time_base.den,
2138  time_base.num * (int64_t)AV_TIME_BASE,
2140  max_ts = av_rescale_rnd(max_ts, time_base.den,
2141  time_base.num * (int64_t)AV_TIME_BASE,
2143  }
2144 
2145  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2146  ts, max_ts, flags);
2147 
2148  if (ret >= 0)
2150  return ret;
2151  }
2152 
2153  if (s->iformat->read_timestamp) {
2154  // try to seek via read_timestamp()
2155  }
2156 
2157  // Fall back on old API if new is not implemented but old is.
2158  // Note the old API has somewhat different semantics.
2159  if (s->iformat->read_seek || 1) {
2160  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2161  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2162  if (ret<0 && ts != min_ts && max_ts != ts) {
2163  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2164  if (ret >= 0)
2165  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2166  }
2167  return ret;
2168  }
2169 
2170  // try some generic seek like seek_frame_generic() but with new ts semantics
2171  return -1; //unreachable
2172 }
2173 
2174 /*******************************************************/
2175 
2176 /**
2177  * Return TRUE if the stream has accurate duration in any stream.
2178  *
2179  * @return TRUE if the stream has accurate duration for at least one component.
2180  */
2182 {
2183  int i;
2184  AVStream *st;
2185 
2186  for (i = 0; i < ic->nb_streams; i++) {
2187  st = ic->streams[i];
2188  if (st->duration != AV_NOPTS_VALUE)
2189  return 1;
2190  }
2191  if (ic->duration != AV_NOPTS_VALUE)
2192  return 1;
2193  return 0;
2194 }
2195 
2196 /**
2197  * Estimate the stream timings from the one of each components.
2198  *
2199  * Also computes the global bitrate if possible.
2200  */
2202 {
2203  int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2204  int64_t duration, duration1, filesize;
2205  int i;
2206  AVStream *st;
2207  AVProgram *p;
2208 
2209  start_time = INT64_MAX;
2210  start_time_text = INT64_MAX;
2211  end_time = INT64_MIN;
2212  duration = INT64_MIN;
2213  for (i = 0; i < ic->nb_streams; i++) {
2214  st = ic->streams[i];
2215  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2216  start_time1 = av_rescale_q(st->start_time, st->time_base,
2217  AV_TIME_BASE_Q);
2219  if (start_time1 < start_time_text)
2220  start_time_text = start_time1;
2221  } else
2222  start_time = FFMIN(start_time, start_time1);
2223  end_time1 = AV_NOPTS_VALUE;
2224  if (st->duration != AV_NOPTS_VALUE) {
2225  end_time1 = start_time1 +
2226  av_rescale_q(st->duration, st->time_base,
2227  AV_TIME_BASE_Q);
2228  end_time = FFMAX(end_time, end_time1);
2229  }
2230  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2231  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2232  p->start_time = start_time1;
2233  if (p->end_time < end_time1)
2234  p->end_time = end_time1;
2235  }
2236  }
2237  if (st->duration != AV_NOPTS_VALUE) {
2238  duration1 = av_rescale_q(st->duration, st->time_base,
2239  AV_TIME_BASE_Q);
2240  duration = FFMAX(duration, duration1);
2241  }
2242  }
2243  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2244  start_time = start_time_text;
2245  else if (start_time > start_time_text)
2246  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2247 
2248  if (start_time != INT64_MAX) {
2249  ic->start_time = start_time;
2250  if (end_time != INT64_MIN) {
2251  if (ic->nb_programs) {
2252  for (i = 0; i < ic->nb_programs; i++) {
2253  p = ic->programs[i];
2254  if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2255  duration = FFMAX(duration, p->end_time - p->start_time);
2256  }
2257  } else
2258  duration = FFMAX(duration, end_time - start_time);
2259  }
2260  }
2261  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2262  ic->duration = duration;
2263  }
2264  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2265  /* compute the bitrate */
2266  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2267  (double) ic->duration;
2268  if (bitrate >= 0 && bitrate <= INT_MAX)
2269  ic->bit_rate = bitrate;
2270  }
2271 }
2272 
2274 {
2275  int i;
2276  AVStream *st;
2277 
2279  for (i = 0; i < ic->nb_streams; i++) {
2280  st = ic->streams[i];
2281  if (st->start_time == AV_NOPTS_VALUE) {
2282  if (ic->start_time != AV_NOPTS_VALUE)
2284  st->time_base);
2285  if (ic->duration != AV_NOPTS_VALUE)
2287  st->time_base);
2288  }
2289  }
2290 }
2291 
2293 {
2294  int64_t filesize, duration;
2295  int i, show_warning = 0;
2296  AVStream *st;
2297 
2298  /* if bit_rate is already set, we believe it */
2299  if (ic->bit_rate <= 0) {
2300  int bit_rate = 0;
2301  for (i = 0; i < ic->nb_streams; i++) {
2302  st = ic->streams[i];
2303  if (st->codec->bit_rate > 0) {
2304  if (INT_MAX - st->codec->bit_rate < bit_rate) {
2305  bit_rate = 0;
2306  break;
2307  }
2308  bit_rate += st->codec->bit_rate;
2309  }
2310  }
2311  ic->bit_rate = bit_rate;
2312  }
2313 
2314  /* if duration is already set, we believe it */
2315  if (ic->duration == AV_NOPTS_VALUE &&
2316  ic->bit_rate != 0) {
2317  filesize = ic->pb ? avio_size(ic->pb) : 0;
2318  if (filesize > ic->data_offset) {
2319  filesize -= ic->data_offset;
2320  for (i = 0; i < ic->nb_streams; i++) {
2321  st = ic->streams[i];
2322  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2323  && st->duration == AV_NOPTS_VALUE) {
2324  duration = av_rescale(8 * filesize, st->time_base.den,
2325  ic->bit_rate *
2326  (int64_t) st->time_base.num);
2327  st->duration = duration;
2328  show_warning = 1;
2329  }
2330  }
2331  }
2332  }
2333  if (show_warning)
2334  av_log(ic, AV_LOG_WARNING,
2335  "Estimating duration from bitrate, this may be inaccurate\n");
2336 }
2337 
2338 #define DURATION_MAX_READ_SIZE 250000LL
2339 #define DURATION_MAX_RETRY 4
2340 
2341 /* only usable for MPEG-PS streams */
2342 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2343 {
2344  AVPacket pkt1, *pkt = &pkt1;
2345  AVStream *st;
2346  int num, den, read_size, i, ret;
2347  int found_duration = 0;
2348  int is_end;
2349  int64_t filesize, offset, duration;
2350  int retry = 0;
2351 
2352  /* flush packet queue */
2353  flush_packet_queue(ic);
2354 
2355  for (i = 0; i < ic->nb_streams; i++) {
2356  st = ic->streams[i];
2357  if (st->start_time == AV_NOPTS_VALUE &&
2358  st->first_dts == AV_NOPTS_VALUE &&
2361  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2362 
2363  if (st->parser) {
2364  av_parser_close(st->parser);
2365  st->parser = NULL;
2366  }
2367  }
2368 
2369  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2370  /* estimate the end time (duration) */
2371  /* XXX: may need to support wrapping */
2372  filesize = ic->pb ? avio_size(ic->pb) : 0;
2373  do {
2374  is_end = found_duration;
2375  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2376  if (offset < 0)
2377  offset = 0;
2378 
2379  avio_seek(ic->pb, offset, SEEK_SET);
2380  read_size = 0;
2381  for (;;) {
2382  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2383  break;
2384 
2385  do {
2386  ret = ff_read_packet(ic, pkt);
2387  } while (ret == AVERROR(EAGAIN));
2388  if (ret != 0)
2389  break;
2390  read_size += pkt->size;
2391  st = ic->streams[pkt->stream_index];
2392  if (pkt->pts != AV_NOPTS_VALUE &&
2393  (st->start_time != AV_NOPTS_VALUE ||
2394  st->first_dts != AV_NOPTS_VALUE)) {
2395  if (pkt->duration == 0) {
2396  ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2397  if (den && num) {
2398  pkt->duration = av_rescale_rnd(1,
2399  num * (int64_t) st->time_base.den,
2400  den * (int64_t) st->time_base.num,
2401  AV_ROUND_DOWN);
2402  }
2403  }
2404  duration = pkt->pts + pkt->duration;
2405  found_duration = 1;
2406  if (st->start_time != AV_NOPTS_VALUE)
2407  duration -= st->start_time;
2408  else
2409  duration -= st->first_dts;
2410  if (duration > 0) {
2411  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2412  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2413  st->duration = duration;
2414  st->info->last_duration = duration;
2415  }
2416  }
2417  av_free_packet(pkt);
2418  }
2419 
2420  /* check if all audio/video streams have valid duration */
2421  if (!is_end) {
2422  is_end = 1;
2423  for (i = 0; i < ic->nb_streams; i++) {
2424  st = ic->streams[i];
2425  switch (st->codec->codec_type) {
2426  case AVMEDIA_TYPE_VIDEO:
2427  case AVMEDIA_TYPE_AUDIO:
2428  if (st->duration == AV_NOPTS_VALUE)
2429  is_end = 0;
2430  }
2431  }
2432  }
2433  } while (!is_end &&
2434  offset &&
2435  ++retry <= DURATION_MAX_RETRY);
2436 
2437  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2438 
2439  /* warn about audio/video streams which duration could not be estimated */
2440  for (i = 0; i < ic->nb_streams; i++) {
2441  st = ic->streams[i];
2442  if (st->duration == AV_NOPTS_VALUE) {
2443  switch (st->codec->codec_type) {
2444  case AVMEDIA_TYPE_VIDEO:
2445  case AVMEDIA_TYPE_AUDIO:
2446  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2447  av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2448  } else
2449  av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2450  }
2451  }
2452  }
2454 
2455  avio_seek(ic->pb, old_offset, SEEK_SET);
2456  for (i = 0; i < ic->nb_streams; i++) {
2457  int j;
2458 
2459  st = ic->streams[i];
2460  st->cur_dts = st->first_dts;
2463  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2464  st->pts_buffer[j] = AV_NOPTS_VALUE;
2465  }
2466 }
2467 
2468 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2469 {
2470  int64_t file_size;
2471 
2472  /* get the file size, if possible */
2473  if (ic->iformat->flags & AVFMT_NOFILE) {
2474  file_size = 0;
2475  } else {
2476  file_size = avio_size(ic->pb);
2477  file_size = FFMAX(0, file_size);
2478  }
2479 
2480  if ((!strcmp(ic->iformat->name, "mpeg") ||
2481  !strcmp(ic->iformat->name, "mpegts")) &&
2482  file_size && ic->pb->seekable) {
2483  /* get accurate estimate from the PTSes */
2484  estimate_timings_from_pts(ic, old_offset);
2486  } else if (has_duration(ic)) {
2487  /* at least one component has timings - we use them for all
2488  * the components */
2491  } else {
2492  /* less precise: use bitrate info */
2495  }
2497 
2498  {
2499  int i;
2500  AVStream av_unused *st;
2501  for (i = 0; i < ic->nb_streams; i++) {
2502  st = ic->streams[i];
2503  av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2504  (double) st->start_time / AV_TIME_BASE,
2505  (double) st->duration / AV_TIME_BASE);
2506  }
2507  av_dlog(ic,
2508  "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2509  (double) ic->start_time / AV_TIME_BASE,
2510  (double) ic->duration / AV_TIME_BASE,
2511  ic->bit_rate / 1000);
2512  }
2513 }
2514 
2515 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2516 {
2517  AVCodecContext *avctx = st->codec;
2518 
2519 #define FAIL(errmsg) do { \
2520  if (errmsg_ptr) \
2521  *errmsg_ptr = errmsg; \
2522  return 0; \
2523  } while (0)
2524 
2525  if ( avctx->codec_id == AV_CODEC_ID_NONE
2526  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2527  FAIL("unknown codec");
2528  switch (avctx->codec_type) {
2529  case AVMEDIA_TYPE_AUDIO:
2530  if (!avctx->frame_size && determinable_frame_size(avctx))
2531  FAIL("unspecified frame size");
2532  if (st->info->found_decoder >= 0 &&
2533  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2534  FAIL("unspecified sample format");
2535  if (!avctx->sample_rate)
2536  FAIL("unspecified sample rate");
2537  if (!avctx->channels)
2538  FAIL("unspecified number of channels");
2539  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2540  FAIL("no decodable DTS frames");
2541  break;
2542  case AVMEDIA_TYPE_VIDEO:
2543  if (!avctx->width)
2544  FAIL("unspecified size");
2545  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2546  FAIL("unspecified pixel format");
2549  FAIL("no frame in rv30/40 and no sar");
2550  break;
2551  case AVMEDIA_TYPE_SUBTITLE:
2552  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2553  FAIL("unspecified size");
2554  break;
2555  case AVMEDIA_TYPE_DATA:
2556  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2557  }
2558 
2559  return 1;
2560 }
2561 
2562 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2565 {
2566  const AVCodec *codec;
2567  int got_picture = 1, ret = 0;
2569  AVSubtitle subtitle;
2570  AVPacket pkt = *avpkt;
2571 
2572  if (!frame)
2573  return AVERROR(ENOMEM);
2574 
2575  if (!avcodec_is_open(st->codec) &&
2576  st->info->found_decoder <= 0 &&
2577  (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2578  AVDictionary *thread_opt = NULL;
2579 
2580  codec = find_decoder(s, st, st->codec->codec_id);
2581 
2582  if (!codec) {
2583  st->info->found_decoder = -st->codec->codec_id;
2584  ret = -1;
2585  goto fail;
2586  }
2587 
2588  /* Force thread count to 1 since the H.264 decoder will not extract
2589  * SPS and PPS to extradata during multi-threaded decoding. */
2590  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2591  if (s->codec_whitelist)
2592  av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2593  ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2594  if (!options)
2595  av_dict_free(&thread_opt);
2596  if (ret < 0) {
2597  st->info->found_decoder = -st->codec->codec_id;
2598  goto fail;
2599  }
2600  st->info->found_decoder = 1;
2601  } else if (!st->info->found_decoder)
2602  st->info->found_decoder = 1;
2603 
2604  if (st->info->found_decoder < 0) {
2605  ret = -1;
2606  goto fail;
2607  }
2608 
2609  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2610  ret >= 0 &&
2612  (!st->codec_info_nb_frames &&
2614  got_picture = 0;
2615  switch (st->codec->codec_type) {
2616  case AVMEDIA_TYPE_VIDEO:
2617  ret = avcodec_decode_video2(st->codec, frame,
2618  &got_picture, &pkt);
2619  break;
2620  case AVMEDIA_TYPE_AUDIO:
2621  ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2622  break;
2623  case AVMEDIA_TYPE_SUBTITLE:
2624  ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2625  &got_picture, &pkt);
2626  ret = pkt.size;
2627  break;
2628  default:
2629  break;
2630  }
2631  if (ret >= 0) {
2632  if (got_picture)
2633  st->nb_decoded_frames++;
2634  pkt.data += ret;
2635  pkt.size -= ret;
2636  ret = got_picture;
2637  }
2638  }
2639 
2640  if (!pkt.data && !got_picture)
2641  ret = -1;
2642 
2643 fail:
2644  av_frame_free(&frame);
2645  return ret;
2646 }
2647 
2648 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2649 {
2650  while (tags->id != AV_CODEC_ID_NONE) {
2651  if (tags->id == id)
2652  return tags->tag;
2653  tags++;
2654  }
2655  return 0;
2656 }
2657 
2658 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2659 {
2660  int i;
2661  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2662  if (tag == tags[i].tag)
2663  return tags[i].id;
2664  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2665  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2666  return tags[i].id;
2667  return AV_CODEC_ID_NONE;
2668 }
2669 
2670 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2671 {
2672  if (flt) {
2673  switch (bps) {
2674  case 32:
2676  case 64:
2678  default:
2679  return AV_CODEC_ID_NONE;
2680  }
2681  } else {
2682  bps += 7;
2683  bps >>= 3;
2684  if (sflags & (1 << (bps - 1))) {
2685  switch (bps) {
2686  case 1:
2687  return AV_CODEC_ID_PCM_S8;
2688  case 2:
2690  case 3:
2692  case 4:
2694  default:
2695  return AV_CODEC_ID_NONE;
2696  }
2697  } else {
2698  switch (bps) {
2699  case 1:
2700  return AV_CODEC_ID_PCM_U8;
2701  case 2:
2703  case 3:
2705  case 4:
2707  default:
2708  return AV_CODEC_ID_NONE;
2709  }
2710  }
2711  }
2712 }
2713 
2714 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2715 {
2716  unsigned int tag;
2717  if (!av_codec_get_tag2(tags, id, &tag))
2718  return 0;
2719  return tag;
2720 }
2721 
2722 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2723  unsigned int *tag)
2724 {
2725  int i;
2726  for (i = 0; tags && tags[i]; i++) {
2727  const AVCodecTag *codec_tags = tags[i];
2728  while (codec_tags->id != AV_CODEC_ID_NONE) {
2729  if (codec_tags->id == id) {
2730  *tag = codec_tags->tag;
2731  return 1;
2732  }
2733  codec_tags++;
2734  }
2735  }
2736  return 0;
2737 }
2738 
2739 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2740 {
2741  int i;
2742  for (i = 0; tags && tags[i]; i++) {
2743  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2744  if (id != AV_CODEC_ID_NONE)
2745  return id;
2746  }
2747  return AV_CODEC_ID_NONE;
2748 }
2749 
2751 {
2752  unsigned int i, j;
2753  int64_t max_time = s->duration +
2754  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2755 
2756  for (i = 0; i < s->nb_chapters; i++)
2757  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2758  AVChapter *ch = s->chapters[i];
2759  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2760  ch->time_base)
2761  : INT64_MAX;
2762 
2763  for (j = 0; j < s->nb_chapters; j++) {
2764  AVChapter *ch1 = s->chapters[j];
2765  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2766  ch->time_base);
2767  if (j != i && next_start > ch->start && next_start < end)
2768  end = next_start;
2769  }
2770  ch->end = (end == INT64_MAX) ? ch->start : end;
2771  }
2772 }
2773 
2774 static int get_std_framerate(int i)
2775 {
2776  if (i < 60 * 12)
2777  return (i + 1) * 1001;
2778  else
2779  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2780 }
2781 
2782 /* Is the time base unreliable?
2783  * This is a heuristic to balance between quick acceptance of the values in
2784  * the headers vs. some extra checks.
2785  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2786  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2787  * And there are "variable" fps files this needs to detect as well. */
2789 {
2790  if (c->time_base.den >= 101L * c->time_base.num ||
2791  c->time_base.den < 5L * c->time_base.num ||
2792  // c->codec_tag == AV_RL32("DIVX") ||
2793  // c->codec_tag == AV_RL32("XVID") ||
2794  c->codec_tag == AV_RL32("mp4v") ||
2796  c->codec_id == AV_CODEC_ID_GIF ||
2797  c->codec_id == AV_CODEC_ID_H264)
2798  return 1;
2799  return 0;
2800 }
2801 
2803 {
2804  int ret;
2805 
2807  avctx->extradata_size = 0;
2808  return AVERROR(EINVAL);
2809  }
2811  if (avctx->extradata) {
2812  memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2813  avctx->extradata_size = size;
2814  ret = 0;
2815  } else {
2816  avctx->extradata_size = 0;
2817  ret = AVERROR(ENOMEM);
2818  }
2819  return ret;
2820 }
2821 
2823 {
2824  int ret = ff_alloc_extradata(avctx, size);
2825  if (ret < 0)
2826  return ret;
2827  ret = avio_read(pb, avctx->extradata, size);
2828  if (ret != size) {
2829  av_freep(&avctx->extradata);
2830  avctx->extradata_size = 0;
2831  av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2832  return ret < 0 ? ret : AVERROR_INVALIDDATA;
2833  }
2834 
2835  return ret;
2836 }
2837 
2838 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2839 {
2840  int i, j;
2841  int64_t last = st->info->last_dts;
2842 
2843  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2844  && ts - (uint64_t)last < INT64_MAX) {
2845  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2846  int64_t duration = ts - last;
2847 
2848  if (!st->info->duration_error)
2849  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2850  if (!st->info->duration_error)
2851  return AVERROR(ENOMEM);
2852 
2853 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2854 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2855  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2856  if (st->info->duration_error[0][1][i] < 1e10) {
2857  int framerate = get_std_framerate(i);
2858  double sdts = dts*framerate/(1001*12);
2859  for (j= 0; j<2; j++) {
2860  int64_t ticks = llrint(sdts+j*0.5);
2861  double error= sdts - ticks + j*0.5;
2862  st->info->duration_error[j][0][i] += error;
2863  st->info->duration_error[j][1][i] += error*error;
2864  }
2865  }
2866  }
2867  st->info->duration_count++;
2869 
2870  if (st->info->duration_count % 10 == 0) {
2871  int n = st->info->duration_count;
2872  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2873  if (st->info->duration_error[0][1][i] < 1e10) {
2874  double a0 = st->info->duration_error[0][0][i] / n;
2875  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2876  double a1 = st->info->duration_error[1][0][i] / n;
2877  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2878  if (error0 > 0.04 && error1 > 0.04) {
2879  st->info->duration_error[0][1][i] = 2e10;
2880  st->info->duration_error[1][1][i] = 2e10;
2881  }
2882  }
2883  }
2884  }
2885 
2886  // ignore the first 4 values, they might have some random jitter
2887  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2888  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2889  }
2890  if (ts != AV_NOPTS_VALUE)
2891  st->info->last_dts = ts;
2892 
2893  return 0;
2894 }
2895 
2897 {
2898  int i, j;
2899 
2900  for (i = 0; i < ic->nb_streams; i++) {
2901  AVStream *st = ic->streams[i];
2902 
2903  if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2904  continue;
2905  // the check for tb_unreliable() is not completely correct, since this is not about handling
2906  // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2907  // ipmovie.c produces.
2908  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)
2909  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);
2910  if (st->info->duration_count>1 && !st->r_frame_rate.num
2911  && tb_unreliable(st->codec)) {
2912  int num = 0;
2913  double best_error= 0.01;
2914  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2915 
2916  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2917  int k;
2918 
2919  if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2920  continue;
2921  if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2922  continue;
2923 
2924  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2925  continue;
2926 
2927  for (k= 0; k<2; k++) {
2928  int n = st->info->duration_count;
2929  double a= st->info->duration_error[k][0][j] / n;
2930  double error= st->info->duration_error[k][1][j]/n - a*a;
2931 
2932  if (error < best_error && best_error> 0.000000001) {
2933  best_error= error;
2934  num = get_std_framerate(j);
2935  }
2936  if (error < 0.02)
2937  av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2938  }
2939  }
2940  // do not increase frame rate by more than 1 % in order to match a standard rate.
2941  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2942  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2943  }
2944  if ( !st->avg_frame_rate.num
2945  && st->r_frame_rate.num && st->info->rfps_duration_sum
2946  && st->info->codec_info_duration <= 0
2947  && st->info->duration_count > 2
2948  && 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
2949  ) {
2950  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2951  st->avg_frame_rate = st->r_frame_rate;
2952  }
2953 
2954  av_freep(&st->info->duration_error);
2955  st->info->last_dts = AV_NOPTS_VALUE;
2956  st->info->duration_count = 0;
2957  st->info->rfps_duration_sum = 0;
2958  }
2959 }
2960 
2962 {
2963  int i, count, ret = 0, j;
2964  int64_t read_size;
2965  AVStream *st;
2966  AVPacket pkt1, *pkt;
2967  int64_t old_offset = avio_tell(ic->pb);
2968  // new streams might appear, no options for those
2969  int orig_nb_streams = ic->nb_streams;
2970  int flush_codecs;
2971  int64_t max_analyze_duration = ic->max_analyze_duration2;
2972  int64_t probesize = ic->probesize2;
2973 
2974  if (!max_analyze_duration)
2975  max_analyze_duration = ic->max_analyze_duration;
2976  if (ic->probesize)
2977  probesize = ic->probesize;
2978  flush_codecs = probesize > 0;
2979 
2980  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2981 
2982  if (!max_analyze_duration) {
2983  if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2984  max_analyze_duration = 10*AV_TIME_BASE;
2985  } else
2986  max_analyze_duration = 5*AV_TIME_BASE;
2987  }
2988 
2989  if (ic->pb)
2990  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2991  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2992 
2993  for (i = 0; i < ic->nb_streams; i++) {
2994  const AVCodec *codec;
2995  AVDictionary *thread_opt = NULL;
2996  st = ic->streams[i];
2997 
2998  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3000 /* if (!st->time_base.num)
3001  st->time_base = */
3002  if (!st->codec->time_base.num)
3003  st->codec->time_base = st->time_base;
3004  }
3005  // only for the split stuff
3006  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3007  st->parser = av_parser_init(st->codec->codec_id);
3008  if (st->parser) {
3009  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3011  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3013  }
3014  } else if (st->need_parsing) {
3015  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3016  "%s, packets or times may be invalid.\n",
3018  }
3019  }
3020  codec = find_decoder(ic, st, st->codec->codec_id);
3021 
3022  /* Force thread count to 1 since the H.264 decoder will not extract
3023  * SPS and PPS to extradata during multi-threaded decoding. */
3024  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3025 
3026  if (ic->codec_whitelist)
3027  av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3028 
3029  /* Ensure that subtitle_header is properly set. */
3031  && codec && !st->codec->codec) {
3032  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3033  av_log(ic, AV_LOG_WARNING,
3034  "Failed to open codec in av_find_stream_info\n");
3035  }
3036 
3037  // Try to just open decoders, in case this is enough to get parameters.
3038  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3039  if (codec && !st->codec->codec)
3040  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3041  av_log(ic, AV_LOG_WARNING,
3042  "Failed to open codec in av_find_stream_info\n");
3043  }
3044  if (!options)
3045  av_dict_free(&thread_opt);
3046  }
3047 
3048  for (i = 0; i < ic->nb_streams; i++) {
3049 #if FF_API_R_FRAME_RATE
3050  ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3051 #endif
3054  }
3055 
3056  count = 0;
3057  read_size = 0;
3058  for (;;) {
3060  ret = AVERROR_EXIT;
3061  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3062  break;
3063  }
3064 
3065  /* check if one codec still needs to be handled */
3066  for (i = 0; i < ic->nb_streams; i++) {
3067  int fps_analyze_framecount = 20;
3068 
3069  st = ic->streams[i];
3070  if (!has_codec_parameters(st, NULL))
3071  break;
3072  /* If the timebase is coarse (like the usual millisecond precision
3073  * of mkv), we need to analyze more frames to reliably arrive at
3074  * the correct fps. */
3075  if (av_q2d(st->time_base) > 0.0005)
3076  fps_analyze_framecount *= 2;
3077  if (!tb_unreliable(st->codec))
3078  fps_analyze_framecount = 0;
3079  if (ic->fps_probe_size >= 0)
3080  fps_analyze_framecount = ic->fps_probe_size;
3082  fps_analyze_framecount = 0;
3083  /* variable fps and no guess at the real fps */
3084  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3085  st->info->duration_count < fps_analyze_framecount &&
3087  break;
3088  if (st->parser && st->parser->parser->split &&
3089  !st->codec->extradata)
3090  break;
3091  if (st->first_dts == AV_NOPTS_VALUE &&
3092  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3093  st->codec_info_nb_frames < ic->max_ts_probe &&
3094  (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3096  break;
3097  }
3098  if (i == ic->nb_streams) {
3099  /* NOTE: If the format has no header, then we need to read some
3100  * packets to get most of the streams, so we cannot stop here. */
3101  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3102  /* If we found the info for all the codecs, we can stop. */
3103  ret = count;
3104  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3105  flush_codecs = 0;
3106  break;
3107  }
3108  }
3109  /* We did not get all the codec info, but we read too much data. */
3110  if (read_size >= probesize) {
3111  ret = count;
3112  av_log(ic, AV_LOG_DEBUG,
3113  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3114  for (i = 0; i < ic->nb_streams; i++)
3115  if (!ic->streams[i]->r_frame_rate.num &&
3116  ic->streams[i]->info->duration_count <= 1 &&
3118  strcmp(ic->iformat->name, "image2"))
3119  av_log(ic, AV_LOG_WARNING,
3120  "Stream #%d: not enough frames to estimate rate; "
3121  "consider increasing probesize\n", i);
3122  break;
3123  }
3124 
3125  /* NOTE: A new stream can be added there if no header in file
3126  * (AVFMTCTX_NOHEADER). */
3127  ret = read_frame_internal(ic, &pkt1);
3128  if (ret == AVERROR(EAGAIN))
3129  continue;
3130 
3131  if (ret < 0) {
3132  /* EOF or error*/
3133  break;
3134  }
3135 
3136  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3138  {
3139  pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3140  &ic->packet_buffer_end);
3141  if (!pkt) {
3142  ret = AVERROR(ENOMEM);
3143  goto find_stream_info_err;
3144  }
3145  if ((ret = av_dup_packet(pkt)) < 0)
3146  goto find_stream_info_err;
3147  }
3148 
3149  st = ic->streams[pkt->stream_index];
3151  read_size += pkt->size;
3152 
3153  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3154  /* check for non-increasing dts */
3155  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3156  st->info->fps_last_dts >= pkt->dts) {
3157  av_log(ic, AV_LOG_DEBUG,
3158  "Non-increasing DTS in stream %d: packet %d with DTS "
3159  "%"PRId64", packet %d with DTS %"PRId64"\n",
3160  st->index, st->info->fps_last_dts_idx,
3162  pkt->dts);
3163  st->info->fps_first_dts =
3165  }
3166  /* Check for a discontinuity in dts. If the difference in dts
3167  * is more than 1000 times the average packet duration in the
3168  * sequence, we treat it as a discontinuity. */
3169  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3171  (pkt->dts - st->info->fps_last_dts) / 1000 >
3172  (st->info->fps_last_dts - st->info->fps_first_dts) /
3173  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3174  av_log(ic, AV_LOG_WARNING,
3175  "DTS discontinuity in stream %d: packet %d with DTS "
3176  "%"PRId64", packet %d with DTS %"PRId64"\n",
3177  st->index, st->info->fps_last_dts_idx,
3179  pkt->dts);
3180  st->info->fps_first_dts =
3182  }
3183 
3184  /* update stored dts values */
3185  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3186  st->info->fps_first_dts = pkt->dts;
3188  }
3189  st->info->fps_last_dts = pkt->dts;
3191  }
3192  if (st->codec_info_nb_frames>1) {
3193  int64_t t = 0;
3194 
3195  if (st->time_base.den > 0)
3197  if (st->avg_frame_rate.num > 0)
3199 
3200  if ( t == 0
3201  && st->codec_info_nb_frames>30
3202  && st->info->fps_first_dts != AV_NOPTS_VALUE
3203  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3205 
3206  if (t >= max_analyze_duration) {
3207  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3208  max_analyze_duration,
3209  t);
3210  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3211  av_packet_unref(pkt);
3212  break;
3213  }
3214  if (pkt->duration) {
3215  st->info->codec_info_duration += pkt->duration;
3216  st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3217  }
3218  }
3219 #if FF_API_R_FRAME_RATE
3220  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3221  ff_rfps_add_frame(ic, st, pkt->dts);
3222 #endif
3223  if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3224  int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3225  if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3226  if (ff_alloc_extradata(st->codec, i))
3227  return AVERROR(ENOMEM);
3228  memcpy(st->codec->extradata, pkt->data,
3229  st->codec->extradata_size);
3230  }
3231  }
3232 
3233  /* If still no information, we try to open the codec and to
3234  * decompress the frame. We try to avoid that in most cases as
3235  * it takes longer and uses more memory. For MPEG-4, we need to
3236  * decompress for QuickTime.
3237  *
3238  * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3239  * least one frame of codec data, this makes sure the codec initializes
3240  * the channel configuration and does not only trust the values from
3241  * the container. */
3242  try_decode_frame(ic, st, pkt,
3243  (options && i < orig_nb_streams) ? &options[i] : NULL);
3244 
3245  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3246  av_packet_unref(pkt);
3247 
3248  st->codec_info_nb_frames++;
3249  count++;
3250  }
3251 
3252  if (flush_codecs) {
3253  AVPacket empty_pkt = { 0 };
3254  int err = 0;
3255  av_init_packet(&empty_pkt);
3256 
3257  for (i = 0; i < ic->nb_streams; i++) {
3258 
3259  st = ic->streams[i];
3260 
3261  /* flush the decoders */
3262  if (st->info->found_decoder == 1) {
3263  do {
3264  err = try_decode_frame(ic, st, &empty_pkt,
3265  (options && i < orig_nb_streams)
3266  ? &options[i] : NULL);
3267  } while (err > 0 && !has_codec_parameters(st, NULL));
3268 
3269  if (err < 0) {
3270  av_log(ic, AV_LOG_INFO,
3271  "decoding for stream %d failed\n", st->index);
3272  }
3273  }
3274  }
3275  }
3276  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3277 
3278  // close codecs which were opened in try_decode_frame()
3279  for (i = 0; i < ic->nb_streams; i++) {
3280  st = ic->streams[i];
3281  avcodec_close(st->codec);
3282  }
3283 
3284  ff_rfps_calculate(ic);
3285 
3286  for (i = 0; i < ic->nb_streams; i++) {
3287  st = ic->streams[i];
3288  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3292  st->codec->codec_tag= tag;
3293  }
3294 
3295  /* estimate average framerate if not set by demuxer */
3296  if (st->info->codec_info_duration_fields &&
3297  !st->avg_frame_rate.num &&
3298  st->info->codec_info_duration) {
3299  int best_fps = 0;
3300  double best_error = 0.01;
3301 
3302  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3303  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3304  st->info->codec_info_duration < 0)
3305  continue;
3307  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3308  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3309 
3310  /* Round guessed framerate to a "standard" framerate if it's
3311  * within 1% of the original estimate. */
3312  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3313  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3314  double error = fabs(av_q2d(st->avg_frame_rate) /
3315  av_q2d(std_fps) - 1);
3316 
3317  if (error < best_error) {
3318  best_error = error;
3319  best_fps = std_fps.num;
3320  }
3321  }
3322  if (best_fps)
3324  best_fps, 12 * 1001, INT_MAX);
3325  }
3326 
3327  if (!st->r_frame_rate.num) {
3328  if ( st->codec->time_base.den * (int64_t) st->time_base.num
3329  <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3330  st->r_frame_rate.num = st->codec->time_base.den;
3332  } else {
3333  st->r_frame_rate.num = st->time_base.den;
3334  st->r_frame_rate.den = st->time_base.num;
3335  }
3336  }
3337  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3338  if (!st->codec->bits_per_coded_sample)
3341  // set stream disposition based on audio service type
3342  switch (st->codec->audio_service_type) {
3345  break;
3348  break;
3351  break;
3354  break;
3357  break;
3358  }
3359  }
3360  }
3361 
3362  if (probesize)
3363  estimate_timings(ic, old_offset);
3364 
3365  if (ret >= 0 && ic->nb_streams)
3366  /* We could not have all the codec parameters before EOF. */
3367  ret = -1;
3368  for (i = 0; i < ic->nb_streams; i++) {
3369  const char *errmsg;
3370  st = ic->streams[i];
3371  if (!has_codec_parameters(st, &errmsg)) {
3372  char buf[256];
3373  avcodec_string(buf, sizeof(buf), st->codec, 0);
3374  av_log(ic, AV_LOG_WARNING,
3375  "Could not find codec parameters for stream %d (%s): %s\n"
3376  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3377  i, buf, errmsg);
3378  } else {
3379  ret = 0;
3380  }
3381  }
3382 
3384 
3385 find_stream_info_err:
3386  for (i = 0; i < ic->nb_streams; i++) {
3387  st = ic->streams[i];
3388  if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3389  ic->streams[i]->codec->thread_count = 0;
3390  if (st->info)
3391  av_freep(&st->info->duration_error);
3392  av_freep(&ic->streams[i]->info);
3393  }
3394  if (ic->pb)
3395  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3396  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3397  return ret;
3398 }
3399 
3401 {
3402  int i, j;
3403 
3404  for (i = 0; i < ic->nb_programs; i++) {
3405  if (ic->programs[i] == last) {
3406  last = NULL;
3407  } else {
3408  if (!last)
3409  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3410  if (ic->programs[i]->stream_index[j] == s)
3411  return ic->programs[i];
3412  }
3413  }
3414  return NULL;
3415 }
3416 
3418  int wanted_stream_nb, int related_stream,
3419  AVCodec **decoder_ret, int flags)
3420 {
3421  int i, nb_streams = ic->nb_streams;
3422  int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3423  unsigned *program = NULL;
3424  const AVCodec *decoder = NULL, *best_decoder = NULL;
3425 
3426  if (related_stream >= 0 && wanted_stream_nb < 0) {
3427  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3428  if (p) {
3429  program = p->stream_index;
3430  nb_streams = p->nb_stream_indexes;
3431  }
3432  }
3433  for (i = 0; i < nb_streams; i++) {
3434  int real_stream_index = program ? program[i] : i;
3435  AVStream *st = ic->streams[real_stream_index];
3436  AVCodecContext *avctx = st->codec;
3437  if (avctx->codec_type != type)
3438  continue;
3439  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3440  continue;
3441  if (wanted_stream_nb != real_stream_index &&
3444  continue;
3445  if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3446  continue;
3447  if (decoder_ret) {
3448  decoder = find_decoder(ic, st, st->codec->codec_id);
3449  if (!decoder) {
3450  if (ret < 0)
3452  continue;
3453  }
3454  }
3456  bitrate = avctx->bit_rate;
3457  if (!bitrate)
3458  bitrate = avctx->rc_max_rate;
3459  multiframe = FFMIN(5, count);
3460  if ((best_multiframe > multiframe) ||
3461  (best_multiframe == multiframe && best_bitrate > bitrate) ||
3462  (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3463  continue;
3464  best_count = count;
3465  best_bitrate = bitrate;
3466  best_multiframe = multiframe;
3467  ret = real_stream_index;
3468  best_decoder = decoder;
3469  if (program && i == nb_streams - 1 && ret < 0) {
3470  program = NULL;
3471  nb_streams = ic->nb_streams;
3472  /* no related stream found, try again with everything */
3473  i = 0;
3474  }
3475  }
3476  if (decoder_ret)
3477  *decoder_ret = (AVCodec*)best_decoder;
3478  return ret;
3479 }
3480 
3481 /*******************************************************/
3482 
3484 {
3485  if (s->iformat->read_play)
3486  return s->iformat->read_play(s);
3487  if (s->pb)
3488  return avio_pause(s->pb, 0);
3489  return AVERROR(ENOSYS);
3490 }
3491 
3493 {
3494  if (s->iformat->read_pause)
3495  return s->iformat->read_pause(s);
3496  if (s->pb)
3497  return avio_pause(s->pb, 1);
3498  return AVERROR(ENOSYS);
3499 }
3500 
3502  int j;
3503  av_assert0(s->nb_streams>0);
3504  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3505 
3506  for (j = 0; j < st->nb_side_data; j++)
3507  av_freep(&st->side_data[j].data);
3508  av_freep(&st->side_data);
3509  st->nb_side_data = 0;
3510 
3511  if (st->parser) {
3512  av_parser_close(st->parser);
3513  }
3514  if (st->attached_pic.data)
3516  av_dict_free(&st->metadata);
3517  av_freep(&st->probe_data.buf);
3518  av_freep(&st->index_entries);
3519  av_freep(&st->codec->extradata);
3521  av_freep(&st->codec);
3522  av_freep(&st->priv_data);
3523  if (st->info)
3524  av_freep(&st->info->duration_error);
3525  av_freep(&st->info);
3526  av_freep(&s->streams[ --s->nb_streams ]);
3527 }
3528 
3530 {
3531  int i;
3532 
3533  if (!s)
3534  return;
3535 
3536  av_opt_free(s);
3537  if (s->iformat && s->iformat->priv_class && s->priv_data)
3538  av_opt_free(s->priv_data);
3539  if (s->oformat && s->oformat->priv_class && s->priv_data)
3540  av_opt_free(s->priv_data);
3541 
3542  for (i = s->nb_streams - 1; i >= 0; i--) {
3543  ff_free_stream(s, s->streams[i]);
3544  }
3545  for (i = s->nb_programs - 1; i >= 0; i--) {
3546  av_dict_free(&s->programs[i]->metadata);
3547  av_freep(&s->programs[i]->stream_index);
3548  av_freep(&s->programs[i]);
3549  }
3550  av_freep(&s->programs);
3551  av_freep(&s->priv_data);
3552  while (s->nb_chapters--) {
3554  av_freep(&s->chapters[s->nb_chapters]);
3555  }
3556  av_freep(&s->chapters);
3557  av_dict_free(&s->metadata);
3558  av_freep(&s->streams);
3559  av_freep(&s->internal);
3560  flush_packet_queue(s);
3561  av_free(s);
3562 }
3563 
3565 {
3566  AVFormatContext *s;
3567  AVIOContext *pb;
3568 
3569  if (!ps || !*ps)
3570  return;
3571 
3572  s = *ps;
3573  pb = s->pb;
3574 
3575  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3576  (s->flags & AVFMT_FLAG_CUSTOM_IO))
3577  pb = NULL;
3578 
3579  flush_packet_queue(s);
3580 
3581  if (s->iformat)
3582  if (s->iformat->read_close)
3583  s->iformat->read_close(s);
3584 
3586 
3587  *ps = NULL;
3588 
3589  avio_close(pb);
3590 }
3591 
3593 {
3594  AVStream *st;
3595  int i;
3596  AVStream **streams;
3597 
3598  if (s->nb_streams >= INT_MAX/sizeof(*streams))
3599  return NULL;
3600  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3601  if (!streams)
3602  return NULL;
3603  s->streams = streams;
3604 
3605  st = av_mallocz(sizeof(AVStream));
3606  if (!st)
3607  return NULL;
3608  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3609  av_free(st);
3610  return NULL;
3611  }
3612  st->info->last_dts = AV_NOPTS_VALUE;
3613 
3614  st->codec = avcodec_alloc_context3(c);
3615  if (s->iformat) {
3616  /* no default bitrate if decoding */
3617  st->codec->bit_rate = 0;
3618 
3619  /* default pts setting is MPEG-like */
3620  avpriv_set_pts_info(st, 33, 1, 90000);
3621  }
3622 
3623  st->index = s->nb_streams;
3624  st->start_time = AV_NOPTS_VALUE;
3625  st->duration = AV_NOPTS_VALUE;
3626  /* we set the current DTS to 0 so that formats without any timestamps
3627  * but durations get some timestamps, formats with some unknown
3628  * timestamps have their first few packets buffered and the
3629  * timestamps corrected before they are returned to the user */
3630  st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3631  st->first_dts = AV_NOPTS_VALUE;
3635 
3638  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3639  st->pts_buffer[i] = AV_NOPTS_VALUE;
3640 
3641  st->sample_aspect_ratio = (AVRational) { 0, 1 };
3642 
3643 #if FF_API_R_FRAME_RATE
3644  st->info->last_dts = AV_NOPTS_VALUE;
3645 #endif
3648 
3650 
3651  s->streams[s->nb_streams++] = st;
3652  return st;
3653 }
3654 
3656 {
3657  AVProgram *program = NULL;
3658  int i;
3659 
3660  av_dlog(ac, "new_program: id=0x%04x\n", id);
3661 
3662  for (i = 0; i < ac->nb_programs; i++)
3663  if (ac->programs[i]->id == id)
3664  program = ac->programs[i];
3665 
3666  if (!program) {
3667  program = av_mallocz(sizeof(AVProgram));
3668  if (!program)
3669  return NULL;
3670  dynarray_add(&ac->programs, &ac->nb_programs, program);
3671  program->discard = AVDISCARD_NONE;
3672  }
3673  program->id = id;
3676 
3677  program->start_time =
3678  program->end_time = AV_NOPTS_VALUE;
3679 
3680  return program;
3681 }
3682 
3684  int64_t start, int64_t end, const char *title)
3685 {
3686  AVChapter *chapter = NULL;
3687  int i;
3688 
3689  if (end != AV_NOPTS_VALUE && start > end) {
3690  av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3691  return NULL;
3692  }
3693 
3694  for (i = 0; i < s->nb_chapters; i++)
3695  if (s->chapters[i]->id == id)
3696  chapter = s->chapters[i];
3697 
3698  if (!chapter) {
3699  chapter = av_mallocz(sizeof(AVChapter));
3700  if (!chapter)
3701  return NULL;
3702  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3703  }
3704  av_dict_set(&chapter->metadata, "title", title, 0);
3705  chapter->id = id;
3706  chapter->time_base = time_base;
3707  chapter->start = start;
3708  chapter->end = end;
3709 
3710  return chapter;
3711 }
3712 
3713 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3714 {
3715  int i, j;
3716  AVProgram *program = NULL;
3717  void *tmp;
3718 
3719  if (idx >= ac->nb_streams) {
3720  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3721  return;
3722  }
3723 
3724  for (i = 0; i < ac->nb_programs; i++) {
3725  if (ac->programs[i]->id != progid)
3726  continue;
3727  program = ac->programs[i];
3728  for (j = 0; j < program->nb_stream_indexes; j++)
3729  if (program->stream_index[j] == idx)
3730  return;
3731 
3732  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3733  if (!tmp)
3734  return;
3735  program->stream_index = tmp;
3736  program->stream_index[program->nb_stream_indexes++] = idx;
3737  return;
3738  }
3739 }
3740 
3741 uint64_t ff_ntp_time(void)
3742 {
3743  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3744 }
3745 
3746 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3747 {
3748  const char *p;
3749  char *q, buf1[20], c;
3750  int nd, len, percentd_found;
3751 
3752  q = buf;
3753  p = path;
3754  percentd_found = 0;
3755  for (;;) {
3756  c = *p++;
3757  if (c == '\0')
3758  break;
3759  if (c == '%') {
3760  do {
3761  nd = 0;
3762  while (av_isdigit(*p))
3763  nd = nd * 10 + *p++ - '0';
3764  c = *p++;
3765  } while (av_isdigit(c));
3766 
3767  switch (c) {
3768  case '%':
3769  goto addchar;
3770  case 'd':
3771  if (percentd_found)
3772  goto fail;
3773  percentd_found = 1;
3774  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3775  len = strlen(buf1);
3776  if ((q - buf + len) > buf_size - 1)
3777  goto fail;
3778  memcpy(q, buf1, len);
3779  q += len;
3780  break;
3781  default:
3782  goto fail;
3783  }
3784  } else {
3785 addchar:
3786  if ((q - buf) < buf_size - 1)
3787  *q++ = c;
3788  }
3789  }
3790  if (!percentd_found)
3791  goto fail;
3792  *q = '\0';
3793  return 0;
3794 fail:
3795  *q = '\0';
3796  return -1;
3797 }
3798 
3799 void av_url_split(char *proto, int proto_size,
3800  char *authorization, int authorization_size,
3801  char *hostname, int hostname_size,
3802  int *port_ptr, char *path, int path_size, const char *url)
3803 {
3804  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3805 
3806  if (port_ptr)
3807  *port_ptr = -1;
3808  if (proto_size > 0)
3809  proto[0] = 0;
3810  if (authorization_size > 0)
3811  authorization[0] = 0;
3812  if (hostname_size > 0)
3813  hostname[0] = 0;
3814  if (path_size > 0)
3815  path[0] = 0;
3816 
3817  /* parse protocol */
3818  if ((p = strchr(url, ':'))) {
3819  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3820  p++; /* skip ':' */
3821  if (*p == '/')
3822  p++;
3823  if (*p == '/')
3824  p++;
3825  } else {
3826  /* no protocol means plain filename */
3827  av_strlcpy(path, url, path_size);
3828  return;
3829  }
3830 
3831  /* separate path from hostname */
3832  ls = strchr(p, '/');
3833  ls2 = strchr(p, '?');
3834  if (!ls)
3835  ls = ls2;
3836  else if (ls && ls2)
3837  ls = FFMIN(ls, ls2);
3838  if (ls)
3839  av_strlcpy(path, ls, path_size);
3840  else
3841  ls = &p[strlen(p)]; // XXX
3842 
3843  /* the rest is hostname, use that to parse auth/port */
3844  if (ls != p) {
3845  /* authorization (user[:pass]@hostname) */
3846  at2 = p;
3847  while ((at = strchr(p, '@')) && at < ls) {
3848  av_strlcpy(authorization, at2,
3849  FFMIN(authorization_size, at + 1 - at2));
3850  p = at + 1; /* skip '@' */
3851  }
3852 
3853  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3854  /* [host]:port */
3855  av_strlcpy(hostname, p + 1,
3856  FFMIN(hostname_size, brk - p));
3857  if (brk[1] == ':' && port_ptr)
3858  *port_ptr = atoi(brk + 2);
3859  } else if ((col = strchr(p, ':')) && col < ls) {
3860  av_strlcpy(hostname, p,
3861  FFMIN(col + 1 - p, hostname_size));
3862  if (port_ptr)
3863  *port_ptr = atoi(col + 1);
3864  } else
3865  av_strlcpy(hostname, p,
3866  FFMIN(ls + 1 - p, hostname_size));
3867  }
3868 }
3869 
3870 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3871 {
3872  int i;
3873  static const char hex_table_uc[16] = { '0', '1', '2', '3',
3874  '4', '5', '6', '7',
3875  '8', '9', 'A', 'B',
3876  'C', 'D', 'E', 'F' };
3877  static const char hex_table_lc[16] = { '0', '1', '2', '3',
3878  '4', '5', '6', '7',
3879  '8', '9', 'a', 'b',
3880  'c', 'd', 'e', 'f' };
3881  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3882 
3883  for (i = 0; i < s; i++) {
3884  buff[i * 2] = hex_table[src[i] >> 4];
3885  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3886  }
3887 
3888  return buff;
3889 }
3890 
3891 int ff_hex_to_data(uint8_t *data, const char *p)
3892 {
3893  int c, len, v;
3894 
3895  len = 0;
3896  v = 1;
3897  for (;;) {
3898  p += strspn(p, SPACE_CHARS);
3899  if (*p == '\0')
3900  break;
3901  c = av_toupper((unsigned char) *p++);
3902  if (c >= '0' && c <= '9')
3903  c = c - '0';
3904  else if (c >= 'A' && c <= 'F')
3905  c = c - 'A' + 10;
3906  else
3907  break;
3908  v = (v << 4) | c;
3909  if (v & 0x100) {
3910  if (data)
3911  data[len] = v;
3912  len++;
3913  v = 1;
3914  }
3915  }
3916  return len;
3917 }
3918 
3919 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3920  unsigned int pts_num, unsigned int pts_den)
3921 {
3922  AVRational new_tb;
3923  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3924  if (new_tb.num != pts_num)
3925  av_log(NULL, AV_LOG_DEBUG,
3926  "st:%d removing common factor %d from timebase\n",
3927  s->index, pts_num / new_tb.num);
3928  } else
3929  av_log(NULL, AV_LOG_WARNING,
3930  "st:%d has too large timebase, reducing\n", s->index);
3931 
3932  if (new_tb.num <= 0 || new_tb.den <= 0) {
3933  av_log(NULL, AV_LOG_ERROR,
3934  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3935  new_tb.num, new_tb.den,
3936  s->index);
3937  return;
3938  }
3939  s->time_base = new_tb;
3940  av_codec_set_pkt_timebase(s->codec, new_tb);
3941  s->pts_wrap_bits = pts_wrap_bits;
3942 }
3943 
3944 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3945  void *context)
3946 {
3947  const char *ptr = str;
3948 
3949  /* Parse key=value pairs. */
3950  for (;;) {
3951  const char *key;
3952  char *dest = NULL, *dest_end;
3953  int key_len, dest_len = 0;
3954 
3955  /* Skip whitespace and potential commas. */
3956  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3957  ptr++;
3958  if (!*ptr)
3959  break;
3960 
3961  key = ptr;
3962 
3963  if (!(ptr = strchr(key, '=')))
3964  break;
3965  ptr++;
3966  key_len = ptr - key;
3967 
3968  callback_get_buf(context, key, key_len, &dest, &dest_len);
3969  dest_end = dest + dest_len - 1;
3970 
3971  if (*ptr == '\"') {
3972  ptr++;
3973  while (*ptr && *ptr != '\"') {
3974  if (*ptr == '\\') {
3975  if (!ptr[1])
3976  break;
3977  if (dest && dest < dest_end)
3978  *dest++ = ptr[1];
3979  ptr += 2;
3980  } else {
3981  if (dest && dest < dest_end)
3982  *dest++ = *ptr;
3983  ptr++;
3984  }
3985  }
3986  if (*ptr == '\"')
3987  ptr++;
3988  } else {
3989  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3990  if (dest && dest < dest_end)
3991  *dest++ = *ptr;
3992  }
3993  if (dest)
3994  *dest = 0;
3995  }
3996 }
3997 
3999 {
4000  int i;
4001  for (i = 0; i < s->nb_streams; i++)
4002  if (s->streams[i]->id == id)
4003  return i;
4004  return -1;
4005 }
4006 
4007 int64_t ff_iso8601_to_unix_time(const char *datestr)
4008 {
4009  struct tm time1 = { 0 }, time2 = { 0 };
4010  char *ret1, *ret2;
4011  ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4012  ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4013  if (ret2 && !ret1)
4014  return av_timegm(&time2);
4015  else
4016  return av_timegm(&time1);
4017 }
4018 
4020  int std_compliance)
4021 {
4022  if (ofmt) {
4023  if (ofmt->query_codec)
4024  return ofmt->query_codec(codec_id, std_compliance);
4025  else if (ofmt->codec_tag)
4026  return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4027  else if (codec_id == ofmt->video_codec ||
4028  codec_id == ofmt->audio_codec ||
4029  codec_id == ofmt->subtitle_codec)
4030  return 1;
4031  }
4032  return AVERROR_PATCHWELCOME;
4033 }
4034 
4036 {
4037 #if CONFIG_NETWORK
4038  int ret;
4040  if ((ret = ff_network_init()) < 0)
4041  return ret;
4042  ff_tls_init();
4043 #endif
4044  return 0;
4045 }
4046 
4048 {
4049 #if CONFIG_NETWORK
4050  ff_network_close();
4051  ff_tls_deinit();
4052 #endif
4053  return 0;
4054 }
4055 
4057  uint64_t channel_layout, int32_t sample_rate,
4059 {
4060  uint32_t flags = 0;
4061  int size = 4;
4062  uint8_t *data;
4063  if (!pkt)
4064  return AVERROR(EINVAL);
4065  if (channels) {
4066  size += 4;
4068  }
4069  if (channel_layout) {
4070  size += 8;
4072  }
4073  if (sample_rate) {
4074  size += 4;
4076  }
4077  if (width || height) {
4078  size += 8;
4080  }
4082  if (!data)
4083  return AVERROR(ENOMEM);
4084  bytestream_put_le32(&data, flags);
4085  if (channels)
4086  bytestream_put_le32(&data, channels);
4087  if (channel_layout)
4088  bytestream_put_le64(&data, channel_layout);
4089  if (sample_rate)
4090  bytestream_put_le32(&data, sample_rate);
4091  if (width || height) {
4092  bytestream_put_le32(&data, width);
4093  bytestream_put_le32(&data, height);
4094  }
4095  return 0;
4096 }
4097 
4099 {
4100  AVRational undef = {0, 1};
4101  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4102  AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4103  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4104 
4105  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4106  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4107  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4108  stream_sample_aspect_ratio = undef;
4109 
4110  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4111  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4112  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4113  frame_sample_aspect_ratio = undef;
4114 
4115  if (stream_sample_aspect_ratio.num)
4116  return stream_sample_aspect_ratio;
4117  else
4118  return frame_sample_aspect_ratio;
4119 }
4120 
4122 {
4123  AVRational fr = st->r_frame_rate;
4124  AVRational codec_fr = st->codec->framerate;
4125  AVRational avg_fr = st->avg_frame_rate;
4126 
4127  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4128  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4129  fr = avg_fr;
4130  }
4131 
4132 
4133  if (st->codec->ticks_per_frame > 1) {
4134  if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4135  && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4136  fr = codec_fr;
4137  }
4138 
4139  return fr;
4140 }
4141 
4143  const char *spec)
4144 {
4145  if (*spec <= '9' && *spec >= '0') /* opt:index */
4146  return strtol(spec, NULL, 0) == st->index;
4147  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4148  *spec == 't') { /* opt:[vasdt] */
4149  enum AVMediaType type;
4150 
4151  switch (*spec++) {
4152  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4153