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