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