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