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