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