Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 3e4318bf

History | View | Annotate | Download (120 KB)

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

1619
    if (stream_index < 0)
1620
        return -1;
1621

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