Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 7c8202cc

History | View | Annotate | Download (94.2 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
            st = s->streams[s->cur_pkt.stream_index];
854
            if(st->codec->debug & FF_DEBUG_PTS)
855
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
856
                    s->cur_pkt.stream_index,
857
                    s->cur_pkt.pts,
858
                    s->cur_pkt.dts,
859
                    s->cur_pkt.size);
860

    
861
            s->cur_st = st;
862
            s->cur_ptr = s->cur_pkt.data;
863
            s->cur_len = s->cur_pkt.size;
864
            if (st->need_parsing && !st->parser) {
865
                st->parser = av_parser_init(st->codec->codec_id);
866
                if (!st->parser) {
867
                    /* no parser available: just output the raw packets */
868
                    st->need_parsing = AVSTREAM_PARSE_NONE;
869
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
870
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
871
                }
872
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
873
                    st->parser->last_frame_offset=
874
                    st->parser->cur_offset= s->cur_pkt.pos;
875
                }
876
            }
877
        }
878
    }
879
    if(st->codec->debug & FF_DEBUG_PTS)
880
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
881
            pkt->stream_index,
882
            pkt->pts,
883
            pkt->dts,
884
            pkt->size);
885

    
886
    return 0;
887
}
888

    
889
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
890
    AVPacketList *pktl= s->packet_buffer;
891
    AVPacketList **plast_pktl= &s->packet_buffer;
892

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

    
895
    pktl = av_mallocz(sizeof(AVPacketList));
896
    if (!pktl)
897
        return NULL;
898

    
899
    /* add the packet in the buffered packet list */
900
    *plast_pktl = pktl;
901
    pktl->pkt= *pkt;
902
    return &pktl->pkt;
903
}
904

    
905
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
906
{
907
    AVPacketList *pktl;
908
    int eof=0;
909
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
910

    
911
    for(;;){
912
        pktl = s->packet_buffer;
913
        if (pktl) {
914
            AVPacket *next_pkt= &pktl->pkt;
915

    
916
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
917
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
918
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
919
                       && next_pkt->dts < pktl->pkt.dts
920
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
921
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
922
                        next_pkt->pts= pktl->pkt.dts;
923
                    }
924
                    pktl= pktl->next;
925
                }
926
                pktl = s->packet_buffer;
927
            }
928

    
929
            if(   next_pkt->pts != AV_NOPTS_VALUE
930
               || next_pkt->dts == AV_NOPTS_VALUE
931
               || !genpts || eof){
932
                /* read packet from packet buffer, if there is data */
933
                *pkt = *next_pkt;
934
                s->packet_buffer = pktl->next;
935
                av_free(pktl);
936
                return 0;
937
            }
938
        }
939
        if(genpts){
940
            int ret= av_read_frame_internal(s, pkt);
941
            if(ret<0){
942
                if(pktl && ret != AVERROR(EAGAIN)){
943
                    eof=1;
944
                    continue;
945
                }else
946
                    return ret;
947
            }
948

    
949
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
950
                return AVERROR(ENOMEM);
951
        }else{
952
            assert(!s->packet_buffer);
953
            return av_read_frame_internal(s, pkt);
954
        }
955
    }
956
}
957

    
958
/* XXX: suppress the packet queue */
959
static void flush_packet_queue(AVFormatContext *s)
960
{
961
    AVPacketList *pktl;
962

    
963
    for(;;) {
964
        pktl = s->packet_buffer;
965
        if (!pktl)
966
            break;
967
        s->packet_buffer = pktl->next;
968
        av_free_packet(&pktl->pkt);
969
        av_free(pktl);
970
    }
971
}
972

    
973
/*******************************************************/
974
/* seek support */
975

    
976
int av_find_default_stream_index(AVFormatContext *s)
977
{
978
    int i;
979
    AVStream *st;
980

    
981
    if (s->nb_streams <= 0)
982
        return -1;
983
    for(i = 0; i < s->nb_streams; i++) {
984
        st = s->streams[i];
985
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
986
            return i;
987
        }
988
    }
989
    return 0;
990
}
991

    
992
/**
993
 * Flush the frame reader.
994
 */
995
static void av_read_frame_flush(AVFormatContext *s)
996
{
997
    AVStream *st;
998
    int i;
999

    
1000
    flush_packet_queue(s);
1001

    
1002
    /* free previous packet */
1003
    if (s->cur_st) {
1004
        if (s->cur_st->parser)
1005
            av_free_packet(&s->cur_pkt);
1006
        s->cur_st = NULL;
1007
    }
1008
    /* fail safe */
1009
    s->cur_ptr = NULL;
1010
    s->cur_len = 0;
1011

    
1012
    /* for each stream, reset read state */
1013
    for(i = 0; i < s->nb_streams; i++) {
1014
        st = s->streams[i];
1015

    
1016
        if (st->parser) {
1017
            av_parser_close(st->parser);
1018
            st->parser = NULL;
1019
        }
1020
        st->last_IP_pts = AV_NOPTS_VALUE;
1021
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1022
    }
1023
}
1024

    
1025
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1026
    int i;
1027

    
1028
    for(i = 0; i < s->nb_streams; i++) {
1029
        AVStream *st = s->streams[i];
1030

    
1031
        st->cur_dts = av_rescale(timestamp,
1032
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1033
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1034
    }
1035
}
1036

    
1037
void ff_reduce_index(AVFormatContext *s, int stream_index)
1038
{
1039
    AVStream *st= s->streams[stream_index];
1040
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1041

    
1042
    if((unsigned)st->nb_index_entries >= max_entries){
1043
        int i;
1044
        for(i=0; 2*i<st->nb_index_entries; i++)
1045
            st->index_entries[i]= st->index_entries[2*i];
1046
        st->nb_index_entries= i;
1047
    }
1048
}
1049

    
1050
int av_add_index_entry(AVStream *st,
1051
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1052
{
1053
    AVIndexEntry *entries, *ie;
1054
    int index;
1055

    
1056
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1057
        return -1;
1058

    
1059
    entries = av_fast_realloc(st->index_entries,
1060
                              &st->index_entries_allocated_size,
1061
                              (st->nb_index_entries + 1) *
1062
                              sizeof(AVIndexEntry));
1063
    if(!entries)
1064
        return -1;
1065

    
1066
    st->index_entries= entries;
1067

    
1068
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1069

    
1070
    if(index<0){
1071
        index= st->nb_index_entries++;
1072
        ie= &entries[index];
1073
        assert(index==0 || ie[-1].timestamp < timestamp);
1074
    }else{
1075
        ie= &entries[index];
1076
        if(ie->timestamp != timestamp){
1077
            if(ie->timestamp <= timestamp)
1078
                return -1;
1079
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1080
            st->nb_index_entries++;
1081
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1082
            distance= ie->min_distance;
1083
    }
1084

    
1085
    ie->pos = pos;
1086
    ie->timestamp = timestamp;
1087
    ie->min_distance= distance;
1088
    ie->size= size;
1089
    ie->flags = flags;
1090

    
1091
    return index;
1092
}
1093

    
1094
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1095
                              int flags)
1096
{
1097
    AVIndexEntry *entries= st->index_entries;
1098
    int nb_entries= st->nb_index_entries;
1099
    int a, b, m;
1100
    int64_t timestamp;
1101

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

    
1105
    while (b - a > 1) {
1106
        m = (a + b) >> 1;
1107
        timestamp = entries[m].timestamp;
1108
        if(timestamp >= wanted_timestamp)
1109
            b = m;
1110
        if(timestamp <= wanted_timestamp)
1111
            a = m;
1112
    }
1113
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1114

    
1115
    if(!(flags & AVSEEK_FLAG_ANY)){
1116
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1117
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1118
        }
1119
    }
1120

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

    
1126
#define DEBUG_SEEK
1127

    
1128
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1129
    AVInputFormat *avif= s->iformat;
1130
    int64_t pos_min, pos_max, pos, pos_limit;
1131
    int64_t ts_min, ts_max, ts;
1132
    int index;
1133
    AVStream *st;
1134

    
1135
    if (stream_index < 0)
1136
        return -1;
1137

    
1138
#ifdef DEBUG_SEEK
1139
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1140
#endif
1141

    
1142
    ts_max=
1143
    ts_min= AV_NOPTS_VALUE;
1144
    pos_limit= -1; //gcc falsely says it may be uninitialized
1145

    
1146
    st= s->streams[stream_index];
1147
    if(st->index_entries){
1148
        AVIndexEntry *e;
1149

    
1150
        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()
1151
        index= FFMAX(index, 0);
1152
        e= &st->index_entries[index];
1153

    
1154
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1155
            pos_min= e->pos;
1156
            ts_min= e->timestamp;
1157
#ifdef DEBUG_SEEK
1158
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1159
               pos_min,ts_min);
1160
#endif
1161
        }else{
1162
            assert(index==0);
1163
        }
1164

    
1165
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1166
        assert(index < st->nb_index_entries);
1167
        if(index >= 0){
1168
            e= &st->index_entries[index];
1169
            assert(e->timestamp >= target_ts);
1170
            pos_max= e->pos;
1171
            ts_max= e->timestamp;
1172
            pos_limit= pos_max - e->min_distance;
1173
#ifdef DEBUG_SEEK
1174
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1175
               pos_max,pos_limit, ts_max);
1176
#endif
1177
        }
1178
    }
1179

    
1180
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1181
    if(pos<0)
1182
        return -1;
1183

    
1184
    /* do the seek */
1185
    url_fseek(s->pb, pos, SEEK_SET);
1186

    
1187
    av_update_cur_dts(s, st, ts);
1188

    
1189
    return 0;
1190
}
1191

    
1192
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 )){
1193
    int64_t pos, ts;
1194
    int64_t start_pos, filesize;
1195
    int no_change;
1196

    
1197
#ifdef DEBUG_SEEK
1198
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1199
#endif
1200

    
1201
    if(ts_min == AV_NOPTS_VALUE){
1202
        pos_min = s->data_offset;
1203
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1204
        if (ts_min == AV_NOPTS_VALUE)
1205
            return -1;
1206
    }
1207

    
1208
    if(ts_max == AV_NOPTS_VALUE){
1209
        int step= 1024;
1210
        filesize = url_fsize(s->pb);
1211
        pos_max = filesize - 1;
1212
        do{
1213
            pos_max -= step;
1214
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1215
            step += step;
1216
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1217
        if (ts_max == AV_NOPTS_VALUE)
1218
            return -1;
1219

    
1220
        for(;;){
1221
            int64_t tmp_pos= pos_max + 1;
1222
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1223
            if(tmp_ts == AV_NOPTS_VALUE)
1224
                break;
1225
            ts_max= tmp_ts;
1226
            pos_max= tmp_pos;
1227
            if(tmp_pos >= filesize)
1228
                break;
1229
        }
1230
        pos_limit= pos_max;
1231
    }
1232

    
1233
    if(ts_min > ts_max){
1234
        return -1;
1235
    }else if(ts_min == ts_max){
1236
        pos_limit= pos_min;
1237
    }
1238

    
1239
    no_change=0;
1240
    while (pos_min < pos_limit) {
1241
#ifdef DEBUG_SEEK
1242
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1243
               pos_min, pos_max,
1244
               ts_min, ts_max);
1245
#endif
1246
        assert(pos_limit <= pos_max);
1247

    
1248
        if(no_change==0){
1249
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1250
            // interpolate position (better than dichotomy)
1251
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1252
                + pos_min - approximate_keyframe_distance;
1253
        }else if(no_change==1){
1254
            // bisection, if interpolation failed to change min or max pos last time
1255
            pos = (pos_min + pos_limit)>>1;
1256
        }else{
1257
            /* linear search if bisection failed, can only happen if there
1258
               are very few or no keyframes between min/max */
1259
            pos=pos_min;
1260
        }
1261
        if(pos <= pos_min)
1262
            pos= pos_min + 1;
1263
        else if(pos > pos_limit)
1264
            pos= pos_limit;
1265
        start_pos= pos;
1266

    
1267
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1268
        if(pos == pos_max)
1269
            no_change++;
1270
        else
1271
            no_change=0;
1272
#ifdef DEBUG_SEEK
1273
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);
1274
#endif
1275
        if(ts == AV_NOPTS_VALUE){
1276
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1277
            return -1;
1278
        }
1279
        assert(ts != AV_NOPTS_VALUE);
1280
        if (target_ts <= ts) {
1281
            pos_limit = start_pos - 1;
1282
            pos_max = pos;
1283
            ts_max = ts;
1284
        }
1285
        if (target_ts >= ts) {
1286
            pos_min = pos;
1287
            ts_min = ts;
1288
        }
1289
    }
1290

    
1291
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1292
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1293
#ifdef DEBUG_SEEK
1294
    pos_min = pos;
1295
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1296
    pos_min++;
1297
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1298
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1299
           pos, ts_min, target_ts, ts_max);
1300
#endif
1301
    *ts_ret= ts;
1302
    return pos;
1303
}
1304

    
1305
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1306
    int64_t pos_min, pos_max;
1307
#if 0
1308
    AVStream *st;
1309

1310
    if (stream_index < 0)
1311
        return -1;
1312

1313
    st= s->streams[stream_index];
1314
#endif
1315

    
1316
    pos_min = s->data_offset;
1317
    pos_max = url_fsize(s->pb) - 1;
1318

    
1319
    if     (pos < pos_min) pos= pos_min;
1320
    else if(pos > pos_max) pos= pos_max;
1321

    
1322
    url_fseek(s->pb, pos, SEEK_SET);
1323

    
1324
#if 0
1325
    av_update_cur_dts(s, st, ts);
1326
#endif
1327
    return 0;
1328
}
1329

    
1330
static int av_seek_frame_generic(AVFormatContext *s,
1331
                                 int stream_index, int64_t timestamp, int flags)
1332
{
1333
    int index;
1334
    AVStream *st;
1335
    AVIndexEntry *ie;
1336

    
1337
    st = s->streams[stream_index];
1338

    
1339
    index = av_index_search_timestamp(st, timestamp, flags);
1340

    
1341
    if(index < 0 || index==st->nb_index_entries-1){
1342
        int i;
1343
        AVPacket pkt;
1344

    
1345
        if(st->index_entries && st->nb_index_entries){
1346
            ie= &st->index_entries[st->nb_index_entries-1];
1347
            url_fseek(s->pb, ie->pos, SEEK_SET);
1348
            av_update_cur_dts(s, st, ie->timestamp);
1349
        }else
1350
            url_fseek(s->pb, 0, SEEK_SET);
1351

    
1352
        for(i=0;; i++) {
1353
            int ret = av_read_frame(s, &pkt);
1354
            if(ret<0)
1355
                break;
1356
            av_free_packet(&pkt);
1357
            if(stream_index == pkt.stream_index){
1358
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1359
                    break;
1360
            }
1361
        }
1362
        index = av_index_search_timestamp(st, timestamp, flags);
1363
    }
1364
    if (index < 0)
1365
        return -1;
1366

    
1367
    av_read_frame_flush(s);
1368
    if (s->iformat->read_seek){
1369
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1370
            return 0;
1371
    }
1372
    ie = &st->index_entries[index];
1373
    url_fseek(s->pb, ie->pos, SEEK_SET);
1374

    
1375
    av_update_cur_dts(s, st, ie->timestamp);
1376

    
1377
    return 0;
1378
}
1379

    
1380
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1381
{
1382
    int ret;
1383
    AVStream *st;
1384

    
1385
    av_read_frame_flush(s);
1386

    
1387
    if(flags & AVSEEK_FLAG_BYTE)
1388
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1389

    
1390
    if(stream_index < 0){
1391
        stream_index= av_find_default_stream_index(s);
1392
        if(stream_index < 0)
1393
            return -1;
1394

    
1395
        st= s->streams[stream_index];
1396
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1397
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1398
    }
1399
    st= s->streams[stream_index];
1400

    
1401
    /* first, we try the format specific seek */
1402
    if (s->iformat->read_seek)
1403
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1404
    else
1405
        ret = -1;
1406
    if (ret >= 0) {
1407
        return 0;
1408
    }
1409

    
1410
    if(s->iformat->read_timestamp)
1411
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1412
    else
1413
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1414
}
1415

    
1416
/*******************************************************/
1417

    
1418
/**
1419
 * Returns TRUE if the stream has accurate duration in any stream.
1420
 *
1421
 * @return TRUE if the stream has accurate duration for at least one component.
1422
 */
1423
static int av_has_duration(AVFormatContext *ic)
1424
{
1425
    int i;
1426
    AVStream *st;
1427

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

    
1436
/**
1437
 * Estimate the stream timings from the one of each components.
1438
 *
1439
 * Also computes the global bitrate if possible.
1440
 */
1441
static void av_update_stream_timings(AVFormatContext *ic)
1442
{
1443
    int64_t start_time, start_time1, end_time, end_time1;
1444
    int64_t duration, duration1;
1445
    int i;
1446
    AVStream *st;
1447

    
1448
    start_time = INT64_MAX;
1449
    end_time = INT64_MIN;
1450
    duration = INT64_MIN;
1451
    for(i = 0;i < ic->nb_streams; i++) {
1452
        st = ic->streams[i];
1453
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1454
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1455
            if (start_time1 < start_time)
1456
                start_time = start_time1;
1457
            if (st->duration != AV_NOPTS_VALUE) {
1458
                end_time1 = start_time1
1459
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1460
                if (end_time1 > end_time)
1461
                    end_time = end_time1;
1462
            }
1463
        }
1464
        if (st->duration != AV_NOPTS_VALUE) {
1465
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1466
            if (duration1 > duration)
1467
                duration = duration1;
1468
        }
1469
    }
1470
    if (start_time != INT64_MAX) {
1471
        ic->start_time = start_time;
1472
        if (end_time != INT64_MIN) {
1473
            if (end_time - start_time > duration)
1474
                duration = end_time - start_time;
1475
        }
1476
    }
1477
    if (duration != INT64_MIN) {
1478
        ic->duration = duration;
1479
        if (ic->file_size > 0) {
1480
            /* compute the bitrate */
1481
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1482
                (double)ic->duration;
1483
        }
1484
    }
1485
}
1486

    
1487
static void fill_all_stream_timings(AVFormatContext *ic)
1488
{
1489
    int i;
1490
    AVStream *st;
1491

    
1492
    av_update_stream_timings(ic);
1493
    for(i = 0;i < ic->nb_streams; i++) {
1494
        st = ic->streams[i];
1495
        if (st->start_time == AV_NOPTS_VALUE) {
1496
            if(ic->start_time != AV_NOPTS_VALUE)
1497
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1498
            if(ic->duration != AV_NOPTS_VALUE)
1499
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1500
        }
1501
    }
1502
}
1503

    
1504
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1505
{
1506
    int64_t filesize, duration;
1507
    int bit_rate, i;
1508
    AVStream *st;
1509

    
1510
    /* if bit_rate is already set, we believe it */
1511
    if (ic->bit_rate == 0) {
1512
        bit_rate = 0;
1513
        for(i=0;i<ic->nb_streams;i++) {
1514
            st = ic->streams[i];
1515
            bit_rate += st->codec->bit_rate;
1516
        }
1517
        ic->bit_rate = bit_rate;
1518
    }
1519

    
1520
    /* if duration is already set, we believe it */
1521
    if (ic->duration == AV_NOPTS_VALUE &&
1522
        ic->bit_rate != 0 &&
1523
        ic->file_size != 0)  {
1524
        filesize = ic->file_size;
1525
        if (filesize > 0) {
1526
            for(i = 0; i < ic->nb_streams; i++) {
1527
                st = ic->streams[i];
1528
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1529
                if (st->duration == AV_NOPTS_VALUE)
1530
                    st->duration = duration;
1531
            }
1532
        }
1533
    }
1534
}
1535

    
1536
#define DURATION_MAX_READ_SIZE 250000
1537

    
1538
/* only usable for MPEG-PS streams */
1539
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1540
{
1541
    AVPacket pkt1, *pkt = &pkt1;
1542
    AVStream *st;
1543
    int read_size, i, ret;
1544
    int64_t end_time;
1545
    int64_t filesize, offset, duration;
1546

    
1547
    /* free previous packet */
1548
    if (ic->cur_st && ic->cur_st->parser)
1549
        av_free_packet(&ic->cur_pkt);
1550
    ic->cur_st = NULL;
1551

    
1552
    /* flush packet queue */
1553
    flush_packet_queue(ic);
1554

    
1555
    for(i=0;i<ic->nb_streams;i++) {
1556
        st = ic->streams[i];
1557
        if (st->parser) {
1558
            av_parser_close(st->parser);
1559
            st->parser= NULL;
1560
        }
1561
    }
1562

    
1563
    /* we read the first packets to get the first PTS (not fully
1564
       accurate, but it is enough now) */
1565
    url_fseek(ic->pb, 0, SEEK_SET);
1566
    read_size = 0;
1567
    for(;;) {
1568
        if (read_size >= DURATION_MAX_READ_SIZE)
1569
            break;
1570
        /* if all info is available, we can stop */
1571
        for(i = 0;i < ic->nb_streams; i++) {
1572
            st = ic->streams[i];
1573
            if (st->start_time == AV_NOPTS_VALUE)
1574
                break;
1575
        }
1576
        if (i == ic->nb_streams)
1577
            break;
1578

    
1579
        ret = av_read_packet(ic, pkt);
1580
        if (ret != 0)
1581
            break;
1582
        read_size += pkt->size;
1583
        st = ic->streams[pkt->stream_index];
1584
        if (pkt->pts != AV_NOPTS_VALUE) {
1585
            if (st->start_time == AV_NOPTS_VALUE)
1586
                st->start_time = pkt->pts;
1587
        }
1588
        av_free_packet(pkt);
1589
    }
1590

    
1591
    /* estimate the end time (duration) */
1592
    /* XXX: may need to support wrapping */
1593
    filesize = ic->file_size;
1594
    offset = filesize - DURATION_MAX_READ_SIZE;
1595
    if (offset < 0)
1596
        offset = 0;
1597

    
1598
    url_fseek(ic->pb, offset, SEEK_SET);
1599
    read_size = 0;
1600
    for(;;) {
1601
        if (read_size >= DURATION_MAX_READ_SIZE)
1602
            break;
1603

    
1604
        ret = av_read_packet(ic, pkt);
1605
        if (ret != 0)
1606
            break;
1607
        read_size += pkt->size;
1608
        st = ic->streams[pkt->stream_index];
1609
        if (pkt->pts != AV_NOPTS_VALUE &&
1610
            st->start_time != AV_NOPTS_VALUE) {
1611
            end_time = pkt->pts;
1612
            duration = end_time - st->start_time;
1613
            if (duration > 0) {
1614
                if (st->duration == AV_NOPTS_VALUE ||
1615
                    st->duration < duration)
1616
                    st->duration = duration;
1617
            }
1618
        }
1619
        av_free_packet(pkt);
1620
    }
1621

    
1622
    fill_all_stream_timings(ic);
1623

    
1624
    url_fseek(ic->pb, old_offset, SEEK_SET);
1625
    for(i=0; i<ic->nb_streams; i++){
1626
        st= ic->streams[i];
1627
        st->cur_dts= st->first_dts;
1628
        st->last_IP_pts = AV_NOPTS_VALUE;
1629
    }
1630
}
1631

    
1632
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1633
{
1634
    int64_t file_size;
1635

    
1636
    /* get the file size, if possible */
1637
    if (ic->iformat->flags & AVFMT_NOFILE) {
1638
        file_size = 0;
1639
    } else {
1640
        file_size = url_fsize(ic->pb);
1641
        if (file_size < 0)
1642
            file_size = 0;
1643
    }
1644
    ic->file_size = file_size;
1645

    
1646
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1647
         !strcmp(ic->iformat->name, "mpegts")) &&
1648
        file_size && !url_is_streamed(ic->pb)) {
1649
        /* get accurate estimate from the PTSes */
1650
        av_estimate_timings_from_pts(ic, old_offset);
1651
    } else if (av_has_duration(ic)) {
1652
        /* at least one component has timings - we use them for all
1653
           the components */
1654
        fill_all_stream_timings(ic);
1655
    } else {
1656
        /* less precise: use bitrate info */
1657
        av_estimate_timings_from_bit_rate(ic);
1658
    }
1659
    av_update_stream_timings(ic);
1660

    
1661
#if 0
1662
    {
1663
        int i;
1664
        AVStream *st;
1665
        for(i = 0;i < ic->nb_streams; i++) {
1666
            st = ic->streams[i];
1667
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1668
               i, (double)st->start_time / AV_TIME_BASE,
1669
               (double)st->duration / AV_TIME_BASE);
1670
        }
1671
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1672
               (double)ic->start_time / AV_TIME_BASE,
1673
               (double)ic->duration / AV_TIME_BASE,
1674
               ic->bit_rate / 1000);
1675
    }
1676
#endif
1677
}
1678

    
1679
static int has_codec_parameters(AVCodecContext *enc)
1680
{
1681
    int val;
1682
    switch(enc->codec_type) {
1683
    case CODEC_TYPE_AUDIO:
1684
        val = enc->sample_rate;
1685
        break;
1686
    case CODEC_TYPE_VIDEO:
1687
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1688
        break;
1689
    default:
1690
        val = 1;
1691
        break;
1692
    }
1693
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1694
}
1695

    
1696
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1697
{
1698
    int16_t *samples;
1699
    AVCodec *codec;
1700
    int got_picture, data_size, ret=0;
1701
    AVFrame picture;
1702

    
1703
  if(!st->codec->codec){
1704
    codec = avcodec_find_decoder(st->codec->codec_id);
1705
    if (!codec)
1706
        return -1;
1707
    ret = avcodec_open(st->codec, codec);
1708
    if (ret < 0)
1709
        return ret;
1710
  }
1711

    
1712
  if(!has_codec_parameters(st->codec)){
1713
    switch(st->codec->codec_type) {
1714
    case CODEC_TYPE_VIDEO:
1715
        ret = avcodec_decode_video(st->codec, &picture,
1716
                                   &got_picture, data, size);
1717
        break;
1718
    case CODEC_TYPE_AUDIO:
1719
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1720
        samples = av_malloc(data_size);
1721
        if (!samples)
1722
            goto fail;
1723
        ret = avcodec_decode_audio2(st->codec, samples,
1724
                                    &data_size, data, size);
1725
        av_free(samples);
1726
        break;
1727
    default:
1728
        break;
1729
    }
1730
  }
1731
 fail:
1732
    return ret;
1733
}
1734

    
1735
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1736
{
1737
    AVInputFormat *fmt;
1738
    fmt = av_probe_input_format2(pd, 1, &score);
1739

    
1740
    if (fmt) {
1741
        if (strncmp(fmt->name, "mp3", 3) == 0)
1742
            st->codec->codec_id = CODEC_ID_MP3;
1743
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1744
            st->codec->codec_id = CODEC_ID_AC3;
1745
    }
1746
    return !!fmt;
1747
}
1748

    
1749
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1750
{
1751
    while (tags->id != CODEC_ID_NONE) {
1752
        if (tags->id == id)
1753
            return tags->tag;
1754
        tags++;
1755
    }
1756
    return 0;
1757
}
1758

    
1759
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1760
{
1761
    int i;
1762
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1763
        if(tag == tags[i].tag)
1764
            return tags[i].id;
1765
    }
1766
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1767
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1768
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1769
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1770
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1771
            return tags[i].id;
1772
    }
1773
    return CODEC_ID_NONE;
1774
}
1775

    
1776
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1777
{
1778
    int i;
1779
    for(i=0; tags && tags[i]; i++){
1780
        int tag= codec_get_tag(tags[i], id);
1781
        if(tag) return tag;
1782
    }
1783
    return 0;
1784
}
1785

    
1786
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1787
{
1788
    int i;
1789
    for(i=0; tags && tags[i]; i++){
1790
        enum CodecID id= codec_get_id(tags[i], tag);
1791
        if(id!=CODEC_ID_NONE) return id;
1792
    }
1793
    return CODEC_ID_NONE;
1794
}
1795

    
1796
/* absolute maximum size we read until we abort */
1797
#define MAX_READ_SIZE        5000000
1798

    
1799
#define MAX_STD_TIMEBASES (60*12+5)
1800
static int get_std_framerate(int i){
1801
    if(i<60*12) return i*1001;
1802
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1803
}
1804

    
1805
/*
1806
 * Is the time base unreliable.
1807
 * This is a heuristic to balance between quick acceptance of the values in
1808
 * the headers vs. some extra checks.
1809
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1810
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1811
 * And there are "variable" fps files this needs to detect as well.
1812
 */
1813
static int tb_unreliable(AVCodecContext *c){
1814
    if(   c->time_base.den >= 101L*c->time_base.num
1815
       || c->time_base.den <    5L*c->time_base.num
1816
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1817
       || c->codec_tag == ff_get_fourcc("XVID")*/
1818
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1819
        return 1;
1820
    return 0;
1821
}
1822

    
1823
int av_find_stream_info(AVFormatContext *ic)
1824
{
1825
    int i, count, ret, read_size, j;
1826
    AVStream *st;
1827
    AVPacket pkt1, *pkt;
1828
    int64_t last_dts[MAX_STREAMS];
1829
    int duration_count[MAX_STREAMS]={0};
1830
    double (*duration_error)[MAX_STD_TIMEBASES];
1831
    offset_t old_offset = url_ftell(ic->pb);
1832
    int64_t codec_info_duration[MAX_STREAMS]={0};
1833
    int codec_info_nb_frames[MAX_STREAMS]={0};
1834
    AVProbeData probe_data[MAX_STREAMS];
1835
    int codec_identified[MAX_STREAMS]={0};
1836

    
1837
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1838
    if (!duration_error) return AVERROR(ENOMEM);
1839

    
1840
    for(i=0;i<ic->nb_streams;i++) {
1841
        st = ic->streams[i];
1842
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1843
/*            if(!st->time_base.num)
1844
                st->time_base= */
1845
            if(!st->codec->time_base.num)
1846
                st->codec->time_base= st->time_base;
1847
        }
1848
        //only for the split stuff
1849
        if (!st->parser) {
1850
            st->parser = av_parser_init(st->codec->codec_id);
1851
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1852
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1853
            }
1854
        }
1855
    }
1856

    
1857
    for(i=0;i<MAX_STREAMS;i++){
1858
        last_dts[i]= AV_NOPTS_VALUE;
1859
    }
1860

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

    
1895
        /* NOTE: a new stream can be added there if no header in file
1896
           (AVFMTCTX_NOHEADER) */
1897
        ret = av_read_frame_internal(ic, &pkt1);
1898
        if (ret < 0) {
1899
            /* EOF or error */
1900
            ret = -1; /* we could not have all the codec parameters before EOF */
1901
            for(i=0;i<ic->nb_streams;i++) {
1902
                st = ic->streams[i];
1903
                if (!has_codec_parameters(st->codec)){
1904
                    char buf[256];
1905
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1906
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1907
                } else {
1908
                    ret = 0;
1909
                }
1910
            }
1911
            break;
1912
        }
1913

    
1914
        pkt= add_to_pktbuf(ic, &pkt1);
1915
        if(av_dup_packet(pkt) < 0)
1916
            return AVERROR(ENOMEM);
1917

    
1918
        read_size += pkt->size;
1919

    
1920
        st = ic->streams[pkt->stream_index];
1921
        if(codec_info_nb_frames[st->index]>1)
1922
            codec_info_duration[st->index] += pkt->duration;
1923
        if (pkt->duration != 0)
1924
            codec_info_nb_frames[st->index]++;
1925

    
1926
        {
1927
            int index= pkt->stream_index;
1928
            int64_t last= last_dts[index];
1929
            int64_t duration= pkt->dts - last;
1930

    
1931
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1932
                double dur= duration * av_q2d(st->time_base);
1933

    
1934
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1935
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1936
                if(duration_count[index] < 2)
1937
                    memset(duration_error[index], 0, sizeof(*duration_error));
1938
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1939
                    int framerate= get_std_framerate(i);
1940
                    int ticks= lrintf(dur*framerate/(1001*12));
1941
                    double error= dur - ticks*1001*12/(double)framerate;
1942
                    duration_error[index][i] += error*error;
1943
                }
1944
                duration_count[index]++;
1945
            }
1946
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1947
                last_dts[pkt->stream_index]= pkt->dts;
1948

    
1949
            if (st->codec->codec_id == CODEC_ID_NONE) {
1950
                AVProbeData *pd = &(probe_data[st->index]);
1951
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1952
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1953
                pd->buf_size += pkt->size;
1954
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1955
            }
1956
        }
1957
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1958
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1959
            if(i){
1960
                st->codec->extradata_size= i;
1961
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1962
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1963
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1964
            }
1965
        }
1966

    
1967
        /* if still no information, we try to open the codec and to
1968
           decompress the frame. We try to avoid that in most cases as
1969
           it takes longer and uses more memory. For MPEG-4, we need to
1970
           decompress for QuickTime. */
1971
        if (!has_codec_parameters(st->codec) /*&&
1972
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1973
             st->codec->codec_id == CODEC_ID_H264 ||
1974
             st->codec->codec_id == CODEC_ID_H263 ||
1975
             st->codec->codec_id == CODEC_ID_H261 ||
1976
             st->codec->codec_id == CODEC_ID_VORBIS ||
1977
             st->codec->codec_id == CODEC_ID_MJPEG ||
1978
             st->codec->codec_id == CODEC_ID_PNG ||
1979
             st->codec->codec_id == CODEC_ID_PAM ||
1980
             st->codec->codec_id == CODEC_ID_PGM ||
1981
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1982
             st->codec->codec_id == CODEC_ID_PBM ||
1983
             st->codec->codec_id == CODEC_ID_PPM ||
1984
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1985
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1986
            try_decode_frame(st, pkt->data, pkt->size);
1987

    
1988
        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) {
1989
            break;
1990
        }
1991
        count++;
1992
    }
1993

    
1994
    // close codecs which were opened in try_decode_frame()
1995
    for(i=0;i<ic->nb_streams;i++) {
1996
        st = ic->streams[i];
1997
        if(st->codec->codec)
1998
            avcodec_close(st->codec);
1999
    }
2000
    for(i=0;i<ic->nb_streams;i++) {
2001
        st = ic->streams[i];
2002
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2003
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2004
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2005

    
2006
            if(duration_count[i]
2007
               && tb_unreliable(st->codec) /*&&
2008
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2009
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2010
                double best_error= 2*av_q2d(st->time_base);
2011
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2012

    
2013
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2014
                    double error= duration_error[i][j] * get_std_framerate(j);
2015
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2016
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2017
                    if(error < best_error){
2018
                        best_error= error;
2019
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2020
                    }
2021
                }
2022
            }
2023

    
2024
            if (!st->r_frame_rate.num){
2025
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2026
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2027
                    st->r_frame_rate.num = st->codec->time_base.den;
2028
                    st->r_frame_rate.den = st->codec->time_base.num;
2029
                }else{
2030
                    st->r_frame_rate.num = st->time_base.den;
2031
                    st->r_frame_rate.den = st->time_base.num;
2032
                }
2033
            }
2034
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2035
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2036
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2037
                if (codec_identified[st->index]) {
2038
                    st->need_parsing = AVSTREAM_PARSE_FULL;
2039
                }
2040
            }
2041
            if(!st->codec->bits_per_sample)
2042
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2043
        }
2044
    }
2045

    
2046
    av_estimate_timings(ic, old_offset);
2047

    
2048
    for(i=0;i<ic->nb_streams;i++) {
2049
        st = ic->streams[i];
2050
        if (codec_identified[st->index])
2051
            break;
2052
    }
2053
    //FIXME this is a mess
2054
    if(i!=ic->nb_streams){
2055
        av_read_frame_flush(ic);
2056
        for(i=0;i<ic->nb_streams;i++) {
2057
            st = ic->streams[i];
2058
            if (codec_identified[st->index]) {
2059
                av_seek_frame(ic, st->index, 0.0, 0);
2060
            }
2061
            st->cur_dts= st->first_dts;
2062
        }
2063
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2064
    }
2065

    
2066
#if 0
2067
    /* correct DTS for B-frame streams with no timestamps */
2068
    for(i=0;i<ic->nb_streams;i++) {
2069
        st = ic->streams[i];
2070
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2071
            if(b-frames){
2072
                ppktl = &ic->packet_buffer;
2073
                while(ppkt1){
2074
                    if(ppkt1->stream_index != i)
2075
                        continue;
2076
                    if(ppkt1->pkt->dts < 0)
2077
                        break;
2078
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2079
                        break;
2080
                    ppkt1->pkt->dts -= delta;
2081
                    ppkt1= ppkt1->next;
2082
                }
2083
                if(ppkt1)
2084
                    continue;
2085
                st->cur_dts -= delta;
2086
            }
2087
        }
2088
    }
2089
#endif
2090

    
2091
    av_free(duration_error);
2092
    for(i=0;i<MAX_STREAMS;i++){
2093
        av_freep(&(probe_data[i].buf));
2094
    }
2095

    
2096
    return ret;
2097
}
2098

    
2099
/*******************************************************/
2100

    
2101
int av_read_play(AVFormatContext *s)
2102
{
2103
    if (s->iformat->read_play)
2104
        return s->iformat->read_play(s);
2105
    if (s->pb)
2106
        return av_url_read_fpause(s->pb, 0);
2107
    return AVERROR(ENOSYS);
2108
}
2109

    
2110
int av_read_pause(AVFormatContext *s)
2111
{
2112
    if (s->iformat->read_pause)
2113
        return s->iformat->read_pause(s);
2114
    if (s->pb)
2115
        return av_url_read_fpause(s->pb, 1);
2116
    return AVERROR(ENOSYS);
2117
}
2118

    
2119
void av_close_input_stream(AVFormatContext *s)
2120
{
2121
    int i;
2122
    AVStream *st;
2123

    
2124
    /* free previous packet */
2125
    if (s->cur_st && s->cur_st->parser)
2126
        av_free_packet(&s->cur_pkt);
2127

    
2128
    if (s->iformat->read_close)
2129
        s->iformat->read_close(s);
2130
    for(i=0;i<s->nb_streams;i++) {
2131
        /* free all data in a stream component */
2132
        st = s->streams[i];
2133
        if (st->parser) {
2134
            av_parser_close(st->parser);
2135
        }
2136
        av_free(st->index_entries);
2137
        av_free(st->codec->extradata);
2138
        av_free(st->codec);
2139
        av_free(st->filename);
2140
        av_free(st);
2141
    }
2142
    for(i=s->nb_programs-1; i>=0; i--) {
2143
        av_freep(&s->programs[i]->provider_name);
2144
        av_freep(&s->programs[i]->name);
2145
        av_freep(&s->programs[i]->stream_index);
2146
        av_freep(&s->programs[i]);
2147
    }
2148
    av_freep(&s->programs);
2149
    flush_packet_queue(s);
2150
    av_freep(&s->priv_data);
2151
    while(s->nb_chapters--) {
2152
        av_free(s->chapters[s->nb_chapters]->title);
2153
        av_free(s->chapters[s->nb_chapters]);
2154
    }
2155
    av_freep(&s->chapters);
2156
    av_free(s);
2157
}
2158

    
2159
void av_close_input_file(AVFormatContext *s)
2160
{
2161
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2162
    av_close_input_stream(s);
2163
    if (pb)
2164
        url_fclose(pb);
2165
}
2166

    
2167
AVStream *av_new_stream(AVFormatContext *s, int id)
2168
{
2169
    AVStream *st;
2170
    int i;
2171

    
2172
    if (s->nb_streams >= MAX_STREAMS)
2173
        return NULL;
2174

    
2175
    st = av_mallocz(sizeof(AVStream));
2176
    if (!st)
2177
        return NULL;
2178

    
2179
    st->codec= avcodec_alloc_context();
2180
    if (s->iformat) {
2181
        /* no default bitrate if decoding */
2182
        st->codec->bit_rate = 0;
2183
    }
2184
    st->index = s->nb_streams;
2185
    st->id = id;
2186
    st->start_time = AV_NOPTS_VALUE;
2187
    st->duration = AV_NOPTS_VALUE;
2188
    st->cur_dts = AV_NOPTS_VALUE;
2189
    st->first_dts = AV_NOPTS_VALUE;
2190

    
2191
    /* default pts setting is MPEG-like */
2192
    av_set_pts_info(st, 33, 1, 90000);
2193
    st->last_IP_pts = AV_NOPTS_VALUE;
2194
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2195
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2196

    
2197
    s->streams[s->nb_streams++] = st;
2198
    return st;
2199
}
2200

    
2201
AVProgram *av_new_program(AVFormatContext *ac, int id)
2202
{
2203
    AVProgram *program=NULL;
2204
    int i;
2205

    
2206
#ifdef DEBUG_SI
2207
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2208
#endif
2209

    
2210
    for(i=0; i<ac->nb_programs; i++)
2211
        if(ac->programs[i]->id == id)
2212
            program = ac->programs[i];
2213

    
2214
    if(!program){
2215
        program = av_mallocz(sizeof(AVProgram));
2216
        if (!program)
2217
            return NULL;
2218
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2219
        program->discard = AVDISCARD_NONE;
2220
    }
2221
    program->id = id;
2222

    
2223
    return program;
2224
}
2225

    
2226
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2227
{
2228
    assert(!provider_name == !name);
2229
    if(name){
2230
        av_free(program->provider_name);
2231
        av_free(program->         name);
2232
        program->provider_name = av_strdup(provider_name);
2233
        program->         name = av_strdup(         name);
2234
    }
2235
}
2236

    
2237
int ff_new_chapter(AVFormatContext *s, int id, int64_t start, int64_t end, const char *title)
2238
{
2239
    AVChapter *chapter = NULL;
2240
    int i;
2241

    
2242
    for(i=0; i<s->nb_chapters; i++)
2243
        if(s->chapters[i]->id == id)
2244
            chapter = s->chapters[i];
2245

    
2246
    if(!chapter){
2247
        chapter= av_mallocz(sizeof(AVChapter));
2248
        if(!chapter)
2249
            return AVERROR(ENOMEM);
2250
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2251
    }
2252
    if(chapter->title)
2253
        av_free(chapter->title);
2254
    chapter->title = av_strdup(title);
2255
    chapter->id    = id;
2256
    chapter->start = start;
2257
    chapter->end   = end;
2258

    
2259
    return 0;
2260
}
2261

    
2262
/************************************************************/
2263
/* output media file */
2264

    
2265
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2266
{
2267
    int ret;
2268

    
2269
    if (s->oformat->priv_data_size > 0) {
2270
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2271
        if (!s->priv_data)
2272
            return AVERROR(ENOMEM);
2273
    } else
2274
        s->priv_data = NULL;
2275

    
2276
    if (s->oformat->set_parameters) {
2277
        ret = s->oformat->set_parameters(s, ap);
2278
        if (ret < 0)
2279
            return ret;
2280
    }
2281
    return 0;
2282
}
2283

    
2284
int av_write_header(AVFormatContext *s)
2285
{
2286
    int ret, i;
2287
    AVStream *st;
2288

    
2289
    // some sanity checks
2290
    for(i=0;i<s->nb_streams;i++) {
2291
        st = s->streams[i];
2292

    
2293
        switch (st->codec->codec_type) {
2294
        case CODEC_TYPE_AUDIO:
2295
            if(st->codec->sample_rate<=0){
2296
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2297
                return -1;
2298
            }
2299
            break;
2300
        case CODEC_TYPE_VIDEO:
2301
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2302
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2303
                return -1;
2304
            }
2305
            if(st->codec->width<=0 || st->codec->height<=0){
2306
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2307
                return -1;
2308
            }
2309
            break;
2310
        }
2311

    
2312
        if(s->oformat->codec_tag){
2313
            if(st->codec->codec_tag){
2314
                //FIXME
2315
                //check that tag + id is in the table
2316
                //if neither is in the table -> OK
2317
                //if tag is in the table with another id -> FAIL
2318
                //if id is in the table with another tag -> FAIL unless strict < ?
2319
            }else
2320
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2321
        }
2322
    }
2323

    
2324
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2325
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2326
        if (!s->priv_data)
2327
            return AVERROR(ENOMEM);
2328
    }
2329

    
2330
    if(s->oformat->write_header){
2331
        ret = s->oformat->write_header(s);
2332
        if (ret < 0)
2333
            return ret;
2334
    }
2335

    
2336
    /* init PTS generation */
2337
    for(i=0;i<s->nb_streams;i++) {
2338
        int64_t den = AV_NOPTS_VALUE;
2339
        st = s->streams[i];
2340

    
2341
        switch (st->codec->codec_type) {
2342
        case CODEC_TYPE_AUDIO:
2343
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2344
            break;
2345
        case CODEC_TYPE_VIDEO:
2346
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2347
            break;
2348
        default:
2349
            break;
2350
        }
2351
        if (den != AV_NOPTS_VALUE) {
2352
            if (den <= 0)
2353
                return AVERROR_INVALIDDATA;
2354
            av_frac_init(&st->pts, 0, 0, den);
2355
        }
2356
    }
2357
    return 0;
2358
}
2359

    
2360
//FIXME merge with compute_pkt_fields
2361
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2362
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2363
    int num, den, frame_size, i;
2364

    
2365
//    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);
2366

    
2367
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2368
        return -1;*/
2369

    
2370
    /* duration field */
2371
    if (pkt->duration == 0) {
2372
        compute_frame_duration(&num, &den, st, NULL, pkt);
2373
        if (den && num) {
2374
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2375
        }
2376
    }
2377

    
2378
    //XXX/FIXME this is a temporary hack until all encoders output pts
2379
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2380
        pkt->dts=
2381
//        pkt->pts= st->cur_dts;
2382
        pkt->pts= st->pts.val;
2383
    }
2384

    
2385
    //calculate dts from pts
2386
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2387
        st->pts_buffer[0]= pkt->pts;
2388
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2389
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2390
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2391
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2392

    
2393
        pkt->dts= st->pts_buffer[0];
2394
    }
2395

    
2396
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2397
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2398
        return -1;
2399
    }
2400
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2401
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2402
        return -1;
2403
    }
2404

    
2405
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2406
    st->cur_dts= pkt->dts;
2407
    st->pts.val= pkt->dts;
2408

    
2409
    /* update pts */
2410
    switch (st->codec->codec_type) {
2411
    case CODEC_TYPE_AUDIO:
2412
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2413

    
2414
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2415
           likely equal to the encoder delay, but it would be better if we
2416
           had the real timestamps from the encoder */
2417
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2418
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2419
        }
2420
        break;
2421
    case CODEC_TYPE_VIDEO:
2422
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2423
        break;
2424
    default:
2425
        break;
2426
    }
2427
    return 0;
2428
}
2429

    
2430
static void truncate_ts(AVStream *st, AVPacket *pkt){
2431
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2432

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

    
2436
    if (pkt->pts != AV_NOPTS_VALUE)
2437
        pkt->pts &= pts_mask;
2438
    if (pkt->dts != AV_NOPTS_VALUE)
2439
        pkt->dts &= pts_mask;
2440
}
2441

    
2442
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2443
{
2444
    int ret;
2445

    
2446
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2447
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2448
        return ret;
2449

    
2450
    truncate_ts(s->streams[pkt->stream_index], pkt);
2451

    
2452
    ret= s->oformat->write_packet(s, pkt);
2453
    if(!ret)
2454
        ret= url_ferror(s->pb);
2455
    return ret;
2456
}
2457

    
2458
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2459
    AVPacketList *pktl, **next_point, *this_pktl;
2460
    int stream_count=0;
2461
    int streams[MAX_STREAMS];
2462

    
2463
    if(pkt){
2464
        AVStream *st= s->streams[ pkt->stream_index];
2465

    
2466
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2467

    
2468
        this_pktl = av_mallocz(sizeof(AVPacketList));
2469
        this_pktl->pkt= *pkt;
2470
        if(pkt->destruct == av_destruct_packet)
2471
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2472
        else
2473
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2474

    
2475
        next_point = &s->packet_buffer;
2476
        while(*next_point){
2477
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2478
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2479
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2480
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2481
                break;
2482
            next_point= &(*next_point)->next;
2483
        }
2484
        this_pktl->next= *next_point;
2485
        *next_point= this_pktl;
2486
    }
2487

    
2488
    memset(streams, 0, sizeof(streams));
2489
    pktl= s->packet_buffer;
2490
    while(pktl){
2491
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2492
        if(streams[ pktl->pkt.stream_index ] == 0)
2493
            stream_count++;
2494
        streams[ pktl->pkt.stream_index ]++;
2495
        pktl= pktl->next;
2496
    }
2497

    
2498
    if(s->nb_streams == stream_count || (flush && stream_count)){
2499
        pktl= s->packet_buffer;
2500
        *out= pktl->pkt;
2501

    
2502
        s->packet_buffer= pktl->next;
2503
        av_freep(&pktl);
2504
        return 1;
2505
    }else{
2506
        av_init_packet(out);
2507
        return 0;
2508
    }
2509
}
2510

    
2511
/**
2512
 * Interleaves an AVPacket correctly so it can be muxed.
2513
 * @param out the interleaved packet will be output here
2514
 * @param in the input packet
2515
 * @param flush 1 if no further packets are available as input and all
2516
 *              remaining packets should be output
2517
 * @return 1 if a packet was output, 0 if no packet could be output,
2518
 *         < 0 if an error occurred
2519
 */
2520
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2521
    if(s->oformat->interleave_packet)
2522
        return s->oformat->interleave_packet(s, out, in, flush);
2523
    else
2524
        return av_interleave_packet_per_dts(s, out, in, flush);
2525
}
2526

    
2527
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2528
    AVStream *st= s->streams[ pkt->stream_index];
2529

    
2530
    //FIXME/XXX/HACK drop zero sized packets
2531
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2532
        return 0;
2533

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

    
2538
    if(pkt->dts == AV_NOPTS_VALUE)
2539
        return -1;
2540

    
2541
    for(;;){
2542
        AVPacket opkt;
2543
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2544
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2545
            return ret;
2546

    
2547
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2548
        ret= s->oformat->write_packet(s, &opkt);
2549

    
2550
        av_free_packet(&opkt);
2551
        pkt= NULL;
2552

    
2553
        if(ret<0)
2554
            return ret;
2555
        if(url_ferror(s->pb))
2556
            return url_ferror(s->pb);
2557
    }
2558
}
2559

    
2560
int av_write_trailer(AVFormatContext *s)
2561
{
2562
    int ret, i;
2563

    
2564
    for(;;){
2565
        AVPacket pkt;
2566
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2567
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2568
            goto fail;
2569
        if(!ret)
2570
            break;
2571

    
2572
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2573
        ret= s->oformat->write_packet(s, &pkt);
2574

    
2575
        av_free_packet(&pkt);
2576

    
2577
        if(ret<0)
2578
            goto fail;
2579
        if(url_ferror(s->pb))
2580
            goto fail;
2581
    }
2582

    
2583
    if(s->oformat->write_trailer)
2584
        ret = s->oformat->write_trailer(s);
2585
fail:
2586
    if(ret == 0)
2587
       ret=url_ferror(s->pb);
2588
    for(i=0;i<s->nb_streams;i++)
2589
        av_freep(&s->streams[i]->priv_data);
2590
    av_freep(&s->priv_data);
2591
    return ret;
2592
}
2593

    
2594
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2595
{
2596
    int i, j;
2597
    AVProgram *program=NULL;
2598
    void *tmp;
2599

    
2600
    for(i=0; i<ac->nb_programs; i++){
2601
        if(ac->programs[i]->id != progid)
2602
            continue;
2603
        program = ac->programs[i];
2604
        for(j=0; j<program->nb_stream_indexes; j++)
2605
            if(program->stream_index[j] == idx)
2606
                return;
2607

    
2608
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2609
        if(!tmp)
2610
            return;
2611
        program->stream_index = tmp;
2612
        program->stream_index[program->nb_stream_indexes++] = idx;
2613
        return;
2614
    }
2615
}
2616

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

    
2645
void dump_format(AVFormatContext *ic,
2646
                 int index,
2647
                 const char *url,
2648
                 int is_output)
2649
{
2650
    int i;
2651

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

    
2701
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2702
{
2703
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2704
}
2705

    
2706
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2707
{
2708
    AVRational frame_rate;
2709
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2710
    *frame_rate_num= frame_rate.num;
2711
    *frame_rate_den= frame_rate.den;
2712
    return ret;
2713
}
2714

    
2715
/**
2716
 * Gets the current time in microseconds.
2717
 */
2718
int64_t av_gettime(void)
2719
{
2720
    struct timeval tv;
2721
    gettimeofday(&tv,NULL);
2722
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2723
}
2724

    
2725
int64_t parse_date(const char *datestr, int duration)
2726
{
2727
    const char *p;
2728
    int64_t t;
2729
    struct tm dt;
2730
    int i;
2731
    static const char *date_fmt[] = {
2732
        "%Y-%m-%d",
2733
        "%Y%m%d",
2734
    };
2735
    static const char *time_fmt[] = {
2736
        "%H:%M:%S",
2737
        "%H%M%S",
2738
    };
2739
    const char *q;
2740
    int is_utc, len;
2741
    char lastch;
2742
    int negative = 0;
2743

    
2744
#undef time
2745
    time_t now = time(0);
2746

    
2747
    len = strlen(datestr);
2748
    if (len > 0)
2749
        lastch = datestr[len - 1];
2750
    else
2751
        lastch = '\0';
2752
    is_utc = (lastch == 'z' || lastch == 'Z');
2753

    
2754
    memset(&dt, 0, sizeof(dt));
2755

    
2756
    p = datestr;
2757
    q = NULL;
2758
    if (!duration) {
2759
        /* parse the year-month-day part */
2760
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2761
            q = small_strptime(p, date_fmt[i], &dt);
2762
            if (q) {
2763
                break;
2764
            }
2765
        }
2766

    
2767
        /* if the year-month-day part is missing, then take the
2768
         * current year-month-day time */
2769
        if (!q) {
2770
            if (is_utc) {
2771
                dt = *gmtime(&now);
2772
            } else {
2773
                dt = *localtime(&now);
2774
            }
2775
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2776
        } else {
2777
            p = q;
2778
        }
2779

    
2780
        if (*p == 'T' || *p == 't' || *p == ' ')
2781
            p++;
2782

    
2783
        /* parse the hour-minute-second part */
2784
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2785
            q = small_strptime(p, time_fmt[i], &dt);
2786
            if (q) {
2787
                break;
2788
            }
2789
        }
2790
    } else {
2791
        /* parse datestr as a duration */
2792
        if (p[0] == '-') {
2793
            negative = 1;
2794
            ++p;
2795
        }
2796
        /* parse datestr as HH:MM:SS */
2797
        q = small_strptime(p, time_fmt[0], &dt);
2798
        if (!q) {
2799
            /* parse datestr as S+ */
2800
            dt.tm_sec = strtol(p, (char **)&q, 10);
2801
            if (q == p)
2802
                /* the parsing didn't succeed */
2803
                return INT64_MIN;
2804
            dt.tm_min = 0;
2805
            dt.tm_hour = 0;
2806
        }
2807
    }
2808

    
2809
    /* Now we have all the fields that we can get */
2810
    if (!q) {
2811
        return INT64_MIN;
2812
    }
2813

    
2814
    if (duration) {
2815
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2816
    } else {
2817
        dt.tm_isdst = -1;       /* unknown */
2818
        if (is_utc) {
2819
            t = mktimegm(&dt);
2820
        } else {
2821
            t = mktime(&dt);
2822
        }
2823
    }
2824

    
2825
    t *= 1000000;
2826

    
2827
    /* parse the .m... part */
2828
    if (*q == '.') {
2829
        int val, n;
2830
        q++;
2831
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2832
            if (!isdigit(*q))
2833
                break;
2834
            val += n * (*q - '0');
2835
        }
2836
        t += val;
2837
    }
2838
    return negative ? -t : t;
2839
}
2840

    
2841
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2842
{
2843
    const char *p;
2844
    char tag[128], *q;
2845

    
2846
    p = info;
2847
    if (*p == '?')
2848
        p++;
2849
    for(;;) {
2850
        q = tag;
2851
        while (*p != '\0' && *p != '=' && *p != '&') {
2852
            if ((q - tag) < sizeof(tag) - 1)
2853
                *q++ = *p;
2854
            p++;
2855
        }
2856
        *q = '\0';
2857
        q = arg;
2858
        if (*p == '=') {
2859
            p++;
2860
            while (*p != '&' && *p != '\0') {
2861
                if ((q - arg) < arg_size - 1) {
2862
                    if (*p == '+')
2863
                        *q++ = ' ';
2864
                    else
2865
                        *q++ = *p;
2866
                }
2867
                p++;
2868
            }
2869
            *q = '\0';
2870
        }
2871
        if (!strcmp(tag, tag1))
2872
            return 1;
2873
        if (*p != '&')
2874
            break;
2875
        p++;
2876
    }
2877
    return 0;
2878
}
2879

    
2880
int av_get_frame_filename(char *buf, int buf_size,
2881
                          const char *path, int number)
2882
{
2883
    const char *p;
2884
    char *q, buf1[20], c;
2885
    int nd, len, percentd_found;
2886

    
2887
    q = buf;
2888
    p = path;
2889
    percentd_found = 0;
2890
    for(;;) {
2891
        c = *p++;
2892
        if (c == '\0')
2893
            break;
2894
        if (c == '%') {
2895
            do {
2896
                nd = 0;
2897
                while (isdigit(*p)) {
2898
                    nd = nd * 10 + *p++ - '0';
2899
                }
2900
                c = *p++;
2901
            } while (isdigit(c));
2902

    
2903
            switch(c) {
2904
            case '%':
2905
                goto addchar;
2906
            case 'd':
2907
                if (percentd_found)
2908
                    goto fail;
2909
                percentd_found = 1;
2910
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2911
                len = strlen(buf1);
2912
                if ((q - buf + len) > buf_size - 1)
2913
                    goto fail;
2914
                memcpy(q, buf1, len);
2915
                q += len;
2916
                break;
2917
            default:
2918
                goto fail;
2919
            }
2920
        } else {
2921
        addchar:
2922
            if ((q - buf) < buf_size - 1)
2923
                *q++ = c;
2924
        }
2925
    }
2926
    if (!percentd_found)
2927
        goto fail;
2928
    *q = '\0';
2929
    return 0;
2930
 fail:
2931
    *q = '\0';
2932
    return -1;
2933
}
2934

    
2935
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2936
{
2937
    int len, i, j, c;
2938
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2939

    
2940
    for(i=0;i<size;i+=16) {
2941
        len = size - i;
2942
        if (len > 16)
2943
            len = 16;
2944
        PRINT("%08x ", i);
2945
        for(j=0;j<16;j++) {
2946
            if (j < len)
2947
                PRINT(" %02x", buf[i+j]);
2948
            else
2949
                PRINT("   ");
2950
        }
2951
        PRINT(" ");
2952
        for(j=0;j<len;j++) {
2953
            c = buf[i+j];
2954
            if (c < ' ' || c > '~')
2955
                c = '.';
2956
            PRINT("%c", c);
2957
        }
2958
        PRINT("\n");
2959
    }
2960
#undef PRINT
2961
}
2962

    
2963
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2964
{
2965
    hex_dump_internal(NULL, f, 0, buf, size);
2966
}
2967

    
2968
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2969
{
2970
    hex_dump_internal(avcl, NULL, level, buf, size);
2971
}
2972

    
2973
 //FIXME needs to know the time_base
2974
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2975
{
2976
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2977
    PRINT("stream #%d:\n", pkt->stream_index);
2978
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2979
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2980
    /* DTS is _always_ valid after av_read_frame() */
2981
    PRINT("  dts=");
2982
    if (pkt->dts == AV_NOPTS_VALUE)
2983
        PRINT("N/A");
2984
    else
2985
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2986
    /* PTS may not be known if B-frames are present. */
2987
    PRINT("  pts=");
2988
    if (pkt->pts == AV_NOPTS_VALUE)
2989
        PRINT("N/A");
2990
    else
2991
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2992
    PRINT("\n");
2993
    PRINT("  size=%d\n", pkt->size);
2994
#undef PRINT
2995
    if (dump_payload)
2996
        av_hex_dump(f, pkt->data, pkt->size);
2997
}
2998

    
2999
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3000
{
3001
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3002
}
3003

    
3004
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3005
{
3006
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3007
}
3008

    
3009
void url_split(char *proto, int proto_size,
3010
               char *authorization, int authorization_size,
3011
               char *hostname, int hostname_size,
3012
               int *port_ptr,
3013
               char *path, int path_size,
3014
               const char *url)
3015
{
3016
    const char *p, *ls, *at, *col, *brk;
3017

    
3018
    if (port_ptr)               *port_ptr = -1;
3019
    if (proto_size > 0)         proto[0] = 0;
3020
    if (authorization_size > 0) authorization[0] = 0;
3021
    if (hostname_size > 0)      hostname[0] = 0;
3022
    if (path_size > 0)          path[0] = 0;
3023

    
3024
    /* parse protocol */
3025
    if ((p = strchr(url, ':'))) {
3026
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3027
        p++; /* skip ':' */
3028
        if (*p == '/') p++;
3029
        if (*p == '/') p++;
3030
    } else {
3031
        /* no protocol means plain filename */
3032
        av_strlcpy(path, url, path_size);
3033
        return;
3034
    }
3035

    
3036
    /* separate path from hostname */
3037
    ls = strchr(p, '/');
3038
    if(!ls)
3039
        ls = strchr(p, '?');
3040
    if(ls)
3041
        av_strlcpy(path, ls, path_size);
3042
    else
3043
        ls = &p[strlen(p)]; // XXX
3044

    
3045
    /* the rest is hostname, use that to parse auth/port */
3046
    if (ls != p) {
3047
        /* authorization (user[:pass]@hostname) */
3048
        if ((at = strchr(p, '@')) && at < ls) {
3049
            av_strlcpy(authorization, p,
3050
                       FFMIN(authorization_size, at + 1 - p));
3051
            p = at + 1; /* skip '@' */
3052
        }
3053

    
3054
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3055
            /* [host]:port */
3056
            av_strlcpy(hostname, p + 1,
3057
                       FFMIN(hostname_size, brk - p));
3058
            if (brk[1] == ':' && port_ptr)
3059
                *port_ptr = atoi(brk + 2);
3060
        } else if ((col = strchr(p, ':')) && col < ls) {
3061
            av_strlcpy(hostname, p,
3062
                       FFMIN(col + 1 - p, hostname_size));
3063
            if (port_ptr) *port_ptr = atoi(col + 1);
3064
        } else
3065
            av_strlcpy(hostname, p,
3066
                       FFMIN(ls + 1 - p, hostname_size));
3067
    }
3068
}
3069

    
3070
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3071
                     int pts_num, int pts_den)
3072
{
3073
    s->pts_wrap_bits = pts_wrap_bits;
3074
    s->time_base.num = pts_num;
3075
    s->time_base.den = pts_den;
3076
}
3077

    
3078
/* fraction handling */
3079

    
3080
/**
3081
 * f = val + (num / den) + 0.5.
3082
 *
3083
 * 'num' is normalized so that it is such as 0 <= num < den.
3084
 *
3085
 * @param f fractional number
3086
 * @param val integer value
3087
 * @param num must be >= 0
3088
 * @param den must be >= 1
3089
 */
3090
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3091
{
3092
    num += (den >> 1);
3093
    if (num >= den) {
3094
        val += num / den;
3095
        num = num % den;
3096
    }
3097
    f->val = val;
3098
    f->num = num;
3099
    f->den = den;
3100
}
3101

    
3102
/**
3103
 * Fractional addition to f: f = f + (incr / f->den).
3104
 *
3105
 * @param f fractional number
3106
 * @param incr increment, can be positive or negative
3107
 */
3108
static void av_frac_add(AVFrac *f, int64_t incr)
3109
{
3110
    int64_t num, den;
3111

    
3112
    num = f->num + incr;
3113
    den = f->den;
3114
    if (num < 0) {
3115
        f->val += num / den;
3116
        num = num % den;
3117
        if (num < 0) {
3118
            num += den;
3119
            f->val--;
3120
        }
3121
    } else if (num >= den) {
3122
        f->val += num / den;
3123
        num = num % den;
3124
    }
3125
    f->num = num;
3126
}