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