Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 20b02bc6

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

1265
    if (stream_index < 0)
1266
        return -1;
1267

1268
    st= s->streams[stream_index];
1269
#endif
1270
1271
    pos_min = s->data_offset;
1272
    pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1273
1274
    if     (pos < pos_min) pos= pos_min;
1275
    else if(pos > pos_max) pos= pos_max;
1276
1277
    url_fseek(&s->pb, pos, SEEK_SET);
1278
1279
#if 0
1280 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ts);
1281 3ba1438d Michael Niedermayer
#endif
1282
    return 0;
1283
}
1284
1285 fb2758c8 Fabrice Bellard
static int av_seek_frame_generic(AVFormatContext *s, 
1286 3ba1438d Michael Niedermayer
                                 int stream_index, int64_t timestamp, int flags)
1287 fb2758c8 Fabrice Bellard
{
1288 8bcb147f Michael Niedermayer
    int index;
1289 fb2758c8 Fabrice Bellard
    AVStream *st;
1290
    AVIndexEntry *ie;
1291
1292
    if (!s->index_built) {
1293
        if (is_raw_stream(s)) {
1294
            av_build_index_raw(s);
1295
        } else {
1296
            return -1;
1297
        }
1298
        s->index_built = 1;
1299
    }
1300
1301
    st = s->streams[stream_index];
1302 3ba1438d Michael Niedermayer
    index = av_index_search_timestamp(st, timestamp, flags & AVSEEK_FLAG_BACKWARD);
1303 fb2758c8 Fabrice Bellard
    if (index < 0)
1304
        return -1;
1305
1306
    /* now we have found the index, we can seek */
1307
    ie = &st->index_entries[index];
1308
    av_read_frame_flush(s);
1309
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1310 3ba1438d Michael Niedermayer
1311 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ie->timestamp);
1312 cdd5034f Michael Niedermayer
1313 fb2758c8 Fabrice Bellard
    return 0;
1314
}
1315
1316
/**
1317 3ba1438d Michael Niedermayer
 * Seek to the key frame at timestamp.
1318 cdd5034f Michael Niedermayer
 * 'timestamp' in 'stream_index'.
1319
 * @param stream_index If stream_index is (-1), a default
1320 eb497825 Nathan Kurz
 * stream is selected, and timestamp is automatically converted 
1321
 * from AV_TIME_BASE units to the stream specific time_base.
1322 3ba1438d Michael Niedermayer
 * @param timestamp timestamp in AVStream.time_base units
1323
 * @param flags flags which select direction and seeking mode
1324 cdd5034f Michael Niedermayer
 * @return >= 0 on success
1325 fb2758c8 Fabrice Bellard
 */
1326 3ba1438d Michael Niedermayer
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1327 fb2758c8 Fabrice Bellard
{
1328
    int ret;
1329 cdd5034f Michael Niedermayer
    AVStream *st;
1330 fb2758c8 Fabrice Bellard
    
1331
    av_read_frame_flush(s);
1332 cdd5034f Michael Niedermayer
    
1333 3ba1438d Michael Niedermayer
    if(flags & AVSEEK_FLAG_BYTE)
1334
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1335
    
1336 cdd5034f Michael Niedermayer
    if(stream_index < 0){
1337
        stream_index= av_find_default_stream_index(s);
1338
        if(stream_index < 0)
1339
            return -1;
1340 3ba1438d Michael Niedermayer
            
1341
        st= s->streams[stream_index];
1342 eb497825 Nathan Kurz
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1343 3ba1438d Michael Niedermayer
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1344 cdd5034f Michael Niedermayer
    }
1345
    st= s->streams[stream_index];
1346
1347 fb2758c8 Fabrice Bellard
    /* first, we try the format specific seek */
1348
    if (s->iformat->read_seek)
1349 3ba1438d Michael Niedermayer
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1350 fb2758c8 Fabrice Bellard
    else
1351
        ret = -1;
1352
    if (ret >= 0) {
1353
        return 0;
1354
    }
1355 8d14a25c Michael Niedermayer
1356
    if(s->iformat->read_timestamp)
1357 3ba1438d Michael Niedermayer
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1358 8d14a25c Michael Niedermayer
    else
1359 3ba1438d Michael Niedermayer
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1360 fb2758c8 Fabrice Bellard
}
1361
1362
/*******************************************************/
1363 12f996ed Fabrice Bellard
1364
/* return TRUE if the stream has accurate timings for at least one component */
1365
static int av_has_timings(AVFormatContext *ic)
1366
{
1367
    int i;
1368
    AVStream *st;
1369
1370
    for(i = 0;i < ic->nb_streams; i++) {
1371
        st = ic->streams[i];
1372
        if (st->start_time != AV_NOPTS_VALUE &&
1373
            st->duration != AV_NOPTS_VALUE)
1374
            return 1;
1375
    }
1376
    return 0;
1377
}
1378
1379
/* estimate the stream timings from the one of each components. Also
1380
   compute the global bitrate if possible */
1381
static void av_update_stream_timings(AVFormatContext *ic)
1382
{
1383
    int64_t start_time, end_time, end_time1;
1384
    int i;
1385
    AVStream *st;
1386
1387
    start_time = MAXINT64;
1388
    end_time = MININT64;
1389
    for(i = 0;i < ic->nb_streams; i++) {
1390
        st = ic->streams[i];
1391
        if (st->start_time != AV_NOPTS_VALUE) {
1392
            if (st->start_time < start_time)
1393
                start_time = st->start_time;
1394
            if (st->duration != AV_NOPTS_VALUE) {
1395
                end_time1 = st->start_time + st->duration;
1396
                if (end_time1 > end_time)
1397
                    end_time = end_time1;
1398
            }
1399
        }
1400
    }
1401
    if (start_time != MAXINT64) {
1402
        ic->start_time = start_time;
1403
        if (end_time != MAXINT64) {
1404
            ic->duration = end_time - start_time;
1405
            if (ic->file_size > 0) {
1406
                /* compute the bit rate */
1407
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1408
                    (double)ic->duration;
1409
            }
1410
        }
1411
    }
1412
1413
}
1414
1415
static void fill_all_stream_timings(AVFormatContext *ic)
1416
{
1417
    int i;
1418
    AVStream *st;
1419
1420
    av_update_stream_timings(ic);
1421
    for(i = 0;i < ic->nb_streams; i++) {
1422
        st = ic->streams[i];
1423
        if (st->start_time == AV_NOPTS_VALUE) {
1424
            st->start_time = ic->start_time;
1425
            st->duration = ic->duration;
1426
        }
1427
    }
1428
}
1429
1430
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1431
{
1432
    int64_t filesize, duration;
1433
    int bit_rate, i;
1434
    AVStream *st;
1435
1436
    /* if bit_rate is already set, we believe it */
1437
    if (ic->bit_rate == 0) {
1438
        bit_rate = 0;
1439
        for(i=0;i<ic->nb_streams;i++) {
1440
            st = ic->streams[i];
1441
            bit_rate += st->codec.bit_rate;
1442
        }
1443
        ic->bit_rate = bit_rate;
1444
    }
1445
1446
    /* if duration is already set, we believe it */
1447
    if (ic->duration == AV_NOPTS_VALUE && 
1448
        ic->bit_rate != 0 && 
1449
        ic->file_size != 0)  {
1450
        filesize = ic->file_size;
1451
        if (filesize > 0) {
1452
            duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1453
            for(i = 0; i < ic->nb_streams; i++) {
1454
                st = ic->streams[i];
1455
                if (st->start_time == AV_NOPTS_VALUE ||
1456
                    st->duration == AV_NOPTS_VALUE) {
1457
                    st->start_time = 0;
1458
                    st->duration = duration;
1459
                }
1460
            }
1461
        }
1462
    }
1463
}
1464
1465
#define DURATION_MAX_READ_SIZE 250000
1466
1467
/* only usable for MPEG-PS streams */
1468
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1469
{
1470
    AVPacket pkt1, *pkt = &pkt1;
1471
    AVStream *st;
1472
    int read_size, i, ret;
1473
    int64_t start_time, end_time, end_time1;
1474
    int64_t filesize, offset, duration;
1475
    
1476 fb2758c8 Fabrice Bellard
    /* free previous packet */
1477
    if (ic->cur_st && ic->cur_st->parser)
1478
        av_free_packet(&ic->cur_pkt); 
1479
    ic->cur_st = NULL;
1480
1481
    /* flush packet queue */
1482
    flush_packet_queue(ic);
1483
1484 0ff7199f Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
1485
        st = ic->streams[i];
1486
        if (st->parser) {
1487
            av_parser_close(st->parser);
1488
            st->parser= NULL;
1489
        }
1490
    }
1491
    
1492 12f996ed Fabrice Bellard
    /* we read the first packets to get the first PTS (not fully
1493
       accurate, but it is enough now) */
1494
    url_fseek(&ic->pb, 0, SEEK_SET);
1495
    read_size = 0;
1496
    for(;;) {
1497
        if (read_size >= DURATION_MAX_READ_SIZE)
1498
            break;
1499
        /* if all info is available, we can stop */
1500
        for(i = 0;i < ic->nb_streams; i++) {
1501
            st = ic->streams[i];
1502
            if (st->start_time == AV_NOPTS_VALUE)
1503
                break;
1504
        }
1505
        if (i == ic->nb_streams)
1506
            break;
1507
1508
        ret = av_read_packet(ic, pkt);
1509
        if (ret != 0)
1510
            break;
1511
        read_size += pkt->size;
1512
        st = ic->streams[pkt->stream_index];
1513
        if (pkt->pts != AV_NOPTS_VALUE) {
1514
            if (st->start_time == AV_NOPTS_VALUE)
1515 9ee91c2f Michael Niedermayer
                st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1516 0a5f92a1 Michael Niedermayer
        }
1517
        av_free_packet(pkt);
1518
    }
1519 12f996ed Fabrice Bellard
1520
    /* we compute the minimum start_time and use it as default */
1521
    start_time = MAXINT64;
1522
    for(i = 0; i < ic->nb_streams; i++) {
1523
        st = ic->streams[i];
1524
        if (st->start_time != AV_NOPTS_VALUE &&
1525
            st->start_time < start_time)
1526
            start_time = st->start_time;
1527
    }
1528
    if (start_time != MAXINT64)
1529
        ic->start_time = start_time;
1530
    
1531
    /* estimate the end time (duration) */
1532
    /* XXX: may need to support wrapping */
1533
    filesize = ic->file_size;
1534
    offset = filesize - DURATION_MAX_READ_SIZE;
1535
    if (offset < 0)
1536
        offset = 0;
1537
1538
    url_fseek(&ic->pb, offset, SEEK_SET);
1539
    read_size = 0;
1540
    for(;;) {
1541
        if (read_size >= DURATION_MAX_READ_SIZE)
1542
            break;
1543
        /* if all info is available, we can stop */
1544
        for(i = 0;i < ic->nb_streams; i++) {
1545
            st = ic->streams[i];
1546
            if (st->duration == AV_NOPTS_VALUE)
1547
                break;
1548
        }
1549
        if (i == ic->nb_streams)
1550
            break;
1551
        
1552
        ret = av_read_packet(ic, pkt);
1553
        if (ret != 0)
1554
            break;
1555
        read_size += pkt->size;
1556
        st = ic->streams[pkt->stream_index];
1557
        if (pkt->pts != AV_NOPTS_VALUE) {
1558 9ee91c2f Michael Niedermayer
            end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1559 12f996ed Fabrice Bellard
            duration = end_time - st->start_time;
1560
            if (duration > 0) {
1561
                if (st->duration == AV_NOPTS_VALUE ||
1562
                    st->duration < duration)
1563
                    st->duration = duration;
1564
            }
1565
        }
1566
        av_free_packet(pkt);
1567
    }
1568
    
1569
    /* estimate total duration */
1570
    end_time = MININT64;
1571
    for(i = 0;i < ic->nb_streams; i++) {
1572
        st = ic->streams[i];
1573
        if (st->duration != AV_NOPTS_VALUE) {
1574
            end_time1 = st->start_time + st->duration;
1575
            if (end_time1 > end_time)
1576
                end_time = end_time1;
1577
        }
1578
    }
1579
    
1580
    /* update start_time (new stream may have been created, so we do
1581
       it at the end */
1582
    if (ic->start_time != AV_NOPTS_VALUE) {
1583
        for(i = 0; i < ic->nb_streams; i++) {
1584
            st = ic->streams[i];
1585
            if (st->start_time == AV_NOPTS_VALUE)
1586
                st->start_time = ic->start_time;
1587
        }
1588
    }
1589
1590
    if (end_time != MININT64) {
1591
        /* put dummy values for duration if needed */
1592
        for(i = 0;i < ic->nb_streams; i++) {
1593
            st = ic->streams[i];
1594
            if (st->duration == AV_NOPTS_VALUE && 
1595
                st->start_time != AV_NOPTS_VALUE)
1596
                st->duration = end_time - st->start_time;
1597
        }
1598
        ic->duration = end_time - ic->start_time;
1599
    }
1600
1601
    url_fseek(&ic->pb, 0, SEEK_SET);
1602
}
1603
1604
static void av_estimate_timings(AVFormatContext *ic)
1605
{
1606
    URLContext *h;
1607
    int64_t file_size;
1608
1609
    /* get the file size, if possible */
1610
    if (ic->iformat->flags & AVFMT_NOFILE) {
1611
        file_size = 0;
1612
    } else {
1613
        h = url_fileno(&ic->pb);
1614
        file_size = url_filesize(h);
1615
        if (file_size < 0)
1616
            file_size = 0;
1617
    }
1618
    ic->file_size = file_size;
1619
1620
    if (ic->iformat == &mpegps_demux) {
1621
        /* get accurate estimate from the PTSes */
1622
        av_estimate_timings_from_pts(ic);
1623
    } else if (av_has_timings(ic)) {
1624
        /* at least one components has timings - we use them for all
1625
           the components */
1626
        fill_all_stream_timings(ic);
1627
    } else {
1628
        /* less precise: use bit rate info */
1629
        av_estimate_timings_from_bit_rate(ic);
1630
    }
1631
    av_update_stream_timings(ic);
1632
1633
#if 0
1634
    {
1635
        int i;
1636
        AVStream *st;
1637
        for(i = 0;i < ic->nb_streams; i++) {
1638
            st = ic->streams[i];
1639
        printf("%d: start_time: %0.3f duration: %0.3f\n", 
1640
               i, (double)st->start_time / AV_TIME_BASE, 
1641
               (double)st->duration / AV_TIME_BASE);
1642
        }
1643
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1644
               (double)ic->start_time / AV_TIME_BASE, 
1645
               (double)ic->duration / AV_TIME_BASE,
1646
               ic->bit_rate / 1000);
1647
    }
1648
#endif
1649
}
1650
1651 b9a281db Fabrice Bellard
static int has_codec_parameters(AVCodecContext *enc)
1652
{
1653
    int val;
1654
    switch(enc->codec_type) {
1655
    case CODEC_TYPE_AUDIO:
1656
        val = enc->sample_rate;
1657
        break;
1658
    case CODEC_TYPE_VIDEO:
1659
        val = enc->width;
1660
        break;
1661
    default:
1662
        val = 1;
1663
        break;
1664
    }
1665
    return (val != 0);
1666
}
1667
1668 fb2758c8 Fabrice Bellard
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1669
{
1670
    int16_t *samples;
1671
    AVCodec *codec;
1672
    int got_picture, ret;
1673
    AVFrame picture;
1674
    
1675
    codec = avcodec_find_decoder(st->codec.codec_id);
1676
    if (!codec)
1677
        return -1;
1678
    ret = avcodec_open(&st->codec, codec);
1679
    if (ret < 0)
1680
        return ret;
1681
    switch(st->codec.codec_type) {
1682
    case CODEC_TYPE_VIDEO:
1683
        ret = avcodec_decode_video(&st->codec, &picture, 
1684
                                   &got_picture, (uint8_t *)data, size);
1685
        break;
1686
    case CODEC_TYPE_AUDIO:
1687
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1688
        if (!samples)
1689
            goto fail;
1690
        ret = avcodec_decode_audio(&st->codec, samples, 
1691
                                   &got_picture, (uint8_t *)data, size);
1692
        av_free(samples);
1693
        break;
1694
    default:
1695
        break;
1696
    }
1697
 fail:
1698
    avcodec_close(&st->codec);
1699
    return ret;
1700
}
1701
1702
/* absolute maximum size we read until we abort */
1703
#define MAX_READ_SIZE        5000000
1704
1705
/* maximum duration until we stop analysing the stream */
1706
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1707
1708 b9a281db Fabrice Bellard
/**
1709
 * Read the beginning of a media file to get stream information. This
1710
 * is useful for file formats with no headers such as MPEG. This
1711
 * function also compute the real frame rate in case of mpeg2 repeat
1712
 * frame mode.
1713
 *
1714
 * @param ic media file handle
1715
 * @return >=0 if OK. AVERROR_xxx if error.  
1716
 */
1717
int av_find_stream_info(AVFormatContext *ic)
1718
{
1719 fb2758c8 Fabrice Bellard
    int i, count, ret, read_size;
1720 b9a281db Fabrice Bellard
    AVStream *st;
1721 fb2758c8 Fabrice Bellard
    AVPacket pkt1, *pkt;
1722 b9a281db Fabrice Bellard
    AVPacketList *pktl=NULL, **ppktl;
1723
1724
    count = 0;
1725
    read_size = 0;
1726
    ppktl = &ic->packet_buffer;
1727
    for(;;) {
1728
        /* check if one codec still needs to be handled */
1729
        for(i=0;i<ic->nb_streams;i++) {
1730
            st = ic->streams[i];
1731 fb2758c8 Fabrice Bellard
            if (!has_codec_parameters(&st->codec))
1732 b9a281db Fabrice Bellard
                break;
1733
        }
1734
        if (i == ic->nb_streams) {
1735
            /* NOTE: if the format has no header, then we need to read
1736
               some packets to get most of the streams, so we cannot
1737
               stop here */
1738 fb2758c8 Fabrice Bellard
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1739 b9a281db Fabrice Bellard
                /* if we found the info for all the codecs, we can stop */
1740
                ret = count;
1741
                break;
1742
            }
1743
        } else {
1744
            /* we did not get all the codec info, but we read too much data */
1745 fb2758c8 Fabrice Bellard
            if (read_size >= MAX_READ_SIZE) {
1746 b9a281db Fabrice Bellard
                ret = count;
1747
                break;
1748
            }
1749
        }
1750
1751 fb2758c8 Fabrice Bellard
        /* NOTE: a new stream can be added there if no header in file
1752
           (AVFMTCTX_NOHEADER) */
1753
        ret = av_read_frame_internal(ic, &pkt1);
1754
        if (ret < 0) {
1755
            /* EOF or error */
1756
            ret = -1; /* we could not have all the codec parameters before EOF */
1757
            if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1758
                i == ic->nb_streams)
1759
                ret = 0;
1760
            break;
1761
        }
1762
1763 b9a281db Fabrice Bellard
        pktl = av_mallocz(sizeof(AVPacketList));
1764
        if (!pktl) {
1765
            ret = AVERROR_NOMEM;
1766
            break;
1767
        }
1768
1769
        /* add the packet in the buffered packet list */
1770
        *ppktl = pktl;
1771
        ppktl = &pktl->next;
1772
1773
        pkt = &pktl->pkt;
1774 fb2758c8 Fabrice Bellard
        *pkt = pkt1;
1775
        
1776
        /* duplicate the packet */
1777
        if (av_dup_packet(pkt) < 0) {
1778
                ret = AVERROR_NOMEM;
1779
                break;
1780 b9a281db Fabrice Bellard
        }
1781
1782 fb2758c8 Fabrice Bellard
        read_size += pkt->size;
1783 b9a281db Fabrice Bellard
1784
        st = ic->streams[pkt->stream_index];
1785 fb2758c8 Fabrice Bellard
        st->codec_info_duration += pkt->duration;
1786
        if (pkt->duration != 0)
1787
            st->codec_info_nb_frames++;
1788
1789
        /* if still no information, we try to open the codec and to
1790
           decompress the frame. We try to avoid that in most cases as
1791
           it takes longer and uses more memory. For MPEG4, we need to
1792
           decompress for Quicktime. */
1793
        if (!has_codec_parameters(&st->codec) &&
1794
            (st->codec.codec_id == CODEC_ID_FLV1 ||
1795
             st->codec.codec_id == CODEC_ID_H264 ||
1796
             st->codec.codec_id == CODEC_ID_H263 ||
1797 61c7c3e3 Michael Niedermayer
             st->codec.codec_id == CODEC_ID_H261 ||
1798 8bfed902 Michael Niedermayer
             st->codec.codec_id == CODEC_ID_VORBIS ||
1799 03cfe134 Michael Niedermayer
             st->codec.codec_id == CODEC_ID_MJPEG ||
1800 4eff7cf4 Michael Niedermayer
             st->codec.codec_id == CODEC_ID_PNG ||
1801 5b6d5596 Michael Niedermayer
             st->codec.codec_id == CODEC_ID_PAM ||
1802
             st->codec.codec_id == CODEC_ID_PGM ||
1803
             st->codec.codec_id == CODEC_ID_PGMYUV ||
1804
             st->codec.codec_id == CODEC_ID_PBM ||
1805
             st->codec.codec_id == CODEC_ID_PPM ||
1806 fb2758c8 Fabrice Bellard
             (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1807
            try_decode_frame(st, pkt->data, pkt->size);
1808
        
1809
        if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1810
            break;
1811 b9a281db Fabrice Bellard
        }
1812
        count++;
1813
    }
1814
1815
    for(i=0;i<ic->nb_streams;i++) {
1816
        st = ic->streams[i];
1817
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1818 1b307feb Michael Niedermayer
            if(st->codec.codec_id == CODEC_ID_RAWVIDEO && !st->codec.codec_tag && !st->codec.bits_per_sample)
1819 d07730dd Michael Niedermayer
                st->codec.codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec.pix_fmt);
1820
            /* set real frame rate info */
1821 fb2758c8 Fabrice Bellard
            /* compute the real frame rate for telecine */
1822
            if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1823
                 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1824
                st->codec.sub_id == 2) {
1825
                if (st->codec_info_nb_frames >= 20) {
1826
                    float coded_frame_rate, est_frame_rate;
1827
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1828
                        (double)st->codec_info_duration ;
1829
                    coded_frame_rate = (double)st->codec.frame_rate /
1830
                        (double)st->codec.frame_rate_base;
1831
#if 0
1832
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1833
                           coded_frame_rate, est_frame_rate);
1834
#endif
1835
                    /* if we detect that it could be a telecine, we
1836
                       signal it. It would be better to do it at a
1837
                       higher level as it can change in a film */
1838
                    if (coded_frame_rate >= 24.97 && 
1839
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1840
                        st->r_frame_rate = 24024;
1841
                        st->r_frame_rate_base = 1001;
1842
                    }
1843
                }
1844
            }
1845
            /* if no real frame rate, use the codec one */
1846 14bea432 Michael Niedermayer
            if (!st->r_frame_rate){
1847
                st->r_frame_rate      = st->codec.frame_rate;
1848
                st->r_frame_rate_base = st->codec.frame_rate_base;
1849
            }
1850 b9a281db Fabrice Bellard
        }
1851 de6d9b64 Fabrice Bellard
    }
1852 b9a281db Fabrice Bellard
1853 12f996ed Fabrice Bellard
    av_estimate_timings(ic);
1854 e928649b Michael Niedermayer
#if 0
1855
    /* correct DTS for b frame streams with no timestamps */
1856
    for(i=0;i<ic->nb_streams;i++) {
1857
        st = ic->streams[i];
1858
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1859
            if(b-frames){
1860
                ppktl = &ic->packet_buffer;
1861
                while(ppkt1){
1862
                    if(ppkt1->stream_index != i)
1863
                        continue;
1864
                    if(ppkt1->pkt->dts < 0)
1865
                        break;
1866
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1867
                        break;
1868
                    ppkt1->pkt->dts -= delta;
1869
                    ppkt1= ppkt1->next;
1870
                }
1871
                if(ppkt1)
1872
                    continue;
1873
                st->cur_dts -= delta;
1874
            }
1875
        }
1876
    }
1877
#endif
1878 b9a281db Fabrice Bellard
    return ret;
1879 de6d9b64 Fabrice Bellard
}
1880
1881 fb2758c8 Fabrice Bellard
/*******************************************************/
1882
1883
/**
1884
 * start playing a network based stream (e.g. RTSP stream) at the
1885
 * current position 
1886
 */
1887
int av_read_play(AVFormatContext *s)
1888
{
1889
    if (!s->iformat->read_play)
1890
        return AVERROR_NOTSUPP;
1891
    return s->iformat->read_play(s);
1892
}
1893
1894
/**
1895
 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1896
 * to resume it.
1897
 */
1898
int av_read_pause(AVFormatContext *s)
1899
{
1900
    if (!s->iformat->read_pause)
1901
        return AVERROR_NOTSUPP;
1902
    return s->iformat->read_pause(s);
1903
}
1904
1905 b9a281db Fabrice Bellard
/**
1906
 * Close a media file (but not its codecs)
1907
 *
1908
 * @param s media file handle
1909
 */
1910 de6d9b64 Fabrice Bellard
void av_close_input_file(AVFormatContext *s)
1911
{
1912 b6892136 Fabrice Bellard
    int i, must_open_file;
1913 da24c5e3 Fabrice Bellard
    AVStream *st;
1914 de6d9b64 Fabrice Bellard
1915 fb2758c8 Fabrice Bellard
    /* free previous packet */
1916
    if (s->cur_st && s->cur_st->parser)
1917
        av_free_packet(&s->cur_pkt); 
1918
1919 b9a281db Fabrice Bellard
    if (s->iformat->read_close)
1920
        s->iformat->read_close(s);
1921 de6d9b64 Fabrice Bellard
    for(i=0;i<s->nb_streams;i++) {
1922 da24c5e3 Fabrice Bellard
        /* free all data in a stream component */
1923
        st = s->streams[i];
1924 fb2758c8 Fabrice Bellard
        if (st->parser) {
1925
            av_parser_close(st->parser);
1926 de6d9b64 Fabrice Bellard
        }
1927 fb2758c8 Fabrice Bellard
        av_free(st->index_entries);
1928
        av_free(st);
1929 de6d9b64 Fabrice Bellard
    }
1930 fb2758c8 Fabrice Bellard
    flush_packet_queue(s);
1931 b6892136 Fabrice Bellard
    must_open_file = 1;
1932 da24c5e3 Fabrice Bellard
    if (s->iformat->flags & AVFMT_NOFILE) {
1933 b6892136 Fabrice Bellard
        must_open_file = 0;
1934
    }
1935
    if (must_open_file) {
1936 96baaa6a Fabrice Bellard
        url_fclose(&s->pb);
1937
    }
1938 a8dbe951 Philip Gladstone
    av_freep(&s->priv_data);
1939 1ea4f593 Fabrice Bellard
    av_free(s);
1940 de6d9b64 Fabrice Bellard
}
1941
1942 b9a281db Fabrice Bellard
/**
1943
 * Add a new stream to a media file. Can only be called in the
1944 da24c5e3 Fabrice Bellard
 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1945
 * format context, then new streams can be added in read_packet too.
1946 b9a281db Fabrice Bellard
 *
1947
 *
1948
 * @param s media file handle
1949 da24c5e3 Fabrice Bellard
 * @param id file format dependent stream id 
1950 b9a281db Fabrice Bellard
 */
1951
AVStream *av_new_stream(AVFormatContext *s, int id)
1952
{
1953
    AVStream *st;
1954
1955
    if (s->nb_streams >= MAX_STREAMS)
1956
        return NULL;
1957
1958
    st = av_mallocz(sizeof(AVStream));
1959
    if (!st)
1960
        return NULL;
1961 1e491e29 Michael Niedermayer
    avcodec_get_context_defaults(&st->codec);
1962 48091512 Fabrice Bellard
    if (s->iformat) {
1963
        /* no default bitrate if decoding */
1964
        st->codec.bit_rate = 0;
1965
    }
1966 b9a281db Fabrice Bellard
    st->index = s->nb_streams;
1967
    st->id = id;
1968 12f996ed Fabrice Bellard
    st->start_time = AV_NOPTS_VALUE;
1969
    st->duration = AV_NOPTS_VALUE;
1970 e928649b Michael Niedermayer
    st->cur_dts = AV_NOPTS_VALUE;
1971 9ee91c2f Michael Niedermayer
1972
    /* default pts settings is MPEG like */
1973
    av_set_pts_info(st, 33, 1, 90000);
1974 77405fc8 Michael Niedermayer
    st->last_IP_pts = AV_NOPTS_VALUE;
1975 9ee91c2f Michael Niedermayer
1976 b9a281db Fabrice Bellard
    s->streams[s->nb_streams++] = st;
1977
    return st;
1978
}
1979
1980
/************************************************************/
1981
/* output media file */
1982 de6d9b64 Fabrice Bellard
1983 87a0a681 Fabrice Bellard
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1984
{
1985
    int ret;
1986 98486a6b Roman Shaposhnik
    
1987
    if (s->oformat->priv_data_size > 0) {
1988
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
1989
        if (!s->priv_data)
1990
            return AVERROR_NOMEM;
1991
    } else
1992
        s->priv_data = NULL;
1993
        
1994 87a0a681 Fabrice Bellard
    if (s->oformat->set_parameters) {
1995
        ret = s->oformat->set_parameters(s, ap);
1996
        if (ret < 0)
1997
            return ret;
1998
    }
1999
    return 0;
2000
}
2001
2002 b9a281db Fabrice Bellard
/**
2003
 * allocate the stream private data and write the stream header to an
2004
 * output media file
2005
 *
2006
 * @param s media file handle
2007
 * @return 0 if OK. AVERROR_xxx if error.  
2008
 */
2009
int av_write_header(AVFormatContext *s)
2010
{
2011 1e51d801 Fabrice Bellard
    int ret, i;
2012
    AVStream *st;
2013
2014
    ret = s->oformat->write_header(s);
2015
    if (ret < 0)
2016
        return ret;
2017
2018
    /* init PTS generation */
2019
    for(i=0;i<s->nb_streams;i++) {
2020
        st = s->streams[i];
2021
2022
        switch (st->codec.codec_type) {
2023
        case CODEC_TYPE_AUDIO:
2024
            av_frac_init(&st->pts, 0, 0, 
2025 9ee91c2f Michael Niedermayer
                         (int64_t)st->time_base.num * st->codec.sample_rate);
2026 1e51d801 Fabrice Bellard
            break;
2027
        case CODEC_TYPE_VIDEO:
2028
            av_frac_init(&st->pts, 0, 0, 
2029 9ee91c2f Michael Niedermayer
                         (int64_t)st->time_base.num * st->codec.frame_rate);
2030 1e51d801 Fabrice Bellard
            break;
2031
        default:
2032
            break;
2033
        }
2034
    }
2035
    return 0;
2036 b9a281db Fabrice Bellard
}
2037
2038 3c895fc0 Michael Niedermayer
//FIXME merge with compute_pkt_fields
2039
static void compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2040
    int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
2041
    int num, den, frame_size;
2042 b0c7f5a9 Michael Niedermayer
2043 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);
2044 e928649b Michael Niedermayer
    
2045
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2046
        return -1;*/
2047
            
2048
    if(pkt->pts != AV_NOPTS_VALUE)
2049
        pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2050
    if(pkt->dts != AV_NOPTS_VALUE)
2051
        pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2052
2053
    /* duration field */
2054
    pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2055 3c895fc0 Michael Niedermayer
    if (pkt->duration == 0) {
2056
        compute_frame_duration(&num, &den, st, NULL, pkt);
2057
        if (den && num) {
2058
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2059
        }
2060
    }
2061 e928649b Michael Niedermayer
2062
    //XXX/FIXME this is a temporary hack until all encoders output pts
2063
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2064
        pkt->dts=
2065
//        pkt->pts= st->cur_dts;
2066
        pkt->pts= st->pts.val;
2067
    }
2068
2069
    //calculate dts from pts    
2070
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2071
        if(b_frames){
2072
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2073 3c895fc0 Michael Niedermayer
                st->last_IP_pts= -pkt->duration;
2074 e928649b Michael Niedermayer
            }
2075
            if(st->last_IP_pts < pkt->pts){
2076
                pkt->dts= st->last_IP_pts;
2077
                st->last_IP_pts= pkt->pts;
2078
            }else
2079
                pkt->dts= pkt->pts;
2080
        }else
2081
            pkt->dts= pkt->pts;
2082
    }
2083
    
2084 3c895fc0 Michael Niedermayer
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2085 e928649b Michael Niedermayer
    st->cur_dts= pkt->dts;
2086
    st->pts.val= pkt->dts;
2087
2088 1e51d801 Fabrice Bellard
    /* update pts */
2089
    switch (st->codec.codec_type) {
2090
    case CODEC_TYPE_AUDIO:
2091 e928649b Michael Niedermayer
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
2092 6d8f985e Michael Niedermayer
2093 b0c7f5a9 Michael Niedermayer
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2094 6d8f985e Michael Niedermayer
           but it would be better if we had the real timestamps from the encoder */
2095 e928649b Michael Niedermayer
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2096 9ee91c2f Michael Niedermayer
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2097 7feb950a Fabrice Bellard
        }
2098 1e51d801 Fabrice Bellard
        break;
2099
    case CODEC_TYPE_VIDEO:
2100 9ee91c2f Michael Niedermayer
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
2101 1e51d801 Fabrice Bellard
        break;
2102
    default:
2103
        break;
2104
    }
2105 3c895fc0 Michael Niedermayer
}
2106
2107
static void truncate_ts(AVStream *st, AVPacket *pkt){
2108
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2109
    
2110 e0c91bc2 Michael Niedermayer
//    if(pkt->dts < 0)
2111
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2112 3c895fc0 Michael Niedermayer
    
2113
    pkt->pts &= pts_mask;
2114
    pkt->dts &= pts_mask;
2115
}
2116
2117
/**
2118
 * Write a packet to an output media file. The packet shall contain
2119
 * one audio or video frame.
2120
 *
2121
 * @param s media file handle
2122
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2123
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2124
 */
2125
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2126
{
2127 576ae256 Michael Niedermayer
    int ret;
2128
2129 3c895fc0 Michael Niedermayer
    compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2130
    
2131
    truncate_ts(s->streams[pkt->stream_index], pkt);
2132
2133 576ae256 Michael Niedermayer
    ret= s->oformat->write_packet(s, pkt);
2134
    if(!ret)
2135
        ret= url_ferror(&s->pb);
2136
    return ret;
2137 3c895fc0 Michael Niedermayer
}
2138
2139
/**
2140 fe2d6fe2 Michael Niedermayer
 * interleave_packet implementation which will interleave per DTS.
2141
 */
2142
static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2143
    AVPacketList *pktl, **next_point, *this_pktl;
2144
    int stream_count=0;
2145
    int streams[MAX_STREAMS];
2146
2147
    if(pkt){
2148
        AVStream *st= s->streams[ pkt->stream_index];
2149
2150
        assert(pkt->destruct != av_destruct_packet); //FIXME
2151
2152
        this_pktl = av_mallocz(sizeof(AVPacketList));
2153
        this_pktl->pkt= *pkt;
2154
        av_dup_packet(&this_pktl->pkt);
2155
2156
        next_point = &s->packet_buffer;
2157
        while(*next_point){
2158
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2159
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2160
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2161
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2162
                break;
2163
            next_point= &(*next_point)->next;
2164
        }
2165
        this_pktl->next= *next_point;
2166
        *next_point= this_pktl;
2167
    }
2168
    
2169
    memset(streams, 0, sizeof(streams));
2170
    pktl= s->packet_buffer;
2171
    while(pktl){
2172
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2173
        if(streams[ pktl->pkt.stream_index ] == 0)
2174
            stream_count++;
2175
        streams[ pktl->pkt.stream_index ]++;
2176
        pktl= pktl->next;
2177
    }
2178
    
2179
    if(s->nb_streams == stream_count || (flush && stream_count)){
2180
        pktl= s->packet_buffer;
2181
        *out= pktl->pkt;
2182
        
2183
        s->packet_buffer= pktl->next;        
2184
        av_freep(&pktl);
2185
        return 1;
2186
    }else{
2187
        av_init_packet(out);
2188
        return 0;
2189
    }
2190
}
2191
2192
/**
2193
 * Interleaves a AVPacket correctly so it can be muxed.
2194
 * @param out the interleaved packet will be output here
2195
 * @param in the input packet
2196
 * @param flush 1 if no further packets are available as input and all
2197
 *              remaining packets should be output
2198
 * @return 1 if a packet was output, 0 if no packet could be output, 
2199
 *         < 0 if an error occured
2200
 */
2201
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2202
    if(s->oformat->interleave_packet)
2203
        return s->oformat->interleave_packet(s, out, in, flush);
2204
    else
2205
        return av_interleave_packet_per_dts(s, out, in, flush);
2206
}
2207
2208
/**
2209 3c895fc0 Michael Niedermayer
 * Writes a packet to an output media file ensuring correct interleaving. 
2210
 * The packet shall contain one audio or video frame.
2211
 * If the packets are already correctly interleaved the application should
2212
 * call av_write_frame() instead as its slightly faster, its also important
2213 fe2d6fe2 Michael Niedermayer
 * to keep in mind that completly non interleaved input will need huge amounts
2214 3c895fc0 Michael Niedermayer
 * of memory to interleave with this, so its prefereable to interleave at the
2215
 * demuxer level
2216
 *
2217
 * @param s media file handle
2218
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2219
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2220
 */
2221
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2222
    AVStream *st= s->streams[ pkt->stream_index];
2223
2224
    compute_pkt_fields2(st, pkt);
2225 6f824977 Michael Niedermayer
    
2226
    //FIXME/XXX/HACK drop zero sized packets
2227
    if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2228
        return 0;
2229 fe2d6fe2 Michael Niedermayer
    
2230 3c895fc0 Michael Niedermayer
    if(pkt->dts == AV_NOPTS_VALUE)
2231
        return -1;
2232
2233 fe2d6fe2 Michael Niedermayer
    for(;;){
2234
        AVPacket opkt;
2235
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2236
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2237
            return ret;
2238 3c895fc0 Michael Niedermayer
        
2239 fe2d6fe2 Michael Niedermayer
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2240
        ret= s->oformat->write_packet(s, &opkt);
2241
        
2242
        av_free_packet(&opkt);
2243
        pkt= NULL;
2244 3c895fc0 Michael Niedermayer
        
2245
        if(ret<0)
2246
            return ret;
2247 576ae256 Michael Niedermayer
        if(url_ferror(&s->pb))
2248
            return url_ferror(&s->pb);
2249 3c895fc0 Michael Niedermayer
    }
2250 b9a281db Fabrice Bellard
}
2251
2252
/**
2253
 * write the stream trailer to an output media file and and free the
2254
 * file private data.
2255
 *
2256
 * @param s media file handle
2257
 * @return 0 if OK. AVERROR_xxx if error.  */
2258
int av_write_trailer(AVFormatContext *s)
2259
{
2260 c40a3a42 Michael Niedermayer
    int ret, i;
2261 3c895fc0 Michael Niedermayer
    
2262 fe2d6fe2 Michael Niedermayer
    for(;;){
2263
        AVPacket pkt;
2264
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2265
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2266 c40a3a42 Michael Niedermayer
            goto fail;
2267 fe2d6fe2 Michael Niedermayer
        if(!ret)
2268
            break;
2269 3c895fc0 Michael Niedermayer
        
2270 fe2d6fe2 Michael Niedermayer
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2271
        ret= s->oformat->write_packet(s, &pkt);
2272
        
2273
        av_free_packet(&pkt);
2274 3c895fc0 Michael Niedermayer
        
2275
        if(ret<0)
2276 c40a3a42 Michael Niedermayer
            goto fail;
2277 576ae256 Michael Niedermayer
        if(url_ferror(&s->pb))
2278
            goto fail;
2279 3c895fc0 Michael Niedermayer
    }
2280
2281 b9a281db Fabrice Bellard
    ret = s->oformat->write_trailer(s);
2282 c40a3a42 Michael Niedermayer
fail:
2283 576ae256 Michael Niedermayer
    if(ret == 0)
2284
       ret=url_ferror(&s->pb);
2285 c40a3a42 Michael Niedermayer
    for(i=0;i<s->nb_streams;i++)
2286
        av_freep(&s->streams[i]->priv_data);
2287 b9a281db Fabrice Bellard
    av_freep(&s->priv_data);
2288
    return ret;
2289 de6d9b64 Fabrice Bellard
}
2290
2291
/* "user interface" functions */
2292
2293
void dump_format(AVFormatContext *ic,
2294
                 int index, 
2295
                 const char *url,
2296
                 int is_output)
2297
{
2298 b9a281db Fabrice Bellard
    int i, flags;
2299 de6d9b64 Fabrice Bellard
    char buf[256];
2300
2301 43465395 Michael Niedermayer
    av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
2302 de6d9b64 Fabrice Bellard
            is_output ? "Output" : "Input",
2303 b9a281db Fabrice Bellard
            index, 
2304
            is_output ? ic->oformat->name : ic->iformat->name, 
2305 de6d9b64 Fabrice Bellard
            is_output ? "to" : "from", url);
2306 12f996ed Fabrice Bellard
    if (!is_output) {
2307 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
2308 12f996ed Fabrice Bellard
        if (ic->duration != AV_NOPTS_VALUE) {
2309
            int hours, mins, secs, us;
2310
            secs = ic->duration / AV_TIME_BASE;
2311
            us = ic->duration % AV_TIME_BASE;
2312
            mins = secs / 60;
2313
            secs %= 60;
2314
            hours = mins / 60;
2315
            mins %= 60;
2316 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
2317 12f996ed Fabrice Bellard
                   (10 * us) / AV_TIME_BASE);
2318
        } else {
2319 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2320 12f996ed Fabrice Bellard
        }
2321 d0f3f159 Wolfram Gloger
        if (ic->start_time != AV_NOPTS_VALUE) {
2322
            int secs, us;
2323
            av_log(NULL, AV_LOG_DEBUG, ", start: ");
2324
            secs = ic->start_time / AV_TIME_BASE;
2325
            us = ic->start_time % AV_TIME_BASE;
2326
            av_log(NULL, AV_LOG_DEBUG, "%d.%06d",
2327
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2328
        }
2329 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
2330 12f996ed Fabrice Bellard
        if (ic->bit_rate) {
2331 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
2332 12f996ed Fabrice Bellard
        } else {
2333 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2334 12f996ed Fabrice Bellard
        }
2335 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, "\n");
2336 12f996ed Fabrice Bellard
    }
2337 de6d9b64 Fabrice Bellard
    for(i=0;i<ic->nb_streams;i++) {
2338
        AVStream *st = ic->streams[i];
2339
        avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2340 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
2341 b9a281db Fabrice Bellard
        /* the pid is an important information, so we display it */
2342
        /* XXX: add a generic system */
2343
        if (is_output)
2344
            flags = ic->oformat->flags;
2345
        else
2346
            flags = ic->iformat->flags;
2347
        if (flags & AVFMT_SHOW_IDS) {
2348 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
2349 b9a281db Fabrice Bellard
        }
2350 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
2351 de6d9b64 Fabrice Bellard
    }
2352
}
2353
2354
typedef struct {
2355 445f1b83 Roman Shaposhnik
    const char *abv;
2356 de6d9b64 Fabrice Bellard
    int width, height;
2357 445f1b83 Roman Shaposhnik
    int frame_rate, frame_rate_base;
2358
} AbvEntry;
2359
2360
static AbvEntry frame_abvs[] = {
2361 ba2a8cb4 Roman Shaposhnik
    { "ntsc",      720, 480, 30000, 1001 },
2362
    { "pal",       720, 576,    25,    1 },
2363
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2364
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2365 904736b5 Roman Shaposhnik
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2366
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2367 445f1b83 Roman Shaposhnik
    { "film",      352, 240,    24,    1 },
2368
    { "ntsc-film", 352, 240, 24000, 1001 },
2369
    { "sqcif",     128,  96,     0,    0 },
2370
    { "qcif",      176, 144,     0,    0 },
2371
    { "cif",       352, 288,     0,    0 },
2372
    { "4cif",      704, 576,     0,    0 },
2373 de6d9b64 Fabrice Bellard
};
2374 445f1b83 Roman Shaposhnik
2375 de6d9b64 Fabrice Bellard
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2376
{
2377
    int i;
2378 445f1b83 Roman Shaposhnik
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2379 de6d9b64 Fabrice Bellard
    const char *p;
2380
    int frame_width = 0, frame_height = 0;
2381
2382
    for(i=0;i<n;i++) {
2383 445f1b83 Roman Shaposhnik
        if (!strcmp(frame_abvs[i].abv, str)) {
2384
            frame_width = frame_abvs[i].width;
2385
            frame_height = frame_abvs[i].height;
2386 de6d9b64 Fabrice Bellard
            break;
2387
        }
2388
    }
2389
    if (i == n) {
2390
        p = str;
2391
        frame_width = strtol(p, (char **)&p, 10);
2392
        if (*p)
2393
            p++;
2394
        frame_height = strtol(p, (char **)&p, 10);
2395
    }
2396
    if (frame_width <= 0 || frame_height <= 0)
2397
        return -1;
2398
    *width_ptr = frame_width;
2399
    *height_ptr = frame_height;
2400
    return 0;
2401
}
2402
2403 445f1b83 Roman Shaposhnik
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2404
{
2405
    int i;
2406
    char* cp;
2407
   
2408
    /* First, we check our abbreviation table */
2409
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2410
         if (!strcmp(frame_abvs[i].abv, arg)) {
2411
             *frame_rate = frame_abvs[i].frame_rate;
2412
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2413
             return 0;
2414
         }
2415
2416
    /* Then, we try to parse it as fraction */
2417
    cp = strchr(arg, '/');
2418
    if (cp) {
2419
        char* cpp;
2420
        *frame_rate = strtol(arg, &cpp, 10);
2421
        if (cpp != arg || cpp == cp) 
2422
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2423
        else
2424
           *frame_rate = 0;
2425
    } 
2426
    else {
2427
        /* Finally we give up and parse it as double */
2428 8bfed902 Michael Niedermayer
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2429 445f1b83 Roman Shaposhnik
        *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2430
    }
2431
    if (!*frame_rate || !*frame_rate_base)
2432
        return -1;
2433
    else
2434
        return 0;
2435
}
2436
2437 916c80e9 Fabrice Bellard
/* Syntax:
2438
 * - If not a duration:
2439
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2440 c5510dd6 Philip Gladstone
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2441 916c80e9 Fabrice Bellard
 * Return the date in micro seconds since 1970 
2442
 * - If duration:
2443
 *  HH[:MM[:SS[.m...]]]
2444
 *  S+[.m...]
2445
 */
2446 0c1a9eda Zdenek Kabelac
int64_t parse_date(const char *datestr, int duration)
2447 de6d9b64 Fabrice Bellard
{
2448
    const char *p;
2449 0c1a9eda Zdenek Kabelac
    int64_t t;
2450 2dbceb9f Philip Gladstone
    struct tm dt;
2451 c5510dd6 Philip Gladstone
    int i;
2452
    static const char *date_fmt[] = {
2453
        "%Y-%m-%d",
2454
        "%Y%m%d",
2455
    };
2456
    static const char *time_fmt[] = {
2457
        "%H:%M:%S",
2458
        "%H%M%S",
2459
    };
2460
    const char *q;
2461 916c80e9 Fabrice Bellard
    int is_utc, len;
2462 c5510dd6 Philip Gladstone
    char lastch;
2463 a6a92a9a Wolfram Gloger
    int negative = 0;
2464 6d8f985e Michael Niedermayer
2465
#undef time
2466 c5510dd6 Philip Gladstone
    time_t now = time(0);
2467
2468 916c80e9 Fabrice Bellard
    len = strlen(datestr);
2469
    if (len > 0)
2470
        lastch = datestr[len - 1];
2471
    else
2472
        lastch = '\0';
2473 c5510dd6 Philip Gladstone
    is_utc = (lastch == 'z' || lastch == 'Z');
2474 2dbceb9f Philip Gladstone
2475
    memset(&dt, 0, sizeof(dt));
2476 de6d9b64 Fabrice Bellard
2477
    p = datestr;
2478 916c80e9 Fabrice Bellard
    q = NULL;
2479 de6d9b64 Fabrice Bellard
    if (!duration) {
2480 c5510dd6 Philip Gladstone
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2481 f71869a4 Fabrice Bellard
            q = small_strptime(p, date_fmt[i], &dt);
2482 c5510dd6 Philip Gladstone
            if (q) {
2483
                break;
2484
            }
2485
        }
2486
2487
        if (!q) {
2488
            if (is_utc) {
2489
                dt = *gmtime(&now);
2490
            } else {
2491
                dt = *localtime(&now);
2492
            }
2493
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2494 de6d9b64 Fabrice Bellard
        } else {
2495 c5510dd6 Philip Gladstone
            p = q;
2496 de6d9b64 Fabrice Bellard
        }
2497 c5510dd6 Philip Gladstone
2498
        if (*p == 'T' || *p == 't' || *p == ' ')
2499
            p++;
2500
2501 916c80e9 Fabrice Bellard
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2502 f71869a4 Fabrice Bellard
            q = small_strptime(p, time_fmt[i], &dt);
2503 916c80e9 Fabrice Bellard
            if (q) {
2504
                break;
2505
            }
2506
        }
2507
    } else {
2508 a6a92a9a Wolfram Gloger
        if (p[0] == '-') {
2509
            negative = 1;
2510
            ++p;
2511
        }
2512 f71869a4 Fabrice Bellard
        q = small_strptime(p, time_fmt[0], &dt);
2513 916c80e9 Fabrice Bellard
        if (!q) {
2514
            dt.tm_sec = strtol(p, (char **)&q, 10);
2515
            dt.tm_min = 0;
2516
            dt.tm_hour = 0;
2517 c5510dd6 Philip Gladstone
        }
2518
    }
2519
2520
    /* Now we have all the fields that we can get */
2521
    if (!q) {
2522
        if (duration)
2523
            return 0;
2524
        else
2525 0c1a9eda Zdenek Kabelac
            return now * int64_t_C(1000000);
2526 de6d9b64 Fabrice Bellard
    }
2527 2dbceb9f Philip Gladstone
2528
    if (duration) {
2529 c5510dd6 Philip Gladstone
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2530 2dbceb9f Philip Gladstone
    } else {
2531 c5510dd6 Philip Gladstone
        dt.tm_isdst = -1;       /* unknown */
2532
        if (is_utc) {
2533
            t = mktimegm(&dt);
2534
        } else {
2535
            t = mktime(&dt);
2536
        }
2537 de6d9b64 Fabrice Bellard
    }
2538 2dbceb9f Philip Gladstone
2539 c5510dd6 Philip Gladstone
    t *= 1000000;
2540
2541
    if (*q == '.') {
2542 de6d9b64 Fabrice Bellard
        int val, n;
2543 c5510dd6 Philip Gladstone
        q++;
2544
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2545
            if (!isdigit(*q)) 
2546
                break;
2547
            val += n * (*q - '0');
2548 de6d9b64 Fabrice Bellard
        }
2549
        t += val;
2550
    }
2551 a6a92a9a Wolfram Gloger
    return negative ? -t : t;
2552 de6d9b64 Fabrice Bellard
}
2553
2554 2dbceb9f Philip Gladstone
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2555 de6d9b64 Fabrice Bellard
   1 if found */
2556
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2557
{
2558
    const char *p;
2559
    char tag[128], *q;
2560
2561
    p = info;
2562
    if (*p == '?')
2563
        p++;
2564
    for(;;) {
2565
        q = tag;
2566
        while (*p != '\0' && *p != '=' && *p != '&') {
2567
            if ((q - tag) < sizeof(tag) - 1)
2568
                *q++ = *p;
2569
            p++;
2570
        }
2571
        *q = '\0';
2572
        q = arg;
2573
        if (*p == '=') {
2574
            p++;
2575
            while (*p != '&' && *p != '\0') {
2576 2dbceb9f Philip Gladstone
                if ((q - arg) < arg_size - 1) {
2577
                    if (*p == '+')
2578
                        *q++ = ' ';
2579
                    else
2580
                        *q++ = *p;
2581
                }
2582 de6d9b64 Fabrice Bellard
                p++;
2583
            }
2584
            *q = '\0';
2585
        }
2586
        if (!strcmp(tag, tag1)) 
2587
            return 1;
2588
        if (*p != '&')
2589
            break;
2590 8d1335ea Philip Gladstone
        p++;
2591 de6d9b64 Fabrice Bellard
    }
2592
    return 0;
2593
}
2594
2595 9150f42e Fabrice Bellard
/* Return in 'buf' the path with '%d' replaced by number. Also handles
2596
   the '%0nd' format where 'n' is the total number of digits and
2597
   '%%'. Return 0 if OK, and -1 if format error */
2598
int get_frame_filename(char *buf, int buf_size,
2599
                       const char *path, int number)
2600
{
2601
    const char *p;
2602 0bf92f79 Panagiotis Issaris
    char *q, buf1[20], c;
2603
    int nd, len, percentd_found;
2604 9150f42e Fabrice Bellard
2605
    q = buf;
2606
    p = path;
2607
    percentd_found = 0;
2608
    for(;;) {
2609
        c = *p++;
2610
        if (c == '\0')
2611
            break;
2612
        if (c == '%') {
2613 c9646fda Philip Gladstone
            do {
2614
                nd = 0;
2615
                while (isdigit(*p)) {
2616
                    nd = nd * 10 + *p++ - '0';
2617
                }
2618
                c = *p++;
2619
            } while (isdigit(c));
2620
2621 9150f42e Fabrice Bellard
            switch(c) {
2622
            case '%':
2623
                goto addchar;
2624
            case 'd':
2625
                if (percentd_found)
2626
                    goto fail;
2627
                percentd_found = 1;
2628
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2629
                len = strlen(buf1);
2630
                if ((q - buf + len) > buf_size - 1)
2631
                    goto fail;
2632
                memcpy(q, buf1, len);
2633
                q += len;
2634
                break;
2635
            default:
2636
                goto fail;
2637
            }
2638
        } else {
2639
        addchar:
2640
            if ((q - buf) < buf_size - 1)
2641
                *q++ = c;
2642
        }
2643
    }
2644
    if (!percentd_found)
2645
        goto fail;
2646
    *q = '\0';
2647
    return 0;
2648
 fail:
2649
    *q = '\0';
2650
    return -1;
2651
}
2652
2653 b9a281db Fabrice Bellard
/**
2654 fb2758c8 Fabrice Bellard
 * Print  nice hexa dump of a buffer
2655
 * @param f stream for output
2656 b9a281db Fabrice Bellard
 * @param buf buffer
2657
 * @param size buffer size
2658
 */
2659 fb2758c8 Fabrice Bellard
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2660 b9a281db Fabrice Bellard
{
2661
    int len, i, j, c;
2662
2663
    for(i=0;i<size;i+=16) {
2664
        len = size - i;
2665
        if (len > 16)
2666
            len = 16;
2667 fb2758c8 Fabrice Bellard
        fprintf(f, "%08x ", i);
2668 b9a281db Fabrice Bellard
        for(j=0;j<16;j++) {
2669
            if (j < len)
2670 fb2758c8 Fabrice Bellard
                fprintf(f, " %02x", buf[i+j]);
2671 b9a281db Fabrice Bellard
            else
2672 fb2758c8 Fabrice Bellard
                fprintf(f, "   ");
2673 b9a281db Fabrice Bellard
        }
2674 fb2758c8 Fabrice Bellard
        fprintf(f, " ");
2675 b9a281db Fabrice Bellard
        for(j=0;j<len;j++) {
2676
            c = buf[i+j];
2677
            if (c < ' ' || c > '~')
2678
                c = '.';
2679 fb2758c8 Fabrice Bellard
            fprintf(f, "%c", c);
2680 b9a281db Fabrice Bellard
        }
2681 fb2758c8 Fabrice Bellard
        fprintf(f, "\n");
2682 b9a281db Fabrice Bellard
    }
2683
}
2684
2685 fb2758c8 Fabrice Bellard
/**
2686
 * Print on 'f' a nice dump of a packet
2687
 * @param f stream for output
2688
 * @param pkt packet to dump
2689
 * @param dump_payload true if the payload must be displayed too
2690
 */
2691
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2692
{
2693
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2694
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2695
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2696 37353960 Fabrice Bellard
    /* DTS is _always_ valid after av_read_frame() */
2697
    fprintf(f, "  dts=");
2698
    if (pkt->dts == AV_NOPTS_VALUE)
2699
        fprintf(f, "N/A");
2700
    else
2701
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2702 fb2758c8 Fabrice Bellard
    /* PTS may be not known if B frames are present */
2703
    fprintf(f, "  pts=");
2704
    if (pkt->pts == AV_NOPTS_VALUE)
2705
        fprintf(f, "N/A");
2706
    else
2707
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2708
    fprintf(f, "\n");
2709
    fprintf(f, "  size=%d\n", pkt->size);
2710
    if (dump_payload)
2711
        av_hex_dump(f, pkt->data, pkt->size);
2712
}
2713
2714 a9a721da Fabrice Bellard
void url_split(char *proto, int proto_size,
2715 6ba5cbc6 Petr Doubek
               char *authorization, int authorization_size,
2716 a9a721da Fabrice Bellard
               char *hostname, int hostname_size,
2717
               int *port_ptr,
2718
               char *path, int path_size,
2719
               const char *url)
2720
{
2721
    const char *p;
2722
    char *q;
2723
    int port;
2724
2725
    port = -1;
2726
2727
    p = url;
2728
    q = proto;
2729
    while (*p != ':' && *p != '\0') {
2730
        if ((q - proto) < proto_size - 1)
2731
            *q++ = *p;
2732
        p++;
2733
    }
2734
    if (proto_size > 0)
2735
        *q = '\0';
2736 6ba5cbc6 Petr Doubek
    if (authorization_size > 0)
2737
        authorization[0] = '\0';
2738 a9a721da Fabrice Bellard
    if (*p == '\0') {
2739
        if (proto_size > 0)
2740
            proto[0] = '\0';
2741
        if (hostname_size > 0)
2742
            hostname[0] = '\0';
2743
        p = url;
2744
    } else {
2745 6ba5cbc6 Petr Doubek
        char *at,*slash; // PETR: position of '@' character and '/' character
2746
2747 a9a721da Fabrice Bellard
        p++;
2748
        if (*p == '/')
2749
            p++;
2750
        if (*p == '/')
2751
            p++;
2752 6ba5cbc6 Petr Doubek
        at = strchr(p,'@'); // PETR: get the position of '@'
2753
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2754
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2755
2756
        q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2757
2758
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2759
            if (*p == '@') {    // PETR: passed '@'
2760
              if (authorization_size > 0)
2761
                  *q = '\0';
2762
              q = hostname;
2763
              at = NULL;
2764
            } else if (!at) {   // PETR: hostname
2765
              if ((q - hostname) < hostname_size - 1)
2766
                  *q++ = *p;
2767
            } else {
2768
              if ((q - authorization) < authorization_size - 1)
2769 a9a721da Fabrice Bellard
                *q++ = *p;
2770 6ba5cbc6 Petr Doubek
            }
2771 a9a721da Fabrice Bellard
            p++;
2772
        }
2773
        if (hostname_size > 0)
2774
            *q = '\0';
2775
        if (*p == ':') {
2776
            p++;
2777
            port = strtoul(p, (char **)&p, 10);
2778
        }
2779
    }
2780
    if (port_ptr)
2781
        *port_ptr = port;
2782
    pstrcpy(path, path_size, p);
2783
}
2784
2785 916c80e9 Fabrice Bellard
/**
2786
 * Set the pts for a given stream
2787
 * @param s stream 
2788
 * @param pts_wrap_bits number of bits effectively used by the pts
2789
 *        (used for wrap control, 33 is the value for MPEG) 
2790
 * @param pts_num numerator to convert to seconds (MPEG: 1) 
2791
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2792
 */
2793 9ee91c2f Michael Niedermayer
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2794 916c80e9 Fabrice Bellard
                     int pts_num, int pts_den)
2795
{
2796
    s->pts_wrap_bits = pts_wrap_bits;
2797 9ee91c2f Michael Niedermayer
    s->time_base.num = pts_num;
2798
    s->time_base.den = pts_den;
2799 916c80e9 Fabrice Bellard
}
2800
2801
/* fraction handling */
2802
2803
/**
2804
 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2805
 * as 0 <= num < den.
2806
 *
2807
 * @param f fractional number
2808
 * @param val integer value
2809
 * @param num must be >= 0
2810
 * @param den must be >= 1 
2811
 */
2812 0c1a9eda Zdenek Kabelac
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2813 916c80e9 Fabrice Bellard
{
2814
    num += (den >> 1);
2815
    if (num >= den) {
2816
        val += num / den;
2817
        num = num % den;
2818
    }
2819
    f->val = val;
2820
    f->num = num;
2821
    f->den = den;
2822
}
2823
2824
/* set f to (val + 0.5) */
2825 0c1a9eda Zdenek Kabelac
void av_frac_set(AVFrac *f, int64_t val)
2826 916c80e9 Fabrice Bellard
{
2827
    f->val = val;
2828
    f->num = f->den >> 1;
2829
}
2830
2831
/**
2832
 * Fractionnal addition to f: f = f + (incr / f->den)
2833
 *
2834
 * @param f fractional number
2835
 * @param incr increment, can be positive or negative
2836
 */
2837 0c1a9eda Zdenek Kabelac
void av_frac_add(AVFrac *f, int64_t incr)
2838 916c80e9 Fabrice Bellard
{
2839 0c1a9eda Zdenek Kabelac
    int64_t num, den;
2840 916c80e9 Fabrice Bellard
2841
    num = f->num + incr;
2842
    den = f->den;
2843
    if (num < 0) {
2844
        f->val += num / den;
2845
        num = num % den;
2846
        if (num < 0) {
2847
            num += den;
2848
            f->val--;
2849
        }
2850
    } else if (num >= den) {
2851
        f->val += num / den;
2852
        num = num % den;
2853
    }
2854
    f->num = num;
2855
}
2856 87a0a681 Fabrice Bellard
2857
/**
2858
 * register a new image format
2859
 * @param img_fmt Image format descriptor
2860
 */
2861
void av_register_image_format(AVImageFormat *img_fmt)
2862
{
2863
    AVImageFormat **p;
2864
2865
    p = &first_image_format;
2866
    while (*p != NULL) p = &(*p)->next;
2867
    *p = img_fmt;
2868
    img_fmt->next = NULL;
2869
}
2870
2871
/* guess image format */
2872
AVImageFormat *av_probe_image_format(AVProbeData *pd)
2873
{
2874
    AVImageFormat *fmt1, *fmt;
2875
    int score, score_max;
2876
2877
    fmt = NULL;
2878
    score_max = 0;
2879
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2880
        if (fmt1->img_probe) {
2881
            score = fmt1->img_probe(pd);
2882
            if (score > score_max) {
2883
                score_max = score;
2884
                fmt = fmt1;
2885
            }
2886
        }
2887
    }
2888
    return fmt;
2889
}
2890
2891
AVImageFormat *guess_image_format(const char *filename)
2892
{
2893
    AVImageFormat *fmt1;
2894
2895
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2896
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2897
            return fmt1;
2898
    }
2899
    return NULL;
2900
}
2901
2902
/**
2903
 * Read an image from a stream. 
2904
 * @param gb byte stream containing the image
2905
 * @param fmt image format, NULL if probing is required
2906
 */
2907
int av_read_image(ByteIOContext *pb, const char *filename,
2908
                  AVImageFormat *fmt,
2909
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2910
{
2911
    char buf[PROBE_BUF_SIZE];
2912
    AVProbeData probe_data, *pd = &probe_data;
2913
    offset_t pos;
2914
    int ret;
2915
2916
    if (!fmt) {
2917 5c91a675 Zdenek Kabelac
        pd->filename = filename;
2918 87a0a681 Fabrice Bellard
        pd->buf = buf;
2919
        pos = url_ftell(pb);
2920
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2921
        url_fseek(pb, pos, SEEK_SET);
2922
        fmt = av_probe_image_format(pd);
2923
    }
2924
    if (!fmt)
2925
        return AVERROR_NOFMT;
2926
    ret = fmt->img_read(pb, alloc_cb, opaque);
2927
    return ret;
2928
}
2929
2930
/**
2931
 * Write an image to a stream.
2932
 * @param pb byte stream for the image output
2933
 * @param fmt image format
2934
 * @param img image data and informations
2935
 */
2936
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2937
{
2938
    return fmt->img_write(pb, img);
2939
}