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