Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 5a757507

History | View | Annotate | Download (64.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
    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
AVOutputFormat *guess_format(const char *short_name, const char *filename, 
71
                             const char *mime_type)
72
{
73
    AVOutputFormat *fmt, *fmt_found;
74
    int score_max, score;
75

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

    
83
    /* find the proper file type */
84
    fmt_found = NULL;
85
    score_max = 0;
86
    fmt = first_oformat;
87
    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
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
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
/* memory handling */
136

    
137
/**
138
 * 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
 * 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
int av_new_packet(AVPacket *pkt, int size)
154
{
155
    void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
156
    if (!data)
157
        return AVERROR_NOMEM;
158
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
159

    
160
    av_init_packet(pkt);
161
    pkt->data = data; 
162
    pkt->size = size;
163
    pkt->destruct = av_destruct_packet;
164
    return 0;
165
}
166

    
167
/* 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
        /* 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
        if (!data) {
177
            return AVERROR_NOMEM;
178
        }
179
        memcpy(data, pkt->data, pkt->size);
180
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
181
        pkt->data = data;
182
        pkt->destruct = av_destruct_packet;
183
    }
184
    return 0;
185
}
186

    
187
/* fifo handling */
188

    
189
int fifo_init(FifoBuffer *f, int size)
190
{
191
    f->buffer = av_malloc(size);
192
    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
    av_free(f->buffer);
202
}
203

    
204
int fifo_size(FifoBuffer *f, uint8_t *rptr)
205
{
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
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
218
{
219
    uint8_t *rptr = *rptr_ptr;
220
    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
void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
246
{
247
    int len;
248
    uint8_t *wptr;
249
    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
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
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
272
{
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
        if (fmt1->read_probe) {
283
            score = fmt1->read_probe(pd);
284
        } else if (fmt1->extensions) {
285
            if (match_ext(pd->filename, fmt1->extensions)) {
286
                score = 50;
287
            }
288
        } 
289
        if (score > score_max) {
290
            score_max = score;
291
            fmt = fmt1;
292
        }
293
    }
294
    return fmt;
295
}
296

    
297
/************************************************************/
298
/* input media file */
299

    
300
/**
301
 * open a media file from an IO stream. 'fmt' must be specified.
302
 */
303

    
304
static const char* format_to_name(void* ptr)
305
{
306
    AVFormatContext* fc = (AVFormatContext*) ptr;
307
    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
    ic->av_class = &av_format_context_class;
320
    return ic;
321
}
322

    
323
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
    ic = av_alloc_format_context();
331
    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
    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
    err = ic->iformat->read_header(ic, ap);
361
    if (err < 0)
362
        goto fail;
363

    
364
    if (pb)
365
        ic->data_offset = url_ftell(&ic->pb);
366

    
367
    *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
#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
{
396
    int err, must_open_file, file_opened;
397
    uint8_t buf[PROBE_BUF_SIZE];
398
    AVProbeData probe_data, *pd = &probe_data;
399
    ByteIOContext pb1, *pb = &pb1;
400
    
401
    file_opened = 0;
402
    pd->filename = "";
403
    if (filename)
404
        pd->filename = filename;
405
    pd->buf = buf;
406
    pd->buf_size = 0;
407

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

    
413
    /* 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
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
417
        must_open_file = 0;
418
    }
419

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

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

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

    
476
/*******************************************************/
477

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

    
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
                                      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
                /* increment read pointer */
710
                s->cur_ptr += len;
711
                s->cur_len -= len;
712
                
713
                /* return packet if any */
714
                if (pkt->size) {
715
                got_packet:
716
                    pkt->duration = 0;
717
                    pkt->stream_index = st->index;
718
                    pkt->pts = st->parser->pts;
719
                    pkt->dts = st->parser->dts;
720
                    pkt->destruct = av_destruct_packet_nofree;
721
                    compute_pkt_fields(s, st, st->parser, pkt);
722
                    return 0;
723
                }
724
            } else {
725
                /* free packet */
726
                av_free_packet(&s->cur_pkt); 
727
                s->cur_st = NULL;
728
            }
729
        } else {
730
            /* read next packet */
731
            ret = av_read_packet(s, &s->cur_pkt);
732
            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
                                        NULL, 0, 
742
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
743
                        if (pkt->size)
744
                            goto got_packet;
745
                    }
746
                }
747
                /* no more packets: really terminates parsing */
748
                return ret;
749
            }
750

    
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
            if (s->cur_pkt.stream_index == 0) {
762
                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
    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
        av_free(pktl);
819
        return 0;
820
    } else {
821
        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
    }
838
}
839

    
840
/*******************************************************/
841
/* seek support */
842

    
843
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
/* 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
/* add a index entry into a sorted list updateing if it is already there */
890
int av_add_index_entry(AVStream *st,
891
                            int64_t pos, int64_t timestamp, int distance, int flags)
892
{
893
    AVIndexEntry *entries, *ie;
894
    int index;
895
    
896
    entries = av_fast_realloc(st->index_entries,
897
                              &st->index_entries_allocated_size,
898
                              (st->nb_index_entries + 1) * 
899
                              sizeof(AVIndexEntry));
900
    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
    }else{
920
        index= st->nb_index_entries++;
921
        ie= &entries[index];
922
    }
923
    
924
    ie->pos = pos;
925
    ie->timestamp = timestamp;
926
    ie->min_distance= distance;
927
    ie->flags = flags;
928
    
929
    return index;
930
}
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
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts, 
950
                            0, AVINDEX_KEYFRAME);
951
        }
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
int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
973
{
974
    AVIndexEntry *entries= st->index_entries;
975
    int nb_entries= st->nb_index_entries;
976
    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

    
985
    while (a < b) {
986
        m = (a + b + 1) >> 1;
987
        timestamp = entries[m].timestamp;
988
        if (timestamp > wanted_timestamp) {
989
            b = m - 1;
990
        } else {
991
            a = m;
992
        }
993
    }
994
    return a;
995
}
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
    index = av_index_search_timestamp(st, timestamp);
1017
    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

    
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
    /* 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
    /* 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
        }
1199
        av_free_packet(pkt);
1200
    }
1201

    
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
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
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
/**
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
    int i, count, ret, read_size;
1402
    AVStream *st;
1403
    AVPacket pkt1, *pkt;
1404
    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
            if (!has_codec_parameters(&st->codec))
1414
                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
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1421
                /* 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
            if (read_size >= MAX_READ_SIZE) {
1428
                ret = count;
1429
                break;
1430
            }
1431
        }
1432

    
1433
        /* 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
        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
        *pkt = pkt1;
1457
        
1458
        /* duplicate the packet */
1459
        if (av_dup_packet(pkt) < 0) {
1460
                ret = AVERROR_NOMEM;
1461
                break;
1462
        }
1463

    
1464
        read_size += pkt->size;
1465

    
1466
        st = ic->streams[pkt->stream_index];
1467
        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
             st->codec.codec_id == CODEC_ID_VORBIS ||
1480
             (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
        }
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
            /* 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
            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
        }
1523
    }
1524

    
1525
    av_estimate_timings(ic);
1526
    return ret;
1527
}
1528

    
1529
/*******************************************************/
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
/**
1554
 * Close a media file (but not its codecs)
1555
 *
1556
 * @param s media file handle
1557
 */
1558
void av_close_input_file(AVFormatContext *s)
1559
{
1560
    int i, must_open_file;
1561
    AVStream *st;
1562

    
1563
    /* free previous packet */
1564
    if (s->cur_st && s->cur_st->parser)
1565
        av_free_packet(&s->cur_pkt); 
1566

    
1567
    if (s->iformat->read_close)
1568
        s->iformat->read_close(s);
1569
    for(i=0;i<s->nb_streams;i++) {
1570
        /* free all data in a stream component */
1571
        st = s->streams[i];
1572
        if (st->parser) {
1573
            av_parser_close(st->parser);
1574
        }
1575
        av_free(st->index_entries);
1576
        av_free(st);
1577
    }
1578
    flush_packet_queue(s);
1579
    must_open_file = 1;
1580
    if (s->iformat->flags & AVFMT_NOFILE) {
1581
        must_open_file = 0;
1582
    }
1583
    if (must_open_file) {
1584
        url_fclose(&s->pb);
1585
    }
1586
    av_freep(&s->priv_data);
1587
    av_free(s);
1588
}
1589

    
1590
/**
1591
 * Add a new stream to a media file. Can only be called in the
1592
 * 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
 *
1595
 *
1596
 * @param s media file handle
1597
 * @param id file format dependent stream id 
1598
 */
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
    avcodec_get_context_defaults(&st->codec);
1610
    if (s->iformat) {
1611
        /* no default bitrate if decoding */
1612
        st->codec.bit_rate = 0;
1613
    }
1614
    st->index = s->nb_streams;
1615
    st->id = id;
1616
    st->start_time = AV_NOPTS_VALUE;
1617
    st->duration = AV_NOPTS_VALUE;
1618
    s->streams[s->nb_streams++] = st;
1619
    return st;
1620
}
1621

    
1622
/************************************************************/
1623
/* output media file */
1624

    
1625
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1626
{
1627
    int ret;
1628
    
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
    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
/**
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
    int ret, i;
1654
    AVStream *st;
1655

    
1656
    /* default pts settings is MPEG like */
1657
    av_set_pts_info(s, 33, 1, 90000);
1658
    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
                         (int64_t)s->pts_num * st->codec.sample_rate);
1670
            break;
1671
        case CODEC_TYPE_VIDEO:
1672
            av_frac_init(&st->pts, 0, 0, 
1673
                         (int64_t)s->pts_num * st->codec.frame_rate);
1674
            break;
1675
        default:
1676
            break;
1677
        }
1678
    }
1679
    return 0;
1680
}
1681

    
1682
/**
1683
 * Write a packet to an output media file. The packet shall contain
1684
 * one audio or video frame.
1685
 *
1686
 * @param s media file handle
1687
 * @param stream_index stream index
1688
 * @param buf buffer containing the frame data
1689
 * @param size size of buffer
1690
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1691
 */
1692
int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf, 
1693
                   int size)
1694
{
1695
    AVStream *st;
1696
    int64_t pts_mask;
1697
    int ret, frame_size;
1698

    
1699
    st = s->streams[stream_index];
1700
    pts_mask = (1LL << s->pts_wrap_bits) - 1;
1701

    
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
    if (ret < 0)
1710
        return ret;
1711

    
1712
    /* update pts */
1713
    switch (st->codec.codec_type) {
1714
    case CODEC_TYPE_AUDIO:
1715
        frame_size = get_audio_frame_size(&st->codec, size);
1716

    
1717
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
1718
           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
            av_frac_add(&st->pts, 
1721
                        (int64_t)s->pts_den * frame_size);
1722
        }
1723
        break;
1724
    case CODEC_TYPE_VIDEO:
1725
        av_frac_add(&st->pts, 
1726
                    (int64_t)s->pts_den * st->codec.frame_rate_base);
1727
        break;
1728
    default:
1729
        break;
1730
    }
1731
    return ret;
1732
}
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
}
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
    int i, flags;
1756
    char buf[256];
1757

    
1758
    av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
1759
            is_output ? "Output" : "Input",
1760
            index, 
1761
            is_output ? ic->oformat->name : ic->iformat->name, 
1762
            is_output ? "to" : "from", url);
1763
    if (!is_output) {
1764
        av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
1765
        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
            av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
1774
                   (10 * us) / AV_TIME_BASE);
1775
        } else {
1776
            av_log(NULL, AV_LOG_DEBUG, "N/A");
1777
        }
1778
        av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
1779
        if (ic->bit_rate) {
1780
            av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
1781
        } else {
1782
            av_log(NULL, AV_LOG_DEBUG, "N/A");
1783
        }
1784
        av_log(NULL, AV_LOG_DEBUG, "\n");
1785
    }
1786
    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
        av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
1790
        /* 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
            av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
1798
        }
1799
        av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
1800
    }
1801
}
1802

    
1803
typedef struct {
1804
    const char *abv;
1805
    int width, height;
1806
    int frame_rate, frame_rate_base;
1807
} AbvEntry;
1808

    
1809
static AbvEntry frame_abvs[] = {
1810
    { "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
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
1815
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
1816
    { "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
};
1823

    
1824
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1825
{
1826
    int i;
1827
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1828
    const char *p;
1829
    int frame_width = 0, frame_height = 0;
1830

    
1831
    for(i=0;i<n;i++) {
1832
        if (!strcmp(frame_abvs[i].abv, str)) {
1833
            frame_width = frame_abvs[i].width;
1834
            frame_height = frame_abvs[i].height;
1835
            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
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
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
1878
        *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
/* Syntax:
1887
 * - If not a duration:
1888
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1889
 * Time is localtime unless Z is suffixed to the end. In this case GMT
1890
 * Return the date in micro seconds since 1970 
1891
 * - If duration:
1892
 *  HH[:MM[:SS[.m...]]]
1893
 *  S+[.m...]
1894
 */
1895
int64_t parse_date(const char *datestr, int duration)
1896
{
1897
    const char *p;
1898
    int64_t t;
1899
    struct tm dt;
1900
    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
    int is_utc, len;
1911
    char lastch;
1912

    
1913
#undef time
1914
    time_t now = time(0);
1915

    
1916
    len = strlen(datestr);
1917
    if (len > 0)
1918
        lastch = datestr[len - 1];
1919
    else
1920
        lastch = '\0';
1921
    is_utc = (lastch == 'z' || lastch == 'Z');
1922

    
1923
    memset(&dt, 0, sizeof(dt));
1924

    
1925
    p = datestr;
1926
    q = NULL;
1927
    if (!duration) {
1928
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1929
            q = small_strptime(p, date_fmt[i], &dt);
1930
            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
        } else {
1943
            p = q;
1944
        }
1945

    
1946
        if (*p == 'T' || *p == 't' || *p == ' ')
1947
            p++;
1948

    
1949
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1950
            q = small_strptime(p, time_fmt[i], &dt);
1951
            if (q) {
1952
                break;
1953
            }
1954
        }
1955
    } else {
1956
        q = small_strptime(p, time_fmt[0], &dt);
1957
        if (!q) {
1958
            dt.tm_sec = strtol(p, (char **)&q, 10);
1959
            dt.tm_min = 0;
1960
            dt.tm_hour = 0;
1961
        }
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
            return now * int64_t_C(1000000);
1970
    }
1971

    
1972
    if (duration) {
1973
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1974
    } else {
1975
        dt.tm_isdst = -1;       /* unknown */
1976
        if (is_utc) {
1977
            t = mktimegm(&dt);
1978
        } else {
1979
            t = mktime(&dt);
1980
        }
1981
    }
1982

    
1983
    t *= 1000000;
1984

    
1985
    if (*q == '.') {
1986
        int val, n;
1987
        q++;
1988
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1989
            if (!isdigit(*q)) 
1990
                break;
1991
            val += n * (*q - '0');
1992
        }
1993
        t += val;
1994
    }
1995
    return t;
1996
}
1997

    
1998
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1999
   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
                if ((q - arg) < arg_size - 1) {
2021
                    if (*p == '+')
2022
                        *q++ = ' ';
2023
                    else
2024
                        *q++ = *p;
2025
                }
2026
                p++;
2027
            }
2028
            *q = '\0';
2029
        }
2030
        if (!strcmp(tag, tag1)) 
2031
            return 1;
2032
        if (*p != '&')
2033
            break;
2034
        p++;
2035
    }
2036
    return 0;
2037
}
2038

    
2039
/* 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
    char *q, buf1[20], c;
2047
    int nd, len, percentd_found;
2048

    
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
            do {
2058
                nd = 0;
2059
                while (isdigit(*p)) {
2060
                    nd = nd * 10 + *p++ - '0';
2061
                }
2062
                c = *p++;
2063
            } while (isdigit(c));
2064

    
2065
            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
/**
2098
 * Print  nice hexa dump of a buffer
2099
 * @param f stream for output
2100
 * @param buf buffer
2101
 * @param size buffer size
2102
 */
2103
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2104
{
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
        fprintf(f, "%08x ", i);
2112
        for(j=0;j<16;j++) {
2113
            if (j < len)
2114
                fprintf(f, " %02x", buf[i+j]);
2115
            else
2116
                fprintf(f, "   ");
2117
        }
2118
        fprintf(f, " ");
2119
        for(j=0;j<len;j++) {
2120
            c = buf[i+j];
2121
            if (c < ' ' || c > '~')
2122
                c = '.';
2123
            fprintf(f, "%c", c);
2124
        }
2125
        fprintf(f, "\n");
2126
    }
2127
}
2128

    
2129
/**
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
    /* 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
    /* 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
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
/**
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
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2237
{
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
void av_frac_set(AVFrac *f, int64_t val)
2250
{
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
void av_frac_add(AVFrac *f, int64_t incr)
2262
{
2263
    int64_t num, den;
2264

    
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

    
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
        pd->filename = filename;
2342
        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
}
2364