Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ ca75a923

History | View | Annotate | Download (90.8 KB)

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

1251
    if (stream_index < 0)
1252
        return -1;
1253

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