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