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