Fix muxing rgb rawvideo in avi regression.
[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 && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2658 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2659 st->codec->codec_tag= 0;
2660 }
2661 if(st->codec->codec_tag){
2662 if (!validate_codec_tag(s, st)) {
2663 char tagbuf[32];
2664 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2665 av_log(s, AV_LOG_ERROR,
2666 "Tag %s/0x%08x incompatible with output codec '%s'\n",
2667 tagbuf, st->codec->codec_tag, st->codec->codec->name);
2668 return AVERROR_INVALIDDATA;
2669 }
2670 }else
2671 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2672 }
2673
2674 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2675 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2676 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2677 }
2678
2679 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2680 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2681 if (!s->priv_data)
2682 return AVERROR(ENOMEM);
2683 }
2684
2685 #if LIBAVFORMAT_VERSION_MAJOR < 53
2686 ff_metadata_mux_compat(s);
2687 #endif
2688
2689 /* set muxer identification string */
2690 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2691 AVMetadata *m;
2692 AVMetadataTag *t;
2693
2694 if (!(m = av_mallocz(sizeof(AVMetadata))))
2695 return AVERROR(ENOMEM);
2696 av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2697 metadata_conv(&m, s->oformat->metadata_conv, NULL);
2698 if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2699 av_metadata_set2(&s->metadata, t->key, t->value, 0);
2700 av_metadata_free(&m);
2701 }
2702
2703 if(s->oformat->write_header){
2704 ret = s->oformat->write_header(s);
2705 if (ret < 0)
2706 return ret;
2707 }
2708
2709 /* init PTS generation */
2710 for(i=0;i<s->nb_streams;i++) {
2711 int64_t den = AV_NOPTS_VALUE;
2712 st = s->streams[i];
2713
2714 switch (st->codec->codec_type) {
2715 case AVMEDIA_TYPE_AUDIO:
2716 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2717 break;
2718 case AVMEDIA_TYPE_VIDEO:
2719 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2720 break;
2721 default:
2722 break;
2723 }
2724 if (den != AV_NOPTS_VALUE) {
2725 if (den <= 0)
2726 return AVERROR_INVALIDDATA;
2727 av_frac_init(&st->pts, 0, 0, den);
2728 }
2729 }
2730 return 0;
2731 }
2732
2733 //FIXME merge with compute_pkt_fields
2734 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2735 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2736 int num, den, frame_size, i;
2737
2738 // 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);
2739
2740 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2741 return -1;*/
2742
2743 /* duration field */
2744 if (pkt->duration == 0) {
2745 compute_frame_duration(&num, &den, st, NULL, pkt);
2746 if (den && num) {
2747 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2748 }
2749 }
2750
2751 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2752 pkt->pts= pkt->dts;
2753
2754 //XXX/FIXME this is a temporary hack until all encoders output pts
2755 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2756 pkt->dts=
2757 // pkt->pts= st->cur_dts;
2758 pkt->pts= st->pts.val;
2759 }
2760
2761 //calculate dts from pts
2762 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2763 st->pts_buffer[0]= pkt->pts;
2764 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2765 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2766 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2767 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2768
2769 pkt->dts= st->pts_buffer[0];
2770 }
2771
2772 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2773 av_log(s, AV_LOG_ERROR,
2774 "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2775 st->index, st->cur_dts, pkt->dts);
2776 return -1;
2777 }
2778 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2779 av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2780 return -1;
2781 }
2782
2783 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2784 st->cur_dts= pkt->dts;
2785 st->pts.val= pkt->dts;
2786
2787 /* update pts */
2788 switch (st->codec->codec_type) {
2789 case AVMEDIA_TYPE_AUDIO:
2790 frame_size = get_audio_frame_size(st->codec, pkt->size);
2791
2792 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2793 likely equal to the encoder delay, but it would be better if we
2794 had the real timestamps from the encoder */
2795 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2796 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2797 }
2798 break;
2799 case AVMEDIA_TYPE_VIDEO:
2800 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2801 break;
2802 default:
2803 break;
2804 }
2805 return 0;
2806 }
2807
2808 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2809 {
2810 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2811
2812 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2813 return ret;
2814
2815 ret= s->oformat->write_packet(s, pkt);
2816 if(!ret)
2817 ret= url_ferror(s->pb);
2818 return ret;
2819 }
2820
2821 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2822 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2823 {
2824 AVPacketList **next_point, *this_pktl;
2825
2826 this_pktl = av_mallocz(sizeof(AVPacketList));
2827 this_pktl->pkt= *pkt;
2828 pkt->destruct= NULL; // do not free original but only the copy
2829 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2830
2831 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2832 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2833 }else
2834 next_point = &s->packet_buffer;
2835
2836 if(*next_point){
2837 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2838 while(!compare(s, &(*next_point)->pkt, pkt)){
2839 next_point= &(*next_point)->next;
2840 }
2841 goto next_non_null;
2842 }else{
2843 next_point = &(s->packet_buffer_end->next);
2844 }
2845 }
2846 assert(!*next_point);
2847
2848 s->packet_buffer_end= this_pktl;
2849 next_non_null:
2850
2851 this_pktl->next= *next_point;
2852
2853 s->streams[pkt->stream_index]->last_in_packet_buffer=
2854 *next_point= this_pktl;
2855 }
2856
2857 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2858 {
2859 AVStream *st = s->streams[ pkt ->stream_index];
2860 AVStream *st2= s->streams[ next->stream_index];
2861 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2862 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2863 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2864 }
2865
2866 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2867 AVPacketList *pktl;
2868 int stream_count=0;
2869 int i;
2870
2871 if(pkt){
2872 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2873 }
2874
2875 for(i=0; i < s->nb_streams; i++)
2876 stream_count+= !!s->streams[i]->last_in_packet_buffer;
2877
2878 if(stream_count && (s->nb_streams == stream_count || flush)){
2879 pktl= s->packet_buffer;
2880 *out= pktl->pkt;
2881
2882 s->packet_buffer= pktl->next;
2883 if(!s->packet_buffer)
2884 s->packet_buffer_end= NULL;
2885
2886 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2887 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2888 av_freep(&pktl);
2889 return 1;
2890 }else{
2891 av_init_packet(out);
2892 return 0;
2893 }
2894 }
2895
2896 /**
2897 * Interleaves an AVPacket correctly so it can be muxed.
2898 * @param out the interleaved packet will be output here
2899 * @param in the input packet
2900 * @param flush 1 if no further packets are available as input and all
2901 * remaining packets should be output
2902 * @return 1 if a packet was output, 0 if no packet could be output,
2903 * < 0 if an error occurred
2904 */
2905 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2906 if(s->oformat->interleave_packet)
2907 return s->oformat->interleave_packet(s, out, in, flush);
2908 else
2909 return av_interleave_packet_per_dts(s, out, in, flush);
2910 }
2911
2912 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2913 AVStream *st= s->streams[ pkt->stream_index];
2914
2915 //FIXME/XXX/HACK drop zero sized packets
2916 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2917 return 0;
2918
2919 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2920 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2921 return -1;
2922
2923 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2924 return -1;
2925
2926 for(;;){
2927 AVPacket opkt;
2928 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2929 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2930 return ret;
2931
2932 ret= s->oformat->write_packet(s, &opkt);
2933
2934 av_free_packet(&opkt);
2935 pkt= NULL;
2936
2937 if(ret<0)
2938 return ret;
2939 if(url_ferror(s->pb))
2940 return url_ferror(s->pb);
2941 }
2942 }
2943
2944 int av_write_trailer(AVFormatContext *s)
2945 {
2946 int ret, i;
2947
2948 for(;;){
2949 AVPacket pkt;
2950 ret= av_interleave_packet(s, &pkt, NULL, 1);
2951 if(ret<0) //FIXME cleanup needed for ret<0 ?
2952 goto fail;
2953 if(!ret)
2954 break;
2955
2956 ret= s->oformat->write_packet(s, &pkt);
2957
2958 av_free_packet(&pkt);
2959
2960 if(ret<0)
2961 goto fail;
2962 if(url_ferror(s->pb))
2963 goto fail;
2964 }
2965
2966 if(s->oformat->write_trailer)
2967 ret = s->oformat->write_trailer(s);
2968 fail:
2969 if(ret == 0)
2970 ret=url_ferror(s->pb);
2971 for(i=0;i<s->nb_streams;i++) {
2972 av_freep(&s->streams[i]->priv_data);
2973 av_freep(&s->streams[i]->index_entries);
2974 }
2975 av_freep(&s->priv_data);
2976 return ret;
2977 }
2978
2979 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2980 {
2981 int i, j;
2982 AVProgram *program=NULL;
2983 void *tmp;
2984
2985 if (idx >= ac->nb_streams) {
2986 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2987 return;
2988 }
2989
2990 for(i=0; i<ac->nb_programs; i++){
2991 if(ac->programs[i]->id != progid)
2992 continue;
2993 program = ac->programs[i];
2994 for(j=0; j<program->nb_stream_indexes; j++)
2995 if(program->stream_index[j] == idx)
2996 return;
2997
2998 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2999 if(!tmp)
3000 return;
3001 program->stream_index = tmp;
3002 program->stream_index[program->nb_stream_indexes++] = idx;
3003 return;
3004 }
3005 }
3006
3007 static void print_fps(double d, const char *postfix){
3008 uint64_t v= lrintf(d*100);
3009 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3010 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3011 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3012 }
3013
3014 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3015 {
3016 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3017 AVMetadataTag *tag=NULL;
3018
3019 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3020 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3021 if(strcmp("language", tag->key))
3022 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3023 }
3024 }
3025 }
3026
3027 /* "user interface" functions */
3028 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3029 {
3030 char buf[256];
3031 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3032 AVStream *st = ic->streams[i];
3033 int g = av_gcd(st->time_base.num, st->time_base.den);
3034 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3035 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3036 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3037 /* the pid is an important information, so we display it */
3038 /* XXX: add a generic system */
3039 if (flags & AVFMT_SHOW_IDS)
3040 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3041 if (lang)
3042 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3043 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3044 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3045 if (st->sample_aspect_ratio.num && // default
3046 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3047 AVRational display_aspect_ratio;
3048 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3049 st->codec->width*st->sample_aspect_ratio.num,
3050 st->codec->height*st->sample_aspect_ratio.den,
3051 1024*1024);
3052 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3053 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3054 display_aspect_ratio.num, display_aspect_ratio.den);
3055 }
3056 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3057 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3058 print_fps(av_q2d(st->avg_frame_rate), "fps");
3059 if(st->r_frame_rate.den && st->r_frame_rate.num)
3060 print_fps(av_q2d(st->r_frame_rate), "tbr");
3061 if(st->time_base.den && st->time_base.num)
3062 print_fps(1/av_q2d(st->time_base), "tbn");
3063 if(st->codec->time_base.den && st->codec->time_base.num)
3064 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3065 }
3066 av_log(NULL, AV_LOG_INFO, "\n");
3067 dump_metadata(NULL, st->metadata, " ");
3068 }
3069
3070 void dump_format(AVFormatContext *ic,
3071 int index,
3072 const char *url,
3073 int is_output)
3074 {
3075 int i;
3076 uint8_t *printed = av_mallocz(ic->nb_streams);
3077 if (ic->nb_streams && !printed)
3078 return;
3079
3080 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3081 is_output ? "Output" : "Input",
3082 index,
3083 is_output ? ic->oformat->name : ic->iformat->name,
3084 is_output ? "to" : "from", url);
3085 dump_metadata(NULL, ic->metadata, " ");
3086 if (!is_output) {
3087 av_log(NULL, AV_LOG_INFO, " Duration: ");
3088 if (ic->duration != AV_NOPTS_VALUE) {
3089 int hours, mins, secs, us;
3090 secs = ic->duration / AV_TIME_BASE;
3091 us = ic->duration % AV_TIME_BASE;
3092 mins = secs / 60;
3093 secs %= 60;
3094 hours = mins / 60;
3095 mins %= 60;
3096 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3097 (100 * us) / AV_TIME_BASE);
3098 } else {
3099 av_log(NULL, AV_LOG_INFO, "N/A");
3100 }
3101 if (ic->start_time != AV_NOPTS_VALUE) {
3102 int secs, us;
3103 av_log(NULL, AV_LOG_INFO, ", start: ");
3104 secs = ic->start_time / AV_TIME_BASE;
3105 us = ic->start_time % AV_TIME_BASE;
3106 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3107 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));