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