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