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