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