Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ c7385375

History | View | Annotate | Download (88.1 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 82583548 Michael Niedermayer
static void update_initial_timestamps(AVFormatContext *s, int stream_index, int64_t dts){
593
    AVStream *st= s->streams[stream_index];
594
    AVPacketList *pktl= s->packet_buffer;
595
596
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
597
        return;
598
599
    st->first_dts= dts - st->cur_dts;
600
    st->cur_dts= dts;
601
602
    for(; pktl; pktl= pktl->next){
603
        if(pktl->pkt.stream_index != stream_index)
604
            continue;
605
        //FIXME think more about this check
606
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
607
            pktl->pkt.pts += st->first_dts;
608
609
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
610
            pktl->pkt.dts += st->first_dts;
611 48a59dfe Michael Niedermayer
612
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
613
            st->start_time= pktl->pkt.pts;
614 82583548 Michael Niedermayer
    }
615
}
616
617 115329f1 Diego Biurrun
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
618 fb2758c8 Fabrice Bellard
                               AVCodecParserContext *pc, AVPacket *pkt)
619
{
620 d9e1efb7 Michael Niedermayer
    int num, den, presentation_delayed, delay, i;
621 a74008a4 Joakim Plate
    int64_t offset;
622 115329f1 Diego Biurrun
623 10a7571b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
624
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
625
        pkt->dts -= 1LL<<st->pts_wrap_bits;
626
    }
627
628 fb2758c8 Fabrice Bellard
    if (pkt->duration == 0) {
629 3c895fc0 Michael Niedermayer
        compute_frame_duration(&num, &den, st, pc, pkt);
630 fb2758c8 Fabrice Bellard
        if (den && num) {
631 77405fc8 Michael Niedermayer
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
632 fb2758c8 Fabrice Bellard
        }
633
    }
634
635 a74008a4 Joakim Plate
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
636
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
637
        /* this will estimate bitrate based on this frame's duration and size */
638
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
639
        if(pkt->pts != AV_NOPTS_VALUE)
640
            pkt->pts += offset;
641
        if(pkt->dts != AV_NOPTS_VALUE)
642
            pkt->dts += offset;
643
    }
644
645 01f4895c Michael Niedermayer
    if(is_intra_only(st->codec))
646 5ba7c3d7 Michael Niedermayer
        pkt->flags |= PKT_FLAG_KEY;
647
648 fb2758c8 Fabrice Bellard
    /* do we have a video B frame ? */
649 befe3b05 Michael Niedermayer
    delay= st->codec->has_b_frames;
650 fb2758c8 Fabrice Bellard
    presentation_delayed = 0;
651 7e4baa66 Michael Niedermayer
    /* XXX: need has_b_frame, but cannot get it if the codec is
652
        not initialized */
653
    if (delay &&
654
        pc && pc->pict_type != FF_B_TYPE)
655
        presentation_delayed = 1;
656 755bfeab Diego Biurrun
    /* This may be redundant, but it should not hurt. */
657 7e4baa66 Michael Niedermayer
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
658
        presentation_delayed = 1;
659 115329f1 Diego Biurrun
660 e928649b Michael Niedermayer
    if(st->cur_dts == AV_NOPTS_VALUE){
661 82583548 Michael Niedermayer
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
662 e928649b Michael Niedermayer
    }
663 fb2758c8 Fabrice Bellard
664 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);
665 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
666 7e4baa66 Michael Niedermayer
    if(delay <=1){
667
        if (presentation_delayed) {
668
            /* DTS = decompression time stamp */
669
            /* PTS = presentation time stamp */
670
            if (pkt->dts == AV_NOPTS_VALUE)
671
                pkt->dts = st->last_IP_pts;
672 82583548 Michael Niedermayer
            update_initial_timestamps(s, pkt->stream_index, pkt->dts);
673 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
674
                pkt->dts = st->cur_dts;
675
676
            /* this is tricky: the dts must be incremented by the duration
677
            of the frame we are displaying, i.e. the last I or P frame */
678
            if (st->last_IP_duration == 0)
679
                st->last_IP_duration = pkt->duration;
680
            st->cur_dts = pkt->dts + st->last_IP_duration;
681
            st->last_IP_duration  = pkt->duration;
682
            st->last_IP_pts= pkt->pts;
683
            /* cannot compute PTS if not present (we can compute it only
684
            by knowing the futur */
685 028d6f3e Michael Niedermayer
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
686 7e4baa66 Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
687
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
688
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
689
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
690
                    pkt->pts += pkt->duration;
691
    //                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);
692
                }
693 90bb394d Michael Niedermayer
            }
694 115329f1 Diego Biurrun
695 7e4baa66 Michael Niedermayer
            /* presentation is not delayed : PTS and DTS are the same */
696
            if(pkt->pts == AV_NOPTS_VALUE)
697
                pkt->pts = pkt->dts;
698 82583548 Michael Niedermayer
            update_initial_timestamps(s, pkt->stream_index, pkt->pts);
699 7e4baa66 Michael Niedermayer
            if(pkt->pts == AV_NOPTS_VALUE)
700
                pkt->pts = st->cur_dts;
701
            pkt->dts = pkt->pts;
702
            st->cur_dts = pkt->pts + pkt->duration;
703
        }
704 fb2758c8 Fabrice Bellard
    }
705 d9e1efb7 Michael Niedermayer
706
    if(pkt->pts != AV_NOPTS_VALUE){
707
        st->pts_buffer[0]= pkt->pts;
708
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
709
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
710
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
711
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
712
        if(pkt->dts == AV_NOPTS_VALUE)
713
            pkt->dts= st->pts_buffer[0];
714 82583548 Michael Niedermayer
        if(delay>1){
715
            update_initial_timestamps(s, pkt->stream_index, pkt->dts); // this should happen on the first packet
716
        }
717 d9e1efb7 Michael Niedermayer
        if(pkt->dts > st->cur_dts)
718
            st->cur_dts = pkt->dts;
719
    }
720
721
//    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);
722 115329f1 Diego Biurrun
723 fb2758c8 Fabrice Bellard
    /* update flags */
724
    if (pc) {
725
        pkt->flags = 0;
726
        /* key frame computation */
727
            if (pc->pict_type == FF_I_TYPE)
728
                pkt->flags |= PKT_FLAG_KEY;
729
    }
730
}
731
732 63dd1377 Michael Niedermayer
void av_destruct_packet_nofree(AVPacket *pkt)
733 fb2758c8 Fabrice Bellard
{
734
    pkt->data = NULL; pkt->size = 0;
735
}
736
737
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
738
{
739
    AVStream *st;
740 37353960 Fabrice Bellard
    int len, ret, i;
741 fb2758c8 Fabrice Bellard
742 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
743
744 fb2758c8 Fabrice Bellard
    for(;;) {
745
        /* select current input stream component */
746
        st = s->cur_st;
747
        if (st) {
748 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
749 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
750
                /* raw data support */
751
                *pkt = s->cur_pkt;
752
                compute_pkt_fields(s, st, NULL, pkt);
753
                s->cur_st = NULL;
754 434cab9e Michael Niedermayer
                break;
755 f3356e9c Michael Niedermayer
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
756 115329f1 Diego Biurrun
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
757 6ec87caa Fabrice Bellard
                                      s->cur_ptr, s->cur_len,
758
                                      s->cur_pkt.pts, s->cur_pkt.dts);
759
                s->cur_pkt.pts = AV_NOPTS_VALUE;
760
                s->cur_pkt.dts = AV_NOPTS_VALUE;
761 fb2758c8 Fabrice Bellard
                /* increment read pointer */
762
                s->cur_ptr += len;
763
                s->cur_len -= len;
764 115329f1 Diego Biurrun
765 fb2758c8 Fabrice Bellard
                /* return packet if any */
766
                if (pkt->size) {
767 37353960 Fabrice Bellard
                got_packet:
768 711737af Daniel Cardenas
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
769 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
770
                    pkt->stream_index = st->index;
771 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
772
                    pkt->dts = st->parser->dts;
773 fb2758c8 Fabrice Bellard
                    pkt->destruct = av_destruct_packet_nofree;
774
                    compute_pkt_fields(s, st, st->parser, pkt);
775 e9b78eeb Michael Niedermayer
776
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
777
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
778
                                           0, 0, AVINDEX_KEYFRAME);
779
                    }
780
781 434cab9e Michael Niedermayer
                    break;
782 fb2758c8 Fabrice Bellard
                }
783
            } else {
784 bcbecff1 Fabrice Bellard
                /* free packet */
785 115329f1 Diego Biurrun
                av_free_packet(&s->cur_pkt);
786 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
787
            }
788
        } else {
789
            /* read next packet */
790
            ret = av_read_packet(s, &s->cur_pkt);
791 37353960 Fabrice Bellard
            if (ret < 0) {
792 8fa36ae0 François Revol
                if (ret == AVERROR(EAGAIN))
793 37353960 Fabrice Bellard
                    return ret;
794
                /* return the last frames, if any */
795
                for(i = 0; i < s->nb_streams; i++) {
796
                    st = s->streams[i];
797 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
798 115329f1 Diego Biurrun
                        av_parser_parse(st->parser, st->codec,
799
                                        &pkt->data, &pkt->size,
800
                                        NULL, 0,
801 6ec87caa Fabrice Bellard
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
802 37353960 Fabrice Bellard
                        if (pkt->size)
803
                            goto got_packet;
804
                    }
805
                }
806
                /* no more packets: really terminates parsing */
807 fb2758c8 Fabrice Bellard
                return ret;
808 37353960 Fabrice Bellard
            }
809 115329f1 Diego Biurrun
810 9ee91c2f Michael Niedermayer
            st = s->streams[s->cur_pkt.stream_index];
811 434cab9e Michael Niedermayer
            if(st->codec->debug & FF_DEBUG_PTS)
812 ccd3228e Dominik Mierzejewski
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
813 434cab9e Michael Niedermayer
                    s->cur_pkt.stream_index,
814
                    s->cur_pkt.pts,
815
                    s->cur_pkt.dts,
816
                    s->cur_pkt.size);
817 fb2758c8 Fabrice Bellard
818
            s->cur_st = st;
819
            s->cur_ptr = s->cur_pkt.data;
820
            s->cur_len = s->cur_pkt.size;
821
            if (st->need_parsing && !st->parser) {
822 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
823 fb2758c8 Fabrice Bellard
                if (!st->parser) {
824
                    /* no parser available : just output the raw packets */
825 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_NONE;
826
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
827 7cbaa7ba Michael Niedermayer
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
828 fb2758c8 Fabrice Bellard
                }
829 e9b78eeb Michael Niedermayer
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
830
                    st->parser->last_frame_offset=
831
                    st->parser->cur_offset= s->cur_pkt.pos;
832
                }
833 fb2758c8 Fabrice Bellard
            }
834
        }
835
    }
836 434cab9e Michael Niedermayer
    if(st->codec->debug & FF_DEBUG_PTS)
837 ccd3228e Dominik Mierzejewski
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
838 434cab9e Michael Niedermayer
            pkt->stream_index,
839
            pkt->pts,
840
            pkt->dts,
841
            pkt->size);
842
843
    return 0;
844 fb2758c8 Fabrice Bellard
}
845
846 02b15cc8 Michael Niedermayer
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
847
    AVPacketList *pktl= s->packet_buffer;
848
    AVPacketList **plast_pktl= &s->packet_buffer;
849
850
    while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
851
852
    pktl = av_mallocz(sizeof(AVPacketList));
853
    if (!pktl)
854
        return NULL;
855
856
    /* add the packet in the buffered packet list */
857
    *plast_pktl = pktl;
858
    pktl->pkt= *pkt;
859
    return &pktl->pkt;
860
}
861
862 fb2758c8 Fabrice Bellard
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
863
{
864 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
865 30bc6613 Michael Niedermayer
    int eof=0;
866
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
867
868
    for(;;){
869
        pktl = s->packet_buffer;
870
        if (pktl) {
871
            AVPacket *next_pkt= &pktl->pkt;
872
873
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
874
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
875 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
876 30bc6613 Michael Niedermayer
                       && next_pkt->dts < pktl->pkt.dts
877
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
878
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
879
                        next_pkt->pts= pktl->pkt.dts;
880
                    }
881
                    pktl= pktl->next;
882
                }
883
                pktl = s->packet_buffer;
884
            }
885 115329f1 Diego Biurrun
886
            if(   next_pkt->pts != AV_NOPTS_VALUE
887
               || next_pkt->dts == AV_NOPTS_VALUE
888 30bc6613 Michael Niedermayer
               || !genpts || eof){
889
                /* read packet from packet buffer, if there is data */
890
                *pkt = *next_pkt;
891
                s->packet_buffer = pktl->next;
892
                av_free(pktl);
893
                return 0;
894
            }
895
        }
896
        if(genpts){
897
            int ret= av_read_frame_internal(s, pkt);
898
            if(ret<0){
899 8fa36ae0 François Revol
                if(pktl && ret != AVERROR(EAGAIN)){
900 30bc6613 Michael Niedermayer
                    eof=1;
901
                    continue;
902
                }else
903
                    return ret;
904
            }
905 115329f1 Diego Biurrun
906 02b15cc8 Michael Niedermayer
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
907 769e10f0 Panagiotis Issaris
                return AVERROR(ENOMEM);
908 30bc6613 Michael Niedermayer
        }else{
909
            assert(!s->packet_buffer);
910
            return av_read_frame_internal(s, pkt);
911
        }
912 fb2758c8 Fabrice Bellard
    }
913
}
914
915
/* XXX: suppress the packet queue */
916
static void flush_packet_queue(AVFormatContext *s)
917
{
918
    AVPacketList *pktl;
919
920
    for(;;) {
921
        pktl = s->packet_buffer;
922 115329f1 Diego Biurrun
        if (!pktl)
923 fb2758c8 Fabrice Bellard
            break;
924
        s->packet_buffer = pktl->next;
925
        av_free_packet(&pktl->pkt);
926
        av_free(pktl);
927 b9a281db Fabrice Bellard
    }
928
}
929
930 da24c5e3 Fabrice Bellard
/*******************************************************/
931 fb2758c8 Fabrice Bellard
/* seek support */
932
933 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
934
{
935
    int i;
936
    AVStream *st;
937
938
    if (s->nb_streams <= 0)
939
        return -1;
940
    for(i = 0; i < s->nb_streams; i++) {
941
        st = s->streams[i];
942 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
943 b754978a Michael Niedermayer
            return i;
944
        }
945
    }
946
    return 0;
947
}
948
949 e36bdf8b Daniel Kristjansson
/**
950
 * Flush the frame reader.
951
 */
952 fb2758c8 Fabrice Bellard
static void av_read_frame_flush(AVFormatContext *s)
953
{
954
    AVStream *st;
955
    int i;
956
957
    flush_packet_queue(s);
958
959
    /* free previous packet */
960
    if (s->cur_st) {
961
        if (s->cur_st->parser)
962
            av_free_packet(&s->cur_pkt);
963
        s->cur_st = NULL;
964
    }
965
    /* fail safe */
966
    s->cur_ptr = NULL;
967
    s->cur_len = 0;
968 115329f1 Diego Biurrun
969 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
970
    for(i = 0; i < s->nb_streams; i++) {
971
        st = s->streams[i];
972 115329f1 Diego Biurrun
973 fb2758c8 Fabrice Bellard
        if (st->parser) {
974
            av_parser_close(st->parser);
975
            st->parser = NULL;
976
        }
977 77405fc8 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
978 a843d1ff Michael Niedermayer
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
979 fb2758c8 Fabrice Bellard
    }
980
}
981
982 22ffac70 Reimar Döffinger
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
983 8bcb147f Michael Niedermayer
    int i;
984
985
    for(i = 0; i < s->nb_streams; i++) {
986 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
987 8bcb147f Michael Niedermayer
988 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
989 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
990
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
991 8bcb147f Michael Niedermayer
    }
992
}
993
994 3e9245a9 Michael Niedermayer
int av_add_index_entry(AVStream *st,
995 30a43f2d Michael Niedermayer
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
996 fb2758c8 Fabrice Bellard
{
997
    AVIndexEntry *entries, *ie;
998 b754978a Michael Niedermayer
    int index;
999 115329f1 Diego Biurrun
1000 568e18b1 Michael Niedermayer
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1001
        return -1;
1002 115329f1 Diego Biurrun
1003 fb2758c8 Fabrice Bellard
    entries = av_fast_realloc(st->index_entries,
1004
                              &st->index_entries_allocated_size,
1005 115329f1 Diego Biurrun
                              (st->nb_index_entries + 1) *
1006 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1007 568e18b1 Michael Niedermayer
    if(!entries)
1008
        return -1;
1009
1010 b754978a Michael Niedermayer
    st->index_entries= entries;
1011
1012 27a5fe5f Michael Niedermayer
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1013 b754978a Michael Niedermayer
1014 3ba1438d Michael Niedermayer
    if(index<0){
1015 3e9245a9 Michael Niedermayer
        index= st->nb_index_entries++;
1016
        ie= &entries[index];
1017 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1018
    }else{
1019
        ie= &entries[index];
1020
        if(ie->timestamp != timestamp){
1021 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1022
                return -1;
1023 3ba1438d Michael Niedermayer
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1024
            st->nb_index_entries++;
1025 755bfeab Diego Biurrun
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1026 3ba1438d Michael Niedermayer
            distance= ie->min_distance;
1027 3e9245a9 Michael Niedermayer
    }
1028 3ba1438d Michael Niedermayer
1029 b754978a Michael Niedermayer
    ie->pos = pos;
1030
    ie->timestamp = timestamp;
1031 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1032 30a43f2d Michael Niedermayer
    ie->size= size;
1033 b754978a Michael Niedermayer
    ie->flags = flags;
1034 115329f1 Diego Biurrun
1035 3e9245a9 Michael Niedermayer
    return index;
1036 fb2758c8 Fabrice Bellard
}
1037
1038 dc56fc38 Michael Niedermayer
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1039 27a5fe5f Michael Niedermayer
                              int flags)
1040 fb2758c8 Fabrice Bellard
{
1041 b754978a Michael Niedermayer
    AVIndexEntry *entries= st->index_entries;
1042
    int nb_entries= st->nb_index_entries;
1043 fb2758c8 Fabrice Bellard
    int a, b, m;
1044
    int64_t timestamp;
1045
1046 3ba1438d Michael Niedermayer
    a = - 1;
1047
    b = nb_entries;
1048 b754978a Michael Niedermayer
1049 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1050
        m = (a + b) >> 1;
1051 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1052 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1053
            b = m;
1054
        if(timestamp <= wanted_timestamp)
1055 b754978a Michael Niedermayer
            a = m;
1056 fb2758c8 Fabrice Bellard
    }
1057 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1058 115329f1 Diego Biurrun
1059 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1060
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1061
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1062
        }
1063
    }
1064 3ba1438d Michael Niedermayer
1065 115329f1 Diego Biurrun
    if(m == nb_entries)
1066 3ba1438d Michael Niedermayer
        return -1;
1067
    return  m;
1068 fb2758c8 Fabrice Bellard
}
1069
1070 8d14a25c Michael Niedermayer
#define DEBUG_SEEK
1071
1072 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1073 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1074
    int64_t pos_min, pos_max, pos, pos_limit;
1075
    int64_t ts_min, ts_max, ts;
1076 89ddd2a9 Michael Niedermayer
    int index;
1077 8d14a25c Michael Niedermayer
    AVStream *st;
1078
1079 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1080
        return -1;
1081 115329f1 Diego Biurrun
1082 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1083 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1084 8d14a25c Michael Niedermayer
#endif
1085
1086
    ts_max=
1087
    ts_min= AV_NOPTS_VALUE;
1088 90b5b51e Diego Biurrun
    pos_limit= -1; //gcc falsely says it may be uninitialized
1089 8d14a25c Michael Niedermayer
1090
    st= s->streams[stream_index];
1091
    if(st->index_entries){
1092
        AVIndexEntry *e;
1093
1094 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()
1095 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1096 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1097
1098
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1099
            pos_min= e->pos;
1100
            ts_min= e->timestamp;
1101
#ifdef DEBUG_SEEK
1102 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1103 8d14a25c Michael Niedermayer
               pos_min,ts_min);
1104
#endif
1105
        }else{
1106
            assert(index==0);
1107
        }
1108 115329f1 Diego Biurrun
1109
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1110 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1111
        if(index >= 0){
1112 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1113
            assert(e->timestamp >= target_ts);
1114
            pos_max= e->pos;
1115
            ts_max= e->timestamp;
1116
            pos_limit= pos_max - e->min_distance;
1117
#ifdef DEBUG_SEEK
1118 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1119 8d14a25c Michael Niedermayer
               pos_max,pos_limit, ts_max);
1120
#endif
1121
        }
1122
    }
1123
1124 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);
1125
    if(pos<0)
1126
        return -1;
1127
1128
    /* do the seek */
1129
    url_fseek(&s->pb, pos, SEEK_SET);
1130
1131
    av_update_cur_dts(s, st, ts);
1132
1133
    return 0;
1134
}
1135
1136
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 )){
1137
    int64_t pos, ts;
1138
    int64_t start_pos, filesize;
1139
    int no_change;
1140
1141
#ifdef DEBUG_SEEK
1142
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1143
#endif
1144
1145 8d14a25c Michael Niedermayer
    if(ts_min == AV_NOPTS_VALUE){
1146
        pos_min = s->data_offset;
1147 89ddd2a9 Michael Niedermayer
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1148 8d14a25c Michael Niedermayer
        if (ts_min == AV_NOPTS_VALUE)
1149
            return -1;
1150
    }
1151
1152
    if(ts_max == AV_NOPTS_VALUE){
1153
        int step= 1024;
1154 6fd93ce2 Kenneth Aafløy
        filesize = url_fsize(&s->pb);
1155
        pos_max = filesize - 1;
1156 8d14a25c Michael Niedermayer
        do{
1157
            pos_max -= step;
1158 89ddd2a9 Michael Niedermayer
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1159 8d14a25c Michael Niedermayer
            step += step;
1160
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1161
        if (ts_max == AV_NOPTS_VALUE)
1162
            return -1;
1163 115329f1 Diego Biurrun
1164 8d14a25c Michael Niedermayer
        for(;;){
1165
            int64_t tmp_pos= pos_max + 1;
1166 89ddd2a9 Michael Niedermayer
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1167 8d14a25c Michael Niedermayer
            if(tmp_ts == AV_NOPTS_VALUE)
1168
                break;
1169
            ts_max= tmp_ts;
1170
            pos_max= tmp_pos;
1171 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1172
                break;
1173 8d14a25c Michael Niedermayer
        }
1174
        pos_limit= pos_max;
1175
    }
1176
1177 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1178
        return -1;
1179
    }else if(ts_min == ts_max){
1180
        pos_limit= pos_min;
1181
    }
1182
1183 8d14a25c Michael Niedermayer
    no_change=0;
1184
    while (pos_min < pos_limit) {
1185
#ifdef DEBUG_SEEK
1186 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1187 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1188
               ts_min, ts_max);
1189
#endif
1190
        assert(pos_limit <= pos_max);
1191
1192
        if(no_change==0){
1193
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1194
            // interpolate position (better than dichotomy)
1195 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1196
                + pos_min - approximate_keyframe_distance;
1197 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1198
            // bisection, if interpolation failed to change min or max pos last time
1199
            pos = (pos_min + pos_limit)>>1;
1200
        }else{
1201
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1202
            pos=pos_min;
1203
        }
1204
        if(pos <= pos_min)
1205
            pos= pos_min + 1;
1206
        else if(pos > pos_limit)
1207
            pos= pos_limit;
1208
        start_pos= pos;
1209
1210 89ddd2a9 Michael Niedermayer
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1211 8d14a25c Michael Niedermayer
        if(pos == pos_max)
1212
            no_change++;
1213
        else
1214
            no_change=0;
1215
#ifdef DEBUG_SEEK
1216 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);
1217 8d14a25c Michael Niedermayer
#endif
1218 db2a0e22 Michael Niedermayer
        if(ts == AV_NOPTS_VALUE){
1219
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1220
            return -1;
1221
        }
1222 8d14a25c Michael Niedermayer
        assert(ts != AV_NOPTS_VALUE);
1223 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1224 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1225
            pos_max = pos;
1226
            ts_max = ts;
1227 3ba1438d Michael Niedermayer
        }
1228
        if (target_ts >= ts) {
1229 8d14a25c Michael Niedermayer
            pos_min = pos;
1230
            ts_min = ts;
1231
        }
1232
    }
1233 115329f1 Diego Biurrun
1234 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1235
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1236 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1237
    pos_min = pos;
1238 89ddd2a9 Michael Niedermayer
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1239 8d14a25c Michael Niedermayer
    pos_min++;
1240 89ddd2a9 Michael Niedermayer
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1241 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1242 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1243
#endif
1244 89ddd2a9 Michael Niedermayer
    *ts_ret= ts;
1245
    return pos;
1246 8d14a25c Michael Niedermayer
}
1247
1248 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1249
    int64_t pos_min, pos_max;
1250
#if 0
1251
    AVStream *st;
1252

1253
    if (stream_index < 0)
1254
        return -1;
1255

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