Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 75b5b631

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

1428
    if (stream_index < 0)
1429
        return -1;
1430

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