Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 4dcde00c

History | View | Annotate | Download (124 KB)

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

1666
    if (stream_index < 0)
1667
        return -1;
1668

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