Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 5a757507

History | View | Annotate | Download (64.9 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * Various utilities for ffmpeg system
3 19720f15 Fabrice Bellard
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 de6d9b64 Fabrice Bellard
 *
5 19720f15 Fabrice Bellard
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9 de6d9b64 Fabrice Bellard
 *
10 19720f15 Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
11 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 19720f15 Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14 de6d9b64 Fabrice Bellard
 *
15 19720f15 Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * 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 b9a281db Fabrice Bellard
AVInputFormat *first_iformat;
25
AVOutputFormat *first_oformat;
26 87a0a681 Fabrice Bellard
AVImageFormat *first_image_format;
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
    ext = strrchr(filename, '.');
52
    if (ext) {
53
        ext++;
54
        p = extensions;
55
        for(;;) {
56
            q = ext1;
57
            while (*p != '\0' && *p != ',') 
58
                *q++ = *p++;
59
            *q = '\0';
60
            if (!strcasecmp(ext1, ext)) 
61
                return 1;
62
            if (*p == '\0') 
63
                break;
64
            p++;
65
        }
66
    }
67
    return 0;
68
}
69
70 b9a281db Fabrice Bellard
AVOutputFormat *guess_format(const char *short_name, const char *filename, 
71
                             const char *mime_type)
72 de6d9b64 Fabrice Bellard
{
73 b9a281db Fabrice Bellard
    AVOutputFormat *fmt, *fmt_found;
74 de6d9b64 Fabrice Bellard
    int score_max, score;
75
76 87a0a681 Fabrice Bellard
    /* specific test for image sequences */
77 94d883e8 Fabrice Bellard
    if (!short_name && filename && 
78
        filename_number_test(filename) >= 0 &&
79
        guess_image_format(filename)) {
80 87a0a681 Fabrice Bellard
        return guess_format("image", NULL, NULL);
81
    }
82
83 de6d9b64 Fabrice Bellard
    /* find the proper file type */
84
    fmt_found = NULL;
85
    score_max = 0;
86 b9a281db Fabrice Bellard
    fmt = first_oformat;
87 de6d9b64 Fabrice Bellard
    while (fmt != NULL) {
88
        score = 0;
89
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
90
            score += 100;
91
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
92
            score += 10;
93
        if (filename && fmt->extensions && 
94
            match_ext(filename, fmt->extensions)) {
95
            score += 5;
96
        }
97
        if (score > score_max) {
98
            score_max = score;
99
            fmt_found = fmt;
100
        }
101
        fmt = fmt->next;
102
    }
103
    return fmt_found;
104
}   
105
106 c5510dd6 Philip Gladstone
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename, 
107
                             const char *mime_type)
108
{
109
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
110
111
    if (fmt) {
112
        AVOutputFormat *stream_fmt;
113
        char stream_format_name[64];
114
115
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
116
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
117
118
        if (stream_fmt)
119
            fmt = stream_fmt;
120
    }
121
122
    return fmt;
123
}
124
125 b9a281db Fabrice Bellard
AVInputFormat *av_find_input_format(const char *short_name)
126
{
127
    AVInputFormat *fmt;
128
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
129
        if (!strcmp(fmt->name, short_name))
130
            return fmt;
131
    }
132
    return NULL;
133
}
134
135 de6d9b64 Fabrice Bellard
/* memory handling */
136
137 b9a281db Fabrice Bellard
/**
138 6fa5a56c Fabrice Bellard
 * Default packet destructor 
139
 */
140
static void av_destruct_packet(AVPacket *pkt)
141
{
142
    av_free(pkt->data);
143
    pkt->data = NULL; pkt->size = 0;
144
}
145
146
/**
147 b9a281db Fabrice Bellard
 * Allocate the payload of a packet and intialized its fields to default values.
148
 *
149
 * @param pkt packet
150
 * @param size wanted payload size
151
 * @return 0 if OK. AVERROR_xxx otherwise.
152
 */
153 de6d9b64 Fabrice Bellard
int av_new_packet(AVPacket *pkt, int size)
154
{
155 6fa5a56c Fabrice Bellard
    void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
156
    if (!data)
157 b9a281db Fabrice Bellard
        return AVERROR_NOMEM;
158 6fa5a56c Fabrice Bellard
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
159 8cd5be98 Michael Niedermayer
160 6fa5a56c Fabrice Bellard
    av_init_packet(pkt);
161
    pkt->data = data; 
162
    pkt->size = size;
163
    pkt->destruct = av_destruct_packet;
164 de6d9b64 Fabrice Bellard
    return 0;
165
}
166
167 fb2758c8 Fabrice Bellard
/* This is a hack - the packet memory allocation stuff is broken. The
168
   packet is allocated if it was not really allocated */
169
int av_dup_packet(AVPacket *pkt)
170
{
171
    if (pkt->destruct != av_destruct_packet) {
172
        uint8_t *data;
173 8a56ac7b Fabrice Bellard
        /* we duplicate the packet and don't forget to put the padding
174
           again */
175
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
176 fb2758c8 Fabrice Bellard
        if (!data) {
177
            return AVERROR_NOMEM;
178
        }
179
        memcpy(data, pkt->data, pkt->size);
180 8a56ac7b Fabrice Bellard
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
181 fb2758c8 Fabrice Bellard
        pkt->data = data;
182
        pkt->destruct = av_destruct_packet;
183
    }
184
    return 0;
185
}
186
187 de6d9b64 Fabrice Bellard
/* fifo handling */
188
189
int fifo_init(FifoBuffer *f, int size)
190
{
191 1ea4f593 Fabrice Bellard
    f->buffer = av_malloc(size);
192 de6d9b64 Fabrice Bellard
    if (!f->buffer)
193
        return -1;
194
    f->end = f->buffer + size;
195
    f->wptr = f->rptr = f->buffer;
196
    return 0;
197
}
198
199
void fifo_free(FifoBuffer *f)
200
{
201 1ea4f593 Fabrice Bellard
    av_free(f->buffer);
202 de6d9b64 Fabrice Bellard
}
203
204 0c1a9eda Zdenek Kabelac
int fifo_size(FifoBuffer *f, uint8_t *rptr)
205 de6d9b64 Fabrice Bellard
{
206
    int size;
207
208
    if (f->wptr >= rptr) {
209
        size = f->wptr - rptr;
210
    } else {
211
        size = (f->end - rptr) + (f->wptr - f->buffer);
212
    }
213
    return size;
214
}
215
216
/* get data from the fifo (return -1 if not enough data) */
217 0c1a9eda Zdenek Kabelac
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
218 de6d9b64 Fabrice Bellard
{
219 0c1a9eda Zdenek Kabelac
    uint8_t *rptr = *rptr_ptr;
220 de6d9b64 Fabrice Bellard
    int size, len;
221
222
    if (f->wptr >= rptr) {
223
        size = f->wptr - rptr;
224
    } else {
225
        size = (f->end - rptr) + (f->wptr - f->buffer);
226
    }
227
    
228
    if (size < buf_size)
229
        return -1;
230
    while (buf_size > 0) {
231
        len = f->end - rptr;
232
        if (len > buf_size)
233
            len = buf_size;
234
        memcpy(buf, rptr, len);
235
        buf += len;
236
        rptr += len;
237
        if (rptr >= f->end)
238
            rptr = f->buffer;
239
        buf_size -= len;
240
    }
241
    *rptr_ptr = rptr;
242
    return 0;
243
}
244
245 0c1a9eda Zdenek Kabelac
void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
246 de6d9b64 Fabrice Bellard
{
247
    int len;
248 0c1a9eda Zdenek Kabelac
    uint8_t *wptr;
249 de6d9b64 Fabrice Bellard
    wptr = *wptr_ptr;
250
    while (size > 0) {
251
        len = f->end - wptr;
252
        if (len > size)
253
            len = size;
254
        memcpy(wptr, buf, len);
255
        wptr += len;
256
        if (wptr >= f->end)
257
            wptr = f->buffer;
258
        buf += len;
259
        size -= len;
260
    }
261
    *wptr_ptr = wptr;
262
}
263
264 b9a281db Fabrice Bellard
int filename_number_test(const char *filename)
265
{
266
    char buf[1024];
267
    return get_frame_filename(buf, sizeof(buf), filename, 1);
268
}
269
270
/* guess file format */
271 a25e098d Fabrice Bellard
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
272 b9a281db Fabrice Bellard
{
273
    AVInputFormat *fmt1, *fmt;
274
    int score, score_max;
275
276
    fmt = NULL;
277
    score_max = 0;
278
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
279
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
280
            continue;
281
        score = 0;
282 a8dbe951 Philip Gladstone
        if (fmt1->read_probe) {
283
            score = fmt1->read_probe(pd);
284
        } else if (fmt1->extensions) {
285 b9a281db Fabrice Bellard
            if (match_ext(pd->filename, fmt1->extensions)) {
286
                score = 50;
287
            }
288 a8dbe951 Philip Gladstone
        } 
289 b9a281db Fabrice Bellard
        if (score > score_max) {
290
            score_max = score;
291
            fmt = fmt1;
292
        }
293
    }
294
    return fmt;
295
}
296
297
/************************************************************/
298
/* input media file */
299 96baaa6a Fabrice Bellard
300 da24c5e3 Fabrice Bellard
/**
301
 * open a media file from an IO stream. 'fmt' must be specified.
302
 */
303 bc874dae Michel Bardiaux
304 43465395 Michael Niedermayer
static const char* format_to_name(void* ptr)
305 bc874dae Michel Bardiaux
{
306 43465395 Michael Niedermayer
    AVFormatContext* fc = (AVFormatContext*) ptr;
307 bc874dae Michel Bardiaux
    if(fc->iformat) return fc->iformat->name;
308
    else if(fc->oformat) return fc->oformat->name;
309
    else return "NULL";
310
}
311
312
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
313
314
AVFormatContext *av_alloc_format_context(void)
315
{
316
    AVFormatContext *ic;
317
    ic = av_mallocz(sizeof(AVFormatContext));
318
    if (!ic) return ic;
319 43465395 Michael Niedermayer
    ic->av_class = &av_format_context_class;
320 bc874dae Michel Bardiaux
    return ic;
321
}
322
323 da24c5e3 Fabrice Bellard
int av_open_input_stream(AVFormatContext **ic_ptr, 
324
                         ByteIOContext *pb, const char *filename, 
325
                         AVInputFormat *fmt, AVFormatParameters *ap)
326
{
327
    int err;
328
    AVFormatContext *ic;
329
330 bc874dae Michel Bardiaux
    ic = av_alloc_format_context();
331 da24c5e3 Fabrice Bellard
    if (!ic) {
332
        err = AVERROR_NOMEM;
333
        goto fail;
334
    }
335
    ic->iformat = fmt;
336
    if (pb)
337
        ic->pb = *pb;
338
    ic->duration = AV_NOPTS_VALUE;
339
    ic->start_time = AV_NOPTS_VALUE;
340
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
341
342
    /* allocate private data */
343
    if (fmt->priv_data_size > 0) {
344
        ic->priv_data = av_mallocz(fmt->priv_data_size);
345
        if (!ic->priv_data) {
346
            err = AVERROR_NOMEM;
347
            goto fail;
348
        }
349
    } else {
350
        ic->priv_data = NULL;
351
    }
352
353
    /* default pts settings is MPEG like */
354
    av_set_pts_info(ic, 33, 1, 90000);
355 fb2758c8 Fabrice Bellard
    ic->last_pkt_pts = AV_NOPTS_VALUE;
356
    ic->last_pkt_dts = AV_NOPTS_VALUE;
357
    ic->last_pkt_stream_pts = AV_NOPTS_VALUE;
358
    ic->last_pkt_stream_dts = AV_NOPTS_VALUE;
359
    
360 da24c5e3 Fabrice Bellard
    err = ic->iformat->read_header(ic, ap);
361
    if (err < 0)
362
        goto fail;
363 fb2758c8 Fabrice Bellard
364
    if (pb)
365
        ic->data_offset = url_ftell(&ic->pb);
366
367 da24c5e3 Fabrice Bellard
    *ic_ptr = ic;
368
    return 0;
369
 fail:
370
    if (ic) {
371
        av_freep(&ic->priv_data);
372
    }
373
    av_free(ic);
374
    *ic_ptr = NULL;
375
    return err;
376
}
377
378 b9a281db Fabrice Bellard
#define PROBE_BUF_SIZE 2048
379
380
/**
381
 * Open a media file as input. The codec are not opened. Only the file
382
 * header (if present) is read.
383
 *
384
 * @param ic_ptr the opened media file handle is put here
385
 * @param filename filename to open.
386
 * @param fmt if non NULL, force the file format to use
387
 * @param buf_size optional buffer size (zero if default is OK)
388
 * @param ap additionnal parameters needed when opening the file (NULL if default)
389
 * @return 0 if OK. AVERROR_xxx otherwise.
390
 */
391
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, 
392
                       AVInputFormat *fmt,
393
                       int buf_size,
394
                       AVFormatParameters *ap)
395 de6d9b64 Fabrice Bellard
{
396 da24c5e3 Fabrice Bellard
    int err, must_open_file, file_opened;
397
    uint8_t buf[PROBE_BUF_SIZE];
398 b9a281db Fabrice Bellard
    AVProbeData probe_data, *pd = &probe_data;
399 da24c5e3 Fabrice Bellard
    ByteIOContext pb1, *pb = &pb1;
400
    
401
    file_opened = 0;
402
    pd->filename = "";
403
    if (filename)
404
        pd->filename = filename;
405 b9a281db Fabrice Bellard
    pd->buf = buf;
406
    pd->buf_size = 0;
407
408
    if (!fmt) {
409
        /* guess format if no file can be opened  */
410 a25e098d Fabrice Bellard
        fmt = av_probe_input_format(pd, 0);
411 de6d9b64 Fabrice Bellard
    }
412
413 b6892136 Fabrice Bellard
    /* do not open file if the format does not need it. XXX: specific
414
       hack needed to handle RTSP/TCP */
415
    must_open_file = 1;
416 da24c5e3 Fabrice Bellard
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
417 b6892136 Fabrice Bellard
        must_open_file = 0;
418
    }
419
420
    if (!fmt || must_open_file) {
421 87a0a681 Fabrice Bellard
        /* if no file needed do not try to open one */
422 da24c5e3 Fabrice Bellard
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
423 b9a281db Fabrice Bellard
            err = AVERROR_IO;
424 96baaa6a Fabrice Bellard
            goto fail;
425 b9a281db Fabrice Bellard
        }
426 da24c5e3 Fabrice Bellard
        file_opened = 1;
427 96baaa6a Fabrice Bellard
        if (buf_size > 0) {
428 da24c5e3 Fabrice Bellard
            url_setbufsize(pb, buf_size);
429 96baaa6a Fabrice Bellard
        }
430 5b25dfa7 Fabrice Bellard
        if (!fmt) {
431
            /* read probe data */
432 da24c5e3 Fabrice Bellard
            pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
433
            url_fseek(pb, 0, SEEK_SET);
434 5b25dfa7 Fabrice Bellard
        }
435 96baaa6a Fabrice Bellard
    }
436
    
437 b9a281db Fabrice Bellard
    /* guess file format */
438
    if (!fmt) {
439 a25e098d Fabrice Bellard
        fmt = av_probe_input_format(pd, 1);
440 b9a281db Fabrice Bellard
    }
441
442
    /* if still no format found, error */
443
    if (!fmt) {
444
        err = AVERROR_NOFMT;
445 da24c5e3 Fabrice Bellard
        goto fail;
446 de6d9b64 Fabrice Bellard
    }
447 b9a281db Fabrice Bellard
        
448 67d06418 Fabrice Bellard
    /* XXX: suppress this hack for redirectors */
449 f3ec2d46 Slavik Gnatenko
#ifdef CONFIG_NETWORK
450 67d06418 Fabrice Bellard
    if (fmt == &redir_demux) {
451 da24c5e3 Fabrice Bellard
        err = redir_open(ic_ptr, pb);
452
        url_fclose(pb);
453 67d06418 Fabrice Bellard
        return err;
454
    }
455 9b2e001f Bill Eldridge
#endif
456 67d06418 Fabrice Bellard
457 87a0a681 Fabrice Bellard
    /* check filename in case of an image number is expected */
458 da24c5e3 Fabrice Bellard
    if (fmt->flags & AVFMT_NEEDNUMBER) {
459
        if (filename_number_test(filename) < 0) { 
460 87a0a681 Fabrice Bellard
            err = AVERROR_NUMEXPECTED;
461 da24c5e3 Fabrice Bellard
            goto fail;
462 87a0a681 Fabrice Bellard
        }
463
    }
464 da24c5e3 Fabrice Bellard
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
465
    if (err)
466
        goto fail;
467 b9a281db Fabrice Bellard
    return 0;
468 de6d9b64 Fabrice Bellard
 fail:
469 da24c5e3 Fabrice Bellard
    if (file_opened)
470
        url_fclose(pb);
471 b9a281db Fabrice Bellard
    *ic_ptr = NULL;
472
    return err;
473 da24c5e3 Fabrice Bellard
    
474 de6d9b64 Fabrice Bellard
}
475
476 da24c5e3 Fabrice Bellard
/*******************************************************/
477
478 b9a281db Fabrice Bellard
/**
479 fb2758c8 Fabrice Bellard
 * Read a transport packet from a media file. This function is
480
 * absolete and should never be used. Use av_read_frame() instead.
481 da24c5e3 Fabrice Bellard
 * 
482 b9a281db Fabrice Bellard
 * @param s media file handle
483
 * @param pkt is filled 
484 da24c5e3 Fabrice Bellard
 * @return 0 if OK. AVERROR_xxx if error.  
485 b9a281db Fabrice Bellard
 */
486 de6d9b64 Fabrice Bellard
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
487
{
488 fb2758c8 Fabrice Bellard
    return s->iformat->read_packet(s, pkt);
489
}
490
491
/**********************************************************/
492
493
/* convert the packet time stamp units and handle wrapping. The
494
   wrapping is handled by considering the next PTS/DTS as a delta to
495
   the previous value. We handle the delta as a fraction to avoid any
496
   rounding errors. */
497
static inline int64_t convert_timestamp_units(AVFormatContext *s,
498
                                        int64_t *plast_pkt_pts,
499
                                        int *plast_pkt_pts_frac,
500
                                        int64_t *plast_pkt_stream_pts,
501
                                        int64_t pts)
502
{
503
    int64_t stream_pts;
504
    int64_t delta_pts;
505
    int shift, pts_frac;
506
507
    if (pts != AV_NOPTS_VALUE) {
508
        stream_pts = pts;
509
        if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
510
            shift = 64 - s->pts_wrap_bits;
511
            delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
512
            /* XXX: overflow possible but very unlikely as it is a delta */
513
            delta_pts = delta_pts * AV_TIME_BASE * s->pts_num;
514
            pts = *plast_pkt_pts + (delta_pts / s->pts_den);
515
            pts_frac = *plast_pkt_pts_frac + (delta_pts % s->pts_den);
516
            if (pts_frac >= s->pts_den) {
517
                pts_frac -= s->pts_den;
518
                pts++;
519
            }
520
        } else {
521
            /* no previous pts, so no wrapping possible */
522
            pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->pts_num) / 
523
                            (double)s->pts_den);
524
            pts_frac = 0;
525
        }
526
        *plast_pkt_stream_pts = stream_pts;
527
        *plast_pkt_pts = pts;
528
        *plast_pkt_pts_frac = pts_frac;
529
    }
530
    return pts;
531
}
532
533
/* get the number of samples of an audio frame. Return (-1) if error */
534
static int get_audio_frame_size(AVCodecContext *enc, int size)
535
{
536
    int frame_size;
537
538
    if (enc->frame_size <= 1) {
539
        /* specific hack for pcm codecs because no frame size is
540
           provided */
541
        switch(enc->codec_id) {
542
        case CODEC_ID_PCM_S16LE:
543
        case CODEC_ID_PCM_S16BE:
544
        case CODEC_ID_PCM_U16LE:
545
        case CODEC_ID_PCM_U16BE:
546
            if (enc->channels == 0)
547
                return -1;
548
            frame_size = size / (2 * enc->channels);
549
            break;
550
        case CODEC_ID_PCM_S8:
551
        case CODEC_ID_PCM_U8:
552
        case CODEC_ID_PCM_MULAW:
553
        case CODEC_ID_PCM_ALAW:
554
            if (enc->channels == 0)
555
                return -1;
556
            frame_size = size / (enc->channels);
557
            break;
558
        default:
559
            /* used for example by ADPCM codecs */
560
            if (enc->bit_rate == 0)
561
                return -1;
562
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
563
            break;
564
        }
565
    } else {
566
        frame_size = enc->frame_size;
567
    }
568
    return frame_size;
569
}
570
571
572
/* return the frame duration in seconds, return 0 if not available */
573
static void compute_frame_duration(int *pnum, int *pden,
574
                                   AVFormatContext *s, AVStream *st, 
575
                                   AVCodecParserContext *pc, AVPacket *pkt)
576
{
577
    int frame_size;
578
579
    *pnum = 0;
580
    *pden = 0;
581
    switch(st->codec.codec_type) {
582
    case CODEC_TYPE_VIDEO:
583
        *pnum = st->codec.frame_rate_base;
584
        *pden = st->codec.frame_rate;
585
        if (pc && pc->repeat_pict) {
586
            *pden *= 2;
587
            *pnum = (*pnum) * (2 + pc->repeat_pict);
588
        }
589
        break;
590
    case CODEC_TYPE_AUDIO:
591
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
592
        if (frame_size < 0)
593
            break;
594
        *pnum = frame_size;
595
        *pden = st->codec.sample_rate;
596
        break;
597
    default:
598
        break;
599
    }
600
}
601
602
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, 
603
                               AVCodecParserContext *pc, AVPacket *pkt)
604
{
605
    int num, den, presentation_delayed;
606
607
    if (pkt->duration == 0) {
608
        compute_frame_duration(&num, &den, s, st, pc, pkt);
609
        if (den && num) {
610
            pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
611
        }
612
    }
613
614
    /* do we have a video B frame ? */
615
    presentation_delayed = 0;
616
    if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
617
        /* XXX: need has_b_frame, but cannot get it if the codec is
618
           not initialized */
619
        if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
620
             st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
621
             st->codec.codec_id == CODEC_ID_MPEG4 ||
622
             st->codec.codec_id == CODEC_ID_H264) && 
623
            pc && pc->pict_type != FF_B_TYPE)
624
            presentation_delayed = 1;
625
    }
626
627
    /* interpolate PTS and DTS if they are not present */
628
    if (presentation_delayed) {
629
        /* DTS = decompression time stamp */
630
        /* PTS = presentation time stamp */
631
        if (pkt->dts == AV_NOPTS_VALUE) {
632
            pkt->dts = st->cur_dts;
633
        } else {
634
            st->cur_dts = pkt->dts;
635
        }
636
        /* this is tricky: the dts must be incremented by the duration
637
           of the frame we are displaying, i.e. the last I or P frame */
638
        if (st->last_IP_duration == 0)
639
            st->cur_dts += pkt->duration;
640
        else
641
            st->cur_dts += st->last_IP_duration;
642
        st->last_IP_duration  = pkt->duration;
643
        /* cannot compute PTS if not present (we can compute it only
644
           by knowing the futur */
645
    } else {
646
        /* presentation is not delayed : PTS and DTS are the same */
647
        if (pkt->pts == AV_NOPTS_VALUE) {
648 2092bd75 Gildas Bazin
            if (pkt->dts == AV_NOPTS_VALUE) {
649
                pkt->pts = st->cur_dts;
650
                pkt->dts = st->cur_dts;
651
            }
652
            else {
653
                st->cur_dts = pkt->dts;
654
                pkt->pts = pkt->dts;
655
            }
656 fb2758c8 Fabrice Bellard
        } else {
657
            st->cur_dts = pkt->pts;
658
            pkt->dts = pkt->pts;
659
        }
660
        st->cur_dts += pkt->duration;
661
    }
662
    
663
    /* update flags */
664
    if (pc) {
665
        pkt->flags = 0;
666
        /* key frame computation */
667
        switch(st->codec.codec_type) {
668
        case CODEC_TYPE_VIDEO:
669
            if (pc->pict_type == FF_I_TYPE)
670
                pkt->flags |= PKT_FLAG_KEY;
671
            break;
672
        case CODEC_TYPE_AUDIO:
673
            pkt->flags |= PKT_FLAG_KEY;
674
            break;
675
        default:
676
            break;
677
        }
678
    }
679
680
}
681
682
static void av_destruct_packet_nofree(AVPacket *pkt)
683
{
684
    pkt->data = NULL; pkt->size = 0;
685
}
686
687
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
688
{
689
    AVStream *st;
690 37353960 Fabrice Bellard
    int len, ret, i;
691 fb2758c8 Fabrice Bellard
692
    for(;;) {
693
        /* select current input stream component */
694
        st = s->cur_st;
695
        if (st) {
696
            if (!st->parser) {
697
                /* no parsing needed: we just output the packet as is */
698
                /* raw data support */
699
                *pkt = s->cur_pkt;
700
                compute_pkt_fields(s, st, NULL, pkt);
701
                s->cur_st = NULL;
702
                return 0;
703
            } else if (s->cur_len > 0) {
704
                len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size, 
705 6ec87caa Fabrice Bellard
                                      s->cur_ptr, s->cur_len,
706
                                      s->cur_pkt.pts, s->cur_pkt.dts);
707
                s->cur_pkt.pts = AV_NOPTS_VALUE;
708
                s->cur_pkt.dts = AV_NOPTS_VALUE;
709 fb2758c8 Fabrice Bellard
                /* increment read pointer */
710
                s->cur_ptr += len;
711
                s->cur_len -= len;
712
                
713
                /* return packet if any */
714
                if (pkt->size) {
715 37353960 Fabrice Bellard
                got_packet:
716 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
717
                    pkt->stream_index = st->index;
718 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
719
                    pkt->dts = st->parser->dts;
720 fb2758c8 Fabrice Bellard
                    pkt->destruct = av_destruct_packet_nofree;
721
                    compute_pkt_fields(s, st, st->parser, pkt);
722
                    return 0;
723
                }
724
            } else {
725 bcbecff1 Fabrice Bellard
                /* free packet */
726
                av_free_packet(&s->cur_pkt); 
727 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
728
            }
729
        } else {
730
            /* read next packet */
731
            ret = av_read_packet(s, &s->cur_pkt);
732 37353960 Fabrice Bellard
            if (ret < 0) {
733
                if (ret == -EAGAIN)
734
                    return ret;
735
                /* return the last frames, if any */
736
                for(i = 0; i < s->nb_streams; i++) {
737
                    st = s->streams[i];
738
                    if (st->parser) {
739
                        av_parser_parse(st->parser, &st->codec, 
740
                                        &pkt->data, &pkt->size, 
741 6ec87caa Fabrice Bellard
                                        NULL, 0, 
742
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
743 37353960 Fabrice Bellard
                        if (pkt->size)
744
                            goto got_packet;
745
                    }
746
                }
747
                /* no more packets: really terminates parsing */
748 fb2758c8 Fabrice Bellard
                return ret;
749 37353960 Fabrice Bellard
            }
750 fb2758c8 Fabrice Bellard
751
            /* convert the packet time stamp units and handle wrapping */
752
            s->cur_pkt.pts = convert_timestamp_units(s, 
753
                                               &s->last_pkt_pts, &s->last_pkt_pts_frac,
754
                                               &s->last_pkt_stream_pts,
755
                                               s->cur_pkt.pts);
756
            s->cur_pkt.dts = convert_timestamp_units(s, 
757
                                               &s->last_pkt_dts,  &s->last_pkt_dts_frac,
758
                                               &s->last_pkt_stream_dts,
759
                                               s->cur_pkt.dts);
760
#if 0
761 6ec87caa Fabrice Bellard
            if (s->cur_pkt.stream_index == 0) {
762 fb2758c8 Fabrice Bellard
                if (s->cur_pkt.pts != AV_NOPTS_VALUE) 
763
                    printf("PACKET pts=%0.3f\n", 
764
                           (double)s->cur_pkt.pts / AV_TIME_BASE);
765
                if (s->cur_pkt.dts != AV_NOPTS_VALUE) 
766
                    printf("PACKET dts=%0.3f\n", 
767
                           (double)s->cur_pkt.dts / AV_TIME_BASE);
768
            }
769
#endif
770
            
771
            /* duration field */
772
            if (s->cur_pkt.duration != 0) {
773
                s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) / 
774
                    s->pts_den;
775
            }
776
777
            st = s->streams[s->cur_pkt.stream_index];
778
            s->cur_st = st;
779
            s->cur_ptr = s->cur_pkt.data;
780
            s->cur_len = s->cur_pkt.size;
781
            if (st->need_parsing && !st->parser) {
782
                st->parser = av_parser_init(st->codec.codec_id);
783
                if (!st->parser) {
784
                    /* no parser available : just output the raw packets */
785
                    st->need_parsing = 0;
786
                }
787
            }
788
        }
789
    }
790
}
791
792
/**
793
 * Return the next frame of a stream. The returned packet is valid
794
 * until the next av_read_frame() or until av_close_input_file() and
795
 * must be freed with av_free_packet. For video, the packet contains
796
 * exactly one frame. For audio, it contains an integer number of
797
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
798
 * data). If the audio frames have a variable size (e.g. MPEG audio),
799
 * then it contains one frame.
800
 * 
801
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
802
 * values in AV_TIME_BASE unit (and guessed if the format cannot
803
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
804
 * has B frames, so it is better to rely on pkt->dts if you do not
805
 * decompress the payload.
806
 * 
807
 * Return 0 if OK, < 0 if error or end of file.  
808
 */
809
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
810
{
811 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
812
813
    pktl = s->packet_buffer;
814
    if (pktl) {
815
        /* read packet from packet buffer, if there is data */
816
        *pkt = pktl->pkt;
817
        s->packet_buffer = pktl->next;
818 1ea4f593 Fabrice Bellard
        av_free(pktl);
819 de6d9b64 Fabrice Bellard
        return 0;
820
    } else {
821 fb2758c8 Fabrice Bellard
        return av_read_frame_internal(s, pkt);
822
    }
823
}
824
825
/* XXX: suppress the packet queue */
826
static void flush_packet_queue(AVFormatContext *s)
827
{
828
    AVPacketList *pktl;
829
830
    for(;;) {
831
        pktl = s->packet_buffer;
832
        if (!pktl) 
833
            break;
834
        s->packet_buffer = pktl->next;
835
        av_free_packet(&pktl->pkt);
836
        av_free(pktl);
837 b9a281db Fabrice Bellard
    }
838
}
839
840 da24c5e3 Fabrice Bellard
/*******************************************************/
841 fb2758c8 Fabrice Bellard
/* seek support */
842
843 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
844
{
845
    int i;
846
    AVStream *st;
847
848
    if (s->nb_streams <= 0)
849
        return -1;
850
    for(i = 0; i < s->nb_streams; i++) {
851
        st = s->streams[i];
852
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
853
            return i;
854
        }
855
    }
856
    return 0;
857
}
858
859 fb2758c8 Fabrice Bellard
/* flush the frame reader */
860
static void av_read_frame_flush(AVFormatContext *s)
861
{
862
    AVStream *st;
863
    int i;
864
865
    flush_packet_queue(s);
866
867
    /* free previous packet */
868
    if (s->cur_st) {
869
        if (s->cur_st->parser)
870
            av_free_packet(&s->cur_pkt);
871
        s->cur_st = NULL;
872
    }
873
    /* fail safe */
874
    s->cur_ptr = NULL;
875
    s->cur_len = 0;
876
    
877
    /* for each stream, reset read state */
878
    for(i = 0; i < s->nb_streams; i++) {
879
        st = s->streams[i];
880
        
881
        if (st->parser) {
882
            av_parser_close(st->parser);
883
            st->parser = NULL;
884
        }
885
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
886
    }
887
}
888
889 b754978a Michael Niedermayer
/* add a index entry into a sorted list updateing if it is already there */
890 3e9245a9 Michael Niedermayer
int av_add_index_entry(AVStream *st,
891
                            int64_t pos, int64_t timestamp, int distance, int flags)
892 fb2758c8 Fabrice Bellard
{
893
    AVIndexEntry *entries, *ie;
894 b754978a Michael Niedermayer
    int index;
895 fb2758c8 Fabrice Bellard
    
896
    entries = av_fast_realloc(st->index_entries,
897
                              &st->index_entries_allocated_size,
898
                              (st->nb_index_entries + 1) * 
899
                              sizeof(AVIndexEntry));
900 b754978a Michael Niedermayer
    st->index_entries= entries;
901
902
    if(st->nb_index_entries){
903
        index= av_index_search_timestamp(st, timestamp);
904
        ie= &entries[index];
905
906
        if(ie->timestamp != timestamp){
907
            if(ie->timestamp < timestamp){
908
                index++; //index points to next instead of previous entry, maybe nonexistant
909
                ie= &st->index_entries[index];
910
            }else
911
                assert(index==0);
912
                
913
            if(index != st->nb_index_entries){
914
                assert(index < st->nb_index_entries);
915
                memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
916
            }
917
            st->nb_index_entries++;
918
        }
919 3e9245a9 Michael Niedermayer
    }else{
920
        index= st->nb_index_entries++;
921
        ie= &entries[index];
922
    }
923 b754978a Michael Niedermayer
    
924
    ie->pos = pos;
925
    ie->timestamp = timestamp;
926 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
927 b754978a Michael Niedermayer
    ie->flags = flags;
928 3e9245a9 Michael Niedermayer
    
929
    return index;
930 fb2758c8 Fabrice Bellard
}
931
932
/* build an index for raw streams using a parser */
933
static void av_build_index_raw(AVFormatContext *s)
934
{
935
    AVPacket pkt1, *pkt = &pkt1;
936
    int ret;
937
    AVStream *st;
938
939
    st = s->streams[0];
940
    av_read_frame_flush(s);
941
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
942
943
    for(;;) {
944
        ret = av_read_frame(s, pkt);
945
        if (ret < 0)
946
            break;
947
        if (pkt->stream_index == 0 && st->parser &&
948
            (pkt->flags & PKT_FLAG_KEY)) {
949 b754978a Michael Niedermayer
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts, 
950 3e9245a9 Michael Niedermayer
                            0, AVINDEX_KEYFRAME);
951 fb2758c8 Fabrice Bellard
        }
952
        av_free_packet(pkt);
953
    }
954
}
955
956
/* return TRUE if we deal with a raw stream (raw codec data and
957
   parsing needed) */
958
static int is_raw_stream(AVFormatContext *s)
959
{
960
    AVStream *st;
961
962
    if (s->nb_streams != 1)
963
        return 0;
964
    st = s->streams[0];
965
    if (!st->need_parsing)
966
        return 0;
967
    return 1;
968
}
969
970
/* return the largest index entry whose timestamp is <=
971
   wanted_timestamp */
972 b754978a Michael Niedermayer
int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
973 fb2758c8 Fabrice Bellard
{
974 b754978a Michael Niedermayer
    AVIndexEntry *entries= st->index_entries;
975
    int nb_entries= st->nb_index_entries;
976 fb2758c8 Fabrice Bellard
    int a, b, m;
977
    int64_t timestamp;
978
979
    if (nb_entries <= 0)
980
        return -1;
981
    
982
    a = 0;
983
    b = nb_entries - 1;
984 b754978a Michael Niedermayer
985
    while (a < b) {
986
        m = (a + b + 1) >> 1;
987 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
988 b754978a Michael Niedermayer
        if (timestamp > wanted_timestamp) {
989 fb2758c8 Fabrice Bellard
            b = m - 1;
990
        } else {
991 b754978a Michael Niedermayer
            a = m;
992 fb2758c8 Fabrice Bellard
        }
993
    }
994 b754978a Michael Niedermayer
    return a;
995 fb2758c8 Fabrice Bellard
}
996
997
static int av_seek_frame_generic(AVFormatContext *s, 
998
                                 int stream_index, int64_t timestamp)
999
{
1000
    int index;
1001
    AVStream *st;
1002
    AVIndexEntry *ie;
1003
1004
    if (!s->index_built) {
1005
        if (is_raw_stream(s)) {
1006
            av_build_index_raw(s);
1007
        } else {
1008
            return -1;
1009
        }
1010
        s->index_built = 1;
1011
    }
1012
1013
    if (stream_index < 0)
1014
        stream_index = 0;
1015
    st = s->streams[stream_index];
1016 b754978a Michael Niedermayer
    index = av_index_search_timestamp(st, timestamp);
1017 fb2758c8 Fabrice Bellard
    if (index < 0)
1018
        return -1;
1019
1020
    /* now we have found the index, we can seek */
1021
    ie = &st->index_entries[index];
1022
    av_read_frame_flush(s);
1023
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1024
    st->cur_dts = ie->timestamp;
1025
    return 0;
1026
}
1027
1028
/**
1029
 * Seek to the key frame just before the frame at timestamp
1030
 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1031
 * stream is selected 
1032
 */
1033
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1034
{
1035
    int ret;
1036
    
1037
    av_read_frame_flush(s);
1038
1039
    /* first, we try the format specific seek */
1040
    if (s->iformat->read_seek)
1041
        ret = s->iformat->read_seek(s, stream_index, timestamp);
1042
    else
1043
        ret = -1;
1044
    if (ret >= 0) {
1045
        return 0;
1046
    }
1047
    
1048
    return av_seek_frame_generic(s, stream_index, timestamp);
1049
}
1050
1051
/*******************************************************/
1052 12f996ed Fabrice Bellard
1053
/* return TRUE if the stream has accurate timings for at least one component */
1054
static int av_has_timings(AVFormatContext *ic)
1055
{
1056
    int i;
1057
    AVStream *st;
1058
1059
    for(i = 0;i < ic->nb_streams; i++) {
1060
        st = ic->streams[i];
1061
        if (st->start_time != AV_NOPTS_VALUE &&
1062
            st->duration != AV_NOPTS_VALUE)
1063
            return 1;
1064
    }
1065
    return 0;
1066
}
1067
1068
/* estimate the stream timings from the one of each components. Also
1069
   compute the global bitrate if possible */
1070
static void av_update_stream_timings(AVFormatContext *ic)
1071
{
1072
    int64_t start_time, end_time, end_time1;
1073
    int i;
1074
    AVStream *st;
1075
1076
    start_time = MAXINT64;
1077
    end_time = MININT64;
1078
    for(i = 0;i < ic->nb_streams; i++) {
1079
        st = ic->streams[i];
1080
        if (st->start_time != AV_NOPTS_VALUE) {
1081
            if (st->start_time < start_time)
1082
                start_time = st->start_time;
1083
            if (st->duration != AV_NOPTS_VALUE) {
1084
                end_time1 = st->start_time + st->duration;
1085
                if (end_time1 > end_time)
1086
                    end_time = end_time1;
1087
            }
1088
        }
1089
    }
1090
    if (start_time != MAXINT64) {
1091
        ic->start_time = start_time;
1092
        if (end_time != MAXINT64) {
1093
            ic->duration = end_time - start_time;
1094
            if (ic->file_size > 0) {
1095
                /* compute the bit rate */
1096
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1097
                    (double)ic->duration;
1098
            }
1099
        }
1100
    }
1101
1102
}
1103
1104
static void fill_all_stream_timings(AVFormatContext *ic)
1105
{
1106
    int i;
1107
    AVStream *st;
1108
1109
    av_update_stream_timings(ic);
1110
    for(i = 0;i < ic->nb_streams; i++) {
1111
        st = ic->streams[i];
1112
        if (st->start_time == AV_NOPTS_VALUE) {
1113
            st->start_time = ic->start_time;
1114
            st->duration = ic->duration;
1115
        }
1116
    }
1117
}
1118
1119
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1120
{
1121
    int64_t filesize, duration;
1122
    int bit_rate, i;
1123
    AVStream *st;
1124
1125
    /* if bit_rate is already set, we believe it */
1126
    if (ic->bit_rate == 0) {
1127
        bit_rate = 0;
1128
        for(i=0;i<ic->nb_streams;i++) {
1129
            st = ic->streams[i];
1130
            bit_rate += st->codec.bit_rate;
1131
        }
1132
        ic->bit_rate = bit_rate;
1133
    }
1134
1135
    /* if duration is already set, we believe it */
1136
    if (ic->duration == AV_NOPTS_VALUE && 
1137
        ic->bit_rate != 0 && 
1138
        ic->file_size != 0)  {
1139
        filesize = ic->file_size;
1140
        if (filesize > 0) {
1141
            duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1142
            for(i = 0; i < ic->nb_streams; i++) {
1143
                st = ic->streams[i];
1144
                if (st->start_time == AV_NOPTS_VALUE ||
1145
                    st->duration == AV_NOPTS_VALUE) {
1146
                    st->start_time = 0;
1147
                    st->duration = duration;
1148
                }
1149
            }
1150
        }
1151
    }
1152
}
1153
1154
#define DURATION_MAX_READ_SIZE 250000
1155
1156
/* only usable for MPEG-PS streams */
1157
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1158
{
1159
    AVPacket pkt1, *pkt = &pkt1;
1160
    AVStream *st;
1161
    int read_size, i, ret;
1162
    int64_t start_time, end_time, end_time1;
1163
    int64_t filesize, offset, duration;
1164
    
1165 fb2758c8 Fabrice Bellard
    /* free previous packet */
1166
    if (ic->cur_st && ic->cur_st->parser)
1167
        av_free_packet(&ic->cur_pkt); 
1168
    ic->cur_st = NULL;
1169
1170
    /* flush packet queue */
1171
    flush_packet_queue(ic);
1172
    
1173
1174 12f996ed Fabrice Bellard
    /* we read the first packets to get the first PTS (not fully
1175
       accurate, but it is enough now) */
1176
    url_fseek(&ic->pb, 0, SEEK_SET);
1177
    read_size = 0;
1178
    for(;;) {
1179
        if (read_size >= DURATION_MAX_READ_SIZE)
1180
            break;
1181
        /* if all info is available, we can stop */
1182
        for(i = 0;i < ic->nb_streams; i++) {
1183
            st = ic->streams[i];
1184
            if (st->start_time == AV_NOPTS_VALUE)
1185
                break;
1186
        }
1187
        if (i == ic->nb_streams)
1188
            break;
1189
1190
        ret = av_read_packet(ic, pkt);
1191
        if (ret != 0)
1192
            break;
1193
        read_size += pkt->size;
1194
        st = ic->streams[pkt->stream_index];
1195
        if (pkt->pts != AV_NOPTS_VALUE) {
1196
            if (st->start_time == AV_NOPTS_VALUE)
1197
                st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1198 0a5f92a1 Michael Niedermayer
        }
1199
        av_free_packet(pkt);
1200
    }
1201 12f996ed Fabrice Bellard
1202
    /* we compute the minimum start_time and use it as default */
1203
    start_time = MAXINT64;
1204
    for(i = 0; i < ic->nb_streams; i++) {
1205
        st = ic->streams[i];
1206
        if (st->start_time != AV_NOPTS_VALUE &&
1207
            st->start_time < start_time)
1208
            start_time = st->start_time;
1209
    }
1210
    if (start_time != MAXINT64)
1211
        ic->start_time = start_time;
1212
    
1213
    /* estimate the end time (duration) */
1214
    /* XXX: may need to support wrapping */
1215
    filesize = ic->file_size;
1216
    offset = filesize - DURATION_MAX_READ_SIZE;
1217
    if (offset < 0)
1218
        offset = 0;
1219
1220
    url_fseek(&ic->pb, offset, SEEK_SET);
1221
    read_size = 0;
1222
    for(;;) {
1223
        if (read_size >= DURATION_MAX_READ_SIZE)
1224
            break;
1225
        /* if all info is available, we can stop */
1226
        for(i = 0;i < ic->nb_streams; i++) {
1227
            st = ic->streams[i];
1228
            if (st->duration == AV_NOPTS_VALUE)
1229
                break;
1230
        }
1231
        if (i == ic->nb_streams)
1232
            break;
1233
        
1234
        ret = av_read_packet(ic, pkt);
1235
        if (ret != 0)
1236
            break;
1237
        read_size += pkt->size;
1238
        st = ic->streams[pkt->stream_index];
1239
        if (pkt->pts != AV_NOPTS_VALUE) {
1240
            end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1241
            duration = end_time - st->start_time;
1242
            if (duration > 0) {
1243
                if (st->duration == AV_NOPTS_VALUE ||
1244
                    st->duration < duration)
1245
                    st->duration = duration;
1246
            }
1247
        }
1248
        av_free_packet(pkt);
1249
    }
1250
    
1251
    /* estimate total duration */
1252
    end_time = MININT64;
1253
    for(i = 0;i < ic->nb_streams; i++) {
1254
        st = ic->streams[i];
1255
        if (st->duration != AV_NOPTS_VALUE) {
1256
            end_time1 = st->start_time + st->duration;
1257
            if (end_time1 > end_time)
1258
                end_time = end_time1;
1259
        }
1260
    }
1261
    
1262
    /* update start_time (new stream may have been created, so we do
1263
       it at the end */
1264
    if (ic->start_time != AV_NOPTS_VALUE) {
1265
        for(i = 0; i < ic->nb_streams; i++) {
1266
            st = ic->streams[i];
1267
            if (st->start_time == AV_NOPTS_VALUE)
1268
                st->start_time = ic->start_time;
1269
        }
1270
    }
1271
1272
    if (end_time != MININT64) {
1273
        /* put dummy values for duration if needed */
1274
        for(i = 0;i < ic->nb_streams; i++) {
1275
            st = ic->streams[i];
1276
            if (st->duration == AV_NOPTS_VALUE && 
1277
                st->start_time != AV_NOPTS_VALUE)
1278
                st->duration = end_time - st->start_time;
1279
        }
1280
        ic->duration = end_time - ic->start_time;
1281
    }
1282
1283
    url_fseek(&ic->pb, 0, SEEK_SET);
1284
}
1285
1286
static void av_estimate_timings(AVFormatContext *ic)
1287
{
1288
    URLContext *h;
1289
    int64_t file_size;
1290
1291
    /* get the file size, if possible */
1292
    if (ic->iformat->flags & AVFMT_NOFILE) {
1293
        file_size = 0;
1294
    } else {
1295
        h = url_fileno(&ic->pb);
1296
        file_size = url_filesize(h);
1297
        if (file_size < 0)
1298
            file_size = 0;
1299
    }
1300
    ic->file_size = file_size;
1301
1302
    if (ic->iformat == &mpegps_demux) {
1303
        /* get accurate estimate from the PTSes */
1304
        av_estimate_timings_from_pts(ic);
1305
    } else if (av_has_timings(ic)) {
1306
        /* at least one components has timings - we use them for all
1307
           the components */
1308
        fill_all_stream_timings(ic);
1309
    } else {
1310
        /* less precise: use bit rate info */
1311
        av_estimate_timings_from_bit_rate(ic);
1312
    }
1313
    av_update_stream_timings(ic);
1314
1315
#if 0
1316
    {
1317
        int i;
1318
        AVStream *st;
1319
        for(i = 0;i < ic->nb_streams; i++) {
1320
            st = ic->streams[i];
1321
        printf("%d: start_time: %0.3f duration: %0.3f\n", 
1322
               i, (double)st->start_time / AV_TIME_BASE, 
1323
               (double)st->duration / AV_TIME_BASE);
1324
        }
1325
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1326
               (double)ic->start_time / AV_TIME_BASE, 
1327
               (double)ic->duration / AV_TIME_BASE,
1328
               ic->bit_rate / 1000);
1329
    }
1330
#endif
1331
}
1332
1333 b9a281db Fabrice Bellard
static int has_codec_parameters(AVCodecContext *enc)
1334
{
1335
    int val;
1336
    switch(enc->codec_type) {
1337
    case CODEC_TYPE_AUDIO:
1338
        val = enc->sample_rate;
1339
        break;
1340
    case CODEC_TYPE_VIDEO:
1341
        val = enc->width;
1342
        break;
1343
    default:
1344
        val = 1;
1345
        break;
1346
    }
1347
    return (val != 0);
1348
}
1349
1350 fb2758c8 Fabrice Bellard
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1351
{
1352
    int16_t *samples;
1353
    AVCodec *codec;
1354
    int got_picture, ret;
1355
    AVFrame picture;
1356
    
1357
    codec = avcodec_find_decoder(st->codec.codec_id);
1358
    if (!codec)
1359
        return -1;
1360
    ret = avcodec_open(&st->codec, codec);
1361
    if (ret < 0)
1362
        return ret;
1363
    switch(st->codec.codec_type) {
1364
    case CODEC_TYPE_VIDEO:
1365
        ret = avcodec_decode_video(&st->codec, &picture, 
1366
                                   &got_picture, (uint8_t *)data, size);
1367
        break;
1368
    case CODEC_TYPE_AUDIO:
1369
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1370
        if (!samples)
1371
            goto fail;
1372
        ret = avcodec_decode_audio(&st->codec, samples, 
1373
                                   &got_picture, (uint8_t *)data, size);
1374
        av_free(samples);
1375
        break;
1376
    default:
1377
        break;
1378
    }
1379
 fail:
1380
    avcodec_close(&st->codec);
1381
    return ret;
1382
}
1383
1384
/* absolute maximum size we read until we abort */
1385
#define MAX_READ_SIZE        5000000
1386
1387
/* maximum duration until we stop analysing the stream */
1388
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1389
1390 b9a281db Fabrice Bellard
/**
1391
 * Read the beginning of a media file to get stream information. This
1392
 * is useful for file formats with no headers such as MPEG. This
1393
 * function also compute the real frame rate in case of mpeg2 repeat
1394
 * frame mode.
1395
 *
1396
 * @param ic media file handle
1397
 * @return >=0 if OK. AVERROR_xxx if error.  
1398
 */
1399
int av_find_stream_info(AVFormatContext *ic)
1400
{
1401 fb2758c8 Fabrice Bellard
    int i, count, ret, read_size;
1402 b9a281db Fabrice Bellard
    AVStream *st;
1403 fb2758c8 Fabrice Bellard
    AVPacket pkt1, *pkt;
1404 b9a281db Fabrice Bellard
    AVPacketList *pktl=NULL, **ppktl;
1405
1406
    count = 0;
1407
    read_size = 0;
1408
    ppktl = &ic->packet_buffer;
1409
    for(;;) {
1410
        /* check if one codec still needs to be handled */
1411
        for(i=0;i<ic->nb_streams;i++) {
1412
            st = ic->streams[i];
1413 fb2758c8 Fabrice Bellard
            if (!has_codec_parameters(&st->codec))
1414 b9a281db Fabrice Bellard
                break;
1415
        }
1416
        if (i == ic->nb_streams) {
1417
            /* NOTE: if the format has no header, then we need to read
1418
               some packets to get most of the streams, so we cannot
1419
               stop here */
1420 fb2758c8 Fabrice Bellard
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1421 b9a281db Fabrice Bellard
                /* if we found the info for all the codecs, we can stop */
1422
                ret = count;
1423
                break;
1424
            }
1425
        } else {
1426
            /* we did not get all the codec info, but we read too much data */
1427 fb2758c8 Fabrice Bellard
            if (read_size >= MAX_READ_SIZE) {
1428 b9a281db Fabrice Bellard
                ret = count;
1429
                break;
1430
            }
1431
        }
1432
1433 fb2758c8 Fabrice Bellard
        /* NOTE: a new stream can be added there if no header in file
1434
           (AVFMTCTX_NOHEADER) */
1435
        ret = av_read_frame_internal(ic, &pkt1);
1436
        if (ret < 0) {
1437
            /* EOF or error */
1438
            ret = -1; /* we could not have all the codec parameters before EOF */
1439
            if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1440
                i == ic->nb_streams)
1441
                ret = 0;
1442
            break;
1443
        }
1444
1445 b9a281db Fabrice Bellard
        pktl = av_mallocz(sizeof(AVPacketList));
1446
        if (!pktl) {
1447
            ret = AVERROR_NOMEM;
1448
            break;
1449
        }
1450
1451
        /* add the packet in the buffered packet list */
1452
        *ppktl = pktl;
1453
        ppktl = &pktl->next;
1454
1455
        pkt = &pktl->pkt;
1456 fb2758c8 Fabrice Bellard
        *pkt = pkt1;
1457
        
1458
        /* duplicate the packet */
1459
        if (av_dup_packet(pkt) < 0) {
1460
                ret = AVERROR_NOMEM;
1461
                break;
1462 b9a281db Fabrice Bellard
        }
1463
1464 fb2758c8 Fabrice Bellard
        read_size += pkt->size;
1465 b9a281db Fabrice Bellard
1466
        st = ic->streams[pkt->stream_index];
1467 fb2758c8 Fabrice Bellard
        st->codec_info_duration += pkt->duration;
1468
        if (pkt->duration != 0)
1469
            st->codec_info_nb_frames++;
1470
1471
        /* if still no information, we try to open the codec and to
1472
           decompress the frame. We try to avoid that in most cases as
1473
           it takes longer and uses more memory. For MPEG4, we need to
1474
           decompress for Quicktime. */
1475
        if (!has_codec_parameters(&st->codec) &&
1476
            (st->codec.codec_id == CODEC_ID_FLV1 ||
1477
             st->codec.codec_id == CODEC_ID_H264 ||
1478
             st->codec.codec_id == CODEC_ID_H263 ||
1479 8bfed902 Michael Niedermayer
             st->codec.codec_id == CODEC_ID_VORBIS ||
1480 fb2758c8 Fabrice Bellard
             (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1481
            try_decode_frame(st, pkt->data, pkt->size);
1482
        
1483
        if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1484
            break;
1485 b9a281db Fabrice Bellard
        }
1486
        count++;
1487
    }
1488
1489
    /* set real frame rate info */
1490
    for(i=0;i<ic->nb_streams;i++) {
1491
        st = ic->streams[i];
1492
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1493 fb2758c8 Fabrice Bellard
            /* compute the real frame rate for telecine */
1494
            if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1495
                 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1496
                st->codec.sub_id == 2) {
1497
                if (st->codec_info_nb_frames >= 20) {
1498
                    float coded_frame_rate, est_frame_rate;
1499
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1500
                        (double)st->codec_info_duration ;
1501
                    coded_frame_rate = (double)st->codec.frame_rate /
1502
                        (double)st->codec.frame_rate_base;
1503
#if 0
1504
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1505
                           coded_frame_rate, est_frame_rate);
1506
#endif
1507
                    /* if we detect that it could be a telecine, we
1508
                       signal it. It would be better to do it at a
1509
                       higher level as it can change in a film */
1510
                    if (coded_frame_rate >= 24.97 && 
1511
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1512
                        st->r_frame_rate = 24024;
1513
                        st->r_frame_rate_base = 1001;
1514
                    }
1515
                }
1516
            }
1517
            /* if no real frame rate, use the codec one */
1518 14bea432 Michael Niedermayer
            if (!st->r_frame_rate){
1519
                st->r_frame_rate      = st->codec.frame_rate;
1520
                st->r_frame_rate_base = st->codec.frame_rate_base;
1521
            }
1522 b9a281db Fabrice Bellard
        }
1523 de6d9b64 Fabrice Bellard
    }
1524 b9a281db Fabrice Bellard
1525 12f996ed Fabrice Bellard
    av_estimate_timings(ic);
1526 b9a281db Fabrice Bellard
    return ret;
1527 de6d9b64 Fabrice Bellard
}
1528
1529 fb2758c8 Fabrice Bellard
/*******************************************************/
1530
1531
/**
1532
 * start playing a network based stream (e.g. RTSP stream) at the
1533
 * current position 
1534
 */
1535
int av_read_play(AVFormatContext *s)
1536
{
1537
    if (!s->iformat->read_play)
1538
        return AVERROR_NOTSUPP;
1539
    return s->iformat->read_play(s);
1540
}
1541
1542
/**
1543
 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1544
 * to resume it.
1545
 */
1546
int av_read_pause(AVFormatContext *s)
1547
{
1548
    if (!s->iformat->read_pause)
1549
        return AVERROR_NOTSUPP;
1550
    return s->iformat->read_pause(s);
1551
}
1552
1553 b9a281db Fabrice Bellard
/**
1554
 * Close a media file (but not its codecs)
1555
 *
1556
 * @param s media file handle
1557
 */
1558 de6d9b64 Fabrice Bellard
void av_close_input_file(AVFormatContext *s)
1559
{
1560 b6892136 Fabrice Bellard
    int i, must_open_file;
1561 da24c5e3 Fabrice Bellard
    AVStream *st;
1562 de6d9b64 Fabrice Bellard
1563 fb2758c8 Fabrice Bellard
    /* free previous packet */
1564
    if (s->cur_st && s->cur_st->parser)
1565
        av_free_packet(&s->cur_pkt); 
1566
1567 b9a281db Fabrice Bellard
    if (s->iformat->read_close)
1568
        s->iformat->read_close(s);
1569 de6d9b64 Fabrice Bellard
    for(i=0;i<s->nb_streams;i++) {
1570 da24c5e3 Fabrice Bellard
        /* free all data in a stream component */
1571
        st = s->streams[i];
1572 fb2758c8 Fabrice Bellard
        if (st->parser) {
1573
            av_parser_close(st->parser);
1574 de6d9b64 Fabrice Bellard
        }
1575 fb2758c8 Fabrice Bellard
        av_free(st->index_entries);
1576
        av_free(st);
1577 de6d9b64 Fabrice Bellard
    }
1578 fb2758c8 Fabrice Bellard
    flush_packet_queue(s);
1579 b6892136 Fabrice Bellard
    must_open_file = 1;
1580 da24c5e3 Fabrice Bellard
    if (s->iformat->flags & AVFMT_NOFILE) {
1581 b6892136 Fabrice Bellard
        must_open_file = 0;
1582
    }
1583
    if (must_open_file) {
1584 96baaa6a Fabrice Bellard
        url_fclose(&s->pb);
1585
    }
1586 a8dbe951 Philip Gladstone
    av_freep(&s->priv_data);
1587 1ea4f593 Fabrice Bellard
    av_free(s);
1588 de6d9b64 Fabrice Bellard
}
1589
1590 b9a281db Fabrice Bellard
/**
1591
 * Add a new stream to a media file. Can only be called in the
1592 da24c5e3 Fabrice Bellard
 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1593
 * format context, then new streams can be added in read_packet too.
1594 b9a281db Fabrice Bellard
 *
1595
 *
1596
 * @param s media file handle
1597 da24c5e3 Fabrice Bellard
 * @param id file format dependent stream id 
1598 b9a281db Fabrice Bellard
 */
1599
AVStream *av_new_stream(AVFormatContext *s, int id)
1600
{
1601
    AVStream *st;
1602
1603
    if (s->nb_streams >= MAX_STREAMS)
1604
        return NULL;
1605
1606
    st = av_mallocz(sizeof(AVStream));
1607
    if (!st)
1608
        return NULL;
1609 1e491e29 Michael Niedermayer
    avcodec_get_context_defaults(&st->codec);
1610 48091512 Fabrice Bellard
    if (s->iformat) {
1611
        /* no default bitrate if decoding */
1612
        st->codec.bit_rate = 0;
1613
    }
1614 b9a281db Fabrice Bellard
    st->index = s->nb_streams;
1615
    st->id = id;
1616 12f996ed Fabrice Bellard
    st->start_time = AV_NOPTS_VALUE;
1617
    st->duration = AV_NOPTS_VALUE;
1618 b9a281db Fabrice Bellard
    s->streams[s->nb_streams++] = st;
1619
    return st;
1620
}
1621
1622
/************************************************************/
1623
/* output media file */
1624 de6d9b64 Fabrice Bellard
1625 87a0a681 Fabrice Bellard
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1626
{
1627
    int ret;
1628 98486a6b Roman Shaposhnik
    
1629
    if (s->oformat->priv_data_size > 0) {
1630
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
1631
        if (!s->priv_data)
1632
            return AVERROR_NOMEM;
1633
    } else
1634
        s->priv_data = NULL;
1635
        
1636 87a0a681 Fabrice Bellard
    if (s->oformat->set_parameters) {
1637
        ret = s->oformat->set_parameters(s, ap);
1638
        if (ret < 0)
1639
            return ret;
1640
    }
1641
    return 0;
1642
}
1643
1644 b9a281db Fabrice Bellard
/**
1645
 * allocate the stream private data and write the stream header to an
1646
 * output media file
1647
 *
1648
 * @param s media file handle
1649
 * @return 0 if OK. AVERROR_xxx if error.  
1650
 */
1651
int av_write_header(AVFormatContext *s)
1652
{
1653 1e51d801 Fabrice Bellard
    int ret, i;
1654
    AVStream *st;
1655
1656 916c80e9 Fabrice Bellard
    /* default pts settings is MPEG like */
1657
    av_set_pts_info(s, 33, 1, 90000);
1658 1e51d801 Fabrice Bellard
    ret = s->oformat->write_header(s);
1659
    if (ret < 0)
1660
        return ret;
1661
1662
    /* init PTS generation */
1663
    for(i=0;i<s->nb_streams;i++) {
1664
        st = s->streams[i];
1665
1666
        switch (st->codec.codec_type) {
1667
        case CODEC_TYPE_AUDIO:
1668
            av_frac_init(&st->pts, 0, 0, 
1669 0c1a9eda Zdenek Kabelac
                         (int64_t)s->pts_num * st->codec.sample_rate);
1670 1e51d801 Fabrice Bellard
            break;
1671
        case CODEC_TYPE_VIDEO:
1672
            av_frac_init(&st->pts, 0, 0, 
1673 0c1a9eda Zdenek Kabelac
                         (int64_t)s->pts_num * st->codec.frame_rate);
1674 1e51d801 Fabrice Bellard
            break;
1675
        default:
1676
            break;
1677
        }
1678
    }
1679
    return 0;
1680 b9a281db Fabrice Bellard
}
1681
1682
/**
1683 1e51d801 Fabrice Bellard
 * Write a packet to an output media file. The packet shall contain
1684
 * one audio or video frame.
1685 b9a281db Fabrice Bellard
 *
1686
 * @param s media file handle
1687 1e51d801 Fabrice Bellard
 * @param stream_index stream index
1688
 * @param buf buffer containing the frame data
1689
 * @param size size of buffer
1690 d4c0ff91 Fabrice Bellard
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1691 b9a281db Fabrice Bellard
 */
1692 1e51d801 Fabrice Bellard
int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf, 
1693
                   int size)
1694 de6d9b64 Fabrice Bellard
{
1695 1e51d801 Fabrice Bellard
    AVStream *st;
1696 0c1a9eda Zdenek Kabelac
    int64_t pts_mask;
1697 7feb950a Fabrice Bellard
    int ret, frame_size;
1698 1e51d801 Fabrice Bellard
1699
    st = s->streams[stream_index];
1700
    pts_mask = (1LL << s->pts_wrap_bits) - 1;
1701 b0c7f5a9 Michael Niedermayer
1702
    /* HACK/FIXME we skip all zero size audio packets so a encoder can pass pts by outputing zero size packets */
1703
    if(st->codec.codec_type==CODEC_TYPE_AUDIO && size==0)
1704
        ret = 0;
1705
    else
1706
        ret = s->oformat->write_packet(s, stream_index, buf, size, 
1707
                                       st->pts.val & pts_mask);
1708
    
1709 1e51d801 Fabrice Bellard
    if (ret < 0)
1710
        return ret;
1711
1712
    /* update pts */
1713
    switch (st->codec.codec_type) {
1714
    case CODEC_TYPE_AUDIO:
1715 fb2758c8 Fabrice Bellard
        frame_size = get_audio_frame_size(&st->codec, size);
1716 6d8f985e Michael Niedermayer
1717 b0c7f5a9 Michael Niedermayer
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
1718 6d8f985e Michael Niedermayer
           but it would be better if we had the real timestamps from the encoder */
1719
        if (frame_size >= 0 && (size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
1720 fb2758c8 Fabrice Bellard
            av_frac_add(&st->pts, 
1721
                        (int64_t)s->pts_den * frame_size);
1722 7feb950a Fabrice Bellard
        }
1723 1e51d801 Fabrice Bellard
        break;
1724
    case CODEC_TYPE_VIDEO:
1725
        av_frac_add(&st->pts, 
1726 14bea432 Michael Niedermayer
                    (int64_t)s->pts_den * st->codec.frame_rate_base);
1727 1e51d801 Fabrice Bellard
        break;
1728
    default:
1729
        break;
1730
    }
1731 d4c0ff91 Fabrice Bellard
    return ret;
1732 b9a281db Fabrice Bellard
}
1733
1734
/**
1735
 * write the stream trailer to an output media file and and free the
1736
 * file private data.
1737
 *
1738
 * @param s media file handle
1739
 * @return 0 if OK. AVERROR_xxx if error.  */
1740
int av_write_trailer(AVFormatContext *s)
1741
{
1742
    int ret;
1743
    ret = s->oformat->write_trailer(s);
1744
    av_freep(&s->priv_data);
1745
    return ret;
1746 de6d9b64 Fabrice Bellard
}
1747
1748
/* "user interface" functions */
1749
1750
void dump_format(AVFormatContext *ic,
1751
                 int index, 
1752
                 const char *url,
1753
                 int is_output)
1754
{
1755 b9a281db Fabrice Bellard
    int i, flags;
1756 de6d9b64 Fabrice Bellard
    char buf[256];
1757
1758 43465395 Michael Niedermayer
    av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
1759 de6d9b64 Fabrice Bellard
            is_output ? "Output" : "Input",
1760 b9a281db Fabrice Bellard
            index, 
1761
            is_output ? ic->oformat->name : ic->iformat->name, 
1762 de6d9b64 Fabrice Bellard
            is_output ? "to" : "from", url);
1763 12f996ed Fabrice Bellard
    if (!is_output) {
1764 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
1765 12f996ed Fabrice Bellard
        if (ic->duration != AV_NOPTS_VALUE) {
1766
            int hours, mins, secs, us;
1767
            secs = ic->duration / AV_TIME_BASE;
1768
            us = ic->duration % AV_TIME_BASE;
1769
            mins = secs / 60;
1770
            secs %= 60;
1771
            hours = mins / 60;
1772
            mins %= 60;
1773 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
1774 12f996ed Fabrice Bellard
                   (10 * us) / AV_TIME_BASE);
1775
        } else {
1776 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG, "N/A");
1777 12f996ed Fabrice Bellard
        }
1778 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
1779 12f996ed Fabrice Bellard
        if (ic->bit_rate) {
1780 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
1781 12f996ed Fabrice Bellard
        } else {
1782 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG, "N/A");
1783 12f996ed Fabrice Bellard
        }
1784 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, "\n");
1785 12f996ed Fabrice Bellard
    }
1786 de6d9b64 Fabrice Bellard
    for(i=0;i<ic->nb_streams;i++) {
1787
        AVStream *st = ic->streams[i];
1788
        avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1789 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
1790 b9a281db Fabrice Bellard
        /* the pid is an important information, so we display it */
1791
        /* XXX: add a generic system */
1792
        if (is_output)
1793
            flags = ic->oformat->flags;
1794
        else
1795
            flags = ic->iformat->flags;
1796
        if (flags & AVFMT_SHOW_IDS) {
1797 43465395 Michael Niedermayer
            av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
1798 b9a281db Fabrice Bellard
        }
1799 43465395 Michael Niedermayer
        av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
1800 de6d9b64 Fabrice Bellard
    }
1801
}
1802
1803
typedef struct {
1804 445f1b83 Roman Shaposhnik
    const char *abv;
1805 de6d9b64 Fabrice Bellard
    int width, height;
1806 445f1b83 Roman Shaposhnik
    int frame_rate, frame_rate_base;
1807
} AbvEntry;
1808
1809
static AbvEntry frame_abvs[] = {
1810 ba2a8cb4 Roman Shaposhnik
    { "ntsc",      720, 480, 30000, 1001 },
1811
    { "pal",       720, 576,    25,    1 },
1812
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1813
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
1814 904736b5 Roman Shaposhnik
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
1815
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
1816 445f1b83 Roman Shaposhnik
    { "film",      352, 240,    24,    1 },
1817
    { "ntsc-film", 352, 240, 24000, 1001 },
1818
    { "sqcif",     128,  96,     0,    0 },
1819
    { "qcif",      176, 144,     0,    0 },
1820
    { "cif",       352, 288,     0,    0 },
1821
    { "4cif",      704, 576,     0,    0 },
1822 de6d9b64 Fabrice Bellard
};
1823 445f1b83 Roman Shaposhnik
1824 de6d9b64 Fabrice Bellard
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1825
{
1826
    int i;
1827 445f1b83 Roman Shaposhnik
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1828 de6d9b64 Fabrice Bellard
    const char *p;
1829
    int frame_width = 0, frame_height = 0;
1830
1831
    for(i=0;i<n;i++) {
1832 445f1b83 Roman Shaposhnik
        if (!strcmp(frame_abvs[i].abv, str)) {
1833
            frame_width = frame_abvs[i].width;
1834
            frame_height = frame_abvs[i].height;
1835 de6d9b64 Fabrice Bellard
            break;
1836
        }
1837
    }
1838
    if (i == n) {
1839
        p = str;
1840
        frame_width = strtol(p, (char **)&p, 10);
1841
        if (*p)
1842
            p++;
1843
        frame_height = strtol(p, (char **)&p, 10);
1844
    }
1845
    if (frame_width <= 0 || frame_height <= 0)
1846
        return -1;
1847
    *width_ptr = frame_width;
1848
    *height_ptr = frame_height;
1849
    return 0;
1850
}
1851
1852 445f1b83 Roman Shaposhnik
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1853
{
1854
    int i;
1855
    char* cp;
1856
   
1857
    /* First, we check our abbreviation table */
1858
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1859
         if (!strcmp(frame_abvs[i].abv, arg)) {
1860
             *frame_rate = frame_abvs[i].frame_rate;
1861
             *frame_rate_base = frame_abvs[i].frame_rate_base;
1862
             return 0;
1863
         }
1864
1865
    /* Then, we try to parse it as fraction */
1866
    cp = strchr(arg, '/');
1867
    if (cp) {
1868
        char* cpp;
1869
        *frame_rate = strtol(arg, &cpp, 10);
1870
        if (cpp != arg || cpp == cp) 
1871
            *frame_rate_base = strtol(cp+1, &cpp, 10);
1872
        else
1873
           *frame_rate = 0;
1874
    } 
1875
    else {
1876
        /* Finally we give up and parse it as double */
1877 8bfed902 Michael Niedermayer
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
1878 445f1b83 Roman Shaposhnik
        *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1879
    }
1880
    if (!*frame_rate || !*frame_rate_base)
1881
        return -1;
1882
    else
1883
        return 0;
1884
}
1885
1886 916c80e9 Fabrice Bellard
/* Syntax:
1887
 * - If not a duration:
1888
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1889 c5510dd6 Philip Gladstone
 * Time is localtime unless Z is suffixed to the end. In this case GMT
1890 916c80e9 Fabrice Bellard
 * Return the date in micro seconds since 1970 
1891
 * - If duration:
1892
 *  HH[:MM[:SS[.m...]]]
1893
 *  S+[.m...]
1894
 */
1895 0c1a9eda Zdenek Kabelac
int64_t parse_date(const char *datestr, int duration)
1896 de6d9b64 Fabrice Bellard
{
1897
    const char *p;
1898 0c1a9eda Zdenek Kabelac
    int64_t t;
1899 2dbceb9f Philip Gladstone
    struct tm dt;
1900 c5510dd6 Philip Gladstone
    int i;
1901
    static const char *date_fmt[] = {
1902
        "%Y-%m-%d",
1903
        "%Y%m%d",
1904
    };
1905
    static const char *time_fmt[] = {
1906
        "%H:%M:%S",
1907
        "%H%M%S",
1908
    };
1909
    const char *q;
1910 916c80e9 Fabrice Bellard
    int is_utc, len;
1911 c5510dd6 Philip Gladstone
    char lastch;
1912 6d8f985e Michael Niedermayer
1913
#undef time
1914 c5510dd6 Philip Gladstone
    time_t now = time(0);
1915
1916 916c80e9 Fabrice Bellard
    len = strlen(datestr);
1917
    if (len > 0)
1918
        lastch = datestr[len - 1];
1919
    else
1920
        lastch = '\0';
1921 c5510dd6 Philip Gladstone
    is_utc = (lastch == 'z' || lastch == 'Z');
1922 2dbceb9f Philip Gladstone
1923
    memset(&dt, 0, sizeof(dt));
1924 de6d9b64 Fabrice Bellard
1925
    p = datestr;
1926 916c80e9 Fabrice Bellard
    q = NULL;
1927 de6d9b64 Fabrice Bellard
    if (!duration) {
1928 c5510dd6 Philip Gladstone
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1929 f71869a4 Fabrice Bellard
            q = small_strptime(p, date_fmt[i], &dt);
1930 c5510dd6 Philip Gladstone
            if (q) {
1931
                break;
1932
            }
1933
        }
1934
1935
        if (!q) {
1936
            if (is_utc) {
1937
                dt = *gmtime(&now);
1938
            } else {
1939
                dt = *localtime(&now);
1940
            }
1941
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1942 de6d9b64 Fabrice Bellard
        } else {
1943 c5510dd6 Philip Gladstone
            p = q;
1944 de6d9b64 Fabrice Bellard
        }
1945 c5510dd6 Philip Gladstone
1946
        if (*p == 'T' || *p == 't' || *p == ' ')
1947
            p++;
1948
1949 916c80e9 Fabrice Bellard
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1950 f71869a4 Fabrice Bellard
            q = small_strptime(p, time_fmt[i], &dt);
1951 916c80e9 Fabrice Bellard
            if (q) {
1952
                break;
1953
            }
1954
        }
1955
    } else {
1956 f71869a4 Fabrice Bellard
        q = small_strptime(p, time_fmt[0], &dt);
1957 916c80e9 Fabrice Bellard
        if (!q) {
1958
            dt.tm_sec = strtol(p, (char **)&q, 10);
1959
            dt.tm_min = 0;
1960
            dt.tm_hour = 0;
1961 c5510dd6 Philip Gladstone
        }
1962
    }
1963
1964
    /* Now we have all the fields that we can get */
1965
    if (!q) {
1966
        if (duration)
1967
            return 0;
1968
        else
1969 0c1a9eda Zdenek Kabelac
            return now * int64_t_C(1000000);
1970 de6d9b64 Fabrice Bellard
    }
1971 2dbceb9f Philip Gladstone
1972
    if (duration) {
1973 c5510dd6 Philip Gladstone
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1974 2dbceb9f Philip Gladstone
    } else {
1975 c5510dd6 Philip Gladstone
        dt.tm_isdst = -1;       /* unknown */
1976
        if (is_utc) {
1977
            t = mktimegm(&dt);
1978
        } else {
1979
            t = mktime(&dt);
1980
        }
1981 de6d9b64 Fabrice Bellard
    }
1982 2dbceb9f Philip Gladstone
1983 c5510dd6 Philip Gladstone
    t *= 1000000;
1984
1985
    if (*q == '.') {
1986 de6d9b64 Fabrice Bellard
        int val, n;
1987 c5510dd6 Philip Gladstone
        q++;
1988
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1989
            if (!isdigit(*q)) 
1990
                break;
1991
            val += n * (*q - '0');
1992 de6d9b64 Fabrice Bellard
        }
1993
        t += val;
1994
    }
1995
    return t;
1996
}
1997
1998 2dbceb9f Philip Gladstone
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1999 de6d9b64 Fabrice Bellard
   1 if found */
2000
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2001
{
2002
    const char *p;
2003
    char tag[128], *q;
2004
2005
    p = info;
2006
    if (*p == '?')
2007
        p++;
2008
    for(;;) {
2009
        q = tag;
2010
        while (*p != '\0' && *p != '=' && *p != '&') {
2011
            if ((q - tag) < sizeof(tag) - 1)
2012
                *q++ = *p;
2013
            p++;
2014
        }
2015
        *q = '\0';
2016
        q = arg;
2017
        if (*p == '=') {
2018
            p++;
2019
            while (*p != '&' && *p != '\0') {
2020 2dbceb9f Philip Gladstone
                if ((q - arg) < arg_size - 1) {
2021
                    if (*p == '+')
2022
                        *q++ = ' ';
2023
                    else
2024
                        *q++ = *p;
2025
                }
2026 de6d9b64 Fabrice Bellard
                p++;
2027
            }
2028
            *q = '\0';
2029
        }
2030
        if (!strcmp(tag, tag1)) 
2031
            return 1;
2032
        if (*p != '&')
2033
            break;
2034 8d1335ea Philip Gladstone
        p++;
2035 de6d9b64 Fabrice Bellard
    }
2036
    return 0;
2037
}
2038
2039 9150f42e Fabrice Bellard
/* Return in 'buf' the path with '%d' replaced by number. Also handles
2040
   the '%0nd' format where 'n' is the total number of digits and
2041
   '%%'. Return 0 if OK, and -1 if format error */
2042
int get_frame_filename(char *buf, int buf_size,
2043
                       const char *path, int number)
2044
{
2045
    const char *p;
2046 0bf92f79 Panagiotis Issaris
    char *q, buf1[20], c;
2047
    int nd, len, percentd_found;
2048 9150f42e Fabrice Bellard
2049
    q = buf;
2050
    p = path;
2051
    percentd_found = 0;
2052
    for(;;) {
2053
        c = *p++;
2054
        if (c == '\0')
2055
            break;
2056
        if (c == '%') {
2057 c9646fda Philip Gladstone
            do {
2058
                nd = 0;
2059
                while (isdigit(*p)) {
2060
                    nd = nd * 10 + *p++ - '0';
2061
                }
2062
                c = *p++;
2063
            } while (isdigit(c));
2064
2065 9150f42e Fabrice Bellard
            switch(c) {
2066
            case '%':
2067
                goto addchar;
2068
            case 'd':
2069
                if (percentd_found)
2070
                    goto fail;
2071
                percentd_found = 1;
2072
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2073
                len = strlen(buf1);
2074
                if ((q - buf + len) > buf_size - 1)
2075
                    goto fail;
2076
                memcpy(q, buf1, len);
2077
                q += len;
2078
                break;
2079
            default:
2080
                goto fail;
2081
            }
2082
        } else {
2083
        addchar:
2084
            if ((q - buf) < buf_size - 1)
2085
                *q++ = c;
2086
        }
2087
    }
2088
    if (!percentd_found)
2089
        goto fail;
2090
    *q = '\0';
2091
    return 0;
2092
 fail:
2093
    *q = '\0';
2094
    return -1;
2095
}
2096
2097 b9a281db Fabrice Bellard
/**
2098 fb2758c8 Fabrice Bellard
 * Print  nice hexa dump of a buffer
2099
 * @param f stream for output
2100 b9a281db Fabrice Bellard
 * @param buf buffer
2101
 * @param size buffer size
2102
 */
2103 fb2758c8 Fabrice Bellard
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2104 b9a281db Fabrice Bellard
{
2105
    int len, i, j, c;
2106
2107
    for(i=0;i<size;i+=16) {
2108
        len = size - i;
2109
        if (len > 16)
2110
            len = 16;
2111 fb2758c8 Fabrice Bellard
        fprintf(f, "%08x ", i);
2112 b9a281db Fabrice Bellard
        for(j=0;j<16;j++) {
2113
            if (j < len)
2114 fb2758c8 Fabrice Bellard
                fprintf(f, " %02x", buf[i+j]);
2115 b9a281db Fabrice Bellard
            else
2116 fb2758c8 Fabrice Bellard
                fprintf(f, "   ");
2117 b9a281db Fabrice Bellard
        }
2118 fb2758c8 Fabrice Bellard
        fprintf(f, " ");
2119 b9a281db Fabrice Bellard
        for(j=0;j<len;j++) {
2120
            c = buf[i+j];
2121
            if (c < ' ' || c > '~')
2122
                c = '.';
2123 fb2758c8 Fabrice Bellard
            fprintf(f, "%c", c);
2124 b9a281db Fabrice Bellard
        }
2125 fb2758c8 Fabrice Bellard
        fprintf(f, "\n");
2126 b9a281db Fabrice Bellard
    }
2127
}
2128
2129 fb2758c8 Fabrice Bellard
/**
2130
 * Print on 'f' a nice dump of a packet
2131
 * @param f stream for output
2132
 * @param pkt packet to dump
2133
 * @param dump_payload true if the payload must be displayed too
2134
 */
2135
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2136
{
2137
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2138
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2139
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2140 37353960 Fabrice Bellard
    /* DTS is _always_ valid after av_read_frame() */
2141
    fprintf(f, "  dts=");
2142
    if (pkt->dts == AV_NOPTS_VALUE)
2143
        fprintf(f, "N/A");
2144
    else
2145
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2146 fb2758c8 Fabrice Bellard
    /* PTS may be not known if B frames are present */
2147
    fprintf(f, "  pts=");
2148
    if (pkt->pts == AV_NOPTS_VALUE)
2149
        fprintf(f, "N/A");
2150
    else
2151
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2152
    fprintf(f, "\n");
2153
    fprintf(f, "  size=%d\n", pkt->size);
2154
    if (dump_payload)
2155
        av_hex_dump(f, pkt->data, pkt->size);
2156
}
2157
2158 a9a721da Fabrice Bellard
void url_split(char *proto, int proto_size,
2159
               char *hostname, int hostname_size,
2160
               int *port_ptr,
2161
               char *path, int path_size,
2162
               const char *url)
2163
{
2164
    const char *p;
2165
    char *q;
2166
    int port;
2167
2168
    port = -1;
2169
2170
    p = url;
2171
    q = proto;
2172
    while (*p != ':' && *p != '\0') {
2173
        if ((q - proto) < proto_size - 1)
2174
            *q++ = *p;
2175
        p++;
2176
    }
2177
    if (proto_size > 0)
2178
        *q = '\0';
2179
    if (*p == '\0') {
2180
        if (proto_size > 0)
2181
            proto[0] = '\0';
2182
        if (hostname_size > 0)
2183
            hostname[0] = '\0';
2184
        p = url;
2185
    } else {
2186
        p++;
2187
        if (*p == '/')
2188
            p++;
2189
        if (*p == '/')
2190
            p++;
2191
        q = hostname;
2192
        while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2193
            if ((q - hostname) < hostname_size - 1)
2194
                *q++ = *p;
2195
            p++;
2196
        }
2197
        if (hostname_size > 0)
2198
            *q = '\0';
2199
        if (*p == ':') {
2200
            p++;
2201
            port = strtoul(p, (char **)&p, 10);
2202
        }
2203
    }
2204
    if (port_ptr)
2205
        *port_ptr = port;
2206
    pstrcpy(path, path_size, p);
2207
}
2208
2209 916c80e9 Fabrice Bellard
/**
2210
 * Set the pts for a given stream
2211
 * @param s stream 
2212
 * @param pts_wrap_bits number of bits effectively used by the pts
2213
 *        (used for wrap control, 33 is the value for MPEG) 
2214
 * @param pts_num numerator to convert to seconds (MPEG: 1) 
2215
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2216
 */
2217
void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2218
                     int pts_num, int pts_den)
2219
{
2220
    s->pts_wrap_bits = pts_wrap_bits;
2221
    s->pts_num = pts_num;
2222
    s->pts_den = pts_den;
2223
}
2224
2225
/* fraction handling */
2226
2227
/**
2228
 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2229
 * as 0 <= num < den.
2230
 *
2231
 * @param f fractional number
2232
 * @param val integer value
2233
 * @param num must be >= 0
2234
 * @param den must be >= 1 
2235
 */
2236 0c1a9eda Zdenek Kabelac
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2237 916c80e9 Fabrice Bellard
{
2238
    num += (den >> 1);
2239
    if (num >= den) {
2240
        val += num / den;
2241
        num = num % den;
2242
    }
2243
    f->val = val;
2244
    f->num = num;
2245
    f->den = den;
2246
}
2247
2248
/* set f to (val + 0.5) */
2249 0c1a9eda Zdenek Kabelac
void av_frac_set(AVFrac *f, int64_t val)
2250 916c80e9 Fabrice Bellard
{
2251
    f->val = val;
2252
    f->num = f->den >> 1;
2253
}
2254
2255
/**
2256
 * Fractionnal addition to f: f = f + (incr / f->den)
2257
 *
2258
 * @param f fractional number
2259
 * @param incr increment, can be positive or negative
2260
 */
2261 0c1a9eda Zdenek Kabelac
void av_frac_add(AVFrac *f, int64_t incr)
2262 916c80e9 Fabrice Bellard
{
2263 0c1a9eda Zdenek Kabelac
    int64_t num, den;
2264 916c80e9 Fabrice Bellard
2265
    num = f->num + incr;
2266
    den = f->den;
2267
    if (num < 0) {
2268
        f->val += num / den;
2269
        num = num % den;
2270
        if (num < 0) {
2271
            num += den;
2272
            f->val--;
2273
        }
2274
    } else if (num >= den) {
2275
        f->val += num / den;
2276
        num = num % den;
2277
    }
2278
    f->num = num;
2279
}
2280 87a0a681 Fabrice Bellard
2281
/**
2282
 * register a new image format
2283
 * @param img_fmt Image format descriptor
2284
 */
2285
void av_register_image_format(AVImageFormat *img_fmt)
2286
{
2287
    AVImageFormat **p;
2288
2289
    p = &first_image_format;
2290
    while (*p != NULL) p = &(*p)->next;
2291
    *p = img_fmt;
2292
    img_fmt->next = NULL;
2293
}
2294
2295
/* guess image format */
2296
AVImageFormat *av_probe_image_format(AVProbeData *pd)
2297
{
2298
    AVImageFormat *fmt1, *fmt;
2299
    int score, score_max;
2300
2301
    fmt = NULL;
2302
    score_max = 0;
2303
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2304
        if (fmt1->img_probe) {
2305
            score = fmt1->img_probe(pd);
2306
            if (score > score_max) {
2307
                score_max = score;
2308
                fmt = fmt1;
2309
            }
2310
        }
2311
    }
2312
    return fmt;
2313
}
2314
2315
AVImageFormat *guess_image_format(const char *filename)
2316
{
2317
    AVImageFormat *fmt1;
2318
2319
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2320
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2321
            return fmt1;
2322
    }
2323
    return NULL;
2324
}
2325
2326
/**
2327
 * Read an image from a stream. 
2328
 * @param gb byte stream containing the image
2329
 * @param fmt image format, NULL if probing is required
2330
 */
2331
int av_read_image(ByteIOContext *pb, const char *filename,
2332
                  AVImageFormat *fmt,
2333
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2334
{
2335
    char buf[PROBE_BUF_SIZE];
2336
    AVProbeData probe_data, *pd = &probe_data;
2337
    offset_t pos;
2338
    int ret;
2339
2340
    if (!fmt) {
2341 5c91a675 Zdenek Kabelac
        pd->filename = filename;
2342 87a0a681 Fabrice Bellard
        pd->buf = buf;
2343
        pos = url_ftell(pb);
2344
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2345
        url_fseek(pb, pos, SEEK_SET);
2346
        fmt = av_probe_image_format(pd);
2347
    }
2348
    if (!fmt)
2349
        return AVERROR_NOFMT;
2350
    ret = fmt->img_read(pb, alloc_cb, opaque);
2351
    return ret;
2352
}
2353
2354
/**
2355
 * Write an image to a stream.
2356
 * @param pb byte stream for the image output
2357
 * @param fmt image format
2358
 * @param img image data and informations
2359
 */
2360
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2361
{
2362
    return fmt->img_write(pb, img);
2363
}