929f5a418c85c76127a561259473c2d58119525b
[libav.git] / libavformat / utils.c
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 #include "avformat.h"
22 #include "internal.h"
23 #include "libavcodec/opt.h"
24 #include "metadata.h"
25 #include "libavutil/avstring.h"
26 #include "riff.h"
27 #include "audiointerleave.h"
28 #include <sys/time.h>
29 #include <time.h>
30 #include <strings.h>
31 #include <stdarg.h>
32 #if CONFIG_NETWORK
33 #include "network.h"
34 #endif
35
36 #undef NDEBUG
37 #include <assert.h>
38
39 /**
40 * @file libavformat/utils.c
41 * various utility functions for use within FFmpeg
42 */
43
44 unsigned avformat_version(void)
45 {
46 return LIBAVFORMAT_VERSION_INT;
47 }
48
49 const char *avformat_configuration(void)
50 {
51 return FFMPEG_CONFIGURATION;
52 }
53
54 const char *avformat_license(void)
55 {
56 #define LICENSE_PREFIX "libavformat license: "
57 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
58 }
59
60 /* fraction handling */
61
62 /**
63 * f = val + (num / den) + 0.5.
64 *
65 * 'num' is normalized so that it is such as 0 <= num < den.
66 *
67 * @param f fractional number
68 * @param val integer value
69 * @param num must be >= 0
70 * @param den must be >= 1
71 */
72 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
73 {
74 num += (den >> 1);
75 if (num >= den) {
76 val += num / den;
77 num = num % den;
78 }
79 f->val = val;
80 f->num = num;
81 f->den = den;
82 }
83
84 /**
85 * Fractional addition to f: f = f + (incr / f->den).
86 *
87 * @param f fractional number
88 * @param incr increment, can be positive or negative
89 */
90 static void av_frac_add(AVFrac *f, int64_t incr)
91 {
92 int64_t num, den;
93
94 num = f->num + incr;
95 den = f->den;
96 if (num < 0) {
97 f->val += num / den;
98 num = num % den;
99 if (num < 0) {
100 num += den;
101 f->val--;
102 }
103 } else if (num >= den) {
104 f->val += num / den;
105 num = num % den;
106 }
107 f->num = num;
108 }
109
110 /** head of registered input format linked list */
111 AVInputFormat *first_iformat = NULL;
112 /** head of registered output format linked list */
113 AVOutputFormat *first_oformat = NULL;
114
115 AVInputFormat *av_iformat_next(AVInputFormat *f)
116 {
117 if(f) return f->next;
118 else return first_iformat;
119 }
120
121 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
122 {
123 if(f) return f->next;
124 else return first_oformat;
125 }
126
127 void av_register_input_format(AVInputFormat *format)
128 {
129 AVInputFormat **p;
130 p = &first_iformat;
131 while (*p != NULL) p = &(*p)->next;
132 *p = format;
133 format->next = NULL;
134 }
135
136 void av_register_output_format(AVOutputFormat *format)
137 {
138 AVOutputFormat **p;
139 p = &first_oformat;
140 while (*p != NULL) p = &(*p)->next;
141 *p = format;
142 format->next = NULL;
143 }
144
145 int av_match_ext(const char *filename, const char *extensions)
146 {
147 const char *ext, *p;
148 char ext1[32], *q;
149
150 if(!filename)
151 return 0;
152
153 ext = strrchr(filename, '.');
154 if (ext) {
155 ext++;
156 p = extensions;
157 for(;;) {
158 q = ext1;
159 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
160 *q++ = *p++;
161 *q = '\0';
162 if (!strcasecmp(ext1, ext))
163 return 1;
164 if (*p == '\0')
165 break;
166 p++;
167 }
168 }
169 return 0;
170 }
171
172 static int match_format(const char *name, const char *names)
173 {
174 const char *p;
175 int len, namelen;
176
177 if (!name || !names)
178 return 0;
179
180 namelen = strlen(name);
181 while ((p = strchr(names, ','))) {
182 len = FFMAX(p - names, namelen);
183 if (!strncasecmp(name, names, len))
184 return 1;
185 names = p+1;
186 }
187 return !strcasecmp(name, names);
188 }
189
190 #if LIBAVFORMAT_VERSION_MAJOR < 53
191 AVOutputFormat *guess_format(const char *short_name, const char *filename,
192 const char *mime_type)
193 {
194 return av_guess_format(short_name, filename, mime_type);
195 }
196 #endif
197
198 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
199 const char *mime_type)
200 {
201 AVOutputFormat *fmt, *fmt_found;
202 int score_max, score;
203
204 /* specific test for image sequences */
205 #if CONFIG_IMAGE2_MUXER
206 if (!short_name && filename &&
207 av_filename_number_test(filename) &&
208 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
209 return av_guess_format("image2", NULL, NULL);
210 }
211 #endif
212 /* Find the proper file type. */
213 fmt_found = NULL;
214 score_max = 0;
215 fmt = first_oformat;
216 while (fmt != NULL) {
217 score = 0;
218 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
219 score += 100;
220 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
221 score += 10;
222 if (filename && fmt->extensions &&
223 av_match_ext(filename, fmt->extensions)) {
224 score += 5;
225 }
226 if (score > score_max) {
227 score_max = score;
228 fmt_found = fmt;
229 }
230 fmt = fmt->next;
231 }
232 return fmt_found;
233 }
234
235 #if LIBAVFORMAT_VERSION_MAJOR < 53
236 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
237 const char *mime_type)
238 {
239 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
240
241 if (fmt) {
242 AVOutputFormat *stream_fmt;
243 char stream_format_name[64];
244
245 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
246 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
247
248 if (stream_fmt)
249 fmt = stream_fmt;
250 }
251
252 return fmt;
253 }
254 #endif
255
256 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
257 const char *filename, const char *mime_type, enum AVMediaType type){
258 if(type == AVMEDIA_TYPE_VIDEO){
259 enum CodecID codec_id= CODEC_ID_NONE;
260
261 #if CONFIG_IMAGE2_MUXER
262 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
263 codec_id= av_guess_image2_codec(filename);
264 }
265 #endif
266 if(codec_id == CODEC_ID_NONE)
267 codec_id= fmt->video_codec;
268 return codec_id;
269 }else if(type == AVMEDIA_TYPE_AUDIO)
270 return fmt->audio_codec;
271 else
272 return CODEC_ID_NONE;
273 }
274
275 AVInputFormat *av_find_input_format(const char *short_name)
276 {
277 AVInputFormat *fmt;
278 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
279 if (match_format(short_name, fmt->name))
280 return fmt;
281 }
282 return NULL;
283 }
284
285 /* memory handling */
286
287
288 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
289 {
290 int ret= av_new_packet(pkt, size);
291
292 if(ret<0)
293 return ret;
294
295 pkt->pos= url_ftell(s);
296
297 ret= get_buffer(s, pkt->data, size);
298 if(ret<=0)
299 av_free_packet(pkt);
300 else
301 av_shrink_packet(pkt, ret);
302
303 return ret;
304 }
305
306
307 int av_filename_number_test(const char *filename)
308 {
309 char buf[1024];
310 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
311 }
312
313 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
314 {
315 AVInputFormat *fmt1, *fmt;
316 int score;
317
318 fmt = NULL;
319 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
320 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
321 continue;
322 score = 0;
323 if (fmt1->read_probe) {
324 score = fmt1->read_probe(pd);
325 } else if (fmt1->extensions) {
326 if (av_match_ext(pd->filename, fmt1->extensions)) {
327 score = 50;
328 }
329 }
330 if (score > *score_max) {
331 *score_max = score;
332 fmt = fmt1;
333 }else if (score == *score_max)
334 fmt = NULL;
335 }
336 return fmt;
337 }
338
339 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
340 int score=0;
341 return av_probe_input_format2(pd, is_opened, &score);
342 }
343
344 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
345 {
346 AVInputFormat *fmt;
347 fmt = av_probe_input_format2(pd, 1, &score);
348
349 if (fmt) {
350 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
351 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
352 if (!strcmp(fmt->name, "mp3")) {
353 st->codec->codec_id = CODEC_ID_MP3;
354 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
355 } else if (!strcmp(fmt->name, "ac3")) {
356 st->codec->codec_id = CODEC_ID_AC3;
357 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
358 } else if (!strcmp(fmt->name, "eac3")) {
359 st->codec->codec_id = CODEC_ID_EAC3;
360 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
361 } else if (!strcmp(fmt->name, "mpegvideo")) {
362 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
363 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
364 } else if (!strcmp(fmt->name, "m4v")) {
365 st->codec->codec_id = CODEC_ID_MPEG4;
366 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
367 } else if (!strcmp(fmt->name, "h264")) {
368 st->codec->codec_id = CODEC_ID_H264;
369 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
370 } else if (!strcmp(fmt->name, "dts")) {
371 st->codec->codec_id = CODEC_ID_DTS;
372 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
373 } else if (!strcmp(fmt->name, "aac")) {
374 st->codec->codec_id = CODEC_ID_AAC;
375 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
376 }
377 }
378 return !!fmt;
379 }
380
381 /************************************************************/
382 /* input media file */
383
384 /**
385 * Open a media file from an IO stream. 'fmt' must be specified.
386 */
387 int av_open_input_stream(AVFormatContext **ic_ptr,
388 ByteIOContext *pb, const char *filename,
389 AVInputFormat *fmt, AVFormatParameters *ap)
390 {
391 int err;
392 AVFormatContext *ic;
393 AVFormatParameters default_ap;
394
395 if(!ap){
396 ap=&default_ap;
397 memset(ap, 0, sizeof(default_ap));
398 }
399
400 if(!ap->prealloced_context)
401 ic = avformat_alloc_context();
402 else
403 ic = *ic_ptr;
404 if (!ic) {
405 err = AVERROR(ENOMEM);
406 goto fail;
407 }
408 ic->iformat = fmt;
409 ic->pb = pb;
410 ic->duration = AV_NOPTS_VALUE;
411 ic->start_time = AV_NOPTS_VALUE;
412 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
413
414 /* allocate private data */
415 if (fmt->priv_data_size > 0) {
416 ic->priv_data = av_mallocz(fmt->priv_data_size);
417 if (!ic->priv_data) {
418 err = AVERROR(ENOMEM);
419 goto fail;
420 }
421 } else {
422 ic->priv_data = NULL;
423 }
424
425 if (ic->iformat->read_header) {
426 err = ic->iformat->read_header(ic, ap);
427 if (err < 0)
428 goto fail;
429 }
430
431 if (pb && !ic->data_offset)
432 ic->data_offset = url_ftell(ic->pb);
433
434 #if LIBAVFORMAT_VERSION_MAJOR < 53
435 ff_metadata_demux_compat(ic);
436 #endif
437
438 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
439
440 *ic_ptr = ic;
441 return 0;
442 fail:
443 if (ic) {
444 int i;
445 av_freep(&ic->priv_data);
446 for(i=0;i<ic->nb_streams;i++) {
447 AVStream *st = ic->streams[i];
448 if (st) {
449 av_free(st->priv_data);
450 av_free(st->codec->extradata);
451 }
452 av_free(st);
453 }
454 }
455 av_free(ic);
456 *ic_ptr = NULL;
457 return err;
458 }
459
460 /** size of probe buffer, for guessing file type from file contents */
461 #define PROBE_BUF_MIN 2048
462 #define PROBE_BUF_MAX (1<<20)
463
464 int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
465 const char *filename, void *logctx,
466 unsigned int offset, unsigned int max_probe_size)
467 {
468 AVProbeData pd = { filename ? filename : "", NULL, -offset };
469 unsigned char *buf = NULL;
470 int ret = 0, probe_size;
471
472 if (!max_probe_size) {
473 max_probe_size = PROBE_BUF_MAX;
474 } else if (max_probe_size > PROBE_BUF_MAX) {
475 max_probe_size = PROBE_BUF_MAX;
476 } else if (max_probe_size < PROBE_BUF_MIN) {
477 return AVERROR(EINVAL);
478 }
479
480 if (offset >= max_probe_size) {
481 return AVERROR(EINVAL);
482 }
483
484 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
485 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
486 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
487 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
488
489 if (probe_size < offset) {
490 continue;
491 }
492
493 /* read probe data */
494 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
495 if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
496 /* fail if error was not end of file, otherwise, lower score */
497 if (ret != AVERROR_EOF) {
498 av_free(buf);
499 return ret;
500 }
501 score = 0;
502 ret = 0; /* error was end of file, nothing read */
503 }
504 pd.buf_size += ret;
505 pd.buf = &buf[offset];
506
507 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
508
509 /* guess file format */
510 *fmt = av_probe_input_format2(&pd, 1, &score);
511 if(*fmt){
512 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
513 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
514 }else
515 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
516 }
517 }
518
519 av_free(buf);
520
521 if (!*fmt) {
522 return AVERROR_INVALIDDATA;
523 }
524
525 if (url_fseek(*pb, 0, SEEK_SET) < 0) {
526 url_fclose(*pb);
527 if (url_fopen(pb, filename, URL_RDONLY) < 0)
528 return AVERROR(EIO);
529 }
530
531 return 0;
532 }
533
534 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
535 AVInputFormat *fmt,
536 int buf_size,
537 AVFormatParameters *ap)
538 {
539 int err;
540 AVProbeData probe_data, *pd = &probe_data;
541 ByteIOContext *pb = NULL;
542 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
543
544 pd->filename = "";
545 if (filename)
546 pd->filename = filename;
547 pd->buf = NULL;
548 pd->buf_size = 0;
549
550 if (!fmt) {
551 /* guess format if no file can be opened */
552 fmt = av_probe_input_format(pd, 0);
553 }
554
555 /* Do not open file if the format does not need it. XXX: specific
556 hack needed to handle RTSP/TCP */
557 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
558 /* if no file needed do not try to open one */
559 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
560 goto fail;
561 }
562 if (buf_size > 0) {
563 url_setbufsize(pb, buf_size);
564 }
565 if ((err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, 0)) < 0) {
566 goto fail;
567 }
568 }
569
570 /* if still no format found, error */
571 if (!fmt) {
572 err = AVERROR_INVALIDDATA;
573 goto fail;
574 }
575
576 /* check filename in case an image number is expected */
577 if (fmt->flags & AVFMT_NEEDNUMBER) {
578 if (!av_filename_number_test(filename)) {
579 err = AVERROR_NUMEXPECTED;
580 goto fail;
581 }
582 }
583 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
584 if (err)
585 goto fail;
586 return 0;
587 fail:
588 av_freep(&pd->buf);
589 if (pb)
590 url_fclose(pb);
591 if (ap && ap->prealloced_context)
592 av_free(*ic_ptr);
593 *ic_ptr = NULL;
594 return err;
595
596 }
597
598 /*******************************************************/
599
600 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
601 AVPacketList **plast_pktl){
602 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
603 if (!pktl)
604 return NULL;
605
606 if (*packet_buffer)
607 (*plast_pktl)->next = pktl;
608 else
609 *packet_buffer = pktl;
610
611 /* add the packet in the buffered packet list */
612 *plast_pktl = pktl;
613 pktl->pkt= *pkt;
614 return &pktl->pkt;
615 }
616
617 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
618 {
619 int ret, i;
620 AVStream *st;
621
622 for(;;){
623 AVPacketList *pktl = s->raw_packet_buffer;
624
625 if (pktl) {
626 *pkt = pktl->pkt;
627 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
628 !s->streams[pkt->stream_index]->probe_packets ||
629 s->raw_packet_buffer_remaining_size < pkt->size){
630 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
631 av_freep(&pd->buf);
632 pd->buf_size = 0;
633 s->raw_packet_buffer = pktl->next;
634 s->raw_packet_buffer_remaining_size += pkt->size;
635 av_free(pktl);
636 return 0;
637 }
638 }
639
640 av_init_packet(pkt);
641 ret= s->iformat->read_packet(s, pkt);
642 if (ret < 0) {
643 if (!pktl || ret == AVERROR(EAGAIN))
644 return ret;
645 for (i = 0; i < s->nb_streams; i++)
646 s->streams[i]->probe_packets = 0;
647 continue;
648 }
649 st= s->streams[pkt->stream_index];
650
651 switch(st->codec->codec_type){
652 case AVMEDIA_TYPE_VIDEO:
653 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
654 break;
655 case AVMEDIA_TYPE_AUDIO:
656 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
657 break;
658 case AVMEDIA_TYPE_SUBTITLE:
659 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
660 break;
661 }
662
663 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
664 !st->probe_packets))
665 return ret;
666
667 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
668 s->raw_packet_buffer_remaining_size -= pkt->size;
669
670 if(st->codec->codec_id == CODEC_ID_PROBE){
671 AVProbeData *pd = &st->probe_data;
672 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
673 --st->probe_packets;
674
675 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
676 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
677 pd->buf_size += pkt->size;
678 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
679
680 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
681 set_codec_from_probe_data(s, st, pd, 1);
682 if(st->codec->codec_id != CODEC_ID_PROBE){
683 pd->buf_size=0;
684 av_freep(&pd->buf);
685 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
686 }
687 }
688 }
689 }
690 }
691
692 /**********************************************************/
693
694 /**
695 * Get the number of samples of an audio frame. Return -1 on error.
696 */
697 static int get_audio_frame_size(AVCodecContext *enc, int size)
698 {
699 int frame_size;
700
701 if(enc->codec_id == CODEC_ID_VORBIS)
702 return -1;
703
704 if (enc->frame_size <= 1) {
705 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
706
707 if (bits_per_sample) {
708 if (enc->channels == 0)
709 return -1;
710 frame_size = (size << 3) / (bits_per_sample * enc->channels);
711 } else {
712 /* used for example by ADPCM codecs */
713 if (enc->bit_rate == 0)
714 return -1;
715 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
716 }
717 } else {
718 frame_size = enc->frame_size;
719 }
720 return frame_size;
721 }
722
723
724 /**
725 * Return the frame duration in seconds. Return 0 if not available.
726 */
727 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
728 AVCodecParserContext *pc, AVPacket *pkt)
729 {
730 int frame_size;
731
732 *pnum = 0;
733 *pden = 0;
734 switch(st->codec->codec_type) {
735 case AVMEDIA_TYPE_VIDEO:
736 if(st->time_base.num*1000LL > st->time_base.den){
737 *pnum = st->time_base.num;
738 *pden = st->time_base.den;
739 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
740 *pnum = st->codec->time_base.num;
741 *pden = st->codec->time_base.den;
742 if (pc && pc->repeat_pict) {
743 *pnum = (*pnum) * (1 + pc->repeat_pict);
744 }
745 }
746 break;
747 case AVMEDIA_TYPE_AUDIO:
748 frame_size = get_audio_frame_size(st->codec, pkt->size);
749 if (frame_size < 0)
750 break;
751 *pnum = frame_size;
752 *pden = st->codec->sample_rate;
753 break;
754 default:
755 break;
756 }
757 }
758
759 static int is_intra_only(AVCodecContext *enc){
760 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
761 return 1;
762 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
763 switch(enc->codec_id){
764 case CODEC_ID_MJPEG:
765 case CODEC_ID_MJPEGB:
766 case CODEC_ID_LJPEG:
767 case CODEC_ID_RAWVIDEO:
768 case CODEC_ID_DVVIDEO:
769 case CODEC_ID_HUFFYUV:
770 case CODEC_ID_FFVHUFF:
771 case CODEC_ID_ASV1:
772 case CODEC_ID_ASV2:
773 case CODEC_ID_VCR1:
774 case CODEC_ID_DNXHD:
775 case CODEC_ID_JPEG2000:
776 return 1;
777 default: break;
778 }
779 }
780 return 0;
781 }
782
783 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
784 int64_t dts, int64_t pts)
785 {
786 AVStream *st= s->streams[stream_index];
787 AVPacketList *pktl= s->packet_buffer;
788
789 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
790 return;
791
792 st->first_dts= dts - st->cur_dts;
793 st->cur_dts= dts;
794
795 for(; pktl; pktl= pktl->next){
796 if(pktl->pkt.stream_index != stream_index)
797 continue;
798 //FIXME think more about this check
799 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
800 pktl->pkt.pts += st->first_dts;
801
802 if(pktl->pkt.dts != AV_NOPTS_VALUE)
803 pktl->pkt.dts += st->first_dts;
804
805 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
806 st->start_time= pktl->pkt.pts;
807 }
808 if (st->start_time == AV_NOPTS_VALUE)
809 st->start_time = pts;
810 }
811
812 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
813 {
814 AVPacketList *pktl= s->packet_buffer;
815 int64_t cur_dts= 0;
816
817 if(st->first_dts != AV_NOPTS_VALUE){
818 cur_dts= st->first_dts;
819 for(; pktl; pktl= pktl->next){
820 if(pktl->pkt.stream_index == pkt->stream_index){
821 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
822 break;
823 cur_dts -= pkt->duration;
824 }
825 }
826 pktl= s->packet_buffer;
827 st->first_dts = cur_dts;
828 }else if(st->cur_dts)
829 return;
830
831 for(; pktl; pktl= pktl->next){
832 if(pktl->pkt.stream_index != pkt->stream_index)
833 continue;
834 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
835 && !pktl->pkt.duration){
836 pktl->pkt.dts= cur_dts;
837 if(!st->codec->has_b_frames)
838 pktl->pkt.pts= cur_dts;
839 cur_dts += pkt->duration;
840 pktl->pkt.duration= pkt->duration;
841 }else
842 break;
843 }
844 if(st->first_dts == AV_NOPTS_VALUE)
845 st->cur_dts= cur_dts;
846 }
847
848 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
849 AVCodecParserContext *pc, AVPacket *pkt)
850 {
851 int num, den, presentation_delayed, delay, i;
852 int64_t offset;
853
854 if (s->flags & AVFMT_FLAG_NOFILLIN)
855 return;
856
857 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
858 pkt->dts= AV_NOPTS_VALUE;
859
860 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
861 //FIXME Set low_delay = 0 when has_b_frames = 1
862 st->codec->has_b_frames = 1;
863
864 /* do we have a video B-frame ? */
865 delay= st->codec->has_b_frames;
866 presentation_delayed = 0;
867 /* XXX: need has_b_frame, but cannot get it if the codec is
868 not initialized */
869 if (delay &&
870 pc && pc->pict_type != FF_B_TYPE)
871 presentation_delayed = 1;
872
873 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
874 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
875 pkt->dts -= 1LL<<st->pts_wrap_bits;
876 }
877
878 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
879 // we take the conservative approach and discard both
880 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
881 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
882 av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
883 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
884 }
885
886 if (pkt->duration == 0) {
887 compute_frame_duration(&num, &den, st, pc, pkt);
888 if (den && num) {
889 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
890
891 if(pkt->duration != 0 && s->packet_buffer)
892 update_initial_durations(s, st, pkt);
893 }
894 }
895
896 /* correct timestamps with byte offset if demuxers only have timestamps
897 on packet boundaries */
898 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
899 /* this will estimate bitrate based on this frame's duration and size */
900 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
901 if(pkt->pts != AV_NOPTS_VALUE)
902 pkt->pts += offset;
903 if(pkt->dts != AV_NOPTS_VALUE)
904 pkt->dts += offset;
905 }
906
907 if (pc && pc->dts_sync_point >= 0) {
908 // we have synchronization info from the parser
909 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
910 if (den > 0) {
911 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
912 if (pkt->dts != AV_NOPTS_VALUE) {
913 // got DTS from the stream, update reference timestamp
914 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
915 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
916 } else if (st->reference_dts != AV_NOPTS_VALUE) {
917 // compute DTS based on reference timestamp
918 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
919 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
920 }
921 if (pc->dts_sync_point > 0)
922 st->reference_dts = pkt->dts; // new reference
923 }
924 }
925
926 /* This may be redundant, but it should not hurt. */
927 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
928 presentation_delayed = 1;
929
930 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
931 /* interpolate PTS and DTS if they are not present */
932 //We skip H264 currently because delay and has_b_frames are not reliably set
933 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
934 if (presentation_delayed) {
935 /* DTS = decompression timestamp */
936 /* PTS = presentation timestamp */
937 if (pkt->dts == AV_NOPTS_VALUE)
938 pkt->dts = st->last_IP_pts;
939 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
940 if (pkt->dts == AV_NOPTS_VALUE)
941 pkt->dts = st->cur_dts;
942
943 /* this is tricky: the dts must be incremented by the duration
944 of the frame we are displaying, i.e. the last I- or P-frame */
945 if (st->last_IP_duration == 0)
946 st->last_IP_duration = pkt->duration;
947 if(pkt->dts != AV_NOPTS_VALUE)
948 st->cur_dts = pkt->dts + st->last_IP_duration;
949 st->last_IP_duration = pkt->duration;
950 st->last_IP_pts= pkt->pts;
951 /* cannot compute PTS if not present (we can compute it only
952 by knowing the future */
953 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
954 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
955 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
956 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
957 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
958 pkt->pts += pkt->duration;
959 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
960 }
961 }
962
963 /* presentation is not delayed : PTS and DTS are the same */
964 if(pkt->pts == AV_NOPTS_VALUE)
965 pkt->pts = pkt->dts;
966 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
967 if(pkt->pts == AV_NOPTS_VALUE)
968 pkt->pts = st->cur_dts;
969 pkt->dts = pkt->pts;
970 if(pkt->pts != AV_NOPTS_VALUE)
971 st->cur_dts = pkt->pts + pkt->duration;
972 }
973 }
974
975 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
976 st->pts_buffer[0]= pkt->pts;
977 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
978 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
979 if(pkt->dts == AV_NOPTS_VALUE)
980 pkt->dts= st->pts_buffer[0];
981 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
982 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
983 }
984 if(pkt->dts > st->cur_dts)
985 st->cur_dts = pkt->dts;
986 }
987
988 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
989
990 /* update flags */
991 if(is_intra_only(st->codec))
992 pkt->flags |= AV_PKT_FLAG_KEY;
993 else if (pc) {
994 pkt->flags = 0;
995 /* keyframe computation */
996 if (pc->key_frame == 1)
997 pkt->flags |= AV_PKT_FLAG_KEY;
998 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
999 pkt->flags |= AV_PKT_FLAG_KEY;
1000 }
1001 if (pc)
1002 pkt->convergence_duration = pc->convergence_duration;
1003 }
1004
1005
1006 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1007 {
1008 AVStream *st;
1009 int len, ret, i;
1010
1011 av_init_packet(pkt);
1012
1013 for(;;) {
1014 /* select current input stream component */
1015 st = s->cur_st;
1016 if (st) {
1017 if (!st->need_parsing || !st->parser) {
1018 /* no parsing needed: we just output the packet as is */
1019 /* raw data support */
1020 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1021 compute_pkt_fields(s, st, NULL, pkt);
1022 s->cur_st = NULL;
1023 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1024 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1025 ff_reduce_index(s, st->index);
1026 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1027 }
1028 break;
1029 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1030 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1031 st->cur_ptr, st->cur_len,
1032 st->cur_pkt.pts, st->cur_pkt.dts,
1033 st->cur_pkt.pos);
1034 st->cur_pkt.pts = AV_NOPTS_VALUE;
1035 st->cur_pkt.dts = AV_NOPTS_VALUE;
1036 /* increment read pointer */
1037 st->cur_ptr += len;
1038 st->cur_len -= len;
1039
1040 /* return packet if any */
1041 if (pkt->size) {
1042 got_packet:
1043 pkt->duration = 0;
1044 pkt->stream_index = st->index;
1045 pkt->pts = st->parser->pts;
1046 pkt->dts = st->parser->dts;
1047 pkt->pos = st->parser->pos;
1048 pkt->destruct = NULL;
1049 compute_pkt_fields(s, st, st->parser, pkt);
1050
1051 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1052 ff_reduce_index(s, st->index);
1053 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1054 0, 0, AVINDEX_KEYFRAME);
1055 }
1056
1057 break;
1058 }
1059 } else {
1060 /* free packet */
1061 av_free_packet(&st->cur_pkt);
1062 s->cur_st = NULL;
1063 }
1064 } else {
1065 AVPacket cur_pkt;
1066 /* read next packet */
1067 ret = av_read_packet(s, &cur_pkt);
1068 if (ret < 0) {
1069 if (ret == AVERROR(EAGAIN))
1070 return ret;
1071 /* return the last frames, if any */
1072 for(i = 0; i < s->nb_streams; i++) {
1073 st = s->streams[i];
1074 if (st->parser && st->need_parsing) {
1075 av_parser_parse2(st->parser, st->codec,
1076 &pkt->data, &pkt->size,
1077 NULL, 0,
1078 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1079 AV_NOPTS_VALUE);
1080 if (pkt->size)
1081 goto got_packet;
1082 }
1083 }
1084 /* no more packets: really terminate parsing */
1085 return ret;
1086 }
1087 st = s->streams[cur_pkt.stream_index];
1088 st->cur_pkt= cur_pkt;
1089
1090 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1091 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1092 st->cur_pkt.pts < st->cur_pkt.dts){
1093 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1094 st->cur_pkt.stream_index,
1095 st->cur_pkt.pts,
1096 st->cur_pkt.dts,
1097 st->cur_pkt.size);
1098 // av_free_packet(&st->cur_pkt);
1099 // return -1;
1100 }
1101
1102 if(s->debug & FF_FDEBUG_TS)
1103 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1104 st->cur_pkt.stream_index,
1105 st->cur_pkt.pts,
1106 st->cur_pkt.dts,
1107 st->cur_pkt.size,
1108 st->cur_pkt.duration,
1109 st->cur_pkt.flags);
1110
1111 s->cur_st = st;
1112 st->cur_ptr = st->cur_pkt.data;
1113 st->cur_len = st->cur_pkt.size;
1114 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1115 st->parser = av_parser_init(st->codec->codec_id);
1116 if (!st->parser) {
1117 /* no parser available: just output the raw packets */
1118 st->need_parsing = AVSTREAM_PARSE_NONE;
1119 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1120 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1121 }
1122 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1123 st->parser->next_frame_offset=
1124 st->parser->cur_offset= st->cur_pkt.pos;
1125 }
1126 }
1127 }
1128 }
1129 if(s->debug & FF_FDEBUG_TS)
1130 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1131 pkt->stream_index,
1132 pkt->pts,
1133 pkt->dts,
1134 pkt->size,
1135 pkt->duration,
1136 pkt->flags);
1137
1138 return 0;
1139 }
1140
1141 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1142 {
1143 AVPacketList *pktl;
1144 int eof=0;
1145 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1146
1147 for(;;){
1148 pktl = s->packet_buffer;
1149 if (pktl) {
1150 AVPacket *next_pkt= &pktl->pkt;
1151
1152 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1153 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1154 if( pktl->pkt.stream_index == next_pkt->stream_index
1155 && next_pkt->dts < pktl->pkt.dts
1156 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1157 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1158 next_pkt->pts= pktl->pkt.dts;
1159 }
1160 pktl= pktl->next;
1161 }
1162 pktl = s->packet_buffer;
1163 }
1164
1165 if( next_pkt->pts != AV_NOPTS_VALUE
1166 || next_pkt->dts == AV_NOPTS_VALUE
1167 || !genpts || eof){
1168 /* read packet from packet buffer, if there is data */
1169 *pkt = *next_pkt;
1170 s->packet_buffer = pktl->next;
1171 av_free(pktl);
1172 return 0;
1173 }
1174 }
1175 if(genpts){
1176 int ret= av_read_frame_internal(s, pkt);
1177 if(ret<0){
1178 if(pktl && ret != AVERROR(EAGAIN)){
1179 eof=1;
1180 continue;
1181 }else
1182 return ret;
1183 }
1184
1185 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1186 &s->packet_buffer_end)) < 0)
1187 return AVERROR(ENOMEM);
1188 }else{
1189 assert(!s->packet_buffer);
1190 return av_read_frame_internal(s, pkt);
1191 }
1192 }
1193 }
1194
1195 /* XXX: suppress the packet queue */
1196 static void flush_packet_queue(AVFormatContext *s)
1197 {
1198 AVPacketList *pktl;
1199
1200 for(;;) {
1201 pktl = s->packet_buffer;
1202 if (!pktl)
1203 break;
1204 s->packet_buffer = pktl->next;
1205 av_free_packet(&pktl->pkt);
1206 av_free(pktl);
1207 }
1208 while(s->raw_packet_buffer){
1209 pktl = s->raw_packet_buffer;
1210 s->raw_packet_buffer = pktl->next;
1211 av_free_packet(&pktl->pkt);
1212 av_free(pktl);
1213 }
1214 s->packet_buffer_end=
1215 s->raw_packet_buffer_end= NULL;
1216 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1217 }
1218
1219 /*******************************************************/
1220 /* seek support */
1221
1222 int av_find_default_stream_index(AVFormatContext *s)
1223 {
1224 int first_audio_index = -1;
1225 int i;
1226 AVStream *st;
1227
1228 if (s->nb_streams <= 0)
1229 return -1;
1230 for(i = 0; i < s->nb_streams; i++) {
1231 st = s->streams[i];
1232 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1233 return i;
1234 }
1235 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1236 first_audio_index = i;
1237 }
1238 return first_audio_index >= 0 ? first_audio_index : 0;
1239 }
1240
1241 /**
1242 * Flush the frame reader.
1243 */
1244 void ff_read_frame_flush(AVFormatContext *s)
1245 {
1246 AVStream *st;
1247 int i, j;
1248
1249 flush_packet_queue(s);
1250
1251 s->cur_st = NULL;
1252
1253 /* for each stream, reset read state */
1254 for(i = 0; i < s->nb_streams; i++) {
1255 st = s->streams[i];
1256
1257 if (st->parser) {
1258 av_parser_close(st->parser);
1259 st->parser = NULL;
1260 av_free_packet(&st->cur_pkt);
1261 }
1262 st->last_IP_pts = AV_NOPTS_VALUE;
1263 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1264 st->reference_dts = AV_NOPTS_VALUE;
1265 /* fail safe */
1266 st->cur_ptr = NULL;
1267 st->cur_len = 0;
1268
1269 st->probe_packets = MAX_PROBE_PACKETS;
1270
1271 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1272 st->pts_buffer[j]= AV_NOPTS_VALUE;
1273 }
1274 }
1275
1276 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1277 int i;
1278
1279 for(i = 0; i < s->nb_streams; i++) {
1280 AVStream *st = s->streams[i];
1281
1282 st->cur_dts = av_rescale(timestamp,
1283 st->time_base.den * (int64_t)ref_st->time_base.num,
1284 st->time_base.num * (int64_t)ref_st->time_base.den);
1285 }
1286 }
1287
1288 void ff_reduce_index(AVFormatContext *s, int stream_index)
1289 {
1290 AVStream *st= s->streams[stream_index];
1291 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1292
1293 if((unsigned)st->nb_index_entries >= max_entries){
1294 int i;
1295 for(i=0; 2*i<st->nb_index_entries; i++)
1296 st->index_entries[i]= st->index_entries[2*i];
1297 st->nb_index_entries= i;
1298 }
1299 }
1300
1301 int av_add_index_entry(AVStream *st,
1302 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1303 {
1304 AVIndexEntry *entries, *ie;
1305 int index;
1306
1307 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1308 return -1;
1309
1310 entries = av_fast_realloc(st->index_entries,
1311 &st->index_entries_allocated_size,
1312 (st->nb_index_entries + 1) *
1313 sizeof(AVIndexEntry));
1314 if(!entries)
1315 return -1;
1316
1317 st->index_entries= entries;
1318
1319 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1320
1321 if(index<0){
1322 index= st->nb_index_entries++;
1323 ie= &entries[index];
1324 assert(index==0 || ie[-1].timestamp < timestamp);
1325 }else{
1326 ie= &entries[index];
1327 if(ie->timestamp != timestamp){
1328 if(ie->timestamp <= timestamp)
1329 return -1;
1330 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1331 st->nb_index_entries++;
1332 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1333 distance= ie->min_distance;
1334 }
1335
1336 ie->pos = pos;
1337 ie->timestamp = timestamp;
1338 ie->min_distance= distance;
1339 ie->size= size;
1340 ie->flags = flags;
1341
1342 return index;
1343 }
1344
1345 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1346 int flags)
1347 {
1348 AVIndexEntry *entries= st->index_entries;
1349 int nb_entries= st->nb_index_entries;
1350 int a, b, m;
1351 int64_t timestamp;
1352
1353 a = - 1;
1354 b = nb_entries;
1355
1356 //optimize appending index entries at the end
1357 if(b && entries[b-1].timestamp < wanted_timestamp)
1358 a= b-1;
1359
1360 while (b - a > 1) {
1361 m = (a + b) >> 1;
1362 timestamp = entries[m].timestamp;
1363 if(timestamp >= wanted_timestamp)
1364 b = m;
1365 if(timestamp <= wanted_timestamp)
1366 a = m;
1367 }
1368 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1369
1370 if(!(flags & AVSEEK_FLAG_ANY)){
1371 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1372 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1373 }
1374 }
1375
1376 if(m == nb_entries)
1377 return -1;
1378 return m;
1379 }
1380
1381 #define DEBUG_SEEK
1382
1383 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1384 AVInputFormat *avif= s->iformat;
1385 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1386 int64_t ts_min, ts_max, ts;
1387 int index;
1388 int64_t ret;
1389 AVStream *st;
1390
1391 if (stream_index < 0)
1392 return -1;
1393
1394 #ifdef DEBUG_SEEK
1395 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1396 #endif
1397
1398 ts_max=
1399 ts_min= AV_NOPTS_VALUE;
1400 pos_limit= -1; //gcc falsely says it may be uninitialized
1401
1402 st= s->streams[stream_index];
1403 if(st->index_entries){
1404 AVIndexEntry *e;
1405
1406 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()
1407 index= FFMAX(index, 0);
1408 e= &st->index_entries[index];
1409
1410 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1411 pos_min= e->pos;
1412 ts_min= e->timestamp;
1413 #ifdef DEBUG_SEEK
1414 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1415 pos_min,ts_min);
1416 #endif
1417 }else{
1418 assert(index==0);
1419 }
1420
1421 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1422 assert(index < st->nb_index_entries);
1423 if(index >= 0){
1424 e= &st->index_entries[index];
1425 assert(e->timestamp >= target_ts);
1426 pos_max= e->pos;
1427 ts_max= e->timestamp;
1428 pos_limit= pos_max - e->min_distance;
1429 #ifdef DEBUG_SEEK
1430 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1431 pos_max,pos_limit, ts_max);
1432 #endif
1433 }
1434 }
1435
1436 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1437 if(pos<0)
1438 return -1;
1439
1440 /* do the seek */
1441 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1442 return ret;
1443
1444 av_update_cur_dts(s, st, ts);
1445
1446 return 0;
1447 }
1448
1449 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1450 int64_t pos, ts;
1451 int64_t start_pos, filesize;
1452 int no_change;
1453
1454 #ifdef DEBUG_SEEK
1455 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1456 #endif
1457
1458 if(ts_min == AV_NOPTS_VALUE){
1459 pos_min = s->data_offset;
1460 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1461 if (ts_min == AV_NOPTS_VALUE)
1462 return -1;
1463 }
1464
1465 if(ts_max == AV_NOPTS_VALUE){
1466 int step= 1024;
1467 filesize = url_fsize(s->pb);
1468 pos_max = filesize - 1;
1469 do{
1470 pos_max -= step;
1471 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1472 step += step;
1473 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1474 if (ts_max == AV_NOPTS_VALUE)
1475 return -1;
1476
1477 for(;;){
1478 int64_t tmp_pos= pos_max + 1;
1479 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1480 if(tmp_ts == AV_NOPTS_VALUE)
1481 break;
1482 ts_max= tmp_ts;
1483 pos_max= tmp_pos;
1484 if(tmp_pos >= filesize)
1485 break;
1486 }
1487 pos_limit= pos_max;
1488 }
1489
1490 if(ts_min > ts_max){
1491 return -1;
1492 }else if(ts_min == ts_max){
1493 pos_limit= pos_min;
1494 }
1495
1496 no_change=0;
1497 while (pos_min < pos_limit) {
1498 #ifdef DEBUG_SEEK
1499 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1500 pos_min, pos_max,
1501 ts_min, ts_max);
1502 #endif
1503 assert(pos_limit <= pos_max);
1504
1505 if(no_change==0){
1506 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1507 // interpolate position (better than dichotomy)
1508 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1509 + pos_min - approximate_keyframe_distance;
1510 }else if(no_change==1){
1511 // bisection, if interpolation failed to change min or max pos last time
1512 pos = (pos_min + pos_limit)>>1;
1513 }else{
1514 /* linear search if bisection failed, can only happen if there
1515 are very few or no keyframes between min/max */
1516 pos=pos_min;
1517 }
1518 if(pos <= pos_min)
1519 pos= pos_min + 1;
1520 else if(pos > pos_limit)
1521 pos= pos_limit;
1522 start_pos= pos;
1523
1524 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1525 if(pos == pos_max)
1526 no_change++;
1527 else
1528 no_change=0;
1529 #ifdef DEBUG_SEEK
1530 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1531 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1532 start_pos, no_change);
1533 #endif
1534 if(ts == AV_NOPTS_VALUE){
1535 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1536 return -1;
1537 }
1538 assert(ts != AV_NOPTS_VALUE);
1539 if (target_ts <= ts) {
1540 pos_limit = start_pos - 1;
1541 pos_max = pos;
1542 ts_max = ts;
1543 }
1544 if (target_ts >= ts) {
1545 pos_min = pos;
1546 ts_min = ts;
1547 }
1548 }
1549
1550 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1551 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1552 #ifdef DEBUG_SEEK
1553 pos_min = pos;
1554 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1555 pos_min++;
1556 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1557 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1558 pos, ts_min, target_ts, ts_max);
1559 #endif
1560 *ts_ret= ts;
1561 return pos;
1562 }
1563
1564 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1565 int64_t pos_min, pos_max;
1566 #if 0
1567 AVStream *st;
1568
1569 if (stream_index < 0)
1570 return -1;
1571
1572 st= s->streams[stream_index];
1573 #endif
1574
1575 pos_min = s->data_offset;
1576 pos_max = url_fsize(s->pb) - 1;
1577
1578 if (pos < pos_min) pos= pos_min;
1579 else if(pos > pos_max) pos= pos_max;
1580
1581 url_fseek(s->pb, pos, SEEK_SET);
1582
1583 #if 0
1584 av_update_cur_dts(s, st, ts);
1585 #endif
1586 return 0;
1587 }
1588
1589 static int av_seek_frame_generic(AVFormatContext *s,
1590 int stream_index, int64_t timestamp, int flags)
1591 {
1592 int index;
1593 int64_t ret;
1594 AVStream *st;
1595 AVIndexEntry *ie;
1596
1597 st = s->streams[stream_index];
1598
1599 index = av_index_search_timestamp(st, timestamp, flags);
1600
1601 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1602 return -1;
1603
1604 if(index < 0 || index==st->nb_index_entries-1){
1605 int i;
1606 AVPacket pkt;
1607
1608 if(st->nb_index_entries){
1609 assert(st->index_entries);
1610 ie= &st->index_entries[st->nb_index_entries-1];
1611 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1612 return ret;
1613 av_update_cur_dts(s, st, ie->timestamp);
1614 }else{
1615 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1616 return ret;
1617 }
1618 for(i=0;; i++) {
1619 int ret;
1620 do{
1621 ret = av_read_frame(s, &pkt);
1622 }while(ret == AVERROR(EAGAIN));
1623 if(ret<0)
1624 break;
1625 av_free_packet(&pkt);
1626 if(stream_index == pkt.stream_index){
1627 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1628 break;
1629 }
1630 }
1631 index = av_index_search_timestamp(st, timestamp, flags);
1632 }
1633 if (index < 0)
1634 return -1;
1635
1636 ff_read_frame_flush(s);
1637 if (s->iformat->read_seek){
1638 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1639 return 0;
1640 }
1641 ie = &st->index_entries[index];
1642 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1643 return ret;
1644 av_update_cur_dts(s, st, ie->timestamp);
1645
1646 return 0;
1647 }
1648
1649 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1650 {
1651 int ret;
1652 AVStream *st;
1653
1654 ff_read_frame_flush(s);
1655
1656 if(flags & AVSEEK_FLAG_BYTE)
1657 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1658
1659 if(stream_index < 0){
1660 stream_index= av_find_default_stream_index(s);
1661 if(stream_index < 0)
1662 return -1;
1663
1664 st= s->streams[stream_index];
1665 /* timestamp for default must be expressed in AV_TIME_BASE units */
1666 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1667 }
1668
1669 /* first, we try the format specific seek */
1670 if (s->iformat->read_seek)
1671 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1672 else
1673 ret = -1;
1674 if (ret >= 0) {
1675 return 0;
1676 }
1677
1678 if(s->iformat->read_timestamp)
1679 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1680 else
1681 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1682 }
1683
1684 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1685 {
1686 if(min_ts > ts || max_ts < ts)
1687 return -1;
1688
1689 ff_read_frame_flush(s);
1690
1691 if (s->iformat->read_seek2)
1692 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1693
1694 if(s->iformat->read_timestamp){
1695 //try to seek via read_timestamp()
1696 }
1697
1698 //Fallback to old API if new is not implemented but old is
1699 //Note the old has somewat different sematics
1700 if(s->iformat->read_seek || 1)
1701 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1702
1703 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1704 }
1705
1706 /*******************************************************/
1707
1708 /**
1709 * Returns TRUE if the stream has accurate duration in any stream.
1710 *
1711 * @return TRUE if the stream has accurate duration for at least one component.
1712 */
1713 static int av_has_duration(AVFormatContext *ic)
1714 {
1715 int i;
1716 AVStream *st;
1717
1718 for(i = 0;i < ic->nb_streams; i++) {
1719 st = ic->streams[i];
1720 if (st->duration != AV_NOPTS_VALUE)
1721 return 1;
1722 }
1723 return 0;
1724 }
1725
1726 /**
1727 * Estimate the stream timings from the one of each components.
1728 *
1729 * Also computes the global bitrate if possible.
1730 */
1731 static void av_update_stream_timings(AVFormatContext *ic)
1732 {
1733 int64_t start_time, start_time1, end_time, end_time1;
1734 int64_t duration, duration1;
1735 int i;
1736 AVStream *st;
1737
1738 start_time = INT64_MAX;
1739 end_time = INT64_MIN;
1740 duration = INT64_MIN;
1741 for(i = 0;i < ic->nb_streams; i++) {
1742 st = ic->streams[i];
1743 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1744 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1745 if (start_time1 < start_time)
1746 start_time = start_time1;
1747 if (st->duration != AV_NOPTS_VALUE) {
1748 end_time1 = start_time1
1749 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1750 if (end_time1 > end_time)
1751 end_time = end_time1;
1752 }
1753 }
1754 if (st->duration != AV_NOPTS_VALUE) {
1755 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1756 if (duration1 > duration)
1757 duration = duration1;
1758 }
1759 }
1760 if (start_time != INT64_MAX) {
1761 ic->start_time = start_time;
1762 if (end_time != INT64_MIN) {
1763 if (end_time - start_time > duration)
1764 duration = end_time - start_time;
1765 }
1766 }
1767 if (duration != INT64_MIN) {
1768 ic->duration = duration;
1769 if (ic->file_size > 0) {
1770 /* compute the bitrate */
1771 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1772 (double)ic->duration;
1773 }
1774 }
1775 }
1776
1777 static void fill_all_stream_timings(AVFormatContext *ic)
1778 {
1779 int i;
1780 AVStream *st;
1781
1782 av_update_stream_timings(ic);
1783 for(i = 0;i < ic->nb_streams; i++) {
1784 st = ic->streams[i];
1785 if (st->start_time == AV_NOPTS_VALUE) {
1786 if(ic->start_time != AV_NOPTS_VALUE)
1787 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1788 if(ic->duration != AV_NOPTS_VALUE)
1789 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1790 }
1791 }
1792 }
1793
1794 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1795 {
1796 int64_t filesize, duration;
1797 int bit_rate, i;
1798 AVStream *st;
1799
1800 /* if bit_rate is already set, we believe it */
1801 if (ic->bit_rate == 0) {
1802 bit_rate = 0;
1803 for(i=0;i<ic->nb_streams;i++) {
1804 st = ic->streams[i];
1805 bit_rate += st->codec->bit_rate;
1806 }
1807 ic->bit_rate = bit_rate;
1808 }
1809
1810 /* if duration is already set, we believe it */
1811 if (ic->duration == AV_NOPTS_VALUE &&
1812 ic->bit_rate != 0 &&
1813 ic->file_size != 0) {
1814 filesize = ic->file_size;
1815 if (filesize > 0) {
1816 for(i = 0; i < ic->nb_streams; i++) {
1817 st = ic->streams[i];
1818 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1819 if (st->duration == AV_NOPTS_VALUE)
1820 st->duration = duration;
1821 }
1822 }
1823 }
1824 }
1825
1826 #define DURATION_MAX_READ_SIZE 250000
1827 #define DURATION_MAX_RETRY 3
1828
1829 /* only usable for MPEG-PS streams */
1830 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1831 {
1832 AVPacket pkt1, *pkt = &pkt1;
1833 AVStream *st;
1834 int read_size, i, ret;
1835 int64_t end_time, start_time[MAX_STREAMS];
1836 int64_t filesize, offset, duration;
1837 int retry=0;
1838
1839 ic->cur_st = NULL;
1840
1841 /* flush packet queue */
1842 flush_packet_queue(ic);
1843
1844 for(i=0;i<ic->nb_streams;i++) {
1845 st = ic->streams[i];
1846 if(st->start_time != AV_NOPTS_VALUE){
1847 start_time[i]= st->start_time;
1848 }else if(st->first_dts != AV_NOPTS_VALUE){
1849 start_time[i]= st->first_dts;
1850 }else
1851 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1852
1853 if (st->parser) {
1854 av_parser_close(st->parser);
1855 st->parser= NULL;
1856 av_free_packet(&st->cur_pkt);
1857 }
1858 }
1859
1860 /* estimate the end time (duration) */
1861 /* XXX: may need to support wrapping */
1862 filesize = ic->file_size;
1863 end_time = AV_NOPTS_VALUE;
1864 do{
1865 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1866 if (offset < 0)
1867 offset = 0;
1868
1869 url_fseek(ic->pb, offset, SEEK_SET);
1870 read_size = 0;
1871 for(;;) {
1872 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1873 break;
1874
1875 do{
1876 ret = av_read_packet(ic, pkt);
1877 }while(ret == AVERROR(EAGAIN));
1878 if (ret != 0)
1879 break;
1880 read_size += pkt->size;
1881 st = ic->streams[pkt->stream_index];
1882 if (pkt->pts != AV_NOPTS_VALUE &&
1883 start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1884 end_time = pkt->pts;
1885 duration = end_time - start_time[pkt->stream_index];
1886 if (duration < 0)
1887 duration += 1LL<<st->pts_wrap_bits;
1888 if (duration > 0) {
1889 if (st->duration == AV_NOPTS_VALUE ||
1890 st->duration < duration)
1891 st->duration = duration;
1892 }
1893 }
1894 av_free_packet(pkt);
1895 }
1896 }while( end_time==AV_NOPTS_VALUE
1897 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1898 && ++retry <= DURATION_MAX_RETRY);
1899
1900 fill_all_stream_timings(ic);
1901
1902 url_fseek(ic->pb, old_offset, SEEK_SET);
1903 for(i=0; i<ic->nb_streams; i++){
1904 st= ic->streams[i];
1905 st->cur_dts= st->first_dts;
1906 st->last_IP_pts = AV_NOPTS_VALUE;
1907 }
1908 }
1909
1910 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1911 {
1912 int64_t file_size;
1913
1914 /* get the file size, if possible */
1915 if (ic->iformat->flags & AVFMT_NOFILE) {
1916 file_size = 0;
1917 } else {
1918 file_size = url_fsize(ic->pb);
1919 if (file_size < 0)
1920 file_size = 0;
1921 }
1922 ic->file_size = file_size;
1923
1924 if ((!strcmp(ic->iformat->name, "mpeg") ||
1925 !strcmp(ic->iformat->name, "mpegts")) &&
1926 file_size && !url_is_streamed(ic->pb)) {
1927 /* get accurate estimate from the PTSes */
1928 av_estimate_timings_from_pts(ic, old_offset);
1929 } else if (av_has_duration(ic)) {
1930 /* at least one component has timings - we use them for all
1931 the components */
1932 fill_all_stream_timings(ic);
1933 } else {
1934 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1935 /* less precise: use bitrate info */
1936 av_estimate_timings_from_bit_rate(ic);
1937 }
1938 av_update_stream_timings(ic);
1939
1940 #if 0
1941 {
1942 int i;
1943 AVStream *st;
1944 for(i = 0;i < ic->nb_streams; i++) {
1945 st = ic->streams[i];
1946 printf("%d: start_time: %0.3f duration: %0.3f\n",
1947 i, (double)st->start_time / AV_TIME_BASE,
1948 (double)st->duration / AV_TIME_BASE);
1949 }
1950 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1951 (double)ic->start_time / AV_TIME_BASE,
1952 (double)ic->duration / AV_TIME_BASE,
1953 ic->bit_rate / 1000);
1954 }
1955 #endif
1956 }
1957
1958 static int has_codec_parameters(AVCodecContext *enc)
1959 {
1960 int val;
1961 switch(enc->codec_type) {
1962 case AVMEDIA_TYPE_AUDIO:
1963 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1964 if(!enc->frame_size &&
1965 (enc->codec_id == CODEC_ID_VORBIS ||
1966 enc->codec_id == CODEC_ID_AAC ||
1967 enc->codec_id == CODEC_ID_MP1 ||
1968 enc->codec_id == CODEC_ID_MP2 ||
1969 enc->codec_id == CODEC_ID_MP3 ||
1970 enc->codec_id == CODEC_ID_SPEEX))
1971 return 0;
1972 break;
1973 case AVMEDIA_TYPE_VIDEO:
1974 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1975 break;
1976 default:
1977 val = 1;
1978 break;
1979 }
1980 return enc->codec_id != CODEC_ID_NONE && val != 0;
1981 }
1982
1983 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1984 {
1985 int16_t *samples;
1986 AVCodec *codec;
1987 int got_picture, data_size, ret=0;
1988 AVFrame picture;
1989
1990 if(!st->codec->codec){
1991 codec = avcodec_find_decoder(st->codec->codec_id);
1992 if (!codec)
1993 return -1;
1994 ret = avcodec_open(st->codec, codec);
1995 if (ret < 0)
1996 return ret;
1997 }
1998
1999 if(!has_codec_parameters(st->codec)){
2000 switch(st->codec->codec_type) {
2001 case AVMEDIA_TYPE_VIDEO:
2002 avcodec_get_frame_defaults(&picture);
2003 ret = avcodec_decode_video2(st->codec, &picture,
2004 &got_picture, avpkt);
2005 break;
2006 case AVMEDIA_TYPE_AUDIO:
2007 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2008 samples = av_malloc(data_size);
2009 if (!samples)
2010 goto fail;
2011 ret = avcodec_decode_audio3(st->codec, samples,
2012 &data_size, avpkt);
2013 av_free(samples);
2014 break;
2015 default:
2016 break;
2017 }
2018 }
2019 fail:
2020 return ret;
2021 }
2022
2023 unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2024 {
2025 while (tags->id != CODEC_ID_NONE) {
2026 if (tags->id == id)
2027 return tags->tag;
2028 tags++;
2029 }
2030 return 0;
2031 }
2032
2033 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2034 {
2035 int i;
2036 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2037 if(tag == tags[i].tag)
2038 return tags[i].id;
2039 }
2040 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2041 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2042 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2043 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2044 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
2045 return tags[i].id;
2046 }
2047 return CODEC_ID_NONE;
2048 }
2049
2050 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2051 {
2052 int i;
2053 for(i=0; tags && tags[i]; i++){
2054 int tag= ff_codec_get_tag(tags[i], id);
2055 if(tag) return tag;
2056 }
2057 return 0;
2058 }
2059
2060 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2061 {
2062 int i;
2063 for(i=0; tags && tags[i]; i++){
2064 enum CodecID id= ff_codec_get_id(tags[i], tag);
2065 if(id!=CODEC_ID_NONE) return id;
2066 }
2067 return CODEC_ID_NONE;
2068 }
2069
2070 static void compute_chapters_end(AVFormatContext *s)
2071 {
2072 unsigned int i;
2073
2074 for (i=0; i+1<s->nb_chapters; i++)
2075 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2076 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2077 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2078 s->chapters[i]->end = s->chapters[i+1]->start;
2079 }
2080
2081 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2082 assert(s->start_time != AV_NOPTS_VALUE);
2083 assert(s->duration > 0);
2084 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2085 AV_TIME_BASE_Q,
2086 s->chapters[i]->time_base);
2087 }
2088 }
2089
2090 #define MAX_STD_TIMEBASES (60*12+5)
2091 static int get_std_framerate(int i){
2092 if(i<60*12) return i*1001;
2093 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2094 }
2095
2096 /*
2097 * Is the time base unreliable.
2098 * This is a heuristic to balance between quick acceptance of the values in
2099 * the headers vs. some extra checks.
2100 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2101 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2102 * And there are "variable" fps files this needs to detect as well.
2103 */
2104 static int tb_unreliable(AVCodecContext *c){
2105 if( c->time_base.den >= 101L*c->time_base.num
2106 || c->time_base.den < 5L*c->time_base.num
2107 /* || c->codec_tag == AV_RL32("DIVX")
2108 || c->codec_tag == AV_RL32("XVID")*/
2109 || c->codec_id == CODEC_ID_MPEG2VIDEO
2110 || c->codec_id == CODEC_ID_H264
2111 )
2112 return 1;
2113 return 0;
2114 }
2115
2116 int av_find_stream_info(AVFormatContext *ic)
2117 {
2118 int i, count, ret, read_size, j;
2119 AVStream *st;
2120 AVPacket pkt1, *pkt;
2121 int64_t last_dts[MAX_STREAMS];
2122 int64_t duration_gcd[MAX_STREAMS]={0};
2123 int duration_count[MAX_STREAMS]={0};
2124 double (*duration_error)[MAX_STD_TIMEBASES];
2125 int64_t old_offset = url_ftell(ic->pb);
2126 int64_t codec_info_duration[MAX_STREAMS]={0};
2127
2128 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2129 if (!duration_error) return AVERROR(ENOMEM);
2130
2131 for(i=0;i<ic->nb_streams;i++) {
2132 st = ic->streams[i];
2133 if (st->codec->codec_id == CODEC_ID_AAC) {
2134 st->codec->sample_rate = 0;
2135 st->codec->frame_size = 0;
2136 st->codec->channels = 0;
2137 }
2138 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2139 /* if(!st->time_base.num)
2140 st->time_base= */
2141 if(!st->codec->time_base.num)
2142 st->codec->time_base= st->time_base;
2143 }
2144 //only for the split stuff
2145 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2146 st->parser = av_parser_init(st->codec->codec_id);
2147 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2148 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2149 }
2150 }
2151 assert(!st->codec->codec);
2152 //try to just open decoders, in case this is enough to get parameters
2153 if(!has_codec_parameters(st->codec)){
2154 AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2155 if (codec)
2156 avcodec_open(st->codec, codec);
2157 }
2158 }
2159
2160 for(i=0;i<MAX_STREAMS;i++){
2161 last_dts[i]= AV_NOPTS_VALUE;
2162 }
2163
2164 count = 0;
2165 read_size = 0;
2166 for(;;) {
2167 if(url_interrupt_cb()){
2168 ret= AVERROR(EINTR);
2169 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2170 break;
2171 }
2172
2173 /* check if one codec still needs to be handled */
2174 for(i=0;i<ic->nb_streams;i++) {
2175 st = ic->streams[i];
2176 if (!has_codec_parameters(st->codec))
2177 break;
2178 /* variable fps and no guess at the real fps */
2179 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2180 && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2181 break;
2182 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2183 break;
2184 if(st->first_dts == AV_NOPTS_VALUE)
2185 break;
2186 }
2187 if (i == ic->nb_streams) {
2188 /* NOTE: if the format has no header, then we need to read
2189 some packets to get most of the streams, so we cannot
2190 stop here */
2191 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2192 /* if we found the info for all the codecs, we can stop */
2193 ret = count;
2194 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2195 break;
2196 }
2197 }
2198 /* we did not get all the codec info, but we read too much data */
2199 if (read_size >= ic->probesize) {
2200 ret = count;
2201 av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2202 break;
2203 }
2204
2205 /* NOTE: a new stream can be added there if no header in file
2206 (AVFMTCTX_NOHEADER) */
2207 ret = av_read_frame_internal(ic, &pkt1);
2208 if(ret == AVERROR(EAGAIN))
2209 continue;
2210 if (ret < 0) {
2211 /* EOF or error */
2212 ret = -1; /* we could not have all the codec parameters before EOF */
2213 for(i=0;i<ic->nb_streams;i++) {
2214 st = ic->streams[i];
2215 if (!has_codec_parameters(st->codec)){
2216 char buf[256];
2217 avcodec_string(buf, sizeof(buf), st->codec, 0);
2218 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2219 } else {
2220 ret = 0;
2221 }
2222 }
2223 break;
2224 }
2225
2226 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2227 if(av_dup_packet(pkt) < 0) {
2228 av_free(duration_error);
2229 return AVERROR(ENOMEM);
2230 }
2231
2232 read_size += pkt->size;
2233
2234 st = ic->streams[pkt->stream_index];
2235 if(st->codec_info_nb_frames>1) {
2236 if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2237 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2238 break;
2239 }
2240 codec_info_duration[st->index] += pkt->duration;
2241 }
2242 st->codec_info_nb_frames++;
2243
2244 {
2245 int index= pkt->stream_index;
2246 int64_t last= last_dts[index];
2247 int64_t duration= pkt->dts - last;
2248
2249 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2250 double dur= duration * av_q2d(st->time_base);
2251
2252 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2253 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2254 if(duration_count[index] < 2)
2255 memset(duration_error[index], 0, sizeof(*duration_error));
2256 for(i=1; i<MAX_STD_TIMEBASES; i++){
2257 int framerate= get_std_framerate(i);
2258 int ticks= lrintf(dur*framerate/(1001*12));
2259 double error= dur - ticks*1001*12/(double)framerate;
2260 duration_error[index][i] += error*error;
2261 }
2262 duration_count[index]++;
2263 // ignore the first 4 values, they might have some random jitter
2264 if (duration_count[index] > 3)
2265 duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2266 }
2267 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2268 last_dts[pkt->stream_index]= pkt->dts;
2269 }
2270 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2271 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2272 if(i){
2273 st->codec->extradata_size= i;
2274 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2275 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2276 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2277 }
2278 }
2279
2280 /* if still no information, we try to open the codec and to
2281 decompress the frame. We try to avoid that in most cases as
2282 it takes longer and uses more memory. For MPEG-4, we need to
2283 decompress for QuickTime. */
2284 if (!has_codec_parameters(st->codec))
2285 try_decode_frame(st, pkt);
2286
2287 count++;
2288 }
2289
2290 // close codecs which were opened in try_decode_frame()
2291 for(i=0;i<ic->nb_streams;i++) {
2292 st = ic->streams[i];
2293 if(st->codec->codec)
2294 avcodec_close(st->codec);
2295 }
2296 for(i=0;i<ic->nb_streams;i++) {
2297 st = ic->streams[i];
2298 if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2299 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2300 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2301 codec_info_duration[i] *(int64_t)st->time_base.num, 60000);
2302 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2303 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2304 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2305
2306 // the check for tb_unreliable() is not completely correct, since this is not about handling
2307 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2308 // ipmovie.c produces.
2309 if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2310 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2311 if(duration_count[i] && !st->r_frame_rate.num
2312 && tb_unreliable(st->codec) /*&&
2313 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2314 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2315 int num = 0;
2316 double best_error= 2*av_q2d(st->time_base);
2317 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2318
2319 for(j=1; j<MAX_STD_TIMEBASES; j++){
2320 double error= duration_error[i][j] * get_std_framerate(j);
2321 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2322 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2323 if(error < best_error){
2324 best_error= error;
2325 num = get_std_framerate(j);
2326 }
2327 }
2328 // do not increase frame rate by more than 1 % in order to match a standard rate.
2329 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2330 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2331 }
2332
2333 if (!st->r_frame_rate.num){
2334 if( st->codec->time_base.den * (int64_t)st->time_base.num
2335 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2336 st->r_frame_rate.num = st->codec->time_base.den;
2337 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2338 }else{
2339 st->r_frame_rate.num = st->time_base.den;
2340 st->r_frame_rate.den = st->time_base.num;
2341 }
2342 }
2343 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2344 if(!st->codec->bits_per_coded_sample)
2345 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2346 }
2347 }
2348
2349 av_estimate_timings(ic, old_offset);
2350
2351 compute_chapters_end(ic);
2352
2353 #if 0
2354 /* correct DTS for B-frame streams with no timestamps */
2355 for(i=0;i<ic->nb_streams;i++) {
2356 st = ic->streams[i];
2357 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2358 if(b-frames){
2359 ppktl = &ic->packet_buffer;
2360 while(ppkt1){
2361 if(ppkt1->stream_index != i)
2362 continue;
2363 if(ppkt1->pkt->dts < 0)
2364 break;
2365 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2366 break;
2367 ppkt1->pkt->dts -= delta;
2368 ppkt1= ppkt1->next;
2369 }
2370 if(ppkt1)
2371 continue;
2372 st->cur_dts -= delta;
2373 }
2374 }
2375 }
2376 #endif
2377
2378 av_free(duration_error);
2379
2380 return ret;
2381 }
2382
2383 /*******************************************************/
2384
2385 int av_read_play(AVFormatContext *s)
2386 {
2387 if (s->iformat->read_play)
2388 return s->iformat->read_play(s);
2389 if (s->pb)
2390 return av_url_read_fpause(s->pb, 0);
2391 return AVERROR(ENOSYS);
2392 }
2393
2394 int av_read_pause(AVFormatContext *s)
2395 {
2396 if (s->iformat->read_pause)
2397 return s->iformat->read_pause(s);
2398 if (s->pb)
2399 return av_url_read_fpause(s->pb, 1);
2400 return AVERROR(ENOSYS);
2401 }
2402
2403 void av_close_input_stream(AVFormatContext *s)
2404 {
2405 int i;
2406 AVStream *st;
2407
2408 if (s->iformat->read_close)
2409 s->iformat->read_close(s);
2410 for(i=0;i<s->nb_streams;i++) {
2411 /* free all data in a stream component */
2412 st = s->streams[i];
2413 if (st->parser) {
2414 av_parser_close(st->parser);
2415 av_free_packet(&st->cur_pkt);
2416 }
2417 av_metadata_free(&st->metadata);
2418 av_free(st->index_entries);
2419 av_free(st->codec->extradata);
2420 av_free(st->codec);
2421 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2422 av_free(st->filename);
2423 #endif
2424 av_free(st->priv_data);
2425 av_free(st);
2426 }
2427 for(i=s->nb_programs-1; i>=0; i--) {
2428 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2429 av_freep(&s->programs[i]->provider_name);
2430 av_freep(&s->programs[i]->name);
2431 #endif
2432 av_metadata_free(&s->programs[i]->metadata);
2433 av_freep(&s->programs[i]->stream_index);
2434 av_freep(&s->programs[i]);
2435 }
2436 av_freep(&s->programs);
2437 flush_packet_queue(s);
2438 av_freep(&s->priv_data);
2439 while(s->nb_chapters--) {
2440 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2441 av_free(s->chapters[s->nb_chapters]->title);
2442 #endif
2443 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2444 av_free(s->chapters[s->nb_chapters]);
2445 }
2446 av_freep(&s->chapters);
2447 av_metadata_free(&s->metadata);
2448 av_free(s);
2449 }
2450
2451 void av_close_input_file(AVFormatContext *s)
2452 {
2453 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2454 av_close_input_stream(s);
2455 if (pb)
2456 url_fclose(pb);
2457 }
2458
2459 AVStream *av_new_stream(AVFormatContext *s, int id)
2460 {
2461 AVStream *st;
2462 int i;
2463
2464 if (s->nb_streams >= MAX_STREAMS)
2465 return NULL;
2466
2467 st = av_mallocz(sizeof(AVStream));
2468 if (!st)
2469 return NULL;
2470
2471 st->codec= avcodec_alloc_context();
2472 if (s->iformat) {
2473 /* no default bitrate if decoding */
2474 st->codec->bit_rate = 0;
2475 }
2476 st->index = s->nb_streams;
2477 st->id = id;
2478 st->start_time = AV_NOPTS_VALUE;
2479 st->duration = AV_NOPTS_VALUE;
2480 /* we set the current DTS to 0 so that formats without any timestamps
2481 but durations get some timestamps, formats with some unknown
2482 timestamps have their first few packets buffered and the
2483 timestamps corrected before they are returned to the user */
2484 st->cur_dts = 0;
2485 st->first_dts = AV_NOPTS_VALUE;
2486 st->probe_packets = MAX_PROBE_PACKETS;
2487
2488 /* default pts setting is MPEG-like */
2489 av_set_pts_info(st, 33, 1, 90000);
2490 st->last_IP_pts = AV_NOPTS_VALUE;
2491 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2492 st->pts_buffer[i]= AV_NOPTS_VALUE;
2493 st->reference_dts = AV_NOPTS_VALUE;
2494
2495 st->sample_aspect_ratio = (AVRational){0,1};
2496
2497 s->streams[s->nb_streams++] = st;
2498 return st;
2499 }
2500
2501 AVProgram *av_new_program(AVFormatContext *ac, int id)
2502 {
2503 AVProgram *program=NULL;
2504 int i;
2505
2506 #ifdef DEBUG_SI
2507 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2508 #endif
2509
2510 for(i=0; i<ac->nb_programs; i++)
2511 if(ac->programs[i]->id == id)
2512 program = ac->programs[i];
2513
2514 if(!program){
2515 program = av_mallocz(sizeof(AVProgram));
2516 if (!program)
2517 return NULL;
2518 dynarray_add(&ac->programs, &ac->nb_programs, program);
2519 program->discard = AVDISCARD_NONE;
2520 }
2521 program->id = id;
2522
2523 return program;
2524 }
2525
2526 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2527 {
2528 AVChapter *chapter = NULL;
2529 int i;
2530
2531 for(i=0; i<s->nb_chapters; i++)
2532 if(s->chapters[i]->id == id)
2533 chapter = s->chapters[i];
2534
2535 if(!chapter){
2536 chapter= av_mallocz(sizeof(AVChapter));
2537 if(!chapter)
2538 return NULL;
2539 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2540 }
2541 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2542 av_free(chapter->title);
2543 #endif
2544 av_metadata_set(&chapter->metadata, "title", title);
2545 chapter->id = id;
2546 chapter->time_base= time_base;
2547 chapter->start = start;
2548 chapter->end = end;
2549
2550 return chapter;
2551 }
2552
2553 /************************************************************/
2554 /* output media file */
2555
2556 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2557 {
2558 int ret;
2559
2560 if (s->oformat->priv_data_size > 0) {
2561 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2562 if (!s->priv_data)
2563 return AVERROR(ENOMEM);
2564 } else
2565 s->priv_data = NULL;
2566
2567 if (s->oformat->set_parameters) {
2568 ret = s->oformat->set_parameters(s, ap);
2569 if (ret < 0)
2570 return ret;
2571 }
2572 return 0;
2573 }
2574
2575 int av_write_header(AVFormatContext *s)
2576 {
2577 int ret, i;
2578 AVStream *st;
2579
2580 // some sanity checks
2581 if (s->nb_streams == 0) {
2582 av_log(s, AV_LOG_ERROR, "no streams\n");
2583 return -1;
2584 }
2585
2586 for(i=0;i<s->nb_streams;i++) {
2587 st = s->streams[i];
2588
2589 switch (st->codec->codec_type) {
2590 case AVMEDIA_TYPE_AUDIO:
2591 if(st->codec->sample_rate<=0){
2592 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2593 return -1;
2594 }
2595 if(!st->codec->block_align)
2596 st->codec->block_align = st->codec->channels *
2597 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2598 break;
2599 case AVMEDIA_TYPE_VIDEO:
2600 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2601 av_log(s, AV_LOG_ERROR, "time base not set\n");
2602 return -1;
2603 }
2604 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2605 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2606 return -1;
2607 }
2608 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2609 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2610 return -1;
2611 }
2612 break;
2613 }
2614
2615 if(s->oformat->codec_tag){
2616 if(st->codec->codec_tag){
2617 //FIXME
2618 //check that tag + id is in the table
2619 //if neither is in the table -> OK
2620 //if tag is in the table with another id -> FAIL
2621 //if id is in the table with another tag -> FAIL unless strict < ?
2622 }else
2623 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2624 }
2625
2626 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2627 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2628 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2629 }
2630
2631 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2632 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2633 if (!s->priv_data)
2634 return AVERROR(ENOMEM);
2635 }
2636
2637 #if LIBAVFORMAT_VERSION_MAJOR < 53
2638 ff_metadata_mux_compat(s);
2639 #endif
2640
2641 /* set muxer identification string */
2642 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2643 AVMetadata *m;
2644 AVMetadataTag *t;
2645
2646 if (!(m = av_mallocz(sizeof(AVMetadata))))
2647 return AVERROR(ENOMEM);
2648 av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2649 metadata_conv(&m, s->oformat->metadata_conv, NULL);
2650 if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2651 av_metadata_set2(&s->metadata, t->key, t->value, 0);
2652 av_metadata_free(&m);
2653 }
2654
2655 if(s->oformat->write_header){
2656 ret = s->oformat->write_header(s);
2657 if (ret < 0)
2658 return ret;
2659 }
2660
2661 /* init PTS generation */
2662 for(i=0;i<s->nb_streams;i++) {
2663 int64_t den = AV_NOPTS_VALUE;
2664 st = s->streams[i];
2665
2666 switch (st->codec->codec_type) {
2667 case AVMEDIA_TYPE_AUDIO:
2668 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2669 break;
2670 case AVMEDIA_TYPE_VIDEO:
2671 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2672 break;
2673 default:
2674 break;
2675 }
2676 if (den != AV_NOPTS_VALUE) {
2677 if (den <= 0)
2678 return AVERROR_INVALIDDATA;
2679 av_frac_init(&st->pts, 0, 0, den);
2680 }
2681 }
2682 return 0;
2683 }
2684
2685 //FIXME merge with compute_pkt_fields
2686 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2687 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2688 int num, den, frame_size, i;
2689
2690 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2691
2692 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2693 return -1;*/
2694
2695 /* duration field */
2696 if (pkt->duration == 0) {
2697 compute_frame_duration(&num, &den, st, NULL, pkt);
2698 if (den && num) {
2699 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2700 }
2701 }
2702
2703 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2704 pkt->pts= pkt->dts;
2705
2706 //XXX/FIXME this is a temporary hack until all encoders output pts
2707 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2708 pkt->dts=
2709 // pkt->pts= st->cur_dts;
2710 pkt->pts= st->pts.val;
2711 }
2712
2713 //calculate dts from pts
2714 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2715 st->pts_buffer[0]= pkt->pts;
2716 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2717 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2718 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2719 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2720
2721 pkt->dts= st->pts_buffer[0];
2722 }
2723
2724 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2725 av_log(s, AV_LOG_ERROR,
2726 "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2727 st->index, st->cur_dts, pkt->dts);
2728 return -1;
2729 }
2730 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2731 av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2732 return -1;
2733 }
2734
2735 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2736 st->cur_dts= pkt->dts;
2737 st->pts.val= pkt->dts;
2738
2739 /* update pts */
2740 switch (st->codec->codec_type) {
2741 case AVMEDIA_TYPE_AUDIO:
2742 frame_size = get_audio_frame_size(st->codec, pkt->size);
2743
2744 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2745 likely equal to the encoder delay, but it would be better if we
2746 had the real timestamps from the encoder */
2747 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2748 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2749 }
2750 break;
2751 case AVMEDIA_TYPE_VIDEO:
2752 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2753 break;
2754 default:
2755 break;
2756 }
2757 return 0;
2758 }
2759
2760 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2761 {
2762 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2763
2764 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2765 return ret;
2766
2767 ret= s->oformat->write_packet(s, pkt);
2768 if(!ret)
2769 ret= url_ferror(s->pb);
2770 return ret;
2771 }
2772
2773 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2774 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2775 {
2776 AVPacketList **next_point, *this_pktl;
2777
2778 this_pktl = av_mallocz(sizeof(AVPacketList));
2779 this_pktl->pkt= *pkt;
2780 pkt->destruct= NULL; // do not free original but only the copy
2781 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2782
2783 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2784 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2785 }else
2786 next_point = &s->packet_buffer;
2787
2788 if(*next_point){
2789 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2790 while(!compare(s, &(*next_point)->pkt, pkt)){
2791 next_point= &(*next_point)->next;
2792 }
2793 goto next_non_null;
2794 }else{
2795 next_point = &(s->packet_buffer_end->next);
2796 }
2797 }
2798 assert(!*next_point);
2799
2800 s->packet_buffer_end= this_pktl;
2801 next_non_null:
2802
2803 this_pktl->next= *next_point;
2804
2805 s->streams[pkt->stream_index]->last_in_packet_buffer=
2806 *next_point= this_pktl;
2807 }
2808
2809 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2810 {
2811 AVStream *st = s->streams[ pkt ->stream_index];
2812 AVStream *st2= s->streams[ next->stream_index];
2813 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2814 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2815 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2816 }
2817
2818 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2819 AVPacketList *pktl;
2820 int stream_count=0;
2821 int i;
2822
2823 if(pkt){
2824 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2825 }
2826
2827 for(i=0; i < s->nb_streams; i++)
2828 stream_count+= !!s->streams[i]->last_in_packet_buffer;
2829
2830 if(stream_count && (s->nb_streams == stream_count || flush)){
2831 pktl= s->packet_buffer;
2832 *out= pktl->pkt;
2833
2834 s->packet_buffer= pktl->next;
2835 if(!s->packet_buffer)
2836 s->packet_buffer_end= NULL;
2837
2838 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2839 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2840 av_freep(&pktl);
2841 return 1;
2842 }else{
2843 av_init_packet(out);
2844 return 0;
2845 }
2846 }
2847
2848 /**
2849 * Interleaves an AVPacket correctly so it can be muxed.
2850 * @param out the interleaved packet will be output here
2851 * @param in the input packet
2852 * @param flush 1 if no further packets are available as input and all
2853 * remaining packets should be output
2854 * @return 1 if a packet was output, 0 if no packet could be output,
2855 * < 0 if an error occurred
2856 */
2857 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2858 if(s->oformat->interleave_packet)
2859 return s->oformat->interleave_packet(s, out, in, flush);
2860 else
2861 return av_interleave_packet_per_dts(s, out, in, flush);
2862 }
2863
2864 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2865 AVStream *st= s->streams[ pkt->stream_index];
2866
2867 //FIXME/XXX/HACK drop zero sized packets
2868 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2869 return 0;
2870
2871 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2872 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2873 return -1;
2874
2875 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2876 return -1;
2877
2878 for(;;){
2879 AVPacket opkt;
2880 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2881 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2882 return ret;
2883
2884 ret= s->oformat->write_packet(s, &opkt);
2885
2886 av_free_packet(&opkt);
2887 pkt= NULL;
2888
2889 if(ret<0)
2890 return ret;
2891 if(url_ferror(s->pb))
2892 return url_ferror(s->pb);
2893 }
2894 }
2895
2896 int av_write_trailer(AVFormatContext *s)
2897 {
2898 int ret, i;
2899
2900 for(;;){
2901 AVPacket pkt;
2902 ret= av_interleave_packet(s, &pkt, NULL, 1);
2903 if(ret<0) //FIXME cleanup needed for ret<0 ?
2904 goto fail;
2905 if(!ret)
2906 break;
2907
2908 ret= s->oformat->write_packet(s, &pkt);
2909
2910 av_free_packet(&pkt);
2911
2912 if(ret<0)
2913 goto fail;
2914 if(url_ferror(s->pb))
2915 goto fail;
2916 }
2917
2918 if(s->oformat->write_trailer)
2919 ret = s->oformat->write_trailer(s);
2920 fail:
2921 if(ret == 0)
2922 ret=url_ferror(s->pb);
2923 for(i=0;i<s->nb_streams;i++) {
2924 av_freep(&s->streams[i]->priv_data);
2925 av_freep(&s->streams[i]->index_entries);
2926 }
2927 av_freep(&s->priv_data);
2928 return ret;
2929 }
2930
2931 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2932 {
2933 int i, j;
2934 AVProgram *program=NULL;
2935 void *tmp;
2936
2937 if (idx >= ac->nb_streams) {
2938 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2939 return;
2940 }
2941
2942 for(i=0; i<ac->nb_programs; i++){
2943 if(ac->programs[i]->id != progid)
2944 continue;
2945 program = ac->programs[i];
2946 for(j=0; j<program->nb_stream_indexes; j++)
2947 if(program->stream_index[j] == idx)
2948 return;
2949
2950 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2951 if(!tmp)
2952 return;
2953 program->stream_index = tmp;
2954 program->stream_index[program->nb_stream_indexes++] = idx;
2955 return;
2956 }
2957 }
2958
2959 static void print_fps(double d, const char *postfix){
2960 uint64_t v= lrintf(d*100);
2961 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2962 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2963 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2964 }
2965
2966 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2967 {
2968 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2969 AVMetadataTag *tag=NULL;
2970
2971 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2972 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2973 if(strcmp("language", tag->key))
2974 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
2975 }
2976 }
2977 }
2978
2979 /* "user interface" functions */
2980 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2981 {
2982 char buf[256];
2983 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2984 AVStream *st = ic->streams[i];
2985 int g = av_gcd(st->time_base.num, st->time_base.den);
2986 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2987 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2988 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2989 /* the pid is an important information, so we display it */
2990 /* XXX: add a generic system */
2991 if (flags & AVFMT_SHOW_IDS)
2992 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2993 if (lang)
2994 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2995 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2996 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2997 if (st->sample_aspect_ratio.num && // default
2998 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2999 AVRational display_aspect_ratio;
3000 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3001 st->codec->width*st->sample_aspect_ratio.num,
3002 st->codec->height*st->sample_aspect_ratio.den,
3003 1024*1024);
3004 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3005 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3006 display_aspect_ratio.num, display_aspect_ratio.den);
3007 }
3008 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3009 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3010 print_fps(av_q2d(st->avg_frame_rate), "fps");
3011 if(st->r_frame_rate.den && st->r_frame_rate.num)
3012 print_fps(av_q2d(st->r_frame_rate), "tbr");
3013 if(st->time_base.den && st->time_base.num)
3014 print_fps(1/av_q2d(st->time_base), "tbn");
3015 if(st->codec->time_base.den && st->codec->time_base.num)
3016 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3017 }
3018 av_log(NULL, AV_LOG_INFO, "\n");
3019 dump_metadata(NULL, st->metadata, " ");
3020 }
3021
3022 void dump_format(AVFormatContext *ic,
3023 int index,
3024 const char *url,
3025 int is_output)
3026 {
3027 int i;
3028 uint8_t *printed = av_mallocz(ic->nb_streams);
3029 if (ic->nb_streams && !printed)
3030 return;
3031
3032 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3033 is_output ? "Output" : "Input",
3034 index,
3035 is_output ? ic->oformat->name : ic->iformat->name,
3036 is_output ? "to" : "from", url);
3037 dump_metadata(NULL, ic->metadata, " ");
3038 if (!is_output) {
3039 av_log(NULL, AV_LOG_INFO, " Duration: ");
3040 if (ic->duration != AV_NOPTS_VALUE) {
3041 int hours, mins, secs, us;
3042 secs = ic->duration / AV_TIME_BASE;
3043 us = ic->duration % AV_TIME_BASE;
3044 mins = secs / 60;
3045 secs %= 60;
3046 hours = mins / 60;
3047 mins %= 60;
3048 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3049 (100 * us) / AV_TIME_BASE);
3050 } else {
3051 av_log(NULL, AV_LOG_INFO, "N/A");
3052 }
3053 if (ic->start_time != AV_NOPTS_VALUE) {
3054 int secs, us;
3055 av_log(NULL, AV_LOG_INFO, ", start: ");
3056 secs = ic->start_time / AV_TIME_BASE;
3057 us = ic->start_time % AV_TIME_BASE;
3058 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3059 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3060 }
3061 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3062 if (ic->bit_rate) {
3063 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3064 } else {
3065 av_log(NULL, AV_LOG_INFO, "N/A");
3066 }
3067 av_log(NULL, AV_LOG_INFO, "\n");
3068 }
3069 for (i = 0; i < ic->nb_chapters; i++) {
3070 AVChapter *ch = ic->chapters[i];
3071 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3072 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3073 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3074
3075 dump_metadata(NULL, ch->metadata, " ");
3076 }
3077 if(ic->nb_programs) {
3078 int j, k, total = 0;
3079 for(j=0; j<ic->nb_programs; j++) {
3080 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3081 "name", NULL, 0);
3082 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3083 name ? name->value : "");
3084 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3085 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3086 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3087 printed[ic->programs[j]->stream_index[k]] = 1;
3088 }
3089 total += ic->programs[j]->nb_stream_indexes;
3090 }
3091 if (total < ic->nb_streams)
3092 av_log(NULL, AV_LOG_INFO, " No Program\n");
3093 }
3094 for(i=0;i<ic->nb_streams;i++)
3095 if (!printed[i])
3096 dump_stream_format(ic, i, index, is_output);
3097
3098 av_free(printed);
3099 }
3100
3101 #if LIBAVFORMAT_VERSION_MAJOR < 53
3102 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3103 {
3104 return av_parse_video_frame_size(width_ptr, height_ptr, str);
3105 }
3106
3107 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3108 {
3109 AVRational frame_rate;
3110 int ret = av_parse_video_frame_rate(&frame_rate, arg);
3111 *frame_rate_num= frame_rate.num;
3112 *frame_rate_den= frame_rate.den;
3113 return ret;
3114 }
3115 #endif
3116
3117 int64_t av_gettime(void)
3118 {
3119 struct timeval tv;
3120 gettimeofday(&tv,NULL);
3121 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3122 }
3123
3124 uint64_t ff_ntp_time(void)
3125 {
3126 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3127 }
3128
3129 int64_t parse_date(const char *datestr, int duration)
3130 {
3131 const char *p;
3132 int64_t t;
3133 struct tm dt;
3134 int i;
3135 static const char * const date_fmt[] = {
3136 "%Y-%m-%d",
3137 "%Y%m%d",
3138 };
3139 static const char * const time_fmt[] = {
3140 "%H:%M:%S",
3141 "%H%M%S",
3142 };
3143 const char *q;
3144 int is_utc, len;
3145 char lastch;
3146 int negative = 0;
3147
3148 #undef time
3149 time_t now = time(0);
3150
3151 len = strlen(datestr);
3152 if (len > 0)
3153 lastch = datestr[len - 1];
3154 else
3155 lastch = '\0';
3156 is_utc = (lastch == 'z' || lastch == 'Z');
3157
3158 memset(&dt, 0, sizeof(dt));
3159
3160 p = datestr;
3161 q = NULL;
3162 if (!duration) {
3163 if (!strncasecmp(datestr, "now", len))
3164 return (int64_t) now * 1000000;
3165
3166 /* parse the year-month-day part */
3167 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3168 q = small_strptime(p, date_fmt[i], &dt);
3169 if (q) {
3170 break;
3171 }
3172 }
3173
3174 /* if the year-month-day part is missing, then take the
3175 * current year-month-day time */
3176 if (!q) {
3177 if (is_utc) {
3178 dt = *gmtime(&now);
3179 } else {
3180 dt = *localtime(&now);
3181 }
3182 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3183 } else {
3184 p = q;
3185 }
3186
3187 if (*p == 'T' || *p == 't' || *p == ' ')
3188 p++;
3189
3190 /* parse the hour-minute-second part */
3191 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3192 q = small_strptime(p, time_fmt[i], &dt);
3193 if (q) {
3194 break;
3195 }
3196 }
3197 } else {
3198 /* parse datestr as a duration */
3199 if (p[0] == '-') {
3200 negative = 1;
3201 ++p;
3202 }
3203 /* parse datestr as HH:MM:SS */
3204 q = small_strptime(p, time_fmt[0], &dt);
3205 if (!q) {
3206 /* parse datestr as S+ */
3207 dt.tm_sec = strtol(p, (char **)&q, 10);
3208 if (q == p)
3209 /* the parsing didn't succeed */
3210 return INT64_MIN;
3211 dt.tm_min = 0;
3212 dt.tm_hour = 0;
3213 }
3214 }
3215
3216 /* Now we have all the fields that we can get */
3217 if (!q) {
3218 return INT64_MIN;
3219 }
3220
3221 if (duration) {
3222 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3223 } else {
3224 dt.tm_isdst = -1; /* unknown */
3225 if (is_utc) {
3226 t = mktimegm(&dt);
3227 } else {
3228 t = mktime(&dt);
3229 }
3230 }
3231
3232 t *= 1000000;
3233
3234 /* parse the .m... part */
3235 if (*q == '.') {
3236 int val, n;
3237 q++;
3238 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3239 if (!isdigit(*q))
3240 break;
3241 val += n * (*q - '0');
3242 }
3243 t += val;
3244 }
3245 return negative ? -t : t;
3246 }
3247
3248 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3249 {
3250 const char *p;
3251 char tag[128], *q;
3252
3253 p = info;
3254 if (*p == '?')
3255 p++;
3256 for(;;) {
3257 q = tag;
3258 while (*p != '\0' && *p != '=' && *p != '&') {
3259 if ((q - tag) < sizeof(tag) - 1)
3260 *q++ = *p;
3261 p++;
3262 }
3263 *q = '\0';
3264 q = arg;
3265 if (*p == '=') {
3266 p++;
3267 while (*p != '&' && *p != '\0') {
3268 if ((q - arg) < arg_size - 1) {
3269 if (*p == '+')
3270 *q++ = ' ';
3271 else
3272 *q++ = *p;
3273 }
3274 p++;
3275 }
3276 *q = '\0';
3277 }
3278 if (!strcmp(tag, tag1))
3279 return 1;
3280 if (*p != '&')
3281 break;
3282 p++;
3283 }
3284 return 0;
3285 }
3286
3287 int av_get_frame_filename(char *buf, int buf_size,
3288 const char *path, int number)
3289 {
3290 const char *p;
3291 char *q, buf1[20], c;
3292 int nd, len, percentd_found;
3293
3294 q = buf;
3295 p = path;
3296 percentd_found = 0;
3297 for(;;) {
3298 c = *p++;
3299 if (c == '\0')
3300 break;
3301 if (c == '%') {
3302 do {
3303 nd = 0;
3304 while (isdigit(*p)) {
3305 nd = nd * 10 + *p++ - '0';
3306 }
3307 c = *p++;
3308 } while (isdigit(c));
3309
3310 switch(c) {
3311 case '%':
3312 goto addchar;
3313 case 'd':
3314 if (percentd_found)
3315 goto fail;
3316 percentd_found = 1;
3317 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3318 len = strlen(buf1);
3319 if ((q - buf + len) > buf_size - 1)
3320 goto fail;
3321 memcpy(q, buf1, len);
3322 q += len;
3323 break;
3324 default:
3325 goto fail;
3326 }
3327 } else {
3328 addchar:
3329 if ((q - buf) < buf_size - 1)
3330 *q++ = c;
3331 }
3332 }
3333 if (!percentd_found)
3334 goto fail;
3335 *q = '\0';
3336 return 0;
3337 fail:
3338 *q = '\0';
3339 return -1;
3340 }
3341
3342 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3343 {
3344 int len, i, j, c;
3345 #undef fprintf
3346 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3347
3348 for(i=0;i<size;i+=16) {
3349 len = size - i;
3350 if (len > 16)
3351 len = 16;
3352 PRINT("%08x ", i);
3353 for(j=0;j<16;j++) {
3354 if (j < len)
3355 PRINT(" %02x", buf[i+j]);
3356 else
3357 PRINT(" ");
3358 }
3359 PRINT(" ");
3360 for(j=0;j<len;j++) {
3361 c = buf[i+j];
3362 if (c < ' ' || c > '~')
3363 c = '.';
3364 PRINT("%c", c);
3365 }
3366 PRINT("\n");
3367 }
3368 #undef PRINT
3369 }
3370
3371 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3372 {
3373 hex_dump_internal(NULL, f, 0, buf, size);
3374 }
3375
3376 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3377 {
3378 hex_dump_internal(avcl, NULL, level, buf, size);
3379 }
3380
3381 //FIXME needs to know the time_base
3382 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3383 {
3384 #undef fprintf
3385 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3386 PRINT("stream #%d:\n", pkt->stream_index);
3387 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3388 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3389 /* DTS is _always_ valid after av_read_frame() */
3390 PRINT(" dts=");
3391 if (pkt->dts == AV_NOPTS_VALUE)
3392 PRINT("N/A");
3393 else
3394 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3395 /* PTS may not be known if B-frames are present. */
3396 PRINT(" pts=");
3397 if (pkt->pts == AV_NOPTS_VALUE)
3398 PRINT("N/A");
3399 else
3400 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3401 PRINT("\n");
3402 PRINT(" size=%d\n", pkt->size);
3403 #undef PRINT
3404 if (dump_payload)
3405 av_hex_dump(f, pkt->data, pkt->size);
3406 }
3407
3408 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3409 {
3410 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3411 }
3412
3413 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3414 {
3415 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3416 }
3417
3418 void ff_url_split(char *proto, int proto_size,
3419 char *authorization, int authorization_size,
3420 char *hostname, int hostname_size,
3421 int *port_ptr,
3422 char *path, int path_size,
3423 const char *url)
3424 {
3425 const char *p, *ls, *at, *col, *brk;
3426
3427 if (port_ptr) *port_ptr = -1;
3428 if (proto_size > 0) proto[0] = 0;
3429 if (authorization_size > 0) authorization[0] = 0;
3430 if (hostname_size > 0) hostname[0] = 0;
3431 if (path_size > 0) path[0] = 0;
3432
3433 /* parse protocol */
3434 if ((p = strchr(url, ':'))) {
3435 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3436 p++; /* skip ':' */
3437 if (*p == '/') p++;
3438 if (*p == '/') p++;
3439 } else {
3440 /* no protocol means plain filename */
3441 av_strlcpy(path, url, path_size);
3442 return;
3443 }
3444
3445 /* separate path from hostname */
3446 ls = strchr(p, '/');
3447 if(!ls)
3448 ls = strchr(p, '?');
3449 if(ls)
3450 av_strlcpy(path, ls, path_size);
3451 else
3452 ls = &p[strlen(p)]; // XXX
3453
3454 /* the rest is hostname, use that to parse auth/port */
3455 if (ls != p) {
3456 /* authorization (user[:pass]@hostname) */
3457 if ((at = strchr(p, '@')) && at < ls) {
3458 av_strlcpy(authorization, p,
3459 FFMIN(authorization_size, at + 1 - p));
3460 p = at + 1; /* skip '@' */
3461 }
3462
3463 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3464 /* [host]:port */
3465 av_strlcpy(hostname, p + 1,
3466 FFMIN(hostname_size, brk - p));
3467 if (brk[1] == ':' && port_ptr)
3468 *port_ptr = atoi(brk + 2);
3469 } else if ((col = strchr(p, ':')) && col < ls) {
3470 av_strlcpy(hostname, p,
3471 FFMIN(col + 1 - p, hostname_size));
3472 if (port_ptr) *port_ptr = atoi(col + 1);
3473 } else
3474 av_strlcpy(hostname, p,
3475 FFMIN(ls + 1 - p, hostname_size));
3476 }
3477 }
3478
3479 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3480 {
3481 int i;
3482 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3483 '4', '5', '6', '7',
3484 '8', '9', 'A', 'B',
3485 'C', 'D', 'E', 'F' };
3486 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3487 '4', '5', '6', '7',
3488 '8', '9', 'a', 'b',
3489 'c', 'd', 'e', 'f' };
3490 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3491
3492 for(i = 0; i < s; i++) {
3493 buff[i * 2] = hex_table[src[i] >> 4];
3494 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3495 }
3496
3497 return buff;
3498 }
3499
3500 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3501 unsigned int pts_num, unsigned int pts_den)
3502 {
3503 s->pts_wrap_bits = pts_wrap_bits;
3504
3505 if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3506 if(s->time_base.num != pts_num)
3507 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3508 }else
3509 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3510
3511 if(!s->time_base.num || !s->time_base.den)
3512 s->time_base.num= s->time_base.den= 0;
3513 }
3514
3515 int ff_url_join(char *str, int size, const char *proto,
3516 const char *authorization, const char *hostname,
3517 int port, const char *fmt, ...)
3518 {
3519 #if CONFIG_NETWORK
3520 struct addrinfo hints, *ai;
3521 #endif
3522
3523 str[0] = '\0';
3524 if (proto)
3525 av_strlcatf(str, size, "%s://", proto);
3526 if (authorization)
3527 av_strlcatf(str, size, "%s@", authorization);
3528 #if CONFIG_NETWORK && defined(AF_INET6)
3529 /* Determine if hostname is a numerical IPv6 address,
3530 * properly escape it within [] in that case. */
3531 memset(&hints, 0, sizeof(hints));
3532 hints.ai_flags = AI_NUMERICHOST;
3533 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3534 if (ai->ai_family == AF_INET6) {
3535 av_strlcat(str, "[", size);
3536 av_strlcat(str, hostname, size);
3537 av_strlcat(str, "]", size);
3538 } else {
3539 av_strlcat(str, hostname, size);
3540 }
3541 freeaddrinfo(ai);
3542 } else
3543 #endif
3544 /* Not an IPv6 address, just output the plain string. */
3545 av_strlcat(str, hostname, size);
3546
3547 if (port >= 0)
3548 av_strlcatf(str, size, ":%d", port);
3549 if (fmt) {
3550 va_list vl;
3551 int len = strlen(str);
3552
3553 va_start(vl, fmt);
3554 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3555 va_end(vl);
3556 }
3557 return strlen(str);
3558 }