Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 4b65d88f

History | View | Annotate | Download (93.9 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 19720f15 Fabrice Bellard
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9 de6d9b64 Fabrice Bellard
 *
10 19720f15 Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
11 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 19720f15 Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14 de6d9b64 Fabrice Bellard
 *
15 19720f15 Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 de6d9b64 Fabrice Bellard
 */
19 8be1c656 Fabrice Bellard
#include "avformat.h"
20 e006c307 Diego Pettenò
#include "allformats.h"
21 c5510dd6 Philip Gladstone
22 b754978a Michael Niedermayer
#undef NDEBUG
23
#include <assert.h>
24
25 e36bdf8b Daniel Kristjansson
/**
26
 * @file libavformat/utils.c
27
 * Various utility functions for using ffmpeg library.
28
 */
29
30 f3a30e3a Luca Barbato
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
31
static void av_frac_add(AVFrac *f, int64_t incr);
32
static void av_frac_set(AVFrac *f, int64_t val);
33
34 e36bdf8b Daniel Kristjansson
/** head of registered input format linked list. */
35 8b69867f Michael Niedermayer
AVInputFormat *first_iformat = NULL;
36 e36bdf8b Daniel Kristjansson
/** head of registered output format linked list. */
37 8b69867f Michael Niedermayer
AVOutputFormat *first_oformat = NULL;
38 e36bdf8b Daniel Kristjansson
/** head of registered image format linked list. */
39 8b69867f Michael Niedermayer
AVImageFormat *first_image_format = NULL;
40 de6d9b64 Fabrice Bellard
41 b9a281db Fabrice Bellard
void av_register_input_format(AVInputFormat *format)
42 de6d9b64 Fabrice Bellard
{
43 b9a281db Fabrice Bellard
    AVInputFormat **p;
44
    p = &first_iformat;
45
    while (*p != NULL) p = &(*p)->next;
46
    *p = format;
47
    format->next = NULL;
48
}
49
50
void av_register_output_format(AVOutputFormat *format)
51
{
52
    AVOutputFormat **p;
53
    p = &first_oformat;
54 de6d9b64 Fabrice Bellard
    while (*p != NULL) p = &(*p)->next;
55
    *p = format;
56
    format->next = NULL;
57
}
58
59 5b25dfa7 Fabrice Bellard
int match_ext(const char *filename, const char *extensions)
60 de6d9b64 Fabrice Bellard
{
61
    const char *ext, *p;
62
    char ext1[32], *q;
63
64 293ed23f Michael Niedermayer
    if(!filename)
65
        return 0;
66 115329f1 Diego Biurrun
67 de6d9b64 Fabrice Bellard
    ext = strrchr(filename, '.');
68
    if (ext) {
69
        ext++;
70
        p = extensions;
71
        for(;;) {
72
            q = ext1;
73 115329f1 Diego Biurrun
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
74 de6d9b64 Fabrice Bellard
                *q++ = *p++;
75
            *q = '\0';
76 115329f1 Diego Biurrun
            if (!strcasecmp(ext1, ext))
77 de6d9b64 Fabrice Bellard
                return 1;
78 115329f1 Diego Biurrun
            if (*p == '\0')
79 de6d9b64 Fabrice Bellard
                break;
80
            p++;
81
        }
82
    }
83
    return 0;
84
}
85
86 115329f1 Diego Biurrun
AVOutputFormat *guess_format(const char *short_name, const char *filename,
87 b9a281db Fabrice Bellard
                             const char *mime_type)
88 de6d9b64 Fabrice Bellard
{
89 b9a281db Fabrice Bellard
    AVOutputFormat *fmt, *fmt_found;
90 de6d9b64 Fabrice Bellard
    int score_max, score;
91
92 87a0a681 Fabrice Bellard
    /* specific test for image sequences */
93 ff70e601 Måns Rullgård
#ifdef CONFIG_IMAGE2_MUXER
94 115329f1 Diego Biurrun
    if (!short_name && filename &&
95 94d883e8 Fabrice Bellard
        filename_number_test(filename) >= 0 &&
96 5b6d5596 Michael Niedermayer
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
97
        return guess_format("image2", NULL, NULL);
98
    }
99 ff70e601 Måns Rullgård
#endif
100 115329f1 Diego Biurrun
    if (!short_name && filename &&
101 5b6d5596 Michael Niedermayer
        filename_number_test(filename) >= 0 &&
102 94d883e8 Fabrice Bellard
        guess_image_format(filename)) {
103 87a0a681 Fabrice Bellard
        return guess_format("image", NULL, NULL);
104
    }
105
106 de6d9b64 Fabrice Bellard
    /* find the proper file type */
107
    fmt_found = NULL;
108
    score_max = 0;
109 b9a281db Fabrice Bellard
    fmt = first_oformat;
110 de6d9b64 Fabrice Bellard
    while (fmt != NULL) {
111
        score = 0;
112
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
113
            score += 100;
114
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
115
            score += 10;
116 115329f1 Diego Biurrun
        if (filename && fmt->extensions &&
117 de6d9b64 Fabrice Bellard
            match_ext(filename, fmt->extensions)) {
118
            score += 5;
119
        }
120
        if (score > score_max) {
121
            score_max = score;
122
            fmt_found = fmt;
123
        }
124
        fmt = fmt->next;
125
    }
126
    return fmt_found;
127 115329f1 Diego Biurrun
}
128 de6d9b64 Fabrice Bellard
129 115329f1 Diego Biurrun
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
130 c5510dd6 Philip Gladstone
                             const char *mime_type)
131
{
132
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
133
134
    if (fmt) {
135
        AVOutputFormat *stream_fmt;
136
        char stream_format_name[64];
137
138
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
139
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
140
141
        if (stream_fmt)
142
            fmt = stream_fmt;
143
    }
144
145
    return fmt;
146
}
147
148 5b6d5596 Michael Niedermayer
/**
149 e36bdf8b Daniel Kristjansson
 * Guesses the codec id based upon muxer and filename.
150 5b6d5596 Michael Niedermayer
 */
151 115329f1 Diego Biurrun
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
152 5b6d5596 Michael Niedermayer
                            const char *filename, const char *mime_type, enum CodecType type){
153
    if(type == CODEC_TYPE_VIDEO){
154
        enum CodecID codec_id= CODEC_ID_NONE;
155
156 ff70e601 Måns Rullgård
#ifdef CONFIG_IMAGE2_MUXER
157 ae214ac3 Michael Niedermayer
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
158 5b6d5596 Michael Niedermayer
            codec_id= av_guess_image2_codec(filename);
159
        }
160 ff70e601 Måns Rullgård
#endif
161 5b6d5596 Michael Niedermayer
        if(codec_id == CODEC_ID_NONE)
162
            codec_id= fmt->video_codec;
163
        return codec_id;
164
    }else if(type == CODEC_TYPE_AUDIO)
165
        return fmt->audio_codec;
166
    else
167
        return CODEC_ID_NONE;
168
}
169
170 e36bdf8b Daniel Kristjansson
/**
171
 * finds AVInputFormat based on input format's short name.
172
 */
173 b9a281db Fabrice Bellard
AVInputFormat *av_find_input_format(const char *short_name)
174
{
175
    AVInputFormat *fmt;
176
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
177
        if (!strcmp(fmt->name, short_name))
178
            return fmt;
179
    }
180
    return NULL;
181
}
182
183 de6d9b64 Fabrice Bellard
/* memory handling */
184
185 b9a281db Fabrice Bellard
/**
186 e36bdf8b Daniel Kristjansson
 * Default packet destructor.
187 6fa5a56c Fabrice Bellard
 */
188 90ad92b3 Michael Niedermayer
void av_destruct_packet(AVPacket *pkt)
189 6fa5a56c Fabrice Bellard
{
190
    av_free(pkt->data);
191
    pkt->data = NULL; pkt->size = 0;
192
}
193
194
/**
195 b9a281db Fabrice Bellard
 * Allocate the payload of a packet and intialized its fields to default values.
196
 *
197
 * @param pkt packet
198
 * @param size wanted payload size
199
 * @return 0 if OK. AVERROR_xxx otherwise.
200
 */
201 de6d9b64 Fabrice Bellard
int av_new_packet(AVPacket *pkt, int size)
202
{
203 568e18b1 Michael Niedermayer
    void *data;
204
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
205 115329f1 Diego Biurrun
        return AVERROR_NOMEM;
206 568e18b1 Michael Niedermayer
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
207 6fa5a56c Fabrice Bellard
    if (!data)
208 b9a281db Fabrice Bellard
        return AVERROR_NOMEM;
209 6fa5a56c Fabrice Bellard
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
210 8cd5be98 Michael Niedermayer
211 6fa5a56c Fabrice Bellard
    av_init_packet(pkt);
212 115329f1 Diego Biurrun
    pkt->data = data;
213 6fa5a56c Fabrice Bellard
    pkt->size = size;
214
    pkt->destruct = av_destruct_packet;
215 de6d9b64 Fabrice Bellard
    return 0;
216
}
217
218 2692067a Michael Niedermayer
/**
219
 * Allocate and read the payload of a packet and intialized its fields to default values.
220
 *
221
 * @param pkt packet
222
 * @param size wanted payload size
223
 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
224
 */
225
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
226
{
227
    int ret= av_new_packet(pkt, size);
228
229
    if(ret<0)
230
        return ret;
231
232
    pkt->pos= url_ftell(s);
233
234
    ret= get_buffer(s, pkt->data, size);
235
    if(ret<=0)
236
        av_free_packet(pkt);
237
    else
238
        pkt->size= ret;
239
240
    return ret;
241
}
242
243 fb2758c8 Fabrice Bellard
/* This is a hack - the packet memory allocation stuff is broken. The
244
   packet is allocated if it was not really allocated */
245
int av_dup_packet(AVPacket *pkt)
246
{
247
    if (pkt->destruct != av_destruct_packet) {
248
        uint8_t *data;
249 8a56ac7b Fabrice Bellard
        /* we duplicate the packet and don't forget to put the padding
250
           again */
251 568e18b1 Michael Niedermayer
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
252 115329f1 Diego Biurrun
            return AVERROR_NOMEM;
253 8a56ac7b Fabrice Bellard
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
254 fb2758c8 Fabrice Bellard
        if (!data) {
255
            return AVERROR_NOMEM;
256
        }
257
        memcpy(data, pkt->data, pkt->size);
258 8a56ac7b Fabrice Bellard
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
259 fb2758c8 Fabrice Bellard
        pkt->data = data;
260
        pkt->destruct = av_destruct_packet;
261
    }
262
    return 0;
263
}
264
265 de6d9b64 Fabrice Bellard
/* fifo handling */
266
267
int fifo_init(FifoBuffer *f, int size)
268
{
269 1ea4f593 Fabrice Bellard
    f->buffer = av_malloc(size);
270 de6d9b64 Fabrice Bellard
    if (!f->buffer)
271
        return -1;
272
    f->end = f->buffer + size;
273
    f->wptr = f->rptr = f->buffer;
274
    return 0;
275
}
276
277
void fifo_free(FifoBuffer *f)
278
{
279 1ea4f593 Fabrice Bellard
    av_free(f->buffer);
280 de6d9b64 Fabrice Bellard
}
281
282 0c1a9eda Zdenek Kabelac
int fifo_size(FifoBuffer *f, uint8_t *rptr)
283 de6d9b64 Fabrice Bellard
{
284
    int size;
285 115329f1 Diego Biurrun
286 0d712409 Michael Niedermayer
    if(!rptr)
287
        rptr= f->rptr;
288 de6d9b64 Fabrice Bellard
289
    if (f->wptr >= rptr) {
290
        size = f->wptr - rptr;
291
    } else {
292
        size = (f->end - rptr) + (f->wptr - f->buffer);
293
    }
294
    return size;
295
}
296
297 e36bdf8b Daniel Kristjansson
/**
298
 * Get data from the fifo (returns -1 if not enough data).
299
 */
300 0c1a9eda Zdenek Kabelac
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
301 de6d9b64 Fabrice Bellard
{
302 0d712409 Michael Niedermayer
    uint8_t *rptr;
303 de6d9b64 Fabrice Bellard
    int size, len;
304
305 0d712409 Michael Niedermayer
    if(!rptr_ptr)
306
        rptr_ptr= &f->rptr;
307
    rptr = *rptr_ptr;
308
309 de6d9b64 Fabrice Bellard
    if (f->wptr >= rptr) {
310
        size = f->wptr - rptr;
311
    } else {
312
        size = (f->end - rptr) + (f->wptr - f->buffer);
313
    }
314 115329f1 Diego Biurrun
315 de6d9b64 Fabrice Bellard
    if (size < buf_size)
316
        return -1;
317
    while (buf_size > 0) {
318
        len = f->end - rptr;
319
        if (len > buf_size)
320
            len = buf_size;
321
        memcpy(buf, rptr, len);
322
        buf += len;
323
        rptr += len;
324
        if (rptr >= f->end)
325
            rptr = f->buffer;
326
        buf_size -= len;
327
    }
328
    *rptr_ptr = rptr;
329
    return 0;
330
}
331
332 e36bdf8b Daniel Kristjansson
/**
333
 * Resizes a FIFO.
334
 */
335 568e18b1 Michael Niedermayer
void fifo_realloc(FifoBuffer *f, unsigned int new_size){
336
    unsigned int old_size= f->end - f->buffer;
337 115329f1 Diego Biurrun
338 0d712409 Michael Niedermayer
    if(old_size < new_size){
339
        uint8_t *old= f->buffer;
340
341
        f->buffer= av_realloc(f->buffer, new_size);
342
343
        f->rptr += f->buffer - old;
344
        f->wptr += f->buffer - old;
345
346
        if(f->wptr < f->rptr){
347
            memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
348
            f->rptr += new_size - old_size;
349
        }
350
        f->end= f->buffer + new_size;
351
    }
352
}
353
354 a97c1e93 Stefan Huehner
void fifo_write(FifoBuffer *f, const uint8_t *buf, int size, uint8_t **wptr_ptr)
355 de6d9b64 Fabrice Bellard
{
356
    int len;
357 0c1a9eda Zdenek Kabelac
    uint8_t *wptr;
358 0d712409 Michael Niedermayer
359
    if(!wptr_ptr)
360
        wptr_ptr= &f->wptr;
361 de6d9b64 Fabrice Bellard
    wptr = *wptr_ptr;
362 0d712409 Michael Niedermayer
363 de6d9b64 Fabrice Bellard
    while (size > 0) {
364
        len = f->end - wptr;
365
        if (len > size)
366
            len = size;
367
        memcpy(wptr, buf, len);
368
        wptr += len;
369
        if (wptr >= f->end)
370
            wptr = f->buffer;
371
        buf += len;
372
        size -= len;
373
    }
374
    *wptr_ptr = wptr;
375
}
376
377 7000a175 Michael Niedermayer
/* get data from the fifo (return -1 if not enough data) */
378
int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
379
{
380
    uint8_t *rptr = *rptr_ptr;
381
    int size, len;
382
383
    if (f->wptr >= rptr) {
384
        size = f->wptr - rptr;
385
    } else {
386
        size = (f->end - rptr) + (f->wptr - f->buffer);
387
    }
388 115329f1 Diego Biurrun
389 7000a175 Michael Niedermayer
    if (size < buf_size)
390
        return -1;
391
    while (buf_size > 0) {
392
        len = f->end - rptr;
393
        if (len > buf_size)
394
            len = buf_size;
395
        put_buffer(pb, rptr, len);
396
        rptr += len;
397
        if (rptr >= f->end)
398
            rptr = f->buffer;
399
        buf_size -= len;
400
    }
401
    *rptr_ptr = rptr;
402
    return 0;
403
}
404
405 b9a281db Fabrice Bellard
int filename_number_test(const char *filename)
406
{
407
    char buf[1024];
408 293ed23f Michael Niedermayer
    if(!filename)
409
        return -1;
410 b9a281db Fabrice Bellard
    return get_frame_filename(buf, sizeof(buf), filename, 1);
411
}
412
413 e36bdf8b Daniel Kristjansson
/**
414
 * Guess file format.
415
 */
416 a25e098d Fabrice Bellard
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
417 b9a281db Fabrice Bellard
{
418
    AVInputFormat *fmt1, *fmt;
419
    int score, score_max;
420
421
    fmt = NULL;
422
    score_max = 0;
423
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
424
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
425
            continue;
426
        score = 0;
427 a8dbe951 Philip Gladstone
        if (fmt1->read_probe) {
428
            score = fmt1->read_probe(pd);
429
        } else if (fmt1->extensions) {
430 b9a281db Fabrice Bellard
            if (match_ext(pd->filename, fmt1->extensions)) {
431
                score = 50;
432
            }
433 115329f1 Diego Biurrun
        }
434 b9a281db Fabrice Bellard
        if (score > score_max) {
435
            score_max = score;
436
            fmt = fmt1;
437
        }
438
    }
439
    return fmt;
440
}
441
442
/************************************************************/
443
/* input media file */
444 96baaa6a Fabrice Bellard
445 da24c5e3 Fabrice Bellard
/**
446 e36bdf8b Daniel Kristjansson
 * Open a media file from an IO stream. 'fmt' must be specified.
447 da24c5e3 Fabrice Bellard
 */
448 43465395 Michael Niedermayer
static const char* format_to_name(void* ptr)
449 bc874dae Michel Bardiaux
{
450 43465395 Michael Niedermayer
    AVFormatContext* fc = (AVFormatContext*) ptr;
451 bc874dae Michel Bardiaux
    if(fc->iformat) return fc->iformat->name;
452
    else if(fc->oformat) return fc->oformat->name;
453
    else return "NULL";
454
}
455
456
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
457
458
AVFormatContext *av_alloc_format_context(void)
459
{
460
    AVFormatContext *ic;
461
    ic = av_mallocz(sizeof(AVFormatContext));
462
    if (!ic) return ic;
463 43465395 Michael Niedermayer
    ic->av_class = &av_format_context_class;
464 bc874dae Michel Bardiaux
    return ic;
465
}
466
467 e36bdf8b Daniel Kristjansson
/**
468
 * Allocates all the structures needed to read an input stream.
469
 *        This does not open the needed codecs for decoding the stream[s].
470
 */
471 115329f1 Diego Biurrun
int av_open_input_stream(AVFormatContext **ic_ptr,
472
                         ByteIOContext *pb, const char *filename,
473 da24c5e3 Fabrice Bellard
                         AVInputFormat *fmt, AVFormatParameters *ap)
474
{
475
    int err;
476
    AVFormatContext *ic;
477 c04c3282 Michael Niedermayer
    AVFormatParameters default_ap;
478
479
    if(!ap){
480
        ap=&default_ap;
481
        memset(ap, 0, sizeof(default_ap));
482
    }
483 da24c5e3 Fabrice Bellard
484 bc874dae Michel Bardiaux
    ic = av_alloc_format_context();
485 da24c5e3 Fabrice Bellard
    if (!ic) {
486
        err = AVERROR_NOMEM;
487
        goto fail;
488
    }
489
    ic->iformat = fmt;
490
    if (pb)
491
        ic->pb = *pb;
492
    ic->duration = AV_NOPTS_VALUE;
493
    ic->start_time = AV_NOPTS_VALUE;
494
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
495
496
    /* allocate private data */
497
    if (fmt->priv_data_size > 0) {
498
        ic->priv_data = av_mallocz(fmt->priv_data_size);
499
        if (!ic->priv_data) {
500
            err = AVERROR_NOMEM;
501
            goto fail;
502
        }
503
    } else {
504
        ic->priv_data = NULL;
505
    }
506
507
    err = ic->iformat->read_header(ic, ap);
508
    if (err < 0)
509
        goto fail;
510 fb2758c8 Fabrice Bellard
511
    if (pb)
512
        ic->data_offset = url_ftell(&ic->pb);
513
514 da24c5e3 Fabrice Bellard
    *ic_ptr = ic;
515
    return 0;
516
 fail:
517
    if (ic) {
518
        av_freep(&ic->priv_data);
519
    }
520
    av_free(ic);
521
    *ic_ptr = NULL;
522
    return err;
523
}
524
525 e36bdf8b Daniel Kristjansson
/** Size of probe buffer, for guessing file type from file contents. */
526 a877eedc Michael Niedermayer
#define PROBE_BUF_MIN 2048
527 329b1e75 Michael Niedermayer
#define PROBE_BUF_MAX (1<<20)
528 b9a281db Fabrice Bellard
529
/**
530
 * Open a media file as input. The codec are not opened. Only the file
531
 * header (if present) is read.
532
 *
533
 * @param ic_ptr the opened media file handle is put here
534
 * @param filename filename to open.
535
 * @param fmt if non NULL, force the file format to use
536
 * @param buf_size optional buffer size (zero if default is OK)
537
 * @param ap additionnal parameters needed when opening the file (NULL if default)
538
 * @return 0 if OK. AVERROR_xxx otherwise.
539
 */
540 115329f1 Diego Biurrun
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
541 b9a281db Fabrice Bellard
                       AVInputFormat *fmt,
542
                       int buf_size,
543
                       AVFormatParameters *ap)
544 de6d9b64 Fabrice Bellard
{
545 a877eedc Michael Niedermayer
    int err, must_open_file, file_opened, probe_size;
546 b9a281db Fabrice Bellard
    AVProbeData probe_data, *pd = &probe_data;
547 da24c5e3 Fabrice Bellard
    ByteIOContext pb1, *pb = &pb1;
548 115329f1 Diego Biurrun
549 da24c5e3 Fabrice Bellard
    file_opened = 0;
550
    pd->filename = "";
551
    if (filename)
552
        pd->filename = filename;
553 a877eedc Michael Niedermayer
    pd->buf = NULL;
554 b9a281db Fabrice Bellard
    pd->buf_size = 0;
555
556
    if (!fmt) {
557
        /* guess format if no file can be opened  */
558 a25e098d Fabrice Bellard
        fmt = av_probe_input_format(pd, 0);
559 de6d9b64 Fabrice Bellard
    }
560
561 b6892136 Fabrice Bellard
    /* do not open file if the format does not need it. XXX: specific
562
       hack needed to handle RTSP/TCP */
563
    must_open_file = 1;
564 da24c5e3 Fabrice Bellard
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
565 b6892136 Fabrice Bellard
        must_open_file = 0;
566 63dd1377 Michael Niedermayer
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
567 b6892136 Fabrice Bellard
    }
568
569
    if (!fmt || must_open_file) {
570 87a0a681 Fabrice Bellard
        /* if no file needed do not try to open one */
571 da24c5e3 Fabrice Bellard
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
572 b9a281db Fabrice Bellard
            err = AVERROR_IO;
573 96baaa6a Fabrice Bellard
            goto fail;
574 b9a281db Fabrice Bellard
        }
575 da24c5e3 Fabrice Bellard
        file_opened = 1;
576 96baaa6a Fabrice Bellard
        if (buf_size > 0) {
577 da24c5e3 Fabrice Bellard
            url_setbufsize(pb, buf_size);
578 96baaa6a Fabrice Bellard
        }
579 a877eedc Michael Niedermayer
580
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
581 5b25dfa7 Fabrice Bellard
            /* read probe data */
582 a877eedc Michael Niedermayer
            pd->buf= av_realloc(pd->buf, probe_size);
583
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
584 53e2f9ca Michael Niedermayer
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
585
                url_fclose(pb);
586
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
587 5e43b17e Michael Niedermayer
                    file_opened = 0;
588 53e2f9ca Michael Niedermayer
                    err = AVERROR_IO;
589
                    goto fail;
590
                }
591
            }
592 a877eedc Michael Niedermayer
            /* guess file format */
593
            fmt = av_probe_input_format(pd, 1);
594 5b25dfa7 Fabrice Bellard
        }
595 a877eedc Michael Niedermayer
        av_freep(&pd->buf);
596 b9a281db Fabrice Bellard
    }
597
598
    /* if still no format found, error */
599
    if (!fmt) {
600
        err = AVERROR_NOFMT;
601 da24c5e3 Fabrice Bellard
        goto fail;
602 de6d9b64 Fabrice Bellard
    }
603 115329f1 Diego Biurrun
604 67d06418 Fabrice Bellard
    /* XXX: suppress this hack for redirectors */
605 f3ec2d46 Slavik Gnatenko
#ifdef CONFIG_NETWORK
606 d2a067d1 Måns Rullgård
    if (fmt == &redir_demuxer) {
607 da24c5e3 Fabrice Bellard
        err = redir_open(ic_ptr, pb);
608
        url_fclose(pb);
609 67d06418 Fabrice Bellard
        return err;
610
    }
611 9b2e001f Bill Eldridge
#endif
612 67d06418 Fabrice Bellard
613 87a0a681 Fabrice Bellard
    /* check filename in case of an image number is expected */
614 da24c5e3 Fabrice Bellard
    if (fmt->flags & AVFMT_NEEDNUMBER) {
615 115329f1 Diego Biurrun
        if (filename_number_test(filename) < 0) {
616 87a0a681 Fabrice Bellard
            err = AVERROR_NUMEXPECTED;
617 da24c5e3 Fabrice Bellard
            goto fail;
618 87a0a681 Fabrice Bellard
        }
619
    }
620 da24c5e3 Fabrice Bellard
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
621
    if (err)
622
        goto fail;
623 b9a281db Fabrice Bellard
    return 0;
624 de6d9b64 Fabrice Bellard
 fail:
625 a877eedc Michael Niedermayer
    av_freep(&pd->buf);
626 da24c5e3 Fabrice Bellard
    if (file_opened)
627
        url_fclose(pb);
628 b9a281db Fabrice Bellard
    *ic_ptr = NULL;
629
    return err;
630 115329f1 Diego Biurrun
631 de6d9b64 Fabrice Bellard
}
632
633 da24c5e3 Fabrice Bellard
/*******************************************************/
634
635 b9a281db Fabrice Bellard
/**
636 e36bdf8b Daniel Kristjansson
 * Read a transport packet from a media file.
637
 *
638
 * This function is absolete and should never be used.
639
 * Use av_read_frame() instead.
640 115329f1 Diego Biurrun
 *
641 b9a281db Fabrice Bellard
 * @param s media file handle
642 115329f1 Diego Biurrun
 * @param pkt is filled
643
 * @return 0 if OK. AVERROR_xxx if error.
644 b9a281db Fabrice Bellard
 */
645 de6d9b64 Fabrice Bellard
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
646
{
647 fb2758c8 Fabrice Bellard
    return s->iformat->read_packet(s, pkt);
648
}
649
650
/**********************************************************/
651
652 e36bdf8b Daniel Kristjansson
/**
653
 * Get the number of samples of an audio frame. Return (-1) if error.
654
 */
655 fb2758c8 Fabrice Bellard
static int get_audio_frame_size(AVCodecContext *enc, int size)
656
{
657
    int frame_size;
658
659
    if (enc->frame_size <= 1) {
660 ac3e1834 Baptiste Coudurier
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
661
662
        if (bits_per_sample) {
663 fb2758c8 Fabrice Bellard
            if (enc->channels == 0)
664
                return -1;
665 f1b163e0 Aurelien Jacobs
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
666 ac3e1834 Baptiste Coudurier
        } else {
667 fb2758c8 Fabrice Bellard
            /* used for example by ADPCM codecs */
668
            if (enc->bit_rate == 0)
669
                return -1;
670
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
671
        }
672
    } else {
673
        frame_size = enc->frame_size;
674
    }
675
    return frame_size;
676
}
677
678
679 e36bdf8b Daniel Kristjansson
/**
680
 * Return the frame duration in seconds, return 0 if not available.
681
 */
682 115329f1 Diego Biurrun
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
683 fb2758c8 Fabrice Bellard
                                   AVCodecParserContext *pc, AVPacket *pkt)
684
{
685
    int frame_size;
686
687
    *pnum = 0;
688
    *pden = 0;
689 01f4895c Michael Niedermayer
    switch(st->codec->codec_type) {
690 fb2758c8 Fabrice Bellard
    case CODEC_TYPE_VIDEO:
691 1677155d Michael Niedermayer
        if(st->time_base.num*1000LL > st->time_base.den){
692 c0df9d75 Michael Niedermayer
            *pnum = st->time_base.num;
693
            *pden = st->time_base.den;
694 01f4895c Michael Niedermayer
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
695
            *pnum = st->codec->time_base.num;
696
            *pden = st->codec->time_base.den;
697 327c4076 Michael Niedermayer
            if (pc && pc->repeat_pict) {
698
                *pden *= 2;
699
                *pnum = (*pnum) * (2 + pc->repeat_pict);
700
            }
701 fb2758c8 Fabrice Bellard
        }
702
        break;
703
    case CODEC_TYPE_AUDIO:
704 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
705 fb2758c8 Fabrice Bellard
        if (frame_size < 0)
706
            break;
707
        *pnum = frame_size;
708 01f4895c Michael Niedermayer
        *pden = st->codec->sample_rate;
709 fb2758c8 Fabrice Bellard
        break;
710
    default:
711
        break;
712
    }
713
}
714
715 5ba7c3d7 Michael Niedermayer
static int is_intra_only(AVCodecContext *enc){
716
    if(enc->codec_type == CODEC_TYPE_AUDIO){
717
        return 1;
718
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
719
        switch(enc->codec_id){
720
        case CODEC_ID_MJPEG:
721
        case CODEC_ID_MJPEGB:
722
        case CODEC_ID_LJPEG:
723
        case CODEC_ID_RAWVIDEO:
724
        case CODEC_ID_DVVIDEO:
725
        case CODEC_ID_HUFFYUV:
726 f37b9768 Loren Merritt
        case CODEC_ID_FFVHUFF:
727 5ba7c3d7 Michael Niedermayer
        case CODEC_ID_ASV1:
728
        case CODEC_ID_ASV2:
729
        case CODEC_ID_VCR1:
730
            return 1;
731
        default: break;
732
        }
733
    }
734
    return 0;
735
}
736
737 77405fc8 Michael Niedermayer
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
738 4fc2c644 Michael Niedermayer
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
739 77405fc8 Michael Niedermayer
    int64_t delta= last_ts - mask/2;
740
    return  ((lsb - delta)&mask) + delta;
741
}
742
743 115329f1 Diego Biurrun
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
744 fb2758c8 Fabrice Bellard
                               AVCodecParserContext *pc, AVPacket *pkt)
745
{
746
    int num, den, presentation_delayed;
747 77405fc8 Michael Niedermayer
    /* handle wrapping */
748 e928649b Michael Niedermayer
    if(st->cur_dts != AV_NOPTS_VALUE){
749
        if(pkt->pts != AV_NOPTS_VALUE)
750
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
751
        if(pkt->dts != AV_NOPTS_VALUE)
752
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
753
    }
754 115329f1 Diego Biurrun
755 fb2758c8 Fabrice Bellard
    if (pkt->duration == 0) {
756 3c895fc0 Michael Niedermayer
        compute_frame_duration(&num, &den, st, pc, pkt);
757 fb2758c8 Fabrice Bellard
        if (den && num) {
758 77405fc8 Michael Niedermayer
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
759 fb2758c8 Fabrice Bellard
        }
760
    }
761
762 01f4895c Michael Niedermayer
    if(is_intra_only(st->codec))
763 5ba7c3d7 Michael Niedermayer
        pkt->flags |= PKT_FLAG_KEY;
764
765 fb2758c8 Fabrice Bellard
    /* do we have a video B frame ? */
766
    presentation_delayed = 0;
767 01f4895c Michael Niedermayer
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
768 fb2758c8 Fabrice Bellard
        /* XXX: need has_b_frame, but cannot get it if the codec is
769
           not initialized */
770 115329f1 Diego Biurrun
        if ((   st->codec->codec_id == CODEC_ID_H264
771
             || st->codec->has_b_frames) &&
772 fb2758c8 Fabrice Bellard
            pc && pc->pict_type != FF_B_TYPE)
773
            presentation_delayed = 1;
774 77405fc8 Michael Niedermayer
        /* this may be redundant, but it shouldnt hurt */
775
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
776
            presentation_delayed = 1;
777 fb2758c8 Fabrice Bellard
    }
778 115329f1 Diego Biurrun
779 e928649b Michael Niedermayer
    if(st->cur_dts == AV_NOPTS_VALUE){
780
        if(presentation_delayed) st->cur_dts = -pkt->duration;
781
        else                     st->cur_dts = 0;
782
    }
783 fb2758c8 Fabrice Bellard
784 3c895fc0 Michael Niedermayer
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
785 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
786
    if (presentation_delayed) {
787
        /* DTS = decompression time stamp */
788
        /* PTS = presentation time stamp */
789
        if (pkt->dts == AV_NOPTS_VALUE) {
790 77405fc8 Michael Niedermayer
            /* if we know the last pts, use it */
791
            if(st->last_IP_pts != AV_NOPTS_VALUE)
792
                st->cur_dts = pkt->dts = st->last_IP_pts;
793
            else
794
                pkt->dts = st->cur_dts;
795 fb2758c8 Fabrice Bellard
        } else {
796
            st->cur_dts = pkt->dts;
797
        }
798
        /* this is tricky: the dts must be incremented by the duration
799
           of the frame we are displaying, i.e. the last I or P frame */
800
        if (st->last_IP_duration == 0)
801
            st->cur_dts += pkt->duration;
802
        else
803
            st->cur_dts += st->last_IP_duration;
804
        st->last_IP_duration  = pkt->duration;
805 77405fc8 Michael Niedermayer
        st->last_IP_pts= pkt->pts;
806 fb2758c8 Fabrice Bellard
        /* cannot compute PTS if not present (we can compute it only
807
           by knowing the futur */
808 a603bf8d Michael Niedermayer
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
809 90bb394d Michael Niedermayer
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
810
            int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
811
            int64_t new_diff= ABS(st->cur_dts - pkt->pts);
812
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
813
                pkt->pts += pkt->duration;
814 3e76d1b5 Michael Niedermayer
//                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
815 90bb394d Michael Niedermayer
            }
816
        }
817 115329f1 Diego Biurrun
818 fb2758c8 Fabrice Bellard
        /* presentation is not delayed : PTS and DTS are the same */
819
        if (pkt->pts == AV_NOPTS_VALUE) {
820 2092bd75 Gildas Bazin
            if (pkt->dts == AV_NOPTS_VALUE) {
821
                pkt->pts = st->cur_dts;
822
                pkt->dts = st->cur_dts;
823
            }
824
            else {
825
                st->cur_dts = pkt->dts;
826
                pkt->pts = pkt->dts;
827
            }
828 fb2758c8 Fabrice Bellard
        } else {
829
            st->cur_dts = pkt->pts;
830
            pkt->dts = pkt->pts;
831
        }
832
        st->cur_dts += pkt->duration;
833
    }
834 e928649b Michael Niedermayer
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
835 115329f1 Diego Biurrun
836 fb2758c8 Fabrice Bellard
    /* update flags */
837
    if (pc) {
838
        pkt->flags = 0;
839
        /* key frame computation */
840 01f4895c Michael Niedermayer
        switch(st->codec->codec_type) {
841 fb2758c8 Fabrice Bellard
        case CODEC_TYPE_VIDEO:
842
            if (pc->pict_type == FF_I_TYPE)
843
                pkt->flags |= PKT_FLAG_KEY;
844
            break;
845
        case CODEC_TYPE_AUDIO:
846
            pkt->flags |= PKT_FLAG_KEY;
847
            break;
848
        default:
849
            break;
850
        }
851
    }
852
}
853
854 63dd1377 Michael Niedermayer
void av_destruct_packet_nofree(AVPacket *pkt)
855 fb2758c8 Fabrice Bellard
{
856
    pkt->data = NULL; pkt->size = 0;
857
}
858
859
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
860
{
861
    AVStream *st;
862 37353960 Fabrice Bellard
    int len, ret, i;
863 fb2758c8 Fabrice Bellard
864
    for(;;) {
865
        /* select current input stream component */
866
        st = s->cur_st;
867
        if (st) {
868 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
869 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
870
                /* raw data support */
871
                *pkt = s->cur_pkt;
872
                compute_pkt_fields(s, st, NULL, pkt);
873
                s->cur_st = NULL;
874
                return 0;
875 f3356e9c Michael Niedermayer
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
876 115329f1 Diego Biurrun
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
877 6ec87caa Fabrice Bellard
                                      s->cur_ptr, s->cur_len,
878
                                      s->cur_pkt.pts, s->cur_pkt.dts);
879
                s->cur_pkt.pts = AV_NOPTS_VALUE;
880
                s->cur_pkt.dts = AV_NOPTS_VALUE;
881 fb2758c8 Fabrice Bellard
                /* increment read pointer */
882
                s->cur_ptr += len;
883
                s->cur_len -= len;
884 115329f1 Diego Biurrun
885 fb2758c8 Fabrice Bellard
                /* return packet if any */
886
                if (pkt->size) {
887 37353960 Fabrice Bellard
                got_packet:
888 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
889
                    pkt->stream_index = st->index;
890 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
891
                    pkt->dts = st->parser->dts;
892 fb2758c8 Fabrice Bellard
                    pkt->destruct = av_destruct_packet_nofree;
893
                    compute_pkt_fields(s, st, st->parser, pkt);
894
                    return 0;
895
                }
896
            } else {
897 bcbecff1 Fabrice Bellard
                /* free packet */
898 115329f1 Diego Biurrun
                av_free_packet(&s->cur_pkt);
899 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
900
            }
901
        } else {
902
            /* read next packet */
903
            ret = av_read_packet(s, &s->cur_pkt);
904 37353960 Fabrice Bellard
            if (ret < 0) {
905
                if (ret == -EAGAIN)
906
                    return ret;
907
                /* return the last frames, if any */
908
                for(i = 0; i < s->nb_streams; i++) {
909
                    st = s->streams[i];
910 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
911 115329f1 Diego Biurrun
                        av_parser_parse(st->parser, st->codec,
912
                                        &pkt->data, &pkt->size,
913
                                        NULL, 0,
914 6ec87caa Fabrice Bellard
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
915 37353960 Fabrice Bellard
                        if (pkt->size)
916
                            goto got_packet;
917
                    }
918
                }
919
                /* no more packets: really terminates parsing */
920 fb2758c8 Fabrice Bellard
                return ret;
921 37353960 Fabrice Bellard
            }
922 115329f1 Diego Biurrun
923 9ee91c2f Michael Niedermayer
            st = s->streams[s->cur_pkt.stream_index];
924 fb2758c8 Fabrice Bellard
925
            s->cur_st = st;
926
            s->cur_ptr = s->cur_pkt.data;
927
            s->cur_len = s->cur_pkt.size;
928
            if (st->need_parsing && !st->parser) {
929 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
930 fb2758c8 Fabrice Bellard
                if (!st->parser) {
931
                    /* no parser available : just output the raw packets */
932
                    st->need_parsing = 0;
933 7cbaa7ba Michael Niedermayer
                }else if(st->need_parsing == 2){
934
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
935 fb2758c8 Fabrice Bellard
                }
936
            }
937
        }
938
    }
939
}
940
941
/**
942 e36bdf8b Daniel Kristjansson
 * Return the next frame of a stream.
943
 *
944
 * The returned packet is valid
945 fb2758c8 Fabrice Bellard
 * until the next av_read_frame() or until av_close_input_file() and
946
 * must be freed with av_free_packet. For video, the packet contains
947
 * exactly one frame. For audio, it contains an integer number of
948
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
949
 * data). If the audio frames have a variable size (e.g. MPEG audio),
950
 * then it contains one frame.
951 115329f1 Diego Biurrun
 *
952 fb2758c8 Fabrice Bellard
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
953
 * values in AV_TIME_BASE unit (and guessed if the format cannot
954
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
955
 * has B frames, so it is better to rely on pkt->dts if you do not
956
 * decompress the payload.
957 115329f1 Diego Biurrun
 *
958 e36bdf8b Daniel Kristjansson
 * @return 0 if OK, < 0 if error or end of file.
959 fb2758c8 Fabrice Bellard
 */
960
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
961
{
962 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
963 30bc6613 Michael Niedermayer
    int eof=0;
964
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
965
966
    for(;;){
967
        pktl = s->packet_buffer;
968
        if (pktl) {
969
            AVPacket *next_pkt= &pktl->pkt;
970
971
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
972
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
973 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
974 30bc6613 Michael Niedermayer
                       && next_pkt->dts < pktl->pkt.dts
975
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
976
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
977
                        next_pkt->pts= pktl->pkt.dts;
978
                    }
979
                    pktl= pktl->next;
980
                }
981
                pktl = s->packet_buffer;
982
            }
983 115329f1 Diego Biurrun
984
            if(   next_pkt->pts != AV_NOPTS_VALUE
985
               || next_pkt->dts == AV_NOPTS_VALUE
986 30bc6613 Michael Niedermayer
               || !genpts || eof){
987
                /* read packet from packet buffer, if there is data */
988
                *pkt = *next_pkt;
989
                s->packet_buffer = pktl->next;
990
                av_free(pktl);
991
                return 0;
992
            }
993
        }
994
        if(genpts){
995
            AVPacketList **plast_pktl= &s->packet_buffer;
996
            int ret= av_read_frame_internal(s, pkt);
997
            if(ret<0){
998
                if(pktl && ret != -EAGAIN){
999
                    eof=1;
1000
                    continue;
1001
                }else
1002
                    return ret;
1003
            }
1004 115329f1 Diego Biurrun
1005 30bc6613 Michael Niedermayer
            /* duplicate the packet */
1006
            if (av_dup_packet(pkt) < 0)
1007
                return AVERROR_NOMEM;
1008 de6d9b64 Fabrice Bellard
1009 30bc6613 Michael Niedermayer
            while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
1010 115329f1 Diego Biurrun
1011 30bc6613 Michael Niedermayer
            pktl = av_mallocz(sizeof(AVPacketList));
1012
            if (!pktl)
1013
                return AVERROR_NOMEM;
1014 115329f1 Diego Biurrun
1015 30bc6613 Michael Niedermayer
            /* add the packet in the buffered packet list */
1016
            *plast_pktl = pktl;
1017 115329f1 Diego Biurrun
            pktl->pkt= *pkt;
1018 30bc6613 Michael Niedermayer
        }else{
1019
            assert(!s->packet_buffer);
1020
            return av_read_frame_internal(s, pkt);
1021
        }
1022 fb2758c8 Fabrice Bellard
    }
1023
}
1024
1025
/* XXX: suppress the packet queue */
1026
static void flush_packet_queue(AVFormatContext *s)
1027
{
1028
    AVPacketList *pktl;
1029
1030
    for(;;) {
1031
        pktl = s->packet_buffer;
1032 115329f1 Diego Biurrun
        if (!pktl)
1033 fb2758c8 Fabrice Bellard
            break;
1034
        s->packet_buffer = pktl->next;
1035
        av_free_packet(&pktl->pkt);
1036
        av_free(pktl);
1037 b9a281db Fabrice Bellard
    }
1038
}
1039
1040 da24c5e3 Fabrice Bellard
/*******************************************************/
1041 fb2758c8 Fabrice Bellard
/* seek support */
1042
1043 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
1044
{
1045
    int i;
1046
    AVStream *st;
1047
1048
    if (s->nb_streams <= 0)
1049
        return -1;
1050
    for(i = 0; i < s->nb_streams; i++) {
1051
        st = s->streams[i];
1052 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1053 b754978a Michael Niedermayer
            return i;
1054
        }
1055
    }
1056
    return 0;
1057
}
1058
1059 e36bdf8b Daniel Kristjansson
/**
1060
 * Flush the frame reader.
1061
 */
1062 fb2758c8 Fabrice Bellard
static void av_read_frame_flush(AVFormatContext *s)
1063
{
1064
    AVStream *st;
1065
    int i;
1066
1067
    flush_packet_queue(s);
1068
1069
    /* free previous packet */
1070
    if (s->cur_st) {
1071
        if (s->cur_st->parser)
1072
            av_free_packet(&s->cur_pkt);
1073
        s->cur_st = NULL;
1074
    }
1075
    /* fail safe */
1076
    s->cur_ptr = NULL;
1077
    s->cur_len = 0;
1078 115329f1 Diego Biurrun
1079 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
1080
    for(i = 0; i < s->nb_streams; i++) {
1081
        st = s->streams[i];
1082 115329f1 Diego Biurrun
1083 fb2758c8 Fabrice Bellard
        if (st->parser) {
1084
            av_parser_close(st->parser);
1085
            st->parser = NULL;
1086
        }
1087 77405fc8 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
1088 fb2758c8 Fabrice Bellard
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1089
    }
1090
}
1091
1092 cdd5034f Michael Niedermayer
/**
1093 e36bdf8b Daniel Kristjansson
 * Updates cur_dts of all streams based on given timestamp and AVStream.
1094
 *
1095
 * Stream ref_st unchanged, others set cur_dts in their native timebase
1096 1a1dc611 Nathan Kurz
 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1097
 * @param timestamp new dts expressed in time_base of param ref_st
1098
 * @param ref_st reference stream giving time_base of param timestamp
1099 8bcb147f Michael Niedermayer
 */
1100 1a1dc611 Nathan Kurz
static void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1101 8bcb147f Michael Niedermayer
    int i;
1102
1103
    for(i = 0; i < s->nb_streams; i++) {
1104 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
1105 8bcb147f Michael Niedermayer
1106 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
1107 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1108
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1109 8bcb147f Michael Niedermayer
    }
1110
}
1111
1112
/**
1113 e36bdf8b Daniel Kristjansson
 * Add a index entry into a sorted list updateing if it is already there.
1114
 *
1115 cdd5034f Michael Niedermayer
 * @param timestamp timestamp in the timebase of the given stream
1116
 */
1117 3e9245a9 Michael Niedermayer
int av_add_index_entry(AVStream *st,
1118 30a43f2d Michael Niedermayer
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1119 fb2758c8 Fabrice Bellard
{
1120
    AVIndexEntry *entries, *ie;
1121 b754978a Michael Niedermayer
    int index;
1122 115329f1 Diego Biurrun
1123 568e18b1 Michael Niedermayer
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1124
        return -1;
1125 115329f1 Diego Biurrun
1126 fb2758c8 Fabrice Bellard
    entries = av_fast_realloc(st->index_entries,
1127
                              &st->index_entries_allocated_size,
1128 115329f1 Diego Biurrun
                              (st->nb_index_entries + 1) *
1129 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1130 568e18b1 Michael Niedermayer
    if(!entries)
1131
        return -1;
1132
1133 b754978a Michael Niedermayer
    st->index_entries= entries;
1134
1135 27a5fe5f Michael Niedermayer
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1136 b754978a Michael Niedermayer
1137 3ba1438d Michael Niedermayer
    if(index<0){
1138 3e9245a9 Michael Niedermayer
        index= st->nb_index_entries++;
1139
        ie= &entries[index];
1140 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1141
    }else{
1142
        ie= &entries[index];
1143
        if(ie->timestamp != timestamp){
1144 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1145
                return -1;
1146 3ba1438d Michael Niedermayer
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1147
            st->nb_index_entries++;
1148
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1149
            distance= ie->min_distance;
1150 3e9245a9 Michael Niedermayer
    }
1151 3ba1438d Michael Niedermayer
1152 b754978a Michael Niedermayer
    ie->pos = pos;
1153
    ie->timestamp = timestamp;
1154 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1155 30a43f2d Michael Niedermayer
    ie->size= size;
1156 b754978a Michael Niedermayer
    ie->flags = flags;
1157 115329f1 Diego Biurrun
1158 3e9245a9 Michael Niedermayer
    return index;
1159 fb2758c8 Fabrice Bellard
}
1160
1161 e36bdf8b Daniel Kristjansson
/**
1162
 * build an index for raw streams using a parser.
1163
 */
1164 fb2758c8 Fabrice Bellard
static void av_build_index_raw(AVFormatContext *s)
1165
{
1166
    AVPacket pkt1, *pkt = &pkt1;
1167
    int ret;
1168
    AVStream *st;
1169
1170
    st = s->streams[0];
1171
    av_read_frame_flush(s);
1172
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1173
1174
    for(;;) {
1175
        ret = av_read_frame(s, pkt);
1176
        if (ret < 0)
1177
            break;
1178
        if (pkt->stream_index == 0 && st->parser &&
1179
            (pkt->flags & PKT_FLAG_KEY)) {
1180 115329f1 Diego Biurrun
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1181 30a43f2d Michael Niedermayer
                            0, 0, AVINDEX_KEYFRAME);
1182 fb2758c8 Fabrice Bellard
        }
1183
        av_free_packet(pkt);
1184
    }
1185
}
1186
1187 e36bdf8b Daniel Kristjansson
/**
1188
 * Returns TRUE if we deal with a raw stream.
1189
 *
1190
 * Raw codec data and parsing needed.
1191
 */
1192 fb2758c8 Fabrice Bellard
static int is_raw_stream(AVFormatContext *s)
1193
{
1194
    AVStream *st;
1195
1196
    if (s->nb_streams != 1)
1197
        return 0;
1198
    st = s->streams[0];
1199
    if (!st->need_parsing)
1200
        return 0;
1201
    return 1;
1202
}
1203
1204 3ba1438d Michael Niedermayer
/**
1205 e36bdf8b Daniel Kristjansson
 * Gets the index for a specific timestamp.
1206 115329f1 Diego Biurrun
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1207
 *                 the timestamp which is <= the requested one, if backward is 0
1208 3ba1438d Michael Niedermayer
 *                 then it will be >=
1209 27a5fe5f Michael Niedermayer
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1210 3ba1438d Michael Niedermayer
 * @return < 0 if no such timestamp could be found
1211
 */
1212 dc56fc38 Michael Niedermayer
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1213 27a5fe5f Michael Niedermayer
                              int flags)
1214 fb2758c8 Fabrice Bellard
{
1215 b754978a Michael Niedermayer
    AVIndexEntry *entries= st->index_entries;
1216
    int nb_entries= st->nb_index_entries;
1217 fb2758c8 Fabrice Bellard
    int a, b, m;
1218
    int64_t timestamp;
1219
1220 3ba1438d Michael Niedermayer
    a = - 1;
1221
    b = nb_entries;
1222 b754978a Michael Niedermayer
1223 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1224
        m = (a + b) >> 1;
1225 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1226 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1227
            b = m;
1228
        if(timestamp <= wanted_timestamp)
1229 b754978a Michael Niedermayer
            a = m;
1230 fb2758c8 Fabrice Bellard
    }
1231 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1232 115329f1 Diego Biurrun
1233 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1234
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1235
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1236
        }
1237
    }
1238 3ba1438d Michael Niedermayer
1239 115329f1 Diego Biurrun
    if(m == nb_entries)
1240 3ba1438d Michael Niedermayer
        return -1;
1241
    return  m;
1242 fb2758c8 Fabrice Bellard
}
1243
1244 8d14a25c Michael Niedermayer
#define DEBUG_SEEK
1245
1246 cdd5034f Michael Niedermayer
/**
1247
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1248
 * this isnt supposed to be called directly by a user application, but by demuxers
1249
 * @param target_ts target timestamp in the time base of the given stream
1250
 * @param stream_index stream number
1251
 */
1252 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1253 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1254
    int64_t pos_min, pos_max, pos, pos_limit;
1255
    int64_t ts_min, ts_max, ts;
1256 6fd93ce2 Kenneth Aafløy
    int64_t start_pos, filesize;
1257 8bcb147f Michael Niedermayer
    int index, no_change;
1258 8d14a25c Michael Niedermayer
    AVStream *st;
1259
1260 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1261
        return -1;
1262 115329f1 Diego Biurrun
1263 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1264 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1265 8d14a25c Michael Niedermayer
#endif
1266
1267
    ts_max=
1268
    ts_min= AV_NOPTS_VALUE;
1269
    pos_limit= -1; //gcc falsely says it may be uninitalized
1270
1271
    st= s->streams[stream_index];
1272
    if(st->index_entries){
1273
        AVIndexEntry *e;
1274
1275 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()
1276 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1277 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1278
1279
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1280
            pos_min= e->pos;
1281
            ts_min= e->timestamp;
1282
#ifdef DEBUG_SEEK
1283 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1284 8d14a25c Michael Niedermayer
               pos_min,ts_min);
1285
#endif
1286
        }else{
1287
            assert(index==0);
1288
        }
1289 115329f1 Diego Biurrun
1290
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1291 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1292
        if(index >= 0){
1293 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1294
            assert(e->timestamp >= target_ts);
1295
            pos_max= e->pos;
1296
            ts_max= e->timestamp;
1297
            pos_limit= pos_max - e->min_distance;
1298
#ifdef DEBUG_SEEK
1299 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1300 8d14a25c Michael Niedermayer
               pos_max,pos_limit, ts_max);
1301
#endif
1302
        }
1303
    }
1304
1305
    if(ts_min == AV_NOPTS_VALUE){
1306
        pos_min = s->data_offset;
1307
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1308
        if (ts_min == AV_NOPTS_VALUE)
1309
            return -1;
1310
    }
1311
1312
    if(ts_max == AV_NOPTS_VALUE){
1313
        int step= 1024;
1314 6fd93ce2 Kenneth Aafløy
        filesize = url_fsize(&s->pb);
1315
        pos_max = filesize - 1;
1316 8d14a25c Michael Niedermayer
        do{
1317
            pos_max -= step;
1318
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1319
            step += step;
1320
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1321
        if (ts_max == AV_NOPTS_VALUE)
1322
            return -1;
1323 115329f1 Diego Biurrun
1324 8d14a25c Michael Niedermayer
        for(;;){
1325
            int64_t tmp_pos= pos_max + 1;
1326
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1327
            if(tmp_ts == AV_NOPTS_VALUE)
1328
                break;
1329
            ts_max= tmp_ts;
1330
            pos_max= tmp_pos;
1331 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1332
                break;
1333 8d14a25c Michael Niedermayer
        }
1334
        pos_limit= pos_max;
1335
    }
1336
1337 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1338
        return -1;
1339
    }else if(ts_min == ts_max){
1340
        pos_limit= pos_min;
1341
    }
1342
1343 8d14a25c Michael Niedermayer
    no_change=0;
1344
    while (pos_min < pos_limit) {
1345
#ifdef DEBUG_SEEK
1346 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1347 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1348
               ts_min, ts_max);
1349
#endif
1350
        assert(pos_limit <= pos_max);
1351
1352
        if(no_change==0){
1353
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1354
            // interpolate position (better than dichotomy)
1355 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1356
                + pos_min - approximate_keyframe_distance;
1357 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1358
            // bisection, if interpolation failed to change min or max pos last time
1359
            pos = (pos_min + pos_limit)>>1;
1360
        }else{
1361
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1362
            pos=pos_min;
1363
        }
1364
        if(pos <= pos_min)
1365
            pos= pos_min + 1;
1366
        else if(pos > pos_limit)
1367
            pos= pos_limit;
1368
        start_pos= pos;
1369
1370
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1371
        if(pos == pos_max)
1372
            no_change++;
1373
        else
1374
            no_change=0;
1375
#ifdef DEBUG_SEEK
1376 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);
1377 8d14a25c Michael Niedermayer
#endif
1378
        assert(ts != AV_NOPTS_VALUE);
1379 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1380 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1381
            pos_max = pos;
1382
            ts_max = ts;
1383 3ba1438d Michael Niedermayer
        }
1384
        if (target_ts >= ts) {
1385 8d14a25c Michael Niedermayer
            pos_min = pos;
1386
            ts_min = ts;
1387
        }
1388
    }
1389 115329f1 Diego Biurrun
1390 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1391
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1392 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1393
    pos_min = pos;
1394
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1395
    pos_min++;
1396
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1397 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1398 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1399
#endif
1400
    /* do the seek */
1401
    url_fseek(&s->pb, pos, SEEK_SET);
1402 cdd5034f Michael Niedermayer
1403 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ts);
1404 8d14a25c Michael Niedermayer
1405
    return 0;
1406
}
1407
1408 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1409
    int64_t pos_min, pos_max;
1410
#if 0
1411
    AVStream *st;
1412

1413
    if (stream_index < 0)
1414
        return -1;
1415

1416
    st= s->streams[stream_index];
1417
#endif
1418
1419
    pos_min = s->data_offset;
1420 a965c478 Aurelien Jacobs
    pos_max = url_fsize(&s->pb) - 1;
1421 3ba1438d Michael Niedermayer
1422
    if     (pos < pos_min) pos= pos_min;
1423
    else if(pos > pos_max) pos= pos_max;
1424
1425
    url_fseek(&s->pb, pos, SEEK_SET);
1426
1427
#if 0
1428 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ts);
1429 3ba1438d Michael Niedermayer
#endif
1430
    return 0;
1431
}
1432
1433 115329f1 Diego Biurrun
static int av_seek_frame_generic(AVFormatContext *s,
1434 3ba1438d Michael Niedermayer
                                 int stream_index, int64_t timestamp, int flags)
1435 fb2758c8 Fabrice Bellard
{
1436 8bcb147f Michael Niedermayer
    int index;
1437 fb2758c8 Fabrice Bellard
    AVStream *st;
1438
    AVIndexEntry *ie;
1439
1440
    if (!s->index_built) {
1441
        if (is_raw_stream(s)) {
1442
            av_build_index_raw(s);
1443
        } else {
1444
            return -1;
1445
        }
1446
        s->index_built = 1;
1447
    }
1448
1449
    st = s->streams[stream_index];
1450 27a5fe5f Michael Niedermayer
    index = av_index_search_timestamp(st, timestamp, flags);
1451 fb2758c8 Fabrice Bellard
    if (index < 0)
1452
        return -1;
1453
1454
    /* now we have found the index, we can seek */
1455
    ie = &st->index_entries[index];
1456
    av_read_frame_flush(s);
1457
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1458 3ba1438d Michael Niedermayer
1459 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ie->timestamp);
1460 cdd5034f Michael Niedermayer
1461 fb2758c8 Fabrice Bellard
    return 0;
1462
}
1463
1464
/**
1465 3ba1438d Michael Niedermayer
 * Seek to the key frame at timestamp.
1466 cdd5034f Michael Niedermayer
 * 'timestamp' in 'stream_index'.
1467
 * @param stream_index If stream_index is (-1), a default
1468 115329f1 Diego Biurrun
 * stream is selected, and timestamp is automatically converted
1469 eb497825 Nathan Kurz
 * from AV_TIME_BASE units to the stream specific time_base.
1470 3ba1438d Michael Niedermayer
 * @param timestamp timestamp in AVStream.time_base units
1471 9c98cdbc Michael Niedermayer
 *        or if there is no stream specified then in AV_TIME_BASE units
1472 3ba1438d Michael Niedermayer
 * @param flags flags which select direction and seeking mode
1473 cdd5034f Michael Niedermayer
 * @return >= 0 on success
1474 fb2758c8 Fabrice Bellard
 */
1475 3ba1438d Michael Niedermayer
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1476 fb2758c8 Fabrice Bellard
{
1477
    int ret;
1478 cdd5034f Michael Niedermayer
    AVStream *st;
1479 115329f1 Diego Biurrun
1480 fb2758c8 Fabrice Bellard
    av_read_frame_flush(s);
1481 115329f1 Diego Biurrun
1482 3ba1438d Michael Niedermayer
    if(flags & AVSEEK_FLAG_BYTE)
1483
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1484 115329f1 Diego Biurrun
1485 cdd5034f Michael Niedermayer
    if(stream_index < 0){
1486
        stream_index= av_find_default_stream_index(s);
1487
        if(stream_index < 0)
1488
            return -1;
1489 115329f1 Diego Biurrun
1490 3ba1438d Michael Niedermayer
        st= s->streams[stream_index];
1491 eb497825 Nathan Kurz
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1492 3ba1438d Michael Niedermayer
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1493 cdd5034f Michael Niedermayer
    }
1494
    st= s->streams[stream_index];
1495
1496 fb2758c8 Fabrice Bellard
    /* first, we try the format specific seek */
1497
    if (s->iformat->read_seek)
1498 3ba1438d Michael Niedermayer
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1499 fb2758c8 Fabrice Bellard
    else
1500
        ret = -1;
1501
    if (ret >= 0) {
1502
        return 0;
1503
    }
1504 8d14a25c Michael Niedermayer
1505
    if(s->iformat->read_timestamp)
1506 3ba1438d Michael Niedermayer
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1507 8d14a25c Michael Niedermayer
    else
1508 3ba1438d Michael Niedermayer
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1509 fb2758c8 Fabrice Bellard
}
1510
1511
/*******************************************************/
1512 12f996ed Fabrice Bellard
1513 e36bdf8b Daniel Kristjansson
/**
1514
 * Returns TRUE if the stream has accurate timings in any stream.
1515
 *
1516
 * @return TRUE if the stream has accurate timings for at least one component.
1517
 */
1518 12f996ed Fabrice Bellard
static int av_has_timings(AVFormatContext *ic)
1519
{
1520
    int i;
1521
    AVStream *st;
1522
1523
    for(i = 0;i < ic->nb_streams; i++) {
1524
        st = ic->streams[i];
1525
        if (st->start_time != AV_NOPTS_VALUE &&
1526
            st->duration != AV_NOPTS_VALUE)
1527
            return 1;
1528
    }
1529
    return 0;
1530
}
1531
1532 e36bdf8b Daniel Kristjansson
/**
1533
 * Estimate the stream timings from the one of each components.
1534
 *
1535
 * Also computes the global bitrate if possible.
1536
 */
1537 12f996ed Fabrice Bellard
static void av_update_stream_timings(AVFormatContext *ic)
1538
{
1539 c0df9d75 Michael Niedermayer
    int64_t start_time, start_time1, end_time, end_time1;
1540 12f996ed Fabrice Bellard
    int i;
1541
    AVStream *st;
1542
1543
    start_time = MAXINT64;
1544
    end_time = MININT64;
1545
    for(i = 0;i < ic->nb_streams; i++) {
1546
        st = ic->streams[i];
1547
        if (st->start_time != AV_NOPTS_VALUE) {
1548 c0df9d75 Michael Niedermayer
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1549
            if (start_time1 < start_time)
1550
                start_time = start_time1;
1551 12f996ed Fabrice Bellard
            if (st->duration != AV_NOPTS_VALUE) {
1552 c0df9d75 Michael Niedermayer
                end_time1 = start_time1
1553
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1554 12f996ed Fabrice Bellard
                if (end_time1 > end_time)
1555
                    end_time = end_time1;
1556
            }
1557
        }
1558
    }
1559
    if (start_time != MAXINT64) {
1560
        ic->start_time = start_time;
1561 69d93a13 Michael Niedermayer
        if (end_time != MININT64) {
1562 12f996ed Fabrice Bellard
            ic->duration = end_time - start_time;
1563
            if (ic->file_size > 0) {
1564
                /* compute the bit rate */
1565 115329f1 Diego Biurrun
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1566 12f996ed Fabrice Bellard
                    (double)ic->duration;
1567
            }
1568
        }
1569
    }
1570
1571
}
1572
1573
static void fill_all_stream_timings(AVFormatContext *ic)
1574
{
1575
    int i;
1576
    AVStream *st;
1577
1578
    av_update_stream_timings(ic);
1579
    for(i = 0;i < ic->nb_streams; i++) {
1580
        st = ic->streams[i];
1581
        if (st->start_time == AV_NOPTS_VALUE) {
1582 c0df9d75 Michael Niedermayer
            if(ic->start_time != AV_NOPTS_VALUE)
1583
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1584
            if(ic->duration != AV_NOPTS_VALUE)
1585
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1586 12f996ed Fabrice Bellard
        }
1587
    }
1588
}
1589
1590
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1591
{
1592
    int64_t filesize, duration;
1593
    int bit_rate, i;
1594
    AVStream *st;
1595
1596
    /* if bit_rate is already set, we believe it */
1597
    if (ic->bit_rate == 0) {
1598
        bit_rate = 0;
1599
        for(i=0;i<ic->nb_streams;i++) {
1600
            st = ic->streams[i];
1601 01f4895c Michael Niedermayer
            bit_rate += st->codec->bit_rate;
1602 12f996ed Fabrice Bellard
        }
1603
        ic->bit_rate = bit_rate;
1604
    }
1605
1606
    /* if duration is already set, we believe it */
1607 115329f1 Diego Biurrun
    if (ic->duration == AV_NOPTS_VALUE &&
1608
        ic->bit_rate != 0 &&
1609 12f996ed Fabrice Bellard
        ic->file_size != 0)  {
1610
        filesize = ic->file_size;
1611
        if (filesize > 0) {
1612
            for(i = 0; i < ic->nb_streams; i++) {
1613
                st = ic->streams[i];
1614 c0df9d75 Michael Niedermayer
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1615 12f996ed Fabrice Bellard
                if (st->start_time == AV_NOPTS_VALUE ||
1616
                    st->duration == AV_NOPTS_VALUE) {
1617
                    st->start_time = 0;
1618
                    st->duration = duration;
1619
                }
1620
            }
1621
        }
1622
    }
1623
}
1624
1625
#define DURATION_MAX_READ_SIZE 250000
1626
1627
/* only usable for MPEG-PS streams */
1628
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1629
{
1630
    AVPacket pkt1, *pkt = &pkt1;
1631
    AVStream *st;
1632
    int read_size, i, ret;
1633 bf4e3bd2 Måns Rullgård
    int64_t end_time;
1634 12f996ed Fabrice Bellard
    int64_t filesize, offset, duration;
1635 115329f1 Diego Biurrun
1636 fb2758c8 Fabrice Bellard
    /* free previous packet */
1637
    if (ic->cur_st && ic->cur_st->parser)
1638 115329f1 Diego Biurrun
        av_free_packet(&ic->cur_pkt);
1639 fb2758c8 Fabrice Bellard
    ic->cur_st = NULL;
1640
1641
    /* flush packet queue */
1642
    flush_packet_queue(ic);
1643
1644 0ff7199f Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
1645
        st = ic->streams[i];
1646
        if (st->parser) {
1647
            av_parser_close(st->parser);
1648
            st->parser= NULL;
1649
        }
1650
    }
1651 115329f1 Diego Biurrun
1652 12f996ed Fabrice Bellard
    /* we read the first packets to get the first PTS (not fully
1653
       accurate, but it is enough now) */
1654
    url_fseek(&ic->pb, 0, SEEK_SET);
1655
    read_size = 0;
1656
    for(;;) {
1657
        if (read_size >= DURATION_MAX_READ_SIZE)
1658
            break;
1659
        /* if all info is available, we can stop */
1660
        for(i = 0;i < ic->nb_streams; i++) {
1661
            st = ic->streams[i];
1662
            if (st->start_time == AV_NOPTS_VALUE)
1663
                break;
1664
        }
1665
        if (i == ic->nb_streams)
1666
            break;
1667
1668
        ret = av_read_packet(ic, pkt);
1669
        if (ret != 0)
1670
            break;
1671
        read_size += pkt->size;
1672
        st = ic->streams[pkt->stream_index];
1673
        if (pkt->pts != AV_NOPTS_VALUE) {
1674
            if (st->start_time == AV_NOPTS_VALUE)
1675 c0df9d75 Michael Niedermayer
                st->start_time = pkt->pts;
1676 0a5f92a1 Michael Niedermayer
        }
1677
        av_free_packet(pkt);
1678
    }
1679 12f996ed Fabrice Bellard
1680
    /* estimate the end time (duration) */
1681
    /* XXX: may need to support wrapping */
1682
    filesize = ic->file_size;
1683
    offset = filesize - DURATION_MAX_READ_SIZE;
1684
    if (offset < 0)
1685
        offset = 0;
1686
1687
    url_fseek(&ic->pb, offset, SEEK_SET);
1688
    read_size = 0;
1689
    for(;;) {
1690
        if (read_size >= DURATION_MAX_READ_SIZE)
1691
            break;
1692
        /* if all info is available, we can stop */
1693
        for(i = 0;i < ic->nb_streams; i++) {
1694
            st = ic->streams[i];
1695
            if (st->duration == AV_NOPTS_VALUE)
1696
                break;
1697
        }
1698
        if (i == ic->nb_streams)
1699
            break;
1700 115329f1 Diego Biurrun
1701 12f996ed Fabrice Bellard
        ret = av_read_packet(ic, pkt);
1702
        if (ret != 0)
1703
            break;
1704
        read_size += pkt->size;
1705
        st = ic->streams[pkt->stream_index];
1706
        if (pkt->pts != AV_NOPTS_VALUE) {
1707 c0df9d75 Michael Niedermayer
            end_time = pkt->pts;
1708 12f996ed Fabrice Bellard
            duration = end_time - st->start_time;
1709
            if (duration > 0) {
1710
                if (st->duration == AV_NOPTS_VALUE ||
1711
                    st->duration < duration)
1712
                    st->duration = duration;
1713
            }
1714
        }
1715
        av_free_packet(pkt);
1716
    }
1717 115329f1 Diego Biurrun
1718 c0df9d75 Michael Niedermayer
    fill_all_stream_timings(ic);
1719 12f996ed Fabrice Bellard
1720
    url_fseek(&ic->pb, 0, SEEK_SET);
1721
}
1722
1723
static void av_estimate_timings(AVFormatContext *ic)
1724
{
1725
    int64_t file_size;
1726
1727
    /* get the file size, if possible */
1728
    if (ic->iformat->flags & AVFMT_NOFILE) {
1729
        file_size = 0;
1730
    } else {
1731 a965c478 Aurelien Jacobs
        file_size = url_fsize(&ic->pb);
1732 12f996ed Fabrice Bellard
        if (file_size < 0)
1733
            file_size = 0;
1734
    }
1735
    ic->file_size = file_size;
1736
1737 ff70e601 Måns Rullgård
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1738
         !strcmp(ic->iformat->name, "mpegts")) &&
1739
        file_size && !ic->pb.is_streamed) {
1740 12f996ed Fabrice Bellard
        /* get accurate estimate from the PTSes */
1741
        av_estimate_timings_from_pts(ic);
1742
    } else if (av_has_timings(ic)) {
1743
        /* at least one components has timings - we use them for all
1744
           the components */
1745
        fill_all_stream_timings(ic);
1746
    } else {
1747
        /* less precise: use bit rate info */
1748
        av_estimate_timings_from_bit_rate(ic);
1749
    }
1750
    av_update_stream_timings(ic);
1751
1752
#if 0
1753
    {
1754
        int i;
1755
        AVStream *st;
1756
        for(i = 0;i < ic->nb_streams; i++) {
1757
            st = ic->streams[i];
1758 115329f1 Diego Biurrun
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1759
               i, (double)st->start_time / AV_TIME_BASE,
1760 12f996ed Fabrice Bellard
               (double)st->duration / AV_TIME_BASE);
1761
        }
1762 115329f1 Diego Biurrun
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1763
               (double)ic->start_time / AV_TIME_BASE,
1764 12f996ed Fabrice Bellard
               (double)ic->duration / AV_TIME_BASE,
1765
               ic->bit_rate / 1000);
1766
    }
1767
#endif
1768
}
1769
1770 b9a281db Fabrice Bellard
static int has_codec_parameters(AVCodecContext *enc)
1771
{
1772
    int val;
1773
    switch(enc->codec_type) {
1774
    case CODEC_TYPE_AUDIO:
1775
        val = enc->sample_rate;
1776
        break;
1777
    case CODEC_TYPE_VIDEO:
1778 644a9262 Michael Niedermayer
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1779 b9a281db Fabrice Bellard
        break;
1780
    default:
1781
        val = 1;
1782
        break;
1783
    }
1784
    return (val != 0);
1785
}
1786
1787 fb2758c8 Fabrice Bellard
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1788
{
1789
    int16_t *samples;
1790
    AVCodec *codec;
1791 43c0040a Michael Niedermayer
    int got_picture, ret=0;
1792 fb2758c8 Fabrice Bellard
    AVFrame picture;
1793 115329f1 Diego Biurrun
1794 01f4895c Michael Niedermayer
  if(!st->codec->codec){
1795
    codec = avcodec_find_decoder(st->codec->codec_id);
1796 fb2758c8 Fabrice Bellard
    if (!codec)
1797
        return -1;
1798 01f4895c Michael Niedermayer
    ret = avcodec_open(st->codec, codec);
1799 fb2758c8 Fabrice Bellard
    if (ret < 0)
1800
        return ret;
1801 43c0040a Michael Niedermayer
  }
1802 644a9262 Michael Niedermayer
1803 01f4895c Michael Niedermayer
  if(!has_codec_parameters(st->codec)){
1804
    switch(st->codec->codec_type) {
1805 fb2758c8 Fabrice Bellard
    case CODEC_TYPE_VIDEO:
1806 115329f1 Diego Biurrun
        ret = avcodec_decode_video(st->codec, &picture,
1807 fb2758c8 Fabrice Bellard
                                   &got_picture, (uint8_t *)data, size);
1808
        break;
1809
    case CODEC_TYPE_AUDIO:
1810
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1811
        if (!samples)
1812
            goto fail;
1813 115329f1 Diego Biurrun
        ret = avcodec_decode_audio(st->codec, samples,
1814 fb2758c8 Fabrice Bellard
                                   &got_picture, (uint8_t *)data, size);
1815
        av_free(samples);
1816
        break;
1817
    default:
1818
        break;
1819
    }
1820 644a9262 Michael Niedermayer
  }
1821 fb2758c8 Fabrice Bellard
 fail:
1822
    return ret;
1823
}
1824
1825
/* absolute maximum size we read until we abort */
1826
#define MAX_READ_SIZE        5000000
1827
1828
/* maximum duration until we stop analysing the stream */
1829 c10824ea Måns Rullgård
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 3.0))
1830 fb2758c8 Fabrice Bellard
1831 b9a281db Fabrice Bellard
/**
1832
 * Read the beginning of a media file to get stream information. This
1833
 * is useful for file formats with no headers such as MPEG. This
1834
 * function also compute the real frame rate in case of mpeg2 repeat
1835
 * frame mode.
1836
 *
1837
 * @param ic media file handle
1838 115329f1 Diego Biurrun
 * @return >=0 if OK. AVERROR_xxx if error.
1839 644a9262 Michael Niedermayer
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1840 b9a281db Fabrice Bellard
 */
1841
int av_find_stream_info(AVFormatContext *ic)
1842
{
1843 9f75260e Michael Niedermayer
    int i, count, ret, read_size, j;
1844 b9a281db Fabrice Bellard
    AVStream *st;
1845 fb2758c8 Fabrice Bellard
    AVPacket pkt1, *pkt;
1846 b9a281db Fabrice Bellard
    AVPacketList *pktl=NULL, **ppktl;
1847 15bc38e5 Michael Niedermayer
    int64_t last_dts[MAX_STREAMS];
1848 3c150d16 Michael Niedermayer
    int64_t duration_sum[MAX_STREAMS];
1849
    int duration_count[MAX_STREAMS]={0};
1850 b9a281db Fabrice Bellard
1851 c0df9d75 Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
1852
        st = ic->streams[i];
1853 01f4895c Michael Niedermayer
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1854 c0df9d75 Michael Niedermayer
/*            if(!st->time_base.num)
1855
                st->time_base= */
1856 01f4895c Michael Niedermayer
            if(!st->codec->time_base.num)
1857
                st->codec->time_base= st->time_base;
1858 c0df9d75 Michael Niedermayer
        }
1859 90ad92b3 Michael Niedermayer
        //only for the split stuff
1860
        if (!st->parser) {
1861 01f4895c Michael Niedermayer
            st->parser = av_parser_init(st->codec->codec_id);
1862 7cbaa7ba Michael Niedermayer
            if(st->need_parsing == 2 && st->parser){
1863
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1864
            }
1865 90ad92b3 Michael Niedermayer
        }
1866 c0df9d75 Michael Niedermayer
    }
1867
1868 15bc38e5 Michael Niedermayer
    for(i=0;i<MAX_STREAMS;i++){
1869
        last_dts[i]= AV_NOPTS_VALUE;
1870 3c150d16 Michael Niedermayer
        duration_sum[i]= INT64_MAX;
1871 15bc38e5 Michael Niedermayer
    }
1872 115329f1 Diego Biurrun
1873 b9a281db Fabrice Bellard
    count = 0;
1874
    read_size = 0;
1875
    ppktl = &ic->packet_buffer;
1876
    for(;;) {
1877
        /* check if one codec still needs to be handled */
1878
        for(i=0;i<ic->nb_streams;i++) {
1879
            st = ic->streams[i];
1880 01f4895c Michael Niedermayer
            if (!has_codec_parameters(st->codec))
1881 b9a281db Fabrice Bellard
                break;
1882 3e76d1b5 Michael Niedermayer
            /* variable fps and no guess at the real fps */
1883 9f75260e Michael Niedermayer
            if(   st->codec->time_base.den >= 101LL*st->codec->time_base.num
1884 01f4895c Michael Niedermayer
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1885 3e76d1b5 Michael Niedermayer
                break;
1886 01f4895c Michael Niedermayer
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1887 90ad92b3 Michael Niedermayer
                break;
1888 b9a281db Fabrice Bellard
        }
1889
        if (i == ic->nb_streams) {
1890
            /* NOTE: if the format has no header, then we need to read
1891
               some packets to get most of the streams, so we cannot
1892
               stop here */
1893 fb2758c8 Fabrice Bellard
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1894 b9a281db Fabrice Bellard
                /* if we found the info for all the codecs, we can stop */
1895
                ret = count;
1896
                break;
1897
            }
1898
        } else {
1899
            /* we did not get all the codec info, but we read too much data */
1900 fb2758c8 Fabrice Bellard
            if (read_size >= MAX_READ_SIZE) {
1901 b9a281db Fabrice Bellard
                ret = count;
1902
                break;
1903
            }
1904
        }
1905
1906 fb2758c8 Fabrice Bellard
        /* NOTE: a new stream can be added there if no header in file
1907
           (AVFMTCTX_NOHEADER) */
1908
        ret = av_read_frame_internal(ic, &pkt1);
1909
        if (ret < 0) {
1910
            /* EOF or error */
1911
            ret = -1; /* we could not have all the codec parameters before EOF */
1912 e19456e3 Michael Niedermayer
            for(i=0;i<ic->nb_streams;i++) {
1913
                st = ic->streams[i];
1914 305ee50f Michael Niedermayer
                if (!has_codec_parameters(st->codec)){
1915
                    char buf[256];
1916
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1917
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1918 344a18c3 Måns Rullgård
                } else {
1919
                    ret = 0;
1920 305ee50f Michael Niedermayer
                }
1921 e19456e3 Michael Niedermayer
            }
1922 fb2758c8 Fabrice Bellard
            break;
1923
        }
1924
1925 b9a281db Fabrice Bellard
        pktl = av_mallocz(sizeof(AVPacketList));
1926
        if (!pktl) {
1927
            ret = AVERROR_NOMEM;
1928
            break;
1929
        }
1930
1931
        /* add the packet in the buffered packet list */
1932
        *ppktl = pktl;
1933
        ppktl = &pktl->next;
1934
1935
        pkt = &pktl->pkt;
1936 fb2758c8 Fabrice Bellard
        *pkt = pkt1;
1937 115329f1 Diego Biurrun
1938 fb2758c8 Fabrice Bellard
        /* duplicate the packet */
1939
        if (av_dup_packet(pkt) < 0) {
1940
                ret = AVERROR_NOMEM;
1941
                break;
1942 b9a281db Fabrice Bellard
        }
1943
1944 fb2758c8 Fabrice Bellard
        read_size += pkt->size;
1945 b9a281db Fabrice Bellard
1946
        st = ic->streams[pkt->stream_index];
1947 fb2758c8 Fabrice Bellard
        st->codec_info_duration += pkt->duration;
1948
        if (pkt->duration != 0)
1949
            st->codec_info_nb_frames++;
1950
1951 cefe0607 Michael Niedermayer
        {
1952 3c150d16 Michael Niedermayer
            int index= pkt->stream_index;
1953
            int64_t last= last_dts[index];
1954
            int64_t duration= pkt->dts - last;
1955
1956
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1957
                if(duration*duration_count[index]*10/9 < duration_sum[index]){
1958
                    duration_sum[index]= duration;
1959
                    duration_count[index]=1;
1960
                }else{
1961
                    int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1962
                    duration_sum[index] += duration;
1963
                    duration_count[index]+= factor;
1964
                }
1965 43c0040a Michael Niedermayer
                if(st->codec_info_nb_frames == 0 && 0)
1966 cefe0607 Michael Niedermayer
                    st->codec_info_duration += duration;
1967 15bc38e5 Michael Niedermayer
            }
1968
            last_dts[pkt->stream_index]= pkt->dts;
1969
        }
1970 01f4895c Michael Niedermayer
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1971
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1972 90ad92b3 Michael Niedermayer
            if(i){
1973 01f4895c Michael Niedermayer
                st->codec->extradata_size= i;
1974 62c52121 Måns Rullgård
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1975 01f4895c Michael Niedermayer
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1976 62c52121 Måns Rullgård
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1977 90ad92b3 Michael Niedermayer
            }
1978
        }
1979 115329f1 Diego Biurrun
1980 fb2758c8 Fabrice Bellard
        /* if still no information, we try to open the codec and to
1981
           decompress the frame. We try to avoid that in most cases as
1982
           it takes longer and uses more memory. For MPEG4, we need to
1983
           decompress for Quicktime. */
1984 01f4895c Michael Niedermayer
        if (!has_codec_parameters(st->codec) /*&&
1985
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1986
             st->codec->codec_id == CODEC_ID_H264 ||
1987
             st->codec->codec_id == CODEC_ID_H263 ||
1988
             st->codec->codec_id == CODEC_ID_H261 ||
1989
             st->codec->codec_id == CODEC_ID_VORBIS ||
1990
             st->codec->codec_id == CODEC_ID_MJPEG ||
1991
             st->codec->codec_id == CODEC_ID_PNG ||
1992
             st->codec->codec_id == CODEC_ID_PAM ||
1993
             st->codec->codec_id == CODEC_ID_PGM ||
1994
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1995
             st->codec->codec_id == CODEC_ID_PBM ||
1996
             st->codec->codec_id == CODEC_ID_PPM ||
1997
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1998
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1999 fb2758c8 Fabrice Bellard
            try_decode_frame(st, pkt->data, pkt->size);
2000 115329f1 Diego Biurrun
2001 cefe0607 Michael Niedermayer
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2002 fb2758c8 Fabrice Bellard
            break;
2003 b9a281db Fabrice Bellard
        }
2004
        count++;
2005
    }
2006
2007 43c0040a Michael Niedermayer
    // close codecs which where opened in try_decode_frame()
2008
    for(i=0;i<ic->nb_streams;i++) {
2009
        st = ic->streams[i];
2010 01f4895c Michael Niedermayer
        if(st->codec->codec)
2011
            avcodec_close(st->codec);
2012 43c0040a Michael Niedermayer
    }
2013 b9a281db Fabrice Bellard
    for(i=0;i<ic->nb_streams;i++) {
2014
        st = ic->streams[i];
2015 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2016
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2017
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2018 15bc38e5 Michael Niedermayer
2019 9f75260e Michael Niedermayer
            if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2020
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2021
                int64_t num, den, error, best_error;
2022 b3506cb4 Michael Niedermayer
2023 3c150d16 Michael Niedermayer
                num= st->time_base.den*duration_count[i];
2024
                den= st->time_base.num*duration_sum[i];
2025 115329f1 Diego Biurrun
2026 9f75260e Michael Niedermayer
                best_error= INT64_MAX;
2027
                for(j=1; j<60*12; j++){
2028
                    error= ABS(1001*12*num - 1001*j*den);
2029
                    if(error < best_error){
2030
                        best_error= error;
2031
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
2032
                    }
2033
                }
2034
                for(j=24; j<=30; j+=6){
2035
                    error= ABS(1001*12*num - 1000*12*j*den);
2036
                    if(error < best_error){
2037
                        best_error= error;
2038
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
2039
                    }
2040 3c150d16 Michael Niedermayer
                }
2041 15bc38e5 Michael Niedermayer
            }
2042
2043 d07730dd Michael Niedermayer
            /* set real frame rate info */
2044 fb2758c8 Fabrice Bellard
            /* compute the real frame rate for telecine */
2045 01f4895c Michael Niedermayer
            if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
2046
                 st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
2047
                st->codec->sub_id == 2) {
2048 fb2758c8 Fabrice Bellard
                if (st->codec_info_nb_frames >= 20) {
2049
                    float coded_frame_rate, est_frame_rate;
2050 115329f1 Diego Biurrun
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
2051 fb2758c8 Fabrice Bellard
                        (double)st->codec_info_duration ;
2052 01f4895c Michael Niedermayer
                    coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
2053 fb2758c8 Fabrice Bellard
#if 0
2054 115329f1 Diego Biurrun
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
2055 fb2758c8 Fabrice Bellard
                           coded_frame_rate, est_frame_rate);
2056
#endif
2057
                    /* if we detect that it could be a telecine, we
2058
                       signal it. It would be better to do it at a
2059
                       higher level as it can change in a film */
2060 115329f1 Diego Biurrun
                    if (coded_frame_rate >= 24.97 &&
2061 fb2758c8 Fabrice Bellard
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
2062 c0df9d75 Michael Niedermayer
                        st->r_frame_rate = (AVRational){24000, 1001};
2063 fb2758c8 Fabrice Bellard
                    }
2064
                }
2065
            }
2066
            /* if no real frame rate, use the codec one */
2067 c0df9d75 Michael Niedermayer
            if (!st->r_frame_rate.num){
2068 01f4895c Michael Niedermayer
                st->r_frame_rate.num = st->codec->time_base.den;
2069
                st->r_frame_rate.den = st->codec->time_base.num;
2070 14bea432 Michael Niedermayer
            }
2071 b9a281db Fabrice Bellard
        }
2072 de6d9b64 Fabrice Bellard
    }
2073 b9a281db Fabrice Bellard
2074 12f996ed Fabrice Bellard
    av_estimate_timings(ic);
2075 e928649b Michael Niedermayer
#if 0
2076
    /* correct DTS for b frame streams with no timestamps */
2077
    for(i=0;i<ic->nb_streams;i++) {
2078
        st = ic->streams[i];
2079 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2080 e928649b Michael Niedermayer
            if(b-frames){
2081
                ppktl = &ic->packet_buffer;
2082
                while(ppkt1){
2083
                    if(ppkt1->stream_index != i)
2084
                        continue;
2085
                    if(ppkt1->pkt->dts < 0)
2086
                        break;
2087
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2088
                        break;
2089
                    ppkt1->pkt->dts -= delta;
2090
                    ppkt1= ppkt1->next;
2091
                }
2092
                if(ppkt1)
2093
                    continue;
2094
                st->cur_dts -= delta;
2095
            }
2096
        }
2097
    }
2098
#endif
2099 b9a281db Fabrice Bellard
    return ret;
2100 de6d9b64 Fabrice Bellard
}
2101
2102 fb2758c8 Fabrice Bellard
/*******************************************************/
2103
2104
/**
2105
 * start playing a network based stream (e.g. RTSP stream) at the
2106 115329f1 Diego Biurrun
 * current position
2107 fb2758c8 Fabrice Bellard
 */
2108
int av_read_play(AVFormatContext *s)
2109
{
2110
    if (!s->iformat->read_play)
2111
        return AVERROR_NOTSUPP;
2112
    return s->iformat->read_play(s);
2113
}
2114
2115
/**
2116 e36bdf8b Daniel Kristjansson
 * Pause a network based stream (e.g. RTSP stream).
2117
 *
2118
 * Use av_read_play() to resume it.
2119 fb2758c8 Fabrice Bellard
 */
2120
int av_read_pause(AVFormatContext *s)
2121
{
2122
    if (!s->iformat->read_pause)
2123
        return AVERROR_NOTSUPP;
2124
    return s->iformat->read_pause(s);
2125
}
2126
2127 b9a281db Fabrice Bellard
/**
2128 e36bdf8b Daniel Kristjansson
 * Close a media file (but not its codecs).
2129 b9a281db Fabrice Bellard
 *
2130
 * @param s media file handle
2131
 */
2132 de6d9b64 Fabrice Bellard
void av_close_input_file(AVFormatContext *s)
2133
{
2134 b6892136 Fabrice Bellard
    int i, must_open_file;
2135 da24c5e3 Fabrice Bellard
    AVStream *st;
2136 de6d9b64 Fabrice Bellard
2137 fb2758c8 Fabrice Bellard
    /* free previous packet */
2138
    if (s->cur_st && s->cur_st->parser)
2139 115329f1 Diego Biurrun
        av_free_packet(&s->cur_pkt);
2140 fb2758c8 Fabrice Bellard
2141 b9a281db Fabrice Bellard
    if (s->iformat->read_close)
2142
        s->iformat->read_close(s);
2143 de6d9b64 Fabrice Bellard
    for(i=0;i<s->nb_streams;i++) {
2144 da24c5e3 Fabrice Bellard
        /* free all data in a stream component */
2145
        st = s->streams[i];
2146 fb2758c8 Fabrice Bellard
        if (st->parser) {
2147
            av_parser_close(st->parser);
2148 de6d9b64 Fabrice Bellard
        }
2149 fb2758c8 Fabrice Bellard
        av_free(st->index_entries);
2150 a5e9102b Måns Rullgård
        av_free(st->codec->extradata);
2151 01f4895c Michael Niedermayer
        av_free(st->codec);
2152 fb2758c8 Fabrice Bellard
        av_free(st);
2153 de6d9b64 Fabrice Bellard
    }
2154 fb2758c8 Fabrice Bellard
    flush_packet_queue(s);
2155 b6892136 Fabrice Bellard
    must_open_file = 1;
2156 da24c5e3 Fabrice Bellard
    if (s->iformat->flags & AVFMT_NOFILE) {
2157 b6892136 Fabrice Bellard
        must_open_file = 0;
2158
    }
2159
    if (must_open_file) {
2160 96baaa6a Fabrice Bellard
        url_fclose(&s->pb);
2161
    }
2162 a8dbe951 Philip Gladstone
    av_freep(&s->priv_data);
2163 1ea4f593 Fabrice Bellard
    av_free(s);
2164 de6d9b64 Fabrice Bellard
}
2165
2166 b9a281db Fabrice Bellard
/**
2167 e36bdf8b Daniel Kristjansson
 * Add a new stream to a media file.
2168 b9a281db Fabrice Bellard
 *
2169 e36bdf8b Daniel Kristjansson
 * Can only be called in the read_header() function. If the flag
2170
 * AVFMTCTX_NOHEADER is in the format context, then new streams
2171
 * can be added in read_packet too.
2172 b9a281db Fabrice Bellard
 *
2173
 * @param s media file handle
2174 115329f1 Diego Biurrun
 * @param id file format dependent stream id
2175 b9a281db Fabrice Bellard
 */
2176
AVStream *av_new_stream(AVFormatContext *s, int id)
2177
{
2178
    AVStream *st;
2179
2180
    if (s->nb_streams >= MAX_STREAMS)
2181
        return NULL;
2182
2183
    st = av_mallocz(sizeof(AVStream));
2184
    if (!st)
2185
        return NULL;
2186 115329f1 Diego Biurrun
2187 01f4895c Michael Niedermayer
    st->codec= avcodec_alloc_context();
2188 48091512 Fabrice Bellard
    if (s->iformat) {
2189
        /* no default bitrate if decoding */
2190 01f4895c Michael Niedermayer
        st->codec->bit_rate = 0;
2191 48091512 Fabrice Bellard
    }
2192 b9a281db Fabrice Bellard
    st->index = s->nb_streams;
2193
    st->id = id;
2194 12f996ed Fabrice Bellard
    st->start_time = AV_NOPTS_VALUE;
2195
    st->duration = AV_NOPTS_VALUE;
2196 e928649b Michael Niedermayer
    st->cur_dts = AV_NOPTS_VALUE;
2197 9ee91c2f Michael Niedermayer
2198
    /* default pts settings is MPEG like */
2199
    av_set_pts_info(st, 33, 1, 90000);
2200 77405fc8 Michael Niedermayer
    st->last_IP_pts = AV_NOPTS_VALUE;
2201 9ee91c2f Michael Niedermayer
2202 b9a281db Fabrice Bellard
    s->streams[s->nb_streams++] = st;
2203
    return st;
2204
}
2205
2206
/************************************************************/
2207
/* output media file */
2208 de6d9b64 Fabrice Bellard
2209 87a0a681 Fabrice Bellard
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2210
{
2211
    int ret;
2212 115329f1 Diego Biurrun
2213 98486a6b Roman Shaposhnik
    if (s->oformat->priv_data_size > 0) {
2214
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2215
        if (!s->priv_data)
2216
            return AVERROR_NOMEM;
2217
    } else
2218
        s->priv_data = NULL;
2219 115329f1 Diego Biurrun
2220 87a0a681 Fabrice Bellard
    if (s->oformat->set_parameters) {
2221
        ret = s->oformat->set_parameters(s, ap);
2222
        if (ret < 0)
2223
            return ret;
2224
    }
2225
    return 0;
2226
}
2227
2228 b9a281db Fabrice Bellard
/**
2229
 * allocate the stream private data and write the stream header to an
2230
 * output media file
2231
 *
2232
 * @param s media file handle
2233 115329f1 Diego Biurrun
 * @return 0 if OK. AVERROR_xxx if error.
2234 b9a281db Fabrice Bellard
 */
2235
int av_write_header(AVFormatContext *s)
2236
{
2237 1e51d801 Fabrice Bellard
    int ret, i;
2238
    AVStream *st;
2239
2240 9450118b Michael Niedermayer
    // some sanity checks
2241
    for(i=0;i<s->nb_streams;i++) {
2242
        st = s->streams[i];
2243
2244
        switch (st->codec->codec_type) {
2245
        case CODEC_TYPE_AUDIO:
2246
            if(st->codec->sample_rate<=0){
2247
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2248
                return -1;
2249
            }
2250
            break;
2251
        case CODEC_TYPE_VIDEO:
2252
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2253
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2254
                return -1;
2255
            }
2256
            if(st->codec->width<=0 || st->codec->height<=0){
2257
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2258
                return -1;
2259
            }
2260
            break;
2261
        }
2262
    }
2263
2264 31e11451 Michael Niedermayer
    if(s->oformat->write_header){
2265
        ret = s->oformat->write_header(s);
2266
        if (ret < 0)
2267
            return ret;
2268
    }
2269 1e51d801 Fabrice Bellard
2270
    /* init PTS generation */
2271
    for(i=0;i<s->nb_streams;i++) {
2272 f0ff20a1 Wolfram Gloger
        int64_t den = AV_NOPTS_VALUE;
2273 1e51d801 Fabrice Bellard
        st = s->streams[i];
2274
2275 01f4895c Michael Niedermayer
        switch (st->codec->codec_type) {
2276 1e51d801 Fabrice Bellard
        case CODEC_TYPE_AUDIO:
2277 f0ff20a1 Wolfram Gloger
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2278 1e51d801 Fabrice Bellard
            break;
2279
        case CODEC_TYPE_VIDEO:
2280 f0ff20a1 Wolfram Gloger
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2281 1e51d801 Fabrice Bellard
            break;
2282
        default:
2283
            break;
2284
        }
2285 f0ff20a1 Wolfram Gloger
        if (den != AV_NOPTS_VALUE) {
2286
            if (den <= 0)
2287
                return AVERROR_INVALIDDATA;
2288
            av_frac_init(&st->pts, 0, 0, den);
2289
        }
2290 1e51d801 Fabrice Bellard
    }
2291
    return 0;
2292 b9a281db Fabrice Bellard
}
2293
2294 3c895fc0 Michael Niedermayer
//FIXME merge with compute_pkt_fields
2295 5edea431 Michael Niedermayer
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2296 01f4895c Michael Niedermayer
    int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2297 3c895fc0 Michael Niedermayer
    int num, den, frame_size;
2298 b0c7f5a9 Michael Niedermayer
2299 3c895fc0 Michael Niedermayer
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
2300 115329f1 Diego Biurrun
2301 e928649b Michael Niedermayer
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2302
        return -1;*/
2303 115329f1 Diego Biurrun
2304 e928649b Michael Niedermayer
    /* duration field */
2305 3c895fc0 Michael Niedermayer
    if (pkt->duration == 0) {
2306
        compute_frame_duration(&num, &den, st, NULL, pkt);
2307
        if (den && num) {
2308
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2309
        }
2310
    }
2311 e928649b Michael Niedermayer
2312
    //XXX/FIXME this is a temporary hack until all encoders output pts
2313
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2314
        pkt->dts=
2315
//        pkt->pts= st->cur_dts;
2316
        pkt->pts= st->pts.val;
2317
    }
2318
2319 115329f1 Diego Biurrun
    //calculate dts from pts
2320 e928649b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2321
        if(b_frames){
2322
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2323 3c895fc0 Michael Niedermayer
                st->last_IP_pts= -pkt->duration;
2324 e928649b Michael Niedermayer
            }
2325
            if(st->last_IP_pts < pkt->pts){
2326
                pkt->dts= st->last_IP_pts;
2327
                st->last_IP_pts= pkt->pts;
2328
            }else
2329
                pkt->dts= pkt->pts;
2330
        }else
2331
            pkt->dts= pkt->pts;
2332
    }
2333 115329f1 Diego Biurrun
2334 5edea431 Michael Niedermayer
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2335 4733abcb Måns Rullgård
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2336 5edea431 Michael Niedermayer
        return -1;
2337
    }
2338
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2339
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2340
        return -1;
2341
    }
2342
2343 3c895fc0 Michael Niedermayer
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2344 e928649b Michael Niedermayer
    st->cur_dts= pkt->dts;
2345
    st->pts.val= pkt->dts;
2346
2347 1e51d801 Fabrice Bellard
    /* update pts */
2348 01f4895c Michael Niedermayer
    switch (st->codec->codec_type) {
2349 1e51d801 Fabrice Bellard
    case CODEC_TYPE_AUDIO:
2350 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2351 6d8f985e Michael Niedermayer
2352 b0c7f5a9 Michael Niedermayer
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2353 6d8f985e Michael Niedermayer
           but it would be better if we had the real timestamps from the encoder */
2354 e928649b Michael Niedermayer
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2355 9ee91c2f Michael Niedermayer
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2356 7feb950a Fabrice Bellard
        }
2357 1e51d801 Fabrice Bellard
        break;
2358
    case CODEC_TYPE_VIDEO:
2359 01f4895c Michael Niedermayer
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2360 1e51d801 Fabrice Bellard
        break;
2361
    default:
2362
        break;
2363
    }
2364 5edea431 Michael Niedermayer
    return 0;
2365 3c895fc0 Michael Niedermayer
}
2366
2367
static void truncate_ts(AVStream *st, AVPacket *pkt){
2368
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2369 115329f1 Diego Biurrun
2370 e0c91bc2 Michael Niedermayer
//    if(pkt->dts < 0)
2371
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2372 115329f1 Diego Biurrun
2373 3c895fc0 Michael Niedermayer
    pkt->pts &= pts_mask;
2374
    pkt->dts &= pts_mask;
2375
}
2376
2377
/**
2378 e36bdf8b Daniel Kristjansson
 * Write a packet to an output media file.
2379
 *
2380
 * The packet shall contain one audio or video frame.
2381 3c895fc0 Michael Niedermayer
 *
2382
 * @param s media file handle
2383
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2384
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2385
 */
2386
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2387
{
2388 576ae256 Michael Niedermayer
    int ret;
2389
2390 5edea431 Michael Niedermayer
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2391
    if(ret<0)
2392
        return ret;
2393 115329f1 Diego Biurrun
2394 3c895fc0 Michael Niedermayer
    truncate_ts(s->streams[pkt->stream_index], pkt);
2395
2396 576ae256 Michael Niedermayer
    ret= s->oformat->write_packet(s, pkt);
2397
    if(!ret)
2398
        ret= url_ferror(&s->pb);
2399
    return ret;
2400 3c895fc0 Michael Niedermayer
}
2401
2402
/**
2403 fe2d6fe2 Michael Niedermayer
 * interleave_packet implementation which will interleave per DTS.
2404 115329f1 Diego Biurrun
 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2405 2577897d Michael Niedermayer
 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2406 fe2d6fe2 Michael Niedermayer
 */
2407
static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2408
    AVPacketList *pktl, **next_point, *this_pktl;
2409
    int stream_count=0;
2410
    int streams[MAX_STREAMS];
2411
2412
    if(pkt){
2413
        AVStream *st= s->streams[ pkt->stream_index];
2414
2415 2577897d Michael Niedermayer
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2416 fe2d6fe2 Michael Niedermayer
2417
        this_pktl = av_mallocz(sizeof(AVPacketList));
2418
        this_pktl->pkt= *pkt;
2419 2577897d Michael Niedermayer
        if(pkt->destruct == av_destruct_packet)
2420
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2421
        else
2422
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2423 fe2d6fe2 Michael Niedermayer
2424
        next_point = &s->packet_buffer;
2425
        while(*next_point){
2426
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2427
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2428
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2429
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2430
                break;
2431
            next_point= &(*next_point)->next;
2432
        }
2433
        this_pktl->next= *next_point;
2434
        *next_point= this_pktl;
2435
    }
2436 115329f1 Diego Biurrun
2437 fe2d6fe2 Michael Niedermayer
    memset(streams, 0, sizeof(streams));
2438
    pktl= s->packet_buffer;
2439
    while(pktl){
2440
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2441
        if(streams[ pktl->pkt.stream_index ] == 0)
2442
            stream_count++;
2443
        streams[ pktl->pkt.stream_index ]++;
2444
        pktl= pktl->next;
2445
    }
2446 115329f1 Diego Biurrun
2447 fe2d6fe2 Michael Niedermayer
    if(s->nb_streams == stream_count || (flush && stream_count)){
2448
        pktl= s->packet_buffer;
2449
        *out= pktl->pkt;
2450 115329f1 Diego Biurrun
2451
        s->packet_buffer= pktl->next;
2452 fe2d6fe2 Michael Niedermayer
        av_freep(&pktl);
2453
        return 1;
2454
    }else{
2455
        av_init_packet(out);
2456
        return 0;
2457
    }
2458
}
2459
2460
/**
2461
 * Interleaves a AVPacket correctly so it can be muxed.
2462
 * @param out the interleaved packet will be output here
2463
 * @param in the input packet
2464
 * @param flush 1 if no further packets are available as input and all
2465
 *              remaining packets should be output
2466 115329f1 Diego Biurrun
 * @return 1 if a packet was output, 0 if no packet could be output,
2467 fe2d6fe2 Michael Niedermayer
 *         < 0 if an error occured
2468
 */
2469
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2470
    if(s->oformat->interleave_packet)
2471
        return s->oformat->interleave_packet(s, out, in, flush);
2472
    else
2473
        return av_interleave_packet_per_dts(s, out, in, flush);
2474
}
2475
2476
/**
2477 e36bdf8b Daniel Kristjansson
 * Writes a packet to an output media file ensuring correct interleaving.
2478
 *
2479
 * The packet must contain one audio or video frame.
2480 3c895fc0 Michael Niedermayer
 * If the packets are already correctly interleaved the application should
2481
 * call av_write_frame() instead as its slightly faster, its also important
2482 fe2d6fe2 Michael Niedermayer
 * to keep in mind that completly non interleaved input will need huge amounts
2483 3c895fc0 Michael Niedermayer
 * of memory to interleave with this, so its prefereable to interleave at the
2484
 * demuxer level
2485
 *
2486
 * @param s media file handle
2487
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2488
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2489
 */
2490
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2491
    AVStream *st= s->streams[ pkt->stream_index];
2492
2493 6f824977 Michael Niedermayer
    //FIXME/XXX/HACK drop zero sized packets
2494 01f4895c Michael Niedermayer
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2495 6f824977 Michael Niedermayer
        return 0;
2496 3ce16b30 Michael Niedermayer
2497
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2498
    if(compute_pkt_fields2(st, pkt) < 0)
2499
        return -1;
2500 115329f1 Diego Biurrun
2501 3c895fc0 Michael Niedermayer
    if(pkt->dts == AV_NOPTS_VALUE)
2502
        return -1;
2503
2504 fe2d6fe2 Michael Niedermayer
    for(;;){
2505
        AVPacket opkt;
2506
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2507
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2508
            return ret;
2509 115329f1 Diego Biurrun
2510 fe2d6fe2 Michael Niedermayer
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2511
        ret= s->oformat->write_packet(s, &opkt);
2512 115329f1 Diego Biurrun
2513 fe2d6fe2 Michael Niedermayer
        av_free_packet(&opkt);
2514
        pkt= NULL;
2515 115329f1 Diego Biurrun
2516 3c895fc0 Michael Niedermayer
        if(ret<0)
2517
            return ret;
2518 576ae256 Michael Niedermayer
        if(url_ferror(&s->pb))
2519
            return url_ferror(&s->pb);
2520 3c895fc0 Michael Niedermayer
    }
2521 b9a281db Fabrice Bellard
}
2522
2523
/**
2524 e36bdf8b Daniel Kristjansson
 * @brief Write the stream trailer to an output media file and
2525
 *        free the file private data.
2526 b9a281db Fabrice Bellard
 *
2527
 * @param s media file handle
2528 e36bdf8b Daniel Kristjansson
 * @return 0 if OK. AVERROR_xxx if error.
2529
 */
2530 b9a281db Fabrice Bellard
int av_write_trailer(AVFormatContext *s)
2531
{
2532 c40a3a42 Michael Niedermayer
    int ret, i;
2533 115329f1 Diego Biurrun
2534 fe2d6fe2 Michael Niedermayer
    for(;;){
2535
        AVPacket pkt;
2536
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2537
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2538 c40a3a42 Michael Niedermayer
            goto fail;
2539 fe2d6fe2 Michael Niedermayer
        if(!ret)
2540
            break;
2541 115329f1 Diego Biurrun
2542 fe2d6fe2 Michael Niedermayer
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2543
        ret= s->oformat->write_packet(s, &pkt);
2544 115329f1 Diego Biurrun
2545 fe2d6fe2 Michael Niedermayer
        av_free_packet(&pkt);
2546 115329f1 Diego Biurrun
2547 3c895fc0 Michael Niedermayer
        if(ret<0)
2548 c40a3a42 Michael Niedermayer
            goto fail;
2549 576ae256 Michael Niedermayer
        if(url_ferror(&s->pb))
2550
            goto fail;
2551 3c895fc0 Michael Niedermayer
    }
2552
2553 31e11451 Michael Niedermayer
    if(s->oformat->write_trailer)
2554
        ret = s->oformat->write_trailer(s);
2555 c40a3a42 Michael Niedermayer
fail:
2556 576ae256 Michael Niedermayer
    if(ret == 0)
2557
       ret=url_ferror(&s->pb);
2558 c40a3a42 Michael Niedermayer
    for(i=0;i<s->nb_streams;i++)
2559
        av_freep(&s->streams[i]->priv_data);
2560 b9a281db Fabrice Bellard
    av_freep(&s->priv_data);
2561
    return ret;
2562 de6d9b64 Fabrice Bellard
}
2563
2564
/* "user interface" functions */
2565
2566
void dump_format(AVFormatContext *ic,
2567 115329f1 Diego Biurrun
                 int index,
2568 de6d9b64 Fabrice Bellard
                 const char *url,
2569
                 int is_output)
2570
{
2571 b9a281db Fabrice Bellard
    int i, flags;
2572 de6d9b64 Fabrice Bellard
    char buf[256];
2573
2574 115329f1 Diego Biurrun
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2575 de6d9b64 Fabrice Bellard
            is_output ? "Output" : "Input",
2576 115329f1 Diego Biurrun
            index,
2577
            is_output ? ic->oformat->name : ic->iformat->name,
2578 de6d9b64 Fabrice Bellard
            is_output ? "to" : "from", url);
2579 12f996ed Fabrice Bellard
    if (!is_output) {
2580 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2581 12f996ed Fabrice Bellard
        if (ic->duration != AV_NOPTS_VALUE) {
2582
            int hours, mins, secs, us;
2583
            secs = ic->duration / AV_TIME_BASE;
2584
            us = ic->duration % AV_TIME_BASE;
2585
            mins = secs / 60;
2586
            secs %= 60;
2587
            hours = mins / 60;
2588
            mins %= 60;
2589 115329f1 Diego Biurrun
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2590 12f996ed Fabrice Bellard
                   (10 * us) / AV_TIME_BASE);
2591
        } else {
2592 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "N/A");
2593 12f996ed Fabrice Bellard
        }
2594 d0f3f159 Wolfram Gloger
        if (ic->start_time != AV_NOPTS_VALUE) {
2595
            int secs, us;
2596 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", start: ");
2597 d0f3f159 Wolfram Gloger
            secs = ic->start_time / AV_TIME_BASE;
2598
            us = ic->start_time % AV_TIME_BASE;
2599 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2600 d0f3f159 Wolfram Gloger
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2601
        }
2602 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2603 12f996ed Fabrice Bellard
        if (ic->bit_rate) {
2604 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2605 12f996ed Fabrice Bellard
        } else {
2606 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "N/A");
2607 12f996ed Fabrice Bellard
        }
2608 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, "\n");
2609 12f996ed Fabrice Bellard
    }
2610 de6d9b64 Fabrice Bellard
    for(i=0;i<ic->nb_streams;i++) {
2611
        AVStream *st = ic->streams[i];
2612 21189011 Michael Niedermayer
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2613 01f4895c Michael Niedermayer
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2614 2143116d Michael Niedermayer
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2615 b9a281db Fabrice Bellard
        /* the pid is an important information, so we display it */
2616
        /* XXX: add a generic system */
2617
        if (is_output)
2618
            flags = ic->oformat->flags;
2619
        else
2620
            flags = ic->iformat->flags;
2621
        if (flags & AVFMT_SHOW_IDS) {
2622 2143116d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2623 b9a281db Fabrice Bellard
        }
2624 c6ec28b1 Michael Niedermayer
        if (strlen(st->language) > 0) {
2625
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2626
        }
2627 21189011 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2628 47dd81c7 Baptiste Coudurier
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2629 21189011 Michael Niedermayer
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2630 780eb1c9 Michael Niedermayer
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2631
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2632
/*            else if(st->time_base.den && st->time_base.num)
2633
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2634
            else
2635
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2636 21189011 Michael Niedermayer
        }
2637 47dd81c7 Baptiste Coudurier
        av_log(NULL, AV_LOG_INFO, "\n");
2638 de6d9b64 Fabrice Bellard
    }
2639
}
2640
2641
typedef struct {
2642 445f1b83 Roman Shaposhnik
    const char *abv;
2643 de6d9b64 Fabrice Bellard
    int width, height;
2644 445f1b83 Roman Shaposhnik
    int frame_rate, frame_rate_base;
2645
} AbvEntry;
2646
2647
static AbvEntry frame_abvs[] = {
2648 ba2a8cb4 Roman Shaposhnik
    { "ntsc",      720, 480, 30000, 1001 },
2649
    { "pal",       720, 576,    25,    1 },
2650
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2651
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2652 904736b5 Roman Shaposhnik
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2653
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2654 445f1b83 Roman Shaposhnik
    { "film",      352, 240,    24,    1 },
2655
    { "ntsc-film", 352, 240, 24000, 1001 },
2656
    { "sqcif",     128,  96,     0,    0 },
2657
    { "qcif",      176, 144,     0,    0 },
2658
    { "cif",       352, 288,     0,    0 },
2659
    { "4cif",      704, 576,     0,    0 },
2660 de6d9b64 Fabrice Bellard
};
2661 445f1b83 Roman Shaposhnik
2662 e36bdf8b Daniel Kristjansson
/**
2663
 * parses width and height out of string str.
2664
 */
2665 de6d9b64 Fabrice Bellard
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2666
{
2667
    int i;
2668 445f1b83 Roman Shaposhnik
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2669 de6d9b64 Fabrice Bellard
    const char *p;
2670
    int frame_width = 0, frame_height = 0;
2671
2672
    for(i=0;i<n;i++) {
2673 445f1b83 Roman Shaposhnik
        if (!strcmp(frame_abvs[i].abv, str)) {
2674
            frame_width = frame_abvs[i].width;
2675
            frame_height = frame_abvs[i].height;
2676 de6d9b64 Fabrice Bellard
            break;
2677
        }
2678
    }
2679
    if (i == n) {
2680
        p = str;
2681
        frame_width = strtol(p, (char **)&p, 10);
2682
        if (*p)
2683
            p++;
2684
        frame_height = strtol(p, (char **)&p, 10);
2685
    }
2686
    if (frame_width <= 0 || frame_height <= 0)
2687
        return -1;
2688
    *width_ptr = frame_width;
2689
    *height_ptr = frame_height;
2690
    return 0;
2691
}
2692
2693 e36bdf8b Daniel Kristjansson
/**
2694
 * Converts frame rate from string to a fraction.
2695
 *
2696
 * First we try to get an exact integer or fractional frame rate.
2697
 * If this fails we convert the frame rate to a double and return
2698
 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2699
 */
2700 445f1b83 Roman Shaposhnik
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2701
{
2702
    int i;
2703
    char* cp;
2704 115329f1 Diego Biurrun
2705 445f1b83 Roman Shaposhnik
    /* First, we check our abbreviation table */
2706
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2707
         if (!strcmp(frame_abvs[i].abv, arg)) {
2708 bb270c08 Diego Biurrun
             *frame_rate = frame_abvs[i].frame_rate;
2709
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2710
             return 0;
2711
         }
2712 445f1b83 Roman Shaposhnik
2713
    /* Then, we try to parse it as fraction */
2714
    cp = strchr(arg, '/');
2715 88805317 Roine Gustafsson
    if (!cp)
2716
        cp = strchr(arg, ':');
2717 445f1b83 Roman Shaposhnik
    if (cp) {
2718
        char* cpp;
2719 bb270c08 Diego Biurrun
        *frame_rate = strtol(arg, &cpp, 10);
2720
        if (cpp != arg || cpp == cp)
2721
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2722
        else
2723
           *frame_rate = 0;
2724 115329f1 Diego Biurrun
    }
2725 445f1b83 Roman Shaposhnik
    else {
2726
        /* Finally we give up and parse it as double */
2727 67dd33f9 Baptiste Coudurier
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2728
        *frame_rate_base = time_base.den;
2729
        *frame_rate = time_base.num;
2730 445f1b83 Roman Shaposhnik
    }
2731
    if (!*frame_rate || !*frame_rate_base)
2732
        return -1;
2733
    else
2734
        return 0;
2735
}
2736
2737 e36bdf8b Daniel Kristjansson
/**
2738
 * Converts date string to number of seconds since Jan 1st, 1970.
2739
 *
2740
 * @code
2741
 * Syntax:
2742 916c80e9 Fabrice Bellard
 * - If not a duration:
2743
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2744 c5510dd6 Philip Gladstone
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2745 115329f1 Diego Biurrun
 * Return the date in micro seconds since 1970
2746 e36bdf8b Daniel Kristjansson
 *
2747
 * - If a duration:
2748 916c80e9 Fabrice Bellard
 *  HH[:MM[:SS[.m...]]]
2749
 *  S+[.m...]
2750 e36bdf8b Daniel Kristjansson
 * @endcode
2751 916c80e9 Fabrice Bellard
 */
2752 ac44871c Gildas Bazin
#ifndef CONFIG_WINCE
2753 0c1a9eda Zdenek Kabelac
int64_t parse_date(const char *datestr, int duration)
2754 de6d9b64 Fabrice Bellard
{
2755
    const char *p;
2756 0c1a9eda Zdenek Kabelac
    int64_t t;
2757 2dbceb9f Philip Gladstone
    struct tm dt;
2758 c5510dd6 Philip Gladstone
    int i;
2759
    static const char *date_fmt[] = {
2760
        "%Y-%m-%d",
2761
        "%Y%m%d",
2762
    };
2763
    static const char *time_fmt[] = {
2764
        "%H:%M:%S",
2765
        "%H%M%S",
2766
    };
2767
    const char *q;
2768 916c80e9 Fabrice Bellard
    int is_utc, len;
2769 c5510dd6 Philip Gladstone
    char lastch;
2770 a6a92a9a Wolfram Gloger
    int negative = 0;
2771 6d8f985e Michael Niedermayer
2772
#undef time
2773 c5510dd6 Philip Gladstone
    time_t now = time(0);
2774
2775 916c80e9 Fabrice Bellard
    len = strlen(datestr);
2776
    if (len > 0)
2777
        lastch = datestr[len - 1];
2778
    else
2779
        lastch = '\0';
2780 c5510dd6 Philip Gladstone
    is_utc = (lastch == 'z' || lastch == 'Z');
2781 2dbceb9f Philip Gladstone
2782
    memset(&dt, 0, sizeof(dt));
2783 de6d9b64 Fabrice Bellard
2784
    p = datestr;
2785 916c80e9 Fabrice Bellard
    q = NULL;
2786 de6d9b64 Fabrice Bellard
    if (!duration) {
2787 c5510dd6 Philip Gladstone
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2788 f71869a4 Fabrice Bellard
            q = small_strptime(p, date_fmt[i], &dt);
2789 c5510dd6 Philip Gladstone
            if (q) {
2790
                break;
2791
            }
2792
        }
2793
2794
        if (!q) {
2795
            if (is_utc) {
2796
                dt = *gmtime(&now);
2797
            } else {
2798
                dt = *localtime(&now);
2799
            }
2800
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2801 de6d9b64 Fabrice Bellard
        } else {
2802 c5510dd6 Philip Gladstone
            p = q;
2803 de6d9b64 Fabrice Bellard
        }
2804 c5510dd6 Philip Gladstone
2805
        if (*p == 'T' || *p == 't' || *p == ' ')
2806
            p++;
2807
2808 916c80e9 Fabrice Bellard
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2809 f71869a4 Fabrice Bellard
            q = small_strptime(p, time_fmt[i], &dt);
2810 916c80e9 Fabrice Bellard
            if (q) {
2811
                break;
2812
            }
2813
        }
2814
    } else {
2815 bb270c08 Diego Biurrun
        if (p[0] == '-') {
2816
            negative = 1;
2817
            ++p;
2818
        }
2819 f71869a4 Fabrice Bellard
        q = small_strptime(p, time_fmt[0], &dt);
2820 916c80e9 Fabrice Bellard
        if (!q) {
2821
            dt.tm_sec = strtol(p, (char **)&q, 10);
2822
            dt.tm_min = 0;
2823
            dt.tm_hour = 0;
2824 c5510dd6 Philip Gladstone
        }
2825
    }
2826
2827
    /* Now we have all the fields that we can get */
2828
    if (!q) {
2829
        if (duration)
2830
            return 0;
2831
        else
2832 0c1a9eda Zdenek Kabelac
            return now * int64_t_C(1000000);
2833