Simplify av_open_input_file
[libav.git] / libavformat / utils.c
CommitLineData
de6d9b64
FB
1/*
2 * Various utilities for ffmpeg system
19720f15 3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
de6d9b64 4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
19720f15
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
de6d9b64 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
de6d9b64 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19720f15
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
de6d9b64 16 *
19720f15 17 * You should have received a copy of the GNU Lesser General Public
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
de6d9b64 20 */
8be1c656 21#include "avformat.h"
4eb72c6b 22#include "opt.h"
75e61b0e 23#include "avstring.h"
45da8124 24#include "riff.h"
82e4ac2c
RP
25#include <sys/time.h>
26#include <time.h>
c5510dd6 27
b754978a
MN
28#undef NDEBUG
29#include <assert.h>
30
e36bdf8b
DK
31/**
32 * @file libavformat/utils.c
33 * Various utility functions for using ffmpeg library.
34 */
35
f3a30e3a
LB
36static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37static void av_frac_add(AVFrac *f, int64_t incr);
f3a30e3a 38
e36bdf8b 39/** head of registered input format linked list. */
8b69867f 40AVInputFormat *first_iformat = NULL;
e36bdf8b 41/** head of registered output format linked list. */
8b69867f 42AVOutputFormat *first_oformat = NULL;
de6d9b64 43
84be6e72
MN
44AVInputFormat *av_iformat_next(AVInputFormat *f)
45{
46 if(f) return f->next;
47 else return first_iformat;
48}
49
50AVOutputFormat *av_oformat_next(AVOutputFormat *f)
51{
52 if(f) return f->next;
53 else return first_oformat;
54}
55
b9a281db 56void av_register_input_format(AVInputFormat *format)
de6d9b64 57{
b9a281db
FB
58 AVInputFormat **p;
59 p = &first_iformat;
60 while (*p != NULL) p = &(*p)->next;
61 *p = format;
62 format->next = NULL;
63}
64
65void av_register_output_format(AVOutputFormat *format)
66{
67 AVOutputFormat **p;
68 p = &first_oformat;
de6d9b64
FB
69 while (*p != NULL) p = &(*p)->next;
70 *p = format;
71 format->next = NULL;
72}
73
5b25dfa7 74int match_ext(const char *filename, const char *extensions)
de6d9b64
FB
75{
76 const char *ext, *p;
77 char ext1[32], *q;
78
293ed23f
MN
79 if(!filename)
80 return 0;
115329f1 81
de6d9b64
FB
82 ext = strrchr(filename, '.');
83 if (ext) {
84 ext++;
85 p = extensions;
86 for(;;) {
87 q = ext1;
115329f1 88 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
de6d9b64
FB
89 *q++ = *p++;
90 *q = '\0';
115329f1 91 if (!strcasecmp(ext1, ext))
de6d9b64 92 return 1;
115329f1 93 if (*p == '\0')
de6d9b64
FB
94 break;
95 p++;
96 }
97 }
98 return 0;
99}
100
115329f1 101AVOutputFormat *guess_format(const char *short_name, const char *filename,
b9a281db 102 const char *mime_type)
de6d9b64 103{
b9a281db 104 AVOutputFormat *fmt, *fmt_found;
de6d9b64
FB
105 int score_max, score;
106
87a0a681 107 /* specific test for image sequences */
ff70e601 108#ifdef CONFIG_IMAGE2_MUXER
115329f1 109 if (!short_name && filename &&
5c07cf53 110 av_filename_number_test(filename) &&
5b6d5596
MN
111 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
112 return guess_format("image2", NULL, NULL);
113 }
ff70e601 114#endif
de6d9b64
FB
115 /* find the proper file type */
116 fmt_found = NULL;
117 score_max = 0;
b9a281db 118 fmt = first_oformat;
de6d9b64
FB
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;
115329f1 125 if (filename && fmt->extensions &&
de6d9b64
FB
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;
115329f1 136}
de6d9b64 137
115329f1 138AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
c5510dd6
PG
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
115329f1 157enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
5b6d5596
MN
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
ff70e601 162#ifdef CONFIG_IMAGE2_MUXER
ae214ac3 163 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
5b6d5596
MN
164 codec_id= av_guess_image2_codec(filename);
165 }
ff70e601 166#endif
5b6d5596
MN
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
b9a281db
FB
176AVInputFormat *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
de6d9b64
FB
186/* memory handling */
187
90ad92b3 188void av_destruct_packet(AVPacket *pkt)
6fa5a56c
FB
189{
190 av_free(pkt->data);
191 pkt->data = NULL; pkt->size = 0;
192}
193
659596f0
RP
194void 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
de6d9b64
FB
205int av_new_packet(AVPacket *pkt, int size)
206{
55bdd34d 207 uint8_t *data;
568e18b1 208 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
769e10f0 209 return AVERROR(ENOMEM);
568e18b1 210 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
6fa5a56c 211 if (!data)
769e10f0 212 return AVERROR(ENOMEM);
6fa5a56c 213 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
8cd5be98 214
6fa5a56c 215 av_init_packet(pkt);
115329f1 216 pkt->data = data;
6fa5a56c
FB
217 pkt->size = size;
218 pkt->destruct = av_destruct_packet;
de6d9b64
FB
219 return 0;
220}
221
2692067a
MN
222int 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
fb2758c8
FB
240int av_dup_packet(AVPacket *pkt)
241{
242 if (pkt->destruct != av_destruct_packet) {
243 uint8_t *data;
8a56ac7b
FB
244 /* we duplicate the packet and don't forget to put the padding
245 again */
568e18b1 246 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
769e10f0 247 return AVERROR(ENOMEM);
8a56ac7b 248 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
fb2758c8 249 if (!data) {
769e10f0 250 return AVERROR(ENOMEM);
fb2758c8
FB
251 }
252 memcpy(data, pkt->data, pkt->size);
8a56ac7b 253 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
fb2758c8
FB
254 pkt->data = data;
255 pkt->destruct = av_destruct_packet;
256 }
257 return 0;
258}
259
5c07cf53 260int av_filename_number_test(const char *filename)
b9a281db
FB
261{
262 char buf[1024];
5c07cf53 263 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
b9a281db
FB
264}
265
79750486 266static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
b9a281db
FB
267{
268 AVInputFormat *fmt1, *fmt;
79750486 269 int score;
b9a281db
FB
270
271 fmt = NULL;
b9a281db 272 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
b8e705ec 273 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
b9a281db
FB
274 continue;
275 score = 0;
a8dbe951
PG
276 if (fmt1->read_probe) {
277 score = fmt1->read_probe(pd);
278 } else if (fmt1->extensions) {
b9a281db
FB
279 if (match_ext(pd->filename, fmt1->extensions)) {
280 score = 50;
281 }
115329f1 282 }
79750486
MN
283 if (score > *score_max) {
284 *score_max = score;
b9a281db
FB
285 fmt = fmt1;
286 }
287 }
288 return fmt;
289}
290
79750486
MN
291AVInputFormat *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
b9a281db
FB
296/************************************************************/
297/* input media file */
96baaa6a 298
da24c5e3 299/**
e36bdf8b 300 * Open a media file from an IO stream. 'fmt' must be specified.
da24c5e3 301 */
43465395 302static const char* format_to_name(void* ptr)
bc874dae 303{
43465395 304 AVFormatContext* fc = (AVFormatContext*) ptr;
bc874dae
MB
305 if(fc->iformat) return fc->iformat->name;
306 else if(fc->oformat) return fc->oformat->name;
307 else return "NULL";
308}
309
66acccf0 310#define OFFSET(x) offsetof(AVFormatContext,x)
755bfeab 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
4eb72c6b
NS
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
316static const AVOption options[]={
8c3dd5dc 317{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
09a45576 318{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
4ff8fcef 319{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
18de0b81 320{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
2c00106c
MN
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"},
8c3dd5dc 323{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
ec1b10f4 324{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
e19fbbec 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},
841f39a7 326{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
4eb72c6b
NS
327{NULL},
328};
329
5e89b50b
PI
330#undef E
331#undef D
332#undef DEFAULT
333
4eb72c6b
NS
334static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
335
702dfe01
BC
336static void avformat_get_context_defaults(AVFormatContext *s)
337{
4eb72c6b 338 memset(s, 0, sizeof(AVFormatContext));
9e6c9470 339
73a8ceaa
PI
340 s->av_class = &av_format_context_class;
341
342 av_opt_set_defaults(s);
4eb72c6b 343}
bc874dae
MB
344
345AVFormatContext *av_alloc_format_context(void)
346{
347 AVFormatContext *ic;
5894991f 348 ic = av_malloc(sizeof(AVFormatContext));
bc874dae 349 if (!ic) return ic;
4eb72c6b 350 avformat_get_context_defaults(ic);
43465395 351 ic->av_class = &av_format_context_class;
bc874dae
MB
352 return ic;
353}
354
115329f1
DB
355int av_open_input_stream(AVFormatContext **ic_ptr,
356 ByteIOContext *pb, const char *filename,
da24c5e3
FB
357 AVInputFormat *fmt, AVFormatParameters *ap)
358{
359 int err;
360 AVFormatContext *ic;
c04c3282
MN
361 AVFormatParameters default_ap;
362
363 if(!ap){
364 ap=&default_ap;
365 memset(ap, 0, sizeof(default_ap));
366 }
da24c5e3 367
4eb72c6b
NS
368 if(!ap->prealloced_context)
369 ic = av_alloc_format_context();
370 else
371 ic = *ic_ptr;
da24c5e3 372 if (!ic) {
769e10f0 373 err = AVERROR(ENOMEM);
da24c5e3
FB
374 goto fail;
375 }
376 ic->iformat = fmt;
899681cd 377 ic->pb = pb;
da24c5e3
FB
378 ic->duration = AV_NOPTS_VALUE;
379 ic->start_time = AV_NOPTS_VALUE;
75e61b0e 380 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
da24c5e3
FB
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) {
769e10f0 386 err = AVERROR(ENOMEM);
da24c5e3
FB
387 goto fail;
388 }
389 } else {
390 ic->priv_data = NULL;
391 }
392
da24c5e3
FB
393 err = ic->iformat->read_header(ic, ap);
394 if (err < 0)
395 goto fail;
fb2758c8 396
faf7cbf1 397 if (pb && !ic->data_offset)
899681cd 398 ic->data_offset = url_ftell(ic->pb);
fb2758c8 399
da24c5e3
FB
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
e36bdf8b 411/** Size of probe buffer, for guessing file type from file contents. */
a877eedc 412#define PROBE_BUF_MIN 2048
329b1e75 413#define PROBE_BUF_MAX (1<<20)
b9a281db 414
115329f1 415int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
b9a281db
FB
416 AVInputFormat *fmt,
417 int buf_size,
418 AVFormatParameters *ap)
de6d9b64 419{
17acc63a 420 int err, probe_size;
b9a281db 421 AVProbeData probe_data, *pd = &probe_data;
17acc63a 422 ByteIOContext *pb = NULL;
115329f1 423
da24c5e3
FB
424 pd->filename = "";
425 if (filename)
426 pd->filename = filename;
a877eedc 427 pd->buf = NULL;
b9a281db
FB
428 pd->buf_size = 0;
429
430 if (!fmt) {
431 /* guess format if no file can be opened */
a25e098d 432 fmt = av_probe_input_format(pd, 0);
de6d9b64 433 }
de6d9b64 434
b6892136
FB
435 /* do not open file if the format does not need it. XXX: specific
436 hack needed to handle RTSP/TCP */
17acc63a 437 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
87a0a681 438 /* if no file needed do not try to open one */
899681cd 439 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
96baaa6a 440 goto fail;
b9a281db 441 }
96baaa6a 442 if (buf_size > 0) {
da24c5e3 443 url_setbufsize(pb, buf_size);
96baaa6a 444 }
a877eedc
MN
445
446 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
79750486 447 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
5b25dfa7 448 /* read probe data */
87e87886 449 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
a877eedc 450 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
9be51815 451 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
497244a8 452 if (url_fseek(pb, 0, SEEK_SET) < 0) {
53e2f9ca 453 url_fclose(pb);
899681cd 454 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
17acc63a 455 pb = NULL;
6f3e0b21 456 err = AVERROR(EIO);
53e2f9ca
MN
457 goto fail;
458 }
459 }
a877eedc 460 /* guess file format */
79750486 461 fmt = av_probe_input_format2(pd, 1, &score);
5b25dfa7 462 }
a877eedc 463 av_freep(&pd->buf);
b9a281db
FB
464 }
465
466 /* if still no format found, error */
467 if (!fmt) {
468 err = AVERROR_NOFMT;
da24c5e3 469 goto fail;
de6d9b64 470 }
115329f1 471
87a0a681 472 /* check filename in case of an image number is expected */
da24c5e3 473 if (fmt->flags & AVFMT_NEEDNUMBER) {
5c07cf53 474 if (!av_filename_number_test(filename)) {
87a0a681 475 err = AVERROR_NUMEXPECTED;
da24c5e3 476 goto fail;
87a0a681
FB
477 }
478 }
da24c5e3
FB
479 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
480 if (err)
481 goto fail;
b9a281db 482 return 0;
de6d9b64 483 fail:
a877eedc 484 av_freep(&pd->buf);
17acc63a 485 if (pb)
da24c5e3 486 url_fclose(pb);
b9a281db
FB
487 *ic_ptr = NULL;
488 return err;
115329f1 489
de6d9b64
FB
490}
491
da24c5e3
FB
492/*******************************************************/
493
de6d9b64
FB
494int av_read_packet(AVFormatContext *s, AVPacket *pkt)
495{
b237eb80 496 av_init_packet(pkt);
fb2758c8
FB
497 return s->iformat->read_packet(s, pkt);
498}
499
500/**********************************************************/
501
e36bdf8b
DK
502/**
503 * Get the number of samples of an audio frame. Return (-1) if error.
504 */
fb2758c8
FB
505static int get_audio_frame_size(AVCodecContext *enc, int size)
506{
507 int frame_size;
508
509 if (enc->frame_size <= 1) {
ac3e1834
BC
510 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
511
512 if (bits_per_sample) {
fb2758c8
FB
513 if (enc->channels == 0)
514 return -1;
f1b163e0 515 frame_size = (size << 3) / (bits_per_sample * enc->channels);
ac3e1834 516 } else {
fb2758c8
FB
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;
fb2758c8
FB
521 }
522 } else {
523 frame_size = enc->frame_size;
524 }
525 return frame_size;
526}
527
528
e36bdf8b
DK
529/**
530 * Return the frame duration in seconds, return 0 if not available.
531 */
115329f1 532static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
fb2758c8
FB
533 AVCodecParserContext *pc, AVPacket *pkt)
534{
535 int frame_size;
536
537 *pnum = 0;
538 *pden = 0;
01f4895c 539 switch(st->codec->codec_type) {
fb2758c8 540 case CODEC_TYPE_VIDEO:
1677155d 541 if(st->time_base.num*1000LL > st->time_base.den){
c0df9d75
MN
542 *pnum = st->time_base.num;
543 *pden = st->time_base.den;
01f4895c
MN
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;
327c4076
MN
547 if (pc && pc->repeat_pict) {
548 *pden *= 2;
549 *pnum = (*pnum) * (2 + pc->repeat_pict);
550 }
fb2758c8
FB
551 }
552 break;
553 case CODEC_TYPE_AUDIO:
01f4895c 554 frame_size = get_audio_frame_size(st->codec, pkt->size);
fb2758c8
FB
555 if (frame_size < 0)
556 break;
557 *pnum = frame_size;
01f4895c 558 *pden = st->codec->sample_rate;
fb2758c8
FB
559 break;
560 default:
561 break;
562 }
563}
564
5ba7c3d7
MN
565static 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:
f37b9768 576 case CODEC_ID_FFVHUFF:
5ba7c3d7
MN
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
9fcbcca6
NB
587static void update_initial_timestamps(AVFormatContext *s, int stream_index,
588 int64_t dts, int64_t pts)
589{
82583548
MN
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;
48a59dfe
MN
608
609 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
610 st->start_time= pktl->pkt.pts;
82583548 611 }
9fcbcca6
NB
612 if (st->start_time == AV_NOPTS_VALUE)
613 st->start_time = pts;
82583548
MN
614}
615
115329f1 616static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
fb2758c8
FB
617 AVCodecParserContext *pc, AVPacket *pkt)
618{
d9e1efb7 619 int num, den, presentation_delayed, delay, i;
a74008a4 620 int64_t offset;
115329f1 621
10a7571b
MN
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
fb2758c8 627 if (pkt->duration == 0) {
3c895fc0 628 compute_frame_duration(&num, &den, st, pc, pkt);
fb2758c8 629 if (den && num) {
77405fc8 630 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
fb2758c8
FB
631 }
632 }
633
a74008a4
JP
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
fb2758c8 644 /* do we have a video B frame ? */
befe3b05 645 delay= st->codec->has_b_frames;
fb2758c8 646 presentation_delayed = 0;
7e4baa66
MN
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;
755bfeab 652 /* This may be redundant, but it should not hurt. */
7e4baa66
MN
653 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
654 presentation_delayed = 1;
115329f1 655
e928649b 656 if(st->cur_dts == AV_NOPTS_VALUE){
82583548 657 st->cur_dts = 0; //FIXME maybe set it to 0 during init
e928649b 658 }
fb2758c8 659
949b1a13 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);
fb2758c8 661 /* interpolate PTS and DTS if they are not present */
7e4baa66
MN
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;
9fcbcca6 668 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
7e4baa66
MN
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 */
028d6f3e 681 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
7e4baa66
MN
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 }
90bb394d 689 }
115329f1 690
7e4baa66
MN
691 /* presentation is not delayed : PTS and DTS are the same */
692 if(pkt->pts == AV_NOPTS_VALUE)
693 pkt->pts = pkt->dts;
9fcbcca6 694 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
7e4baa66
MN
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 }
fb2758c8 700 }
d9e1efb7
MN
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];
82583548 710 if(delay>1){
9fcbcca6 711 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
82583548 712 }
d9e1efb7
MN
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);
115329f1 718
fb2758c8 719 /* update flags */
3a1d3588
JD
720 if(is_intra_only(st->codec))
721 pkt->flags |= PKT_FLAG_KEY;
722 else if (pc) {
fb2758c8
FB
723 pkt->flags = 0;
724 /* key frame computation */
fb2758c8
FB
725 if (pc->pict_type == FF_I_TYPE)
726 pkt->flags |= PKT_FLAG_KEY;
fb2758c8 727 }
fb2758c8
FB
728}
729
63dd1377 730void av_destruct_packet_nofree(AVPacket *pkt)
fb2758c8
FB
731{
732 pkt->data = NULL; pkt->size = 0;
733}
734
735static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
736{
737 AVStream *st;
37353960 738 int len, ret, i;
fb2758c8 739
b237eb80
MN
740 av_init_packet(pkt);
741
fb2758c8
FB
742 for(;;) {
743 /* select current input stream component */
744 st = s->cur_st;
745 if (st) {
90ad92b3 746 if (!st->need_parsing || !st->parser) {
fb2758c8
FB
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;
434cab9e 752 break;
f3356e9c 753 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
115329f1 754 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
6ec87caa
FB
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;
fb2758c8
FB
759 /* increment read pointer */
760 s->cur_ptr += len;
761 s->cur_len -= len;
115329f1 762
fb2758c8
FB
763 /* return packet if any */
764 if (pkt->size) {
37353960 765 got_packet:
711737af 766 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
fb2758c8
FB
767 pkt->duration = 0;
768 pkt->stream_index = st->index;
6ec87caa
FB
769 pkt->pts = st->parser->pts;
770 pkt->dts = st->parser->dts;
fb2758c8
FB
771 pkt->destruct = av_destruct_packet_nofree;
772 compute_pkt_fields(s, st, st->parser, pkt);
e9b78eeb
MN
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
434cab9e 779 break;
fb2758c8
FB
780 }
781 } else {
bcbecff1 782 /* free packet */
115329f1 783 av_free_packet(&s->cur_pkt);
fb2758c8
FB
784 s->cur_st = NULL;
785 }
786 } else {
fb2758c8
FB
787 /* read next packet */
788 ret = av_read_packet(s, &s->cur_pkt);
37353960 789 if (ret < 0) {
8fa36ae0 790 if (ret == AVERROR(EAGAIN))
37353960
FB
791 return ret;
792 /* return the last frames, if any */
793 for(i = 0; i < s->nb_streams; i++) {
794 st = s->streams[i];
90ad92b3 795 if (st->parser && st->need_parsing) {
115329f1
DB
796 av_parser_parse(st->parser, st->codec,
797 &pkt->data, &pkt->size,
798 NULL, 0,
6ec87caa 799 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
37353960
FB
800 if (pkt->size)
801 goto got_packet;
802 }
803 }
804 /* no more packets: really terminates parsing */
fb2758c8 805 return ret;
37353960 806 }
115329f1 807
9ee91c2f 808 st = s->streams[s->cur_pkt.stream_index];
434cab9e 809 if(st->codec->debug & FF_DEBUG_PTS)
ccd3228e 810 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
434cab9e
MN
811 s->cur_pkt.stream_index,
812 s->cur_pkt.pts,
813 s->cur_pkt.dts,
814 s->cur_pkt.size);
fb2758c8 815
fb2758c8
FB
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) {
01f4895c 820 st->parser = av_parser_init(st->codec->codec_id);
fb2758c8
FB
821 if (!st->parser) {
822 /* no parser available : just output the raw packets */
57004ff1
AJ
823 st->need_parsing = AVSTREAM_PARSE_NONE;
824 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
7cbaa7ba 825 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
fb2758c8 826 }
e9b78eeb
MN
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 }
fb2758c8
FB
831 }
832 }
833 }
434cab9e 834 if(st->codec->debug & FF_DEBUG_PTS)
ccd3228e 835 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
434cab9e
MN
836 pkt->stream_index,
837 pkt->pts,
838 pkt->dts,
839 pkt->size);
840
841 return 0;
fb2758c8
FB
842}
843
02b15cc8
MN
844static 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
fb2758c8
FB
860int av_read_frame(AVFormatContext *s, AVPacket *pkt)
861{
de6d9b64 862 AVPacketList *pktl;
30bc6613
MN
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;
30bc6613
MN
870
871 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
872 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
115329f1 873 if( pktl->pkt.stream_index == next_pkt->stream_index
30bc6613
MN
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 }
115329f1
DB
883
884 if( next_pkt->pts != AV_NOPTS_VALUE
885 || next_pkt->dts == AV_NOPTS_VALUE
30bc6613
MN
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){
30bc6613
MN
895 int ret= av_read_frame_internal(s, pkt);
896 if(ret<0){
8fa36ae0 897 if(pktl && ret != AVERROR(EAGAIN)){
30bc6613
MN
898 eof=1;
899 continue;
900 }else
901 return ret;
902 }
115329f1 903
02b15cc8 904 if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
769e10f0 905 return AVERROR(ENOMEM);
30bc6613
MN
906 }else{
907 assert(!s->packet_buffer);
908 return av_read_frame_internal(s, pkt);
909 }
fb2758c8
FB
910 }
911}
912
913/* XXX: suppress the packet queue */
914static void flush_packet_queue(AVFormatContext *s)
915{
916 AVPacketList *pktl;
917
918 for(;;) {
919 pktl = s->packet_buffer;
115329f1 920 if (!pktl)
fb2758c8
FB
921 break;
922 s->packet_buffer = pktl->next;
923 av_free_packet(&pktl->pkt);
924 av_free(pktl);
b9a281db
FB
925 }
926}
927
da24c5e3 928/*******************************************************/
fb2758c8
FB
929/* seek support */
930
b754978a
MN
931int 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];
01f4895c 940 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
b754978a
MN
941 return i;
942 }
943 }
944 return 0;
945}
946
e36bdf8b
DK
947/**
948 * Flush the frame reader.
949 */
fb2758c8
FB
950static 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;
115329f1 966
fb2758c8
FB
967 /* for each stream, reset read state */
968 for(i = 0; i < s->nb_streams; i++) {
969 st = s->streams[i];
115329f1 970
fb2758c8
FB
971 if (st->parser) {
972 av_parser_close(st->parser);
973 st->parser = NULL;
974 }
77405fc8 975 st->last_IP_pts = AV_NOPTS_VALUE;
a843d1ff 976 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
fb2758c8
FB
977 }
978}
979
22ffac70 980void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
8bcb147f
MN
981 int i;
982
983 for(i = 0; i < s->nb_streams; i++) {
1a1dc611 984 AVStream *st = s->streams[i];
8bcb147f 985
115329f1 986 st->cur_dts = av_rescale(timestamp,
1a1dc611
NK
987 st->time_base.den * (int64_t)ref_st->time_base.num,
988 st->time_base.num * (int64_t)ref_st->time_base.den);
8bcb147f
MN
989 }
990}
991
3e9245a9 992int av_add_index_entry(AVStream *st,
30a43f2d 993 int64_t pos, int64_t timestamp, int size, int distance, int flags)
fb2758c8
FB
994{
995 AVIndexEntry *entries, *ie;
b754978a 996 int index;
115329f1 997
568e18b1
MN
998 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
999 return -1;
115329f1 1000
fb2758c8
FB
1001 entries = av_fast_realloc(st->index_entries,
1002 &st->index_entries_allocated_size,
115329f1 1003 (st->nb_index_entries + 1) *
fb2758c8 1004 sizeof(AVIndexEntry));
568e18b1
MN
1005 if(!entries)
1006 return -1;
1007
b754978a
MN
1008 st->index_entries= entries;
1009
27a5fe5f 1010 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
b754978a 1011
3ba1438d 1012 if(index<0){
3e9245a9
MN
1013 index= st->nb_index_entries++;
1014 ie= &entries[index];
3ba1438d
MN
1015 assert(index==0 || ie[-1].timestamp < timestamp);
1016 }else{
1017 ie= &entries[index];
1018 if(ie->timestamp != timestamp){
528c2c73
MN
1019 if(ie->timestamp <= timestamp)
1020 return -1;
3ba1438d
MN
1021 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1022 st->nb_index_entries++;
755bfeab 1023 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
3ba1438d 1024 distance= ie->min_distance;
3e9245a9 1025 }
3ba1438d 1026
b754978a
MN
1027 ie->pos = pos;
1028 ie->timestamp = timestamp;
3e9245a9 1029 ie->min_distance= distance;
30a43f2d 1030 ie->size= size;
b754978a 1031 ie->flags = flags;
115329f1 1032
3e9245a9 1033 return index;
fb2758c8
FB
1034}
1035
dc56fc38 1036int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
27a5fe5f 1037 int flags)
fb2758c8 1038{
b754978a
MN
1039 AVIndexEntry *entries= st->index_entries;
1040 int nb_entries= st->nb_index_entries;
fb2758c8
FB
1041 int a, b, m;
1042 int64_t timestamp;
1043
3ba1438d
MN
1044 a = - 1;
1045 b = nb_entries;
b754978a 1046
3ba1438d
MN
1047 while (b - a > 1) {
1048 m = (a + b) >> 1;
fb2758c8 1049 timestamp = entries[m].timestamp;
3ba1438d
MN
1050 if(timestamp >= wanted_timestamp)
1051 b = m;
1052 if(timestamp <= wanted_timestamp)
b754978a 1053 a = m;
fb2758c8 1054 }
27a5fe5f 1055 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
115329f1 1056
27a5fe5f
MN
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 }
3ba1438d 1062
115329f1 1063 if(m == nb_entries)
3ba1438d
MN
1064 return -1;
1065 return m;
fb2758c8
FB
1066}
1067
0f652a8e 1068#define DEBUG_SEEK
8d14a25c 1069
3ba1438d 1070int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
8d14a25c
MN
1071 AVInputFormat *avif= s->iformat;
1072 int64_t pos_min, pos_max, pos, pos_limit;
1073 int64_t ts_min, ts_max, ts;
89ddd2a9 1074 int index;
8d14a25c
MN
1075 AVStream *st;
1076
cdd5034f
MN
1077 if (stream_index < 0)
1078 return -1;
115329f1 1079
8d14a25c 1080#ifdef DEBUG_SEEK
4733abcb 1081 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
8d14a25c
MN
1082#endif
1083
1084 ts_max=
1085 ts_min= AV_NOPTS_VALUE;
90b5b51e 1086 pos_limit= -1; //gcc falsely says it may be uninitialized
8d14a25c
MN
1087
1088 st= s->streams[stream_index];
1089 if(st->index_entries){
1090 AVIndexEntry *e;
1091
27a5fe5f 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()
3ba1438d 1093 index= FFMAX(index, 0);
8d14a25c
MN
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
115329f1 1100 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
8d14a25c
MN
1101 pos_min,ts_min);
1102#endif
1103 }else{
1104 assert(index==0);
1105 }
115329f1
DB
1106
1107 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
27a5fe5f
MN
1108 assert(index < st->nb_index_entries);
1109 if(index >= 0){
8d14a25c
MN
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
115329f1 1116 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
8d14a25c
MN
1117 pos_max,pos_limit, ts_max);
1118#endif
1119 }
1120 }
1121
89ddd2a9
MN
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 */
899681cd 1127 url_fseek(s->pb, pos, SEEK_SET);
89ddd2a9
MN
1128
1129 av_update_cur_dts(s, st, ts);
1130
1131 return 0;
1132}
1133
89ddd2a9
MN
1134int64_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
8d14a25c
MN
1143 if(ts_min == AV_NOPTS_VALUE){
1144 pos_min = s->data_offset;
89ddd2a9 1145 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
8d14a25c
MN
1146 if (ts_min == AV_NOPTS_VALUE)
1147 return -1;
1148 }
1149
1150 if(ts_max == AV_NOPTS_VALUE){
1151 int step= 1024;
899681cd 1152 filesize = url_fsize(s->pb);
6fd93ce2 1153 pos_max = filesize - 1;
8d14a25c
MN
1154 do{
1155 pos_max -= step;
89ddd2a9 1156 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
8d14a25c
MN
1157 step += step;
1158 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1159 if (ts_max == AV_NOPTS_VALUE)
1160 return -1;
115329f1 1161
8d14a25c
MN
1162 for(;;){
1163 int64_t tmp_pos= pos_max + 1;
89ddd2a9 1164 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
8d14a25c
MN
1165 if(tmp_ts == AV_NOPTS_VALUE)
1166 break;
1167 ts_max= tmp_ts;
1168 pos_max= tmp_pos;
6fd93ce2
KA
1169 if(tmp_pos >= filesize)
1170 break;
8d14a25c
MN
1171 }
1172 pos_limit= pos_max;
1173 }
1174
53f7c43f
MN
1175 if(ts_min > ts_max){
1176 return -1;
1177 }else if(ts_min == ts_max){
1178 pos_limit= pos_min;
1179 }
1180
8d14a25c
MN
1181 no_change=0;
1182 while (pos_min < pos_limit) {
1183#ifdef DEBUG_SEEK
115329f1 1184 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
8d14a25c
MN
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)
3ba1438d
MN
1193 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1194 + pos_min - approximate_keyframe_distance;
8d14a25c
MN
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
89ddd2a9 1208 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
8d14a25c
MN
1209 if(pos == pos_max)
1210 no_change++;
1211 else
1212 no_change=0;
1213#ifdef DEBUG_SEEK
4733abcb 1214av_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);
8d14a25c 1215#endif
db2a0e22
MN
1216 if(ts == AV_NOPTS_VALUE){
1217 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1218 return -1;
1219 }
8d14a25c 1220 assert(ts != AV_NOPTS_VALUE);
3ba1438d 1221 if (target_ts <= ts) {
8d14a25c
MN
1222 pos_limit = start_pos - 1;
1223 pos_max = pos;
1224 ts_max = ts;
3ba1438d
MN
1225 }
1226 if (target_ts >= ts) {
8d14a25c
MN
1227 pos_min = pos;
1228 ts_min = ts;
8d14a25c
MN
1229 }
1230 }
115329f1 1231
3ba1438d
MN
1232 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1233 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
8d14a25c
MN
1234#ifdef DEBUG_SEEK
1235 pos_min = pos;
89ddd2a9 1236 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
8d14a25c 1237 pos_min++;
89ddd2a9 1238 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
115329f1 1239 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
8d14a25c
MN
1240 pos, ts_min, target_ts, ts_max);
1241#endif
89ddd2a9
MN
1242 *ts_ret= ts;
1243 return pos;
8d14a25c
MN
1244}
1245
3ba1438d 1246static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
3ba1438d
MN
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;
899681cd 1258 pos_max = url_fsize(s->pb) - 1;
3ba1438d
MN
1259
1260 if (pos < pos_min) pos= pos_min;
1261 else if(pos > pos_max) pos= pos_max;
1262
899681cd 1263 url_fseek(s->pb, pos, SEEK_SET);
3ba1438d
MN
1264
1265#if 0
8bcb147f 1266 av_update_cur_dts(s, st, ts);
3ba1438d
MN
1267#endif
1268 return 0;
1269}
1270
115329f1 1271static int av_seek_frame_generic(AVFormatContext *s,
3ba1438d 1272 int stream_index, int64_t timestamp, int flags)
fb2758c8 1273{
8bcb147f 1274 int index;
fb2758c8
FB
1275 AVStream *st;
1276 AVIndexEntry *ie;
1277
fb2758c8 1278 st = s->streams[stream_index];
e9b78eeb 1279
27a5fe5f 1280 index = av_index_search_timestamp(st, timestamp, flags);
e9b78eeb 1281
b5a3541d 1282 if(index < 0 || index==st->nb_index_entries-1){
e9b78eeb
MN
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];
899681cd 1288 url_fseek(s->pb, ie->pos, SEEK_SET);
e9b78eeb
MN
1289 av_update_cur_dts(s, st, ie->timestamp);
1290 }else
899681cd 1291 url_fseek(s->pb, 0, SEEK_SET);
e9b78eeb
MN
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 }
fb2758c8
FB
1305 if (index < 0)
1306 return -1;
1307
fb2758c8 1308 av_read_frame_flush(s);
e9b78eeb
MN
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];
899681cd 1314 url_fseek(s->pb, ie->pos, SEEK_SET);
3ba1438d 1315
8bcb147f 1316 av_update_cur_dts(s, st, ie->timestamp);
cdd5034f 1317
fb2758c8
FB
1318 return 0;
1319}
1320
3ba1438d 1321int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
fb2758c8
FB
1322{
1323 int ret;
cdd5034f 1324 AVStream *st;
115329f1 1325
fb2758c8 1326 av_read_frame_flush(s);
115329f1 1327
3ba1438d
MN
1328 if(flags & AVSEEK_FLAG_BYTE)
1329 return av_seek_frame_byte(s, stream_index, timestamp, flags);
115329f1 1330
cdd5034f
MN
1331 if(stream_index < 0){
1332 stream_index= av_find_default_stream_index(s);
1333 if(stream_index < 0)
1334 return -1;
115329f1 1335
3ba1438d 1336 st= s->streams[stream_index];
eb497825 1337 /* timestamp for default must be expressed in AV_TIME_BASE units */
3ba1438d 1338 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
cdd5034f
MN
1339 }
1340 st= s->streams[stream_index];
1341
fb2758c8
FB
1342 /* first, we try the format specific seek */
1343 if (s->iformat->read_seek)
3ba1438d 1344 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
fb2758c8
FB
1345 else
1346 ret = -1;
1347 if (ret >= 0) {
1348 return 0;
1349 }
8d14a25c
MN
1350
1351 if(s->iformat->read_timestamp)
3ba1438d 1352 return av_seek_frame_binary(s, stream_index, timestamp, flags);
8d14a25c 1353 else
3ba1438d 1354 return av_seek_frame_generic(s, stream_index, timestamp, flags);
fb2758c8
FB
1355}
1356
1357/*******************************************************/
12f996ed 1358
e36bdf8b 1359/**
c1e8b678 1360 * Returns TRUE if the stream has accurate duration in any stream.
e36bdf8b 1361 *
c1e8b678 1362 * @return TRUE if the stream has accurate duration for at least one component.
e36bdf8b 1363 */
c1e8b678 1364static int av_has_duration(AVFormatContext *ic)
12f996ed
FB
1365{
1366 int i;
1367 AVStream *st;
1368
1369 for(i = 0;i < ic->nb_streams; i++) {
1370 st = ic->streams[i];
c1e8b678 1371 if (st->duration != AV_NOPTS_VALUE)
12f996ed
FB
1372 return 1;
1373 }
1374 return 0;
1375}
1376
e36bdf8b
DK
1377/**
1378 * Estimate the stream timings from the one of each components.
1379 *
1380 * Also computes the global bitrate if possible.
1381 */
12f996ed
FB
1382static void av_update_stream_timings(AVFormatContext *ic)
1383{
c0df9d75 1384 int64_t start_time, start_time1, end_time, end_time1;
c1e8b678 1385 int64_t duration, duration1;
12f996ed
FB
1386 int i;
1387 AVStream *st;
1388
f27a7268
MR
1389 start_time = INT64_MAX;
1390 end_time = INT64_MIN;
c1e8b678 1391 duration = INT64_MIN;
12f996ed
FB
1392 for(i = 0;i < ic->nb_streams; i++) {
1393 st = ic->streams[i];
1394 if (st->start_time != AV_NOPTS_VALUE) {
c0df9d75
MN
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;
12f996ed 1398 if (st->duration != AV_NOPTS_VALUE) {
c0df9d75
MN
1399 end_time1 = start_time1
1400 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
12f996ed
FB
1401 if (end_time1 > end_time)
1402 end_time = end_time1;
1403 }
1404 }
c1e8b678
NB
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 }
12f996ed 1410 }
f27a7268 1411 if (start_time != INT64_MAX) {
12f996ed 1412 ic->start_time = start_time;
f27a7268 1413 if (end_time != INT64_MIN) {
c1e8b678
NB
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;
12f996ed
FB
1424 }
1425 }
12f996ed
FB
1426}
1427
1428static 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) {
c0df9d75
MN
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);
12f996ed
FB
1441 }
1442 }
1443}
1444
1445static 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];
01f4895c 1456 bit_rate += st->codec->bit_rate;
12f996ed
FB
1457 }
1458 ic->bit_rate = bit_rate;
1459 }
1460
1461 /* if duration is already set, we believe it */
115329f1
DB
1462 if (ic->duration == AV_NOPTS_VALUE &&
1463 ic->bit_rate != 0 &&
12f996ed
FB
1464 ic->file_size != 0) {
1465 filesize = ic->file_size;
1466 if (filesize > 0) {
12f996ed
FB
1467 for(i = 0; i < ic->nb_streams; i++) {
1468 st = ic->streams[i];
c0df9d75 1469 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
9f32041d 1470 if (st->duration == AV_NOPTS_VALUE)
12f996ed 1471 st->duration = duration;
12f996ed
FB
1472 }
1473 }
1474 }
1475}
1476
12f996ed
FB
1477#define DURATION_MAX_READ_SIZE 250000
1478
1479/* only usable for MPEG-PS streams */
9ecf7fad 1480static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
12f996ed
FB
1481{
1482 AVPacket pkt1, *pkt = &pkt1;
1483 AVStream *st;
1484 int read_size, i, ret;
bf4e3bd2 1485 int64_t end_time;
12f996ed 1486 int64_t filesize, offset, duration;
115329f1 1487
578688fa
LA
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 }
115329f1 1503
12f996ed
FB
1504 /* we read the first packets to get the first PTS (not fully
1505 accurate, but it is enough now) */
899681cd 1506 url_fseek(ic->pb, 0, SEEK_SET);
12f996ed
FB
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)
c0df9d75 1527 st->start_time = pkt->pts;
0a5f92a1
MN
1528 }
1529 av_free_packet(pkt);
1530 }
12f996ed 1531
12f996ed
FB
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
899681cd 1539 url_fseek(ic->pb, offset, SEEK_SET);
12f996ed
FB
1540 read_size = 0;
1541 for(;;) {
1542 if (read_size >= DURATION_MAX_READ_SIZE)
1543 break;
115329f1 1544
12f996ed
FB
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];
bf494092
NB
1550 if (pkt->pts != AV_NOPTS_VALUE &&
1551 st->start_time != AV_NOPTS_VALUE) {
c0df9d75 1552 end_time = pkt->pts;
12f996ed
FB
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 }
115329f1 1562
c0df9d75 1563 fill_all_stream_timings(ic);
12f996ed 1564
899681cd 1565 url_fseek(ic->pb, old_offset, SEEK_SET);
df886e7e
MN
1566 for(i=0; i<ic->nb_streams; i++){
1567 st= ic->streams[i];
1568 st->cur_dts= st->first_dts;
cc5297e8 1569 st->last_IP_pts = AV_NOPTS_VALUE;
df886e7e 1570 }
12f996ed
FB
1571}
1572
9ecf7fad 1573static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
12f996ed 1574{
12f996ed
FB
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 {
899681cd 1581 file_size = url_fsize(ic->pb);
12f996ed
FB
1582 if (file_size < 0)
1583 file_size = 0;
1584 }
1585 ic->file_size = file_size;
1586
ff70e601
MR
1587 if ((!strcmp(ic->iformat->name, "mpeg") ||
1588 !strcmp(ic->iformat->name, "mpegts")) &&
899681cd 1589 file_size && !ic->pb->is_streamed) {
12f996ed 1590 /* get accurate estimate from the PTSes */
9ecf7fad 1591 av_estimate_timings_from_pts(ic, old_offset);
c1e8b678 1592 } else if (av_has_duration(ic)) {
12f996ed
FB
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];
115329f1
DB
1608 printf("%d: start_time: %0.3f duration: %0.3f\n",
1609 i, (double)st->start_time / AV_TIME_BASE,
12f996ed
FB
1610 (double)st->duration / AV_TIME_BASE);
1611 }
115329f1
DB
1612 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1613 (double)ic->start_time / AV_TIME_BASE,
12f996ed
FB
1614 (double)ic->duration / AV_TIME_BASE,
1615 ic->bit_rate / 1000);
1616 }
1617#endif
1618}
1619
b9a281db
FB
1620static 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:
644a9262 1628 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
b9a281db
FB
1629 break;
1630 default:
1631 val = 1;
1632 break;
1633 }
3303926c 1634 return (enc->codec_id != CODEC_ID_NONE && val != 0);
b9a281db
FB
1635}
1636
fb2758c8
FB
1637static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1638{
1639 int16_t *samples;
1640 AVCodec *codec;
3fdb6af9 1641 int got_picture, data_size, ret=0;
fb2758c8 1642 AVFrame picture;
115329f1 1643
01f4895c
MN
1644 if(!st->codec->codec){
1645 codec = avcodec_find_decoder(st->codec->codec_id);
fb2758c8
FB
1646 if (!codec)
1647 return -1;
01f4895c 1648 ret = avcodec_open(st->codec, codec);
fb2758c8
FB
1649 if (ret < 0)
1650 return ret;
43c0040a 1651 }
644a9262 1652
01f4895c
MN
1653 if(!has_codec_parameters(st->codec)){
1654 switch(st->codec->codec_type) {
fb2758c8 1655 case CODEC_TYPE_VIDEO:
115329f1 1656 ret = avcodec_decode_video(st->codec, &picture,
fb2758c8
FB
1657 &got_picture, (uint8_t *)data, size);
1658 break;
1659 case CODEC_TYPE_AUDIO:
3fdb6af9
BC
1660 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1661 samples = av_malloc(data_size);
fb2758c8
FB
1662 if (!samples)
1663 goto fail;
3fdb6af9
BC
1664 ret = avcodec_decode_audio2(st->codec, samples,
1665 &data_size, (uint8_t *)data, size);
fb2758c8
FB
1666 av_free(samples);
1667 break;
1668 default:
1669 break;
1670 }
644a9262 1671 }
fb2758c8 1672 fail:
fb2758c8
FB
1673 return ret;
1674}
1675
6fea687e
JD
1676static 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 }
efd5fc53 1687 return !!fmt;
6fea687e
JD
1688}
1689
45da8124
AJ
1690unsigned 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
1700enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1701{
41415d28
MN
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;
45da8124
AJ
1713 }
1714 return CODEC_ID_NONE;
1715}
1716
1717unsigned 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
1727enum 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
fb2758c8
FB
1737/* absolute maximum size we read until we abort */
1738#define MAX_READ_SIZE 5000000
1739
fd97f6a2 1740#define MAX_STD_TIMEBASES (60*12+5)
4d43cbcc
MN
1741static int get_std_framerate(int i){
1742 if(i<60*12) return i*1001;
fd97f6a2 1743 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
4d43cbcc
MN
1744}
1745
b9a281db
FB
1746int av_find_stream_info(AVFormatContext *ic)
1747{
9f75260e 1748 int i, count, ret, read_size, j;
b9a281db 1749 AVStream *st;
fb2758c8 1750 AVPacket pkt1, *pkt;
15bc38e5 1751 int64_t last_dts[MAX_STREAMS];
3c150d16 1752 int duration_count[MAX_STREAMS]={0};
0cbff027 1753 double (*duration_error)[MAX_STD_TIMEBASES];
899681cd 1754 offset_t old_offset = url_ftell(ic->pb);
ea486ab3
BC
1755 int64_t codec_info_duration[MAX_STREAMS]={0};
1756 int codec_info_nb_frames[MAX_STREAMS]={0};
6fea687e
JD
1757 AVProbeData probe_data[MAX_STREAMS];
1758 int codec_identified[MAX_STREAMS]={0};
b9a281db 1759
0cbff027 1760 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
769e10f0 1761 if (!duration_error) return AVERROR(ENOMEM);
0cbff027 1762
c0df9d75
MN
1763 for(i=0;i<ic->nb_streams;i++) {
1764 st = ic->streams[i];
01f4895c 1765 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
c0df9d75
MN
1766/* if(!st->time_base.num)
1767 st->time_base= */
01f4895c
MN
1768 if(!st->codec->time_base.num)
1769 st->codec->time_base= st->time_base;
c0df9d75 1770 }
90ad92b3
MN
1771 //only for the split stuff
1772 if (!st->parser) {
01f4895c 1773 st->parser = av_parser_init(st->codec->codec_id);
57004ff1 1774 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
7cbaa7ba
MN
1775 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1776 }
90ad92b3 1777 }
c0df9d75
MN
1778 }
1779
15bc38e5
MN
1780 for(i=0;i<MAX_STREAMS;i++){
1781 last_dts[i]= AV_NOPTS_VALUE;
15bc38e5 1782 }
115329f1 1783
6fea687e 1784 memset(probe_data, 0, sizeof(probe_data));
b9a281db
FB
1785 count = 0;
1786 read_size = 0;
b9a281db
FB
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];
01f4895c 1791 if (!has_codec_parameters(st->codec))
b9a281db 1792 break;
3e76d1b5 1793 /* variable fps and no guess at the real fps */
6cc65ab3 1794 if( (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
01f4895c 1795 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
3e76d1b5 1796 break;
01f4895c 1797 if(st->parser && st->parser->parser->split && !st->codec->extradata)
90ad92b3 1798 break;
82583548
MN
1799 if(st->first_dts == AV_NOPTS_VALUE)
1800 break;
b9a281db
FB
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 */
fb2758c8 1806 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
b9a281db
FB
1807 /* if we found the info for all the codecs, we can stop */
1808 ret = count;
1809 break;
1810 }
5fb83c38 1811 }
35eab0c0
MN
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 }
b9a281db 1817
fb2758c8
FB
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 */
e19456e3
MN
1824 for(i=0;i<ic->nb_streams;i++) {
1825 st = ic->streams[i];
305ee50f
MN
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);
344a18c3
MR
1830 } else {
1831 ret = 0;
305ee50f 1832 }
e19456e3 1833 }
fb2758c8
FB
1834 break;
1835 }
1836
02b15cc8
MN
1837 pkt= add_to_pktbuf(ic, &pkt1);
1838 if(av_dup_packet(pkt) < 0)
1839 return AVERROR(ENOMEM);
b9a281db 1840
fb2758c8 1841 read_size += pkt->size;
b9a281db
FB
1842
1843 st = ic->streams[pkt->stream_index];
ea486ab3
BC
1844 if(codec_info_nb_frames[st->index]>1)
1845 codec_info_duration[st->index] += pkt->duration;
fb2758c8 1846 if (pkt->duration != 0)
ea486ab3 1847 codec_info_nb_frames[st->index]++;
fb2758c8 1848
cefe0607 1849 {
3c150d16
MN
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){
4d43cbcc
MN
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);
1694118b 1859 if(duration_count[index] < 2)
0cbff027 1860 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
69c262d1
MN
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 }
4d43cbcc 1867 duration_count[index]++;
15bc38e5 1868 }
fd97f6a2
MN
1869 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1870 last_dts[pkt->stream_index]= pkt->dts;
6fea687e
JD
1871
1872 if (st->codec->codec_id == CODEC_ID_NONE) {
1873 AVProbeData *pd = &(probe_data[st->index]);
9be51815 1874 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
6fea687e
JD
1875 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1876 pd->buf_size += pkt->size;
9be51815 1877 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
6fea687e 1878 }
15bc38e5 1879 }
01f4895c
MN
1880 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1881 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
90ad92b3 1882 if(i){
01f4895c 1883 st->codec->extradata_size= i;
62c52121 1884 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
01f4895c 1885 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
62c52121 1886 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
90ad92b3
MN
1887 }
1888 }
115329f1 1889
fb2758c8
FB
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. */
01f4895c
MN
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))*/)
fb2758c8 1909 try_decode_frame(st, pkt->data, pkt->size);
115329f1 1910
b3fc0925 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) {
fb2758c8 1912 break;
b9a281db
FB
1913 }
1914 count++;
1915 }
1916
43c0040a
MN
1917 // close codecs which where opened in try_decode_frame()
1918 for(i=0;i<ic->nb_streams;i++) {
1919 st = ic->streams[i];
01f4895c
MN
1920 if(st->codec->codec)
1921 avcodec_close(st->codec);
43c0040a 1922 }
b9a281db
FB
1923 for(i=0;i<ic->nb_streams;i++) {
1924 st = ic->streams[i];
01f4895c
MN
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);
15bc38e5 1928
1694118b 1929 if(duration_count[i]
4d43cbcc 1930 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
730ba406 1931 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
4d43cbcc
MN
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);
9f75260e
MN
1940 if(error < best_error){
1941 best_error= error;
4d43cbcc 1942 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
9f75260e 1943 }
3c150d16 1944 }
15bc38e5
MN
1945 }
1946
c0df9d75 1947 if (!st->r_frame_rate.num){
5523d5f4
MN
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 }
14bea432 1956 }
a185f52a 1957 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
19ecf882 1958 if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
e0c850a8 1959 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
6fea687e 1960 if (codec_identified[st->index]) {
57004ff1 1961 st->need_parsing = AVSTREAM_PARSE_FULL;
6fea687e
JD
1962 }
1963 }
a185f52a
MN
1964 if(!st->codec->bits_per_sample)
1965 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
b9a281db 1966 }
de6d9b64 1967 }
b9a281db 1968
9ecf7fad 1969 av_estimate_timings(ic, old_offset);
6fea687e
JD
1970
1971 for(i=0;i<ic->nb_streams;i++) {
1972 st = ic->streams[i];
c7385375
MN
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;
6fea687e 1985 }
899681cd 1986 url_fseek(ic->pb, ic->data_offset, SEEK_SET);
6fea687e
JD
1987 }
1988
e928649b
MN
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];
01f4895c 1993 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
e928649b
MN
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
0cbff027
KA
2013
2014 av_free(duration_error);
6fea687e
JD
2015 for(i=0;i<MAX_STREAMS;i++){
2016 av_freep(&(probe_data[i].buf));
2017 }
0cbff027 2018
b9a281db 2019 return ret;
de6d9b64
FB
2020}
2021
fb2758c8
FB
2022/*******************************************************/
2023
fb2758c8
FB
2024int av_read_play(AVFormatContext *s)
2025{
fa13095a
BA
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);
fb2758c8
FB
2031}
2032
fb2758c8
FB
2033int av_read_pause(AVFormatContext *s)
2034{
fa13095a
BA
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);
fb2758c8
FB
2040}
2041
de6d9b64
FB
2042void av_close_input_file(AVFormatContext *s)
2043{
b6892136 2044 int i, must_open_file;
da24c5e3 2045 AVStream *st;
de6d9b64 2046
fb2758c8
FB
2047 /* free previous packet */
2048 if (s->cur_st && s->cur_st->parser)
115329f1 2049 av_free_packet(&s->cur_pkt);
fb2758c8 2050
b9a281db
FB
2051 if (s->iformat->read_close)
2052 s->iformat->read_close(s);
de6d9b64 2053 for(i=0;i<s->nb_streams;i++) {
da24c5e3
FB
2054 /* free all data in a stream component */
2055 st = s->streams[i];
fb2758c8
FB
2056 if (st->parser) {
2057 av_parser_close(st->parser);
de6d9b64 2058 }
fb2758c8 2059 av_free(st->index_entries);
a5e9102b 2060 av_free(st->codec->extradata);
01f4895c 2061 av_free(st->codec);
fb2758c8 2062 av_free(st);
de6d9b64 2063 }
15afa396
NS
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);
526efa10 2067 av_freep(&s->programs[i]->stream_index);
15afa396
NS
2068 av_freep(&s->programs[i]);
2069 }
fb2758c8 2070 flush_packet_queue(s);
b6892136 2071 must_open_file = 1;
da24c5e3 2072 if (s->iformat->flags & AVFMT_NOFILE) {
b6892136
FB
2073 must_open_file = 0;
2074 }
2075 if (must_open_file) {
899681cd 2076 url_fclose(s->pb);
96baaa6a 2077 }
a8dbe951 2078 av_freep(&s->priv_data);
1ea4f593 2079 av_free(s);
de6d9b64
FB
2080}
2081
b9a281db
FB
2082AVStream *av_new_stream(AVFormatContext *s, int id)
2083{
2084 AVStream *st;
504ee036 2085 int i;
b9a281db
FB
2086
2087 if (s->nb_streams >= MAX_STREAMS)
2088 return NULL;
2089
2090 st = av_mallocz(sizeof(AVStream));
2091 if (!st)
2092 return NULL;
115329f1 2093
01f4895c 2094 st->codec= avcodec_alloc_context();
48091512
FB
2095 if (s->iformat) {
2096 /* no default bitrate if decoding */
01f4895c 2097 st->codec->bit_rate = 0;
48091512 2098 }
b9a281db
FB
2099 st->index = s->nb_streams;
2100 st->id = id;
12f996ed
FB
2101 st->start_time = AV_NOPTS_VALUE;
2102 st->duration = AV_NOPTS_VALUE;
e928649b 2103 st->cur_dts = AV_NOPTS_VALUE;
82583548 2104 st->first_dts = AV_NOPTS_VALUE;
9ee91c2f
MN
2105
2106 /* default pts settings is MPEG like */
2107 av_set_pts_info(st, 33, 1, 90000);
77405fc8 2108 st->last_IP_pts = AV_NOPTS_VALUE;
504ee036
MN
2109 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2110 st->pts_buffer[i]= AV_NOPTS_VALUE;
9ee91c2f 2111
b9a281db
FB
2112 s->streams[s->nb_streams++] = st;
2113 return st;
2114}
2115
15afa396
NS
2116AVProgram *av_new_program(AVFormatContext *ac, int id)
2117{
2118 AVProgram *program=NULL;
2119 int i;
2120
2121#ifdef DEBUG_SI
2122 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2123#endif
2124
2125 for(i=0; i<ac->nb_programs; i++)
2126 if(ac->programs[i]->id == id)
2127 program = ac->programs[i];
2128
2129 if(!program){
2130 program = av_mallocz(sizeof(AVProgram));
2131 if (!program)
2132 return NULL;
2133 dynarray_add(&ac->programs, &ac->nb_programs, program);
2134 program->discard = AVDISCARD_NONE;
2135 }
2136 program->id = id;
2137
2138 return program;
2139}
2140
2141void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2142{
2143 assert(!provider_name == !name);
2144 if(name){
2145 av_free(program->provider_name);
2146 av_free(program-> name);
2147 program->provider_name = av_strdup(provider_name);
2148 program-> name = av_strdup( name);
2149 }
2150}
2151
2152
b9a281db
FB
2153/************************************************************/
2154/* output media file */
de6d9b64 2155
87a0a681
FB
2156int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2157{
2158 int ret;
115329f1 2159
98486a6b
RS
2160 if (s->oformat->priv_data_size > 0) {
2161 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2162 if (!s->priv_data)
769e10f0 2163 return AVERROR(ENOMEM);
98486a6b
RS
2164 } else
2165 s->priv_data = NULL;
115329f1 2166
87a0a681
FB
2167 if (s->oformat->set_parameters) {
2168 ret = s->oformat->set_parameters(s, ap);
2169 if (ret < 0)
2170 return ret;
2171 }
2172 return 0;
2173}
2174
b9a281db
FB
2175int av_write_header(AVFormatContext *s)
2176{
1e51d801
FB
2177 int ret, i;
2178 AVStream *st;
2179
9450118b
MN
2180 // some sanity checks
2181 for(i=0;i<s->nb_streams;i++) {
2182 st = s->streams[i];
2183
2184 switch (st->codec->codec_type) {
2185 case CODEC_TYPE_AUDIO:
2186 if(st->codec->sample_rate<=0){
2187 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2188 return -1;
2189 }
2190 break;
2191 case CODEC_TYPE_VIDEO:
2192 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2193 av_log(s, AV_LOG_ERROR, "time base not set\n");
2194 return -1;
2195 }
2196 if(st->codec->width<=0 || st->codec->height<=0){
2197 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2198 return -1;
2199 }
2200 break;
2201 }
5ecfa9f5
MN
2202
2203 if(s->oformat->codec_tag){
2204 if(st->codec->codec_tag){
2205 //FIXME
2206 //check that tag + id is in the table
2207 //if neither is in the table -> ok
2208 //if tag is in the table with another id -> FAIL
2209 //if id is in the table with another tag -> FAIL unless strict < ?
2210 }else
2211 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2212 }
9450118b
MN
2213 }
2214
8fae2df5 2215 if (!s->priv_data && s->oformat->priv_data_size > 0) {
c6efa4b5
BC
2216 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2217 if (!s->priv_data)
769e10f0 2218 return AVERROR(ENOMEM);
8fae2df5 2219 }
c6efa4b5 2220
31e11451
MN
2221 if(s->oformat->write_header){
2222 ret = s->oformat->write_header(s);
2223 if (ret < 0)
2224 return ret;
2225 }
1e51d801
FB
2226
2227 /* init PTS generation */
2228 for(i=0;i<s->nb_streams;i++) {
f0ff20a1 2229 int64_t den = AV_NOPTS_VALUE;
1e51d801
FB
2230 st = s->streams[i];
2231
01f4895c 2232 switch (st->codec->codec_type) {
1e51d801 2233 case CODEC_TYPE_AUDIO:
f0ff20a1 2234 den = (int64_t)st->time_base.num * st->codec->sample_rate;
1e51d801
FB
2235 break;
2236 case CODEC_TYPE_VIDEO:
f0ff20a1 2237 den = (int64_t)st->time_base.num * st->codec->time_base.den;
1e51d801
FB
2238 break;
2239 default:
2240 break;
2241 }
f0ff20a1
WG
2242 if (den != AV_NOPTS_VALUE) {
2243 if (den <= 0)
2244 return AVERROR_INVALIDDATA;
2245 av_frac_init(&st->pts, 0, 0, den);
2246 }
1e51d801
FB
2247 }
2248 return 0;
b9a281db
FB
2249}
2250
3c895fc0 2251//FIXME merge with compute_pkt_fields
5edea431 2252static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
504ee036
MN
2253 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2254 int num, den, frame_size, i;
b0c7f5a9 2255
949b1a13 2256// 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);
115329f1 2257
e928649b
MN
2258/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2259 return -1;*/
115329f1 2260
e928649b 2261 /* duration field */
3c895fc0
MN
2262 if (pkt->duration == 0) {
2263 compute_frame_duration(&num, &den, st, NULL, pkt);
2264 if (den && num) {
2265 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2266 }
2267 }
e928649b
MN
2268
2269 //XXX/FIXME this is a temporary hack until all encoders output pts
504ee036 2270 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
e928649b
MN
2271 pkt->dts=
2272// pkt->pts= st->cur_dts;
2273 pkt->pts= st->pts.val;
2274 }
2275
115329f1 2276 //calculate dts from pts
e928649b 2277 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
504ee036
MN
2278 st->pts_buffer[0]= pkt->pts;
2279 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2280 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2281 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1345f4ed 2282 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
504ee036
MN
2283
2284 pkt->dts= st->pts_buffer[0];
e928649b 2285 }
115329f1 2286
5edea431 2287 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
578688fa 2288 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
5edea431
MN
2289 return -1;
2290 }
2291 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
578688fa 2292 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
5edea431
MN
2293 return -1;
2294 }
2295
949b1a13 2296// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
e928649b
MN
2297 st->cur_dts= pkt->dts;
2298 st->pts.val= pkt->dts;
2299
1e51d801 2300 /* update pts */
01f4895c 2301 switch (st->codec->codec_type) {
1e51d801 2302 case CODEC_TYPE_AUDIO:
01f4895c 2303 frame_size = get_audio_frame_size(st->codec, pkt->size);
6d8f985e 2304
b0c7f5a9 2305 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
6d8f985e 2306 but it would be better if we had the real timestamps from the encoder */
e928649b 2307 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
9ee91c2f 2308 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
7feb950a 2309 }
1e51d801
FB
2310 break;
2311 case CODEC_TYPE_VIDEO:
01f4895c 2312 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
1e51d801
FB
2313 break;
2314 default:
2315 break;
2316 }
5edea431 2317 return 0;
3c895fc0
MN
2318}
2319
2320static void truncate_ts(AVStream *st, AVPacket *pkt){
2321 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
115329f1 2322
e0c91bc2
MN
2323// if(pkt->dts < 0)
2324// pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
115329f1 2325
68a432cf 2326 if (pkt->pts != AV_NOPTS_VALUE)
8533284d 2327 pkt->pts &= pts_mask;
68a432cf 2328 if (pkt->dts != AV_NOPTS_VALUE)
8533284d 2329 pkt->dts &= pts_mask;
3c895fc0
MN
2330}
2331
3c895fc0
MN
2332int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2333{
576ae256
MN
2334 int ret;
2335
5edea431 2336 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
494bbf58 2337 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
5edea431 2338 return ret;
115329f1 2339
3c895fc0
MN
2340 truncate_ts(s->streams[pkt->stream_index], pkt);
2341
576ae256
MN
2342 ret= s->oformat->write_packet(s, pkt);
2343 if(!ret)
899681cd 2344 ret= url_ferror(s->pb);
576ae256 2345 return ret;
3c895fc0
MN
2346}
2347
f21c0b4c 2348int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
fe2d6fe2
MN
2349 AVPacketList *pktl, **next_point, *this_pktl;
2350 int stream_count=0;
2351 int streams[MAX_STREAMS];
2352
2353 if(pkt){
2354 AVStream *st= s->streams[ pkt->stream_index];
2355
2577897d 2356// assert(pkt->destruct != av_destruct_packet); //FIXME
fe2d6fe2
MN
2357
2358 this_pktl = av_mallocz(sizeof(AVPacketList));
2359 this_pktl->pkt= *pkt;
2577897d
MN
2360 if(pkt->destruct == av_destruct_packet)
2361 pkt->destruct= NULL; // non shared -> must keep original from being freed
2362 else
2363 av_dup_packet(&this_pktl->pkt); //shared -> must dup
fe2d6fe2
MN
2364
2365 next_point = &s->packet_buffer;
2366 while(*next_point){
2367 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2368 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2369 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2370 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2371 break;
2372 next_point= &(*next_point)->next;
2373 }
2374 this_pktl->next= *next_point;
2375 *next_point= this_pktl;
2376 }
115329f1 2377
fe2d6fe2
MN
2378 memset(streams, 0, sizeof(streams));
2379 pktl= s->packet_buffer;
2380 while(pktl){
949b1a13 2381//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
fe2d6fe2
MN
2382 if(streams[ pktl->pkt.stream_index ] == 0)
2383 stream_count++;
2384 streams[ pktl->pkt.stream_index ]++;
2385 pktl= pktl->next;
2386 }
115329f1 2387
fe2d6fe2
MN
2388 if(s->nb_streams == stream_count || (flush && stream_count)){
2389 pktl= s->packet_buffer;
2390 *out= pktl->pkt;
115329f1
DB
2391
2392 s->packet_buffer= pktl->next;
fe2d6fe2
MN
2393 av_freep(&pktl);
2394 return 1;
2395 }else{
2396 av_init_packet(out);
2397 return 0;
2398 }
2399}
2400
2401/**
2402 * Interleaves a AVPacket correctly so it can be muxed.
2403 * @param out the interleaved packet will be output here
2404 * @param in the input packet
2405 * @param flush 1 if no further packets are available as input and all
2406 * remaining packets should be output
115329f1 2407 * @return 1 if a packet was output, 0 if no packet could be output,
fe2d6fe2
MN
2408 * < 0 if an error occured
2409 */
2410static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2411 if(s->oformat->interleave_packet)
2412 return s->oformat->interleave_packet(s, out, in, flush);
2413 else
2414 return av_interleave_packet_per_dts(s, out, in, flush);
2415}
2416
3c895fc0 2417int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3c895fc0
MN
2418 AVStream *st= s->streams[ pkt->stream_index];
2419
6f824977 2420 //FIXME/XXX/HACK drop zero sized packets
01f4895c 2421 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
6f824977 2422 return 0;
3ce16b30 2423
949b1a13 2424//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
494bbf58 2425 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3ce16b30 2426 return -1;
115329f1 2427
3c895fc0
MN
2428 if(pkt->dts == AV_NOPTS_VALUE)
2429 return -1;
3c895fc0 2430
fe2d6fe2
MN
2431 for(;;){
2432 AVPacket opkt;
2433 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2434 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2435 return ret;
115329f1 2436
fe2d6fe2
MN
2437 truncate_ts(s->streams[opkt.stream_index], &opkt);
2438 ret= s->oformat->write_packet(s, &opkt);
115329f1 2439
fe2d6fe2
MN
2440 av_free_packet(&opkt);
2441 pkt= NULL;
115329f1 2442
3c895fc0
MN
2443 if(ret<0)
2444 return ret;
899681cd
BA
2445 if(url_ferror(s->pb))
2446 return url_ferror(s->pb);
3c895fc0 2447 }
b9a281db
FB
2448}
2449
b9a281db
FB
2450int av_write_trailer(AVFormatContext *s)
2451{
c40a3a42 2452 int ret, i;
115329f1 2453
fe2d6fe2
MN
2454 for(;;){
2455 AVPacket pkt;
2456 ret= av_interleave_packet(s, &pkt, NULL, 1);
2457 if(ret<0) //FIXME cleanup needed for ret<0 ?
c40a3a42 2458 goto fail;
fe2d6fe2
MN
2459 if(!ret)
2460 break;
115329f1 2461
fe2d6fe2
MN
2462 truncate_ts(s->streams[pkt.stream_index], &pkt);
2463 ret= s->oformat->write_packet(s, &pkt);
115329f1 2464
fe2d6fe2 2465 av_free_packet(&pkt);
115329f1 2466
3c895fc0 2467 if(ret<0)
c40a3a42 2468 goto fail;
899681cd 2469 if(url_ferror(s->pb))
576ae256 2470 goto fail;
3c895fc0
MN
2471 }
2472
31e11451
MN
2473 if(s->oformat->write_trailer)
2474 ret = s->oformat->write_trailer(s);
c40a3a42 2475fail:
576ae256 2476 if(ret == 0)
899681cd 2477 ret=url_ferror(s->pb);
c40a3a42
MN
2478 for(i=0;i<s->nb_streams;i++)
2479 av_freep(&s->streams[i]->priv_data);
b9a281db
FB
2480 av_freep(&s->priv_data);
2481 return ret;
de6d9b64
FB
2482}
2483
526efa10
NS
2484void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2485{
2486 int i, j;
2487 AVProgram *program=NULL;
2488 void *tmp;
2489
2490 for(i=0; i<ac->nb_programs; i++){
2491 if(ac->programs[i]->id != progid)
2492 continue;
2493 program = ac->programs[i];
2494 for(j=0; j<program->nb_stream_indexes; j++)
2495 if(program->stream_index[j] == idx)
2496 return;
2497
2498 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2499 if(!tmp)
2500 return;
2501 program->stream_index = tmp;
2502 program->stream_index[program->nb_stream_indexes++] = idx;
2503 return;
2504 }
2505}
2506
de6d9b64 2507/* "user interface" functions */
4e745a3b 2508static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
fad0e030 2509{
4e745a3b 2510 char buf[256];
fad0e030
NS
2511 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2512 AVStream *st = ic->streams[i];
2513 int g = ff_gcd(st->time_base.num, st->time_base.den);
2514 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2515 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2516 /* the pid is an important information, so we display it */
2517 /* XXX: add a generic system */
2518 if (flags & AVFMT_SHOW_IDS)
2519 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2520 if (strlen(st->language) > 0)
2521 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2522 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2523 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2524 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2525 if(st->r_frame_rate.den && st->r_frame_rate.num)
5fba300d 2526 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
fad0e030 2527/* else if(st->time_base.den && st->time_base.num)
5fba300d 2528 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
fad0e030 2529 else
5fba300d 2530 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
fad0e030
NS
2531 }
2532 av_log(NULL, AV_LOG_INFO, "\n");
2533}
de6d9b64
FB
2534
2535void dump_format(AVFormatContext *ic,
115329f1 2536 int index,
de6d9b64
FB
2537 const char *url,
2538 int is_output)
2539{
63bb42fb 2540 int i;
de6d9b64 2541
115329f1 2542 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
de6d9b64 2543 is_output ? "Output" : "Input",
115329f1
DB
2544 index,
2545 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64 2546 is_output ? "to" : "from", url);
12f996ed 2547 if (!is_output) {
2143116d 2548 av_log(NULL, AV_LOG_INFO, " Duration: ");
12f996ed
FB
2549 if (ic->duration != AV_NOPTS_VALUE) {
2550 int hours, mins, secs, us;
2551 secs = ic->duration / AV_TIME_BASE;
2552 us = ic->duration % AV_TIME_BASE;
2553 mins = secs / 60;
2554 secs %= 60;
2555 hours = mins / 60;
2556 mins %= 60;
115329f1 2557 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
12f996ed
FB
2558 (10 * us) / AV_TIME_BASE);
2559 } else {
2143116d 2560 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2561 }
d0f3f159
WG
2562 if (ic->start_time != AV_NOPTS_VALUE) {
2563 int secs, us;
2143116d 2564 av_log(NULL, AV_LOG_INFO, ", start: ");
d0f3f159
WG
2565 secs = ic->start_time / AV_TIME_BASE;
2566 us = ic->start_time % AV_TIME_BASE;
2143116d 2567 av_log(NULL, AV_LOG_INFO, "%d.%06d",
d0f3f159
WG
2568 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2569 }
2143116d 2570 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
12f996ed 2571 if (ic->bit_rate) {
2143116d 2572 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
12f996ed 2573 } else {
2143116d 2574 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2575 }
2143116d 2576 av_log(NULL, AV_LOG_INFO, "\n");
12f996ed 2577 }
526efa10
NS
2578 if(ic->nb_programs) {
2579 int j, k;
2580 for(j=0; j<ic->nb_programs; j++) {
f473666f
NS
2581 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2582 ic->programs[j]->name ? ic->programs[j]->name : "");
526efa10 2583 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
4e745a3b 2584 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
526efa10
NS
2585 }
2586 } else
fad0e030 2587 for(i=0;i<ic->nb_streams;i++)
4e745a3b 2588 dump_stream_format(ic, i, index, is_output);
de6d9b64
FB
2589}
2590
de6d9b64
FB
2591int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2592{
26ef3220 2593 return av_parse_video_frame_size(width_ptr, height_ptr, str);
de6d9b64
FB
2594}
2595
26ef3220 2596int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
445f1b83 2597{
26ef3220
SS
2598 AVRational frame_rate;
2599 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2600 *frame_rate_num= frame_rate.num;
2601 *frame_rate_den= frame_rate.den;
2602 return ret;
445f1b83
RS
2603}
2604
82e4ac2c
RP
2605/**
2606 * gets the current time in micro seconds.
2607 */
2608int64_t av_gettime(void)
2609{
2610 struct timeval tv;
2611 gettimeofday(&tv,NULL);
2612 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2613}
2614
0c1a9eda 2615int64_t parse_date(const char *datestr, int duration)
de6d9b64
FB
2616{
2617 const char *p;
0c1a9eda 2618 int64_t t;
2dbceb9f 2619 struct tm dt;
c5510dd6
PG
2620 int i;
2621 static const char *date_fmt[] = {
2622 "%Y-%m-%d",
2623 "%Y%m%d",
2624 };
2625 static const char *time_fmt[] = {
2626 "%H:%M:%S",
2627 "%H%M%S",
2628 };
2629 const char *q;
916c80e9 2630 int is_utc, len;
c5510dd6 2631 char lastch;
a6a92a9a 2632 int negative = 0;
6d8f985e
MN
2633
2634#undef time
c5510dd6
PG
2635 time_t now = time(0);
2636
916c80e9
FB
2637 len = strlen(datestr);
2638 if (len > 0)
2639 lastch = datestr[len - 1];
2640 else
2641 lastch = '\0';
c5510dd6 2642 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
2643
2644 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
2645
2646 p = datestr;
916c80e9 2647 q = NULL;
de6d9b64 2648 if (!duration) {
a8f70d72 2649 /* parse the year-month-day part */
c5510dd6 2650 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
f71869a4 2651 q = small_strptime(p, date_fmt[i], &dt);
c5510dd6
PG
2652 if (q) {
2653 break;
2654 }
2655 }
2656
a8f70d72
SS
2657 /* if the year-month-day part is missing, then take the
2658 * current year-month-day time */
c5510dd6
PG
2659 if (!q) {
2660 if (is_utc) {
2661 dt = *gmtime(&now);
2662 } else {
2663 dt = *localtime(&now);
2664 }
2665 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 2666 } else {
c5510dd6 2667 p = q;
de6d9b64 2668 }
c5510dd6
PG
2669
2670 if (*p == 'T' || *p == 't' || *p == ' ')
2671 p++;
c5510dd6 2672
a8f70d72 2673 /* parse the hour-minute-second part */
916c80e9 2674 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
f71869a4 2675 q = small_strptime(p, time_fmt[i], &dt);
916c80e9
FB
2676 if (q) {
2677 break;
2678 }
2679 }
2680 } else {
a8f70d72 2681 /* parse datestr as a duration */
bb270c08
DB
2682 if (p[0] == '-') {
2683 negative = 1;
2684 ++p;
2685 }
a8f70d72 2686 /* parse datestr as HH:MM:SS */
f71869a4 2687 q = small_strptime(p, time_fmt[0], &dt);
916c80e9 2688 if (!q) {
a8f70d72 2689 /* parse datestr as S+ */
916c80e9 2690 dt.tm_sec = strtol(p, (char **)&q, 10);
f9436161
SS
2691 if (q == p)
2692 /* the parsing didn't succeed */
2693 return INT64_MIN;
916c80e9
FB
2694 dt.tm_min = 0;
2695 dt.tm_hour = 0;
c5510dd6
PG
2696 }
2697 }
2698
2699 /* Now we have all the fields that we can get */
2700 if (!q) {
f9436161 2701 return INT64_MIN;
de6d9b64 2702 }
2dbceb9f
PG
2703
2704 if (duration) {
c5510dd6 2705 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 2706 } else {
c5510dd6
PG
2707 dt.tm_isdst = -1; /* unknown */
2708 if (is_utc) {
2709 t = mktimegm(&dt);
2710 } else {
2711 t = mktime(&dt);
2712 }
de6d9b64 2713 }
2dbceb9f 2714
c5510dd6
PG
2715 t *= 1000000;
2716
a8f70d72 2717 /* parse the .m... part */
c5510dd6 2718 if (*q == '.') {
de6d9b64 2719 int val, n;
c5510dd6
PG
2720 q++;
2721 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
115329f1 2722 if (!isdigit(*q))
c5510dd6
PG
2723 break;
2724 val += n * (*q - '0');
de6d9b64
FB
2725 }
2726 t += val;
2727 }
a6a92a9a 2728 return negative ? -t : t;
de6d9b64
FB
2729}
2730
de6d9b64
FB
2731int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2732{
2733 const char *p;
2734 char tag[128], *q;
2735
2736 p = info;
2737 if (*p == '?')
2738 p++;
2739 for(;;) {
2740 q = tag;
2741 while (*p != '\0' && *p != '=' && *p != '&') {
2742 if ((q - tag) < sizeof(tag) - 1)
2743 *q++ = *p;
2744 p++;
2745 }
2746 *q = '\0';
2747 q = arg;
2748 if (*p == '=') {
2749 p++;
2750 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
2751 if ((q - arg) < arg_size - 1) {
2752 if (*p == '+')
2753 *q++ = ' ';
2754 else
2755 *q++ = *p;
2756 }
de6d9b64
FB
2757 p++;
2758 }
2759 *q = '\0';
2760 }
115329f1 2761 if (!strcmp(tag, tag1))
de6d9b64
FB
2762 return 1;
2763 if (*p != '&')
2764 break;
8d1335ea 2765 p++;
de6d9b64
FB
2766 }
2767 return 0;
2768}
2769
5c07cf53
MB
2770int av_get_frame_filename(char *buf, int buf_size,
2771 const char *path, int number)
9150f42e
FB
2772{
2773 const char *p;
0bf92f79
PI
2774 char *q, buf1[20], c;
2775 int nd, len, percentd_found;
9150f42e
FB
2776
2777 q = buf;
2778 p = path;
2779 percentd_found = 0;
2780 for(;;) {
2781 c = *p++;
2782 if (c == '\0')
2783 break;
2784 if (c == '%') {
c9646fda
PG
2785 do {
2786 nd = 0;
2787 while (isdigit(*p)) {
2788 nd = nd * 10 + *p++ - '0';
2789 }
2790 c = *p++;
c9646fda
PG
2791 } while (isdigit(c));
2792
9150f42e
FB
2793 switch(c) {
2794 case '%':
2795 goto addchar;
2796 case 'd':
2797 if (percentd_found)
2798 goto fail;
2799 percentd_found = 1;
2800 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2801 len = strlen(buf1);
2802 if ((q - buf + len) > buf_size - 1)
2803 goto fail;
2804 memcpy(q, buf1, len);
2805 q += len;
2806 break;
2807 default:
2808 goto fail;
2809 }
2810 } else {
2811 addchar:
2812 if ((q - buf) < buf_size - 1)
2813 *q++ = c;
2814 }
2815 }
2816 if (!percentd_found)
2817 goto fail;
2818 *q = '\0';
2819 return 0;
2820 fail:
2821 *q = '\0';
2822 return -1;
2823}
2824
750f0e1f 2825static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
b9a281db
FB
2826{
2827 int len, i, j, c;
750f0e1f 2828#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
b9a281db
FB
2829
2830 for(i=0;i<size;i+=16) {
2831 len = size - i;
2832 if (len > 16)
2833 len = 16;
750f0e1f 2834 PRINT("%08x ", i);
b9a281db
FB
2835 for(j=0;j<16;j++) {
2836 if (j < len)
750f0e1f 2837 PRINT(" %02x", buf[i+j]);
b9a281db 2838 else
750f0e1f 2839 PRINT(" ");
b9a281db 2840 }
750f0e1f 2841 PRINT(" ");
b9a281db
FB
2842 for(j=0;j<len;j++) {
2843 c = buf[i+j];
2844 if (c < ' ' || c > '~')
2845 c = '.';
750f0e1f 2846 PRINT("%c", c);
b9a281db 2847 }
750f0e1f 2848 PRINT("\n");
b9a281db 2849 }
750f0e1f
PI
2850#undef PRINT
2851}
2852
2853void av_hex_dump(FILE *f, uint8_t *buf, int size)
2854{
2855 hex_dump_internal(NULL, f, 0, buf, size);
2856}
2857
2858void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2859{
2860 hex_dump_internal(avcl, NULL, level, buf, size);
b9a281db
FB
2861}
2862
c0df9d75 2863 //FIXME needs to know the time_base
750f0e1f 2864static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
fb2758c8 2865{
750f0e1f
PI
2866#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2867 PRINT("stream #%d:\n", pkt->stream_index);
2868 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2869 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
37353960 2870 /* DTS is _always_ valid after av_read_frame() */
750f0e1f 2871 PRINT(" dts=");
37353960 2872 if (pkt->dts == AV_NOPTS_VALUE)
750f0e1f 2873 PRINT("N/A");
37353960 2874 else
750f0e1f 2875 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
fb2758c8 2876 /* PTS may be not known if B frames are present */
750f0e1f 2877 PRINT(" pts=");
fb2758c8 2878 if (pkt->pts == AV_NOPTS_VALUE)
750f0e1f 2879 PRINT("N/A");
fb2758c8 2880 else
750f0e1f
PI
2881 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2882 PRINT("\n");
2883 PRINT(" size=%d\n", pkt->size);
2884#undef PRINT
fb2758c8
FB
2885 if (dump_payload)
2886 av_hex_dump(f, pkt->data, pkt->size);
2887}
2888
750f0e1f
PI
2889void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2890{
2891 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2892}
2893
2894void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2895{
2896 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2897}
2898
a9a721da 2899void url_split(char *proto, int proto_size,
6ba5cbc6 2900 char *authorization, int authorization_size,
a9a721da
FB
2901 char *hostname, int hostname_size,
2902 int *port_ptr,
2903 char *path, int path_size,
2904 const char *url)
2905{
c5be140c 2906 const char *p, *ls, *at, *col, *brk, *q;
7e1e297e
RB
2907
2908 if (port_ptr) *port_ptr = -1;
2909 if (proto_size > 0) proto[0] = 0;
2910 if (authorization_size > 0) authorization[0] = 0;
2911 if (hostname_size > 0) hostname[0] = 0;
2912 if (path_size > 0) path[0] = 0;
2913
2914 /* parse protocol */
2915 if ((p = strchr(url, ':'))) {
2916 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2917 p++; /* skip ':' */
2918 if (*p == '/') p++;
2919 if (*p == '/') p++;
a9a721da 2920 } else {
7e1e297e
RB
2921 /* no protocol means plain filename */
2922 av_strlcpy(path, url, path_size);
2923 return;
2924 }
6ba5cbc6 2925
7e1e297e 2926 /* separate path from hostname */
c5be140c
RB
2927 if ((ls = strchr(p, '/'))) {
2928 if ((q = strchr(ls, '?')))
2929 av_strlcpy(path, ls, FFMIN(path_size, q - ls + 1));
2930 else
2931 av_strlcpy(path, ls, path_size);
2932 } else if (!(ls = strchr(p, '?')))
7e1e297e
RB
2933 ls = &p[strlen(p)]; // XXX
2934
2935 /* the rest is hostname, use that to parse auth/port */
2936 if (ls != p) {
2937 /* authorization (user[:pass]@hostname) */
2938 if ((at = strchr(p, '@')) && at < ls) {
2939 av_strlcpy(authorization, p,
2940 FFMIN(authorization_size, at + 1 - p));
2941 p = at + 1; /* skip '@' */
a9a721da 2942 }
7e1e297e 2943
f8f88a42
RB
2944 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
2945 /* [host]:port */
2946 av_strlcpy(hostname, p + 1,
2947 FFMIN(hostname_size, brk - p));
2948 if (brk[1] == ':' && port_ptr)
2949 *port_ptr = atoi(brk + 2);
2950 } else if ((col = strchr(p, ':')) && col < ls) {
2951 av_strlcpy(hostname, p,
2952 FFMIN(col + 1 - p, hostname_size));
2953 if (port_ptr) *port_ptr = atoi(col + 1);
2954 } else
2955 av_strlcpy(hostname, p,
2956 FFMIN(ls + 1 - p, hostname_size));
a9a721da 2957 }
a9a721da
FB
2958}
2959
9ee91c2f 2960void av_set_pts_info(AVStream *s, int pts_wrap_bits,
916c80e9
FB
2961 int pts_num, int pts_den)
2962{
2963 s->pts_wrap_bits = pts_wrap_bits;
9ee91c2f
MN
2964 s->time_base.num = pts_num;
2965 s->time_base.den = pts_den;
916c80e9
FB
2966}
2967
2968/* fraction handling */
2969
2970/**
e36bdf8b
DK
2971 * f = val + (num / den) + 0.5.
2972 *
2973 * 'num' is normalized so that it is such as 0 <= num < den.
916c80e9
FB
2974 *
2975 * @param f fractional number
2976 * @param val integer value
2977 * @param num must be >= 0
115329f1 2978 * @param den must be >= 1
916c80e9 2979 */
f3a30e3a 2980static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
916c80e9
FB
2981{
2982 num += (den >> 1);
2983 if (num >= den) {
2984 val += num / den;
2985 num = num % den;
2986 }
2987 f->val = val;
2988 f->num = num;
2989 f->den = den;
2990}
2991
e36bdf8b 2992/**
e36bdf8b 2993 * Fractionnal addition to f: f = f + (incr / f->den).
916c80e9
FB
2994 *
2995 * @param f fractional number
2996 * @param incr increment, can be positive or negative
2997 */
f3a30e3a 2998static void av_frac_add(AVFrac *f, int64_t incr)
916c80e9 2999{
0c1a9eda 3000 int64_t num, den;
916c80e9
FB
3001
3002 num = f->num + incr;
3003 den = f->den;
3004 if (num < 0) {
3005 f->val += num / den;
3006 num = num % den;
3007 if (num < 0) {
3008 num += den;
3009 f->val--;
3010 }
3011 } else if (num >= den) {
3012 f->val += num / den;
3013 num = num % den;
3014 }
3015 f->num = num;
3016}