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