Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 41415d28

History | View | Annotate | Download (87.3 KB)

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

1227
    if (stream_index < 0)
1228
        return -1;
1229

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