Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 198ac67f

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

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

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