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