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