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