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