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