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