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