FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
utils.c
Go to the documentation of this file.
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #undef NDEBUG
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdint.h>
26 
27 #include "config.h"
28 
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
39 
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
43 
44 #include "audiointerleave.h"
45 #include "avformat.h"
46 #include "avio_internal.h"
47 #include "id3v2.h"
48 #include "internal.h"
49 #include "metadata.h"
50 #if CONFIG_NETWORK
51 #include "network.h"
52 #endif
53 #include "riff.h"
54 #include "url.h"
55 
56 /**
57  * @file
58  * various utility functions for use within FFmpeg
59  */
60 
61 unsigned avformat_version(void)
62 {
65 }
66 
67 const char *avformat_configuration(void)
68 {
69  return FFMPEG_CONFIGURATION;
70 }
71 
72 const char *avformat_license(void)
73 {
74 #define LICENSE_PREFIX "libavformat license: "
75  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
76 }
77 
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
79 
80 static int is_relative(int64_t ts) {
81  return ts > (RELATIVE_TS_BASE - (1LL<<48));
82 }
83 
84 /**
85  * Wrap a given time stamp, if there is an indication for an overflow
86  *
87  * @param st stream
88  * @param timestamp the time stamp to wrap
89  * @return resulting time stamp
90  */
91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
92 {
94  st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
96  timestamp < st->pts_wrap_reference)
97  return timestamp + (1ULL << st->pts_wrap_bits);
98  else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
99  timestamp >= st->pts_wrap_reference)
100  return timestamp - (1ULL << st->pts_wrap_bits);
101  }
102  return timestamp;
103 }
104 
105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
112 
113 int64_t av_stream_get_end_pts(const AVStream *st)
114 {
115  return st->pts.val;
116 }
117 
119 {
120  return st->parser;
121 }
122 
124 {
125  int i;
127  for (i = 0; i < s->nb_streams; i++) {
128  AVStream *st = s->streams[i];
129  st->inject_global_side_data = 1;
130  }
131 }
132 
134 {
135  if (st->codec->codec)
136  return st->codec->codec;
137 
138  switch (st->codec->codec_type) {
139  case AVMEDIA_TYPE_VIDEO:
140  if (s->video_codec) return s->video_codec;
141  break;
142  case AVMEDIA_TYPE_AUDIO:
143  if (s->audio_codec) return s->audio_codec;
144  break;
146  if (s->subtitle_codec) return s->subtitle_codec;
147  break;
148  }
149 
150  return avcodec_find_decoder(codec_id);
151 }
152 
154 {
155  return s->probe_score;
156 }
157 
158 /* an arbitrarily chosen "sane" max packet size -- 50M */
159 #define SANE_CHUNK_SIZE (50000000)
160 
162 {
163  if (s->maxsize>= 0) {
164  int64_t remaining= s->maxsize - avio_tell(s);
165  if (remaining < size) {
166  int64_t newsize = avio_size(s);
167  if (!s->maxsize || s->maxsize<newsize)
168  s->maxsize = newsize - !newsize;
169  remaining= s->maxsize - avio_tell(s);
170  remaining= FFMAX(remaining, 0);
171  }
172 
173  if (s->maxsize>= 0 && remaining+1 < size) {
174  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
175  size = remaining+1;
176  }
177  }
178  return size;
179 }
180 
181 /* Read the data in sane-sized chunks and append to pkt.
182  * Return the number of bytes read or an error. */
184 {
185  int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
186  int orig_size = pkt->size;
187  int ret;
188 
189  do {
190  int prev_size = pkt->size;
191  int read_size;
192 
193  /* When the caller requests a lot of data, limit it to the amount
194  * left in file or SANE_CHUNK_SIZE when it is not known. */
195  read_size = size;
196  if (read_size > SANE_CHUNK_SIZE/10) {
197  read_size = ffio_limit(s, read_size);
198  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
199  if (s->maxsize < 0)
200  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
201  }
202 
203  ret = av_grow_packet(pkt, read_size);
204  if (ret < 0)
205  break;
206 
207  ret = avio_read(s, pkt->data + prev_size, read_size);
208  if (ret != read_size) {
209  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
210  break;
211  }
212 
213  size -= read_size;
214  } while (size > 0);
215  if (size > 0)
216  pkt->flags |= AV_PKT_FLAG_CORRUPT;
217 
218  pkt->pos = orig_pos;
219  if (!pkt->size)
220  av_free_packet(pkt);
221  return pkt->size > orig_size ? pkt->size - orig_size : ret;
222 }
223 
225 {
226  av_init_packet(pkt);
227  pkt->data = NULL;
228  pkt->size = 0;
229  pkt->pos = avio_tell(s);
230 
231  return append_packet_chunked(s, pkt, size);
232 }
233 
235 {
236  if (!pkt->size)
237  return av_get_packet(s, pkt, size);
238  return append_packet_chunked(s, pkt, size);
239 }
240 
241 int av_filename_number_test(const char *filename)
242 {
243  char buf[1024];
244  return filename &&
245  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
246 }
247 
249  AVProbeData *pd)
250 {
251  static const struct {
252  const char *name;
253  enum AVCodecID id;
254  enum AVMediaType type;
255  } fmt_id_type[] = {
265  { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
266  { 0 }
267  };
268  int score;
269  AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
270 
271  if (fmt && st->request_probe <= score) {
272  int i;
273  av_log(s, AV_LOG_DEBUG,
274  "Probe with size=%d, packets=%d detected %s with score=%d\n",
276  fmt->name, score);
277  for (i = 0; fmt_id_type[i].name; i++) {
278  if (!strcmp(fmt->name, fmt_id_type[i].name)) {
279  st->codec->codec_id = fmt_id_type[i].id;
280  st->codec->codec_type = fmt_id_type[i].type;
281  return score;
282  }
283  }
284  }
285  return 0;
286 }
287 
288 /************************************************************/
289 /* input media file */
290 
292  int err;
293 
294  if (ic->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  * Return the frame duration in seconds. Return 0 if not available.
717  */
718 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
720 {
721  int frame_size;
722 
723  *pnum = 0;
724  *pden = 0;
725  switch (st->codec->codec_type) {
726  case AVMEDIA_TYPE_VIDEO:
727  if (st->r_frame_rate.num && !pc) {
728  *pnum = st->r_frame_rate.den;
729  *pden = st->r_frame_rate.num;
730  } else if (st->time_base.num * 1000LL > st->time_base.den) {
731  *pnum = st->time_base.num;
732  *pden = st->time_base.den;
733  } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
734  *pnum = st->codec->time_base.num;
735  *pden = st->codec->time_base.den;
736  if (pc && pc->repeat_pict) {
737  if (*pnum > INT_MAX / (1 + pc->repeat_pict))
738  *pden /= 1 + pc->repeat_pict;
739  else
740  *pnum *= 1 + pc->repeat_pict;
741  }
742  /* If this codec can be interlaced or progressive then we need
743  * a parser to compute duration of a packet. Thus if we have
744  * no parser in such case leave duration undefined. */
745  if (st->codec->ticks_per_frame > 1 && !pc)
746  *pnum = *pden = 0;
747  }
748  break;
749  case AVMEDIA_TYPE_AUDIO:
750  frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
751  if (frame_size <= 0 || st->codec->sample_rate <= 0)
752  break;
753  *pnum = frame_size;
754  *pden = st->codec->sample_rate;
755  break;
756  default:
757  break;
758  }
759 }
760 
761 static int is_intra_only(AVCodecContext *enc) {
762  const AVCodecDescriptor *desc;
763 
764  if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
765  return 1;
766 
767  desc = av_codec_get_codec_descriptor(enc);
768  if (!desc) {
769  desc = avcodec_descriptor_get(enc->codec_id);
771  }
772  if (desc)
773  return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
774  return 0;
775 }
776 
778 {
779  if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
780  if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
781  return 1;
782 #if CONFIG_H264_DECODER
783  if (st->codec->has_b_frames &&
785  return 1;
786 #endif
787  if (st->codec->has_b_frames<3)
788  return st->nb_decoded_frames >= 7;
789  else if (st->codec->has_b_frames<4)
790  return st->nb_decoded_frames >= 18;
791  else
792  return st->nb_decoded_frames >= 20;
793 }
794 
796 {
797  if (pktl->next)
798  return pktl->next;
799  if (pktl == s->packet_buffer_end)
800  return s->parse_queue;
801  return NULL;
802 }
803 
804 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
805  int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
807 
808  if(!onein_oneout) {
809  int delay = st->codec->has_b_frames;
810  int i;
811 
812  if (dts == AV_NOPTS_VALUE) {
813  int64_t best_score = INT64_MAX;
814  for (i = 0; i<delay; i++) {
815  if (st->pts_reorder_error_count[i]) {
816  int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
817  if (score < best_score) {
818  best_score = score;
819  dts = pts_buffer[i];
820  }
821  }
822  }
823  } else {
824  for (i = 0; i<delay; i++) {
825  if (pts_buffer[i] != AV_NOPTS_VALUE) {
826  int64_t diff = FFABS(pts_buffer[i] - dts)
827  + (uint64_t)st->pts_reorder_error[i];
828  diff = FFMAX(diff, st->pts_reorder_error[i]);
829  st->pts_reorder_error[i] = diff;
830  st->pts_reorder_error_count[i]++;
831  if (st->pts_reorder_error_count[i] > 250) {
832  st->pts_reorder_error[i] >>= 1;
833  st->pts_reorder_error_count[i] >>= 1;
834  }
835  }
836  }
837  }
838  }
839 
840  if (dts == AV_NOPTS_VALUE)
841  dts = pts_buffer[0];
842 
843  return dts;
844 }
845 
846 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
847  int64_t dts, int64_t pts, AVPacket *pkt)
848 {
849  AVStream *st = s->streams[stream_index];
851  int64_t pts_buffer[MAX_REORDER_DELAY+1];
852  int64_t shift;
853  int i, delay;
854 
855  if (st->first_dts != AV_NOPTS_VALUE ||
856  dts == AV_NOPTS_VALUE ||
857  st->cur_dts == AV_NOPTS_VALUE ||
858  is_relative(dts))
859  return;
860 
861  delay = st->codec->has_b_frames;
862  st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
863  st->cur_dts = dts;
864  shift = st->first_dts - RELATIVE_TS_BASE;
865 
866  for (i = 0; i<MAX_REORDER_DELAY+1; i++)
867  pts_buffer[i] = AV_NOPTS_VALUE;
868 
869  if (is_relative(pts))
870  pts += shift;
871 
872  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
873  if (pktl->pkt.stream_index != stream_index)
874  continue;
875  if (is_relative(pktl->pkt.pts))
876  pktl->pkt.pts += shift;
877 
878  if (is_relative(pktl->pkt.dts))
879  pktl->pkt.dts += shift;
880 
881  if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
882  st->start_time = pktl->pkt.pts;
883 
884  if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
885  pts_buffer[0] = pktl->pkt.pts;
886  for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
887  FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
888 
889  pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
890  }
891  }
892 
893  if (st->start_time == AV_NOPTS_VALUE)
894  st->start_time = pts;
895 }
896 
898  int stream_index, int duration)
899 {
901  int64_t cur_dts = RELATIVE_TS_BASE;
902 
903  if (st->first_dts != AV_NOPTS_VALUE) {
905  return;
907  cur_dts = st->first_dts;
908  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
909  if (pktl->pkt.stream_index == stream_index) {
910  if (pktl->pkt.pts != pktl->pkt.dts ||
911  pktl->pkt.dts != AV_NOPTS_VALUE ||
912  pktl->pkt.duration)
913  break;
914  cur_dts -= duration;
915  }
916  }
917  if (pktl && pktl->pkt.dts != st->first_dts) {
918  av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
919  av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
920  return;
921  }
922  if (!pktl) {
923  av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
924  return;
925  }
926  pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
927  st->first_dts = cur_dts;
928  } else if (st->cur_dts != RELATIVE_TS_BASE)
929  return;
930 
931  for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
932  if (pktl->pkt.stream_index != stream_index)
933  continue;
934  if (pktl->pkt.pts == pktl->pkt.dts &&
935  (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
936  !pktl->pkt.duration) {
937  pktl->pkt.dts = cur_dts;
938  if (!st->codec->has_b_frames)
939  pktl->pkt.pts = cur_dts;
940 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
941  pktl->pkt.duration = duration;
942  } else
943  break;
944  cur_dts = pktl->pkt.dts + pktl->pkt.duration;
945  }
946  if (!pktl)
947  st->cur_dts = cur_dts;
948 }
949 
952 {
953  int num, den, presentation_delayed, delay, i;
954  int64_t offset;
956  int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
958 
959  if (s->flags & AVFMT_FLAG_NOFILLIN)
960  return;
961 
962  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
963  if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
964  if (st->last_dts_for_order_check <= pkt->dts) {
965  st->dts_ordered++;
966  } else {
968  "DTS %"PRIi64" < %"PRIi64" out of order\n",
969  pkt->dts,
971  st->dts_misordered++;
972  }
973  if (st->dts_ordered + st->dts_misordered > 250) {
974  st->dts_ordered >>= 1;
975  st->dts_misordered >>= 1;
976  }
977  }
978 
979  st->last_dts_for_order_check = pkt->dts;
980  if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
981  pkt->dts = AV_NOPTS_VALUE;
982  }
983 
984  if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
985  pkt->dts = AV_NOPTS_VALUE;
986 
987  if (pc && pc->pict_type == AV_PICTURE_TYPE_B
988  && !st->codec->has_b_frames)
989  //FIXME Set low_delay = 0 when has_b_frames = 1
990  st->codec->has_b_frames = 1;
991 
992  /* do we have a video B-frame ? */
993  delay = st->codec->has_b_frames;
994  presentation_delayed = 0;
995 
996  /* XXX: need has_b_frame, but cannot get it if the codec is
997  * not initialized */
998  if (delay &&
999  pc && pc->pict_type != AV_PICTURE_TYPE_B)
1000  presentation_delayed = 1;
1001 
1002  if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1003  st->pts_wrap_bits < 63 &&
1004  pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1005  if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1006  pkt->dts -= 1LL << st->pts_wrap_bits;
1007  } else
1008  pkt->pts += 1LL << st->pts_wrap_bits;
1009  }
1010 
1011  /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1012  * We take the conservative approach and discard both.
1013  * Note: If this is misbehaving for an H.264 file, then possibly
1014  * presentation_delayed is not set correctly. */
1015  if (delay == 1 && pkt->dts == pkt->pts &&
1016  pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1017  av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1018  if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1019  && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1020  pkt->dts = AV_NOPTS_VALUE;
1021  }
1022 
1023  duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1024  if (pkt->duration == 0) {
1025  ff_compute_frame_duration(&num, &den, st, pc, pkt);
1026  if (den && num) {
1027  duration = (AVRational) {num, den};
1028  pkt->duration = av_rescale_rnd(1,
1029  num * (int64_t) st->time_base.den,
1030  den * (int64_t) st->time_base.num,
1031  AV_ROUND_DOWN);
1032  }
1033  }
1034 
1035  if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1036  update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1037 
1038  /* Correct timestamps with byte offset if demuxers only have timestamps
1039  * on packet boundaries */
1040  if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1041  /* this will estimate bitrate based on this frame's duration and size */
1042  offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1043  if (pkt->pts != AV_NOPTS_VALUE)
1044  pkt->pts += offset;
1045  if (pkt->dts != AV_NOPTS_VALUE)
1046  pkt->dts += offset;
1047  }
1048 
1049  /* This may be redundant, but it should not hurt. */
1050  if (pkt->dts != AV_NOPTS_VALUE &&
1051  pkt->pts != AV_NOPTS_VALUE &&
1052  pkt->pts > pkt->dts)
1053  presentation_delayed = 1;
1054 
1055  av_dlog(NULL,
1056  "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1057  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1058  pkt->stream_index, pc, pkt->duration);
1059  /* Interpolate PTS and DTS if they are not present. We skip H264
1060  * currently because delay and has_b_frames are not reliably set. */
1061  if ((delay == 0 || (delay == 1 && pc)) &&
1062  onein_oneout) {
1063  if (presentation_delayed) {
1064  /* DTS = decompression timestamp */
1065  /* PTS = presentation timestamp */
1066  if (pkt->dts == AV_NOPTS_VALUE)
1067  pkt->dts = st->last_IP_pts;
1068  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1069  if (pkt->dts == AV_NOPTS_VALUE)
1070  pkt->dts = st->cur_dts;
1071 
1072  /* This is tricky: the dts must be incremented by the duration
1073  * of the frame we are displaying, i.e. the last I- or P-frame. */
1074  if (st->last_IP_duration == 0)
1075  st->last_IP_duration = pkt->duration;
1076  if (pkt->dts != AV_NOPTS_VALUE)
1077  st->cur_dts = pkt->dts + st->last_IP_duration;
1078  st->last_IP_duration = pkt->duration;
1079  st->last_IP_pts = pkt->pts;
1080  /* Cannot compute PTS if not present (we can compute it only
1081  * by knowing the future. */
1082  } else if (pkt->pts != AV_NOPTS_VALUE ||
1083  pkt->dts != AV_NOPTS_VALUE ||
1084  pkt->duration ) {
1085 
1086  /* presentation is not delayed : PTS and DTS are the same */
1087  if (pkt->pts == AV_NOPTS_VALUE)
1088  pkt->pts = pkt->dts;
1090  pkt->pts, pkt);
1091  if (pkt->pts == AV_NOPTS_VALUE)
1092  pkt->pts = st->cur_dts;
1093  pkt->dts = pkt->pts;
1094  if (pkt->pts != AV_NOPTS_VALUE)
1095  st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1096  }
1097  }
1098 
1099  if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1100  st->pts_buffer[0] = pkt->pts;
1101  for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1102  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1103 
1104  pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1105  }
1106  // We skipped it above so we try here.
1107  if (!onein_oneout)
1108  // This should happen on the first packet
1109  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1110  if (pkt->dts > st->cur_dts)
1111  st->cur_dts = pkt->dts;
1112 
1113  av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1114  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1115 
1116  /* update flags */
1117  if (is_intra_only(st->codec))
1118  pkt->flags |= AV_PKT_FLAG_KEY;
1119  if (pc)
1121 }
1122 
1123 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1124 {
1125  while (*pkt_buf) {
1126  AVPacketList *pktl = *pkt_buf;
1127  *pkt_buf = pktl->next;
1128  av_free_packet(&pktl->pkt);
1129  av_freep(&pktl);
1130  }
1131  *pkt_buf_end = NULL;
1132 }
1133 
1134 /**
1135  * Parse a packet, add all split parts to parse_queue.
1136  *
1137  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1138  */
1139 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1140 {
1141  AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1142  AVStream *st = s->streams[stream_index];
1143  uint8_t *data = pkt ? pkt->data : NULL;
1144  int size = pkt ? pkt->size : 0;
1145  int ret = 0, got_output = 0;
1146 
1147  if (!pkt) {
1149  pkt = &flush_pkt;
1150  got_output = 1;
1151  } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1152  // preserve 0-size sync packets
1153  compute_pkt_fields(s, st, st->parser, pkt);
1154  }
1155 
1156  while (size > 0 || (pkt == &flush_pkt && got_output)) {
1157  int len;
1158 
1159  av_init_packet(&out_pkt);
1160  len = av_parser_parse2(st->parser, st->codec,
1161  &out_pkt.data, &out_pkt.size, data, size,
1162  pkt->pts, pkt->dts, pkt->pos);
1163 
1164  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1165  pkt->pos = -1;
1166  /* increment read pointer */
1167  data += len;
1168  size -= len;
1169 
1170  got_output = !!out_pkt.size;
1171 
1172  if (!out_pkt.size)
1173  continue;
1174 
1175  if (pkt->side_data) {
1176  out_pkt.side_data = pkt->side_data;
1177  out_pkt.side_data_elems = pkt->side_data_elems;
1178  pkt->side_data = NULL;
1179  pkt->side_data_elems = 0;
1180  }
1181 
1182  /* set the duration */
1183  out_pkt.duration = 0;
1184  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1185  if (st->codec->sample_rate > 0) {
1186  out_pkt.duration =
1188  (AVRational) { 1, st->codec->sample_rate },
1189  st->time_base,
1190  AV_ROUND_DOWN);
1191  }
1192  }
1193 
1194  out_pkt.stream_index = st->index;
1195  out_pkt.pts = st->parser->pts;
1196  out_pkt.dts = st->parser->dts;
1197  out_pkt.pos = st->parser->pos;
1198 
1200  out_pkt.pos = st->parser->frame_offset;
1201 
1202  if (st->parser->key_frame == 1 ||
1203  (st->parser->key_frame == -1 &&
1205  out_pkt.flags |= AV_PKT_FLAG_KEY;
1206 
1207  if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1208  out_pkt.flags |= AV_PKT_FLAG_KEY;
1209 
1210  compute_pkt_fields(s, st, st->parser, &out_pkt);
1211 
1212  if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1213  out_pkt.buf = pkt->buf;
1214  pkt->buf = NULL;
1215 #if FF_API_DESTRUCT_PACKET
1217  out_pkt.destruct = pkt->destruct;
1218  pkt->destruct = NULL;
1220 #endif
1221  }
1222  if ((ret = av_dup_packet(&out_pkt)) < 0)
1223  goto fail;
1224 
1225  if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1226  av_free_packet(&out_pkt);
1227  ret = AVERROR(ENOMEM);
1228  goto fail;
1229  }
1230  }
1231 
1232  /* end of the stream => close and free the parser */
1233  if (pkt == &flush_pkt) {
1234  av_parser_close(st->parser);
1235  st->parser = NULL;
1236  }
1237 
1238 fail:
1240  return ret;
1241 }
1242 
1243 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1244  AVPacketList **pkt_buffer_end,
1245  AVPacket *pkt)
1246 {
1247  AVPacketList *pktl;
1248  av_assert0(*pkt_buffer);
1249  pktl = *pkt_buffer;
1250  *pkt = pktl->pkt;
1251  *pkt_buffer = pktl->next;
1252  if (!pktl->next)
1253  *pkt_buffer_end = NULL;
1254  av_freep(&pktl);
1255  return 0;
1256 }
1257 
1259 {
1260  int ret = 0, i, got_packet = 0;
1261  AVDictionary *metadata = NULL;
1262 
1263  av_init_packet(pkt);
1264 
1265  while (!got_packet && !s->parse_queue) {
1266  AVStream *st;
1267  AVPacket cur_pkt;
1268 
1269  /* read next packet */
1270  ret = ff_read_packet(s, &cur_pkt);
1271  if (ret < 0) {
1272  if (ret == AVERROR(EAGAIN))
1273  return ret;
1274  /* flush the parsers */
1275  for (i = 0; i < s->nb_streams; i++) {
1276  st = s->streams[i];
1277  if (st->parser && st->need_parsing)
1278  parse_packet(s, NULL, st->index);
1279  }
1280  /* all remaining packets are now in parse_queue =>
1281  * really terminate parsing */
1282  break;
1283  }
1284  ret = 0;
1285  st = s->streams[cur_pkt.stream_index];
1286 
1287  if (cur_pkt.pts != AV_NOPTS_VALUE &&
1288  cur_pkt.dts != AV_NOPTS_VALUE &&
1289  cur_pkt.pts < cur_pkt.dts) {
1291  "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1292  cur_pkt.stream_index,
1293  av_ts2str(cur_pkt.pts),
1294  av_ts2str(cur_pkt.dts),
1295  cur_pkt.size);
1296  }
1297  if (s->debug & FF_FDEBUG_TS)
1298  av_log(s, AV_LOG_DEBUG,
1299  "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1300  cur_pkt.stream_index,
1301  av_ts2str(cur_pkt.pts),
1302  av_ts2str(cur_pkt.dts),
1303  cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1304 
1305  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1306  st->parser = av_parser_init(st->codec->codec_id);
1307  if (!st->parser) {
1308  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1309  "%s, packets or times may be invalid.\n",
1311  /* no parser available: just output the raw packets */
1313  } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1315  else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1316  st->parser->flags |= PARSER_FLAG_ONCE;
1317  else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1319  }
1320 
1321  if (!st->need_parsing || !st->parser) {
1322  /* no parsing needed: we just output the packet as is */
1323  *pkt = cur_pkt;
1324  compute_pkt_fields(s, st, NULL, pkt);
1325  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1326  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1327  ff_reduce_index(s, st->index);
1328  av_add_index_entry(st, pkt->pos, pkt->dts,
1329  0, 0, AVINDEX_KEYFRAME);
1330  }
1331  got_packet = 1;
1332  } else if (st->discard < AVDISCARD_ALL) {
1333  if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1334  return ret;
1335  } else {
1336  /* free packet */
1337  av_free_packet(&cur_pkt);
1338  }
1339  if (pkt->flags & AV_PKT_FLAG_KEY)
1340  st->skip_to_keyframe = 0;
1341  if (st->skip_to_keyframe) {
1342  av_free_packet(&cur_pkt);
1343  if (got_packet) {
1344  *pkt = cur_pkt;
1345  }
1346  got_packet = 0;
1347  }
1348  }
1349 
1350  if (!got_packet && s->parse_queue)
1352 
1353  if (ret >= 0) {
1354  AVStream *st = s->streams[pkt->stream_index];
1355  if (st->skip_samples) {
1357  if (p) {
1358  AV_WL32(p, st->skip_samples);
1359  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1360  }
1361  st->skip_samples = 0;
1362  }
1363 
1364  if (st->inject_global_side_data) {
1365  for (i = 0; i < st->nb_side_data; i++) {
1366  AVPacketSideData *src_sd = &st->side_data[i];
1367  uint8_t *dst_data;
1368 
1369  if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1370  continue;
1371 
1372  dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1373  if (!dst_data) {
1374  av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1375  continue;
1376  }
1377 
1378  memcpy(dst_data, src_sd->data, src_sd->size);
1379  }
1380  st->inject_global_side_data = 0;
1381  }
1382 
1383  if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1385  }
1386 
1387  av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1388  if (metadata) {
1390  av_dict_copy(&s->metadata, metadata, 0);
1391  av_dict_free(&metadata);
1392  av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1393  }
1394 
1395  if (s->debug & FF_FDEBUG_TS)
1396  av_log(s, AV_LOG_DEBUG,
1397  "read_frame_internal stream=%d, pts=%s, dts=%s, "
1398  "size=%d, duration=%d, flags=%d\n",
1399  pkt->stream_index,
1400  av_ts2str(pkt->pts),
1401  av_ts2str(pkt->dts),
1402  pkt->size, pkt->duration, pkt->flags);
1403 
1404  return ret;
1405 }
1406 
1408 {
1409  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1410  int eof = 0;
1411  int ret;
1412  AVStream *st;
1413 
1414  if (!genpts) {
1415  ret = s->packet_buffer
1417  &s->packet_buffer_end, pkt)
1418  : read_frame_internal(s, pkt);
1419  if (ret < 0)
1420  return ret;
1421  goto return_packet;
1422  }
1423 
1424  for (;;) {
1425  AVPacketList *pktl = s->packet_buffer;
1426 
1427  if (pktl) {
1428  AVPacket *next_pkt = &pktl->pkt;
1429 
1430  if (next_pkt->dts != AV_NOPTS_VALUE) {
1431  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1432  // last dts seen for this stream. if any of packets following
1433  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1434  int64_t last_dts = next_pkt->dts;
1435  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1436  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1437  (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1438  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1439  // not B-frame
1440  next_pkt->pts = pktl->pkt.dts;
1441  }
1442  if (last_dts != AV_NOPTS_VALUE) {
1443  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1444  last_dts = pktl->pkt.dts;
1445  }
1446  }
1447  pktl = pktl->next;
1448  }
1449  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1450  // Fixing the last reference frame had none pts issue (For MXF etc).
1451  // We only do this when
1452  // 1. eof.
1453  // 2. we are not able to resolve a pts value for current packet.
1454  // 3. the packets for this stream at the end of the files had valid dts.
1455  next_pkt->pts = last_dts + next_pkt->duration;
1456  }
1457  pktl = s->packet_buffer;
1458  }
1459 
1460  /* read packet from packet buffer, if there is data */
1461  st = s->streams[next_pkt->stream_index];
1462  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1463  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1465  &s->packet_buffer_end, pkt);
1466  goto return_packet;
1467  }
1468  }
1469 
1470  ret = read_frame_internal(s, pkt);
1471  if (ret < 0) {
1472  if (pktl && ret != AVERROR(EAGAIN)) {
1473  eof = 1;
1474  continue;
1475  } else
1476  return ret;
1477  }
1478 
1480  &s->packet_buffer_end)) < 0)
1481  return AVERROR(ENOMEM);
1482  }
1483 
1484 return_packet:
1485 
1486  st = s->streams[pkt->stream_index];
1487  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1488  ff_reduce_index(s, st->index);
1489  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1490  }
1491 
1492  if (is_relative(pkt->dts))
1493  pkt->dts -= RELATIVE_TS_BASE;
1494  if (is_relative(pkt->pts))
1495  pkt->pts -= RELATIVE_TS_BASE;
1496 
1497  return ret;
1498 }
1499 
1500 /* XXX: suppress the packet queue */
1502 {
1506 
1508 }
1509 
1510 /*******************************************************/
1511 /* seek support */
1512 
1514 {
1515  int i;
1516  AVStream *st;
1517  int best_stream = 0;
1518  int best_score = -1;
1519 
1520  if (s->nb_streams <= 0)
1521  return -1;
1522  for (i = 0; i < s->nb_streams; i++) {
1523  int score = 0;
1524  st = s->streams[i];
1525  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1527  if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1528  score += 25;
1529  else
1530  score += 100;
1531  }
1532  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1533  if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1534  score += 12;
1535  else
1536  score += 50;
1537  }
1538 
1539  if (score > best_score) {
1540  best_score = score;
1541  best_stream = i;
1542  }
1543  }
1544  return best_stream;
1545 }
1546 
1547 /** Flush the frame reader. */
1549 {
1550  AVStream *st;
1551  int i, j;
1552 
1553  flush_packet_queue(s);
1554 
1555  /* Reset read state for each stream. */
1556  for (i = 0; i < s->nb_streams; i++) {
1557  st = s->streams[i];
1558 
1559  if (st->parser) {
1560  av_parser_close(st->parser);
1561  st->parser = NULL;
1562  }
1565  if (st->first_dts == AV_NOPTS_VALUE)
1566  st->cur_dts = RELATIVE_TS_BASE;
1567  else
1568  /* We set the current DTS to an unspecified origin. */
1569  st->cur_dts = AV_NOPTS_VALUE;
1570 
1572 
1573  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1574  st->pts_buffer[j] = AV_NOPTS_VALUE;
1575 
1577  st->inject_global_side_data = 1;
1578  }
1579 }
1580 
1581 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1582 {
1583  int i;
1584 
1585  for (i = 0; i < s->nb_streams; i++) {
1586  AVStream *st = s->streams[i];
1587 
1588  st->cur_dts =
1589  av_rescale(timestamp,
1590  st->time_base.den * (int64_t) ref_st->time_base.num,
1591  st->time_base.num * (int64_t) ref_st->time_base.den);
1592  }
1593 }
1594 
1595 void ff_reduce_index(AVFormatContext *s, int stream_index)
1596 {
1597  AVStream *st = s->streams[stream_index];
1598  unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1599 
1600  if ((unsigned) st->nb_index_entries >= max_entries) {
1601  int i;
1602  for (i = 0; 2 * i < st->nb_index_entries; i++)
1603  st->index_entries[i] = st->index_entries[2 * i];
1604  st->nb_index_entries = i;
1605  }
1606 }
1607 
1608 int ff_add_index_entry(AVIndexEntry **index_entries,
1609  int *nb_index_entries,
1610  unsigned int *index_entries_allocated_size,
1611  int64_t pos, int64_t timestamp,
1612  int size, int distance, int flags)
1613 {
1614  AVIndexEntry *entries, *ie;
1615  int index;
1616 
1617  if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1618  return -1;
1619 
1620  if (timestamp == AV_NOPTS_VALUE)
1621  return AVERROR(EINVAL);
1622 
1623  if (size < 0 || size > 0x3FFFFFFF)
1624  return AVERROR(EINVAL);
1625 
1626  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1627  timestamp -= RELATIVE_TS_BASE;
1628 
1629  entries = av_fast_realloc(*index_entries,
1630  index_entries_allocated_size,
1631  (*nb_index_entries + 1) *
1632  sizeof(AVIndexEntry));
1633  if (!entries)
1634  return -1;
1635 
1636  *index_entries = entries;
1637 
1638  index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1639  timestamp, AVSEEK_FLAG_ANY);
1640 
1641  if (index < 0) {
1642  index = (*nb_index_entries)++;
1643  ie = &entries[index];
1644  av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1645  } else {
1646  ie = &entries[index];
1647  if (ie->timestamp != timestamp) {
1648  if (ie->timestamp <= timestamp)
1649  return -1;
1650  memmove(entries + index + 1, entries + index,
1651  sizeof(AVIndexEntry) * (*nb_index_entries - index));
1652  (*nb_index_entries)++;
1653  } else if (ie->pos == pos && distance < ie->min_distance)
1654  // do not reduce the distance
1655  distance = ie->min_distance;
1656  }
1657 
1658  ie->pos = pos;
1659  ie->timestamp = timestamp;
1660  ie->min_distance = distance;
1661  ie->size = size;
1662  ie->flags = flags;
1663 
1664  return index;
1665 }
1666 
1667 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1668  int size, int distance, int flags)
1669 {
1670  timestamp = wrap_timestamp(st, timestamp);
1672  &st->index_entries_allocated_size, pos,
1673  timestamp, size, distance, flags);
1674 }
1675 
1676 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1677  int64_t wanted_timestamp, int flags)
1678 {
1679  int a, b, m;
1680  int64_t timestamp;
1681 
1682  a = -1;
1683  b = nb_entries;
1684 
1685  // Optimize appending index entries at the end.
1686  if (b && entries[b - 1].timestamp < wanted_timestamp)
1687  a = b - 1;
1688 
1689  while (b - a > 1) {
1690  m = (a + b) >> 1;
1691  timestamp = entries[m].timestamp;
1692  if (timestamp >= wanted_timestamp)
1693  b = m;
1694  if (timestamp <= wanted_timestamp)
1695  a = m;
1696  }
1697  m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1698 
1699  if (!(flags & AVSEEK_FLAG_ANY))
1700  while (m >= 0 && m < nb_entries &&
1701  !(entries[m].flags & AVINDEX_KEYFRAME))
1702  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1703 
1704  if (m == nb_entries)
1705  return -1;
1706  return m;
1707 }
1708 
1709 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1710 {
1712  wanted_timestamp, flags);
1713 }
1714 
1715 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1716  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1717 {
1718  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1719  if (stream_index >= 0)
1720  ts = wrap_timestamp(s->streams[stream_index], ts);
1721  return ts;
1722 }
1723 
1724 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1725  int64_t target_ts, int flags)
1726 {
1727  AVInputFormat *avif = s->iformat;
1728  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1729  int64_t ts_min, ts_max, ts;
1730  int index;
1731  int64_t ret;
1732  AVStream *st;
1733 
1734  if (stream_index < 0)
1735  return -1;
1736 
1737  av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1738 
1739  ts_max =
1740  ts_min = AV_NOPTS_VALUE;
1741  pos_limit = -1; // GCC falsely says it may be uninitialized.
1742 
1743  st = s->streams[stream_index];
1744  if (st->index_entries) {
1745  AVIndexEntry *e;
1746 
1747  /* FIXME: Whole function must be checked for non-keyframe entries in
1748  * index case, especially read_timestamp(). */
1749  index = av_index_search_timestamp(st, target_ts,
1750  flags | AVSEEK_FLAG_BACKWARD);
1751  index = FFMAX(index, 0);
1752  e = &st->index_entries[index];
1753 
1754  if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1755  pos_min = e->pos;
1756  ts_min = e->timestamp;
1757  av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1758  pos_min, av_ts2str(ts_min));
1759  } else {
1760  av_assert1(index == 0);
1761  }
1762 
1763  index = av_index_search_timestamp(st, target_ts,
1764  flags & ~AVSEEK_FLAG_BACKWARD);
1765  av_assert0(index < st->nb_index_entries);
1766  if (index >= 0) {
1767  e = &st->index_entries[index];
1768  av_assert1(e->timestamp >= target_ts);
1769  pos_max = e->pos;
1770  ts_max = e->timestamp;
1771  pos_limit = pos_max - e->min_distance;
1772  av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1773  " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1774  }
1775  }
1776 
1777  pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1778  ts_min, ts_max, flags, &ts, avif->read_timestamp);
1779  if (pos < 0)
1780  return -1;
1781 
1782  /* do the seek */
1783  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1784  return ret;
1785 
1787  ff_update_cur_dts(s, st, ts);
1788 
1789  return 0;
1790 }
1791 
1792 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1793  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1794 {
1795  int64_t step = 1024;
1796  int64_t limit, ts_max;
1797  int64_t filesize = avio_size(s->pb);
1798  int64_t pos_max = filesize - 1;
1799  do {
1800  limit = pos_max;
1801  pos_max = FFMAX(0, (pos_max) - step);
1802  ts_max = ff_read_timestamp(s, stream_index,
1803  &pos_max, limit, read_timestamp);
1804  step += step;
1805  } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1806  if (ts_max == AV_NOPTS_VALUE)
1807  return -1;
1808 
1809  for (;;) {
1810  int64_t tmp_pos = pos_max + 1;
1811  int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1812  &tmp_pos, INT64_MAX, read_timestamp);
1813  if (tmp_ts == AV_NOPTS_VALUE)
1814  break;
1815  av_assert0(tmp_pos > pos_max);
1816  ts_max = tmp_ts;
1817  pos_max = tmp_pos;
1818  if (tmp_pos >= filesize)
1819  break;
1820  }
1821 
1822  if (ts)
1823  *ts = ts_max;
1824  if (pos)
1825  *pos = pos_max;
1826 
1827  return 0;
1828 }
1829 
1830 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1831  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1832  int64_t ts_min, int64_t ts_max,
1833  int flags, int64_t *ts_ret,
1834  int64_t (*read_timestamp)(struct AVFormatContext *, int,
1835  int64_t *, int64_t))
1836 {
1837  int64_t pos, ts;
1838  int64_t start_pos;
1839  int no_change;
1840  int ret;
1841 
1842  av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1843 
1844  if (ts_min == AV_NOPTS_VALUE) {
1845  pos_min = s->data_offset;
1846  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1847  if (ts_min == AV_NOPTS_VALUE)
1848  return -1;
1849  }
1850 
1851  if (ts_min >= target_ts) {
1852  *ts_ret = ts_min;
1853  return pos_min;
1854  }
1855 
1856  if (ts_max == AV_NOPTS_VALUE) {
1857  if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1858  return ret;
1859  pos_limit = pos_max;
1860  }
1861 
1862  if (ts_max <= target_ts) {
1863  *ts_ret = ts_max;
1864  return pos_max;
1865  }
1866 
1867  if (ts_min > ts_max)
1868  return -1;
1869  else if (ts_min == ts_max)
1870  pos_limit = pos_min;
1871 
1872  no_change = 0;
1873  while (pos_min < pos_limit) {
1874  av_dlog(s,
1875  "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1876  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1877  assert(pos_limit <= pos_max);
1878 
1879  if (no_change == 0) {
1880  int64_t approximate_keyframe_distance = pos_max - pos_limit;
1881  // interpolate position (better than dichotomy)
1882  pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1883  ts_max - ts_min) +
1884  pos_min - approximate_keyframe_distance;
1885  } else if (no_change == 1) {
1886  // bisection if interpolation did not change min / max pos last time
1887  pos = (pos_min + pos_limit) >> 1;
1888  } else {
1889  /* linear search if bisection failed, can only happen if there
1890  * are very few or no keyframes between min/max */
1891  pos = pos_min;
1892  }
1893  if (pos <= pos_min)
1894  pos = pos_min + 1;
1895  else if (pos > pos_limit)
1896  pos = pos_limit;
1897  start_pos = pos;
1898 
1899  // May pass pos_limit instead of -1.
1900  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1901  if (pos == pos_max)
1902  no_change++;
1903  else
1904  no_change = 0;
1905  av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1906  " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1907  pos_min, pos, pos_max,
1908  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1909  pos_limit, start_pos, no_change);
1910  if (ts == AV_NOPTS_VALUE) {
1911  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1912  return -1;
1913  }
1914  if (target_ts <= ts) {
1915  pos_limit = start_pos - 1;
1916  pos_max = pos;
1917  ts_max = ts;
1918  }
1919  if (target_ts >= ts) {
1920  pos_min = pos;
1921  ts_min = ts;
1922  }
1923  }
1924 
1925  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1926  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1927 #if 0
1928  pos_min = pos;
1929  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1930  pos_min++;
1931  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1932  av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1933  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1934 #endif
1935  *ts_ret = ts;
1936  return pos;
1937 }
1938 
1939 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1940  int64_t pos, int flags)
1941 {
1942  int64_t pos_min, pos_max;
1943 
1944  pos_min = s->data_offset;
1945  pos_max = avio_size(s->pb) - 1;
1946 
1947  if (pos < pos_min)
1948  pos = pos_min;
1949  else if (pos > pos_max)
1950  pos = pos_max;
1951 
1952  avio_seek(s->pb, pos, SEEK_SET);
1953 
1954  s->io_repositioned = 1;
1955 
1956  return 0;
1957 }
1958 
1959 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1960  int64_t timestamp, int flags)
1961 {
1962  int index;
1963  int64_t ret;
1964  AVStream *st;
1965  AVIndexEntry *ie;
1966 
1967  st = s->streams[stream_index];
1968 
1969  index = av_index_search_timestamp(st, timestamp, flags);
1970 
1971  if (index < 0 && st->nb_index_entries &&
1972  timestamp < st->index_entries[0].timestamp)
1973  return -1;
1974 
1975  if (index < 0 || index == st->nb_index_entries - 1) {
1976  AVPacket pkt;
1977  int nonkey = 0;
1978 
1979  if (st->nb_index_entries) {
1981  ie = &st->index_entries[st->nb_index_entries - 1];
1982  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1983  return ret;
1984  ff_update_cur_dts(s, st, ie->timestamp);
1985  } else {
1986  if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1987  return ret;
1988  }
1989  for (;;) {
1990  int read_status;
1991  do {
1992  read_status = av_read_frame(s, &pkt);
1993  } while (read_status == AVERROR(EAGAIN));
1994  if (read_status < 0)
1995  break;
1996  av_free_packet(&pkt);
1997  if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
1998  if (pkt.flags & AV_PKT_FLAG_KEY)
1999  break;
2000  if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2001  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);
2002  break;
2003  }
2004  }
2005  }
2006  index = av_index_search_timestamp(st, timestamp, flags);
2007  }
2008  if (index < 0)
2009  return -1;
2010 
2012  if (s->iformat->read_seek)
2013  if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2014  return 0;
2015  ie = &st->index_entries[index];
2016  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2017  return ret;
2018  ff_update_cur_dts(s, st, ie->timestamp);
2019 
2020  return 0;
2021 }
2022 
2023 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2024  int64_t timestamp, int flags)
2025 {
2026  int ret;
2027  AVStream *st;
2028 
2029  if (flags & AVSEEK_FLAG_BYTE) {
2030  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2031  return -1;
2033  return seek_frame_byte(s, stream_index, timestamp, flags);
2034  }
2035 
2036  if (stream_index < 0) {
2037  stream_index = av_find_default_stream_index(s);
2038  if (stream_index < 0)
2039  return -1;
2040 
2041  st = s->streams[stream_index];
2042  /* timestamp for default must be expressed in AV_TIME_BASE units */
2043  timestamp = av_rescale(timestamp, st->time_base.den,
2044  AV_TIME_BASE * (int64_t) st->time_base.num);
2045  }
2046 
2047  /* first, we try the format specific seek */
2048  if (s->iformat->read_seek) {
2050  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2051  } else
2052  ret = -1;
2053  if (ret >= 0)
2054  return 0;
2055 
2056  if (s->iformat->read_timestamp &&
2057  !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2059  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2060  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2062  return seek_frame_generic(s, stream_index, timestamp, flags);
2063  } else
2064  return -1;
2065 }
2066 
2067 int av_seek_frame(AVFormatContext *s, int stream_index,
2068  int64_t timestamp, int flags)
2069 {
2070  int ret;
2071 
2072  if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2073  int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2074  if ((flags & AVSEEK_FLAG_BACKWARD))
2075  max_ts = timestamp;
2076  else
2077  min_ts = timestamp;
2078  return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2079  flags & ~AVSEEK_FLAG_BACKWARD);
2080  }
2081 
2082  ret = seek_frame_internal(s, stream_index, timestamp, flags);
2083 
2084  if (ret >= 0)
2086 
2087  return ret;
2088 }
2089 
2090 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2091  int64_t ts, int64_t max_ts, int flags)
2092 {
2093  if (min_ts > ts || max_ts < ts)
2094  return -1;
2095  if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2096  return AVERROR(EINVAL);
2097 
2098  if (s->seek2any>0)
2099  flags |= AVSEEK_FLAG_ANY;
2100  flags &= ~AVSEEK_FLAG_BACKWARD;
2101 
2102  if (s->iformat->read_seek2) {
2103  int ret;
2105 
2106  if (stream_index == -1 && s->nb_streams == 1) {
2107  AVRational time_base = s->streams[0]->time_base;
2108  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2109  min_ts = av_rescale_rnd(min_ts, time_base.den,
2110  time_base.num * (int64_t)AV_TIME_BASE,
2112  max_ts = av_rescale_rnd(max_ts, time_base.den,
2113  time_base.num * (int64_t)AV_TIME_BASE,
2115  }
2116 
2117  ret = s->iformat->read_seek2(s, stream_index, min_ts,
2118  ts, max_ts, flags);
2119 
2120  if (ret >= 0)
2122  return ret;
2123  }
2124 
2125  if (s->iformat->read_timestamp) {
2126  // try to seek via read_timestamp()
2127  }
2128 
2129  // Fall back on old API if new is not implemented but old is.
2130  // Note the old API has somewhat different semantics.
2131  if (s->iformat->read_seek || 1) {
2132  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2133  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2134  if (ret<0 && ts != min_ts && max_ts != ts) {
2135  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2136  if (ret >= 0)
2137  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2138  }
2139  return ret;
2140  }
2141 
2142  // try some generic seek like seek_frame_generic() but with new ts semantics
2143  return -1; //unreachable
2144 }
2145 
2146 /*******************************************************/
2147 
2148 /**
2149  * Return TRUE if the stream has accurate duration in any stream.
2150  *
2151  * @return TRUE if the stream has accurate duration for at least one component.
2152  */
2154 {
2155  int i;
2156  AVStream *st;
2157 
2158  for (i = 0; i < ic->nb_streams; i++) {
2159  st = ic->streams[i];
2160  if (st->duration != AV_NOPTS_VALUE)
2161  return 1;
2162  }
2163  if (ic->duration != AV_NOPTS_VALUE)
2164  return 1;
2165  return 0;
2166 }
2167 
2168 /**
2169  * Estimate the stream timings from the one of each components.
2170  *
2171  * Also computes the global bitrate if possible.
2172  */
2174 {
2175  int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2176  int64_t duration, duration1, filesize;
2177  int i;
2178  AVStream *st;
2179  AVProgram *p;
2180 
2181  start_time = INT64_MAX;
2182  start_time_text = INT64_MAX;
2183  end_time = INT64_MIN;
2184  duration = INT64_MIN;
2185  for (i = 0; i < ic->nb_streams; i++) {
2186  st = ic->streams[i];
2187  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2188  start_time1 = av_rescale_q(st->start_time, st->time_base,
2189  AV_TIME_BASE_Q);
2191  if (start_time1 < start_time_text)
2192  start_time_text = start_time1;
2193  } else
2194  start_time = FFMIN(start_time, start_time1);
2195  end_time1 = AV_NOPTS_VALUE;
2196  if (st->duration != AV_NOPTS_VALUE) {
2197  end_time1 = start_time1 +
2198  av_rescale_q(st->duration, st->time_base,
2199  AV_TIME_BASE_Q);
2200  end_time = FFMAX(end_time, end_time1);
2201  }
2202  for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2203  if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2204  p->start_time = start_time1;
2205  if (p->end_time < end_time1)
2206  p->end_time = end_time1;
2207  }
2208  }
2209  if (st->duration != AV_NOPTS_VALUE) {
2210  duration1 = av_rescale_q(st->duration, st->time_base,
2211  AV_TIME_BASE_Q);
2212  duration = FFMAX(duration, duration1);
2213  }
2214  }
2215  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2216  start_time = start_time_text;
2217  else if (start_time > start_time_text)
2218  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2219 
2220  if (start_time != INT64_MAX) {
2221  ic->start_time = start_time;
2222  if (end_time != INT64_MIN) {
2223  if (ic->nb_programs) {
2224  for (i = 0; i < ic->nb_programs; i++) {
2225  p = ic->programs[i];
2226  if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2227  duration = FFMAX(duration, p->end_time - p->start_time);
2228  }
2229  } else
2230  duration = FFMAX(duration, end_time - start_time);
2231  }
2232  }
2233  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2234  ic->duration = duration;
2235  }
2236  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2237  /* compute the bitrate */
2238  double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2239  (double) ic->duration;
2240  if (bitrate >= 0 && bitrate <= INT_MAX)
2241  ic->bit_rate = bitrate;
2242  }
2243 }
2244 
2246 {
2247  int i;
2248  AVStream *st;
2249 
2251  for (i = 0; i < ic->nb_streams; i++) {
2252  st = ic->streams[i];
2253  if (st->start_time == AV_NOPTS_VALUE) {
2254  if (ic->start_time != AV_NOPTS_VALUE)
2256  st->time_base);
2257  if (ic->duration != AV_NOPTS_VALUE)
2259  st->time_base);
2260  }
2261  }
2262 }
2263 
2265 {
2266  int64_t filesize, duration;
2267  int i, show_warning = 0;
2268  AVStream *st;
2269 
2270  /* if bit_rate is already set, we believe it */
2271  if (ic->bit_rate <= 0) {
2272  int bit_rate = 0;
2273  for (i = 0; i < ic->nb_streams; i++) {
2274  st = ic->streams[i];
2275  if (st->codec->bit_rate > 0) {
2276  if (INT_MAX - st->codec->bit_rate < bit_rate) {
2277  bit_rate = 0;
2278  break;
2279  }
2280  bit_rate += st->codec->bit_rate;
2281  }
2282  }
2283  ic->bit_rate = bit_rate;
2284  }
2285 
2286  /* if duration is already set, we believe it */
2287  if (ic->duration == AV_NOPTS_VALUE &&
2288  ic->bit_rate != 0) {
2289  filesize = ic->pb ? avio_size(ic->pb) : 0;
2290  if (filesize > ic->data_offset) {
2291  filesize -= ic->data_offset;
2292  for (i = 0; i < ic->nb_streams; i++) {
2293  st = ic->streams[i];
2294  if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2295  && st->duration == AV_NOPTS_VALUE) {
2296  duration = av_rescale(8 * filesize, st->time_base.den,
2297  ic->bit_rate *
2298  (int64_t) st->time_base.num);
2299  st->duration = duration;
2300  show_warning = 1;
2301  }
2302  }
2303  }
2304  }
2305  if (show_warning)
2306  av_log(ic, AV_LOG_WARNING,
2307  "Estimating duration from bitrate, this may be inaccurate\n");
2308 }
2309 
2310 #define DURATION_MAX_READ_SIZE 250000LL
2311 #define DURATION_MAX_RETRY 4
2312 
2313 /* only usable for MPEG-PS streams */
2314 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2315 {
2316  AVPacket pkt1, *pkt = &pkt1;
2317  AVStream *st;
2318  int num, den, read_size, i, ret;
2319  int found_duration = 0;
2320  int is_end;
2321  int64_t filesize, offset, duration;
2322  int retry = 0;
2323 
2324  /* flush packet queue */
2325  flush_packet_queue(ic);
2326 
2327  for (i = 0; i < ic->nb_streams; i++) {
2328  st = ic->streams[i];
2329  if (st->start_time == AV_NOPTS_VALUE &&
2330  st->first_dts == AV_NOPTS_VALUE &&
2333  "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2334 
2335  if (st->parser) {
2336  av_parser_close(st->parser);
2337  st->parser = NULL;
2338  }
2339  }
2340 
2341  av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2342  /* estimate the end time (duration) */
2343  /* XXX: may need to support wrapping */
2344  filesize = ic->pb ? avio_size(ic->pb) : 0;
2345  do {
2346  is_end = found_duration;
2347  offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2348  if (offset < 0)
2349  offset = 0;
2350 
2351  avio_seek(ic->pb, offset, SEEK_SET);
2352  read_size = 0;
2353  for (;;) {
2354  if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2355  break;
2356 
2357  do {
2358  ret = ff_read_packet(ic, pkt);
2359  } while (ret == AVERROR(EAGAIN));
2360  if (ret != 0)
2361  break;
2362  read_size += pkt->size;
2363  st = ic->streams[pkt->stream_index];
2364  if (pkt->pts != AV_NOPTS_VALUE &&
2365  (st->start_time != AV_NOPTS_VALUE ||
2366  st->first_dts != AV_NOPTS_VALUE)) {
2367  if (pkt->duration == 0) {
2368  ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2369  if (den && num) {
2370  pkt->duration = av_rescale_rnd(1,
2371  num * (int64_t) st->time_base.den,
2372  den * (int64_t) st->time_base.num,
2373  AV_ROUND_DOWN);
2374  }
2375  }
2376  duration = pkt->pts + pkt->duration;
2377  found_duration = 1;
2378  if (st->start_time != AV_NOPTS_VALUE)
2379  duration -= st->start_time;
2380  else
2381  duration -= st->first_dts;
2382  if (duration > 0) {
2383  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2384  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2385  st->duration = duration;
2386  st->info->last_duration = duration;
2387  }
2388  }
2389  av_free_packet(pkt);
2390  }
2391 
2392  /* check if all audio/video streams have valid duration */
2393  if (!is_end) {
2394  is_end = 1;
2395  for (i = 0; i < ic->nb_streams; i++) {
2396  st = ic->streams[i];
2397  switch (st->codec->codec_type) {
2398  case AVMEDIA_TYPE_VIDEO:
2399  case AVMEDIA_TYPE_AUDIO:
2400  if (st->duration == AV_NOPTS_VALUE)
2401  is_end = 0;
2402  }
2403  }
2404  }
2405  } while (!is_end &&
2406  offset &&
2407  ++retry <= DURATION_MAX_RETRY);
2408 
2409  av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2410 
2411  /* warn about audio/video streams which duration could not be estimated */
2412  for (i = 0; i < ic->nb_streams; i++) {
2413  st = ic->streams[i];
2414  if (st->duration == AV_NOPTS_VALUE) {
2415  switch (st->codec->codec_type) {
2416  case AVMEDIA_TYPE_VIDEO:
2417  case AVMEDIA_TYPE_AUDIO:
2418  if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2419  av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2420  } else
2421  av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2422  }
2423  }
2424  }
2426 
2427  avio_seek(ic->pb, old_offset, SEEK_SET);
2428  for (i = 0; i < ic->nb_streams; i++) {
2429  int j;
2430 
2431  st = ic->streams[i];
2432  st->cur_dts = st->first_dts;
2435  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2436  st->pts_buffer[j] = AV_NOPTS_VALUE;
2437  }
2438 }
2439 
2440 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2441 {
2442  int64_t file_size;
2443 
2444  /* get the file size, if possible */
2445  if (ic->iformat->flags & AVFMT_NOFILE) {
2446  file_size = 0;
2447  } else {
2448  file_size = avio_size(ic->pb);
2449  file_size = FFMAX(0, file_size);
2450  }
2451 
2452  if ((!strcmp(ic->iformat->name, "mpeg") ||
2453  !strcmp(ic->iformat->name, "mpegts")) &&
2454  file_size && ic->pb->seekable) {
2455  /* get accurate estimate from the PTSes */
2456  estimate_timings_from_pts(ic, old_offset);
2458  } else if (has_duration(ic)) {
2459  /* at least one component has timings - we use them for all
2460  * the components */
2463  } else {
2464  /* less precise: use bitrate info */
2467  }
2469 
2470  {
2471  int i;
2472  AVStream av_unused *st;
2473  for (i = 0; i < ic->nb_streams; i++) {
2474  st = ic->streams[i];
2475  av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2476  (double) st->start_time / AV_TIME_BASE,
2477  (double) st->duration / AV_TIME_BASE);
2478  }
2479  av_dlog(ic,
2480  "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2481  (double) ic->start_time / AV_TIME_BASE,
2482  (double) ic->duration / AV_TIME_BASE,
2483  ic->bit_rate / 1000);
2484  }
2485 }
2486 
2487 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2488 {
2489  AVCodecContext *avctx = st->codec;
2490 
2491 #define FAIL(errmsg) do { \
2492  if (errmsg_ptr) \
2493  *errmsg_ptr = errmsg; \
2494  return 0; \
2495  } while (0)
2496 
2497  if ( avctx->codec_id == AV_CODEC_ID_NONE
2498  && avctx->codec_type != AVMEDIA_TYPE_DATA)
2499  FAIL("unknown codec");
2500  switch (avctx->codec_type) {
2501  case AVMEDIA_TYPE_AUDIO:
2502  if (!avctx->frame_size && determinable_frame_size(avctx))
2503  FAIL("unspecified frame size");
2504  if (st->info->found_decoder >= 0 &&
2505  avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2506  FAIL("unspecified sample format");
2507  if (!avctx->sample_rate)
2508  FAIL("unspecified sample rate");
2509  if (!avctx->channels)
2510  FAIL("unspecified number of channels");
2511  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2512  FAIL("no decodable DTS frames");
2513  break;
2514  case AVMEDIA_TYPE_VIDEO:
2515  if (!avctx->width)
2516  FAIL("unspecified size");
2517  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2518  FAIL("unspecified pixel format");
2521  FAIL("no frame in rv30/40 and no sar");
2522  break;
2523  case AVMEDIA_TYPE_SUBTITLE:
2524  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2525  FAIL("unspecified size");
2526  break;
2527  case AVMEDIA_TYPE_DATA:
2528  if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2529  }
2530 
2531  return 1;
2532 }
2533 
2534 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2537 {
2538  const AVCodec *codec;
2539  int got_picture = 1, ret = 0;
2541  AVSubtitle subtitle;
2542  AVPacket pkt = *avpkt;
2543 
2544  if (!frame)
2545  return AVERROR(ENOMEM);
2546 
2547  if (!avcodec_is_open(st->codec) &&
2548  st->info->found_decoder <= 0 &&
2549  (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2550  AVDictionary *thread_opt = NULL;
2551 
2552  codec = find_decoder(s, st, st->codec->codec_id);
2553 
2554  if (!codec) {
2555  st->info->found_decoder = -st->codec->codec_id;
2556  ret = -1;
2557  goto fail;
2558  }
2559 
2560  /* Force thread count to 1 since the H.264 decoder will not extract
2561  * SPS and PPS to extradata during multi-threaded decoding. */
2562  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2563  ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2564  if (!options)
2565  av_dict_free(&thread_opt);
2566  if (ret < 0) {
2567  st->info->found_decoder = -st->codec->codec_id;
2568  goto fail;
2569  }
2570  st->info->found_decoder = 1;
2571  } else if (!st->info->found_decoder)
2572  st->info->found_decoder = 1;
2573 
2574  if (st->info->found_decoder < 0) {
2575  ret = -1;
2576  goto fail;
2577  }
2578 
2579  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2580  ret >= 0 &&
2582  (!st->codec_info_nb_frames &&
2584  got_picture = 0;
2585  switch (st->codec->codec_type) {
2586  case AVMEDIA_TYPE_VIDEO:
2587  ret = avcodec_decode_video2(st->codec, frame,
2588  &got_picture, &pkt);
2589  break;
2590  case AVMEDIA_TYPE_AUDIO:
2591  ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2592  break;
2593  case AVMEDIA_TYPE_SUBTITLE:
2594  ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2595  &got_picture, &pkt);
2596  ret = pkt.size;
2597  break;
2598  default:
2599  break;
2600  }
2601  if (ret >= 0) {
2602  if (got_picture)
2603  st->nb_decoded_frames++;
2604  pkt.data += ret;
2605  pkt.size -= ret;
2606  ret = got_picture;
2607  }
2608  }
2609 
2610  if (!pkt.data && !got_picture)
2611  ret = -1;
2612 
2613 fail:
2614  av_frame_free(&frame);
2615  return ret;
2616 }
2617 
2618 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2619 {
2620  while (tags->id != AV_CODEC_ID_NONE) {
2621  if (tags->id == id)
2622  return tags->tag;
2623  tags++;
2624  }
2625  return 0;
2626 }
2627 
2628 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2629 {
2630  int i;
2631  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2632  if (tag == tags[i].tag)
2633  return tags[i].id;
2634  for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2635  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2636  return tags[i].id;
2637  return AV_CODEC_ID_NONE;
2638 }
2639 
2640 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2641 {
2642  if (flt) {
2643  switch (bps) {
2644  case 32:
2646  case 64:
2648  default:
2649  return AV_CODEC_ID_NONE;
2650  }
2651  } else {
2652  bps += 7;
2653  bps >>= 3;
2654  if (sflags & (1 << (bps - 1))) {
2655  switch (bps) {
2656  case 1:
2657  return AV_CODEC_ID_PCM_S8;
2658  case 2:
2660  case 3:
2662  case 4:
2664  default:
2665  return AV_CODEC_ID_NONE;
2666  }
2667  } else {
2668  switch (bps) {
2669  case 1:
2670  return AV_CODEC_ID_PCM_U8;
2671  case 2:
2673  case 3:
2675  case 4:
2677  default:
2678  return AV_CODEC_ID_NONE;
2679  }
2680  }
2681  }
2682 }
2683 
2684 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2685 {
2686  unsigned int tag;
2687  if (!av_codec_get_tag2(tags, id, &tag))
2688  return 0;
2689  return tag;
2690 }
2691 
2692 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2693  unsigned int *tag)
2694 {
2695  int i;
2696  for (i = 0; tags && tags[i]; i++) {
2697  const AVCodecTag *codec_tags = tags[i];
2698  while (codec_tags->id != AV_CODEC_ID_NONE) {
2699  if (codec_tags->id == id) {
2700  *tag = codec_tags->tag;
2701  return 1;
2702  }
2703  codec_tags++;
2704  }
2705  }
2706  return 0;
2707 }
2708 
2709 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2710 {
2711  int i;
2712  for (i = 0; tags && tags[i]; i++) {
2713  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2714  if (id != AV_CODEC_ID_NONE)
2715  return id;
2716  }
2717  return AV_CODEC_ID_NONE;
2718 }
2719 
2721 {
2722  unsigned int i, j;
2723  int64_t max_time = s->duration +
2724  ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2725 
2726  for (i = 0; i < s->nb_chapters; i++)
2727  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2728  AVChapter *ch = s->chapters[i];
2729  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2730  ch->time_base)
2731  : INT64_MAX;
2732 
2733  for (j = 0; j < s->nb_chapters; j++) {
2734  AVChapter *ch1 = s->chapters[j];
2735  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2736  ch->time_base);
2737  if (j != i && next_start > ch->start && next_start < end)
2738  end = next_start;
2739  }
2740  ch->end = (end == INT64_MAX) ? ch->start : end;
2741  }
2742 }
2743 
2744 static int get_std_framerate(int i)
2745 {
2746  if (i < 60 * 12)
2747  return (i + 1) * 1001;
2748  else
2749  return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2750 }
2751 
2752 /* Is the time base unreliable?
2753  * This is a heuristic to balance between quick acceptance of the values in
2754  * the headers vs. some extra checks.
2755  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2756  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2757  * And there are "variable" fps files this needs to detect as well. */
2759 {
2760  if (c->time_base.den >= 101L * c->time_base.num ||
2761  c->time_base.den < 5L * c->time_base.num ||
2762  // c->codec_tag == AV_RL32("DIVX") ||
2763  // c->codec_tag == AV_RL32("XVID") ||
2764  c->codec_tag == AV_RL32("mp4v") ||
2766  c->codec_id == AV_CODEC_ID_GIF ||
2767  c->codec_id == AV_CODEC_ID_H264)
2768  return 1;
2769  return 0;
2770 }
2771 
2772 #if FF_API_FORMAT_PARAMETERS
2773 int av_find_stream_info(AVFormatContext *ic)
2774 {
2775  return avformat_find_stream_info(ic, NULL);
2776 }
2777 #endif
2778 
2780 {
2781  int ret;
2782 
2784  avctx->extradata_size = 0;
2785  return AVERROR(EINVAL);
2786  }
2788  if (avctx->extradata) {
2789  memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2790  avctx->extradata_size = size;
2791  ret = 0;
2792  } else {
2793  avctx->extradata_size = 0;
2794  ret = AVERROR(ENOMEM);
2795  }
2796  return ret;
2797 }
2798 
2800 {
2801  int ret = ff_alloc_extradata(avctx, size);
2802  if (ret < 0)
2803  return ret;
2804  ret = avio_read(pb, avctx->extradata, size);
2805  if (ret != size) {
2806  av_freep(&avctx->extradata);
2807  avctx->extradata_size = 0;
2808  av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2809  return ret < 0 ? ret : AVERROR_INVALIDDATA;
2810  }
2811 
2812  return ret;
2813 }
2814 
2815 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2816 {
2817  int i, j;
2818  int64_t last = st->info->last_dts;
2819 
2820  if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2821  && ts - (uint64_t)last < INT64_MAX) {
2822  double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2823  int64_t duration = ts - last;
2824 
2825  if (!st->info->duration_error)
2826  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2827  if (!st->info->duration_error)
2828  return AVERROR(ENOMEM);
2829 
2830 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2831 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2832  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2833  if (st->info->duration_error[0][1][i] < 1e10) {
2834  int framerate = get_std_framerate(i);
2835  double sdts = dts*framerate/(1001*12);
2836  for (j= 0; j<2; j++) {
2837  int64_t ticks = llrint(sdts+j*0.5);
2838  double error= sdts - ticks + j*0.5;
2839  st->info->duration_error[j][0][i] += error;
2840  st->info->duration_error[j][1][i] += error*error;
2841  }
2842  }
2843  }
2844  st->info->duration_count++;
2846 
2847  if (st->info->duration_count % 10 == 0) {
2848  int n = st->info->duration_count;
2849  for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2850  if (st->info->duration_error[0][1][i] < 1e10) {
2851  double a0 = st->info->duration_error[0][0][i] / n;
2852  double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2853  double a1 = st->info->duration_error[1][0][i] / n;
2854  double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2855  if (error0 > 0.04 && error1 > 0.04) {
2856  st->info->duration_error[0][1][i] = 2e10;
2857  st->info->duration_error[1][1][i] = 2e10;
2858  }
2859  }
2860  }
2861  }
2862 
2863  // ignore the first 4 values, they might have some random jitter
2864  if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2865  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2866  }
2867  if (ts != AV_NOPTS_VALUE)
2868  st->info->last_dts = ts;
2869 
2870  return 0;
2871 }
2872 
2874 {
2875  int i, j;
2876 
2877  for (i = 0; i < ic->nb_streams; i++) {
2878  AVStream *st = ic->streams[i];
2879 
2880  if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2881  continue;
2882  // the check for tb_unreliable() is not completely correct, since this is not about handling
2883  // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2884  // ipmovie.c produces.
2885  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)
2886  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);
2887  if (st->info->duration_count>1 && !st->r_frame_rate.num
2888  && tb_unreliable(st->codec)) {
2889  int num = 0;
2890  double best_error= 0.01;
2891  AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2892 
2893  for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2894  int k;
2895 
2896  if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2897  continue;
2898  if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2899  continue;
2900 
2901  if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2902  continue;
2903 
2904  for (k= 0; k<2; k++) {
2905  int n = st->info->duration_count;
2906  double a= st->info->duration_error[k][0][j] / n;
2907  double error= st->info->duration_error[k][1][j]/n - a*a;
2908 
2909  if (error < best_error && best_error> 0.000000001) {
2910  best_error= error;
2911  num = get_std_framerate(j);
2912  }
2913  if (error < 0.02)
2914  av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2915  }
2916  }
2917  // do not increase frame rate by more than 1 % in order to match a standard rate.
2918  if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2919  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2920  }
2921  if ( !st->avg_frame_rate.num
2922  && st->r_frame_rate.num && st->info->rfps_duration_sum
2923  && st->info->codec_info_duration <= 0
2924  && st->info->duration_count > 2
2925  && 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
2926  ) {
2927  av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2928  st->avg_frame_rate = st->r_frame_rate;
2929  }
2930 
2931  av_freep(&st->info->duration_error);
2932  st->info->last_dts = AV_NOPTS_VALUE;
2933  st->info->duration_count = 0;
2934  st->info->rfps_duration_sum = 0;
2935  }
2936 }
2937 
2939 {
2940  int i, count, ret = 0, j;
2941  int64_t read_size;
2942  AVStream *st;
2943  AVPacket pkt1, *pkt;
2944  int64_t old_offset = avio_tell(ic->pb);
2945  // new streams might appear, no options for those
2946  int orig_nb_streams = ic->nb_streams;
2947  int flush_codecs;
2948  int64_t max_analyze_duration = ic->max_analyze_duration2;
2949  int64_t probesize = ic->probesize2;
2950 
2951  if (!max_analyze_duration)
2952  max_analyze_duration = ic->max_analyze_duration;
2953  if (ic->probesize)
2954  probesize = ic->probesize;
2955  flush_codecs = probesize > 0;
2956 
2957  av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2958 
2959  if (!max_analyze_duration) {
2960  if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2961  max_analyze_duration = 10*AV_TIME_BASE;
2962  } else
2963  max_analyze_duration = 5*AV_TIME_BASE;
2964  }
2965 
2966  if (ic->pb)
2967  av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2968  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2969 
2970  for (i = 0; i < ic->nb_streams; i++) {
2971  const AVCodec *codec;
2972  AVDictionary *thread_opt = NULL;
2973  st = ic->streams[i];
2974 
2975  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2977 /* if (!st->time_base.num)
2978  st->time_base = */
2979  if (!st->codec->time_base.num)
2980  st->codec->time_base = st->time_base;
2981  }
2982  // only for the split stuff
2983  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2984  st->parser = av_parser_init(st->codec->codec_id);
2985  if (st->parser) {
2986  if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
2988  } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2990  }
2991  } else if (st->need_parsing) {
2992  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2993  "%s, packets or times may be invalid.\n",
2995  }
2996  }
2997  codec = find_decoder(ic, st, st->codec->codec_id);
2998 
2999  /* Force thread count to 1 since the H.264 decoder will not extract
3000  * SPS and PPS to extradata during multi-threaded decoding. */
3001  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3002 
3003  /* Ensure that subtitle_header is properly set. */
3005  && codec && !st->codec->codec) {
3006  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3007  av_log(ic, AV_LOG_WARNING,
3008  "Failed to open codec in av_find_stream_info\n");
3009  }
3010 
3011  // Try to just open decoders, in case this is enough to get parameters.
3012  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3013  if (codec && !st->codec->codec)
3014  if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3015  av_log(ic, AV_LOG_WARNING,
3016  "Failed to open codec in av_find_stream_info\n");
3017  }
3018  if (!options)
3019  av_dict_free(&thread_opt);
3020  }
3021 
3022  for (i = 0; i < ic->nb_streams; i++) {
3023 #if FF_API_R_FRAME_RATE
3024  ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3025 #endif
3028  }
3029 
3030  count = 0;
3031  read_size = 0;
3032  for (;;) {
3034  ret = AVERROR_EXIT;
3035  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3036  break;
3037  }
3038 
3039  /* check if one codec still needs to be handled */
3040  for (i = 0; i < ic->nb_streams; i++) {
3041  int fps_analyze_framecount = 20;
3042 
3043  st = ic->streams[i];
3044  if (!has_codec_parameters(st, NULL))
3045  break;
3046  /* If the timebase is coarse (like the usual millisecond precision
3047  * of mkv), we need to analyze more frames to reliably arrive at
3048  * the correct fps. */
3049  if (av_q2d(st->time_base) > 0.0005)
3050  fps_analyze_framecount *= 2;
3051  if (!tb_unreliable(st->codec))
3052  fps_analyze_framecount = 0;
3053  if (ic->fps_probe_size >= 0)
3054  fps_analyze_framecount = ic->fps_probe_size;
3056  fps_analyze_framecount = 0;
3057  /* variable fps and no guess at the real fps */
3058  if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3059  st->info->duration_count < fps_analyze_framecount &&
3061  break;
3062  if (st->parser && st->parser->parser->split &&
3063  !st->codec->extradata)
3064  break;
3065  if (st->first_dts == AV_NOPTS_VALUE &&
3066  !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3067  st->codec_info_nb_frames < ic->max_ts_probe &&
3068  (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3070  break;
3071  }
3072  if (i == ic->nb_streams) {
3073  /* NOTE: If the format has no header, then we need to read some
3074  * packets to get most of the streams, so we cannot stop here. */
3075  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3076  /* If we found the info for all the codecs, we can stop. */
3077  ret = count;
3078  av_log(ic, AV_LOG_DEBUG, "All info found\n");
3079  flush_codecs = 0;
3080  break;
3081  }
3082  }
3083  /* We did not get all the codec info, but we read too much data. */
3084  if (read_size >= probesize) {
3085  ret = count;
3086  av_log(ic, AV_LOG_DEBUG,
3087  "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3088  for (i = 0; i < ic->nb_streams; i++)
3089  if (!ic->streams[i]->r_frame_rate.num &&
3090  ic->streams[i]->info->duration_count <= 1 &&
3092  strcmp(ic->iformat->name, "image2"))
3093  av_log(ic, AV_LOG_WARNING,
3094  "Stream #%d: not enough frames to estimate rate; "
3095  "consider increasing probesize\n", i);
3096  break;
3097  }
3098 
3099  /* NOTE: A new stream can be added there if no header in file
3100  * (AVFMTCTX_NOHEADER). */
3101  ret = read_frame_internal(ic, &pkt1);
3102  if (ret == AVERROR(EAGAIN))
3103  continue;
3104 
3105  if (ret < 0) {
3106  /* EOF or error*/
3107  break;
3108  }
3109 
3110  if (ic->flags & AVFMT_FLAG_NOBUFFER)
3112  {
3113  pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3114  &ic->packet_buffer_end);
3115  if (!pkt) {
3116  ret = AVERROR(ENOMEM);
3117  goto find_stream_info_err;
3118  }
3119  if ((ret = av_dup_packet(pkt)) < 0)
3120  goto find_stream_info_err;
3121  }
3122 
3123  st = ic->streams[pkt->stream_index];
3125  read_size += pkt->size;
3126 
3127  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3128  /* check for non-increasing dts */
3129  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3130  st->info->fps_last_dts >= pkt->dts) {
3131  av_log(ic, AV_LOG_DEBUG,
3132  "Non-increasing DTS in stream %d: packet %d with DTS "
3133  "%"PRId64", packet %d with DTS %"PRId64"\n",
3134  st->index, st->info->fps_last_dts_idx,
3136  pkt->dts);
3137  st->info->fps_first_dts =
3139  }
3140  /* Check for a discontinuity in dts. If the difference in dts
3141  * is more than 1000 times the average packet duration in the
3142  * sequence, we treat it as a discontinuity. */
3143  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3145  (pkt->dts - st->info->fps_last_dts) / 1000 >
3146  (st->info->fps_last_dts - st->info->fps_first_dts) /
3147  (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3148  av_log(ic, AV_LOG_WARNING,
3149  "DTS discontinuity in stream %d: packet %d with DTS "
3150  "%"PRId64", packet %d with DTS %"PRId64"\n",
3151  st->index, st->info->fps_last_dts_idx,
3153  pkt->dts);
3154  st->info->fps_first_dts =
3156  }
3157 
3158  /* update stored dts values */
3159  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3160  st->info->fps_first_dts = pkt->dts;
3162  }
3163  st->info->fps_last_dts = pkt->dts;
3165  }
3166  if (st->codec_info_nb_frames>1) {
3167  int64_t t = 0;
3168 
3169  if (st->time_base.den > 0)
3171  if (st->avg_frame_rate.num > 0)
3173 
3174  if ( t == 0
3175  && st->codec_info_nb_frames>30
3176  && st->info->fps_first_dts != AV_NOPTS_VALUE
3177  && st->info->fps_last_dts != AV_NOPTS_VALUE)
3179 
3180  if (t >= max_analyze_duration) {
3181  av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3182  max_analyze_duration,
3183  t);
3184  break;
3185  }
3186  if (pkt->duration) {
3187  st->info->codec_info_duration += pkt->duration;
3188  st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3189  }
3190  }
3191 #if FF_API_R_FRAME_RATE
3192  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3193  ff_rfps_add_frame(ic, st, pkt->dts);
3194 #endif
3195  if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3196  int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3197  if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3198  if (ff_alloc_extradata(st->codec, i))
3199  return AVERROR(ENOMEM);
3200  memcpy(st->codec->extradata, pkt->data,
3201  st->codec->extradata_size);
3202  }
3203  }
3204 
3205  /* If still no information, we try to open the codec and to
3206  * decompress the frame. We try to avoid that in most cases as
3207  * it takes longer and uses more memory. For MPEG-4, we need to
3208  * decompress for QuickTime.
3209  *
3210  * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3211  * least one frame of codec data, this makes sure the codec initializes
3212  * the channel configuration and does not only trust the values from
3213  * the container. */
3214  try_decode_frame(ic, st, pkt,
3215  (options && i < orig_nb_streams) ? &options[i] : NULL);
3216 
3217  st->codec_info_nb_frames++;
3218  count++;
3219  }
3220 
3221  if (flush_codecs) {
3222  AVPacket empty_pkt = { 0 };
3223  int err = 0;
3224  av_init_packet(&empty_pkt);
3225 
3226  for (i = 0; i < ic->nb_streams; i++) {
3227 
3228  st = ic->streams[i];
3229 
3230  /* flush the decoders */
3231  if (st->info->found_decoder == 1) {
3232  do {
3233  err = try_decode_frame(ic, st, &empty_pkt,
3234  (options && i < orig_nb_streams)
3235  ? &options[i] : NULL);
3236  } while (err > 0 && !has_codec_parameters(st, NULL));
3237 
3238  if (err < 0) {
3239  av_log(ic, AV_LOG_INFO,
3240  "decoding for stream %d failed\n", st->index);
3241  }
3242  }
3243  }
3244  }
3245  av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3246 
3247  // close codecs which were opened in try_decode_frame()
3248  for (i = 0; i < ic->nb_streams; i++) {
3249  st = ic->streams[i];
3250  avcodec_close(st->codec);
3251  }
3252 
3253  ff_rfps_calculate(ic);
3254 
3255  for (i = 0; i < ic->nb_streams; i++) {
3256  st = ic->streams[i];
3257  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3261  st->codec->codec_tag= tag;
3262  }
3263 
3264  /* estimate average framerate if not set by demuxer */
3265  if (st->info->codec_info_duration_fields &&
3266  !st->avg_frame_rate.num &&
3267  st->info->codec_info_duration) {
3268  int best_fps = 0;
3269  double best_error = 0.01;
3270 
3271  if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3272  st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3273  st->info->codec_info_duration < 0)
3274  continue;
3276  st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3277  st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3278 
3279  /* Round guessed framerate to a "standard" framerate if it's
3280  * within 1% of the original estimate. */
3281  for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3282  AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3283  double error = fabs(av_q2d(st->avg_frame_rate) /
3284  av_q2d(std_fps) - 1);
3285 
3286  if (error < best_error) {
3287  best_error = error;
3288  best_fps = std_fps.num;
3289  }
3290  }
3291  if (best_fps)
3293  best_fps, 12 * 1001, INT_MAX);
3294  }
3295 
3296  if (!st->r_frame_rate.num) {
3297  if ( st->codec->time_base.den * (int64_t) st->time_base.num
3298  <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3299  st->r_frame_rate.num = st->codec->time_base.den;
3301  } else {
3302  st->r_frame_rate.num = st->time_base.den;
3303  st->r_frame_rate.den = st->time_base.num;
3304  }
3305  }
3306  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3307  if (!st->codec->bits_per_coded_sample)
3310  // set stream disposition based on audio service type
3311  switch (st->codec->audio_service_type) {
3314  break;
3317  break;
3320  break;
3323  break;
3326  break;
3327  }
3328  }
3329  }
3330 
3331  if (probesize)
3332  estimate_timings(ic, old_offset);
3333 
3334  if (ret >= 0 && ic->nb_streams)
3335  /* We could not have all the codec parameters before EOF. */
3336  ret = -1;
3337  for (i = 0; i < ic->nb_streams; i++) {
3338  const char *errmsg;
3339  st = ic->streams[i];
3340  if (!has_codec_parameters(st, &errmsg)) {
3341  char buf[256];
3342  avcodec_string(buf, sizeof(buf), st->codec, 0);
3343  av_log(ic, AV_LOG_WARNING,
3344  "Could not find codec parameters for stream %d (%s): %s\n"
3345  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3346  i, buf, errmsg);
3347  } else {
3348  ret = 0;
3349  }
3350  }
3351 
3353 
3354 find_stream_info_err:
3355  for (i = 0; i < ic->nb_streams; i++) {
3356  st = ic->streams[i];
3357  if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3358  ic->streams[i]->codec->thread_count = 0;
3359  if (st->info)
3360  av_freep(&st->info->duration_error);
3361  av_freep(&ic->streams[i]->info);
3362  }
3363  if (ic->pb)
3364  av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3365  avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3366  return ret;
3367 }
3368 
3370 {
3371  int i, j;
3372 
3373  for (i = 0; i < ic->nb_programs; i++) {
3374  if (ic->programs[i] == last) {
3375  last = NULL;
3376  } else {
3377  if (!last)
3378  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3379  if (ic->programs[i]->stream_index[j] == s)
3380  return ic->programs[i];
3381  }
3382  }
3383  return NULL;
3384 }
3385 
3387  int wanted_stream_nb, int related_stream,
3388  AVCodec **decoder_ret, int flags)
3389 {
3390  int i, nb_streams = ic->nb_streams;
3391  int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3392  unsigned *program = NULL;
3393  const AVCodec *decoder = NULL, *best_decoder = NULL;
3394 
3395  if (related_stream >= 0 && wanted_stream_nb < 0) {
3396  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3397  if (p) {
3398  program = p->stream_index;
3399  nb_streams = p->nb_stream_indexes;
3400  }
3401  }
3402  for (i = 0; i < nb_streams; i++) {
3403  int real_stream_index = program ? program[i] : i;
3404  AVStream *st = ic->streams[real_stream_index];
3405  AVCodecContext *avctx = st->codec;
3406  if (avctx->codec_type != type)
3407  continue;
3408  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3409  continue;
3410  if (wanted_stream_nb != real_stream_index &&
3413  continue;
3414  if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3415  continue;
3416  if (decoder_ret) {
3417  decoder = find_decoder(ic, st, st->codec->codec_id);
3418  if (!decoder) {
3419  if (ret < 0)
3421  continue;
3422  }
3423  }
3425  bitrate = avctx->bit_rate;
3426  if (!bitrate)
3427  bitrate = avctx->rc_max_rate;
3428  multiframe = FFMIN(5, count);
3429  if ((best_multiframe > multiframe) ||
3430  (best_multiframe == multiframe && best_bitrate > bitrate) ||
3431  (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3432  continue;
3433  best_count = count;
3434  best_bitrate = bitrate;
3435  best_multiframe = multiframe;
3436  ret = real_stream_index;
3437  best_decoder = decoder;
3438  if (program && i == nb_streams - 1 && ret < 0) {
3439  program = NULL;
3440  nb_streams = ic->nb_streams;
3441  /* no related stream found, try again with everything */
3442  i = 0;
3443  }
3444  }
3445  if (decoder_ret)
3446  *decoder_ret = (AVCodec*)best_decoder;
3447  return ret;
3448 }
3449 
3450 /*******************************************************/
3451 
3453 {
3454  if (s->iformat->read_play)
3455  return s->iformat->read_play(s);
3456  if (s->pb)
3457  return avio_pause(s->pb, 0);
3458  return AVERROR(ENOSYS);
3459 }
3460 
3462 {
3463  if (s->iformat->read_pause)
3464  return s->iformat->read_pause(s);
3465  if (s->pb)
3466  return avio_pause(s->pb, 1);
3467  return AVERROR(ENOSYS);
3468 }
3469 
3471  int j;
3472  av_assert0(s->nb_streams>0);
3473  av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3474 
3475  for (j = 0; j < st->nb_side_data; j++)
3476  av_freep(&st->side_data[j].data);
3477  av_freep(&st->side_data);
3478  st->nb_side_data = 0;
3479 
3480  if (st->parser) {
3481  av_parser_close(st->parser);
3482  }
3483  if (st->attached_pic.data)
3485  av_dict_free(&st->metadata);
3486  av_freep(&st->probe_data.buf);
3487  av_freep(&st->index_entries);
3488  av_freep(&st->codec->extradata);
3490  av_freep(&st->codec);
3491  av_freep(&st->priv_data);
3492  if (st->info)
3493  av_freep(&st->info->duration_error);
3494  av_freep(&st->info);
3495  av_freep(&s->streams[ --s->nb_streams ]);
3496 }
3497 
3499 {
3500  int i;
3501 
3502  if (!s)
3503  return;
3504 
3505  av_opt_free(s);
3506  if (s->iformat && s->iformat->priv_class && s->priv_data)
3507  av_opt_free(s->priv_data);
3508  if (s->oformat && s->oformat->priv_class && s->priv_data)
3509  av_opt_free(s->priv_data);
3510 
3511  for (i = s->nb_streams - 1; i >= 0; i--) {
3512  ff_free_stream(s, s->streams[i]);
3513  }
3514  for (i = s->nb_programs - 1; i >= 0; i--) {
3515  av_dict_free(&s->programs[i]->metadata);
3516  av_freep(&s->programs[i]->stream_index);
3517  av_freep(&s->programs[i]);
3518  }
3519  av_freep(&s->programs);
3520  av_freep(&s->priv_data);
3521  while (s->nb_chapters--) {
3523  av_freep(&s->chapters[s->nb_chapters]);
3524  }
3525  av_freep(&s->chapters);
3526  av_dict_free(&s->metadata);
3527  av_freep(&s->streams);
3528  av_freep(&s->internal);
3529  flush_packet_queue(s);
3530  av_free(s);
3531 }
3532 
3533 #if FF_API_CLOSE_INPUT_FILE
3534 void av_close_input_file(AVFormatContext *s)
3535 {
3537 }
3538 #endif
3539 
3541 {
3542  AVFormatContext *s;
3543  AVIOContext *pb;
3544 
3545  if (!ps || !*ps)
3546  return;
3547 
3548  s = *ps;
3549  pb = s->pb;
3550 
3551  if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3552  (s->flags & AVFMT_FLAG_CUSTOM_IO))
3553  pb = NULL;
3554 
3555  flush_packet_queue(s);
3556 
3557  if (s->iformat)
3558  if (s->iformat->read_close)
3559  s->iformat->read_close(s);
3560 
3562 
3563  *ps = NULL;
3564 
3565  avio_close(pb);
3566 }
3567 
3568 #if FF_API_NEW_STREAM
3569 AVStream *av_new_stream(AVFormatContext *s, int id)
3570 {
3571  AVStream *st = avformat_new_stream(s, NULL);
3572  if (st)
3573  st->id = id;
3574  return st;
3575 }
3576 #endif
3577 
3579 {
3580  AVStream *st;
3581  int i;
3582  AVStream **streams;
3583 
3584  if (s->nb_streams >= INT_MAX/sizeof(*streams))
3585  return NULL;
3586  streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3587  if (!streams)
3588  return NULL;
3589  s->streams = streams;
3590 
3591  st = av_mallocz(sizeof(AVStream));
3592  if (!st)
3593  return NULL;
3594  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3595  av_free(st);
3596  return NULL;
3597  }
3598  st->info->last_dts = AV_NOPTS_VALUE;
3599 
3600  st->codec = avcodec_alloc_context3(c);
3601  if (s->iformat) {
3602  /* no default bitrate if decoding */
3603  st->codec->bit_rate = 0;
3604 
3605  /* default pts setting is MPEG-like */
3606  avpriv_set_pts_info(st, 33, 1, 90000);
3607  }
3608 
3609  st->index = s->nb_streams;
3610  st->start_time = AV_NOPTS_VALUE;
3611  st->duration = AV_NOPTS_VALUE;
3612  /* we set the current DTS to 0 so that formats without any timestamps
3613  * but durations get some timestamps, formats with some unknown
3614  * timestamps have their first few packets buffered and the
3615  * timestamps corrected before they are returned to the user */
3616  st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3617  st->first_dts = AV_NOPTS_VALUE;
3621 
3624  for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3625  st->pts_buffer[i] = AV_NOPTS_VALUE;
3626 
3627  st->sample_aspect_ratio = (AVRational) { 0, 1 };
3628 
3629 #if FF_API_R_FRAME_RATE
3630  st->info->last_dts = AV_NOPTS_VALUE;
3631 #endif
3634 
3636 
3637  s->streams[s->nb_streams++] = st;
3638  return st;
3639 }
3640 
3642 {
3643  AVProgram *program = NULL;
3644  int i;
3645 
3646  av_dlog(ac, "new_program: id=0x%04x\n", id);
3647 
3648  for (i = 0; i < ac->nb_programs; i++)
3649  if (ac->programs[i]->id == id)
3650  program = ac->programs[i];
3651 
3652  if (!program) {
3653  program = av_mallocz(sizeof(AVProgram));
3654  if (!program)
3655  return NULL;
3656  dynarray_add(&ac->programs, &ac->nb_programs, program);
3657  program->discard = AVDISCARD_NONE;
3658  }
3659  program->id = id;
3662 
3663  program->start_time =
3664  program->end_time = AV_NOPTS_VALUE;
3665 
3666  return program;
3667 }
3668 
3670  int64_t start, int64_t end, const char *title)
3671 {
3672  AVChapter *chapter = NULL;
3673  int i;
3674 
3675  if (end != AV_NOPTS_VALUE && start > end) {
3676  av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3677  return NULL;
3678  }
3679 
3680  for (i = 0; i < s->nb_chapters; i++)
3681  if (s->chapters[i]->id == id)
3682  chapter = s->chapters[i];
3683 
3684  if (!chapter) {
3685  chapter = av_mallocz(sizeof(AVChapter));
3686  if (!chapter)
3687  return NULL;
3688  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3689  }
3690  av_dict_set(&chapter->metadata, "title", title, 0);
3691  chapter->id = id;
3692  chapter->time_base = time_base;
3693  chapter->start = start;
3694  chapter->end = end;
3695 
3696  return chapter;
3697 }
3698 
3699 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3700 {
3701  int i, j;
3702  AVProgram *program = NULL;
3703  void *tmp;
3704 
3705  if (idx >= ac->nb_streams) {
3706  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3707  return;
3708  }
3709 
3710  for (i = 0; i < ac->nb_programs; i++) {
3711  if (ac->programs[i]->id != progid)
3712  continue;
3713  program = ac->programs[i];
3714  for (j = 0; j < program->nb_stream_indexes; j++)
3715  if (program->stream_index[j] == idx)
3716  return;
3717 
3718  tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3719  if (!tmp)
3720  return;
3721  program->stream_index = tmp;
3722  program->stream_index[program->nb_stream_indexes++] = idx;
3723  return;
3724  }
3725 }
3726 
3727 uint64_t ff_ntp_time(void)
3728 {
3729  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3730 }
3731 
3732 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3733 {
3734  const char *p;
3735  char *q, buf1[20], c;
3736  int nd, len, percentd_found;
3737 
3738  q = buf;
3739  p = path;
3740  percentd_found = 0;
3741  for (;;) {
3742  c = *p++;
3743  if (c == '\0')
3744  break;
3745  if (c == '%') {
3746  do {
3747  nd = 0;
3748  while (av_isdigit(*p))
3749  nd = nd * 10 + *p++ - '0';
3750  c = *p++;
3751  } while (av_isdigit(c));
3752 
3753  switch (c) {
3754  case '%':
3755  goto addchar;
3756  case 'd':
3757  if (percentd_found)
3758  goto fail;
3759  percentd_found = 1;
3760  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3761  len = strlen(buf1);
3762  if ((q - buf + len) > buf_size - 1)
3763  goto fail;
3764  memcpy(q, buf1, len);
3765  q += len;
3766  break;
3767  default:
3768  goto fail;
3769  }
3770  } else {
3771 addchar:
3772  if ((q - buf) < buf_size - 1)
3773  *q++ = c;
3774  }
3775  }
3776  if (!percentd_found)
3777  goto fail;
3778  *q = '\0';
3779  return 0;
3780 fail:
3781  *q = '\0';
3782  return -1;
3783 }
3784 
3785 void av_url_split(char *proto, int proto_size,
3786  char *authorization, int authorization_size,
3787  char *hostname, int hostname_size,
3788  int *port_ptr, char *path, int path_size, const char *url)
3789 {
3790  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3791 
3792  if (port_ptr)
3793  *port_ptr = -1;
3794  if (proto_size > 0)
3795  proto[0] = 0;
3796  if (authorization_size > 0)
3797  authorization[0] = 0;
3798  if (hostname_size > 0)
3799  hostname[0] = 0;
3800  if (path_size > 0)
3801  path[0] = 0;
3802 
3803  /* parse protocol */
3804  if ((p = strchr(url, ':'))) {
3805  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3806  p++; /* skip ':' */
3807  if (*p == '/')
3808  p++;
3809  if (*p == '/')
3810  p++;
3811  } else {
3812  /* no protocol means plain filename */
3813  av_strlcpy(path, url, path_size);
3814  return;
3815  }
3816 
3817  /* separate path from hostname */
3818  ls = strchr(p, '/');
3819  ls2 = strchr(p, '?');
3820  if (!ls)
3821  ls = ls2;
3822  else if (ls && ls2)
3823  ls = FFMIN(ls, ls2);
3824  if (ls)
3825  av_strlcpy(path, ls, path_size);
3826  else
3827  ls = &p[strlen(p)]; // XXX
3828 
3829  /* the rest is hostname, use that to parse auth/port */
3830  if (ls != p) {
3831  /* authorization (user[:pass]@hostname) */
3832  at2 = p;
3833  while ((at = strchr(p, '@')) && at < ls) {
3834  av_strlcpy(authorization, at2,
3835  FFMIN(authorization_size, at + 1 - at2));
3836  p = at + 1; /* skip '@' */
3837  }
3838 
3839  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3840  /* [host]:port */
3841  av_strlcpy(hostname, p + 1,
3842  FFMIN(hostname_size, brk - p));
3843  if (brk[1] == ':' && port_ptr)
3844  *port_ptr = atoi(brk + 2);
3845  } else if ((col = strchr(p, ':')) && col < ls) {
3846  av_strlcpy(hostname, p,
3847  FFMIN(col + 1 - p, hostname_size));
3848  if (port_ptr)
3849  *port_ptr = atoi(col + 1);
3850  } else
3851  av_strlcpy(hostname, p,
3852  FFMIN(ls + 1 - p, hostname_size));
3853  }
3854 }
3855 
3856 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3857 {
3858  int i;
3859  static const char hex_table_uc[16] = { '0', '1', '2', '3',
3860  '4', '5', '6', '7',
3861  '8', '9', 'A', 'B',
3862  'C', 'D', 'E', 'F' };
3863  static const char hex_table_lc[16] = { '0', '1', '2', '3',
3864  '4', '5', '6', '7',
3865  '8', '9', 'a', 'b',
3866  'c', 'd', 'e', 'f' };
3867  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3868 
3869  for (i = 0; i < s; i++) {
3870  buff[i * 2] = hex_table[src[i] >> 4];
3871  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3872  }
3873 
3874  return buff;
3875 }
3876 
3877 int ff_hex_to_data(uint8_t *data, const char *p)
3878 {
3879  int c, len, v;
3880 
3881  len = 0;
3882  v = 1;
3883  for (;;) {
3884  p += strspn(p, SPACE_CHARS);
3885  if (*p == '\0')
3886  break;
3887  c = av_toupper((unsigned char) *p++);
3888  if (c >= '0' && c <= '9')
3889  c = c - '0';
3890  else if (c >= 'A' && c <= 'F')
3891  c = c - 'A' + 10;
3892  else
3893  break;
3894  v = (v << 4) | c;
3895  if (v & 0x100) {
3896  if (data)
3897  data[len] = v;
3898  len++;
3899  v = 1;
3900  }
3901  }
3902  return len;
3903 }
3904 
3905 #if FF_API_SET_PTS_INFO
3906 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3907  unsigned int pts_num, unsigned int pts_den)
3908 {
3909  avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3910 }
3911 #endif
3912 
3913 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3914  unsigned int pts_num, unsigned int pts_den)
3915 {
3916  AVRational new_tb;
3917  if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3918  if (new_tb.num != pts_num)
3919  av_log(NULL, AV_LOG_DEBUG,
3920  "st:%d removing common factor %d from timebase\n",
3921  s->index, pts_num / new_tb.num);
3922  } else
3923  av_log(NULL, AV_LOG_WARNING,
3924  "st:%d has too large timebase, reducing\n", s->index);
3925 
3926  if (new_tb.num <= 0 || new_tb.den <= 0) {
3927  av_log(NULL, AV_LOG_ERROR,
3928  "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3929  new_tb.num, new_tb.den,
3930  s->index);
3931  return;
3932  }
3933  s->time_base = new_tb;
3934  av_codec_set_pkt_timebase(s->codec, new_tb);
3935  s->pts_wrap_bits = pts_wrap_bits;
3936 }
3937 
3938 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3939  void *context)
3940 {
3941  const char *ptr = str;
3942 
3943  /* Parse key=value pairs. */
3944  for (;;) {
3945  const char *key;
3946  char *dest = NULL, *dest_end;
3947  int key_len, dest_len = 0;
3948 
3949  /* Skip whitespace and potential commas. */
3950  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3951  ptr++;
3952  if (!*ptr)
3953  break;
3954 
3955  key = ptr;
3956 
3957  if (!(ptr = strchr(key, '=')))
3958  break;
3959  ptr++;
3960  key_len = ptr - key;
3961 
3962  callback_get_buf(context, key, key_len, &dest, &dest_len);
3963  dest_end = dest + dest_len - 1;
3964 
3965  if (*ptr == '\"') {
3966  ptr++;
3967  while (*ptr && *ptr != '\"') {
3968  if (*ptr == '\\') {
3969  if (!ptr[1])
3970  break;
3971  if (dest && dest < dest_end)
3972  *dest++ = ptr[1];
3973  ptr += 2;
3974  } else {
3975  if (dest && dest < dest_end)
3976  *dest++ = *ptr;
3977  ptr++;
3978  }
3979  }
3980  if (*ptr == '\"')
3981  ptr++;
3982  } else {
3983  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3984  if (dest && dest < dest_end)
3985  *dest++ = *ptr;
3986  }
3987  if (dest)
3988  *dest = 0;
3989  }
3990 }
3991 
3993 {
3994  int i;
3995  for (i = 0; i < s->nb_streams; i++)
3996  if (s->streams[i]->id == id)
3997  return i;
3998  return -1;
3999 }
4000 
4001 int64_t ff_iso8601_to_unix_time(const char *datestr)
4002 {
4003  struct tm time1 = { 0 }, time2 = { 0 };
4004  char *ret1, *ret2;
4005  ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4006  ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4007  if (ret2 && !ret1)
4008  return av_timegm(&time2);
4009  else
4010  return av_timegm(&time1);
4011 }
4012 
4014  int std_compliance)
4015 {
4016  if (ofmt) {
4017  if (ofmt->query_codec)
4018  return ofmt->query_codec(codec_id, std_compliance);
4019  else if (ofmt->codec_tag)
4020  return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4021  else if (codec_id == ofmt->video_codec ||
4022  codec_id == ofmt->audio_codec ||
4023  codec_id == ofmt->subtitle_codec)
4024  return 1;
4025  }
4026  return AVERROR_PATCHWELCOME;
4027 }
4028 
4030 {
4031 #if CONFIG_NETWORK
4032  int ret;
4034  if ((ret = ff_network_init()) < 0)
4035  return ret;
4036  ff_tls_init();
4037 #endif
4038  return 0;
4039 }
4040 
4042 {
4043 #if CONFIG_NETWORK
4044  ff_network_close();
4045  ff_tls_deinit();
4046 #endif
4047  return 0;
4048 }
4049 
4051  uint64_t channel_layout, int32_t sample_rate,
4053 {
4054  uint32_t flags = 0;
4055  int size = 4;
4056  uint8_t *data;
4057  if (!pkt)
4058  return AVERROR(EINVAL);
4059  if (channels) {
4060  size += 4;
4062  }
4063  if (channel_layout) {
4064  size += 8;
4066  }
4067  if (sample_rate) {
4068  size += 4;
4070  }
4071  if (width || height) {
4072  size += 8;
4074  }
4076  if (!data)
4077  return AVERROR(ENOMEM);
4078  bytestream_put_le32(&data, flags);
4079  if (channels)
4080  bytestream_put_le32(&data, channels);
4081  if (channel_layout)
4082  bytestream_put_le64(&data, channel_layout);
4083  if (sample_rate)
4084  bytestream_put_le32(&data, sample_rate);
4085  if (width || height) {
4086  bytestream_put_le32(&data, width);
4087  bytestream_put_le32(&data, height);
4088  }
4089  return 0;
4090 }
4091 
4093 {
4094  AVRational undef = {0, 1};
4095  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4096  AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4097  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4098 
4099  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4100  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4101  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4102  stream_sample_aspect_ratio = undef;
4103 
4104  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4105  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4106  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4107  frame_sample_aspect_ratio = undef;
4108 
4109  if (stream_sample_aspect_ratio.num)
4110  return stream_sample_aspect_ratio;
4111  else
4112  return frame_sample_aspect_ratio;
4113 }
4114 
4116 {
4117  AVRational fr = st->r_frame_rate;
4118  AVRational codec_fr = av_inv_q(st->codec->time_base);
4119  AVRational avg_fr = st->avg_frame_rate;
4120 
4121  if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4122  av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4123  fr = avg_fr;
4124  }
4125 
4126 
4127  if (st->codec->ticks_per_frame > 1) {
4128  codec_fr.den *= st->codec->ticks_per_frame;
4129  if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4130  && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4131  fr = codec_fr;
4132  }
4133 
4134  return fr;
4135 }
4136 
4138  const char *spec)
4139 {
4140  if (*spec <= '9' && *spec >= '0') /* opt:index */
4141  return strtol(spec, NULL, 0) == st->index;
4142  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4143  *spec == 't') { /* opt:[vasdt] */
4144  enum AVMediaType type;
4145 
4146  switch (*spec++) {
4147  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4148  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4149  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4150  case 'd': type = AVMEDIA_TYPE_DATA; break;
4151  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4152  default: av_assert0(0);
4153  }
4154  if (type != st->codec->codec_type)
4155  return 0;
4156  if (*spec++ == ':') { /* possibly followed by :index */
4157  int i, index = strtol(spec, NULL, 0);
4158  for (i = 0; i < s->nb_streams; i++)
4159  if (s->streams[i]->codec->codec_type == type && index-- == 0)
4160  return i == st->index;
4161  return 0;
4162  }
4163  return 1;
4164  } else if (*spec == 'p' && *(spec + 1) == ':') {
4165  int prog_id, i, j;
4166  char *endptr;
4167  spec += 2;
4168  prog_id = strtol(spec, &endptr, 0);
4169  for (i = 0; i < s->nb_programs; i++) {
4170  if (s->programs[i]->id != prog_id)
4171  continue;
4172 
4173  if (*endptr++ == ':') {
4174  int stream_idx = strtol(endptr, NULL, 0);
4175  return stream_idx >= 0 &&
4176  stream_idx < s->programs[i]->nb_stream_indexes &&
4177  st->index == s->programs[i]->stream_index[stream_idx];
4178  }
4179 
4180  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4181  if (st->index == s->programs[i]->stream_index[j])
4182  return 1;
4183  }
4184  return 0;
4185  } else if (*spec == '#' ||
4186  (*spec == 'i' && *(spec + 1) == ':')) {
4187  int stream_id;
4188  char *endptr;
4189  spec += 1 + (*spec == 'i');
4190  stream_id = strtol(spec, &endptr, 0);
4191  if (!*endptr)
4192  return stream_id == st->id;
4193  } else if (*spec == 'm' && *(spec + 1) == ':') {
4195  char *key, *val;
4196  int ret;
4197 
4198  spec += 2;
4199  val = strchr(spec, ':');
4200 
4201  key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4202  if (!key)
4203  return AVERROR(ENOMEM);
4204 
4205  tag = av_dict_get(st->metadata, key, NULL, 0);
4206  if (tag) {
4207  if (!val || !strcmp(tag->value, val + 1))
4208  ret = 1;
4209  else
4210  ret = 0;
4211  } else
4212  ret = 0;
4213 
4214  av_freep(&key);
4215  return ret;
4216  } else if (!*spec) /* empty specifier, matches everything */
4217  return 1;
4218 
4219  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4220  return AVERROR(EINVAL);
4221 }
4222 
4224 {
4225  static const uint8_t avci100_1080p_extradata[] = {
4226  // SPS
4227  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4228  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4229  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4230  0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4231  0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4232  0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4233  0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4234  0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4235  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4236  // PPS
4237  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4238  0xd0
4239  };
4240  static const uint8_t avci100_1080i_extradata[] = {
4241  // SPS
4242  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4243  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4244  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4245  0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4246  0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4247  0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4248  0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4249  0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4250  0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4251  0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4252  0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4253  // PPS
4254  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4255  0xd0
4256  };
4257  static const uint8_t avci50_1080i_extradata[] = {
4258  // SPS
4259  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4260  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4261  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4262  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4263  0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4264  0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4265  0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4266  0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4267  0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4268  0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4269  0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4270  // PPS
4271  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4272  0x11
4273  };
4274  static const uint8_t avci100_720p_extradata[] = {
4275  // SPS
4276  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4277  0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4278  0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4279  0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4280  0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4281  0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4282  0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4283  0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4284  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4285  0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4286  // PPS
4287  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4288  0x11
4289  };
4290 
4291  const uint8_t *data = NULL;
4292  int size = 0;
4293 
4294  if (st->codec->width == 1920) {
4295  if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4296  data = avci100_1080p_extradata;
4297  size = sizeof(avci100_1080p_extradata);
4298  } else {
4299  data = avci100_1080i_extradata;
4300  size = sizeof(avci100_1080i_extradata);
4301  }
4302  } else if (st->codec->width == 1440) {
4303  data = avci50_1080i_extradata;
4304  size = sizeof(avci50_1080i_extradata);
4305  } else if (st->codec->width == 1280) {
4306  data = avci100_720p_extradata;
4307  size = sizeof(avci100_720p_extradata);
4308  }
4309 
4310  if (!size)
4311  return 0;
4312 
4313  av_freep(&st->codec->extradata);
4314  if (ff_alloc_extradata(st->codec, size))
4315  return AVERROR(ENOMEM);
4316  memcpy(st->codec->extradata, data, size);
4317 
4318  return 0;
4319 }
4320 
4322  int *size)
4323 {
4324  int i;
4325 
4326  for (i = 0; i < st->nb_side_data; i++) {
4327  if (st->side_data[i].type == type) {
4328  if (size)
4329  *size = st->side_data[i].size;
4330  return st->side_data[i].data;
4331  }
4332  }
4333  return NULL;
4334 }