Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 03cfe134

History | View | Annotate | Download (75.9 KB)

1
/*
2
 * Various utilities for ffmpeg system
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * 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
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * 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
 */
19
#include "avformat.h"
20

    
21
#undef NDEBUG
22
#include <assert.h>
23

    
24
AVInputFormat *first_iformat;
25
AVOutputFormat *first_oformat;
26
AVImageFormat *first_image_format;
27

    
28
void av_register_input_format(AVInputFormat *format)
29
{
30
    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
    while (*p != NULL) p = &(*p)->next;
42
    *p = format;
43
    format->next = NULL;
44
}
45

    
46
int match_ext(const char *filename, const char *extensions)
47
{
48
    const char *ext, *p;
49
    char ext1[32], *q;
50

    
51
    if(!filename)
52
        return 0;
53
    
54
    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
AVOutputFormat *guess_format(const char *short_name, const char *filename, 
74
                             const char *mime_type)
75
{
76
    AVOutputFormat *fmt, *fmt_found;
77
    int score_max, score;
78

    
79
    /* specific test for image sequences */
80
    if (!short_name && filename && 
81
        filename_number_test(filename) >= 0 &&
82
        guess_image_format(filename)) {
83
        return guess_format("image", NULL, NULL);
84
    }
85

    
86
    /* find the proper file type */
87
    fmt_found = NULL;
88
    score_max = 0;
89
    fmt = first_oformat;
90
    while (fmt != NULL) {
91
        score = 0;
92
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
93
            score += 100;
94
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
95
            score += 10;
96
        if (filename && fmt->extensions && 
97
            match_ext(filename, fmt->extensions)) {
98
            score += 5;
99
        }
100
        if (score > score_max) {
101
            score_max = score;
102
            fmt_found = fmt;
103
        }
104
        fmt = fmt->next;
105
    }
106
    return fmt_found;
107
}   
108

    
109
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename, 
110
                             const char *mime_type)
111
{
112
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
113

    
114
    if (fmt) {
115
        AVOutputFormat *stream_fmt;
116
        char stream_format_name[64];
117

    
118
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
119
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
120

    
121
        if (stream_fmt)
122
            fmt = stream_fmt;
123
    }
124

    
125
    return fmt;
126
}
127

    
128
AVInputFormat *av_find_input_format(const char *short_name)
129
{
130
    AVInputFormat *fmt;
131
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
132
        if (!strcmp(fmt->name, short_name))
133
            return fmt;
134
    }
135
    return NULL;
136
}
137

    
138
/* memory handling */
139

    
140
/**
141
 * Default packet destructor 
142
 */
143
static void av_destruct_packet(AVPacket *pkt)
144
{
145
    av_free(pkt->data);
146
    pkt->data = NULL; pkt->size = 0;
147
}
148

    
149
/**
150
 * Allocate the payload of a packet and intialized its fields to default values.
151
 *
152
 * @param pkt packet
153
 * @param size wanted payload size
154
 * @return 0 if OK. AVERROR_xxx otherwise.
155
 */
156
int av_new_packet(AVPacket *pkt, int size)
157
{
158
    void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
159
    if (!data)
160
        return AVERROR_NOMEM;
161
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
162

    
163
    av_init_packet(pkt);
164
    pkt->data = data; 
165
    pkt->size = size;
166
    pkt->destruct = av_destruct_packet;
167
    return 0;
168
}
169

    
170
/* This is a hack - the packet memory allocation stuff is broken. The
171
   packet is allocated if it was not really allocated */
172
int av_dup_packet(AVPacket *pkt)
173
{
174
    if (pkt->destruct != av_destruct_packet) {
175
        uint8_t *data;
176
        /* we duplicate the packet and don't forget to put the padding
177
           again */
178
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
179
        if (!data) {
180
            return AVERROR_NOMEM;
181
        }
182
        memcpy(data, pkt->data, pkt->size);
183
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
184
        pkt->data = data;
185
        pkt->destruct = av_destruct_packet;
186
    }
187
    return 0;
188
}
189

    
190
/* fifo handling */
191

    
192
int fifo_init(FifoBuffer *f, int size)
193
{
194
    f->buffer = av_malloc(size);
195
    if (!f->buffer)
196
        return -1;
197
    f->end = f->buffer + size;
198
    f->wptr = f->rptr = f->buffer;
199
    return 0;
200
}
201

    
202
void fifo_free(FifoBuffer *f)
203
{
204
    av_free(f->buffer);
205
}
206

    
207
int fifo_size(FifoBuffer *f, uint8_t *rptr)
208
{
209
    int size;
210

    
211
    if (f->wptr >= rptr) {
212
        size = f->wptr - rptr;
213
    } else {
214
        size = (f->end - rptr) + (f->wptr - f->buffer);
215
    }
216
    return size;
217
}
218

    
219
/* get data from the fifo (return -1 if not enough data) */
220
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
221
{
222
    uint8_t *rptr = *rptr_ptr;
223
    int size, len;
224

    
225
    if (f->wptr >= rptr) {
226
        size = f->wptr - rptr;
227
    } else {
228
        size = (f->end - rptr) + (f->wptr - f->buffer);
229
    }
230
    
231
    if (size < buf_size)
232
        return -1;
233
    while (buf_size > 0) {
234
        len = f->end - rptr;
235
        if (len > buf_size)
236
            len = buf_size;
237
        memcpy(buf, rptr, len);
238
        buf += len;
239
        rptr += len;
240
        if (rptr >= f->end)
241
            rptr = f->buffer;
242
        buf_size -= len;
243
    }
244
    *rptr_ptr = rptr;
245
    return 0;
246
}
247

    
248
void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
249
{
250
    int len;
251
    uint8_t *wptr;
252
    wptr = *wptr_ptr;
253
    while (size > 0) {
254
        len = f->end - wptr;
255
        if (len > size)
256
            len = size;
257
        memcpy(wptr, buf, len);
258
        wptr += len;
259
        if (wptr >= f->end)
260
            wptr = f->buffer;
261
        buf += len;
262
        size -= len;
263
    }
264
    *wptr_ptr = wptr;
265
}
266

    
267
int filename_number_test(const char *filename)
268
{
269
    char buf[1024];
270
    if(!filename)
271
        return -1;
272
    return get_frame_filename(buf, sizeof(buf), filename, 1);
273
}
274

    
275
/* guess file format */
276
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
277
{
278
    AVInputFormat *fmt1, *fmt;
279
    int score, score_max;
280

    
281
    fmt = NULL;
282
    score_max = 0;
283
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
284
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
285
            continue;
286
        score = 0;
287
        if (fmt1->read_probe) {
288
            score = fmt1->read_probe(pd);
289
        } else if (fmt1->extensions) {
290
            if (match_ext(pd->filename, fmt1->extensions)) {
291
                score = 50;
292
            }
293
        } 
294
        if (score > score_max) {
295
            score_max = score;
296
            fmt = fmt1;
297
        }
298
    }
299
    return fmt;
300
}
301

    
302
/************************************************************/
303
/* input media file */
304

    
305
/**
306
 * open a media file from an IO stream. 'fmt' must be specified.
307
 */
308

    
309
static const char* format_to_name(void* ptr)
310
{
311
    AVFormatContext* fc = (AVFormatContext*) ptr;
312
    if(fc->iformat) return fc->iformat->name;
313
    else if(fc->oformat) return fc->oformat->name;
314
    else return "NULL";
315
}
316

    
317
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
318

    
319
AVFormatContext *av_alloc_format_context(void)
320
{
321
    AVFormatContext *ic;
322
    ic = av_mallocz(sizeof(AVFormatContext));
323
    if (!ic) return ic;
324
    ic->av_class = &av_format_context_class;
325
    return ic;
326
}
327

    
328
int av_open_input_stream(AVFormatContext **ic_ptr, 
329
                         ByteIOContext *pb, const char *filename, 
330
                         AVInputFormat *fmt, AVFormatParameters *ap)
331
{
332
    int err;
333
    AVFormatContext *ic;
334

    
335
    ic = av_alloc_format_context();
336
    if (!ic) {
337
        err = AVERROR_NOMEM;
338
        goto fail;
339
    }
340
    ic->iformat = fmt;
341
    if (pb)
342
        ic->pb = *pb;
343
    ic->duration = AV_NOPTS_VALUE;
344
    ic->start_time = AV_NOPTS_VALUE;
345
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
346

    
347
    /* allocate private data */
348
    if (fmt->priv_data_size > 0) {
349
        ic->priv_data = av_mallocz(fmt->priv_data_size);
350
        if (!ic->priv_data) {
351
            err = AVERROR_NOMEM;
352
            goto fail;
353
        }
354
    } else {
355
        ic->priv_data = NULL;
356
    }
357

    
358
    err = ic->iformat->read_header(ic, ap);
359
    if (err < 0)
360
        goto fail;
361

    
362
    if (pb)
363
        ic->data_offset = url_ftell(&ic->pb);
364

    
365
    *ic_ptr = ic;
366
    return 0;
367
 fail:
368
    if (ic) {
369
        av_freep(&ic->priv_data);
370
    }
371
    av_free(ic);
372
    *ic_ptr = NULL;
373
    return err;
374
}
375

    
376
#define PROBE_BUF_SIZE 2048
377

    
378
/**
379
 * Open a media file as input. The codec are not opened. Only the file
380
 * header (if present) is read.
381
 *
382
 * @param ic_ptr the opened media file handle is put here
383
 * @param filename filename to open.
384
 * @param fmt if non NULL, force the file format to use
385
 * @param buf_size optional buffer size (zero if default is OK)
386
 * @param ap additionnal parameters needed when opening the file (NULL if default)
387
 * @return 0 if OK. AVERROR_xxx otherwise.
388
 */
389
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, 
390
                       AVInputFormat *fmt,
391
                       int buf_size,
392
                       AVFormatParameters *ap)
393
{
394
    int err, must_open_file, file_opened;
395
    uint8_t buf[PROBE_BUF_SIZE];
396
    AVProbeData probe_data, *pd = &probe_data;
397
    ByteIOContext pb1, *pb = &pb1;
398
    
399
    file_opened = 0;
400
    pd->filename = "";
401
    if (filename)
402
        pd->filename = filename;
403
    pd->buf = buf;
404
    pd->buf_size = 0;
405

    
406
    if (!fmt) {
407
        /* guess format if no file can be opened  */
408
        fmt = av_probe_input_format(pd, 0);
409
    }
410

    
411
    /* do not open file if the format does not need it. XXX: specific
412
       hack needed to handle RTSP/TCP */
413
    must_open_file = 1;
414
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
415
        must_open_file = 0;
416
    }
417

    
418
    if (!fmt || must_open_file) {
419
        /* if no file needed do not try to open one */
420
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
421
            err = AVERROR_IO;
422
            goto fail;
423
        }
424
        file_opened = 1;
425
        if (buf_size > 0) {
426
            url_setbufsize(pb, buf_size);
427
        }
428
        if (!fmt) {
429
            /* read probe data */
430
            pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
431
            url_fseek(pb, 0, SEEK_SET);
432
        }
433
    }
434
    
435
    /* guess file format */
436
    if (!fmt) {
437
        fmt = av_probe_input_format(pd, 1);
438
    }
439

    
440
    /* if still no format found, error */
441
    if (!fmt) {
442
        err = AVERROR_NOFMT;
443
        goto fail;
444
    }
445
        
446
    /* XXX: suppress this hack for redirectors */
447
#ifdef CONFIG_NETWORK
448
    if (fmt == &redir_demux) {
449
        err = redir_open(ic_ptr, pb);
450
        url_fclose(pb);
451
        return err;
452
    }
453
#endif
454

    
455
    /* check filename in case of an image number is expected */
456
    if (fmt->flags & AVFMT_NEEDNUMBER) {
457
        if (filename_number_test(filename) < 0) { 
458
            err = AVERROR_NUMEXPECTED;
459
            goto fail;
460
        }
461
    }
462
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
463
    if (err)
464
        goto fail;
465
    return 0;
466
 fail:
467
    if (file_opened)
468
        url_fclose(pb);
469
    *ic_ptr = NULL;
470
    return err;
471
    
472
}
473

    
474
/*******************************************************/
475

    
476
/**
477
 * Read a transport packet from a media file. This function is
478
 * absolete and should never be used. Use av_read_frame() instead.
479
 * 
480
 * @param s media file handle
481
 * @param pkt is filled 
482
 * @return 0 if OK. AVERROR_xxx if error.  
483
 */
484
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
485
{
486
    return s->iformat->read_packet(s, pkt);
487
}
488

    
489
/**********************************************************/
490

    
491
/* get the number of samples of an audio frame. Return (-1) if error */
492
static int get_audio_frame_size(AVCodecContext *enc, int size)
493
{
494
    int frame_size;
495

    
496
    if (enc->frame_size <= 1) {
497
        /* specific hack for pcm codecs because no frame size is
498
           provided */
499
        switch(enc->codec_id) {
500
        case CODEC_ID_PCM_S16LE:
501
        case CODEC_ID_PCM_S16BE:
502
        case CODEC_ID_PCM_U16LE:
503
        case CODEC_ID_PCM_U16BE:
504
            if (enc->channels == 0)
505
                return -1;
506
            frame_size = size / (2 * enc->channels);
507
            break;
508
        case CODEC_ID_PCM_S8:
509
        case CODEC_ID_PCM_U8:
510
        case CODEC_ID_PCM_MULAW:
511
        case CODEC_ID_PCM_ALAW:
512
            if (enc->channels == 0)
513
                return -1;
514
            frame_size = size / (enc->channels);
515
            break;
516
        default:
517
            /* used for example by ADPCM codecs */
518
            if (enc->bit_rate == 0)
519
                return -1;
520
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
521
            break;
522
        }
523
    } else {
524
        frame_size = enc->frame_size;
525
    }
526
    return frame_size;
527
}
528

    
529

    
530
/* return the frame duration in seconds, return 0 if not available */
531
static void compute_frame_duration(int *pnum, int *pden, AVStream *st, 
532
                                   AVCodecParserContext *pc, AVPacket *pkt)
533
{
534
    int frame_size;
535

    
536
    *pnum = 0;
537
    *pden = 0;
538
    switch(st->codec.codec_type) {
539
    case CODEC_TYPE_VIDEO:
540
        *pnum = st->codec.frame_rate_base;
541
        *pden = st->codec.frame_rate;
542
        if (pc && pc->repeat_pict) {
543
            *pden *= 2;
544
            *pnum = (*pnum) * (2 + pc->repeat_pict);
545
        }
546
        break;
547
    case CODEC_TYPE_AUDIO:
548
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
549
        if (frame_size < 0)
550
            break;
551
        *pnum = frame_size;
552
        *pden = st->codec.sample_rate;
553
        break;
554
    default:
555
        break;
556
    }
557
}
558

    
559
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
560
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
561
    int64_t delta= last_ts - mask/2;
562
    return  ((lsb - delta)&mask) + delta;
563
}
564

    
565
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, 
566
                               AVCodecParserContext *pc, AVPacket *pkt)
567
{
568
    int num, den, presentation_delayed;
569

    
570
    /* handle wrapping */
571
    if(st->cur_dts != AV_NOPTS_VALUE){
572
        if(pkt->pts != AV_NOPTS_VALUE)
573
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
574
        if(pkt->dts != AV_NOPTS_VALUE)
575
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
576
    }
577
    
578
    if (pkt->duration == 0) {
579
        compute_frame_duration(&num, &den, st, pc, pkt);
580
        if (den && num) {
581
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
582
        }
583
    }
584

    
585
    /* do we have a video B frame ? */
586
    presentation_delayed = 0;
587
    if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
588
        /* XXX: need has_b_frame, but cannot get it if the codec is
589
           not initialized */
590
        if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
591
             st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
592
             st->codec.codec_id == CODEC_ID_MPEG4 ||
593
             st->codec.codec_id == CODEC_ID_H264) && 
594
            pc && pc->pict_type != FF_B_TYPE)
595
            presentation_delayed = 1;
596
        /* this may be redundant, but it shouldnt hurt */
597
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
598
            presentation_delayed = 1;
599
    }
600
    
601
    if(st->cur_dts == AV_NOPTS_VALUE){
602
        if(presentation_delayed) st->cur_dts = -pkt->duration;
603
        else                     st->cur_dts = 0;
604
    }
605

    
606
//    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);
607
    /* interpolate PTS and DTS if they are not present */
608
    if (presentation_delayed) {
609
        /* DTS = decompression time stamp */
610
        /* PTS = presentation time stamp */
611
        if (pkt->dts == AV_NOPTS_VALUE) {
612
            /* if we know the last pts, use it */
613
            if(st->last_IP_pts != AV_NOPTS_VALUE)
614
                st->cur_dts = pkt->dts = st->last_IP_pts;
615
            else
616
                pkt->dts = st->cur_dts;
617
        } else {
618
            st->cur_dts = pkt->dts;
619
        }
620
        /* this is tricky: the dts must be incremented by the duration
621
           of the frame we are displaying, i.e. the last I or P frame */
622
        if (st->last_IP_duration == 0)
623
            st->cur_dts += pkt->duration;
624
        else
625
            st->cur_dts += st->last_IP_duration;
626
        st->last_IP_duration  = pkt->duration;
627
        st->last_IP_pts= pkt->pts;
628
        /* cannot compute PTS if not present (we can compute it only
629
           by knowing the futur */
630
    } else {
631
        /* presentation is not delayed : PTS and DTS are the same */
632
        if (pkt->pts == AV_NOPTS_VALUE) {
633
            if (pkt->dts == AV_NOPTS_VALUE) {
634
                pkt->pts = st->cur_dts;
635
                pkt->dts = st->cur_dts;
636
            }
637
            else {
638
                st->cur_dts = pkt->dts;
639
                pkt->pts = pkt->dts;
640
            }
641
        } else {
642
            st->cur_dts = pkt->pts;
643
            pkt->dts = pkt->pts;
644
        }
645
        st->cur_dts += pkt->duration;
646
    }
647
//    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);
648
    
649
    /* update flags */
650
    if (pc) {
651
        pkt->flags = 0;
652
        /* key frame computation */
653
        switch(st->codec.codec_type) {
654
        case CODEC_TYPE_VIDEO:
655
            if (pc->pict_type == FF_I_TYPE)
656
                pkt->flags |= PKT_FLAG_KEY;
657
            break;
658
        case CODEC_TYPE_AUDIO:
659
            pkt->flags |= PKT_FLAG_KEY;
660
            break;
661
        default:
662
            break;
663
        }
664
    }
665

    
666
    /* convert the packet time stamp units */
667
    if(pkt->pts != AV_NOPTS_VALUE)
668
        pkt->pts = av_rescale(pkt->pts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
669
    if(pkt->dts != AV_NOPTS_VALUE)
670
        pkt->dts = av_rescale(pkt->dts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
671

    
672
    /* duration field */
673
    pkt->duration = av_rescale(pkt->duration, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
674
}
675

    
676
static void av_destruct_packet_nofree(AVPacket *pkt)
677
{
678
    pkt->data = NULL; pkt->size = 0;
679
}
680

    
681
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
682
{
683
    AVStream *st;
684
    int len, ret, i;
685

    
686
    for(;;) {
687
        /* select current input stream component */
688
        st = s->cur_st;
689
        if (st) {
690
            if (!st->parser) {
691
                /* no parsing needed: we just output the packet as is */
692
                /* raw data support */
693
                *pkt = s->cur_pkt;
694
                compute_pkt_fields(s, st, NULL, pkt);
695
                s->cur_st = NULL;
696
                return 0;
697
            } else if (s->cur_len > 0) {
698
                len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size, 
699
                                      s->cur_ptr, s->cur_len,
700
                                      s->cur_pkt.pts, s->cur_pkt.dts);
701
                s->cur_pkt.pts = AV_NOPTS_VALUE;
702
                s->cur_pkt.dts = AV_NOPTS_VALUE;
703
                /* increment read pointer */
704
                s->cur_ptr += len;
705
                s->cur_len -= len;
706
                
707
                /* return packet if any */
708
                if (pkt->size) {
709
                got_packet:
710
                    pkt->duration = 0;
711
                    pkt->stream_index = st->index;
712
                    pkt->pts = st->parser->pts;
713
                    pkt->dts = st->parser->dts;
714
                    pkt->destruct = av_destruct_packet_nofree;
715
                    compute_pkt_fields(s, st, st->parser, pkt);
716
                    return 0;
717
                }
718
            } else {
719
                /* free packet */
720
                av_free_packet(&s->cur_pkt); 
721
                s->cur_st = NULL;
722
            }
723
        } else {
724
            /* read next packet */
725
            ret = av_read_packet(s, &s->cur_pkt);
726
            if (ret < 0) {
727
                if (ret == -EAGAIN)
728
                    return ret;
729
                /* return the last frames, if any */
730
                for(i = 0; i < s->nb_streams; i++) {
731
                    st = s->streams[i];
732
                    if (st->parser) {
733
                        av_parser_parse(st->parser, &st->codec, 
734
                                        &pkt->data, &pkt->size, 
735
                                        NULL, 0, 
736
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
737
                        if (pkt->size)
738
                            goto got_packet;
739
                    }
740
                }
741
                /* no more packets: really terminates parsing */
742
                return ret;
743
            }
744
            
745
            st = s->streams[s->cur_pkt.stream_index];
746

    
747
            s->cur_st = st;
748
            s->cur_ptr = s->cur_pkt.data;
749
            s->cur_len = s->cur_pkt.size;
750
            if (st->need_parsing && !st->parser) {
751
                st->parser = av_parser_init(st->codec.codec_id);
752
                if (!st->parser) {
753
                    /* no parser available : just output the raw packets */
754
                    st->need_parsing = 0;
755
                }
756
            }
757
        }
758
    }
759
}
760

    
761
/**
762
 * Return the next frame of a stream. The returned packet is valid
763
 * until the next av_read_frame() or until av_close_input_file() and
764
 * must be freed with av_free_packet. For video, the packet contains
765
 * exactly one frame. For audio, it contains an integer number of
766
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
767
 * data). If the audio frames have a variable size (e.g. MPEG audio),
768
 * then it contains one frame.
769
 * 
770
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
771
 * values in AV_TIME_BASE unit (and guessed if the format cannot
772
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
773
 * has B frames, so it is better to rely on pkt->dts if you do not
774
 * decompress the payload.
775
 * 
776
 * Return 0 if OK, < 0 if error or end of file.  
777
 */
778
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
779
{
780
    AVPacketList *pktl;
781

    
782
    pktl = s->packet_buffer;
783
    if (pktl) {
784
        /* read packet from packet buffer, if there is data */
785
        *pkt = pktl->pkt;
786
        s->packet_buffer = pktl->next;
787
        av_free(pktl);
788
        return 0;
789
    } else {
790
        return av_read_frame_internal(s, pkt);
791
    }
792
}
793

    
794
/* XXX: suppress the packet queue */
795
static void flush_packet_queue(AVFormatContext *s)
796
{
797
    AVPacketList *pktl;
798

    
799
    for(;;) {
800
        pktl = s->packet_buffer;
801
        if (!pktl) 
802
            break;
803
        s->packet_buffer = pktl->next;
804
        av_free_packet(&pktl->pkt);
805
        av_free(pktl);
806
    }
807
}
808

    
809
/*******************************************************/
810
/* seek support */
811

    
812
int av_find_default_stream_index(AVFormatContext *s)
813
{
814
    int i;
815
    AVStream *st;
816

    
817
    if (s->nb_streams <= 0)
818
        return -1;
819
    for(i = 0; i < s->nb_streams; i++) {
820
        st = s->streams[i];
821
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
822
            return i;
823
        }
824
    }
825
    return 0;
826
}
827

    
828
/* flush the frame reader */
829
static void av_read_frame_flush(AVFormatContext *s)
830
{
831
    AVStream *st;
832
    int i;
833

    
834
    flush_packet_queue(s);
835

    
836
    /* free previous packet */
837
    if (s->cur_st) {
838
        if (s->cur_st->parser)
839
            av_free_packet(&s->cur_pkt);
840
        s->cur_st = NULL;
841
    }
842
    /* fail safe */
843
    s->cur_ptr = NULL;
844
    s->cur_len = 0;
845
    
846
    /* for each stream, reset read state */
847
    for(i = 0; i < s->nb_streams; i++) {
848
        st = s->streams[i];
849
        
850
        if (st->parser) {
851
            av_parser_close(st->parser);
852
            st->parser = NULL;
853
        }
854
        st->last_IP_pts = AV_NOPTS_VALUE;
855
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
856
    }
857
}
858

    
859
/**
860
 * add a index entry into a sorted list updateing if it is already there.
861
 * @param timestamp timestamp in the timebase of the given stream
862
 */
863
int av_add_index_entry(AVStream *st,
864
                            int64_t pos, int64_t timestamp, int distance, int flags)
865
{
866
    AVIndexEntry *entries, *ie;
867
    int index;
868
    
869
    entries = av_fast_realloc(st->index_entries,
870
                              &st->index_entries_allocated_size,
871
                              (st->nb_index_entries + 1) * 
872
                              sizeof(AVIndexEntry));
873
    st->index_entries= entries;
874

    
875
    if(st->nb_index_entries){
876
        index= av_index_search_timestamp(st, timestamp);
877
        ie= &entries[index];
878

    
879
        if(ie->timestamp != timestamp){
880
            if(ie->timestamp < timestamp){
881
                index++; //index points to next instead of previous entry, maybe nonexistant
882
                ie= &st->index_entries[index];
883
            }else
884
                assert(index==0);
885
                
886
            if(index != st->nb_index_entries){
887
                assert(index < st->nb_index_entries);
888
                memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
889
            }
890
            st->nb_index_entries++;
891
        }else{
892
            if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
893
                distance= ie->min_distance;
894
        }
895
    }else{
896
        index= st->nb_index_entries++;
897
        ie= &entries[index];
898
    }
899
    
900
    ie->pos = pos;
901
    ie->timestamp = timestamp;
902
    ie->min_distance= distance;
903
    ie->flags = flags;
904
    
905
    return index;
906
}
907

    
908
/* build an index for raw streams using a parser */
909
static void av_build_index_raw(AVFormatContext *s)
910
{
911
    AVPacket pkt1, *pkt = &pkt1;
912
    int ret;
913
    AVStream *st;
914

    
915
    st = s->streams[0];
916
    av_read_frame_flush(s);
917
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
918

    
919
    for(;;) {
920
        ret = av_read_frame(s, pkt);
921
        if (ret < 0)
922
            break;
923
        if (pkt->stream_index == 0 && st->parser &&
924
            (pkt->flags & PKT_FLAG_KEY)) {
925
            int64_t dts= av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
926
            av_add_index_entry(st, st->parser->frame_offset, dts, 
927
                            0, AVINDEX_KEYFRAME);
928
        }
929
        av_free_packet(pkt);
930
    }
931
}
932

    
933
/* return TRUE if we deal with a raw stream (raw codec data and
934
   parsing needed) */
935
static int is_raw_stream(AVFormatContext *s)
936
{
937
    AVStream *st;
938

    
939
    if (s->nb_streams != 1)
940
        return 0;
941
    st = s->streams[0];
942
    if (!st->need_parsing)
943
        return 0;
944
    return 1;
945
}
946

    
947
/* return the largest index entry whose timestamp is <=
948
   wanted_timestamp */
949
int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
950
{
951
    AVIndexEntry *entries= st->index_entries;
952
    int nb_entries= st->nb_index_entries;
953
    int a, b, m;
954
    int64_t timestamp;
955

    
956
    if (nb_entries <= 0)
957
        return -1;
958
    
959
    a = 0;
960
    b = nb_entries - 1;
961

    
962
    while (a < b) {
963
        m = (a + b + 1) >> 1;
964
        timestamp = entries[m].timestamp;
965
        if (timestamp > wanted_timestamp) {
966
            b = m - 1;
967
        } else {
968
            a = m;
969
        }
970
    }
971
    return a;
972
}
973

    
974
#define DEBUG_SEEK
975

    
976
/**
977
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
978
 * this isnt supposed to be called directly by a user application, but by demuxers
979
 * @param target_ts target timestamp in the time base of the given stream
980
 * @param stream_index stream number
981
 */
982
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts){
983
    AVInputFormat *avif= s->iformat;
984
    int64_t pos_min, pos_max, pos, pos_limit;
985
    int64_t ts_min, ts_max, ts;
986
    int64_t start_pos;
987
    int index, no_change, i;
988
    AVStream *st;
989

    
990
    if (stream_index < 0)
991
        return -1;
992
    
993
#ifdef DEBUG_SEEK
994
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
995
#endif
996

    
997
    ts_max=
998
    ts_min= AV_NOPTS_VALUE;
999
    pos_limit= -1; //gcc falsely says it may be uninitalized
1000

    
1001
    st= s->streams[stream_index];
1002
    if(st->index_entries){
1003
        AVIndexEntry *e;
1004

    
1005
        index= av_index_search_timestamp(st, target_ts);
1006
        e= &st->index_entries[index];
1007

    
1008
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1009
            pos_min= e->pos;
1010
            ts_min= e->timestamp;
1011
#ifdef DEBUG_SEEK
1012
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%llx dts_min=%lld\n", 
1013
               pos_min,ts_min);
1014
#endif
1015
        }else{
1016
            assert(index==0);
1017
        }
1018
        index++;
1019
        if(index < st->nb_index_entries){
1020
            e= &st->index_entries[index];
1021
            assert(e->timestamp >= target_ts);
1022
            pos_max= e->pos;
1023
            ts_max= e->timestamp;
1024
            pos_limit= pos_max - e->min_distance;
1025
#ifdef DEBUG_SEEK
1026
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n", 
1027
               pos_max,pos_limit, ts_max);
1028
#endif
1029
        }
1030
    }
1031

    
1032
    if(ts_min == AV_NOPTS_VALUE){
1033
        pos_min = s->data_offset;
1034
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1035
        if (ts_min == AV_NOPTS_VALUE)
1036
            return -1;
1037
    }
1038

    
1039
    if(ts_max == AV_NOPTS_VALUE){
1040
        int step= 1024;
1041
        pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1042
        do{
1043
            pos_max -= step;
1044
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1045
            step += step;
1046
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1047
        if (ts_max == AV_NOPTS_VALUE)
1048
            return -1;
1049
        
1050
        for(;;){
1051
            int64_t tmp_pos= pos_max + 1;
1052
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1053
            if(tmp_ts == AV_NOPTS_VALUE)
1054
                break;
1055
            ts_max= tmp_ts;
1056
            pos_max= tmp_pos;
1057
        }
1058
        pos_limit= pos_max;
1059
    }
1060

    
1061
    no_change=0;
1062
    while (pos_min < pos_limit) {
1063
#ifdef DEBUG_SEEK
1064
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n", 
1065
               pos_min, pos_max,
1066
               ts_min, ts_max);
1067
#endif
1068
        assert(pos_limit <= pos_max);
1069

    
1070
        if(no_change==0){
1071
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1072
            // interpolate position (better than dichotomy)
1073
            pos = (int64_t)((double)(pos_max - pos_min) *
1074
                            (double)(target_ts - ts_min) /
1075
                            (double)(ts_max - ts_min)) + pos_min - approximate_keyframe_distance;
1076
        }else if(no_change==1){
1077
            // bisection, if interpolation failed to change min or max pos last time
1078
            pos = (pos_min + pos_limit)>>1;
1079
        }else{
1080
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1081
            pos=pos_min;
1082
        }
1083
        if(pos <= pos_min)
1084
            pos= pos_min + 1;
1085
        else if(pos > pos_limit)
1086
            pos= pos_limit;
1087
        start_pos= pos;
1088

    
1089
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1090
        if(pos == pos_max)
1091
            no_change++;
1092
        else
1093
            no_change=0;
1094
#ifdef DEBUG_SEEK
1095
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);
1096
#endif
1097
        assert(ts != AV_NOPTS_VALUE);
1098
        if (target_ts < ts) {
1099
            pos_limit = start_pos - 1;
1100
            pos_max = pos;
1101
            ts_max = ts;
1102
        } else {
1103
            pos_min = pos;
1104
            ts_min = ts;
1105
            /* check if we are lucky */
1106
            if (target_ts == ts)
1107
                break;
1108
        }
1109
    }
1110
    
1111
    pos = pos_min;
1112
#ifdef DEBUG_SEEK
1113
    pos_min = pos;
1114
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1115
    pos_min++;
1116
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1117
    av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n", 
1118
           pos, ts_min, target_ts, ts_max);
1119
#endif
1120
    /* do the seek */
1121
    url_fseek(&s->pb, pos, SEEK_SET);
1122

    
1123
    ts= av_rescale(ts_min, AV_TIME_BASE*(int64_t)st->time_base.num, st->time_base.den);
1124
    for(i = 0; i < s->nb_streams; i++) {
1125
        st = s->streams[i];
1126

    
1127
        st->cur_dts = av_rescale(ts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
1128
    }
1129

    
1130
    return 0;
1131
}
1132

    
1133
static int av_seek_frame_generic(AVFormatContext *s, 
1134
                                 int stream_index, int64_t timestamp)
1135
{
1136
    int index, i;
1137
    AVStream *st;
1138
    AVIndexEntry *ie;
1139

    
1140
    if (!s->index_built) {
1141
        if (is_raw_stream(s)) {
1142
            av_build_index_raw(s);
1143
        } else {
1144
            return -1;
1145
        }
1146
        s->index_built = 1;
1147
    }
1148

    
1149
    st = s->streams[stream_index];
1150
    index = av_index_search_timestamp(st, timestamp);
1151
    if (index < 0)
1152
        return -1;
1153

    
1154
    /* now we have found the index, we can seek */
1155
    ie = &st->index_entries[index];
1156
    av_read_frame_flush(s);
1157
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1158
    
1159
    timestamp= av_rescale(ie->timestamp, AV_TIME_BASE*(int64_t)st->time_base.num, st->time_base.den);
1160
    for(i = 0; i < s->nb_streams; i++) {
1161
        st = s->streams[i];
1162

    
1163
        st->cur_dts = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
1164
    }
1165

    
1166
    return 0;
1167
}
1168

    
1169
/**
1170
 * Seek to the key frame just before the frame at timestamp
1171
 * 'timestamp' in 'stream_index'.
1172
 * @param stream_index If stream_index is (-1), a default
1173
 * stream is selected
1174
 * @param timestamp timestamp in AV_TIME_BASE units
1175
 * @return >= 0 on success
1176
 */
1177
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1178
{
1179
    int ret;
1180
    AVStream *st;
1181
    
1182
    av_read_frame_flush(s);
1183
    
1184
    if(stream_index < 0){
1185
        stream_index= av_find_default_stream_index(s);
1186
        if(stream_index < 0)
1187
            return -1;
1188
    }
1189
    st= s->streams[stream_index];
1190

    
1191
    timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1192

    
1193
    /* first, we try the format specific seek */
1194
    if (s->iformat->read_seek)
1195
        ret = s->iformat->read_seek(s, stream_index, timestamp);
1196
    else
1197
        ret = -1;
1198
    if (ret >= 0) {
1199
        return 0;
1200
    }
1201

    
1202
    if(s->iformat->read_timestamp)
1203
        return av_seek_frame_binary(s, stream_index, timestamp);
1204
    else
1205
        return av_seek_frame_generic(s, stream_index, timestamp);
1206
}
1207

    
1208
/*******************************************************/
1209

    
1210
/* return TRUE if the stream has accurate timings for at least one component */
1211
static int av_has_timings(AVFormatContext *ic)
1212
{
1213
    int i;
1214
    AVStream *st;
1215

    
1216
    for(i = 0;i < ic->nb_streams; i++) {
1217
        st = ic->streams[i];
1218
        if (st->start_time != AV_NOPTS_VALUE &&
1219
            st->duration != AV_NOPTS_VALUE)
1220
            return 1;
1221
    }
1222
    return 0;
1223
}
1224

    
1225
/* estimate the stream timings from the one of each components. Also
1226
   compute the global bitrate if possible */
1227
static void av_update_stream_timings(AVFormatContext *ic)
1228
{
1229
    int64_t start_time, end_time, end_time1;
1230
    int i;
1231
    AVStream *st;
1232

    
1233
    start_time = MAXINT64;
1234
    end_time = MININT64;
1235
    for(i = 0;i < ic->nb_streams; i++) {
1236
        st = ic->streams[i];
1237
        if (st->start_time != AV_NOPTS_VALUE) {
1238
            if (st->start_time < start_time)
1239
                start_time = st->start_time;
1240
            if (st->duration != AV_NOPTS_VALUE) {
1241
                end_time1 = st->start_time + st->duration;
1242
                if (end_time1 > end_time)
1243
                    end_time = end_time1;
1244
            }
1245
        }
1246
    }
1247
    if (start_time != MAXINT64) {
1248
        ic->start_time = start_time;
1249
        if (end_time != MAXINT64) {
1250
            ic->duration = end_time - start_time;
1251
            if (ic->file_size > 0) {
1252
                /* compute the bit rate */
1253
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1254
                    (double)ic->duration;
1255
            }
1256
        }
1257
    }
1258

    
1259
}
1260

    
1261
static void fill_all_stream_timings(AVFormatContext *ic)
1262
{
1263
    int i;
1264
    AVStream *st;
1265

    
1266
    av_update_stream_timings(ic);
1267
    for(i = 0;i < ic->nb_streams; i++) {
1268
        st = ic->streams[i];
1269
        if (st->start_time == AV_NOPTS_VALUE) {
1270
            st->start_time = ic->start_time;
1271
            st->duration = ic->duration;
1272
        }
1273
    }
1274
}
1275

    
1276
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1277
{
1278
    int64_t filesize, duration;
1279
    int bit_rate, i;
1280
    AVStream *st;
1281

    
1282
    /* if bit_rate is already set, we believe it */
1283
    if (ic->bit_rate == 0) {
1284
        bit_rate = 0;
1285
        for(i=0;i<ic->nb_streams;i++) {
1286
            st = ic->streams[i];
1287
            bit_rate += st->codec.bit_rate;
1288
        }
1289
        ic->bit_rate = bit_rate;
1290
    }
1291

    
1292
    /* if duration is already set, we believe it */
1293
    if (ic->duration == AV_NOPTS_VALUE && 
1294
        ic->bit_rate != 0 && 
1295
        ic->file_size != 0)  {
1296
        filesize = ic->file_size;
1297
        if (filesize > 0) {
1298
            duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1299
            for(i = 0; i < ic->nb_streams; i++) {
1300
                st = ic->streams[i];
1301
                if (st->start_time == AV_NOPTS_VALUE ||
1302
                    st->duration == AV_NOPTS_VALUE) {
1303
                    st->start_time = 0;
1304
                    st->duration = duration;
1305
                }
1306
            }
1307
        }
1308
    }
1309
}
1310

    
1311
#define DURATION_MAX_READ_SIZE 250000
1312

    
1313
/* only usable for MPEG-PS streams */
1314
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1315
{
1316
    AVPacket pkt1, *pkt = &pkt1;
1317
    AVStream *st;
1318
    int read_size, i, ret;
1319
    int64_t start_time, end_time, end_time1;
1320
    int64_t filesize, offset, duration;
1321
    
1322
    /* free previous packet */
1323
    if (ic->cur_st && ic->cur_st->parser)
1324
        av_free_packet(&ic->cur_pkt); 
1325
    ic->cur_st = NULL;
1326

    
1327
    /* flush packet queue */
1328
    flush_packet_queue(ic);
1329

    
1330
    for(i=0;i<ic->nb_streams;i++) {
1331
        st = ic->streams[i];
1332
        if (st->parser) {
1333
            av_parser_close(st->parser);
1334
            st->parser= NULL;
1335
        }
1336
    }
1337
    
1338
    /* we read the first packets to get the first PTS (not fully
1339
       accurate, but it is enough now) */
1340
    url_fseek(&ic->pb, 0, SEEK_SET);
1341
    read_size = 0;
1342
    for(;;) {
1343
        if (read_size >= DURATION_MAX_READ_SIZE)
1344
            break;
1345
        /* if all info is available, we can stop */
1346
        for(i = 0;i < ic->nb_streams; i++) {
1347
            st = ic->streams[i];
1348
            if (st->start_time == AV_NOPTS_VALUE)
1349
                break;
1350
        }
1351
        if (i == ic->nb_streams)
1352
            break;
1353

    
1354
        ret = av_read_packet(ic, pkt);
1355
        if (ret != 0)
1356
            break;
1357
        read_size += pkt->size;
1358
        st = ic->streams[pkt->stream_index];
1359
        if (pkt->pts != AV_NOPTS_VALUE) {
1360
            if (st->start_time == AV_NOPTS_VALUE)
1361
                st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1362
        }
1363
        av_free_packet(pkt);
1364
    }
1365

    
1366
    /* we compute the minimum start_time and use it as default */
1367
    start_time = MAXINT64;
1368
    for(i = 0; i < ic->nb_streams; i++) {
1369
        st = ic->streams[i];
1370
        if (st->start_time != AV_NOPTS_VALUE &&
1371
            st->start_time < start_time)
1372
            start_time = st->start_time;
1373
    }
1374
    if (start_time != MAXINT64)
1375
        ic->start_time = start_time;
1376
    
1377
    /* estimate the end time (duration) */
1378
    /* XXX: may need to support wrapping */
1379
    filesize = ic->file_size;
1380
    offset = filesize - DURATION_MAX_READ_SIZE;
1381
    if (offset < 0)
1382
        offset = 0;
1383

    
1384
    url_fseek(&ic->pb, offset, SEEK_SET);
1385
    read_size = 0;
1386
    for(;;) {
1387
        if (read_size >= DURATION_MAX_READ_SIZE)
1388
            break;
1389
        /* if all info is available, we can stop */
1390
        for(i = 0;i < ic->nb_streams; i++) {
1391
            st = ic->streams[i];
1392
            if (st->duration == AV_NOPTS_VALUE)
1393
                break;
1394
        }
1395
        if (i == ic->nb_streams)
1396
            break;
1397
        
1398
        ret = av_read_packet(ic, pkt);
1399
        if (ret != 0)
1400
            break;
1401
        read_size += pkt->size;
1402
        st = ic->streams[pkt->stream_index];
1403
        if (pkt->pts != AV_NOPTS_VALUE) {
1404
            end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1405
            duration = end_time - st->start_time;
1406
            if (duration > 0) {
1407
                if (st->duration == AV_NOPTS_VALUE ||
1408
                    st->duration < duration)
1409
                    st->duration = duration;
1410
            }
1411
        }
1412
        av_free_packet(pkt);
1413
    }
1414
    
1415
    /* estimate total duration */
1416
    end_time = MININT64;
1417
    for(i = 0;i < ic->nb_streams; i++) {
1418
        st = ic->streams[i];
1419
        if (st->duration != AV_NOPTS_VALUE) {
1420
            end_time1 = st->start_time + st->duration;
1421
            if (end_time1 > end_time)
1422
                end_time = end_time1;
1423
        }
1424
    }
1425
    
1426
    /* update start_time (new stream may have been created, so we do
1427
       it at the end */
1428
    if (ic->start_time != AV_NOPTS_VALUE) {
1429
        for(i = 0; i < ic->nb_streams; i++) {
1430
            st = ic->streams[i];
1431
            if (st->start_time == AV_NOPTS_VALUE)
1432
                st->start_time = ic->start_time;
1433
        }
1434
    }
1435

    
1436
    if (end_time != MININT64) {
1437
        /* put dummy values for duration if needed */
1438
        for(i = 0;i < ic->nb_streams; i++) {
1439
            st = ic->streams[i];
1440
            if (st->duration == AV_NOPTS_VALUE && 
1441
                st->start_time != AV_NOPTS_VALUE)
1442
                st->duration = end_time - st->start_time;
1443
        }
1444
        ic->duration = end_time - ic->start_time;
1445
    }
1446

    
1447
    url_fseek(&ic->pb, 0, SEEK_SET);
1448
}
1449

    
1450
static void av_estimate_timings(AVFormatContext *ic)
1451
{
1452
    URLContext *h;
1453
    int64_t file_size;
1454

    
1455
    /* get the file size, if possible */
1456
    if (ic->iformat->flags & AVFMT_NOFILE) {
1457
        file_size = 0;
1458
    } else {
1459
        h = url_fileno(&ic->pb);
1460
        file_size = url_filesize(h);
1461
        if (file_size < 0)
1462
            file_size = 0;
1463
    }
1464
    ic->file_size = file_size;
1465

    
1466
    if (ic->iformat == &mpegps_demux) {
1467
        /* get accurate estimate from the PTSes */
1468
        av_estimate_timings_from_pts(ic);
1469
    } else if (av_has_timings(ic)) {
1470
        /* at least one components has timings - we use them for all
1471
           the components */
1472
        fill_all_stream_timings(ic);
1473
    } else {
1474
        /* less precise: use bit rate info */
1475
        av_estimate_timings_from_bit_rate(ic);
1476
    }
1477
    av_update_stream_timings(ic);
1478

    
1479
#if 0
1480
    {
1481
        int i;
1482
        AVStream *st;
1483
        for(i = 0;i < ic->nb_streams; i++) {
1484
            st = ic->streams[i];
1485
        printf("%d: start_time: %0.3f duration: %0.3f\n", 
1486
               i, (double)st->start_time / AV_TIME_BASE, 
1487
               (double)st->duration / AV_TIME_BASE);
1488
        }
1489
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1490
               (double)ic->start_time / AV_TIME_BASE, 
1491
               (double)ic->duration / AV_TIME_BASE,
1492
               ic->bit_rate / 1000);
1493
    }
1494
#endif
1495
}
1496

    
1497
static int has_codec_parameters(AVCodecContext *enc)
1498
{
1499
    int val;
1500
    switch(enc->codec_type) {
1501
    case CODEC_TYPE_AUDIO:
1502
        val = enc->sample_rate;
1503
        break;
1504
    case CODEC_TYPE_VIDEO:
1505
        val = enc->width;
1506
        break;
1507
    default:
1508
        val = 1;
1509
        break;
1510
    }
1511
    return (val != 0);
1512
}
1513

    
1514
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1515
{
1516
    int16_t *samples;
1517
    AVCodec *codec;
1518
    int got_picture, ret;
1519
    AVFrame picture;
1520
    
1521
    codec = avcodec_find_decoder(st->codec.codec_id);
1522
    if (!codec)
1523
        return -1;
1524
    ret = avcodec_open(&st->codec, codec);
1525
    if (ret < 0)
1526
        return ret;
1527
    switch(st->codec.codec_type) {
1528
    case CODEC_TYPE_VIDEO:
1529
        ret = avcodec_decode_video(&st->codec, &picture, 
1530
                                   &got_picture, (uint8_t *)data, size);
1531
        break;
1532
    case CODEC_TYPE_AUDIO:
1533
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1534
        if (!samples)
1535
            goto fail;
1536
        ret = avcodec_decode_audio(&st->codec, samples, 
1537
                                   &got_picture, (uint8_t *)data, size);
1538
        av_free(samples);
1539
        break;
1540
    default:
1541
        break;
1542
    }
1543
 fail:
1544
    avcodec_close(&st->codec);
1545
    return ret;
1546
}
1547

    
1548
/* absolute maximum size we read until we abort */
1549
#define MAX_READ_SIZE        5000000
1550

    
1551
/* maximum duration until we stop analysing the stream */
1552
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1553

    
1554
/**
1555
 * Read the beginning of a media file to get stream information. This
1556
 * is useful for file formats with no headers such as MPEG. This
1557
 * function also compute the real frame rate in case of mpeg2 repeat
1558
 * frame mode.
1559
 *
1560
 * @param ic media file handle
1561
 * @return >=0 if OK. AVERROR_xxx if error.  
1562
 */
1563
int av_find_stream_info(AVFormatContext *ic)
1564
{
1565
    int i, count, ret, read_size;
1566
    AVStream *st;
1567
    AVPacket pkt1, *pkt;
1568
    AVPacketList *pktl=NULL, **ppktl;
1569

    
1570
    count = 0;
1571
    read_size = 0;
1572
    ppktl = &ic->packet_buffer;
1573
    for(;;) {
1574
        /* check if one codec still needs to be handled */
1575
        for(i=0;i<ic->nb_streams;i++) {
1576
            st = ic->streams[i];
1577
            if (!has_codec_parameters(&st->codec))
1578
                break;
1579
        }
1580
        if (i == ic->nb_streams) {
1581
            /* NOTE: if the format has no header, then we need to read
1582
               some packets to get most of the streams, so we cannot
1583
               stop here */
1584
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1585
                /* if we found the info for all the codecs, we can stop */
1586
                ret = count;
1587
                break;
1588
            }
1589
        } else {
1590
            /* we did not get all the codec info, but we read too much data */
1591
            if (read_size >= MAX_READ_SIZE) {
1592
                ret = count;
1593
                break;
1594
            }
1595
        }
1596

    
1597
        /* NOTE: a new stream can be added there if no header in file
1598
           (AVFMTCTX_NOHEADER) */
1599
        ret = av_read_frame_internal(ic, &pkt1);
1600
        if (ret < 0) {
1601
            /* EOF or error */
1602
            ret = -1; /* we could not have all the codec parameters before EOF */
1603
            if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1604
                i == ic->nb_streams)
1605
                ret = 0;
1606
            break;
1607
        }
1608

    
1609
        pktl = av_mallocz(sizeof(AVPacketList));
1610
        if (!pktl) {
1611
            ret = AVERROR_NOMEM;
1612
            break;
1613
        }
1614

    
1615
        /* add the packet in the buffered packet list */
1616
        *ppktl = pktl;
1617
        ppktl = &pktl->next;
1618

    
1619
        pkt = &pktl->pkt;
1620
        *pkt = pkt1;
1621
        
1622
        /* duplicate the packet */
1623
        if (av_dup_packet(pkt) < 0) {
1624
                ret = AVERROR_NOMEM;
1625
                break;
1626
        }
1627

    
1628
        read_size += pkt->size;
1629

    
1630
        st = ic->streams[pkt->stream_index];
1631
        st->codec_info_duration += pkt->duration;
1632
        if (pkt->duration != 0)
1633
            st->codec_info_nb_frames++;
1634

    
1635
        /* if still no information, we try to open the codec and to
1636
           decompress the frame. We try to avoid that in most cases as
1637
           it takes longer and uses more memory. For MPEG4, we need to
1638
           decompress for Quicktime. */
1639
        if (!has_codec_parameters(&st->codec) &&
1640
            (st->codec.codec_id == CODEC_ID_FLV1 ||
1641
             st->codec.codec_id == CODEC_ID_H264 ||
1642
             st->codec.codec_id == CODEC_ID_H263 ||
1643
             st->codec.codec_id == CODEC_ID_VORBIS ||
1644
             st->codec.codec_id == CODEC_ID_MJPEG ||
1645
             (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1646
            try_decode_frame(st, pkt->data, pkt->size);
1647
        
1648
        if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1649
            break;
1650
        }
1651
        count++;
1652
    }
1653

    
1654
    /* set real frame rate info */
1655
    for(i=0;i<ic->nb_streams;i++) {
1656
        st = ic->streams[i];
1657
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1658
            /* compute the real frame rate for telecine */
1659
            if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1660
                 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1661
                st->codec.sub_id == 2) {
1662
                if (st->codec_info_nb_frames >= 20) {
1663
                    float coded_frame_rate, est_frame_rate;
1664
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1665
                        (double)st->codec_info_duration ;
1666
                    coded_frame_rate = (double)st->codec.frame_rate /
1667
                        (double)st->codec.frame_rate_base;
1668
#if 0
1669
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1670
                           coded_frame_rate, est_frame_rate);
1671
#endif
1672
                    /* if we detect that it could be a telecine, we
1673
                       signal it. It would be better to do it at a
1674
                       higher level as it can change in a film */
1675
                    if (coded_frame_rate >= 24.97 && 
1676
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1677
                        st->r_frame_rate = 24024;
1678
                        st->r_frame_rate_base = 1001;
1679
                    }
1680
                }
1681
            }
1682
            /* if no real frame rate, use the codec one */
1683
            if (!st->r_frame_rate){
1684
                st->r_frame_rate      = st->codec.frame_rate;
1685
                st->r_frame_rate_base = st->codec.frame_rate_base;
1686
            }
1687
        }
1688
    }
1689

    
1690
    av_estimate_timings(ic);
1691
#if 0
1692
    /* correct DTS for b frame streams with no timestamps */
1693
    for(i=0;i<ic->nb_streams;i++) {
1694
        st = ic->streams[i];
1695
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1696
            if(b-frames){
1697
                ppktl = &ic->packet_buffer;
1698
                while(ppkt1){
1699
                    if(ppkt1->stream_index != i)
1700
                        continue;
1701
                    if(ppkt1->pkt->dts < 0)
1702
                        break;
1703
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1704
                        break;
1705
                    ppkt1->pkt->dts -= delta;
1706
                    ppkt1= ppkt1->next;
1707
                }
1708
                if(ppkt1)
1709
                    continue;
1710
                st->cur_dts -= delta;
1711
            }
1712
        }
1713
    }
1714
#endif
1715
    return ret;
1716
}
1717

    
1718
/*******************************************************/
1719

    
1720
/**
1721
 * start playing a network based stream (e.g. RTSP stream) at the
1722
 * current position 
1723
 */
1724
int av_read_play(AVFormatContext *s)
1725
{
1726
    if (!s->iformat->read_play)
1727
        return AVERROR_NOTSUPP;
1728
    return s->iformat->read_play(s);
1729
}
1730

    
1731
/**
1732
 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1733
 * to resume it.
1734
 */
1735
int av_read_pause(AVFormatContext *s)
1736
{
1737
    if (!s->iformat->read_pause)
1738
        return AVERROR_NOTSUPP;
1739
    return s->iformat->read_pause(s);
1740
}
1741

    
1742
/**
1743
 * Close a media file (but not its codecs)
1744
 *
1745
 * @param s media file handle
1746
 */
1747
void av_close_input_file(AVFormatContext *s)
1748
{
1749
    int i, must_open_file;
1750
    AVStream *st;
1751

    
1752
    /* free previous packet */
1753
    if (s->cur_st && s->cur_st->parser)
1754
        av_free_packet(&s->cur_pkt); 
1755

    
1756
    if (s->iformat->read_close)
1757
        s->iformat->read_close(s);
1758
    for(i=0;i<s->nb_streams;i++) {
1759
        /* free all data in a stream component */
1760
        st = s->streams[i];
1761
        if (st->parser) {
1762
            av_parser_close(st->parser);
1763
        }
1764
        av_free(st->index_entries);
1765
        av_free(st);
1766
    }
1767
    flush_packet_queue(s);
1768
    must_open_file = 1;
1769
    if (s->iformat->flags & AVFMT_NOFILE) {
1770
        must_open_file = 0;
1771
    }
1772
    if (must_open_file) {
1773
        url_fclose(&s->pb);
1774
    }
1775
    av_freep(&s->priv_data);
1776
    av_free(s);
1777
}
1778

    
1779
/**
1780
 * Add a new stream to a media file. Can only be called in the
1781
 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1782
 * format context, then new streams can be added in read_packet too.
1783
 *
1784
 *
1785
 * @param s media file handle
1786
 * @param id file format dependent stream id 
1787
 */
1788
AVStream *av_new_stream(AVFormatContext *s, int id)
1789
{
1790
    AVStream *st;
1791

    
1792
    if (s->nb_streams >= MAX_STREAMS)
1793
        return NULL;
1794

    
1795
    st = av_mallocz(sizeof(AVStream));
1796
    if (!st)
1797
        return NULL;
1798
    avcodec_get_context_defaults(&st->codec);
1799
    if (s->iformat) {
1800
        /* no default bitrate if decoding */
1801
        st->codec.bit_rate = 0;
1802
    }
1803
    st->index = s->nb_streams;
1804
    st->id = id;
1805
    st->start_time = AV_NOPTS_VALUE;
1806
    st->duration = AV_NOPTS_VALUE;
1807
    st->cur_dts = AV_NOPTS_VALUE;
1808

    
1809
    /* default pts settings is MPEG like */
1810
    av_set_pts_info(st, 33, 1, 90000);
1811
    st->last_IP_pts = AV_NOPTS_VALUE;
1812

    
1813
    s->streams[s->nb_streams++] = st;
1814
    return st;
1815
}
1816

    
1817
/************************************************************/
1818
/* output media file */
1819

    
1820
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1821
{
1822
    int ret;
1823
    
1824
    if (s->oformat->priv_data_size > 0) {
1825
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
1826
        if (!s->priv_data)
1827
            return AVERROR_NOMEM;
1828
    } else
1829
        s->priv_data = NULL;
1830
        
1831
    if (s->oformat->set_parameters) {
1832
        ret = s->oformat->set_parameters(s, ap);
1833
        if (ret < 0)
1834
            return ret;
1835
    }
1836
    return 0;
1837
}
1838

    
1839
/**
1840
 * allocate the stream private data and write the stream header to an
1841
 * output media file
1842
 *
1843
 * @param s media file handle
1844
 * @return 0 if OK. AVERROR_xxx if error.  
1845
 */
1846
int av_write_header(AVFormatContext *s)
1847
{
1848
    int ret, i;
1849
    AVStream *st;
1850

    
1851
    ret = s->oformat->write_header(s);
1852
    if (ret < 0)
1853
        return ret;
1854

    
1855
    /* init PTS generation */
1856
    for(i=0;i<s->nb_streams;i++) {
1857
        st = s->streams[i];
1858

    
1859
        switch (st->codec.codec_type) {
1860
        case CODEC_TYPE_AUDIO:
1861
            av_frac_init(&st->pts, 0, 0, 
1862
                         (int64_t)st->time_base.num * st->codec.sample_rate);
1863
            break;
1864
        case CODEC_TYPE_VIDEO:
1865
            av_frac_init(&st->pts, 0, 0, 
1866
                         (int64_t)st->time_base.num * st->codec.frame_rate);
1867
            break;
1868
        default:
1869
            break;
1870
        }
1871
    }
1872
    return 0;
1873
}
1874

    
1875
//FIXME merge with compute_pkt_fields
1876
static void compute_pkt_fields2(AVStream *st, AVPacket *pkt){
1877
    int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
1878
    int num, den, frame_size;
1879

    
1880
//    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);
1881
    
1882
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
1883
        return -1;*/
1884
            
1885
    if(pkt->pts != AV_NOPTS_VALUE)
1886
        pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1887
    if(pkt->dts != AV_NOPTS_VALUE)
1888
        pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1889

    
1890
    /* duration field */
1891
    pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1892
    if (pkt->duration == 0) {
1893
        compute_frame_duration(&num, &den, st, NULL, pkt);
1894
        if (den && num) {
1895
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
1896
        }
1897
    }
1898

    
1899
    //XXX/FIXME this is a temporary hack until all encoders output pts
1900
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
1901
        pkt->dts=
1902
//        pkt->pts= st->cur_dts;
1903
        pkt->pts= st->pts.val;
1904
    }
1905

    
1906
    //calculate dts from pts    
1907
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
1908
        if(b_frames){
1909
            if(st->last_IP_pts == AV_NOPTS_VALUE){
1910
                st->last_IP_pts= -pkt->duration;
1911
            }
1912
            if(st->last_IP_pts < pkt->pts){
1913
                pkt->dts= st->last_IP_pts;
1914
                st->last_IP_pts= pkt->pts;
1915
            }else
1916
                pkt->dts= pkt->pts;
1917
        }else
1918
            pkt->dts= pkt->pts;
1919
    }
1920
    
1921
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
1922
    st->cur_dts= pkt->dts;
1923
    st->pts.val= pkt->dts;
1924

    
1925
    /* update pts */
1926
    switch (st->codec.codec_type) {
1927
    case CODEC_TYPE_AUDIO:
1928
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
1929

    
1930
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
1931
           but it would be better if we had the real timestamps from the encoder */
1932
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
1933
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
1934
        }
1935
        break;
1936
    case CODEC_TYPE_VIDEO:
1937
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
1938
        break;
1939
    default:
1940
        break;
1941
    }
1942
}
1943

    
1944
static void truncate_ts(AVStream *st, AVPacket *pkt){
1945
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
1946
    
1947
    if(pkt->dts < 0)
1948
        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
1949
    
1950
    pkt->pts &= pts_mask;
1951
    pkt->dts &= pts_mask;
1952
}
1953

    
1954
/**
1955
 * Write a packet to an output media file. The packet shall contain
1956
 * one audio or video frame.
1957
 *
1958
 * @param s media file handle
1959
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
1960
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1961
 */
1962
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
1963
{
1964
    compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
1965
    
1966
    truncate_ts(s->streams[pkt->stream_index], pkt);
1967

    
1968
    return s->oformat->write_packet(s, pkt);
1969
}
1970

    
1971
/**
1972
 * Writes a packet to an output media file ensuring correct interleaving. 
1973
 * The packet shall contain one audio or video frame.
1974
 * If the packets are already correctly interleaved the application should
1975
 * call av_write_frame() instead as its slightly faster, its also important
1976
 * to keep in mind that non interlaved input will need huge amounts
1977
 * of memory to interleave with this, so its prefereable to interleave at the
1978
 * demuxer level
1979
 *
1980
 * @param s media file handle
1981
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
1982
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1983
 */
1984
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
1985
    AVPacketList *pktl, **next_point, *this_pktl;
1986
    int stream_count=0;
1987
    int streams[MAX_STREAMS];
1988
    AVStream *st= s->streams[ pkt->stream_index];
1989

    
1990
    compute_pkt_fields2(st, pkt);
1991
    
1992
    //FIXME/XXX/HACK drop zero sized packets
1993
    if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
1994
        return 0;
1995

    
1996
    if(pkt->dts == AV_NOPTS_VALUE)
1997
        return -1;
1998
        
1999
    assert(pkt->destruct != av_destruct_packet); //FIXME
2000

    
2001
    this_pktl = av_mallocz(sizeof(AVPacketList));
2002
    this_pktl->pkt= *pkt;
2003
    av_dup_packet(&this_pktl->pkt);
2004

    
2005
    next_point = &s->packet_buffer;
2006
    while(*next_point){
2007
        AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2008
        int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2009
        int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2010
        if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2011
            break;
2012
        next_point= &(*next_point)->next;
2013
    }
2014
    this_pktl->next= *next_point;
2015
    *next_point= this_pktl;
2016
    
2017
    memset(streams, 0, sizeof(streams));
2018
    pktl= s->packet_buffer;
2019
    while(pktl){
2020
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2021
        if(streams[ pktl->pkt.stream_index ] == 0)
2022
            stream_count++;
2023
        streams[ pktl->pkt.stream_index ]++;
2024
        pktl= pktl->next;
2025
    }
2026

    
2027
    while(s->nb_streams == stream_count){
2028
        int ret;
2029

    
2030
        pktl= s->packet_buffer;
2031
//av_log(s, AV_LOG_DEBUG, "write st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2032
        truncate_ts(s->streams[pktl->pkt.stream_index], &pktl->pkt);
2033
        ret= s->oformat->write_packet(s, &pktl->pkt);
2034
        
2035
        s->packet_buffer= pktl->next;        
2036
        if((--streams[ pktl->pkt.stream_index ]) == 0)
2037
            stream_count--;
2038

    
2039
        av_free_packet(&pktl->pkt);
2040
        av_freep(&pktl);
2041
        
2042
        if(ret<0)
2043
            return ret;
2044
    }
2045
    return 0;
2046
}
2047

    
2048
/**
2049
 * write the stream trailer to an output media file and and free the
2050
 * file private data.
2051
 *
2052
 * @param s media file handle
2053
 * @return 0 if OK. AVERROR_xxx if error.  */
2054
int av_write_trailer(AVFormatContext *s)
2055
{
2056
    int ret;
2057
    
2058
    while(s->packet_buffer){
2059
        int ret;
2060
        AVPacketList *pktl= s->packet_buffer;
2061

    
2062
//av_log(s, AV_LOG_DEBUG, "write_trailer st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2063
        truncate_ts(s->streams[pktl->pkt.stream_index], &pktl->pkt);
2064
        ret= s->oformat->write_packet(s, &pktl->pkt);
2065
        
2066
        s->packet_buffer= pktl->next;        
2067

    
2068
        av_free_packet(&pktl->pkt);
2069
        av_freep(&pktl);
2070
        
2071
        if(ret<0)
2072
            return ret;
2073
    }
2074

    
2075
    ret = s->oformat->write_trailer(s);
2076
    av_freep(&s->priv_data);
2077
    return ret;
2078
}
2079

    
2080
/* "user interface" functions */
2081

    
2082
void dump_format(AVFormatContext *ic,
2083
                 int index, 
2084
                 const char *url,
2085
                 int is_output)
2086
{
2087
    int i, flags;
2088
    char buf[256];
2089

    
2090
    av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
2091
            is_output ? "Output" : "Input",
2092
            index, 
2093
            is_output ? ic->oformat->name : ic->iformat->name, 
2094
            is_output ? "to" : "from", url);
2095
    if (!is_output) {
2096
        av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
2097
        if (ic->duration != AV_NOPTS_VALUE) {
2098
            int hours, mins, secs, us;
2099
            secs = ic->duration / AV_TIME_BASE;
2100
            us = ic->duration % AV_TIME_BASE;
2101
            mins = secs / 60;
2102
            secs %= 60;
2103
            hours = mins / 60;
2104
            mins %= 60;
2105
            av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
2106
                   (10 * us) / AV_TIME_BASE);
2107
        } else {
2108
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2109
        }
2110
        av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
2111
        if (ic->bit_rate) {
2112
            av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
2113
        } else {
2114
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2115
        }
2116
        av_log(NULL, AV_LOG_DEBUG, "\n");
2117
    }
2118
    for(i=0;i<ic->nb_streams;i++) {
2119
        AVStream *st = ic->streams[i];
2120
        avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2121
        av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
2122
        /* the pid is an important information, so we display it */
2123
        /* XXX: add a generic system */
2124
        if (is_output)
2125
            flags = ic->oformat->flags;
2126
        else
2127
            flags = ic->iformat->flags;
2128
        if (flags & AVFMT_SHOW_IDS) {
2129
            av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
2130
        }
2131
        av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
2132
    }
2133
}
2134

    
2135
typedef struct {
2136
    const char *abv;
2137
    int width, height;
2138
    int frame_rate, frame_rate_base;
2139
} AbvEntry;
2140

    
2141
static AbvEntry frame_abvs[] = {
2142
    { "ntsc",      720, 480, 30000, 1001 },
2143
    { "pal",       720, 576,    25,    1 },
2144
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2145
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2146
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2147
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2148
    { "film",      352, 240,    24,    1 },
2149
    { "ntsc-film", 352, 240, 24000, 1001 },
2150
    { "sqcif",     128,  96,     0,    0 },
2151
    { "qcif",      176, 144,     0,    0 },
2152
    { "cif",       352, 288,     0,    0 },
2153
    { "4cif",      704, 576,     0,    0 },
2154
};
2155

    
2156
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2157
{
2158
    int i;
2159
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2160
    const char *p;
2161
    int frame_width = 0, frame_height = 0;
2162

    
2163
    for(i=0;i<n;i++) {
2164
        if (!strcmp(frame_abvs[i].abv, str)) {
2165
            frame_width = frame_abvs[i].width;
2166
            frame_height = frame_abvs[i].height;
2167
            break;
2168
        }
2169
    }
2170
    if (i == n) {
2171
        p = str;
2172
        frame_width = strtol(p, (char **)&p, 10);
2173
        if (*p)
2174
            p++;
2175
        frame_height = strtol(p, (char **)&p, 10);
2176
    }
2177
    if (frame_width <= 0 || frame_height <= 0)
2178
        return -1;
2179
    *width_ptr = frame_width;
2180
    *height_ptr = frame_height;
2181
    return 0;
2182
}
2183

    
2184
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2185
{
2186
    int i;
2187
    char* cp;
2188
   
2189
    /* First, we check our abbreviation table */
2190
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2191
         if (!strcmp(frame_abvs[i].abv, arg)) {
2192
             *frame_rate = frame_abvs[i].frame_rate;
2193
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2194
             return 0;
2195
         }
2196

    
2197
    /* Then, we try to parse it as fraction */
2198
    cp = strchr(arg, '/');
2199
    if (cp) {
2200
        char* cpp;
2201
        *frame_rate = strtol(arg, &cpp, 10);
2202
        if (cpp != arg || cpp == cp) 
2203
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2204
        else
2205
           *frame_rate = 0;
2206
    } 
2207
    else {
2208
        /* Finally we give up and parse it as double */
2209
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2210
        *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2211
    }
2212
    if (!*frame_rate || !*frame_rate_base)
2213
        return -1;
2214
    else
2215
        return 0;
2216
}
2217

    
2218
/* Syntax:
2219
 * - If not a duration:
2220
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2221
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2222
 * Return the date in micro seconds since 1970 
2223
 * - If duration:
2224
 *  HH[:MM[:SS[.m...]]]
2225
 *  S+[.m...]
2226
 */
2227
int64_t parse_date(const char *datestr, int duration)
2228
{
2229
    const char *p;
2230
    int64_t t;
2231
    struct tm dt;
2232
    int i;
2233
    static const char *date_fmt[] = {
2234
        "%Y-%m-%d",
2235
        "%Y%m%d",
2236
    };
2237
    static const char *time_fmt[] = {
2238
        "%H:%M:%S",
2239
        "%H%M%S",
2240
    };
2241
    const char *q;
2242
    int is_utc, len;
2243
    char lastch;
2244
    int negative = 0;
2245

    
2246
#undef time
2247
    time_t now = time(0);
2248

    
2249
    len = strlen(datestr);
2250
    if (len > 0)
2251
        lastch = datestr[len - 1];
2252
    else
2253
        lastch = '\0';
2254
    is_utc = (lastch == 'z' || lastch == 'Z');
2255

    
2256
    memset(&dt, 0, sizeof(dt));
2257

    
2258
    p = datestr;
2259
    q = NULL;
2260
    if (!duration) {
2261
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2262
            q = small_strptime(p, date_fmt[i], &dt);
2263
            if (q) {
2264
                break;
2265
            }
2266
        }
2267

    
2268
        if (!q) {
2269
            if (is_utc) {
2270
                dt = *gmtime(&now);
2271
            } else {
2272
                dt = *localtime(&now);
2273
            }
2274
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2275
        } else {
2276
            p = q;
2277
        }
2278

    
2279
        if (*p == 'T' || *p == 't' || *p == ' ')
2280
            p++;
2281

    
2282
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2283
            q = small_strptime(p, time_fmt[i], &dt);
2284
            if (q) {
2285
                break;
2286
            }
2287
        }
2288
    } else {
2289
        if (p[0] == '-') {
2290
            negative = 1;
2291
            ++p;
2292
        }
2293
        q = small_strptime(p, time_fmt[0], &dt);
2294
        if (!q) {
2295
            dt.tm_sec = strtol(p, (char **)&q, 10);
2296
            dt.tm_min = 0;
2297
            dt.tm_hour = 0;
2298
        }
2299
    }
2300

    
2301
    /* Now we have all the fields that we can get */
2302
    if (!q) {
2303
        if (duration)
2304
            return 0;
2305
        else
2306
            return now * int64_t_C(1000000);
2307
    }
2308

    
2309
    if (duration) {
2310
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2311
    } else {
2312
        dt.tm_isdst = -1;       /* unknown */
2313
        if (is_utc) {
2314
            t = mktimegm(&dt);
2315
        } else {
2316
            t = mktime(&dt);
2317
        }
2318
    }
2319

    
2320
    t *= 1000000;
2321

    
2322
    if (*q == '.') {
2323
        int val, n;
2324
        q++;
2325
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2326
            if (!isdigit(*q)) 
2327
                break;
2328
            val += n * (*q - '0');
2329
        }
2330
        t += val;
2331
    }
2332
    return negative ? -t : t;
2333
}
2334

    
2335
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2336
   1 if found */
2337
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2338
{
2339
    const char *p;
2340
    char tag[128], *q;
2341

    
2342
    p = info;
2343
    if (*p == '?')
2344
        p++;
2345
    for(;;) {
2346
        q = tag;
2347
        while (*p != '\0' && *p != '=' && *p != '&') {
2348
            if ((q - tag) < sizeof(tag) - 1)
2349
                *q++ = *p;
2350
            p++;
2351
        }
2352
        *q = '\0';
2353
        q = arg;
2354
        if (*p == '=') {
2355
            p++;
2356
            while (*p != '&' && *p != '\0') {
2357
                if ((q - arg) < arg_size - 1) {
2358
                    if (*p == '+')
2359
                        *q++ = ' ';
2360
                    else
2361
                        *q++ = *p;
2362
                }
2363
                p++;
2364
            }
2365
            *q = '\0';
2366
        }
2367
        if (!strcmp(tag, tag1)) 
2368
            return 1;
2369
        if (*p != '&')
2370
            break;
2371
        p++;
2372
    }
2373
    return 0;
2374
}
2375

    
2376
/* Return in 'buf' the path with '%d' replaced by number. Also handles
2377
   the '%0nd' format where 'n' is the total number of digits and
2378
   '%%'. Return 0 if OK, and -1 if format error */
2379
int get_frame_filename(char *buf, int buf_size,
2380
                       const char *path, int number)
2381
{
2382
    const char *p;
2383
    char *q, buf1[20], c;
2384
    int nd, len, percentd_found;
2385

    
2386
    q = buf;
2387
    p = path;
2388
    percentd_found = 0;
2389
    for(;;) {
2390
        c = *p++;
2391
        if (c == '\0')
2392
            break;
2393
        if (c == '%') {
2394
            do {
2395
                nd = 0;
2396
                while (isdigit(*p)) {
2397
                    nd = nd * 10 + *p++ - '0';
2398
                }
2399
                c = *p++;
2400
            } while (isdigit(c));
2401

    
2402
            switch(c) {
2403
            case '%':
2404
                goto addchar;
2405
            case 'd':
2406
                if (percentd_found)
2407
                    goto fail;
2408
                percentd_found = 1;
2409
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2410
                len = strlen(buf1);
2411
                if ((q - buf + len) > buf_size - 1)
2412
                    goto fail;
2413
                memcpy(q, buf1, len);
2414
                q += len;
2415
                break;
2416
            default:
2417
                goto fail;
2418
            }
2419
        } else {
2420
        addchar:
2421
            if ((q - buf) < buf_size - 1)
2422
                *q++ = c;
2423
        }
2424
    }
2425
    if (!percentd_found)
2426
        goto fail;
2427
    *q = '\0';
2428
    return 0;
2429
 fail:
2430
    *q = '\0';
2431
    return -1;
2432
}
2433

    
2434
/**
2435
 * Print  nice hexa dump of a buffer
2436
 * @param f stream for output
2437
 * @param buf buffer
2438
 * @param size buffer size
2439
 */
2440
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2441
{
2442
    int len, i, j, c;
2443

    
2444
    for(i=0;i<size;i+=16) {
2445
        len = size - i;
2446
        if (len > 16)
2447
            len = 16;
2448
        fprintf(f, "%08x ", i);
2449
        for(j=0;j<16;j++) {
2450
            if (j < len)
2451
                fprintf(f, " %02x", buf[i+j]);
2452
            else
2453
                fprintf(f, "   ");
2454
        }
2455
        fprintf(f, " ");
2456
        for(j=0;j<len;j++) {
2457
            c = buf[i+j];
2458
            if (c < ' ' || c > '~')
2459
                c = '.';
2460
            fprintf(f, "%c", c);
2461
        }
2462
        fprintf(f, "\n");
2463
    }
2464
}
2465

    
2466
/**
2467
 * Print on 'f' a nice dump of a packet
2468
 * @param f stream for output
2469
 * @param pkt packet to dump
2470
 * @param dump_payload true if the payload must be displayed too
2471
 */
2472
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2473
{
2474
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2475
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2476
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2477
    /* DTS is _always_ valid after av_read_frame() */
2478
    fprintf(f, "  dts=");
2479
    if (pkt->dts == AV_NOPTS_VALUE)
2480
        fprintf(f, "N/A");
2481
    else
2482
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2483
    /* PTS may be not known if B frames are present */
2484
    fprintf(f, "  pts=");
2485
    if (pkt->pts == AV_NOPTS_VALUE)
2486
        fprintf(f, "N/A");
2487
    else
2488
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2489
    fprintf(f, "\n");
2490
    fprintf(f, "  size=%d\n", pkt->size);
2491
    if (dump_payload)
2492
        av_hex_dump(f, pkt->data, pkt->size);
2493
}
2494

    
2495
void url_split(char *proto, int proto_size,
2496
               char *hostname, int hostname_size,
2497
               int *port_ptr,
2498
               char *path, int path_size,
2499
               const char *url)
2500
{
2501
    const char *p;
2502
    char *q;
2503
    int port;
2504

    
2505
    port = -1;
2506

    
2507
    p = url;
2508
    q = proto;
2509
    while (*p != ':' && *p != '\0') {
2510
        if ((q - proto) < proto_size - 1)
2511
            *q++ = *p;
2512
        p++;
2513
    }
2514
    if (proto_size > 0)
2515
        *q = '\0';
2516
    if (*p == '\0') {
2517
        if (proto_size > 0)
2518
            proto[0] = '\0';
2519
        if (hostname_size > 0)
2520
            hostname[0] = '\0';
2521
        p = url;
2522
    } else {
2523
        p++;
2524
        if (*p == '/')
2525
            p++;
2526
        if (*p == '/')
2527
            p++;
2528
        q = hostname;
2529
        while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2530
            if ((q - hostname) < hostname_size - 1)
2531
                *q++ = *p;
2532
            p++;
2533
        }
2534
        if (hostname_size > 0)
2535
            *q = '\0';
2536
        if (*p == ':') {
2537
            p++;
2538
            port = strtoul(p, (char **)&p, 10);
2539
        }
2540
    }
2541
    if (port_ptr)
2542
        *port_ptr = port;
2543
    pstrcpy(path, path_size, p);
2544
}
2545

    
2546
/**
2547
 * Set the pts for a given stream
2548
 * @param s stream 
2549
 * @param pts_wrap_bits number of bits effectively used by the pts
2550
 *        (used for wrap control, 33 is the value for MPEG) 
2551
 * @param pts_num numerator to convert to seconds (MPEG: 1) 
2552
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2553
 */
2554
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2555
                     int pts_num, int pts_den)
2556
{
2557
    s->pts_wrap_bits = pts_wrap_bits;
2558
    s->time_base.num = pts_num;
2559
    s->time_base.den = pts_den;
2560
}
2561

    
2562
/* fraction handling */
2563

    
2564
/**
2565
 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2566
 * as 0 <= num < den.
2567
 *
2568
 * @param f fractional number
2569
 * @param val integer value
2570
 * @param num must be >= 0
2571
 * @param den must be >= 1 
2572
 */
2573
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2574
{
2575
    num += (den >> 1);
2576
    if (num >= den) {
2577
        val += num / den;
2578
        num = num % den;
2579
    }
2580
    f->val = val;
2581
    f->num = num;
2582
    f->den = den;
2583
}
2584

    
2585
/* set f to (val + 0.5) */
2586
void av_frac_set(AVFrac *f, int64_t val)
2587
{
2588
    f->val = val;
2589
    f->num = f->den >> 1;
2590
}
2591

    
2592
/**
2593
 * Fractionnal addition to f: f = f + (incr / f->den)
2594
 *
2595
 * @param f fractional number
2596
 * @param incr increment, can be positive or negative
2597
 */
2598
void av_frac_add(AVFrac *f, int64_t incr)
2599
{
2600
    int64_t num, den;
2601

    
2602
    num = f->num + incr;
2603
    den = f->den;
2604
    if (num < 0) {
2605
        f->val += num / den;
2606
        num = num % den;
2607
        if (num < 0) {
2608
            num += den;
2609
            f->val--;
2610
        }
2611
    } else if (num >= den) {
2612
        f->val += num / den;
2613
        num = num % den;
2614
    }
2615
    f->num = num;
2616
}
2617

    
2618
/**
2619
 * register a new image format
2620
 * @param img_fmt Image format descriptor
2621
 */
2622
void av_register_image_format(AVImageFormat *img_fmt)
2623
{
2624
    AVImageFormat **p;
2625

    
2626
    p = &first_image_format;
2627
    while (*p != NULL) p = &(*p)->next;
2628
    *p = img_fmt;
2629
    img_fmt->next = NULL;
2630
}
2631

    
2632
/* guess image format */
2633
AVImageFormat *av_probe_image_format(AVProbeData *pd)
2634
{
2635
    AVImageFormat *fmt1, *fmt;
2636
    int score, score_max;
2637

    
2638
    fmt = NULL;
2639
    score_max = 0;
2640
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2641
        if (fmt1->img_probe) {
2642
            score = fmt1->img_probe(pd);
2643
            if (score > score_max) {
2644
                score_max = score;
2645
                fmt = fmt1;
2646
            }
2647
        }
2648
    }
2649
    return fmt;
2650
}
2651

    
2652
AVImageFormat *guess_image_format(const char *filename)
2653
{
2654
    AVImageFormat *fmt1;
2655

    
2656
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2657
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2658
            return fmt1;
2659
    }
2660
    return NULL;
2661
}
2662

    
2663
/**
2664
 * Read an image from a stream. 
2665
 * @param gb byte stream containing the image
2666
 * @param fmt image format, NULL if probing is required
2667
 */
2668
int av_read_image(ByteIOContext *pb, const char *filename,
2669
                  AVImageFormat *fmt,
2670
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2671
{
2672
    char buf[PROBE_BUF_SIZE];
2673
    AVProbeData probe_data, *pd = &probe_data;
2674
    offset_t pos;
2675
    int ret;
2676

    
2677
    if (!fmt) {
2678
        pd->filename = filename;
2679
        pd->buf = buf;
2680
        pos = url_ftell(pb);
2681
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2682
        url_fseek(pb, pos, SEEK_SET);
2683
        fmt = av_probe_image_format(pd);
2684
    }
2685
    if (!fmt)
2686
        return AVERROR_NOFMT;
2687
    ret = fmt->img_read(pb, alloc_cb, opaque);
2688
    return ret;
2689
}
2690

    
2691
/**
2692
 * Write an image to a stream.
2693
 * @param pb byte stream for the image output
2694
 * @param fmt image format
2695
 * @param img image data and informations
2696
 */
2697
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2698
{
2699
    return fmt->img_write(pb, img);
2700
}
2701