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