Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ d20d1449

History | View | Annotate | Download (122 KB)

1 de6d9b64 Fabrice Bellard
/*
2 a85736f2 Diego Biurrun
 * various utility functions for use within FFmpeg
3 19720f15 Fabrice Bellard
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 de6d9b64 Fabrice Bellard
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 19720f15 Fabrice Bellard
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 de6d9b64 Fabrice Bellard
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 19720f15 Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16 de6d9b64 Fabrice Bellard
 *
17 19720f15 Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 de6d9b64 Fabrice Bellard
 */
21 8be1c656 Fabrice Bellard
#include "avformat.h"
22 f1c80e35 Ronald S. Bultje
#include "internal.h"
23 603a5f04 Francesco Lavra
#include "libavcodec/internal.h"
24 6ed04040 Michael Niedermayer
#include "libavutil/opt.h"
25 06a7bd9a Michael Niedermayer
#include "metadata.h"
26 6612d8cf Reimar Döffinger
#include "id3v2.h"
27 245976da Diego Biurrun
#include "libavutil/avstring.h"
28 45da8124 Aurelien Jacobs
#include "riff.h"
29 c26e58e3 Måns Rullgård
#include "audiointerleave.h"
30 82e4ac2c Ramiro Polla
#include <sys/time.h>
31
#include <time.h>
32 ea452b54 Aurelien Jacobs
#include <strings.h>
33 780d7897 Martin Storsjö
#include <stdarg.h>
34
#if CONFIG_NETWORK
35
#include "network.h"
36
#endif
37 c5510dd6 Philip Gladstone
38 b754978a Michael Niedermayer
#undef NDEBUG
39
#include <assert.h>
40
41 e36bdf8b Daniel Kristjansson
/**
42 ba87f080 Diego Biurrun
 * @file
43 a85736f2 Diego Biurrun
 * various utility functions for use within FFmpeg
44 e36bdf8b Daniel Kristjansson
 */
45
46 c97429e2 Stefano Sabatini
unsigned avformat_version(void)
47
{
48
    return LIBAVFORMAT_VERSION_INT;
49
}
50
51 41600690 Stefano Sabatini
const char *avformat_configuration(void)
52 c1736936 Diego Biurrun
{
53
    return FFMPEG_CONFIGURATION;
54
}
55
56 41600690 Stefano Sabatini
const char *avformat_license(void)
57 c1736936 Diego Biurrun
{
58
#define LICENSE_PREFIX "libavformat license: "
59
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
60
}
61
62 8163c870 Stefano Sabatini
/* fraction handling */
63
64
/**
65
 * f = val + (num / den) + 0.5.
66
 *
67
 * 'num' is normalized so that it is such as 0 <= num < den.
68
 *
69
 * @param f fractional number
70
 * @param val integer value
71
 * @param num must be >= 0
72
 * @param den must be >= 1
73
 */
74
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
75
{
76
    num += (den >> 1);
77
    if (num >= den) {
78
        val += num / den;
79
        num = num % den;
80
    }
81
    f->val = val;
82
    f->num = num;
83
    f->den = den;
84
}
85
86
/**
87
 * Fractional addition to f: f = f + (incr / f->den).
88
 *
89
 * @param f fractional number
90
 * @param incr increment, can be positive or negative
91
 */
92
static void av_frac_add(AVFrac *f, int64_t incr)
93
{
94
    int64_t num, den;
95
96
    num = f->num + incr;
97
    den = f->den;
98
    if (num < 0) {
99
        f->val += num / den;
100
        num = num % den;
101
        if (num < 0) {
102
            num += den;
103
            f->val--;
104
        }
105
    } else if (num >= den) {
106
        f->val += num / den;
107
        num = num % den;
108
    }
109
    f->num = num;
110
}
111 f3a30e3a Luca Barbato
112 a85736f2 Diego Biurrun
/** head of registered input format linked list */
113 114c9a59 Aurelien Jacobs
#if !FF_API_FIRST_FORMAT
114
static
115
#endif
116 8b69867f Michael Niedermayer
AVInputFormat *first_iformat = NULL;
117 a85736f2 Diego Biurrun
/** head of registered output format linked list */
118 114c9a59 Aurelien Jacobs
#if !FF_API_FIRST_FORMAT
119
static
120
#endif
121 8b69867f Michael Niedermayer
AVOutputFormat *first_oformat = NULL;
122 de6d9b64 Fabrice Bellard
123 84be6e72 Michael Niedermayer
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
124
{
125
    if(f) return f->next;
126
    else  return first_iformat;
127
}
128
129
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
130
{
131
    if(f) return f->next;
132
    else  return first_oformat;
133
}
134
135 b9a281db Fabrice Bellard
void av_register_input_format(AVInputFormat *format)
136 de6d9b64 Fabrice Bellard
{
137 b9a281db Fabrice Bellard
    AVInputFormat **p;
138
    p = &first_iformat;
139
    while (*p != NULL) p = &(*p)->next;
140
    *p = format;
141
    format->next = NULL;
142
}
143
144
void av_register_output_format(AVOutputFormat *format)
145
{
146
    AVOutputFormat **p;
147
    p = &first_oformat;
148 de6d9b64 Fabrice Bellard
    while (*p != NULL) p = &(*p)->next;
149
    *p = format;
150
    format->next = NULL;
151
}
152
153 8eb631fa Stefano Sabatini
int av_match_ext(const char *filename, const char *extensions)
154
{
155 de6d9b64 Fabrice Bellard
    const char *ext, *p;
156
    char ext1[32], *q;
157
158 293ed23f Michael Niedermayer
    if(!filename)
159
        return 0;
160 115329f1 Diego Biurrun
161 de6d9b64 Fabrice Bellard
    ext = strrchr(filename, '.');
162
    if (ext) {
163
        ext++;
164
        p = extensions;
165
        for(;;) {
166
            q = ext1;
167 115329f1 Diego Biurrun
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
168 de6d9b64 Fabrice Bellard
                *q++ = *p++;
169
            *q = '\0';
170 115329f1 Diego Biurrun
            if (!strcasecmp(ext1, ext))
171 de6d9b64 Fabrice Bellard
                return 1;
172 115329f1 Diego Biurrun
            if (*p == '\0')
173 de6d9b64 Fabrice Bellard
                break;
174
            p++;
175
        }
176
    }
177
    return 0;
178
}
179
180 2323ac01 Baptiste Coudurier
static int match_format(const char *name, const char *names)
181
{
182
    const char *p;
183
    int len, namelen;
184
185
    if (!name || !names)
186
        return 0;
187
188
    namelen = strlen(name);
189
    while ((p = strchr(names, ','))) {
190
        len = FFMAX(p - names, namelen);
191
        if (!strncasecmp(name, names, len))
192
            return 1;
193
        names = p+1;
194
    }
195
    return !strcasecmp(name, names);
196
}
197
198 198ac67f Aurelien Jacobs
#if FF_API_GUESS_FORMAT
199 115329f1 Diego Biurrun
AVOutputFormat *guess_format(const char *short_name, const char *filename,
200 b9a281db Fabrice Bellard
                             const char *mime_type)
201 de6d9b64 Fabrice Bellard
{
202 a1f547b9 Stefano Sabatini
    return av_guess_format(short_name, filename, mime_type);
203
}
204
#endif
205
206
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
207
                                const char *mime_type)
208
{
209 27323146 Anton Khirnov
    AVOutputFormat *fmt = NULL, *fmt_found;
210 de6d9b64 Fabrice Bellard
    int score_max, score;
211
212 87a0a681 Fabrice Bellard
    /* specific test for image sequences */
213 b250f9c6 Aurelien Jacobs
#if CONFIG_IMAGE2_MUXER
214 115329f1 Diego Biurrun
    if (!short_name && filename &&
215 5c07cf53 Michel Bardiaux
        av_filename_number_test(filename) &&
216 5b6d5596 Michael Niedermayer
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
217 0f52ef1a Stefano Sabatini
        return av_guess_format("image2", NULL, NULL);
218 5b6d5596 Michael Niedermayer
    }
219 ff70e601 Måns Rullgård
#endif
220 a85736f2 Diego Biurrun
    /* Find the proper file type. */
221 de6d9b64 Fabrice Bellard
    fmt_found = NULL;
222
    score_max = 0;
223 27323146 Anton Khirnov
    while ((fmt = av_oformat_next(fmt))) {
224 de6d9b64 Fabrice Bellard
        score = 0;
225
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
226
            score += 100;
227
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
228
            score += 10;
229 115329f1 Diego Biurrun
        if (filename && fmt->extensions &&
230 aa13b573 Stefano Sabatini
            av_match_ext(filename, fmt->extensions)) {
231 de6d9b64 Fabrice Bellard
            score += 5;
232
        }
233
        if (score > score_max) {
234
            score_max = score;
235
            fmt_found = fmt;
236
        }
237
    }
238
    return fmt_found;
239 115329f1 Diego Biurrun
}
240 de6d9b64 Fabrice Bellard
241 198ac67f Aurelien Jacobs
#if FF_API_GUESS_FORMAT
242 115329f1 Diego Biurrun
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
243 c5510dd6 Philip Gladstone
                             const char *mime_type)
244
{
245 0f52ef1a Stefano Sabatini
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
246 c5510dd6 Philip Gladstone
247
    if (fmt) {
248
        AVOutputFormat *stream_fmt;
249
        char stream_format_name[64];
250
251
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
252 0f52ef1a Stefano Sabatini
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
253 c5510dd6 Philip Gladstone
254
        if (stream_fmt)
255
            fmt = stream_fmt;
256
    }
257
258
    return fmt;
259
}
260 1642ee43 Stefano Sabatini
#endif
261 c5510dd6 Philip Gladstone
262 115329f1 Diego Biurrun
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
263 72415b2a Stefano Sabatini
                            const char *filename, const char *mime_type, enum AVMediaType type){
264
    if(type == AVMEDIA_TYPE_VIDEO){
265 5b6d5596 Michael Niedermayer
        enum CodecID codec_id= CODEC_ID_NONE;
266
267 b250f9c6 Aurelien Jacobs
#if CONFIG_IMAGE2_MUXER
268 ae214ac3 Michael Niedermayer
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
269 5b6d5596 Michael Niedermayer
            codec_id= av_guess_image2_codec(filename);
270
        }
271 ff70e601 Måns Rullgård
#endif
272 5b6d5596 Michael Niedermayer
        if(codec_id == CODEC_ID_NONE)
273
            codec_id= fmt->video_codec;
274
        return codec_id;
275 72415b2a Stefano Sabatini
    }else if(type == AVMEDIA_TYPE_AUDIO)
276 5b6d5596 Michael Niedermayer
        return fmt->audio_codec;
277 118ccae0 Aurelien Jacobs
    else if (type == AVMEDIA_TYPE_SUBTITLE)
278
        return fmt->subtitle_codec;
279 5b6d5596 Michael Niedermayer
    else
280
        return CODEC_ID_NONE;
281
}
282
283 b9a281db Fabrice Bellard
AVInputFormat *av_find_input_format(const char *short_name)
284
{
285 27323146 Anton Khirnov
    AVInputFormat *fmt = NULL;
286
    while ((fmt = av_iformat_next(fmt))) {
287 2323ac01 Baptiste Coudurier
        if (match_format(short_name, fmt->name))
288 b9a281db Fabrice Bellard
            return fmt;
289
    }
290
    return NULL;
291
}
292
293 13728334 Aurelien Jacobs
#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
294 b462d132 Måns Rullgård
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
295
{
296
    av_destruct_packet_nofree(pkt);
297
}
298
299
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
300
{
301
    av_destruct_packet(pkt);
302
}
303 de6d9b64 Fabrice Bellard
304 b462d132 Måns Rullgård
FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
305
{
306
    return av_new_packet(pkt, size);
307
}
308
309
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
310
{
311
    return av_dup_packet(pkt);
312
}
313
314
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
315
{
316
    av_free_packet(pkt);
317
}
318
319
FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
320
{
321
    av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
322
    av_init_packet(pkt);
323
}
324
#endif
325 de6d9b64 Fabrice Bellard
326 2692067a Michael Niedermayer
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
327
{
328
    int ret= av_new_packet(pkt, size);
329
330
    if(ret<0)
331
        return ret;
332
333
    pkt->pos= url_ftell(s);
334
335
    ret= get_buffer(s, pkt->data, size);
336
    if(ret<=0)
337
        av_free_packet(pkt);
338
    else
339 feb993e5 Reimar Döffinger
        av_shrink_packet(pkt, ret);
340 2692067a Michael Niedermayer
341
    return ret;
342
}
343
344 6bfc2683 Reimar Döffinger
int av_append_packet(ByteIOContext *s, AVPacket *pkt, int size)
345
{
346
    int ret;
347
    int old_size;
348
    if (!pkt->size)
349
        return av_get_packet(s, pkt, size);
350
    old_size = pkt->size;
351
    ret = av_grow_packet(pkt, size);
352
    if (ret < 0)
353
        return ret;
354
    ret = get_buffer(s, pkt->data + old_size, size);
355
    av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
356
    return ret;
357
}
358
359 fb2758c8 Fabrice Bellard
360 5c07cf53 Michel Bardiaux
int av_filename_number_test(const char *filename)
361 b9a281db Fabrice Bellard
{
362
    char buf[1024];
363 5c07cf53 Michel Bardiaux
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
364 b9a281db Fabrice Bellard
}
365
366 8e2ee182 Reimar Döffinger
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
367 b9a281db Fabrice Bellard
{
368 6612d8cf Reimar Döffinger
    AVProbeData lpd = *pd;
369 27323146 Anton Khirnov
    AVInputFormat *fmt1 = NULL, *fmt;
370 79750486 Michael Niedermayer
    int score;
371 b9a281db Fabrice Bellard
372 6612d8cf Reimar Döffinger
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
373
        int id3len = ff_id3v2_tag_len(lpd.buf);
374
        if (lpd.buf_size > id3len + 16) {
375
            lpd.buf += id3len;
376
            lpd.buf_size -= id3len;
377
        }
378
    }
379
380 b9a281db Fabrice Bellard
    fmt = NULL;
381 27323146 Anton Khirnov
    while ((fmt1 = av_iformat_next(fmt1))) {
382 b8e705ec Reimar Döffinger
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
383 b9a281db Fabrice Bellard
            continue;
384
        score = 0;
385 a8dbe951 Philip Gladstone
        if (fmt1->read_probe) {
386 6612d8cf Reimar Döffinger
            score = fmt1->read_probe(&lpd);
387 a8dbe951 Philip Gladstone
        } else if (fmt1->extensions) {
388 6612d8cf Reimar Döffinger
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
389 b9a281db Fabrice Bellard
                score = 50;
390
            }
391 115329f1 Diego Biurrun
        }
392 79750486 Michael Niedermayer
        if (score > *score_max) {
393
            *score_max = score;
394 b9a281db Fabrice Bellard
            fmt = fmt1;
395 4b3cca36 Michael Niedermayer
        }else if (score == *score_max)
396
            fmt = NULL;
397 b9a281db Fabrice Bellard
    }
398
    return fmt;
399
}
400
401 79750486 Michael Niedermayer
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
402
    int score=0;
403
    return av_probe_input_format2(pd, is_opened, &score);
404
}
405
406 db46c4e1 Baptiste Coudurier
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
407 64cd3108 Michael Niedermayer
{
408 cf5b33d9 Stefano Sabatini
    static const struct {
409
        const char *name; enum CodecID id; enum AVMediaType type;
410
    } fmt_id_type[] = {
411
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
412
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
413
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
414
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
415
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
416
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
417
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
418
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
419
        { 0 }
420
    };
421
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
422 64cd3108 Michael Niedermayer
423
    if (fmt) {
424 cf5b33d9 Stefano Sabatini
        int i;
425 db46c4e1 Baptiste Coudurier
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
426
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
427 cf5b33d9 Stefano Sabatini
        for (i = 0; fmt_id_type[i].name; i++) {
428
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
429
                st->codec->codec_id   = fmt_id_type[i].id;
430
                st->codec->codec_type = fmt_id_type[i].type;
431
                break;
432
            }
433 f1588ed5 Andreas Öman
        }
434 64cd3108 Michael Niedermayer
    }
435
    return !!fmt;
436
}
437
438 b9a281db Fabrice Bellard
/************************************************************/
439
/* input media file */
440 96baaa6a Fabrice Bellard
441 da24c5e3 Fabrice Bellard
/**
442 e36bdf8b Daniel Kristjansson
 * Open a media file from an IO stream. 'fmt' must be specified.
443 da24c5e3 Fabrice Bellard
 */
444 115329f1 Diego Biurrun
int av_open_input_stream(AVFormatContext **ic_ptr,
445
                         ByteIOContext *pb, const char *filename,
446 da24c5e3 Fabrice Bellard
                         AVInputFormat *fmt, AVFormatParameters *ap)
447
{
448
    int err;
449
    AVFormatContext *ic;
450 c04c3282 Michael Niedermayer
    AVFormatParameters default_ap;
451
452
    if(!ap){
453
        ap=&default_ap;
454
        memset(ap, 0, sizeof(default_ap));
455
    }
456 da24c5e3 Fabrice Bellard
457 4eb72c6b Nico Sabbi
    if(!ap->prealloced_context)
458 8e2fd8e1 Stefano Sabatini
        ic = avformat_alloc_context();
459 4eb72c6b Nico Sabbi
    else
460
        ic = *ic_ptr;
461 da24c5e3 Fabrice Bellard
    if (!ic) {
462 769e10f0 Panagiotis Issaris
        err = AVERROR(ENOMEM);
463 da24c5e3 Fabrice Bellard
        goto fail;
464
    }
465
    ic->iformat = fmt;
466 899681cd Björn Axelsson
    ic->pb = pb;
467 da24c5e3 Fabrice Bellard
    ic->duration = AV_NOPTS_VALUE;
468
    ic->start_time = AV_NOPTS_VALUE;
469 75e61b0e Måns Rullgård
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
470 da24c5e3 Fabrice Bellard
471
    /* allocate private data */
472
    if (fmt->priv_data_size > 0) {
473
        ic->priv_data = av_mallocz(fmt->priv_data_size);
474
        if (!ic->priv_data) {
475 769e10f0 Panagiotis Issaris
            err = AVERROR(ENOMEM);
476 da24c5e3 Fabrice Bellard
            goto fail;
477
        }
478
    } else {
479
        ic->priv_data = NULL;
480
    }
481
482 6612d8cf Reimar Döffinger
    // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
483
    if (ic->pb)
484
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
485
486 e145ce20 Ronald S. Bultje
    if (ic->iformat->read_header) {
487 1e2802c5 Ronald S. Bultje
        err = ic->iformat->read_header(ic, ap);
488
        if (err < 0)
489
            goto fail;
490 e145ce20 Ronald S. Bultje
    }
491 fb2758c8 Fabrice Bellard
492 faf7cbf1 Michael Niedermayer
    if (pb && !ic->data_offset)
493 899681cd Björn Axelsson
        ic->data_offset = url_ftell(ic->pb);
494 fb2758c8 Fabrice Bellard
495 54036be1 Aurelien Jacobs
#if FF_API_OLD_METADATA
496 e99f76ab Aurelien Jacobs
    ff_metadata_demux_compat(ic);
497
#endif
498
499 af122d6a Baptiste Coudurier
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
500
501 da24c5e3 Fabrice Bellard
    *ic_ptr = ic;
502
    return 0;
503
 fail:
504
    if (ic) {
505 ccafd472 Baptiste Coudurier
        int i;
506 da24c5e3 Fabrice Bellard
        av_freep(&ic->priv_data);
507 ccafd472 Baptiste Coudurier
        for(i=0;i<ic->nb_streams;i++) {
508
            AVStream *st = ic->streams[i];
509
            if (st) {
510
                av_free(st->priv_data);
511
                av_free(st->codec->extradata);
512 ec973f45 Przemysław Sobala
                av_free(st->codec);
513 fd0368e7 Aurelien Jacobs
                av_free(st->info);
514 ccafd472 Baptiste Coudurier
            }
515
            av_free(st);
516
        }
517 da24c5e3 Fabrice Bellard
    }
518
    av_free(ic);
519
    *ic_ptr = NULL;
520
    return err;
521
}
522
523 a85736f2 Diego Biurrun
/** size of probe buffer, for guessing file type from file contents */
524 a877eedc Michael Niedermayer
#define PROBE_BUF_MIN 2048
525 329b1e75 Michael Niedermayer
#define PROBE_BUF_MAX (1<<20)
526 b9a281db Fabrice Bellard
527 eadd495d Micah F. Galizia
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
528
                          const char *filename, void *logctx,
529
                          unsigned int offset, unsigned int max_probe_size)
530
{
531
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
532
    unsigned char *buf = NULL;
533
    int ret = 0, probe_size;
534
535
    if (!max_probe_size) {
536
        max_probe_size = PROBE_BUF_MAX;
537
    } else if (max_probe_size > PROBE_BUF_MAX) {
538
        max_probe_size = PROBE_BUF_MAX;
539
    } else if (max_probe_size < PROBE_BUF_MIN) {
540
        return AVERROR(EINVAL);
541
    }
542
543
    if (offset >= max_probe_size) {
544
        return AVERROR(EINVAL);
545
    }
546
547 532aa889 Micah F. Galizia
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
548
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
549 eadd495d Micah F. Galizia
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
550
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
551
552
        if (probe_size < offset) {
553
            continue;
554
        }
555
556
        /* read probe data */
557
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
558
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
559
            /* fail if error was not end of file, otherwise, lower score */
560
            if (ret != AVERROR_EOF) {
561
                av_free(buf);
562
                return ret;
563
            }
564
            score = 0;
565 c7f625ee Måns Rullgård
            ret = 0;            /* error was end of file, nothing read */
566 eadd495d Micah F. Galizia
        }
567
        pd.buf_size += ret;
568
        pd.buf = &buf[offset];
569
570
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
571
572
        /* guess file format */
573
        *fmt = av_probe_input_format2(&pd, 1, &score);
574
        if(*fmt){
575
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
576
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
577
            }else
578
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
579
        }
580
    }
581
582 532aa889 Micah F. Galizia
    if (!*fmt) {
583 01d91b9b Tomas Härdin
        av_free(buf);
584 532aa889 Micah F. Galizia
        return AVERROR_INVALIDDATA;
585
    }
586
587 01d91b9b Tomas Härdin
    /* rewind. reuse probe buffer to avoid seeking */
588
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
589
        av_free(buf);
590 eadd495d Micah F. Galizia
591 01d91b9b Tomas Härdin
    return ret;
592 eadd495d Micah F. Galizia
}
593
594 115329f1 Diego Biurrun
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
595 b9a281db Fabrice Bellard
                       AVInputFormat *fmt,
596
                       int buf_size,
597
                       AVFormatParameters *ap)
598 de6d9b64 Fabrice Bellard
{
599 eadd495d Micah F. Galizia
    int err;
600 b9a281db Fabrice Bellard
    AVProbeData probe_data, *pd = &probe_data;
601 17acc63a Reimar Döffinger
    ByteIOContext *pb = NULL;
602 e9b06816 Michael Niedermayer
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
603 115329f1 Diego Biurrun
604 da24c5e3 Fabrice Bellard
    pd->filename = "";
605
    if (filename)
606
        pd->filename = filename;
607 a877eedc Michael Niedermayer
    pd->buf = NULL;
608 b9a281db Fabrice Bellard
    pd->buf_size = 0;
609
610
    if (!fmt) {
611 a85736f2 Diego Biurrun
        /* guess format if no file can be opened */
612 a25e098d Fabrice Bellard
        fmt = av_probe_input_format(pd, 0);
613 de6d9b64 Fabrice Bellard
    }
614
615 a85736f2 Diego Biurrun
    /* Do not open file if the format does not need it. XXX: specific
616 b6892136 Fabrice Bellard
       hack needed to handle RTSP/TCP */
617 17acc63a Reimar Döffinger
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
618 87a0a681 Fabrice Bellard
        /* if no file needed do not try to open one */
619 899681cd Björn Axelsson
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
620 96baaa6a Fabrice Bellard
            goto fail;
621 b9a281db Fabrice Bellard
        }
622 96baaa6a Fabrice Bellard
        if (buf_size > 0) {
623 da24c5e3 Fabrice Bellard
            url_setbufsize(pb, buf_size);
624 96baaa6a Fabrice Bellard
        }
625 2898526d Jean-Daniel Dupas
        if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
626 eadd495d Micah F. Galizia
            goto fail;
627 5b25dfa7 Fabrice Bellard
        }
628 b9a281db Fabrice Bellard
    }
629
630
    /* if still no format found, error */
631
    if (!fmt) {
632 2928b83c Stefano Sabatini
        err = AVERROR_INVALIDDATA;
633 da24c5e3 Fabrice Bellard
        goto fail;
634 de6d9b64 Fabrice Bellard
    }
635 115329f1 Diego Biurrun
636 a85736f2 Diego Biurrun
    /* check filename in case an image number is expected */
637 da24c5e3 Fabrice Bellard
    if (fmt->flags & AVFMT_NEEDNUMBER) {
638 5c07cf53 Michel Bardiaux
        if (!av_filename_number_test(filename)) {
639 87a0a681 Fabrice Bellard
            err = AVERROR_NUMEXPECTED;
640 da24c5e3 Fabrice Bellard
            goto fail;
641 87a0a681 Fabrice Bellard
        }
642
    }
643 da24c5e3 Fabrice Bellard
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
644
    if (err)
645
        goto fail;
646 b9a281db Fabrice Bellard
    return 0;
647 de6d9b64 Fabrice Bellard
 fail:
648 a877eedc Michael Niedermayer
    av_freep(&pd->buf);
649 17acc63a Reimar Döffinger
    if (pb)
650 da24c5e3 Fabrice Bellard
        url_fclose(pb);
651 ebb82604 Art Clarke
    if (ap && ap->prealloced_context)
652
        av_free(*ic_ptr);
653
    *ic_ptr = NULL;
654 b9a281db Fabrice Bellard
    return err;
655 115329f1 Diego Biurrun
656 de6d9b64 Fabrice Bellard
}
657
658 da24c5e3 Fabrice Bellard
/*******************************************************/
659
660 5c5b1731 Måns Rullgård
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
661
                               AVPacketList **plast_pktl){
662
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
663 9d3b9f2c Michael Niedermayer
    if (!pktl)
664
        return NULL;
665
666 5c5b1731 Måns Rullgård
    if (*packet_buffer)
667
        (*plast_pktl)->next = pktl;
668
    else
669
        *packet_buffer = pktl;
670
671 9d3b9f2c Michael Niedermayer
    /* add the packet in the buffered packet list */
672
    *plast_pktl = pktl;
673
    pktl->pkt= *pkt;
674
    return &pktl->pkt;
675
}
676
677 de6d9b64 Fabrice Bellard
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
678
{
679 86cb7e33 Baptiste Coudurier
    int ret, i;
680 62600469 Michael Niedermayer
    AVStream *st;
681 0bef08e5 Michael Niedermayer
682
    for(;;){
683
        AVPacketList *pktl = s->raw_packet_buffer;
684
685
        if (pktl) {
686
            *pkt = pktl->pkt;
687 86cb7e33 Baptiste Coudurier
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
688 af122d6a Baptiste Coudurier
               !s->streams[pkt->stream_index]->probe_packets ||
689
               s->raw_packet_buffer_remaining_size < pkt->size){
690
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
691
                av_freep(&pd->buf);
692
                pd->buf_size = 0;
693 0bef08e5 Michael Niedermayer
                s->raw_packet_buffer = pktl->next;
694 af122d6a Baptiste Coudurier
                s->raw_packet_buffer_remaining_size += pkt->size;
695 0bef08e5 Michael Niedermayer
                av_free(pktl);
696
                return 0;
697
            }
698
        }
699
700 55823964 Michael Niedermayer
        av_init_packet(pkt);
701
        ret= s->iformat->read_packet(s, pkt);
702 86cb7e33 Baptiste Coudurier
        if (ret < 0) {
703
            if (!pktl || ret == AVERROR(EAGAIN))
704
                return ret;
705
            for (i = 0; i < s->nb_streams; i++)
706
                s->streams[i]->probe_packets = 0;
707
            continue;
708
        }
709 55823964 Michael Niedermayer
        st= s->streams[pkt->stream_index];
710 62600469 Michael Niedermayer
711 55823964 Michael Niedermayer
        switch(st->codec->codec_type){
712 72415b2a Stefano Sabatini
        case AVMEDIA_TYPE_VIDEO:
713 55823964 Michael Niedermayer
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
714
            break;
715 72415b2a Stefano Sabatini
        case AVMEDIA_TYPE_AUDIO:
716 55823964 Michael Niedermayer
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
717
            break;
718 72415b2a Stefano Sabatini
        case AVMEDIA_TYPE_SUBTITLE:
719 55823964 Michael Niedermayer
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
720
            break;
721
        }
722 62600469 Michael Niedermayer
723 86cb7e33 Baptiste Coudurier
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
724
                     !st->probe_packets))
725 744b4c02 Michael Niedermayer
            return ret;
726
727 5c5b1731 Måns Rullgård
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
728 af122d6a Baptiste Coudurier
        s->raw_packet_buffer_remaining_size -= pkt->size;
729 744b4c02 Michael Niedermayer
730 0bef08e5 Michael Niedermayer
        if(st->codec->codec_id == CODEC_ID_PROBE){
731
            AVProbeData *pd = &st->probe_data;
732 0e500e0d Michael Niedermayer
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
733 86cb7e33 Baptiste Coudurier
            --st->probe_packets;
734
735 0bef08e5 Michael Niedermayer
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
736
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
737
            pd->buf_size += pkt->size;
738
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
739
740 942de2f4 Michael Niedermayer
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
741 0f1f4816 Michael Niedermayer
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
742
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
743 25d3fb73 Michael Niedermayer
                if(st->codec->codec_id != CODEC_ID_PROBE){
744
                    pd->buf_size=0;
745
                    av_freep(&pd->buf);
746 0e500e0d Michael Niedermayer
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
747 25d3fb73 Michael Niedermayer
                }
748 942de2f4 Michael Niedermayer
            }
749 0bef08e5 Michael Niedermayer
        }
750
    }
751 fb2758c8 Fabrice Bellard
}
752
753
/**********************************************************/
754
755 e36bdf8b Daniel Kristjansson
/**
756 a85736f2 Diego Biurrun
 * Get the number of samples of an audio frame. Return -1 on error.
757 e36bdf8b Daniel Kristjansson
 */
758 fb2758c8 Fabrice Bellard
static int get_audio_frame_size(AVCodecContext *enc, int size)
759
{
760
    int frame_size;
761
762 c924ca78 Michael Niedermayer
    if(enc->codec_id == CODEC_ID_VORBIS)
763
        return -1;
764
765 fb2758c8 Fabrice Bellard
    if (enc->frame_size <= 1) {
766 ac3e1834 Baptiste Coudurier
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
767
768
        if (bits_per_sample) {
769 fb2758c8 Fabrice Bellard
            if (enc->channels == 0)
770
                return -1;
771 f1b163e0 Aurelien Jacobs
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
772 ac3e1834 Baptiste Coudurier
        } else {
773 fb2758c8 Fabrice Bellard
            /* used for example by ADPCM codecs */
774
            if (enc->bit_rate == 0)
775
                return -1;
776 db5dc02b Baptiste Coudurier
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
777 fb2758c8 Fabrice Bellard
        }
778
    } else {
779
        frame_size = enc->frame_size;
780
    }
781
    return frame_size;
782
}
783
784
785 e36bdf8b Daniel Kristjansson
/**
786 a85736f2 Diego Biurrun
 * Return the frame duration in seconds. Return 0 if not available.
787 e36bdf8b Daniel Kristjansson
 */
788 115329f1 Diego Biurrun
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
789 fb2758c8 Fabrice Bellard
                                   AVCodecParserContext *pc, AVPacket *pkt)
790
{
791
    int frame_size;
792
793
    *pnum = 0;
794
    *pden = 0;
795 01f4895c Michael Niedermayer
    switch(st->codec->codec_type) {
796 72415b2a Stefano Sabatini
    case AVMEDIA_TYPE_VIDEO:
797 1677155d Michael Niedermayer
        if(st->time_base.num*1000LL > st->time_base.den){
798 c0df9d75 Michael Niedermayer
            *pnum = st->time_base.num;
799
            *pden = st->time_base.den;
800 01f4895c Michael Niedermayer
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
801
            *pnum = st->codec->time_base.num;
802
            *pden = st->codec->time_base.den;
803 327c4076 Michael Niedermayer
            if (pc && pc->repeat_pict) {
804 810c451b Ivan Schreter
                *pnum = (*pnum) * (1 + pc->repeat_pict);
805 327c4076 Michael Niedermayer
            }
806 497431a5 Michael Niedermayer
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
807
            //Thus if we have no parser in such case leave duration undefined.
808
            if(st->codec->ticks_per_frame>1 && !pc){
809
                *pnum = *pden = 0;
810
            }
811 fb2758c8 Fabrice Bellard
        }
812
        break;
813 72415b2a Stefano Sabatini
    case AVMEDIA_TYPE_AUDIO:
814 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
815 6cbce636 Daniel Kang
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
816 fb2758c8 Fabrice Bellard
            break;
817
        *pnum = frame_size;
818 01f4895c Michael Niedermayer
        *pden = st->codec->sample_rate;
819 fb2758c8 Fabrice Bellard
        break;
820
    default:
821
        break;
822
    }
823
}
824
825 5ba7c3d7 Michael Niedermayer
static int is_intra_only(AVCodecContext *enc){
826 72415b2a Stefano Sabatini
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
827 5ba7c3d7 Michael Niedermayer
        return 1;
828 72415b2a Stefano Sabatini
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
829 5ba7c3d7 Michael Niedermayer
        switch(enc->codec_id){
830
        case CODEC_ID_MJPEG:
831
        case CODEC_ID_MJPEGB:
832
        case CODEC_ID_LJPEG:
833
        case CODEC_ID_RAWVIDEO:
834
        case CODEC_ID_DVVIDEO:
835
        case CODEC_ID_HUFFYUV:
836 f37b9768 Loren Merritt
        case CODEC_ID_FFVHUFF:
837 5ba7c3d7 Michael Niedermayer
        case CODEC_ID_ASV1:
838
        case CODEC_ID_ASV2:
839
        case CODEC_ID_VCR1:
840 b774fdd7 Baptiste Coudurier
        case CODEC_ID_DNXHD:
841 aa915625 Baptiste Coudurier
        case CODEC_ID_JPEG2000:
842 5ba7c3d7 Michael Niedermayer
            return 1;
843
        default: break;
844
        }
845
    }
846
    return 0;
847
}
848
849 9fcbcca6 Neil Brown
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
850
                                      int64_t dts, int64_t pts)
851
{
852 82583548 Michael Niedermayer
    AVStream *st= s->streams[stream_index];
853
    AVPacketList *pktl= s->packet_buffer;
854
855 7efeb73a Michael Niedermayer
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
856 82583548 Michael Niedermayer
        return;
857
858
    st->first_dts= dts - st->cur_dts;
859
    st->cur_dts= dts;
860
861
    for(; pktl; pktl= pktl->next){
862
        if(pktl->pkt.stream_index != stream_index)
863
            continue;
864
        //FIXME think more about this check
865
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
866
            pktl->pkt.pts += st->first_dts;
867
868
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
869
            pktl->pkt.dts += st->first_dts;
870 48a59dfe Michael Niedermayer
871
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
872
            st->start_time= pktl->pkt.pts;
873 82583548 Michael Niedermayer
    }
874 9fcbcca6 Neil Brown
    if (st->start_time == AV_NOPTS_VALUE)
875
        st->start_time = pts;
876 82583548 Michael Niedermayer
}
877
878 83a9db42 Michael Niedermayer
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
879
{
880
    AVPacketList *pktl= s->packet_buffer;
881 820ad60c Michael Niedermayer
    int64_t cur_dts= 0;
882
883
    if(st->first_dts != AV_NOPTS_VALUE){
884
        cur_dts= st->first_dts;
885
        for(; pktl; pktl= pktl->next){
886
            if(pktl->pkt.stream_index == pkt->stream_index){
887
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
888
                    break;
889
                cur_dts -= pkt->duration;
890
            }
891
        }
892
        pktl= s->packet_buffer;
893
        st->first_dts = cur_dts;
894
    }else if(st->cur_dts)
895
        return;
896 83a9db42 Michael Niedermayer
897
    for(; pktl; pktl= pktl->next){
898
        if(pktl->pkt.stream_index != pkt->stream_index)
899
            continue;
900 91acf9a8 Michael Niedermayer
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
901
           && !pktl->pkt.duration){
902 820ad60c Michael Niedermayer
            pktl->pkt.dts= cur_dts;
903 5853423c Michael Niedermayer
            if(!st->codec->has_b_frames)
904 820ad60c Michael Niedermayer
                pktl->pkt.pts= cur_dts;
905
            cur_dts += pkt->duration;
906 83a9db42 Michael Niedermayer
            pktl->pkt.duration= pkt->duration;
907
        }else
908
            break;
909
    }
910 820ad60c Michael Niedermayer
    if(st->first_dts == AV_NOPTS_VALUE)
911
        st->cur_dts= cur_dts;
912 83a9db42 Michael Niedermayer
}
913
914 115329f1 Diego Biurrun
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
915 fb2758c8 Fabrice Bellard
                               AVCodecParserContext *pc, AVPacket *pkt)
916
{
917 d9e1efb7 Michael Niedermayer
    int num, den, presentation_delayed, delay, i;
918 a74008a4 Joakim Plate
    int64_t offset;
919 115329f1 Diego Biurrun
920 fe8344a2 Michael Niedermayer
    if (s->flags & AVFMT_FLAG_NOFILLIN)
921
        return;
922
923 c55806e3 Michael Niedermayer
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
924
        pkt->dts= AV_NOPTS_VALUE;
925
926 f4a4be3f Wallak
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
927 e18027ac Carl Eugen Hoyos
        //FIXME Set low_delay = 0 when has_b_frames = 1
928 818062f2 Baptiste Coudurier
        st->codec->has_b_frames = 1;
929
930 f781f748 Michael Niedermayer
    /* do we have a video B-frame ? */
931
    delay= st->codec->has_b_frames;
932
    presentation_delayed = 0;
933
    /* XXX: need has_b_frame, but cannot get it if the codec is
934
        not initialized */
935
    if (delay &&
936
        pc && pc->pict_type != FF_B_TYPE)
937
        presentation_delayed = 1;
938
939 10a7571b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
940
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
941
        pkt->dts -= 1LL<<st->pts_wrap_bits;
942
    }
943
944 9806f846 Michael Niedermayer
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
945
    // we take the conservative approach and discard both
946
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
947
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
948 b0a18c2f XBMC
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
949 9806f846 Michael Niedermayer
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
950
    }
951
952 fb2758c8 Fabrice Bellard
    if (pkt->duration == 0) {
953 3c895fc0 Michael Niedermayer
        compute_frame_duration(&num, &den, st, pc, pkt);
954 fb2758c8 Fabrice Bellard
        if (den && num) {
955 0e1f78f9 Michael Niedermayer
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
956 83a9db42 Michael Niedermayer
957 820ad60c Michael Niedermayer
            if(pkt->duration != 0 && s->packet_buffer)
958 83a9db42 Michael Niedermayer
                update_initial_durations(s, st, pkt);
959 fb2758c8 Fabrice Bellard
        }
960
    }
961
962 a85736f2 Diego Biurrun
    /* correct timestamps with byte offset if demuxers only have timestamps
963
       on packet boundaries */
964 a74008a4 Joakim Plate
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
965
        /* this will estimate bitrate based on this frame's duration and size */
966
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
967
        if(pkt->pts != AV_NOPTS_VALUE)
968
            pkt->pts += offset;
969
        if(pkt->dts != AV_NOPTS_VALUE)
970
            pkt->dts += offset;
971
    }
972
973 27ca0a79 Ivan Schreter
    if (pc && pc->dts_sync_point >= 0) {
974
        // we have synchronization info from the parser
975
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
976
        if (den > 0) {
977
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
978
            if (pkt->dts != AV_NOPTS_VALUE) {
979
                // got DTS from the stream, update reference timestamp
980
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
981
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
982
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
983
                // compute DTS based on reference timestamp
984
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
985
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
986
            }
987
            if (pc->dts_sync_point > 0)
988
                st->reference_dts = pkt->dts; // new reference
989
        }
990
    }
991
992 755bfeab Diego Biurrun
    /* This may be redundant, but it should not hurt. */
993 7e4baa66 Michael Niedermayer
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
994
        presentation_delayed = 1;
995 115329f1 Diego Biurrun
996 949b1a13 Steve L'Homme
//    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);
997 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
998 9e6c124a Michael Niedermayer
    //We skip H264 currently because delay and has_b_frames are not reliably set
999
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1000 7e4baa66 Michael Niedermayer
        if (presentation_delayed) {
1001 a85736f2 Diego Biurrun
            /* DTS = decompression timestamp */
1002
            /* PTS = presentation timestamp */
1003 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
1004 635fbcb1 Michael Niedermayer
                pkt->dts = st->last_IP_pts;
1005 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1006 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
1007
                pkt->dts = st->cur_dts;
1008
1009
            /* this is tricky: the dts must be incremented by the duration
1010 a85736f2 Diego Biurrun
            of the frame we are displaying, i.e. the last I- or P-frame */
1011 635fbcb1 Michael Niedermayer
            if (st->last_IP_duration == 0)
1012
                st->last_IP_duration = pkt->duration;
1013 7efeb73a Michael Niedermayer
            if(pkt->dts != AV_NOPTS_VALUE)
1014 cdb5af79 Michael Niedermayer
                st->cur_dts = pkt->dts + st->last_IP_duration;
1015 635fbcb1 Michael Niedermayer
            st->last_IP_duration  = pkt->duration;
1016
            st->last_IP_pts= pkt->pts;
1017 7e4baa66 Michael Niedermayer
            /* cannot compute PTS if not present (we can compute it only
1018 a85736f2 Diego Biurrun
            by knowing the future */
1019 028d6f3e Michael Niedermayer
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1020 7e4baa66 Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1021
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1022
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1023
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1024
                    pkt->pts += pkt->duration;
1025
    //                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);
1026
                }
1027 90bb394d Michael Niedermayer
            }
1028 115329f1 Diego Biurrun
1029 7e4baa66 Michael Niedermayer
            /* presentation is not delayed : PTS and DTS are the same */
1030
            if(pkt->pts == AV_NOPTS_VALUE)
1031
                pkt->pts = pkt->dts;
1032 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1033 7e4baa66 Michael Niedermayer
            if(pkt->pts == AV_NOPTS_VALUE)
1034
                pkt->pts = st->cur_dts;
1035
            pkt->dts = pkt->pts;
1036 7efeb73a Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE)
1037 cdb5af79 Michael Niedermayer
                st->cur_dts = pkt->pts + pkt->duration;
1038 7e4baa66 Michael Niedermayer
        }
1039 fb2758c8 Fabrice Bellard
    }
1040 d9e1efb7 Michael Niedermayer
1041 cb5b96cd Baptiste Coudurier
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1042 d9e1efb7 Michael Niedermayer
        st->pts_buffer[0]= pkt->pts;
1043
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1044
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1045
        if(pkt->dts == AV_NOPTS_VALUE)
1046
            pkt->dts= st->pts_buffer[0];
1047 9e6c124a Michael Niedermayer
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1048 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1049 82583548 Michael Niedermayer
        }
1050 d9e1efb7 Michael Niedermayer
        if(pkt->dts > st->cur_dts)
1051
            st->cur_dts = pkt->dts;
1052
    }
1053
1054
//    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);
1055 115329f1 Diego Biurrun
1056 fb2758c8 Fabrice Bellard
    /* update flags */
1057 3a1d3588 Jeff Downs
    if(is_intra_only(st->codec))
1058 cc947f04 Jean-Daniel Dupas
        pkt->flags |= AV_PKT_FLAG_KEY;
1059 3a1d3588 Jeff Downs
    else if (pc) {
1060 fb2758c8 Fabrice Bellard
        pkt->flags = 0;
1061 a85736f2 Diego Biurrun
        /* keyframe computation */
1062 6363af44 Ivan Schreter
        if (pc->key_frame == 1)
1063 cc947f04 Jean-Daniel Dupas
            pkt->flags |= AV_PKT_FLAG_KEY;
1064 6363af44 Ivan Schreter
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1065 cc947f04 Jean-Daniel Dupas
            pkt->flags |= AV_PKT_FLAG_KEY;
1066 fb2758c8 Fabrice Bellard
    }
1067 b1fa4942 Ivan Schreter
    if (pc)
1068
        pkt->convergence_duration = pc->convergence_duration;
1069 fb2758c8 Fabrice Bellard
}
1070
1071
1072
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1073
{
1074
    AVStream *st;
1075 37353960 Fabrice Bellard
    int len, ret, i;
1076 fb2758c8 Fabrice Bellard
1077 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
1078
1079 fb2758c8 Fabrice Bellard
    for(;;) {
1080
        /* select current input stream component */
1081
        st = s->cur_st;
1082
        if (st) {
1083 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
1084 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
1085
                /* raw data support */
1086 3a41c2f7 Michael Niedermayer
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1087 fb2758c8 Fabrice Bellard
                compute_pkt_fields(s, st, NULL, pkt);
1088
                s->cur_st = NULL;
1089 74f5ae84 Reimar Döffinger
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1090 cc947f04 Jean-Daniel Dupas
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1091 74f5ae84 Reimar Döffinger
                    ff_reduce_index(s, st->index);
1092
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1093
                }
1094 434cab9e Michael Niedermayer
                break;
1095 3a41c2f7 Michael Niedermayer
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1096 61c23c15 Ivan Schreter
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1097
                                       st->cur_ptr, st->cur_len,
1098
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1099
                                       st->cur_pkt.pos);
1100 3a41c2f7 Michael Niedermayer
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1101
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1102 fb2758c8 Fabrice Bellard
                /* increment read pointer */
1103 3a41c2f7 Michael Niedermayer
                st->cur_ptr += len;
1104
                st->cur_len -= len;
1105 115329f1 Diego Biurrun
1106 fb2758c8 Fabrice Bellard
                /* return packet if any */
1107
                if (pkt->size) {
1108 37353960 Fabrice Bellard
                got_packet:
1109 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
1110
                    pkt->stream_index = st->index;
1111 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
1112
                    pkt->dts = st->parser->dts;
1113 61c23c15 Ivan Schreter
                    pkt->pos = st->parser->pos;
1114 a5266a47 Michael Niedermayer
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1115
                        s->cur_st = NULL;
1116
                        pkt->destruct= st->cur_pkt.destruct;
1117 22d78b05 Eli Friedman
                        st->cur_pkt.destruct= NULL;
1118 a5266a47 Michael Niedermayer
                        st->cur_pkt.data    = NULL;
1119
                        assert(st->cur_len == 0);
1120
                    }else{
1121 80d403fc Reimar Döffinger
                    pkt->destruct = NULL;
1122 a5266a47 Michael Niedermayer
                    }
1123 fb2758c8 Fabrice Bellard
                    compute_pkt_fields(s, st, st->parser, pkt);
1124 e9b78eeb Michael Niedermayer
1125 cc947f04 Jean-Daniel Dupas
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1126 3dea63bd Paul Kelly
                        ff_reduce_index(s, st->index);
1127 e9b78eeb Michael Niedermayer
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1128
                                           0, 0, AVINDEX_KEYFRAME);
1129
                    }
1130
1131 434cab9e Michael Niedermayer
                    break;
1132 fb2758c8 Fabrice Bellard
                }
1133
            } else {
1134 bcbecff1 Fabrice Bellard
                /* free packet */
1135 3a41c2f7 Michael Niedermayer
                av_free_packet(&st->cur_pkt);
1136 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
1137
            }
1138
        } else {
1139 3a41c2f7 Michael Niedermayer
            AVPacket cur_pkt;
1140 fb2758c8 Fabrice Bellard
            /* read next packet */
1141 3a41c2f7 Michael Niedermayer
            ret = av_read_packet(s, &cur_pkt);
1142 37353960 Fabrice Bellard
            if (ret < 0) {
1143 8fa36ae0 François Revol
                if (ret == AVERROR(EAGAIN))
1144 37353960 Fabrice Bellard
                    return ret;
1145
                /* return the last frames, if any */
1146
                for(i = 0; i < s->nb_streams; i++) {
1147
                    st = s->streams[i];
1148 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
1149 61c23c15 Ivan Schreter
                        av_parser_parse2(st->parser, st->codec,
1150 115329f1 Diego Biurrun
                                        &pkt->data, &pkt->size,
1151
                                        NULL, 0,
1152 61c23c15 Ivan Schreter
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1153
                                        AV_NOPTS_VALUE);
1154 37353960 Fabrice Bellard
                        if (pkt->size)
1155
                            goto got_packet;
1156
                    }
1157
                }
1158 a85736f2 Diego Biurrun
                /* no more packets: really terminate parsing */
1159 fb2758c8 Fabrice Bellard
                return ret;
1160 37353960 Fabrice Bellard
            }
1161 3a41c2f7 Michael Niedermayer
            st = s->streams[cur_pkt.stream_index];
1162
            st->cur_pkt= cur_pkt;
1163 115329f1 Diego Biurrun
1164 3a41c2f7 Michael Niedermayer
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1165
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1166
               st->cur_pkt.pts < st->cur_pkt.dts){
1167 b18a4ab2 Michael Niedermayer
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1168 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.stream_index,
1169
                    st->cur_pkt.pts,
1170
                    st->cur_pkt.dts,
1171
                    st->cur_pkt.size);
1172
//                av_free_packet(&st->cur_pkt);
1173 b18a4ab2 Michael Niedermayer
//                return -1;
1174
            }
1175
1176 45b2b05f Michael Niedermayer
            if(s->debug & FF_FDEBUG_TS)
1177 050ba6f4 Baptiste Coudurier
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1178 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.stream_index,
1179
                    st->cur_pkt.pts,
1180
                    st->cur_pkt.dts,
1181
                    st->cur_pkt.size,
1182 050ba6f4 Baptiste Coudurier
                    st->cur_pkt.duration,
1183 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.flags);
1184 fb2758c8 Fabrice Bellard
1185
            s->cur_st = st;
1186 3a41c2f7 Michael Niedermayer
            st->cur_ptr = st->cur_pkt.data;
1187
            st->cur_len = st->cur_pkt.size;
1188 fe8344a2 Michael Niedermayer
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1189 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
1190 fb2758c8 Fabrice Bellard
                if (!st->parser) {
1191 a85736f2 Diego Biurrun
                    /* no parser available: just output the raw packets */
1192 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1193
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1194 7cbaa7ba Michael Niedermayer
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1195 74a6df59 Alex Converse
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1196
                    st->parser->flags |= PARSER_FLAG_ONCE;
1197 fb2758c8 Fabrice Bellard
                }
1198
            }
1199
        }
1200
    }
1201 45b2b05f Michael Niedermayer
    if(s->debug & FF_FDEBUG_TS)
1202 050ba6f4 Baptiste Coudurier
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1203 434cab9e Michael Niedermayer
            pkt->stream_index,
1204
            pkt->pts,
1205
            pkt->dts,
1206 3041a4a1 Michael Niedermayer
            pkt->size,
1207 050ba6f4 Baptiste Coudurier
            pkt->duration,
1208 3041a4a1 Michael Niedermayer
            pkt->flags);
1209 434cab9e Michael Niedermayer
1210
    return 0;
1211 fb2758c8 Fabrice Bellard
}
1212
1213
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1214
{
1215 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
1216 30bc6613 Michael Niedermayer
    int eof=0;
1217
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1218
1219
    for(;;){
1220
        pktl = s->packet_buffer;
1221
        if (pktl) {
1222
            AVPacket *next_pkt= &pktl->pkt;
1223
1224
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1225 5be5d28c Stephen Dredge
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1226 30bc6613 Michael Niedermayer
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1227 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1228 5be5d28c Stephen Dredge
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1229
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1230 30bc6613 Michael Niedermayer
                        next_pkt->pts= pktl->pkt.dts;
1231
                    }
1232
                    pktl= pktl->next;
1233
                }
1234
                pktl = s->packet_buffer;
1235
            }
1236 115329f1 Diego Biurrun
1237
            if(   next_pkt->pts != AV_NOPTS_VALUE
1238
               || next_pkt->dts == AV_NOPTS_VALUE
1239 30bc6613 Michael Niedermayer
               || !genpts || eof){
1240
                /* read packet from packet buffer, if there is data */
1241
                *pkt = *next_pkt;
1242
                s->packet_buffer = pktl->next;
1243
                av_free(pktl);
1244
                return 0;
1245
            }
1246
        }
1247
        if(genpts){
1248
            int ret= av_read_frame_internal(s, pkt);
1249
            if(ret<0){
1250 8fa36ae0 François Revol
                if(pktl && ret != AVERROR(EAGAIN)){
1251 30bc6613 Michael Niedermayer
                    eof=1;
1252
                    continue;
1253
                }else
1254
                    return ret;
1255
            }
1256 115329f1 Diego Biurrun
1257 5c5b1731 Måns Rullgård
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1258
                                           &s->packet_buffer_end)) < 0)
1259 769e10f0 Panagiotis Issaris
                return AVERROR(ENOMEM);
1260 30bc6613 Michael Niedermayer
        }else{
1261
            assert(!s->packet_buffer);
1262
            return av_read_frame_internal(s, pkt);
1263
        }
1264 fb2758c8 Fabrice Bellard
    }
1265
}
1266
1267
/* XXX: suppress the packet queue */
1268
static void flush_packet_queue(AVFormatContext *s)
1269
{
1270
    AVPacketList *pktl;
1271
1272
    for(;;) {
1273
        pktl = s->packet_buffer;
1274 115329f1 Diego Biurrun
        if (!pktl)
1275 fb2758c8 Fabrice Bellard
            break;
1276
        s->packet_buffer = pktl->next;
1277
        av_free_packet(&pktl->pkt);
1278
        av_free(pktl);
1279 b9a281db Fabrice Bellard
    }
1280 86cb7e33 Baptiste Coudurier
    while(s->raw_packet_buffer){
1281
        pktl = s->raw_packet_buffer;
1282
        s->raw_packet_buffer = pktl->next;
1283
        av_free_packet(&pktl->pkt);
1284
        av_free(pktl);
1285
    }
1286 42831b46 Michael Niedermayer
    s->packet_buffer_end=
1287
    s->raw_packet_buffer_end= NULL;
1288 af122d6a Baptiste Coudurier
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1289 b9a281db Fabrice Bellard
}
1290
1291 da24c5e3 Fabrice Bellard
/*******************************************************/
1292 fb2758c8 Fabrice Bellard
/* seek support */
1293
1294 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
1295
{
1296 ca162a50 Aurelien Jacobs
    int first_audio_index = -1;
1297 b754978a Michael Niedermayer
    int i;
1298
    AVStream *st;
1299
1300
    if (s->nb_streams <= 0)
1301
        return -1;
1302
    for(i = 0; i < s->nb_streams; i++) {
1303
        st = s->streams[i];
1304 72415b2a Stefano Sabatini
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1305 b754978a Michael Niedermayer
            return i;
1306
        }
1307 72415b2a Stefano Sabatini
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1308 ca162a50 Aurelien Jacobs
            first_audio_index = i;
1309 b754978a Michael Niedermayer
    }
1310 ca162a50 Aurelien Jacobs
    return first_audio_index >= 0 ? first_audio_index : 0;
1311 b754978a Michael Niedermayer
}
1312
1313 e36bdf8b Daniel Kristjansson
/**
1314
 * Flush the frame reader.
1315
 */
1316 972ffe62 Aurelien Jacobs
void ff_read_frame_flush(AVFormatContext *s)
1317 fb2758c8 Fabrice Bellard
{
1318
    AVStream *st;
1319 106fa129 John Stebbins
    int i, j;
1320 fb2758c8 Fabrice Bellard
1321
    flush_packet_queue(s);
1322
1323 3a41c2f7 Michael Niedermayer
    s->cur_st = NULL;
1324 115329f1 Diego Biurrun
1325 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
1326
    for(i = 0; i < s->nb_streams; i++) {
1327
        st = s->streams[i];
1328 115329f1 Diego Biurrun
1329 fb2758c8 Fabrice Bellard
        if (st->parser) {
1330
            av_parser_close(st->parser);
1331
            st->parser = NULL;
1332 3a41c2f7 Michael Niedermayer
            av_free_packet(&st->cur_pkt);
1333 fb2758c8 Fabrice Bellard
        }
1334 635fbcb1 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
1335 a843d1ff Michael Niedermayer
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1336 27ca0a79 Ivan Schreter
        st->reference_dts = AV_NOPTS_VALUE;
1337 3a41c2f7 Michael Niedermayer
        /* fail safe */
1338
        st->cur_ptr = NULL;
1339
        st->cur_len = 0;
1340 86cb7e33 Baptiste Coudurier
1341
        st->probe_packets = MAX_PROBE_PACKETS;
1342 106fa129 John Stebbins
1343
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1344
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1345 fb2758c8 Fabrice Bellard
    }
1346
}
1347
1348 22ffac70 Reimar Döffinger
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1349 8bcb147f Michael Niedermayer
    int i;
1350
1351
    for(i = 0; i < s->nb_streams; i++) {
1352 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
1353 8bcb147f Michael Niedermayer
1354 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
1355 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1356
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1357 8bcb147f Michael Niedermayer
    }
1358
}
1359
1360 3dea63bd Paul Kelly
void ff_reduce_index(AVFormatContext *s, int stream_index)
1361
{
1362
    AVStream *st= s->streams[stream_index];
1363
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1364
1365
    if((unsigned)st->nb_index_entries >= max_entries){
1366
        int i;
1367
        for(i=0; 2*i<st->nb_index_entries; i++)
1368
            st->index_entries[i]= st->index_entries[2*i];
1369
        st->nb_index_entries= i;
1370
    }
1371
}
1372
1373 3e9245a9 Michael Niedermayer
int av_add_index_entry(AVStream *st,
1374 30a43f2d Michael Niedermayer
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1375 fb2758c8 Fabrice Bellard
{
1376
    AVIndexEntry *entries, *ie;
1377 b754978a Michael Niedermayer
    int index;
1378 115329f1 Diego Biurrun
1379 568e18b1 Michael Niedermayer
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1380
        return -1;
1381 115329f1 Diego Biurrun
1382 fb2758c8 Fabrice Bellard
    entries = av_fast_realloc(st->index_entries,
1383
                              &st->index_entries_allocated_size,
1384 115329f1 Diego Biurrun
                              (st->nb_index_entries + 1) *
1385 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1386 568e18b1 Michael Niedermayer
    if(!entries)
1387
        return -1;
1388
1389 b754978a Michael Niedermayer
    st->index_entries= entries;
1390
1391 27a5fe5f Michael Niedermayer
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1392 b754978a Michael Niedermayer
1393 3ba1438d Michael Niedermayer
    if(index<0){
1394 3e9245a9 Michael Niedermayer
        index= st->nb_index_entries++;
1395
        ie= &entries[index];
1396 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1397
    }else{
1398
        ie= &entries[index];
1399
        if(ie->timestamp != timestamp){
1400 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1401
                return -1;
1402 3ba1438d Michael Niedermayer
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1403
            st->nb_index_entries++;
1404 755bfeab Diego Biurrun
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1405 3ba1438d Michael Niedermayer
            distance= ie->min_distance;
1406 3e9245a9 Michael Niedermayer
    }
1407 3ba1438d Michael Niedermayer
1408 b754978a Michael Niedermayer
    ie->pos = pos;
1409
    ie->timestamp = timestamp;
1410 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1411 30a43f2d Michael Niedermayer
    ie->size= size;
1412 b754978a Michael Niedermayer
    ie->flags = flags;
1413 115329f1 Diego Biurrun
1414 3e9245a9 Michael Niedermayer
    return index;
1415 fb2758c8 Fabrice Bellard
}
1416
1417 dc56fc38 Michael Niedermayer
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1418 27a5fe5f Michael Niedermayer
                              int flags)
1419 fb2758c8 Fabrice Bellard
{
1420 b754978a Michael Niedermayer
    AVIndexEntry *entries= st->index_entries;
1421
    int nb_entries= st->nb_index_entries;
1422 fb2758c8 Fabrice Bellard
    int a, b, m;
1423
    int64_t timestamp;
1424
1425 3ba1438d Michael Niedermayer
    a = - 1;
1426
    b = nb_entries;
1427 b754978a Michael Niedermayer
1428 67c10de7 Michael Niedermayer
    //optimize appending index entries at the end
1429
    if(b && entries[b-1].timestamp < wanted_timestamp)
1430
        a= b-1;
1431
1432 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1433
        m = (a + b) >> 1;
1434 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1435 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1436
            b = m;
1437
        if(timestamp <= wanted_timestamp)
1438 b754978a Michael Niedermayer
            a = m;
1439 fb2758c8 Fabrice Bellard
    }
1440 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1441 115329f1 Diego Biurrun
1442 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1443
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1444
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1445
        }
1446
    }
1447 3ba1438d Michael Niedermayer
1448 115329f1 Diego Biurrun
    if(m == nb_entries)
1449 3ba1438d Michael Niedermayer
        return -1;
1450
    return  m;
1451 fb2758c8 Fabrice Bellard
}
1452
1453 0f652a8e Benoit Fouet
#define DEBUG_SEEK
1454 8d14a25c Michael Niedermayer
1455 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1456 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1457 e6586575 Diego Biurrun
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1458 8d14a25c Michael Niedermayer
    int64_t ts_min, ts_max, ts;
1459 89ddd2a9 Michael Niedermayer
    int index;
1460 b593f7fd Sean Soria
    int64_t ret;
1461 8d14a25c Michael Niedermayer
    AVStream *st;
1462
1463 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1464
        return -1;
1465 115329f1 Diego Biurrun
1466 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1467 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1468 8d14a25c Michael Niedermayer
#endif
1469
1470
    ts_max=
1471
    ts_min= AV_NOPTS_VALUE;
1472 90b5b51e Diego Biurrun
    pos_limit= -1; //gcc falsely says it may be uninitialized
1473 8d14a25c Michael Niedermayer
1474
    st= s->streams[stream_index];
1475
    if(st->index_entries){
1476
        AVIndexEntry *e;
1477
1478 a85736f2 Diego Biurrun
        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()
1479 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1480 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1481
1482
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1483
            pos_min= e->pos;
1484
            ts_min= e->timestamp;
1485
#ifdef DEBUG_SEEK
1486 c0492097 Diego Biurrun
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1487
                   pos_min,ts_min);
1488 8d14a25c Michael Niedermayer
#endif
1489
        }else{
1490
            assert(index==0);
1491
        }
1492 115329f1 Diego Biurrun
1493
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1494 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1495
        if(index >= 0){
1496 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1497
            assert(e->timestamp >= target_ts);
1498
            pos_max= e->pos;
1499
            ts_max= e->timestamp;
1500
            pos_limit= pos_max - e->min_distance;
1501
#ifdef DEBUG_SEEK
1502 c0492097 Diego Biurrun
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1503
                   pos_max,pos_limit, ts_max);
1504 8d14a25c Michael Niedermayer
#endif
1505
        }
1506
    }
1507
1508 89ddd2a9 Michael Niedermayer
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1509
    if(pos<0)
1510
        return -1;
1511
1512
    /* do the seek */
1513 b593f7fd Sean Soria
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1514
        return ret;
1515 89ddd2a9 Michael Niedermayer
1516
    av_update_cur_dts(s, st, ts);
1517
1518
    return 0;
1519
}
1520
1521
int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1522
    int64_t pos, ts;
1523
    int64_t start_pos, filesize;
1524
    int no_change;
1525
1526
#ifdef DEBUG_SEEK
1527
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1528
#endif
1529
1530 8d14a25c Michael Niedermayer
    if(ts_min == AV_NOPTS_VALUE){
1531
        pos_min = s->data_offset;
1532 89ddd2a9 Michael Niedermayer
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1533 8d14a25c Michael Niedermayer
        if (ts_min == AV_NOPTS_VALUE)
1534
            return -1;
1535
    }
1536
1537
    if(ts_max == AV_NOPTS_VALUE){
1538
        int step= 1024;
1539 899681cd Björn Axelsson
        filesize = url_fsize(s->pb);
1540 6fd93ce2 Kenneth Aafløy
        pos_max = filesize - 1;
1541 8d14a25c Michael Niedermayer
        do{
1542
            pos_max -= step;
1543 89ddd2a9 Michael Niedermayer
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1544 8d14a25c Michael Niedermayer
            step += step;
1545
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1546
        if (ts_max == AV_NOPTS_VALUE)
1547
            return -1;
1548 115329f1 Diego Biurrun
1549 8d14a25c Michael Niedermayer
        for(;;){
1550
            int64_t tmp_pos= pos_max + 1;
1551 89ddd2a9 Michael Niedermayer
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1552 8d14a25c Michael Niedermayer
            if(tmp_ts == AV_NOPTS_VALUE)
1553
                break;
1554
            ts_max= tmp_ts;
1555
            pos_max= tmp_pos;
1556 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1557
                break;
1558 8d14a25c Michael Niedermayer
        }
1559
        pos_limit= pos_max;
1560
    }
1561
1562 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1563
        return -1;
1564
    }else if(ts_min == ts_max){
1565
        pos_limit= pos_min;
1566
    }
1567
1568 8d14a25c Michael Niedermayer
    no_change=0;
1569
    while (pos_min < pos_limit) {
1570
#ifdef DEBUG_SEEK
1571 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1572 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1573
               ts_min, ts_max);
1574
#endif
1575
        assert(pos_limit <= pos_max);
1576
1577
        if(no_change==0){
1578
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1579
            // interpolate position (better than dichotomy)
1580 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1581
                + pos_min - approximate_keyframe_distance;
1582 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1583
            // bisection, if interpolation failed to change min or max pos last time
1584
            pos = (pos_min + pos_limit)>>1;
1585
        }else{
1586 a85736f2 Diego Biurrun
            /* linear search if bisection failed, can only happen if there
1587
               are very few or no keyframes between min/max */
1588 8d14a25c Michael Niedermayer
            pos=pos_min;
1589
        }
1590
        if(pos <= pos_min)
1591
            pos= pos_min + 1;
1592
        else if(pos > pos_limit)
1593
            pos= pos_limit;
1594
        start_pos= pos;
1595
1596 89ddd2a9 Michael Niedermayer
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1597 8d14a25c Michael Niedermayer
        if(pos == pos_max)
1598
            no_change++;
1599
        else
1600
            no_change=0;
1601
#ifdef DEBUG_SEEK
1602 c0492097 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1603
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1604
               start_pos, no_change);
1605 8d14a25c Michael Niedermayer
#endif
1606 db2a0e22 Michael Niedermayer
        if(ts == AV_NOPTS_VALUE){
1607
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1608
            return -1;
1609
        }
1610 8d14a25c Michael Niedermayer
        assert(ts != AV_NOPTS_VALUE);
1611 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1612 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1613
            pos_max = pos;
1614
            ts_max = ts;
1615 3ba1438d Michael Niedermayer
        }
1616
        if (target_ts >= ts) {
1617 8d14a25c Michael Niedermayer
            pos_min = pos;
1618
            ts_min = ts;
1619
        }
1620
    }
1621 115329f1 Diego Biurrun
1622 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1623
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1624 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1625
    pos_min = pos;
1626 89ddd2a9 Michael Niedermayer
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1627 8d14a25c Michael Niedermayer
    pos_min++;
1628 89ddd2a9 Michael Niedermayer
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1629 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1630 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1631
#endif
1632 89ddd2a9 Michael Niedermayer
    *ts_ret= ts;
1633
    return pos;
1634 8d14a25c Michael Niedermayer
}
1635
1636 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1637
    int64_t pos_min, pos_max;
1638
#if 0
1639
    AVStream *st;
1640

1641
    if (stream_index < 0)
1642
        return -1;
1643

1644
    st= s->streams[stream_index];
1645
#endif
1646
1647
    pos_min = s->data_offset;
1648 899681cd Björn Axelsson
    pos_max = url_fsize(s->pb) - 1;
1649 3ba1438d Michael Niedermayer
1650
    if     (pos < pos_min) pos= pos_min;
1651
    else if(pos > pos_max) pos= pos_max;
1652
1653 899681cd Björn Axelsson
    url_fseek(s->pb, pos, SEEK_SET);
1654 3ba1438d Michael Niedermayer
1655
#if 0
1656 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ts);
1657 3ba1438d Michael Niedermayer
#endif
1658
    return 0;
1659
}
1660
1661 115329f1 Diego Biurrun
static int av_seek_frame_generic(AVFormatContext *s,
1662 3ba1438d Michael Niedermayer
                                 int stream_index, int64_t timestamp, int flags)
1663 fb2758c8 Fabrice Bellard
{
1664 6659b32a Sean Soria
    int index;
1665
    int64_t ret;
1666 fb2758c8 Fabrice Bellard
    AVStream *st;
1667
    AVIndexEntry *ie;
1668
1669
    st = s->streams[stream_index];
1670 e9b78eeb Michael Niedermayer
1671 27a5fe5f Michael Niedermayer
    index = av_index_search_timestamp(st, timestamp, flags);
1672 e9b78eeb Michael Niedermayer
1673 8c3b161e Michael Niedermayer
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1674
        return -1;
1675
1676 b5a3541d Michael Niedermayer
    if(index < 0 || index==st->nb_index_entries-1){
1677 e9b78eeb Michael Niedermayer
        int i;
1678
        AVPacket pkt;
1679
1680 5e5c9086 Michael Niedermayer
        if(st->nb_index_entries){
1681
            assert(st->index_entries);
1682 e9b78eeb Michael Niedermayer
            ie= &st->index_entries[st->nb_index_entries-1];
1683 aaec4e03 Baptiste Coudurier
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1684
                return ret;
1685 e9b78eeb Michael Niedermayer
            av_update_cur_dts(s, st, ie->timestamp);
1686 aaec4e03 Baptiste Coudurier
        }else{
1687 3a4f91f5 Reimar Döffinger
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1688 aaec4e03 Baptiste Coudurier
                return ret;
1689
        }
1690 e9b78eeb Michael Niedermayer
        for(i=0;; i++) {
1691 cda6902d Michael Niedermayer
            int ret;
1692
            do{
1693
                ret = av_read_frame(s, &pkt);
1694
            }while(ret == AVERROR(EAGAIN));
1695 e9b78eeb Michael Niedermayer
            if(ret<0)
1696
                break;
1697
            av_free_packet(&pkt);
1698
            if(stream_index == pkt.stream_index){
1699 cc947f04 Jean-Daniel Dupas
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1700 e9b78eeb Michael Niedermayer
                    break;
1701
            }
1702
        }
1703
        index = av_index_search_timestamp(st, timestamp, flags);
1704
    }
1705 fb2758c8 Fabrice Bellard
    if (index < 0)
1706
        return -1;
1707
1708 972ffe62 Aurelien Jacobs
    ff_read_frame_flush(s);
1709 e9b78eeb Michael Niedermayer
    if (s->iformat->read_seek){
1710
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1711
            return 0;
1712
    }
1713
    ie = &st->index_entries[index];
1714 aaec4e03 Baptiste Coudurier
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1715
        return ret;
1716 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ie->timestamp);
1717 cdd5034f Michael Niedermayer
1718 fb2758c8 Fabrice Bellard
    return 0;
1719
}
1720
1721 3ba1438d Michael Niedermayer
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1722 fb2758c8 Fabrice Bellard
{
1723
    int ret;
1724 cdd5034f Michael Niedermayer
    AVStream *st;
1725 115329f1 Diego Biurrun
1726 972ffe62 Aurelien Jacobs
    ff_read_frame_flush(s);
1727 115329f1 Diego Biurrun
1728 3ba1438d Michael Niedermayer
    if(flags & AVSEEK_FLAG_BYTE)
1729
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1730 115329f1 Diego Biurrun
1731 cdd5034f Michael Niedermayer
    if(stream_index < 0){
1732
        stream_index= av_find_default_stream_index(s);
1733
        if(stream_index < 0)
1734
            return -1;
1735 115329f1 Diego Biurrun
1736 3ba1438d Michael Niedermayer
        st= s->streams[stream_index];
1737 eb497825 Nathan Kurz
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1738 3ba1438d Michael Niedermayer
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1739 cdd5034f Michael Niedermayer
    }
1740
1741 fb2758c8 Fabrice Bellard
    /* first, we try the format specific seek */
1742
    if (s->iformat->read_seek)
1743 3ba1438d Michael Niedermayer
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1744 fb2758c8 Fabrice Bellard
    else
1745
        ret = -1;
1746
    if (ret >= 0) {
1747
        return 0;
1748
    }
1749 8d14a25c Michael Niedermayer
1750
    if(s->iformat->read_timestamp)
1751 3ba1438d Michael Niedermayer
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1752 8d14a25c Michael Niedermayer
    else
1753 3ba1438d Michael Niedermayer
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1754 fb2758c8 Fabrice Bellard
}
1755
1756 32d88592 Michael Niedermayer
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1757
{
1758
    if(min_ts > ts || max_ts < ts)
1759
        return -1;
1760
1761 972ffe62 Aurelien Jacobs
    ff_read_frame_flush(s);
1762 32d88592 Michael Niedermayer
1763
    if (s->iformat->read_seek2)
1764
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1765
1766
    if(s->iformat->read_timestamp){
1767
        //try to seek via read_timestamp()
1768
    }
1769
1770
    //Fallback to old API if new is not implemented but old is
1771
    //Note the old has somewat different sematics
1772
    if(s->iformat->read_seek || 1)
1773 85b4230f Michael Niedermayer
        return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1774 32d88592 Michael Niedermayer
1775
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1776
}
1777
1778 fb2758c8 Fabrice Bellard
/*******************************************************/
1779 12f996ed Fabrice Bellard
1780 e36bdf8b Daniel Kristjansson
/**
1781 49bd8e4b Måns Rullgård
 * Return TRUE if the stream has accurate duration in any stream.
1782 e36bdf8b Daniel Kristjansson
 *
1783 c1e8b678 Neil Brown
 * @return TRUE if the stream has accurate duration for at least one component.
1784 e36bdf8b Daniel Kristjansson
 */
1785 c1e8b678 Neil Brown
static int av_has_duration(AVFormatContext *ic)
1786 12f996ed Fabrice Bellard
{
1787
    int i;
1788
    AVStream *st;
1789
1790
    for(i = 0;i < ic->nb_streams; i++) {
1791
        st = ic->streams[i];
1792 c1e8b678 Neil Brown
        if (st->duration != AV_NOPTS_VALUE)
1793 12f996ed Fabrice Bellard
            return 1;
1794
    }
1795
    return 0;
1796
}
1797
1798 e36bdf8b Daniel Kristjansson
/**
1799
 * Estimate the stream timings from the one of each components.
1800
 *
1801
 * Also computes the global bitrate if possible.
1802
 */
1803 12f996ed Fabrice Bellard
static void av_update_stream_timings(AVFormatContext *ic)
1804
{
1805 c0df9d75 Michael Niedermayer
    int64_t start_time, start_time1, end_time, end_time1;
1806 c1e8b678 Neil Brown
    int64_t duration, duration1;
1807 12f996ed Fabrice Bellard
    int i;
1808
    AVStream *st;
1809
1810 f27a7268 Måns Rullgård
    start_time = INT64_MAX;
1811
    end_time = INT64_MIN;
1812 c1e8b678 Neil Brown
    duration = INT64_MIN;
1813 12f996ed Fabrice Bellard
    for(i = 0;i < ic->nb_streams; i++) {
1814
        st = ic->streams[i];
1815 7f938dd3 Aurelien Jacobs
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1816 c0df9d75 Michael Niedermayer
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1817
            if (start_time1 < start_time)
1818
                start_time = start_time1;
1819 12f996ed Fabrice Bellard
            if (st->duration != AV_NOPTS_VALUE) {
1820 c0df9d75 Michael Niedermayer
                end_time1 = start_time1
1821
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1822 12f996ed Fabrice Bellard
                if (end_time1 > end_time)
1823
                    end_time = end_time1;
1824
            }
1825
        }
1826 c1e8b678 Neil Brown
        if (st->duration != AV_NOPTS_VALUE) {
1827
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1828
            if (duration1 > duration)
1829
                duration = duration1;
1830
        }
1831 12f996ed Fabrice Bellard
    }
1832 f27a7268 Måns Rullgård
    if (start_time != INT64_MAX) {
1833 12f996ed Fabrice Bellard
        ic->start_time = start_time;
1834 f27a7268 Måns Rullgård
        if (end_time != INT64_MIN) {
1835 c1e8b678 Neil Brown
            if (end_time - start_time > duration)
1836
                duration = end_time - start_time;
1837
        }
1838
    }
1839
    if (duration != INT64_MIN) {
1840
        ic->duration = duration;
1841
        if (ic->file_size > 0) {
1842 a85736f2 Diego Biurrun
            /* compute the bitrate */
1843 c1e8b678 Neil Brown
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1844
                (double)ic->duration;
1845 12f996ed Fabrice Bellard
        }
1846
    }
1847
}
1848
1849
static void fill_all_stream_timings(AVFormatContext *ic)
1850
{
1851
    int i;
1852
    AVStream *st;
1853
1854
    av_update_stream_timings(ic);
1855
    for(i = 0;i < ic->nb_streams; i++) {
1856
        st = ic->streams[i];
1857
        if (st->start_time == AV_NOPTS_VALUE) {
1858 c0df9d75 Michael Niedermayer
            if(ic->start_time != AV_NOPTS_VALUE)
1859
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1860
            if(ic->duration != AV_NOPTS_VALUE)
1861
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1862 12f996ed Fabrice Bellard
        }
1863
    }
1864
}
1865
1866
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1867
{
1868
    int64_t filesize, duration;
1869
    int bit_rate, i;
1870
    AVStream *st;
1871
1872
    /* if bit_rate is already set, we believe it */
1873 9100d4d6 David Czech
    if (ic->bit_rate <= 0) {
1874 12f996ed Fabrice Bellard
        bit_rate = 0;
1875
        for(i=0;i<ic->nb_streams;i++) {
1876
            st = ic->streams[i];
1877 9100d4d6 David Czech
            if (st->codec->bit_rate > 0)
1878 01f4895c Michael Niedermayer
            bit_rate += st->codec->bit_rate;
1879 12f996ed Fabrice Bellard
        }
1880
        ic->bit_rate = bit_rate;
1881
    }
1882
1883
    /* if duration is already set, we believe it */
1884 115329f1 Diego Biurrun
    if (ic->duration == AV_NOPTS_VALUE &&
1885
        ic->bit_rate != 0 &&
1886 12f996ed Fabrice Bellard
        ic->file_size != 0)  {
1887
        filesize = ic->file_size;
1888
        if (filesize > 0) {
1889
            for(i = 0; i < ic->nb_streams; i++) {
1890
                st = ic->streams[i];
1891 c0df9d75 Michael Niedermayer
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1892 9f32041d Neil Brown
                if (st->duration == AV_NOPTS_VALUE)
1893 12f996ed Fabrice Bellard
                    st->duration = duration;
1894
            }
1895
        }
1896
    }
1897
}
1898
1899
#define DURATION_MAX_READ_SIZE 250000
1900 411ff322 Michael Niedermayer
#define DURATION_MAX_RETRY 3
1901 12f996ed Fabrice Bellard
1902
/* only usable for MPEG-PS streams */
1903 bc5c918e Diego Biurrun
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1904 12f996ed Fabrice Bellard
{
1905
    AVPacket pkt1, *pkt = &pkt1;
1906
    AVStream *st;
1907
    int read_size, i, ret;
1908 3e4318bf Aurelien Jacobs
    int64_t end_time;
1909 12f996ed Fabrice Bellard
    int64_t filesize, offset, duration;
1910 411ff322 Michael Niedermayer
    int retry=0;
1911 115329f1 Diego Biurrun
1912 578688fa Luca Abeni
    ic->cur_st = NULL;
1913
1914
    /* flush packet queue */
1915
    flush_packet_queue(ic);
1916
1917 e99179de Aurelien Jacobs
    for (i=0; i<ic->nb_streams; i++) {
1918 578688fa Luca Abeni
        st = ic->streams[i];
1919 3e4318bf Aurelien Jacobs
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1920 cc20679a Michael Niedermayer
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1921
1922 578688fa Luca Abeni
        if (st->parser) {
1923
            av_parser_close(st->parser);
1924
            st->parser= NULL;
1925 3a41c2f7 Michael Niedermayer
            av_free_packet(&st->cur_pkt);
1926 578688fa Luca Abeni
        }
1927
    }
1928 115329f1 Diego Biurrun
1929 12f996ed Fabrice Bellard
    /* estimate the end time (duration) */
1930
    /* XXX: may need to support wrapping */
1931
    filesize = ic->file_size;
1932 411ff322 Michael Niedermayer
    end_time = AV_NOPTS_VALUE;
1933
    do{
1934
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1935 12f996ed Fabrice Bellard
    if (offset < 0)
1936
        offset = 0;
1937
1938 899681cd Björn Axelsson
    url_fseek(ic->pb, offset, SEEK_SET);
1939 12f996ed Fabrice Bellard
    read_size = 0;
1940
    for(;;) {
1941 411ff322 Michael Niedermayer
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1942 12f996ed Fabrice Bellard
            break;
1943 115329f1 Diego Biurrun
1944 cda6902d Michael Niedermayer
        do{
1945
            ret = av_read_packet(ic, pkt);
1946
        }while(ret == AVERROR(EAGAIN));
1947 12f996ed Fabrice Bellard
        if (ret != 0)
1948
            break;
1949
        read_size += pkt->size;
1950
        st = ic->streams[pkt->stream_index];
1951 bf494092 Neil Brown
        if (pkt->pts != AV_NOPTS_VALUE &&
1952 3e4318bf Aurelien Jacobs
            (st->start_time != AV_NOPTS_VALUE ||
1953
             st->first_dts  != AV_NOPTS_VALUE)) {
1954
            duration = end_time = pkt->pts;
1955
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1956
            else                                   duration -= st->first_dts;
1957 d30a8beb Michael Niedermayer
            if (duration < 0)
1958
                duration += 1LL<<st->pts_wrap_bits;
1959 12f996ed Fabrice Bellard
            if (duration > 0) {
1960
                if (st->duration == AV_NOPTS_VALUE ||
1961
                    st->duration < duration)
1962
                    st->duration = duration;
1963
            }
1964
        }
1965
        av_free_packet(pkt);
1966
    }
1967 411ff322 Michael Niedermayer
    }while(   end_time==AV_NOPTS_VALUE
1968
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1969
           && ++retry <= DURATION_MAX_RETRY);
1970 115329f1 Diego Biurrun
1971 c0df9d75 Michael Niedermayer
    fill_all_stream_timings(ic);
1972 12f996ed Fabrice Bellard
1973 899681cd Björn Axelsson
    url_fseek(ic->pb, old_offset, SEEK_SET);
1974 e99179de Aurelien Jacobs
    for (i=0; i<ic->nb_streams; i++) {
1975 df886e7e Michael Niedermayer
        st= ic->streams[i];
1976
        st->cur_dts= st->first_dts;
1977 635fbcb1 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
1978 df886e7e Michael Niedermayer
    }
1979 12f996ed Fabrice Bellard
}
1980
1981 bc5c918e Diego Biurrun
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1982 12f996ed Fabrice Bellard
{
1983
    int64_t file_size;
1984
1985
    /* get the file size, if possible */
1986
    if (ic->iformat->flags & AVFMT_NOFILE) {
1987
        file_size = 0;
1988
    } else {
1989 899681cd Björn Axelsson
        file_size = url_fsize(ic->pb);
1990 12f996ed Fabrice Bellard
        if (file_size < 0)
1991
            file_size = 0;
1992
    }
1993
    ic->file_size = file_size;
1994
1995 ff70e601 Måns Rullgård
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1996
         !strcmp(ic->iformat->name, "mpegts")) &&
1997 ceeacce6 Aurelien Jacobs
        file_size && !url_is_streamed(ic->pb)) {
1998 12f996ed Fabrice Bellard
        /* get accurate estimate from the PTSes */
1999 9ecf7fad Wolfram Gloger
        av_estimate_timings_from_pts(ic, old_offset);
2000 c1e8b678 Neil Brown
    } else if (av_has_duration(ic)) {
2001 a85736f2 Diego Biurrun
        /* at least one component has timings - we use them for all
2002 12f996ed Fabrice Bellard
           the components */
2003
        fill_all_stream_timings(ic);
2004
    } else {
2005 77ac76a3 Michael Niedermayer
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2006 a85736f2 Diego Biurrun
        /* less precise: use bitrate info */
2007 12f996ed Fabrice Bellard
        av_estimate_timings_from_bit_rate(ic);
2008
    }
2009
    av_update_stream_timings(ic);
2010
2011
#if 0
2012
    {
2013
        int i;
2014
        AVStream *st;
2015
        for(i = 0;i < ic->nb_streams; i++) {
2016
            st = ic->streams[i];
2017 115329f1 Diego Biurrun
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2018
               i, (double)st->start_time / AV_TIME_BASE,
2019 12f996ed Fabrice Bellard
               (double)st->duration / AV_TIME_BASE);
2020
        }
2021 115329f1 Diego Biurrun
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2022
               (double)ic->start_time / AV_TIME_BASE,
2023 12f996ed Fabrice Bellard
               (double)ic->duration / AV_TIME_BASE,
2024
               ic->bit_rate / 1000);
2025
    }
2026
#endif
2027
}
2028
2029 b9a281db Fabrice Bellard
static int has_codec_parameters(AVCodecContext *enc)
2030
{
2031
    int val;
2032
    switch(enc->codec_type) {
2033 72415b2a Stefano Sabatini
    case AVMEDIA_TYPE_AUDIO:
2034 5d6e4c16 Stefano Sabatini
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2035 f3b5a1a2 Baptiste Coudurier
        if(!enc->frame_size &&
2036
           (enc->codec_id == CODEC_ID_VORBIS ||
2037 1d07029f Justin Ruggles
            enc->codec_id == CODEC_ID_AAC ||
2038 b7884740 Michael Niedermayer
            enc->codec_id == CODEC_ID_MP1 ||
2039
            enc->codec_id == CODEC_ID_MP2 ||
2040 8425ceca Baptiste Coudurier
            enc->codec_id == CODEC_ID_MP3 ||
2041 1d07029f Justin Ruggles
            enc->codec_id == CODEC_ID_SPEEX))
2042 4d35bf74 Michael Niedermayer
            return 0;
2043 b9a281db Fabrice Bellard
        break;
2044 72415b2a Stefano Sabatini
    case AVMEDIA_TYPE_VIDEO:
2045 644a9262 Michael Niedermayer
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2046 b9a281db Fabrice Bellard
        break;
2047
    default:
2048
        val = 1;
2049
        break;
2050
    }
2051 ccd425e7 Diego Biurrun
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2052 b9a281db Fabrice Bellard
}
2053
2054 ae447836 Baptiste Coudurier
static int has_decode_delay_been_guessed(AVStream *st)
2055
{
2056
    return st->codec->codec_id != CODEC_ID_H264 ||
2057 581ba2ce Baptiste Coudurier
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2058 ae447836 Baptiste Coudurier
}
2059
2060 655d47c2 Thilo Borgmann
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2061 fb2758c8 Fabrice Bellard
{
2062
    int16_t *samples;
2063
    AVCodec *codec;
2064 3fdb6af9 Baptiste Coudurier
    int got_picture, data_size, ret=0;
2065 fb2758c8 Fabrice Bellard
    AVFrame picture;
2066 115329f1 Diego Biurrun
2067 e472ea34 Baptiste Coudurier
    if(!st->codec->codec){
2068
        codec = avcodec_find_decoder(st->codec->codec_id);
2069
        if (!codec)
2070
            return -1;
2071
        ret = avcodec_open(st->codec, codec);
2072
        if (ret < 0)
2073
            return ret;
2074
    }
2075 644a9262 Michael Niedermayer
2076 ae447836 Baptiste Coudurier
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2077 e472ea34 Baptiste Coudurier
        switch(st->codec->codec_type) {
2078 72415b2a Stefano Sabatini
        case AVMEDIA_TYPE_VIDEO:
2079 1bd280f7 Baptiste Coudurier
            avcodec_get_frame_defaults(&picture);
2080 e472ea34 Baptiste Coudurier
            ret = avcodec_decode_video2(st->codec, &picture,
2081
                                        &got_picture, avpkt);
2082
            break;
2083 72415b2a Stefano Sabatini
        case AVMEDIA_TYPE_AUDIO:
2084 e472ea34 Baptiste Coudurier
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2085
            samples = av_malloc(data_size);
2086
            if (!samples)
2087
                goto fail;
2088
            ret = avcodec_decode_audio3(st->codec, samples,
2089
                                        &data_size, avpkt);
2090
            av_free(samples);
2091
            break;
2092
        default:
2093
            break;
2094
        }
2095 fb2758c8 Fabrice Bellard
    }
2096
 fail:
2097
    return ret;
2098
}
2099
2100 83c27079 Stefano Sabatini
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2101 45da8124 Aurelien Jacobs
{
2102
    while (tags->id != CODEC_ID_NONE) {
2103
        if (tags->id == id)
2104
            return tags->tag;
2105
        tags++;
2106
    }
2107
    return 0;
2108
}
2109
2110 1a40491e Daniel Verkamp
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2111 45da8124 Aurelien Jacobs
{
2112 41415d28 Michael Niedermayer
    int i;
2113
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2114
        if(tag == tags[i].tag)
2115
            return tags[i].id;
2116
    }
2117
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2118 603a5f04 Francesco Lavra
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2119 41415d28 Michael Niedermayer
            return tags[i].id;
2120 45da8124 Aurelien Jacobs
    }
2121
    return CODEC_ID_NONE;
2122
}
2123
2124 15545a09 Stefano Sabatini
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2125 45da8124 Aurelien Jacobs
{
2126
    int i;
2127
    for(i=0; tags && tags[i]; i++){
2128 1a40491e Daniel Verkamp
        int tag= ff_codec_get_tag(tags[i], id);
2129 45da8124 Aurelien Jacobs
        if(tag) return tag;
2130
    }
2131
    return 0;
2132
}
2133
2134 15545a09 Stefano Sabatini
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2135 45da8124 Aurelien Jacobs
{
2136
    int i;
2137
    for(i=0; tags && tags[i]; i++){
2138 1a40491e Daniel Verkamp
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2139 45da8124 Aurelien Jacobs
        if(id!=CODEC_ID_NONE) return id;
2140
    }
2141
    return CODEC_ID_NONE;
2142
}
2143
2144 c2c3dedf Aurelien Jacobs
static void compute_chapters_end(AVFormatContext *s)
2145
{
2146
    unsigned int i;
2147
2148
    for (i=0; i+1<s->nb_chapters; i++)
2149
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2150
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2151
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2152
            s->chapters[i]->end = s->chapters[i+1]->start;
2153
        }
2154
2155
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2156
        assert(s->start_time != AV_NOPTS_VALUE);
2157
        assert(s->duration > 0);
2158
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2159
                                           AV_TIME_BASE_Q,
2160
                                           s->chapters[i]->time_base);
2161
    }
2162
}
2163
2164 4d43cbcc Michael Niedermayer
static int get_std_framerate(int i){
2165
    if(i<60*12) return i*1001;
2166 aecf157e Reimar Döffinger
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2167 4d43cbcc Michael Niedermayer
}
2168
2169 945208ca Michael Niedermayer
/*
2170
 * Is the time base unreliable.
2171
 * This is a heuristic to balance between quick acceptance of the values in
2172
 * the headers vs. some extra checks.
2173 a85736f2 Diego Biurrun
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2174
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2175 945208ca Michael Niedermayer
 * And there are "variable" fps files this needs to detect as well.
2176
 */
2177
static int tb_unreliable(AVCodecContext *c){
2178
    if(   c->time_base.den >= 101L*c->time_base.num
2179
       || c->time_base.den <    5L*c->time_base.num
2180 2bb6eba2 Aurelien Jacobs
/*       || c->codec_tag == AV_RL32("DIVX")
2181
       || c->codec_tag == AV_RL32("XVID")*/
2182 7f123e7f Michael Niedermayer
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2183
       || c->codec_id == CODEC_ID_H264
2184
       )
2185 945208ca Michael Niedermayer
        return 1;
2186
    return 0;
2187
}
2188
2189 b9a281db Fabrice Bellard
int av_find_stream_info(AVFormatContext *ic)
2190
{
2191 9f75260e Michael Niedermayer
    int i, count, ret, read_size, j;
2192 b9a281db Fabrice Bellard
    AVStream *st;
2193 fb2758c8 Fabrice Bellard
    AVPacket pkt1, *pkt;
2194 bc5c918e Diego Biurrun
    int64_t old_offset = url_ftell(ic->pb);
2195 0cbff027 Kristian Amlie
2196 c0df9d75 Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
2197 62784e37 Benjamin Larsson
        AVCodec *codec;
2198 c0df9d75 Michael Niedermayer
        st = ic->streams[i];
2199 e7e291e9 Alex Converse
        if (st->codec->codec_id == CODEC_ID_AAC) {
2200
            st->codec->sample_rate = 0;
2201
            st->codec->frame_size = 0;
2202
            st->codec->channels = 0;
2203
        }
2204 b3c0fc76 Aurelien Jacobs
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2205
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2206 c0df9d75 Michael Niedermayer
/*            if(!st->time_base.num)
2207
                st->time_base= */
2208 01f4895c Michael Niedermayer
            if(!st->codec->time_base.num)
2209
                st->codec->time_base= st->time_base;
2210 c0df9d75 Michael Niedermayer
        }
2211 90ad92b3 Michael Niedermayer
        //only for the split stuff
2212 fe8344a2 Michael Niedermayer
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2213 01f4895c Michael Niedermayer
            st->parser = av_parser_init(st->codec->codec_id);
2214 57004ff1 Aurelien Jacobs
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2215 7cbaa7ba Michael Niedermayer
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2216
            }
2217 90ad92b3 Michael Niedermayer
        }
2218 43e4d57f Michael Niedermayer
        assert(!st->codec->codec);
2219 62784e37 Benjamin Larsson
        codec = avcodec_find_decoder(st->codec->codec_id);
2220
2221
        /* Force decoding of at least one frame of codec data
2222
         * this makes sure the codec initializes the channel configuration
2223
         * and does not trust the values from the container.
2224
         */
2225
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2226
            st->codec->channels = 0;
2227
2228 cb2c971d Aurelien Jacobs
        /* Ensure that subtitle_header is properly set. */
2229
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2230
            && codec && !st->codec->codec)
2231
            avcodec_open(st->codec, codec);
2232
2233 43e4d57f Michael Niedermayer
        //try to just open decoders, in case this is enough to get parameters
2234
        if(!has_codec_parameters(st->codec)){
2235 cb2c971d Aurelien Jacobs
            if (codec && !st->codec->codec)
2236 43e4d57f Michael Niedermayer
                avcodec_open(st->codec, codec);
2237
        }
2238 c0df9d75 Michael Niedermayer
    }
2239
2240 feb2440c Aurelien Jacobs
    for (i=0; i<ic->nb_streams; i++) {
2241 fd0368e7 Aurelien Jacobs
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2242 15bc38e5 Michael Niedermayer
    }
2243 115329f1 Diego Biurrun
2244 b9a281db Fabrice Bellard
    count = 0;
2245
    read_size = 0;
2246
    for(;;) {
2247 1d14361d Michael Niedermayer
        if(url_interrupt_cb()){
2248
            ret= AVERROR(EINTR);
2249 71ee6515 Michael Niedermayer
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2250 1d14361d Michael Niedermayer
            break;
2251
        }
2252
2253 b9a281db Fabrice Bellard
        /* check if one codec still needs to be handled */
2254
        for(i=0;i<ic->nb_streams;i++) {
2255
            st = ic->streams[i];
2256 01f4895c Michael Niedermayer
            if (!has_codec_parameters(st->codec))
2257 b9a281db Fabrice Bellard
                break;
2258 3e76d1b5 Michael Niedermayer
            /* variable fps and no guess at the real fps */
2259 0e5f33f2 Michael Niedermayer
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2260 fd0368e7 Aurelien Jacobs
               && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2261 3e76d1b5 Michael Niedermayer
                break;
2262 01f4895c Michael Niedermayer
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2263 90ad92b3 Michael Niedermayer
                break;
2264 82583548 Michael Niedermayer
            if(st->first_dts == AV_NOPTS_VALUE)
2265
                break;
2266 b9a281db Fabrice Bellard
        }
2267
        if (i == ic->nb_streams) {
2268
            /* NOTE: if the format has no header, then we need to read
2269
               some packets to get most of the streams, so we cannot
2270
               stop here */
2271 fb2758c8 Fabrice Bellard
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2272 b9a281db Fabrice Bellard
                /* if we found the info for all the codecs, we can stop */
2273
                ret = count;
2274 71ee6515 Michael Niedermayer
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2275 b9a281db Fabrice Bellard
                break;
2276
            }
2277 5fb83c38 Michael Niedermayer
        }
2278 35eab0c0 Michael Niedermayer
        /* we did not get all the codec info, but we read too much data */
2279 57011a13 Baptiste Coudurier
        if (read_size >= ic->probesize) {
2280 35eab0c0 Michael Niedermayer
            ret = count;
2281 9bbe9a0d Jai Menon
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2282 35eab0c0 Michael Niedermayer
            break;
2283
        }
2284 b9a281db Fabrice Bellard
2285 fb2758c8 Fabrice Bellard
        /* NOTE: a new stream can be added there if no header in file
2286
           (AVFMTCTX_NOHEADER) */
2287
        ret = av_read_frame_internal(ic, &pkt1);
2288 feb2440c Aurelien Jacobs
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2289 fb2758c8 Fabrice Bellard
            /* EOF or error */
2290
            ret = -1; /* we could not have all the codec parameters before EOF */
2291 e19456e3 Michael Niedermayer
            for(i=0;i<ic->nb_streams;i++) {
2292
                st = ic->streams[i];
2293 305ee50f Michael Niedermayer
                if (!has_codec_parameters(st->codec)){
2294
                    char buf[256];
2295
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2296 657eca1f Michael Niedermayer
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2297 344a18c3 Måns Rullgård
                } else {
2298
                    ret = 0;
2299 305ee50f Michael Niedermayer
                }
2300 e19456e3 Michael Niedermayer
            }
2301 fb2758c8 Fabrice Bellard
            break;
2302
        }
2303
2304 feb2440c Aurelien Jacobs
        if (ret == AVERROR(EAGAIN))
2305
            continue;
2306
2307 5c5b1731 Måns Rullgård
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2308 fd0368e7 Aurelien Jacobs
        if ((ret = av_dup_packet(pkt)) < 0)
2309
            goto find_stream_info_err;
2310 b9a281db Fabrice Bellard
2311 fb2758c8 Fabrice Bellard
        read_size += pkt->size;
2312 b9a281db Fabrice Bellard
2313
        st = ic->streams[pkt->stream_index];
2314 fd0368e7 Aurelien Jacobs
        if (st->codec_info_nb_frames>1) {
2315
            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) {
2316 657eca1f Michael Niedermayer
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2317 3a560188 Baptiste Coudurier
                break;
2318 71ee6515 Michael Niedermayer
            }
2319 fd0368e7 Aurelien Jacobs
            st->info->codec_info_duration += pkt->duration;
2320 3a560188 Baptiste Coudurier
        }
2321 cefe0607 Michael Niedermayer
        {
2322 fd0368e7 Aurelien Jacobs
            int64_t last = st->info->last_dts;
2323 3c150d16 Michael Niedermayer
            int64_t duration= pkt->dts - last;
2324
2325
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2326 4d43cbcc Michael Niedermayer
                double dur= duration * av_q2d(st->time_base);
2327
2328 72415b2a Stefano Sabatini
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2329 4d43cbcc Michael Niedermayer
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2330 fd0368e7 Aurelien Jacobs
                if (st->info->duration_count < 2)
2331
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2332
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2333 69c262d1 Michael Niedermayer
                    int framerate= get_std_framerate(i);
2334
                    int ticks= lrintf(dur*framerate/(1001*12));
2335
                    double error= dur - ticks*1001*12/(double)framerate;
2336 fd0368e7 Aurelien Jacobs
                    st->info->duration_error[i] += error*error;
2337 69c262d1 Michael Niedermayer
                }
2338 fd0368e7 Aurelien Jacobs
                st->info->duration_count++;
2339 85142724 Reimar Döffinger
                // ignore the first 4 values, they might have some random jitter
2340 fd0368e7 Aurelien Jacobs
                if (st->info->duration_count > 3)
2341
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2342 15bc38e5 Michael Niedermayer
            }
2343 fd0368e7 Aurelien Jacobs
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2344
                st->info->last_dts = pkt->dts;
2345 15bc38e5 Michael Niedermayer
        }
2346 01f4895c Michael Niedermayer
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2347
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2348 90ad92b3 Michael Niedermayer
            if(i){
2349 01f4895c Michael Niedermayer
                st->codec->extradata_size= i;
2350 62c52121 Måns Rullgård
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2351 01f4895c Michael Niedermayer
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2352 62c52121 Måns Rullgård
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2353 90ad92b3 Michael Niedermayer
            }
2354
        }
2355 115329f1 Diego Biurrun
2356 fb2758c8 Fabrice Bellard
        /* if still no information, we try to open the codec and to
2357
           decompress the frame. We try to avoid that in most cases as
2358 a85736f2 Diego Biurrun
           it takes longer and uses more memory. For MPEG-4, we need to
2359
           decompress for QuickTime. */
2360 ae447836 Baptiste Coudurier
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2361 655d47c2 Thilo Borgmann
            try_decode_frame(st, pkt);
2362 115329f1 Diego Biurrun
2363 9d3fdf20 Baptiste Coudurier
        st->codec_info_nb_frames++;
2364 b9a281db Fabrice Bellard
        count++;
2365
    }
2366
2367 bd107136 Diego Biurrun
    // close codecs which were opened in try_decode_frame()
2368 43c0040a Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
2369
        st = ic->streams[i];
2370 01f4895c Michael Niedermayer
        if(st->codec->codec)
2371
            avcodec_close(st->codec);
2372 43c0040a Michael Niedermayer
    }
2373 b9a281db Fabrice Bellard
    for(i=0;i<ic->nb_streams;i++) {
2374
        st = ic->streams[i];
2375 fd0368e7 Aurelien Jacobs
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2376 02b398ef Michael Niedermayer
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2377 6c6e6ef5 Michael Niedermayer
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2378 fd0368e7 Aurelien Jacobs
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2379 72415b2a Stefano Sabatini
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2380 dd1c8f3e Luca Abeni
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2381 01f4895c Michael Niedermayer
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2382 15bc38e5 Michael Niedermayer
2383 85142724 Reimar Döffinger
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2384
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2385
            // ipmovie.c produces.
2386 fd0368e7 Aurelien Jacobs
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2387
                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);
2388
            if (st->info->duration_count && !st->r_frame_rate.num
2389 945208ca Michael Niedermayer
               && tb_unreliable(st->codec) /*&&
2390 a85736f2 Diego Biurrun
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2391 fd0368e7 Aurelien Jacobs
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2392 fe02d9e7 Reimar Döffinger
                int num = 0;
2393 4d43cbcc Michael Niedermayer
                double best_error= 2*av_q2d(st->time_base);
2394 fd0368e7 Aurelien Jacobs
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2395 4d43cbcc Michael Niedermayer
2396 fd0368e7 Aurelien Jacobs
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2397
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2398 72415b2a Stefano Sabatini
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2399 4d43cbcc Michael Niedermayer
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2400 9f75260e Michael Niedermayer
                    if(error < best_error){
2401
                        best_error= error;
2402 fe02d9e7 Reimar Döffinger
                        num = get_std_framerate(j);
2403 9f75260e Michael Niedermayer
                    }
2404 3c150d16 Michael Niedermayer
                }
2405 fe02d9e7 Reimar Döffinger
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2406
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2407
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2408 15bc38e5 Michael Niedermayer
            }
2409
2410 c0df9d75 Michael Niedermayer
            if (!st->r_frame_rate.num){
2411 5523d5f4 Michael Niedermayer
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2412 3797c74b Michael Niedermayer
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2413 5523d5f4 Michael Niedermayer
                    st->r_frame_rate.num = st->codec->time_base.den;
2414 3797c74b Michael Niedermayer
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2415 5523d5f4 Michael Niedermayer
                }else{
2416
                    st->r_frame_rate.num = st->time_base.den;
2417
                    st->r_frame_rate.den = st->time_base.num;
2418
                }
2419 14bea432 Michael Niedermayer
            }
2420 72415b2a Stefano Sabatini
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2421 dd1c8f3e Luca Abeni
            if(!st->codec->bits_per_coded_sample)
2422
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2423 b9a281db Fabrice Bellard
        }
2424 de6d9b64 Fabrice Bellard
    }
2425 b9a281db Fabrice Bellard
2426 9ecf7fad Wolfram Gloger
    av_estimate_timings(ic, old_offset);
2427 6fea687e John Donaghy
2428 c2c3dedf Aurelien Jacobs
    compute_chapters_end(ic);
2429
2430 e928649b Michael Niedermayer
#if 0
2431 a85736f2 Diego Biurrun
    /* correct DTS for B-frame streams with no timestamps */
2432 e928649b Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
2433
        st = ic->streams[i];
2434 72415b2a Stefano Sabatini
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2435 e928649b Michael Niedermayer
            if(b-frames){
2436
                ppktl = &ic->packet_buffer;
2437
                while(ppkt1){
2438
                    if(ppkt1->stream_index != i)
2439
                        continue;
2440
                    if(ppkt1->pkt->dts < 0)
2441
                        break;
2442
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2443
                        break;
2444
                    ppkt1->pkt->dts -= delta;
2445
                    ppkt1= ppkt1->next;
2446
                }
2447
                if(ppkt1)
2448
                    continue;
2449
                st->cur_dts -= delta;
2450
            }
2451
        }
2452
    }
2453
#endif
2454 0cbff027 Kristian Amlie
2455 fd0368e7 Aurelien Jacobs
 find_stream_info_err:
2456
    for (i=0; i < ic->nb_streams; i++)
2457
        av_freep(&ic->streams[i]->info);
2458 b9a281db Fabrice Bellard
    return ret;
2459 de6d9b64 Fabrice Bellard
}
2460
2461 9128ae08 Nicolas George
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2462
{
2463
    int i, j;
2464
2465
    for (i = 0; i < ic->nb_programs; i++)
2466
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2467
            if (ic->programs[i]->stream_index[j] == s)
2468
                return ic->programs[i];
2469
    return NULL;
2470
}
2471
2472
int av_find_best_stream(AVFormatContext *ic,
2473
                        enum AVMediaType type,
2474
                        int wanted_stream_nb,
2475
                        int related_stream,
2476
                        AVCodec **decoder_ret,
2477
                        int flags)
2478
{
2479
    int i, nb_streams = ic->nb_streams, stream_number = 0;
2480
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2481
    unsigned *program = NULL;
2482
    AVCodec *decoder = NULL, *best_decoder = NULL;
2483
2484
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2485
        AVProgram *p = find_program_from_stream(ic, related_stream);
2486
        if (p) {
2487
            program = p->stream_index;
2488
            nb_streams = p->nb_stream_indexes;
2489
        }
2490
    }
2491
    for (i = 0; i < nb_streams; i++) {
2492
        AVStream *st = ic->streams[program ? program[i] : i];
2493
        AVCodecContext *avctx = st->codec;
2494
        if (avctx->codec_type != type)
2495
            continue;
2496
        if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2497
            continue;
2498
        if (decoder_ret) {
2499
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2500
            if (!decoder) {
2501
                if (ret < 0)
2502
                    ret = AVERROR_DECODER_NOT_FOUND;
2503
                continue;
2504
            }
2505
        }
2506
        if (best_count >= st->codec_info_nb_frames)
2507
            continue;
2508
        best_count = st->codec_info_nb_frames;
2509
        ret = i;
2510
        best_decoder = decoder;
2511
        if (program && i == nb_streams - 1 && ret < 0) {
2512
            program = NULL;
2513
            nb_streams = ic->nb_streams;
2514
            i = 0; /* no related stream found, try again with everything */
2515
        }
2516
    }
2517
    if (decoder_ret)
2518
        *decoder_ret = best_decoder;
2519
    return ret;
2520
}
2521
2522 fb2758c8 Fabrice Bellard
/*******************************************************/
2523
2524
int av_read_play(AVFormatContext *s)
2525
{
2526 fa13095a Björn Axelsson
    if (s->iformat->read_play)
2527
        return s->iformat->read_play(s);
2528 fd2982a0 Aurelien Jacobs
    if (s->pb)
2529 502bdf68 Michael Niedermayer
        return av_url_read_fpause(s->pb, 0);
2530 fa13095a Björn Axelsson
    return AVERROR(ENOSYS);
2531 fb2758c8 Fabrice Bellard
}
2532
2533
int av_read_pause(AVFormatContext *s)
2534
{
2535 fa13095a Björn Axelsson
    if (s->iformat->read_pause)
2536
        return s->iformat->read_pause(s);
2537 fd2982a0 Aurelien Jacobs
    if (s->pb)
2538 502bdf68 Michael Niedermayer
        return av_url_read_fpause(s->pb, 1);
2539 fa13095a Björn Axelsson
    return AVERROR(ENOSYS);
2540 fb2758c8 Fabrice Bellard
}
2541
2542 2506fd54 Reimar Döffinger
void av_close_input_stream(AVFormatContext *s)
2543 de6d9b64 Fabrice Bellard
{
2544 ca75a923 Reimar Döffinger
    int i;
2545 da24c5e3 Fabrice Bellard
    AVStream *st;
2546 de6d9b64 Fabrice Bellard
2547 81bd4119 Stefano Sabatini
    flush_packet_queue(s);
2548 b9a281db Fabrice Bellard
    if (s->iformat->read_close)
2549
        s->iformat->read_close(s);
2550 de6d9b64 Fabrice Bellard
    for(i=0;i<s->nb_streams;i++) {
2551 da24c5e3 Fabrice Bellard
        /* free all data in a stream component */
2552
        st = s->streams[i];
2553 fb2758c8 Fabrice Bellard
        if (st->parser) {
2554
            av_parser_close(st->parser);
2555 3a41c2f7 Michael Niedermayer
            av_free_packet(&st->cur_pkt);
2556 de6d9b64 Fabrice Bellard
        }
2557 094d9df7 Aurelien Jacobs
        av_metadata_free(&st->metadata);
2558 fb2758c8 Fabrice Bellard
        av_free(st->index_entries);
2559 a5e9102b Måns Rullgård
        av_free(st->codec->extradata);
2560 cb2c971d Aurelien Jacobs
        av_free(st->codec->subtitle_header);
2561 01f4895c Michael Niedermayer
        av_free(st->codec);
2562 54036be1 Aurelien Jacobs
#if FF_API_OLD_METADATA
2563 f8d7c9d3 Evgeniy Stepanov
        av_free(st->filename);
2564 827f7e28 Aurelien Jacobs
#endif
2565 ade8d8b9 Baptiste Coudurier
        av_free(st->priv_data);
2566 fd0368e7 Aurelien Jacobs
        av_free(st->info);
2567 fb2758c8 Fabrice Bellard
        av_free(st);
2568 de6d9b64 Fabrice Bellard
    }
2569 15afa396 Nico Sabbi
    for(i=s->nb_programs-1; i>=0; i--) {
2570 54036be1 Aurelien Jacobs
#if FF_API_OLD_METADATA
2571 15afa396 Nico Sabbi
        av_freep(&s->programs[i]->provider_name);
2572
        av_freep(&s->programs[i]->name);
2573 827f7e28 Aurelien Jacobs
#endif
2574 094d9df7 Aurelien Jacobs
        av_metadata_free(&s->programs[i]->metadata);
2575 526efa10 Nico Sabbi
        av_freep(&s->programs[i]->stream_index);
2576 15afa396 Nico Sabbi
        av_freep(&s->programs[i]);
2577
    }
2578 ceedda75 Michael Niedermayer
    av_freep(&s->programs);
2579 a8dbe951 Philip Gladstone
    av_freep(&s->priv_data);
2580 7c8202cc Michael Niedermayer
    while(s->nb_chapters--) {
2581 54036be1 Aurelien Jacobs
#if FF_API_OLD_METADATA
2582 7c8202cc Michael Niedermayer
        av_free(s->chapters[s->nb_chapters]->title);
2583 827f7e28 Aurelien Jacobs
#endif
2584 094d9df7 Aurelien Jacobs
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2585 7c8202cc Michael Niedermayer
        av_free(s->chapters[s->nb_chapters]);
2586 79d7836a Anton Khirnov
    }
2587
    av_freep(&s->chapters);
2588 094d9df7 Aurelien Jacobs
    av_metadata_free(&s->metadata);
2589 668338c5 Måns Rullgård
    av_freep(&s->key);
2590 1ea4f593 Fabrice Bellard
    av_free(s);
2591 de6d9b64 Fabrice Bellard
}
2592
2593 2506fd54 Reimar Döffinger
void av_close_input_file(AVFormatContext *s)
2594
{
2595
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2596
    av_close_input_stream(s);
2597
    if (pb)
2598
        url_fclose(pb);
2599
}
2600
2601 b9a281db Fabrice Bellard
AVStream *av_new_stream(AVFormatContext *s, int id)
2602
{
2603
    AVStream *st;
2604 504ee036 Michael Niedermayer
    int i;
2605 61138c43 Aurelien Jacobs
2606
#if FF_API_MAX_STREAMS
2607
    if (s->nb_streams >= MAX_STREAMS){
2608
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2609
        return NULL;
2610
    }
2611
#else
2612 38aab35f Aurelien Jacobs
    AVStream **streams;
2613 b9a281db Fabrice Bellard
2614 38aab35f Aurelien Jacobs
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2615
        return NULL;
2616
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2617
    if (!streams)
2618
        return NULL;
2619
    s->streams = streams;
2620
#endif
2621 b9a281db Fabrice Bellard
2622
    st = av_mallocz(sizeof(AVStream));
2623
    if (!st)
2624
        return NULL;
2625 fd0368e7 Aurelien Jacobs
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2626
        av_free(st);
2627
        return NULL;
2628
    }
2629 115329f1 Diego Biurrun
2630 01f4895c Michael Niedermayer
    st->codec= avcodec_alloc_context();
2631 48091512 Fabrice Bellard
    if (s->iformat) {
2632
        /* no default bitrate if decoding */
2633 01f4895c Michael Niedermayer
        st->codec->bit_rate = 0;
2634 48091512 Fabrice Bellard
    }
2635 b9a281db Fabrice Bellard
    st->index = s->nb_streams;
2636
    st->id = id;
2637 12f996ed Fabrice Bellard
    st->start_time = AV_NOPTS_VALUE;
2638
    st->duration = AV_NOPTS_VALUE;
2639 6d77d9ac Michael Niedermayer
        /* we set the current DTS to 0 so that formats without any timestamps
2640
           but durations get some timestamps, formats with some unknown
2641
           timestamps have their first few packets buffered and the
2642
           timestamps corrected before they are returned to the user */
2643
    st->cur_dts = 0;
2644 82583548 Michael Niedermayer
    st->first_dts = AV_NOPTS_VALUE;
2645 86cb7e33 Baptiste Coudurier
    st->probe_packets = MAX_PROBE_PACKETS;
2646 9ee91c2f Michael Niedermayer
2647 a85736f2 Diego Biurrun
    /* default pts setting is MPEG-like */
2648 9ee91c2f Michael Niedermayer
    av_set_pts_info(st, 33, 1, 90000);
2649 635fbcb1 Michael Niedermayer
    st->last_IP_pts = AV_NOPTS_VALUE;
2650 504ee036 Michael Niedermayer
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2651
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2652 27ca0a79 Ivan Schreter
    st->reference_dts = AV_NOPTS_VALUE;
2653 9ee91c2f Michael Niedermayer
2654 c30a4489 Aurelien Jacobs
    st->sample_aspect_ratio = (AVRational){0,1};
2655
2656 b9a281db Fabrice Bellard
    s->streams[s->nb_streams++] = st;
2657
    return st;
2658
}
2659
2660 15afa396 Nico Sabbi
AVProgram *av_new_program(AVFormatContext *ac, int id)
2661
{
2662
    AVProgram *program=NULL;
2663
    int i;
2664
2665
#ifdef DEBUG_SI
2666
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2667
#endif
2668
2669
    for(i=0; i<ac->nb_programs; i++)
2670
        if(ac->programs[i]->id == id)
2671
            program = ac->programs[i];
2672
2673
    if(!program){
2674
        program = av_mallocz(sizeof(AVProgram));
2675
        if (!program)
2676
            return NULL;
2677
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2678
        program->discard = AVDISCARD_NONE;
2679
    }
2680
    program->id = id;
2681
2682
    return program;
2683
}
2684
2685 abd2256d Michael Niedermayer
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2686 79d7836a Anton Khirnov
{
2687 7a2a3e8e Michael Niedermayer
    AVChapter *chapter = NULL;
2688
    int i;
2689
2690 7c8202cc Michael Niedermayer
    for(i=0; i<s->nb_chapters; i++)
2691 7a2a3e8e Michael Niedermayer
        if(s->chapters[i]->id == id)
2692
            chapter = s->chapters[i];
2693
2694
    if(!chapter){
2695
        chapter= av_mallocz(sizeof(AVChapter));
2696 6b43e2c7 Michael Niedermayer
        if(!chapter)
2697 5c37f43a Michael Niedermayer
            return NULL;
2698 7c8202cc Michael Niedermayer
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2699 7a2a3e8e Michael Niedermayer
    }
2700 54036be1 Aurelien Jacobs
#if FF_API_OLD_METADATA
2701 ebea1d76 Aurelien Jacobs
    av_free(chapter->title);
2702 827f7e28 Aurelien Jacobs
#endif
2703 2ef6c124 Stefano Sabatini
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2704 7a2a3e8e Michael Niedermayer
    chapter->id    = id;
2705 abd2256d Michael Niedermayer
    chapter->time_base= time_base;
2706 79d7836a Anton Khirnov
    chapter->start = start;
2707 747fb6c6 Michael Niedermayer