Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ a23c9c4a

History | View | Annotate | Download (92.5 KB)

1 de6d9b64 Fabrice Bellard
/*
2 a85736f2 Diego Biurrun
 * various utility functions for use within FFmpeg
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 a85736f2 Diego Biurrun
 * various utility functions for use within FFmpeg
34 e36bdf8b Daniel Kristjansson
 */
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 a85736f2 Diego Biurrun
/** head of registered input format linked list */
40 8b69867f Michael Niedermayer
AVInputFormat *first_iformat = NULL;
41 a85736f2 Diego Biurrun
/** 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 a85736f2 Diego Biurrun
    /* Find the proper file type. */
116 de6d9b64 Fabrice Bellard
    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 a85736f2 Diego Biurrun
        /* We duplicate the packet and don't forget to add the padding again. */
245 568e18b1 Michael Niedermayer
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
246 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
247 8a56ac7b Fabrice Bellard
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
248 fb2758c8 Fabrice Bellard
        if (!data) {
249 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
250 fb2758c8 Fabrice Bellard
        }
251
        memcpy(data, pkt->data, pkt->size);
252 8a56ac7b Fabrice Bellard
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
253 fb2758c8 Fabrice Bellard
        pkt->data = data;
254
        pkt->destruct = av_destruct_packet;
255
    }
256
    return 0;
257
}
258
259 5c07cf53 Michel Bardiaux
int av_filename_number_test(const char *filename)
260 b9a281db Fabrice Bellard
{
261
    char buf[1024];
262 5c07cf53 Michel Bardiaux
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
263 b9a281db Fabrice Bellard
}
264
265 79750486 Michael Niedermayer
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
266 b9a281db Fabrice Bellard
{
267
    AVInputFormat *fmt1, *fmt;
268 79750486 Michael Niedermayer
    int score;
269 b9a281db Fabrice Bellard
270
    fmt = NULL;
271
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
272 b8e705ec Reimar Döffinger
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
273 b9a281db Fabrice Bellard
            continue;
274
        score = 0;
275 a8dbe951 Philip Gladstone
        if (fmt1->read_probe) {
276
            score = fmt1->read_probe(pd);
277
        } else if (fmt1->extensions) {
278 b9a281db Fabrice Bellard
            if (match_ext(pd->filename, fmt1->extensions)) {
279
                score = 50;
280
            }
281 115329f1 Diego Biurrun
        }
282 79750486 Michael Niedermayer
        if (score > *score_max) {
283
            *score_max = score;
284 b9a281db Fabrice Bellard
            fmt = fmt1;
285
        }
286
    }
287
    return fmt;
288
}
289
290 79750486 Michael Niedermayer
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
291
    int score=0;
292
    return av_probe_input_format2(pd, is_opened, &score);
293
}
294
295 b9a281db Fabrice Bellard
/************************************************************/
296
/* input media file */
297 96baaa6a Fabrice Bellard
298 da24c5e3 Fabrice Bellard
/**
299 e36bdf8b Daniel Kristjansson
 * Open a media file from an IO stream. 'fmt' must be specified.
300 da24c5e3 Fabrice Bellard
 */
301 43465395 Michael Niedermayer
static const char* format_to_name(void* ptr)
302 bc874dae Michel Bardiaux
{
303 43465395 Michael Niedermayer
    AVFormatContext* fc = (AVFormatContext*) ptr;
304 bc874dae Michel Bardiaux
    if(fc->iformat) return fc->iformat->name;
305
    else if(fc->oformat) return fc->oformat->name;
306
    else return "NULL";
307
}
308
309 66acccf0 Panagiotis Issaris
#define OFFSET(x) offsetof(AVFormatContext,x)
310 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
311 4eb72c6b Nico Sabbi
//these names are too long to be readable
312
#define E AV_OPT_FLAG_ENCODING_PARAM
313
#define D AV_OPT_FLAG_DECODING_PARAM
314
315
static const AVOption options[]={
316 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 */
317 09a45576 Panagiotis Issaris
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
318 4ff8fcef Panagiotis Issaris
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
319 18de0b81 Baptiste Coudurier
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
320 2c00106c Michael Niedermayer
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
321
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
322 8c3dd5dc Panagiotis Issaris
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
323 ec1b10f4 Panagiotis Issaris
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
324 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},
325 841f39a7 Reimar Döffinger
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
326 3dea63bd Paul Kelly
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, INT_MAX, 0, INT_MAX, 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 a85736f2 Diego Biurrun
/** 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 a85736f2 Diego Biurrun
        /* 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 a85736f2 Diego Biurrun
    /* Do not open file if the format does not need it. XXX: specific
436 b6892136 Fabrice Bellard
       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 a85736f2 Diego Biurrun
    /* check filename in case 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 a85736f2 Diego Biurrun
 * Get the number of samples of an audio frame. Return -1 on error.
523 e36bdf8b Daniel Kristjansson
 */
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 a85736f2 Diego Biurrun
 * Return the frame duration in seconds. Return 0 if not available.
550 e36bdf8b Daniel Kristjansson
 */
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 a85736f2 Diego Biurrun
    /* correct timestamps with byte offset if demuxers only have timestamps
654
       on packet boundaries */
655 a74008a4 Joakim Plate
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
656
        /* this will estimate bitrate based on this frame's duration and size */
657
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
658
        if(pkt->pts != AV_NOPTS_VALUE)
659
            pkt->pts += offset;
660
        if(pkt->dts != AV_NOPTS_VALUE)
661
            pkt->dts += offset;
662
    }
663
664 a85736f2 Diego Biurrun
    /* do we have a video B-frame ? */
665 befe3b05 Michael Niedermayer
    delay= st->codec->has_b_frames;
666 fb2758c8 Fabrice Bellard
    presentation_delayed = 0;
667 7e4baa66 Michael Niedermayer
    /* XXX: need has_b_frame, but cannot get it if the codec is
668
        not initialized */
669
    if (delay &&
670
        pc && pc->pict_type != FF_B_TYPE)
671
        presentation_delayed = 1;
672 755bfeab Diego Biurrun
    /* This may be redundant, but it should not hurt. */
673 7e4baa66 Michael Niedermayer
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
674
        presentation_delayed = 1;
675 115329f1 Diego Biurrun
676 e928649b Michael Niedermayer
    if(st->cur_dts == AV_NOPTS_VALUE){
677 82583548 Michael Niedermayer
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
678 e928649b Michael Niedermayer
    }
679 fb2758c8 Fabrice Bellard
680 949b1a13 Steve L'Homme
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
681 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
682 7e4baa66 Michael Niedermayer
    if(delay <=1){
683
        if (presentation_delayed) {
684 a85736f2 Diego Biurrun
            /* DTS = decompression timestamp */
685
            /* PTS = presentation timestamp */
686 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
687
                pkt->dts = st->last_IP_pts;
688 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
689 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
690
                pkt->dts = st->cur_dts;
691
692
            /* this is tricky: the dts must be incremented by the duration
693 a85736f2 Diego Biurrun
            of the frame we are displaying, i.e. the last I- or P-frame */
694 7e4baa66 Michael Niedermayer
            if (st->last_IP_duration == 0)
695
                st->last_IP_duration = pkt->duration;
696
            st->cur_dts = pkt->dts + st->last_IP_duration;
697
            st->last_IP_duration  = pkt->duration;
698
            st->last_IP_pts= pkt->pts;
699
            /* cannot compute PTS if not present (we can compute it only
700 a85736f2 Diego Biurrun
            by knowing the future */
701 028d6f3e Michael Niedermayer
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
702 7e4baa66 Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
703
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
704
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
705
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
706
                    pkt->pts += pkt->duration;
707
    //                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);
708
                }
709 90bb394d Michael Niedermayer
            }
710 115329f1 Diego Biurrun
711 7e4baa66 Michael Niedermayer
            /* presentation is not delayed : PTS and DTS are the same */
712
            if(pkt->pts == AV_NOPTS_VALUE)
713
                pkt->pts = pkt->dts;
714 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
715 7e4baa66 Michael Niedermayer
            if(pkt->pts == AV_NOPTS_VALUE)
716
                pkt->pts = st->cur_dts;
717
            pkt->dts = pkt->pts;
718
            st->cur_dts = pkt->pts + pkt->duration;
719
        }
720 fb2758c8 Fabrice Bellard
    }
721 d9e1efb7 Michael Niedermayer
722
    if(pkt->pts != AV_NOPTS_VALUE){
723
        st->pts_buffer[0]= pkt->pts;
724
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
725
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
726
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
727
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
728
        if(pkt->dts == AV_NOPTS_VALUE)
729
            pkt->dts= st->pts_buffer[0];
730 82583548 Michael Niedermayer
        if(delay>1){
731 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
732 82583548 Michael Niedermayer
        }
733 d9e1efb7 Michael Niedermayer
        if(pkt->dts > st->cur_dts)
734
            st->cur_dts = pkt->dts;
735
    }
736
737
//    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);
738 115329f1 Diego Biurrun
739 fb2758c8 Fabrice Bellard
    /* update flags */
740 3a1d3588 Jeff Downs
    if(is_intra_only(st->codec))
741
        pkt->flags |= PKT_FLAG_KEY;
742
    else if (pc) {
743 fb2758c8 Fabrice Bellard
        pkt->flags = 0;
744 a85736f2 Diego Biurrun
        /* keyframe computation */
745 fb2758c8 Fabrice Bellard
            if (pc->pict_type == FF_I_TYPE)
746
                pkt->flags |= PKT_FLAG_KEY;
747
    }
748
}
749
750 63dd1377 Michael Niedermayer
void av_destruct_packet_nofree(AVPacket *pkt)
751 fb2758c8 Fabrice Bellard
{
752
    pkt->data = NULL; pkt->size = 0;
753
}
754
755
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
756
{
757
    AVStream *st;
758 37353960 Fabrice Bellard
    int len, ret, i;
759 fb2758c8 Fabrice Bellard
760 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
761
762 fb2758c8 Fabrice Bellard
    for(;;) {
763
        /* select current input stream component */
764
        st = s->cur_st;
765
        if (st) {
766 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
767 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
768
                /* raw data support */
769
                *pkt = s->cur_pkt;
770
                compute_pkt_fields(s, st, NULL, pkt);
771
                s->cur_st = NULL;
772 434cab9e Michael Niedermayer
                break;
773 f3356e9c Michael Niedermayer
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
774 115329f1 Diego Biurrun
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
775 6ec87caa Fabrice Bellard
                                      s->cur_ptr, s->cur_len,
776
                                      s->cur_pkt.pts, s->cur_pkt.dts);
777
                s->cur_pkt.pts = AV_NOPTS_VALUE;
778
                s->cur_pkt.dts = AV_NOPTS_VALUE;
779 fb2758c8 Fabrice Bellard
                /* increment read pointer */
780
                s->cur_ptr += len;
781
                s->cur_len -= len;
782 115329f1 Diego Biurrun
783 fb2758c8 Fabrice Bellard
                /* return packet if any */
784
                if (pkt->size) {
785 37353960 Fabrice Bellard
                got_packet:
786 711737af Daniel Cardenas
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
787 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
788
                    pkt->stream_index = st->index;
789 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
790
                    pkt->dts = st->parser->dts;
791 fb2758c8 Fabrice Bellard
                    pkt->destruct = av_destruct_packet_nofree;
792
                    compute_pkt_fields(s, st, st->parser, pkt);
793 e9b78eeb Michael Niedermayer
794
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
795 3dea63bd Paul Kelly
                        ff_reduce_index(s, st->index);
796 e9b78eeb Michael Niedermayer
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
797
                                           0, 0, AVINDEX_KEYFRAME);
798
                    }
799
800 434cab9e Michael Niedermayer
                    break;
801 fb2758c8 Fabrice Bellard
                }
802
            } else {
803 bcbecff1 Fabrice Bellard
                /* free packet */
804 115329f1 Diego Biurrun
                av_free_packet(&s->cur_pkt);
805 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
806
            }
807
        } else {
808
            /* read next packet */
809
            ret = av_read_packet(s, &s->cur_pkt);
810 37353960 Fabrice Bellard
            if (ret < 0) {
811 8fa36ae0 François Revol
                if (ret == AVERROR(EAGAIN))
812 37353960 Fabrice Bellard
                    return ret;
813
                /* return the last frames, if any */
814
                for(i = 0; i < s->nb_streams; i++) {
815
                    st = s->streams[i];
816 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
817 115329f1 Diego Biurrun
                        av_parser_parse(st->parser, st->codec,
818
                                        &pkt->data, &pkt->size,
819
                                        NULL, 0,
820 6ec87caa Fabrice Bellard
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
821 37353960 Fabrice Bellard
                        if (pkt->size)
822
                            goto got_packet;
823
                    }
824
                }
825 a85736f2 Diego Biurrun
                /* no more packets: really terminate parsing */
826 fb2758c8 Fabrice Bellard
                return ret;
827 37353960 Fabrice Bellard
            }
828 115329f1 Diego Biurrun
829 9ee91c2f Michael Niedermayer
            st = s->streams[s->cur_pkt.stream_index];
830 434cab9e Michael Niedermayer
            if(st->codec->debug & FF_DEBUG_PTS)
831 ccd3228e Dominik Mierzejewski
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
832 434cab9e Michael Niedermayer
                    s->cur_pkt.stream_index,
833
                    s->cur_pkt.pts,
834
                    s->cur_pkt.dts,
835
                    s->cur_pkt.size);
836 fb2758c8 Fabrice Bellard
837
            s->cur_st = st;
838
            s->cur_ptr = s->cur_pkt.data;
839
            s->cur_len = s->cur_pkt.size;
840
            if (st->need_parsing && !st->parser) {
841 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
842 fb2758c8 Fabrice Bellard
                if (!st->parser) {
843 a85736f2 Diego Biurrun
                    /* no parser available: just output the raw packets */
844 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_NONE;
845
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
846 7cbaa7ba Michael Niedermayer
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
847 fb2758c8 Fabrice Bellard
                }
848 e9b78eeb Michael Niedermayer
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
849
                    st->parser->last_frame_offset=
850
                    st->parser->cur_offset= s->cur_pkt.pos;
851
                }
852 fb2758c8 Fabrice Bellard
            }
853
        }
854
    }
855 434cab9e Michael Niedermayer
    if(st->codec->debug & FF_DEBUG_PTS)
856 ccd3228e Dominik Mierzejewski
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
857 434cab9e Michael Niedermayer
            pkt->stream_index,
858
            pkt->pts,
859
            pkt->dts,
860
            pkt->size);
861
862
    return 0;
863 fb2758c8 Fabrice Bellard
}
864
865 02b15cc8 Michael Niedermayer
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
866
    AVPacketList *pktl= s->packet_buffer;
867
    AVPacketList **plast_pktl= &s->packet_buffer;
868
869
    while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
870
871
    pktl = av_mallocz(sizeof(AVPacketList));
872
    if (!pktl)
873
        return NULL;
874
875
    /* add the packet in the buffered packet list */
876
    *plast_pktl = pktl;
877
    pktl->pkt= *pkt;
878
    return &pktl->pkt;
879
}
880
881 fb2758c8 Fabrice Bellard
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
882
{
883 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
884 30bc6613 Michael Niedermayer
    int eof=0;
885
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
886
887
    for(;;){
888
        pktl = s->packet_buffer;
889
        if (pktl) {
890
            AVPacket *next_pkt= &pktl->pkt;
891
892
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
893
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
894 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
895 30bc6613 Michael Niedermayer
                       && next_pkt->dts < pktl->pkt.dts
896
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
897
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
898
                        next_pkt->pts= pktl->pkt.dts;
899
                    }
900
                    pktl= pktl->next;
901
                }
902
                pktl = s->packet_buffer;
903
            }
904 115329f1 Diego Biurrun
905
            if(   next_pkt->pts != AV_NOPTS_VALUE
906
               || next_pkt->dts == AV_NOPTS_VALUE
907 30bc6613 Michael Niedermayer
               || !genpts || eof){
908
                /* read packet from packet buffer, if there is data */
909
                *pkt = *next_pkt;
910
                s->packet_buffer = pktl->next;
911
                av_free(pktl);
912
                return 0;
913
            }
914
        }
915
        if(genpts){
916
            int ret= av_read_frame_internal(s, pkt);
917
            if(ret<0){
918 8fa36ae0 François Revol
                if(pktl && ret != AVERROR(EAGAIN)){
919 30bc6613 Michael Niedermayer
                    eof=1;
920
                    continue;
921
                }else
922
                    return ret;
923
            }
924 115329f1 Diego Biurrun
925 02b15cc8 Michael Niedermayer
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
926 769e10f0 Panagiotis Issaris
                return AVERROR(ENOMEM);
927 30bc6613 Michael Niedermayer
        }else{
928
            assert(!s->packet_buffer);
929
            return av_read_frame_internal(s, pkt);
930
        }
931 fb2758c8 Fabrice Bellard
    }
932
}
933
934
/* XXX: suppress the packet queue */
935
static void flush_packet_queue(AVFormatContext *s)
936
{
937
    AVPacketList *pktl;
938
939
    for(;;) {
940
        pktl = s->packet_buffer;
941 115329f1 Diego Biurrun
        if (!pktl)
942 fb2758c8 Fabrice Bellard
            break;
943
        s->packet_buffer = pktl->next;
944
        av_free_packet(&pktl->pkt);
945
        av_free(pktl);
946 b9a281db Fabrice Bellard
    }
947
}
948
949 da24c5e3 Fabrice Bellard
/*******************************************************/
950 fb2758c8 Fabrice Bellard
/* seek support */
951
952 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
953
{
954
    int i;
955
    AVStream *st;
956
957
    if (s->nb_streams <= 0)
958
        return -1;
959
    for(i = 0; i < s->nb_streams; i++) {
960
        st = s->streams[i];
961 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
962 b754978a Michael Niedermayer
            return i;
963
        }
964
    }
965
    return 0;
966
}
967
968 e36bdf8b Daniel Kristjansson
/**
969
 * Flush the frame reader.
970
 */
971 fb2758c8 Fabrice Bellard
static void av_read_frame_flush(AVFormatContext *s)
972
{
973
    AVStream *st;
974
    int i;
975
976
    flush_packet_queue(s);
977
978
    /* free previous packet */
979
    if (s->cur_st) {
980
        if (s->cur_st->parser)
981
            av_free_packet(&s->cur_pkt);
982
        s->cur_st = NULL;
983
    }
984
    /* fail safe */
985
    s->cur_ptr = NULL;
986
    s->cur_len = 0;
987 115329f1 Diego Biurrun
988 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
989
    for(i = 0; i < s->nb_streams; i++) {
990
        st = s->streams[i];
991 115329f1 Diego Biurrun
992 fb2758c8 Fabrice Bellard
        if (st->parser) {
993
            av_parser_close(st->parser);
994
            st->parser = NULL;
995
        }
996 77405fc8 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
997 a843d1ff Michael Niedermayer
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
998 fb2758c8 Fabrice Bellard
    }
999
}
1000
1001 22ffac70 Reimar Döffinger
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1002 8bcb147f Michael Niedermayer
    int i;
1003
1004
    for(i = 0; i < s->nb_streams; i++) {
1005 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
1006 8bcb147f Michael Niedermayer
1007 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
1008 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1009
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1010 8bcb147f Michael Niedermayer
    }
1011
}
1012
1013 3dea63bd Paul Kelly
void ff_reduce_index(AVFormatContext *s, int stream_index)
1014
{
1015
    AVStream *st= s->streams[stream_index];
1016
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1017
1018
    if((unsigned)st->nb_index_entries >= max_entries){
1019
        int i;
1020
        for(i=0; 2*i<st->nb_index_entries; i++)
1021
            st->index_entries[i]= st->index_entries[2*i];
1022
        st->nb_index_entries= i;
1023
    }
1024
}
1025
1026 3e9245a9 Michael Niedermayer
int av_add_index_entry(AVStream *st,
1027 30a43f2d Michael Niedermayer
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1028 fb2758c8 Fabrice Bellard
{
1029
    AVIndexEntry *entries, *ie;
1030 b754978a Michael Niedermayer
    int index;
1031 115329f1 Diego Biurrun
1032 568e18b1 Michael Niedermayer
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1033
        return -1;
1034 115329f1 Diego Biurrun
1035 fb2758c8 Fabrice Bellard
    entries = av_fast_realloc(st->index_entries,
1036
                              &st->index_entries_allocated_size,
1037 115329f1 Diego Biurrun
                              (st->nb_index_entries + 1) *
1038 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1039 568e18b1 Michael Niedermayer
    if(!entries)
1040
        return -1;
1041
1042 b754978a Michael Niedermayer
    st->index_entries= entries;
1043
1044 27a5fe5f Michael Niedermayer
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1045 b754978a Michael Niedermayer
1046 3ba1438d Michael Niedermayer
    if(index<0){
1047 3e9245a9 Michael Niedermayer
        index= st->nb_index_entries++;
1048
        ie= &entries[index];
1049 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1050
    }else{
1051
        ie= &entries[index];
1052
        if(ie->timestamp != timestamp){
1053 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1054
                return -1;
1055 3ba1438d Michael Niedermayer
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1056
            st->nb_index_entries++;
1057 755bfeab Diego Biurrun
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1058 3ba1438d Michael Niedermayer
            distance= ie->min_distance;
1059 3e9245a9 Michael Niedermayer
    }
1060 3ba1438d Michael Niedermayer
1061 b754978a Michael Niedermayer
    ie->pos = pos;
1062
    ie->timestamp = timestamp;
1063 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1064 30a43f2d Michael Niedermayer
    ie->size= size;
1065 b754978a Michael Niedermayer
    ie->flags = flags;
1066 115329f1 Diego Biurrun
1067 3e9245a9 Michael Niedermayer
    return index;
1068 fb2758c8 Fabrice Bellard
}
1069
1070 dc56fc38 Michael Niedermayer
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1071 27a5fe5f Michael Niedermayer
                              int flags)
1072 fb2758c8 Fabrice Bellard
{
1073 b754978a Michael Niedermayer
    AVIndexEntry *entries= st->index_entries;
1074
    int nb_entries= st->nb_index_entries;
1075 fb2758c8 Fabrice Bellard
    int a, b, m;
1076
    int64_t timestamp;
1077
1078 3ba1438d Michael Niedermayer
    a = - 1;
1079
    b = nb_entries;
1080 b754978a Michael Niedermayer
1081 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1082
        m = (a + b) >> 1;
1083 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1084 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1085
            b = m;
1086
        if(timestamp <= wanted_timestamp)
1087 b754978a Michael Niedermayer
            a = m;
1088 fb2758c8 Fabrice Bellard
    }
1089 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1090 115329f1 Diego Biurrun
1091 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1092
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1093
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1094
        }
1095
    }
1096 3ba1438d Michael Niedermayer
1097 115329f1 Diego Biurrun
    if(m == nb_entries)
1098 3ba1438d Michael Niedermayer
        return -1;
1099
    return  m;
1100 fb2758c8 Fabrice Bellard
}
1101
1102 0f652a8e Benoit Fouet
#define DEBUG_SEEK
1103 8d14a25c Michael Niedermayer
1104 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1105 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1106
    int64_t pos_min, pos_max, pos, pos_limit;
1107
    int64_t ts_min, ts_max, ts;
1108 89ddd2a9 Michael Niedermayer
    int index;
1109 8d14a25c Michael Niedermayer
    AVStream *st;
1110
1111 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1112
        return -1;
1113 115329f1 Diego Biurrun
1114 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1115 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1116 8d14a25c Michael Niedermayer
#endif
1117
1118
    ts_max=
1119
    ts_min= AV_NOPTS_VALUE;
1120 90b5b51e Diego Biurrun
    pos_limit= -1; //gcc falsely says it may be uninitialized
1121 8d14a25c Michael Niedermayer
1122
    st= s->streams[stream_index];
1123
    if(st->index_entries){
1124
        AVIndexEntry *e;
1125
1126 a85736f2 Diego Biurrun
        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()
1127 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1128 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1129
1130
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1131
            pos_min= e->pos;
1132
            ts_min= e->timestamp;
1133
#ifdef DEBUG_SEEK
1134 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1135 8d14a25c Michael Niedermayer
               pos_min,ts_min);
1136
#endif
1137
        }else{
1138
            assert(index==0);
1139
        }
1140 115329f1 Diego Biurrun
1141
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1142 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1143
        if(index >= 0){
1144 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1145
            assert(e->timestamp >= target_ts);
1146
            pos_max= e->pos;
1147
            ts_max= e->timestamp;
1148
            pos_limit= pos_max - e->min_distance;
1149
#ifdef DEBUG_SEEK
1150 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1151 8d14a25c Michael Niedermayer
               pos_max,pos_limit, ts_max);
1152
#endif
1153
        }
1154
    }
1155
1156 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);
1157
    if(pos<0)
1158
        return -1;
1159
1160
    /* do the seek */
1161 899681cd Björn Axelsson
    url_fseek(s->pb, pos, SEEK_SET);
1162 89ddd2a9 Michael Niedermayer
1163
    av_update_cur_dts(s, st, ts);
1164
1165
    return 0;
1166
}
1167
1168
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 )){
1169
    int64_t pos, ts;
1170
    int64_t start_pos, filesize;
1171
    int no_change;
1172
1173
#ifdef DEBUG_SEEK
1174
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1175
#endif
1176
1177 8d14a25c Michael Niedermayer
    if(ts_min == AV_NOPTS_VALUE){
1178
        pos_min = s->data_offset;
1179 89ddd2a9 Michael Niedermayer
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1180 8d14a25c Michael Niedermayer
        if (ts_min == AV_NOPTS_VALUE)
1181
            return -1;
1182
    }
1183
1184
    if(ts_max == AV_NOPTS_VALUE){
1185
        int step= 1024;
1186 899681cd Björn Axelsson
        filesize = url_fsize(s->pb);
1187 6fd93ce2 Kenneth Aafløy
        pos_max = filesize - 1;
1188 8d14a25c Michael Niedermayer
        do{
1189
            pos_max -= step;
1190 89ddd2a9 Michael Niedermayer
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1191 8d14a25c Michael Niedermayer
            step += step;
1192
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1193
        if (ts_max == AV_NOPTS_VALUE)
1194
            return -1;
1195 115329f1 Diego Biurrun
1196 8d14a25c Michael Niedermayer
        for(;;){
1197
            int64_t tmp_pos= pos_max + 1;
1198 89ddd2a9 Michael Niedermayer
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1199 8d14a25c Michael Niedermayer
            if(tmp_ts == AV_NOPTS_VALUE)
1200
                break;
1201
            ts_max= tmp_ts;
1202
            pos_max= tmp_pos;
1203 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1204
                break;
1205 8d14a25c Michael Niedermayer
        }
1206
        pos_limit= pos_max;
1207
    }
1208
1209 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1210
        return -1;
1211
    }else if(ts_min == ts_max){
1212
        pos_limit= pos_min;
1213
    }
1214
1215 8d14a25c Michael Niedermayer
    no_change=0;
1216
    while (pos_min < pos_limit) {
1217
#ifdef DEBUG_SEEK
1218 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1219 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1220
               ts_min, ts_max);
1221
#endif
1222
        assert(pos_limit <= pos_max);
1223
1224
        if(no_change==0){
1225
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1226
            // interpolate position (better than dichotomy)
1227 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1228
                + pos_min - approximate_keyframe_distance;
1229 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1230
            // bisection, if interpolation failed to change min or max pos last time
1231
            pos = (pos_min + pos_limit)>>1;
1232
        }else{
1233 a85736f2 Diego Biurrun
            /* linear search if bisection failed, can only happen if there
1234
               are very few or no keyframes between min/max */
1235 8d14a25c Michael Niedermayer
            pos=pos_min;
1236
        }
1237
        if(pos <= pos_min)
1238
            pos= pos_min + 1;
1239
        else if(pos > pos_limit)
1240
            pos= pos_limit;
1241
        start_pos= pos;
1242
1243 89ddd2a9 Michael Niedermayer
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1244 8d14a25c Michael Niedermayer
        if(pos == pos_max)
1245
            no_change++;
1246
        else
1247
            no_change=0;
1248
#ifdef DEBUG_SEEK
1249 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);
1250 8d14a25c Michael Niedermayer
#endif
1251 db2a0e22 Michael Niedermayer
        if(ts == AV_NOPTS_VALUE){
1252
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1253
            return -1;
1254
        }
1255 8d14a25c Michael Niedermayer
        assert(ts != AV_NOPTS_VALUE);
1256 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1257 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1258
            pos_max = pos;
1259
            ts_max = ts;
1260 3ba1438d Michael Niedermayer
        }
1261
        if (target_ts >= ts) {
1262 8d14a25c Michael Niedermayer
            pos_min = pos;
1263
            ts_min = ts;
1264
        }
1265
    }
1266 115329f1 Diego Biurrun
1267 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1268
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1269 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1270
    pos_min = pos;
1271 89ddd2a9 Michael Niedermayer
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1272 8d14a25c Michael Niedermayer
    pos_min++;
1273 89ddd2a9 Michael Niedermayer
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1274 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1275 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1276
#endif
1277 89ddd2a9 Michael Niedermayer
    *ts_ret= ts;
1278
    return pos;
1279 8d14a25c Michael Niedermayer
}
1280
1281 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1282
    int64_t pos_min, pos_max;
1283
#if 0
1284
    AVStream *st;
1285

1286
    if (stream_index < 0)
1287
        return -1;
1288

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