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