Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 15bc38e5

History | View | Annotate | Download (85.1 KB)

1
/*
2
 * Various utilities for ffmpeg system
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
#include "avformat.h"
20

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

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

    
28
void av_register_input_format(AVInputFormat *format)
29
{
30
    AVInputFormat **p;
31
    p = &first_iformat;
32
    while (*p != NULL) p = &(*p)->next;
33
    *p = format;
34
    format->next = NULL;
35
}
36

    
37
void av_register_output_format(AVOutputFormat *format)
38
{
39
    AVOutputFormat **p;
40
    p = &first_oformat;
41
    while (*p != NULL) p = &(*p)->next;
42
    *p = format;
43
    format->next = NULL;
44
}
45

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

    
51
    if(!filename)
52
        return 0;
53
    
54
    ext = strrchr(filename, '.');
55
    if (ext) {
56
        ext++;
57
        p = extensions;
58
        for(;;) {
59
            q = ext1;
60
            while (*p != '\0' && *p != ',') 
61
                *q++ = *p++;
62
            *q = '\0';
63
            if (!strcasecmp(ext1, ext)) 
64
                return 1;
65
            if (*p == '\0') 
66
                break;
67
            p++;
68
        }
69
    }
70
    return 0;
71
}
72

    
73
AVOutputFormat *guess_format(const char *short_name, const char *filename, 
74
                             const char *mime_type)
75
{
76
    AVOutputFormat *fmt, *fmt_found;
77
    int score_max, score;
78

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

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

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

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

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

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

    
130
    return fmt;
131
}
132

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

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

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

    
163
/* memory handling */
164

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

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

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

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

    
215
/* fifo handling */
216

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
459
#define PROBE_BUF_SIZE 2048
460

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

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

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

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

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

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

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

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

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

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

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

    
619

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

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

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

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

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

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

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

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

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

    
787
    /* convert the packet time stamp units */
788
    if(pkt->pts != AV_NOPTS_VALUE)
789
        pkt->pts = av_rescale(pkt->pts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
790
    if(pkt->dts != AV_NOPTS_VALUE)
791
        pkt->dts = av_rescale(pkt->dts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
792

    
793
    /* duration field */
794
    pkt->duration = av_rescale(pkt->duration, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
795
}
796

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

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

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

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

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

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

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

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

    
930
/*******************************************************/
931
/* seek support */
932

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

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

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

    
955
    flush_packet_queue(s);
956

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

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

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

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

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

    
1015
    index= av_index_search_timestamp(st, timestamp, 0);
1016

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

    
1032
    ie->pos = pos;
1033
    ie->timestamp = timestamp;
1034
    ie->min_distance= distance;
1035
    ie->flags = flags;
1036
    
1037
    return index;
1038
}
1039

    
1040
/* build an index for raw streams using a parser */
1041
static void av_build_index_raw(AVFormatContext *s)
1042
{
1043
    AVPacket pkt1, *pkt = &pkt1;
1044
    int ret;
1045
    AVStream *st;
1046

    
1047
    st = s->streams[0];
1048
    av_read_frame_flush(s);
1049
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1050

    
1051
    for(;;) {
1052
        ret = av_read_frame(s, pkt);
1053
        if (ret < 0)
1054
            break;
1055
        if (pkt->stream_index == 0 && st->parser &&
1056
            (pkt->flags & PKT_FLAG_KEY)) {
1057
            int64_t dts= av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
1058
            av_add_index_entry(st, st->parser->frame_offset, dts, 
1059
                            0, AVINDEX_KEYFRAME);
1060
        }
1061
        av_free_packet(pkt);
1062
    }
1063
}
1064

    
1065
/* return TRUE if we deal with a raw stream (raw codec data and
1066
   parsing needed) */
1067
static int is_raw_stream(AVFormatContext *s)
1068
{
1069
    AVStream *st;
1070

    
1071
    if (s->nb_streams != 1)
1072
        return 0;
1073
    st = s->streams[0];
1074
    if (!st->need_parsing)
1075
        return 0;
1076
    return 1;
1077
}
1078

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

    
1094
    a = - 1;
1095
    b = nb_entries;
1096

    
1097
    while (b - a > 1) {
1098
        m = (a + b) >> 1;
1099
        timestamp = entries[m].timestamp;
1100
        if(timestamp >= wanted_timestamp)
1101
            b = m;
1102
        if(timestamp <= wanted_timestamp)
1103
            a = m;
1104
    }
1105
    m= backward ? a : b;
1106

    
1107
    if(m == nb_entries) 
1108
        return -1;
1109
    return  m;
1110
}
1111

    
1112
#define DEBUG_SEEK
1113

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

    
1128
    if (stream_index < 0)
1129
        return -1;
1130
    
1131
#ifdef DEBUG_SEEK
1132
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
1133
#endif
1134

    
1135
    ts_max=
1136
    ts_min= AV_NOPTS_VALUE;
1137
    pos_limit= -1; //gcc falsely says it may be uninitalized
1138

    
1139
    st= s->streams[stream_index];
1140
    if(st->index_entries){
1141
        AVIndexEntry *e;
1142

    
1143
        index= av_index_search_timestamp(st, target_ts, 1);
1144
        index= FFMAX(index, 0);
1145
        e= &st->index_entries[index];
1146

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

    
1171
    if(ts_min == AV_NOPTS_VALUE){
1172
        pos_min = s->data_offset;
1173
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1174
        if (ts_min == AV_NOPTS_VALUE)
1175
            return -1;
1176
    }
1177

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

    
1200
    no_change=0;
1201
    while (pos_min < pos_limit) {
1202
#ifdef DEBUG_SEEK
1203
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n", 
1204
               pos_min, pos_max,
1205
               ts_min, ts_max);
1206
#endif
1207
        assert(pos_limit <= pos_max);
1208

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

    
1227
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1228
        if(pos == pos_max)
1229
            no_change++;
1230
        else
1231
            no_change=0;
1232
#ifdef DEBUG_SEEK
1233
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);
1234
#endif
1235
        assert(ts != AV_NOPTS_VALUE);
1236
        if (target_ts <= ts) {
1237
            pos_limit = start_pos - 1;
1238
            pos_max = pos;
1239
            ts_max = ts;
1240
        }
1241
        if (target_ts >= ts) {
1242
            pos_min = pos;
1243
            ts_min = ts;
1244
        }
1245
    }
1246
    
1247
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1248
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1249
#ifdef DEBUG_SEEK
1250
    pos_min = pos;
1251
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1252
    pos_min++;
1253
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1254
    av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n", 
1255
           pos, ts_min, target_ts, ts_max);
1256
#endif
1257
    /* do the seek */
1258
    url_fseek(&s->pb, pos, SEEK_SET);
1259

    
1260
    av_update_cur_dts(s, st, ts);
1261

    
1262
    return 0;
1263
}
1264

    
1265
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1266
    AVInputFormat *avif= s->iformat;
1267
    int64_t pos_min, pos_max;
1268
#if 0
1269
    AVStream *st;
1270

1271
    if (stream_index < 0)
1272
        return -1;
1273

1274
    st= s->streams[stream_index];
1275
#endif
1276

    
1277
    pos_min = s->data_offset;
1278
    pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1279

    
1280
    if     (pos < pos_min) pos= pos_min;
1281
    else if(pos > pos_max) pos= pos_max;
1282

    
1283
    url_fseek(&s->pb, pos, SEEK_SET);
1284

    
1285
#if 0
1286
    av_update_cur_dts(s, st, ts);
1287
#endif
1288
    return 0;
1289
}
1290

    
1291
static int av_seek_frame_generic(AVFormatContext *s, 
1292
                                 int stream_index, int64_t timestamp, int flags)
1293
{
1294
    int index;
1295
    AVStream *st;
1296
    AVIndexEntry *ie;
1297

    
1298
    if (!s->index_built) {
1299
        if (is_raw_stream(s)) {
1300
            av_build_index_raw(s);
1301
        } else {
1302
            return -1;
1303
        }
1304
        s->index_built = 1;
1305
    }
1306

    
1307
    st = s->streams[stream_index];
1308
    index = av_index_search_timestamp(st, timestamp, flags & AVSEEK_FLAG_BACKWARD);
1309
    if (index < 0)
1310
        return -1;
1311

    
1312
    /* now we have found the index, we can seek */
1313
    ie = &st->index_entries[index];
1314
    av_read_frame_flush(s);
1315
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1316

    
1317
    av_update_cur_dts(s, st, ie->timestamp);
1318

    
1319
    return 0;
1320
}
1321

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

    
1353
    /* first, we try the format specific seek */
1354
    if (s->iformat->read_seek)
1355
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1356
    else
1357
        ret = -1;
1358
    if (ret >= 0) {
1359
        return 0;
1360
    }
1361

    
1362
    if(s->iformat->read_timestamp)
1363
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1364
    else
1365
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1366
}
1367

    
1368
/*******************************************************/
1369

    
1370
/* return TRUE if the stream has accurate timings for at least one component */
1371
static int av_has_timings(AVFormatContext *ic)
1372
{
1373
    int i;
1374
    AVStream *st;
1375

    
1376
    for(i = 0;i < ic->nb_streams; i++) {
1377
        st = ic->streams[i];
1378
        if (st->start_time != AV_NOPTS_VALUE &&
1379
            st->duration != AV_NOPTS_VALUE)
1380
            return 1;
1381
    }
1382
    return 0;
1383
}
1384

    
1385
/* estimate the stream timings from the one of each components. Also
1386
   compute the global bitrate if possible */
1387
static void av_update_stream_timings(AVFormatContext *ic)
1388
{
1389
    int64_t start_time, end_time, end_time1;
1390
    int i;
1391
    AVStream *st;
1392

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

    
1419
}
1420

    
1421
static void fill_all_stream_timings(AVFormatContext *ic)
1422
{
1423
    int i;
1424
    AVStream *st;
1425

    
1426
    av_update_stream_timings(ic);
1427
    for(i = 0;i < ic->nb_streams; i++) {
1428
        st = ic->streams[i];
1429
        if (st->start_time == AV_NOPTS_VALUE) {
1430
            st->start_time = ic->start_time;
1431
            st->duration = ic->duration;
1432
        }
1433
    }
1434
}
1435

    
1436
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1437
{
1438
    int64_t filesize, duration;
1439
    int bit_rate, i;
1440
    AVStream *st;
1441

    
1442
    /* if bit_rate is already set, we believe it */
1443
    if (ic->bit_rate == 0) {
1444
        bit_rate = 0;
1445
        for(i=0;i<ic->nb_streams;i++) {
1446
            st = ic->streams[i];
1447
            bit_rate += st->codec.bit_rate;
1448
        }
1449
        ic->bit_rate = bit_rate;
1450
    }
1451

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

    
1471
#define DURATION_MAX_READ_SIZE 250000
1472

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

    
1487
    /* flush packet queue */
1488
    flush_packet_queue(ic);
1489

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

    
1514
        ret = av_read_packet(ic, pkt);
1515
        if (ret != 0)
1516
            break;
1517
        read_size += pkt->size;
1518
        st = ic->streams[pkt->stream_index];
1519
        if (pkt->pts != AV_NOPTS_VALUE) {
1520
            if (st->start_time == AV_NOPTS_VALUE)
1521
                st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1522
        }
1523
        av_free_packet(pkt);
1524
    }
1525

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

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

    
1596
    if (end_time != MININT64) {
1597
        /* put dummy values for duration if needed */
1598
        for(i = 0;i < ic->nb_streams; i++) {
1599
            st = ic->streams[i];
1600
            if (st->duration == AV_NOPTS_VALUE && 
1601
                st->start_time != AV_NOPTS_VALUE)
1602
                st->duration = end_time - st->start_time;
1603
        }
1604
        ic->duration = end_time - ic->start_time;
1605
    }
1606

    
1607
    url_fseek(&ic->pb, 0, SEEK_SET);
1608
}
1609

    
1610
static void av_estimate_timings(AVFormatContext *ic)
1611
{
1612
    URLContext *h;
1613
    int64_t file_size;
1614

    
1615
    /* get the file size, if possible */
1616
    if (ic->iformat->flags & AVFMT_NOFILE) {
1617
        file_size = 0;
1618
    } else {
1619
        h = url_fileno(&ic->pb);
1620
        file_size = url_filesize(h);
1621
        if (file_size < 0)
1622
            file_size = 0;
1623
    }
1624
    ic->file_size = file_size;
1625

    
1626
    if ((ic->iformat == &mpegps_demux || ic->iformat == &mpegts_demux) && file_size && !ic->pb.is_streamed) {
1627
        /* get accurate estimate from the PTSes */
1628
        av_estimate_timings_from_pts(ic);
1629
    } else if (av_has_timings(ic)) {
1630
        /* at least one components has timings - we use them for all
1631
           the components */
1632
        fill_all_stream_timings(ic);
1633
    } else {
1634
        /* less precise: use bit rate info */
1635
        av_estimate_timings_from_bit_rate(ic);
1636
    }
1637
    av_update_stream_timings(ic);
1638

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

    
1657
static int has_codec_parameters(AVCodecContext *enc)
1658
{
1659
    int val;
1660
    switch(enc->codec_type) {
1661
    case CODEC_TYPE_AUDIO:
1662
        val = enc->sample_rate;
1663
        break;
1664
    case CODEC_TYPE_VIDEO:
1665
        val = enc->width;
1666
        break;
1667
    default:
1668
        val = 1;
1669
        break;
1670
    }
1671
    return (val != 0);
1672
}
1673

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

    
1708
/* absolute maximum size we read until we abort */
1709
#define MAX_READ_SIZE        5000000
1710

    
1711
/* maximum duration until we stop analysing the stream */
1712
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1713

    
1714
/**
1715
 * Read the beginning of a media file to get stream information. This
1716
 * is useful for file formats with no headers such as MPEG. This
1717
 * function also compute the real frame rate in case of mpeg2 repeat
1718
 * frame mode.
1719
 *
1720
 * @param ic media file handle
1721
 * @return >=0 if OK. AVERROR_xxx if error.  
1722
 */
1723
int av_find_stream_info(AVFormatContext *ic)
1724
{
1725
    int i, count, ret, read_size;
1726
    AVStream *st;
1727
    AVPacket pkt1, *pkt;
1728
    AVPacketList *pktl=NULL, **ppktl;
1729
    int64_t last_dts[MAX_STREAMS];
1730
    int64_t best_duration[MAX_STREAMS];
1731

    
1732
    for(i=0;i<MAX_STREAMS;i++){
1733
        last_dts[i]= AV_NOPTS_VALUE;
1734
        best_duration[i]= INT64_MAX;
1735
    }
1736
    
1737
    count = 0;
1738
    read_size = 0;
1739
    ppktl = &ic->packet_buffer;
1740
    for(;;) {
1741
        /* check if one codec still needs to be handled */
1742
        for(i=0;i<ic->nb_streams;i++) {
1743
            st = ic->streams[i];
1744
            if (!has_codec_parameters(&st->codec))
1745
                break;
1746
        }
1747
        if (i == ic->nb_streams) {
1748
            /* NOTE: if the format has no header, then we need to read
1749
               some packets to get most of the streams, so we cannot
1750
               stop here */
1751
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1752
                /* if we found the info for all the codecs, we can stop */
1753
                ret = count;
1754
                break;
1755
            }
1756
        } else {
1757
            /* we did not get all the codec info, but we read too much data */
1758
            if (read_size >= MAX_READ_SIZE) {
1759
                ret = count;
1760
                break;
1761
            }
1762
        }
1763

    
1764
        /* NOTE: a new stream can be added there if no header in file
1765
           (AVFMTCTX_NOHEADER) */
1766
        ret = av_read_frame_internal(ic, &pkt1);
1767
        if (ret < 0) {
1768
            /* EOF or error */
1769
            ret = -1; /* we could not have all the codec parameters before EOF */
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_MPEG4 && !st->need_parsing)))
1829
            try_decode_frame(st, pkt->data, pkt->size);
1830
        
1831
        if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1832
            break;
1833
        }
1834
        count++;
1835
    }
1836

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

    
1843
            if(best_duration[i] < INT64_MAX && st->codec.frame_rate_base*1000 <= st->codec.frame_rate){
1844
                st->r_frame_rate= st->codec.frame_rate;
1845
                st->r_frame_rate_base= av_rescale(best_duration[i], st->codec.frame_rate, AV_TIME_BASE);
1846
                av_reduce(&st->r_frame_rate, &st->r_frame_rate_base, st->r_frame_rate, st->r_frame_rate_base, 1<<15);
1847
            }
1848

    
1849
            /* set real frame rate info */
1850
            /* compute the real frame rate for telecine */
1851
            if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1852
                 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1853
                st->codec.sub_id == 2) {
1854
                if (st->codec_info_nb_frames >= 20) {
1855
                    float coded_frame_rate, est_frame_rate;
1856
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1857
                        (double)st->codec_info_duration ;
1858
                    coded_frame_rate = (double)st->codec.frame_rate /
1859
                        (double)st->codec.frame_rate_base;
1860
#if 0
1861
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1862
                           coded_frame_rate, est_frame_rate);
1863
#endif
1864
                    /* if we detect that it could be a telecine, we
1865
                       signal it. It would be better to do it at a
1866
                       higher level as it can change in a film */
1867
                    if (coded_frame_rate >= 24.97 && 
1868
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1869
                        st->r_frame_rate = 24024;
1870
                        st->r_frame_rate_base = 1001;
1871
                    }
1872
                }
1873
            }
1874
            /* if no real frame rate, use the codec one */
1875
            if (!st->r_frame_rate){
1876
                st->r_frame_rate      = st->codec.frame_rate;
1877
                st->r_frame_rate_base = st->codec.frame_rate_base;
1878
            }
1879
        }
1880
    }
1881

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

    
1910
/*******************************************************/
1911

    
1912
/**
1913
 * start playing a network based stream (e.g. RTSP stream) at the
1914
 * current position 
1915
 */
1916
int av_read_play(AVFormatContext *s)
1917
{
1918
    if (!s->iformat->read_play)
1919
        return AVERROR_NOTSUPP;
1920
    return s->iformat->read_play(s);
1921
}
1922

    
1923
/**
1924
 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1925
 * to resume it.
1926
 */
1927
int av_read_pause(AVFormatContext *s)
1928
{
1929
    if (!s->iformat->read_pause)
1930
        return AVERROR_NOTSUPP;
1931
    return s->iformat->read_pause(s);
1932
}
1933

    
1934
/**
1935
 * Close a media file (but not its codecs)
1936
 *
1937
 * @param s media file handle
1938
 */
1939
void av_close_input_file(AVFormatContext *s)
1940
{
1941
    int i, must_open_file;
1942
    AVStream *st;
1943

    
1944
    /* free previous packet */
1945
    if (s->cur_st && s->cur_st->parser)
1946
        av_free_packet(&s->cur_pkt); 
1947

    
1948
    if (s->iformat->read_close)
1949
        s->iformat->read_close(s);
1950
    for(i=0;i<s->nb_streams;i++) {
1951
        /* free all data in a stream component */
1952
        st = s->streams[i];
1953
        if (st->parser) {
1954
            av_parser_close(st->parser);
1955
        }
1956
        av_free(st->index_entries);
1957
        av_free(st);
1958
    }
1959
    flush_packet_queue(s);
1960
    must_open_file = 1;
1961
    if (s->iformat->flags & AVFMT_NOFILE) {
1962
        must_open_file = 0;
1963
    }
1964
    if (must_open_file) {
1965
        url_fclose(&s->pb);
1966
    }
1967
    av_freep(&s->priv_data);
1968
    av_free(s);
1969
}
1970

    
1971
/**
1972
 * Add a new stream to a media file. Can only be called in the
1973
 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1974
 * format context, then new streams can be added in read_packet too.
1975
 *
1976
 *
1977
 * @param s media file handle
1978
 * @param id file format dependent stream id 
1979
 */
1980
AVStream *av_new_stream(AVFormatContext *s, int id)
1981
{
1982
    AVStream *st;
1983

    
1984
    if (s->nb_streams >= MAX_STREAMS)
1985
        return NULL;
1986

    
1987
    st = av_mallocz(sizeof(AVStream));
1988
    if (!st)
1989
        return NULL;
1990
    avcodec_get_context_defaults(&st->codec);
1991
    if (s->iformat) {
1992
        /* no default bitrate if decoding */
1993
        st->codec.bit_rate = 0;
1994
    }
1995
    st->index = s->nb_streams;
1996
    st->id = id;
1997
    st->start_time = AV_NOPTS_VALUE;
1998
    st->duration = AV_NOPTS_VALUE;
1999
    st->cur_dts = AV_NOPTS_VALUE;
2000

    
2001
    /* default pts settings is MPEG like */
2002
    av_set_pts_info(st, 33, 1, 90000);
2003
    st->last_IP_pts = AV_NOPTS_VALUE;
2004

    
2005
    s->streams[s->nb_streams++] = st;
2006
    return st;
2007
}
2008

    
2009
/************************************************************/
2010
/* output media file */
2011

    
2012
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2013
{
2014
    int ret;
2015
    
2016
    if (s->oformat->priv_data_size > 0) {
2017
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2018
        if (!s->priv_data)
2019
            return AVERROR_NOMEM;
2020
    } else
2021
        s->priv_data = NULL;
2022
        
2023
    if (s->oformat->set_parameters) {
2024
        ret = s->oformat->set_parameters(s, ap);
2025
        if (ret < 0)
2026
            return ret;
2027
    }
2028
    return 0;
2029
}
2030

    
2031
/**
2032
 * allocate the stream private data and write the stream header to an
2033
 * output media file
2034
 *
2035
 * @param s media file handle
2036
 * @return 0 if OK. AVERROR_xxx if error.  
2037
 */
2038
int av_write_header(AVFormatContext *s)
2039
{
2040
    int ret, i;
2041
    AVStream *st;
2042

    
2043
    ret = s->oformat->write_header(s);
2044
    if (ret < 0)
2045
        return ret;
2046

    
2047
    /* init PTS generation */
2048
    for(i=0;i<s->nb_streams;i++) {
2049
        st = s->streams[i];
2050

    
2051
        switch (st->codec.codec_type) {
2052
        case CODEC_TYPE_AUDIO:
2053
            av_frac_init(&st->pts, 0, 0, 
2054
                         (int64_t)st->time_base.num * st->codec.sample_rate);
2055
            break;
2056
        case CODEC_TYPE_VIDEO:
2057
            av_frac_init(&st->pts, 0, 0, 
2058
                         (int64_t)st->time_base.num * st->codec.frame_rate);
2059
            break;
2060
        default:
2061
            break;
2062
        }
2063
    }
2064
    return 0;
2065
}
2066

    
2067
//FIXME merge with compute_pkt_fields
2068
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2069
    int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
2070
    int num, den, frame_size;
2071

    
2072
//    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);
2073
    
2074
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2075
        return -1;*/
2076
            
2077
    if(pkt->pts != AV_NOPTS_VALUE)
2078
        pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2079
    if(pkt->dts != AV_NOPTS_VALUE)
2080
        pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2081

    
2082
    /* duration field */
2083
    pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2084
    if (pkt->duration == 0) {
2085
        compute_frame_duration(&num, &den, st, NULL, pkt);
2086
        if (den && num) {
2087
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2088
        }
2089
    }
2090

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

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

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

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

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

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

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

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

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

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

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

    
2191
        assert(pkt->destruct != av_destruct_packet); //FIXME
2192

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

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

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

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

    
2265
    if(compute_pkt_fields2(st, pkt) < 0)
2266
        return -1;
2267
    
2268
    //FIXME/XXX/HACK drop zero sized packets
2269
    if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2270
        return 0;
2271
    
2272
    if(pkt->dts == AV_NOPTS_VALUE)
2273
        return -1;
2274

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

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

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

    
2333
/* "user interface" functions */
2334

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

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

    
2396
typedef struct {
2397
    const char *abv;
2398
    int width, height;
2399
    int frame_rate, frame_rate_base;
2400
} AbvEntry;
2401

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

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

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

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

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

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

    
2507
#undef time
2508
    time_t now = time(0);
2509

    
2510
    len = strlen(datestr);
2511
    if (len > 0)
2512
        lastch = datestr[len - 1];
2513
    else
2514
        lastch = '\0';
2515
    is_utc = (lastch == 'z' || lastch == 'Z');
2516

    
2517
    memset(&dt, 0, sizeof(dt));
2518

    
2519
    p = datestr;
2520
    q = NULL;
2521
    if (!duration) {
2522
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2523
            q = small_strptime(p, date_fmt[i], &dt);
2524
            if (q) {
2525
                break;
2526
            }
2527
        }
2528

    
2529
        if (!q) {
2530
            if (is_utc) {
2531
                dt = *gmtime(&now);
2532
            } else {
2533
                dt = *localtime(&now);
2534
            }
2535
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2536
        } else {
2537
            p = q;
2538
        }
2539

    
2540
        if (*p == 'T' || *p == 't' || *p == ' ')
2541
            p++;
2542

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

    
2562
    /* Now we have all the fields that we can get */
2563
    if (!q) {
2564
        if (duration)
2565
            return 0;
2566
        else
2567
            return now * int64_t_C(1000000);
2568
    }
2569

    
2570
    if (duration) {
2571
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2572
    } else {
2573
        dt.tm_isdst = -1;       /* unknown */
2574
        if (is_utc) {
2575
            t = mktimegm(&dt);
2576
        } else {
2577
            t = mktime(&dt);
2578
        }
2579
    }
2580

    
2581
    t *= 1000000;
2582

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

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

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

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

    
2647
    q = buf;
2648
    p = path;
2649
    percentd_found = 0;
2650
    for(;;) {
2651
        c = *p++;
2652
        if (c == '\0')
2653
            break;
2654
        if (c == '%') {
2655
            do {
2656
                nd = 0;
2657
                while (isdigit(*p)) {
2658
                    nd = nd * 10 + *p++ - '0';
2659
                }
2660
                c = *p++;
2661
            } while (isdigit(c));
2662

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

    
2695
/**
2696
 * Print  nice hexa dump of a buffer
2697
 * @param f stream for output
2698
 * @param buf buffer
2699
 * @param size buffer size
2700
 */
2701
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2702
{
2703
    int len, i, j, c;
2704

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

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

    
2756
void url_split(char *proto, int proto_size,
2757
               char *authorization, int authorization_size,
2758
               char *hostname, int hostname_size,
2759
               int *port_ptr,
2760
               char *path, int path_size,
2761
               const char *url)
2762
{
2763
    const char *p;
2764
    char *q;
2765
    int port;
2766

    
2767
    port = -1;
2768

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

    
2789
        p++;
2790
        if (*p == '/')
2791
            p++;
2792
        if (*p == '/')
2793
            p++;
2794
        at = strchr(p,'@'); // PETR: get the position of '@'
2795
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2796
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2797

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

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

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

    
2843
/* fraction handling */
2844

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

    
2866
/* set f to (val + 0.5) */
2867
void av_frac_set(AVFrac *f, int64_t val)
2868
{
2869
    f->val = val;
2870
    f->num = f->den >> 1;
2871
}
2872

    
2873
/**
2874
 * Fractionnal addition to f: f = f + (incr / f->den)
2875
 *
2876
 * @param f fractional number
2877
 * @param incr increment, can be positive or negative
2878
 */
2879
void av_frac_add(AVFrac *f, int64_t incr)
2880
{
2881
    int64_t num, den;
2882

    
2883
    num = f->num + incr;
2884
    den = f->den;
2885
    if (num < 0) {
2886
        f->val += num / den;
2887
        num = num % den;
2888
        if (num < 0) {
2889
            num += den;
2890
            f->val--;
2891
        }
2892
    } else if (num >= den) {
2893
        f->val += num / den;
2894
        num = num % den;
2895
    }
2896
    f->num = num;
2897
}
2898

    
2899
/**
2900
 * register a new image format
2901
 * @param img_fmt Image format descriptor
2902
 */
2903
void av_register_image_format(AVImageFormat *img_fmt)
2904
{
2905
    AVImageFormat **p;
2906

    
2907
    p = &first_image_format;
2908
    while (*p != NULL) p = &(*p)->next;
2909
    *p = img_fmt;
2910
    img_fmt->next = NULL;
2911
}
2912

    
2913
/* guess image format */
2914
AVImageFormat *av_probe_image_format(AVProbeData *pd)
2915
{
2916
    AVImageFormat *fmt1, *fmt;
2917
    int score, score_max;
2918

    
2919
    fmt = NULL;
2920
    score_max = 0;
2921
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2922
        if (fmt1->img_probe) {
2923
            score = fmt1->img_probe(pd);
2924
            if (score > score_max) {
2925
                score_max = score;
2926
                fmt = fmt1;
2927
            }
2928
        }
2929
    }
2930
    return fmt;
2931
}
2932

    
2933
AVImageFormat *guess_image_format(const char *filename)
2934
{
2935
    AVImageFormat *fmt1;
2936

    
2937
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2938
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2939
            return fmt1;
2940
    }
2941
    return NULL;
2942
}
2943

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

    
2958
    if (!fmt) {
2959
        pd->filename = filename;
2960
        pd->buf = buf;
2961
        pos = url_ftell(pb);
2962
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2963
        url_fseek(pb, pos, SEEK_SET);
2964
        fmt = av_probe_image_format(pd);
2965
    }
2966
    if (!fmt)
2967
        return AVERROR_NOFMT;
2968
    ret = fmt->img_read(pb, alloc_cb, opaque);
2969
    return ret;
2970
}
2971

    
2972
/**
2973
 * Write an image to a stream.
2974
 * @param pb byte stream for the image output
2975
 * @param fmt image format
2976
 * @param img image data and informations
2977
 */
2978
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2979
{
2980
    return fmt->img_write(pb, img);
2981
}
2982