Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 5cc9253f

History | View | Annotate | Download (91.8 KB)

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

1270
    if (stream_index < 0)
1271
        return -1;
1272

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