Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 327c4076

History | View | Annotate | Download (85.8 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 != ',' && q-ext1<sizeof(ext1)-1) 
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;
184
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
185
        return AVERROR_NOMEM;        
186
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
187
    if (!data)
188
        return AVERROR_NOMEM;
189
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
190

    
191
    av_init_packet(pkt);
192
    pkt->data = data; 
193
    pkt->size = size;
194
    pkt->destruct = av_destruct_packet;
195
    return 0;
196
}
197

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

    
220
/* fifo handling */
221

    
222
int fifo_init(FifoBuffer *f, int size)
223
{
224
    f->buffer = av_malloc(size);
225
    if (!f->buffer)
226
        return -1;
227
    f->end = f->buffer + size;
228
    f->wptr = f->rptr = f->buffer;
229
    return 0;
230
}
231

    
232
void fifo_free(FifoBuffer *f)
233
{
234
    av_free(f->buffer);
235
}
236

    
237
int fifo_size(FifoBuffer *f, uint8_t *rptr)
238
{
239
    int size;
240
    
241
    if(!rptr)
242
        rptr= f->rptr;
243

    
244
    if (f->wptr >= rptr) {
245
        size = f->wptr - rptr;
246
    } else {
247
        size = (f->end - rptr) + (f->wptr - f->buffer);
248
    }
249
    return size;
250
}
251

    
252
/* get data from the fifo (return -1 if not enough data) */
253
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
254
{
255
    uint8_t *rptr;
256
    int size, len;
257

    
258
    if(!rptr_ptr)
259
        rptr_ptr= &f->rptr;
260
    rptr = *rptr_ptr;
261

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

    
285
void fifo_realloc(FifoBuffer *f, unsigned int new_size){
286
    unsigned int old_size= f->end - f->buffer;
287
    
288
    if(old_size < new_size){
289
        uint8_t *old= f->buffer;
290

    
291
        f->buffer= av_realloc(f->buffer, new_size);
292

    
293
        f->rptr += f->buffer - old;
294
        f->wptr += f->buffer - old;
295

    
296
        if(f->wptr < f->rptr){
297
            memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
298
            f->rptr += new_size - old_size;
299
        }
300
        f->end= f->buffer + new_size;
301
    }
302
}
303

    
304
void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
305
{
306
    int len;
307
    uint8_t *wptr;
308

    
309
    if(!wptr_ptr)
310
        wptr_ptr= &f->wptr;
311
    wptr = *wptr_ptr;
312

    
313
    while (size > 0) {
314
        len = f->end - wptr;
315
        if (len > size)
316
            len = size;
317
        memcpy(wptr, buf, len);
318
        wptr += len;
319
        if (wptr >= f->end)
320
            wptr = f->buffer;
321
        buf += len;
322
        size -= len;
323
    }
324
    *wptr_ptr = wptr;
325
}
326

    
327
/* get data from the fifo (return -1 if not enough data) */
328
int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
329
{
330
    uint8_t *rptr = *rptr_ptr;
331
    int size, len;
332

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

    
355
int filename_number_test(const char *filename)
356
{
357
    char buf[1024];
358
    if(!filename)
359
        return -1;
360
    return get_frame_filename(buf, sizeof(buf), filename, 1);
361
}
362

    
363
/* guess file format */
364
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
365
{
366
    AVInputFormat *fmt1, *fmt;
367
    int score, score_max;
368

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

    
390
/************************************************************/
391
/* input media file */
392

    
393
/**
394
 * open a media file from an IO stream. 'fmt' must be specified.
395
 */
396

    
397
static const char* format_to_name(void* ptr)
398
{
399
    AVFormatContext* fc = (AVFormatContext*) ptr;
400
    if(fc->iformat) return fc->iformat->name;
401
    else if(fc->oformat) return fc->oformat->name;
402
    else return "NULL";
403
}
404

    
405
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
406

    
407
AVFormatContext *av_alloc_format_context(void)
408
{
409
    AVFormatContext *ic;
410
    ic = av_mallocz(sizeof(AVFormatContext));
411
    if (!ic) return ic;
412
    ic->av_class = &av_format_context_class;
413
    return ic;
414
}
415

    
416
int av_open_input_stream(AVFormatContext **ic_ptr, 
417
                         ByteIOContext *pb, const char *filename, 
418
                         AVInputFormat *fmt, AVFormatParameters *ap)
419
{
420
    int err;
421
    AVFormatContext *ic;
422

    
423
    ic = av_alloc_format_context();
424
    if (!ic) {
425
        err = AVERROR_NOMEM;
426
        goto fail;
427
    }
428
    ic->iformat = fmt;
429
    if (pb)
430
        ic->pb = *pb;
431
    ic->duration = AV_NOPTS_VALUE;
432
    ic->start_time = AV_NOPTS_VALUE;
433
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
434

    
435
    /* allocate private data */
436
    if (fmt->priv_data_size > 0) {
437
        ic->priv_data = av_mallocz(fmt->priv_data_size);
438
        if (!ic->priv_data) {
439
            err = AVERROR_NOMEM;
440
            goto fail;
441
        }
442
    } else {
443
        ic->priv_data = NULL;
444
    }
445

    
446
    err = ic->iformat->read_header(ic, ap);
447
    if (err < 0)
448
        goto fail;
449

    
450
    if (pb)
451
        ic->data_offset = url_ftell(&ic->pb);
452

    
453
    *ic_ptr = ic;
454
    return 0;
455
 fail:
456
    if (ic) {
457
        av_freep(&ic->priv_data);
458
    }
459
    av_free(ic);
460
    *ic_ptr = NULL;
461
    return err;
462
}
463

    
464
#define PROBE_BUF_SIZE 2048
465

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

    
494
    if (!fmt) {
495
        /* guess format if no file can be opened  */
496
        fmt = av_probe_input_format(pd, 0);
497
    }
498

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

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

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

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

    
569
/*******************************************************/
570

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

    
584
/**********************************************************/
585

    
586
/* get the number of samples of an audio frame. Return (-1) if error */
587
static int get_audio_frame_size(AVCodecContext *enc, int size)
588
{
589
    int frame_size;
590

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

    
624

    
625
/* return the frame duration in seconds, return 0 if not available */
626
static void compute_frame_duration(int *pnum, int *pden, AVStream *st, 
627
                                   AVCodecParserContext *pc, AVPacket *pkt)
628
{
629
    int frame_size;
630

    
631
    *pnum = 0;
632
    *pden = 0;
633
    switch(st->codec.codec_type) {
634
    case CODEC_TYPE_VIDEO:
635
        if(st->time_base.num*1000 > st->time_base.den){
636
            *pnum = st->time_base.num;
637
            *pden = st->time_base.den;
638
        }else if(st->codec.time_base.num*1000 > st->codec.time_base.den){
639
            *pnum = st->codec.time_base.num;
640
            *pden = st->codec.time_base.den;
641
            if (pc && pc->repeat_pict) {
642
                *pden *= 2;
643
                *pnum = (*pnum) * (2 + pc->repeat_pict);
644
            }
645
        }
646
        break;
647
    case CODEC_TYPE_AUDIO:
648
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
649
        if (frame_size < 0)
650
            break;
651
        *pnum = frame_size;
652
        *pden = st->codec.sample_rate;
653
        break;
654
    default:
655
        break;
656
    }
657
}
658

    
659
static int is_intra_only(AVCodecContext *enc){
660
    if(enc->codec_type == CODEC_TYPE_AUDIO){
661
        return 1;
662
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
663
        switch(enc->codec_id){
664
        case CODEC_ID_MJPEG:
665
        case CODEC_ID_MJPEGB:
666
        case CODEC_ID_LJPEG:
667
        case CODEC_ID_RAWVIDEO:
668
        case CODEC_ID_DVVIDEO:
669
        case CODEC_ID_HUFFYUV:
670
        case CODEC_ID_FFVHUFF:
671
        case CODEC_ID_ASV1:
672
        case CODEC_ID_ASV2:
673
        case CODEC_ID_VCR1:
674
            return 1;
675
        default: break;
676
        }
677
    }
678
    return 0;
679
}
680

    
681
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
682
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
683
    int64_t delta= last_ts - mask/2;
684
    return  ((lsb - delta)&mask) + delta;
685
}
686

    
687
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, 
688
                               AVCodecParserContext *pc, AVPacket *pkt)
689
{
690
    int num, den, presentation_delayed;
691
    /* handle wrapping */
692
    if(st->cur_dts != AV_NOPTS_VALUE){
693
        if(pkt->pts != AV_NOPTS_VALUE)
694
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
695
        if(pkt->dts != AV_NOPTS_VALUE)
696
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
697
    }
698
    
699
    if (pkt->duration == 0) {
700
        compute_frame_duration(&num, &den, st, pc, pkt);
701
        if (den && num) {
702
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
703
        }
704
    }
705

    
706
    if(is_intra_only(&st->codec))
707
        pkt->flags |= PKT_FLAG_KEY;
708

    
709
    /* do we have a video B frame ? */
710
    presentation_delayed = 0;
711
    if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
712
        /* XXX: need has_b_frame, but cannot get it if the codec is
713
           not initialized */
714
        if ((   st->codec.codec_id == CODEC_ID_H264 
715
             || st->codec.has_b_frames) && 
716
            pc && pc->pict_type != FF_B_TYPE)
717
            presentation_delayed = 1;
718
        /* this may be redundant, but it shouldnt hurt */
719
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
720
            presentation_delayed = 1;
721
    }
722
    
723
    if(st->cur_dts == AV_NOPTS_VALUE){
724
        if(presentation_delayed) st->cur_dts = -pkt->duration;
725
        else                     st->cur_dts = 0;
726
    }
727

    
728
//    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);
729
    /* interpolate PTS and DTS if they are not present */
730
    if (presentation_delayed) {
731
        /* DTS = decompression time stamp */
732
        /* PTS = presentation time stamp */
733
        if (pkt->dts == AV_NOPTS_VALUE) {
734
            /* if we know the last pts, use it */
735
            if(st->last_IP_pts != AV_NOPTS_VALUE)
736
                st->cur_dts = pkt->dts = st->last_IP_pts;
737
            else
738
                pkt->dts = st->cur_dts;
739
        } else {
740
            st->cur_dts = pkt->dts;
741
        }
742
        /* this is tricky: the dts must be incremented by the duration
743
           of the frame we are displaying, i.e. the last I or P frame */
744
        if (st->last_IP_duration == 0)
745
            st->cur_dts += pkt->duration;
746
        else
747
            st->cur_dts += st->last_IP_duration;
748
        st->last_IP_duration  = pkt->duration;
749
        st->last_IP_pts= pkt->pts;
750
        /* cannot compute PTS if not present (we can compute it only
751
           by knowing the futur */
752
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
753
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
754
            int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
755
            int64_t new_diff= ABS(st->cur_dts - pkt->pts);
756
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
757
                pkt->pts += pkt->duration;
758
//                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
759
            }
760
        }
761
    
762
        /* presentation is not delayed : PTS and DTS are the same */
763
        if (pkt->pts == AV_NOPTS_VALUE) {
764
            if (pkt->dts == AV_NOPTS_VALUE) {
765
                pkt->pts = st->cur_dts;
766
                pkt->dts = st->cur_dts;
767
            }
768
            else {
769
                st->cur_dts = pkt->dts;
770
                pkt->pts = pkt->dts;
771
            }
772
        } else {
773
            st->cur_dts = pkt->pts;
774
            pkt->dts = pkt->pts;
775
        }
776
        st->cur_dts += pkt->duration;
777
    }
778
//    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);
779
    
780
    /* update flags */
781
    if (pc) {
782
        pkt->flags = 0;
783
        /* key frame computation */
784
        switch(st->codec.codec_type) {
785
        case CODEC_TYPE_VIDEO:
786
            if (pc->pict_type == FF_I_TYPE)
787
                pkt->flags |= PKT_FLAG_KEY;
788
            break;
789
        case CODEC_TYPE_AUDIO:
790
            pkt->flags |= PKT_FLAG_KEY;
791
            break;
792
        default:
793
            break;
794
        }
795
    }
796
}
797

    
798
void av_destruct_packet_nofree(AVPacket *pkt)
799
{
800
    pkt->data = NULL; pkt->size = 0;
801
}
802

    
803
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
804
{
805
    AVStream *st;
806
    int len, ret, i;
807

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

    
869
            s->cur_st = st;
870
            s->cur_ptr = s->cur_pkt.data;
871
            s->cur_len = s->cur_pkt.size;
872
            if (st->need_parsing && !st->parser) {
873
                st->parser = av_parser_init(st->codec.codec_id);
874
                if (!st->parser) {
875
                    /* no parser available : just output the raw packets */
876
                    st->need_parsing = 0;
877
                }
878
            }
879
        }
880
    }
881
}
882

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

    
904
    pktl = s->packet_buffer;
905
    if (pktl) {
906
        /* read packet from packet buffer, if there is data */
907
        *pkt = pktl->pkt;
908
        s->packet_buffer = pktl->next;
909
        av_free(pktl);
910
        return 0;
911
    } else {
912
        return av_read_frame_internal(s, pkt);
913
    }
914
}
915

    
916
/* XXX: suppress the packet queue */
917
static void flush_packet_queue(AVFormatContext *s)
918
{
919
    AVPacketList *pktl;
920

    
921
    for(;;) {
922
        pktl = s->packet_buffer;
923
        if (!pktl) 
924
            break;
925
        s->packet_buffer = pktl->next;
926
        av_free_packet(&pktl->pkt);
927
        av_free(pktl);
928
    }
929
}
930

    
931
/*******************************************************/
932
/* seek support */
933

    
934
int av_find_default_stream_index(AVFormatContext *s)
935
{
936
    int i;
937
    AVStream *st;
938

    
939
    if (s->nb_streams <= 0)
940
        return -1;
941
    for(i = 0; i < s->nb_streams; i++) {
942
        st = s->streams[i];
943
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
944
            return i;
945
        }
946
    }
947
    return 0;
948
}
949

    
950
/* flush the frame reader */
951
static void av_read_frame_flush(AVFormatContext *s)
952
{
953
    AVStream *st;
954
    int i;
955

    
956
    flush_packet_queue(s);
957

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

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

    
991
    for(i = 0; i < s->nb_streams; i++) {
992
        AVStream *st = s->streams[i];
993

    
994
        st->cur_dts = av_rescale(timestamp, 
995
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
996
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
997
    }
998
}
999

    
1000
/**
1001
 * add a index entry into a sorted list updateing if it is already there.
1002
 * @param timestamp timestamp in the timebase of the given stream
1003
 */
1004
int av_add_index_entry(AVStream *st,
1005
                            int64_t pos, int64_t timestamp, int distance, int flags)
1006
{
1007
    AVIndexEntry *entries, *ie;
1008
    int index;
1009
    
1010
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1011
        return -1;
1012
    
1013
    entries = av_fast_realloc(st->index_entries,
1014
                              &st->index_entries_allocated_size,
1015
                              (st->nb_index_entries + 1) * 
1016
                              sizeof(AVIndexEntry));
1017
    if(!entries)
1018
        return -1;
1019

    
1020
    st->index_entries= entries;
1021

    
1022
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1023

    
1024
    if(index<0){
1025
        index= st->nb_index_entries++;
1026
        ie= &entries[index];
1027
        assert(index==0 || ie[-1].timestamp < timestamp);
1028
    }else{
1029
        ie= &entries[index];
1030
        if(ie->timestamp != timestamp){
1031
            if(ie->timestamp <= timestamp)
1032
                return -1;
1033
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1034
            st->nb_index_entries++;
1035
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1036
            distance= ie->min_distance;
1037
    }
1038

    
1039
    ie->pos = pos;
1040
    ie->timestamp = timestamp;
1041
    ie->min_distance= distance;
1042
    ie->flags = flags;
1043
    
1044
    return index;
1045
}
1046

    
1047
/* build an index for raw streams using a parser */
1048
static void av_build_index_raw(AVFormatContext *s)
1049
{
1050
    AVPacket pkt1, *pkt = &pkt1;
1051
    int ret;
1052
    AVStream *st;
1053

    
1054
    st = s->streams[0];
1055
    av_read_frame_flush(s);
1056
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1057

    
1058
    for(;;) {
1059
        ret = av_read_frame(s, pkt);
1060
        if (ret < 0)
1061
            break;
1062
        if (pkt->stream_index == 0 && st->parser &&
1063
            (pkt->flags & PKT_FLAG_KEY)) {
1064
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts, 
1065
                            0, AVINDEX_KEYFRAME);
1066
        }
1067
        av_free_packet(pkt);
1068
    }
1069
}
1070

    
1071
/* return TRUE if we deal with a raw stream (raw codec data and
1072
   parsing needed) */
1073
static int is_raw_stream(AVFormatContext *s)
1074
{
1075
    AVStream *st;
1076

    
1077
    if (s->nb_streams != 1)
1078
        return 0;
1079
    st = s->streams[0];
1080
    if (!st->need_parsing)
1081
        return 0;
1082
    return 1;
1083
}
1084

    
1085
/**
1086
 * gets the index for a specific timestamp.
1087
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to 
1088
 *                 the timestamp which is <= the requested one, if backward is 0 
1089
 *                 then it will be >=
1090
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1091
 * @return < 0 if no such timestamp could be found
1092
 */
1093
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1094
                              int flags)
1095
{
1096
    AVIndexEntry *entries= st->index_entries;
1097
    int nb_entries= st->nb_index_entries;
1098
    int a, b, m;
1099
    int64_t timestamp;
1100

    
1101
    a = - 1;
1102
    b = nb_entries;
1103

    
1104
    while (b - a > 1) {
1105
        m = (a + b) >> 1;
1106
        timestamp = entries[m].timestamp;
1107
        if(timestamp >= wanted_timestamp)
1108
            b = m;
1109
        if(timestamp <= wanted_timestamp)
1110
            a = m;
1111
    }
1112
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1113
    
1114
    if(!(flags & AVSEEK_FLAG_ANY)){
1115
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1116
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1117
        }
1118
    }
1119

    
1120
    if(m == nb_entries) 
1121
        return -1;
1122
    return  m;
1123
}
1124

    
1125
#define DEBUG_SEEK
1126

    
1127
/**
1128
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1129
 * this isnt supposed to be called directly by a user application, but by demuxers
1130
 * @param target_ts target timestamp in the time base of the given stream
1131
 * @param stream_index stream number
1132
 */
1133
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1134
    AVInputFormat *avif= s->iformat;
1135
    int64_t pos_min, pos_max, pos, pos_limit;
1136
    int64_t ts_min, ts_max, ts;
1137
    int64_t start_pos;
1138
    int index, no_change;
1139
    AVStream *st;
1140

    
1141
    if (stream_index < 0)
1142
        return -1;
1143
    
1144
#ifdef DEBUG_SEEK
1145
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
1146
#endif
1147

    
1148
    ts_max=
1149
    ts_min= AV_NOPTS_VALUE;
1150
    pos_limit= -1; //gcc falsely says it may be uninitalized
1151

    
1152
    st= s->streams[stream_index];
1153
    if(st->index_entries){
1154
        AVIndexEntry *e;
1155

    
1156
        index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non keyframe entries in index case, especially read_timestamp()
1157
        index= FFMAX(index, 0);
1158
        e= &st->index_entries[index];
1159

    
1160
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1161
            pos_min= e->pos;
1162
            ts_min= e->timestamp;
1163
#ifdef DEBUG_SEEK
1164
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%llx dts_min=%lld\n", 
1165
               pos_min,ts_min);
1166
#endif
1167
        }else{
1168
            assert(index==0);
1169
        }
1170
        
1171
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD); 
1172
        assert(index < st->nb_index_entries);
1173
        if(index >= 0){
1174
            e= &st->index_entries[index];
1175
            assert(e->timestamp >= target_ts);
1176
            pos_max= e->pos;
1177
            ts_max= e->timestamp;
1178
            pos_limit= pos_max - e->min_distance;
1179
#ifdef DEBUG_SEEK
1180
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n", 
1181
               pos_max,pos_limit, ts_max);
1182
#endif
1183
        }
1184
    }
1185

    
1186
    if(ts_min == AV_NOPTS_VALUE){
1187
        pos_min = s->data_offset;
1188
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1189
        if (ts_min == AV_NOPTS_VALUE)
1190
            return -1;
1191
    }
1192

    
1193
    if(ts_max == AV_NOPTS_VALUE){
1194
        int step= 1024;
1195
        pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1196
        do{
1197
            pos_max -= step;
1198
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1199
            step += step;
1200
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1201
        if (ts_max == AV_NOPTS_VALUE)
1202
            return -1;
1203
        
1204
        for(;;){
1205
            int64_t tmp_pos= pos_max + 1;
1206
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1207
            if(tmp_ts == AV_NOPTS_VALUE)
1208
                break;
1209
            ts_max= tmp_ts;
1210
            pos_max= tmp_pos;
1211
        }
1212
        pos_limit= pos_max;
1213
    }
1214

    
1215
    no_change=0;
1216
    while (pos_min < pos_limit) {
1217
#ifdef DEBUG_SEEK
1218
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n", 
1219
               pos_min, pos_max,
1220
               ts_min, ts_max);
1221
#endif
1222
        assert(pos_limit <= pos_max);
1223

    
1224
        if(no_change==0){
1225
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1226
            // interpolate position (better than dichotomy)
1227
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1228
                + pos_min - approximate_keyframe_distance;
1229
        }else if(no_change==1){
1230
            // bisection, if interpolation failed to change min or max pos last time
1231
            pos = (pos_min + pos_limit)>>1;
1232
        }else{
1233
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1234
            pos=pos_min;
1235
        }
1236
        if(pos <= pos_min)
1237
            pos= pos_min + 1;
1238
        else if(pos > pos_limit)
1239
            pos= pos_limit;
1240
        start_pos= pos;
1241

    
1242
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1243
        if(pos == pos_max)
1244
            no_change++;
1245
        else
1246
            no_change=0;
1247
#ifdef DEBUG_SEEK
1248
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);
1249
#endif
1250
        assert(ts != AV_NOPTS_VALUE);
1251
        if (target_ts <= ts) {
1252
            pos_limit = start_pos - 1;
1253
            pos_max = pos;
1254
            ts_max = ts;
1255
        }
1256
        if (target_ts >= ts) {
1257
            pos_min = pos;
1258
            ts_min = ts;
1259
        }
1260
    }
1261
    
1262
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1263
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1264
#ifdef DEBUG_SEEK
1265
    pos_min = pos;
1266
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1267
    pos_min++;
1268
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1269
    av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n", 
1270
           pos, ts_min, target_ts, ts_max);
1271
#endif
1272
    /* do the seek */
1273
    url_fseek(&s->pb, pos, SEEK_SET);
1274

    
1275
    av_update_cur_dts(s, st, ts);
1276

    
1277
    return 0;
1278
}
1279

    
1280
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1281
    int64_t pos_min, pos_max;
1282
#if 0
1283
    AVStream *st;
1284

1285
    if (stream_index < 0)
1286
        return -1;
1287

1288
    st= s->streams[stream_index];
1289
#endif
1290

    
1291
    pos_min = s->data_offset;
1292
    pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1293

    
1294
    if     (pos < pos_min) pos= pos_min;
1295
    else if(pos > pos_max) pos= pos_max;
1296

    
1297
    url_fseek(&s->pb, pos, SEEK_SET);
1298

    
1299
#if 0
1300
    av_update_cur_dts(s, st, ts);
1301
#endif
1302
    return 0;
1303
}
1304

    
1305
static int av_seek_frame_generic(AVFormatContext *s, 
1306
                                 int stream_index, int64_t timestamp, int flags)
1307
{
1308
    int index;
1309
    AVStream *st;
1310
    AVIndexEntry *ie;
1311

    
1312
    if (!s->index_built) {
1313
        if (is_raw_stream(s)) {
1314
            av_build_index_raw(s);
1315
        } else {
1316
            return -1;
1317
        }
1318
        s->index_built = 1;
1319
    }
1320

    
1321
    st = s->streams[stream_index];
1322
    index = av_index_search_timestamp(st, timestamp, flags);
1323
    if (index < 0)
1324
        return -1;
1325

    
1326
    /* now we have found the index, we can seek */
1327
    ie = &st->index_entries[index];
1328
    av_read_frame_flush(s);
1329
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1330

    
1331
    av_update_cur_dts(s, st, ie->timestamp);
1332

    
1333
    return 0;
1334
}
1335

    
1336
/**
1337
 * Seek to the key frame at timestamp.
1338
 * 'timestamp' in 'stream_index'.
1339
 * @param stream_index If stream_index is (-1), a default
1340
 * stream is selected, and timestamp is automatically converted 
1341
 * from AV_TIME_BASE units to the stream specific time_base.
1342
 * @param timestamp timestamp in AVStream.time_base units
1343
 * @param flags flags which select direction and seeking mode
1344
 * @return >= 0 on success
1345
 */
1346
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1347
{
1348
    int ret;
1349
    AVStream *st;
1350
    
1351
    av_read_frame_flush(s);
1352
    
1353
    if(flags & AVSEEK_FLAG_BYTE)
1354
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1355
    
1356
    if(stream_index < 0){
1357
        stream_index= av_find_default_stream_index(s);
1358
        if(stream_index < 0)
1359
            return -1;
1360
            
1361
        st= s->streams[stream_index];
1362
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1363
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1364
    }
1365
    st= s->streams[stream_index];
1366

    
1367
    /* first, we try the format specific seek */
1368
    if (s->iformat->read_seek)
1369
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1370
    else
1371
        ret = -1;
1372
    if (ret >= 0) {
1373
        return 0;
1374
    }
1375

    
1376
    if(s->iformat->read_timestamp)
1377
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1378
    else
1379
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1380
}
1381

    
1382
/*******************************************************/
1383

    
1384
/* return TRUE if the stream has accurate timings for at least one component */
1385
static int av_has_timings(AVFormatContext *ic)
1386
{
1387
    int i;
1388
    AVStream *st;
1389

    
1390
    for(i = 0;i < ic->nb_streams; i++) {
1391
        st = ic->streams[i];
1392
        if (st->start_time != AV_NOPTS_VALUE &&
1393
            st->duration != AV_NOPTS_VALUE)
1394
            return 1;
1395
    }
1396
    return 0;
1397
}
1398

    
1399
/* estimate the stream timings from the one of each components. Also
1400
   compute the global bitrate if possible */
1401
static void av_update_stream_timings(AVFormatContext *ic)
1402
{
1403
    int64_t start_time, start_time1, end_time, end_time1;
1404
    int i;
1405
    AVStream *st;
1406

    
1407
    start_time = MAXINT64;
1408
    end_time = MININT64;
1409
    for(i = 0;i < ic->nb_streams; i++) {
1410
        st = ic->streams[i];
1411
        if (st->start_time != AV_NOPTS_VALUE) {
1412
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1413
            if (start_time1 < start_time)
1414
                start_time = start_time1;
1415
            if (st->duration != AV_NOPTS_VALUE) {
1416
                end_time1 = start_time1
1417
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1418
                if (end_time1 > end_time)
1419
                    end_time = end_time1;
1420
            }
1421
        }
1422
    }
1423
    if (start_time != MAXINT64) {
1424
        ic->start_time = start_time;
1425
        if (end_time != MAXINT64) {
1426
            ic->duration = end_time - start_time;
1427
            if (ic->file_size > 0) {
1428
                /* compute the bit rate */
1429
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1430
                    (double)ic->duration;
1431
            }
1432
        }
1433
    }
1434

    
1435
}
1436

    
1437
static void fill_all_stream_timings(AVFormatContext *ic)
1438
{
1439
    int i;
1440
    AVStream *st;
1441

    
1442
    av_update_stream_timings(ic);
1443
    for(i = 0;i < ic->nb_streams; i++) {
1444
        st = ic->streams[i];
1445
        if (st->start_time == AV_NOPTS_VALUE) {
1446
            if(ic->start_time != AV_NOPTS_VALUE)
1447
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1448
            if(ic->duration != AV_NOPTS_VALUE)
1449
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1450
        }
1451
    }
1452
}
1453

    
1454
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1455
{
1456
    int64_t filesize, duration;
1457
    int bit_rate, i;
1458
    AVStream *st;
1459

    
1460
    /* if bit_rate is already set, we believe it */
1461
    if (ic->bit_rate == 0) {
1462
        bit_rate = 0;
1463
        for(i=0;i<ic->nb_streams;i++) {
1464
            st = ic->streams[i];
1465
            bit_rate += st->codec.bit_rate;
1466
        }
1467
        ic->bit_rate = bit_rate;
1468
    }
1469

    
1470
    /* if duration is already set, we believe it */
1471
    if (ic->duration == AV_NOPTS_VALUE && 
1472
        ic->bit_rate != 0 && 
1473
        ic->file_size != 0)  {
1474
        filesize = ic->file_size;
1475
        if (filesize > 0) {
1476
            for(i = 0; i < ic->nb_streams; i++) {
1477
                st = ic->streams[i];
1478
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1479
                if (st->start_time == AV_NOPTS_VALUE ||
1480
                    st->duration == AV_NOPTS_VALUE) {
1481
                    st->start_time = 0;
1482
                    st->duration = duration;
1483
                }
1484
            }
1485
        }
1486
    }
1487
}
1488

    
1489
#define DURATION_MAX_READ_SIZE 250000
1490

    
1491
/* only usable for MPEG-PS streams */
1492
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1493
{
1494
    AVPacket pkt1, *pkt = &pkt1;
1495
    AVStream *st;
1496
    int read_size, i, ret;
1497
    int64_t start_time, end_time, end_time1;
1498
    int64_t filesize, offset, duration;
1499
    
1500
    /* free previous packet */
1501
    if (ic->cur_st && ic->cur_st->parser)
1502
        av_free_packet(&ic->cur_pkt); 
1503
    ic->cur_st = NULL;
1504

    
1505
    /* flush packet queue */
1506
    flush_packet_queue(ic);
1507

    
1508
    for(i=0;i<ic->nb_streams;i++) {
1509
        st = ic->streams[i];
1510
        if (st->parser) {
1511
            av_parser_close(st->parser);
1512
            st->parser= NULL;
1513
        }
1514
    }
1515
    
1516
    /* we read the first packets to get the first PTS (not fully
1517
       accurate, but it is enough now) */
1518
    url_fseek(&ic->pb, 0, SEEK_SET);
1519
    read_size = 0;
1520
    for(;;) {
1521
        if (read_size >= DURATION_MAX_READ_SIZE)
1522
            break;
1523
        /* if all info is available, we can stop */
1524
        for(i = 0;i < ic->nb_streams; i++) {
1525
            st = ic->streams[i];
1526
            if (st->start_time == AV_NOPTS_VALUE)
1527
                break;
1528
        }
1529
        if (i == ic->nb_streams)
1530
            break;
1531

    
1532
        ret = av_read_packet(ic, pkt);
1533
        if (ret != 0)
1534
            break;
1535
        read_size += pkt->size;
1536
        st = ic->streams[pkt->stream_index];
1537
        if (pkt->pts != AV_NOPTS_VALUE) {
1538
            if (st->start_time == AV_NOPTS_VALUE)
1539
                st->start_time = pkt->pts;
1540
        }
1541
        av_free_packet(pkt);
1542
    }
1543

    
1544
    /* estimate the end time (duration) */
1545
    /* XXX: may need to support wrapping */
1546
    filesize = ic->file_size;
1547
    offset = filesize - DURATION_MAX_READ_SIZE;
1548
    if (offset < 0)
1549
        offset = 0;
1550

    
1551
    url_fseek(&ic->pb, offset, SEEK_SET);
1552
    read_size = 0;
1553
    for(;;) {
1554
        if (read_size >= DURATION_MAX_READ_SIZE)
1555
            break;
1556
        /* if all info is available, we can stop */
1557
        for(i = 0;i < ic->nb_streams; i++) {
1558
            st = ic->streams[i];
1559
            if (st->duration == AV_NOPTS_VALUE)
1560
                break;
1561
        }
1562
        if (i == ic->nb_streams)
1563
            break;
1564
        
1565
        ret = av_read_packet(ic, pkt);
1566
        if (ret != 0)
1567
            break;
1568
        read_size += pkt->size;
1569
        st = ic->streams[pkt->stream_index];
1570
        if (pkt->pts != AV_NOPTS_VALUE) {
1571
            end_time = pkt->pts;
1572
            duration = end_time - st->start_time;
1573
            if (duration > 0) {
1574
                if (st->duration == AV_NOPTS_VALUE ||
1575
                    st->duration < duration)
1576
                    st->duration = duration;
1577
            }
1578
        }
1579
        av_free_packet(pkt);
1580
    }
1581
    
1582
    fill_all_stream_timings(ic);
1583

    
1584
    url_fseek(&ic->pb, 0, SEEK_SET);
1585
}
1586

    
1587
static void av_estimate_timings(AVFormatContext *ic)
1588
{
1589
    URLContext *h;
1590
    int64_t file_size;
1591

    
1592
    /* get the file size, if possible */
1593
    if (ic->iformat->flags & AVFMT_NOFILE) {
1594
        file_size = 0;
1595
    } else {
1596
        h = url_fileno(&ic->pb);
1597
        file_size = url_filesize(h);
1598
        if (file_size < 0)
1599
            file_size = 0;
1600
    }
1601
    ic->file_size = file_size;
1602

    
1603
    if ((ic->iformat == &mpegps_demux || ic->iformat == &mpegts_demux) && file_size && !ic->pb.is_streamed) {
1604
        /* get accurate estimate from the PTSes */
1605
        av_estimate_timings_from_pts(ic);
1606
    } else if (av_has_timings(ic)) {
1607
        /* at least one components has timings - we use them for all
1608
           the components */
1609
        fill_all_stream_timings(ic);
1610
    } else {
1611
        /* less precise: use bit rate info */
1612
        av_estimate_timings_from_bit_rate(ic);
1613
    }
1614
    av_update_stream_timings(ic);
1615

    
1616
#if 0
1617
    {
1618
        int i;
1619
        AVStream *st;
1620
        for(i = 0;i < ic->nb_streams; i++) {
1621
            st = ic->streams[i];
1622
        printf("%d: start_time: %0.3f duration: %0.3f\n", 
1623
               i, (double)st->start_time / AV_TIME_BASE, 
1624
               (double)st->duration / AV_TIME_BASE);
1625
        }
1626
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1627
               (double)ic->start_time / AV_TIME_BASE, 
1628
               (double)ic->duration / AV_TIME_BASE,
1629
               ic->bit_rate / 1000);
1630
    }
1631
#endif
1632
}
1633

    
1634
static int has_codec_parameters(AVCodecContext *enc)
1635
{
1636
    int val;
1637
    switch(enc->codec_type) {
1638
    case CODEC_TYPE_AUDIO:
1639
        val = enc->sample_rate;
1640
        break;
1641
    case CODEC_TYPE_VIDEO:
1642
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1643
        break;
1644
    default:
1645
        val = 1;
1646
        break;
1647
    }
1648
    return (val != 0);
1649
}
1650

    
1651
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1652
{
1653
    int16_t *samples;
1654
    AVCodec *codec;
1655
    int got_picture, ret;
1656
    AVFrame picture;
1657
    
1658
    codec = avcodec_find_decoder(st->codec.codec_id);
1659
    if (!codec)
1660
        return -1;
1661
    ret = avcodec_open(&st->codec, codec);
1662
    if (ret < 0)
1663
        return ret;
1664

    
1665
  if(!has_codec_parameters(&st->codec)){
1666
    switch(st->codec.codec_type) {
1667
    case CODEC_TYPE_VIDEO:
1668
        ret = avcodec_decode_video(&st->codec, &picture, 
1669
                                   &got_picture, (uint8_t *)data, size);
1670
        break;
1671
    case CODEC_TYPE_AUDIO:
1672
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1673
        if (!samples)
1674
            goto fail;
1675
        ret = avcodec_decode_audio(&st->codec, samples, 
1676
                                   &got_picture, (uint8_t *)data, size);
1677
        av_free(samples);
1678
        break;
1679
    default:
1680
        break;
1681
    }
1682
  }
1683
 fail:
1684
    avcodec_close(&st->codec);
1685
    return ret;
1686
}
1687

    
1688
/* absolute maximum size we read until we abort */
1689
#define MAX_READ_SIZE        5000000
1690

    
1691
/* maximum duration until we stop analysing the stream */
1692
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1693

    
1694
/**
1695
 * Read the beginning of a media file to get stream information. This
1696
 * is useful for file formats with no headers such as MPEG. This
1697
 * function also compute the real frame rate in case of mpeg2 repeat
1698
 * frame mode.
1699
 *
1700
 * @param ic media file handle
1701
 * @return >=0 if OK. AVERROR_xxx if error.  
1702
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1703
 */
1704
int av_find_stream_info(AVFormatContext *ic)
1705
{
1706
    int i, count, ret, read_size;
1707
    AVStream *st;
1708
    AVPacket pkt1, *pkt;
1709
    AVPacketList *pktl=NULL, **ppktl;
1710
    int64_t last_dts[MAX_STREAMS];
1711
    int64_t best_duration[MAX_STREAMS];
1712

    
1713
    for(i=0;i<ic->nb_streams;i++) {
1714
        st = ic->streams[i];
1715
        if(st->codec.codec_type == CODEC_TYPE_VIDEO){
1716
/*            if(!st->time_base.num)
1717
                st->time_base= */
1718
            if(!st->codec.time_base.num)
1719
                st->codec.time_base= st->time_base;
1720
        }
1721
    }
1722

    
1723
    for(i=0;i<MAX_STREAMS;i++){
1724
        last_dts[i]= AV_NOPTS_VALUE;
1725
        best_duration[i]= INT64_MAX;
1726
    }
1727
    
1728
    count = 0;
1729
    read_size = 0;
1730
    ppktl = &ic->packet_buffer;
1731
    for(;;) {
1732
        /* check if one codec still needs to be handled */
1733
        for(i=0;i<ic->nb_streams;i++) {
1734
            st = ic->streams[i];
1735
            if (!has_codec_parameters(&st->codec))
1736
                break;
1737
            /* variable fps and no guess at the real fps */
1738
            if(   st->codec.time_base.den >= 1000LL*st->codec.time_base.num
1739
               && best_duration[i]== INT64_MAX && st->codec.codec_type == CODEC_TYPE_VIDEO)
1740
                break;
1741
        }
1742
        if (i == ic->nb_streams) {
1743
            /* NOTE: if the format has no header, then we need to read
1744
               some packets to get most of the streams, so we cannot
1745
               stop here */
1746
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1747
                /* if we found the info for all the codecs, we can stop */
1748
                ret = count;
1749
                break;
1750
            }
1751
        } else {
1752
            /* we did not get all the codec info, but we read too much data */
1753
            if (read_size >= MAX_READ_SIZE) {
1754
                ret = count;
1755
                break;
1756
            }
1757
        }
1758

    
1759
        /* NOTE: a new stream can be added there if no header in file
1760
           (AVFMTCTX_NOHEADER) */
1761
        ret = av_read_frame_internal(ic, &pkt1);
1762
        if (ret < 0) {
1763
            /* EOF or error */
1764
            ret = -1; /* we could not have all the codec parameters before EOF */
1765
            for(i=0;i<ic->nb_streams;i++) {
1766
                st = ic->streams[i];
1767
                if (!has_codec_parameters(&st->codec))
1768
                    break;
1769
            }
1770
            if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1771
                i == ic->nb_streams)
1772
                ret = 0;
1773
            break;
1774
        }
1775

    
1776
        pktl = av_mallocz(sizeof(AVPacketList));
1777
        if (!pktl) {
1778
            ret = AVERROR_NOMEM;
1779
            break;
1780
        }
1781

    
1782
        /* add the packet in the buffered packet list */
1783
        *ppktl = pktl;
1784
        ppktl = &pktl->next;
1785

    
1786
        pkt = &pktl->pkt;
1787
        *pkt = pkt1;
1788
        
1789
        /* duplicate the packet */
1790
        if (av_dup_packet(pkt) < 0) {
1791
                ret = AVERROR_NOMEM;
1792
                break;
1793
        }
1794

    
1795
        read_size += pkt->size;
1796

    
1797
        st = ic->streams[pkt->stream_index];
1798
        st->codec_info_duration += pkt->duration;
1799
        if (pkt->duration != 0)
1800
            st->codec_info_nb_frames++;
1801

    
1802
        if(st->codec.codec_type == CODEC_TYPE_VIDEO){
1803
            int64_t last= last_dts[pkt->stream_index];
1804
            
1805
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && last < pkt->dts && 
1806
               best_duration[pkt->stream_index] > pkt->dts - last){
1807
                best_duration[pkt->stream_index] = pkt->dts - last;
1808
            }
1809
            last_dts[pkt->stream_index]= pkt->dts;
1810
        }
1811
        /* if still no information, we try to open the codec and to
1812
           decompress the frame. We try to avoid that in most cases as
1813
           it takes longer and uses more memory. For MPEG4, we need to
1814
           decompress for Quicktime. */
1815
        if (!has_codec_parameters(&st->codec) /*&&
1816
            (st->codec.codec_id == CODEC_ID_FLV1 ||
1817
             st->codec.codec_id == CODEC_ID_H264 ||
1818
             st->codec.codec_id == CODEC_ID_H263 ||
1819
             st->codec.codec_id == CODEC_ID_H261 ||
1820
             st->codec.codec_id == CODEC_ID_VORBIS ||
1821
             st->codec.codec_id == CODEC_ID_MJPEG ||
1822
             st->codec.codec_id == CODEC_ID_PNG ||
1823
             st->codec.codec_id == CODEC_ID_PAM ||
1824
             st->codec.codec_id == CODEC_ID_PGM ||
1825
             st->codec.codec_id == CODEC_ID_PGMYUV ||
1826
             st->codec.codec_id == CODEC_ID_PBM ||
1827
             st->codec.codec_id == CODEC_ID_PPM ||
1828
             st->codec.codec_id == CODEC_ID_SHORTEN ||
1829
             (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1830
            try_decode_frame(st, pkt->data, pkt->size);
1831
        
1832
        if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1833
            break;
1834
        }
1835
        count++;
1836
    }
1837

    
1838
    for(i=0;i<ic->nb_streams;i++) {
1839
        st = ic->streams[i];
1840
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1841
            if(st->codec.codec_id == CODEC_ID_RAWVIDEO && !st->codec.codec_tag && !st->codec.bits_per_sample)
1842
                st->codec.codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec.pix_fmt);
1843

    
1844
            if(best_duration[i] < INT64_MAX && st->codec.time_base.num*1000 <= st->codec.time_base.den){
1845
                int int_fps;
1846

    
1847
                st->r_frame_rate.num= st->time_base.den;
1848
                st->r_frame_rate.den= st->time_base.num*best_duration[i];
1849
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->r_frame_rate.num, st->r_frame_rate.den, 1<<15);
1850
                
1851
                int_fps= av_rescale(st->r_frame_rate.num, 1, st->r_frame_rate.den); // 1/0
1852
                
1853
                if(int_fps>0 && av_rescale(st->r_frame_rate.num, 1, int_fps) == st->r_frame_rate.den){
1854
                    st->r_frame_rate.num= int_fps;
1855
                    st->r_frame_rate.den= 1;
1856
                }               
1857
            }
1858

    
1859
            /* set real frame rate info */
1860
            /* compute the real frame rate for telecine */
1861
            if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1862
                 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1863
                st->codec.sub_id == 2) {
1864
                if (st->codec_info_nb_frames >= 20) {
1865
                    float coded_frame_rate, est_frame_rate;
1866
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1867
                        (double)st->codec_info_duration ;
1868
                    coded_frame_rate = 1.0/av_q2d(st->codec.time_base);
1869
#if 0
1870
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1871
                           coded_frame_rate, est_frame_rate);
1872
#endif
1873
                    /* if we detect that it could be a telecine, we
1874
                       signal it. It would be better to do it at a
1875
                       higher level as it can change in a film */
1876
                    if (coded_frame_rate >= 24.97 && 
1877
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1878
                        st->r_frame_rate = (AVRational){24000, 1001};
1879
                    }
1880
                }
1881
            }
1882
            /* if no real frame rate, use the codec one */
1883
            if (!st->r_frame_rate.num){
1884
                st->r_frame_rate.num = st->codec.time_base.den;
1885
                st->r_frame_rate.den = st->codec.time_base.num;
1886
            }
1887
        }
1888
    }
1889

    
1890
    av_estimate_timings(ic);
1891
#if 0
1892
    /* correct DTS for b frame streams with no timestamps */
1893
    for(i=0;i<ic->nb_streams;i++) {
1894
        st = ic->streams[i];
1895
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1896
            if(b-frames){
1897
                ppktl = &ic->packet_buffer;
1898
                while(ppkt1){
1899
                    if(ppkt1->stream_index != i)
1900
                        continue;
1901
                    if(ppkt1->pkt->dts < 0)
1902
                        break;
1903
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1904
                        break;
1905
                    ppkt1->pkt->dts -= delta;
1906
                    ppkt1= ppkt1->next;
1907
                }
1908
                if(ppkt1)
1909
                    continue;
1910
                st->cur_dts -= delta;
1911
            }
1912
        }
1913
    }
1914
#endif
1915
    return ret;
1916
}
1917

    
1918
/*******************************************************/
1919

    
1920
/**
1921
 * start playing a network based stream (e.g. RTSP stream) at the
1922
 * current position 
1923
 */
1924
int av_read_play(AVFormatContext *s)
1925
{
1926
    if (!s->iformat->read_play)
1927
        return AVERROR_NOTSUPP;
1928
    return s->iformat->read_play(s);
1929
}
1930

    
1931
/**
1932
 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1933
 * to resume it.
1934
 */
1935
int av_read_pause(AVFormatContext *s)
1936
{
1937
    if (!s->iformat->read_pause)
1938
        return AVERROR_NOTSUPP;
1939
    return s->iformat->read_pause(s);
1940
}
1941

    
1942
/**
1943
 * Close a media file (but not its codecs)
1944
 *
1945
 * @param s media file handle
1946
 */
1947
void av_close_input_file(AVFormatContext *s)
1948
{
1949
    int i, must_open_file;
1950
    AVStream *st;
1951

    
1952
    /* free previous packet */
1953
    if (s->cur_st && s->cur_st->parser)
1954
        av_free_packet(&s->cur_pkt); 
1955

    
1956
    if (s->iformat->read_close)
1957
        s->iformat->read_close(s);
1958
    for(i=0;i<s->nb_streams;i++) {
1959
        /* free all data in a stream component */
1960
        st = s->streams[i];
1961
        if (st->parser) {
1962
            av_parser_close(st->parser);
1963
        }
1964
        av_free(st->index_entries);
1965
        av_free(st);
1966
    }
1967
    flush_packet_queue(s);
1968
    must_open_file = 1;
1969
    if (s->iformat->flags & AVFMT_NOFILE) {
1970
        must_open_file = 0;
1971
    }
1972
    if (must_open_file) {
1973
        url_fclose(&s->pb);
1974
    }
1975
    av_freep(&s->priv_data);
1976
    av_free(s);
1977
}
1978

    
1979
/**
1980
 * Add a new stream to a media file. Can only be called in the
1981
 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1982
 * format context, then new streams can be added in read_packet too.
1983
 *
1984
 *
1985
 * @param s media file handle
1986
 * @param id file format dependent stream id 
1987
 */
1988
AVStream *av_new_stream(AVFormatContext *s, int id)
1989
{
1990
    AVStream *st;
1991

    
1992
    if (s->nb_streams >= MAX_STREAMS)
1993
        return NULL;
1994

    
1995
    st = av_mallocz(sizeof(AVStream));
1996
    if (!st)
1997
        return NULL;
1998
    avcodec_get_context_defaults(&st->codec);
1999
    if (s->iformat) {
2000
        /* no default bitrate if decoding */
2001
        st->codec.bit_rate = 0;
2002
    }
2003
    st->index = s->nb_streams;
2004
    st->id = id;
2005
    st->start_time = AV_NOPTS_VALUE;
2006
    st->duration = AV_NOPTS_VALUE;
2007
    st->cur_dts = AV_NOPTS_VALUE;
2008

    
2009
    /* default pts settings is MPEG like */
2010
    av_set_pts_info(st, 33, 1, 90000);
2011
    st->last_IP_pts = AV_NOPTS_VALUE;
2012

    
2013
    s->streams[s->nb_streams++] = st;
2014
    return st;
2015
}
2016

    
2017
/************************************************************/
2018
/* output media file */
2019

    
2020
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2021
{
2022
    int ret;
2023
    
2024
    if (s->oformat->priv_data_size > 0) {
2025
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2026
        if (!s->priv_data)
2027
            return AVERROR_NOMEM;
2028
    } else
2029
        s->priv_data = NULL;
2030
        
2031
    if (s->oformat->set_parameters) {
2032
        ret = s->oformat->set_parameters(s, ap);
2033
        if (ret < 0)
2034
            return ret;
2035
    }
2036
    return 0;
2037
}
2038

    
2039
/**
2040
 * allocate the stream private data and write the stream header to an
2041
 * output media file
2042
 *
2043
 * @param s media file handle
2044
 * @return 0 if OK. AVERROR_xxx if error.  
2045
 */
2046
int av_write_header(AVFormatContext *s)
2047
{
2048
    int ret, i;
2049
    AVStream *st;
2050

    
2051
    ret = s->oformat->write_header(s);
2052
    if (ret < 0)
2053
        return ret;
2054

    
2055
    /* init PTS generation */
2056
    for(i=0;i<s->nb_streams;i++) {
2057
        st = s->streams[i];
2058

    
2059
        switch (st->codec.codec_type) {
2060
        case CODEC_TYPE_AUDIO:
2061
            av_frac_init(&st->pts, 0, 0, 
2062
                         (int64_t)st->time_base.num * st->codec.sample_rate);
2063
            break;
2064
        case CODEC_TYPE_VIDEO:
2065
            av_frac_init(&st->pts, 0, 0, 
2066
                         (int64_t)st->time_base.num * st->codec.time_base.den);
2067
            break;
2068
        default:
2069
            break;
2070
        }
2071
    }
2072
    return 0;
2073
}
2074

    
2075
//FIXME merge with compute_pkt_fields
2076
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2077
    int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
2078
    int num, den, frame_size;
2079

    
2080
//    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);
2081
    
2082
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2083
        return -1;*/
2084
            
2085
    /* duration field */
2086
    if (pkt->duration == 0) {
2087
        compute_frame_duration(&num, &den, st, NULL, pkt);
2088
        if (den && num) {
2089
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2090
        }
2091
    }
2092

    
2093
    //XXX/FIXME this is a temporary hack until all encoders output pts
2094
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2095
        pkt->dts=
2096
//        pkt->pts= st->cur_dts;
2097
        pkt->pts= st->pts.val;
2098
    }
2099

    
2100
    //calculate dts from pts    
2101
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2102
        if(b_frames){
2103
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2104
                st->last_IP_pts= -pkt->duration;
2105
            }
2106
            if(st->last_IP_pts < pkt->pts){
2107
                pkt->dts= st->last_IP_pts;
2108
                st->last_IP_pts= pkt->pts;
2109
            }else
2110
                pkt->dts= pkt->pts;
2111
        }else
2112
            pkt->dts= pkt->pts;
2113
    }
2114
    
2115
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2116
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %Ld >= %Ld\n", st->cur_dts, pkt->dts);
2117
        return -1;
2118
    }
2119
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2120
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2121
        return -1;
2122
    }
2123

    
2124
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2125
    st->cur_dts= pkt->dts;
2126
    st->pts.val= pkt->dts;
2127

    
2128
    /* update pts */
2129
    switch (st->codec.codec_type) {
2130
    case CODEC_TYPE_AUDIO:
2131
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
2132

    
2133
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2134
           but it would be better if we had the real timestamps from the encoder */
2135
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2136
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2137
        }
2138
        break;
2139
    case CODEC_TYPE_VIDEO:
2140
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.time_base.num);
2141
        break;
2142
    default:
2143
        break;
2144
    }
2145
    return 0;
2146
}
2147

    
2148
static void truncate_ts(AVStream *st, AVPacket *pkt){
2149
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2150
    
2151
//    if(pkt->dts < 0)
2152
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2153
    
2154
    pkt->pts &= pts_mask;
2155
    pkt->dts &= pts_mask;
2156
}
2157

    
2158
/**
2159
 * Write a packet to an output media file. The packet shall contain
2160
 * one audio or video frame.
2161
 *
2162
 * @param s media file handle
2163
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2164
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2165
 */
2166
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2167
{
2168
    int ret;
2169

    
2170
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2171
    if(ret<0)
2172
        return ret;
2173
    
2174
    truncate_ts(s->streams[pkt->stream_index], pkt);
2175

    
2176
    ret= s->oformat->write_packet(s, pkt);
2177
    if(!ret)
2178
        ret= url_ferror(&s->pb);
2179
    return ret;
2180
}
2181

    
2182
/**
2183
 * interleave_packet implementation which will interleave per DTS.
2184
 */
2185
static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2186
    AVPacketList *pktl, **next_point, *this_pktl;
2187
    int stream_count=0;
2188
    int streams[MAX_STREAMS];
2189

    
2190
    if(pkt){
2191
        AVStream *st= s->streams[ pkt->stream_index];
2192

    
2193
        assert(pkt->destruct != av_destruct_packet); //FIXME
2194

    
2195
        this_pktl = av_mallocz(sizeof(AVPacketList));
2196
        this_pktl->pkt= *pkt;
2197
        av_dup_packet(&this_pktl->pkt);
2198

    
2199
        next_point = &s->packet_buffer;
2200
        while(*next_point){
2201
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2202
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2203
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2204
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2205
                break;
2206
            next_point= &(*next_point)->next;
2207
        }
2208
        this_pktl->next= *next_point;
2209
        *next_point= this_pktl;
2210
    }
2211
    
2212
    memset(streams, 0, sizeof(streams));
2213
    pktl= s->packet_buffer;
2214
    while(pktl){
2215
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2216
        if(streams[ pktl->pkt.stream_index ] == 0)
2217
            stream_count++;
2218
        streams[ pktl->pkt.stream_index ]++;
2219
        pktl= pktl->next;
2220
    }
2221
    
2222
    if(s->nb_streams == stream_count || (flush && stream_count)){
2223
        pktl= s->packet_buffer;
2224
        *out= pktl->pkt;
2225
        
2226
        s->packet_buffer= pktl->next;        
2227
        av_freep(&pktl);
2228
        return 1;
2229
    }else{
2230
        av_init_packet(out);
2231
        return 0;
2232
    }
2233
}
2234

    
2235
/**
2236
 * Interleaves a AVPacket correctly so it can be muxed.
2237
 * @param out the interleaved packet will be output here
2238
 * @param in the input packet
2239
 * @param flush 1 if no further packets are available as input and all
2240
 *              remaining packets should be output
2241
 * @return 1 if a packet was output, 0 if no packet could be output, 
2242
 *         < 0 if an error occured
2243
 */
2244
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2245
    if(s->oformat->interleave_packet)
2246
        return s->oformat->interleave_packet(s, out, in, flush);
2247
    else
2248
        return av_interleave_packet_per_dts(s, out, in, flush);
2249
}
2250

    
2251
/**
2252
 * Writes a packet to an output media file ensuring correct interleaving. 
2253
 * The packet shall contain one audio or video frame.
2254
 * If the packets are already correctly interleaved the application should
2255
 * call av_write_frame() instead as its slightly faster, its also important
2256
 * to keep in mind that completly non interleaved input will need huge amounts
2257
 * of memory to interleave with this, so its prefereable to interleave at the
2258
 * demuxer level
2259
 *
2260
 * @param s media file handle
2261
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2262
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2263
 */
2264
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2265
    AVStream *st= s->streams[ pkt->stream_index];
2266

    
2267
    //FIXME/XXX/HACK drop zero sized packets
2268
    if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2269
        return 0;
2270

    
2271
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2272
    if(compute_pkt_fields2(st, pkt) < 0)
2273
        return -1;
2274
    
2275
    if(pkt->dts == AV_NOPTS_VALUE)
2276
        return -1;
2277

    
2278
    for(;;){
2279
        AVPacket opkt;
2280
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2281
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2282
            return ret;
2283
        
2284
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2285
        ret= s->oformat->write_packet(s, &opkt);
2286
        
2287
        av_free_packet(&opkt);
2288
        pkt= NULL;
2289
        
2290
        if(ret<0)
2291
            return ret;
2292
        if(url_ferror(&s->pb))
2293
            return url_ferror(&s->pb);
2294
    }
2295
}
2296

    
2297
/**
2298
 * write the stream trailer to an output media file and and free the
2299
 * file private data.
2300
 *
2301
 * @param s media file handle
2302
 * @return 0 if OK. AVERROR_xxx if error.  */
2303
int av_write_trailer(AVFormatContext *s)
2304
{
2305
    int ret, i;
2306
    
2307
    for(;;){
2308
        AVPacket pkt;
2309
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2310
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2311
            goto fail;
2312
        if(!ret)
2313
            break;
2314
        
2315
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2316
        ret= s->oformat->write_packet(s, &pkt);
2317
        
2318
        av_free_packet(&pkt);
2319
        
2320
        if(ret<0)
2321
            goto fail;
2322
        if(url_ferror(&s->pb))
2323
            goto fail;
2324
    }
2325

    
2326
    ret = s->oformat->write_trailer(s);
2327
fail:
2328
    if(ret == 0)
2329
       ret=url_ferror(&s->pb);
2330
    for(i=0;i<s->nb_streams;i++)
2331
        av_freep(&s->streams[i]->priv_data);
2332
    av_freep(&s->priv_data);
2333
    return ret;
2334
}
2335

    
2336
/* "user interface" functions */
2337

    
2338
void dump_format(AVFormatContext *ic,
2339
                 int index, 
2340
                 const char *url,
2341
                 int is_output)
2342
{
2343
    int i, flags;
2344
    char buf[256];
2345

    
2346
    av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
2347
            is_output ? "Output" : "Input",
2348
            index, 
2349
            is_output ? ic->oformat->name : ic->iformat->name, 
2350
            is_output ? "to" : "from", url);
2351
    if (!is_output) {
2352
        av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
2353
        if (ic->duration != AV_NOPTS_VALUE) {
2354
            int hours, mins, secs, us;
2355
            secs = ic->duration / AV_TIME_BASE;
2356
            us = ic->duration % AV_TIME_BASE;
2357
            mins = secs / 60;
2358
            secs %= 60;
2359
            hours = mins / 60;
2360
            mins %= 60;
2361
            av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
2362
                   (10 * us) / AV_TIME_BASE);
2363
        } else {
2364
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2365
        }
2366
        if (ic->start_time != AV_NOPTS_VALUE) {
2367
            int secs, us;
2368
            av_log(NULL, AV_LOG_DEBUG, ", start: ");
2369
            secs = ic->start_time / AV_TIME_BASE;
2370
            us = ic->start_time % AV_TIME_BASE;
2371
            av_log(NULL, AV_LOG_DEBUG, "%d.%06d",
2372
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2373
        }
2374
        av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
2375
        if (ic->bit_rate) {
2376
            av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
2377
        } else {
2378
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2379
        }
2380
        av_log(NULL, AV_LOG_DEBUG, "\n");
2381
    }
2382
    for(i=0;i<ic->nb_streams;i++) {
2383
        AVStream *st = ic->streams[i];
2384
        avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2385
        av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
2386
        /* the pid is an important information, so we display it */
2387
        /* XXX: add a generic system */
2388
        if (is_output)
2389
            flags = ic->oformat->flags;
2390
        else
2391
            flags = ic->iformat->flags;
2392
        if (flags & AVFMT_SHOW_IDS) {
2393
            av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
2394
        }
2395
        av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
2396
    }
2397
}
2398

    
2399
typedef struct {
2400
    const char *abv;
2401
    int width, height;
2402
    int frame_rate, frame_rate_base;
2403
} AbvEntry;
2404

    
2405
static AbvEntry frame_abvs[] = {
2406
    { "ntsc",      720, 480, 30000, 1001 },
2407
    { "pal",       720, 576,    25,    1 },
2408
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2409
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2410
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2411
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2412
    { "film",      352, 240,    24,    1 },
2413
    { "ntsc-film", 352, 240, 24000, 1001 },
2414
    { "sqcif",     128,  96,     0,    0 },
2415
    { "qcif",      176, 144,     0,    0 },
2416
    { "cif",       352, 288,     0,    0 },
2417
    { "4cif",      704, 576,     0,    0 },
2418
};
2419

    
2420
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2421
{
2422
    int i;
2423
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2424
    const char *p;
2425
    int frame_width = 0, frame_height = 0;
2426

    
2427
    for(i=0;i<n;i++) {
2428
        if (!strcmp(frame_abvs[i].abv, str)) {
2429
            frame_width = frame_abvs[i].width;
2430
            frame_height = frame_abvs[i].height;
2431
            break;
2432
        }
2433
    }
2434
    if (i == n) {
2435
        p = str;
2436
        frame_width = strtol(p, (char **)&p, 10);
2437
        if (*p)
2438
            p++;
2439
        frame_height = strtol(p, (char **)&p, 10);
2440
    }
2441
    if (frame_width <= 0 || frame_height <= 0)
2442
        return -1;
2443
    *width_ptr = frame_width;
2444
    *height_ptr = frame_height;
2445
    return 0;
2446
}
2447

    
2448
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2449
{
2450
    int i;
2451
    char* cp;
2452
   
2453
    /* First, we check our abbreviation table */
2454
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2455
         if (!strcmp(frame_abvs[i].abv, arg)) {
2456
             *frame_rate = frame_abvs[i].frame_rate;
2457
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2458
             return 0;
2459
         }
2460

    
2461
    /* Then, we try to parse it as fraction */
2462
    cp = strchr(arg, '/');
2463
    if (!cp)
2464
        cp = strchr(arg, ':');
2465
    if (cp) {
2466
        char* cpp;
2467
        *frame_rate = strtol(arg, &cpp, 10);
2468
        if (cpp != arg || cpp == cp) 
2469
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2470
        else
2471
           *frame_rate = 0;
2472
    } 
2473
    else {
2474
        /* Finally we give up and parse it as double */
2475
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2476
        *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2477
    }
2478
    if (!*frame_rate || !*frame_rate_base)
2479
        return -1;
2480
    else
2481
        return 0;
2482
}
2483

    
2484
/* Syntax:
2485
 * - If not a duration:
2486
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2487
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2488
 * Return the date in micro seconds since 1970 
2489
 * - If duration:
2490
 *  HH[:MM[:SS[.m...]]]
2491
 *  S+[.m...]
2492
 */
2493
int64_t parse_date(const char *datestr, int duration)
2494
{
2495
    const char *p;
2496
    int64_t t;
2497
    struct tm dt;
2498
    int i;
2499
    static const char *date_fmt[] = {
2500
        "%Y-%m-%d",
2501
        "%Y%m%d",
2502
    };
2503
    static const char *time_fmt[] = {
2504
        "%H:%M:%S",
2505
        "%H%M%S",
2506
    };
2507
    const char *q;
2508
    int is_utc, len;
2509
    char lastch;
2510
    int negative = 0;
2511

    
2512
#undef time
2513
    time_t now = time(0);
2514

    
2515
    len = strlen(datestr);
2516
    if (len > 0)
2517
        lastch = datestr[len - 1];
2518
    else
2519
        lastch = '\0';
2520
    is_utc = (lastch == 'z' || lastch == 'Z');
2521

    
2522
    memset(&dt, 0, sizeof(dt));
2523

    
2524
    p = datestr;
2525
    q = NULL;
2526
    if (!duration) {
2527
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2528
            q = small_strptime(p, date_fmt[i], &dt);
2529
            if (q) {
2530
                break;
2531
            }
2532
        }
2533

    
2534
        if (!q) {
2535
            if (is_utc) {
2536
                dt = *gmtime(&now);
2537
            } else {
2538
                dt = *localtime(&now);
2539
            }
2540
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2541
        } else {
2542
            p = q;
2543
        }
2544

    
2545
        if (*p == 'T' || *p == 't' || *p == ' ')
2546
            p++;
2547

    
2548
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2549
            q = small_strptime(p, time_fmt[i], &dt);
2550
            if (q) {
2551
                break;
2552
            }
2553
        }
2554
    } else {
2555
        if (p[0] == '-') {
2556
            negative = 1;
2557
            ++p;
2558
        }
2559
        q = small_strptime(p, time_fmt[0], &dt);
2560
        if (!q) {
2561
            dt.tm_sec = strtol(p, (char **)&q, 10);
2562
            dt.tm_min = 0;
2563
            dt.tm_hour = 0;
2564
        }
2565
    }
2566

    
2567
    /* Now we have all the fields that we can get */
2568
    if (!q) {
2569
        if (duration)
2570
            return 0;
2571
        else
2572
            return now * int64_t_C(1000000);
2573
    }
2574

    
2575
    if (duration) {
2576
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2577
    } else {
2578
        dt.tm_isdst = -1;       /* unknown */
2579
        if (is_utc) {
2580
            t = mktimegm(&dt);
2581
        } else {
2582
            t = mktime(&dt);
2583
        }
2584
    }
2585

    
2586
    t *= 1000000;
2587

    
2588
    if (*q == '.') {
2589
        int val, n;
2590
        q++;
2591
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2592
            if (!isdigit(*q)) 
2593
                break;
2594
            val += n * (*q - '0');
2595
        }
2596
        t += val;
2597
    }
2598
    return negative ? -t : t;
2599
}
2600

    
2601
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2602
   1 if found */
2603
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2604
{
2605
    const char *p;
2606
    char tag[128], *q;
2607

    
2608
    p = info;
2609
    if (*p == '?')
2610
        p++;
2611
    for(;;) {
2612
        q = tag;
2613
        while (*p != '\0' && *p != '=' && *p != '&') {
2614
            if ((q - tag) < sizeof(tag) - 1)
2615
                *q++ = *p;
2616
            p++;
2617
        }
2618
        *q = '\0';
2619
        q = arg;
2620
        if (*p == '=') {
2621
            p++;
2622
            while (*p != '&' && *p != '\0') {
2623
                if ((q - arg) < arg_size - 1) {
2624
                    if (*p == '+')
2625
                        *q++ = ' ';
2626
                    else
2627
                        *q++ = *p;
2628
                }
2629
                p++;
2630
            }
2631
            *q = '\0';
2632
        }
2633
        if (!strcmp(tag, tag1)) 
2634
            return 1;
2635
        if (*p != '&')
2636
            break;
2637
        p++;
2638
    }
2639
    return 0;
2640
}
2641

    
2642
/* Return in 'buf' the path with '%d' replaced by number. Also handles
2643
   the '%0nd' format where 'n' is the total number of digits and
2644
   '%%'. Return 0 if OK, and -1 if format error */
2645
int get_frame_filename(char *buf, int buf_size,
2646
                       const char *path, int number)
2647
{
2648
    const char *p;
2649
    char *q, buf1[20], c;
2650
    int nd, len, percentd_found;
2651

    
2652
    q = buf;
2653
    p = path;
2654
    percentd_found = 0;
2655
    for(;;) {
2656
        c = *p++;
2657
        if (c == '\0')
2658
            break;
2659
        if (c == '%') {
2660
            do {
2661
                nd = 0;
2662
                while (isdigit(*p)) {
2663
                    nd = nd * 10 + *p++ - '0';
2664
                }
2665
                c = *p++;
2666
            } while (isdigit(c));
2667

    
2668
            switch(c) {
2669
            case '%':
2670
                goto addchar;
2671
            case 'd':
2672
                if (percentd_found)
2673
                    goto fail;
2674
                percentd_found = 1;
2675
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2676
                len = strlen(buf1);
2677
                if ((q - buf + len) > buf_size - 1)
2678
                    goto fail;
2679
                memcpy(q, buf1, len);
2680
                q += len;
2681
                break;
2682
            default:
2683
                goto fail;
2684
            }
2685
        } else {
2686
        addchar:
2687
            if ((q - buf) < buf_size - 1)
2688
                *q++ = c;
2689
        }
2690
    }
2691
    if (!percentd_found)
2692
        goto fail;
2693
    *q = '\0';
2694
    return 0;
2695
 fail:
2696
    *q = '\0';
2697
    return -1;
2698
}
2699

    
2700
/**
2701
 * Print  nice hexa dump of a buffer
2702
 * @param f stream for output
2703
 * @param buf buffer
2704
 * @param size buffer size
2705
 */
2706
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2707
{
2708
    int len, i, j, c;
2709

    
2710
    for(i=0;i<size;i+=16) {
2711
        len = size - i;
2712
        if (len > 16)
2713
            len = 16;
2714
        fprintf(f, "%08x ", i);
2715
        for(j=0;j<16;j++) {
2716
            if (j < len)
2717
                fprintf(f, " %02x", buf[i+j]);
2718
            else
2719
                fprintf(f, "   ");
2720
        }
2721
        fprintf(f, " ");
2722
        for(j=0;j<len;j++) {
2723
            c = buf[i+j];
2724
            if (c < ' ' || c > '~')
2725
                c = '.';
2726
            fprintf(f, "%c", c);
2727
        }
2728
        fprintf(f, "\n");
2729
    }
2730
}
2731

    
2732
/**
2733
 * Print on 'f' a nice dump of a packet
2734
 * @param f stream for output
2735
 * @param pkt packet to dump
2736
 * @param dump_payload true if the payload must be displayed too
2737
 */
2738
 //FIXME needs to know the time_base
2739
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2740
{
2741
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2742
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2743
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2744
    /* DTS is _always_ valid after av_read_frame() */
2745
    fprintf(f, "  dts=");
2746
    if (pkt->dts == AV_NOPTS_VALUE)
2747
        fprintf(f, "N/A");
2748
    else
2749
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2750
    /* PTS may be not known if B frames are present */
2751
    fprintf(f, "  pts=");
2752
    if (pkt->pts == AV_NOPTS_VALUE)
2753
        fprintf(f, "N/A");
2754
    else
2755
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2756
    fprintf(f, "\n");
2757
    fprintf(f, "  size=%d\n", pkt->size);
2758
    if (dump_payload)
2759
        av_hex_dump(f, pkt->data, pkt->size);
2760
}
2761

    
2762
void url_split(char *proto, int proto_size,
2763
               char *authorization, int authorization_size,
2764
               char *hostname, int hostname_size,
2765
               int *port_ptr,
2766
               char *path, int path_size,
2767
               const char *url)
2768
{
2769
    const char *p;
2770
    char *q;
2771
    int port;
2772

    
2773
    port = -1;
2774

    
2775
    p = url;
2776
    q = proto;
2777
    while (*p != ':' && *p != '\0') {
2778
        if ((q - proto) < proto_size - 1)
2779
            *q++ = *p;
2780
        p++;
2781
    }
2782
    if (proto_size > 0)
2783
        *q = '\0';
2784
    if (authorization_size > 0)
2785
        authorization[0] = '\0';
2786
    if (*p == '\0') {
2787
        if (proto_size > 0)
2788
            proto[0] = '\0';
2789
        if (hostname_size > 0)
2790
            hostname[0] = '\0';
2791
        p = url;
2792
    } else {
2793
        char *at,*slash; // PETR: position of '@' character and '/' character
2794

    
2795
        p++;
2796
        if (*p == '/')
2797
            p++;
2798
        if (*p == '/')
2799
            p++;
2800
        at = strchr(p,'@'); // PETR: get the position of '@'
2801
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2802
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2803

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

    
2806
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2807
            if (*p == '@') {    // PETR: passed '@'
2808
              if (authorization_size > 0)
2809
                  *q = '\0';
2810
              q = hostname;
2811
              at = NULL;
2812
            } else if (!at) {   // PETR: hostname
2813
              if ((q - hostname) < hostname_size - 1)
2814
                  *q++ = *p;
2815
            } else {
2816
              if ((q - authorization) < authorization_size - 1)
2817
                *q++ = *p;
2818
            }
2819
            p++;
2820
        }
2821
        if (hostname_size > 0)
2822
            *q = '\0';
2823
        if (*p == ':') {
2824
            p++;
2825
            port = strtoul(p, (char **)&p, 10);
2826
        }
2827
    }
2828
    if (port_ptr)
2829
        *port_ptr = port;
2830
    pstrcpy(path, path_size, p);
2831
}
2832

    
2833
/**
2834
 * Set the pts for a given stream
2835
 * @param s stream 
2836
 * @param pts_wrap_bits number of bits effectively used by the pts
2837
 *        (used for wrap control, 33 is the value for MPEG) 
2838
 * @param pts_num numerator to convert to seconds (MPEG: 1) 
2839
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2840
 */
2841
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2842
                     int pts_num, int pts_den)
2843
{
2844
    s->pts_wrap_bits = pts_wrap_bits;
2845
    s->time_base.num = pts_num;
2846
    s->time_base.den = pts_den;
2847
}
2848

    
2849
/* fraction handling */
2850

    
2851
/**
2852
 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2853
 * as 0 <= num < den.
2854
 *
2855
 * @param f fractional number
2856
 * @param val integer value
2857
 * @param num must be >= 0
2858
 * @param den must be >= 1 
2859
 */
2860
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2861
{
2862
    num += (den >> 1);
2863
    if (num >= den) {
2864
        val += num / den;
2865
        num = num % den;
2866
    }
2867
    f->val = val;
2868
    f->num = num;
2869
    f->den = den;
2870
}
2871

    
2872
/* set f to (val + 0.5) */
2873
void av_frac_set(AVFrac *f, int64_t val)
2874
{
2875
    f->val = val;
2876
    f->num = f->den >> 1;
2877
}
2878

    
2879
/**
2880
 * Fractionnal addition to f: f = f + (incr / f->den)
2881
 *
2882
 * @param f fractional number
2883
 * @param incr increment, can be positive or negative
2884
 */
2885
void av_frac_add(AVFrac *f, int64_t incr)
2886
{
2887
    int64_t num, den;
2888

    
2889
    num = f->num + incr;
2890
    den = f->den;
2891
    if (num < 0) {
2892
        f->val += num / den;
2893
        num = num % den;
2894
        if (num < 0) {
2895
            num += den;
2896
            f->val--;
2897
        }
2898
    } else if (num >= den) {
2899
        f->val += num / den;
2900
        num = num % den;
2901
    }
2902
    f->num = num;
2903
}
2904

    
2905
/**
2906
 * register a new image format
2907
 * @param img_fmt Image format descriptor
2908
 */
2909
void av_register_image_format(AVImageFormat *img_fmt)
2910
{
2911
    AVImageFormat **p;
2912

    
2913
    p = &first_image_format;
2914
    while (*p != NULL) p = &(*p)->next;
2915
    *p = img_fmt;
2916
    img_fmt->next = NULL;
2917
}
2918

    
2919
/* guess image format */
2920
AVImageFormat *av_probe_image_format(AVProbeData *pd)
2921
{
2922
    AVImageFormat *fmt1, *fmt;
2923
    int score, score_max;
2924

    
2925
    fmt = NULL;
2926
    score_max = 0;
2927
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2928
        if (fmt1->img_probe) {
2929
            score = fmt1->img_probe(pd);
2930
            if (score > score_max) {
2931
                score_max = score;
2932
                fmt = fmt1;
2933
            }
2934
        }
2935
    }
2936
    return fmt;
2937
}
2938

    
2939
AVImageFormat *guess_image_format(const char *filename)
2940
{
2941
    AVImageFormat *fmt1;
2942

    
2943
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2944
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2945
            return fmt1;
2946
    }
2947
    return NULL;
2948
}
2949

    
2950
/**
2951
 * Read an image from a stream. 
2952
 * @param gb byte stream containing the image
2953
 * @param fmt image format, NULL if probing is required
2954
 */
2955
int av_read_image(ByteIOContext *pb, const char *filename,
2956
                  AVImageFormat *fmt,
2957
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2958
{
2959
    char buf[PROBE_BUF_SIZE];
2960
    AVProbeData probe_data, *pd = &probe_data;
2961
    offset_t pos;
2962
    int ret;
2963

    
2964
    if (!fmt) {
2965
        pd->filename = filename;
2966
        pd->buf = buf;
2967
        pos = url_ftell(pb);
2968
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2969
        url_fseek(pb, pos, SEEK_SET);
2970
        fmt = av_probe_image_format(pd);
2971
    }
2972
    if (!fmt)
2973
        return AVERROR_NOFMT;
2974
    ret = fmt->img_read(pb, alloc_cb, opaque);
2975
    return ret;
2976
}
2977

    
2978
/**
2979
 * Write an image to a stream.
2980
 * @param pb byte stream for the image output
2981
 * @param fmt image format
2982
 * @param img image data and informations
2983
 */
2984
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2985
{
2986
    return fmt->img_write(pb, img);
2987
}
2988