Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 890d2799

History | View | Annotate | Download (90.8 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * Various utilities for ffmpeg system
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 4eb72c6b Nico Sabbi
#include "opt.h"
23 75e61b0e Måns Rullgård
#include "avstring.h"
24 45da8124 Aurelien Jacobs
#include "riff.h"
25 82e4ac2c Ramiro Polla
#include <sys/time.h>
26
#include <time.h>
27 c5510dd6 Philip Gladstone
28 b754978a Michael Niedermayer
#undef NDEBUG
29
#include <assert.h>
30
31 e36bdf8b Daniel Kristjansson
/**
32
 * @file libavformat/utils.c
33
 * Various utility functions for using ffmpeg library.
34
 */
35
36 f3a30e3a Luca Barbato
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37
static void av_frac_add(AVFrac *f, int64_t incr);
38
39 e36bdf8b Daniel Kristjansson
/** head of registered input format linked list. */
40 8b69867f Michael Niedermayer
AVInputFormat *first_iformat = NULL;
41 e36bdf8b Daniel Kristjansson
/** head of registered output format linked list. */
42 8b69867f Michael Niedermayer
AVOutputFormat *first_oformat = NULL;
43 de6d9b64 Fabrice Bellard
44 b9a281db Fabrice Bellard
void av_register_input_format(AVInputFormat *format)
45 de6d9b64 Fabrice Bellard
{
46 b9a281db Fabrice Bellard
    AVInputFormat **p;
47
    p = &first_iformat;
48
    while (*p != NULL) p = &(*p)->next;
49
    *p = format;
50
    format->next = NULL;
51
}
52
53
void av_register_output_format(AVOutputFormat *format)
54
{
55
    AVOutputFormat **p;
56
    p = &first_oformat;
57 de6d9b64 Fabrice Bellard
    while (*p != NULL) p = &(*p)->next;
58
    *p = format;
59
    format->next = NULL;
60
}
61
62 5b25dfa7 Fabrice Bellard
int match_ext(const char *filename, const char *extensions)
63 de6d9b64 Fabrice Bellard
{
64
    const char *ext, *p;
65
    char ext1[32], *q;
66
67 293ed23f Michael Niedermayer
    if(!filename)
68
        return 0;
69 115329f1 Diego Biurrun
70 de6d9b64 Fabrice Bellard
    ext = strrchr(filename, '.');
71
    if (ext) {
72
        ext++;
73
        p = extensions;
74
        for(;;) {
75
            q = ext1;
76 115329f1 Diego Biurrun
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
77 de6d9b64 Fabrice Bellard
                *q++ = *p++;
78
            *q = '\0';
79 115329f1 Diego Biurrun
            if (!strcasecmp(ext1, ext))
80 de6d9b64 Fabrice Bellard
                return 1;
81 115329f1 Diego Biurrun
            if (*p == '\0')
82 de6d9b64 Fabrice Bellard
                break;
83
            p++;
84
        }
85
    }
86
    return 0;
87
}
88
89 115329f1 Diego Biurrun
AVOutputFormat *guess_format(const char *short_name, const char *filename,
90 b9a281db Fabrice Bellard
                             const char *mime_type)
91 de6d9b64 Fabrice Bellard
{
92 b9a281db Fabrice Bellard
    AVOutputFormat *fmt, *fmt_found;
93 de6d9b64 Fabrice Bellard
    int score_max, score;
94
95 87a0a681 Fabrice Bellard
    /* specific test for image sequences */
96 ff70e601 Måns Rullgård
#ifdef CONFIG_IMAGE2_MUXER
97 115329f1 Diego Biurrun
    if (!short_name && filename &&
98 5c07cf53 Michel Bardiaux
        av_filename_number_test(filename) &&
99 5b6d5596 Michael Niedermayer
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
100
        return guess_format("image2", NULL, NULL);
101
    }
102 ff70e601 Måns Rullgård
#endif
103 de6d9b64 Fabrice Bellard
    /* find the proper file type */
104
    fmt_found = NULL;
105
    score_max = 0;
106 b9a281db Fabrice Bellard
    fmt = first_oformat;
107 de6d9b64 Fabrice Bellard
    while (fmt != NULL) {
108
        score = 0;
109
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
110
            score += 100;
111
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
112
            score += 10;
113 115329f1 Diego Biurrun
        if (filename && fmt->extensions &&
114 de6d9b64 Fabrice Bellard
            match_ext(filename, fmt->extensions)) {
115
            score += 5;
116
        }
117
        if (score > score_max) {
118
            score_max = score;
119
            fmt_found = fmt;
120
        }
121
        fmt = fmt->next;
122
    }
123
    return fmt_found;
124 115329f1 Diego Biurrun
}
125 de6d9b64 Fabrice Bellard
126 115329f1 Diego Biurrun
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
127 c5510dd6 Philip Gladstone
                             const char *mime_type)
128
{
129
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
130
131
    if (fmt) {
132
        AVOutputFormat *stream_fmt;
133
        char stream_format_name[64];
134
135
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
136
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
137
138
        if (stream_fmt)
139
            fmt = stream_fmt;
140
    }
141
142
    return fmt;
143
}
144
145 115329f1 Diego Biurrun
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
146 5b6d5596 Michael Niedermayer
                            const char *filename, const char *mime_type, enum CodecType type){
147
    if(type == CODEC_TYPE_VIDEO){
148
        enum CodecID codec_id= CODEC_ID_NONE;
149
150 ff70e601 Måns Rullgård
#ifdef CONFIG_IMAGE2_MUXER
151 ae214ac3 Michael Niedermayer
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
152 5b6d5596 Michael Niedermayer
            codec_id= av_guess_image2_codec(filename);
153
        }
154 ff70e601 Måns Rullgård
#endif
155 5b6d5596 Michael Niedermayer
        if(codec_id == CODEC_ID_NONE)
156
            codec_id= fmt->video_codec;
157
        return codec_id;
158
    }else if(type == CODEC_TYPE_AUDIO)
159
        return fmt->audio_codec;
160
    else
161
        return CODEC_ID_NONE;
162
}
163
164 b9a281db Fabrice Bellard
AVInputFormat *av_find_input_format(const char *short_name)
165
{
166
    AVInputFormat *fmt;
167
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
168
        if (!strcmp(fmt->name, short_name))
169
            return fmt;
170
    }
171
    return NULL;
172
}
173
174 de6d9b64 Fabrice Bellard
/* memory handling */
175
176 90ad92b3 Michael Niedermayer
void av_destruct_packet(AVPacket *pkt)
177 6fa5a56c Fabrice Bellard
{
178
    av_free(pkt->data);
179
    pkt->data = NULL; pkt->size = 0;
180
}
181
182 659596f0 Ramiro Polla
void av_init_packet(AVPacket *pkt)
183
{
184
    pkt->pts   = AV_NOPTS_VALUE;
185
    pkt->dts   = AV_NOPTS_VALUE;
186
    pkt->pos   = -1;
187
    pkt->duration = 0;
188
    pkt->flags = 0;
189
    pkt->stream_index = 0;
190
    pkt->destruct= av_destruct_packet_nofree;
191
}
192
193 de6d9b64 Fabrice Bellard
int av_new_packet(AVPacket *pkt, int size)
194
{
195 55bdd34d Baptiste Coudurier
    uint8_t *data;
196 568e18b1 Michael Niedermayer
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
197 769e10f0 Panagiotis Issaris
        return AVERROR(ENOMEM);
198 568e18b1 Michael Niedermayer
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
199 6fa5a56c Fabrice Bellard
    if (!data)
200 769e10f0 Panagiotis Issaris
        return AVERROR(ENOMEM);
201 6fa5a56c Fabrice Bellard
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
202 8cd5be98 Michael Niedermayer
203 6fa5a56c Fabrice Bellard
    av_init_packet(pkt);
204 115329f1 Diego Biurrun
    pkt->data = data;
205 6fa5a56c Fabrice Bellard
    pkt->size = size;
206
    pkt->destruct = av_destruct_packet;
207 de6d9b64 Fabrice Bellard
    return 0;
208
}
209
210 2692067a Michael Niedermayer
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
211
{
212
    int ret= av_new_packet(pkt, size);
213
214
    if(ret<0)
215
        return ret;
216
217
    pkt->pos= url_ftell(s);
218
219
    ret= get_buffer(s, pkt->data, size);
220
    if(ret<=0)
221
        av_free_packet(pkt);
222
    else
223
        pkt->size= ret;
224
225
    return ret;
226
}
227
228 fb2758c8 Fabrice Bellard
int av_dup_packet(AVPacket *pkt)
229
{
230
    if (pkt->destruct != av_destruct_packet) {
231
        uint8_t *data;
232 8a56ac7b Fabrice Bellard
        /* we duplicate the packet and don't forget to put the padding
233
           again */
234 568e18b1 Michael Niedermayer
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
235 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
236 8a56ac7b Fabrice Bellard
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
237 fb2758c8 Fabrice Bellard
        if (!data) {
238 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
239 fb2758c8 Fabrice Bellard
        }
240
        memcpy(data, pkt->data, pkt->size);
241 8a56ac7b Fabrice Bellard
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
242 fb2758c8 Fabrice Bellard
        pkt->data = data;
243
        pkt->destruct = av_destruct_packet;
244
    }
245
    return 0;
246
}
247
248 5c07cf53 Michel Bardiaux
int av_filename_number_test(const char *filename)
249 b9a281db Fabrice Bellard
{
250
    char buf[1024];
251 5c07cf53 Michel Bardiaux
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
252 b9a281db Fabrice Bellard
}
253
254 79750486 Michael Niedermayer
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
255 b9a281db Fabrice Bellard
{
256
    AVInputFormat *fmt1, *fmt;
257 79750486 Michael Niedermayer
    int score;
258 b9a281db Fabrice Bellard
259
    fmt = NULL;
260
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
261 b8e705ec Reimar Döffinger
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
262 b9a281db Fabrice Bellard
            continue;
263
        score = 0;
264 a8dbe951 Philip Gladstone
        if (fmt1->read_probe) {
265
            score = fmt1->read_probe(pd);
266
        } else if (fmt1->extensions) {
267 b9a281db Fabrice Bellard
            if (match_ext(pd->filename, fmt1->extensions)) {
268
                score = 50;
269
            }
270 115329f1 Diego Biurrun
        }
271 79750486 Michael Niedermayer
        if (score > *score_max) {
272
            *score_max = score;
273 b9a281db Fabrice Bellard
            fmt = fmt1;
274
        }
275
    }
276
    return fmt;
277
}
278
279 79750486 Michael Niedermayer
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
280
    int score=0;
281
    return av_probe_input_format2(pd, is_opened, &score);
282
}
283
284 b9a281db Fabrice Bellard
/************************************************************/
285
/* input media file */
286 96baaa6a Fabrice Bellard
287 da24c5e3 Fabrice Bellard
/**
288 e36bdf8b Daniel Kristjansson
 * Open a media file from an IO stream. 'fmt' must be specified.
289 da24c5e3 Fabrice Bellard
 */
290 43465395 Michael Niedermayer
static const char* format_to_name(void* ptr)
291 bc874dae Michel Bardiaux
{
292 43465395 Michael Niedermayer
    AVFormatContext* fc = (AVFormatContext*) ptr;
293 bc874dae Michel Bardiaux
    if(fc->iformat) return fc->iformat->name;
294
    else if(fc->oformat) return fc->oformat->name;
295
    else return "NULL";
296
}
297
298 66acccf0 Panagiotis Issaris
#define OFFSET(x) offsetof(AVFormatContext,x)
299 755bfeab Diego Biurrun
#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
300 4eb72c6b Nico Sabbi
//these names are too long to be readable
301
#define E AV_OPT_FLAG_ENCODING_PARAM
302
#define D AV_OPT_FLAG_DECODING_PARAM
303
304
static const AVOption options[]={
305 8c3dd5dc Panagiotis Issaris
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
306 09a45576 Panagiotis Issaris
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
307 4ff8fcef Panagiotis Issaris
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
308 18de0b81 Baptiste Coudurier
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
309 2c00106c Michael Niedermayer
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
310
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
311 8c3dd5dc Panagiotis Issaris
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
312 ec1b10f4 Panagiotis Issaris
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
313 e19fbbec Víctor Paesa
{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
314 4eb72c6b Nico Sabbi
{NULL},
315
};
316
317 5e89b50b Panagiotis Issaris
#undef E
318
#undef D
319
#undef DEFAULT
320
321 4eb72c6b Nico Sabbi
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
322
323 702dfe01 Baptiste Coudurier
static void avformat_get_context_defaults(AVFormatContext *s)
324
{
325 4eb72c6b Nico Sabbi
    memset(s, 0, sizeof(AVFormatContext));
326 9e6c9470 Nico Sabbi
327 73a8ceaa Panagiotis Issaris
    s->av_class = &av_format_context_class;
328
329
    av_opt_set_defaults(s);
330 4eb72c6b Nico Sabbi
}
331 bc874dae Michel Bardiaux
332
AVFormatContext *av_alloc_format_context(void)
333
{
334
    AVFormatContext *ic;
335 5894991f Panagiotis Issaris
    ic = av_malloc(sizeof(AVFormatContext));
336 bc874dae Michel Bardiaux
    if (!ic) return ic;
337 4eb72c6b Nico Sabbi
    avformat_get_context_defaults(ic);
338 43465395 Michael Niedermayer
    ic->av_class = &av_format_context_class;
339 bc874dae Michel Bardiaux
    return ic;
340
}
341
342 115329f1 Diego Biurrun
int av_open_input_stream(AVFormatContext **ic_ptr,
343
                         ByteIOContext *pb, const char *filename,
344 da24c5e3 Fabrice Bellard
                         AVInputFormat *fmt, AVFormatParameters *ap)
345
{
346
    int err;
347
    AVFormatContext *ic;
348 c04c3282 Michael Niedermayer
    AVFormatParameters default_ap;
349
350
    if(!ap){
351
        ap=&default_ap;
352
        memset(ap, 0, sizeof(default_ap));
353
    }
354 da24c5e3 Fabrice Bellard
355 4eb72c6b Nico Sabbi
    if(!ap->prealloced_context)
356
        ic = av_alloc_format_context();
357
    else
358
        ic = *ic_ptr;
359 da24c5e3 Fabrice Bellard
    if (!ic) {
360 769e10f0 Panagiotis Issaris
        err = AVERROR(ENOMEM);
361 da24c5e3 Fabrice Bellard
        goto fail;
362
    }
363
    ic->iformat = fmt;
364 899681cd Björn Axelsson
    ic->pb = pb;
365 da24c5e3 Fabrice Bellard
    ic->duration = AV_NOPTS_VALUE;
366
    ic->start_time = AV_NOPTS_VALUE;
367 75e61b0e Måns Rullgård
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
368 da24c5e3 Fabrice Bellard
369
    /* allocate private data */
370
    if (fmt->priv_data_size > 0) {
371
        ic->priv_data = av_mallocz(fmt->priv_data_size);
372
        if (!ic->priv_data) {
373 769e10f0 Panagiotis Issaris
            err = AVERROR(ENOMEM);
374 da24c5e3 Fabrice Bellard
            goto fail;
375
        }
376
    } else {
377
        ic->priv_data = NULL;
378
    }
379
380
    err = ic->iformat->read_header(ic, ap);
381
    if (err < 0)
382
        goto fail;
383 fb2758c8 Fabrice Bellard
384 faf7cbf1 Michael Niedermayer
    if (pb && !ic->data_offset)
385 899681cd Björn Axelsson
        ic->data_offset = url_ftell(ic->pb);
386 fb2758c8 Fabrice Bellard
387 da24c5e3 Fabrice Bellard
    *ic_ptr = ic;
388
    return 0;
389
 fail:
390
    if (ic) {
391
        av_freep(&ic->priv_data);
392
    }
393
    av_free(ic);
394
    *ic_ptr = NULL;
395
    return err;
396
}
397
398 e36bdf8b Daniel Kristjansson
/** Size of probe buffer, for guessing file type from file contents. */
399 a877eedc Michael Niedermayer
#define PROBE_BUF_MIN 2048
400 329b1e75 Michael Niedermayer
#define PROBE_BUF_MAX (1<<20)
401 b9a281db Fabrice Bellard
402 115329f1 Diego Biurrun
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
403 b9a281db Fabrice Bellard
                       AVInputFormat *fmt,
404
                       int buf_size,
405
                       AVFormatParameters *ap)
406 de6d9b64 Fabrice Bellard
{
407 a877eedc Michael Niedermayer
    int err, must_open_file, file_opened, probe_size;
408 b9a281db Fabrice Bellard
    AVProbeData probe_data, *pd = &probe_data;
409 899681cd Björn Axelsson
    ByteIOContext *pb;
410 115329f1 Diego Biurrun
411 da24c5e3 Fabrice Bellard
    file_opened = 0;
412
    pd->filename = "";
413
    if (filename)
414
        pd->filename = filename;
415 a877eedc Michael Niedermayer
    pd->buf = NULL;
416 b9a281db Fabrice Bellard
    pd->buf_size = 0;
417
418
    if (!fmt) {
419
        /* guess format if no file can be opened  */
420 a25e098d Fabrice Bellard
        fmt = av_probe_input_format(pd, 0);
421 de6d9b64 Fabrice Bellard
    }
422
423 b6892136 Fabrice Bellard
    /* do not open file if the format does not need it. XXX: specific
424
       hack needed to handle RTSP/TCP */
425
    must_open_file = 1;
426 da24c5e3 Fabrice Bellard
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
427 b6892136 Fabrice Bellard
        must_open_file = 0;
428 90b5b51e Diego Biurrun
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise it is uninitialized
429 b6892136 Fabrice Bellard
    }
430
431
    if (!fmt || must_open_file) {
432 87a0a681 Fabrice Bellard
        /* if no file needed do not try to open one */
433 899681cd Björn Axelsson
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
434 96baaa6a Fabrice Bellard
            goto fail;
435 b9a281db Fabrice Bellard
        }
436 da24c5e3 Fabrice Bellard
        file_opened = 1;
437 96baaa6a Fabrice Bellard
        if (buf_size > 0) {
438 da24c5e3 Fabrice Bellard
            url_setbufsize(pb, buf_size);
439 96baaa6a Fabrice Bellard
        }
440 a877eedc Michael Niedermayer
441
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
442 79750486 Michael Niedermayer
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
443 5b25dfa7 Fabrice Bellard
            /* read probe data */
444 87e87886 Michael Niedermayer
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
445 a877eedc Michael Niedermayer
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
446 9be51815 Wolfram Gloger
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
447 497244a8 Baptiste Coudurier
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
448 53e2f9ca Michael Niedermayer
                url_fclose(pb);
449 899681cd Björn Axelsson
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
450 5e43b17e Michael Niedermayer
                    file_opened = 0;
451 6f3e0b21 Panagiotis Issaris
                    err = AVERROR(EIO);
452 53e2f9ca Michael Niedermayer
                    goto fail;
453
                }
454
            }
455 a877eedc Michael Niedermayer
            /* guess file format */
456 79750486 Michael Niedermayer
            fmt = av_probe_input_format2(pd, 1, &score);
457 5b25dfa7 Fabrice Bellard
        }
458 a877eedc Michael Niedermayer
        av_freep(&pd->buf);
459 b9a281db Fabrice Bellard
    }
460
461
    /* if still no format found, error */
462
    if (!fmt) {
463
        err = AVERROR_NOFMT;
464 da24c5e3 Fabrice Bellard
        goto fail;
465 de6d9b64 Fabrice Bellard
    }
466 115329f1 Diego Biurrun
467 87a0a681 Fabrice Bellard
    /* check filename in case of an image number is expected */
468 da24c5e3 Fabrice Bellard
    if (fmt->flags & AVFMT_NEEDNUMBER) {
469 5c07cf53 Michel Bardiaux
        if (!av_filename_number_test(filename)) {
470 87a0a681 Fabrice Bellard
            err = AVERROR_NUMEXPECTED;
471 da24c5e3 Fabrice Bellard
            goto fail;
472 87a0a681 Fabrice Bellard
        }
473
    }
474 da24c5e3 Fabrice Bellard
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
475
    if (err)
476
        goto fail;
477 b9a281db Fabrice Bellard
    return 0;
478 de6d9b64 Fabrice Bellard
 fail:
479 a877eedc Michael Niedermayer
    av_freep(&pd->buf);
480 da24c5e3 Fabrice Bellard
    if (file_opened)
481
        url_fclose(pb);
482 b9a281db Fabrice Bellard
    *ic_ptr = NULL;
483
    return err;
484 115329f1 Diego Biurrun
485 de6d9b64 Fabrice Bellard
}
486
487 da24c5e3 Fabrice Bellard
/*******************************************************/
488
489 de6d9b64 Fabrice Bellard
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
490
{
491 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
492 fb2758c8 Fabrice Bellard
    return s->iformat->read_packet(s, pkt);
493
}
494
495
/**********************************************************/
496
497 e36bdf8b Daniel Kristjansson
/**
498
 * Get the number of samples of an audio frame. Return (-1) if error.
499
 */
500 fb2758c8 Fabrice Bellard
static int get_audio_frame_size(AVCodecContext *enc, int size)
501
{
502
    int frame_size;
503
504
    if (enc->frame_size <= 1) {
505 ac3e1834 Baptiste Coudurier
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
506
507
        if (bits_per_sample) {
508 fb2758c8 Fabrice Bellard
            if (enc->channels == 0)
509
                return -1;
510 f1b163e0 Aurelien Jacobs
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
511 ac3e1834 Baptiste Coudurier
        } else {
512 fb2758c8 Fabrice Bellard
            /* used for example by ADPCM codecs */
513
            if (enc->bit_rate == 0)
514
                return -1;
515
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
516
        }
517
    } else {
518
        frame_size = enc->frame_size;
519
    }
520
    return frame_size;
521
}
522
523
524 e36bdf8b Daniel Kristjansson
/**
525
 * Return the frame duration in seconds, return 0 if not available.
526
 */
527 115329f1 Diego Biurrun
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
528 fb2758c8 Fabrice Bellard
                                   AVCodecParserContext *pc, AVPacket *pkt)
529
{
530
    int frame_size;
531
532
    *pnum = 0;
533
    *pden = 0;
534 01f4895c Michael Niedermayer
    switch(st->codec->codec_type) {
535 fb2758c8 Fabrice Bellard
    case CODEC_TYPE_VIDEO:
536 1677155d Michael Niedermayer
        if(st->time_base.num*1000LL > st->time_base.den){
537 c0df9d75 Michael Niedermayer
            *pnum = st->time_base.num;
538
            *pden = st->time_base.den;
539 01f4895c Michael Niedermayer
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
540
            *pnum = st->codec->time_base.num;
541
            *pden = st->codec->time_base.den;
542 327c4076 Michael Niedermayer
            if (pc && pc->repeat_pict) {
543
                *pden *= 2;
544
                *pnum = (*pnum) * (2 + pc->repeat_pict);
545
            }
546 fb2758c8 Fabrice Bellard
        }
547
        break;
548
    case CODEC_TYPE_AUDIO:
549 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
550 fb2758c8 Fabrice Bellard
        if (frame_size < 0)
551
            break;
552
        *pnum = frame_size;
553 01f4895c Michael Niedermayer
        *pden = st->codec->sample_rate;
554 fb2758c8 Fabrice Bellard
        break;
555
    default:
556
        break;
557
    }
558
}
559
560 5ba7c3d7 Michael Niedermayer
static int is_intra_only(AVCodecContext *enc){
561
    if(enc->codec_type == CODEC_TYPE_AUDIO){
562
        return 1;
563
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
564
        switch(enc->codec_id){
565
        case CODEC_ID_MJPEG:
566
        case CODEC_ID_MJPEGB:
567
        case CODEC_ID_LJPEG:
568
        case CODEC_ID_RAWVIDEO:
569
        case CODEC_ID_DVVIDEO:
570
        case CODEC_ID_HUFFYUV:
571 f37b9768 Loren Merritt
        case CODEC_ID_FFVHUFF:
572 5ba7c3d7 Michael Niedermayer
        case CODEC_ID_ASV1:
573
        case CODEC_ID_ASV2:
574
        case CODEC_ID_VCR1:
575
            return 1;
576
        default: break;
577
        }
578
    }
579
    return 0;
580
}
581
582 9fcbcca6 Neil Brown
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
583
                                      int64_t dts, int64_t pts)
584
{
585 82583548 Michael Niedermayer
    AVStream *st= s->streams[stream_index];
586
    AVPacketList *pktl= s->packet_buffer;
587
588
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
589
        return;
590
591
    st->first_dts= dts - st->cur_dts;
592
    st->cur_dts= dts;
593
594
    for(; pktl; pktl= pktl->next){
595
        if(pktl->pkt.stream_index != stream_index)
596
            continue;
597
        //FIXME think more about this check
598
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
599
            pktl->pkt.pts += st->first_dts;
600
601
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
602
            pktl->pkt.dts += st->first_dts;
603 48a59dfe Michael Niedermayer
604
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
605
            st->start_time= pktl->pkt.pts;
606 82583548 Michael Niedermayer
    }
607 9fcbcca6 Neil Brown
    if (st->start_time == AV_NOPTS_VALUE)
608
        st->start_time = pts;
609 82583548 Michael Niedermayer
}
610
611 115329f1 Diego Biurrun
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
612 fb2758c8 Fabrice Bellard
                               AVCodecParserContext *pc, AVPacket *pkt)
613
{
614 d9e1efb7 Michael Niedermayer
    int num, den, presentation_delayed, delay, i;
615 a74008a4 Joakim Plate
    int64_t offset;
616 115329f1 Diego Biurrun
617 10a7571b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
618
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
619
        pkt->dts -= 1LL<<st->pts_wrap_bits;
620
    }
621
622 fb2758c8 Fabrice Bellard
    if (pkt->duration == 0) {
623 3c895fc0 Michael Niedermayer
        compute_frame_duration(&num, &den, st, pc, pkt);
624 fb2758c8 Fabrice Bellard
        if (den && num) {
625 77405fc8 Michael Niedermayer
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
626 fb2758c8 Fabrice Bellard
        }
627
    }
628
629 a74008a4 Joakim Plate
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
630
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
631
        /* this will estimate bitrate based on this frame's duration and size */
632
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
633
        if(pkt->pts != AV_NOPTS_VALUE)
634
            pkt->pts += offset;
635
        if(pkt->dts != AV_NOPTS_VALUE)
636
            pkt->dts += offset;
637
    }
638
639 fb2758c8 Fabrice Bellard
    /* do we have a video B frame ? */
640 befe3b05 Michael Niedermayer
    delay= st->codec->has_b_frames;
641 fb2758c8 Fabrice Bellard
    presentation_delayed = 0;
642 7e4baa66 Michael Niedermayer
    /* XXX: need has_b_frame, but cannot get it if the codec is
643
        not initialized */
644
    if (delay &&
645
        pc && pc->pict_type != FF_B_TYPE)
646
        presentation_delayed = 1;
647 755bfeab Diego Biurrun
    /* This may be redundant, but it should not hurt. */
648 7e4baa66 Michael Niedermayer
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
649
        presentation_delayed = 1;
650 115329f1 Diego Biurrun
651 e928649b Michael Niedermayer
    if(st->cur_dts == AV_NOPTS_VALUE){
652 82583548 Michael Niedermayer
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
653 e928649b Michael Niedermayer
    }
654 fb2758c8 Fabrice Bellard
655 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);
656 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
657 7e4baa66 Michael Niedermayer
    if(delay <=1){
658
        if (presentation_delayed) {
659
            /* DTS = decompression time stamp */
660
            /* PTS = presentation time stamp */
661
            if (pkt->dts == AV_NOPTS_VALUE)
662
                pkt->dts = st->last_IP_pts;
663 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
664 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
665
                pkt->dts = st->cur_dts;
666
667
            /* this is tricky: the dts must be incremented by the duration
668
            of the frame we are displaying, i.e. the last I or P frame */
669
            if (st->last_IP_duration == 0)
670
                st->last_IP_duration = pkt->duration;
671
            st->cur_dts = pkt->dts + st->last_IP_duration;
672
            st->last_IP_duration  = pkt->duration;
673
            st->last_IP_pts= pkt->pts;
674
            /* cannot compute PTS if not present (we can compute it only
675
            by knowing the futur */
676 028d6f3e Michael Niedermayer
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
677 7e4baa66 Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
678
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
679
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
680
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
681
                    pkt->pts += pkt->duration;
682
    //                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);
683
                }
684 90bb394d Michael Niedermayer
            }
685 115329f1 Diego Biurrun
686 7e4baa66 Michael Niedermayer
            /* presentation is not delayed : PTS and DTS are the same */
687
            if(pkt->pts == AV_NOPTS_VALUE)
688
                pkt->pts = pkt->dts;
689 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
690 7e4baa66 Michael Niedermayer
            if(pkt->pts == AV_NOPTS_VALUE)
691
                pkt->pts = st->cur_dts;
692
            pkt->dts = pkt->pts;
693
            st->cur_dts = pkt->pts + pkt->duration;
694
        }
695 fb2758c8 Fabrice Bellard
    }
696 d9e1efb7 Michael Niedermayer
697
    if(pkt->pts != AV_NOPTS_VALUE){
698
        st->pts_buffer[0]= pkt->pts;
699
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
700
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
701
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
702
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
703
        if(pkt->dts == AV_NOPTS_VALUE)
704
            pkt->dts= st->pts_buffer[0];
705 82583548 Michael Niedermayer
        if(delay>1){
706 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
707 82583548 Michael Niedermayer
        }
708 d9e1efb7 Michael Niedermayer
        if(pkt->dts > st->cur_dts)
709
            st->cur_dts = pkt->dts;
710
    }
711
712
//    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);
713 115329f1 Diego Biurrun
714 fb2758c8 Fabrice Bellard
    /* update flags */
715 3a1d3588 Jeff Downs
    if(is_intra_only(st->codec))
716
        pkt->flags |= PKT_FLAG_KEY;
717
    else if (pc) {
718 fb2758c8 Fabrice Bellard
        pkt->flags = 0;
719
        /* key frame computation */
720
            if (pc->pict_type == FF_I_TYPE)
721
                pkt->flags |= PKT_FLAG_KEY;
722
    }
723
}
724
725 63dd1377 Michael Niedermayer
void av_destruct_packet_nofree(AVPacket *pkt)
726 fb2758c8 Fabrice Bellard
{
727
    pkt->data = NULL; pkt->size = 0;
728
}
729
730
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
731
{
732
    AVStream *st;
733 37353960 Fabrice Bellard
    int len, ret, i;
734 fb2758c8 Fabrice Bellard
735 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
736
737 fb2758c8 Fabrice Bellard
    for(;;) {
738
        /* select current input stream component */
739
        st = s->cur_st;
740
        if (st) {
741 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
742 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
743
                /* raw data support */
744
                *pkt = s->cur_pkt;
745
                compute_pkt_fields(s, st, NULL, pkt);
746
                s->cur_st = NULL;
747 434cab9e Michael Niedermayer
                break;
748 f3356e9c Michael Niedermayer
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
749 115329f1 Diego Biurrun
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
750 6ec87caa Fabrice Bellard
                                      s->cur_ptr, s->cur_len,
751
                                      s->cur_pkt.pts, s->cur_pkt.dts);
752
                s->cur_pkt.pts = AV_NOPTS_VALUE;
753
                s->cur_pkt.dts = AV_NOPTS_VALUE;
754 fb2758c8 Fabrice Bellard
                /* increment read pointer */
755
                s->cur_ptr += len;
756
                s->cur_len -= len;
757 115329f1 Diego Biurrun
758 fb2758c8 Fabrice Bellard
                /* return packet if any */
759
                if (pkt->size) {
760 37353960 Fabrice Bellard
                got_packet:
761 711737af Daniel Cardenas
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
762 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
763
                    pkt->stream_index = st->index;
764 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
765
                    pkt->dts = st->parser->dts;
766 fb2758c8 Fabrice Bellard
                    pkt->destruct = av_destruct_packet_nofree;
767
                    compute_pkt_fields(s, st, st->parser, pkt);
768 e9b78eeb Michael Niedermayer
769
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
770
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
771
                                           0, 0, AVINDEX_KEYFRAME);
772
                    }
773
774 434cab9e Michael Niedermayer
                    break;
775 fb2758c8 Fabrice Bellard
                }
776
            } else {
777 bcbecff1 Fabrice Bellard
                /* free packet */
778 115329f1 Diego Biurrun
                av_free_packet(&s->cur_pkt);
779 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
780
            }
781
        } else {
782
            /* read next packet */
783
            ret = av_read_packet(s, &s->cur_pkt);
784 37353960 Fabrice Bellard
            if (ret < 0) {
785 8fa36ae0 François Revol
                if (ret == AVERROR(EAGAIN))
786 37353960 Fabrice Bellard
                    return ret;
787
                /* return the last frames, if any */
788
                for(i = 0; i < s->nb_streams; i++) {
789
                    st = s->streams[i];
790 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
791 115329f1 Diego Biurrun
                        av_parser_parse(st->parser, st->codec,
792
                                        &pkt->data, &pkt->size,
793
                                        NULL, 0,
794 6ec87caa Fabrice Bellard
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
795 37353960 Fabrice Bellard
                        if (pkt->size)
796
                            goto got_packet;
797
                    }
798
                }
799
                /* no more packets: really terminates parsing */
800 fb2758c8 Fabrice Bellard
                return ret;
801 37353960 Fabrice Bellard
            }
802 115329f1 Diego Biurrun
803 9ee91c2f Michael Niedermayer
            st = s->streams[s->cur_pkt.stream_index];
804 434cab9e Michael Niedermayer
            if(st->codec->debug & FF_DEBUG_PTS)
805 ccd3228e Dominik Mierzejewski
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
806 434cab9e Michael Niedermayer
                    s->cur_pkt.stream_index,
807
                    s->cur_pkt.pts,
808
                    s->cur_pkt.dts,
809
                    s->cur_pkt.size);
810 fb2758c8 Fabrice Bellard
811
            s->cur_st = st;
812
            s->cur_ptr = s->cur_pkt.data;
813
            s->cur_len = s->cur_pkt.size;
814
            if (st->need_parsing && !st->parser) {
815 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
816 fb2758c8 Fabrice Bellard
                if (!st->parser) {
817
                    /* no parser available : just output the raw packets */
818 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_NONE;
819
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
820 7cbaa7ba Michael Niedermayer
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
821 fb2758c8 Fabrice Bellard
                }
822 e9b78eeb Michael Niedermayer
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
823
                    st->parser->last_frame_offset=
824
                    st->parser->cur_offset= s->cur_pkt.pos;
825
                }
826 fb2758c8 Fabrice Bellard
            }
827
        }
828
    }
829 434cab9e Michael Niedermayer
    if(st->codec->debug & FF_DEBUG_PTS)
830 ccd3228e Dominik Mierzejewski
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
831 434cab9e Michael Niedermayer
            pkt->stream_index,
832
            pkt->pts,
833
            pkt->dts,
834
            pkt->size);
835
836
    return 0;
837 fb2758c8 Fabrice Bellard
}
838
839 02b15cc8 Michael Niedermayer
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
840
    AVPacketList *pktl= s->packet_buffer;
841
    AVPacketList **plast_pktl= &s->packet_buffer;
842
843
    while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
844
845
    pktl = av_mallocz(sizeof(AVPacketList));
846
    if (!pktl)
847
        return NULL;
848
849
    /* add the packet in the buffered packet list */
850
    *plast_pktl = pktl;
851
    pktl->pkt= *pkt;
852
    return &pktl->pkt;
853
}
854
855 fb2758c8 Fabrice Bellard
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
856
{
857 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
858 30bc6613 Michael Niedermayer
    int eof=0;
859
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
860
861
    for(;;){
862
        pktl = s->packet_buffer;
863
        if (pktl) {
864
            AVPacket *next_pkt= &pktl->pkt;
865
866
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
867
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
868 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
869 30bc6613 Michael Niedermayer
                       && next_pkt->dts < pktl->pkt.dts
870
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
871
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
872
                        next_pkt->pts= pktl->pkt.dts;
873
                    }
874
                    pktl= pktl->next;
875
                }
876
                pktl = s->packet_buffer;
877
            }
878 115329f1 Diego Biurrun
879
            if(   next_pkt->pts != AV_NOPTS_VALUE
880
               || next_pkt->dts == AV_NOPTS_VALUE
881 30bc6613 Michael Niedermayer
               || !genpts || eof){
882
                /* read packet from packet buffer, if there is data */
883
                *pkt = *next_pkt;
884
                s->packet_buffer = pktl->next;
885
                av_free(pktl);
886
                return 0;
887
            }
888
        }
889
        if(genpts){
890
            int ret= av_read_frame_internal(s, pkt);
891
            if(ret<0){
892 8fa36ae0 François Revol
                if(pktl && ret != AVERROR(EAGAIN)){
893 30bc6613 Michael Niedermayer
                    eof=1;
894
                    continue;
895
                }else
896
                    return ret;
897
            }
898 115329f1 Diego Biurrun
899 02b15cc8 Michael Niedermayer
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
900 769e10f0 Panagiotis Issaris
                return AVERROR(ENOMEM);
901 30bc6613 Michael Niedermayer
        }else{
902
            assert(!s->packet_buffer);
903
            return av_read_frame_internal(s, pkt);
904
        }
905 fb2758c8 Fabrice Bellard
    }
906
}
907
908
/* XXX: suppress the packet queue */
909
static void flush_packet_queue(AVFormatContext *s)
910
{
911
    AVPacketList *pktl;
912
913
    for(;;) {
914
        pktl = s->packet_buffer;
915 115329f1 Diego Biurrun
        if (!pktl)
916 fb2758c8 Fabrice Bellard
            break;
917
        s->packet_buffer = pktl->next;
918
        av_free_packet(&pktl->pkt);
919
        av_free(pktl);
920 b9a281db Fabrice Bellard
    }
921
}
922
923 da24c5e3 Fabrice Bellard
/*******************************************************/
924 fb2758c8 Fabrice Bellard
/* seek support */
925
926 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
927
{
928
    int i;
929
    AVStream *st;
930
931
    if (s->nb_streams <= 0)
932
        return -1;
933
    for(i = 0; i < s->nb_streams; i++) {
934
        st = s->streams[i];
935 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
936 b754978a Michael Niedermayer
            return i;
937
        }
938
    }
939
    return 0;
940
}
941
942 e36bdf8b Daniel Kristjansson
/**
943
 * Flush the frame reader.
944
 */
945 fb2758c8 Fabrice Bellard
static void av_read_frame_flush(AVFormatContext *s)
946
{
947
    AVStream *st;
948
    int i;
949
950
    flush_packet_queue(s);
951
952
    /* free previous packet */
953
    if (s->cur_st) {
954
        if (s->cur_st->parser)
955
            av_free_packet(&s->cur_pkt);
956
        s->cur_st = NULL;
957
    }
958
    /* fail safe */
959
    s->cur_ptr = NULL;
960
    s->cur_len = 0;
961 115329f1 Diego Biurrun
962 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
963
    for(i = 0; i < s->nb_streams; i++) {
964
        st = s->streams[i];
965 115329f1 Diego Biurrun
966 fb2758c8 Fabrice Bellard
        if (st->parser) {
967
            av_parser_close(st->parser);
968
            st->parser = NULL;
969
        }
970 77405fc8 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
971 a843d1ff Michael Niedermayer
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
972 fb2758c8 Fabrice Bellard
    }
973
}
974
975 22ffac70 Reimar Döffinger
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
976 8bcb147f Michael Niedermayer
    int i;
977
978
    for(i = 0; i < s->nb_streams; i++) {
979 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
980 8bcb147f Michael Niedermayer
981 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
982 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
983
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
984 8bcb147f Michael Niedermayer
    }
985
}
986
987 3e9245a9 Michael Niedermayer
int av_add_index_entry(AVStream *st,
988 30a43f2d Michael Niedermayer
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
989 fb2758c8 Fabrice Bellard
{
990
    AVIndexEntry *entries, *ie;
991 b754978a Michael Niedermayer
    int index;
992 115329f1 Diego Biurrun
993 568e18b1 Michael Niedermayer
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
994
        return -1;
995 115329f1 Diego Biurrun
996 fb2758c8 Fabrice Bellard
    entries = av_fast_realloc(st->index_entries,
997
                              &st->index_entries_allocated_size,
998 115329f1 Diego Biurrun
                              (st->nb_index_entries + 1) *
999 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1000 568e18b1 Michael Niedermayer
    if(!entries)
1001
        return -1;
1002
1003 b754978a Michael Niedermayer
    st->index_entries= entries;
1004
1005 27a5fe5f Michael Niedermayer
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1006 b754978a Michael Niedermayer
1007 3ba1438d Michael Niedermayer
    if(index<0){
1008 3e9245a9 Michael Niedermayer
        index= st->nb_index_entries++;
1009
        ie= &entries[index];
1010 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1011
    }else{
1012
        ie= &entries[index];
1013
        if(ie->timestamp != timestamp){
1014 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1015
                return -1;
1016 3ba1438d Michael Niedermayer
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1017
            st->nb_index_entries++;
1018 755bfeab Diego Biurrun
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1019 3ba1438d Michael Niedermayer
            distance= ie->min_distance;
1020 3e9245a9 Michael Niedermayer
    }
1021 3ba1438d Michael Niedermayer
1022 b754978a Michael Niedermayer
    ie->pos = pos;
1023
    ie->timestamp = timestamp;
1024 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1025 30a43f2d Michael Niedermayer
    ie->size= size;
1026 b754978a Michael Niedermayer
    ie->flags = flags;
1027 115329f1 Diego Biurrun
1028 3e9245a9 Michael Niedermayer
    return index;
1029 fb2758c8 Fabrice Bellard
}
1030
1031 dc56fc38 Michael Niedermayer
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1032 27a5fe5f Michael Niedermayer
                              int flags)
1033 fb2758c8 Fabrice Bellard
{
1034 b754978a Michael Niedermayer
    AVIndexEntry *entries= st->index_entries;
1035
    int nb_entries= st->nb_index_entries;
1036 fb2758c8 Fabrice Bellard
    int a, b, m;
1037
    int64_t timestamp;
1038
1039 3ba1438d Michael Niedermayer
    a = - 1;
1040
    b = nb_entries;
1041 b754978a Michael Niedermayer
1042 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1043
        m = (a + b) >> 1;
1044 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1045 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1046
            b = m;
1047
        if(timestamp <= wanted_timestamp)
1048 b754978a Michael Niedermayer
            a = m;
1049 fb2758c8 Fabrice Bellard
    }
1050 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1051 115329f1 Diego Biurrun
1052 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1053
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1054
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1055
        }
1056
    }
1057 3ba1438d Michael Niedermayer
1058 115329f1 Diego Biurrun
    if(m == nb_entries)
1059 3ba1438d Michael Niedermayer
        return -1;
1060
    return  m;
1061 fb2758c8 Fabrice Bellard
}
1062
1063 0f652a8e Benoit Fouet
#define DEBUG_SEEK
1064 8d14a25c Michael Niedermayer
1065 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1066 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1067
    int64_t pos_min, pos_max, pos, pos_limit;
1068
    int64_t ts_min, ts_max, ts;
1069 89ddd2a9 Michael Niedermayer
    int index;
1070 8d14a25c Michael Niedermayer
    AVStream *st;
1071
1072 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1073
        return -1;
1074 115329f1 Diego Biurrun
1075 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1076 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1077 8d14a25c Michael Niedermayer
#endif
1078
1079
    ts_max=
1080
    ts_min= AV_NOPTS_VALUE;
1081 90b5b51e Diego Biurrun
    pos_limit= -1; //gcc falsely says it may be uninitialized
1082 8d14a25c Michael Niedermayer
1083
    st= s->streams[stream_index];
1084
    if(st->index_entries){
1085
        AVIndexEntry *e;
1086
1087 27a5fe5f Michael Niedermayer
        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()
1088 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1089 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1090
1091
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1092
            pos_min= e->pos;
1093
            ts_min= e->timestamp;
1094
#ifdef DEBUG_SEEK
1095 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1096 8d14a25c Michael Niedermayer
               pos_min,ts_min);
1097
#endif
1098
        }else{
1099
            assert(index==0);
1100
        }
1101 115329f1 Diego Biurrun
1102
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1103 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1104
        if(index >= 0){
1105 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1106
            assert(e->timestamp >= target_ts);
1107
            pos_max= e->pos;
1108
            ts_max= e->timestamp;
1109
            pos_limit= pos_max - e->min_distance;
1110
#ifdef DEBUG_SEEK
1111 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1112 8d14a25c Michael Niedermayer
               pos_max,pos_limit, ts_max);
1113
#endif
1114
        }
1115
    }
1116
1117 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);
1118
    if(pos<0)
1119
        return -1;
1120
1121
    /* do the seek */
1122 899681cd Björn Axelsson
    url_fseek(s->pb, pos, SEEK_SET);
1123 89ddd2a9 Michael Niedermayer
1124
    av_update_cur_dts(s, st, ts);
1125
1126
    return 0;
1127
}
1128
1129
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 )){
1130
    int64_t pos, ts;
1131
    int64_t start_pos, filesize;
1132
    int no_change;
1133
1134
#ifdef DEBUG_SEEK
1135
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1136
#endif
1137
1138 8d14a25c Michael Niedermayer
    if(ts_min == AV_NOPTS_VALUE){
1139
        pos_min = s->data_offset;
1140 89ddd2a9 Michael Niedermayer
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1141 8d14a25c Michael Niedermayer
        if (ts_min == AV_NOPTS_VALUE)
1142
            return -1;
1143
    }
1144
1145
    if(ts_max == AV_NOPTS_VALUE){
1146
        int step= 1024;
1147 899681cd Björn Axelsson
        filesize = url_fsize(s->pb);
1148 6fd93ce2 Kenneth Aafløy
        pos_max = filesize - 1;
1149 8d14a25c Michael Niedermayer
        do{
1150
            pos_max -= step;
1151 89ddd2a9 Michael Niedermayer
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1152 8d14a25c Michael Niedermayer
            step += step;
1153
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1154
        if (ts_max == AV_NOPTS_VALUE)
1155
            return -1;
1156 115329f1 Diego Biurrun
1157 8d14a25c Michael Niedermayer
        for(;;){
1158
            int64_t tmp_pos= pos_max + 1;
1159 89ddd2a9 Michael Niedermayer
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1160 8d14a25c Michael Niedermayer
            if(tmp_ts == AV_NOPTS_VALUE)
1161
                break;
1162
            ts_max= tmp_ts;
1163
            pos_max= tmp_pos;
1164 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1165
                break;
1166 8d14a25c Michael Niedermayer
        }
1167
        pos_limit= pos_max;
1168
    }
1169
1170 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1171
        return -1;
1172
    }else if(ts_min == ts_max){
1173
        pos_limit= pos_min;
1174
    }
1175
1176 8d14a25c Michael Niedermayer
    no_change=0;
1177
    while (pos_min < pos_limit) {
1178
#ifdef DEBUG_SEEK
1179 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1180 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1181
               ts_min, ts_max);
1182
#endif
1183
        assert(pos_limit <= pos_max);
1184
1185
        if(no_change==0){
1186
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1187
            // interpolate position (better than dichotomy)
1188 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1189
                + pos_min - approximate_keyframe_distance;
1190 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1191
            // bisection, if interpolation failed to change min or max pos last time
1192
            pos = (pos_min + pos_limit)>>1;
1193
        }else{
1194
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1195
            pos=pos_min;
1196
        }
1197
        if(pos <= pos_min)
1198
            pos= pos_min + 1;
1199
        else if(pos > pos_limit)
1200
            pos= pos_limit;
1201
        start_pos= pos;
1202
1203 89ddd2a9 Michael Niedermayer
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1204 8d14a25c Michael Niedermayer
        if(pos == pos_max)
1205
            no_change++;
1206
        else
1207
            no_change=0;
1208
#ifdef DEBUG_SEEK
1209 4733abcb Måns Rullgård
av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1210 8d14a25c Michael Niedermayer
#endif
1211 db2a0e22 Michael Niedermayer
        if(ts == AV_NOPTS_VALUE){
1212
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1213
            return -1;
1214
        }
1215 8d14a25c Michael Niedermayer
        assert(ts != AV_NOPTS_VALUE);
1216 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1217 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1218
            pos_max = pos;
1219
            ts_max = ts;
1220 3ba1438d Michael Niedermayer
        }
1221
        if (target_ts >= ts) {
1222 8d14a25c Michael Niedermayer
            pos_min = pos;
1223
            ts_min = ts;
1224
        }
1225
    }
1226 115329f1 Diego Biurrun
1227 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1228
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1229 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1230
    pos_min = pos;
1231 89ddd2a9 Michael Niedermayer
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1232 8d14a25c Michael Niedermayer
    pos_min++;
1233 89ddd2a9 Michael Niedermayer
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1234 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1235 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1236
#endif
1237 89ddd2a9 Michael Niedermayer
    *ts_ret= ts;
1238
    return pos;
1239 8d14a25c Michael Niedermayer
}
1240
1241 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1242
    int64_t pos_min, pos_max;
1243
#if 0
1244
    AVStream *st;
1245

1246
    if (stream_index < 0)
1247
        return -1;
1248

1249
    st= s->streams[stream_index];
1250
#endif
1251
1252
    pos_min = s->data_offset;
1253 899681cd Björn Axelsson
    pos_max = url_fsize(s->pb) - 1;
1254 3ba1438d Michael Niedermayer
1255
    if     (pos < pos_min) pos= pos_min;
1256
    else if(pos > pos_max) pos= pos_max;
1257
1258 899681cd Björn Axelsson
    url_fseek(s->pb, pos, SEEK_SET);
1259 3ba1438d Michael Niedermayer
1260
#if 0
1261 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ts);
1262 3ba1438d Michael Niedermayer
#endif
1263
    return 0;
1264
}
1265
1266 115329f1 Diego Biurrun
static int av_seek_frame_generic(AVFormatContext *s,
1267 3ba1438d Michael Niedermayer
                                 int stream_index, int64_t timestamp, int flags)
1268 fb2758c8 Fabrice Bellard
{
1269 8bcb147f Michael Niedermayer
    int index;
1270 fb2758c8 Fabrice Bellard
    AVStream *st;
1271
    AVIndexEntry *ie;
1272
1273
    st = s->streams[stream_index];
1274 e9b78eeb Michael Niedermayer
1275 27a5fe5f Michael Niedermayer
    index = av_index_search_timestamp(st, timestamp, flags);
1276 e9b78eeb Michael Niedermayer
1277 b5a3541d Michael Niedermayer
    if(index < 0 || index==st->nb_index_entries-1){
1278 e9b78eeb Michael Niedermayer
        int i;
1279
        AVPacket pkt;
1280
1281
        if(st->index_entries && st->nb_index_entries){
1282
            ie= &st->index_entries[st->nb_index_entries-1];
1283 899681cd Björn Axelsson
            url_fseek(s->pb, ie->pos, SEEK_SET);
1284 e9b78eeb Michael Niedermayer
            av_update_cur_dts(s, st, ie->timestamp);
1285
        }else
1286 899681cd Björn Axelsson
            url_fseek(s->pb, 0, SEEK_SET);
1287 e9b78eeb Michael Niedermayer
1288
        for(i=0;; i++) {
1289
            int ret = av_read_frame(s, &pkt);
1290
            if(ret<0)
1291
                break;
1292
            av_free_packet(&pkt);
1293
            if(stream_index == pkt.stream_index){
1294
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1295
                    break;
1296
            }
1297
        }
1298
        index = av_index_search_timestamp(st, timestamp, flags);
1299
    }
1300 fb2758c8 Fabrice Bellard
    if (index < 0)
1301
        return -1;
1302
1303
    av_read_frame_flush(s);
1304 e9b78eeb Michael Niedermayer
    if (s->iformat->read_seek){
1305
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1306
            return 0;
1307
    }
1308
    ie = &st->index_entries[index];
1309 899681cd Björn Axelsson
    url_fseek(s->pb, ie->pos, SEEK_SET);
1310 3ba1438d Michael Niedermayer
1311 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ie->timestamp);
1312 cdd5034f Michael Niedermayer
1313 fb2758c8 Fabrice Bellard
    return 0;
1314
}
1315
1316 3ba1438d Michael Niedermayer
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1317 fb2758c8 Fabrice Bellard
{
1318
    int ret;
1319 cdd5034f Michael Niedermayer
    AVStream *st;
1320 115329f1 Diego Biurrun
1321 fb2758c8 Fabrice Bellard
    av_read_frame_flush(s);
1322 115329f1 Diego Biurrun
1323 3ba1438d Michael Niedermayer
    if(flags & AVSEEK_FLAG_BYTE)
1324
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1325 115329f1 Diego Biurrun
1326 cdd5034f Michael Niedermayer
    if(stream_index < 0){
1327
        stream_index= av_find_default_stream_index(s);
1328
        if(stream_index < 0)
1329
            return -1;
1330 115329f1 Diego Biurrun
1331 3ba1438d Michael Niedermayer
        st= s->streams[stream_index];
1332 eb497825 Nathan Kurz
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1333 3ba1438d Michael Niedermayer
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1334 cdd5034f Michael Niedermayer
    }
1335
    st= s->streams[stream_index];
1336
1337 fb2758c8 Fabrice Bellard
    /* first, we try the format specific seek */
1338
    if (s->iformat->read_seek)
1339 3ba1438d Michael Niedermayer
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1340 fb2758c8 Fabrice Bellard
    else
1341
        ret = -1;
1342
    if (ret >= 0) {
1343
        return 0;
1344
    }
1345 8d14a25c Michael Niedermayer
1346
    if(s->iformat->read_timestamp)
1347 3ba1438d Michael Niedermayer
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1348 8d14a25c Michael Niedermayer
    else
1349 3ba1438d Michael Niedermayer
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1350 fb2758c8 Fabrice Bellard
}
1351
1352
/*******************************************************/
1353 12f996ed Fabrice Bellard
1354 e36bdf8b Daniel Kristjansson
/**
1355 c1e8b678 Neil Brown
 * Returns TRUE if the stream has accurate duration in any stream.
1356 e36bdf8b Daniel Kristjansson
 *
1357 c1e8b678 Neil Brown
 * @return TRUE if the stream has accurate duration for at least one component.
1358 e36bdf8b Daniel Kristjansson
 */
1359 c1e8b678 Neil Brown
static int av_has_duration(AVFormatContext *ic)
1360 12f996ed Fabrice Bellard
{
1361
    int i;
1362
    AVStream *st;
1363
1364
    for(i = 0;i < ic->nb_streams; i++) {
1365
        st = ic->streams[i];
1366 c1e8b678 Neil Brown
        if (st->duration != AV_NOPTS_VALUE)
1367 12f996ed Fabrice Bellard
            return 1;
1368
    }
1369
    return 0;
1370
}
1371
1372 e36bdf8b Daniel Kristjansson
/**
1373
 * Estimate the stream timings from the one of each components.
1374
 *
1375
 * Also computes the global bitrate if possible.
1376
 */
1377 12f996ed Fabrice Bellard
static void av_update_stream_timings(AVFormatContext *ic)
1378
{
1379 c0df9d75 Michael Niedermayer
    int64_t start_time, start_time1, end_time, end_time1;
1380 c1e8b678 Neil Brown
    int64_t duration, duration1;
1381 12f996ed Fabrice Bellard
    int i;
1382
    AVStream *st;
1383
1384 f27a7268 Måns Rullgård
    start_time = INT64_MAX;
1385
    end_time = INT64_MIN;
1386 c1e8b678 Neil Brown
    duration = INT64_MIN;
1387 12f996ed Fabrice Bellard
    for(i = 0;i < ic->nb_streams; i++) {
1388
        st = ic->streams[i];
1389
        if (st->start_time != AV_NOPTS_VALUE) {
1390 c0df9d75 Michael Niedermayer
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1391
            if (start_time1 < start_time)
1392
                start_time = start_time1;
1393 12f996ed Fabrice Bellard
            if (st->duration != AV_NOPTS_VALUE) {
1394 c0df9d75 Michael Niedermayer
                end_time1 = start_time1
1395
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1396 12f996ed Fabrice Bellard
                if (end_time1 > end_time)
1397
                    end_time = end_time1;
1398
            }
1399
        }
1400 c1e8b678 Neil Brown
        if (st->duration != AV_NOPTS_VALUE) {
1401
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1402
            if (duration1 > duration)
1403
                duration = duration1;
1404
        }
1405 12f996ed Fabrice Bellard
    }
1406 f27a7268 Måns Rullgård
    if (start_time != INT64_MAX) {
1407 12f996ed Fabrice Bellard
        ic->start_time = start_time;
1408 f27a7268 Måns Rullgård
        if (end_time != INT64_MIN) {
1409 c1e8b678 Neil Brown
            if (end_time - start_time > duration)
1410
                duration = end_time - start_time;
1411
        }
1412
    }
1413
    if (duration != INT64_MIN) {
1414
        ic->duration = duration;
1415
        if (ic->file_size > 0) {
1416
            /* compute the bit rate */
1417
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1418
                (double)ic->duration;
1419 12f996ed Fabrice Bellard
        }
1420
    }
1421
}
1422
1423
static void fill_all_stream_timings(AVFormatContext *ic)
1424
{
1425
    int i;
1426
    AVStream *st;
1427
1428
    av_update_stream_timings(ic);
1429
    for(i = 0;i < ic->nb_streams; i++) {
1430
        st = ic->streams[i];
1431
        if (st->start_time == AV_NOPTS_VALUE) {
1432 c0df9d75 Michael Niedermayer
            if(ic->start_time != AV_NOPTS_VALUE)
1433
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1434
            if(ic->duration != AV_NOPTS_VALUE)
1435
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1436 12f996ed Fabrice Bellard
        }
1437
    }
1438
}
1439
1440
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1441
{
1442
    int64_t filesize, duration;
1443
    int bit_rate, i;
1444
    AVStream *st;
1445
1446
    /* if bit_rate is already set, we believe it */
1447
    if (ic->bit_rate == 0) {
1448
        bit_rate = 0;
1449
        for(i=0;i<ic->nb_streams;i++) {
1450
            st = ic->streams[i];
1451 01f4895c Michael Niedermayer
            bit_rate += st->codec->bit_rate;
1452 12f996ed Fabrice Bellard
        }
1453
        ic->bit_rate = bit_rate;
1454
    }
1455
1456
    /* if duration is already set, we believe it */
1457 115329f1 Diego Biurrun
    if (ic->duration == AV_NOPTS_VALUE &&
1458
        ic->bit_rate != 0 &&
1459 12f996ed Fabrice Bellard
        ic->file_size != 0)  {
1460
        filesize = ic->file_size;
1461
        if (filesize > 0) {
1462
            for(i = 0; i < ic->nb_streams; i++) {
1463
                st = ic->streams[i];
1464 c0df9d75 Michael Niedermayer
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1465 9f32041d Neil Brown
                if (st->duration == AV_NOPTS_VALUE)
1466 12f996ed Fabrice Bellard
                    st->duration = duration;
1467
            }
1468
        }
1469
    }
1470
}
1471
1472
#define DURATION_MAX_READ_SIZE 250000
1473
1474
/* only usable for MPEG-PS streams */
1475 9ecf7fad Wolfram Gloger
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1476 12f996ed Fabrice Bellard
{
1477
    AVPacket pkt1, *pkt = &pkt1;
1478
    AVStream *st;
1479
    int read_size, i, ret;
1480 bf4e3bd2 Måns Rullgård
    int64_t end_time;
1481 12f996ed Fabrice Bellard
    int64_t filesize, offset, duration;
1482 115329f1 Diego Biurrun
1483 578688fa Luca Abeni
    /* free previous packet */
1484
    if (ic->cur_st && ic->cur_st->parser)
1485
        av_free_packet(&ic->cur_pkt);
1486
    ic->cur_st = NULL;
1487
1488
    /* flush packet queue */
1489
    flush_packet_queue(ic);
1490
1491
    for(i=0;i<ic->nb_streams;i++) {
1492
        st = ic->streams[i];
1493
        if (st->parser) {
1494
            av_parser_close(st->parser);
1495
            st->parser= NULL;
1496
        }
1497
    }
1498 115329f1 Diego Biurrun
1499 12f996ed Fabrice Bellard
    /* we read the first packets to get the first PTS (not fully
1500
       accurate, but it is enough now) */
1501 899681cd Björn Axelsson
    url_fseek(ic->pb, 0, SEEK_SET);
1502 12f996ed Fabrice Bellard
    read_size = 0;
1503
    for(;;) {
1504
        if (read_size >= DURATION_MAX_READ_SIZE)
1505
            break;
1506
        /* if all info is available, we can stop */
1507
        for(i = 0;i < ic->nb_streams; i++) {
1508
            st = ic->streams[i];
1509
            if (st->start_time == AV_NOPTS_VALUE)
1510
                break;
1511
        }
1512
        if (i == ic->nb_streams)
1513
            break;
1514
1515
        ret = av_read_packet(ic, pkt);
1516
        if (ret != 0)
1517
            break;
1518
        read_size += pkt->size;
1519
        st = ic->streams[pkt->stream_index];
1520
        if (pkt->pts != AV_NOPTS_VALUE) {
1521
            if (st->start_time == AV_NOPTS_VALUE)
1522 c0df9d75 Michael Niedermayer
                st->start_time = pkt->pts;
1523 0a5f92a1 Michael Niedermayer
        }
1524
        av_free_packet(pkt);
1525
    }
1526 12f996ed Fabrice Bellard
1527
    /* estimate the end time (duration) */
1528
    /* XXX: may need to support wrapping */
1529
    filesize = ic->file_size;
1530
    offset = filesize - DURATION_MAX_READ_SIZE;
1531
    if (offset < 0)
1532
        offset = 0;
1533
1534 899681cd Björn Axelsson
    url_fseek(ic->pb, offset, SEEK_SET);
1535 12f996ed Fabrice Bellard
    read_size = 0;
1536
    for(;;) {
1537
        if (read_size >= DURATION_MAX_READ_SIZE)
1538
            break;
1539 115329f1 Diego Biurrun
1540 12f996ed Fabrice Bellard
        ret = av_read_packet(ic, pkt);
1541
        if (ret != 0)
1542
            break;
1543
        read_size += pkt->size;
1544
        st = ic->streams[pkt->stream_index];
1545 bf494092 Neil Brown
        if (pkt->pts != AV_NOPTS_VALUE &&
1546
            st->start_time != AV_NOPTS_VALUE) {
1547 c0df9d75 Michael Niedermayer
            end_time = pkt->pts;
1548 12f996ed Fabrice Bellard
            duration = end_time - st->start_time;
1549
            if (duration > 0) {
1550
                if (st->duration == AV_NOPTS_VALUE ||
1551
                    st->duration < duration)
1552
                    st->duration = duration;
1553
            }
1554
        }
1555
        av_free_packet(pkt);
1556
    }
1557 115329f1 Diego Biurrun
1558 c0df9d75 Michael Niedermayer
    fill_all_stream_timings(ic);
1559 12f996ed Fabrice Bellard
1560 899681cd Björn Axelsson
    url_fseek(ic->pb, old_offset, SEEK_SET);
1561 df886e7e Michael Niedermayer
    for(i=0; i<ic->nb_streams; i++){
1562
        st= ic->streams[i];
1563
        st->cur_dts= st->first_dts;
1564 cc5297e8 Wolfram Gloger
        st->last_IP_pts = AV_NOPTS_VALUE;
1565 df886e7e Michael Niedermayer
    }
1566 12f996ed Fabrice Bellard
}
1567
1568 9ecf7fad Wolfram Gloger
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1569 12f996ed Fabrice Bellard
{
1570
    int64_t file_size;
1571
1572
    /* get the file size, if possible */
1573
    if (ic->iformat->flags & AVFMT_NOFILE) {
1574
        file_size = 0;
1575
    } else {
1576 899681cd Björn Axelsson
        file_size = url_fsize(ic->pb);
1577 12f996ed Fabrice Bellard
        if (file_size < 0)
1578
            file_size = 0;
1579
    }
1580
    ic->file_size = file_size;
1581
1582 ff70e601 Måns Rullgård
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1583
         !strcmp(ic->iformat->name, "mpegts")) &&
1584 899681cd Björn Axelsson
        file_size && !ic->pb->is_streamed) {
1585 12f996ed Fabrice Bellard
        /* get accurate estimate from the PTSes */
1586 9ecf7fad Wolfram Gloger
        av_estimate_timings_from_pts(ic, old_offset);
1587 c1e8b678 Neil Brown
    } else if (av_has_duration(ic)) {
1588 12f996ed Fabrice Bellard
        /* at least one components has timings - we use them for all
1589
           the components */
1590
        fill_all_stream_timings(ic);
1591
    } else {
1592
        /* less precise: use bit rate info */
1593
        av_estimate_timings_from_bit_rate(ic);
1594
    }
1595
    av_update_stream_timings(ic);
1596
1597
#if 0
1598
    {
1599
        int i;
1600
        AVStream *st;
1601
        for(i = 0;i < ic->nb_streams; i++) {
1602
            st = ic->streams[i];
1603 115329f1 Diego Biurrun
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1604
               i, (double)st->start_time / AV_TIME_BASE,
1605 12f996ed Fabrice Bellard
               (double)st->duration / AV_TIME_BASE);
1606
        }
1607 115329f1 Diego Biurrun
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1608
               (double)ic->start_time / AV_TIME_BASE,
1609 12f996ed Fabrice Bellard
               (double)ic->duration / AV_TIME_BASE,
1610
               ic->bit_rate / 1000);
1611
    }
1612
#endif
1613
}
1614
1615 b9a281db Fabrice Bellard
static int has_codec_parameters(AVCodecContext *enc)
1616
{
1617
    int val;
1618
    switch(enc->codec_type) {
1619
    case CODEC_TYPE_AUDIO:
1620
        val = enc->sample_rate;
1621
        break;
1622
    case CODEC_TYPE_VIDEO:
1623 644a9262 Michael Niedermayer
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1624 b9a281db Fabrice Bellard
        break;
1625
    default:
1626
        val = 1;
1627
        break;
1628
    }
1629 3303926c Ronald S. Bultje
    return (enc->codec_id != CODEC_ID_NONE && val != 0);
1630 b9a281db Fabrice Bellard
}
1631
1632 fb2758c8 Fabrice Bellard
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1633
{
1634
    int16_t *samples;
1635
    AVCodec *codec;
1636 3fdb6af9 Baptiste Coudurier
    int got_picture, data_size, ret=0;
1637 fb2758c8 Fabrice Bellard
    AVFrame picture;
1638 115329f1 Diego Biurrun
1639 01f4895c Michael Niedermayer
  if(!st->codec->codec){
1640
    codec = avcodec_find_decoder(st->codec->codec_id);
1641 fb2758c8 Fabrice Bellard
    if (!codec)
1642
        return -1;
1643 01f4895c Michael Niedermayer
    ret = avcodec_open(st->codec, codec);
1644 fb2758c8 Fabrice Bellard
    if (ret < 0)
1645
        return ret;
1646 43c0040a Michael Niedermayer
  }
1647 644a9262 Michael Niedermayer
1648 01f4895c Michael Niedermayer
  if(!has_codec_parameters(st->codec)){
1649
    switch(st->codec->codec_type) {
1650 fb2758c8 Fabrice Bellard
    case CODEC_TYPE_VIDEO:
1651 115329f1 Diego Biurrun
        ret = avcodec_decode_video(st->codec, &picture,
1652 fb2758c8 Fabrice Bellard
                                   &got_picture, (uint8_t *)data, size);
1653
        break;
1654
    case CODEC_TYPE_AUDIO:
1655 3fdb6af9 Baptiste Coudurier
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1656
        samples = av_malloc(data_size);
1657 fb2758c8 Fabrice Bellard
        if (!samples)
1658
            goto fail;
1659 3fdb6af9 Baptiste Coudurier
        ret = avcodec_decode_audio2(st->codec, samples,
1660
                                    &data_size, (uint8_t *)data, size);
1661 fb2758c8 Fabrice Bellard
        av_free(samples);
1662
        break;
1663
    default:
1664
        break;
1665
    }
1666 644a9262 Michael Niedermayer
  }
1667 fb2758c8 Fabrice Bellard
 fail:
1668
    return ret;
1669
}
1670
1671 6fea687e John Donaghy
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1672
{
1673
    AVInputFormat *fmt;
1674
    fmt = av_probe_input_format2(pd, 1, &score);
1675
1676
    if (fmt) {
1677
        if (strncmp(fmt->name, "mp3", 3) == 0)
1678
            st->codec->codec_id = CODEC_ID_MP3;
1679
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1680
            st->codec->codec_id = CODEC_ID_AC3;
1681
    }
1682 efd5fc53 Benoit Fouet
    return !!fmt;
1683 6fea687e John Donaghy
}
1684
1685 45da8124 Aurelien Jacobs
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1686
{
1687
    while (tags->id != CODEC_ID_NONE) {
1688
        if (tags->id == id)
1689
            return tags->tag;
1690
        tags++;
1691
    }
1692
    return 0;
1693
}
1694
1695
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1696
{
1697 41415d28 Michael Niedermayer
    int i;
1698
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1699
        if(tag == tags[i].tag)
1700
            return tags[i].id;
1701
    }
1702
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1703
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1704
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1705
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1706
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1707
            return tags[i].id;
1708 45da8124 Aurelien Jacobs
    }
1709
    return CODEC_ID_NONE;
1710
}
1711
1712
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1713
{
1714
    int i;
1715
    for(i=0; tags && tags[i]; i++){
1716
        int tag= codec_get_tag(tags[i], id);
1717
        if(tag) return tag;
1718
    }
1719
    return 0;
1720
}
1721
1722
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1723
{
1724
    int i;
1725
    for(i=0; tags && tags[i]; i++){
1726
        enum CodecID id= codec_get_id(tags[i], tag);
1727
        if(id!=CODEC_ID_NONE) return id;
1728
    }
1729
    return CODEC_ID_NONE;
1730
}
1731
1732 fb2758c8 Fabrice Bellard
/* absolute maximum size we read until we abort */
1733
#define MAX_READ_SIZE        5000000
1734
1735 fd97f6a2 Michael Niedermayer
#define MAX_STD_TIMEBASES (60*12+5)
1736 4d43cbcc Michael Niedermayer
static int get_std_framerate(int i){
1737
    if(i<60*12) return i*1001;
1738 fd97f6a2 Michael Niedermayer
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1739 4d43cbcc Michael Niedermayer
}
1740
1741 b9a281db Fabrice Bellard
int av_find_stream_info(AVFormatContext *ic)
1742
{
1743 9f75260e Michael Niedermayer
    int i, count, ret, read_size, j;
1744 b9a281db Fabrice Bellard
    AVStream *st;
1745 fb2758c8 Fabrice Bellard
    AVPacket pkt1, *pkt;
1746 15bc38e5 Michael Niedermayer
    int64_t last_dts[MAX_STREAMS];
1747 3c150d16 Michael Niedermayer
    int duration_count[MAX_STREAMS]={0};
1748 0cbff027 Kristian Amlie
    double (*duration_error)[MAX_STD_TIMEBASES];
1749 899681cd Björn Axelsson
    offset_t old_offset = url_ftell(ic->pb);
1750 ea486ab3 Baptiste Coudurier
    int64_t codec_info_duration[MAX_STREAMS]={0};
1751
    int codec_info_nb_frames[MAX_STREAMS]={0};
1752 6fea687e John Donaghy
    AVProbeData probe_data[MAX_STREAMS];
1753
    int codec_identified[MAX_STREAMS]={0};
1754 b9a281db Fabrice Bellard
1755 0cbff027 Kristian Amlie
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1756 769e10f0 Panagiotis Issaris
    if (!duration_error) return AVERROR(ENOMEM);
1757 0cbff027 Kristian Amlie
1758 c0df9d75 Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
1759
        st = ic->streams[i];
1760 01f4895c Michael Niedermayer
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1761 c0df9d75 Michael Niedermayer
/*            if(!st->time_base.num)
1762
                st->time_base= */
1763 01f4895c Michael Niedermayer
            if(!st->codec->time_base.num)
1764
                st->codec->time_base= st->time_base;
1765 c0df9d75 Michael Niedermayer
        }
1766 90ad92b3 Michael Niedermayer
        //only for the split stuff
1767
        if (!st->parser) {
1768 01f4895c Michael Niedermayer
            st->parser = av_parser_init(st->codec->codec_id);
1769 57004ff1 Aurelien Jacobs
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1770 7cbaa7ba Michael Niedermayer
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1771
            }
1772 90ad92b3 Michael Niedermayer
        }
1773 c0df9d75 Michael Niedermayer
    }
1774
1775 15bc38e5 Michael Niedermayer
    for(i=0;i<MAX_STREAMS;i++){
1776
        last_dts[i]= AV_NOPTS_VALUE;
1777
    }
1778 115329f1 Diego Biurrun
1779 6fea687e John Donaghy
    memset(probe_data, 0, sizeof(probe_data));
1780 b9a281db Fabrice Bellard
    count = 0;
1781
    read_size = 0;
1782
    for(;;) {
1783
        /* check if one codec still needs to be handled */
1784
        for(i=0;i<ic->nb_streams;i++) {
1785
            st = ic->streams[i];
1786 01f4895c Michael Niedermayer
            if (!has_codec_parameters(st->codec))
1787 b9a281db Fabrice Bellard
                break;
1788 3e76d1b5 Michael Niedermayer
            /* variable fps and no guess at the real fps */
1789 6cc65ab3 Michael Niedermayer
            if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1790 01f4895c Michael Niedermayer
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1791 3e76d1b5 Michael Niedermayer
                break;
1792 01f4895c Michael Niedermayer
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1793 90ad92b3 Michael Niedermayer
                break;
1794 82583548 Michael Niedermayer
            if(st->first_dts == AV_NOPTS_VALUE)
1795
                break;
1796 b9a281db Fabrice Bellard
        }
1797
        if (i == ic->nb_streams) {
1798
            /* NOTE: if the format has no header, then we need to read
1799
               some packets to get most of the streams, so we cannot
1800
               stop here */
1801 fb2758c8 Fabrice Bellard
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1802 b9a281db Fabrice Bellard
                /* if we found the info for all the codecs, we can stop */
1803
                ret = count;
1804
                break;
1805
            }
1806 5fb83c38 Michael Niedermayer
        }
1807 35eab0c0 Michael Niedermayer
        /* we did not get all the codec info, but we read too much data */
1808
        if (read_size >= MAX_READ_SIZE) {
1809
            ret = count;
1810
            break;
1811
        }
1812 b9a281db Fabrice Bellard
1813 fb2758c8 Fabrice Bellard
        /* NOTE: a new stream can be added there if no header in file
1814
           (AVFMTCTX_NOHEADER) */
1815
        ret = av_read_frame_internal(ic, &pkt1);
1816
        if (ret < 0) {
1817
            /* EOF or error */
1818
            ret = -1; /* we could not have all the codec parameters before EOF */
1819 e19456e3 Michael Niedermayer
            for(i=0;i<ic->nb_streams;i++) {
1820
                st = ic->streams[i];
1821 305ee50f Michael Niedermayer
                if (!has_codec_parameters(st->codec)){
1822
                    char buf[256];
1823
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1824
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1825 344a18c3 Måns Rullgård
                } else {
1826
                    ret = 0;
1827 305ee50f Michael Niedermayer
                }
1828 e19456e3 Michael Niedermayer
            }
1829 fb2758c8 Fabrice Bellard
            break;
1830
        }
1831
1832 02b15cc8 Michael Niedermayer
        pkt= add_to_pktbuf(ic, &pkt1);
1833
        if(av_dup_packet(pkt) < 0)
1834
            return AVERROR(ENOMEM);
1835 b9a281db Fabrice Bellard
1836 fb2758c8 Fabrice Bellard
        read_size += pkt->size;
1837 b9a281db Fabrice Bellard
1838
        st = ic->streams[pkt->stream_index];
1839 ea486ab3 Baptiste Coudurier
        if(codec_info_nb_frames[st->index]>1)
1840
            codec_info_duration[st->index] += pkt->duration;
1841 fb2758c8 Fabrice Bellard
        if (pkt->duration != 0)
1842 ea486ab3 Baptiste Coudurier
            codec_info_nb_frames[st->index]++;
1843 fb2758c8 Fabrice Bellard
1844 cefe0607 Michael Niedermayer
        {
1845 3c150d16 Michael Niedermayer
            int index= pkt->stream_index;
1846
            int64_t last= last_dts[index];
1847
            int64_t duration= pkt->dts - last;
1848
1849
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1850 4d43cbcc Michael Niedermayer
                double dur= duration * av_q2d(st->time_base);
1851
1852
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1853
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1854 1694118b Michael Niedermayer
                if(duration_count[index] < 2)
1855 0cbff027 Kristian Amlie
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1856 69c262d1 Michael Niedermayer
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1857
                    int framerate= get_std_framerate(i);
1858
                    int ticks= lrintf(dur*framerate/(1001*12));
1859
                    double error= dur - ticks*1001*12/(double)framerate;
1860
                    duration_error[index][i] += error*error;
1861
                }
1862 4d43cbcc Michael Niedermayer
                duration_count[index]++;
1863 15bc38e5 Michael Niedermayer
            }
1864 fd97f6a2 Michael Niedermayer
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1865
                last_dts[pkt->stream_index]= pkt->dts;
1866 6fea687e John Donaghy
1867
            if (st->codec->codec_id == CODEC_ID_NONE) {
1868
                AVProbeData *pd = &(probe_data[st->index]);
1869 9be51815 Wolfram Gloger
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1870 6fea687e John Donaghy
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1871
                pd->buf_size += pkt->size;
1872 9be51815 Wolfram Gloger
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1873 6fea687e John Donaghy
            }
1874 15bc38e5 Michael Niedermayer
        }
1875 01f4895c Michael Niedermayer
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1876
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1877 90ad92b3 Michael Niedermayer
            if(i){
1878 01f4895c Michael Niedermayer
                st->codec->extradata_size= i;
1879 62c52121 Måns Rullgård
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1880 01f4895c Michael Niedermayer
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1881 62c52121 Måns Rullgård
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1882 90ad92b3 Michael Niedermayer
            }
1883
        }
1884 115329f1 Diego Biurrun
1885 fb2758c8 Fabrice Bellard
        /* if still no information, we try to open the codec and to
1886
           decompress the frame. We try to avoid that in most cases as
1887
           it takes longer and uses more memory. For MPEG4, we need to
1888
           decompress for Quicktime. */
1889 01f4895c Michael Niedermayer
        if (!has_codec_parameters(st->codec) /*&&
1890
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1891
             st->codec->codec_id == CODEC_ID_H264 ||
1892
             st->codec->codec_id == CODEC_ID_H263 ||
1893
             st->codec->codec_id == CODEC_ID_H261 ||
1894
             st->codec->codec_id == CODEC_ID_VORBIS ||
1895
             st->codec->codec_id == CODEC_ID_MJPEG ||
1896
             st->codec->codec_id == CODEC_ID_PNG ||
1897
             st->codec->codec_id == CODEC_ID_PAM ||
1898
             st->codec->codec_id == CODEC_ID_PGM ||
1899
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1900
             st->codec->codec_id == CODEC_ID_PBM ||
1901
             st->codec->codec_id == CODEC_ID_PPM ||
1902
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1903
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1904 fb2758c8 Fabrice Bellard
            try_decode_frame(st, pkt->data, pkt->size);
1905 115329f1 Diego Biurrun
1906 b3fc0925 Måns Rullgård
        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) {
1907 fb2758c8 Fabrice Bellard
            break;
1908 b9a281db Fabrice Bellard
        }
1909
        count++;
1910
    }
1911
1912 43c0040a Michael Niedermayer
    // close codecs which where opened in try_decode_frame()
1913
    for(i=0;i<ic->nb_streams;i++) {
1914
        st = ic->streams[i];
1915 01f4895c Michael Niedermayer
        if(st->codec->codec)
1916
            avcodec_close(st->codec);
1917 43c0040a Michael Niedermayer
    }
1918 b9a281db Fabrice Bellard
    for(i=0;i<ic->nb_streams;i++) {
1919
        st = ic->streams[i];
1920 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1921
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1922
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1923 15bc38e5 Michael Niedermayer
1924 1694118b Michael Niedermayer
            if(duration_count[i]
1925 4d43cbcc Michael Niedermayer
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1926 730ba406 Michael Niedermayer
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1927 4d43cbcc Michael Niedermayer
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1928
                double best_error= 2*av_q2d(st->time_base);
1929
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1930
1931
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1932
                    double error= duration_error[i][j] * get_std_framerate(j);
1933
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1934
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1935 9f75260e Michael Niedermayer
                    if(error < best_error){
1936
                        best_error= error;
1937 4d43cbcc Michael Niedermayer
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1938 9f75260e Michael Niedermayer
                    }
1939 3c150d16 Michael Niedermayer
                }
1940 15bc38e5 Michael Niedermayer
            }
1941
1942 c0df9d75 Michael Niedermayer
            if (!st->r_frame_rate.num){
1943 5523d5f4 Michael Niedermayer
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1944
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1945
                    st->r_frame_rate.num = st->codec->time_base.den;
1946
                    st->r_frame_rate.den = st->codec->time_base.num;
1947
                }else{
1948
                    st->r_frame_rate.num = st->time_base.den;
1949
                    st->r_frame_rate.den = st->time_base.num;
1950
                }
1951 14bea432 Michael Niedermayer
            }
1952 a185f52a Michael Niedermayer
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1953 19ecf882 Ronald S. Bultje
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1954 e0c850a8 Michael Niedermayer
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
1955 6fea687e John Donaghy
                if (codec_identified[st->index]) {
1956 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_FULL;
1957 6fea687e John Donaghy
                }
1958
            }
1959 a185f52a Michael Niedermayer
            if(!st->codec->bits_per_sample)
1960
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1961 b9a281db Fabrice Bellard
        }
1962 de6d9b64 Fabrice Bellard
    }
1963 b9a281db Fabrice Bellard
1964 9ecf7fad Wolfram Gloger
    av_estimate_timings(ic, old_offset);
1965 6fea687e John Donaghy
1966
    for(i=0;i<ic->nb_streams;i++) {
1967
        st = ic->streams[i];
1968 c7385375 Michael Niedermayer
        if (codec_identified[st->index])
1969
            break;
1970
    }
1971
    //FIXME this is a mess
1972
    if(i!=ic->nb_streams){
1973
        av_read_frame_flush(ic);
1974
        for(i=0;i<ic->nb_streams;i++) {
1975
            st = ic->streams[i];
1976
            if (codec_identified[st->index]) {
1977
                av_seek_frame(ic, st->index, 0.0, 0);
1978
            }
1979
            st->cur_dts= st->first_dts;
1980 6fea687e John Donaghy
        }
1981 899681cd Björn Axelsson
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
1982 6fea687e John Donaghy
    }
1983
1984 e928649b Michael Niedermayer
#if 0
1985
    /* correct DTS for b frame streams with no timestamps */
1986
    for(i=0;i<ic->nb_streams;i++) {
1987
        st = ic->streams[i];
1988 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1989 e928649b Michael Niedermayer
            if(b-frames){
1990
                ppktl = &ic->packet_buffer;
1991
                while(ppkt1){
1992
                    if(ppkt1->stream_index != i)
1993
                        continue;
1994
                    if(ppkt1->pkt->dts < 0)
1995
                        break;
1996
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1997
                        break;
1998
                    ppkt1->pkt->dts -= delta;
1999
                    ppkt1= ppkt1->next;
2000
                }
2001
                if(ppkt1)
2002
                    continue;
2003
                st->cur_dts -= delta;
2004
            }
2005
        }
2006
    }
2007
#endif
2008 0cbff027 Kristian Amlie
2009
    av_free(duration_error);
2010 6fea687e John Donaghy
    for(i=0;i<MAX_STREAMS;i++){
2011
        av_freep(&(probe_data[i].buf));
2012
    }
2013 0cbff027 Kristian Amlie
2014 b9a281db Fabrice Bellard
    return ret;
2015 de6d9b64 Fabrice Bellard
}
2016
2017 fb2758c8 Fabrice Bellard
/*******************************************************/
2018
2019
int av_read_play(AVFormatContext *s)
2020
{
2021
    if (!s->iformat->read_play)
2022 85565db0 Panagiotis Issaris
        return AVERROR(ENOSYS);
2023 fb2758c8 Fabrice Bellard
    return s->iformat->read_play(s);
2024
}
2025
2026
int av_read_pause(AVFormatContext *s)
2027
{
2028
    if (!s->iformat->read_pause)
2029 85565db0 Panagiotis Issaris
        return AVERROR(ENOSYS);
2030 fb2758c8 Fabrice Bellard
    return s->iformat->read_pause(s);
2031
}
2032
2033 de6d9b64 Fabrice Bellard
void av_close_input_file(AVFormatContext *s)
2034
{
2035 b6892136 Fabrice Bellard
    int i, must_open_file;
2036 da24c5e3 Fabrice Bellard
    AVStream *st;
2037 de6d9b64 Fabrice Bellard
2038 fb2758c8 Fabrice Bellard
    /* free previous packet */
2039
    if (s->cur_st && s->cur_st->parser)
2040 115329f1 Diego Biurrun
        av_free_packet(&s->cur_pkt);
2041 fb2758c8 Fabrice Bellard
2042 b9a281db Fabrice Bellard
    if (s->iformat->read_close)
2043
        s->iformat->read_close(s);
2044 de6d9b64 Fabrice Bellard
    for(i=0;i<s->nb_streams;i++) {
2045 da24c5e3 Fabrice Bellard
        /* free all data in a stream component */
2046
        st = s->streams[i];
2047 fb2758c8 Fabrice Bellard
        if (st->parser) {
2048
            av_parser_close(st->parser);
2049 de6d9b64 Fabrice Bellard
        }
2050 fb2758c8 Fabrice Bellard
        av_free(st->index_entries);
2051 a5e9102b Måns Rullgård
        av_free(st->codec->extradata);
2052 01f4895c Michael Niedermayer
        av_free(st->codec);
2053 fb2758c8 Fabrice Bellard
        av_free(st);
2054 de6d9b64 Fabrice Bellard
    }
2055 15afa396 Nico Sabbi
    for(i=s->nb_programs-1; i>=0; i--) {
2056
        av_freep(&s->programs[i]->provider_name);
2057
        av_freep(&s->programs[i]->name);
2058 526efa10 Nico Sabbi
        av_freep(&s->programs[i]->stream_index);
2059 15afa396 Nico Sabbi
        av_freep(&s->programs[i]);
2060
    }
2061 fb2758c8 Fabrice Bellard
    flush_packet_queue(s);
2062 b6892136 Fabrice Bellard
    must_open_file = 1;
2063 da24c5e3 Fabrice Bellard
    if (s->iformat->flags & AVFMT_NOFILE) {
2064 b6892136 Fabrice Bellard
        must_open_file = 0;
2065
    }
2066
    if (must_open_file) {
2067 899681cd Björn Axelsson
        url_fclose(s->pb);
2068 96baaa6a Fabrice Bellard
    }
2069 a8dbe951 Philip Gladstone
    av_freep(&s->priv_data);
2070 1ea4f593 Fabrice Bellard
    av_free(s);
2071 de6d9b64 Fabrice Bellard
}
2072
2073 b9a281db Fabrice Bellard
AVStream *av_new_stream(AVFormatContext *s, int id)
2074
{
2075
    AVStream *st;
2076 504ee036 Michael Niedermayer
    int i;
2077 b9a281db Fabrice Bellard
2078
    if (s->nb_streams >= MAX_STREAMS)
2079
        return NULL;
2080
2081
    st = av_mallocz(sizeof(AVStream));
2082
    if (!st)
2083
        return NULL;
2084 115329f1 Diego Biurrun
2085 01f4895c Michael Niedermayer
    st->codec= avcodec_alloc_context();
2086 48091512 Fabrice Bellard
    if (s->iformat) {
2087
        /* no default bitrate if decoding */
2088 01f4895c Michael Niedermayer
        st->codec->bit_rate = 0;
2089 48091512 Fabrice Bellard
    }
2090 b9a281db Fabrice Bellard
    st->index = s->nb_streams;
2091
    st->id = id;
2092 12f996ed Fabrice Bellard
    st->start_time = AV_NOPTS_VALUE;
2093
    st->duration = AV_NOPTS_VALUE;
2094 e928649b Michael Niedermayer
    st->cur_dts = AV_NOPTS_VALUE;
2095 82583548 Michael Niedermayer
    st->first_dts = AV_NOPTS_VALUE;
2096 9ee91c2f Michael Niedermayer
2097
    /* default pts settings is MPEG like */
2098
    av_set_pts_info(st, 33, 1, 90000);
2099 77405fc8 Michael Niedermayer
    st->last_IP_pts = AV_NOPTS_VALUE;
2100 504ee036 Michael Niedermayer
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2101
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2102 9ee91c2f Michael Niedermayer
2103 b9a281db Fabrice Bellard
    s->streams[s->nb_streams++] = st;
2104
    return st;
2105
}
2106
2107 15afa396 Nico Sabbi
AVProgram *av_new_program(AVFormatContext *ac, int id)
2108
{
2109
    AVProgram *program=NULL;
2110
    int i;
2111
2112
#ifdef DEBUG_SI
2113
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2114
#endif
2115
2116
    for(i=0; i<ac->nb_programs; i++)
2117
        if(ac->programs[i]->id == id)
2118
            program = ac->programs[i];
2119
2120
    if(!program){
2121
        program = av_mallocz(sizeof(AVProgram));
2122
        if (!program)
2123
            return NULL;
2124
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2125
        program->discard = AVDISCARD_NONE;
2126
    }
2127
    program->id = id;
2128
2129
    return program;
2130
}
2131
2132
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2133
{
2134
    assert(!provider_name == !name);
2135
    if(name){
2136
        av_free(program->provider_name);
2137
        av_free(program->         name);
2138
        program->provider_name = av_strdup(provider_name);
2139
        program->         name = av_strdup(         name);
2140
    }
2141
}
2142
2143
2144 b9a281db Fabrice Bellard
/************************************************************/
2145
/* output media file */
2146 de6d9b64 Fabrice Bellard
2147 87a0a681 Fabrice Bellard
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2148
{
2149
    int ret;
2150 115329f1 Diego Biurrun
2151 98486a6b Roman Shaposhnik
    if (s->oformat->priv_data_size > 0) {
2152
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2153
        if (!s->priv_data)
2154 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
2155 98486a6b Roman Shaposhnik
    } else
2156
        s->priv_data = NULL;
2157 115329f1 Diego Biurrun
2158 87a0a681 Fabrice Bellard
    if (s->oformat->set_parameters) {
2159
        ret = s->oformat->set_parameters(s, ap);
2160
        if (ret < 0)
2161
            return ret;
2162
    }
2163
    return 0;
2164
}
2165
2166 b9a281db Fabrice Bellard
int av_write_header(AVFormatContext *s)
2167
{
2168 1e51d801 Fabrice Bellard
    int ret, i;
2169
    AVStream *st;
2170
2171 9450118b Michael Niedermayer
    // some sanity checks
2172
    for(i=0;i<s->nb_streams;i++) {
2173
        st = s->streams[i];
2174
2175
        switch (st->codec->codec_type) {
2176
        case CODEC_TYPE_AUDIO:
2177
            if(st->codec->sample_rate<=0){
2178
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2179
                return -1;
2180
            }
2181
            break;
2182
        case CODEC_TYPE_VIDEO:
2183
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2184
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2185
                return -1;
2186
            }
2187
            if(st->codec->width<=0 || st->codec->height<=0){
2188
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2189
                return -1;
2190
            }
2191
            break;
2192
        }
2193 5ecfa9f5 Michael Niedermayer
2194
        if(s->oformat->codec_tag){
2195
            if(st->codec->codec_tag){
2196
                //FIXME
2197
                //check that tag + id is in the table
2198
                //if neither is in the table -> ok
2199
                //if tag is in the table with another id -> FAIL
2200
                //if id is in the table with another tag -> FAIL unless strict < ?
2201
            }else
2202
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2203
        }
2204 9450118b Michael Niedermayer
    }
2205
2206 8fae2df5 Baptiste Coudurier
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2207 c6efa4b5 Baptiste Coudurier
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2208
        if (!s->priv_data)
2209 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
2210 8fae2df5 Baptiste Coudurier
    }
2211 c6efa4b5 Baptiste Coudurier
2212 31e11451 Michael Niedermayer
    if(s->oformat->write_header){
2213
        ret = s->oformat->write_header(s);
2214
        if (ret < 0)
2215
            return ret;
2216
    }
2217 1e51d801 Fabrice Bellard
2218
    /* init PTS generation */
2219
    for(i=0;i<s->nb_streams;i++) {
2220 f0ff20a1 Wolfram Gloger
        int64_t den = AV_NOPTS_VALUE;
2221 1e51d801 Fabrice Bellard
        st = s->streams[i];
2222
2223 01f4895c Michael Niedermayer
        switch (st->codec->codec_type) {
2224 1e51d801 Fabrice Bellard
        case CODEC_TYPE_AUDIO:
2225 f0ff20a1 Wolfram Gloger
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2226 1e51d801 Fabrice Bellard
            break;
2227
        case CODEC_TYPE_VIDEO:
2228 f0ff20a1 Wolfram Gloger
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2229 1e51d801 Fabrice Bellard
            break;
2230
        default:
2231
            break;
2232
        }
2233 f0ff20a1 Wolfram Gloger
        if (den != AV_NOPTS_VALUE) {
2234
            if (den <= 0)
2235
                return AVERROR_INVALIDDATA;
2236
            av_frac_init(&st->pts, 0, 0, den);
2237
        }
2238 1e51d801 Fabrice Bellard
    }
2239
    return 0;
2240 b9a281db Fabrice Bellard
}
2241
2242 3c895fc0 Michael Niedermayer
//FIXME merge with compute_pkt_fields
2243 5edea431 Michael Niedermayer
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2244 504ee036 Michael Niedermayer
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2245
    int num, den, frame_size, i;
2246 b0c7f5a9 Michael Niedermayer
2247 949b1a13 Steve L'Homme
//    av_log(st->codec, 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);
2248 115329f1 Diego Biurrun
2249 e928649b Michael Niedermayer
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2250
        return -1;*/
2251 115329f1 Diego Biurrun
2252 e928649b Michael Niedermayer
    /* duration field */
2253 3c895fc0 Michael Niedermayer
    if (pkt->duration == 0) {
2254
        compute_frame_duration(&num, &den, st, NULL, pkt);
2255
        if (den && num) {
2256
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2257
        }
2258
    }
2259 e928649b Michael Niedermayer
2260
    //XXX/FIXME this is a temporary hack until all encoders output pts
2261 504ee036 Michael Niedermayer
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2262 e928649b Michael Niedermayer
        pkt->dts=
2263
//        pkt->pts= st->cur_dts;
2264
        pkt->pts= st->pts.val;
2265
    }
2266
2267 115329f1 Diego Biurrun
    //calculate dts from pts
2268 e928649b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2269 504ee036 Michael Niedermayer
        st->pts_buffer[0]= pkt->pts;
2270
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2271
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2272
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2273 1345f4ed Diego Biurrun
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2274 504ee036 Michael Niedermayer
2275
        pkt->dts= st->pts_buffer[0];
2276 e928649b Michael Niedermayer
    }
2277 115329f1 Diego Biurrun
2278 5edea431 Michael Niedermayer
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2279 578688fa Luca Abeni
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2280 5edea431 Michael Niedermayer
        return -1;
2281
    }
2282
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2283 578688fa Luca Abeni
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2284 5edea431 Michael Niedermayer
        return -1;
2285
    }
2286
2287 949b1a13 Steve L'Homme
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2288 e928649b Michael Niedermayer
    st->cur_dts= pkt->dts;
2289
    st->pts.val= pkt->dts;
2290
2291 1e51d801 Fabrice Bellard
    /* update pts */
2292 01f4895c Michael Niedermayer
    switch (st->codec->codec_type) {
2293 1e51d801 Fabrice Bellard
    case CODEC_TYPE_AUDIO:
2294 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2295 6d8f985e Michael Niedermayer
2296 b0c7f5a9 Michael Niedermayer
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2297 6d8f985e Michael Niedermayer
           but it would be better if we had the real timestamps from the encoder */
2298 e928649b Michael Niedermayer
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2299 9ee91c2f Michael Niedermayer
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2300 7feb950a Fabrice Bellard
        }
2301 1e51d801 Fabrice Bellard
        break;
2302
    case CODEC_TYPE_VIDEO:
2303 01f4895c Michael Niedermayer
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2304 1e51d801 Fabrice Bellard
        break;
2305
    default:
2306
        break;
2307
    }
2308 5edea431 Michael Niedermayer
    return 0;
2309 3c895fc0 Michael Niedermayer
}
2310
2311
static void truncate_ts(AVStream *st, AVPacket *pkt){
2312
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2313 115329f1 Diego Biurrun
2314 e0c91bc2 Michael Niedermayer
//    if(pkt->dts < 0)
2315
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2316 115329f1 Diego Biurrun
2317 68a432cf Baptiste Coudurier
    if (pkt->pts != AV_NOPTS_VALUE)
2318 8533284d Andy Parkins
        pkt->pts &= pts_mask;
2319 68a432cf Baptiste Coudurier
    if (pkt->dts != AV_NOPTS_VALUE)
2320 8533284d Andy Parkins
        pkt->dts &= pts_mask;
2321 3c895fc0 Michael Niedermayer
}
2322
2323
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2324
{
2325 576ae256 Michael Niedermayer
    int ret;
2326
2327 5edea431 Michael Niedermayer
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2328 494bbf58 Michael Niedermayer
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2329 5edea431 Michael Niedermayer
        return ret;
2330 115329f1 Diego Biurrun
2331 3c895fc0 Michael Niedermayer
    truncate_ts(s->streams[pkt->stream_index], pkt);
2332
2333 576ae256 Michael Niedermayer
    ret= s->oformat->write_packet(s, pkt);
2334
    if(!ret)
2335 899681cd Björn Axelsson
        ret= url_ferror(s->pb);
2336 576ae256 Michael Niedermayer
    return ret;
2337 3c895fc0 Michael Niedermayer
}
2338
2339 f21c0b4c Baptiste Coudurier
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2340 fe2d6fe2 Michael Niedermayer
    AVPacketList *pktl, **next_point, *this_pktl;
2341
    int stream_count=0;
2342
    int streams[MAX_STREAMS];
2343
2344
    if(pkt){
2345
        AVStream *st= s->streams[ pkt->stream_index];
2346
2347 2577897d Michael Niedermayer
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2348 fe2d6fe2 Michael Niedermayer
2349
        this_pktl = av_mallocz(sizeof(AVPacketList));
2350
        this_pktl->pkt= *pkt;
2351 2577897d Michael Niedermayer
        if(pkt->destruct == av_destruct_packet)
2352
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2353
        else
2354
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2355 fe2d6fe2 Michael Niedermayer
2356
        next_point = &s->packet_buffer;
2357
        while(*next_point){
2358
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2359
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2360
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2361
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2362
                break;
2363
            next_point= &(*next_point)->next;
2364
        }
2365
        this_pktl->next= *next_point;
2366
        *next_point= this_pktl;
2367
    }
2368 115329f1 Diego Biurrun
2369 fe2d6fe2 Michael Niedermayer
    memset(streams, 0, sizeof(streams));
2370
    pktl= s->packet_buffer;
2371
    while(pktl){
2372 949b1a13 Steve L'Homme
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2373 fe2d6fe2 Michael Niedermayer
        if(streams[ pktl->pkt.stream_index ] == 0)
2374
            stream_count++;
2375
        streams[ pktl->pkt.stream_index ]++;
2376
        pktl= pktl->next;
2377
    }
2378 115329f1 Diego Biurrun
2379 fe2d6fe2 Michael Niedermayer
    if(s->nb_streams == stream_count || (flush && stream_count)){
2380
        pktl= s->packet_buffer;
2381
        *out= pktl->pkt;
2382 115329f1 Diego Biurrun
2383
        s->packet_buffer= pktl->next;
2384 fe2d6fe2 Michael Niedermayer
        av_freep(&pktl);
2385
        return 1;
2386
    }else{
2387
        av_init_packet(out);
2388
        return 0;
2389
    }
2390
}
2391
2392
/**
2393
 * Interleaves a AVPacket correctly so it can be muxed.
2394
 * @param out the interleaved packet will be output here
2395
 * @param in the input packet
2396
 * @param flush 1 if no further packets are available as input and all
2397
 *              remaining packets should be output
2398 115329f1 Diego Biurrun
 * @return 1 if a packet was output, 0 if no packet could be output,
2399 fe2d6fe2 Michael Niedermayer
 *         < 0 if an error occured
2400
 */
2401
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2402
    if(s->oformat->interleave_packet)
2403
        return s->oformat->interleave_packet(s, out, in, flush);
2404
    else
2405
        return av_interleave_packet_per_dts(s, out, in, flush);
2406
}
2407
2408 3c895fc0 Michael Niedermayer
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2409
    AVStream *st= s->streams[ pkt->stream_index];
2410
2411 6f824977 Michael Niedermayer
    //FIXME/XXX/HACK drop zero sized packets
2412 01f4895c Michael Niedermayer
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2413 6f824977 Michael Niedermayer
        return 0;
2414 3ce16b30 Michael Niedermayer
2415 949b1a13 Steve L'Homme
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2416 494bbf58 Michael Niedermayer
    if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2417 3ce16b30 Michael Niedermayer
        return -1;
2418 115329f1 Diego Biurrun
2419 3c895fc0 Michael Niedermayer
    if(pkt->dts == AV_NOPTS_VALUE)
2420
        return -1;
2421
2422 fe2d6fe2 Michael Niedermayer
    for(;;){
2423
        AVPacket opkt;
2424
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2425
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2426
            return ret;
2427 115329f1 Diego Biurrun
2428 fe2d6fe2 Michael Niedermayer
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2429
        ret= s->oformat->write_packet(s, &opkt);
2430 115329f1 Diego Biurrun
2431 fe2d6fe2 Michael Niedermayer
        av_free_packet(&opkt);
2432
        pkt= NULL;
2433 115329f1 Diego Biurrun
2434 3c895fc0 Michael Niedermayer
        if(ret<0)
2435
            return ret;
2436 899681cd Björn Axelsson
        if(url_ferror(s->pb))
2437
            return url_ferror(s->pb);
2438 3c895fc0 Michael Niedermayer
    }
2439 b9a281db Fabrice Bellard
}
2440
2441
int av_write_trailer(AVFormatContext *s)
2442
{
2443 c40a3a42 Michael Niedermayer
    int ret, i;
2444 115329f1 Diego Biurrun
2445 fe2d6fe2 Michael Niedermayer
    for(;;){
2446
        AVPacket pkt;
2447
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2448
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2449 c40a3a42 Michael Niedermayer
            goto fail;
2450 fe2d6fe2 Michael Niedermayer
        if(!ret)
2451
            break;
2452 115329f1 Diego Biurrun
2453 fe2d6fe2 Michael Niedermayer
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2454
        ret= s->oformat->write_packet(s, &pkt);
2455 115329f1 Diego Biurrun
2456 fe2d6fe2 Michael Niedermayer
        av_free_packet(&pkt);
2457 115329f1 Diego Biurrun
2458 3c895fc0 Michael Niedermayer
        if(ret<0)
2459 c40a3a42 Michael Niedermayer
            goto fail;
2460 899681cd Björn Axelsson
        if(url_ferror(s->pb))
2461 576ae256 Michael Niedermayer
            goto fail;
2462 3c895fc0 Michael Niedermayer
    }
2463
2464 31e11451 Michael Niedermayer
    if(s->oformat->write_trailer)
2465
        ret = s->oformat->write_trailer(s);
2466 c40a3a42 Michael Niedermayer
fail:
2467 576ae256 Michael Niedermayer
    if(ret == 0)
2468 899681cd Björn Axelsson
       ret=url_ferror(s->pb);
2469 c40a3a42 Michael Niedermayer
    for(i=0;i<s->nb_streams;i++)
2470
        av_freep(&s->streams[i]->priv_data);
2471 b9a281db Fabrice Bellard
    av_freep(&s->priv_data);
2472
    return ret;
2473 de6d9b64 Fabrice Bellard
}
2474
2475 526efa10 Nico Sabbi
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2476
{
2477
    int i, j;
2478
    AVProgram *program=NULL;
2479
    void *tmp;
2480
2481
    for(i=0; i<ac->nb_programs; i++){
2482
        if(ac->programs[i]->id != progid)
2483
            continue;
2484
        program = ac->programs[i];
2485
        for(j=0; j<program->nb_stream_indexes; j++)
2486
            if(program->stream_index[j] == idx)
2487
                return;
2488
2489
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2490
        if(!tmp)
2491
            return;
2492
        program->stream_index = tmp;
2493
        program->stream_index[program->nb_stream_indexes++] = idx;
2494
        return;
2495
    }
2496
}
2497
2498 de6d9b64 Fabrice Bellard
/* "user interface" functions */
2499 4e745a3b Baptiste Coudurier
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2500 fad0e030 Nico Sabbi
{
2501 4e745a3b Baptiste Coudurier
    char buf[256];
2502 fad0e030 Nico Sabbi
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2503
    AVStream *st = ic->streams[i];
2504
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2505
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2506
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2507
    /* the pid is an important information, so we display it */
2508
    /* XXX: add a generic system */
2509
    if (flags & AVFMT_SHOW_IDS)
2510
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2511
    if (strlen(st->language) > 0)
2512
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2513
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2514
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2515
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2516
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2517 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2518 fad0e030 Nico Sabbi
/*      else if(st->time_base.den && st->time_base.num)
2519 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2520 fad0e030 Nico Sabbi
        else
2521 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2522 fad0e030 Nico Sabbi
    }
2523
    av_log(NULL, AV_LOG_INFO, "\n");
2524
}
2525 de6d9b64 Fabrice Bellard
2526
void dump_format(AVFormatContext *ic,
2527 115329f1 Diego Biurrun
                 int index,
2528 de6d9b64 Fabrice Bellard
                 const char *url,
2529
                 int is_output)
2530
{
2531 63bb42fb Diego Biurrun
    int i;
2532 de6d9b64 Fabrice Bellard
2533 115329f1 Diego Biurrun
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2534 de6d9b64 Fabrice Bellard
            is_output ? "Output" : "Input",
2535 115329f1 Diego Biurrun
            index,
2536
            is_output ? ic->oformat->name : ic->iformat->name,
2537 de6d9b64 Fabrice Bellard
            is_output ? "to" : "from", url);
2538 12f996ed Fabrice Bellard
    if (!is_output) {
2539 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2540 12f996ed Fabrice Bellard
        if (ic->duration != AV_NOPTS_VALUE) {
2541
            int hours, mins, secs, us;
2542
            secs = ic->duration / AV_TIME_BASE;
2543
            us = ic->duration % AV_TIME_BASE;
2544
            mins = secs / 60;
2545
            secs %= 60;
2546
            hours = mins / 60;
2547
            mins %= 60;
2548 115329f1 Diego Biurrun
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2549 12f996ed Fabrice Bellard
                   (10 * us) / AV_TIME_BASE);
2550
        } else {
2551 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "N/A");
2552 12f996ed Fabrice Bellard
        }
2553 d0f3f159 Wolfram Gloger
        if (ic->start_time != AV_NOPTS_VALUE) {
2554
            int secs, us;
2555 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", start: ");
2556 d0f3f159 Wolfram Gloger
            secs = ic->start_time / AV_TIME_BASE;
2557
            us = ic->start_time % AV_TIME_BASE;
2558 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2559 d0f3f159 Wolfram Gloger
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2560
        }
2561 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2562 12f996ed Fabrice Bellard
        if (ic->bit_rate) {
2563 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2564 12f996ed Fabrice Bellard
        } else {
2565 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "N/A");
2566 12f996ed Fabrice Bellard
        }
2567 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, "\n");
2568 12f996ed Fabrice Bellard
    }
2569 526efa10 Nico Sabbi
    if(ic->nb_programs) {
2570
        int j, k;
2571
        for(j=0; j<ic->nb_programs; j++) {
2572 f473666f Nico Sabbi
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2573
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2574 526efa10 Nico Sabbi
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2575 4e745a3b Baptiste Coudurier
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2576 526efa10 Nico Sabbi
         }
2577
    } else
2578 fad0e030 Nico Sabbi
    for(i=0;i<ic->nb_streams;i++)
2579 4e745a3b Baptiste Coudurier
        dump_stream_format(ic, i, index, is_output);
2580 de6d9b64 Fabrice Bellard
}
2581
2582
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2583
{
2584 26ef3220 Stefano Sabatini
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2585 de6d9b64 Fabrice Bellard
}
2586
2587 26ef3220 Stefano Sabatini
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2588 445f1b83 Roman Shaposhnik
{
2589 26ef3220 Stefano Sabatini
    AVRational frame_rate;
2590
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2591
    *frame_rate_num= frame_rate.num;
2592
    *frame_rate_den= frame_rate.den;
2593
    return ret;
2594 445f1b83 Roman Shaposhnik
}
2595
2596 82e4ac2c Ramiro Polla
/**
2597
 * gets the current time in micro seconds.
2598
 */
2599
int64_t av_gettime(void)
2600
{
2601
    struct timeval tv;
2602
    gettimeofday(&tv,NULL);
2603
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2604
}
2605
2606 0c1a9eda Zdenek Kabelac
int64_t parse_date(const char *datestr, int duration)
2607 de6d9b64 Fabrice Bellard
{
2608
    const char *p;
2609 0c1a9eda Zdenek Kabelac
    int64_t t;
2610 2dbceb9f Philip Gladstone
    struct tm dt;
2611 c5510dd6 Philip Gladstone
    int i;
2612
    static const char *date_fmt[] = {
2613
        "%Y-%m-%d",
2614
        "%Y%m%d",
2615
    };
2616
    static const char *time_fmt[] = {
2617
        "%H:%M:%S",
2618
        "%H%M%S",
2619
    };
2620
    const char *q;
2621 916c80e9 Fabrice Bellard
    int is_utc, len;
2622 c5510dd6 Philip Gladstone
    char lastch;
2623 a6a92a9a Wolfram Gloger
    int negative = 0;
2624 6d8f985e Michael Niedermayer
2625
#undef time
2626 c5510dd6 Philip Gladstone
    time_t now = time(0);
2627
2628 916c80e9 Fabrice Bellard
    len = strlen(datestr);
2629
    if (len > 0)
2630
        lastch = datestr[len - 1];
2631
    else
2632
        lastch = '\0';
2633 c5510dd6 Philip Gladstone
    is_utc = (lastch == 'z' || lastch == 'Z');
2634 2dbceb9f Philip Gladstone
2635
    memset(&dt, 0, sizeof(dt));
2636 de6d9b64 Fabrice Bellard
2637
    p = datestr;
2638 916c80e9 Fabrice Bellard
    q = NULL;
2639 de6d9b64 Fabrice Bellard
    if (!duration) {
2640 a8f70d72 Stefano Sabatini
        /* parse the year-month-day part */
2641 c5510dd6 Philip Gladstone
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2642 f71869a4 Fabrice Bellard
            q = small_strptime(p, date_fmt[i], &dt);
2643 c5510dd6 Philip Gladstone
            if (q) {
2644
                break;
2645
            }
2646
        }
2647
2648 a8f70d72 Stefano Sabatini
        /* if the year-month-day part is missing, then take the
2649
         * current year-month-day time */
2650 c5510dd6 Philip Gladstone
        if (!q) {
2651
            if (is_utc) {
2652
                dt = *gmtime(&now);
2653
            } else {
2654
                dt = *localtime(&now);
2655
            }
2656
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2657 de6d9b64 Fabrice Bellard
        } else {
2658 c5510dd6 Philip Gladstone
            p = q;
2659 de6d9b64 Fabrice Bellard
        }
2660 c5510dd6 Philip Gladstone
2661
        if (*p == 'T' || *p == 't' || *p == ' ')
2662
            p++;
2663
2664 a8f70d72 Stefano Sabatini
        /* parse the hour-minute-second part */
2665 916c80e9 Fabrice Bellard
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2666 f71869a4 Fabrice Bellard
            q = small_strptime(p, time_fmt[i], &dt);
2667 916c80e9 Fabrice Bellard
            if (q) {
2668
                break;
2669
            }
2670
        }
2671
    } else {
2672 a8f70d72 Stefano Sabatini
        /* parse datestr as a duration */
2673 bb270c08 Diego Biurrun
        if (p[0] == '-') {
2674
            negative = 1;
2675
            ++p;
2676
        }
2677 a8f70d72 Stefano Sabatini
        /* parse datestr as HH:MM:SS */
2678 f71869a4 Fabrice Bellard
        q = small_strptime(p, time_fmt[0], &dt);
2679 916c80e9 Fabrice Bellard
        if (!q) {
2680 a8f70d72 Stefano Sabatini
            /* parse datestr as S+ */
2681 916c80e9 Fabrice Bellard
            dt.tm_sec = strtol(p, (char **)&q, 10);
2682 f9436161 Stefano Sabatini
            if (q == p)
2683
                /* the parsing didn't succeed */
2684
                return INT64_MIN;
2685 916c80e9 Fabrice Bellard
            dt.tm_min = 0;
2686
            dt.tm_hour = 0;
2687 c5510dd6 Philip Gladstone
        }
2688
    }
2689
2690
    /* Now we have all the fields that we can get */
2691
    if (!q) {
2692 f9436161 Stefano Sabatini
        return INT64_MIN;
2693 de6d9b64 Fabrice Bellard
    }
2694 2dbceb9f Philip Gladstone
2695
    if (duration) {
2696 c5510dd6 Philip Gladstone
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2697 2dbceb9f Philip Gladstone
    } else {
2698 c5510dd6 Philip Gladstone
        dt.tm_isdst = -1;       /* unknown */
2699
        if (is_utc) {
2700
            t = mktimegm(&dt);
2701
        } else {
2702
            t = mktime(&dt);
2703
        }
2704 de6d9b64 Fabrice Bellard
    }
2705 2dbceb9f Philip Gladstone
2706 c5510dd6 Philip Gladstone
    t *= 1000000;
2707
2708 a8f70d72 Stefano Sabatini
    /* parse the .m... part */
2709 c5510dd6 Philip Gladstone
    if (*q == '.') {
2710 de6d9b64 Fabrice Bellard
        int val, n;
2711 c5510dd6 Philip Gladstone
        q++;
2712
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2713 115329f1 Diego Biurrun
            if (!isdigit(*q))
2714 c5510dd6 Philip Gladstone
                break;
2715
            val += n * (*q - '0');
2716 de6d9b64 Fabrice Bellard
        }
2717
        t += val;
2718
    }
2719 a6a92a9a Wolfram Gloger
    return negative ? -t : t;
2720 de6d9b64 Fabrice Bellard
}
2721
2722
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2723
{
2724
    const char *p;
2725
    char tag[128], *q;
2726
2727
    p = info;
2728
    if (*p == '?')
2729
        p++;
2730
    for(;;) {
2731
        q = tag;
2732
        while (*p != '\0' && *p != '=' && *p != '&') {
2733
            if ((q - tag) < sizeof(tag) - 1)
2734
                *q++ = *p;
2735
            p++;
2736
        }
2737
        *q = '\0';
2738
        q = arg;
2739
        if (*p == '=') {
2740
            p++;
2741
            while (*p != '&' && *p != '\0') {
2742 2dbceb9f Philip Gladstone
                if ((q - arg) < arg_size - 1) {
2743
                    if (*p == '+')
2744
                        *q++ = ' ';
2745
                    else
2746
                        *q++ = *p;
2747
                }
2748