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