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