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