Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 7f938dd3

History | View | Annotate | Download (92.4 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 fb2758c8 Fabrice Bellard
        av_free(st);
2116 de6d9b64 Fabrice Bellard
    }
2117 15afa396 Nico Sabbi
    for(i=s->nb_programs-1; i>=0; i--) {
2118
        av_freep(&s->programs[i]->provider_name);
2119
        av_freep(&s->programs[i]->name);
2120 526efa10 Nico Sabbi
        av_freep(&s->programs[i]->stream_index);
2121 15afa396 Nico Sabbi
        av_freep(&s->programs[i]);
2122
    }
2123 fb2758c8 Fabrice Bellard
    flush_packet_queue(s);
2124 a8dbe951 Philip Gladstone
    av_freep(&s->priv_data);
2125 1ea4f593 Fabrice Bellard
    av_free(s);
2126 de6d9b64 Fabrice Bellard
}
2127
2128 2506fd54 Reimar Döffinger
void av_close_input_file(AVFormatContext *s)
2129
{
2130
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2131
    av_close_input_stream(s);
2132
    if (pb)
2133
        url_fclose(pb);
2134
}
2135
2136 b9a281db Fabrice Bellard
AVStream *av_new_stream(AVFormatContext *s, int id)
2137
{
2138
    AVStream *st;
2139 504ee036 Michael Niedermayer
    int i;
2140 b9a281db Fabrice Bellard
2141
    if (s->nb_streams >= MAX_STREAMS)
2142
        return NULL;
2143
2144
    st = av_mallocz(sizeof(AVStream));
2145
    if (!st)
2146
        return NULL;
2147 115329f1 Diego Biurrun
2148 01f4895c Michael Niedermayer
    st->codec= avcodec_alloc_context();
2149 48091512 Fabrice Bellard
    if (s->iformat) {
2150
        /* no default bitrate if decoding */
2151 01f4895c Michael Niedermayer
        st->codec->bit_rate = 0;
2152 48091512 Fabrice Bellard
    }
2153 b9a281db Fabrice Bellard
    st->index = s->nb_streams;
2154
    st->id = id;
2155 12f996ed Fabrice Bellard
    st->start_time = AV_NOPTS_VALUE;
2156
    st->duration = AV_NOPTS_VALUE;
2157 e928649b Michael Niedermayer
    st->cur_dts = AV_NOPTS_VALUE;
2158 82583548 Michael Niedermayer
    st->first_dts = AV_NOPTS_VALUE;
2159 9ee91c2f Michael Niedermayer
2160 a85736f2 Diego Biurrun
    /* default pts setting is MPEG-like */
2161 9ee91c2f Michael Niedermayer
    av_set_pts_info(st, 33, 1, 90000);
2162 77405fc8 Michael Niedermayer
    st->last_IP_pts = AV_NOPTS_VALUE;
2163 504ee036 Michael Niedermayer
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2164
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2165 9ee91c2f Michael Niedermayer
2166 b9a281db Fabrice Bellard
    s->streams[s->nb_streams++] = st;
2167
    return st;
2168
}
2169
2170 15afa396 Nico Sabbi
AVProgram *av_new_program(AVFormatContext *ac, int id)
2171
{
2172
    AVProgram *program=NULL;
2173
    int i;
2174
2175
#ifdef DEBUG_SI
2176
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2177
#endif
2178
2179
    for(i=0; i<ac->nb_programs; i++)
2180
        if(ac->programs[i]->id == id)
2181
            program = ac->programs[i];
2182
2183
    if(!program){
2184
        program = av_mallocz(sizeof(AVProgram));
2185
        if (!program)
2186
            return NULL;
2187
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2188
        program->discard = AVDISCARD_NONE;
2189
    }
2190
    program->id = id;
2191
2192
    return program;
2193
}
2194
2195
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2196
{
2197
    assert(!provider_name == !name);
2198
    if(name){
2199
        av_free(program->provider_name);
2200
        av_free(program->         name);
2201
        program->provider_name = av_strdup(provider_name);
2202
        program->         name = av_strdup(         name);
2203
    }
2204
}
2205
2206
2207 b9a281db Fabrice Bellard
/************************************************************/
2208
/* output media file */
2209 de6d9b64 Fabrice Bellard
2210 87a0a681 Fabrice Bellard
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2211
{
2212
    int ret;
2213 115329f1 Diego Biurrun
2214 98486a6b Roman Shaposhnik
    if (s->oformat->priv_data_size > 0) {
2215
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2216
        if (!s->priv_data)
2217 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
2218 98486a6b Roman Shaposhnik
    } else
2219
        s->priv_data = NULL;
2220 115329f1 Diego Biurrun
2221 87a0a681 Fabrice Bellard
    if (s->oformat->set_parameters) {
2222
        ret = s->oformat->set_parameters(s, ap);
2223
        if (ret < 0)
2224
            return ret;
2225
    }
2226
    return 0;
2227
}
2228
2229 b9a281db Fabrice Bellard
int av_write_header(AVFormatContext *s)
2230
{
2231 1e51d801 Fabrice Bellard
    int ret, i;
2232
    AVStream *st;
2233
2234 9450118b Michael Niedermayer
    // some sanity checks
2235
    for(i=0;i<s->nb_streams;i++) {
2236
        st = s->streams[i];
2237
2238
        switch (st->codec->codec_type) {
2239
        case CODEC_TYPE_AUDIO:
2240
            if(st->codec->sample_rate<=0){
2241
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2242
                return -1;
2243
            }
2244
            break;
2245
        case CODEC_TYPE_VIDEO:
2246
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2247
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2248
                return -1;
2249
            }
2250
            if(st->codec->width<=0 || st->codec->height<=0){
2251
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2252
                return -1;
2253
            }
2254
            break;
2255
        }
2256 5ecfa9f5 Michael Niedermayer
2257
        if(s->oformat->codec_tag){
2258
            if(st->codec->codec_tag){
2259
                //FIXME
2260
                //check that tag + id is in the table
2261 a85736f2 Diego Biurrun
                //if neither is in the table -> OK
2262 5ecfa9f5 Michael Niedermayer
                //if tag is in the table with another id -> FAIL
2263
                //if id is in the table with another tag -> FAIL unless strict < ?
2264
            }else
2265
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2266
        }
2267 9450118b Michael Niedermayer
    }
2268
2269 8fae2df5 Baptiste Coudurier
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2270 c6efa4b5 Baptiste Coudurier
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2271
        if (!s->priv_data)
2272 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
2273 8fae2df5 Baptiste Coudurier
    }
2274 c6efa4b5 Baptiste Coudurier
2275 31e11451 Michael Niedermayer
    if(s->oformat->write_header){
2276
        ret = s->oformat->write_header(s);
2277
        if (ret < 0)
2278
            return ret;
2279
    }
2280 1e51d801 Fabrice Bellard
2281
    /* init PTS generation */
2282
    for(i=0;i<s->nb_streams;i++) {
2283 f0ff20a1 Wolfram Gloger
        int64_t den = AV_NOPTS_VALUE;
2284 1e51d801 Fabrice Bellard
        st = s->streams[i];
2285
2286 01f4895c Michael Niedermayer
        switch (st->codec->codec_type) {
2287 1e51d801 Fabrice Bellard
        case CODEC_TYPE_AUDIO:
2288 f0ff20a1 Wolfram Gloger
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2289 1e51d801 Fabrice Bellard
            break;
2290
        case CODEC_TYPE_VIDEO:
2291 f0ff20a1 Wolfram Gloger
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2292 1e51d801 Fabrice Bellard
            break;
2293
        default:
2294
            break;
2295
        }
2296 f0ff20a1 Wolfram Gloger
        if (den != AV_NOPTS_VALUE) {
2297
            if (den <= 0)
2298
                return AVERROR_INVALIDDATA;
2299
            av_frac_init(&st->pts, 0, 0, den);
2300
        }
2301 1e51d801 Fabrice Bellard
    }
2302
    return 0;
2303 b9a281db Fabrice Bellard
}
2304
2305 3c895fc0 Michael Niedermayer
//FIXME merge with compute_pkt_fields
2306 5edea431 Michael Niedermayer
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2307 504ee036 Michael Niedermayer
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2308
    int num, den, frame_size, i;
2309 b0c7f5a9 Michael Niedermayer
2310 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);
2311 115329f1 Diego Biurrun
2312 e928649b Michael Niedermayer
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2313
        return -1;*/
2314 115329f1 Diego Biurrun
2315 e928649b Michael Niedermayer
    /* duration field */
2316 3c895fc0 Michael Niedermayer
    if (pkt->duration == 0) {
2317
        compute_frame_duration(&num, &den, st, NULL, pkt);
2318
        if (den && num) {
2319
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2320
        }
2321
    }
2322 e928649b Michael Niedermayer
2323
    //XXX/FIXME this is a temporary hack until all encoders output pts
2324 504ee036 Michael Niedermayer
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2325 e928649b Michael Niedermayer
        pkt->dts=
2326
//        pkt->pts= st->cur_dts;
2327
        pkt->pts= st->pts.val;
2328
    }
2329
2330 115329f1 Diego Biurrun
    //calculate dts from pts
2331 e928649b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2332 504ee036 Michael Niedermayer
        st->pts_buffer[0]= pkt->pts;
2333
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2334
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2335
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2336 1345f4ed Diego Biurrun
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2337 504ee036 Michael Niedermayer
2338
        pkt->dts= st->pts_buffer[0];
2339 e928649b Michael Niedermayer
    }
2340 115329f1 Diego Biurrun
2341 5edea431 Michael Niedermayer
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2342 578688fa Luca Abeni
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2343 5edea431 Michael Niedermayer
        return -1;
2344
    }
2345
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2346 578688fa Luca Abeni
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2347 5edea431 Michael Niedermayer
        return -1;
2348
    }
2349
2350 949b1a13 Steve L'Homme
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2351 e928649b Michael Niedermayer
    st->cur_dts= pkt->dts;
2352
    st->pts.val= pkt->dts;
2353
2354 1e51d801 Fabrice Bellard
    /* update pts */
2355 01f4895c Michael Niedermayer
    switch (st->codec->codec_type) {
2356 1e51d801 Fabrice Bellard
    case CODEC_TYPE_AUDIO:
2357 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2358 6d8f985e Michael Niedermayer
2359 a85736f2 Diego Biurrun
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2360
           likely equal to the encoder delay, but it would be better if we
2361
           had the real timestamps from the encoder */
2362 e928649b Michael Niedermayer
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2363 9ee91c2f Michael Niedermayer
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2364 7feb950a Fabrice Bellard
        }
2365 1e51d801 Fabrice Bellard
        break;
2366
    case CODEC_TYPE_VIDEO:
2367 01f4895c Michael Niedermayer
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2368 1e51d801 Fabrice Bellard
        break;
2369
    default:
2370
        break;
2371
    }
2372 5edea431 Michael Niedermayer
    return 0;
2373 3c895fc0 Michael Niedermayer
}
2374
2375
static void truncate_ts(AVStream *st, AVPacket *pkt){
2376
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2377 115329f1 Diego Biurrun
2378 e0c91bc2 Michael Niedermayer
//    if(pkt->dts < 0)
2379 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
2380 115329f1 Diego Biurrun
2381 68a432cf Baptiste Coudurier
    if (pkt->pts != AV_NOPTS_VALUE)
2382 8533284d Andy Parkins
        pkt->pts &= pts_mask;
2383 68a432cf Baptiste Coudurier
    if (pkt->dts != AV_NOPTS_VALUE)
2384 8533284d Andy Parkins
        pkt->dts &= pts_mask;
2385 3c895fc0 Michael Niedermayer
}
2386
2387
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2388
{
2389 576ae256 Michael Niedermayer
    int ret;
2390
2391 5edea431 Michael Niedermayer
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2392 494bbf58 Michael Niedermayer
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2393 5edea431 Michael Niedermayer
        return ret;
2394 115329f1 Diego Biurrun
2395 3c895fc0 Michael Niedermayer
    truncate_ts(s->streams[pkt->stream_index], pkt);
2396
2397 576ae256 Michael Niedermayer
    ret= s->oformat->write_packet(s, pkt);
2398
    if(!ret)
2399 899681cd Björn Axelsson
        ret= url_ferror(s->pb);
2400 576ae256 Michael Niedermayer
    return ret;
2401 3c895fc0 Michael Niedermayer
}
2402
2403 f21c0b4c Baptiste Coudurier
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2404 fe2d6fe2 Michael Niedermayer
    AVPacketList *pktl, **next_point, *this_pktl;
2405
    int stream_count=0;
2406
    int streams[MAX_STREAMS];
2407
2408
    if(pkt){
2409
        AVStream *st= s->streams[ pkt->stream_index];
2410
2411 2577897d Michael Niedermayer
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2412 fe2d6fe2 Michael Niedermayer
2413
        this_pktl = av_mallocz(sizeof(AVPacketList));
2414
        this_pktl->pkt= *pkt;
2415 2577897d Michael Niedermayer
        if(pkt->destruct == av_destruct_packet)
2416 a85736f2 Diego Biurrun
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2417 2577897d Michael Niedermayer
        else
2418
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2419 fe2d6fe2 Michael Niedermayer
2420
        next_point = &s->packet_buffer;
2421
        while(*next_point){
2422
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2423
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2424
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2425
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2426
                break;
2427
            next_point= &(*next_point)->next;
2428
        }
2429
        this_pktl->next= *next_point;
2430
        *next_point= this_pktl;
2431
    }
2432 115329f1 Diego Biurrun
2433 fe2d6fe2 Michael Niedermayer
    memset(streams, 0, sizeof(streams));
2434
    pktl= s->packet_buffer;
2435
    while(pktl){
2436 949b1a13 Steve L'Homme
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2437 fe2d6fe2 Michael Niedermayer
        if(streams[ pktl->pkt.stream_index ] == 0)
2438
            stream_count++;
2439
        streams[ pktl->pkt.stream_index ]++;
2440
        pktl= pktl->next;
2441
    }
2442 115329f1 Diego Biurrun
2443 fe2d6fe2 Michael Niedermayer
    if(s->nb_streams == stream_count || (flush && stream_count)){
2444
        pktl= s->packet_buffer;
2445
        *out= pktl->pkt;
2446 115329f1 Diego Biurrun
2447
        s->packet_buffer= pktl->next;
2448 fe2d6fe2 Michael Niedermayer
        av_freep(&pktl);
2449
        return 1;
2450
    }else{
2451
        av_init_packet(out);
2452
        return 0;
2453
    }
2454
}
2455
2456
/**
2457 a85736f2 Diego Biurrun
 * Interleaves an AVPacket correctly so it can be muxed.
2458 fe2d6fe2 Michael Niedermayer
 * @param out the interleaved packet will be output here
2459
 * @param in the input packet
2460
 * @param flush 1 if no further packets are available as input and all
2461
 *              remaining packets should be output
2462 115329f1 Diego Biurrun
 * @return 1 if a packet was output, 0 if no packet could be output,
2463 fe2d6fe2 Michael Niedermayer
 *         < 0 if an error occured
2464
 */
2465
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2466
    if(s->oformat->interleave_packet)
2467
        return s->oformat->interleave_packet(s, out, in, flush);
2468
    else
2469
        return av_interleave_packet_per_dts(s, out, in, flush);
2470
}
2471
2472 3c895fc0 Michael Niedermayer
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2473
    AVStream *st= s->streams[ pkt->stream_index];
2474
2475 6f824977 Michael Niedermayer
    //FIXME/XXX/HACK drop zero sized packets
2476 01f4895c Michael Niedermayer
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2477 6f824977 Michael Niedermayer
        return 0;
2478 3ce16b30 Michael Niedermayer
2479 949b1a13 Steve L'Homme
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2480 494bbf58 Michael Niedermayer
    if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2481 3ce16b30 Michael Niedermayer
        return -1;
2482 115329f1 Diego Biurrun
2483 3c895fc0 Michael Niedermayer
    if(pkt->dts == AV_NOPTS_VALUE)
2484
        return -1;
2485
2486 fe2d6fe2 Michael Niedermayer
    for(;;){
2487
        AVPacket opkt;
2488
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2489
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2490
            return ret;
2491 115329f1 Diego Biurrun
2492 fe2d6fe2 Michael Niedermayer
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2493
        ret= s->oformat->write_packet(s, &opkt);
2494 115329f1 Diego Biurrun
2495 fe2d6fe2 Michael Niedermayer
        av_free_packet(&opkt);
2496
        pkt= NULL;
2497 115329f1 Diego Biurrun
2498 3c895fc0 Michael Niedermayer
        if(ret<0)
2499
            return ret;
2500 899681cd Björn Axelsson
        if(url_ferror(s->pb))
2501
            return url_ferror(s->pb);
2502 3c895fc0 Michael Niedermayer
    }
2503 b9a281db Fabrice Bellard
}
2504
2505
int av_write_trailer(AVFormatContext *s)
2506
{
2507 c40a3a42 Michael Niedermayer
    int ret, i;
2508 115329f1 Diego Biurrun
2509 fe2d6fe2 Michael Niedermayer
    for(;;){
2510
        AVPacket pkt;
2511
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2512
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2513 c40a3a42 Michael Niedermayer
            goto fail;
2514 fe2d6fe2 Michael Niedermayer
        if(!ret)
2515
            break;
2516 115329f1 Diego Biurrun
2517 fe2d6fe2 Michael Niedermayer
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2518
        ret= s->oformat->write_packet(s, &pkt);
2519 115329f1 Diego Biurrun
2520 fe2d6fe2 Michael Niedermayer
        av_free_packet(&pkt);
2521 115329f1 Diego Biurrun
2522 3c895fc0 Michael Niedermayer
        if(ret<0)
2523 c40a3a42 Michael Niedermayer
            goto fail;
2524 899681cd Björn Axelsson
        if(url_ferror(s->pb))
2525 576ae256 Michael Niedermayer
            goto fail;
2526 3c895fc0 Michael Niedermayer
    }
2527
2528 31e11451 Michael Niedermayer
    if(s->oformat->write_trailer)
2529
        ret = s->oformat->write_trailer(s);
2530 c40a3a42 Michael Niedermayer
fail:
2531 576ae256 Michael Niedermayer
    if(ret == 0)
2532 899681cd Björn Axelsson
       ret=url_ferror(s->pb);
2533 c40a3a42 Michael Niedermayer
    for(i=0;i<s->nb_streams;i++)
2534
        av_freep(&s->streams[i]->priv_data);
2535 b9a281db Fabrice Bellard
    av_freep(&s->priv_data);
2536
    return ret;
2537 de6d9b64 Fabrice Bellard
}
2538
2539 526efa10 Nico Sabbi
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2540
{
2541
    int i, j;
2542
    AVProgram *program=NULL;
2543
    void *tmp;
2544
2545
    for(i=0; i<ac->nb_programs; i++){
2546
        if(ac->programs[i]->id != progid)
2547
            continue;
2548
        program = ac->programs[i];
2549
        for(j=0; j<program->nb_stream_indexes; j++)
2550
            if(program->stream_index[j] == idx)
2551
                return;
2552
2553
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2554
        if(!tmp)
2555
            return;
2556
        program->stream_index = tmp;
2557
        program->stream_index[program->nb_stream_indexes++] = idx;
2558
        return;
2559
    }
2560
}
2561
2562 de6d9b64 Fabrice Bellard
/* "user interface" functions */
2563 4e745a3b Baptiste Coudurier
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2564 fad0e030 Nico Sabbi
{
2565 4e745a3b Baptiste Coudurier
    char buf[256];
2566 fad0e030 Nico Sabbi
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2567
    AVStream *st = ic->streams[i];
2568
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2569
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2570
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2571
    /* the pid is an important information, so we display it */
2572
    /* XXX: add a generic system */
2573
    if (flags & AVFMT_SHOW_IDS)
2574
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2575
    if (strlen(st->language) > 0)
2576
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2577
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2578
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2579
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2580
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2581 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2582 fad0e030 Nico Sabbi
/*      else if(st->time_base.den && st->time_base.num)
2583 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2584 fad0e030 Nico Sabbi
        else
2585 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2586 fad0e030 Nico Sabbi
    }
2587
    av_log(NULL, AV_LOG_INFO, "\n");
2588
}
2589 de6d9b64 Fabrice Bellard
2590
void dump_format(AVFormatContext *ic,
2591 115329f1 Diego Biurrun
                 int index,
2592 de6d9b64 Fabrice Bellard
                 const char *url,
2593
                 int is_output)
2594
{
2595 63bb42fb Diego Biurrun
    int i;
2596 de6d9b64 Fabrice Bellard
2597 115329f1 Diego Biurrun
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2598 de6d9b64 Fabrice Bellard
            is_output ? "Output" : "Input",
2599 115329f1 Diego Biurrun
            index,
2600
            is_output ? ic->oformat->name : ic->iformat->name,
2601 de6d9b64 Fabrice Bellard
            is_output ? "to" : "from", url);
2602 12f996ed Fabrice Bellard
    if (!is_output) {
2603 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2604 12f996ed Fabrice Bellard
        if (ic->duration != AV_NOPTS_VALUE) {
2605
            int hours, mins, secs, us;
2606
            secs = ic->duration / AV_TIME_BASE;
2607
            us = ic->duration % AV_TIME_BASE;
2608
            mins = secs / 60;
2609
            secs %= 60;
2610
            hours = mins / 60;
2611
            mins %= 60;
2612 115329f1 Diego Biurrun
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2613 12f996ed Fabrice Bellard
                   (10 * us) / AV_TIME_BASE);
2614
        } else {
2615 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "N/A");
2616 12f996ed Fabrice Bellard
        }
2617 d0f3f159 Wolfram Gloger
        if (ic->start_time != AV_NOPTS_VALUE) {
2618
            int secs, us;
2619 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", start: ");
2620 d0f3f159 Wolfram Gloger
            secs = ic->start_time / AV_TIME_BASE;
2621
            us = ic->start_time % AV_TIME_BASE;
2622 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2623 d0f3f159 Wolfram Gloger
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2624
        }
2625 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2626 12f996ed Fabrice Bellard
        if (ic->bit_rate) {
2627 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2628 12f996ed Fabrice Bellard
        } else {
2629 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "N/A");
2630 12f996ed Fabrice Bellard
        }
2631 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, "\n");
2632 12f996ed Fabrice Bellard
    }
2633 526efa10 Nico Sabbi
    if(ic->nb_programs) {
2634
        int j, k;
2635
        for(j=0; j<ic->nb_programs; j++) {
2636 f473666f Nico Sabbi
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2637
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2638 526efa10 Nico Sabbi
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2639 4e745a3b Baptiste Coudurier
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2640 526efa10 Nico Sabbi
         }
2641
    } else
2642 fad0e030 Nico Sabbi
    for(i=0;i<ic->nb_streams;i++)
2643 4e745a3b Baptiste Coudurier
        dump_stream_format(ic, i, index, is_output);
2644 de6d9b64 Fabrice Bellard
}
2645
2646
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2647
{
2648 26ef3220 Stefano Sabatini
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2649 de6d9b64 Fabrice Bellard
}
2650
2651 26ef3220 Stefano Sabatini
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2652 445f1b83 Roman Shaposhnik
{
2653 26ef3220 Stefano Sabatini
    AVRational frame_rate;
2654
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2655
    *frame_rate_num= frame_rate.num;
2656
    *frame_rate_den= frame_rate.den;
2657
    return ret;
2658 445f1b83 Roman Shaposhnik
}
2659
2660 82e4ac2c Ramiro Polla
/**
2661 a85736f2 Diego Biurrun
 * Gets the current time in microseconds.
2662 82e4ac2c Ramiro Polla
 */
2663
int64_t av_gettime(void)
2664
{
2665
    struct timeval tv;
2666
    gettimeofday(&tv,NULL);
2667
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2668
}
2669
2670 0c1a9eda Zdenek Kabelac
int64_t parse_date(const char *datestr, int duration)
2671 de6d9b64 Fabrice Bellard
{
2672
    const char *p;
2673 0c1a9eda Zdenek Kabelac
    int64_t t;
2674 2dbceb9f Philip Gladstone
    struct tm dt;
2675 c5510dd6 Philip Gladstone
    int i;
2676
    static const char *date_fmt[] = {
2677
        "%Y-%m-%d",
2678
        "%Y%m%d",
2679
    };
2680
    static const char *time_fmt[] = {
2681
        "%H:%M:%S",
2682
        "%H%M%S",
2683
    };
2684
    const char *q;
2685 916c80e9 Fabrice Bellard
    int is_utc, len;
2686 c5510dd6 Philip Gladstone
    char lastch;
2687 a6a92a9a Wolfram Gloger
    int negative = 0;
2688 6d8f985e Michael Niedermayer
2689
#undef time
2690 c5510dd6 Philip Gladstone
    time_t now = time(0);
2691
2692 916c80e9 Fabrice Bellard
    len = strlen(datestr);
2693
    if (len > 0)
2694
        lastch = datestr[len - 1];
2695
    else
2696
        lastch = '\0';
2697 c5510dd6 Philip Gladstone
    is_utc = (lastch == 'z' || lastch == 'Z');
2698 2dbceb9f Philip Gladstone
2699
    memset(&dt, 0, sizeof(dt));
2700 de6d9b64 Fabrice Bellard
2701
    p = datestr;
2702 916c80e9 Fabrice Bellard
    q = NULL;
2703 de6d9b64 Fabrice Bellard
    if (!duration) {
2704 a8f70d72 Stefano Sabatini
        /* parse the year-month-day part */
2705 c5510dd6 Philip Gladstone
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2706 f71869a4 Fabrice Bellard
            q = small_strptime(p, date_fmt[i], &dt);
2707 c5510dd6 Philip Gladstone
            if (q) {
2708
                break;
2709
            }
2710
        }
2711
2712 a8f70d72 Stefano Sabatini
        /* if the year-month-day part is missing, then take the
2713
         * current year-month-day time */
2714 c5510dd6 Philip Gladstone
        if (!q) {
2715
            if (is_utc) {
2716
                dt = *gmtime(&now);
2717
            } else {
2718
                dt = *localtime(&now);
2719
            }
2720
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2721 de6d9b64 Fabrice Bellard
        } else {
2722 c5510dd6 Philip Gladstone
            p = q;
2723 de6d9b64 Fabrice Bellard
        }
2724 c5510dd6 Philip Gladstone
2725
        if (*p == 'T' || *p == 't' || *p == ' ')
2726
            p++;
2727
2728 a8f70d72 Stefano Sabatini
        /* parse the hour-minute-second part */
2729 916c80e9 Fabrice Bellard
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2730 f71869a4 Fabrice Bellard