Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ b18a4ab2

History | View | Annotate | Download (94.7 KB)

1
/*
2
 * various utility functions for use within FFmpeg
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#include "avformat.h"
22
#include "libavcodec/opt.h"
23
#include "libavutil/avstring.h"
24
#include "riff.h"
25
#include <sys/time.h>
26
#include <time.h>
27

    
28
#undef NDEBUG
29
#include <assert.h>
30

    
31
/**
32
 * @file libavformat/utils.c
33
 * various utility functions for use within FFmpeg
34
 */
35

    
36
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37
static void av_frac_add(AVFrac *f, int64_t incr);
38

    
39
/** head of registered input format linked list */
40
AVInputFormat *first_iformat = NULL;
41
/** head of registered output format linked list */
42
AVOutputFormat *first_oformat = NULL;
43

    
44
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
45
{
46
    if(f) return f->next;
47
    else  return first_iformat;
48
}
49

    
50
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
51
{
52
    if(f) return f->next;
53
    else  return first_oformat;
54
}
55

    
56
void av_register_input_format(AVInputFormat *format)
57
{
58
    AVInputFormat **p;
59
    p = &first_iformat;
60
    while (*p != NULL) p = &(*p)->next;
61
    *p = format;
62
    format->next = NULL;
63
}
64

    
65
void av_register_output_format(AVOutputFormat *format)
66
{
67
    AVOutputFormat **p;
68
    p = &first_oformat;
69
    while (*p != NULL) p = &(*p)->next;
70
    *p = format;
71
    format->next = NULL;
72
}
73

    
74
int match_ext(const char *filename, const char *extensions)
75
{
76
    const char *ext, *p;
77
    char ext1[32], *q;
78

    
79
    if(!filename)
80
        return 0;
81

    
82
    ext = strrchr(filename, '.');
83
    if (ext) {
84
        ext++;
85
        p = extensions;
86
        for(;;) {
87
            q = ext1;
88
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
89
                *q++ = *p++;
90
            *q = '\0';
91
            if (!strcasecmp(ext1, ext))
92
                return 1;
93
            if (*p == '\0')
94
                break;
95
            p++;
96
        }
97
    }
98
    return 0;
99
}
100

    
101
AVOutputFormat *guess_format(const char *short_name, const char *filename,
102
                             const char *mime_type)
103
{
104
    AVOutputFormat *fmt, *fmt_found;
105
    int score_max, score;
106

    
107
    /* specific test for image sequences */
108
#ifdef CONFIG_IMAGE2_MUXER
109
    if (!short_name && filename &&
110
        av_filename_number_test(filename) &&
111
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
112
        return guess_format("image2", NULL, NULL);
113
    }
114
#endif
115
    /* Find the proper file type. */
116
    fmt_found = NULL;
117
    score_max = 0;
118
    fmt = first_oformat;
119
    while (fmt != NULL) {
120
        score = 0;
121
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
122
            score += 100;
123
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
124
            score += 10;
125
        if (filename && fmt->extensions &&
126
            match_ext(filename, fmt->extensions)) {
127
            score += 5;
128
        }
129
        if (score > score_max) {
130
            score_max = score;
131
            fmt_found = fmt;
132
        }
133
        fmt = fmt->next;
134
    }
135
    return fmt_found;
136
}
137

    
138
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
139
                             const char *mime_type)
140
{
141
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
142

    
143
    if (fmt) {
144
        AVOutputFormat *stream_fmt;
145
        char stream_format_name[64];
146

    
147
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
148
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
149

    
150
        if (stream_fmt)
151
            fmt = stream_fmt;
152
    }
153

    
154
    return fmt;
155
}
156

    
157
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
158
                            const char *filename, const char *mime_type, enum CodecType type){
159
    if(type == CODEC_TYPE_VIDEO){
160
        enum CodecID codec_id= CODEC_ID_NONE;
161

    
162
#ifdef CONFIG_IMAGE2_MUXER
163
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
164
            codec_id= av_guess_image2_codec(filename);
165
        }
166
#endif
167
        if(codec_id == CODEC_ID_NONE)
168
            codec_id= fmt->video_codec;
169
        return codec_id;
170
    }else if(type == CODEC_TYPE_AUDIO)
171
        return fmt->audio_codec;
172
    else
173
        return CODEC_ID_NONE;
174
}
175

    
176
AVInputFormat *av_find_input_format(const char *short_name)
177
{
178
    AVInputFormat *fmt;
179
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
180
        if (!strcmp(fmt->name, short_name))
181
            return fmt;
182
    }
183
    return NULL;
184
}
185

    
186
/* memory handling */
187

    
188
void av_destruct_packet(AVPacket *pkt)
189
{
190
    av_free(pkt->data);
191
    pkt->data = NULL; pkt->size = 0;
192
}
193

    
194
void av_init_packet(AVPacket *pkt)
195
{
196
    pkt->pts   = AV_NOPTS_VALUE;
197
    pkt->dts   = AV_NOPTS_VALUE;
198
    pkt->pos   = -1;
199
    pkt->duration = 0;
200
    pkt->flags = 0;
201
    pkt->stream_index = 0;
202
    pkt->destruct= av_destruct_packet_nofree;
203
}
204

    
205
int av_new_packet(AVPacket *pkt, int size)
206
{
207
    uint8_t *data;
208
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
209
        return AVERROR(ENOMEM);
210
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
211
    if (!data)
212
        return AVERROR(ENOMEM);
213
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
214

    
215
    av_init_packet(pkt);
216
    pkt->data = data;
217
    pkt->size = size;
218
    pkt->destruct = av_destruct_packet;
219
    return 0;
220
}
221

    
222
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
223
{
224
    int ret= av_new_packet(pkt, size);
225

    
226
    if(ret<0)
227
        return ret;
228

    
229
    pkt->pos= url_ftell(s);
230

    
231
    ret= get_buffer(s, pkt->data, size);
232
    if(ret<=0)
233
        av_free_packet(pkt);
234
    else
235
        pkt->size= ret;
236

    
237
    return ret;
238
}
239

    
240
int av_dup_packet(AVPacket *pkt)
241
{
242
    if (pkt->destruct != av_destruct_packet) {
243
        uint8_t *data;
244
        /* We duplicate the packet and don't forget to add the padding again. */
245
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
246
            return AVERROR(ENOMEM);
247
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
248
        if (!data) {
249
            return AVERROR(ENOMEM);
250
        }
251
        memcpy(data, pkt->data, pkt->size);
252
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
253
        pkt->data = data;
254
        pkt->destruct = av_destruct_packet;
255
    }
256
    return 0;
257
}
258

    
259
int av_filename_number_test(const char *filename)
260
{
261
    char buf[1024];
262
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
263
}
264

    
265
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
266
{
267
    AVInputFormat *fmt1, *fmt;
268
    int score;
269

    
270
    fmt = NULL;
271
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
272
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
273
            continue;
274
        score = 0;
275
        if (fmt1->read_probe) {
276
            score = fmt1->read_probe(pd);
277
        } else if (fmt1->extensions) {
278
            if (match_ext(pd->filename, fmt1->extensions)) {
279
                score = 50;
280
            }
281
        }
282
        if (score > *score_max) {
283
            *score_max = score;
284
            fmt = fmt1;
285
        }else if (score == *score_max)
286
            fmt = NULL;
287
    }
288
    return fmt;
289
}
290

    
291
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
292
    int score=0;
293
    return av_probe_input_format2(pd, is_opened, &score);
294
}
295

    
296
/************************************************************/
297
/* input media file */
298

    
299
/**
300
 * Open a media file from an IO stream. 'fmt' must be specified.
301
 */
302
static const char* format_to_name(void* ptr)
303
{
304
    AVFormatContext* fc = (AVFormatContext*) ptr;
305
    if(fc->iformat) return fc->iformat->name;
306
    else if(fc->oformat) return fc->oformat->name;
307
    else return "NULL";
308
}
309

    
310
#define OFFSET(x) offsetof(AVFormatContext,x)
311
#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
312
//these names are too long to be readable
313
#define E AV_OPT_FLAG_ENCODING_PARAM
314
#define D AV_OPT_FLAG_DECODING_PARAM
315

    
316
static const AVOption options[]={
317
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
318
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
319
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
320
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
321
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
322
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
323
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
324
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
325
{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
326
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
327
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
328
{"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
329
{NULL},
330
};
331

    
332
#undef E
333
#undef D
334
#undef DEFAULT
335

    
336
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
337

    
338
static void avformat_get_context_defaults(AVFormatContext *s)
339
{
340
    memset(s, 0, sizeof(AVFormatContext));
341

    
342
    s->av_class = &av_format_context_class;
343

    
344
    av_opt_set_defaults(s);
345
}
346

    
347
AVFormatContext *av_alloc_format_context(void)
348
{
349
    AVFormatContext *ic;
350
    ic = av_malloc(sizeof(AVFormatContext));
351
    if (!ic) return ic;
352
    avformat_get_context_defaults(ic);
353
    ic->av_class = &av_format_context_class;
354
    return ic;
355
}
356

    
357
int av_open_input_stream(AVFormatContext **ic_ptr,
358
                         ByteIOContext *pb, const char *filename,
359
                         AVInputFormat *fmt, AVFormatParameters *ap)
360
{
361
    int err;
362
    AVFormatContext *ic;
363
    AVFormatParameters default_ap;
364

    
365
    if(!ap){
366
        ap=&default_ap;
367
        memset(ap, 0, sizeof(default_ap));
368
    }
369

    
370
    if(!ap->prealloced_context)
371
        ic = av_alloc_format_context();
372
    else
373
        ic = *ic_ptr;
374
    if (!ic) {
375
        err = AVERROR(ENOMEM);
376
        goto fail;
377
    }
378
    ic->iformat = fmt;
379
    ic->pb = pb;
380
    ic->duration = AV_NOPTS_VALUE;
381
    ic->start_time = AV_NOPTS_VALUE;
382
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
383

    
384
    /* allocate private data */
385
    if (fmt->priv_data_size > 0) {
386
        ic->priv_data = av_mallocz(fmt->priv_data_size);
387
        if (!ic->priv_data) {
388
            err = AVERROR(ENOMEM);
389
            goto fail;
390
        }
391
    } else {
392
        ic->priv_data = NULL;
393
    }
394

    
395
    err = ic->iformat->read_header(ic, ap);
396
    if (err < 0)
397
        goto fail;
398

    
399
    if (pb && !ic->data_offset)
400
        ic->data_offset = url_ftell(ic->pb);
401

    
402
    *ic_ptr = ic;
403
    return 0;
404
 fail:
405
    if (ic) {
406
        av_freep(&ic->priv_data);
407
    }
408
    av_free(ic);
409
    *ic_ptr = NULL;
410
    return err;
411
}
412

    
413
/** size of probe buffer, for guessing file type from file contents */
414
#define PROBE_BUF_MIN 2048
415
#define PROBE_BUF_MAX (1<<20)
416

    
417
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
418
                       AVInputFormat *fmt,
419
                       int buf_size,
420
                       AVFormatParameters *ap)
421
{
422
    int err, probe_size;
423
    AVProbeData probe_data, *pd = &probe_data;
424
    ByteIOContext *pb = NULL;
425

    
426
    pd->filename = "";
427
    if (filename)
428
        pd->filename = filename;
429
    pd->buf = NULL;
430
    pd->buf_size = 0;
431

    
432
    if (!fmt) {
433
        /* guess format if no file can be opened */
434
        fmt = av_probe_input_format(pd, 0);
435
    }
436

    
437
    /* Do not open file if the format does not need it. XXX: specific
438
       hack needed to handle RTSP/TCP */
439
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
440
        /* if no file needed do not try to open one */
441
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
442
            goto fail;
443
        }
444
        if (buf_size > 0) {
445
            url_setbufsize(pb, buf_size);
446
        }
447

    
448
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
449
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
450
            /* read probe data */
451
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
452
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
453
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
454
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
455
                url_fclose(pb);
456
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
457
                    pb = NULL;
458
                    err = AVERROR(EIO);
459
                    goto fail;
460
                }
461
            }
462
            /* guess file format */
463
            fmt = av_probe_input_format2(pd, 1, &score);
464
        }
465
        av_freep(&pd->buf);
466
    }
467

    
468
    /* if still no format found, error */
469
    if (!fmt) {
470
        err = AVERROR_NOFMT;
471
        goto fail;
472
    }
473

    
474
    /* check filename in case an image number is expected */
475
    if (fmt->flags & AVFMT_NEEDNUMBER) {
476
        if (!av_filename_number_test(filename)) {
477
            err = AVERROR_NUMEXPECTED;
478
            goto fail;
479
        }
480
    }
481
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
482
    if (err)
483
        goto fail;
484
    return 0;
485
 fail:
486
    av_freep(&pd->buf);
487
    if (pb)
488
        url_fclose(pb);
489
    *ic_ptr = NULL;
490
    return err;
491

    
492
}
493

    
494
/*******************************************************/
495

    
496
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
497
{
498
    int ret;
499
    AVStream *st;
500
    av_init_packet(pkt);
501
    ret= s->iformat->read_packet(s, pkt);
502
    if (ret < 0)
503
        return ret;
504
    st= s->streams[pkt->stream_index];
505

    
506
    switch(st->codec->codec_type){
507
    case CODEC_TYPE_VIDEO:
508
        if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
509
        break;
510
    case CODEC_TYPE_AUDIO:
511
        if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
512
        break;
513
    case CODEC_TYPE_SUBTITLE:
514
        if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
515
        break;
516
    }
517

    
518
    return ret;
519
}
520

    
521
/**********************************************************/
522

    
523
/**
524
 * Get the number of samples of an audio frame. Return -1 on error.
525
 */
526
static int get_audio_frame_size(AVCodecContext *enc, int size)
527
{
528
    int frame_size;
529

    
530
    if (enc->frame_size <= 1) {
531
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
532

    
533
        if (bits_per_sample) {
534
            if (enc->channels == 0)
535
                return -1;
536
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
537
        } else {
538
            /* used for example by ADPCM codecs */
539
            if (enc->bit_rate == 0)
540
                return -1;
541
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
542
        }
543
    } else {
544
        frame_size = enc->frame_size;
545
    }
546
    return frame_size;
547
}
548

    
549

    
550
/**
551
 * Return the frame duration in seconds. Return 0 if not available.
552
 */
553
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
554
                                   AVCodecParserContext *pc, AVPacket *pkt)
555
{
556
    int frame_size;
557

    
558
    *pnum = 0;
559
    *pden = 0;
560
    switch(st->codec->codec_type) {
561
    case CODEC_TYPE_VIDEO:
562
        if(st->time_base.num*1000LL > st->time_base.den){
563
            *pnum = st->time_base.num;
564
            *pden = st->time_base.den;
565
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
566
            *pnum = st->codec->time_base.num;
567
            *pden = st->codec->time_base.den;
568
            if (pc && pc->repeat_pict) {
569
                *pden *= 2;
570
                *pnum = (*pnum) * (2 + pc->repeat_pict);
571
            }
572
        }
573
        break;
574
    case CODEC_TYPE_AUDIO:
575
        frame_size = get_audio_frame_size(st->codec, pkt->size);
576
        if (frame_size < 0)
577
            break;
578
        *pnum = frame_size;
579
        *pden = st->codec->sample_rate;
580
        break;
581
    default:
582
        break;
583
    }
584
}
585

    
586
static int is_intra_only(AVCodecContext *enc){
587
    if(enc->codec_type == CODEC_TYPE_AUDIO){
588
        return 1;
589
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
590
        switch(enc->codec_id){
591
        case CODEC_ID_MJPEG:
592
        case CODEC_ID_MJPEGB:
593
        case CODEC_ID_LJPEG:
594
        case CODEC_ID_RAWVIDEO:
595
        case CODEC_ID_DVVIDEO:
596
        case CODEC_ID_HUFFYUV:
597
        case CODEC_ID_FFVHUFF:
598
        case CODEC_ID_ASV1:
599
        case CODEC_ID_ASV2:
600
        case CODEC_ID_VCR1:
601
            return 1;
602
        default: break;
603
        }
604
    }
605
    return 0;
606
}
607

    
608
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
609
                                      int64_t dts, int64_t pts)
610
{
611
    AVStream *st= s->streams[stream_index];
612
    AVPacketList *pktl= s->packet_buffer;
613

    
614
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
615
        return;
616

    
617
    st->first_dts= dts - st->cur_dts;
618
    st->cur_dts= dts;
619

    
620
    for(; pktl; pktl= pktl->next){
621
        if(pktl->pkt.stream_index != stream_index)
622
            continue;
623
        //FIXME think more about this check
624
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
625
            pktl->pkt.pts += st->first_dts;
626

    
627
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
628
            pktl->pkt.dts += st->first_dts;
629

    
630
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
631
            st->start_time= pktl->pkt.pts;
632
    }
633
    if (st->start_time == AV_NOPTS_VALUE)
634
        st->start_time = pts;
635
}
636

    
637
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
638
{
639
    AVPacketList *pktl= s->packet_buffer;
640

    
641
    assert(pkt->duration && !st->cur_dts);
642

    
643
    for(; pktl; pktl= pktl->next){
644
        if(pktl->pkt.stream_index != pkt->stream_index)
645
            continue;
646
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
647
           && !pktl->pkt.duration){
648
            pktl->pkt.pts= pktl->pkt.dts= st->cur_dts;
649
            st->cur_dts += pkt->duration;
650
            pktl->pkt.duration= pkt->duration;
651
        }else
652
            break;
653
    }
654
}
655

    
656
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
657
                               AVCodecParserContext *pc, AVPacket *pkt)
658
{
659
    int num, den, presentation_delayed, delay, i;
660
    int64_t offset;
661

    
662
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
663
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
664
        pkt->dts -= 1LL<<st->pts_wrap_bits;
665
    }
666

    
667
    if (pkt->duration == 0) {
668
        compute_frame_duration(&num, &den, st, pc, pkt);
669
        if (den && num) {
670
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
671

    
672
            if(st->cur_dts == 0 && pkt->duration != 0)
673
                update_initial_durations(s, st, pkt);
674
        }
675
    }
676

    
677
    /* correct timestamps with byte offset if demuxers only have timestamps
678
       on packet boundaries */
679
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
680
        /* this will estimate bitrate based on this frame's duration and size */
681
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
682
        if(pkt->pts != AV_NOPTS_VALUE)
683
            pkt->pts += offset;
684
        if(pkt->dts != AV_NOPTS_VALUE)
685
            pkt->dts += offset;
686
    }
687

    
688
    /* do we have a video B-frame ? */
689
    delay= st->codec->has_b_frames;
690
    presentation_delayed = 0;
691
    /* XXX: need has_b_frame, but cannot get it if the codec is
692
        not initialized */
693
    if (delay &&
694
        pc && pc->pict_type != FF_B_TYPE)
695
        presentation_delayed = 1;
696
    /* This may be redundant, but it should not hurt. */
697
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
698
        presentation_delayed = 1;
699

    
700
    if(st->cur_dts == AV_NOPTS_VALUE){
701
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
702
    }
703

    
704
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
705
    /* interpolate PTS and DTS if they are not present */
706
    if(delay <=1){
707
        if (presentation_delayed) {
708
            /* DTS = decompression timestamp */
709
            /* PTS = presentation timestamp */
710
            if (pkt->dts == AV_NOPTS_VALUE)
711
                pkt->dts = st->last_IP_pts;
712
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
713
            if (pkt->dts == AV_NOPTS_VALUE)
714
                pkt->dts = st->cur_dts;
715

    
716
            /* this is tricky: the dts must be incremented by the duration
717
            of the frame we are displaying, i.e. the last I- or P-frame */
718
            if (st->last_IP_duration == 0)
719
                st->last_IP_duration = pkt->duration;
720
            st->cur_dts = pkt->dts + st->last_IP_duration;
721
            st->last_IP_duration  = pkt->duration;
722
            st->last_IP_pts= pkt->pts;
723
            /* cannot compute PTS if not present (we can compute it only
724
            by knowing the future */
725
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
726
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
727
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
728
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
729
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
730
                    pkt->pts += pkt->duration;
731
    //                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
732
                }
733
            }
734

    
735
            /* presentation is not delayed : PTS and DTS are the same */
736
            if(pkt->pts == AV_NOPTS_VALUE)
737
                pkt->pts = pkt->dts;
738
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
739
            if(pkt->pts == AV_NOPTS_VALUE)
740
                pkt->pts = st->cur_dts;
741
            pkt->dts = pkt->pts;
742
            st->cur_dts = pkt->pts + pkt->duration;
743
        }
744
    }
745

    
746
    if(pkt->pts != AV_NOPTS_VALUE){
747
        st->pts_buffer[0]= pkt->pts;
748
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
749
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
750
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
751
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
752
        if(pkt->dts == AV_NOPTS_VALUE)
753
            pkt->dts= st->pts_buffer[0];
754
        if(delay>1){
755
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
756
        }
757
        if(pkt->dts > st->cur_dts)
758
            st->cur_dts = pkt->dts;
759
    }
760

    
761
//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
762

    
763
    /* update flags */
764
    if(is_intra_only(st->codec))
765
        pkt->flags |= PKT_FLAG_KEY;
766
    else if (pc) {
767
        pkt->flags = 0;
768
        /* keyframe computation */
769
            if (pc->pict_type == FF_I_TYPE)
770
                pkt->flags |= PKT_FLAG_KEY;
771
    }
772
}
773

    
774
void av_destruct_packet_nofree(AVPacket *pkt)
775
{
776
    pkt->data = NULL; pkt->size = 0;
777
}
778

    
779
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
780
{
781
    AVStream *st;
782
    int len, ret, i;
783

    
784
    av_init_packet(pkt);
785

    
786
    for(;;) {
787
        /* select current input stream component */
788
        st = s->cur_st;
789
        if (st) {
790
            if (!st->need_parsing || !st->parser) {
791
                /* no parsing needed: we just output the packet as is */
792
                /* raw data support */
793
                *pkt = s->cur_pkt;
794
                compute_pkt_fields(s, st, NULL, pkt);
795
                s->cur_st = NULL;
796
                break;
797
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
798
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
799
                                      s->cur_ptr, s->cur_len,
800
                                      s->cur_pkt.pts, s->cur_pkt.dts);
801
                s->cur_pkt.pts = AV_NOPTS_VALUE;
802
                s->cur_pkt.dts = AV_NOPTS_VALUE;
803
                /* increment read pointer */
804
                s->cur_ptr += len;
805
                s->cur_len -= len;
806

    
807
                /* return packet if any */
808
                if (pkt->size) {
809
                got_packet:
810
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
811
                    pkt->duration = 0;
812
                    pkt->stream_index = st->index;
813
                    pkt->pts = st->parser->pts;
814
                    pkt->dts = st->parser->dts;
815
                    pkt->destruct = av_destruct_packet_nofree;
816
                    compute_pkt_fields(s, st, st->parser, pkt);
817

    
818
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
819
                        ff_reduce_index(s, st->index);
820
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
821
                                           0, 0, AVINDEX_KEYFRAME);
822
                    }
823

    
824
                    break;
825
                }
826
            } else {
827
                /* free packet */
828
                av_free_packet(&s->cur_pkt);
829
                s->cur_st = NULL;
830
            }
831
        } else {
832
            /* read next packet */
833
            ret = av_read_packet(s, &s->cur_pkt);
834
            if (ret < 0) {
835
                if (ret == AVERROR(EAGAIN))
836
                    return ret;
837
                /* return the last frames, if any */
838
                for(i = 0; i < s->nb_streams; i++) {
839
                    st = s->streams[i];
840
                    if (st->parser && st->need_parsing) {
841
                        av_parser_parse(st->parser, st->codec,
842
                                        &pkt->data, &pkt->size,
843
                                        NULL, 0,
844
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
845
                        if (pkt->size)
846
                            goto got_packet;
847
                    }
848
                }
849
                /* no more packets: really terminate parsing */
850
                return ret;
851
            }
852

    
853
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
854
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
855
               s->cur_pkt.pts < s->cur_pkt.dts){
856
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
857
                    s->cur_pkt.stream_index,
858
                    s->cur_pkt.pts,
859
                    s->cur_pkt.dts,
860
                    s->cur_pkt.size);
861
//                av_free_packet(&s->cur_pkt);
862
//                return -1;
863
            }
864

    
865
            st = s->streams[s->cur_pkt.stream_index];
866
            if(st->codec->debug & FF_DEBUG_PTS)
867
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
868
                    s->cur_pkt.stream_index,
869
                    s->cur_pkt.pts,
870
                    s->cur_pkt.dts,
871
                    s->cur_pkt.size);
872

    
873
            s->cur_st = st;
874
            s->cur_ptr = s->cur_pkt.data;
875
            s->cur_len = s->cur_pkt.size;
876
            if (st->need_parsing && !st->parser) {
877
                st->parser = av_parser_init(st->codec->codec_id);
878
                if (!st->parser) {
879
                    /* no parser available: just output the raw packets */
880
                    st->need_parsing = AVSTREAM_PARSE_NONE;
881
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
882
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
883
                }
884
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
885
                    st->parser->last_frame_offset=
886
                    st->parser->cur_offset= s->cur_pkt.pos;
887
                }
888
            }
889
        }
890
    }
891
    if(st->codec->debug & FF_DEBUG_PTS)
892
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
893
            pkt->stream_index,
894
            pkt->pts,
895
            pkt->dts,
896
            pkt->size);
897

    
898
    return 0;
899
}
900

    
901
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
902
    AVPacketList *pktl= s->packet_buffer;
903
    AVPacketList **plast_pktl= &s->packet_buffer;
904

    
905
    while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
906

    
907
    pktl = av_mallocz(sizeof(AVPacketList));
908
    if (!pktl)
909
        return NULL;
910

    
911
    /* add the packet in the buffered packet list */
912
    *plast_pktl = pktl;
913
    pktl->pkt= *pkt;
914
    return &pktl->pkt;
915
}
916

    
917
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
918
{
919
    AVPacketList *pktl;
920
    int eof=0;
921
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
922

    
923
    for(;;){
924
        pktl = s->packet_buffer;
925
        if (pktl) {
926
            AVPacket *next_pkt= &pktl->pkt;
927

    
928
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
929
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
930
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
931
                       && next_pkt->dts < pktl->pkt.dts
932
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
933
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
934
                        next_pkt->pts= pktl->pkt.dts;
935
                    }
936
                    pktl= pktl->next;
937
                }
938
                pktl = s->packet_buffer;
939
            }
940

    
941
            if(   next_pkt->pts != AV_NOPTS_VALUE
942
               || next_pkt->dts == AV_NOPTS_VALUE
943
               || !genpts || eof){
944
                /* read packet from packet buffer, if there is data */
945
                *pkt = *next_pkt;
946
                s->packet_buffer = pktl->next;
947
                av_free(pktl);
948
                return 0;
949
            }
950
        }
951
        if(genpts){
952
            int ret= av_read_frame_internal(s, pkt);
953
            if(ret<0){
954
                if(pktl && ret != AVERROR(EAGAIN)){
955
                    eof=1;
956
                    continue;
957
                }else
958
                    return ret;
959
            }
960

    
961
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
962
                return AVERROR(ENOMEM);
963
        }else{
964
            assert(!s->packet_buffer);
965
            return av_read_frame_internal(s, pkt);
966
        }
967
    }
968
}
969

    
970
/* XXX: suppress the packet queue */
971
static void flush_packet_queue(AVFormatContext *s)
972
{
973
    AVPacketList *pktl;
974

    
975
    for(;;) {
976
        pktl = s->packet_buffer;
977
        if (!pktl)
978
            break;
979
        s->packet_buffer = pktl->next;
980
        av_free_packet(&pktl->pkt);
981
        av_free(pktl);
982
    }
983
}
984

    
985
/*******************************************************/
986
/* seek support */
987

    
988
int av_find_default_stream_index(AVFormatContext *s)
989
{
990
    int i;
991
    AVStream *st;
992

    
993
    if (s->nb_streams <= 0)
994
        return -1;
995
    for(i = 0; i < s->nb_streams; i++) {
996
        st = s->streams[i];
997
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
998
            return i;
999
        }
1000
    }
1001
    return 0;
1002
}
1003

    
1004
/**
1005
 * Flush the frame reader.
1006
 */
1007
static void av_read_frame_flush(AVFormatContext *s)
1008
{
1009
    AVStream *st;
1010
    int i;
1011

    
1012
    flush_packet_queue(s);
1013

    
1014
    /* free previous packet */
1015
    if (s->cur_st) {
1016
        if (s->cur_st->parser)
1017
            av_free_packet(&s->cur_pkt);
1018
        s->cur_st = NULL;
1019
    }
1020
    /* fail safe */
1021
    s->cur_ptr = NULL;
1022
    s->cur_len = 0;
1023

    
1024
    /* for each stream, reset read state */
1025
    for(i = 0; i < s->nb_streams; i++) {
1026
        st = s->streams[i];
1027

    
1028
        if (st->parser) {
1029
            av_parser_close(st->parser);
1030
            st->parser = NULL;
1031
        }
1032
        st->last_IP_pts = AV_NOPTS_VALUE;
1033
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1034
    }
1035
}
1036

    
1037
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1038
    int i;
1039

    
1040
    for(i = 0; i < s->nb_streams; i++) {
1041
        AVStream *st = s->streams[i];
1042

    
1043
        st->cur_dts = av_rescale(timestamp,
1044
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1045
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1046
    }
1047
}
1048

    
1049
void ff_reduce_index(AVFormatContext *s, int stream_index)
1050
{
1051
    AVStream *st= s->streams[stream_index];
1052
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1053

    
1054
    if((unsigned)st->nb_index_entries >= max_entries){
1055
        int i;
1056
        for(i=0; 2*i<st->nb_index_entries; i++)
1057
            st->index_entries[i]= st->index_entries[2*i];
1058
        st->nb_index_entries= i;
1059
    }
1060
}
1061

    
1062
int av_add_index_entry(AVStream *st,
1063
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1064
{
1065
    AVIndexEntry *entries, *ie;
1066
    int index;
1067

    
1068
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1069
        return -1;
1070

    
1071
    entries = av_fast_realloc(st->index_entries,
1072
                              &st->index_entries_allocated_size,
1073
                              (st->nb_index_entries + 1) *
1074
                              sizeof(AVIndexEntry));
1075
    if(!entries)
1076
        return -1;
1077

    
1078
    st->index_entries= entries;
1079

    
1080
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1081

    
1082
    if(index<0){
1083
        index= st->nb_index_entries++;
1084
        ie= &entries[index];
1085
        assert(index==0 || ie[-1].timestamp < timestamp);
1086
    }else{
1087
        ie= &entries[index];
1088
        if(ie->timestamp != timestamp){
1089
            if(ie->timestamp <= timestamp)
1090
                return -1;
1091
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1092
            st->nb_index_entries++;
1093
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1094
            distance= ie->min_distance;
1095
    }
1096

    
1097
    ie->pos = pos;
1098
    ie->timestamp = timestamp;
1099
    ie->min_distance= distance;
1100
    ie->size= size;
1101
    ie->flags = flags;
1102

    
1103
    return index;
1104
}
1105

    
1106
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1107
                              int flags)
1108
{
1109
    AVIndexEntry *entries= st->index_entries;
1110
    int nb_entries= st->nb_index_entries;
1111
    int a, b, m;
1112
    int64_t timestamp;
1113

    
1114
    a = - 1;
1115
    b = nb_entries;
1116

    
1117
    while (b - a > 1) {
1118
        m = (a + b) >> 1;
1119
        timestamp = entries[m].timestamp;
1120
        if(timestamp >= wanted_timestamp)
1121
            b = m;
1122
        if(timestamp <= wanted_timestamp)
1123
            a = m;
1124
    }
1125
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1126

    
1127
    if(!(flags & AVSEEK_FLAG_ANY)){
1128
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1129
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1130
        }
1131
    }
1132

    
1133
    if(m == nb_entries)
1134
        return -1;
1135
    return  m;
1136
}
1137

    
1138
#define DEBUG_SEEK
1139

    
1140
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1141
    AVInputFormat *avif= s->iformat;
1142
    int64_t pos_min, pos_max, pos, pos_limit;
1143
    int64_t ts_min, ts_max, ts;
1144
    int index;
1145
    AVStream *st;
1146

    
1147
    if (stream_index < 0)
1148
        return -1;
1149

    
1150
#ifdef DEBUG_SEEK
1151
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1152
#endif
1153

    
1154
    ts_max=
1155
    ts_min= AV_NOPTS_VALUE;
1156
    pos_limit= -1; //gcc falsely says it may be uninitialized
1157

    
1158
    st= s->streams[stream_index];
1159
    if(st->index_entries){
1160
        AVIndexEntry *e;
1161

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

    
1166
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1167
            pos_min= e->pos;
1168
            ts_min= e->timestamp;
1169
#ifdef DEBUG_SEEK
1170
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1171
               pos_min,ts_min);
1172
#endif
1173
        }else{
1174
            assert(index==0);
1175
        }
1176

    
1177
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1178
        assert(index < st->nb_index_entries);
1179
        if(index >= 0){
1180
            e= &st->index_entries[index];
1181
            assert(e->timestamp >= target_ts);
1182
            pos_max= e->pos;
1183
            ts_max= e->timestamp;
1184
            pos_limit= pos_max - e->min_distance;
1185
#ifdef DEBUG_SEEK
1186
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1187
               pos_max,pos_limit, ts_max);
1188
#endif
1189
        }
1190
    }
1191

    
1192
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1193
    if(pos<0)
1194
        return -1;
1195

    
1196
    /* do the seek */
1197
    url_fseek(s->pb, pos, SEEK_SET);
1198

    
1199
    av_update_cur_dts(s, st, ts);
1200

    
1201
    return 0;
1202
}
1203

    
1204
int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1205
    int64_t pos, ts;
1206
    int64_t start_pos, filesize;
1207
    int no_change;
1208

    
1209
#ifdef DEBUG_SEEK
1210
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1211
#endif
1212

    
1213
    if(ts_min == AV_NOPTS_VALUE){
1214
        pos_min = s->data_offset;
1215
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1216
        if (ts_min == AV_NOPTS_VALUE)
1217
            return -1;
1218
    }
1219

    
1220
    if(ts_max == AV_NOPTS_VALUE){
1221
        int step= 1024;
1222
        filesize = url_fsize(s->pb);
1223
        pos_max = filesize - 1;
1224
        do{
1225
            pos_max -= step;
1226
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1227
            step += step;
1228
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1229
        if (ts_max == AV_NOPTS_VALUE)
1230
            return -1;
1231

    
1232
        for(;;){
1233
            int64_t tmp_pos= pos_max + 1;
1234
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1235
            if(tmp_ts == AV_NOPTS_VALUE)
1236
                break;
1237
            ts_max= tmp_ts;
1238
            pos_max= tmp_pos;
1239
            if(tmp_pos >= filesize)
1240
                break;
1241
        }
1242
        pos_limit= pos_max;
1243
    }
1244

    
1245
    if(ts_min > ts_max){
1246
        return -1;
1247
    }else if(ts_min == ts_max){
1248
        pos_limit= pos_min;
1249
    }
1250

    
1251
    no_change=0;
1252
    while (pos_min < pos_limit) {
1253
#ifdef DEBUG_SEEK
1254
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1255
               pos_min, pos_max,
1256
               ts_min, ts_max);
1257
#endif
1258
        assert(pos_limit <= pos_max);
1259

    
1260
        if(no_change==0){
1261
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1262
            // interpolate position (better than dichotomy)
1263
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1264
                + pos_min - approximate_keyframe_distance;
1265
        }else if(no_change==1){
1266
            // bisection, if interpolation failed to change min or max pos last time
1267
            pos = (pos_min + pos_limit)>>1;
1268
        }else{
1269
            /* linear search if bisection failed, can only happen if there
1270
               are very few or no keyframes between min/max */
1271
            pos=pos_min;
1272
        }
1273
        if(pos <= pos_min)
1274
            pos= pos_min + 1;
1275
        else if(pos > pos_limit)
1276
            pos= pos_limit;
1277
        start_pos= pos;
1278

    
1279
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1280
        if(pos == pos_max)
1281
            no_change++;
1282
        else
1283
            no_change=0;
1284
#ifdef DEBUG_SEEK
1285
av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1286
#endif
1287
        if(ts == AV_NOPTS_VALUE){
1288
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1289
            return -1;
1290
        }
1291
        assert(ts != AV_NOPTS_VALUE);
1292
        if (target_ts <= ts) {
1293
            pos_limit = start_pos - 1;
1294
            pos_max = pos;
1295
            ts_max = ts;
1296
        }
1297
        if (target_ts >= ts) {
1298
            pos_min = pos;
1299
            ts_min = ts;
1300
        }
1301
    }
1302

    
1303
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1304
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1305
#ifdef DEBUG_SEEK
1306
    pos_min = pos;
1307
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1308
    pos_min++;
1309
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1310
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1311
           pos, ts_min, target_ts, ts_max);
1312
#endif
1313
    *ts_ret= ts;
1314
    return pos;
1315
}
1316

    
1317
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1318
    int64_t pos_min, pos_max;
1319
#if 0
1320
    AVStream *st;
1321

1322
    if (stream_index < 0)
1323
        return -1;
1324

1325
    st= s->streams[stream_index];
1326
#endif
1327

    
1328
    pos_min = s->data_offset;
1329
    pos_max = url_fsize(s->pb) - 1;
1330

    
1331
    if     (pos < pos_min) pos= pos_min;
1332
    else if(pos > pos_max) pos= pos_max;
1333

    
1334
    url_fseek(s->pb, pos, SEEK_SET);
1335

    
1336
#if 0
1337
    av_update_cur_dts(s, st, ts);
1338
#endif
1339
    return 0;
1340
}
1341

    
1342
static int av_seek_frame_generic(AVFormatContext *s,
1343
                                 int stream_index, int64_t timestamp, int flags)
1344
{
1345
    int index;
1346
    AVStream *st;
1347
    AVIndexEntry *ie;
1348

    
1349
    st = s->streams[stream_index];
1350

    
1351
    index = av_index_search_timestamp(st, timestamp, flags);
1352

    
1353
    if(index < 0 || index==st->nb_index_entries-1){
1354
        int i;
1355
        AVPacket pkt;
1356

    
1357
        if(st->index_entries && st->nb_index_entries){
1358
            ie= &st->index_entries[st->nb_index_entries-1];
1359
            url_fseek(s->pb, ie->pos, SEEK_SET);
1360
            av_update_cur_dts(s, st, ie->timestamp);
1361
        }else
1362
            url_fseek(s->pb, 0, SEEK_SET);
1363

    
1364
        for(i=0;; i++) {
1365
            int ret = av_read_frame(s, &pkt);
1366
            if(ret<0)
1367
                break;
1368
            av_free_packet(&pkt);
1369
            if(stream_index == pkt.stream_index){
1370
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1371
                    break;
1372
            }
1373
        }
1374
        index = av_index_search_timestamp(st, timestamp, flags);
1375
    }
1376
    if (index < 0)
1377
        return -1;
1378

    
1379
    av_read_frame_flush(s);
1380
    if (s->iformat->read_seek){
1381
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1382
            return 0;
1383
    }
1384
    ie = &st->index_entries[index];
1385
    url_fseek(s->pb, ie->pos, SEEK_SET);
1386

    
1387
    av_update_cur_dts(s, st, ie->timestamp);
1388

    
1389
    return 0;
1390
}
1391

    
1392
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1393
{
1394
    int ret;
1395
    AVStream *st;
1396

    
1397
    av_read_frame_flush(s);
1398

    
1399
    if(flags & AVSEEK_FLAG_BYTE)
1400
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1401

    
1402
    if(stream_index < 0){
1403
        stream_index= av_find_default_stream_index(s);
1404
        if(stream_index < 0)
1405
            return -1;
1406

    
1407
        st= s->streams[stream_index];
1408
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1409
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1410
    }
1411
    st= s->streams[stream_index];
1412

    
1413
    /* first, we try the format specific seek */
1414
    if (s->iformat->read_seek)
1415
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1416
    else
1417
        ret = -1;
1418
    if (ret >= 0) {
1419
        return 0;
1420
    }
1421

    
1422
    if(s->iformat->read_timestamp)
1423
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1424
    else
1425
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1426
}
1427

    
1428
/*******************************************************/
1429

    
1430
/**
1431
 * Returns TRUE if the stream has accurate duration in any stream.
1432
 *
1433
 * @return TRUE if the stream has accurate duration for at least one component.
1434
 */
1435
static int av_has_duration(AVFormatContext *ic)
1436
{
1437
    int i;
1438
    AVStream *st;
1439

    
1440
    for(i = 0;i < ic->nb_streams; i++) {
1441
        st = ic->streams[i];
1442
        if (st->duration != AV_NOPTS_VALUE)
1443
            return 1;
1444
    }
1445
    return 0;
1446
}
1447

    
1448
/**
1449
 * Estimate the stream timings from the one of each components.
1450
 *
1451
 * Also computes the global bitrate if possible.
1452
 */
1453
static void av_update_stream_timings(AVFormatContext *ic)
1454
{
1455
    int64_t start_time, start_time1, end_time, end_time1;
1456
    int64_t duration, duration1;
1457
    int i;
1458
    AVStream *st;
1459

    
1460
    start_time = INT64_MAX;
1461
    end_time = INT64_MIN;
1462
    duration = INT64_MIN;
1463
    for(i = 0;i < ic->nb_streams; i++) {
1464
        st = ic->streams[i];
1465
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1466
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1467
            if (start_time1 < start_time)
1468
                start_time = start_time1;
1469
            if (st->duration != AV_NOPTS_VALUE) {
1470
                end_time1 = start_time1
1471
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1472
                if (end_time1 > end_time)
1473
                    end_time = end_time1;
1474
            }
1475
        }
1476
        if (st->duration != AV_NOPTS_VALUE) {
1477
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1478
            if (duration1 > duration)
1479
                duration = duration1;
1480
        }
1481
    }
1482
    if (start_time != INT64_MAX) {
1483
        ic->start_time = start_time;
1484
        if (end_time != INT64_MIN) {
1485
            if (end_time - start_time > duration)
1486
                duration = end_time - start_time;
1487
        }
1488
    }
1489
    if (duration != INT64_MIN) {
1490
        ic->duration = duration;
1491
        if (ic->file_size > 0) {
1492
            /* compute the bitrate */
1493
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1494
                (double)ic->duration;
1495
        }
1496
    }
1497
}
1498

    
1499
static void fill_all_stream_timings(AVFormatContext *ic)
1500
{
1501
    int i;
1502
    AVStream *st;
1503

    
1504
    av_update_stream_timings(ic);
1505
    for(i = 0;i < ic->nb_streams; i++) {
1506
        st = ic->streams[i];
1507
        if (st->start_time == AV_NOPTS_VALUE) {
1508
            if(ic->start_time != AV_NOPTS_VALUE)
1509
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1510
            if(ic->duration != AV_NOPTS_VALUE)
1511
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1512
        }
1513
    }
1514
}
1515

    
1516
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1517
{
1518
    int64_t filesize, duration;
1519
    int bit_rate, i;
1520
    AVStream *st;
1521

    
1522
    /* if bit_rate is already set, we believe it */
1523
    if (ic->bit_rate == 0) {
1524
        bit_rate = 0;
1525
        for(i=0;i<ic->nb_streams;i++) {
1526
            st = ic->streams[i];
1527
            bit_rate += st->codec->bit_rate;
1528
        }
1529
        ic->bit_rate = bit_rate;
1530
    }
1531

    
1532
    /* if duration is already set, we believe it */
1533
    if (ic->duration == AV_NOPTS_VALUE &&
1534
        ic->bit_rate != 0 &&
1535
        ic->file_size != 0)  {
1536
        filesize = ic->file_size;
1537
        if (filesize > 0) {
1538
            for(i = 0; i < ic->nb_streams; i++) {
1539
                st = ic->streams[i];
1540
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1541
                if (st->duration == AV_NOPTS_VALUE)
1542
                    st->duration = duration;
1543
            }
1544
        }
1545
    }
1546
}
1547

    
1548
#define DURATION_MAX_READ_SIZE 250000
1549

    
1550
/* only usable for MPEG-PS streams */
1551
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1552
{
1553
    AVPacket pkt1, *pkt = &pkt1;
1554
    AVStream *st;
1555
    int read_size, i, ret;
1556
    int64_t end_time;
1557
    int64_t filesize, offset, duration;
1558

    
1559
    /* free previous packet */
1560
    if (ic->cur_st && ic->cur_st->parser)
1561
        av_free_packet(&ic->cur_pkt);
1562
    ic->cur_st = NULL;
1563

    
1564
    /* flush packet queue */
1565
    flush_packet_queue(ic);
1566

    
1567
    for(i=0;i<ic->nb_streams;i++) {
1568
        st = ic->streams[i];
1569
        if (st->parser) {
1570
            av_parser_close(st->parser);
1571
            st->parser= NULL;
1572
        }
1573
    }
1574

    
1575
    /* we read the first packets to get the first PTS (not fully
1576
       accurate, but it is enough now) */
1577
    url_fseek(ic->pb, 0, SEEK_SET);
1578
    read_size = 0;
1579
    for(;;) {
1580
        if (read_size >= DURATION_MAX_READ_SIZE)
1581
            break;
1582
        /* if all info is available, we can stop */
1583
        for(i = 0;i < ic->nb_streams; i++) {
1584
            st = ic->streams[i];
1585
            if (st->start_time == AV_NOPTS_VALUE)
1586
                break;
1587
        }
1588
        if (i == ic->nb_streams)
1589
            break;
1590

    
1591
        ret = av_read_packet(ic, pkt);
1592
        if (ret != 0)
1593
            break;
1594
        read_size += pkt->size;
1595
        st = ic->streams[pkt->stream_index];
1596
        if (pkt->pts != AV_NOPTS_VALUE) {
1597
            if (st->start_time == AV_NOPTS_VALUE)
1598
                st->start_time = pkt->pts;
1599
        }
1600
        av_free_packet(pkt);
1601
    }
1602

    
1603
    /* estimate the end time (duration) */
1604
    /* XXX: may need to support wrapping */
1605
    filesize = ic->file_size;
1606
    offset = filesize - DURATION_MAX_READ_SIZE;
1607
    if (offset < 0)
1608
        offset = 0;
1609

    
1610
    url_fseek(ic->pb, offset, SEEK_SET);
1611
    read_size = 0;
1612
    for(;;) {
1613
        if (read_size >= DURATION_MAX_READ_SIZE)
1614
            break;
1615

    
1616
        ret = av_read_packet(ic, pkt);
1617
        if (ret != 0)
1618
            break;
1619
        read_size += pkt->size;
1620
        st = ic->streams[pkt->stream_index];
1621
        if (pkt->pts != AV_NOPTS_VALUE &&
1622
            st->start_time != AV_NOPTS_VALUE) {
1623
            end_time = pkt->pts;
1624
            duration = end_time - st->start_time;
1625
            if (duration > 0) {
1626
                if (st->duration == AV_NOPTS_VALUE ||
1627
                    st->duration < duration)
1628
                    st->duration = duration;
1629
            }
1630
        }
1631
        av_free_packet(pkt);
1632
    }
1633

    
1634
    fill_all_stream_timings(ic);
1635

    
1636
    url_fseek(ic->pb, old_offset, SEEK_SET);
1637
    for(i=0; i<ic->nb_streams; i++){
1638
        st= ic->streams[i];
1639
        st->cur_dts= st->first_dts;
1640
        st->last_IP_pts = AV_NOPTS_VALUE;
1641
    }
1642
}
1643

    
1644
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1645
{
1646
    int64_t file_size;
1647

    
1648
    /* get the file size, if possible */
1649
    if (ic->iformat->flags & AVFMT_NOFILE) {
1650
        file_size = 0;
1651
    } else {
1652
        file_size = url_fsize(ic->pb);
1653
        if (file_size < 0)
1654
            file_size = 0;
1655
    }
1656
    ic->file_size = file_size;
1657

    
1658
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1659
         !strcmp(ic->iformat->name, "mpegts")) &&
1660
        file_size && !url_is_streamed(ic->pb)) {
1661
        /* get accurate estimate from the PTSes */
1662
        av_estimate_timings_from_pts(ic, old_offset);
1663
    } else if (av_has_duration(ic)) {
1664
        /* at least one component has timings - we use them for all
1665
           the components */
1666
        fill_all_stream_timings(ic);
1667
    } else {
1668
        /* less precise: use bitrate info */
1669
        av_estimate_timings_from_bit_rate(ic);
1670
    }
1671
    av_update_stream_timings(ic);
1672

    
1673
#if 0
1674
    {
1675
        int i;
1676
        AVStream *st;
1677
        for(i = 0;i < ic->nb_streams; i++) {
1678
            st = ic->streams[i];
1679
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1680
               i, (double)st->start_time / AV_TIME_BASE,
1681
               (double)st->duration / AV_TIME_BASE);
1682
        }
1683
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1684
               (double)ic->start_time / AV_TIME_BASE,
1685
               (double)ic->duration / AV_TIME_BASE,
1686
               ic->bit_rate / 1000);
1687
    }
1688
#endif
1689
}
1690

    
1691
static int has_codec_parameters(AVCodecContext *enc)
1692
{
1693
    int val;
1694
    switch(enc->codec_type) {
1695
    case CODEC_TYPE_AUDIO:
1696
        val = enc->sample_rate;
1697
        break;
1698
    case CODEC_TYPE_VIDEO:
1699
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1700
        break;
1701
    default:
1702
        val = 1;
1703
        break;
1704
    }
1705
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1706
}
1707

    
1708
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1709
{
1710
    int16_t *samples;
1711
    AVCodec *codec;
1712
    int got_picture, data_size, ret=0;
1713
    AVFrame picture;
1714

    
1715
  if(!st->codec->codec){
1716
    codec = avcodec_find_decoder(st->codec->codec_id);
1717
    if (!codec)
1718
        return -1;
1719
    ret = avcodec_open(st->codec, codec);
1720
    if (ret < 0)
1721
        return ret;
1722
  }
1723

    
1724
  if(!has_codec_parameters(st->codec)){
1725
    switch(st->codec->codec_type) {
1726
    case CODEC_TYPE_VIDEO:
1727
        ret = avcodec_decode_video(st->codec, &picture,
1728
                                   &got_picture, data, size);
1729
        break;
1730
    case CODEC_TYPE_AUDIO:
1731
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1732
        samples = av_malloc(data_size);
1733
        if (!samples)
1734
            goto fail;
1735
        ret = avcodec_decode_audio2(st->codec, samples,
1736
                                    &data_size, data, size);
1737
        av_free(samples);
1738
        break;
1739
    default:
1740
        break;
1741
    }
1742
  }
1743
 fail:
1744
    return ret;
1745
}
1746

    
1747
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1748
{
1749
    AVInputFormat *fmt;
1750
    fmt = av_probe_input_format2(pd, 1, &score);
1751

    
1752
    if (fmt) {
1753
        if (strncmp(fmt->name, "mp3", 3) == 0)
1754
            st->codec->codec_id = CODEC_ID_MP3;
1755
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1756
            st->codec->codec_id = CODEC_ID_AC3;
1757
    }
1758
    return !!fmt;
1759
}
1760

    
1761
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1762
{
1763
    while (tags->id != CODEC_ID_NONE) {
1764
        if (tags->id == id)
1765
            return tags->tag;
1766
        tags++;
1767
    }
1768
    return 0;
1769
}
1770

    
1771
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1772
{
1773
    int i;
1774
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1775
        if(tag == tags[i].tag)
1776
            return tags[i].id;
1777
    }
1778
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1779
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1780
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1781
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1782
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1783
            return tags[i].id;
1784
    }
1785
    return CODEC_ID_NONE;
1786
}
1787

    
1788
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1789
{
1790
    int i;
1791
    for(i=0; tags && tags[i]; i++){
1792
        int tag= codec_get_tag(tags[i], id);
1793
        if(tag) return tag;
1794
    }
1795
    return 0;
1796
}
1797

    
1798
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1799
{
1800
    int i;
1801
    for(i=0; tags && tags[i]; i++){
1802
        enum CodecID id= codec_get_id(tags[i], tag);
1803
        if(id!=CODEC_ID_NONE) return id;
1804
    }
1805
    return CODEC_ID_NONE;
1806
}
1807

    
1808
/* absolute maximum size we read until we abort */
1809
#define MAX_READ_SIZE        5000000
1810

    
1811
#define MAX_STD_TIMEBASES (60*12+5)
1812
static int get_std_framerate(int i){
1813
    if(i<60*12) return i*1001;
1814
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1815
}
1816

    
1817
/*
1818
 * Is the time base unreliable.
1819
 * This is a heuristic to balance between quick acceptance of the values in
1820
 * the headers vs. some extra checks.
1821
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1822
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1823
 * And there are "variable" fps files this needs to detect as well.
1824
 */
1825
static int tb_unreliable(AVCodecContext *c){
1826
    if(   c->time_base.den >= 101L*c->time_base.num
1827
       || c->time_base.den <    5L*c->time_base.num
1828
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1829
       || c->codec_tag == ff_get_fourcc("XVID")*/
1830
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1831
        return 1;
1832
    return 0;
1833
}
1834

    
1835
int av_find_stream_info(AVFormatContext *ic)
1836
{
1837
    int i, count, ret, read_size, j;
1838
    AVStream *st;
1839
    AVPacket pkt1, *pkt;
1840
    int64_t last_dts[MAX_STREAMS];
1841
    int duration_count[MAX_STREAMS]={0};
1842
    double (*duration_error)[MAX_STD_TIMEBASES];
1843
    offset_t old_offset = url_ftell(ic->pb);
1844
    int64_t codec_info_duration[MAX_STREAMS]={0};
1845
    int codec_info_nb_frames[MAX_STREAMS]={0};
1846
    AVProbeData probe_data[MAX_STREAMS];
1847
    int codec_identified[MAX_STREAMS]={0};
1848

    
1849
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1850
    if (!duration_error) return AVERROR(ENOMEM);
1851

    
1852
    for(i=0;i<ic->nb_streams;i++) {
1853
        st = ic->streams[i];
1854
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1855
/*            if(!st->time_base.num)
1856
                st->time_base= */
1857
            if(!st->codec->time_base.num)
1858
                st->codec->time_base= st->time_base;
1859
        }
1860
        //only for the split stuff
1861
        if (!st->parser) {
1862
            st->parser = av_parser_init(st->codec->codec_id);
1863
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1864
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1865
            }
1866
        }
1867
    }
1868

    
1869
    for(i=0;i<MAX_STREAMS;i++){
1870
        last_dts[i]= AV_NOPTS_VALUE;
1871
    }
1872

    
1873
    memset(probe_data, 0, sizeof(probe_data));
1874
    count = 0;
1875
    read_size = 0;
1876
    for(;;) {
1877
        /* check if one codec still needs to be handled */
1878
        for(i=0;i<ic->nb_streams;i++) {
1879
            st = ic->streams[i];
1880
            if (!has_codec_parameters(st->codec))
1881
                break;
1882
            /* variable fps and no guess at the real fps */
1883
            if(   tb_unreliable(st->codec)
1884
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1885
                break;
1886
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1887
                break;
1888
            if(st->first_dts == AV_NOPTS_VALUE)
1889
                break;
1890
        }
1891
        if (i == ic->nb_streams) {
1892
            /* NOTE: if the format has no header, then we need to read
1893
               some packets to get most of the streams, so we cannot
1894
               stop here */
1895
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1896
                /* if we found the info for all the codecs, we can stop */
1897
                ret = count;
1898
                break;
1899
            }
1900
        }
1901
        /* we did not get all the codec info, but we read too much data */
1902
        if (read_size >= MAX_READ_SIZE) {
1903
            ret = count;
1904
            break;
1905
        }
1906

    
1907
        /* NOTE: a new stream can be added there if no header in file
1908
           (AVFMTCTX_NOHEADER) */
1909
        ret = av_read_frame_internal(ic, &pkt1);
1910
        if (ret < 0) {
1911
            /* EOF or error */
1912
            ret = -1; /* we could not have all the codec parameters before EOF */
1913
            for(i=0;i<ic->nb_streams;i++) {
1914
                st = ic->streams[i];
1915
                if (!has_codec_parameters(st->codec)){
1916
                    char buf[256];
1917
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1918
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1919
                } else {
1920
                    ret = 0;
1921
                }
1922
            }
1923
            break;
1924
        }
1925

    
1926
        pkt= add_to_pktbuf(ic, &pkt1);
1927
        if(av_dup_packet(pkt) < 0)
1928
            return AVERROR(ENOMEM);
1929

    
1930
        read_size += pkt->size;
1931

    
1932
        st = ic->streams[pkt->stream_index];
1933
        if(codec_info_nb_frames[st->index]>1)
1934
            codec_info_duration[st->index] += pkt->duration;
1935
        if (pkt->duration != 0)
1936
            codec_info_nb_frames[st->index]++;
1937

    
1938
        {
1939
            int index= pkt->stream_index;
1940
            int64_t last= last_dts[index];
1941
            int64_t duration= pkt->dts - last;
1942

    
1943
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1944
                double dur= duration * av_q2d(st->time_base);
1945

    
1946
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1947
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1948
                if(duration_count[index] < 2)
1949
                    memset(duration_error[index], 0, sizeof(*duration_error));
1950
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1951
                    int framerate= get_std_framerate(i);
1952
                    int ticks= lrintf(dur*framerate/(1001*12));
1953
                    double error= dur - ticks*1001*12/(double)framerate;
1954
                    duration_error[index][i] += error*error;
1955
                }
1956
                duration_count[index]++;
1957
            }
1958
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1959
                last_dts[pkt->stream_index]= pkt->dts;
1960

    
1961
            if (st->codec->codec_id == CODEC_ID_NONE) {
1962
                AVProbeData *pd = &(probe_data[st->index]);
1963
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1964
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1965
                pd->buf_size += pkt->size;
1966
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1967
            }
1968
        }
1969
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1970
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1971
            if(i){
1972
                st->codec->extradata_size= i;
1973
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1974
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1975
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1976
            }
1977
        }
1978

    
1979
        /* if still no information, we try to open the codec and to
1980
           decompress the frame. We try to avoid that in most cases as
1981
           it takes longer and uses more memory. For MPEG-4, we need to
1982
           decompress for QuickTime. */
1983
        if (!has_codec_parameters(st->codec) /*&&
1984
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1985
             st->codec->codec_id == CODEC_ID_H264 ||
1986
             st->codec->codec_id == CODEC_ID_H263 ||
1987
             st->codec->codec_id == CODEC_ID_H261 ||
1988
             st->codec->codec_id == CODEC_ID_VORBIS ||
1989
             st->codec->codec_id == CODEC_ID_MJPEG ||
1990
             st->codec->codec_id == CODEC_ID_PNG ||
1991
             st->codec->codec_id == CODEC_ID_PAM ||
1992
             st->codec->codec_id == CODEC_ID_PGM ||
1993
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1994
             st->codec->codec_id == CODEC_ID_PBM ||
1995
             st->codec->codec_id == CODEC_ID_PPM ||
1996
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1997
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1998
            try_decode_frame(st, pkt->data, pkt->size);
1999

    
2000
        if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2001
            break;
2002
        }
2003
        count++;
2004
    }
2005

    
2006
    // close codecs which were opened in try_decode_frame()
2007
    for(i=0;i<ic->nb_streams;i++) {
2008
        st = ic->streams[i];
2009
        if(st->codec->codec)
2010
            avcodec_close(st->codec);
2011
    }
2012
    for(i=0;i<ic->nb_streams;i++) {
2013
        st = ic->streams[i];
2014
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2015
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2016
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2017

    
2018
            if(duration_count[i]
2019
               && tb_unreliable(st->codec) /*&&
2020
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2021
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2022
                double best_error= 2*av_q2d(st->time_base);
2023
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2024

    
2025
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2026
                    double error= duration_error[i][j] * get_std_framerate(j);
2027
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2028
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2029
                    if(error < best_error){
2030
                        best_error= error;
2031
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2032
                    }
2033
                }
2034
            }
2035

    
2036
            if (!st->r_frame_rate.num){
2037
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2038
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2039
                    st->r_frame_rate.num = st->codec->time_base.den;
2040
                    st->r_frame_rate.den = st->codec->time_base.num;
2041
                }else{
2042
                    st->r_frame_rate.num = st->time_base.den;
2043
                    st->r_frame_rate.den = st->time_base.num;
2044
                }
2045
            }
2046
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2047
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2048
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2049
                if (codec_identified[st->index]) {
2050
                    st->need_parsing = AVSTREAM_PARSE_FULL;
2051
                }
2052
            }
2053
            if(!st->codec->bits_per_sample)
2054
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2055
        }
2056
    }
2057

    
2058
    av_estimate_timings(ic, old_offset);
2059

    
2060
    for(i=0;i<ic->nb_streams;i++) {
2061
        st = ic->streams[i];
2062
        if (codec_identified[st->index])
2063
            break;
2064
    }
2065
    //FIXME this is a mess
2066
    if(i!=ic->nb_streams){
2067
        av_read_frame_flush(ic);
2068
        for(i=0;i<ic->nb_streams;i++) {
2069
            st = ic->streams[i];
2070
            if (codec_identified[st->index]) {
2071
                av_seek_frame(ic, st->index, 0.0, 0);
2072
            }
2073
            st->cur_dts= st->first_dts;
2074
        }
2075
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2076
    }
2077

    
2078
#if 0
2079
    /* correct DTS for B-frame streams with no timestamps */
2080
    for(i=0;i<ic->nb_streams;i++) {
2081
        st = ic->streams[i];
2082
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2083
            if(b-frames){
2084
                ppktl = &ic->packet_buffer;
2085
                while(ppkt1){
2086
                    if(ppkt1->stream_index != i)
2087
                        continue;
2088
                    if(ppkt1->pkt->dts < 0)
2089
                        break;
2090
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2091
                        break;
2092
                    ppkt1->pkt->dts -= delta;
2093
                    ppkt1= ppkt1->next;
2094
                }
2095
                if(ppkt1)
2096
                    continue;
2097
                st->cur_dts -= delta;
2098
            }
2099
        }
2100
    }
2101
#endif
2102

    
2103
    av_free(duration_error);
2104
    for(i=0;i<MAX_STREAMS;i++){
2105
        av_freep(&(probe_data[i].buf));
2106
    }
2107

    
2108
    return ret;
2109
}
2110

    
2111
/*******************************************************/
2112

    
2113
int av_read_play(AVFormatContext *s)
2114
{
2115
    if (s->iformat->read_play)
2116
        return s->iformat->read_play(s);
2117
    if (s->pb)
2118
        return av_url_read_fpause(s->pb, 0);
2119
    return AVERROR(ENOSYS);
2120
}
2121

    
2122
int av_read_pause(AVFormatContext *s)
2123
{
2124
    if (s->iformat->read_pause)
2125
        return s->iformat->read_pause(s);
2126
    if (s->pb)
2127
        return av_url_read_fpause(s->pb, 1);
2128
    return AVERROR(ENOSYS);
2129
}
2130

    
2131
void av_close_input_stream(AVFormatContext *s)
2132
{
2133
    int i;
2134
    AVStream *st;
2135

    
2136
    /* free previous packet */
2137
    if (s->cur_st && s->cur_st->parser)
2138
        av_free_packet(&s->cur_pkt);
2139

    
2140
    if (s->iformat->read_close)
2141
        s->iformat->read_close(s);
2142
    for(i=0;i<s->nb_streams;i++) {
2143
        /* free all data in a stream component */
2144
        st = s->streams[i];
2145
        if (st->parser) {
2146
            av_parser_close(st->parser);
2147
        }
2148
        av_free(st->index_entries);
2149
        av_free(st->codec->extradata);
2150
        av_free(st->codec);
2151
        av_free(st->filename);
2152
        av_free(st);
2153
    }
2154
    for(i=s->nb_programs-1; i>=0; i--) {
2155
        av_freep(&s->programs[i]->provider_name);
2156
        av_freep(&s->programs[i]->name);
2157
        av_freep(&s->programs[i]->stream_index);
2158
        av_freep(&s->programs[i]);
2159
    }
2160
    av_freep(&s->programs);
2161
    flush_packet_queue(s);
2162
    av_freep(&s->priv_data);
2163
    while(s->nb_chapters--) {
2164
        av_free(s->chapters[s->nb_chapters]->title);
2165
        av_free(s->chapters[s->nb_chapters]);
2166
    }
2167
    av_freep(&s->chapters);
2168
    av_free(s);
2169
}
2170

    
2171
void av_close_input_file(AVFormatContext *s)
2172
{
2173
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2174
    av_close_input_stream(s);
2175
    if (pb)
2176
        url_fclose(pb);
2177
}
2178

    
2179
AVStream *av_new_stream(AVFormatContext *s, int id)
2180
{
2181
    AVStream *st;
2182
    int i;
2183

    
2184
    if (s->nb_streams >= MAX_STREAMS)
2185
        return NULL;
2186

    
2187
    st = av_mallocz(sizeof(AVStream));
2188
    if (!st)
2189
        return NULL;
2190

    
2191
    st->codec= avcodec_alloc_context();
2192
    if (s->iformat) {
2193
        /* no default bitrate if decoding */
2194
        st->codec->bit_rate = 0;
2195
    }
2196
    st->index = s->nb_streams;
2197
    st->id = id;
2198
    st->start_time = AV_NOPTS_VALUE;
2199
    st->duration = AV_NOPTS_VALUE;
2200
    st->cur_dts = AV_NOPTS_VALUE;
2201
    st->first_dts = AV_NOPTS_VALUE;
2202

    
2203
    /* default pts setting is MPEG-like */
2204
    av_set_pts_info(st, 33, 1, 90000);
2205
    st->last_IP_pts = AV_NOPTS_VALUE;
2206
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2207
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2208

    
2209
    s->streams[s->nb_streams++] = st;
2210
    return st;
2211
}
2212

    
2213
AVProgram *av_new_program(AVFormatContext *ac, int id)
2214
{
2215
    AVProgram *program=NULL;
2216
    int i;
2217

    
2218
#ifdef DEBUG_SI
2219
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2220
#endif
2221

    
2222
    for(i=0; i<ac->nb_programs; i++)
2223
        if(ac->programs[i]->id == id)
2224
            program = ac->programs[i];
2225

    
2226
    if(!program){
2227
        program = av_mallocz(sizeof(AVProgram));
2228
        if (!program)
2229
            return NULL;
2230
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2231
        program->discard = AVDISCARD_NONE;
2232
    }
2233
    program->id = id;
2234

    
2235
    return program;
2236
}
2237

    
2238
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2239
{
2240
    assert(!provider_name == !name);
2241
    if(name){
2242
        av_free(program->provider_name);
2243
        av_free(program->         name);
2244
        program->provider_name = av_strdup(provider_name);
2245
        program->         name = av_strdup(         name);
2246
    }
2247
}
2248

    
2249
AVChapter *ff_new_chapter(AVFormatContext *s, int id, int64_t start, int64_t end, const char *title)
2250
{
2251
    AVChapter *chapter = NULL;
2252
    int i;
2253

    
2254
    for(i=0; i<s->nb_chapters; i++)
2255
        if(s->chapters[i]->id == id)
2256
            chapter = s->chapters[i];
2257

    
2258
    if(!chapter){
2259
        chapter= av_mallocz(sizeof(AVChapter));
2260
        if(!chapter)
2261
            return NULL;
2262
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2263
    }
2264
    if(chapter->title)
2265
        av_free(chapter->title);
2266
    chapter->title = av_strdup(title);
2267
    chapter->id    = id;
2268
    chapter->start = start;
2269
    chapter->end   = end;
2270

    
2271
    return chapter;
2272
}
2273

    
2274
/************************************************************/
2275
/* output media file */
2276

    
2277
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2278
{
2279
    int ret;
2280

    
2281
    if (s->oformat->priv_data_size > 0) {
2282
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2283
        if (!s->priv_data)
2284
            return AVERROR(ENOMEM);
2285
    } else
2286
        s->priv_data = NULL;
2287

    
2288
    if (s->oformat->set_parameters) {
2289
        ret = s->oformat->set_parameters(s, ap);
2290
        if (ret < 0)
2291
            return ret;
2292
    }
2293
    return 0;
2294
}
2295

    
2296
int av_write_header(AVFormatContext *s)
2297
{
2298
    int ret, i;
2299
    AVStream *st;
2300

    
2301
    // some sanity checks
2302
    for(i=0;i<s->nb_streams;i++) {
2303
        st = s->streams[i];
2304

    
2305
        switch (st->codec->codec_type) {
2306
        case CODEC_TYPE_AUDIO:
2307
            if(st->codec->sample_rate<=0){
2308
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2309
                return -1;
2310
            }
2311
            break;
2312
        case CODEC_TYPE_VIDEO:
2313
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2314
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2315
                return -1;
2316
            }
2317
            if(st->codec->width<=0 || st->codec->height<=0){
2318
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2319
                return -1;
2320
            }
2321
            break;
2322
        }
2323

    
2324
        if(s->oformat->codec_tag){
2325
            if(st->codec->codec_tag){
2326
                //FIXME
2327
                //check that tag + id is in the table
2328
                //if neither is in the table -> OK
2329
                //if tag is in the table with another id -> FAIL
2330
                //if id is in the table with another tag -> FAIL unless strict < ?
2331
            }else
2332
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2333
        }
2334
    }
2335

    
2336
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2337
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2338
        if (!s->priv_data)
2339
            return AVERROR(ENOMEM);
2340
    }
2341

    
2342
    if(s->oformat->write_header){
2343
        ret = s->oformat->write_header(s);
2344
        if (ret < 0)
2345
            return ret;
2346
    }
2347

    
2348
    /* init PTS generation */
2349
    for(i=0;i<s->nb_streams;i++) {
2350
        int64_t den = AV_NOPTS_VALUE;
2351
        st = s->streams[i];
2352

    
2353
        switch (st->codec->codec_type) {
2354
        case CODEC_TYPE_AUDIO:
2355
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2356
            break;
2357
        case CODEC_TYPE_VIDEO:
2358
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2359
            break;
2360
        default:
2361
            break;
2362
        }
2363
        if (den != AV_NOPTS_VALUE) {
2364
            if (den <= 0)
2365
                return AVERROR_INVALIDDATA;
2366
            av_frac_init(&st->pts, 0, 0, den);
2367
        }
2368
    }
2369
    return 0;
2370
}
2371

    
2372
//FIXME merge with compute_pkt_fields
2373
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2374
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2375
    int num, den, frame_size, i;
2376

    
2377
//    av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2378

    
2379
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2380
        return -1;*/
2381

    
2382
    /* duration field */
2383
    if (pkt->duration == 0) {
2384
        compute_frame_duration(&num, &den, st, NULL, pkt);
2385
        if (den && num) {
2386
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2387
        }
2388
    }
2389

    
2390
    //XXX/FIXME this is a temporary hack until all encoders output pts
2391
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2392
        pkt->dts=
2393
//        pkt->pts= st->cur_dts;
2394
        pkt->pts= st->pts.val;
2395
    }
2396

    
2397
    //calculate dts from pts
2398
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2399
        st->pts_buffer[0]= pkt->pts;
2400
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2401
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2402
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2403
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2404

    
2405
        pkt->dts= st->pts_buffer[0];
2406
    }
2407

    
2408
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2409
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2410
        return -1;
2411
    }
2412
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2413
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2414
        return -1;
2415
    }
2416

    
2417
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2418
    st->cur_dts= pkt->dts;
2419
    st->pts.val= pkt->dts;
2420

    
2421
    /* update pts */
2422
    switch (st->codec->codec_type) {
2423
    case CODEC_TYPE_AUDIO:
2424
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2425

    
2426
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2427
           likely equal to the encoder delay, but it would be better if we
2428
           had the real timestamps from the encoder */
2429
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2430
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2431
        }
2432
        break;
2433
    case CODEC_TYPE_VIDEO:
2434
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2435
        break;
2436
    default:
2437
        break;
2438
    }
2439
    return 0;
2440
}
2441

    
2442
static void truncate_ts(AVStream *st, AVPacket *pkt){
2443
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2444

    
2445
//    if(pkt->dts < 0)
2446
//        pkt->dts= 0;  //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
2447

    
2448
    if (pkt->pts != AV_NOPTS_VALUE)
2449
        pkt->pts &= pts_mask;
2450
    if (pkt->dts != AV_NOPTS_VALUE)
2451
        pkt->dts &= pts_mask;
2452
}
2453

    
2454
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2455
{
2456
    int ret;
2457

    
2458
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2459
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2460
        return ret;
2461

    
2462
    truncate_ts(s->streams[pkt->stream_index], pkt);
2463

    
2464
    ret= s->oformat->write_packet(s, pkt);
2465
    if(!ret)
2466
        ret= url_ferror(s->pb);
2467
    return ret;
2468
}
2469

    
2470
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2471
    AVPacketList *pktl, **next_point, *this_pktl;
2472
    int stream_count=0;
2473
    int streams[MAX_STREAMS];
2474

    
2475
    if(pkt){
2476
        AVStream *st= s->streams[ pkt->stream_index];
2477

    
2478
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2479

    
2480
        this_pktl = av_mallocz(sizeof(AVPacketList));
2481
        this_pktl->pkt= *pkt;
2482
        if(pkt->destruct == av_destruct_packet)
2483
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2484
        else
2485
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2486

    
2487
        next_point = &s->packet_buffer;
2488
        while(*next_point){
2489
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2490
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2491
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2492
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2493
                break;
2494
            next_point= &(*next_point)->next;
2495
        }
2496
        this_pktl->next= *next_point;
2497
        *next_point= this_pktl;
2498
    }
2499

    
2500
    memset(streams, 0, sizeof(streams));
2501
    pktl= s->packet_buffer;
2502
    while(pktl){
2503
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2504
        if(streams[ pktl->pkt.stream_index ] == 0)
2505
            stream_count++;
2506
        streams[ pktl->pkt.stream_index ]++;
2507
        pktl= pktl->next;
2508
    }
2509

    
2510
    if(s->nb_streams == stream_count || (flush && stream_count)){
2511
        pktl= s->packet_buffer;
2512
        *out= pktl->pkt;
2513

    
2514
        s->packet_buffer= pktl->next;
2515
        av_freep(&pktl);
2516
        return 1;
2517
    }else{
2518
        av_init_packet(out);
2519
        return 0;
2520
    }
2521
}
2522

    
2523
/**
2524
 * Interleaves an AVPacket correctly so it can be muxed.
2525
 * @param out the interleaved packet will be output here
2526
 * @param in the input packet
2527
 * @param flush 1 if no further packets are available as input and all
2528
 *              remaining packets should be output
2529
 * @return 1 if a packet was output, 0 if no packet could be output,
2530
 *         < 0 if an error occurred
2531
 */
2532
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2533
    if(s->oformat->interleave_packet)
2534
        return s->oformat->interleave_packet(s, out, in, flush);
2535
    else
2536
        return av_interleave_packet_per_dts(s, out, in, flush);
2537
}
2538

    
2539
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2540
    AVStream *st= s->streams[ pkt->stream_index];
2541

    
2542
    //FIXME/XXX/HACK drop zero sized packets
2543
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2544
        return 0;
2545

    
2546
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2547
    if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2548
        return -1;
2549

    
2550
    if(pkt->dts == AV_NOPTS_VALUE)
2551
        return -1;
2552

    
2553
    for(;;){
2554
        AVPacket opkt;
2555
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2556
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2557
            return ret;
2558

    
2559
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2560
        ret= s->oformat->write_packet(s, &opkt);
2561

    
2562
        av_free_packet(&opkt);
2563
        pkt= NULL;
2564

    
2565
        if(ret<0)
2566
            return ret;
2567
        if(url_ferror(s->pb))
2568
            return url_ferror(s->pb);
2569
    }
2570
}
2571

    
2572
int av_write_trailer(AVFormatContext *s)
2573
{
2574
    int ret, i;
2575

    
2576
    for(;;){
2577
        AVPacket pkt;
2578
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2579
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2580
            goto fail;
2581
        if(!ret)
2582
            break;
2583

    
2584
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2585
        ret= s->oformat->write_packet(s, &pkt);
2586

    
2587
        av_free_packet(&pkt);
2588

    
2589
        if(ret<0)
2590
            goto fail;
2591
        if(url_ferror(s->pb))
2592
            goto fail;
2593
    }
2594

    
2595
    if(s->oformat->write_trailer)
2596
        ret = s->oformat->write_trailer(s);
2597
fail:
2598
    if(ret == 0)
2599
       ret=url_ferror(s->pb);
2600
    for(i=0;i<s->nb_streams;i++)
2601
        av_freep(&s->streams[i]->priv_data);
2602
    av_freep(&s->priv_data);
2603
    return ret;
2604
}
2605

    
2606
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2607
{
2608
    int i, j;
2609
    AVProgram *program=NULL;
2610
    void *tmp;
2611

    
2612
    for(i=0; i<ac->nb_programs; i++){
2613
        if(ac->programs[i]->id != progid)
2614
            continue;
2615
        program = ac->programs[i];
2616
        for(j=0; j<program->nb_stream_indexes; j++)
2617
            if(program->stream_index[j] == idx)
2618
                return;
2619

    
2620
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2621
        if(!tmp)
2622
            return;
2623
        program->stream_index = tmp;
2624
        program->stream_index[program->nb_stream_indexes++] = idx;
2625
        return;
2626
    }
2627
}
2628

    
2629
/* "user interface" functions */
2630
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2631
{
2632
    char buf[256];
2633
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2634
    AVStream *st = ic->streams[i];
2635
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2636
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2637
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2638
    /* the pid is an important information, so we display it */
2639
    /* XXX: add a generic system */
2640
    if (flags & AVFMT_SHOW_IDS)
2641
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2642
    if (strlen(st->language) > 0)
2643
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2644
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2645
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2646
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2647
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2648
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2649
/*      else if(st->time_base.den && st->time_base.num)
2650
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2651
        else
2652
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2653
    }
2654
    av_log(NULL, AV_LOG_INFO, "\n");
2655
}
2656

    
2657
void dump_format(AVFormatContext *ic,
2658
                 int index,
2659
                 const char *url,
2660
                 int is_output)
2661
{
2662
    int i;
2663

    
2664
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2665
            is_output ? "Output" : "Input",
2666
            index,
2667
            is_output ? ic->oformat->name : ic->iformat->name,
2668
            is_output ? "to" : "from", url);
2669
    if (!is_output) {
2670
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2671
        if (ic->duration != AV_NOPTS_VALUE) {
2672
            int hours, mins, secs, us;
2673
            secs = ic->duration / AV_TIME_BASE;
2674
            us = ic->duration % AV_TIME_BASE;
2675
            mins = secs / 60;
2676
            secs %= 60;
2677
            hours = mins / 60;
2678
            mins %= 60;
2679
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2680
                   (100 * us) / AV_TIME_BASE);
2681
        } else {
2682
            av_log(NULL, AV_LOG_INFO, "N/A");
2683
        }
2684
        if (ic->start_time != AV_NOPTS_VALUE) {
2685
            int secs, us;
2686
            av_log(NULL, AV_LOG_INFO, ", start: ");
2687
            secs = ic->start_time / AV_TIME_BASE;
2688
            us = ic->start_time % AV_TIME_BASE;
2689
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2690
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2691
        }
2692
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2693
        if (ic->bit_rate) {
2694
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2695
        } else {
2696
            av_log(NULL, AV_LOG_INFO, "N/A");
2697
        }
2698
        av_log(NULL, AV_LOG_INFO, "\n");
2699
    }
2700
    if(ic->nb_programs) {
2701
        int j, k;
2702
        for(j=0; j<ic->nb_programs; j++) {
2703
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2704
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2705
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2706
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2707
         }
2708
    } else
2709
    for(i=0;i<ic->nb_streams;i++)
2710
        dump_stream_format(ic, i, index, is_output);
2711
}
2712

    
2713
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2714
{
2715
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2716
}
2717

    
2718
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2719
{
2720
    AVRational frame_rate;
2721
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2722
    *frame_rate_num= frame_rate.num;
2723
    *frame_rate_den= frame_rate.den;
2724
    return ret;
2725
}
2726

    
2727
/**
2728
 * Gets the current time in microseconds.
2729
 */
2730
int64_t av_gettime(void)
2731
{
2732
    struct timeval tv;
2733
    gettimeofday(&tv,NULL);
2734
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2735
}
2736

    
2737
int64_t parse_date(const char *datestr, int duration)
2738
{
2739
    const char *p;
2740
    int64_t t;
2741
    struct tm dt;
2742
    int i;
2743
    static const char *date_fmt[] = {
2744
        "%Y-%m-%d",
2745
        "%Y%m%d",
2746
    };
2747
    static const char *time_fmt[] = {
2748
        "%H:%M:%S",
2749
        "%H%M%S",
2750
    };
2751
    const char *q;
2752
    int is_utc, len;
2753
    char lastch;
2754
    int negative = 0;
2755

    
2756
#undef time
2757
    time_t now = time(0);
2758

    
2759
    len = strlen(datestr);
2760
    if (len > 0)
2761
        lastch = datestr[len - 1];
2762
    else
2763
        lastch = '\0';
2764
    is_utc = (lastch == 'z' || lastch == 'Z');
2765

    
2766
    memset(&dt, 0, sizeof(dt));
2767

    
2768
    p = datestr;
2769
    q = NULL;
2770
    if (!duration) {
2771
        /* parse the year-month-day part */
2772
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2773
            q = small_strptime(p, date_fmt[i], &dt);
2774
            if (q) {
2775
                break;
2776
            }
2777
        }
2778

    
2779
        /* if the year-month-day part is missing, then take the
2780
         * current year-month-day time */
2781
        if (!q) {
2782
            if (is_utc) {
2783
                dt = *gmtime(&now);
2784
            } else {
2785
                dt = *localtime(&now);
2786
            }
2787
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2788
        } else {
2789
            p = q;
2790
        }
2791

    
2792
        if (*p == 'T' || *p == 't' || *p == ' ')
2793
            p++;
2794

    
2795
        /* parse the hour-minute-second part */
2796
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2797
            q = small_strptime(p, time_fmt[i], &dt);
2798
            if (q) {
2799
                break;
2800
            }
2801
        }
2802
    } else {
2803
        /* parse datestr as a duration */
2804
        if (p[0] == '-') {
2805
            negative = 1;
2806
            ++p;
2807
        }
2808
        /* parse datestr as HH:MM:SS */
2809
        q = small_strptime(p, time_fmt[0], &dt);
2810
        if (!q) {
2811
            /* parse datestr as S+ */
2812
            dt.tm_sec = strtol(p, (char **)&q, 10);
2813
            if (q == p)
2814
                /* the parsing didn't succeed */
2815
                return INT64_MIN;
2816
            dt.tm_min = 0;
2817
            dt.tm_hour = 0;
2818
        }
2819
    }
2820

    
2821
    /* Now we have all the fields that we can get */
2822
    if (!q) {
2823
        return INT64_MIN;
2824
    }
2825

    
2826
    if (duration) {
2827
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2828
    } else {
2829
        dt.tm_isdst = -1;       /* unknown */
2830
        if (is_utc) {
2831
            t = mktimegm(&dt);
2832
        } else {
2833
            t = mktime(&dt);
2834
        }
2835
    }
2836

    
2837
    t *= 1000000;
2838

    
2839
    /* parse the .m... part */
2840
    if (*q == '.') {
2841
        int val, n;
2842
        q++;
2843
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2844
            if (!isdigit(*q))
2845
                break;
2846
            val += n * (*q - '0');
2847
        }
2848
        t += val;
2849
    }
2850
    return negative ? -t : t;
2851
}
2852

    
2853
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2854
{
2855
    const char *p;
2856
    char tag[128], *q;
2857

    
2858
    p = info;
2859
    if (*p == '?')
2860
        p++;
2861
    for(;;) {
2862
        q = tag;
2863
        while (*p != '\0' && *p != '=' && *p != '&') {
2864
            if ((q - tag) < sizeof(tag) - 1)
2865
                *q++ = *p;
2866
            p++;
2867
        }
2868
        *q = '\0';
2869
        q = arg;
2870
        if (*p == '=') {
2871
            p++;
2872
            while (*p != '&' && *p != '\0') {
2873
                if ((q - arg) < arg_size - 1) {
2874
                    if (*p == '+')
2875
                        *q++ = ' ';
2876
                    else
2877
                        *q++ = *p;
2878
                }
2879
                p++;
2880
            }
2881
            *q = '\0';
2882
        }
2883
        if (!strcmp(tag, tag1))
2884
            return 1;
2885
        if (*p != '&')
2886
            break;
2887
        p++;
2888
    }
2889
    return 0;
2890
}
2891

    
2892
int av_get_frame_filename(char *buf, int buf_size,
2893
                          const char *path, int number)
2894
{
2895
    const char *p;
2896
    char *q, buf1[20], c;
2897
    int nd, len, percentd_found;
2898

    
2899
    q = buf;
2900
    p = path;
2901
    percentd_found = 0;
2902
    for(;;) {
2903
        c = *p++;
2904
        if (c == '\0')
2905
            break;
2906
        if (c == '%') {
2907
            do {
2908
                nd = 0;
2909
                while (isdigit(*p)) {
2910
                    nd = nd * 10 + *p++ - '0';
2911
                }
2912
                c = *p++;
2913
            } while (isdigit(c));
2914

    
2915
            switch(c) {
2916
            case '%':
2917
                goto addchar;
2918
            case 'd':
2919
                if (percentd_found)
2920
                    goto fail;
2921
                percentd_found = 1;
2922
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2923
                len = strlen(buf1);
2924
                if ((q - buf + len) > buf_size - 1)
2925
                    goto fail;
2926
                memcpy(q, buf1, len);
2927
                q += len;
2928
                break;
2929
            default:
2930
                goto fail;
2931
            }
2932
        } else {
2933
        addchar:
2934
            if ((q - buf) < buf_size - 1)
2935
                *q++ = c;
2936
        }
2937
    }
2938
    if (!percentd_found)
2939
        goto fail;
2940
    *q = '\0';
2941
    return 0;
2942
 fail:
2943
    *q = '\0';
2944
    return -1;
2945
}
2946

    
2947
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2948
{
2949
    int len, i, j, c;
2950
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2951

    
2952
    for(i=0;i<size;i+=16) {
2953
        len = size - i;
2954
        if (len > 16)
2955
            len = 16;
2956
        PRINT("%08x ", i);
2957
        for(j=0;j<16;j++) {
2958
            if (j < len)
2959
                PRINT(" %02x", buf[i+j]);
2960
            else
2961
                PRINT("   ");
2962
        }
2963
        PRINT(" ");
2964
        for(j=0;j<len;j++) {
2965
            c = buf[i+j];
2966
            if (c < ' ' || c > '~')
2967
                c = '.';
2968
            PRINT("%c", c);
2969
        }
2970
        PRINT("\n");
2971
    }
2972
#undef PRINT
2973
}
2974

    
2975
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2976
{
2977
    hex_dump_internal(NULL, f, 0, buf, size);
2978
}
2979

    
2980
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2981
{
2982
    hex_dump_internal(avcl, NULL, level, buf, size);
2983
}
2984

    
2985
 //FIXME needs to know the time_base
2986
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2987
{
2988
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2989
    PRINT("stream #%d:\n", pkt->stream_index);
2990
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2991
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2992
    /* DTS is _always_ valid after av_read_frame() */
2993
    PRINT("  dts=");
2994
    if (pkt->dts == AV_NOPTS_VALUE)
2995
        PRINT("N/A");
2996
    else
2997
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2998
    /* PTS may not be known if B-frames are present. */
2999
    PRINT("  pts=");
3000
    if (pkt->pts == AV_NOPTS_VALUE)
3001
        PRINT("N/A");
3002
    else
3003
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3004
    PRINT("\n");
3005
    PRINT("  size=%d\n", pkt->size);
3006
#undef PRINT
3007
    if (dump_payload)
3008
        av_hex_dump(f, pkt->data, pkt->size);
3009
}
3010

    
3011
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3012
{
3013
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3014
}
3015

    
3016
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3017
{
3018
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3019
}
3020

    
3021
void url_split(char *proto, int proto_size,
3022
               char *authorization, int authorization_size,
3023
               char *hostname, int hostname_size,
3024
               int *port_ptr,
3025
               char *path, int path_size,
3026
               const char *url)
3027
{
3028
    const char *p, *ls, *at, *col, *brk;
3029

    
3030
    if (port_ptr)               *port_ptr = -1;
3031
    if (proto_size > 0)         proto[0] = 0;
3032
    if (authorization_size > 0) authorization[0] = 0;
3033
    if (hostname_size > 0)      hostname[0] = 0;
3034
    if (path_size > 0)          path[0] = 0;
3035

    
3036
    /* parse protocol */
3037
    if ((p = strchr(url, ':'))) {
3038
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3039
        p++; /* skip ':' */
3040
        if (*p == '/') p++;
3041
        if (*p == '/') p++;
3042
    } else {
3043
        /* no protocol means plain filename */
3044
        av_strlcpy(path, url, path_size);
3045
        return;
3046
    }
3047

    
3048
    /* separate path from hostname */
3049
    ls = strchr(p, '/');
3050
    if(!ls)
3051
        ls = strchr(p, '?');
3052
    if(ls)
3053
        av_strlcpy(path, ls, path_size);
3054
    else
3055
        ls = &p[strlen(p)]; // XXX
3056

    
3057
    /* the rest is hostname, use that to parse auth/port */
3058
    if (ls != p) {
3059
        /* authorization (user[:pass]@hostname) */
3060
        if ((at = strchr(p, '@')) && at < ls) {
3061
            av_strlcpy(authorization, p,
3062
                       FFMIN(authorization_size, at + 1 - p));
3063
            p = at + 1; /* skip '@' */
3064
        }
3065

    
3066
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3067
            /* [host]:port */
3068
            av_strlcpy(hostname, p + 1,
3069
                       FFMIN(hostname_size, brk - p));
3070
            if (brk[1] == ':' && port_ptr)
3071
                *port_ptr = atoi(brk + 2);
3072
        } else if ((col = strchr(p, ':')) && col < ls) {
3073
            av_strlcpy(hostname, p,
3074
                       FFMIN(col + 1 - p, hostname_size));
3075
            if (port_ptr) *port_ptr = atoi(col + 1);
3076
        } else
3077
            av_strlcpy(hostname, p,
3078
                       FFMIN(ls + 1 - p, hostname_size));
3079
    }
3080
}
3081

    
3082
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3083
                     int pts_num, int pts_den)
3084
{
3085
    s->pts_wrap_bits = pts_wrap_bits;
3086
    s->time_base.num = pts_num;
3087
    s->time_base.den = pts_den;
3088
}
3089

    
3090
/* fraction handling */
3091

    
3092
/**
3093
 * f = val + (num / den) + 0.5.
3094
 *
3095
 * 'num' is normalized so that it is such as 0 <= num < den.
3096
 *
3097
 * @param f fractional number
3098
 * @param val integer value
3099
 * @param num must be >= 0
3100
 * @param den must be >= 1
3101
 */
3102
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3103
{
3104
    num += (den >> 1);
3105
    if (num >= den) {
3106
        val += num / den;
3107
        num = num % den;
3108
    }
3109
    f->val = val;
3110
    f->num = num;
3111
    f->den = den;
3112
}
3113

    
3114
/**
3115
 * Fractional addition to f: f = f + (incr / f->den).
3116
 *
3117
 * @param f fractional number
3118
 * @param incr increment, can be positive or negative
3119
 */
3120
static void av_frac_add(AVFrac *f, int64_t incr)
3121
{
3122
    int64_t num, den;
3123

    
3124
    num = f->num + incr;
3125
    den = f->den;
3126
    if (num < 0) {
3127
        f->val += num / den;
3128
        num = num % den;
3129
        if (num < 0) {
3130
            num += den;
3131
            f->val--;
3132
        }
3133
    } else if (num >= den) {
3134
        f->val += num / den;
3135
        num = num % den;
3136
    }
3137
    f->num = num;
3138
}