Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ f473666f

History | View | Annotate | Download (91.1 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
    if (pb)
365
        ic->pb = *pb;
366
    ic->duration = AV_NOPTS_VALUE;
367
    ic->start_time = AV_NOPTS_VALUE;
368 75e61b0e Måns Rullgård
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
369 da24c5e3 Fabrice Bellard
370
    /* allocate private data */
371
    if (fmt->priv_data_size > 0) {
372
        ic->priv_data = av_mallocz(fmt->priv_data_size);
373
        if (!ic->priv_data) {
374 769e10f0 Panagiotis Issaris
            err = AVERROR(ENOMEM);
375 da24c5e3 Fabrice Bellard
            goto fail;
376
        }
377
    } else {
378
        ic->priv_data = NULL;
379
    }
380
381
    err = ic->iformat->read_header(ic, ap);
382
    if (err < 0)
383
        goto fail;
384 fb2758c8 Fabrice Bellard
385 faf7cbf1 Michael Niedermayer
    if (pb && !ic->data_offset)
386 fb2758c8 Fabrice Bellard
        ic->data_offset = url_ftell(&ic->pb);
387
388 da24c5e3 Fabrice Bellard
    *ic_ptr = ic;
389
    return 0;
390
 fail:
391
    if (ic) {
392
        av_freep(&ic->priv_data);
393
    }
394
    av_free(ic);
395
    *ic_ptr = NULL;
396
    return err;
397
}
398
399 e36bdf8b Daniel Kristjansson
/** Size of probe buffer, for guessing file type from file contents. */
400 a877eedc Michael Niedermayer
#define PROBE_BUF_MIN 2048
401 329b1e75 Michael Niedermayer
#define PROBE_BUF_MAX (1<<20)
402 b9a281db Fabrice Bellard
403 115329f1 Diego Biurrun
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
404 b9a281db Fabrice Bellard
                       AVInputFormat *fmt,
405
                       int buf_size,
406
                       AVFormatParameters *ap)
407 de6d9b64 Fabrice Bellard
{
408 a877eedc Michael Niedermayer
    int err, must_open_file, file_opened, probe_size;
409 b9a281db Fabrice Bellard
    AVProbeData probe_data, *pd = &probe_data;
410 da24c5e3 Fabrice Bellard
    ByteIOContext pb1, *pb = &pb1;
411 115329f1 Diego Biurrun
412 da24c5e3 Fabrice Bellard
    file_opened = 0;
413
    pd->filename = "";
414
    if (filename)
415
        pd->filename = filename;
416 a877eedc Michael Niedermayer
    pd->buf = NULL;
417 b9a281db Fabrice Bellard
    pd->buf_size = 0;
418
419
    if (!fmt) {
420
        /* guess format if no file can be opened  */
421 a25e098d Fabrice Bellard
        fmt = av_probe_input_format(pd, 0);
422 de6d9b64 Fabrice Bellard
    }
423
424 b6892136 Fabrice Bellard
    /* do not open file if the format does not need it. XXX: specific
425
       hack needed to handle RTSP/TCP */
426
    must_open_file = 1;
427 da24c5e3 Fabrice Bellard
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
428 b6892136 Fabrice Bellard
        must_open_file = 0;
429 90b5b51e Diego Biurrun
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise it is uninitialized
430 b6892136 Fabrice Bellard
    }
431
432
    if (!fmt || must_open_file) {
433 87a0a681 Fabrice Bellard
        /* if no file needed do not try to open one */
434 0ba0c8de Benoit Fouet
        if ((err=url_fopen(pb, filename, URL_RDONLY)) < 0) {
435 96baaa6a Fabrice Bellard
            goto fail;
436 b9a281db Fabrice Bellard
        }
437 da24c5e3 Fabrice Bellard
        file_opened = 1;
438 96baaa6a Fabrice Bellard
        if (buf_size > 0) {
439 da24c5e3 Fabrice Bellard
            url_setbufsize(pb, buf_size);
440 96baaa6a Fabrice Bellard
        }
441 a877eedc Michael Niedermayer
442
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
443 79750486 Michael Niedermayer
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
444 5b25dfa7 Fabrice Bellard
            /* read probe data */
445 87e87886 Michael Niedermayer
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
446 a877eedc Michael Niedermayer
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
447 9be51815 Wolfram Gloger
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
448 497244a8 Baptiste Coudurier
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
449 53e2f9ca Michael Niedermayer
                url_fclose(pb);
450
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
451 5e43b17e Michael Niedermayer
                    file_opened = 0;
452 6f3e0b21 Panagiotis Issaris
                    err = AVERROR(EIO);
453 53e2f9ca Michael Niedermayer
                    goto fail;
454
                }
455
            }
456 a877eedc Michael Niedermayer
            /* guess file format */
457 79750486 Michael Niedermayer
            fmt = av_probe_input_format2(pd, 1, &score);
458 5b25dfa7 Fabrice Bellard
        }
459 a877eedc Michael Niedermayer
        av_freep(&pd->buf);
460 b9a281db Fabrice Bellard
    }
461
462
    /* if still no format found, error */
463
    if (!fmt) {
464
        err = AVERROR_NOFMT;
465 da24c5e3 Fabrice Bellard
        goto fail;
466 de6d9b64 Fabrice Bellard
    }
467 115329f1 Diego Biurrun
468 67d06418 Fabrice Bellard
    /* XXX: suppress this hack for redirectors */
469 e7047005 Alex Beregszaszi
#ifdef CONFIG_REDIR_DEMUXER
470 6369638b Aurelien Jacobs
    if (!strcmp(fmt->name, "redir")) {
471 7241a6bb Aurelien Jacobs
        int redir_open(AVFormatContext **ic_ptr, ByteIOContext *f);
472 da24c5e3 Fabrice Bellard
        err = redir_open(ic_ptr, pb);
473
        url_fclose(pb);
474 67d06418 Fabrice Bellard
        return err;
475
    }
476 9b2e001f Bill Eldridge
#endif
477 67d06418 Fabrice Bellard
478 87a0a681 Fabrice Bellard
    /* check filename in case of an image number is expected */
479 da24c5e3 Fabrice Bellard
    if (fmt->flags & AVFMT_NEEDNUMBER) {
480 5c07cf53 Michel Bardiaux
        if (!av_filename_number_test(filename)) {
481 87a0a681 Fabrice Bellard
            err = AVERROR_NUMEXPECTED;
482 da24c5e3 Fabrice Bellard
            goto fail;
483 87a0a681 Fabrice Bellard
        }
484
    }
485 da24c5e3 Fabrice Bellard
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
486
    if (err)
487
        goto fail;
488 b9a281db Fabrice Bellard
    return 0;
489 de6d9b64 Fabrice Bellard
 fail:
490 a877eedc Michael Niedermayer
    av_freep(&pd->buf);
491 da24c5e3 Fabrice Bellard
    if (file_opened)
492
        url_fclose(pb);
493 b9a281db Fabrice Bellard
    *ic_ptr = NULL;
494
    return err;
495 115329f1 Diego Biurrun
496 de6d9b64 Fabrice Bellard
}
497
498 da24c5e3 Fabrice Bellard
/*******************************************************/
499
500 de6d9b64 Fabrice Bellard
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
501
{
502 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
503 fb2758c8 Fabrice Bellard
    return s->iformat->read_packet(s, pkt);
504
}
505
506
/**********************************************************/
507
508 e36bdf8b Daniel Kristjansson
/**
509
 * Get the number of samples of an audio frame. Return (-1) if error.
510
 */
511 fb2758c8 Fabrice Bellard
static int get_audio_frame_size(AVCodecContext *enc, int size)
512
{
513
    int frame_size;
514
515
    if (enc->frame_size <= 1) {
516 ac3e1834 Baptiste Coudurier
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
517
518
        if (bits_per_sample) {
519 fb2758c8 Fabrice Bellard
            if (enc->channels == 0)
520
                return -1;
521 f1b163e0 Aurelien Jacobs
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
522 ac3e1834 Baptiste Coudurier
        } else {
523 fb2758c8 Fabrice Bellard
            /* used for example by ADPCM codecs */
524
            if (enc->bit_rate == 0)
525
                return -1;
526
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
527
        }
528
    } else {
529
        frame_size = enc->frame_size;
530
    }
531
    return frame_size;
532
}
533
534
535 e36bdf8b Daniel Kristjansson
/**
536
 * Return the frame duration in seconds, return 0 if not available.
537
 */
538 115329f1 Diego Biurrun
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
539 fb2758c8 Fabrice Bellard
                                   AVCodecParserContext *pc, AVPacket *pkt)
540
{
541
    int frame_size;
542
543
    *pnum = 0;
544
    *pden = 0;
545 01f4895c Michael Niedermayer
    switch(st->codec->codec_type) {
546 fb2758c8 Fabrice Bellard
    case CODEC_TYPE_VIDEO:
547 1677155d Michael Niedermayer
        if(st->time_base.num*1000LL > st->time_base.den){
548 c0df9d75 Michael Niedermayer
            *pnum = st->time_base.num;
549
            *pden = st->time_base.den;
550 01f4895c Michael Niedermayer
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
551
            *pnum = st->codec->time_base.num;
552
            *pden = st->codec->time_base.den;
553 327c4076 Michael Niedermayer
            if (pc && pc->repeat_pict) {
554
                *pden *= 2;
555
                *pnum = (*pnum) * (2 + pc->repeat_pict);
556
            }
557 fb2758c8 Fabrice Bellard
        }
558
        break;
559
    case CODEC_TYPE_AUDIO:
560 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
561 fb2758c8 Fabrice Bellard
        if (frame_size < 0)
562
            break;
563
        *pnum = frame_size;
564 01f4895c Michael Niedermayer
        *pden = st->codec->sample_rate;
565 fb2758c8 Fabrice Bellard
        break;
566
    default:
567
        break;
568
    }
569
}
570
571 5ba7c3d7 Michael Niedermayer
static int is_intra_only(AVCodecContext *enc){
572
    if(enc->codec_type == CODEC_TYPE_AUDIO){
573
        return 1;
574
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
575
        switch(enc->codec_id){
576
        case CODEC_ID_MJPEG:
577
        case CODEC_ID_MJPEGB:
578
        case CODEC_ID_LJPEG:
579
        case CODEC_ID_RAWVIDEO:
580
        case CODEC_ID_DVVIDEO:
581
        case CODEC_ID_HUFFYUV:
582 f37b9768 Loren Merritt
        case CODEC_ID_FFVHUFF:
583 5ba7c3d7 Michael Niedermayer
        case CODEC_ID_ASV1:
584
        case CODEC_ID_ASV2:
585
        case CODEC_ID_VCR1:
586
            return 1;
587
        default: break;
588
        }
589
    }
590
    return 0;
591
}
592
593 9fcbcca6 Neil Brown
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
594
                                      int64_t dts, int64_t pts)
595
{
596 82583548 Michael Niedermayer
    AVStream *st= s->streams[stream_index];
597
    AVPacketList *pktl= s->packet_buffer;
598
599
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
600
        return;
601
602
    st->first_dts= dts - st->cur_dts;
603
    st->cur_dts= dts;
604
605
    for(; pktl; pktl= pktl->next){
606
        if(pktl->pkt.stream_index != stream_index)
607
            continue;
608
        //FIXME think more about this check
609
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
610
            pktl->pkt.pts += st->first_dts;
611
612
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
613
            pktl->pkt.dts += st->first_dts;
614 48a59dfe Michael Niedermayer
615
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
616
            st->start_time= pktl->pkt.pts;
617 82583548 Michael Niedermayer
    }
618 9fcbcca6 Neil Brown
    if (st->start_time == AV_NOPTS_VALUE)
619
        st->start_time = pts;
620 82583548 Michael Niedermayer
}
621
622 115329f1 Diego Biurrun
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
623 fb2758c8 Fabrice Bellard
                               AVCodecParserContext *pc, AVPacket *pkt)
624
{
625 d9e1efb7 Michael Niedermayer
    int num, den, presentation_delayed, delay, i;
626 a74008a4 Joakim Plate
    int64_t offset;
627 115329f1 Diego Biurrun
628 10a7571b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
629
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
630
        pkt->dts -= 1LL<<st->pts_wrap_bits;
631
    }
632
633 fb2758c8 Fabrice Bellard
    if (pkt->duration == 0) {
634 3c895fc0 Michael Niedermayer
        compute_frame_duration(&num, &den, st, pc, pkt);
635 fb2758c8 Fabrice Bellard
        if (den && num) {
636 77405fc8 Michael Niedermayer
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
637 fb2758c8 Fabrice Bellard
        }
638
    }
639
640 a74008a4 Joakim Plate
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
641
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
642
        /* this will estimate bitrate based on this frame's duration and size */
643
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
644
        if(pkt->pts != AV_NOPTS_VALUE)
645
            pkt->pts += offset;
646
        if(pkt->dts != AV_NOPTS_VALUE)
647
            pkt->dts += offset;
648
    }
649
650 fb2758c8 Fabrice Bellard
    /* do we have a video B frame ? */
651 befe3b05 Michael Niedermayer
    delay= st->codec->has_b_frames;
652 fb2758c8 Fabrice Bellard
    presentation_delayed = 0;
653 7e4baa66 Michael Niedermayer
    /* XXX: need has_b_frame, but cannot get it if the codec is
654
        not initialized */
655
    if (delay &&
656
        pc && pc->pict_type != FF_B_TYPE)
657
        presentation_delayed = 1;
658 755bfeab Diego Biurrun
    /* This may be redundant, but it should not hurt. */
659 7e4baa66 Michael Niedermayer
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
660
        presentation_delayed = 1;
661 115329f1 Diego Biurrun
662 e928649b Michael Niedermayer
    if(st->cur_dts == AV_NOPTS_VALUE){
663 82583548 Michael Niedermayer
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
664 e928649b Michael Niedermayer
    }
665 fb2758c8 Fabrice Bellard
666 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);
667 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
668 7e4baa66 Michael Niedermayer
    if(delay <=1){
669
        if (presentation_delayed) {
670
            /* DTS = decompression time stamp */
671
            /* PTS = presentation time stamp */
672
            if (pkt->dts == AV_NOPTS_VALUE)
673
                pkt->dts = st->last_IP_pts;
674 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
675 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
676
                pkt->dts = st->cur_dts;
677
678
            /* this is tricky: the dts must be incremented by the duration
679
            of the frame we are displaying, i.e. the last I or P frame */
680
            if (st->last_IP_duration == 0)
681
                st->last_IP_duration = pkt->duration;
682
            st->cur_dts = pkt->dts + st->last_IP_duration;
683
            st->last_IP_duration  = pkt->duration;
684
            st->last_IP_pts= pkt->pts;
685
            /* cannot compute PTS if not present (we can compute it only
686
            by knowing the futur */
687 028d6f3e Michael Niedermayer
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
688 7e4baa66 Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
689
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
690
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
691
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
692
                    pkt->pts += pkt->duration;
693
    //                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);
694
                }
695 90bb394d Michael Niedermayer
            }
696 115329f1 Diego Biurrun
697 7e4baa66 Michael Niedermayer
            /* presentation is not delayed : PTS and DTS are the same */
698
            if(pkt->pts == AV_NOPTS_VALUE)
699
                pkt->pts = pkt->dts;
700 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
701 7e4baa66 Michael Niedermayer
            if(pkt->pts == AV_NOPTS_VALUE)
702
                pkt->pts = st->cur_dts;
703
            pkt->dts = pkt->pts;
704
            st->cur_dts = pkt->pts + pkt->duration;
705
        }
706 fb2758c8 Fabrice Bellard
    }
707 d9e1efb7 Michael Niedermayer
708
    if(pkt->pts != AV_NOPTS_VALUE){
709
        st->pts_buffer[0]= pkt->pts;
710
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
711
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
712
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
713
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
714
        if(pkt->dts == AV_NOPTS_VALUE)
715
            pkt->dts= st->pts_buffer[0];
716 82583548 Michael Niedermayer
        if(delay>1){
717 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
718 82583548 Michael Niedermayer
        }
719 d9e1efb7 Michael Niedermayer
        if(pkt->dts > st->cur_dts)
720
            st->cur_dts = pkt->dts;
721
    }
722
723
//    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);
724 115329f1 Diego Biurrun
725 fb2758c8 Fabrice Bellard
    /* update flags */
726 3a1d3588 Jeff Downs
    if(is_intra_only(st->codec))
727
        pkt->flags |= PKT_FLAG_KEY;
728
    else if (pc) {
729 fb2758c8 Fabrice Bellard
        pkt->flags = 0;
730
        /* key frame computation */
731
            if (pc->pict_type == FF_I_TYPE)
732
                pkt->flags |= PKT_FLAG_KEY;
733
    }
734
}
735
736 63dd1377 Michael Niedermayer
void av_destruct_packet_nofree(AVPacket *pkt)
737 fb2758c8 Fabrice Bellard
{
738
    pkt->data = NULL; pkt->size = 0;
739
}
740
741
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
742
{
743
    AVStream *st;
744 37353960 Fabrice Bellard
    int len, ret, i;
745 fb2758c8 Fabrice Bellard
746 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
747
748 fb2758c8 Fabrice Bellard
    for(;;) {
749
        /* select current input stream component */
750
        st = s->cur_st;
751
        if (st) {
752 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
753 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
754
                /* raw data support */
755
                *pkt = s->cur_pkt;
756
                compute_pkt_fields(s, st, NULL, pkt);
757
                s->cur_st = NULL;
758 434cab9e Michael Niedermayer
                break;
759 f3356e9c Michael Niedermayer
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
760 115329f1 Diego Biurrun
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
761 6ec87caa Fabrice Bellard
                                      s->cur_ptr, s->cur_len,
762
                                      s->cur_pkt.pts, s->cur_pkt.dts);
763
                s->cur_pkt.pts = AV_NOPTS_VALUE;
764
                s->cur_pkt.dts = AV_NOPTS_VALUE;
765 fb2758c8 Fabrice Bellard
                /* increment read pointer */
766
                s->cur_ptr += len;
767
                s->cur_len -= len;
768 115329f1 Diego Biurrun
769 fb2758c8 Fabrice Bellard
                /* return packet if any */
770
                if (pkt->size) {
771 37353960 Fabrice Bellard
                got_packet:
772 711737af Daniel Cardenas
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
773 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
774
                    pkt->stream_index = st->index;
775 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
776
                    pkt->dts = st->parser->dts;
777 fb2758c8 Fabrice Bellard
                    pkt->destruct = av_destruct_packet_nofree;
778
                    compute_pkt_fields(s, st, st->parser, pkt);
779 e9b78eeb Michael Niedermayer
780
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
781
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
782
                                           0, 0, AVINDEX_KEYFRAME);
783
                    }
784
785 434cab9e Michael Niedermayer
                    break;
786 fb2758c8 Fabrice Bellard
                }
787
            } else {
788 bcbecff1 Fabrice Bellard
                /* free packet */
789 115329f1 Diego Biurrun
                av_free_packet(&s->cur_pkt);
790 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
791
            }
792
        } else {
793
            /* read next packet */
794
            ret = av_read_packet(s, &s->cur_pkt);
795 37353960 Fabrice Bellard
            if (ret < 0) {
796 8fa36ae0 François Revol
                if (ret == AVERROR(EAGAIN))
797 37353960 Fabrice Bellard
                    return ret;
798
                /* return the last frames, if any */
799
                for(i = 0; i < s->nb_streams; i++) {
800
                    st = s->streams[i];
801 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
802 115329f1 Diego Biurrun
                        av_parser_parse(st->parser, st->codec,
803
                                        &pkt->data, &pkt->size,
804
                                        NULL, 0,
805 6ec87caa Fabrice Bellard
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
806 37353960 Fabrice Bellard
                        if (pkt->size)
807
                            goto got_packet;
808
                    }
809
                }
810
                /* no more packets: really terminates parsing */
811 fb2758c8 Fabrice Bellard
                return ret;
812 37353960 Fabrice Bellard
            }
813 115329f1 Diego Biurrun
814 9ee91c2f Michael Niedermayer
            st = s->streams[s->cur_pkt.stream_index];
815 434cab9e Michael Niedermayer
            if(st->codec->debug & FF_DEBUG_PTS)
816 ccd3228e Dominik Mierzejewski
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
817 434cab9e Michael Niedermayer
                    s->cur_pkt.stream_index,
818
                    s->cur_pkt.pts,
819
                    s->cur_pkt.dts,
820
                    s->cur_pkt.size);
821 fb2758c8 Fabrice Bellard
822
            s->cur_st = st;
823
            s->cur_ptr = s->cur_pkt.data;
824
            s->cur_len = s->cur_pkt.size;
825
            if (st->need_parsing && !st->parser) {
826 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
827 fb2758c8 Fabrice Bellard
                if (!st->parser) {
828
                    /* no parser available : just output the raw packets */
829 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_NONE;
830
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
831 7cbaa7ba Michael Niedermayer
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
832 fb2758c8 Fabrice Bellard
                }
833 e9b78eeb Michael Niedermayer
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
834
                    st->parser->last_frame_offset=
835
                    st->parser->cur_offset= s->cur_pkt.pos;
836
                }
837 fb2758c8 Fabrice Bellard
            }
838
        }
839
    }
840 434cab9e Michael Niedermayer
    if(st->codec->debug & FF_DEBUG_PTS)
841 ccd3228e Dominik Mierzejewski
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
842 434cab9e Michael Niedermayer
            pkt->stream_index,
843
            pkt->pts,
844
            pkt->dts,
845
            pkt->size);
846
847
    return 0;
848 fb2758c8 Fabrice Bellard
}
849
850 02b15cc8 Michael Niedermayer
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
851
    AVPacketList *pktl= s->packet_buffer;
852
    AVPacketList **plast_pktl= &s->packet_buffer;
853
854
    while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
855
856
    pktl = av_mallocz(sizeof(AVPacketList));
857
    if (!pktl)
858
        return NULL;
859
860
    /* add the packet in the buffered packet list */
861
    *plast_pktl = pktl;
862
    pktl->pkt= *pkt;
863
    return &pktl->pkt;
864
}
865
866 fb2758c8 Fabrice Bellard
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
867
{
868 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
869 30bc6613 Michael Niedermayer
    int eof=0;
870
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
871
872
    for(;;){
873
        pktl = s->packet_buffer;
874
        if (pktl) {
875
            AVPacket *next_pkt= &pktl->pkt;
876
877
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
878
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
879 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
880 30bc6613 Michael Niedermayer
                       && next_pkt->dts < pktl->pkt.dts
881
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
882
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
883
                        next_pkt->pts= pktl->pkt.dts;
884
                    }
885
                    pktl= pktl->next;
886
                }
887
                pktl = s->packet_buffer;
888
            }
889 115329f1 Diego Biurrun
890
            if(   next_pkt->pts != AV_NOPTS_VALUE
891
               || next_pkt->dts == AV_NOPTS_VALUE
892 30bc6613 Michael Niedermayer
               || !genpts || eof){
893
                /* read packet from packet buffer, if there is data */
894
                *pkt = *next_pkt;
895
                s->packet_buffer = pktl->next;
896
                av_free(pktl);
897
                return 0;
898
            }
899
        }
900
        if(genpts){
901
            int ret= av_read_frame_internal(s, pkt);
902
            if(ret<0){
903 8fa36ae0 François Revol
                if(pktl && ret != AVERROR(EAGAIN)){
904 30bc6613 Michael Niedermayer
                    eof=1;
905
                    continue;
906
                }else
907
                    return ret;
908
            }
909 115329f1 Diego Biurrun
910 02b15cc8 Michael Niedermayer
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
911 769e10f0 Panagiotis Issaris
                return AVERROR(ENOMEM);
912 30bc6613 Michael Niedermayer
        }else{
913
            assert(!s->packet_buffer);
914
            return av_read_frame_internal(s, pkt);
915
        }
916 fb2758c8 Fabrice Bellard
    }
917
}
918
919
/* XXX: suppress the packet queue */
920
static void flush_packet_queue(AVFormatContext *s)
921
{
922
    AVPacketList *pktl;
923
924
    for(;;) {
925
        pktl = s->packet_buffer;
926 115329f1 Diego Biurrun
        if (!pktl)
927 fb2758c8 Fabrice Bellard
            break;
928
        s->packet_buffer = pktl->next;
929
        av_free_packet(&pktl->pkt);
930
        av_free(pktl);
931 b9a281db Fabrice Bellard
    }
932
}
933
934 da24c5e3 Fabrice Bellard
/*******************************************************/
935 fb2758c8 Fabrice Bellard
/* seek support */
936
937 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
938
{
939
    int i;
940
    AVStream *st;
941
942
    if (s->nb_streams <= 0)
943
        return -1;
944
    for(i = 0; i < s->nb_streams; i++) {
945
        st = s->streams[i];
946 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
947 b754978a Michael Niedermayer
            return i;
948
        }
949
    }
950
    return 0;
951
}
952
953 e36bdf8b Daniel Kristjansson
/**
954
 * Flush the frame reader.
955
 */
956 fb2758c8 Fabrice Bellard
static void av_read_frame_flush(AVFormatContext *s)
957
{
958
    AVStream *st;
959
    int i;
960
961
    flush_packet_queue(s);
962
963
    /* free previous packet */
964
    if (s->cur_st) {
965
        if (s->cur_st->parser)
966
            av_free_packet(&s->cur_pkt);
967
        s->cur_st = NULL;
968
    }
969
    /* fail safe */
970
    s->cur_ptr = NULL;
971
    s->cur_len = 0;
972 115329f1 Diego Biurrun
973 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
974
    for(i = 0; i < s->nb_streams; i++) {
975
        st = s->streams[i];
976 115329f1 Diego Biurrun
977 fb2758c8 Fabrice Bellard
        if (st->parser) {
978
            av_parser_close(st->parser);
979
            st->parser = NULL;
980
        }
981 77405fc8 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
982 a843d1ff Michael Niedermayer
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
983 fb2758c8 Fabrice Bellard
    }
984
}
985
986 22ffac70 Reimar Döffinger
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
987 8bcb147f Michael Niedermayer
    int i;
988
989
    for(i = 0; i < s->nb_streams; i++) {
990 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
991 8bcb147f Michael Niedermayer
992 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
993 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
994
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
995 8bcb147f Michael Niedermayer
    }
996
}
997
998 3e9245a9 Michael Niedermayer
int av_add_index_entry(AVStream *st,
999 30a43f2d Michael Niedermayer
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1000 fb2758c8 Fabrice Bellard
{
1001
    AVIndexEntry *entries, *ie;
1002 b754978a Michael Niedermayer
    int index;
1003 115329f1 Diego Biurrun
1004 568e18b1 Michael Niedermayer
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1005
        return -1;
1006 115329f1 Diego Biurrun
1007 fb2758c8 Fabrice Bellard
    entries = av_fast_realloc(st->index_entries,
1008
                              &st->index_entries_allocated_size,
1009 115329f1 Diego Biurrun
                              (st->nb_index_entries + 1) *
1010 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1011 568e18b1 Michael Niedermayer
    if(!entries)
1012
        return -1;
1013
1014 b754978a Michael Niedermayer
    st->index_entries= entries;
1015
1016 27a5fe5f Michael Niedermayer
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1017 b754978a Michael Niedermayer
1018 3ba1438d Michael Niedermayer
    if(index<0){
1019 3e9245a9 Michael Niedermayer
        index= st->nb_index_entries++;
1020
        ie= &entries[index];
1021 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1022
    }else{
1023
        ie= &entries[index];
1024
        if(ie->timestamp != timestamp){
1025 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1026
                return -1;
1027 3ba1438d Michael Niedermayer
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1028
            st->nb_index_entries++;
1029 755bfeab Diego Biurrun
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1030 3ba1438d Michael Niedermayer
            distance= ie->min_distance;
1031 3e9245a9 Michael Niedermayer
    }
1032 3ba1438d Michael Niedermayer
1033 b754978a Michael Niedermayer
    ie->pos = pos;
1034
    ie->timestamp = timestamp;
1035 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1036 30a43f2d Michael Niedermayer
    ie->size= size;
1037 b754978a Michael Niedermayer
    ie->flags = flags;
1038 115329f1 Diego Biurrun
1039 3e9245a9 Michael Niedermayer
    return index;
1040 fb2758c8 Fabrice Bellard
}
1041
1042 dc56fc38 Michael Niedermayer
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1043 27a5fe5f Michael Niedermayer
                              int flags)
1044 fb2758c8 Fabrice Bellard
{
1045 b754978a Michael Niedermayer
    AVIndexEntry *entries= st->index_entries;
1046
    int nb_entries= st->nb_index_entries;
1047 fb2758c8 Fabrice Bellard
    int a, b, m;
1048
    int64_t timestamp;
1049
1050 3ba1438d Michael Niedermayer
    a = - 1;
1051
    b = nb_entries;
1052 b754978a Michael Niedermayer
1053 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1054
        m = (a + b) >> 1;
1055 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1056 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1057
            b = m;
1058
        if(timestamp <= wanted_timestamp)
1059 b754978a Michael Niedermayer
            a = m;
1060 fb2758c8 Fabrice Bellard
    }
1061 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1062 115329f1 Diego Biurrun
1063 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1064
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1065
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1066
        }
1067
    }
1068 3ba1438d Michael Niedermayer
1069 115329f1 Diego Biurrun
    if(m == nb_entries)
1070 3ba1438d Michael Niedermayer
        return -1;
1071
    return  m;
1072 fb2758c8 Fabrice Bellard
}
1073
1074 0f652a8e Benoit Fouet
#define DEBUG_SEEK
1075 8d14a25c Michael Niedermayer
1076 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1077 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1078
    int64_t pos_min, pos_max, pos, pos_limit;
1079
    int64_t ts_min, ts_max, ts;
1080 89ddd2a9 Michael Niedermayer
    int index;
1081 8d14a25c Michael Niedermayer
    AVStream *st;
1082
1083 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1084
        return -1;
1085 115329f1 Diego Biurrun
1086 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1087 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1088 8d14a25c Michael Niedermayer
#endif
1089
1090
    ts_max=
1091
    ts_min= AV_NOPTS_VALUE;
1092 90b5b51e Diego Biurrun
    pos_limit= -1; //gcc falsely says it may be uninitialized
1093 8d14a25c Michael Niedermayer
1094
    st= s->streams[stream_index];
1095
    if(st->index_entries){
1096
        AVIndexEntry *e;
1097
1098 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()
1099 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1100 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1101
1102
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1103
            pos_min= e->pos;
1104
            ts_min= e->timestamp;
1105
#ifdef DEBUG_SEEK
1106 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1107 8d14a25c Michael Niedermayer
               pos_min,ts_min);
1108
#endif
1109
        }else{
1110
            assert(index==0);
1111
        }
1112 115329f1 Diego Biurrun
1113
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1114 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1115
        if(index >= 0){
1116 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1117
            assert(e->timestamp >= target_ts);
1118
            pos_max= e->pos;
1119
            ts_max= e->timestamp;
1120
            pos_limit= pos_max - e->min_distance;
1121
#ifdef DEBUG_SEEK
1122 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1123 8d14a25c Michael Niedermayer
               pos_max,pos_limit, ts_max);
1124
#endif
1125
        }
1126
    }
1127
1128 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);
1129
    if(pos<0)
1130
        return -1;
1131
1132
    /* do the seek */
1133
    url_fseek(&s->pb, pos, SEEK_SET);
1134
1135
    av_update_cur_dts(s, st, ts);
1136
1137
    return 0;
1138
}
1139
1140
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 )){
1141
    int64_t pos, ts;
1142
    int64_t start_pos, filesize;
1143
    int no_change;
1144
1145
#ifdef DEBUG_SEEK
1146
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1147
#endif
1148
1149 8d14a25c Michael Niedermayer
    if(ts_min == AV_NOPTS_VALUE){
1150
        pos_min = s->data_offset;
1151 89ddd2a9 Michael Niedermayer
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1152 8d14a25c Michael Niedermayer
        if (ts_min == AV_NOPTS_VALUE)
1153
            return -1;
1154
    }
1155
1156
    if(ts_max == AV_NOPTS_VALUE){
1157
        int step= 1024;
1158 6fd93ce2 Kenneth Aafløy
        filesize = url_fsize(&s->pb);
1159
        pos_max = filesize - 1;
1160 8d14a25c Michael Niedermayer
        do{
1161
            pos_max -= step;
1162 89ddd2a9 Michael Niedermayer
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1163 8d14a25c Michael Niedermayer
            step += step;
1164
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1165
        if (ts_max == AV_NOPTS_VALUE)
1166
            return -1;
1167 115329f1 Diego Biurrun
1168 8d14a25c Michael Niedermayer
        for(;;){
1169
            int64_t tmp_pos= pos_max + 1;
1170 89ddd2a9 Michael Niedermayer
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1171 8d14a25c Michael Niedermayer
            if(tmp_ts == AV_NOPTS_VALUE)
1172
                break;
1173
            ts_max= tmp_ts;
1174
            pos_max= tmp_pos;
1175 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1176
                break;
1177 8d14a25c Michael Niedermayer
        }
1178
        pos_limit= pos_max;
1179
    }
1180
1181 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1182
        return -1;
1183
    }else if(ts_min == ts_max){
1184
        pos_limit= pos_min;
1185
    }
1186
1187 8d14a25c Michael Niedermayer
    no_change=0;
1188
    while (pos_min < pos_limit) {
1189
#ifdef DEBUG_SEEK
1190 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1191 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1192
               ts_min, ts_max);
1193
#endif
1194
        assert(pos_limit <= pos_max);
1195
1196
        if(no_change==0){
1197
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1198
            // interpolate position (better than dichotomy)
1199 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1200
                + pos_min - approximate_keyframe_distance;
1201 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1202
            // bisection, if interpolation failed to change min or max pos last time
1203
            pos = (pos_min + pos_limit)>>1;
1204
        }else{
1205
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1206
            pos=pos_min;
1207
        }
1208
        if(pos <= pos_min)
1209
            pos= pos_min + 1;
1210
        else if(pos > pos_limit)
1211
            pos= pos_limit;
1212
        start_pos= pos;
1213
1214 89ddd2a9 Michael Niedermayer
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1215 8d14a25c Michael Niedermayer
        if(pos == pos_max)
1216
            no_change++;
1217
        else
1218
            no_change=0;
1219
#ifdef DEBUG_SEEK
1220 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);
1221 8d14a25c Michael Niedermayer
#endif
1222 db2a0e22 Michael Niedermayer
        if(ts == AV_NOPTS_VALUE){
1223
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1224
            return -1;
1225
        }
1226 8d14a25c Michael Niedermayer
        assert(ts != AV_NOPTS_VALUE);
1227 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1228 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1229
            pos_max = pos;
1230
            ts_max = ts;
1231 3ba1438d Michael Niedermayer
        }
1232
        if (target_ts >= ts) {
1233 8d14a25c Michael Niedermayer
            pos_min = pos;
1234
            ts_min = ts;
1235
        }
1236
    }
1237 115329f1 Diego Biurrun
1238 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1239
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1240 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1241
    pos_min = pos;
1242 89ddd2a9 Michael Niedermayer
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1243 8d14a25c Michael Niedermayer
    pos_min++;
1244 89ddd2a9 Michael Niedermayer
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1245 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1246 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1247
#endif
1248 89ddd2a9 Michael Niedermayer
    *ts_ret= ts;
1249
    return pos;
1250 8d14a25c Michael Niedermayer
}
1251
1252 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1253
    int64_t pos_min, pos_max;
1254
#if 0
1255
    AVStream *st;
1256

1257
    if (stream_index < 0)
1258
        return -1;
1259

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