Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 512f973e

History | View | Annotate | Download (125 KB)

1 de6d9b64 Fabrice Bellard
/*
2 a85736f2 Diego Biurrun
 * various utility functions for use within FFmpeg
3 19720f15 Fabrice Bellard
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 de6d9b64 Fabrice Bellard
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 19720f15 Fabrice Bellard
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 de6d9b64 Fabrice Bellard
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 19720f15 Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16 de6d9b64 Fabrice Bellard
 *
17 19720f15 Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 de6d9b64 Fabrice Bellard
 */
21 77f21ce4 Stefano Sabatini
22
/* #define DEBUG */
23
24 8be1c656 Fabrice Bellard
#include "avformat.h"
25 f8bc86d4 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 a85736f2 Diego Biurrun
 * various utility functions for use within FFmpeg
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 e528cdac Michael Niedermayer
    return FFMPEG_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 0cb88628 Michael Niedermayer
    return LICENSE_PREFIX FFMPEG_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 471fe57e 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 384c9c2f Anton Khirnov
    pkt->pos= avio_tell(s);
338 2692067a Michael Niedermayer
339 e63a3628 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 471fe57e 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 e63a3628 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 5b56ad03 Michael Niedermayer
AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
371 b9a281db Fabrice Bellard
{
372 6612d8cf Reimar Döffinger
    AVProbeData lpd = *pd;
373 27323146 Anton Khirnov
    AVInputFormat *fmt1 = NULL, *fmt;
374 5b56ad03 Michael Niedermayer
    int score, score_max=0;
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 5b56ad03 Michael Niedermayer
        if (score > score_max) {
397
            score_max = score;
398 b9a281db Fabrice Bellard
            fmt = fmt1;
399 5b56ad03 Michael Niedermayer
        }else if (score == score_max)
400 4b3cca36 Michael Niedermayer
            fmt = NULL;
401 b9a281db Fabrice Bellard
    }
402 5b56ad03 Michael Niedermayer
    *score_ret= score_max;
403 b9a281db Fabrice Bellard
    return fmt;
404
}
405
406 5b56ad03 Michael Niedermayer
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
407
{
408
    int score_ret;
409
    AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
410
    if(score_ret > *score_max){
411
        *score_max= score_ret;
412
        return fmt;
413
    }else
414
        return NULL;
415
}
416
417 79750486 Michael Niedermayer
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
418
    int score=0;
419
    return av_probe_input_format2(pd, is_opened, &score);
420
}
421
422 5b56ad03 Michael Niedermayer
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
423 64cd3108 Michael Niedermayer
{
424 cf5b33d9 Stefano Sabatini
    static const struct {
425
        const char *name; enum CodecID id; enum AVMediaType type;
426
    } fmt_id_type[] = {
427
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
428
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
429
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
430
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
431
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
432
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
433
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
434
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
435
        { 0 }
436
    };
437 5b56ad03 Michael Niedermayer
    int score;
438
    AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
439 64cd3108 Michael Niedermayer
440
    if (fmt) {
441 cf5b33d9 Stefano Sabatini
        int i;
442 db46c4e1 Baptiste Coudurier
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
443
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
444 cf5b33d9 Stefano Sabatini
        for (i = 0; fmt_id_type[i].name; i++) {
445
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
446
                st->codec->codec_id   = fmt_id_type[i].id;
447
                st->codec->codec_type = fmt_id_type[i].type;
448
                break;
449
            }
450 f1588ed5 Andreas Öman
        }
451 64cd3108 Michael Niedermayer
    }
452 5b56ad03 Michael Niedermayer
    return score;
453 64cd3108 Michael Niedermayer
}
454
455 b9a281db Fabrice Bellard
/************************************************************/
456
/* input media file */
457 96baaa6a Fabrice Bellard
458 da24c5e3 Fabrice Bellard
/**
459 e36bdf8b Daniel Kristjansson
 * Open a media file from an IO stream. 'fmt' must be specified.
460 da24c5e3 Fabrice Bellard
 */
461 115329f1 Diego Biurrun
int av_open_input_stream(AVFormatContext **ic_ptr,
462 471fe57e Anton Khirnov
                         AVIOContext *pb, const char *filename,
463 da24c5e3 Fabrice Bellard
                         AVInputFormat *fmt, AVFormatParameters *ap)
464
{
465
    int err;
466
    AVFormatContext *ic;
467 c04c3282 Michael Niedermayer
    AVFormatParameters default_ap;
468
469
    if(!ap){
470
        ap=&default_ap;
471
        memset(ap, 0, sizeof(default_ap));
472
    }
473 da24c5e3 Fabrice Bellard
474 4eb72c6b Nico Sabbi
    if(!ap->prealloced_context)
475 8e2fd8e1 Stefano Sabatini
        ic = avformat_alloc_context();
476 4eb72c6b Nico Sabbi
    else
477
        ic = *ic_ptr;
478 da24c5e3 Fabrice Bellard
    if (!ic) {
479 769e10f0 Panagiotis Issaris
        err = AVERROR(ENOMEM);
480 da24c5e3 Fabrice Bellard
        goto fail;
481
    }
482
    ic->iformat = fmt;
483 899681cd Björn Axelsson
    ic->pb = pb;
484 da24c5e3 Fabrice Bellard
    ic->duration = AV_NOPTS_VALUE;
485
    ic->start_time = AV_NOPTS_VALUE;
486 75e61b0e Måns Rullgård
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
487 da24c5e3 Fabrice Bellard
488
    /* allocate private data */
489
    if (fmt->priv_data_size > 0) {
490
        ic->priv_data = av_mallocz(fmt->priv_data_size);
491
        if (!ic->priv_data) {
492 769e10f0 Panagiotis Issaris
            err = AVERROR(ENOMEM);
493 da24c5e3 Fabrice Bellard
            goto fail;
494
        }
495
    } else {
496
        ic->priv_data = NULL;
497
    }
498
499 471fe57e Anton Khirnov
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
500 6612d8cf Reimar Döffinger
    if (ic->pb)
501
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
502
503 e145ce20 Ronald S. Bultje
    if (ic->iformat->read_header) {
504 1e2802c5 Ronald S. Bultje
        err = ic->iformat->read_header(ic, ap);
505
        if (err < 0)
506
            goto fail;
507 e145ce20 Ronald S. Bultje
    }
508 fb2758c8 Fabrice Bellard
509 faf7cbf1 Michael Niedermayer
    if (pb && !ic->data_offset)
510 384c9c2f Anton Khirnov
        ic->data_offset = avio_tell(ic->pb);
511 fb2758c8 Fabrice Bellard
512 54036be1 Aurelien Jacobs
#if FF_API_OLD_METADATA
513 e99f76ab Aurelien Jacobs
    ff_metadata_demux_compat(ic);
514
#endif
515
516 af122d6a Baptiste Coudurier
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
517
518 da24c5e3 Fabrice Bellard
    *ic_ptr = ic;
519
    return 0;
520
 fail:
521
    if (ic) {
522 ccafd472 Baptiste Coudurier
        int i;
523 da24c5e3 Fabrice Bellard
        av_freep(&ic->priv_data);
524 ccafd472 Baptiste Coudurier
        for(i=0;i<ic->nb_streams;i++) {
525
            AVStream *st = ic->streams[i];
526
            if (st) {
527
                av_free(st->priv_data);
528
                av_free(st->codec->extradata);
529 ec973f45 Przemysław Sobala
                av_free(st->codec);
530 fd0368e7 Aurelien Jacobs
                av_free(st->info);
531 ccafd472 Baptiste Coudurier
            }
532
            av_free(st);
533
        }
534 da24c5e3 Fabrice Bellard
    }
535
    av_free(ic);
536
    *ic_ptr = NULL;
537
    return err;
538
}
539
540 a85736f2 Diego Biurrun
/** size of probe buffer, for guessing file type from file contents */
541 a877eedc Michael Niedermayer
#define PROBE_BUF_MIN 2048
542 329b1e75 Michael Niedermayer
#define PROBE_BUF_MAX (1<<20)
543 b9a281db Fabrice Bellard
544 471fe57e Anton Khirnov
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
545 eadd495d Micah F. Galizia
                          const char *filename, void *logctx,
546
                          unsigned int offset, unsigned int max_probe_size)
547
{
548
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
549
    unsigned char *buf = NULL;
550
    int ret = 0, probe_size;
551
552
    if (!max_probe_size) {
553
        max_probe_size = PROBE_BUF_MAX;
554
    } else if (max_probe_size > PROBE_BUF_MAX) {
555
        max_probe_size = PROBE_BUF_MAX;
556
    } else if (max_probe_size < PROBE_BUF_MIN) {
557
        return AVERROR(EINVAL);
558
    }
559
560
    if (offset >= max_probe_size) {
561
        return AVERROR(EINVAL);
562
    }
563
564 532aa889 Micah F. Galizia
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
565
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
566 eadd495d Micah F. Galizia
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
567
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
568
569
        if (probe_size < offset) {
570
            continue;
571
        }
572
573
        /* read probe data */
574
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
575 e63a3628 Anton Khirnov
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
576 eadd495d Micah F. Galizia
            /* fail if error was not end of file, otherwise, lower score */
577
            if (ret != AVERROR_EOF) {
578
                av_free(buf);
579
                return ret;
580
            }
581
            score = 0;
582 c7f625ee Måns Rullgård
            ret = 0;            /* error was end of file, nothing read */
583 eadd495d Micah F. Galizia
        }
584
        pd.buf_size += ret;
585
        pd.buf = &buf[offset];
586
587
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
588
589
        /* guess file format */
590
        *fmt = av_probe_input_format2(&pd, 1, &score);
591
        if(*fmt){
592
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
593
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
594
            }else
595
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
596
        }
597
    }
598
599 532aa889 Micah F. Galizia
    if (!*fmt) {
600 01d91b9b Tomas Härdin
        av_free(buf);
601 532aa889 Micah F. Galizia
        return AVERROR_INVALIDDATA;
602
    }
603
604 01d91b9b Tomas Härdin
    /* rewind. reuse probe buffer to avoid seeking */
605 f8bc86d4 Anton Khirnov
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
606 01d91b9b Tomas Härdin
        av_free(buf);
607 eadd495d Micah F. Galizia
608 01d91b9b Tomas Härdin
    return ret;
609 eadd495d Micah F. Galizia
}
610
611 115329f1 Diego Biurrun
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
612 b9a281db Fabrice Bellard
                       AVInputFormat *fmt,
613
                       int buf_size,
614
                       AVFormatParameters *ap)
615 de6d9b64 Fabrice Bellard
{
616 eadd495d Micah F. Galizia
    int err;
617 b9a281db Fabrice Bellard
    AVProbeData probe_data, *pd = &probe_data;
618 471fe57e Anton Khirnov
    AVIOContext *pb = NULL;
619 e9b06816 Michael Niedermayer
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
620 115329f1 Diego Biurrun
621 da24c5e3 Fabrice Bellard
    pd->filename = "";
622
    if (filename)
623
        pd->filename = filename;
624 a877eedc Michael Niedermayer
    pd->buf = NULL;
625 b9a281db Fabrice Bellard
    pd->buf_size = 0;
626
627
    if (!fmt) {
628 a85736f2 Diego Biurrun
        /* guess format if no file can be opened */
629 a25e098d Fabrice Bellard
        fmt = av_probe_input_format(pd, 0);
630 de6d9b64 Fabrice Bellard
    }
631
632 a85736f2 Diego Biurrun
    /* Do not open file if the format does not need it. XXX: specific
633 b6892136 Fabrice Bellard
       hack needed to handle RTSP/TCP */
634 17acc63a Reimar Döffinger
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
635 87a0a681 Fabrice Bellard
        /* if no file needed do not try to open one */
636 ebb92e07 Anton Khirnov
        if ((err=avio_open(&pb, filename, URL_RDONLY)) < 0) {
637 96baaa6a Fabrice Bellard
            goto fail;
638 b9a281db Fabrice Bellard
        }
639 96baaa6a Fabrice Bellard
        if (buf_size > 0) {
640 59f65d95 Anton Khirnov
            ffio_set_buf_size(pb, buf_size);
641 96baaa6a Fabrice Bellard
        }
642 070e5ba5 Anssi Hannula
        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
643 eadd495d Micah F. Galizia
            goto fail;
644 5b25dfa7 Fabrice Bellard
        }
645 b9a281db Fabrice Bellard
    }
646
647
    /* if still no format found, error */
648
    if (!fmt) {
649 2928b83c Stefano Sabatini
        err = AVERROR_INVALIDDATA;
650 da24c5e3 Fabrice Bellard
        goto fail;
651 de6d9b64 Fabrice Bellard
    }
652 115329f1 Diego Biurrun
653 a85736f2 Diego Biurrun
    /* check filename in case an image number is expected */
654 da24c5e3 Fabrice Bellard
    if (fmt->flags & AVFMT_NEEDNUMBER) {
655 5c07cf53 Michel Bardiaux
        if (!av_filename_number_test(filename)) {
656 87a0a681 Fabrice Bellard
            err = AVERROR_NUMEXPECTED;
657 da24c5e3 Fabrice Bellard
            goto fail;
658 87a0a681 Fabrice Bellard
        }
659
    }
660 da24c5e3 Fabrice Bellard
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
661
    if (err)
662
        goto fail;
663 b9a281db Fabrice Bellard
    return 0;
664 de6d9b64 Fabrice Bellard
 fail:
665 a877eedc Michael Niedermayer
    av_freep(&pd->buf);
666 17acc63a Reimar Döffinger
    if (pb)
667 ebb92e07 Anton Khirnov
        avio_close(pb);
668 ebb82604 Art Clarke
    if (ap && ap->prealloced_context)
669
        av_free(*ic_ptr);
670
    *ic_ptr = NULL;
671 b9a281db Fabrice Bellard
    return err;
672 115329f1 Diego Biurrun
673 de6d9b64 Fabrice Bellard
}
674
675 da24c5e3 Fabrice Bellard
/*******************************************************/
676
677 5c5b1731 Måns Rullgård
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
678
                               AVPacketList **plast_pktl){
679
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
680 9d3b9f2c Michael Niedermayer
    if (!pktl)
681
        return NULL;
682
683 5c5b1731 Måns Rullgård
    if (*packet_buffer)
684
        (*plast_pktl)->next = pktl;
685
    else
686
        *packet_buffer = pktl;
687
688 9d3b9f2c Michael Niedermayer
    /* add the packet in the buffered packet list */
689
    *plast_pktl = pktl;
690
    pktl->pkt= *pkt;
691
    return &pktl->pkt;
692
}
693
694 de6d9b64 Fabrice Bellard
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
695
{
696 86cb7e33 Baptiste Coudurier
    int ret, i;
697 62600469 Michael Niedermayer
    AVStream *st;
698 0bef08e5 Michael Niedermayer
699
    for(;;){
700
        AVPacketList *pktl = s->raw_packet_buffer;
701
702
        if (pktl) {
703
            *pkt = pktl->pkt;
704 5b56ad03 Michael Niedermayer
            if(s->streams[pkt->stream_index]->request_probe <= 0){
705 0bef08e5 Michael Niedermayer
                s->raw_packet_buffer = pktl->next;
706 af122d6a Baptiste Coudurier
                s->raw_packet_buffer_remaining_size += pkt->size;
707 0bef08e5 Michael Niedermayer
                av_free(pktl);
708
                return 0;
709
            }
710
        }
711
712 55823964 Michael Niedermayer
        av_init_packet(pkt);
713
        ret= s->iformat->read_packet(s, pkt);
714 86cb7e33 Baptiste Coudurier
        if (ret < 0) {
715
            if (!pktl || ret == AVERROR(EAGAIN))
716
                return ret;
717
            for (i = 0; i < s->nb_streams; i++)
718 5b56ad03 Michael Niedermayer
                if(s->streams[i]->request_probe > 0)
719
                    s->streams[i]->request_probe = -1;
720 86cb7e33 Baptiste Coudurier
            continue;
721
        }
722 55823964 Michael Niedermayer
        st= s->streams[pkt->stream_index];
723 62600469 Michael Niedermayer
724 55823964 Michael Niedermayer
        switch(st->codec->codec_type){
725 72415b2a Stefano Sabatini
        case AVMEDIA_TYPE_VIDEO:
726 55823964 Michael Niedermayer
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
727
            break;
728 72415b2a Stefano Sabatini
        case AVMEDIA_TYPE_AUDIO:
729 55823964 Michael Niedermayer
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
730
            break;
731 72415b2a Stefano Sabatini
        case AVMEDIA_TYPE_SUBTITLE:
732 55823964 Michael Niedermayer
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
733
            break;
734
        }
735 62600469 Michael Niedermayer
736 5b56ad03 Michael Niedermayer
        if(!pktl && st->request_probe <= 0)
737 744b4c02 Michael Niedermayer
            return ret;
738
739 5c5b1731 Måns Rullgård
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
740 af122d6a Baptiste Coudurier
        s->raw_packet_buffer_remaining_size -= pkt->size;
741 744b4c02 Michael Niedermayer
742 5b56ad03 Michael Niedermayer
        if(st->request_probe>0){
743 0bef08e5 Michael Niedermayer
            AVProbeData *pd = &st->probe_data;
744 15957b19 Michael Niedermayer
            int end;
745
            av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
746 86cb7e33 Baptiste Coudurier
            --st->probe_packets;
747
748 0bef08e5 Michael Niedermayer
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
749
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
750
            pd->buf_size += pkt->size;
751
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
752
753 15957b19 Michael Niedermayer
            end=    s->raw_packet_buffer_remaining_size <= 0
754
                 || st->probe_packets<=0;
755
756
            if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
757 5b56ad03 Michael Niedermayer
                int score= set_codec_from_probe_data(s, st, pd);
758
                if(    (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
759
                    || end){
760 25d3fb73 Michael Niedermayer
                    pd->buf_size=0;
761
                    av_freep(&pd->buf);
762 5b56ad03 Michael Niedermayer
                    st->request_probe= -1;
763
                    if(st->codec->codec_id != CODEC_ID_NONE){
764 0e500e0d Michael Niedermayer
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
765 15957b19 Michael Niedermayer
                    }else
766
                        av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
767 25d3fb73 Michael Niedermayer
                }
768 942de2f4 Michael Niedermayer
            }
769 0bef08e5 Michael Niedermayer
        }
770
    }
771 fb2758c8 Fabrice Bellard
}
772
773
/**********************************************************/
774
775 e36bdf8b Daniel Kristjansson
/**
776 a85736f2 Diego Biurrun
 * Get the number of samples of an audio frame. Return -1 on error.
777 e36bdf8b Daniel Kristjansson
 */
778 fb2758c8 Fabrice Bellard
static int get_audio_frame_size(AVCodecContext *enc, int size)
779
{
780
    int frame_size;
781
782 c924ca78 Michael Niedermayer
    if(enc->codec_id == CODEC_ID_VORBIS)
783
        return -1;
784
785 fb2758c8 Fabrice Bellard
    if (enc->frame_size <= 1) {
786 ac3e1834 Baptiste Coudurier
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
787
788
        if (bits_per_sample) {
789 fb2758c8 Fabrice Bellard
            if (enc->channels == 0)
790
                return -1;
791 f1b163e0 Aurelien Jacobs
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
792 ac3e1834 Baptiste Coudurier
        } else {
793 fb2758c8 Fabrice Bellard
            /* used for example by ADPCM codecs */
794
            if (enc->bit_rate == 0)
795
                return -1;
796 db5dc02b Baptiste Coudurier
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
797 fb2758c8 Fabrice Bellard
        }
798
    } else {
799
        frame_size = enc->frame_size;
800
    }
801
    return frame_size;
802
}
803
804
805 e36bdf8b Daniel Kristjansson
/**
806 a85736f2 Diego Biurrun
 * Return the frame duration in seconds. Return 0 if not available.
807 e36bdf8b Daniel Kristjansson
 */
808 115329f1 Diego Biurrun
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
809 fb2758c8 Fabrice Bellard
                                   AVCodecParserContext *pc, AVPacket *pkt)
810
{
811
    int frame_size;
812
813
    *pnum = 0;
814
    *pden = 0;
815 01f4895c Michael Niedermayer
    switch(st->codec->codec_type) {
816 72415b2a Stefano Sabatini
    case AVMEDIA_TYPE_VIDEO:
817 1677155d Michael Niedermayer
        if(st->time_base.num*1000LL > st->time_base.den){
818 c0df9d75 Michael Niedermayer
            *pnum = st->time_base.num;
819
            *pden = st->time_base.den;
820 01f4895c Michael Niedermayer
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
821
            *pnum = st->codec->time_base.num;
822
            *pden = st->codec->time_base.den;
823 327c4076 Michael Niedermayer
            if (pc && pc->repeat_pict) {
824 810c451b Ivan Schreter
                *pnum = (*pnum) * (1 + pc->repeat_pict);
825 327c4076 Michael Niedermayer
            }
826 497431a5 Michael Niedermayer
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
827
            //Thus if we have no parser in such case leave duration undefined.
828
            if(st->codec->ticks_per_frame>1 && !pc){
829
                *pnum = *pden = 0;
830
            }
831 fb2758c8 Fabrice Bellard
        }
832
        break;
833 72415b2a Stefano Sabatini
    case AVMEDIA_TYPE_AUDIO:
834 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
835 6cbce636 Daniel Kang
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
836 fb2758c8 Fabrice Bellard
            break;
837
        *pnum = frame_size;
838 01f4895c Michael Niedermayer
        *pden = st->codec->sample_rate;
839 fb2758c8 Fabrice Bellard
        break;
840
    default:
841
        break;
842
    }
843
}
844
845 5ba7c3d7 Michael Niedermayer
static int is_intra_only(AVCodecContext *enc){
846 72415b2a Stefano Sabatini
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
847 5ba7c3d7 Michael Niedermayer
        return 1;
848 72415b2a Stefano Sabatini
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
849 5ba7c3d7 Michael Niedermayer
        switch(enc->codec_id){
850
        case CODEC_ID_MJPEG:
851
        case CODEC_ID_MJPEGB:
852
        case CODEC_ID_LJPEG:
853
        case CODEC_ID_RAWVIDEO:
854
        case CODEC_ID_DVVIDEO:
855
        case CODEC_ID_HUFFYUV:
856 f37b9768 Loren Merritt
        case CODEC_ID_FFVHUFF:
857 5ba7c3d7 Michael Niedermayer
        case CODEC_ID_ASV1:
858
        case CODEC_ID_ASV2:
859
        case CODEC_ID_VCR1:
860 b774fdd7 Baptiste Coudurier
        case CODEC_ID_DNXHD:
861 aa915625 Baptiste Coudurier
        case CODEC_ID_JPEG2000:
862 5ba7c3d7 Michael Niedermayer
            return 1;
863
        default: break;
864
        }
865
    }
866
    return 0;
867
}
868
869 9fcbcca6 Neil Brown
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
870
                                      int64_t dts, int64_t pts)
871
{
872 82583548 Michael Niedermayer
    AVStream *st= s->streams[stream_index];
873
    AVPacketList *pktl= s->packet_buffer;
874
875 7efeb73a Michael Niedermayer
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
876 82583548 Michael Niedermayer
        return;
877
878
    st->first_dts= dts - st->cur_dts;
879
    st->cur_dts= dts;
880
881
    for(; pktl; pktl= pktl->next){
882
        if(pktl->pkt.stream_index != stream_index)
883
            continue;
884
        //FIXME think more about this check
885
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
886
            pktl->pkt.pts += st->first_dts;
887
888
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
889
            pktl->pkt.dts += st->first_dts;
890 48a59dfe Michael Niedermayer
891
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
892
            st->start_time= pktl->pkt.pts;
893 82583548 Michael Niedermayer
    }
894 9fcbcca6 Neil Brown
    if (st->start_time == AV_NOPTS_VALUE)
895
        st->start_time = pts;
896 82583548 Michael Niedermayer
}
897
898 83a9db42 Michael Niedermayer
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
899
{
900
    AVPacketList *pktl= s->packet_buffer;
901 820ad60c Michael Niedermayer
    int64_t cur_dts= 0;
902
903
    if(st->first_dts != AV_NOPTS_VALUE){
904
        cur_dts= st->first_dts;
905
        for(; pktl; pktl= pktl->next){
906
            if(pktl->pkt.stream_index == pkt->stream_index){
907
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
908
                    break;
909
                cur_dts -= pkt->duration;
910
            }
911
        }
912
        pktl= s->packet_buffer;
913
        st->first_dts = cur_dts;
914
    }else if(st->cur_dts)
915
        return;
916 83a9db42 Michael Niedermayer
917
    for(; pktl; pktl= pktl->next){
918
        if(pktl->pkt.stream_index != pkt->stream_index)
919
            continue;
920 91acf9a8 Michael Niedermayer
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
921
           && !pktl->pkt.duration){
922 820ad60c Michael Niedermayer
            pktl->pkt.dts= cur_dts;
923 5853423c Michael Niedermayer
            if(!st->codec->has_b_frames)
924 820ad60c Michael Niedermayer
                pktl->pkt.pts= cur_dts;
925
            cur_dts += pkt->duration;
926 83a9db42 Michael Niedermayer
            pktl->pkt.duration= pkt->duration;
927
        }else
928
            break;
929
    }
930 820ad60c Michael Niedermayer
    if(st->first_dts == AV_NOPTS_VALUE)
931
        st->cur_dts= cur_dts;
932 83a9db42 Michael Niedermayer
}
933
934 115329f1 Diego Biurrun
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
935 fb2758c8 Fabrice Bellard
                               AVCodecParserContext *pc, AVPacket *pkt)
936
{
937 d9e1efb7 Michael Niedermayer
    int num, den, presentation_delayed, delay, i;
938 a74008a4 Joakim Plate
    int64_t offset;
939 115329f1 Diego Biurrun
940 fe8344a2 Michael Niedermayer
    if (s->flags & AVFMT_FLAG_NOFILLIN)
941
        return;
942
943 c55806e3 Michael Niedermayer
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
944
        pkt->dts= AV_NOPTS_VALUE;
945
946 f4a4be3f Wallak
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
947 e18027ac Carl Eugen Hoyos
        //FIXME Set low_delay = 0 when has_b_frames = 1
948 818062f2 Baptiste Coudurier
        st->codec->has_b_frames = 1;
949
950 f781f748 Michael Niedermayer
    /* do we have a video B-frame ? */
951
    delay= st->codec->has_b_frames;
952
    presentation_delayed = 0;
953 b38f008e Alexander Strange
954
    // ignore delay caused by frame threading so that the mpeg2-without-dts
955
    // warning will not trigger
956
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
957
        delay -= st->codec->thread_count-1;
958
959 f781f748 Michael Niedermayer
    /* XXX: need has_b_frame, but cannot get it if the codec is
960
        not initialized */
961
    if (delay &&
962
        pc && pc->pict_type != FF_B_TYPE)
963
        presentation_delayed = 1;
964
965 10a7571b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
966
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
967
        pkt->dts -= 1LL<<st->pts_wrap_bits;
968
    }
969
970 9806f846 Michael Niedermayer
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
971
    // we take the conservative approach and discard both
972
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
973
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
974 b0a18c2f XBMC
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
975 9806f846 Michael Niedermayer
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
976
    }
977
978 fb2758c8 Fabrice Bellard
    if (pkt->duration == 0) {
979 3c895fc0 Michael Niedermayer
        compute_frame_duration(&num, &den, st, pc, pkt);
980 fb2758c8 Fabrice Bellard
        if (den && num) {
981 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);
982 83a9db42 Michael Niedermayer
983 820ad60c Michael Niedermayer
            if(pkt->duration != 0 && s->packet_buffer)
984 83a9db42 Michael Niedermayer
                update_initial_durations(s, st, pkt);
985 fb2758c8 Fabrice Bellard
        }
986
    }
987
988 a85736f2 Diego Biurrun
    /* correct timestamps with byte offset if demuxers only have timestamps
989
       on packet boundaries */
990 a74008a4 Joakim Plate
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
991
        /* this will estimate bitrate based on this frame's duration and size */
992
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
993
        if(pkt->pts != AV_NOPTS_VALUE)
994
            pkt->pts += offset;
995
        if(pkt->dts != AV_NOPTS_VALUE)
996
            pkt->dts += offset;
997
    }
998
999 27ca0a79 Ivan Schreter
    if (pc && pc->dts_sync_point >= 0) {
1000
        // we have synchronization info from the parser
1001
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1002
        if (den > 0) {
1003
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1004
            if (pkt->dts != AV_NOPTS_VALUE) {
1005
                // got DTS from the stream, update reference timestamp
1006
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1007
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1008
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
1009
                // compute DTS based on reference timestamp
1010
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1011
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1012
            }
1013
            if (pc->dts_sync_point > 0)
1014
                st->reference_dts = pkt->dts; // new reference
1015
        }
1016
    }
1017
1018 755bfeab Diego Biurrun
    /* This may be redundant, but it should not hurt. */
1019 7e4baa66 Michael Niedermayer
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1020
        presentation_delayed = 1;
1021 115329f1 Diego Biurrun
1022 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);
1023 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
1024 9e6c124a Michael Niedermayer
    //We skip H264 currently because delay and has_b_frames are not reliably set
1025
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1026 7e4baa66 Michael Niedermayer
        if (presentation_delayed) {
1027 a85736f2 Diego Biurrun
            /* DTS = decompression timestamp */
1028
            /* PTS = presentation timestamp */
1029 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
1030 635fbcb1 Michael Niedermayer
                pkt->dts = st->last_IP_pts;
1031 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1032 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
1033
                pkt->dts = st->cur_dts;
1034
1035
            /* this is tricky: the dts must be incremented by the duration
1036 a85736f2 Diego Biurrun
            of the frame we are displaying, i.e. the last I- or P-frame */
1037 635fbcb1 Michael Niedermayer
            if (st->last_IP_duration == 0)
1038
                st->last_IP_duration = pkt->duration;
1039 7efeb73a Michael Niedermayer
            if(pkt->dts != AV_NOPTS_VALUE)
1040 cdb5af79 Michael Niedermayer
                st->cur_dts = pkt->dts + st->last_IP_duration;
1041 635fbcb1 Michael Niedermayer
            st->last_IP_duration  = pkt->duration;
1042
            st->last_IP_pts= pkt->pts;
1043 7e4baa66 Michael Niedermayer
            /* cannot compute PTS if not present (we can compute it only
1044 a85736f2 Diego Biurrun
            by knowing the future */
1045 028d6f3e Michael Niedermayer
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1046 7e4baa66 Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1047
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1048
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1049
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1050
                    pkt->pts += pkt->duration;
1051
    //                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);
1052
                }
1053 90bb394d Michael Niedermayer
            }
1054 115329f1 Diego Biurrun
1055 7e4baa66 Michael Niedermayer
            /* presentation is not delayed : PTS and DTS are the same */
1056
            if(pkt->pts == AV_NOPTS_VALUE)
1057
                pkt->pts = pkt->dts;
1058 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1059 7e4baa66 Michael Niedermayer
            if(pkt->pts == AV_NOPTS_VALUE)
1060
                pkt->pts = st->cur_dts;
1061
            pkt->dts = pkt->pts;
1062 7efeb73a Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE)
1063 cdb5af79 Michael Niedermayer
                st->cur_dts = pkt->pts + pkt->duration;
1064 7e4baa66 Michael Niedermayer
        }
1065 fb2758c8 Fabrice Bellard
    }
1066 d9e1efb7 Michael Niedermayer
1067 cb5b96cd Baptiste Coudurier
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1068 d9e1efb7 Michael Niedermayer
        st->pts_buffer[0]= pkt->pts;
1069
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1070
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1071
        if(pkt->dts == AV_NOPTS_VALUE)
1072
            pkt->dts= st->pts_buffer[0];
1073 9e6c124a Michael Niedermayer
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1074 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1075 82583548 Michael Niedermayer
        }
1076 d9e1efb7 Michael Niedermayer
        if(pkt->dts > st->cur_dts)
1077
            st->cur_dts = pkt->dts;
1078
    }
1079
1080
//    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);
1081 115329f1 Diego Biurrun
1082 fb2758c8 Fabrice Bellard
    /* update flags */
1083 3a1d3588 Jeff Downs
    if(is_intra_only(st->codec))
1084 cc947f04 Jean-Daniel Dupas
        pkt->flags |= AV_PKT_FLAG_KEY;
1085 3a1d3588 Jeff Downs
    else if (pc) {
1086 fb2758c8 Fabrice Bellard
        pkt->flags = 0;
1087 a85736f2 Diego Biurrun
        /* keyframe computation */
1088 6363af44 Ivan Schreter
        if (pc->key_frame == 1)
1089 cc947f04 Jean-Daniel Dupas
            pkt->flags |= AV_PKT_FLAG_KEY;
1090 6363af44 Ivan Schreter
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1091 cc947f04 Jean-Daniel Dupas
            pkt->flags |= AV_PKT_FLAG_KEY;
1092 fb2758c8 Fabrice Bellard
    }
1093 b1fa4942 Ivan Schreter
    if (pc)
1094
        pkt->convergence_duration = pc->convergence_duration;
1095 fb2758c8 Fabrice Bellard
}
1096
1097
1098
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1099
{
1100
    AVStream *st;
1101 37353960 Fabrice Bellard
    int len, ret, i;
1102 fb2758c8 Fabrice Bellard
1103 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
1104
1105 fb2758c8 Fabrice Bellard
    for(;;) {
1106
        /* select current input stream component */
1107
        st = s->cur_st;
1108
        if (st) {
1109 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
1110 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
1111
                /* raw data support */
1112 3a41c2f7 Michael Niedermayer
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1113 fb2758c8 Fabrice Bellard
                compute_pkt_fields(s, st, NULL, pkt);
1114
                s->cur_st = NULL;
1115 74f5ae84 Reimar Döffinger
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1116 cc947f04 Jean-Daniel Dupas
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1117 74f5ae84 Reimar Döffinger
                    ff_reduce_index(s, st->index);
1118
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1119
                }
1120 434cab9e Michael Niedermayer
                break;
1121 3a41c2f7 Michael Niedermayer
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1122 61c23c15 Ivan Schreter
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1123
                                       st->cur_ptr, st->cur_len,
1124
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1125
                                       st->cur_pkt.pos);
1126 3a41c2f7 Michael Niedermayer
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1127
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1128 fb2758c8 Fabrice Bellard
                /* increment read pointer */
1129 3a41c2f7 Michael Niedermayer
                st->cur_ptr += len;
1130
                st->cur_len -= len;
1131 115329f1 Diego Biurrun
1132 fb2758c8 Fabrice Bellard
                /* return packet if any */
1133
                if (pkt->size) {
1134 37353960 Fabrice Bellard
                got_packet:
1135 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
1136
                    pkt->stream_index = st->index;
1137 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
1138
                    pkt->dts = st->parser->dts;
1139 61c23c15 Ivan Schreter
                    pkt->pos = st->parser->pos;
1140 a5266a47 Michael Niedermayer
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1141
                        s->cur_st = NULL;
1142
                        pkt->destruct= st->cur_pkt.destruct;
1143 22d78b05 Eli Friedman
                        st->cur_pkt.destruct= NULL;
1144 a5266a47 Michael Niedermayer
                        st->cur_pkt.data    = NULL;
1145
                        assert(st->cur_len == 0);
1146
                    }else{
1147 80d403fc Reimar Döffinger
                    pkt->destruct = NULL;
1148 a5266a47 Michael Niedermayer
                    }
1149 fb2758c8 Fabrice Bellard
                    compute_pkt_fields(s, st, st->parser, pkt);
1150 e9b78eeb Michael Niedermayer
1151 cc947f04 Jean-Daniel Dupas
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1152 3dea63bd Paul Kelly
                        ff_reduce_index(s, st->index);
1153 e9b78eeb Michael Niedermayer
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1154
                                           0, 0, AVINDEX_KEYFRAME);
1155
                    }
1156
1157 434cab9e Michael Niedermayer
                    break;
1158 fb2758c8 Fabrice Bellard
                }
1159
            } else {
1160 bcbecff1 Fabrice Bellard
                /* free packet */
1161 3a41c2f7 Michael Niedermayer
                av_free_packet(&st->cur_pkt);
1162 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
1163
            }
1164
        } else {
1165 3a41c2f7 Michael Niedermayer
            AVPacket cur_pkt;
1166 fb2758c8 Fabrice Bellard
            /* read next packet */
1167 3a41c2f7 Michael Niedermayer
            ret = av_read_packet(s, &cur_pkt);
1168 37353960 Fabrice Bellard
            if (ret < 0) {
1169 8fa36ae0 François Revol
                if (ret == AVERROR(EAGAIN))
1170 37353960 Fabrice Bellard
                    return ret;
1171
                /* return the last frames, if any */
1172
                for(i = 0; i < s->nb_streams; i++) {
1173
                    st = s->streams[i];
1174 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
1175 61c23c15 Ivan Schreter
                        av_parser_parse2(st->parser, st->codec,
1176 115329f1 Diego Biurrun
                                        &pkt->data, &pkt->size,
1177
                                        NULL, 0,
1178 61c23c15 Ivan Schreter
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1179
                                        AV_NOPTS_VALUE);
1180 37353960 Fabrice Bellard
                        if (pkt->size)
1181
                            goto got_packet;
1182
                    }
1183
                }
1184 a85736f2 Diego Biurrun
                /* no more packets: really terminate parsing */
1185 fb2758c8 Fabrice Bellard
                return ret;
1186 37353960 Fabrice Bellard
            }
1187 3a41c2f7 Michael Niedermayer
            st = s->streams[cur_pkt.stream_index];
1188
            st->cur_pkt= cur_pkt;
1189 115329f1 Diego Biurrun
1190 3a41c2f7 Michael Niedermayer
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1191
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1192
               st->cur_pkt.pts < st->cur_pkt.dts){
1193 b18a4ab2 Michael Niedermayer
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1194 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.stream_index,
1195
                    st->cur_pkt.pts,
1196
                    st->cur_pkt.dts,
1197
                    st->cur_pkt.size);
1198
//                av_free_packet(&st->cur_pkt);
1199 b18a4ab2 Michael Niedermayer
//                return -1;
1200
            }
1201
1202 45b2b05f Michael Niedermayer
            if(s->debug & FF_FDEBUG_TS)
1203 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",
1204 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.stream_index,
1205
                    st->cur_pkt.pts,
1206
                    st->cur_pkt.dts,
1207
                    st->cur_pkt.size,
1208 050ba6f4 Baptiste Coudurier
                    st->cur_pkt.duration,
1209 3a41c2f7 Michael Niedermayer
                    st->cur_pkt.flags);
1210 fb2758c8 Fabrice Bellard
1211
            s->cur_st = st;
1212 3a41c2f7 Michael Niedermayer
            st->cur_ptr = st->cur_pkt.data;
1213
            st->cur_len = st->cur_pkt.size;
1214 fe8344a2 Michael Niedermayer
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1215 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
1216 fb2758c8 Fabrice Bellard
                if (!st->parser) {
1217 a85736f2 Diego Biurrun
                    /* no parser available: just output the raw packets */
1218 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1219
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1220 7cbaa7ba Michael Niedermayer
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1221 74a6df59 Alex Converse
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1222
                    st->parser->flags |= PARSER_FLAG_ONCE;
1223 fb2758c8 Fabrice Bellard
                }
1224
            }
1225
        }
1226
    }
1227 45b2b05f Michael Niedermayer
    if(s->debug & FF_FDEBUG_TS)
1228 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",
1229 434cab9e Michael Niedermayer
            pkt->stream_index,
1230
            pkt->pts,
1231
            pkt->dts,
1232 3041a4a1 Michael Niedermayer
            pkt->size,
1233 050ba6f4 Baptiste Coudurier
            pkt->duration,
1234 3041a4a1 Michael Niedermayer
            pkt->flags);
1235 434cab9e Michael Niedermayer
1236
    return 0;
1237 fb2758c8 Fabrice Bellard
}
1238
1239
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1240
{
1241 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
1242 30bc6613 Michael Niedermayer
    int eof=0;
1243
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1244
1245
    for(;;){
1246
        pktl = s->packet_buffer;
1247
        if (pktl) {
1248
            AVPacket *next_pkt= &pktl->pkt;
1249
1250
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1251 5be5d28c Stephen Dredge
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1252 30bc6613 Michael Niedermayer
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1253 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1254 5be5d28c Stephen Dredge
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1255
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1256 30bc6613 Michael Niedermayer
                        next_pkt->pts= pktl->pkt.dts;
1257
                    }
1258
                    pktl= pktl->next;
1259
                }
1260
                pktl = s->packet_buffer;
1261
            }
1262 115329f1 Diego Biurrun
1263
            if(   next_pkt->pts != AV_NOPTS_VALUE
1264
               || next_pkt->dts == AV_NOPTS_VALUE
1265 30bc6613 Michael Niedermayer
               || !genpts || eof){
1266
                /* read packet from packet buffer, if there is data */
1267
                *pkt = *next_pkt;
1268
                s->packet_buffer = pktl->next;
1269
                av_free(pktl);
1270
                return 0;
1271
            }
1272
        }
1273
        if(genpts){
1274
            int ret= av_read_frame_internal(s, pkt);
1275
            if(ret<0){
1276 8fa36ae0 François Revol
                if(pktl && ret != AVERROR(EAGAIN)){
1277 30bc6613 Michael Niedermayer
                    eof=1;
1278
                    continue;
1279
                }else
1280
                    return ret;
1281
            }
1282 115329f1 Diego Biurrun
1283 5c5b1731 Måns Rullgård
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1284
                                           &s->packet_buffer_end)) < 0)
1285 769e10f0 Panagiotis Issaris
                return AVERROR(ENOMEM);
1286 30bc6613 Michael Niedermayer
        }else{
1287
            assert(!s->packet_buffer);
1288
            return av_read_frame_internal(s, pkt);
1289
        }
1290 fb2758c8 Fabrice Bellard
    }
1291
}
1292
1293
/* XXX: suppress the packet queue */
1294
static void flush_packet_queue(AVFormatContext *s)
1295
{
1296
    AVPacketList *pktl;
1297
1298
    for(;;) {
1299
        pktl = s->packet_buffer;
1300 115329f1 Diego Biurrun
        if (!pktl)
1301 fb2758c8 Fabrice Bellard
            break;
1302
        s->packet_buffer = pktl->next;
1303
        av_free_packet(&pktl->pkt);
1304
        av_free(pktl);
1305 b9a281db Fabrice Bellard
    }
1306 86cb7e33 Baptiste Coudurier
    while(s->raw_packet_buffer){
1307
        pktl = s->raw_packet_buffer;
1308
        s->raw_packet_buffer = pktl->next;
1309
        av_free_packet(&pktl->pkt);
1310
        av_free(pktl);
1311
    }
1312 42831b46 Michael Niedermayer
    s->packet_buffer_end=
1313
    s->raw_packet_buffer_end= NULL;
1314 af122d6a Baptiste Coudurier
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1315 b9a281db Fabrice Bellard
}
1316
1317 da24c5e3 Fabrice Bellard
/*******************************************************/
1318 fb2758c8 Fabrice Bellard
/* seek support */
1319
1320 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
1321
{
1322 ca162a50 Aurelien Jacobs
    int first_audio_index = -1;
1323 b754978a Michael Niedermayer
    int i;
1324
    AVStream *st;
1325
1326
    if (s->nb_streams <= 0)
1327
        return -1;
1328
    for(i = 0; i < s->nb_streams; i++) {
1329
        st = s->streams[i];
1330 72415b2a Stefano Sabatini
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1331 b754978a Michael Niedermayer
            return i;
1332
        }
1333 72415b2a Stefano Sabatini
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1334 ca162a50 Aurelien Jacobs
            first_audio_index = i;
1335 b754978a Michael Niedermayer
    }
1336 ca162a50 Aurelien Jacobs
    return first_audio_index >= 0 ? first_audio_index : 0;
1337 b754978a Michael Niedermayer
}
1338
1339 e36bdf8b Daniel Kristjansson
/**
1340
 * Flush the frame reader.
1341
 */
1342 972ffe62 Aurelien Jacobs
void ff_read_frame_flush(AVFormatContext *s)
1343 fb2758c8 Fabrice Bellard
{
1344
    AVStream *st;
1345 106fa129 John Stebbins
    int i, j;
1346 fb2758c8 Fabrice Bellard
1347
    flush_packet_queue(s);
1348
1349 3a41c2f7 Michael Niedermayer
    s->cur_st = NULL;
1350 115329f1 Diego Biurrun
1351 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
1352
    for(i = 0; i < s->nb_streams; i++) {
1353
        st = s->streams[i];
1354 115329f1 Diego Biurrun
1355 fb2758c8 Fabrice Bellard
        if (st->parser) {
1356
            av_parser_close(st->parser);
1357
            st->parser = NULL;
1358 3a41c2f7 Michael Niedermayer
            av_free_packet(&st->cur_pkt);
1359 fb2758c8 Fabrice Bellard
        }
1360 635fbcb1 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
1361 a843d1ff Michael Niedermayer
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1362 27ca0a79 Ivan Schreter
        st->reference_dts = AV_NOPTS_VALUE;
1363 3a41c2f7 Michael Niedermayer
        /* fail safe */
1364
        st->cur_ptr = NULL;
1365
        st->cur_len = 0;
1366 86cb7e33 Baptiste Coudurier
1367
        st->probe_packets = MAX_PROBE_PACKETS;
1368 106fa129 John Stebbins
1369
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1370
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1371 fb2758c8 Fabrice Bellard
    }
1372
}
1373
1374 22ffac70 Reimar Döffinger
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1375 8bcb147f Michael Niedermayer
    int i;
1376
1377
    for(i = 0; i < s->nb_streams; i++) {
1378 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
1379 8bcb147f Michael Niedermayer
1380 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
1381 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1382
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1383 8bcb147f Michael Niedermayer
    }
1384
}
1385
1386 3dea63bd Paul Kelly
void ff_reduce_index(AVFormatContext *s, int stream_index)
1387
{
1388
    AVStream *st= s->streams[stream_index];
1389
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1390
1391
    if((unsigned)st->nb_index_entries >= max_entries){
1392
        int i;
1393
        for(i=0; 2*i<st->nb_index_entries; i++)
1394
            st->index_entries[i]= st->index_entries[2*i];
1395
        st->nb_index_entries= i;
1396
    }
1397
}
1398
1399 2d9fd181 Peter Ross
int ff_add_index_entry(AVIndexEntry **index_entries,
1400
                       int *nb_index_entries,
1401
                       unsigned int *index_entries_allocated_size,
1402
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1403 fb2758c8 Fabrice Bellard
{
1404
    AVIndexEntry *entries, *ie;
1405 b754978a Michael Niedermayer
    int index;
1406 115329f1 Diego Biurrun
1407 2d9fd181 Peter Ross
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1408 568e18b1 Michael Niedermayer
        return -1;
1409 115329f1 Diego Biurrun
1410 2d9fd181 Peter Ross
    entries = av_fast_realloc(*index_entries,
1411
                              index_entries_allocated_size,
1412
                              (*nb_index_entries + 1) *
1413 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1414 568e18b1 Michael Niedermayer
    if(!entries)
1415
        return -1;
1416
1417 2d9fd181 Peter Ross
    *index_entries= entries;
1418 b754978a Michael Niedermayer
1419 2d9fd181 Peter Ross
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1420 b754978a Michael Niedermayer
1421 3ba1438d Michael Niedermayer
    if(index<0){
1422 2d9fd181 Peter Ross
        index= (*nb_index_entries)++;
1423 3e9245a9 Michael Niedermayer
        ie= &entries[index];
1424 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1425
    }else{
1426
        ie= &entries[index];
1427
        if(ie->timestamp != timestamp){
1428 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1429
                return -1;
1430 2d9fd181 Peter Ross
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1431
            (*nb_index_entries)++;
1432 755bfeab Diego Biurrun
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1433 3ba1438d Michael Niedermayer
            distance= ie->min_distance;
1434 3e9245a9 Michael Niedermayer
    }
1435 3ba1438d Michael Niedermayer
1436 b754978a Michael Niedermayer
    ie->pos = pos;
1437
    ie->timestamp = timestamp;
1438 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1439 30a43f2d Michael Niedermayer
    ie->size= size;
1440 b754978a Michael Niedermayer
    ie->flags = flags;
1441 115329f1 Diego Biurrun
1442 3e9245a9 Michael Niedermayer
    return index;
1443 fb2758c8 Fabrice Bellard
}
1444
1445 2d9fd181 Peter Ross
int av_add_index_entry(AVStream *st,
1446
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1447
{
1448
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1449
                              &st->index_entries_allocated_size, pos,
1450
                              timestamp, size, distance, flags);
1451
}
1452
1453
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1454
                              int64_t wanted_timestamp, int flags)
1455 fb2758c8 Fabrice Bellard
{
1456
    int a, b, m;
1457
    int64_t timestamp;
1458
1459 3ba1438d Michael Niedermayer
    a = - 1;
1460
    b = nb_entries;
1461 b754978a Michael Niedermayer
1462 67c10de7 Michael Niedermayer
    //optimize appending index entries at the end
1463
    if(b && entries[b-1].timestamp < wanted_timestamp)
1464
        a= b-1;
1465
1466 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1467
        m = (a + b) >> 1;
1468 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1469 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1470
            b = m;
1471
        if(timestamp <= wanted_timestamp)
1472 b754978a Michael Niedermayer
            a = m;
1473 fb2758c8 Fabrice Bellard
    }
1474 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1475 115329f1 Diego Biurrun
1476 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1477
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1478
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1479
        }
1480
    }
1481 3ba1438d Michael Niedermayer
1482 115329f1 Diego Biurrun
    if(m == nb_entries)
1483 3ba1438d Michael Niedermayer
        return -1;
1484
    return  m;
1485 fb2758c8 Fabrice Bellard
}
1486
1487 2d9fd181 Peter Ross
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1488
                              int flags)
1489
{
1490
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1491
                                     wanted_timestamp, flags);
1492
}
1493
1494 0f652a8e Benoit Fouet
#define DEBUG_SEEK
1495 8d14a25c Michael Niedermayer
1496 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1497 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1498 e6586575 Diego Biurrun
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1499 8d14a25c Michael Niedermayer
    int64_t ts_min, ts_max, ts;
1500 89ddd2a9 Michael Niedermayer
    int index;
1501 b593f7fd Sean Soria
    int64_t ret;
1502 8d14a25c Michael Niedermayer
    AVStream *st;
1503
1504 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1505
        return -1;
1506 115329f1 Diego Biurrun
1507 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1508 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1509 8d14a25c Michael Niedermayer
#endif
1510
1511
    ts_max=
1512
    ts_min= AV_NOPTS_VALUE;
1513 90b5b51e Diego Biurrun
    pos_limit= -1; //gcc falsely says it may be uninitialized
1514 8d14a25c Michael Niedermayer
1515
    st= s->streams[stream_index];
1516
    if(st->index_entries){
1517
        AVIndexEntry *e;
1518
1519 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()
1520 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1521 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1522
1523
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1524
            pos_min= e->pos;
1525
            ts_min= e->timestamp;
1526
#ifdef DEBUG_SEEK
1527 c0492097 Diego Biurrun
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1528
                   pos_min,ts_min);
1529 8d14a25c Michael Niedermayer
#endif
1530
        }else{
1531
            assert(index==0);
1532
        }
1533 115329f1 Diego Biurrun
1534
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1535 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1536
        if(index >= 0){
1537 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1538
            assert(e->timestamp >= target_ts);
1539
            pos_max= e->pos;
1540
            ts_max= e->timestamp;
1541
            pos_limit= pos_max - e->min_distance;
1542
#ifdef DEBUG_SEEK
1543 c0492097 Diego Biurrun
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1544
                   pos_max,pos_limit, ts_max);
1545 8d14a25c Michael Niedermayer
#endif
1546
        }
1547
    }
1548
1549 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);
1550
    if(pos<0)
1551
        return -1;
1552
1553
    /* do the seek */
1554 f59d8ff8 Anton Khirnov
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1555 b593f7fd Sean Soria
        return ret;
1556 89ddd2a9 Michael Niedermayer
1557
    av_update_cur_dts(s, st, ts);
1558
1559
    return 0;
1560
}
1561
1562
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 )){
1563
    int64_t pos, ts;
1564
    int64_t start_pos, filesize;
1565
    int no_change;
1566
1567
#ifdef DEBUG_SEEK
1568
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1569
#endif
1570
1571 8d14a25c Michael Niedermayer
    if(ts_min == AV_NOPTS_VALUE){
1572
        pos_min = s->data_offset;
1573 89ddd2a9 Michael Niedermayer
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1574 8d14a25c Michael Niedermayer
        if (ts_min == AV_NOPTS_VALUE)
1575
            return -1;
1576
    }
1577
1578
    if(ts_max == AV_NOPTS_VALUE){
1579
        int step= 1024;
1580 db44ea96 Anton Khirnov
        filesize = avio_size(s->pb);
1581 6fd93ce2 Kenneth Aafløy
        pos_max = filesize - 1;
1582 8d14a25c Michael Niedermayer
        do{
1583
            pos_max -= step;
1584 89ddd2a9 Michael Niedermayer
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1585 8d14a25c Michael Niedermayer
            step += step;
1586
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1587
        if (ts_max == AV_NOPTS_VALUE)
1588
            return -1;
1589 115329f1 Diego Biurrun
1590 8d14a25c Michael Niedermayer
        for(;;){
1591
            int64_t tmp_pos= pos_max + 1;
1592 89ddd2a9 Michael Niedermayer
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1593 8d14a25c Michael Niedermayer
            if(tmp_ts == AV_NOPTS_VALUE)
1594
                break;
1595
            ts_max= tmp_ts;
1596
            pos_max= tmp_pos;
1597 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1598
                break;
1599 8d14a25c Michael Niedermayer
        }
1600
        pos_limit= pos_max;
1601
    }
1602
1603 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1604
        return -1;
1605
    }else if(ts_min == ts_max){
1606
        pos_limit= pos_min;
1607
    }
1608
1609 8d14a25c Michael Niedermayer
    no_change=0;
1610
    while (pos_min < pos_limit) {
1611
#ifdef DEBUG_SEEK
1612 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1613 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1614
               ts_min, ts_max);
1615
#endif
1616
        assert(pos_limit <= pos_max);
1617
1618
        if(no_change==0){
1619
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1620
            // interpolate position (better than dichotomy)
1621 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1622
                + pos_min - approximate_keyframe_distance;
1623 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1624
            // bisection, if interpolation failed to change min or max pos last time
1625
            pos = (pos_min + pos_limit)>>1;
1626
        }else{
1627 a85736f2 Diego Biurrun
            /* linear search if bisection failed, can only happen if there
1628
               are very few or no keyframes between min/max */
1629 8d14a25c Michael Niedermayer
            pos=pos_min;
1630
        }
1631
        if(pos <= pos_min)
1632
            pos= pos_min + 1;
1633
        else if(pos > pos_limit)
1634
            pos= pos_limit;
1635
        start_pos= pos;
1636
1637 89ddd2a9 Michael Niedermayer
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1638 8d14a25c Michael Niedermayer
        if(pos == pos_max)
1639
            no_change++;
1640
        else
1641
            no_change=0;
1642
#ifdef DEBUG_SEEK
1643 c0492097 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1644
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1645
               start_pos, no_change);
1646 8d14a25c Michael Niedermayer
#endif
1647 db2a0e22 Michael Niedermayer
        if(ts == AV_NOPTS_VALUE){
1648
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1649
            return -1;
1650
        }
1651 8d14a25c Michael Niedermayer
        assert(ts != AV_NOPTS_VALUE);
1652 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1653 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1654
            pos_max = pos;
1655
            ts_max = ts;
1656 3ba1438d Michael Niedermayer
        }
1657
        if (target_ts >= ts) {
1658 8d14a25c Michael Niedermayer
            pos_min = pos;
1659
            ts_min = ts;
1660
        }
1661
    }
1662 115329f1 Diego Biurrun
1663 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1664
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1665 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1666
    pos_min = pos;
1667 89ddd2a9 Michael Niedermayer
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1668 8d14a25c Michael Niedermayer
    pos_min++;
1669 89ddd2a9 Michael Niedermayer
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1670 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1671 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1672
#endif
1673 89ddd2a9 Michael Niedermayer
    *ts_ret= ts;
1674
    return pos;
1675 8d14a25c Michael Niedermayer
}
1676
1677 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1678
    int64_t pos_min, pos_max;
1679
#if 0
1680
    AVStream *st;
1681

1682
    if (stream_index < 0)
1683
        return -1;
1684

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