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