Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ e5026c36

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

1519
    if (stream_index < 0)
1520
        return -1;
1521

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