Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ e63a3628

History | View | Annotate | Download (121 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 471fe57e Anton Khirnov
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
327 2692067a Michael Niedermayer
{
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 e63a3628 Anton Khirnov
    ret= avio_read(s, pkt->data, size);
336 2692067a Michael Niedermayer
    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 471fe57e Anton Khirnov
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
345 6bfc2683 Reimar Döffinger
{
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 e63a3628 Anton Khirnov
    ret = avio_read(s, pkt->data + old_size, size);
355 6bfc2683 Reimar Döffinger
    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 471fe57e Anton Khirnov
                         AVIOContext *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 471fe57e Anton Khirnov
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
483 6612d8cf Reimar Döffinger
    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 471fe57e Anton Khirnov
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
528 eadd495d Micah F. Galizia
                          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 e63a3628 Anton Khirnov
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
559 eadd495d Micah F. Galizia
            /* 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 e74c01db Anssi Hannula
    if ((ret = ff_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
589 01d91b9b Tomas Härdin
        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 471fe57e Anton Khirnov
    AVIOContext *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 070e5ba5 Anssi Hannula
        if (!fmt && (err = av_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 b38f008e Alexander Strange
934
    // ignore delay caused by frame threading so that the mpeg2-without-dts
935
    // warning will not trigger
936
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
937
        delay -= st->codec->thread_count-1;
938
939 f781f748 Michael Niedermayer
    /* XXX: need has_b_frame, but cannot get it if the codec is
940
        not initialized */
941
    if (delay &&
942
        pc && pc->pict_type != FF_B_TYPE)
943
        presentation_delayed = 1;
944
945 10a7571b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
946
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
947
        pkt->dts -= 1LL<<st->pts_wrap_bits;
948
    }
949
950 9806f846 Michael Niedermayer
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
951
    // we take the conservative approach and discard both
952
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
953
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
954 b0a18c2f XBMC
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
955 9806f846 Michael Niedermayer
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
956
    }
957
958 fb2758c8 Fabrice Bellard
    if (pkt->duration == 0) {
959 3c895fc0 Michael Niedermayer
        compute_frame_duration(&num, &den, st, pc, pkt);
960 fb2758c8 Fabrice Bellard
        if (den && num) {
961 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);
962 83a9db42 Michael Niedermayer
963 820ad60c Michael Niedermayer
            if(pkt->duration != 0 && s->packet_buffer)
964 83a9db42 Michael Niedermayer
                update_initial_durations(s, st, pkt);
965 fb2758c8 Fabrice Bellard
        }
966
    }
967
968 a85736f2 Diego Biurrun
    /* correct timestamps with byte offset if demuxers only have timestamps
969
       on packet boundaries */
970 a74008a4 Joakim Plate
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
971
        /* this will estimate bitrate based on this frame's duration and size */
972
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
973
        if(pkt->pts != AV_NOPTS_VALUE)
974
            pkt->pts += offset;
975
        if(pkt->dts != AV_NOPTS_VALUE)
976
            pkt->dts += offset;
977
    }
978
979 27ca0a79 Ivan Schreter
    if (pc && pc->dts_sync_point >= 0) {
980
        // we have synchronization info from the parser
981
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
982
        if (den > 0) {
983
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
984
            if (pkt->dts != AV_NOPTS_VALUE) {
985
                // got DTS from the stream, update reference timestamp
986
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
987
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
988
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
989
                // compute DTS based on reference timestamp
990
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
991
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
992
            }
993
            if (pc->dts_sync_point > 0)
994
                st->reference_dts = pkt->dts; // new reference
995
        }
996
    }
997
998 755bfeab Diego Biurrun
    /* This may be redundant, but it should not hurt. */
999 7e4baa66 Michael Niedermayer
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1000
        presentation_delayed = 1;
1001 115329f1 Diego Biurrun
1002 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);
1003 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
1004 9e6c124a Michael Niedermayer
    //We skip H264 currently because delay and has_b_frames are not reliably set
1005
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1006 7e4baa66 Michael Niedermayer
        if (presentation_delayed) {
1007 a85736f2 Diego Biurrun
            /* DTS = decompression timestamp */
1008
            /* PTS = presentation timestamp */
1009 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
1010 635fbcb1 Michael Niedermayer
                pkt->dts = st->last_IP_pts;
1011 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1012 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
1013
                pkt->dts = st->cur_dts;
1014
1015
            /* this is tricky: the dts must be incremented by the duration
1016 a85736f2 Diego Biurrun
            of the frame we are displaying, i.e. the last I- or P-frame */
1017 635fbcb1 Michael Niedermayer
            if (st->last_IP_duration == 0)
1018
                st->last_IP_duration = pkt->duration;
1019 7efeb73a Michael Niedermayer
            if(pkt->dts != AV_NOPTS_VALUE)
1020 cdb5af79 Michael Niedermayer
                st->cur_dts = pkt->dts + st->last_IP_duration;
1021 635fbcb1 Michael Niedermayer
            st->last_IP_duration  = pkt->duration;
1022
            st->last_IP_pts= pkt->pts;
1023 7e4baa66 Michael Niedermayer
            /* cannot compute PTS if not present (we can compute it only
1024 a85736f2 Diego Biurrun
            by knowing the future */
1025 028d6f3e Michael Niedermayer
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1026 7e4baa66 Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1027
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1028
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1029
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1030
                    pkt->pts += pkt->duration;
1031
    //                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);
1032
                }
1033 90bb394d Michael Niedermayer
            }
1034 115329f1 Diego Biurrun
1035 7e4baa66 Michael Niedermayer
            /* presentation is not delayed : PTS and DTS are the same */
1036
            if(pkt->pts == AV_NOPTS_VALUE)
1037
                pkt->pts = pkt->dts;
1038 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1039 7e4baa66 Michael Niedermayer
            if(pkt->pts == AV_NOPTS_VALUE)
1040
                pkt->pts = st->cur_dts;
1041
            pkt->dts = pkt->pts;
1042 7efeb73a Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE)
1043 cdb5af79 Michael Niedermayer
                st->cur_dts = pkt->pts + pkt->duration;
1044 7e4baa66 Michael Niedermayer
        }
1045 fb2758c8 Fabrice Bellard
    }
1046 d9e1efb7 Michael Niedermayer
1047 cb5b96cd Baptiste Coudurier
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1048 d9e1efb7 Michael Niedermayer
        st->pts_buffer[0]= pkt->pts;
1049
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1050
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1051
        if(pkt->dts == AV_NOPTS_VALUE)
1052
            pkt->dts= st->pts_buffer[0];
1053 9e6c124a Michael Niedermayer
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1054 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1055 82583548 Michael Niedermayer
        }
1056 d9e1efb7 Michael Niedermayer
        if(pkt->dts > st->cur_dts)
1057
            st->cur_dts = pkt->dts;
1058
    }
1059
1060
//    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);
1061 115329f1 Diego Biurrun
1062 fb2758c8 Fabrice Bellard
    /* update flags */
1063 3a1d3588 Jeff Downs
    if(is_intra_only(st->codec))
1064 cc947f04 Jean-Daniel Dupas
        pkt->flags |= AV_PKT_FLAG_KEY;
1065 3a1d3588 Jeff Downs
    else if (pc) {
1066 fb2758c8 Fabrice Bellard
        pkt->flags = 0;
1067 a85736f2 Diego Biurrun
        /* keyframe computation */
1068 6363af44 Ivan Schreter
        if (pc->key_frame == 1)
1069 cc947f04 Jean-Daniel Dupas
            pkt->flags |= AV_PKT_FLAG_KEY;
1070 6363af44 Ivan Schreter
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1071 cc947f04 Jean-Daniel Dupas
            pkt->flags |= AV_PKT_FLAG_KEY;
1072 fb2758c8 Fabrice Bellard
    }
1073 b1fa4942 Ivan Schreter
    if (pc)
1074
        pkt->convergence_duration = pc->convergence_duration;
1075 fb2758c8 Fabrice Bellard
}
1076
1077
1078
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1079
{
1080
    AVStream *st;
1081 37353960 Fabrice Bellard
    int len, ret, i;
1082 fb2758c8 Fabrice Bellard
1083 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
1084
1085 fb2758c8 Fabrice Bellard
    for(;;) {
1086
        /* select current input stream component */
1087
        st = s->cur_st;
1088
        if (st) {
1089 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
1090 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
1091
                /* raw data support */
1092 3a41c2f7 Michael Niedermayer
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1093 fb2758c8 Fabrice Bellard
                compute_pkt_fields(s, st, NULL, pkt);
1094
                s->cur_st = NULL;
1095 74f5ae84 Reimar Döffinger
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1096 cc947f04 Jean-Daniel Dupas
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1097 74f5ae84 Reimar Döffinger
                    ff_reduce_index(s, st->index);
1098
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1099
                }
1100 434cab9e Michael Niedermayer
                break;
1101 3a41c2f7 Michael Niedermayer
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1102 61c23c15 Ivan Schreter
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1103
                                       st->cur_ptr, st->cur_len,
1104
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1105
                                       st->cur_pkt.pos);
1106 3a41c2f7 Michael Niedermayer
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1107
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1108 fb2758c8 Fabrice Bellard
                /* increment read pointer */
1109 3a41c2f7 Michael Niedermayer
                st->cur_ptr += len;
1110
                st->cur_len -= len;
1111 115329f1 Diego Biurrun
1112 fb2758c8 Fabrice Bellard
                /* return packet if any */
1113
                if (pkt->size) {
1114 37353960 Fabrice Bellard
                got_packet:
1115 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
1116
                    pkt->stream_index = st->index;
1117 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
1118
                    pkt->dts = st->parser->dts;
1119 61c23c15 Ivan Schreter
                    pkt->pos = st->parser->pos;
1120 a5266a47 Michael Niedermayer
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1121
                        s->cur_st = NULL;
1122
                        pkt->destruct= st->cur_pkt.destruct;
1123 22d78b05 Eli Friedman
                        st->cur_pkt.destruct= NULL;
1124 a5266a47 Michael Niedermayer
                        st->cur_pkt.data    = NULL;
1125
                        assert(st->cur_len == 0);
1126
                    }else{
1127 80d403fc Reimar Döffinger
                    pkt->destruct = NULL;
1128 a5266a47 Michael Niedermayer
                    }
1129 fb2758c8 Fabrice Bellard
                    compute_pkt_fields(s, st, st->parser, pkt);
1130 e9b78eeb Michael Niedermayer
1131 cc947f04 Jean-Daniel Dupas
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1132 3dea63bd Paul Kelly
                        ff_reduce_index(s, st->index);
1133 e9b78eeb Michael Niedermayer
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1134
                                           0, 0, AVINDEX_KEYFRAME);
1135
                    }
1136
1137 434cab9e Michael Niedermayer
                    break;
1138 fb2758c8 Fabrice Bellard
                }
1139
            } else {
1140 bcbecff1 Fabrice Bellard
                /* free packet */
1141 3a41c2f7 Michael Niedermayer
                av_free_packet(&st->cur_pkt);
1142 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
1143
            }
1144
        } else {
1145 3a41c2f7 Michael Niedermayer
            AVPacket cur_pkt;
1146 fb2758c8 Fabrice Bellard
            /* read next packet */
1147 3a41c2f7 Michael Niedermayer
            ret = av_read_packet(s, &cur_pkt);
1148 37353960 Fabrice Bellard
            if (ret < 0) {
1149 8fa36ae0 François Revol
                if (ret == AVERROR(EAGAIN))
1150 37353960 Fabrice Bellard
                    return ret;
1151
                /* return the last frames, if any */
1152
                for(i = 0; i < s->nb_streams; i++) {
1153
                    st = s->streams[i];
1154 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
1155 61c23c15 Ivan Schreter
                        av_parser_parse2(st->parser, st->codec,
1156 115329f1 Diego Biurrun
                                        &pkt->data, &pkt->size,
1157
                                        NULL, 0,
1158 61c23c15 Ivan Schreter
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1159
                                        AV_NOPTS_VALUE);
1160 37353960 Fabrice Bellard
                        if (pkt->size)
1161
                            goto got_packet;
1162
                    }
1163
                }
1164 a85736f2 Diego Biurrun
                /* no more packets: really terminate parsing */
1165 fb2758c8 Fabrice Bellard
                return ret;
1166 37353960 Fabrice Bellard
            }
1167 3a41c2f7 Michael Niedermayer
            st = s->streams[cur_pkt.stream_index];
1168
            st->cur_pkt= cur_pkt;
1169 115329f1 Diego Biurrun
1170 3a41c2f7 Michael Niedermayer
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1171
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1172
               st->cur_pkt.pts < st->cur_pkt.dts){
1173 b18a4ab2 Michael Niedermayer
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1174 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.stream_index,
1175
                    st->cur_pkt.pts,
1176
                    st->cur_pkt.dts,
1177
                    st->cur_pkt.size);
1178
//                av_free_packet(&st->cur_pkt);
1179 b18a4ab2 Michael Niedermayer
//                return -1;
1180
            }
1181
1182 45b2b05f Michael Niedermayer
            if(s->debug & FF_FDEBUG_TS)
1183 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",
1184 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.stream_index,
1185
                    st->cur_pkt.pts,
1186
                    st->cur_pkt.dts,
1187
                    st->cur_pkt.size,
1188 050ba6f4 Baptiste Coudurier
                    st->cur_pkt.duration,
1189 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.flags);
1190 fb2758c8 Fabrice Bellard
1191
            s->cur_st = st;
1192 3a41c2f7 Michael Niedermayer
            st->cur_ptr = st->cur_pkt.data;
1193
            st->cur_len = st->cur_pkt.size;
1194 fe8344a2 Michael Niedermayer
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1195 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
1196 fb2758c8 Fabrice Bellard
                if (!st->parser) {
1197 a85736f2 Diego Biurrun
                    /* no parser available: just output the raw packets */
1198 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1199
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1200 7cbaa7ba Michael Niedermayer
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1201 74a6df59 Alex Converse
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1202
                    st->parser->flags |= PARSER_FLAG_ONCE;
1203 fb2758c8 Fabrice Bellard
                }
1204
            }
1205
        }
1206
    }
1207 45b2b05f Michael Niedermayer
    if(s->debug & FF_FDEBUG_TS)
1208 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",
1209 434cab9e Michael Niedermayer
            pkt->stream_index,
1210
            pkt->pts,
1211
            pkt->dts,
1212 3041a4a1 Michael Niedermayer
            pkt->size,
1213 050ba6f4 Baptiste Coudurier
            pkt->duration,
1214 3041a4a1 Michael Niedermayer
            pkt->flags);
1215 434cab9e Michael Niedermayer
1216
    return 0;
1217 fb2758c8 Fabrice Bellard
}
1218
1219
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1220
{
1221 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
1222 30bc6613 Michael Niedermayer
    int eof=0;
1223
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1224
1225
    for(;;){
1226
        pktl = s->packet_buffer;
1227
        if (pktl) {
1228
            AVPacket *next_pkt= &pktl->pkt;
1229
1230
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1231 5be5d28c Stephen Dredge
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1232 30bc6613 Michael Niedermayer
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1233 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1234 5be5d28c Stephen Dredge
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1235
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1236 30bc6613 Michael Niedermayer
                        next_pkt->pts= pktl->pkt.dts;
1237
                    }
1238
                    pktl= pktl->next;
1239
                }
1240
                pktl = s->packet_buffer;
1241
            }
1242 115329f1 Diego Biurrun
1243
            if(   next_pkt->pts != AV_NOPTS_VALUE
1244
               || next_pkt->dts == AV_NOPTS_VALUE
1245 30bc6613 Michael Niedermayer
               || !genpts || eof){
1246
                /* read packet from packet buffer, if there is data */
1247
                *pkt = *next_pkt;
1248
                s->packet_buffer = pktl->next;
1249
                av_free(pktl);
1250
                return 0;
1251
            }
1252
        }
1253
        if(genpts){
1254
            int ret= av_read_frame_internal(s, pkt);
1255
            if(ret<0){
1256 8fa36ae0 François Revol
                if(pktl && ret != AVERROR(EAGAIN)){
1257 30bc6613 Michael Niedermayer
                    eof=1;
1258
                    continue;
1259
                }else
1260
                    return ret;
1261
            }
1262 115329f1 Diego Biurrun
1263 5c5b1731 Måns Rullgård
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1264
                                           &s->packet_buffer_end)) < 0)
1265 769e10f0 Panagiotis Issaris
                return AVERROR(ENOMEM);
1266 30bc6613 Michael Niedermayer
        }else{
1267
            assert(!s->packet_buffer);
1268
            return av_read_frame_internal(s, pkt);
1269
        }
1270 fb2758c8 Fabrice Bellard
    }
1271
}
1272
1273
/* XXX: suppress the packet queue */
1274
static void flush_packet_queue(AVFormatContext *s)
1275
{
1276
    AVPacketList *pktl;
1277
1278
    for(;;) {
1279
        pktl = s->packet_buffer;
1280 115329f1 Diego Biurrun
        if (!pktl)
1281 fb2758c8 Fabrice Bellard
            break;
1282
        s->packet_buffer = pktl->next;
1283
        av_free_packet(&pktl->pkt);
1284
        av_free(pktl);
1285 b9a281db Fabrice Bellard
    }
1286 86cb7e33 Baptiste Coudurier
    while(s->raw_packet_buffer){
1287
        pktl = s->raw_packet_buffer;
1288
        s->raw_packet_buffer = pktl->next;
1289
        av_free_packet(&pktl->pkt);
1290
        av_free(pktl);
1291
    }
1292 42831b46 Michael Niedermayer
    s->packet_buffer_end=
1293
    s->raw_packet_buffer_end= NULL;
1294 af122d6a Baptiste Coudurier
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1295 b9a281db Fabrice Bellard
}
1296
1297 da24c5e3 Fabrice Bellard
/*******************************************************/
1298 fb2758c8 Fabrice Bellard
/* seek support */
1299
1300 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
1301
{
1302 ca162a50 Aurelien Jacobs
    int first_audio_index = -1;
1303 b754978a Michael Niedermayer
    int i;
1304
    AVStream *st;
1305
1306
    if (s->nb_streams <= 0)
1307
        return -1;
1308
    for(i = 0; i < s->nb_streams; i++) {
1309
        st = s->streams[i];
1310 72415b2a Stefano Sabatini
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1311 b754978a Michael Niedermayer
            return i;
1312
        }
1313 72415b2a Stefano Sabatini
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1314 ca162a50 Aurelien Jacobs
            first_audio_index = i;
1315 b754978a Michael Niedermayer
    }
1316 ca162a50 Aurelien Jacobs
    return first_audio_index >= 0 ? first_audio_index : 0;
1317 b754978a Michael Niedermayer
}
1318
1319 e36bdf8b Daniel Kristjansson
/**
1320
 * Flush the frame reader.
1321
 */
1322 972ffe62 Aurelien Jacobs
void ff_read_frame_flush(AVFormatContext *s)
1323 fb2758c8 Fabrice Bellard
{
1324
    AVStream *st;
1325 106fa129 John Stebbins
    int i, j;
1326 fb2758c8 Fabrice Bellard
1327
    flush_packet_queue(s);
1328
1329 3a41c2f7 Michael Niedermayer
    s->cur_st = NULL;
1330 115329f1 Diego Biurrun
1331 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
1332
    for(i = 0; i < s->nb_streams; i++) {
1333
        st = s->streams[i];
1334 115329f1 Diego Biurrun
1335 fb2758c8 Fabrice Bellard
        if (st->parser) {
1336
            av_parser_close(st->parser);
1337
            st->parser = NULL;
1338 3a41c2f7 Michael Niedermayer
            av_free_packet(&st->cur_pkt);
1339 fb2758c8 Fabrice Bellard
        }
1340 635fbcb1 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
1341 a843d1ff Michael Niedermayer
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1342 27ca0a79 Ivan Schreter
        st->reference_dts = AV_NOPTS_VALUE;
1343 3a41c2f7 Michael Niedermayer
        /* fail safe */
1344
        st->cur_ptr = NULL;
1345
        st->cur_len = 0;
1346 86cb7e33 Baptiste Coudurier
1347
        st->probe_packets = MAX_PROBE_PACKETS;
1348 106fa129 John Stebbins
1349
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1350
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1351 fb2758c8 Fabrice Bellard
    }
1352
}
1353
1354 22ffac70 Reimar Döffinger
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1355 8bcb147f Michael Niedermayer
    int i;
1356
1357
    for(i = 0; i < s->nb_streams; i++) {
1358 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
1359 8bcb147f Michael Niedermayer
1360 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
1361 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1362
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1363 8bcb147f Michael Niedermayer
    }
1364
}
1365
1366 3dea63bd Paul Kelly
void ff_reduce_index(AVFormatContext *s, int stream_index)
1367
{
1368
    AVStream *st= s->streams[stream_index];
1369
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1370
1371
    if((unsigned)st->nb_index_entries >= max_entries){
1372
        int i;
1373
        for(i=0; 2*i<st->nb_index_entries; i++)
1374
            st->index_entries[i]= st->index_entries[2*i];
1375
        st->nb_index_entries= i;
1376
    }
1377
}
1378
1379 2d9fd181 Peter Ross
int ff_add_index_entry(AVIndexEntry **index_entries,
1380
                       int *nb_index_entries,
1381
                       unsigned int *index_entries_allocated_size,
1382
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1383 fb2758c8 Fabrice Bellard
{
1384
    AVIndexEntry *entries, *ie;
1385 b754978a Michael Niedermayer
    int index;
1386 115329f1 Diego Biurrun
1387 2d9fd181 Peter Ross
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1388 568e18b1 Michael Niedermayer
        return -1;
1389 115329f1 Diego Biurrun
1390 2d9fd181 Peter Ross
    entries = av_fast_realloc(*index_entries,
1391
                              index_entries_allocated_size,
1392
                              (*nb_index_entries + 1) *
1393 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1394 568e18b1 Michael Niedermayer
    if(!entries)
1395
        return -1;
1396
1397 2d9fd181 Peter Ross
    *index_entries= entries;
1398 b754978a Michael Niedermayer
1399 2d9fd181 Peter Ross
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1400 b754978a Michael Niedermayer
1401 3ba1438d Michael Niedermayer
    if(index<0){
1402 2d9fd181 Peter Ross
        index= (*nb_index_entries)++;
1403 3e9245a9 Michael Niedermayer
        ie= &entries[index];
1404 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1405
    }else{
1406
        ie= &entries[index];
1407
        if(ie->timestamp != timestamp){
1408 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1409
                return -1;
1410 2d9fd181 Peter Ross
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1411
            (*nb_index_entries)++;
1412 755bfeab Diego Biurrun
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1413 3ba1438d Michael Niedermayer
            distance= ie->min_distance;
1414 3e9245a9 Michael Niedermayer
    }
1415 3ba1438d Michael Niedermayer
1416 b754978a Michael Niedermayer
    ie->pos = pos;
1417
    ie->timestamp = timestamp;
1418 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1419 30a43f2d Michael Niedermayer
    ie->size= size;
1420 b754978a Michael Niedermayer
    ie->flags = flags;
1421 115329f1 Diego Biurrun
1422 3e9245a9 Michael Niedermayer
    return index;
1423 fb2758c8 Fabrice Bellard
}
1424
1425 2d9fd181 Peter Ross
int av_add_index_entry(AVStream *st,
1426
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1427
{
1428
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1429
                              &st->index_entries_allocated_size, pos,
1430
                              timestamp, size, distance, flags);
1431
}
1432
1433
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1434
                              int64_t wanted_timestamp, int flags)
1435 fb2758c8 Fabrice Bellard
{
1436
    int a, b, m;
1437
    int64_t timestamp;
1438
1439 3ba1438d Michael Niedermayer
    a = - 1;
1440
    b = nb_entries;
1441 b754978a Michael Niedermayer
1442 67c10de7 Michael Niedermayer
    //optimize appending index entries at the end
1443
    if(b && entries[b-1].timestamp < wanted_timestamp)
1444
        a= b-1;
1445
1446 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1447
        m = (a + b) >> 1;
1448 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1449 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1450
            b = m;
1451
        if(timestamp <= wanted_timestamp)
1452 b754978a Michael Niedermayer
            a = m;
1453 fb2758c8 Fabrice Bellard
    }
1454 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1455 115329f1 Diego Biurrun
1456 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1457
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1458
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1459
        }
1460
    }
1461 3ba1438d Michael Niedermayer
1462 115329f1 Diego Biurrun
    if(m == nb_entries)
1463 3ba1438d Michael Niedermayer
        return -1;
1464
    return  m;
1465 fb2758c8 Fabrice Bellard
}
1466
1467 2d9fd181 Peter Ross
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1468
                              int flags)
1469
{
1470
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1471
                                     wanted_timestamp, flags);
1472
}
1473
1474 0f652a8e Benoit Fouet
#define DEBUG_SEEK
1475 8d14a25c Michael Niedermayer
1476 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1477 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1478 e6586575 Diego Biurrun
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1479 8d14a25c Michael Niedermayer
    int64_t ts_min, ts_max, ts;
1480 89ddd2a9 Michael Niedermayer
    int index;
1481 b593f7fd Sean Soria
    int64_t ret;
1482 8d14a25c Michael Niedermayer
    AVStream *st;
1483
1484 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1485
        return -1;
1486 115329f1 Diego Biurrun
1487 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1488 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1489 8d14a25c Michael Niedermayer
#endif
1490
1491
    ts_max=
1492
    ts_min= AV_NOPTS_VALUE;
1493 90b5b51e Diego Biurrun
    pos_limit= -1; //gcc falsely says it may be uninitialized
1494 8d14a25c Michael Niedermayer
1495
    st= s->streams[stream_index];
1496
    if(st->index_entries){
1497
        AVIndexEntry *e;
1498
1499 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()
1500 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1501 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1502
1503
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1504
            pos_min= e->pos;
1505
            ts_min= e->timestamp;
1506
#ifdef DEBUG_SEEK
1507 c0492097 Diego Biurrun
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1508
                   pos_min,ts_min);
1509 8d14a25c Michael Niedermayer
#endif
1510
        }else{
1511
            assert(index==0);
1512
        }
1513 115329f1 Diego Biurrun
1514
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1515 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1516
        if(index >= 0){
1517 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1518
            assert(e->timestamp >= target_ts);
1519
            pos_max= e->pos;
1520
            ts_max= e->timestamp;
1521
            pos_limit= pos_max - e->min_distance;
1522
#ifdef DEBUG_SEEK
1523 c0492097 Diego Biurrun
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1524
                   pos_max,pos_limit, ts_max);
1525 8d14a25c Michael Niedermayer
#endif
1526
        }
1527
    }
1528
1529 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);
1530
    if(pos<0)
1531
        return -1;
1532
1533
    /* do the seek */
1534 b593f7fd Sean Soria
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1535
        return ret;
1536 89ddd2a9 Michael Niedermayer
1537
    av_update_cur_dts(s, st, ts);
1538
1539
    return 0;
1540
}
1541
1542
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 )){
1543
    int64_t pos, ts;
1544
    int64_t start_pos, filesize;
1545
    int no_change;
1546
1547
#ifdef DEBUG_SEEK
1548
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1549
#endif
1550
1551 8d14a25c Michael Niedermayer
    if(ts_min == AV_NOPTS_VALUE){
1552
        pos_min = s->data_offset;
1553 89ddd2a9 Michael Niedermayer
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1554 8d14a25c Michael Niedermayer
        if (ts_min == AV_NOPTS_VALUE)
1555
            return -1;
1556
    }
1557
1558
    if(ts_max == AV_NOPTS_VALUE){
1559
        int step= 1024;
1560 899681cd Björn Axelsson
        filesize = url_fsize(s->pb);
1561 6fd93ce2 Kenneth Aafløy
        pos_max = filesize - 1;
1562 8d14a25c Michael Niedermayer
        do{
1563
            pos_max -= step;
1564 89ddd2a9 Michael Niedermayer
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1565 8d14a25c Michael Niedermayer
            step += step;
1566
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1567
        if (ts_max == AV_NOPTS_VALUE)
1568
            return -1;
1569 115329f1 Diego Biurrun
1570 8d14a25c Michael Niedermayer
        for(;;){
1571
            int64_t tmp_pos= pos_max + 1;
1572 89ddd2a9 Michael Niedermayer
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1573 8d14a25c Michael Niedermayer
            if(tmp_ts == AV_NOPTS_VALUE)
1574
                break;
1575
            ts_max= tmp_ts;
1576
            pos_max= tmp_pos;
1577 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1578
                break;
1579 8d14a25c Michael Niedermayer
        }
1580
        pos_limit= pos_max;
1581
    }
1582
1583 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1584
        return -1;
1585
    }else if(ts_min == ts_max){
1586
        pos_limit= pos_min;
1587
    }
1588
1589 8d14a25c Michael Niedermayer
    no_change=0;
1590
    while (pos_min < pos_limit) {
1591
#ifdef DEBUG_SEEK
1592 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1593 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1594
               ts_min, ts_max);
1595
#endif
1596
        assert(pos_limit <= pos_max);
1597
1598
        if(no_change==0){
1599
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1600
            // interpolate position (better than dichotomy)
1601 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1602
                + pos_min - approximate_keyframe_distance;
1603 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1604
            // bisection, if interpolation failed to change min or max pos last time
1605
            pos = (pos_min + pos_limit)>>1;
1606
        }else{
1607 a85736f2 Diego Biurrun
            /* linear search if bisection failed, can only happen if there
1608
               are very few or no keyframes between min/max */
1609 8d14a25c Michael Niedermayer
            pos=pos_min;
1610
        }
1611
        if(pos <= pos_min)
1612
            pos= pos_min + 1;
1613
        else if(pos > pos_limit)
1614
            pos= pos_limit;
1615
        start_pos= pos;
1616
1617 89ddd2a9 Michael Niedermayer
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1618 8d14a25c Michael Niedermayer
        if(pos == pos_max)
1619
            no_change++;
1620
        else
1621
            no_change=0;
1622
#ifdef DEBUG_SEEK
1623 c0492097 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1624
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1625
               start_pos, no_change);
1626 8d14a25c Michael Niedermayer
#endif
1627 db2a0e22 Michael Niedermayer
        if(ts == AV_NOPTS_VALUE){
1628
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1629
            return -1;
1630
        }
1631 8d14a25c Michael Niedermayer
        assert(ts != AV_NOPTS_VALUE);
1632 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1633 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1634
            pos_max = pos;
1635
            ts_max = ts;
1636 3ba1438d Michael Niedermayer
        }
1637
        if (target_ts >= ts) {
1638 8d14a25c Michael Niedermayer
            pos_min = pos;
1639
            ts_min = ts;
1640
        }
1641
    }
1642 115329f1 Diego Biurrun
1643 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1644
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1645 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1646
    pos_min = pos;
1647 89ddd2a9 Michael Niedermayer
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1648 8d14a25c Michael Niedermayer
    pos_min++;
1649 89ddd2a9 Michael Niedermayer
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1650 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1651 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1652
#endif
1653 89ddd2a9 Michael Niedermayer
    *ts_ret= ts;
1654
    return pos;
1655 8d14a25c Michael Niedermayer
}
1656
1657 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1658
    int64_t pos_min, pos_max;
1659
#if 0
1660
    AVStream *st;
1661

1662
    if (stream_index < 0)
1663
        return -1;
1664

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