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