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