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