FFmpeg  1.2.12
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  } else if (st->reference_dts != AV_NOPTS_VALUE) {
1169  // compute DTS based on reference timestamp
1170  pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1171  }
1172 
1173  if (st->reference_dts != AV_NOPTS_VALUE && pkt->pts == AV_NOPTS_VALUE)
1174  pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1175 
1176  if (pc->dts_sync_point > 0)
1177  st->reference_dts = pkt->dts; // new reference
1178  }
1179  }
1180 
1181  /* This may be redundant, but it should not hurt. */
1182  if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1183  presentation_delayed = 1;
1184 
1185  av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1186  presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1187  /* interpolate PTS and DTS if they are not present */
1188  //We skip H264 currently because delay and has_b_frames are not reliably set
1189  if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1190  if (presentation_delayed) {
1191  /* DTS = decompression timestamp */
1192  /* PTS = presentation timestamp */
1193  if (pkt->dts == AV_NOPTS_VALUE)
1194  pkt->dts = st->last_IP_pts;
1195  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1196  if (pkt->dts == AV_NOPTS_VALUE)
1197  pkt->dts = st->cur_dts;
1198 
1199  /* this is tricky: the dts must be incremented by the duration
1200  of the frame we are displaying, i.e. the last I- or P-frame */
1201  if (st->last_IP_duration == 0)
1202  st->last_IP_duration = pkt->duration;
1203  if(pkt->dts != AV_NOPTS_VALUE)
1204  st->cur_dts = pkt->dts + st->last_IP_duration;
1205  st->last_IP_duration = pkt->duration;
1206  st->last_IP_pts= pkt->pts;
1207  /* cannot compute PTS if not present (we can compute it only
1208  by knowing the future */
1209  } else if (pkt->pts != AV_NOPTS_VALUE ||
1210  pkt->dts != AV_NOPTS_VALUE ||
1211  pkt->duration ) {
1212  int duration = pkt->duration;
1213 
1214  /* presentation is not delayed : PTS and DTS are the same */
1215  if (pkt->pts == AV_NOPTS_VALUE)
1216  pkt->pts = pkt->dts;
1218  pkt->pts, pkt);
1219  if (pkt->pts == AV_NOPTS_VALUE)
1220  pkt->pts = st->cur_dts;
1221  pkt->dts = pkt->pts;
1222  if (pkt->pts != AV_NOPTS_VALUE)
1223  st->cur_dts = pkt->pts + duration;
1224  }
1225  }
1226 
1227  if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1228  st->pts_buffer[0]= pkt->pts;
1229  for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1230  FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1231  if(pkt->dts == AV_NOPTS_VALUE)
1232  pkt->dts= st->pts_buffer[0];
1233  }
1234  if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1235  update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1236  }
1237  if(pkt->dts > st->cur_dts)
1238  st->cur_dts = pkt->dts;
1239 
1240  av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1241  presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1242 
1243  /* update flags */
1244  if (is_intra_only(st->codec))
1245  pkt->flags |= AV_PKT_FLAG_KEY;
1246  if (pc)
1248 }
1249 
1250 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1251 {
1252  while (*pkt_buf) {
1253  AVPacketList *pktl = *pkt_buf;
1254  *pkt_buf = pktl->next;
1255  av_free_packet(&pktl->pkt);
1256  av_freep(&pktl);
1257  }
1258  *pkt_buf_end = NULL;
1259 }
1260 
1266 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1267 {
1268  AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1269  AVStream *st = s->streams[stream_index];
1270  uint8_t *data = pkt ? pkt->data : NULL;
1271  int size = pkt ? pkt->size : 0;
1272  int ret = 0, got_output = 0;
1273 
1274  if (!pkt) {
1276  pkt = &flush_pkt;
1277  got_output = 1;
1278  } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1279  // preserve 0-size sync packets
1280  compute_pkt_fields(s, st, st->parser, pkt);
1281  }
1282 
1283  while (size > 0 || (pkt == &flush_pkt && got_output)) {
1284  int len;
1285 
1286  av_init_packet(&out_pkt);
1287  len = av_parser_parse2(st->parser, st->codec,
1288  &out_pkt.data, &out_pkt.size, data, size,
1289  pkt->pts, pkt->dts, pkt->pos);
1290 
1291  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1292  pkt->pos = -1;
1293  /* increment read pointer */
1294  data += len;
1295  size -= len;
1296 
1297  got_output = !!out_pkt.size;
1298 
1299  if (!out_pkt.size)
1300  continue;
1301 
1302  /* set the duration */
1303  out_pkt.duration = 0;
1304  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1305  if (st->codec->sample_rate > 0) {
1306  out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1307  (AVRational){ 1, st->codec->sample_rate },
1308  st->time_base,
1309  AV_ROUND_DOWN);
1310  }
1311  } else if (st->codec->time_base.num != 0 &&
1312  st->codec->time_base.den != 0) {
1313  out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1314  st->codec->time_base,
1315  st->time_base,
1316  AV_ROUND_DOWN);
1317  }
1318 
1319  out_pkt.stream_index = st->index;
1320  out_pkt.pts = st->parser->pts;
1321  out_pkt.dts = st->parser->dts;
1322  out_pkt.pos = st->parser->pos;
1323 
1325  out_pkt.pos = st->parser->frame_offset;
1326 
1327  if (st->parser->key_frame == 1 ||
1328  (st->parser->key_frame == -1 &&
1330  out_pkt.flags |= AV_PKT_FLAG_KEY;
1331 
1332  if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1333  out_pkt.flags |= AV_PKT_FLAG_KEY;
1334 
1335  compute_pkt_fields(s, st, st->parser, &out_pkt);
1336 
1337  if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1338  out_pkt.destruct = pkt->destruct;
1339  pkt->destruct = NULL;
1340  }
1341  if ((ret = av_dup_packet(&out_pkt)) < 0)
1342  goto fail;
1343 
1344  if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1345  av_free_packet(&out_pkt);
1346  ret = AVERROR(ENOMEM);
1347  goto fail;
1348  }
1349  }
1350 
1351 
1352  /* end of the stream => close and free the parser */
1353  if (pkt == &flush_pkt) {
1354  av_parser_close(st->parser);
1355  st->parser = NULL;
1356  }
1357 
1358 fail:
1360  return ret;
1361 }
1362 
1363 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1364  AVPacketList **pkt_buffer_end,
1365  AVPacket *pkt)
1366 {
1367  AVPacketList *pktl;
1368  av_assert0(*pkt_buffer);
1369  pktl = *pkt_buffer;
1370  *pkt = pktl->pkt;
1371  *pkt_buffer = pktl->next;
1372  if (!pktl->next)
1373  *pkt_buffer_end = NULL;
1374  av_freep(&pktl);
1375  return 0;
1376 }
1377 
1379 {
1380  int ret = 0, i, got_packet = 0;
1381 
1382  av_init_packet(pkt);
1383 
1384  while (!got_packet && !s->parse_queue) {
1385  AVStream *st;
1386  AVPacket cur_pkt;
1387 
1388  /* read next packet */
1389  ret = ff_read_packet(s, &cur_pkt);
1390  if (ret < 0) {
1391  if (ret == AVERROR(EAGAIN))
1392  return ret;
1393  /* flush the parsers */
1394  for(i = 0; i < s->nb_streams; i++) {
1395  st = s->streams[i];
1396  if (st->parser && st->need_parsing)
1397  parse_packet(s, NULL, st->index);
1398  }
1399  /* all remaining packets are now in parse_queue =>
1400  * really terminate parsing */
1401  break;
1402  }
1403  ret = 0;
1404  st = s->streams[cur_pkt.stream_index];
1405 
1406  if (cur_pkt.pts != AV_NOPTS_VALUE &&
1407  cur_pkt.dts != AV_NOPTS_VALUE &&
1408  cur_pkt.pts < cur_pkt.dts) {
1409  av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1410  cur_pkt.stream_index,
1411  av_ts2str(cur_pkt.pts),
1412  av_ts2str(cur_pkt.dts),
1413  cur_pkt.size);
1414  }
1415  if (s->debug & FF_FDEBUG_TS)
1416  av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1417  cur_pkt.stream_index,
1418  av_ts2str(cur_pkt.pts),
1419  av_ts2str(cur_pkt.dts),
1420  cur_pkt.size,
1421  cur_pkt.duration,
1422  cur_pkt.flags);
1423 
1424  if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1425  st->parser = av_parser_init(st->codec->codec_id);
1426  if (!st->parser) {
1427  av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1428  "%s, packets or times may be invalid.\n",
1430  /* no parser available: just output the raw packets */
1432  } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1434  } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1435  st->parser->flags |= PARSER_FLAG_ONCE;
1436  } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1438  }
1439  }
1440 
1441  if (!st->need_parsing || !st->parser) {
1442  /* no parsing needed: we just output the packet as is */
1443  *pkt = cur_pkt;
1444  compute_pkt_fields(s, st, NULL, pkt);
1445  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1446  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1447  ff_reduce_index(s, st->index);
1448  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1449  }
1450  got_packet = 1;
1451  } else if (st->discard < AVDISCARD_ALL) {
1452  if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1453  return ret;
1454  } else {
1455  /* free packet */
1456  av_free_packet(&cur_pkt);
1457  }
1458  if (pkt->flags & AV_PKT_FLAG_KEY)
1459  st->skip_to_keyframe = 0;
1460  if (st->skip_to_keyframe) {
1461  av_free_packet(&cur_pkt);
1462  if (got_packet) {
1463  *pkt = cur_pkt;
1464  }
1465  got_packet = 0;
1466  }
1467  }
1468 
1469  if (!got_packet && s->parse_queue)
1471 
1472  if(s->debug & FF_FDEBUG_TS)
1473  av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1474  pkt->stream_index,
1475  av_ts2str(pkt->pts),
1476  av_ts2str(pkt->dts),
1477  pkt->size,
1478  pkt->duration,
1479  pkt->flags);
1480 
1481  return ret;
1482 }
1483 
1485 {
1486  const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1487  int eof = 0;
1488  int ret;
1489  AVStream *st;
1490 
1491  if (!genpts) {
1492  ret = s->packet_buffer ?
1494  read_frame_internal(s, pkt);
1495  if (ret < 0)
1496  return ret;
1497  goto return_packet;
1498  }
1499 
1500  for (;;) {
1501  AVPacketList *pktl = s->packet_buffer;
1502 
1503  if (pktl) {
1504  AVPacket *next_pkt = &pktl->pkt;
1505 
1506  if (next_pkt->dts != AV_NOPTS_VALUE) {
1507  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1508  // last dts seen for this stream. if any of packets following
1509  // current one had no dts, we will set this to AV_NOPTS_VALUE.
1510  int64_t last_dts = next_pkt->dts;
1511  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1512  if (pktl->pkt.stream_index == next_pkt->stream_index &&
1513  (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1514  if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1515  next_pkt->pts = pktl->pkt.dts;
1516  }
1517  if (last_dts != AV_NOPTS_VALUE) {
1518  // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1519  last_dts = pktl->pkt.dts;
1520  }
1521  }
1522  pktl = pktl->next;
1523  }
1524  if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1525  // Fixing the last reference frame had none pts issue (For MXF etc).
1526  // We only do this when
1527  // 1. eof.
1528  // 2. we are not able to resolve a pts value for current packet.
1529  // 3. the packets for this stream at the end of the files had valid dts.
1530  next_pkt->pts = last_dts + next_pkt->duration;
1531  }
1532  pktl = s->packet_buffer;
1533  }
1534 
1535  /* read packet from packet buffer, if there is data */
1536  st = s->streams[next_pkt->stream_index];
1537  if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1538  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1540  &s->packet_buffer_end, pkt);
1541  goto return_packet;
1542  }
1543  }
1544 
1545  ret = read_frame_internal(s, pkt);
1546  if (ret < 0) {
1547  if (pktl && ret != AVERROR(EAGAIN)) {
1548  eof = 1;
1549  continue;
1550  } else
1551  return ret;
1552  }
1553 
1555  &s->packet_buffer_end)) < 0)
1556  return AVERROR(ENOMEM);
1557  }
1558 
1559 return_packet:
1560 
1561  st = s->streams[pkt->stream_index];
1562  if (st->skip_samples) {
1564  AV_WL32(p, st->skip_samples);
1565  av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1566  st->skip_samples = 0;
1567  }
1568 
1569  if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1570  ff_reduce_index(s, st->index);
1571  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1572  }
1573 
1574  if (is_relative(pkt->dts))
1575  pkt->dts -= RELATIVE_TS_BASE;
1576  if (is_relative(pkt->pts))
1577  pkt->pts -= RELATIVE_TS_BASE;
1578 
1579  return ret;
1580 }
1581 
1582 /* XXX: suppress the packet queue */
1584 {
1588 
1590 }
1591 
1592 /*******************************************************/
1593 /* seek support */
1594 
1596 {
1597  int first_audio_index = -1;
1598  int i;
1599  AVStream *st;
1600 
1601  if (s->nb_streams <= 0)
1602  return -1;
1603  for(i = 0; i < s->nb_streams; i++) {
1604  st = s->streams[i];
1605  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1607  return i;
1608  }
1609  if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1610  first_audio_index = i;
1611  }
1612  return first_audio_index >= 0 ? first_audio_index : 0;
1613 }
1614 
1619 {
1620  AVStream *st;
1621  int i, j;
1622 
1623  flush_packet_queue(s);
1624 
1625  /* for each stream, reset read state */
1626  for(i = 0; i < s->nb_streams; i++) {
1627  st = s->streams[i];
1628 
1629  if (st->parser) {
1630  av_parser_close(st->parser);
1631  st->parser = NULL;
1632  }
1635  else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1637 
1639 
1640  for(j=0; j<MAX_REORDER_DELAY+1; j++)
1641  st->pts_buffer[j]= AV_NOPTS_VALUE;
1642  }
1643 }
1644 
1645 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1646 {
1647  int i;
1648 
1649  for(i = 0; i < s->nb_streams; i++) {
1650  AVStream *st = s->streams[i];
1651 
1652  st->cur_dts = av_rescale(timestamp,
1653  st->time_base.den * (int64_t)ref_st->time_base.num,
1654  st->time_base.num * (int64_t)ref_st->time_base.den);
1655  }
1656 }
1657 
1658 void ff_reduce_index(AVFormatContext *s, int stream_index)
1659 {
1660  AVStream *st= s->streams[stream_index];
1661  unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1662 
1663  if((unsigned)st->nb_index_entries >= max_entries){
1664  int i;
1665  for(i=0; 2*i<st->nb_index_entries; i++)
1666  st->index_entries[i]= st->index_entries[2*i];
1667  st->nb_index_entries= i;
1668  }
1669 }
1670 
1671 int ff_add_index_entry(AVIndexEntry **index_entries,
1672  int *nb_index_entries,
1673  unsigned int *index_entries_allocated_size,
1674  int64_t pos, int64_t timestamp, int size, int distance, int flags)
1675 {
1676  AVIndexEntry *entries, *ie;
1677  int index;
1678 
1679  if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1680  return -1;
1681 
1682  if(timestamp == AV_NOPTS_VALUE)
1683  return AVERROR(EINVAL);
1684 
1685  if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1686  timestamp -= RELATIVE_TS_BASE;
1687 
1688  entries = av_fast_realloc(*index_entries,
1689  index_entries_allocated_size,
1690  (*nb_index_entries + 1) *
1691  sizeof(AVIndexEntry));
1692  if(!entries)
1693  return -1;
1694 
1695  *index_entries= entries;
1696 
1697  index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1698 
1699  if(index<0){
1700  index= (*nb_index_entries)++;
1701  ie= &entries[index];
1702  assert(index==0 || ie[-1].timestamp < timestamp);
1703  }else{
1704  ie= &entries[index];
1705  if(ie->timestamp != timestamp){
1706  if(ie->timestamp <= timestamp)
1707  return -1;
1708  memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1709  (*nb_index_entries)++;
1710  }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1711  distance= ie->min_distance;
1712  }
1713 
1714  ie->pos = pos;
1715  ie->timestamp = timestamp;
1716  ie->min_distance= distance;
1717  ie->size= size;
1718  ie->flags = flags;
1719 
1720  return index;
1721 }
1722 
1724  int64_t pos, int64_t timestamp, int size, int distance, int flags)
1725 {
1726  timestamp = wrap_timestamp(st, timestamp);
1728  &st->index_entries_allocated_size, pos,
1729  timestamp, size, distance, flags);
1730 }
1731 
1732 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1733  int64_t wanted_timestamp, int flags)
1734 {
1735  int a, b, m;
1736  int64_t timestamp;
1737 
1738  a = - 1;
1739  b = nb_entries;
1740 
1741  //optimize appending index entries at the end
1742  if(b && entries[b-1].timestamp < wanted_timestamp)
1743  a= b-1;
1744 
1745  while (b - a > 1) {
1746  m = (a + b) >> 1;
1747  timestamp = entries[m].timestamp;
1748  if(timestamp >= wanted_timestamp)
1749  b = m;
1750  if(timestamp <= wanted_timestamp)
1751  a = m;
1752  }
1753  m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1754 
1755  if(!(flags & AVSEEK_FLAG_ANY)){
1756  while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1757  m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1758  }
1759  }
1760 
1761  if(m == nb_entries)
1762  return -1;
1763  return m;
1764 }
1765 
1766 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1767  int flags)
1768 {
1770  wanted_timestamp, flags);
1771 }
1772 
1773 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1774  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1775 {
1776  int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1777  if (stream_index >= 0)
1778  ts = wrap_timestamp(s->streams[stream_index], ts);
1779  return ts;
1780 }
1781 
1782 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1783 {
1784  AVInputFormat *avif= s->iformat;
1785  int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1786  int64_t ts_min, ts_max, ts;
1787  int index;
1788  int64_t ret;
1789  AVStream *st;
1790 
1791  if (stream_index < 0)
1792  return -1;
1793 
1794  av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1795 
1796  ts_max=
1797  ts_min= AV_NOPTS_VALUE;
1798  pos_limit= -1; //gcc falsely says it may be uninitialized
1799 
1800  st= s->streams[stream_index];
1801  if(st->index_entries){
1802  AVIndexEntry *e;
1803 
1804  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()
1805  index= FFMAX(index, 0);
1806  e= &st->index_entries[index];
1807 
1808  if(e->timestamp <= target_ts || e->pos == e->min_distance){
1809  pos_min= e->pos;
1810  ts_min= e->timestamp;
1811  av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1812  pos_min, av_ts2str(ts_min));
1813  }else{
1814  assert(index==0);
1815  }
1816 
1817  index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1818  assert(index < st->nb_index_entries);
1819  if(index >= 0){
1820  e= &st->index_entries[index];
1821  assert(e->timestamp >= target_ts);
1822  pos_max= e->pos;
1823  ts_max= e->timestamp;
1824  pos_limit= pos_max - e->min_distance;
1825  av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1826  pos_max, pos_limit, av_ts2str(ts_max));
1827  }
1828  }
1829 
1830  pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1831  if(pos<0)
1832  return -1;
1833 
1834  /* do the seek */
1835  if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1836  return ret;
1837 
1839  ff_update_cur_dts(s, st, ts);
1840 
1841  return 0;
1842 }
1843 
1844 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1845  int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1846  int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1847  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1848 {
1849  int64_t pos, ts;
1850  int64_t start_pos, filesize;
1851  int no_change;
1852 
1853  av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1854 
1855  if(ts_min == AV_NOPTS_VALUE){
1856  pos_min = s->data_offset;
1857  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1858  if (ts_min == AV_NOPTS_VALUE)
1859  return -1;
1860  }
1861 
1862  if(ts_min >= target_ts){
1863  *ts_ret= ts_min;
1864  return pos_min;
1865  }
1866 
1867  if(ts_max == AV_NOPTS_VALUE){
1868  int64_t step= 1024;
1869  int64_t limit;
1870  filesize = avio_size(s->pb);
1871  pos_max = filesize - 1;
1872  do{
1873  limit = pos_max;
1874  pos_max = FFMAX(0, pos_max - step);
1875  ts_max = ff_read_timestamp(s, stream_index, &pos_max, limit, read_timestamp);
1876  step += step;
1877  }while(ts_max == AV_NOPTS_VALUE && 2*limit > step);
1878  if (ts_max == AV_NOPTS_VALUE)
1879  return -1;
1880 
1881  for(;;){
1882  int64_t tmp_pos= pos_max + 1;
1883  int64_t tmp_ts= ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1884  if(tmp_ts == AV_NOPTS_VALUE)
1885  break;
1886  ts_max= tmp_ts;
1887  pos_max= tmp_pos;
1888  if(tmp_pos >= filesize)
1889  break;
1890  }
1891  pos_limit= pos_max;
1892  }
1893 
1894  if(ts_max <= target_ts){
1895  *ts_ret= ts_max;
1896  return pos_max;
1897  }
1898 
1899  if(ts_min > ts_max){
1900  return -1;
1901  }else if(ts_min == ts_max){
1902  pos_limit= pos_min;
1903  }
1904 
1905  no_change=0;
1906  while (pos_min < pos_limit) {
1907  av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1908  pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1909  assert(pos_limit <= pos_max);
1910 
1911  if(no_change==0){
1912  int64_t approximate_keyframe_distance= pos_max - pos_limit;
1913  // interpolate position (better than dichotomy)
1914  pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1915  + pos_min - approximate_keyframe_distance;
1916  }else if(no_change==1){
1917  // bisection, if interpolation failed to change min or max pos last time
1918  pos = (pos_min + pos_limit)>>1;
1919  }else{
1920  /* linear search if bisection failed, can only happen if there
1921  are very few or no keyframes between min/max */
1922  pos=pos_min;
1923  }
1924  if(pos <= pos_min)
1925  pos= pos_min + 1;
1926  else if(pos > pos_limit)
1927  pos= pos_limit;
1928  start_pos= pos;
1929 
1930  ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1931  if(pos == pos_max)
1932  no_change++;
1933  else
1934  no_change=0;
1935  av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1936  pos_min, pos, pos_max,
1937  av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1938  pos_limit, start_pos, no_change);
1939  if(ts == AV_NOPTS_VALUE){
1940  av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1941  return -1;
1942  }
1943  assert(ts != AV_NOPTS_VALUE);
1944  if (target_ts <= ts) {
1945  pos_limit = start_pos - 1;
1946  pos_max = pos;
1947  ts_max = ts;
1948  }
1949  if (target_ts >= ts) {
1950  pos_min = pos;
1951  ts_min = ts;
1952  }
1953  }
1954 
1955  pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1956  ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1957 #if 0
1958  pos_min = pos;
1959  ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1960  pos_min++;
1961  ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1962  av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1963  pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1964 #endif
1965  *ts_ret= ts;
1966  return pos;
1967 }
1968 
1969 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1970  int64_t pos_min, pos_max;
1971 
1972  pos_min = s->data_offset;
1973  pos_max = avio_size(s->pb) - 1;
1974 
1975  if (pos < pos_min) pos= pos_min;
1976  else if(pos > pos_max) pos= pos_max;
1977 
1978  avio_seek(s->pb, pos, SEEK_SET);
1979 
1980  return 0;
1981 }
1982 
1984  int stream_index, int64_t timestamp, int flags)
1985 {
1986  int index;
1987  int64_t ret;
1988  AVStream *st;
1989  AVIndexEntry *ie;
1990 
1991  st = s->streams[stream_index];
1992 
1993  index = av_index_search_timestamp(st, timestamp, flags);
1994 
1995  if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1996  return -1;
1997 
1998  if(index < 0 || index==st->nb_index_entries-1){
1999  AVPacket pkt;
2000  int nonkey=0;
2001 
2002  if(st->nb_index_entries){
2003  assert(st->index_entries);
2004  ie= &st->index_entries[st->nb_index_entries-1];
2005  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2006  return ret;
2007  ff_update_cur_dts(s, st, ie->timestamp);
2008  }else{
2009  if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2010  return ret;
2011  }
2012  for (;;) {
2013  int read_status;
2014  do{
2015  read_status = av_read_frame(s, &pkt);
2016  } while (read_status == AVERROR(EAGAIN));
2017  if (read_status < 0)
2018  break;
2019  av_free_packet(&pkt);
2020  if(stream_index == pkt.stream_index && pkt.dts > timestamp){
2021  if(pkt.flags & AV_PKT_FLAG_KEY)
2022  break;
2023  if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
2024  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);
2025  break;
2026  }
2027  }
2028  }
2029  index = av_index_search_timestamp(st, timestamp, flags);
2030  }
2031  if (index < 0)
2032  return -1;
2033 
2035  if (s->iformat->read_seek){
2036  if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2037  return 0;
2038  }
2039  ie = &st->index_entries[index];
2040  if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2041  return ret;
2042  ff_update_cur_dts(s, st, ie->timestamp);
2043 
2044  return 0;
2045 }
2046 
2047 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2048  int64_t timestamp, int flags)
2049 {
2050  int ret;
2051  AVStream *st;
2052 
2053  if (flags & AVSEEK_FLAG_BYTE) {
2054  if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2055  return -1;
2057  return seek_frame_byte(s, stream_index, timestamp, flags);
2058  }
2059 
2060  if(stream_index < 0){
2061  stream_index= av_find_default_stream_index(s);
2062  if(stream_index < 0)
2063  return -1;
2064 
2065  st= s->streams[stream_index];
2066  /* timestamp for default must be expressed in AV_TIME_BASE units */
2067  timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2068  }
2069 
2070  /* first, we try the format specific seek */
2071  if (s->iformat->read_seek) {
2073  ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2074  } else
2075  ret = -1;
2076  if (ret >= 0) {
2077  return 0;
2078  }
2079 
2080  if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2082  return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2083  } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2085  return seek_frame_generic(s, stream_index, timestamp, flags);
2086  }
2087  else
2088  return -1;
2089 }
2090 
2091 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2092 {
2093  int ret = seek_frame_internal(s, stream_index, timestamp, flags);
2094 
2095  if (ret >= 0)
2097 
2098  return ret;
2099 }
2100 
2101 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2102 {
2103  if(min_ts > ts || max_ts < ts)
2104  return -1;
2105 
2106  if(s->seek2any>0)
2107  flags |= AVSEEK_FLAG_ANY;
2108 
2109  if (s->iformat->read_seek2) {
2110  int ret;
2112 
2113  if (stream_index == -1 && s->nb_streams == 1) {
2114  AVRational time_base = s->streams[0]->time_base;
2115  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2116  min_ts = av_rescale_rnd(min_ts, time_base.den,
2117  time_base.num * (int64_t)AV_TIME_BASE,
2119  max_ts = av_rescale_rnd(max_ts, time_base.den,
2120  time_base.num * (int64_t)AV_TIME_BASE,
2122  }
2123 
2124  ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2125 
2126  if (ret >= 0)
2128  return ret;
2129  }
2130 
2131  if(s->iformat->read_timestamp){
2132  //try to seek via read_timestamp()
2133  }
2134 
2135  //Fallback to old API if new is not implemented but old is
2136  //Note the old has somewhat different semantics
2137  if (s->iformat->read_seek || 1) {
2138  int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2139  int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2140  if (ret<0 && ts != min_ts && max_ts != ts) {
2141  ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2142  if (ret >= 0)
2143  ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2144  }
2145  return ret;
2146  }
2147 
2148  // try some generic seek like seek_frame_generic() but with new ts semantics
2149  return -1; //unreachable
2150 }
2151 
2152 /*******************************************************/
2153 
2160 {
2161  int i;
2162  AVStream *st;
2163 
2164  for(i = 0;i < ic->nb_streams; i++) {
2165  st = ic->streams[i];
2166  if (st->duration != AV_NOPTS_VALUE)
2167  return 1;
2168  }
2169  if (ic->duration != AV_NOPTS_VALUE)
2170  return 1;
2171  return 0;
2172 }
2173 
2180 {
2181  int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2182  int64_t duration, duration1, filesize;
2183  int i;
2184  AVStream *st;
2185  AVProgram *p;
2186 
2187  start_time = INT64_MAX;
2188  start_time_text = INT64_MAX;
2189  end_time = INT64_MIN;
2190  duration = INT64_MIN;
2191  for(i = 0;i < ic->nb_streams; i++) {
2192  st = ic->streams[i];
2193  if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2194  start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2196  if (start_time1 < start_time_text)
2197  start_time_text = start_time1;
2198  } else
2199  start_time = FFMIN(start_time, start_time1);
2200  end_time1 = AV_NOPTS_VALUE;
2201  if (st->duration != AV_NOPTS_VALUE) {
2202  end_time1 = start_time1
2204  end_time = FFMAX(end_time, end_time1);
2205  }
2206  for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2207  if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2208  p->start_time = start_time1;
2209  if(p->end_time < end_time1)
2210  p->end_time = end_time1;
2211  }
2212  }
2213  if (st->duration != AV_NOPTS_VALUE) {
2214  duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2215  duration = FFMAX(duration, duration1);
2216  }
2217  }
2218  if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2219  start_time = start_time_text;
2220  else if(start_time > start_time_text)
2221  av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2222 
2223  if (start_time != INT64_MAX) {
2224  ic->start_time = start_time;
2225  if (end_time != INT64_MIN) {
2226  if (ic->nb_programs) {
2227  for (i=0; i<ic->nb_programs; i++) {
2228  p = ic->programs[i];
2229  if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2230  duration = FFMAX(duration, p->end_time - p->start_time);
2231  }
2232  } else
2233  duration = FFMAX(duration, end_time - start_time);
2234  }
2235  }
2236  if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2237  ic->duration = duration;
2238  }
2239  if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2240  /* compute the bitrate */
2241  double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2242  (double)ic->duration;
2243  if (bitrate >= 0 && bitrate <= INT_MAX)
2244  ic->bit_rate = bitrate;
2245  }
2246 }
2247 
2249 {
2250  int i;
2251  AVStream *st;
2252 
2254  for(i = 0;i < ic->nb_streams; i++) {
2255  st = ic->streams[i];
2256  if (st->start_time == AV_NOPTS_VALUE) {
2257  if(ic->start_time != AV_NOPTS_VALUE)
2259  if(ic->duration != AV_NOPTS_VALUE)
2261  }
2262  }
2263 }
2264 
2266 {
2267  int64_t filesize, duration;
2268  int bit_rate, i;
2269  AVStream *st;
2270 
2271  /* if bit_rate is already set, we believe it */
2272  if (ic->bit_rate <= 0) {
2273  bit_rate = 0;
2274  for(i=0;i<ic->nb_streams;i++) {
2275  st = ic->streams[i];
2276  if (st->codec->bit_rate > 0)
2277  bit_rate += st->codec->bit_rate;
2278  }
2279  ic->bit_rate = bit_rate;
2280  }
2281 
2282  /* if duration is already set, we believe it */
2283  if (ic->duration == AV_NOPTS_VALUE &&
2284  ic->bit_rate != 0) {
2285  filesize = ic->pb ? avio_size(ic->pb) : 0;
2286  if (filesize > 0) {
2287  for(i = 0; i < ic->nb_streams; i++) {
2288  st = ic->streams[i];
2289  duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2290  if (st->duration == AV_NOPTS_VALUE)
2291  st->duration = duration;
2292  }
2293  }
2294  }
2295 }
2296 
2297 #define DURATION_MAX_READ_SIZE 250000LL
2298 #define DURATION_MAX_RETRY 4
2299 
2300 /* only usable for MPEG-PS streams */
2301 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2302 {
2303  AVPacket pkt1, *pkt = &pkt1;
2304  AVStream *st;
2305  int read_size, i, ret;
2306  int64_t end_time;
2307  int64_t filesize, offset, duration;
2308  int retry=0;
2309 
2310  /* flush packet queue */
2311  flush_packet_queue(ic);
2312 
2313  for (i=0; i<ic->nb_streams; i++) {
2314  st = ic->streams[i];
2315  if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2316  av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2317 
2318  if (st->parser) {
2319  av_parser_close(st->parser);
2320  st->parser= NULL;
2321  }
2322  }
2323 
2324  /* estimate the end time (duration) */
2325  /* XXX: may need to support wrapping */
2326  filesize = ic->pb ? avio_size(ic->pb) : 0;
2327  end_time = AV_NOPTS_VALUE;
2328  do{
2329  offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2330  if (offset < 0)
2331  offset = 0;
2332 
2333  avio_seek(ic->pb, offset, SEEK_SET);
2334  read_size = 0;
2335  for(;;) {
2336  if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2337  break;
2338 
2339  do {
2340  ret = ff_read_packet(ic, pkt);
2341  } while(ret == AVERROR(EAGAIN));
2342  if (ret != 0)
2343  break;
2344  read_size += pkt->size;
2345  st = ic->streams[pkt->stream_index];
2346  if (pkt->pts != AV_NOPTS_VALUE &&
2347  (st->start_time != AV_NOPTS_VALUE ||
2348  st->first_dts != AV_NOPTS_VALUE)) {
2349  duration = end_time = pkt->pts;
2350  if (st->start_time != AV_NOPTS_VALUE)
2351  duration -= st->start_time;
2352  else
2353  duration -= st->first_dts;
2354  if (duration > 0) {
2355  if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2356  (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2357  st->duration = duration;
2358  st->info->last_duration = duration;
2359  }
2360  }
2361  av_free_packet(pkt);
2362  }
2363  }while( end_time==AV_NOPTS_VALUE
2364  && filesize > (DURATION_MAX_READ_SIZE<<retry)
2365  && ++retry <= DURATION_MAX_RETRY);
2366 
2368 
2369  avio_seek(ic->pb, old_offset, SEEK_SET);
2370  for (i=0; i<ic->nb_streams; i++) {
2371  st= ic->streams[i];
2372  st->cur_dts= st->first_dts;
2375  }
2376 }
2377 
2378 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2379 {
2380  int64_t file_size;
2381 
2382  /* get the file size, if possible */
2383  if (ic->iformat->flags & AVFMT_NOFILE) {
2384  file_size = 0;
2385  } else {
2386  file_size = avio_size(ic->pb);
2387  file_size = FFMAX(0, file_size);
2388  }
2389 
2390  if ((!strcmp(ic->iformat->name, "mpeg") ||
2391  !strcmp(ic->iformat->name, "mpegts")) &&
2392  file_size && ic->pb->seekable) {
2393  /* get accurate estimate from the PTSes */
2394  estimate_timings_from_pts(ic, old_offset);
2396  } else if (has_duration(ic)) {
2397  /* at least one component has timings - we use them for all
2398  the components */
2401  } else {
2402  av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2403  /* less precise: use bitrate info */
2406  }
2408 
2409  {
2410  int i;
2411  AVStream av_unused *st;
2412  for(i = 0;i < ic->nb_streams; i++) {
2413  st = ic->streams[i];
2414  av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2415  (double) st->start_time / AV_TIME_BASE,
2416  (double) st->duration / AV_TIME_BASE);
2417  }
2418  av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2419  (double) ic->start_time / AV_TIME_BASE,
2420  (double) ic->duration / AV_TIME_BASE,
2421  ic->bit_rate / 1000);
2422  }
2423 }
2424 
2425 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2426 {
2427  AVCodecContext *avctx = st->codec;
2428 
2429 #define FAIL(errmsg) do { \
2430  if (errmsg_ptr) \
2431  *errmsg_ptr = errmsg; \
2432  return 0; \
2433  } while (0)
2434 
2435  switch (avctx->codec_type) {
2436  case AVMEDIA_TYPE_AUDIO:
2437  if (!avctx->frame_size && determinable_frame_size(avctx))
2438  FAIL("unspecified frame size");
2439  if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2440  FAIL("unspecified sample format");
2441  if (!avctx->sample_rate)
2442  FAIL("unspecified sample rate");
2443  if (!avctx->channels)
2444  FAIL("unspecified number of channels");
2445  if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2446  FAIL("no decodable DTS frames");
2447  break;
2448  case AVMEDIA_TYPE_VIDEO:
2449  if (!avctx->width)
2450  FAIL("unspecified size");
2451  if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2452  FAIL("unspecified pixel format");
2455  FAIL("no frame in rv30/40 and no sar");
2456  break;
2457  case AVMEDIA_TYPE_SUBTITLE:
2458  if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2459  FAIL("unspecified size");
2460  break;
2461  case AVMEDIA_TYPE_DATA:
2462  if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2463  }
2464 
2465  if (avctx->codec_id == AV_CODEC_ID_NONE)
2466  FAIL("unknown codec");
2467  return 1;
2468 }
2469 
2470 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2472 {
2473  const AVCodec *codec;
2474  int got_picture = 1, ret = 0;
2476  AVSubtitle subtitle;
2477  AVPacket pkt = *avpkt;
2478 
2479  if (!frame)
2480  return AVERROR(ENOMEM);
2481 
2482  if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2483  AVDictionary *thread_opt = NULL;
2484 
2485  codec = st->codec->codec ? st->codec->codec :
2487 
2488  if (!codec) {
2489  st->info->found_decoder = -1;
2490  ret = -1;
2491  goto fail;
2492  }
2493 
2494  /* force thread count to 1 since the h264 decoder will not extract SPS
2495  * and PPS to extradata during multi-threaded decoding */
2496  av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2497  ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2498  if (!options)
2499  av_dict_free(&thread_opt);
2500  if (ret < 0) {
2501  st->info->found_decoder = -1;
2502  goto fail;
2503  }
2504  st->info->found_decoder = 1;
2505  } else if (!st->info->found_decoder)
2506  st->info->found_decoder = 1;
2507 
2508  if (st->info->found_decoder < 0) {
2509  ret = -1;
2510  goto fail;
2511  }
2512 
2513  while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2514  ret >= 0 &&
2515  (!has_codec_parameters(st, NULL) ||
2518  got_picture = 0;
2520  switch(st->codec->codec_type) {
2521  case AVMEDIA_TYPE_VIDEO:
2522  ret = avcodec_decode_video2(st->codec, frame,
2523  &got_picture, &pkt);
2524  break;
2525  case AVMEDIA_TYPE_AUDIO:
2526  ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2527  break;
2528  case AVMEDIA_TYPE_SUBTITLE:
2529  ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2530  &got_picture, &pkt);
2531  ret = pkt.size;
2532  break;
2533  default:
2534  break;
2535  }
2536  if (ret >= 0) {
2537  if (got_picture)
2538  st->nb_decoded_frames++;
2539  pkt.data += ret;
2540  pkt.size -= ret;
2541  ret = got_picture;
2542  }
2543  }
2544 
2545  if(!pkt.data && !got_picture)
2546  ret = -1;
2547 
2548 fail:
2549  avcodec_free_frame(&frame);
2550  return ret;
2551 }
2552 
2553 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2554 {
2555  while (tags->id != AV_CODEC_ID_NONE) {
2556  if (tags->id == id)
2557  return tags->tag;
2558  tags++;
2559  }
2560  return 0;
2561 }
2562 
2563 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2564 {
2565  int i;
2566  for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2567  if(tag == tags[i].tag)
2568  return tags[i].id;
2569  }
2570  for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2571  if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2572  return tags[i].id;
2573  }
2574  return AV_CODEC_ID_NONE;
2575 }
2576 
2577 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2578 {
2579  if (flt) {
2580  switch (bps) {
2581  case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2582  case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2583  default: return AV_CODEC_ID_NONE;
2584  }
2585  } else {
2586  bps += 7;
2587  bps >>= 3;
2588  if (sflags & (1 << (bps - 1))) {
2589  switch (bps) {
2590  case 1: return AV_CODEC_ID_PCM_S8;
2591  case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2592  case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2593  case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2594  default: return AV_CODEC_ID_NONE;
2595  }
2596  } else {
2597  switch (bps) {
2598  case 1: return AV_CODEC_ID_PCM_U8;
2599  case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2600  case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2601  case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2602  default: return AV_CODEC_ID_NONE;
2603  }
2604  }
2605  }
2606 }
2607 
2608 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2609 {
2610  unsigned int tag;
2611  if (!av_codec_get_tag2(tags, id, &tag))
2612  return 0;
2613  return tag;
2614 }
2615 
2616 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2617  unsigned int *tag)
2618 {
2619  int i;
2620  for(i=0; tags && tags[i]; i++){
2621  const AVCodecTag *codec_tags = tags[i];
2622  while (codec_tags->id != AV_CODEC_ID_NONE) {
2623  if (codec_tags->id == id) {
2624  *tag = codec_tags->tag;
2625  return 1;
2626  }
2627  codec_tags++;
2628  }
2629  }
2630  return 0;
2631 }
2632 
2633 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2634 {
2635  int i;
2636  for(i=0; tags && tags[i]; i++){
2637  enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2638  if(id!=AV_CODEC_ID_NONE) return id;
2639  }
2640  return AV_CODEC_ID_NONE;
2641 }
2642 
2644 {
2645  unsigned int i, j;
2646  int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2647 
2648  for (i = 0; i < s->nb_chapters; i++)
2649  if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2650  AVChapter *ch = s->chapters[i];
2651  int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2652  : INT64_MAX;
2653 
2654  for (j = 0; j < s->nb_chapters; j++) {
2655  AVChapter *ch1 = s->chapters[j];
2656  int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2657  if (j != i && next_start > ch->start && next_start < end)
2658  end = next_start;
2659  }
2660  ch->end = (end == INT64_MAX) ? ch->start : end;
2661  }
2662 }
2663 
2664 static int get_std_framerate(int i){
2665  if(i<60*12) return (i+1)*1001;
2666  else return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2667 }
2668 
2669 /*
2670  * Is the time base unreliable.
2671  * This is a heuristic to balance between quick acceptance of the values in
2672  * the headers vs. some extra checks.
2673  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2674  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2675  * And there are "variable" fps files this needs to detect as well.
2676  */
2678  if( c->time_base.den >= 101LL*c->time_base.num
2679  || c->time_base.den < 5LL*c->time_base.num
2680 /* || c->codec_tag == AV_RL32("DIVX")
2681  || c->codec_tag == AV_RL32("XVID")*/
2682  || c->codec_tag == AV_RL32("mp4v")
2684  || c->codec_id == AV_CODEC_ID_H264
2685  )
2686  return 1;
2687  return 0;
2688 }
2689 
2690 #if FF_API_FORMAT_PARAMETERS
2691 int av_find_stream_info(AVFormatContext *ic)
2692 {
2693  return avformat_find_stream_info(ic, NULL);
2694 }
2695 #endif
2696 
2698 {
2699  int i, count, ret, read_size, j;
2700  AVStream *st;
2701  AVPacket pkt1, *pkt;
2702  int64_t old_offset = avio_tell(ic->pb);
2703  int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2704  int flush_codecs = ic->probesize > 0;
2705 
2706  if(ic->pb)
2707  av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2708 
2709  for(i=0;i<ic->nb_streams;i++) {
2710  const AVCodec *codec;
2711  AVDictionary *thread_opt = NULL;
2712  st = ic->streams[i];
2713 
2714  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2716 /* if(!st->time_base.num)
2717  st->time_base= */
2718  if(!st->codec->time_base.num)
2719  st->codec->time_base= st->time_base;
2720  }
2721  //only for the split stuff
2722  if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2723  st->parser = av_parser_init(st->codec->codec_id);
2724  if(st->parser){
2727  } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2729  }
2730  } else if (st->need_parsing) {
2731  av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2732  "%s, packets or times may be invalid.\n",
2734  }
2735  }
2736  codec = st->codec->codec ? st->codec->codec :
2738 
2739  /* force thread count to 1 since the h264 decoder will not extract SPS
2740  * and PPS to extradata during multi-threaded decoding */
2741  av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2742 
2743  /* Ensure that subtitle_header is properly set. */
2745  && codec && !st->codec->codec)
2746  avcodec_open2(st->codec, codec, options ? &options[i]
2747  : &thread_opt);
2748 
2749  //try to just open decoders, in case this is enough to get parameters
2750  if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2751  if (codec && !st->codec->codec)
2752  avcodec_open2(st->codec, codec, options ? &options[i]
2753  : &thread_opt);
2754  }
2755  if (!options)
2756  av_dict_free(&thread_opt);
2757  }
2758 
2759  for (i=0; i<ic->nb_streams; i++) {
2760 #if FF_API_R_FRAME_RATE
2761  ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2762 #endif
2765  }
2766 
2767  count = 0;
2768  read_size = 0;
2769  for(;;) {
2771  ret= AVERROR_EXIT;
2772  av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2773  break;
2774  }
2775 
2776  /* check if one codec still needs to be handled */
2777  for(i=0;i<ic->nb_streams;i++) {
2778  int fps_analyze_framecount = 20;
2779 
2780  st = ic->streams[i];
2781  if (!has_codec_parameters(st, NULL))
2782  break;
2783  /* if the timebase is coarse (like the usual millisecond precision
2784  of mkv), we need to analyze more frames to reliably arrive at
2785  the correct fps */
2786  if (av_q2d(st->time_base) > 0.0005)
2787  fps_analyze_framecount *= 2;
2788  if (ic->fps_probe_size >= 0)
2789  fps_analyze_framecount = ic->fps_probe_size;
2791  fps_analyze_framecount = 0;
2792  /* variable fps and no guess at the real fps */
2793  if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2794  && st->info->duration_count < fps_analyze_framecount
2795  && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2796  break;
2797  if(st->parser && st->parser->parser->split && !st->codec->extradata)
2798  break;
2799  if (st->first_dts == AV_NOPTS_VALUE &&
2800  (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2802  break;
2803  }
2804  if (i == ic->nb_streams) {
2805  /* NOTE: if the format has no header, then we need to read
2806  some packets to get most of the streams, so we cannot
2807  stop here */
2808  if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2809  /* if we found the info for all the codecs, we can stop */
2810  ret = count;
2811  av_log(ic, AV_LOG_DEBUG, "All info found\n");
2812  flush_codecs = 0;
2813  break;
2814  }
2815  }
2816  /* we did not get all the codec info, but we read too much data */
2817  if (read_size >= ic->probesize) {
2818  ret = count;
2819  av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2820  for (i = 0; i < ic->nb_streams; i++)
2821  if (!ic->streams[i]->r_frame_rate.num &&
2822  ic->streams[i]->info->duration_count <= 1)
2823  av_log(ic, AV_LOG_WARNING,
2824  "Stream #%d: not enough frames to estimate rate; "
2825  "consider increasing probesize\n", i);
2826  break;
2827  }
2828 
2829  /* NOTE: a new stream can be added there if no header in file
2830  (AVFMTCTX_NOHEADER) */
2831  ret = read_frame_internal(ic, &pkt1);
2832  if (ret == AVERROR(EAGAIN))
2833  continue;
2834 
2835  if (ret < 0) {
2836  /* EOF or error*/
2837  break;
2838  }
2839 
2840  if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2841  pkt = &pkt1;
2842  } else {
2843  pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2844  &ic->packet_buffer_end);
2845  if ((ret = av_dup_packet(pkt)) < 0)
2846  goto find_stream_info_err;
2847  }
2848 
2849  st = ic->streams[pkt->stream_index];
2851  read_size += pkt->size;
2852 
2853  if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2854  /* check for non-increasing dts */
2855  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2856  st->info->fps_last_dts >= pkt->dts) {
2857  av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2858  "packet %d with DTS %"PRId64", packet %d with DTS "
2859  "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2860  st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2862  }
2863  /* check for a discontinuity in dts - if the difference in dts
2864  * is more than 1000 times the average packet duration in the sequence,
2865  * we treat it as a discontinuity */
2866  if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2868  (pkt->dts - st->info->fps_last_dts) / 1000 >
2870  av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2871  "packet %d with DTS %"PRId64", packet %d with DTS "
2872  "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2873  st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2875  }
2876 
2877  /* update stored dts values */
2878  if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2879  st->info->fps_first_dts = pkt->dts;
2881  }
2882  st->info->fps_last_dts = pkt->dts;
2884  }
2885  if (st->codec_info_nb_frames>1) {
2886  int64_t t=0;
2887  if (st->time_base.den > 0)
2889  if (st->avg_frame_rate.num > 0)
2891 
2892  if (t >= ic->max_analyze_duration) {
2893  av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2894  break;
2895  }
2896  if (pkt->duration) {
2897  st->info->codec_info_duration += pkt->duration;
2898  st->info->codec_info_duration_fields += st->parser && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2899  }
2900  }
2901 #if FF_API_R_FRAME_RATE
2902  {
2903  int64_t last = st->info->last_dts;
2904 
2905  if( pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2906  && pkt->dts - (uint64_t)last < INT64_MAX){
2907  double dts= (is_relative(pkt->dts) ? pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2908  int64_t duration= pkt->dts - last;
2909 
2910  if (!st->info->duration_error)
2911  st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2912 
2913 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2914 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2915  for (i=0; i<MAX_STD_TIMEBASES; i++) {
2916  int framerate= get_std_framerate(i);
2917  double sdts= dts*framerate/(1001*12);
2918  for(j=0; j<2; j++){
2919  int64_t ticks= llrint(sdts+j*0.5);
2920  double error= sdts - ticks + j*0.5;
2921  st->info->duration_error[j][0][i] += error;
2922  st->info->duration_error[j][1][i] += error*error;
2923  }
2924  }
2925  st->info->duration_count++;
2926  // ignore the first 4 values, they might have some random jitter
2927  if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2928  st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2929  }
2930  if (pkt->dts != AV_NOPTS_VALUE)
2931  st->info->last_dts = pkt->dts;
2932  }
2933 #endif
2934  if(st->parser && st->parser->parser->split && !st->codec->extradata){
2935  int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2936  if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2937  st->codec->extradata_size= i;
2939  if (!st->codec->extradata)
2940  return AVERROR(ENOMEM);
2941  memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2942  memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2943  }
2944  }
2945 
2946  /* if still no information, we try to open the codec and to
2947  decompress the frame. We try to avoid that in most cases as
2948  it takes longer and uses more memory. For MPEG-4, we need to
2949  decompress for QuickTime.
2950 
2951  If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2952  least one frame of codec data, this makes sure the codec initializes
2953  the channel configuration and does not only trust the values from the container.
2954  */
2955  try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2956 
2957  st->codec_info_nb_frames++;
2958  count++;
2959  }
2960 
2961  if (flush_codecs) {
2962  AVPacket empty_pkt = { 0 };
2963  int err = 0;
2964  av_init_packet(&empty_pkt);
2965 
2966  ret = -1; /* we could not have all the codec parameters before EOF */
2967  for(i=0;i<ic->nb_streams;i++) {
2968  const char *errmsg;
2969 
2970  st = ic->streams[i];
2971 
2972  /* flush the decoders */
2973  if (st->info->found_decoder == 1) {
2974  do {
2975  err = try_decode_frame(st, &empty_pkt,
2976  (options && i < orig_nb_streams) ?
2977  &options[i] : NULL);
2978  } while (err > 0 && !has_codec_parameters(st, NULL));
2979 
2980  if (err < 0) {
2981  av_log(ic, AV_LOG_INFO,
2982  "decoding for stream %d failed\n", st->index);
2983  }
2984  }
2985 
2986  if (!has_codec_parameters(st, &errmsg)) {
2987  char buf[256];
2988  avcodec_string(buf, sizeof(buf), st->codec, 0);
2989  av_log(ic, AV_LOG_WARNING,
2990  "Could not find codec parameters for stream %d (%s): %s\n"
2991  "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
2992  i, buf, errmsg);
2993  } else {
2994  ret = 0;
2995  }
2996  }
2997  }
2998 
2999  // close codecs which were opened in try_decode_frame()
3000  for(i=0;i<ic->nb_streams;i++) {
3001  st = ic->streams[i];
3002  avcodec_close(st->codec);
3003  }
3004  for(i=0;i<ic->nb_streams;i++) {
3005  st = ic->streams[i];
3006  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3010  st->codec->codec_tag= tag;
3011  }
3012 
3013  /* estimate average framerate if not set by demuxer */
3015  int best_fps = 0;
3016  double best_error = 0.01;
3017 
3019  st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3020  st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3021 
3022  /* round guessed framerate to a "standard" framerate if it's
3023  * within 1% of the original estimate*/
3024  for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3025  AVRational std_fps = { get_std_framerate(j), 12*1001 };
3026  double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3027 
3028  if (error < best_error) {
3029  best_error = error;
3030  best_fps = std_fps.num;
3031  }
3032  }
3033  if (best_fps) {
3035  best_fps, 12*1001, INT_MAX);
3036  }
3037  }
3038  // the check for tb_unreliable() is not completely correct, since this is not about handling
3039  // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3040  // ipmovie.c produces.
3041  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)
3042  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);
3043  if (st->info->duration_count>1 && !st->r_frame_rate.num
3044  && tb_unreliable(st->codec)) {
3045  int num = 0;
3046  double best_error= 0.01;
3047 
3048  for (j=0; j<MAX_STD_TIMEBASES; j++) {
3049  int k;
3050 
3051  if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3052  continue;
3053  if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3054  continue;
3055  for(k=0; k<2; k++){
3056  int n= st->info->duration_count;
3057  double a= st->info->duration_error[k][0][j] / n;
3058  double error= st->info->duration_error[k][1][j]/n - a*a;
3059 
3060  if(error < best_error && best_error> 0.000000001){
3061  best_error= error;
3062  num = get_std_framerate(j);
3063  }
3064  if(error < 0.02)
3065  av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3066  }
3067  }
3068  // do not increase frame rate by more than 1 % in order to match a standard rate.
3069  if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3070  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3071  }
3072 
3073  if (!st->r_frame_rate.num){
3074  if( st->codec->time_base.den * (int64_t)st->time_base.num
3075  <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3076  st->r_frame_rate.num = st->codec->time_base.den;
3077  st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3078  }else{
3079  st->r_frame_rate.num = st->time_base.den;
3080  st->r_frame_rate.den = st->time_base.num;
3081  }
3082  }
3083  }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3084  if(!st->codec->bits_per_coded_sample)
3086  // set stream disposition based on audio service type
3087  switch (st->codec->audio_service_type) {
3095  st->disposition = AV_DISPOSITION_COMMENT; break;
3097  st->disposition = AV_DISPOSITION_KARAOKE; break;
3098  }
3099  }
3100  }
3101 
3102  if(ic->probesize)
3103  estimate_timings(ic, old_offset);
3104 
3106 
3107  find_stream_info_err:
3108  for (i=0; i < ic->nb_streams; i++) {
3109  st = ic->streams[i];
3110  if (ic->streams[i]->codec)
3111  ic->streams[i]->codec->thread_count = 0;
3112  if (st->info)
3113  av_freep(&st->info->duration_error);
3114  av_freep(&ic->streams[i]->info);
3115  }
3116  if(ic->pb)
3117  av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3118  return ret;
3119 }
3120 
3122 {
3123  int i, j;
3124 
3125  for (i = 0; i < ic->nb_programs; i++) {
3126  if (ic->programs[i] == last) {
3127  last = NULL;
3128  } else {
3129  if (!last)
3130  for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3131  if (ic->programs[i]->stream_index[j] == s)
3132  return ic->programs[i];
3133  }
3134  }
3135  return NULL;
3136 }
3137 
3139  enum AVMediaType type,
3140  int wanted_stream_nb,
3141  int related_stream,
3142  AVCodec **decoder_ret,
3143  int flags)
3144 {
3145  int i, nb_streams = ic->nb_streams;
3146  int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3147  unsigned *program = NULL;
3148  AVCodec *decoder = NULL, *best_decoder = NULL;
3149 
3150  if (related_stream >= 0 && wanted_stream_nb < 0) {
3151  AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3152  if (p) {
3153  program = p->stream_index;
3154  nb_streams = p->nb_stream_indexes;
3155  }
3156  }
3157  for (i = 0; i < nb_streams; i++) {
3158  int real_stream_index = program ? program[i] : i;
3159  AVStream *st = ic->streams[real_stream_index];
3160  AVCodecContext *avctx = st->codec;
3161  if (avctx->codec_type != type)
3162  continue;
3163  if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3164  continue;
3166  continue;
3167  if (decoder_ret) {
3168  decoder = avcodec_find_decoder(st->codec->codec_id);
3169  if (!decoder) {
3170  if (ret < 0)
3172  continue;
3173  }
3174  }
3175  count = st->codec_info_nb_frames;
3176  bitrate = avctx->bit_rate;
3177  multiframe = FFMIN(5, count);
3178  if ((best_multiframe > multiframe) ||
3179  (best_multiframe == multiframe && best_bitrate > bitrate) ||
3180  (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3181  continue;
3182  best_count = count;
3183  best_bitrate = bitrate;
3184  best_multiframe = multiframe;
3185  ret = real_stream_index;
3186  best_decoder = decoder;
3187  if (program && i == nb_streams - 1 && ret < 0) {
3188  program = NULL;
3189  nb_streams = ic->nb_streams;
3190  i = 0; /* no related stream found, try again with everything */
3191  }
3192  }
3193  if (decoder_ret)
3194  *decoder_ret = best_decoder;
3195  return ret;
3196 }
3197 
3198 /*******************************************************/
3199 
3201 {
3202  if (s->iformat->read_play)
3203  return s->iformat->read_play(s);
3204  if (s->pb)
3205  return avio_pause(s->pb, 0);
3206  return AVERROR(ENOSYS);
3207 }
3208 
3210 {
3211  if (s->iformat->read_pause)
3212  return s->iformat->read_pause(s);
3213  if (s->pb)
3214  return avio_pause(s->pb, 1);
3215  return AVERROR(ENOSYS);
3216 }
3217 
3219  av_assert0(s->nb_streams>0);
3220  av_assert0(s->streams[ s->nb_streams-1 ] == st);
3221 
3222  if (st->parser) {
3223  av_parser_close(st->parser);
3224  }
3225  if (st->attached_pic.data)
3227  av_dict_free(&st->metadata);
3228  av_freep(&st->index_entries);
3229  av_freep(&st->codec->extradata);
3231  av_freep(&st->codec);
3232  av_freep(&st->priv_data);
3233  if (st->info)
3234  av_freep(&st->info->duration_error);
3235  av_freep(&st->info);
3236  av_freep(&st->probe_data.buf);
3237  av_freep(&s->streams[ --s->nb_streams ]);
3238 }
3239 
3241 {
3242  int i;
3243 
3244  if (!s)
3245  return;
3246 
3247  av_opt_free(s);
3248  if (s->iformat && s->iformat->priv_class && s->priv_data)
3249  av_opt_free(s->priv_data);
3250 
3251  for(i=s->nb_streams-1; i>=0; i--) {
3252  ff_free_stream(s, s->streams[i]);
3253  }
3254  for(i=s->nb_programs-1; i>=0; i--) {
3255  av_dict_free(&s->programs[i]->metadata);
3256  av_freep(&s->programs[i]->stream_index);
3257  av_freep(&s->programs[i]);
3258  }
3259  av_freep(&s->programs);
3260  av_freep(&s->priv_data);
3261  while(s->nb_chapters--) {
3263  av_freep(&s->chapters[s->nb_chapters]);
3264  }
3265  av_freep(&s->chapters);
3266  av_dict_free(&s->metadata);
3267  av_freep(&s->streams);
3268  av_free(s);
3269 }
3270 
3271 #if FF_API_CLOSE_INPUT_FILE
3272 void av_close_input_file(AVFormatContext *s)
3273 {
3275 }
3276 #endif
3277 
3279 {
3280  AVFormatContext *s = *ps;
3281  AVIOContext *pb = s->pb;
3282 
3283  if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3284  (s->flags & AVFMT_FLAG_CUSTOM_IO))
3285  pb = NULL;
3286 
3287  flush_packet_queue(s);
3288 
3289  if (s->iformat) {
3290  if (s->iformat->read_close)
3291  s->iformat->read_close(s);
3292  }
3293 
3295 
3296  *ps = NULL;
3297 
3298  avio_close(pb);
3299 }
3300 
3301 #if FF_API_NEW_STREAM
3302 AVStream *av_new_stream(AVFormatContext *s, int id)
3303 {
3304  AVStream *st = avformat_new_stream(s, NULL);
3305  if (st)
3306  st->id = id;
3307  return st;
3308 }
3309 #endif
3310 
3312 {
3313  AVStream *st;
3314  int i;
3315  AVStream **streams;
3316 
3317  if (s->nb_streams >= INT_MAX/sizeof(*streams))
3318  return NULL;
3319  streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3320  if (!streams)
3321  return NULL;
3322  s->streams = streams;
3323 
3324  st = av_mallocz(sizeof(AVStream));
3325  if (!st)
3326  return NULL;
3327  if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3328  av_free(st);
3329  return NULL;
3330  }
3331  st->info->last_dts = AV_NOPTS_VALUE;
3332 
3333  st->codec = avcodec_alloc_context3(c);
3334  if (s->iformat) {
3335  /* no default bitrate if decoding */
3336  st->codec->bit_rate = 0;
3337  }
3338  st->index = s->nb_streams;
3339  st->start_time = AV_NOPTS_VALUE;
3340  st->duration = AV_NOPTS_VALUE;
3341  /* we set the current DTS to 0 so that formats without any timestamps
3342  but durations get some timestamps, formats with some unknown
3343  timestamps have their first few packets buffered and the
3344  timestamps corrected before they are returned to the user */
3345  st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3346  st->first_dts = AV_NOPTS_VALUE;
3350 
3351  /* default pts setting is MPEG-like */
3352  avpriv_set_pts_info(st, 33, 1, 90000);
3354  for(i=0; i<MAX_REORDER_DELAY+1; i++)
3355  st->pts_buffer[i]= AV_NOPTS_VALUE;
3357 
3358  st->sample_aspect_ratio = (AVRational){0,1};
3359 
3360 #if FF_API_R_FRAME_RATE
3361  st->info->last_dts = AV_NOPTS_VALUE;
3362 #endif
3365 
3366  s->streams[s->nb_streams++] = st;
3367  return st;
3368 }
3369 
3371 {
3372  AVProgram *program=NULL;
3373  int i;
3374 
3375  av_dlog(ac, "new_program: id=0x%04x\n", id);
3376 
3377  for(i=0; i<ac->nb_programs; i++)
3378  if(ac->programs[i]->id == id)
3379  program = ac->programs[i];
3380 
3381  if(!program){
3382  program = av_mallocz(sizeof(AVProgram));
3383  if (!program)
3384  return NULL;
3385  dynarray_add(&ac->programs, &ac->nb_programs, program);
3386  program->discard = AVDISCARD_NONE;
3387  }
3388  program->id = id;
3391 
3392  program->start_time =
3393  program->end_time = AV_NOPTS_VALUE;
3394 
3395  return program;
3396 }
3397 
3398 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3399 {
3400  AVChapter *chapter = NULL;
3401  int i;
3402 
3403  for(i=0; i<s->nb_chapters; i++)
3404  if(s->chapters[i]->id == id)
3405  chapter = s->chapters[i];
3406 
3407  if(!chapter){
3408  chapter= av_mallocz(sizeof(AVChapter));
3409  if(!chapter)
3410  return NULL;
3411  dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3412  }
3413  av_dict_set(&chapter->metadata, "title", title, 0);
3414  chapter->id = id;
3415  chapter->time_base= time_base;
3416  chapter->start = start;
3417  chapter->end = end;
3418 
3419  return chapter;
3420 }
3421 
3422 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3423 {
3424  int i, j;
3425  AVProgram *program=NULL;
3426  void *tmp;
3427 
3428  if (idx >= ac->nb_streams) {
3429  av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3430  return;
3431  }
3432 
3433  for(i=0; i<ac->nb_programs; i++){
3434  if(ac->programs[i]->id != progid)
3435  continue;
3436  program = ac->programs[i];
3437  for(j=0; j<program->nb_stream_indexes; j++)
3438  if(program->stream_index[j] == idx)
3439  return;
3440 
3441  tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3442  if(!tmp)
3443  return;
3444  program->stream_index = tmp;
3445  program->stream_index[program->nb_stream_indexes++] = idx;
3446  return;
3447  }
3448 }
3449 
3450 static void print_fps(double d, const char *postfix){
3451  uint64_t v= lrintf(d*100);
3452  if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3453  else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3454  else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3455 }
3456 
3457 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3458 {
3459  if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3461 
3462  av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3463  while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3464  if(strcmp("language", tag->key)){
3465  const char *p = tag->value;
3466  av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3467  while(*p) {
3468  char tmp[256];
3469  size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3470  av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3471  av_log(ctx, AV_LOG_INFO, "%s", tmp);
3472  p += len;
3473  if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3474  if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3475  if (*p) p++;
3476  }
3477  av_log(ctx, AV_LOG_INFO, "\n");
3478  }
3479  }
3480  }
3481 }
3482 
3483 /* "user interface" functions */
3484 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3485 {
3486  char buf[256];
3487  int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3488  AVStream *st = ic->streams[i];
3489  int g = av_gcd(st->time_base.num, st->time_base.den);
3490  AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3491  avcodec_string(buf, sizeof(buf), st->codec, is_output);
3492  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3493  /* the pid is an important information, so we display it */
3494  /* XXX: add a generic system */
3495  if (flags & AVFMT_SHOW_IDS)
3496  av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3497  if (lang)
3498  av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3499  av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3500  av_log(NULL, AV_LOG_INFO, ": %s", buf);
3501  if (st->sample_aspect_ratio.num && // default
3503  AVRational display_aspect_ratio;
3504  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3507  1024*1024);
3508  av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3510  display_aspect_ratio.num, display_aspect_ratio.den);
3511  }
3512  if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3513  if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3514  print_fps(av_q2d(st->avg_frame_rate), "fps");
3515 #if FF_API_R_FRAME_RATE
3516  if(st->r_frame_rate.den && st->r_frame_rate.num)
3517  print_fps(av_q2d(st->r_frame_rate), "tbr");
3518 #endif
3519  if(st->time_base.den && st->time_base.num)
3520  print_fps(1/av_q2d(st->time_base), "tbn");
3521  if(st->codec->time_base.den && st->codec->time_base.num)
3522  print_fps(1/av_q2d(st->codec->time_base), "tbc");
3523  }
3525  av_log(NULL, AV_LOG_INFO, " (default)");
3526  if (st->disposition & AV_DISPOSITION_DUB)
3527  av_log(NULL, AV_LOG_INFO, " (dub)");
3529  av_log(NULL, AV_LOG_INFO, " (original)");
3531  av_log(NULL, AV_LOG_INFO, " (comment)");
3533  av_log(NULL, AV_LOG_INFO, " (lyrics)");
3535  av_log(NULL, AV_LOG_INFO, " (karaoke)");
3537  av_log(NULL, AV_LOG_INFO, " (forced)");
3539  av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3541  av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3543  av_log(NULL, AV_LOG_INFO, " (clean effects)");
3544  av_log(NULL, AV_LOG_INFO, "\n");
3545  dump_metadata(NULL, st->metadata, " ");
3546 }
3547 
3549  int index,
3550  const char *url,
3551  int is_output)
3552 {
3553  int i;
3554  uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3555  if (ic->nb_streams && !printed)
3556  return;
3557 
3558  av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3559  is_output ? "Output" : "Input",
3560  index,
3561  is_output ? ic->oformat->name : ic->iformat->name,
3562  is_output ? "to" : "from", url);
3563  dump_metadata(NULL, ic->metadata, " ");
3564  if (!is_output) {
3565  av_log(NULL, AV_LOG_INFO, " Duration: ");
3566  if (ic->duration != AV_NOPTS_VALUE) {
3567  int hours, mins, secs, us;
3568  int64_t duration = ic->duration + 5000;
3569  secs = duration / AV_TIME_BASE;
3570  us = duration % AV_TIME_BASE;
3571  mins = secs / 60;
3572  secs %= 60;
3573  hours = mins / 60;
3574  mins %= 60;
3575  av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3576  (100 * us) / AV_TIME_BASE);
3577  } else {
3578  av_log(NULL, AV_LOG_INFO, "N/A");
3579  }
3580  if (ic->start_time != AV_NOPTS_VALUE) {
3581  int secs, us;
3582  av_log(NULL, AV_LOG_INFO, ", start: ");
3583  secs = ic->start_time / AV_TIME_BASE;
3584  us = abs(ic->start_time % AV_TIME_BASE);
3585  av_log(NULL, AV_LOG_INFO, "%d.%06d",
3586  secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3587  }
3588  av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3589  if (ic->bit_rate) {
3590  av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3591  } else {
3592  av_log(NULL, AV_LOG_INFO, "N/A");
3593  }
3594  av_log(NULL, AV_LOG_INFO, "\n");
3595  }
3596  for (i = 0; i < ic->nb_chapters; i++) {
3597  AVChapter *ch = ic->chapters[i];
3598  av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3599  av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3600  av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3601 
3602  dump_metadata(NULL, ch->metadata, " ");
3603  }
3604  if(ic->nb_programs) {
3605  int j, k, total = 0;
3606  for(j=0; j<ic->nb_programs; j++) {
3608  "name", NULL, 0);
3609  av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3610  name ? name->value : "");
3611  dump_metadata(NULL, ic->programs[j]->metadata, " ");
3612  for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3613  dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3614  printed[ic->programs[j]->stream_index[k]] = 1;
3615  }
3616  total += ic->programs[j]->nb_stream_indexes;
3617  }
3618  if (total < ic->nb_streams)
3619  av_log(NULL, AV_LOG_INFO, " No Program\n");
3620  }
3621  for(i=0;i<ic->nb_streams;i++)
3622  if (!printed[i])
3623  dump_stream_format(ic, i, index, is_output);
3624 
3625  av_free(printed);
3626 }
3627 
3628 #if FF_API_AV_GETTIME && CONFIG_SHARED && HAVE_SYMVER
3629 FF_SYMVER(int64_t, av_gettime, (void), "LIBAVFORMAT_54")
3630 {
3631  return av_gettime();
3632 }
3633 #endif
3634 
3635 uint64_t ff_ntp_time(void)
3636 {
3637  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3638 }
3639 
3640 int av_get_frame_filename(char *buf, int buf_size,
3641  const char *path, int number)
3642 {
3643  const char *p;
3644  char *q, buf1[20], c;
3645  int nd, len, percentd_found;
3646 
3647  q = buf;
3648  p = path;
3649  percentd_found = 0;
3650  for(;;) {
3651  c = *p++;
3652  if (c == '\0')
3653  break;
3654  if (c == '%') {
3655  do {
3656  nd = 0;
3657  while (av_isdigit(*p)) {
3658  nd = nd * 10 + *p++ - '0';
3659  }
3660  c = *p++;
3661  } while (av_isdigit(c));
3662 
3663  switch(c) {
3664  case '%':
3665  goto addchar;
3666  case 'd':
3667  if (percentd_found)
3668  goto fail;
3669  percentd_found = 1;
3670  snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3671  len = strlen(buf1);
3672  if ((q - buf + len) > buf_size - 1)
3673  goto fail;
3674  memcpy(q, buf1, len);
3675  q += len;
3676  break;
3677  default:
3678  goto fail;
3679  }
3680  } else {
3681  addchar:
3682  if ((q - buf) < buf_size - 1)
3683  *q++ = c;
3684  }
3685  }
3686  if (!percentd_found)
3687  goto fail;
3688  *q = '\0';
3689  return 0;
3690  fail:
3691  *q = '\0';
3692  return -1;
3693 }
3694 
3695 static void hex_dump_internal(void *avcl, FILE *f, int level,
3696  const uint8_t *buf, int size)
3697 {
3698  int len, i, j, c;
3699 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3700 
3701  for(i=0;i<size;i+=16) {
3702  len = size - i;
3703  if (len > 16)
3704  len = 16;
3705  PRINT("%08x ", i);
3706  for(j=0;j<16;j++) {
3707  if (j < len)
3708  PRINT(" %02x", buf[i+j]);
3709  else
3710  PRINT(" ");
3711  }
3712  PRINT(" ");
3713  for(j=0;j<len;j++) {
3714  c = buf[i+j];
3715  if (c < ' ' || c > '~')
3716  c = '.';
3717  PRINT("%c", c);
3718  }
3719  PRINT("\n");
3720  }
3721 #undef PRINT
3722 }
3723 
3724 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3725 {
3726  hex_dump_internal(NULL, f, 0, buf, size);
3727 }
3728 
3729 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3730 {
3731  hex_dump_internal(avcl, NULL, level, buf, size);
3732 }
3733 
3734 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3735 {
3736 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3737  PRINT("stream #%d:\n", pkt->stream_index);
3738  PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3739  PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3740  /* DTS is _always_ valid after av_read_frame() */
3741  PRINT(" dts=");
3742  if (pkt->dts == AV_NOPTS_VALUE)
3743  PRINT("N/A");
3744  else
3745  PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3746  /* PTS may not be known if B-frames are present. */
3747  PRINT(" pts=");
3748  if (pkt->pts == AV_NOPTS_VALUE)
3749  PRINT("N/A");
3750  else
3751  PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3752  PRINT("\n");
3753  PRINT(" size=%d\n", pkt->size);
3754 #undef PRINT
3755  if (dump_payload)
3756  av_hex_dump(f, pkt->data, pkt->size);
3757 }
3758 
3759 #if FF_API_PKT_DUMP
3760 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3761 {
3762  AVRational tb = { 1, AV_TIME_BASE };
3763  pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3764 }
3765 #endif
3766 
3767 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3768 {
3769  pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3770 }
3771 
3772 #if FF_API_PKT_DUMP
3773 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3774 {
3775  AVRational tb = { 1, AV_TIME_BASE };
3776  pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3777 }
3778 #endif
3779 
3780 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3781  AVStream *st)
3782 {
3783  pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3784 }
3785 
3786 void av_url_split(char *proto, int proto_size,
3787  char *authorization, int authorization_size,
3788  char *hostname, int hostname_size,
3789  int *port_ptr,
3790  char *path, int path_size,
3791  const char *url)
3792 {
3793  const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3794 
3795  if (port_ptr) *port_ptr = -1;
3796  if (proto_size > 0) proto[0] = 0;
3797  if (authorization_size > 0) authorization[0] = 0;
3798  if (hostname_size > 0) hostname[0] = 0;
3799  if (path_size > 0) path[0] = 0;
3800 
3801  /* parse protocol */
3802  if ((p = strchr(url, ':'))) {
3803  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3804  p++; /* skip ':' */
3805  if (*p == '/') p++;
3806  if (*p == '/') p++;
3807  } else {
3808  /* no protocol means plain filename */
3809  av_strlcpy(path, url, path_size);
3810  return;
3811  }
3812 
3813  /* separate path from hostname */
3814  ls = strchr(p, '/');
3815  ls2 = strchr(p, '?');
3816  if(!ls)
3817  ls = ls2;
3818  else if (ls && ls2)
3819  ls = FFMIN(ls, ls2);
3820  if(ls)
3821  av_strlcpy(path, ls, path_size);
3822  else
3823  ls = &p[strlen(p)]; // XXX
3824 
3825  /* the rest is hostname, use that to parse auth/port */
3826  if (ls != p) {
3827  /* authorization (user[:pass]@hostname) */
3828  at2 = p;
3829  while ((at = strchr(p, '@')) && at < ls) {
3830  av_strlcpy(authorization, at2,
3831  FFMIN(authorization_size, at + 1 - at2));
3832  p = at + 1; /* skip '@' */
3833  }
3834 
3835  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3836  /* [host]:port */
3837  av_strlcpy(hostname, p + 1,
3838  FFMIN(hostname_size, brk - p));
3839  if (brk[1] == ':' && port_ptr)
3840  *port_ptr = atoi(brk + 2);
3841  } else if ((col = strchr(p, ':')) && col < ls) {
3842  av_strlcpy(hostname, p,
3843  FFMIN(col + 1 - p, hostname_size));
3844  if (port_ptr) *port_ptr = atoi(col + 1);
3845  } else
3846  av_strlcpy(hostname, p,
3847  FFMIN(ls + 1 - p, hostname_size));
3848  }
3849 }
3850 
3851 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3852 {
3853  int i;
3854  static const char hex_table_uc[16] = { '0', '1', '2', '3',
3855  '4', '5', '6', '7',
3856  '8', '9', 'A', 'B',
3857  'C', 'D', 'E', 'F' };
3858  static const char hex_table_lc[16] = { '0', '1', '2', '3',
3859  '4', '5', '6', '7',
3860  '8', '9', 'a', 'b',
3861  'c', 'd', 'e', 'f' };
3862  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3863 
3864  for(i = 0; i < s; i++) {
3865  buff[i * 2] = hex_table[src[i] >> 4];
3866  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3867  }
3868 
3869  return buff;
3870 }
3871 
3872 int ff_hex_to_data(uint8_t *data, const char *p)
3873 {
3874  int c, len, v;
3875 
3876  len = 0;
3877  v = 1;
3878  for (;;) {
3879  p += strspn(p, SPACE_CHARS);
3880  if (*p == '\0')
3881  break;
3882  c = av_toupper((unsigned char) *p++);
3883  if (c >= '0' && c <= '9')
3884  c = c - '0';
3885  else if (c >= 'A' && c <= 'F')
3886  c = c - 'A' + 10;
3887  else
3888  break;
3889  v = (v << 4) | c;
3890  if (v & 0x100) {
3891  if (data)
3892  data[len] = v;
3893  len++;
3894  v = 1;
3895  }
3896  }
3897  return len;
3898 }
3899 
3900 #if FF_API_SET_PTS_INFO
3901 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3902  unsigned int pts_num, unsigned int pts_den)
3903 {
3904  avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3905 }
3906 #endif
3907 
3908 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3909  unsigned int pts_num, unsigned int pts_den)
3910 {
3911  AVRational new_tb;
3912  if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3913  if(new_tb.num != pts_num)
3914  av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3915  }else
3916  av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3917 
3918  if(new_tb.num <= 0 || new_tb.den <= 0) {
3919  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);
3920  return;
3921  }
3922  s->time_base = new_tb;
3923  av_codec_set_pkt_timebase(s->codec, new_tb);
3924  s->pts_wrap_bits = pts_wrap_bits;
3925 }
3926 
3927 int ff_url_join(char *str, int size, const char *proto,
3928  const char *authorization, const char *hostname,
3929  int port, const char *fmt, ...)
3930 {
3931 #if CONFIG_NETWORK
3932  struct addrinfo hints = { 0 }, *ai;
3933 #endif
3934 
3935  str[0] = '\0';
3936  if (proto)
3937  av_strlcatf(str, size, "%s://", proto);
3938  if (authorization && authorization[0])
3939  av_strlcatf(str, size, "%s@", authorization);
3940 #if CONFIG_NETWORK && defined(AF_INET6)
3941  /* Determine if hostname is a numerical IPv6 address,
3942  * properly escape it within [] in that case. */
3943  hints.ai_flags = AI_NUMERICHOST;
3944  if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3945  if (ai->ai_family == AF_INET6) {
3946  av_strlcat(str, "[", size);
3947  av_strlcat(str, hostname, size);
3948  av_strlcat(str, "]", size);
3949  } else {
3950  av_strlcat(str, hostname, size);
3951  }
3952  freeaddrinfo(ai);
3953  } else
3954 #endif
3955  /* Not an IPv6 address, just output the plain string. */
3956  av_strlcat(str, hostname, size);
3957 
3958  if (port >= 0)
3959  av_strlcatf(str, size, ":%d", port);
3960  if (fmt) {
3961  va_list vl;
3962  int len = strlen(str);
3963 
3964  va_start(vl, fmt);
3965  vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3966  va_end(vl);
3967  }
3968  return strlen(str);
3969 }
3970 
3972  AVFormatContext *src)
3973 {
3974  AVPacket local_pkt;
3975 
3976  local_pkt = *pkt;
3977  local_pkt.stream_index = dst_stream;
3978  if (pkt->pts != AV_NOPTS_VALUE)
3979  local_pkt.pts = av_rescale_q(pkt->pts,
3980  src->streams[pkt->stream_index]->time_base,
3981  dst->streams[dst_stream]->time_base);
3982  if (pkt->dts != AV_NOPTS_VALUE)
3983  local_pkt.dts = av_rescale_q(pkt->dts,
3984  src->streams[pkt->stream_index]->time_base,
3985  dst->streams[dst_stream]->time_base);
3986  if (pkt->duration)
3987  local_pkt.duration = av_rescale_q(pkt->duration,
3988  src->streams[pkt->stream_index]->time_base,
3989  dst->streams[dst_stream]->time_base);
3990  return av_write_frame(dst, &local_pkt);
3991 }
3992 
3993 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3994  void *context)
3995 {
3996  const char *ptr = str;
3997 
3998  /* Parse key=value pairs. */
3999  for (;;) {
4000  const char *key;
4001  char *dest = NULL, *dest_end;
4002  int key_len, dest_len = 0;
4003 
4004  /* Skip whitespace and potential commas. */
4005  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4006  ptr++;
4007  if (!*ptr)
4008  break;
4009 
4010  key = ptr;
4011 
4012  if (!(ptr = strchr(key, '=')))
4013  break;
4014  ptr++;
4015  key_len = ptr - key;
4016 
4017  callback_get_buf(context, key, key_len, &dest, &dest_len);
4018  dest_end = dest + dest_len - 1;
4019 
4020  if (*ptr == '\"') {
4021  ptr++;
4022  while (*ptr && *ptr != '\"') {
4023  if (*ptr == '\\') {
4024  if (!ptr[1])
4025  break;
4026  if (dest && dest < dest_end)
4027  *dest++ = ptr[1];
4028  ptr += 2;
4029  } else {
4030  if (dest && dest < dest_end)
4031  *dest++ = *ptr;
4032  ptr++;
4033  }
4034  }
4035  if (*ptr == '\"')
4036  ptr++;
4037  } else {
4038  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4039  if (dest && dest < dest_end)
4040  *dest++ = *ptr;
4041  }
4042  if (dest)
4043  *dest = 0;
4044  }
4045 }
4046 
4048 {
4049  int i;
4050  for (i = 0; i < s->nb_streams; i++) {
4051  if (s->streams[i]->id == id)
4052  return i;
4053  }
4054  return -1;
4055 }
4056 
4057 void ff_make_absolute_url(char *buf, int size, const char *base,
4058  const char *rel)
4059 {
4060  char *sep, *path_query;
4061  /* Absolute path, relative to the current server */
4062  if (base && strstr(base, "://") && rel[0] == '/') {
4063  if (base != buf)
4064  av_strlcpy(buf, base, size);
4065  sep = strstr(buf, "://");
4066  if (sep) {
4067  /* Take scheme from base url */
4068  if (rel[1] == '/') {
4069  sep[1] = '\0';
4070  } else {
4071  /* Take scheme and host from base url */
4072  sep += 3;
4073  sep = strchr(sep, '/');
4074  if (sep)
4075  *sep = '\0';
4076  }
4077  }
4078  av_strlcat(buf, rel, size);
4079  return;
4080  }
4081  /* If rel actually is an absolute url, just copy it */
4082  if (!base || strstr(rel, "://") || rel[0] == '/') {
4083  av_strlcpy(buf, rel, size);
4084  return;
4085  }
4086  if (base != buf)
4087  av_strlcpy(buf, base, size);
4088 
4089  /* Strip off any query string from base */
4090  path_query = strchr(buf, '?');
4091  if (path_query != NULL)
4092  *path_query = '\0';
4093 
4094  /* Is relative path just a new query part? */
4095  if (rel[0] == '?') {
4096  av_strlcat(buf, rel, size);
4097  return;
4098  }
4099 
4100  /* Remove the file name from the base url */
4101  sep = strrchr(buf, '/');
4102  if (sep)
4103  sep[1] = '\0';
4104  else
4105  buf[0] = '\0';
4106  while (av_strstart(rel, "../", NULL) && sep) {
4107  /* Remove the path delimiter at the end */
4108  sep[0] = '\0';
4109  sep = strrchr(buf, '/');
4110  /* If the next directory name to pop off is "..", break here */
4111  if (!strcmp(sep ? &sep[1] : buf, "..")) {
4112  /* Readd the slash we just removed */
4113  av_strlcat(buf, "/", size);
4114  break;
4115  }
4116  /* Cut off the directory name */
4117  if (sep)
4118  sep[1] = '\0';
4119  else
4120  buf[0] = '\0';
4121  rel += 3;
4122  }
4123  av_strlcat(buf, rel, size);
4124 }
4125 
4126 int64_t ff_iso8601_to_unix_time(const char *datestr)
4127 {
4128  struct tm time1 = {0}, time2 = {0};
4129  char *ret1, *ret2;
4130  ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4131  ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4132  if (ret2 && !ret1)
4133  return av_timegm(&time2);
4134  else
4135  return av_timegm(&time1);
4136 }
4137 
4138 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4139 {
4140  if (ofmt) {
4141  if (ofmt->query_codec)
4142  return ofmt->query_codec(codec_id, std_compliance);
4143  else if (ofmt->codec_tag)
4144  return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4145  else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4146  codec_id == ofmt->subtitle_codec)
4147  return 1;
4148  }
4149  return AVERROR_PATCHWELCOME;
4150 }
4151 
4153 {
4154 #if CONFIG_NETWORK
4155  int ret;
4157  if ((ret = ff_network_init()) < 0)
4158  return ret;
4159  ff_tls_init();
4160 #endif
4161  return 0;
4162 }
4163 
4165 {
4166 #if CONFIG_NETWORK
4167  ff_network_close();
4168  ff_tls_deinit();
4169 #endif
4170  return 0;
4171 }
4172 
4174  uint64_t channel_layout, int32_t sample_rate,
4176 {
4177  uint32_t flags = 0;
4178  int size = 4;
4179  uint8_t *data;
4180  if (!pkt)
4181  return AVERROR(EINVAL);
4182  if (channels) {
4183  size += 4;
4185  }
4186  if (channel_layout) {
4187  size += 8;
4189  }
4190  if (sample_rate) {
4191  size += 4;
4193  }
4194  if (width || height) {
4195  size += 8;
4197  }
4199  if (!data)
4200  return AVERROR(ENOMEM);
4201  bytestream_put_le32(&data, flags);
4202  if (channels)
4203  bytestream_put_le32(&data, channels);
4204  if (channel_layout)
4205  bytestream_put_le64(&data, channel_layout);
4206  if (sample_rate)
4207  bytestream_put_le32(&data, sample_rate);
4208  if (width || height) {
4209  bytestream_put_le32(&data, width);
4210  bytestream_put_le32(&data, height);
4211  }
4212  return 0;
4213 }
4214 
4216 {
4217  return ff_codec_bmp_tags;
4218 }
4220 {
4221  return ff_codec_wav_tags;
4222 }
4223 
4225 {
4226  AVRational undef = {0, 1};
4227  AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4228  AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4229  AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4230 
4231  av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4232  stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4233  if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4234  stream_sample_aspect_ratio = undef;
4235 
4236  av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4237  frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4238  if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4239  frame_sample_aspect_ratio = undef;
4240 
4241  if (stream_sample_aspect_ratio.num)
4242  return stream_sample_aspect_ratio;
4243  else
4244  return frame_sample_aspect_ratio;
4245 }
4246 
4248  const char *spec)
4249 {
4250  if (*spec <= '9' && *spec >= '0') /* opt:index */
4251  return strtol(spec, NULL, 0) == st->index;
4252  else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4253  *spec == 't') { /* opt:[vasdt] */
4254  enum AVMediaType type;
4255 
4256  switch (*spec++) {
4257  case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4258  case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4259  case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4260  case 'd': type = AVMEDIA_TYPE_DATA; break;
4261  case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4262  default: av_assert0(0);
4263  }
4264  if (type != st->codec->codec_type)
4265  return 0;
4266  if (*spec++ == ':') { /* possibly followed by :index */
4267  int i, index = strtol(spec, NULL, 0);
4268  for (i = 0; i < s->nb_streams; i++)
4269  if (s->streams[i]->codec->codec_type == type && index-- == 0)
4270  return i == st->index;
4271  return 0;
4272  }
4273  return 1;
4274  } else if (*spec == 'p' && *(spec + 1) == ':') {
4275  int prog_id, i, j;
4276  char *endptr;
4277  spec += 2;
4278  prog_id = strtol(spec, &endptr, 0);
4279  for (i = 0; i < s->nb_programs; i++) {
4280  if (s->programs[i]->id != prog_id)
4281  continue;
4282 
4283  if (*endptr++ == ':') {
4284  int stream_idx = strtol(endptr, NULL, 0);
4285  return stream_idx >= 0 &&
4286  stream_idx < s->programs[i]->nb_stream_indexes &&
4287  st->index == s->programs[i]->stream_index[stream_idx];
4288  }
4289 
4290  for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4291  if (st->index == s->programs[i]->stream_index[j])
4292  return 1;
4293  }
4294  return 0;
4295  } else if (*spec == '#') {
4296  int sid;
4297  char *endptr;
4298  sid = strtol(spec + 1, &endptr, 0);
4299  if (!*endptr)
4300  return st->id == sid;
4301  } else if (!*spec) /* empty specifier, matches everything */
4302  return 1;
4303 
4304  av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4305  return AVERROR(EINVAL);
4306 }
4307 
4309 {
4310  static const uint8_t avci100_1080p_extradata[] = {
4311  // SPS
4312  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4313  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4314  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4315  0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4316  0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4317  0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4318  0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4319  0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4320  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4321  // PPS
4322  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4323  0xd0
4324  };
4325  static const uint8_t avci100_1080i_extradata[] = {
4326  // SPS
4327  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4328  0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4329  0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4330  0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4331  0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4332  0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4333  0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4334  0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4335  0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4336  0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4337  0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4338  // PPS
4339  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4340  0xd0
4341  };
4342  static const uint8_t avci50_1080i_extradata[] = {
4343  // SPS
4344  0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4345  0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4346  0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4347  0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4348  0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4349  0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4350  0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4351  0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4352  0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4353  0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4354  0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4355  // PPS
4356  0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4357  0x11
4358  };
4359  static const uint8_t avci100_720p_extradata[] = {
4360  // SPS
4361  0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4362  0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4363  0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4364  0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4365  0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4366  0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4367  0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4368  0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4369  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4370  0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4371  // PPS
4372  0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4373  0x11
4374  };
4375  int size = 0;
4376  const uint8_t *data = 0;
4377  if (st->codec->width == 1920) {
4378  if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4379  data = avci100_1080p_extradata;
4380  size = sizeof(avci100_1080p_extradata);
4381  } else {
4382  data = avci100_1080i_extradata;
4383  size = sizeof(avci100_1080i_extradata);
4384  }
4385  } else if (st->codec->width == 1440) {
4386  data = avci50_1080i_extradata;
4387  size = sizeof(avci50_1080i_extradata);
4388  } else if (st->codec->width == 1280) {
4389  data = avci100_720p_extradata;
4390  size = sizeof(avci100_720p_extradata);
4391  }
4392  if (!size)
4393  return;
4394  av_freep(&st->codec->extradata);
4395  st->codec->extradata_size = 0;
4397  if (!st->codec->extradata)
4398  return;
4399  memcpy(st->codec->extradata, data, size);
4400  st->codec->extradata_size = size;
4401 }
4402 
4403 static int match_host_pattern(const char *pattern, const char *hostname)
4404 {
4405  int len_p, len_h;
4406  if (!strcmp(pattern, "*"))
4407  return 1;
4408  // Skip a possible *. at the start of the pattern
4409  if (pattern[0] == '*')
4410  pattern++;
4411  if (pattern[0] == '.')
4412  pattern++;
4413  len_p = strlen(pattern);
4414  len_h = strlen(hostname);
4415  if (len_p > len_h)
4416  return 0;
4417  // Simply check if the end of hostname is equal to 'pattern'
4418  if (!strcmp(pattern, &hostname[len_h - len_p])) {
4419  if (len_h == len_p)
4420  return 1; // Exact match
4421  if (hostname[len_h - len_p - 1] == '.')
4422  return 1; // The matched substring is a domain and not just a substring of a domain
4423  }
4424  return 0;
4425 }
4426 
4427 int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
4428 {
4429  char *buf, *start;
4430  int ret = 0;
4431  if (!no_proxy)
4432  return 0;
4433  if (!hostname)
4434  return 0;
4435  buf = av_strdup(no_proxy);
4436  if (!buf)
4437  return 0;
4438  start = buf;
4439  while (start) {
4440  char *sep, *next = NULL;
4441  start += strspn(start, " ,");
4442  sep = start + strcspn(start, " ,");
4443  if (*sep) {
4444  next = sep + 1;
4445  *sep = '\0';
4446  }
4447  if (match_host_pattern(start, hostname)) {
4448  ret = 1;
4449  break;
4450  }
4451  start = next;
4452  }
4453  av_free(buf);
4454  return ret;
4455 }