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