Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ bb54f6ab

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

1323
    if (stream_index < 0)
1324
        return -1;
1325

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