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