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