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