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