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