Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 20b02bc6

History | View | Annotate | Download (83.4 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 = NULL;
25
AVOutputFormat *first_oformat = NULL;
26
AVImageFormat *first_image_format = NULL;
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
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
83
        return guess_format("image2", NULL, NULL);
84
    }
85
    if (!short_name && filename && 
86
        filename_number_test(filename) >= 0 &&
87
        guess_image_format(filename)) {
88
        return guess_format("image", NULL, NULL);
89
    }
90

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

    
114
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename, 
115
                             const char *mime_type)
116
{
117
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
118

    
119
    if (fmt) {
120
        AVOutputFormat *stream_fmt;
121
        char stream_format_name[64];
122

    
123
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
124
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
125

    
126
        if (stream_fmt)
127
            fmt = stream_fmt;
128
    }
129

    
130
    return fmt;
131
}
132

    
133
/**
134
 * guesses the codec id based upon muxer and filename.
135
 */
136
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, 
137
                            const char *filename, const char *mime_type, enum CodecType type){
138
    if(type == CODEC_TYPE_VIDEO){
139
        enum CodecID codec_id= CODEC_ID_NONE;
140

    
141
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
142
            codec_id= av_guess_image2_codec(filename);
143
        }
144
        if(codec_id == CODEC_ID_NONE)
145
            codec_id= fmt->video_codec;
146
        return codec_id;
147
    }else if(type == CODEC_TYPE_AUDIO)
148
        return fmt->audio_codec;
149
    else
150
        return CODEC_ID_NONE;
151
}
152

    
153
AVInputFormat *av_find_input_format(const char *short_name)
154
{
155
    AVInputFormat *fmt;
156
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
157
        if (!strcmp(fmt->name, short_name))
158
            return fmt;
159
    }
160
    return NULL;
161
}
162

    
163
/* memory handling */
164

    
165
/**
166
 * Default packet destructor 
167
 */
168
static void av_destruct_packet(AVPacket *pkt)
169
{
170
    av_free(pkt->data);
171
    pkt->data = NULL; pkt->size = 0;
172
}
173

    
174
/**
175
 * Allocate the payload of a packet and intialized its fields to default values.
176
 *
177
 * @param pkt packet
178
 * @param size wanted payload size
179
 * @return 0 if OK. AVERROR_xxx otherwise.
180
 */
181
int av_new_packet(AVPacket *pkt, int size)
182
{
183
    void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
184
    if (!data)
185
        return AVERROR_NOMEM;
186
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
187

    
188
    av_init_packet(pkt);
189
    pkt->data = data; 
190
    pkt->size = size;
191
    pkt->destruct = av_destruct_packet;
192
    return 0;
193
}
194

    
195
/* This is a hack - the packet memory allocation stuff is broken. The
196
   packet is allocated if it was not really allocated */
197
int av_dup_packet(AVPacket *pkt)
198
{
199
    if (pkt->destruct != av_destruct_packet) {
200
        uint8_t *data;
201
        /* we duplicate the packet and don't forget to put the padding
202
           again */
203
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
204
        if (!data) {
205
            return AVERROR_NOMEM;
206
        }
207
        memcpy(data, pkt->data, pkt->size);
208
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
209
        pkt->data = data;
210
        pkt->destruct = av_destruct_packet;
211
    }
212
    return 0;
213
}
214

    
215
/* fifo handling */
216

    
217
int fifo_init(FifoBuffer *f, int size)
218
{
219
    f->buffer = av_malloc(size);
220
    if (!f->buffer)
221
        return -1;
222
    f->end = f->buffer + size;
223
    f->wptr = f->rptr = f->buffer;
224
    return 0;
225
}
226

    
227
void fifo_free(FifoBuffer *f)
228
{
229
    av_free(f->buffer);
230
}
231

    
232
int fifo_size(FifoBuffer *f, uint8_t *rptr)
233
{
234
    int size;
235
    
236
    if(!rptr)
237
        rptr= f->rptr;
238

    
239
    if (f->wptr >= rptr) {
240
        size = f->wptr - rptr;
241
    } else {
242
        size = (f->end - rptr) + (f->wptr - f->buffer);
243
    }
244
    return size;
245
}
246

    
247
/* get data from the fifo (return -1 if not enough data) */
248
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
249
{
250
    uint8_t *rptr;
251
    int size, len;
252

    
253
    if(!rptr_ptr)
254
        rptr_ptr= &f->rptr;
255
    rptr = *rptr_ptr;
256

    
257
    if (f->wptr >= rptr) {
258
        size = f->wptr - rptr;
259
    } else {
260
        size = (f->end - rptr) + (f->wptr - f->buffer);
261
    }
262
    
263
    if (size < buf_size)
264
        return -1;
265
    while (buf_size > 0) {
266
        len = f->end - rptr;
267
        if (len > buf_size)
268
            len = buf_size;
269
        memcpy(buf, rptr, len);
270
        buf += len;
271
        rptr += len;
272
        if (rptr >= f->end)
273
            rptr = f->buffer;
274
        buf_size -= len;
275
    }
276
    *rptr_ptr = rptr;
277
    return 0;
278
}
279

    
280
void fifo_realloc(FifoBuffer *f, int new_size){
281
    int old_size= f->end - f->buffer;
282
    
283
    if(old_size < new_size){
284
        uint8_t *old= f->buffer;
285

    
286
        f->buffer= av_realloc(f->buffer, new_size);
287

    
288
        f->rptr += f->buffer - old;
289
        f->wptr += f->buffer - old;
290

    
291
        if(f->wptr < f->rptr){
292
            memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
293
            f->rptr += new_size - old_size;
294
        }
295
        f->end= f->buffer + new_size;
296
    }
297
}
298

    
299
void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
300
{
301
    int len;
302
    uint8_t *wptr;
303

    
304
    if(!wptr_ptr)
305
        wptr_ptr= &f->wptr;
306
    wptr = *wptr_ptr;
307

    
308
    while (size > 0) {
309
        len = f->end - wptr;
310
        if (len > size)
311
            len = size;
312
        memcpy(wptr, buf, len);
313
        wptr += len;
314
        if (wptr >= f->end)
315
            wptr = f->buffer;
316
        buf += len;
317
        size -= len;
318
    }
319
    *wptr_ptr = wptr;
320
}
321

    
322
/* get data from the fifo (return -1 if not enough data) */
323
int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
324
{
325
    uint8_t *rptr = *rptr_ptr;
326
    int size, len;
327

    
328
    if (f->wptr >= rptr) {
329
        size = f->wptr - rptr;
330
    } else {
331
        size = (f->end - rptr) + (f->wptr - f->buffer);
332
    }
333
    
334
    if (size < buf_size)
335
        return -1;
336
    while (buf_size > 0) {
337
        len = f->end - rptr;
338
        if (len > buf_size)
339
            len = buf_size;
340
        put_buffer(pb, rptr, len);
341
        rptr += len;
342
        if (rptr >= f->end)
343
            rptr = f->buffer;
344
        buf_size -= len;
345
    }
346
    *rptr_ptr = rptr;
347
    return 0;
348
}
349

    
350
int filename_number_test(const char *filename)
351
{
352
    char buf[1024];
353
    if(!filename)
354
        return -1;
355
    return get_frame_filename(buf, sizeof(buf), filename, 1);
356
}
357

    
358
/* guess file format */
359
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
360
{
361
    AVInputFormat *fmt1, *fmt;
362
    int score, score_max;
363

    
364
    fmt = NULL;
365
    score_max = 0;
366
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
367
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
368
            continue;
369
        score = 0;
370
        if (fmt1->read_probe) {
371
            score = fmt1->read_probe(pd);
372
        } else if (fmt1->extensions) {
373
            if (match_ext(pd->filename, fmt1->extensions)) {
374
                score = 50;
375
            }
376
        } 
377
        if (score > score_max) {
378
            score_max = score;
379
            fmt = fmt1;
380
        }
381
    }
382
    return fmt;
383
}
384

    
385
/************************************************************/
386
/* input media file */
387

    
388
/**
389
 * open a media file from an IO stream. 'fmt' must be specified.
390
 */
391

    
392
static const char* format_to_name(void* ptr)
393
{
394
    AVFormatContext* fc = (AVFormatContext*) ptr;
395
    if(fc->iformat) return fc->iformat->name;
396
    else if(fc->oformat) return fc->oformat->name;
397
    else return "NULL";
398
}
399

    
400
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
401

    
402
AVFormatContext *av_alloc_format_context(void)
403
{
404
    AVFormatContext *ic;
405
    ic = av_mallocz(sizeof(AVFormatContext));
406
    if (!ic) return ic;
407
    ic->av_class = &av_format_context_class;
408
    return ic;
409
}
410

    
411
int av_open_input_stream(AVFormatContext **ic_ptr, 
412
                         ByteIOContext *pb, const char *filename, 
413
                         AVInputFormat *fmt, AVFormatParameters *ap)
414
{
415
    int err;
416
    AVFormatContext *ic;
417

    
418
    ic = av_alloc_format_context();
419
    if (!ic) {
420
        err = AVERROR_NOMEM;
421
        goto fail;
422
    }
423
    ic->iformat = fmt;
424
    if (pb)
425
        ic->pb = *pb;
426
    ic->duration = AV_NOPTS_VALUE;
427
    ic->start_time = AV_NOPTS_VALUE;
428
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
429

    
430
    /* allocate private data */
431
    if (fmt->priv_data_size > 0) {
432
        ic->priv_data = av_mallocz(fmt->priv_data_size);
433
        if (!ic->priv_data) {
434
            err = AVERROR_NOMEM;
435
            goto fail;
436
        }
437
    } else {
438
        ic->priv_data = NULL;
439
    }
440

    
441
    err = ic->iformat->read_header(ic, ap);
442
    if (err < 0)
443
        goto fail;
444

    
445
    if (pb)
446
        ic->data_offset = url_ftell(&ic->pb);
447

    
448
    *ic_ptr = ic;
449
    return 0;
450
 fail:
451
    if (ic) {
452
        av_freep(&ic->priv_data);
453
    }
454
    av_free(ic);
455
    *ic_ptr = NULL;
456
    return err;
457
}
458

    
459
#define PROBE_BUF_SIZE 2048
460

    
461
/**
462
 * Open a media file as input. The codec are not opened. Only the file
463
 * header (if present) is read.
464
 *
465
 * @param ic_ptr the opened media file handle is put here
466
 * @param filename filename to open.
467
 * @param fmt if non NULL, force the file format to use
468
 * @param buf_size optional buffer size (zero if default is OK)
469
 * @param ap additionnal parameters needed when opening the file (NULL if default)
470
 * @return 0 if OK. AVERROR_xxx otherwise.
471
 */
472
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, 
473
                       AVInputFormat *fmt,
474
                       int buf_size,
475
                       AVFormatParameters *ap)
476
{
477
    int err, must_open_file, file_opened;
478
    uint8_t buf[PROBE_BUF_SIZE];
479
    AVProbeData probe_data, *pd = &probe_data;
480
    ByteIOContext pb1, *pb = &pb1;
481
    
482
    file_opened = 0;
483
    pd->filename = "";
484
    if (filename)
485
        pd->filename = filename;
486
    pd->buf = buf;
487
    pd->buf_size = 0;
488

    
489
    if (!fmt) {
490
        /* guess format if no file can be opened  */
491
        fmt = av_probe_input_format(pd, 0);
492
    }
493

    
494
    /* do not open file if the format does not need it. XXX: specific
495
       hack needed to handle RTSP/TCP */
496
    must_open_file = 1;
497
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
498
        must_open_file = 0;
499
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
500
    }
501

    
502
    if (!fmt || must_open_file) {
503
        /* if no file needed do not try to open one */
504
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
505
            err = AVERROR_IO;
506
            goto fail;
507
        }
508
        file_opened = 1;
509
        if (buf_size > 0) {
510
            url_setbufsize(pb, buf_size);
511
        }
512
        if (!fmt) {
513
            /* read probe data */
514
            pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
515
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
516
                url_fclose(pb);
517
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
518
                    err = AVERROR_IO;
519
                    goto fail;
520
                }
521
            }
522
        }
523
    }
524
    
525
    /* guess file format */
526
    if (!fmt) {
527
        fmt = av_probe_input_format(pd, 1);
528
    }
529

    
530
    /* if still no format found, error */
531
    if (!fmt) {
532
        err = AVERROR_NOFMT;
533
        goto fail;
534
    }
535
        
536
    /* XXX: suppress this hack for redirectors */
537
#ifdef CONFIG_NETWORK
538
    if (fmt == &redir_demux) {
539
        err = redir_open(ic_ptr, pb);
540
        url_fclose(pb);
541
        return err;
542
    }
543
#endif
544

    
545
    /* check filename in case of an image number is expected */
546
    if (fmt->flags & AVFMT_NEEDNUMBER) {
547
        if (filename_number_test(filename) < 0) { 
548
            err = AVERROR_NUMEXPECTED;
549
            goto fail;
550
        }
551
    }
552
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
553
    if (err)
554
        goto fail;
555
    return 0;
556
 fail:
557
    if (file_opened)
558
        url_fclose(pb);
559
    *ic_ptr = NULL;
560
    return err;
561
    
562
}
563

    
564
/*******************************************************/
565

    
566
/**
567
 * Read a transport packet from a media file. This function is
568
 * absolete and should never be used. Use av_read_frame() instead.
569
 * 
570
 * @param s media file handle
571
 * @param pkt is filled 
572
 * @return 0 if OK. AVERROR_xxx if error.  
573
 */
574
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
575
{
576
    return s->iformat->read_packet(s, pkt);
577
}
578

    
579
/**********************************************************/
580

    
581
/* get the number of samples of an audio frame. Return (-1) if error */
582
static int get_audio_frame_size(AVCodecContext *enc, int size)
583
{
584
    int frame_size;
585

    
586
    if (enc->frame_size <= 1) {
587
        /* specific hack for pcm codecs because no frame size is
588
           provided */
589
        switch(enc->codec_id) {
590
        case CODEC_ID_PCM_S16LE:
591
        case CODEC_ID_PCM_S16BE:
592
        case CODEC_ID_PCM_U16LE:
593
        case CODEC_ID_PCM_U16BE:
594
            if (enc->channels == 0)
595
                return -1;
596
            frame_size = size / (2 * enc->channels);
597
            break;
598
        case CODEC_ID_PCM_S8:
599
        case CODEC_ID_PCM_U8:
600
        case CODEC_ID_PCM_MULAW:
601
        case CODEC_ID_PCM_ALAW:
602
            if (enc->channels == 0)
603
                return -1;
604
            frame_size = size / (enc->channels);
605
            break;
606
        default:
607
            /* used for example by ADPCM codecs */
608
            if (enc->bit_rate == 0)
609
                return -1;
610
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
611
            break;
612
        }
613
    } else {
614
        frame_size = enc->frame_size;
615
    }
616
    return frame_size;
617
}
618

    
619

    
620
/* return the frame duration in seconds, return 0 if not available */
621
static void compute_frame_duration(int *pnum, int *pden, AVStream *st, 
622
                                   AVCodecParserContext *pc, AVPacket *pkt)
623
{
624
    int frame_size;
625

    
626
    *pnum = 0;
627
    *pden = 0;
628
    switch(st->codec.codec_type) {
629
    case CODEC_TYPE_VIDEO:
630
        *pnum = st->codec.frame_rate_base;
631
        *pden = st->codec.frame_rate;
632
        if (pc && pc->repeat_pict) {
633
            *pden *= 2;
634
            *pnum = (*pnum) * (2 + pc->repeat_pict);
635
        }
636
        break;
637
    case CODEC_TYPE_AUDIO:
638
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
639
        if (frame_size < 0)
640
            break;
641
        *pnum = frame_size;
642
        *pden = st->codec.sample_rate;
643
        break;
644
    default:
645
        break;
646
    }
647
}
648

    
649
static int is_intra_only(AVCodecContext *enc){
650
    if(enc->codec_type == CODEC_TYPE_AUDIO){
651
        return 1;
652
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
653
        switch(enc->codec_id){
654
        case CODEC_ID_MJPEG:
655
        case CODEC_ID_MJPEGB:
656
        case CODEC_ID_LJPEG:
657
        case CODEC_ID_RAWVIDEO:
658
        case CODEC_ID_DVVIDEO:
659
        case CODEC_ID_HUFFYUV:
660
        case CODEC_ID_FFVHUFF:
661
        case CODEC_ID_ASV1:
662
        case CODEC_ID_ASV2:
663
        case CODEC_ID_VCR1:
664
            return 1;
665
        default: break;
666
        }
667
    }
668
    return 0;
669
}
670

    
671
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
672
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
673
    int64_t delta= last_ts - mask/2;
674
    return  ((lsb - delta)&mask) + delta;
675
}
676

    
677
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, 
678
                               AVCodecParserContext *pc, AVPacket *pkt)
679
{
680
    int num, den, presentation_delayed;
681

    
682
    /* handle wrapping */
683
    if(st->cur_dts != AV_NOPTS_VALUE){
684
        if(pkt->pts != AV_NOPTS_VALUE)
685
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
686
        if(pkt->dts != AV_NOPTS_VALUE)
687
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
688
    }
689
    
690
    if (pkt->duration == 0) {
691
        compute_frame_duration(&num, &den, st, pc, pkt);
692
        if (den && num) {
693
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
694
        }
695
    }
696

    
697
    if(is_intra_only(&st->codec))
698
        pkt->flags |= PKT_FLAG_KEY;
699

    
700
    /* do we have a video B frame ? */
701
    presentation_delayed = 0;
702
    if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
703
        /* XXX: need has_b_frame, but cannot get it if the codec is
704
           not initialized */
705
        if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
706
             st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
707
             st->codec.codec_id == CODEC_ID_MPEG4 ||
708
             st->codec.codec_id == CODEC_ID_H264) && 
709
            pc && pc->pict_type != FF_B_TYPE)
710
            presentation_delayed = 1;
711
        /* this may be redundant, but it shouldnt hurt */
712
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
713
            presentation_delayed = 1;
714
    }
715
    
716
    if(st->cur_dts == AV_NOPTS_VALUE){
717
        if(presentation_delayed) st->cur_dts = -pkt->duration;
718
        else                     st->cur_dts = 0;
719
    }
720

    
721
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
722
    /* interpolate PTS and DTS if they are not present */
723
    if (presentation_delayed) {
724
        /* DTS = decompression time stamp */
725
        /* PTS = presentation time stamp */
726
        if (pkt->dts == AV_NOPTS_VALUE) {
727
            /* if we know the last pts, use it */
728
            if(st->last_IP_pts != AV_NOPTS_VALUE)
729
                st->cur_dts = pkt->dts = st->last_IP_pts;
730
            else
731
                pkt->dts = st->cur_dts;
732
        } else {
733
            st->cur_dts = pkt->dts;
734
        }
735
        /* this is tricky: the dts must be incremented by the duration
736
           of the frame we are displaying, i.e. the last I or P frame */
737
        if (st->last_IP_duration == 0)
738
            st->cur_dts += pkt->duration;
739
        else
740
            st->cur_dts += st->last_IP_duration;
741
        st->last_IP_duration  = pkt->duration;
742
        st->last_IP_pts= pkt->pts;
743
        /* cannot compute PTS if not present (we can compute it only
744
           by knowing the futur */
745
    } else {
746
        /* presentation is not delayed : PTS and DTS are the same */
747
        if (pkt->pts == AV_NOPTS_VALUE) {
748
            if (pkt->dts == AV_NOPTS_VALUE) {
749
                pkt->pts = st->cur_dts;
750
                pkt->dts = st->cur_dts;
751
            }
752
            else {
753
                st->cur_dts = pkt->dts;
754
                pkt->pts = pkt->dts;
755
            }
756
        } else {
757
            st->cur_dts = pkt->pts;
758
            pkt->dts = pkt->pts;
759
        }
760
        st->cur_dts += pkt->duration;
761
    }
762
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
763
    
764
    /* update flags */
765
    if (pc) {
766
        pkt->flags = 0;
767
        /* key frame computation */
768
        switch(st->codec.codec_type) {
769
        case CODEC_TYPE_VIDEO:
770
            if (pc->pict_type == FF_I_TYPE)
771
                pkt->flags |= PKT_FLAG_KEY;
772
            break;
773
        case CODEC_TYPE_AUDIO:
774
            pkt->flags |= PKT_FLAG_KEY;
775
            break;
776
        default:
777
            break;
778
        }
779
    }
780

    
781
    /* convert the packet time stamp units */
782
    if(pkt->pts != AV_NOPTS_VALUE)
783
        pkt->pts = av_rescale(pkt->pts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
784
    if(pkt->dts != AV_NOPTS_VALUE)
785
        pkt->dts = av_rescale(pkt->dts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
786

    
787
    /* duration field */
788
    pkt->duration = av_rescale(pkt->duration, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
789
}
790

    
791
void av_destruct_packet_nofree(AVPacket *pkt)
792
{
793
    pkt->data = NULL; pkt->size = 0;
794
}
795

    
796
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
797
{
798
    AVStream *st;
799
    int len, ret, i;
800

    
801
    for(;;) {
802
        /* select current input stream component */
803
        st = s->cur_st;
804
        if (st) {
805
            if (!st->parser) {
806
                /* no parsing needed: we just output the packet as is */
807
                /* raw data support */
808
                *pkt = s->cur_pkt;
809
                compute_pkt_fields(s, st, NULL, pkt);
810
                s->cur_st = NULL;
811
                return 0;
812
            } else if (s->cur_len > 0) {
813
                len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size, 
814
                                      s->cur_ptr, s->cur_len,
815
                                      s->cur_pkt.pts, s->cur_pkt.dts);
816
                s->cur_pkt.pts = AV_NOPTS_VALUE;
817
                s->cur_pkt.dts = AV_NOPTS_VALUE;
818
                /* increment read pointer */
819
                s->cur_ptr += len;
820
                s->cur_len -= len;
821
                
822
                /* return packet if any */
823
                if (pkt->size) {
824
                got_packet:
825
                    pkt->duration = 0;
826
                    pkt->stream_index = st->index;
827
                    pkt->pts = st->parser->pts;
828
                    pkt->dts = st->parser->dts;
829
                    pkt->destruct = av_destruct_packet_nofree;
830
                    compute_pkt_fields(s, st, st->parser, pkt);
831
                    return 0;
832
                }
833
            } else {
834
                /* free packet */
835
                av_free_packet(&s->cur_pkt); 
836
                s->cur_st = NULL;
837
            }
838
        } else {
839
            /* read next packet */
840
            ret = av_read_packet(s, &s->cur_pkt);
841
            if (ret < 0) {
842
                if (ret == -EAGAIN)
843
                    return ret;
844
                /* return the last frames, if any */
845
                for(i = 0; i < s->nb_streams; i++) {
846
                    st = s->streams[i];
847
                    if (st->parser) {
848
                        av_parser_parse(st->parser, &st->codec, 
849
                                        &pkt->data, &pkt->size, 
850
                                        NULL, 0, 
851
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
852
                        if (pkt->size)
853
                            goto got_packet;
854
                    }
855
                }
856
                /* no more packets: really terminates parsing */
857
                return ret;
858
            }
859
            
860
            st = s->streams[s->cur_pkt.stream_index];
861

    
862
            s->cur_st = st;
863
            s->cur_ptr = s->cur_pkt.data;
864
            s->cur_len = s->cur_pkt.size;
865
            if (st->need_parsing && !st->parser) {
866
                st->parser = av_parser_init(st->codec.codec_id);
867
                if (!st->parser) {
868
                    /* no parser available : just output the raw packets */
869
                    st->need_parsing = 0;
870
                }
871
            }
872
        }
873
    }
874
}
875

    
876
/**
877
 * Return the next frame of a stream. The returned packet is valid
878
 * until the next av_read_frame() or until av_close_input_file() and
879
 * must be freed with av_free_packet. For video, the packet contains
880
 * exactly one frame. For audio, it contains an integer number of
881
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
882
 * data). If the audio frames have a variable size (e.g. MPEG audio),
883
 * then it contains one frame.
884
 * 
885
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
886
 * values in AV_TIME_BASE unit (and guessed if the format cannot
887
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
888
 * has B frames, so it is better to rely on pkt->dts if you do not
889
 * decompress the payload.
890
 * 
891
 * Return 0 if OK, < 0 if error or end of file.  
892
 */
893
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
894
{
895
    AVPacketList *pktl;
896

    
897
    pktl = s->packet_buffer;
898
    if (pktl) {
899
        /* read packet from packet buffer, if there is data */
900
        *pkt = pktl->pkt;
901
        s->packet_buffer = pktl->next;
902
        av_free(pktl);
903
        return 0;
904
    } else {
905
        return av_read_frame_internal(s, pkt);
906
    }
907
}
908

    
909
/* XXX: suppress the packet queue */
910
static void flush_packet_queue(AVFormatContext *s)
911
{
912
    AVPacketList *pktl;
913

    
914
    for(;;) {
915
        pktl = s->packet_buffer;
916
        if (!pktl) 
917
            break;
918
        s->packet_buffer = pktl->next;
919
        av_free_packet(&pktl->pkt);
920
        av_free(pktl);
921
    }
922
}
923

    
924
/*******************************************************/
925
/* seek support */
926

    
927
int av_find_default_stream_index(AVFormatContext *s)
928
{
929
    int i;
930
    AVStream *st;
931

    
932
    if (s->nb_streams <= 0)
933
        return -1;
934
    for(i = 0; i < s->nb_streams; i++) {
935
        st = s->streams[i];
936
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
937
            return i;
938
        }
939
    }
940
    return 0;
941
}
942

    
943
/* flush the frame reader */
944
static void av_read_frame_flush(AVFormatContext *s)
945
{
946
    AVStream *st;
947
    int i;
948

    
949
    flush_packet_queue(s);
950

    
951
    /* free previous packet */
952
    if (s->cur_st) {
953
        if (s->cur_st->parser)
954
            av_free_packet(&s->cur_pkt);
955
        s->cur_st = NULL;
956
    }
957
    /* fail safe */
958
    s->cur_ptr = NULL;
959
    s->cur_len = 0;
960
    
961
    /* for each stream, reset read state */
962
    for(i = 0; i < s->nb_streams; i++) {
963
        st = s->streams[i];
964
        
965
        if (st->parser) {
966
            av_parser_close(st->parser);
967
            st->parser = NULL;
968
        }
969
        st->last_IP_pts = AV_NOPTS_VALUE;
970
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
971
    }
972
}
973

    
974
/**
975
 * updates cur_dts of all streams based on given timestamp and AVStream.
976
 * stream ref_st unchanged, others set cur_dts in their native timebase
977
 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
978
 * @param timestamp new dts expressed in time_base of param ref_st
979
 * @param ref_st reference stream giving time_base of param timestamp
980
 */
981
static void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
982
    int i;
983

    
984
    for(i = 0; i < s->nb_streams; i++) {
985
        AVStream *st = s->streams[i];
986

    
987
        st->cur_dts = av_rescale(timestamp, 
988
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
989
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
990
    }
991
}
992

    
993
/**
994
 * add a index entry into a sorted list updateing if it is already there.
995
 * @param timestamp timestamp in the timebase of the given stream
996
 */
997
int av_add_index_entry(AVStream *st,
998
                            int64_t pos, int64_t timestamp, int distance, int flags)
999
{
1000
    AVIndexEntry *entries, *ie;
1001
    int index;
1002
    
1003
    entries = av_fast_realloc(st->index_entries,
1004
                              &st->index_entries_allocated_size,
1005
                              (st->nb_index_entries + 1) * 
1006
                              sizeof(AVIndexEntry));
1007
    st->index_entries= entries;
1008

    
1009
    index= av_index_search_timestamp(st, timestamp, 0);
1010

    
1011
    if(index<0){
1012
        index= st->nb_index_entries++;
1013
        ie= &entries[index];
1014
        assert(index==0 || ie[-1].timestamp < timestamp);
1015
    }else{
1016
        ie= &entries[index];
1017
        if(ie->timestamp != timestamp){
1018
            if(ie->timestamp <= timestamp)
1019
                return -1;
1020
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1021
            st->nb_index_entries++;
1022
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1023
            distance= ie->min_distance;
1024
    }
1025

    
1026
    ie->pos = pos;
1027
    ie->timestamp = timestamp;
1028
    ie->min_distance= distance;
1029
    ie->flags = flags;
1030
    
1031
    return index;
1032
}
1033

    
1034
/* build an index for raw streams using a parser */
1035
static void av_build_index_raw(AVFormatContext *s)
1036
{
1037
    AVPacket pkt1, *pkt = &pkt1;
1038
    int ret;
1039
    AVStream *st;
1040

    
1041
    st = s->streams[0];
1042
    av_read_frame_flush(s);
1043
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1044

    
1045
    for(;;) {
1046
        ret = av_read_frame(s, pkt);
1047
        if (ret < 0)
1048
            break;
1049
        if (pkt->stream_index == 0 && st->parser &&
1050
            (pkt->flags & PKT_FLAG_KEY)) {
1051
            int64_t dts= av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
1052
            av_add_index_entry(st, st->parser->frame_offset, dts, 
1053
                            0, AVINDEX_KEYFRAME);
1054
        }
1055
        av_free_packet(pkt);
1056
    }
1057
}
1058

    
1059
/* return TRUE if we deal with a raw stream (raw codec data and
1060
   parsing needed) */
1061
static int is_raw_stream(AVFormatContext *s)
1062
{
1063
    AVStream *st;
1064

    
1065
    if (s->nb_streams != 1)
1066
        return 0;
1067
    st = s->streams[0];
1068
    if (!st->need_parsing)
1069
        return 0;
1070
    return 1;
1071
}
1072

    
1073
/**
1074
 * gets the index for a specific timestamp.
1075
 * @param backward if non zero then the returned index will correspond to 
1076
 *                 the timestamp which is <= the requested one, if backward is 0 
1077
 *                 then it will be >=
1078
 * @return < 0 if no such timestamp could be found
1079
 */
1080
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1081
                              int backward)
1082
{
1083
    AVIndexEntry *entries= st->index_entries;
1084
    int nb_entries= st->nb_index_entries;
1085
    int a, b, m;
1086
    int64_t timestamp;
1087

    
1088
    a = - 1;
1089
    b = nb_entries;
1090

    
1091
    while (b - a > 1) {
1092
        m = (a + b) >> 1;
1093
        timestamp = entries[m].timestamp;
1094
        if(timestamp >= wanted_timestamp)
1095
            b = m;
1096
        if(timestamp <= wanted_timestamp)
1097
            a = m;
1098
    }
1099
    m= backward ? a : b;
1100

    
1101
    if(m == nb_entries) 
1102
        return -1;
1103
    return  m;
1104
}
1105

    
1106
#define DEBUG_SEEK
1107

    
1108
/**
1109
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1110
 * this isnt supposed to be called directly by a user application, but by demuxers
1111
 * @param target_ts target timestamp in the time base of the given stream
1112
 * @param stream_index stream number
1113
 */
1114
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1115
    AVInputFormat *avif= s->iformat;
1116
    int64_t pos_min, pos_max, pos, pos_limit;
1117
    int64_t ts_min, ts_max, ts;
1118
    int64_t start_pos;
1119
    int index, no_change;
1120
    AVStream *st;
1121

    
1122
    if (stream_index < 0)
1123
        return -1;
1124
    
1125
#ifdef DEBUG_SEEK
1126
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
1127
#endif
1128

    
1129
    ts_max=
1130
    ts_min= AV_NOPTS_VALUE;
1131
    pos_limit= -1; //gcc falsely says it may be uninitalized
1132

    
1133
    st= s->streams[stream_index];
1134
    if(st->index_entries){
1135
        AVIndexEntry *e;
1136

    
1137
        index= av_index_search_timestamp(st, target_ts, 1);
1138
        index= FFMAX(index, 0);
1139
        e= &st->index_entries[index];
1140

    
1141
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1142
            pos_min= e->pos;
1143
            ts_min= e->timestamp;
1144
#ifdef DEBUG_SEEK
1145
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%llx dts_min=%lld\n", 
1146
               pos_min,ts_min);
1147
#endif
1148
        }else{
1149
            assert(index==0);
1150
        }
1151
        index++;
1152
        if(index < st->nb_index_entries){
1153
            e= &st->index_entries[index];
1154
            assert(e->timestamp >= target_ts);
1155
            pos_max= e->pos;
1156
            ts_max= e->timestamp;
1157
            pos_limit= pos_max - e->min_distance;
1158
#ifdef DEBUG_SEEK
1159
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n", 
1160
               pos_max,pos_limit, ts_max);
1161
#endif
1162
        }
1163
    }
1164

    
1165
    if(ts_min == AV_NOPTS_VALUE){
1166
        pos_min = s->data_offset;
1167
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1168
        if (ts_min == AV_NOPTS_VALUE)
1169
            return -1;
1170
    }
1171

    
1172
    if(ts_max == AV_NOPTS_VALUE){
1173
        int step= 1024;
1174
        pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1175
        do{
1176
            pos_max -= step;
1177
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1178
            step += step;
1179
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1180
        if (ts_max == AV_NOPTS_VALUE)
1181
            return -1;
1182
        
1183
        for(;;){
1184
            int64_t tmp_pos= pos_max + 1;
1185
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1186
            if(tmp_ts == AV_NOPTS_VALUE)
1187
                break;
1188
            ts_max= tmp_ts;
1189
            pos_max= tmp_pos;
1190
        }
1191
        pos_limit= pos_max;
1192
    }
1193

    
1194
    no_change=0;
1195
    while (pos_min < pos_limit) {
1196
#ifdef DEBUG_SEEK
1197
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n", 
1198
               pos_min, pos_max,
1199
               ts_min, ts_max);
1200
#endif
1201
        assert(pos_limit <= pos_max);
1202

    
1203
        if(no_change==0){
1204
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1205
            // interpolate position (better than dichotomy)
1206
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1207
                + pos_min - approximate_keyframe_distance;
1208
        }else if(no_change==1){
1209
            // bisection, if interpolation failed to change min or max pos last time
1210
            pos = (pos_min + pos_limit)>>1;
1211
        }else{
1212
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1213
            pos=pos_min;
1214
        }
1215
        if(pos <= pos_min)
1216
            pos= pos_min + 1;
1217
        else if(pos > pos_limit)
1218
            pos= pos_limit;
1219
        start_pos= pos;
1220

    
1221
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1222
        if(pos == pos_max)
1223
            no_change++;
1224
        else
1225
            no_change=0;
1226
#ifdef DEBUG_SEEK
1227
av_log(s, AV_LOG_DEBUG, "%Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1228
#endif
1229
        assert(ts != AV_NOPTS_VALUE);
1230
        if (target_ts <= ts) {
1231
            pos_limit = start_pos - 1;
1232
            pos_max = pos;
1233
            ts_max = ts;
1234
        }
1235
        if (target_ts >= ts) {
1236
            pos_min = pos;
1237
            ts_min = ts;
1238
        }
1239
    }
1240
    
1241
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1242
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1243
#ifdef DEBUG_SEEK
1244
    pos_min = pos;
1245
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1246
    pos_min++;
1247
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1248
    av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n", 
1249
           pos, ts_min, target_ts, ts_max);
1250
#endif
1251
    /* do the seek */
1252
    url_fseek(&s->pb, pos, SEEK_SET);
1253

    
1254
    av_update_cur_dts(s, st, ts);
1255

    
1256
    return 0;
1257
}
1258

    
1259
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1260
    AVInputFormat *avif= s->iformat;
1261
    int64_t pos_min, pos_max;
1262
#if 0
1263
    AVStream *st;
1264

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

1268
    st= s->streams[stream_index];
1269
#endif
1270

    
1271
    pos_min = s->data_offset;
1272
    pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1273

    
1274
    if     (pos < pos_min) pos= pos_min;
1275
    else if(pos > pos_max) pos= pos_max;
1276

    
1277
    url_fseek(&s->pb, pos, SEEK_SET);
1278

    
1279
#if 0
1280
    av_update_cur_dts(s, st, ts);
1281
#endif
1282
    return 0;
1283
}
1284

    
1285
static int av_seek_frame_generic(AVFormatContext *s, 
1286
                                 int stream_index, int64_t timestamp, int flags)
1287
{
1288
    int index;
1289
    AVStream *st;
1290
    AVIndexEntry *ie;
1291

    
1292
    if (!s->index_built) {
1293
        if (is_raw_stream(s)) {
1294
            av_build_index_raw(s);
1295
        } else {
1296
            return -1;
1297
        }
1298
        s->index_built = 1;
1299
    }
1300

    
1301
    st = s->streams[stream_index];
1302
    index = av_index_search_timestamp(st, timestamp, flags & AVSEEK_FLAG_BACKWARD);
1303
    if (index < 0)
1304
        return -1;
1305

    
1306
    /* now we have found the index, we can seek */
1307
    ie = &st->index_entries[index];
1308
    av_read_frame_flush(s);
1309
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1310

    
1311
    av_update_cur_dts(s, st, ie->timestamp);
1312

    
1313
    return 0;
1314
}
1315

    
1316
/**
1317
 * Seek to the key frame at timestamp.
1318
 * 'timestamp' in 'stream_index'.
1319
 * @param stream_index If stream_index is (-1), a default
1320
 * stream is selected, and timestamp is automatically converted 
1321
 * from AV_TIME_BASE units to the stream specific time_base.
1322
 * @param timestamp timestamp in AVStream.time_base units
1323
 * @param flags flags which select direction and seeking mode
1324
 * @return >= 0 on success
1325
 */
1326
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1327
{
1328
    int ret;
1329
    AVStream *st;
1330
    
1331
    av_read_frame_flush(s);
1332
    
1333
    if(flags & AVSEEK_FLAG_BYTE)
1334
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1335
    
1336
    if(stream_index < 0){
1337
        stream_index= av_find_default_stream_index(s);
1338
        if(stream_index < 0)
1339
            return -1;
1340
            
1341
        st= s->streams[stream_index];
1342
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1343
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1344
    }
1345
    st= s->streams[stream_index];
1346

    
1347
    /* first, we try the format specific seek */
1348
    if (s->iformat->read_seek)
1349
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1350
    else
1351
        ret = -1;
1352
    if (ret >= 0) {
1353
        return 0;
1354
    }
1355

    
1356
    if(s->iformat->read_timestamp)
1357
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1358
    else
1359
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1360
}
1361

    
1362
/*******************************************************/
1363

    
1364
/* return TRUE if the stream has accurate timings for at least one component */
1365
static int av_has_timings(AVFormatContext *ic)
1366
{
1367
    int i;
1368
    AVStream *st;
1369

    
1370
    for(i = 0;i < ic->nb_streams; i++) {
1371
        st = ic->streams[i];
1372
        if (st->start_time != AV_NOPTS_VALUE &&
1373
            st->duration != AV_NOPTS_VALUE)
1374
            return 1;
1375
    }
1376
    return 0;
1377
}
1378

    
1379
/* estimate the stream timings from the one of each components. Also
1380
   compute the global bitrate if possible */
1381
static void av_update_stream_timings(AVFormatContext *ic)
1382
{
1383
    int64_t start_time, end_time, end_time1;
1384
    int i;
1385
    AVStream *st;
1386

    
1387
    start_time = MAXINT64;
1388
    end_time = MININT64;
1389
    for(i = 0;i < ic->nb_streams; i++) {
1390
        st = ic->streams[i];
1391
        if (st->start_time != AV_NOPTS_VALUE) {
1392
            if (st->start_time < start_time)
1393
                start_time = st->start_time;
1394
            if (st->duration != AV_NOPTS_VALUE) {
1395
                end_time1 = st->start_time + st->duration;
1396
                if (end_time1 > end_time)
1397
                    end_time = end_time1;
1398
            }
1399
        }
1400
    }
1401
    if (start_time != MAXINT64) {
1402
        ic->start_time = start_time;
1403
        if (end_time != MAXINT64) {
1404
            ic->duration = end_time - start_time;
1405
            if (ic->file_size > 0) {
1406
                /* compute the bit rate */
1407
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1408
                    (double)ic->duration;
1409
            }
1410
        }
1411
    }
1412

    
1413
}
1414

    
1415
static void fill_all_stream_timings(AVFormatContext *ic)
1416
{
1417
    int i;
1418
    AVStream *st;
1419

    
1420
    av_update_stream_timings(ic);
1421
    for(i = 0;i < ic->nb_streams; i++) {
1422
        st = ic->streams[i];
1423
        if (st->start_time == AV_NOPTS_VALUE) {
1424
            st->start_time = ic->start_time;
1425
            st->duration = ic->duration;
1426
        }
1427
    }
1428
}
1429

    
1430
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1431
{
1432
    int64_t filesize, duration;
1433
    int bit_rate, i;
1434
    AVStream *st;
1435

    
1436
    /* if bit_rate is already set, we believe it */
1437
    if (ic->bit_rate == 0) {
1438
        bit_rate = 0;
1439
        for(i=0;i<ic->nb_streams;i++) {
1440
            st = ic->streams[i];
1441
            bit_rate += st->codec.bit_rate;
1442
        }
1443
        ic->bit_rate = bit_rate;
1444
    }
1445

    
1446
    /* if duration is already set, we believe it */
1447
    if (ic->duration == AV_NOPTS_VALUE && 
1448
        ic->bit_rate != 0 && 
1449
        ic->file_size != 0)  {
1450
        filesize = ic->file_size;
1451
        if (filesize > 0) {
1452
            duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1453
            for(i = 0; i < ic->nb_streams; i++) {
1454
                st = ic->streams[i];
1455
                if (st->start_time == AV_NOPTS_VALUE ||
1456
                    st->duration == AV_NOPTS_VALUE) {
1457
                    st->start_time = 0;
1458
                    st->duration = duration;
1459
                }
1460
            }
1461
        }
1462
    }
1463
}
1464

    
1465
#define DURATION_MAX_READ_SIZE 250000
1466

    
1467
/* only usable for MPEG-PS streams */
1468
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1469
{
1470
    AVPacket pkt1, *pkt = &pkt1;
1471
    AVStream *st;
1472
    int read_size, i, ret;
1473
    int64_t start_time, end_time, end_time1;
1474
    int64_t filesize, offset, duration;
1475
    
1476
    /* free previous packet */
1477
    if (ic->cur_st && ic->cur_st->parser)
1478
        av_free_packet(&ic->cur_pkt); 
1479
    ic->cur_st = NULL;
1480

    
1481
    /* flush packet queue */
1482
    flush_packet_queue(ic);
1483

    
1484
    for(i=0;i<ic->nb_streams;i++) {
1485
        st = ic->streams[i];
1486
        if (st->parser) {
1487
            av_parser_close(st->parser);
1488
            st->parser= NULL;
1489
        }
1490
    }
1491
    
1492
    /* we read the first packets to get the first PTS (not fully
1493
       accurate, but it is enough now) */
1494
    url_fseek(&ic->pb, 0, SEEK_SET);
1495
    read_size = 0;
1496
    for(;;) {
1497
        if (read_size >= DURATION_MAX_READ_SIZE)
1498
            break;
1499
        /* if all info is available, we can stop */
1500
        for(i = 0;i < ic->nb_streams; i++) {
1501
            st = ic->streams[i];
1502
            if (st->start_time == AV_NOPTS_VALUE)
1503
                break;
1504
        }
1505
        if (i == ic->nb_streams)
1506
            break;
1507

    
1508
        ret = av_read_packet(ic, pkt);
1509
        if (ret != 0)
1510
            break;
1511
        read_size += pkt->size;
1512
        st = ic->streams[pkt->stream_index];
1513
        if (pkt->pts != AV_NOPTS_VALUE) {
1514
            if (st->start_time == AV_NOPTS_VALUE)
1515
                st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1516
        }
1517
        av_free_packet(pkt);
1518
    }
1519

    
1520
    /* we compute the minimum start_time and use it as default */
1521
    start_time = MAXINT64;
1522
    for(i = 0; i < ic->nb_streams; i++) {
1523
        st = ic->streams[i];
1524
        if (st->start_time != AV_NOPTS_VALUE &&
1525
            st->start_time < start_time)
1526
            start_time = st->start_time;
1527
    }
1528
    if (start_time != MAXINT64)
1529
        ic->start_time = start_time;
1530
    
1531
    /* estimate the end time (duration) */
1532
    /* XXX: may need to support wrapping */
1533
    filesize = ic->file_size;
1534
    offset = filesize - DURATION_MAX_READ_SIZE;
1535
    if (offset < 0)
1536
        offset = 0;
1537

    
1538
    url_fseek(&ic->pb, offset, SEEK_SET);
1539
    read_size = 0;
1540
    for(;;) {
1541
        if (read_size >= DURATION_MAX_READ_SIZE)
1542
            break;
1543
        /* if all info is available, we can stop */
1544
        for(i = 0;i < ic->nb_streams; i++) {
1545
            st = ic->streams[i];
1546
            if (st->duration == AV_NOPTS_VALUE)
1547
                break;
1548
        }
1549
        if (i == ic->nb_streams)
1550
            break;
1551
        
1552
        ret = av_read_packet(ic, pkt);
1553
        if (ret != 0)
1554
            break;
1555
        read_size += pkt->size;
1556
        st = ic->streams[pkt->stream_index];
1557
        if (pkt->pts != AV_NOPTS_VALUE) {
1558
            end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1559
            duration = end_time - st->start_time;
1560
            if (duration > 0) {
1561
                if (st->duration == AV_NOPTS_VALUE ||
1562
                    st->duration < duration)
1563
                    st->duration = duration;
1564
            }
1565
        }
1566
        av_free_packet(pkt);
1567
    }
1568
    
1569
    /* estimate total duration */
1570
    end_time = MININT64;
1571
    for(i = 0;i < ic->nb_streams; i++) {
1572
        st = ic->streams[i];
1573
        if (st->duration != AV_NOPTS_VALUE) {
1574
            end_time1 = st->start_time + st->duration;
1575
            if (end_time1 > end_time)
1576
                end_time = end_time1;
1577
        }
1578
    }
1579
    
1580
    /* update start_time (new stream may have been created, so we do
1581
       it at the end */
1582
    if (ic->start_time != AV_NOPTS_VALUE) {
1583
        for(i = 0; i < ic->nb_streams; i++) {
1584
            st = ic->streams[i];
1585
            if (st->start_time == AV_NOPTS_VALUE)
1586
                st->start_time = ic->start_time;
1587
        }
1588
    }
1589

    
1590
    if (end_time != MININT64) {
1591
        /* put dummy values for duration if needed */
1592
        for(i = 0;i < ic->nb_streams; i++) {
1593
            st = ic->streams[i];
1594
            if (st->duration == AV_NOPTS_VALUE && 
1595
                st->start_time != AV_NOPTS_VALUE)
1596
                st->duration = end_time - st->start_time;
1597
        }
1598
        ic->duration = end_time - ic->start_time;
1599
    }
1600

    
1601
    url_fseek(&ic->pb, 0, SEEK_SET);
1602
}
1603

    
1604
static void av_estimate_timings(AVFormatContext *ic)
1605
{
1606
    URLContext *h;
1607
    int64_t file_size;
1608

    
1609
    /* get the file size, if possible */
1610
    if (ic->iformat->flags & AVFMT_NOFILE) {
1611
        file_size = 0;
1612
    } else {
1613
        h = url_fileno(&ic->pb);
1614
        file_size = url_filesize(h);
1615
        if (file_size < 0)
1616
            file_size = 0;
1617
    }
1618
    ic->file_size = file_size;
1619

    
1620
    if (ic->iformat == &mpegps_demux) {
1621
        /* get accurate estimate from the PTSes */
1622
        av_estimate_timings_from_pts(ic);
1623
    } else if (av_has_timings(ic)) {
1624
        /* at least one components has timings - we use them for all
1625
           the components */
1626
        fill_all_stream_timings(ic);
1627
    } else {
1628
        /* less precise: use bit rate info */
1629
        av_estimate_timings_from_bit_rate(ic);
1630
    }
1631
    av_update_stream_timings(ic);
1632

    
1633
#if 0
1634
    {
1635
        int i;
1636
        AVStream *st;
1637
        for(i = 0;i < ic->nb_streams; i++) {
1638
            st = ic->streams[i];
1639
        printf("%d: start_time: %0.3f duration: %0.3f\n", 
1640
               i, (double)st->start_time / AV_TIME_BASE, 
1641
               (double)st->duration / AV_TIME_BASE);
1642
        }
1643
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1644
               (double)ic->start_time / AV_TIME_BASE, 
1645
               (double)ic->duration / AV_TIME_BASE,
1646
               ic->bit_rate / 1000);
1647
    }
1648
#endif
1649
}
1650

    
1651
static int has_codec_parameters(AVCodecContext *enc)
1652
{
1653
    int val;
1654
    switch(enc->codec_type) {
1655
    case CODEC_TYPE_AUDIO:
1656
        val = enc->sample_rate;
1657
        break;
1658
    case CODEC_TYPE_VIDEO:
1659
        val = enc->width;
1660
        break;
1661
    default:
1662
        val = 1;
1663
        break;
1664
    }
1665
    return (val != 0);
1666
}
1667

    
1668
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1669
{
1670
    int16_t *samples;
1671
    AVCodec *codec;
1672
    int got_picture, ret;
1673
    AVFrame picture;
1674
    
1675
    codec = avcodec_find_decoder(st->codec.codec_id);
1676
    if (!codec)
1677
        return -1;
1678
    ret = avcodec_open(&st->codec, codec);
1679
    if (ret < 0)
1680
        return ret;
1681
    switch(st->codec.codec_type) {
1682
    case CODEC_TYPE_VIDEO:
1683
        ret = avcodec_decode_video(&st->codec, &picture, 
1684
                                   &got_picture, (uint8_t *)data, size);
1685
        break;
1686
    case CODEC_TYPE_AUDIO:
1687
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1688
        if (!samples)
1689
            goto fail;
1690
        ret = avcodec_decode_audio(&st->codec, samples, 
1691
                                   &got_picture, (uint8_t *)data, size);
1692
        av_free(samples);
1693
        break;
1694
    default:
1695
        break;
1696
    }
1697
 fail:
1698
    avcodec_close(&st->codec);
1699
    return ret;
1700
}
1701

    
1702
/* absolute maximum size we read until we abort */
1703
#define MAX_READ_SIZE        5000000
1704

    
1705
/* maximum duration until we stop analysing the stream */
1706
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1707

    
1708
/**
1709
 * Read the beginning of a media file to get stream information. This
1710
 * is useful for file formats with no headers such as MPEG. This
1711
 * function also compute the real frame rate in case of mpeg2 repeat
1712
 * frame mode.
1713
 *
1714
 * @param ic media file handle
1715
 * @return >=0 if OK. AVERROR_xxx if error.  
1716
 */
1717
int av_find_stream_info(AVFormatContext *ic)
1718
{
1719
    int i, count, ret, read_size;
1720
    AVStream *st;
1721
    AVPacket pkt1, *pkt;
1722
    AVPacketList *pktl=NULL, **ppktl;
1723

    
1724
    count = 0;
1725
    read_size = 0;
1726
    ppktl = &ic->packet_buffer;
1727
    for(;;) {
1728
        /* check if one codec still needs to be handled */
1729
        for(i=0;i<ic->nb_streams;i++) {
1730
            st = ic->streams[i];
1731
            if (!has_codec_parameters(&st->codec))
1732
                break;
1733
        }
1734
        if (i == ic->nb_streams) {
1735
            /* NOTE: if the format has no header, then we need to read
1736
               some packets to get most of the streams, so we cannot
1737
               stop here */
1738
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1739
                /* if we found the info for all the codecs, we can stop */
1740
                ret = count;
1741
                break;
1742
            }
1743
        } else {
1744
            /* we did not get all the codec info, but we read too much data */
1745
            if (read_size >= MAX_READ_SIZE) {
1746
                ret = count;
1747
                break;
1748
            }
1749
        }
1750

    
1751
        /* NOTE: a new stream can be added there if no header in file
1752
           (AVFMTCTX_NOHEADER) */
1753
        ret = av_read_frame_internal(ic, &pkt1);
1754
        if (ret < 0) {
1755
            /* EOF or error */
1756
            ret = -1; /* we could not have all the codec parameters before EOF */
1757
            if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1758
                i == ic->nb_streams)
1759
                ret = 0;
1760
            break;
1761
        }
1762

    
1763
        pktl = av_mallocz(sizeof(AVPacketList));
1764
        if (!pktl) {
1765
            ret = AVERROR_NOMEM;
1766
            break;
1767
        }
1768

    
1769
        /* add the packet in the buffered packet list */
1770
        *ppktl = pktl;
1771
        ppktl = &pktl->next;
1772

    
1773
        pkt = &pktl->pkt;
1774
        *pkt = pkt1;
1775
        
1776
        /* duplicate the packet */
1777
        if (av_dup_packet(pkt) < 0) {
1778
                ret = AVERROR_NOMEM;
1779
                break;
1780
        }
1781

    
1782
        read_size += pkt->size;
1783

    
1784
        st = ic->streams[pkt->stream_index];
1785
        st->codec_info_duration += pkt->duration;
1786
        if (pkt->duration != 0)
1787
            st->codec_info_nb_frames++;
1788

    
1789
        /* if still no information, we try to open the codec and to
1790
           decompress the frame. We try to avoid that in most cases as
1791
           it takes longer and uses more memory. For MPEG4, we need to
1792
           decompress for Quicktime. */
1793
        if (!has_codec_parameters(&st->codec) &&
1794
            (st->codec.codec_id == CODEC_ID_FLV1 ||
1795
             st->codec.codec_id == CODEC_ID_H264 ||
1796
             st->codec.codec_id == CODEC_ID_H263 ||
1797
             st->codec.codec_id == CODEC_ID_H261 ||
1798
             st->codec.codec_id == CODEC_ID_VORBIS ||
1799
             st->codec.codec_id == CODEC_ID_MJPEG ||
1800
             st->codec.codec_id == CODEC_ID_PNG ||
1801
             st->codec.codec_id == CODEC_ID_PAM ||
1802
             st->codec.codec_id == CODEC_ID_PGM ||
1803
             st->codec.codec_id == CODEC_ID_PGMYUV ||
1804
             st->codec.codec_id == CODEC_ID_PBM ||
1805
             st->codec.codec_id == CODEC_ID_PPM ||
1806
             (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1807
            try_decode_frame(st, pkt->data, pkt->size);
1808
        
1809
        if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1810
            break;
1811
        }
1812
        count++;
1813
    }
1814

    
1815
    for(i=0;i<ic->nb_streams;i++) {
1816
        st = ic->streams[i];
1817
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1818
            if(st->codec.codec_id == CODEC_ID_RAWVIDEO && !st->codec.codec_tag && !st->codec.bits_per_sample)
1819
                st->codec.codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec.pix_fmt);
1820
            /* set real frame rate info */
1821
            /* compute the real frame rate for telecine */
1822
            if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1823
                 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1824
                st->codec.sub_id == 2) {
1825
                if (st->codec_info_nb_frames >= 20) {
1826
                    float coded_frame_rate, est_frame_rate;
1827
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1828
                        (double)st->codec_info_duration ;
1829
                    coded_frame_rate = (double)st->codec.frame_rate /
1830
                        (double)st->codec.frame_rate_base;
1831
#if 0
1832
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1833
                           coded_frame_rate, est_frame_rate);
1834
#endif
1835
                    /* if we detect that it could be a telecine, we
1836
                       signal it. It would be better to do it at a
1837
                       higher level as it can change in a film */
1838
                    if (coded_frame_rate >= 24.97 && 
1839
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1840
                        st->r_frame_rate = 24024;
1841
                        st->r_frame_rate_base = 1001;
1842
                    }
1843
                }
1844
            }
1845
            /* if no real frame rate, use the codec one */
1846
            if (!st->r_frame_rate){
1847
                st->r_frame_rate      = st->codec.frame_rate;
1848
                st->r_frame_rate_base = st->codec.frame_rate_base;
1849
            }
1850
        }
1851
    }
1852

    
1853
    av_estimate_timings(ic);
1854
#if 0
1855
    /* correct DTS for b frame streams with no timestamps */
1856
    for(i=0;i<ic->nb_streams;i++) {
1857
        st = ic->streams[i];
1858
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1859
            if(b-frames){
1860
                ppktl = &ic->packet_buffer;
1861
                while(ppkt1){
1862
                    if(ppkt1->stream_index != i)
1863
                        continue;
1864
                    if(ppkt1->pkt->dts < 0)
1865
                        break;
1866
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1867
                        break;
1868
                    ppkt1->pkt->dts -= delta;
1869
                    ppkt1= ppkt1->next;
1870
                }
1871
                if(ppkt1)
1872
                    continue;
1873
                st->cur_dts -= delta;
1874
            }
1875
        }
1876
    }
1877
#endif
1878
    return ret;
1879
}
1880

    
1881
/*******************************************************/
1882

    
1883
/**
1884
 * start playing a network based stream (e.g. RTSP stream) at the
1885
 * current position 
1886
 */
1887
int av_read_play(AVFormatContext *s)
1888
{
1889
    if (!s->iformat->read_play)
1890
        return AVERROR_NOTSUPP;
1891
    return s->iformat->read_play(s);
1892
}
1893

    
1894
/**
1895
 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1896
 * to resume it.
1897
 */
1898
int av_read_pause(AVFormatContext *s)
1899
{
1900
    if (!s->iformat->read_pause)
1901
        return AVERROR_NOTSUPP;
1902
    return s->iformat->read_pause(s);
1903
}
1904

    
1905
/**
1906
 * Close a media file (but not its codecs)
1907
 *
1908
 * @param s media file handle
1909
 */
1910
void av_close_input_file(AVFormatContext *s)
1911
{
1912
    int i, must_open_file;
1913
    AVStream *st;
1914

    
1915
    /* free previous packet */
1916
    if (s->cur_st && s->cur_st->parser)
1917
        av_free_packet(&s->cur_pkt); 
1918

    
1919
    if (s->iformat->read_close)
1920
        s->iformat->read_close(s);
1921
    for(i=0;i<s->nb_streams;i++) {
1922
        /* free all data in a stream component */
1923
        st = s->streams[i];
1924
        if (st->parser) {
1925
            av_parser_close(st->parser);
1926
        }
1927
        av_free(st->index_entries);
1928
        av_free(st);
1929
    }
1930
    flush_packet_queue(s);
1931
    must_open_file = 1;
1932
    if (s->iformat->flags & AVFMT_NOFILE) {
1933
        must_open_file = 0;
1934
    }
1935
    if (must_open_file) {
1936
        url_fclose(&s->pb);
1937
    }
1938
    av_freep(&s->priv_data);
1939
    av_free(s);
1940
}
1941

    
1942
/**
1943
 * Add a new stream to a media file. Can only be called in the
1944
 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1945
 * format context, then new streams can be added in read_packet too.
1946
 *
1947
 *
1948
 * @param s media file handle
1949
 * @param id file format dependent stream id 
1950
 */
1951
AVStream *av_new_stream(AVFormatContext *s, int id)
1952
{
1953
    AVStream *st;
1954

    
1955
    if (s->nb_streams >= MAX_STREAMS)
1956
        return NULL;
1957

    
1958
    st = av_mallocz(sizeof(AVStream));
1959
    if (!st)
1960
        return NULL;
1961
    avcodec_get_context_defaults(&st->codec);
1962
    if (s->iformat) {
1963
        /* no default bitrate if decoding */
1964
        st->codec.bit_rate = 0;
1965
    }
1966
    st->index = s->nb_streams;
1967
    st->id = id;
1968
    st->start_time = AV_NOPTS_VALUE;
1969
    st->duration = AV_NOPTS_VALUE;
1970
    st->cur_dts = AV_NOPTS_VALUE;
1971

    
1972
    /* default pts settings is MPEG like */
1973
    av_set_pts_info(st, 33, 1, 90000);
1974
    st->last_IP_pts = AV_NOPTS_VALUE;
1975

    
1976
    s->streams[s->nb_streams++] = st;
1977
    return st;
1978
}
1979

    
1980
/************************************************************/
1981
/* output media file */
1982

    
1983
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1984
{
1985
    int ret;
1986
    
1987
    if (s->oformat->priv_data_size > 0) {
1988
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
1989
        if (!s->priv_data)
1990
            return AVERROR_NOMEM;
1991
    } else
1992
        s->priv_data = NULL;
1993
        
1994
    if (s->oformat->set_parameters) {
1995
        ret = s->oformat->set_parameters(s, ap);
1996
        if (ret < 0)
1997
            return ret;
1998
    }
1999
    return 0;
2000
}
2001

    
2002
/**
2003
 * allocate the stream private data and write the stream header to an
2004
 * output media file
2005
 *
2006
 * @param s media file handle
2007
 * @return 0 if OK. AVERROR_xxx if error.  
2008
 */
2009
int av_write_header(AVFormatContext *s)
2010
{
2011
    int ret, i;
2012
    AVStream *st;
2013

    
2014
    ret = s->oformat->write_header(s);
2015
    if (ret < 0)
2016
        return ret;
2017

    
2018
    /* init PTS generation */
2019
    for(i=0;i<s->nb_streams;i++) {
2020
        st = s->streams[i];
2021

    
2022
        switch (st->codec.codec_type) {
2023
        case CODEC_TYPE_AUDIO:
2024
            av_frac_init(&st->pts, 0, 0, 
2025
                         (int64_t)st->time_base.num * st->codec.sample_rate);
2026
            break;
2027
        case CODEC_TYPE_VIDEO:
2028
            av_frac_init(&st->pts, 0, 0, 
2029
                         (int64_t)st->time_base.num * st->codec.frame_rate);
2030
            break;
2031
        default:
2032
            break;
2033
        }
2034
    }
2035
    return 0;
2036
}
2037

    
2038
//FIXME merge with compute_pkt_fields
2039
static void compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2040
    int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
2041
    int num, den, frame_size;
2042

    
2043
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
2044
    
2045
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2046
        return -1;*/
2047
            
2048
    if(pkt->pts != AV_NOPTS_VALUE)
2049
        pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2050
    if(pkt->dts != AV_NOPTS_VALUE)
2051
        pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2052

    
2053
    /* duration field */
2054
    pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2055
    if (pkt->duration == 0) {
2056
        compute_frame_duration(&num, &den, st, NULL, pkt);
2057
        if (den && num) {
2058
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2059
        }
2060
    }
2061

    
2062
    //XXX/FIXME this is a temporary hack until all encoders output pts
2063
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2064
        pkt->dts=
2065
//        pkt->pts= st->cur_dts;
2066
        pkt->pts= st->pts.val;
2067
    }
2068

    
2069
    //calculate dts from pts    
2070
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2071
        if(b_frames){
2072
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2073
                st->last_IP_pts= -pkt->duration;
2074
            }
2075
            if(st->last_IP_pts < pkt->pts){
2076
                pkt->dts= st->last_IP_pts;
2077
                st->last_IP_pts= pkt->pts;
2078
            }else
2079
                pkt->dts= pkt->pts;
2080
        }else
2081
            pkt->dts= pkt->pts;
2082
    }
2083
    
2084
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2085
    st->cur_dts= pkt->dts;
2086
    st->pts.val= pkt->dts;
2087

    
2088
    /* update pts */
2089
    switch (st->codec.codec_type) {
2090
    case CODEC_TYPE_AUDIO:
2091
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
2092

    
2093
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2094
           but it would be better if we had the real timestamps from the encoder */
2095
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2096
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2097
        }
2098
        break;
2099
    case CODEC_TYPE_VIDEO:
2100
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
2101
        break;
2102
    default:
2103
        break;
2104
    }
2105
}
2106

    
2107
static void truncate_ts(AVStream *st, AVPacket *pkt){
2108
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2109
    
2110
//    if(pkt->dts < 0)
2111
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2112
    
2113
    pkt->pts &= pts_mask;
2114
    pkt->dts &= pts_mask;
2115
}
2116

    
2117
/**
2118
 * Write a packet to an output media file. The packet shall contain
2119
 * one audio or video frame.
2120
 *
2121
 * @param s media file handle
2122
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2123
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2124
 */
2125
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2126
{
2127
    int ret;
2128

    
2129
    compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2130
    
2131
    truncate_ts(s->streams[pkt->stream_index], pkt);
2132

    
2133
    ret= s->oformat->write_packet(s, pkt);
2134
    if(!ret)
2135
        ret= url_ferror(&s->pb);
2136
    return ret;
2137
}
2138

    
2139
/**
2140
 * interleave_packet implementation which will interleave per DTS.
2141
 */
2142
static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2143
    AVPacketList *pktl, **next_point, *this_pktl;
2144
    int stream_count=0;
2145
    int streams[MAX_STREAMS];
2146

    
2147
    if(pkt){
2148
        AVStream *st= s->streams[ pkt->stream_index];
2149

    
2150
        assert(pkt->destruct != av_destruct_packet); //FIXME
2151

    
2152
        this_pktl = av_mallocz(sizeof(AVPacketList));
2153
        this_pktl->pkt= *pkt;
2154
        av_dup_packet(&this_pktl->pkt);
2155

    
2156
        next_point = &s->packet_buffer;
2157
        while(*next_point){
2158
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2159
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2160
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2161
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2162
                break;
2163
            next_point= &(*next_point)->next;
2164
        }
2165
        this_pktl->next= *next_point;
2166
        *next_point= this_pktl;
2167
    }
2168
    
2169
    memset(streams, 0, sizeof(streams));
2170
    pktl= s->packet_buffer;
2171
    while(pktl){
2172
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2173
        if(streams[ pktl->pkt.stream_index ] == 0)
2174
            stream_count++;
2175
        streams[ pktl->pkt.stream_index ]++;
2176
        pktl= pktl->next;
2177
    }
2178
    
2179
    if(s->nb_streams == stream_count || (flush && stream_count)){
2180
        pktl= s->packet_buffer;
2181
        *out= pktl->pkt;
2182
        
2183
        s->packet_buffer= pktl->next;        
2184
        av_freep(&pktl);
2185
        return 1;
2186
    }else{
2187
        av_init_packet(out);
2188
        return 0;
2189
    }
2190
}
2191

    
2192
/**
2193
 * Interleaves a AVPacket correctly so it can be muxed.
2194
 * @param out the interleaved packet will be output here
2195
 * @param in the input packet
2196
 * @param flush 1 if no further packets are available as input and all
2197
 *              remaining packets should be output
2198
 * @return 1 if a packet was output, 0 if no packet could be output, 
2199
 *         < 0 if an error occured
2200
 */
2201
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2202
    if(s->oformat->interleave_packet)
2203
        return s->oformat->interleave_packet(s, out, in, flush);
2204
    else
2205
        return av_interleave_packet_per_dts(s, out, in, flush);
2206
}
2207

    
2208
/**
2209
 * Writes a packet to an output media file ensuring correct interleaving. 
2210
 * The packet shall contain one audio or video frame.
2211
 * If the packets are already correctly interleaved the application should
2212
 * call av_write_frame() instead as its slightly faster, its also important
2213
 * to keep in mind that completly non interleaved input will need huge amounts
2214
 * of memory to interleave with this, so its prefereable to interleave at the
2215
 * demuxer level
2216
 *
2217
 * @param s media file handle
2218
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2219
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2220
 */
2221
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2222
    AVStream *st= s->streams[ pkt->stream_index];
2223

    
2224
    compute_pkt_fields2(st, pkt);
2225
    
2226
    //FIXME/XXX/HACK drop zero sized packets
2227
    if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2228
        return 0;
2229
    
2230
    if(pkt->dts == AV_NOPTS_VALUE)
2231
        return -1;
2232

    
2233
    for(;;){
2234
        AVPacket opkt;
2235
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2236
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2237
            return ret;
2238
        
2239
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2240
        ret= s->oformat->write_packet(s, &opkt);
2241
        
2242
        av_free_packet(&opkt);
2243
        pkt= NULL;
2244
        
2245
        if(ret<0)
2246
            return ret;
2247
        if(url_ferror(&s->pb))
2248
            return url_ferror(&s->pb);
2249
    }
2250
}
2251

    
2252
/**
2253
 * write the stream trailer to an output media file and and free the
2254
 * file private data.
2255
 *
2256
 * @param s media file handle
2257
 * @return 0 if OK. AVERROR_xxx if error.  */
2258
int av_write_trailer(AVFormatContext *s)
2259
{
2260
    int ret, i;
2261
    
2262
    for(;;){
2263
        AVPacket pkt;
2264
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2265
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2266
            goto fail;
2267
        if(!ret)
2268
            break;
2269
        
2270
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2271
        ret= s->oformat->write_packet(s, &pkt);
2272
        
2273
        av_free_packet(&pkt);
2274
        
2275
        if(ret<0)
2276
            goto fail;
2277
        if(url_ferror(&s->pb))
2278
            goto fail;
2279
    }
2280

    
2281
    ret = s->oformat->write_trailer(s);
2282
fail:
2283
    if(ret == 0)
2284
       ret=url_ferror(&s->pb);
2285
    for(i=0;i<s->nb_streams;i++)
2286
        av_freep(&s->streams[i]->priv_data);
2287
    av_freep(&s->priv_data);
2288
    return ret;
2289
}
2290

    
2291
/* "user interface" functions */
2292

    
2293
void dump_format(AVFormatContext *ic,
2294
                 int index, 
2295
                 const char *url,
2296
                 int is_output)
2297
{
2298
    int i, flags;
2299
    char buf[256];
2300

    
2301
    av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
2302
            is_output ? "Output" : "Input",
2303
            index, 
2304
            is_output ? ic->oformat->name : ic->iformat->name, 
2305
            is_output ? "to" : "from", url);
2306
    if (!is_output) {
2307
        av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
2308
        if (ic->duration != AV_NOPTS_VALUE) {
2309
            int hours, mins, secs, us;
2310
            secs = ic->duration / AV_TIME_BASE;
2311
            us = ic->duration % AV_TIME_BASE;
2312
            mins = secs / 60;
2313
            secs %= 60;
2314
            hours = mins / 60;
2315
            mins %= 60;
2316
            av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
2317
                   (10 * us) / AV_TIME_BASE);
2318
        } else {
2319
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2320
        }
2321
        if (ic->start_time != AV_NOPTS_VALUE) {
2322
            int secs, us;
2323
            av_log(NULL, AV_LOG_DEBUG, ", start: ");
2324
            secs = ic->start_time / AV_TIME_BASE;
2325
            us = ic->start_time % AV_TIME_BASE;
2326
            av_log(NULL, AV_LOG_DEBUG, "%d.%06d",
2327
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2328
        }
2329
        av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
2330
        if (ic->bit_rate) {
2331
            av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
2332
        } else {
2333
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2334
        }
2335
        av_log(NULL, AV_LOG_DEBUG, "\n");
2336
    }
2337
    for(i=0;i<ic->nb_streams;i++) {
2338
        AVStream *st = ic->streams[i];
2339
        avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2340
        av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
2341
        /* the pid is an important information, so we display it */
2342
        /* XXX: add a generic system */
2343
        if (is_output)
2344
            flags = ic->oformat->flags;
2345
        else
2346
            flags = ic->iformat->flags;
2347
        if (flags & AVFMT_SHOW_IDS) {
2348
            av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
2349
        }
2350
        av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
2351
    }
2352
}
2353

    
2354
typedef struct {
2355
    const char *abv;
2356
    int width, height;
2357
    int frame_rate, frame_rate_base;
2358
} AbvEntry;
2359

    
2360
static AbvEntry frame_abvs[] = {
2361
    { "ntsc",      720, 480, 30000, 1001 },
2362
    { "pal",       720, 576,    25,    1 },
2363
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2364
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2365
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2366
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2367
    { "film",      352, 240,    24,    1 },
2368
    { "ntsc-film", 352, 240, 24000, 1001 },
2369
    { "sqcif",     128,  96,     0,    0 },
2370
    { "qcif",      176, 144,     0,    0 },
2371
    { "cif",       352, 288,     0,    0 },
2372
    { "4cif",      704, 576,     0,    0 },
2373
};
2374

    
2375
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2376
{
2377
    int i;
2378
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2379
    const char *p;
2380
    int frame_width = 0, frame_height = 0;
2381

    
2382
    for(i=0;i<n;i++) {
2383
        if (!strcmp(frame_abvs[i].abv, str)) {
2384
            frame_width = frame_abvs[i].width;
2385
            frame_height = frame_abvs[i].height;
2386
            break;
2387
        }
2388
    }
2389
    if (i == n) {
2390
        p = str;
2391
        frame_width = strtol(p, (char **)&p, 10);
2392
        if (*p)
2393
            p++;
2394
        frame_height = strtol(p, (char **)&p, 10);
2395
    }
2396
    if (frame_width <= 0 || frame_height <= 0)
2397
        return -1;
2398
    *width_ptr = frame_width;
2399
    *height_ptr = frame_height;
2400
    return 0;
2401
}
2402

    
2403
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2404
{
2405
    int i;
2406
    char* cp;
2407
   
2408
    /* First, we check our abbreviation table */
2409
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2410
         if (!strcmp(frame_abvs[i].abv, arg)) {
2411
             *frame_rate = frame_abvs[i].frame_rate;
2412
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2413
             return 0;
2414
         }
2415

    
2416
    /* Then, we try to parse it as fraction */
2417
    cp = strchr(arg, '/');
2418
    if (cp) {
2419
        char* cpp;
2420
        *frame_rate = strtol(arg, &cpp, 10);
2421
        if (cpp != arg || cpp == cp) 
2422
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2423
        else
2424
           *frame_rate = 0;
2425
    } 
2426
    else {
2427
        /* Finally we give up and parse it as double */
2428
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2429
        *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2430
    }
2431
    if (!*frame_rate || !*frame_rate_base)
2432
        return -1;
2433
    else
2434
        return 0;
2435
}
2436

    
2437
/* Syntax:
2438
 * - If not a duration:
2439
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2440
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2441
 * Return the date in micro seconds since 1970 
2442
 * - If duration:
2443
 *  HH[:MM[:SS[.m...]]]
2444
 *  S+[.m...]
2445
 */
2446
int64_t parse_date(const char *datestr, int duration)
2447
{
2448
    const char *p;
2449
    int64_t t;
2450
    struct tm dt;
2451
    int i;
2452
    static const char *date_fmt[] = {
2453
        "%Y-%m-%d",
2454
        "%Y%m%d",
2455
    };
2456
    static const char *time_fmt[] = {
2457
        "%H:%M:%S",
2458
        "%H%M%S",
2459
    };
2460
    const char *q;
2461
    int is_utc, len;
2462
    char lastch;
2463
    int negative = 0;
2464

    
2465
#undef time
2466
    time_t now = time(0);
2467

    
2468
    len = strlen(datestr);
2469
    if (len > 0)
2470
        lastch = datestr[len - 1];
2471
    else
2472
        lastch = '\0';
2473
    is_utc = (lastch == 'z' || lastch == 'Z');
2474

    
2475
    memset(&dt, 0, sizeof(dt));
2476

    
2477
    p = datestr;
2478
    q = NULL;
2479
    if (!duration) {
2480
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2481
            q = small_strptime(p, date_fmt[i], &dt);
2482
            if (q) {
2483
                break;
2484
            }
2485
        }
2486

    
2487
        if (!q) {
2488
            if (is_utc) {
2489
                dt = *gmtime(&now);
2490
            } else {
2491
                dt = *localtime(&now);
2492
            }
2493
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2494
        } else {
2495
            p = q;
2496
        }
2497

    
2498
        if (*p == 'T' || *p == 't' || *p == ' ')
2499
            p++;
2500

    
2501
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2502
            q = small_strptime(p, time_fmt[i], &dt);
2503
            if (q) {
2504
                break;
2505
            }
2506
        }
2507
    } else {
2508
        if (p[0] == '-') {
2509
            negative = 1;
2510
            ++p;
2511
        }
2512
        q = small_strptime(p, time_fmt[0], &dt);
2513
        if (!q) {
2514
            dt.tm_sec = strtol(p, (char **)&q, 10);
2515
            dt.tm_min = 0;
2516
            dt.tm_hour = 0;
2517
        }
2518
    }
2519

    
2520
    /* Now we have all the fields that we can get */
2521
    if (!q) {
2522
        if (duration)
2523
            return 0;
2524
        else
2525
            return now * int64_t_C(1000000);
2526
    }
2527

    
2528
    if (duration) {
2529
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2530
    } else {
2531
        dt.tm_isdst = -1;       /* unknown */
2532
        if (is_utc) {
2533
            t = mktimegm(&dt);
2534
        } else {
2535
            t = mktime(&dt);
2536
        }
2537
    }
2538

    
2539
    t *= 1000000;
2540

    
2541
    if (*q == '.') {
2542
        int val, n;
2543
        q++;
2544
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2545
            if (!isdigit(*q)) 
2546
                break;
2547
            val += n * (*q - '0');
2548
        }
2549
        t += val;
2550
    }
2551
    return negative ? -t : t;
2552
}
2553

    
2554
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2555
   1 if found */
2556
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2557
{
2558
    const char *p;
2559
    char tag[128], *q;
2560

    
2561
    p = info;
2562
    if (*p == '?')
2563
        p++;
2564
    for(;;) {
2565
        q = tag;
2566
        while (*p != '\0' && *p != '=' && *p != '&') {
2567
            if ((q - tag) < sizeof(tag) - 1)
2568
                *q++ = *p;
2569
            p++;
2570
        }
2571
        *q = '\0';
2572
        q = arg;
2573
        if (*p == '=') {
2574
            p++;
2575
            while (*p != '&' && *p != '\0') {
2576
                if ((q - arg) < arg_size - 1) {
2577
                    if (*p == '+')
2578
                        *q++ = ' ';
2579
                    else
2580
                        *q++ = *p;
2581
                }
2582
                p++;
2583
            }
2584
            *q = '\0';
2585
        }
2586
        if (!strcmp(tag, tag1)) 
2587
            return 1;
2588
        if (*p != '&')
2589
            break;
2590
        p++;
2591
    }
2592
    return 0;
2593
}
2594

    
2595
/* Return in 'buf' the path with '%d' replaced by number. Also handles
2596
   the '%0nd' format where 'n' is the total number of digits and
2597
   '%%'. Return 0 if OK, and -1 if format error */
2598
int get_frame_filename(char *buf, int buf_size,
2599
                       const char *path, int number)
2600
{
2601
    const char *p;
2602
    char *q, buf1[20], c;
2603
    int nd, len, percentd_found;
2604

    
2605
    q = buf;
2606
    p = path;
2607
    percentd_found = 0;
2608
    for(;;) {
2609
        c = *p++;
2610
        if (c == '\0')
2611
            break;
2612
        if (c == '%') {
2613
            do {
2614
                nd = 0;
2615
                while (isdigit(*p)) {
2616
                    nd = nd * 10 + *p++ - '0';
2617
                }
2618
                c = *p++;
2619
            } while (isdigit(c));
2620

    
2621
            switch(c) {
2622
            case '%':
2623
                goto addchar;
2624
            case 'd':
2625
                if (percentd_found)
2626
                    goto fail;
2627
                percentd_found = 1;
2628
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2629
                len = strlen(buf1);
2630
                if ((q - buf + len) > buf_size - 1)
2631
                    goto fail;
2632
                memcpy(q, buf1, len);
2633
                q += len;
2634
                break;
2635
            default:
2636
                goto fail;
2637
            }
2638
        } else {
2639
        addchar:
2640
            if ((q - buf) < buf_size - 1)
2641
                *q++ = c;
2642
        }
2643
    }
2644
    if (!percentd_found)
2645
        goto fail;
2646
    *q = '\0';
2647
    return 0;
2648
 fail:
2649
    *q = '\0';
2650
    return -1;
2651
}
2652

    
2653
/**
2654
 * Print  nice hexa dump of a buffer
2655
 * @param f stream for output
2656
 * @param buf buffer
2657
 * @param size buffer size
2658
 */
2659
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2660
{
2661
    int len, i, j, c;
2662

    
2663
    for(i=0;i<size;i+=16) {
2664
        len = size - i;
2665
        if (len > 16)
2666
            len = 16;
2667
        fprintf(f, "%08x ", i);
2668
        for(j=0;j<16;j++) {
2669
            if (j < len)
2670
                fprintf(f, " %02x", buf[i+j]);
2671
            else
2672
                fprintf(f, "   ");
2673
        }
2674
        fprintf(f, " ");
2675
        for(j=0;j<len;j++) {
2676
            c = buf[i+j];
2677
            if (c < ' ' || c > '~')
2678
                c = '.';
2679
            fprintf(f, "%c", c);
2680
        }
2681
        fprintf(f, "\n");
2682
    }
2683
}
2684

    
2685
/**
2686
 * Print on 'f' a nice dump of a packet
2687
 * @param f stream for output
2688
 * @param pkt packet to dump
2689
 * @param dump_payload true if the payload must be displayed too
2690
 */
2691
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2692
{
2693
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2694
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2695
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2696
    /* DTS is _always_ valid after av_read_frame() */
2697
    fprintf(f, "  dts=");
2698
    if (pkt->dts == AV_NOPTS_VALUE)
2699
        fprintf(f, "N/A");
2700
    else
2701
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2702
    /* PTS may be not known if B frames are present */
2703
    fprintf(f, "  pts=");
2704
    if (pkt->pts == AV_NOPTS_VALUE)
2705
        fprintf(f, "N/A");
2706
    else
2707
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2708
    fprintf(f, "\n");
2709
    fprintf(f, "  size=%d\n", pkt->size);
2710
    if (dump_payload)
2711
        av_hex_dump(f, pkt->data, pkt->size);
2712
}
2713

    
2714
void url_split(char *proto, int proto_size,
2715
               char *authorization, int authorization_size,
2716
               char *hostname, int hostname_size,
2717
               int *port_ptr,
2718
               char *path, int path_size,
2719
               const char *url)
2720
{
2721
    const char *p;
2722
    char *q;
2723
    int port;
2724

    
2725
    port = -1;
2726

    
2727
    p = url;
2728
    q = proto;
2729
    while (*p != ':' && *p != '\0') {
2730
        if ((q - proto) < proto_size - 1)
2731
            *q++ = *p;
2732
        p++;
2733
    }
2734
    if (proto_size > 0)
2735
        *q = '\0';
2736
    if (authorization_size > 0)
2737
        authorization[0] = '\0';
2738
    if (*p == '\0') {
2739
        if (proto_size > 0)
2740
            proto[0] = '\0';
2741
        if (hostname_size > 0)
2742
            hostname[0] = '\0';
2743
        p = url;
2744
    } else {
2745
        char *at,*slash; // PETR: position of '@' character and '/' character
2746

    
2747
        p++;
2748
        if (*p == '/')
2749
            p++;
2750
        if (*p == '/')
2751
            p++;
2752
        at = strchr(p,'@'); // PETR: get the position of '@'
2753
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2754
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2755

    
2756
        q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2757

    
2758
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2759
            if (*p == '@') {    // PETR: passed '@'
2760
              if (authorization_size > 0)
2761
                  *q = '\0';
2762
              q = hostname;
2763
              at = NULL;
2764
            } else if (!at) {   // PETR: hostname
2765
              if ((q - hostname) < hostname_size - 1)
2766
                  *q++ = *p;
2767
            } else {
2768
              if ((q - authorization) < authorization_size - 1)
2769
                *q++ = *p;
2770
            }
2771
            p++;
2772
        }
2773
        if (hostname_size > 0)
2774
            *q = '\0';
2775
        if (*p == ':') {
2776
            p++;
2777
            port = strtoul(p, (char **)&p, 10);
2778
        }
2779
    }
2780
    if (port_ptr)
2781
        *port_ptr = port;
2782
    pstrcpy(path, path_size, p);
2783
}
2784

    
2785
/**
2786
 * Set the pts for a given stream
2787
 * @param s stream 
2788
 * @param pts_wrap_bits number of bits effectively used by the pts
2789
 *        (used for wrap control, 33 is the value for MPEG) 
2790
 * @param pts_num numerator to convert to seconds (MPEG: 1) 
2791
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2792
 */
2793
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2794
                     int pts_num, int pts_den)
2795
{
2796
    s->pts_wrap_bits = pts_wrap_bits;
2797
    s->time_base.num = pts_num;
2798
    s->time_base.den = pts_den;
2799
}
2800

    
2801
/* fraction handling */
2802

    
2803
/**
2804
 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2805
 * as 0 <= num < den.
2806
 *
2807
 * @param f fractional number
2808
 * @param val integer value
2809
 * @param num must be >= 0
2810
 * @param den must be >= 1 
2811
 */
2812
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2813
{
2814
    num += (den >> 1);
2815
    if (num >= den) {
2816
        val += num / den;
2817
        num = num % den;
2818
    }
2819
    f->val = val;
2820
    f->num = num;
2821
    f->den = den;
2822
}
2823

    
2824
/* set f to (val + 0.5) */
2825
void av_frac_set(AVFrac *f, int64_t val)
2826
{
2827
    f->val = val;
2828
    f->num = f->den >> 1;
2829
}
2830

    
2831
/**
2832
 * Fractionnal addition to f: f = f + (incr / f->den)
2833
 *
2834
 * @param f fractional number
2835
 * @param incr increment, can be positive or negative
2836
 */
2837
void av_frac_add(AVFrac *f, int64_t incr)
2838
{
2839
    int64_t num, den;
2840

    
2841
    num = f->num + incr;
2842
    den = f->den;
2843
    if (num < 0) {
2844
        f->val += num / den;
2845
        num = num % den;
2846
        if (num < 0) {
2847
            num += den;
2848
            f->val--;
2849
        }
2850
    } else if (num >= den) {
2851
        f->val += num / den;
2852
        num = num % den;
2853
    }
2854
    f->num = num;
2855
}
2856

    
2857
/**
2858
 * register a new image format
2859
 * @param img_fmt Image format descriptor
2860
 */
2861
void av_register_image_format(AVImageFormat *img_fmt)
2862
{
2863
    AVImageFormat **p;
2864

    
2865
    p = &first_image_format;
2866
    while (*p != NULL) p = &(*p)->next;
2867
    *p = img_fmt;
2868
    img_fmt->next = NULL;
2869
}
2870

    
2871
/* guess image format */
2872
AVImageFormat *av_probe_image_format(AVProbeData *pd)
2873
{
2874
    AVImageFormat *fmt1, *fmt;
2875
    int score, score_max;
2876

    
2877
    fmt = NULL;
2878
    score_max = 0;
2879
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2880
        if (fmt1->img_probe) {
2881
            score = fmt1->img_probe(pd);
2882
            if (score > score_max) {
2883
                score_max = score;
2884
                fmt = fmt1;
2885
            }
2886
        }
2887
    }
2888
    return fmt;
2889
}
2890

    
2891
AVImageFormat *guess_image_format(const char *filename)
2892
{
2893
    AVImageFormat *fmt1;
2894

    
2895
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2896
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2897
            return fmt1;
2898
    }
2899
    return NULL;
2900
}
2901

    
2902
/**
2903
 * Read an image from a stream. 
2904
 * @param gb byte stream containing the image
2905
 * @param fmt image format, NULL if probing is required
2906
 */
2907
int av_read_image(ByteIOContext *pb, const char *filename,
2908
                  AVImageFormat *fmt,
2909
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2910
{
2911
    char buf[PROBE_BUF_SIZE];
2912
    AVProbeData probe_data, *pd = &probe_data;
2913
    offset_t pos;
2914
    int ret;
2915

    
2916
    if (!fmt) {
2917
        pd->filename = filename;
2918
        pd->buf = buf;
2919
        pos = url_ftell(pb);
2920
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2921
        url_fseek(pb, pos, SEEK_SET);
2922
        fmt = av_probe_image_format(pd);
2923
    }
2924
    if (!fmt)
2925
        return AVERROR_NOFMT;
2926
    ret = fmt->img_read(pb, alloc_cb, opaque);
2927
    return ret;
2928
}
2929

    
2930
/**
2931
 * Write an image to a stream.
2932
 * @param pb byte stream for the image output
2933
 * @param fmt image format
2934
 * @param img image data and informations
2935
 */
2936
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2937
{
2938
    return fmt->img_write(pb, img);
2939
}
2940