Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 91acf9a8

History | View | Annotate | Download (93.6 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 "opt.h"
23
#include "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
        }
286
    }
287
    return fmt;
288
}
289

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

    
295
/************************************************************/
296
/* input media file */
297

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

    
309
#define OFFSET(x) offsetof(AVFormatContext,x)
310
#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
311
//these names are too long to be readable
312
#define E AV_OPT_FLAG_ENCODING_PARAM
313
#define D AV_OPT_FLAG_DECODING_PARAM
314

    
315
static const AVOption options[]={
316
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
317
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
318
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
319
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
320
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
321
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
322
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
323
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
324
{"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},
325
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
326
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, INT_MAX, 0, INT_MAX, D},
327
{NULL},
328
};
329

    
330
#undef E
331
#undef D
332
#undef DEFAULT
333

    
334
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
335

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

    
340
    s->av_class = &av_format_context_class;
341

    
342
    av_opt_set_defaults(s);
343
}
344

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

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

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

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

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

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

    
397
    if (pb && !ic->data_offset)
398
        ic->data_offset = url_ftell(ic->pb);
399

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

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

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

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

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

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

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

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

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

    
490
}
491

    
492
/*******************************************************/
493

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

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

    
516
    return ret;
517
}
518

    
519
/**********************************************************/
520

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

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

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

    
547

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

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

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

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

    
612
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
613
        return;
614

    
615
    st->first_dts= dts - st->cur_dts;
616
    st->cur_dts= dts;
617

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

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

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

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

    
639
    assert(pkt->duration && !st->cur_dts);
640

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

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

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

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

    
670
            if(st->cur_dts == 0)
671
                update_initial_durations(s, st, pkt);
672
        }
673
    }
674

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

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

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

    
702
//    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);
703
    /* interpolate PTS and DTS if they are not present */
704
    if(delay <=1){
705
        if (presentation_delayed) {
706
            int fields= 2 + (pc ? pc->repeat_pict : 0);
707
            int field_duration= pkt->duration / fields;
708
            int parity= pc ? pc->parity : 0;
709
            /* DTS = decompression timestamp */
710
            /* PTS = presentation timestamp */
711
            if (pkt->dts == AV_NOPTS_VALUE)
712
                pkt->dts = st->last_IP_pts[parity];
713
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
714
            if (pkt->dts == AV_NOPTS_VALUE)
715
                pkt->dts = st->cur_dts;
716

    
717
            /* this is tricky: the dts must be incremented by the duration
718
            of the frame we are displaying, i.e. the last I- or P-frame */
719
            st->cur_dts = pkt->dts;
720
            for(i=0; i<fields; i++){
721
                int p= (parity + i)&1;
722
                if(!st->last_IP_duration[p])
723
                    st->last_IP_duration[p]= field_duration;
724
                st->cur_dts += st->last_IP_duration[p];
725
                st->last_IP_pts[p]= pkt->pts;
726
                if(pkt->pts != AV_NOPTS_VALUE)
727
                    st->last_IP_pts[p] += i*field_duration;
728
                st->last_IP_duration[p]= field_duration;
729
            }
730
            /* cannot compute PTS if not present (we can compute it only
731
            by knowing the future */
732
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
733
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
734
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
735
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
736
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
737
                    pkt->pts += pkt->duration;
738
    //                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);
739
                }
740
            }
741

    
742
            /* presentation is not delayed : PTS and DTS are the same */
743
            if(pkt->pts == AV_NOPTS_VALUE)
744
                pkt->pts = pkt->dts;
745
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
746
            if(pkt->pts == AV_NOPTS_VALUE)
747
                pkt->pts = st->cur_dts;
748
            pkt->dts = pkt->pts;
749
            st->cur_dts = pkt->pts + pkt->duration;
750
        }
751
    }
752

    
753
    if(pkt->pts != AV_NOPTS_VALUE){
754
        st->pts_buffer[0]= pkt->pts;
755
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
756
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
757
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
758
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
759
        if(pkt->dts == AV_NOPTS_VALUE)
760
            pkt->dts= st->pts_buffer[0];
761
        if(delay>1){
762
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
763
        }
764
        if(pkt->dts > st->cur_dts)
765
            st->cur_dts = pkt->dts;
766
    }
767

    
768
//    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);
769

    
770
    /* update flags */
771
    if(is_intra_only(st->codec))
772
        pkt->flags |= PKT_FLAG_KEY;
773
    else if (pc) {
774
        pkt->flags = 0;
775
        /* keyframe computation */
776
            if (pc->pict_type == FF_I_TYPE)
777
                pkt->flags |= PKT_FLAG_KEY;
778
    }
779
}
780

    
781
void av_destruct_packet_nofree(AVPacket *pkt)
782
{
783
    pkt->data = NULL; pkt->size = 0;
784
}
785

    
786
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
787
{
788
    AVStream *st;
789
    int len, ret, i;
790

    
791
    av_init_packet(pkt);
792

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

    
814
                /* return packet if any */
815
                if (pkt->size) {
816
                got_packet:
817
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
818
                    pkt->duration = 0;
819
                    pkt->stream_index = st->index;
820
                    pkt->pts = st->parser->pts;
821
                    pkt->dts = st->parser->dts;
822
                    pkt->destruct = av_destruct_packet_nofree;
823
                    compute_pkt_fields(s, st, st->parser, pkt);
824

    
825
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
826
                        ff_reduce_index(s, st->index);
827
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
828
                                           0, 0, AVINDEX_KEYFRAME);
829
                    }
830

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

    
860
            st = s->streams[s->cur_pkt.stream_index];
861
            if(st->codec->debug & FF_DEBUG_PTS)
862
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
863
                    s->cur_pkt.stream_index,
864
                    s->cur_pkt.pts,
865
                    s->cur_pkt.dts,
866
                    s->cur_pkt.size);
867

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

    
893
    return 0;
894
}
895

    
896
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
897
    AVPacketList *pktl= s->packet_buffer;
898
    AVPacketList **plast_pktl= &s->packet_buffer;
899

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

    
902
    pktl = av_mallocz(sizeof(AVPacketList));
903
    if (!pktl)
904
        return NULL;
905

    
906
    /* add the packet in the buffered packet list */
907
    *plast_pktl = pktl;
908
    pktl->pkt= *pkt;
909
    return &pktl->pkt;
910
}
911

    
912
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
913
{
914
    AVPacketList *pktl;
915
    int eof=0;
916
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
917

    
918
    for(;;){
919
        pktl = s->packet_buffer;
920
        if (pktl) {
921
            AVPacket *next_pkt= &pktl->pkt;
922

    
923
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
924
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
925
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
926
                       && next_pkt->dts < pktl->pkt.dts
927
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
928
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
929
                        next_pkt->pts= pktl->pkt.dts;
930
                    }
931
                    pktl= pktl->next;
932
                }
933
                pktl = s->packet_buffer;
934
            }
935

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

    
956
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
957
                return AVERROR(ENOMEM);
958
        }else{
959
            assert(!s->packet_buffer);
960
            return av_read_frame_internal(s, pkt);
961
        }
962
    }
963
}
964

    
965
/* XXX: suppress the packet queue */
966
static void flush_packet_queue(AVFormatContext *s)
967
{
968
    AVPacketList *pktl;
969

    
970
    for(;;) {
971
        pktl = s->packet_buffer;
972
        if (!pktl)
973
            break;
974
        s->packet_buffer = pktl->next;
975
        av_free_packet(&pktl->pkt);
976
        av_free(pktl);
977
    }
978
}
979

    
980
/*******************************************************/
981
/* seek support */
982

    
983
int av_find_default_stream_index(AVFormatContext *s)
984
{
985
    int i;
986
    AVStream *st;
987

    
988
    if (s->nb_streams <= 0)
989
        return -1;
990
    for(i = 0; i < s->nb_streams; i++) {
991
        st = s->streams[i];
992
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
993
            return i;
994
        }
995
    }
996
    return 0;
997
}
998

    
999
/**
1000
 * Flush the frame reader.
1001
 */
1002
static void av_read_frame_flush(AVFormatContext *s)
1003
{
1004
    AVStream *st;
1005
    int i;
1006

    
1007
    flush_packet_queue(s);
1008

    
1009
    /* free previous packet */
1010
    if (s->cur_st) {
1011
        if (s->cur_st->parser)
1012
            av_free_packet(&s->cur_pkt);
1013
        s->cur_st = NULL;
1014
    }
1015
    /* fail safe */
1016
    s->cur_ptr = NULL;
1017
    s->cur_len = 0;
1018

    
1019
    /* for each stream, reset read state */
1020
    for(i = 0; i < s->nb_streams; i++) {
1021
        st = s->streams[i];
1022

    
1023
        if (st->parser) {
1024
            av_parser_close(st->parser);
1025
            st->parser = NULL;
1026
        }
1027
        st->last_IP_pts[0] =
1028
        st->last_IP_pts[1] = AV_NOPTS_VALUE;
1029
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1030
    }
1031
}
1032

    
1033
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1034
    int i;
1035

    
1036
    for(i = 0; i < s->nb_streams; i++) {
1037
        AVStream *st = s->streams[i];
1038

    
1039
        st->cur_dts = av_rescale(timestamp,
1040
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1041
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1042
    }
1043
}
1044

    
1045
void ff_reduce_index(AVFormatContext *s, int stream_index)
1046
{
1047
    AVStream *st= s->streams[stream_index];
1048
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1049

    
1050
    if((unsigned)st->nb_index_entries >= max_entries){
1051
        int i;
1052
        for(i=0; 2*i<st->nb_index_entries; i++)
1053
            st->index_entries[i]= st->index_entries[2*i];
1054
        st->nb_index_entries= i;
1055
    }
1056
}
1057

    
1058
int av_add_index_entry(AVStream *st,
1059
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1060
{
1061
    AVIndexEntry *entries, *ie;
1062
    int index;
1063

    
1064
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1065
        return -1;
1066

    
1067
    entries = av_fast_realloc(st->index_entries,
1068
                              &st->index_entries_allocated_size,
1069
                              (st->nb_index_entries + 1) *
1070
                              sizeof(AVIndexEntry));
1071
    if(!entries)
1072
        return -1;
1073

    
1074
    st->index_entries= entries;
1075

    
1076
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1077

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

    
1093
    ie->pos = pos;
1094
    ie->timestamp = timestamp;
1095
    ie->min_distance= distance;
1096
    ie->size= size;
1097
    ie->flags = flags;
1098

    
1099
    return index;
1100
}
1101

    
1102
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1103
                              int flags)
1104
{
1105
    AVIndexEntry *entries= st->index_entries;
1106
    int nb_entries= st->nb_index_entries;
1107
    int a, b, m;
1108
    int64_t timestamp;
1109

    
1110
    a = - 1;
1111
    b = nb_entries;
1112

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

    
1123
    if(!(flags & AVSEEK_FLAG_ANY)){
1124
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1125
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1126
        }
1127
    }
1128

    
1129
    if(m == nb_entries)
1130
        return -1;
1131
    return  m;
1132
}
1133

    
1134
#define DEBUG_SEEK
1135

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

    
1143
    if (stream_index < 0)
1144
        return -1;
1145

    
1146
#ifdef DEBUG_SEEK
1147
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1148
#endif
1149

    
1150
    ts_max=
1151
    ts_min= AV_NOPTS_VALUE;
1152
    pos_limit= -1; //gcc falsely says it may be uninitialized
1153

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

    
1158
        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()
1159
        index= FFMAX(index, 0);
1160
        e= &st->index_entries[index];
1161

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

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

    
1188
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1189
    if(pos<0)
1190
        return -1;
1191

    
1192
    /* do the seek */
1193
    url_fseek(s->pb, pos, SEEK_SET);
1194

    
1195
    av_update_cur_dts(s, st, ts);
1196

    
1197
    return 0;
1198
}
1199

    
1200
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 )){
1201
    int64_t pos, ts;
1202
    int64_t start_pos, filesize;
1203
    int no_change;
1204

    
1205
#ifdef DEBUG_SEEK
1206
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1207
#endif
1208

    
1209
    if(ts_min == AV_NOPTS_VALUE){
1210
        pos_min = s->data_offset;
1211
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1212
        if (ts_min == AV_NOPTS_VALUE)
1213
            return -1;
1214
    }
1215

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

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

    
1241
    if(ts_min > ts_max){
1242
        return -1;
1243
    }else if(ts_min == ts_max){
1244
        pos_limit= pos_min;
1245
    }
1246

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

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

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

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

    
1313
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1314
    int64_t pos_min, pos_max;
1315
#if 0
1316
    AVStream *st;
1317

1318
    if (stream_index < 0)
1319
        return -1;
1320

1321
    st= s->streams[stream_index];
1322
#endif
1323

    
1324
    pos_min = s->data_offset;
1325
    pos_max = url_fsize(s->pb) - 1;
1326

    
1327
    if     (pos < pos_min) pos= pos_min;
1328
    else if(pos > pos_max) pos= pos_max;
1329

    
1330
    url_fseek(s->pb, pos, SEEK_SET);
1331

    
1332
#if 0
1333
    av_update_cur_dts(s, st, ts);
1334
#endif
1335
    return 0;
1336
}
1337

    
1338
static int av_seek_frame_generic(AVFormatContext *s,
1339
                                 int stream_index, int64_t timestamp, int flags)
1340
{
1341
    int index;
1342
    AVStream *st;
1343
    AVIndexEntry *ie;
1344

    
1345
    st = s->streams[stream_index];
1346

    
1347
    index = av_index_search_timestamp(st, timestamp, flags);
1348

    
1349
    if(index < 0 || index==st->nb_index_entries-1){
1350
        int i;
1351
        AVPacket pkt;
1352

    
1353
        if(st->index_entries && st->nb_index_entries){
1354
            ie= &st->index_entries[st->nb_index_entries-1];
1355
            url_fseek(s->pb, ie->pos, SEEK_SET);
1356
            av_update_cur_dts(s, st, ie->timestamp);
1357
        }else
1358
            url_fseek(s->pb, 0, SEEK_SET);
1359

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

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

    
1383
    av_update_cur_dts(s, st, ie->timestamp);
1384

    
1385
    return 0;
1386
}
1387

    
1388
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1389
{
1390
    int ret;
1391
    AVStream *st;
1392

    
1393
    av_read_frame_flush(s);
1394

    
1395
    if(flags & AVSEEK_FLAG_BYTE)
1396
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1397

    
1398
    if(stream_index < 0){
1399
        stream_index= av_find_default_stream_index(s);
1400
        if(stream_index < 0)
1401
            return -1;
1402

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

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

    
1418
    if(s->iformat->read_timestamp)
1419
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1420
    else
1421
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1422
}
1423

    
1424
/*******************************************************/
1425

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

    
1436
    for(i = 0;i < ic->nb_streams; i++) {
1437
        st = ic->streams[i];
1438
        if (st->duration != AV_NOPTS_VALUE)
1439
            return 1;
1440
    }
1441
    return 0;
1442
}
1443

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

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

    
1495
static void fill_all_stream_timings(AVFormatContext *ic)
1496
{
1497
    int i;
1498
    AVStream *st;
1499

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

    
1512
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1513
{
1514
    int64_t filesize, duration;
1515
    int bit_rate, i;
1516
    AVStream *st;
1517

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

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

    
1544
#define DURATION_MAX_READ_SIZE 250000
1545

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

    
1555
    /* free previous packet */
1556
    if (ic->cur_st && ic->cur_st->parser)
1557
        av_free_packet(&ic->cur_pkt);
1558
    ic->cur_st = NULL;
1559

    
1560
    /* flush packet queue */
1561
    flush_packet_queue(ic);
1562

    
1563
    for(i=0;i<ic->nb_streams;i++) {
1564
        st = ic->streams[i];
1565
        if (st->parser) {
1566
            av_parser_close(st->parser);
1567
            st->parser= NULL;
1568
        }
1569
    }
1570

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

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

    
1599
    /* estimate the end time (duration) */
1600
    /* XXX: may need to support wrapping */
1601
    filesize = ic->file_size;
1602
    offset = filesize - DURATION_MAX_READ_SIZE;
1603
    if (offset < 0)
1604
        offset = 0;
1605

    
1606
    url_fseek(ic->pb, offset, SEEK_SET);
1607
    read_size = 0;
1608
    for(;;) {
1609
        if (read_size >= DURATION_MAX_READ_SIZE)
1610
            break;
1611

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

    
1630
    fill_all_stream_timings(ic);
1631

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

    
1641
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1642
{
1643
    int64_t file_size;
1644

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

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

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

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

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

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

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

    
1744
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1745
{
1746
    AVInputFormat *fmt;
1747
    fmt = av_probe_input_format2(pd, 1, &score);
1748

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

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

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

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

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

    
1805
/* absolute maximum size we read until we abort */
1806
#define MAX_READ_SIZE        5000000
1807

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

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

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

    
1846
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1847
    if (!duration_error) return AVERROR(ENOMEM);
1848

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

    
1866
    for(i=0;i<MAX_STREAMS;i++){
1867
        last_dts[i]= AV_NOPTS_VALUE;
1868
    }
1869

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

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

    
1923
        pkt= add_to_pktbuf(ic, &pkt1);
1924
        if(av_dup_packet(pkt) < 0)
1925
            return AVERROR(ENOMEM);
1926

    
1927
        read_size += pkt->size;
1928

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

    
1935
        {
1936
            int index= pkt->stream_index;
1937
            int64_t last= last_dts[index];
1938
            int64_t duration= pkt->dts - last;
1939

    
1940
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1941
                double dur= duration * av_q2d(st->time_base);
1942

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

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

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

    
1997
        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) {
1998
            break;
1999
        }
2000
        count++;
2001
    }
2002

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

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

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

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

    
2055
    av_estimate_timings(ic, old_offset);
2056

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

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

    
2100
    av_free(duration_error);
2101
    for(i=0;i<MAX_STREAMS;i++){
2102
        av_freep(&(probe_data[i].buf));
2103
    }
2104

    
2105
    return ret;
2106
}
2107

    
2108
/*******************************************************/
2109

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

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

    
2128
void av_close_input_stream(AVFormatContext *s)
2129
{
2130
    int i;
2131
    AVStream *st;
2132

    
2133
    /* free previous packet */
2134
    if (s->cur_st && s->cur_st->parser)
2135
        av_free_packet(&s->cur_pkt);
2136

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

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

    
2170
AVStream *av_new_stream(AVFormatContext *s, int id)
2171
{
2172
    AVStream *st;
2173
    int i;
2174

    
2175
    if (s->nb_streams >= MAX_STREAMS)
2176
        return NULL;
2177

    
2178
    st = av_mallocz(sizeof(AVStream));
2179
    if (!st)
2180
        return NULL;
2181

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

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

    
2201
    s->streams[s->nb_streams++] = st;
2202
    return st;
2203
}
2204

    
2205
AVProgram *av_new_program(AVFormatContext *ac, int id)
2206
{
2207
    AVProgram *program=NULL;
2208
    int i;
2209

    
2210
#ifdef DEBUG_SI
2211
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2212
#endif
2213

    
2214
    for(i=0; i<ac->nb_programs; i++)
2215
        if(ac->programs[i]->id == id)
2216
            program = ac->programs[i];
2217

    
2218
    if(!program){
2219
        program = av_mallocz(sizeof(AVProgram));
2220
        if (!program)
2221
            return NULL;
2222
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2223
        program->discard = AVDISCARD_NONE;
2224
    }
2225
    program->id = id;
2226

    
2227
    return program;
2228
}
2229

    
2230
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2231
{
2232
    assert(!provider_name == !name);
2233
    if(name){
2234
        av_free(program->provider_name);
2235
        av_free(program->         name);
2236
        program->provider_name = av_strdup(provider_name);
2237
        program->         name = av_strdup(         name);
2238
    }
2239
}
2240

    
2241

    
2242
/************************************************************/
2243
/* output media file */
2244

    
2245
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2246
{
2247
    int ret;
2248

    
2249
    if (s->oformat->priv_data_size > 0) {
2250
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2251
        if (!s->priv_data)
2252
            return AVERROR(ENOMEM);
2253
    } else
2254
        s->priv_data = NULL;
2255

    
2256
    if (s->oformat->set_parameters) {
2257
        ret = s->oformat->set_parameters(s, ap);
2258
        if (ret < 0)
2259
            return ret;
2260
    }
2261
    return 0;
2262
}
2263

    
2264
int av_write_header(AVFormatContext *s)
2265
{
2266
    int ret, i;
2267
    AVStream *st;
2268

    
2269
    // some sanity checks
2270
    for(i=0;i<s->nb_streams;i++) {
2271
        st = s->streams[i];
2272

    
2273
        switch (st->codec->codec_type) {
2274
        case CODEC_TYPE_AUDIO:
2275
            if(st->codec->sample_rate<=0){
2276
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2277
                return -1;
2278
            }
2279
            break;
2280
        case CODEC_TYPE_VIDEO:
2281
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2282
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2283
                return -1;
2284
            }
2285
            if(st->codec->width<=0 || st->codec->height<=0){
2286
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2287
                return -1;
2288
            }
2289
            break;
2290
        }
2291

    
2292
        if(s->oformat->codec_tag){
2293
            if(st->codec->codec_tag){
2294
                //FIXME
2295
                //check that tag + id is in the table
2296
                //if neither is in the table -> OK
2297
                //if tag is in the table with another id -> FAIL
2298
                //if id is in the table with another tag -> FAIL unless strict < ?
2299
            }else
2300
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2301
        }
2302
    }
2303

    
2304
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2305
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2306
        if (!s->priv_data)
2307
            return AVERROR(ENOMEM);
2308
    }
2309

    
2310
    if(s->oformat->write_header){
2311
        ret = s->oformat->write_header(s);
2312
        if (ret < 0)
2313
            return ret;
2314
    }
2315

    
2316
    /* init PTS generation */
2317
    for(i=0;i<s->nb_streams;i++) {
2318
        int64_t den = AV_NOPTS_VALUE;
2319
        st = s->streams[i];
2320

    
2321
        switch (st->codec->codec_type) {
2322
        case CODEC_TYPE_AUDIO:
2323
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2324
            break;
2325
        case CODEC_TYPE_VIDEO:
2326
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2327
            break;
2328
        default:
2329
            break;
2330
        }
2331
        if (den != AV_NOPTS_VALUE) {
2332
            if (den <= 0)
2333
                return AVERROR_INVALIDDATA;
2334
            av_frac_init(&st->pts, 0, 0, den);
2335
        }
2336
    }
2337
    return 0;
2338
}
2339

    
2340
//FIXME merge with compute_pkt_fields
2341
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2342
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2343
    int num, den, frame_size, i;
2344

    
2345
//    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);
2346

    
2347
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2348
        return -1;*/
2349

    
2350
    /* duration field */
2351
    if (pkt->duration == 0) {
2352
        compute_frame_duration(&num, &den, st, NULL, pkt);
2353
        if (den && num) {
2354
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2355
        }
2356
    }
2357

    
2358
    //XXX/FIXME this is a temporary hack until all encoders output pts
2359
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2360
        pkt->dts=
2361
//        pkt->pts= st->cur_dts;
2362
        pkt->pts= st->pts.val;
2363
    }
2364

    
2365
    //calculate dts from pts
2366
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2367
        st->pts_buffer[0]= pkt->pts;
2368
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2369
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2370
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2371
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2372

    
2373
        pkt->dts= st->pts_buffer[0];
2374
    }
2375

    
2376
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2377
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2378
        return -1;
2379
    }
2380
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2381
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2382
        return -1;
2383
    }
2384

    
2385
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2386
    st->cur_dts= pkt->dts;
2387
    st->pts.val= pkt->dts;
2388

    
2389
    /* update pts */
2390
    switch (st->codec->codec_type) {
2391
    case CODEC_TYPE_AUDIO:
2392
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2393

    
2394
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2395
           likely equal to the encoder delay, but it would be better if we
2396
           had the real timestamps from the encoder */
2397
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2398
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2399
        }
2400
        break;
2401
    case CODEC_TYPE_VIDEO:
2402
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2403
        break;
2404
    default:
2405
        break;
2406
    }
2407
    return 0;
2408
}
2409

    
2410
static void truncate_ts(AVStream *st, AVPacket *pkt){
2411
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2412

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

    
2416
    if (pkt->pts != AV_NOPTS_VALUE)
2417
        pkt->pts &= pts_mask;
2418
    if (pkt->dts != AV_NOPTS_VALUE)
2419
        pkt->dts &= pts_mask;
2420
}
2421

    
2422
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2423
{
2424
    int ret;
2425

    
2426
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2427
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2428
        return ret;
2429

    
2430
    truncate_ts(s->streams[pkt->stream_index], pkt);
2431

    
2432
    ret= s->oformat->write_packet(s, pkt);
2433
    if(!ret)
2434
        ret= url_ferror(s->pb);
2435
    return ret;
2436
}
2437

    
2438
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2439
    AVPacketList *pktl, **next_point, *this_pktl;
2440
    int stream_count=0;
2441
    int streams[MAX_STREAMS];
2442

    
2443
    if(pkt){
2444
        AVStream *st= s->streams[ pkt->stream_index];
2445

    
2446
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2447

    
2448
        this_pktl = av_mallocz(sizeof(AVPacketList));
2449
        this_pktl->pkt= *pkt;
2450
        if(pkt->destruct == av_destruct_packet)
2451
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2452
        else
2453
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2454

    
2455
        next_point = &s->packet_buffer;
2456
        while(*next_point){
2457
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2458
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2459
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2460
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2461
                break;
2462
            next_point= &(*next_point)->next;
2463
        }
2464
        this_pktl->next= *next_point;
2465
        *next_point= this_pktl;
2466
    }
2467

    
2468
    memset(streams, 0, sizeof(streams));
2469
    pktl= s->packet_buffer;
2470
    while(pktl){
2471
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2472
        if(streams[ pktl->pkt.stream_index ] == 0)
2473
            stream_count++;
2474
        streams[ pktl->pkt.stream_index ]++;
2475
        pktl= pktl->next;
2476
    }
2477

    
2478
    if(s->nb_streams == stream_count || (flush && stream_count)){
2479
        pktl= s->packet_buffer;
2480
        *out= pktl->pkt;
2481

    
2482
        s->packet_buffer= pktl->next;
2483
        av_freep(&pktl);
2484
        return 1;
2485
    }else{
2486
        av_init_packet(out);
2487
        return 0;
2488
    }
2489
}
2490

    
2491
/**
2492
 * Interleaves an AVPacket correctly so it can be muxed.
2493
 * @param out the interleaved packet will be output here
2494
 * @param in the input packet
2495
 * @param flush 1 if no further packets are available as input and all
2496
 *              remaining packets should be output
2497
 * @return 1 if a packet was output, 0 if no packet could be output,
2498
 *         < 0 if an error occured
2499
 */
2500
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2501
    if(s->oformat->interleave_packet)
2502
        return s->oformat->interleave_packet(s, out, in, flush);
2503
    else
2504
        return av_interleave_packet_per_dts(s, out, in, flush);
2505
}
2506

    
2507
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2508
    AVStream *st= s->streams[ pkt->stream_index];
2509

    
2510
    //FIXME/XXX/HACK drop zero sized packets
2511
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2512
        return 0;
2513

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

    
2518
    if(pkt->dts == AV_NOPTS_VALUE)
2519
        return -1;
2520

    
2521
    for(;;){
2522
        AVPacket opkt;
2523
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2524
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2525
            return ret;
2526

    
2527
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2528
        ret= s->oformat->write_packet(s, &opkt);
2529

    
2530
        av_free_packet(&opkt);
2531
        pkt= NULL;
2532

    
2533
        if(ret<0)
2534
            return ret;
2535
        if(url_ferror(s->pb))
2536
            return url_ferror(s->pb);
2537
    }
2538
}
2539

    
2540
int av_write_trailer(AVFormatContext *s)
2541
{
2542
    int ret, i;
2543

    
2544
    for(;;){
2545
        AVPacket pkt;
2546
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2547
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2548
            goto fail;
2549
        if(!ret)
2550
            break;
2551

    
2552
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2553
        ret= s->oformat->write_packet(s, &pkt);
2554

    
2555
        av_free_packet(&pkt);
2556

    
2557
        if(ret<0)
2558
            goto fail;
2559
        if(url_ferror(s->pb))
2560
            goto fail;
2561
    }
2562

    
2563
    if(s->oformat->write_trailer)
2564
        ret = s->oformat->write_trailer(s);
2565
fail:
2566
    if(ret == 0)
2567
       ret=url_ferror(s->pb);
2568
    for(i=0;i<s->nb_streams;i++)
2569
        av_freep(&s->streams[i]->priv_data);
2570
    av_freep(&s->priv_data);
2571
    return ret;
2572
}
2573

    
2574
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2575
{
2576
    int i, j;
2577
    AVProgram *program=NULL;
2578
    void *tmp;
2579

    
2580
    for(i=0; i<ac->nb_programs; i++){
2581
        if(ac->programs[i]->id != progid)
2582
            continue;
2583
        program = ac->programs[i];
2584
        for(j=0; j<program->nb_stream_indexes; j++)
2585
            if(program->stream_index[j] == idx)
2586
                return;
2587

    
2588
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2589
        if(!tmp)
2590
            return;
2591
        program->stream_index = tmp;
2592
        program->stream_index[program->nb_stream_indexes++] = idx;
2593
        return;
2594
    }
2595
}
2596

    
2597
/* "user interface" functions */
2598
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2599
{
2600
    char buf[256];
2601
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2602
    AVStream *st = ic->streams[i];
2603
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2604
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2605
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2606
    /* the pid is an important information, so we display it */
2607
    /* XXX: add a generic system */
2608
    if (flags & AVFMT_SHOW_IDS)
2609
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2610
    if (strlen(st->language) > 0)
2611
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2612
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2613
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2614
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2615
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2616
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2617
/*      else if(st->time_base.den && st->time_base.num)
2618
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2619
        else
2620
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2621
    }
2622
    av_log(NULL, AV_LOG_INFO, "\n");
2623
}
2624

    
2625
void dump_format(AVFormatContext *ic,
2626
                 int index,
2627
                 const char *url,
2628
                 int is_output)
2629
{
2630
    int i;
2631

    
2632
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2633
            is_output ? "Output" : "Input",
2634
            index,
2635
            is_output ? ic->oformat->name : ic->iformat->name,
2636
            is_output ? "to" : "from", url);
2637
    if (!is_output) {
2638
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2639
        if (ic->duration != AV_NOPTS_VALUE) {
2640
            int hours, mins, secs, us;
2641
            secs = ic->duration / AV_TIME_BASE;
2642
            us = ic->duration % AV_TIME_BASE;
2643
            mins = secs / 60;
2644
            secs %= 60;
2645
            hours = mins / 60;
2646
            mins %= 60;
2647
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2648
                   (10 * us) / AV_TIME_BASE);
2649
        } else {
2650
            av_log(NULL, AV_LOG_INFO, "N/A");
2651
        }
2652
        if (ic->start_time != AV_NOPTS_VALUE) {
2653
            int secs, us;
2654
            av_log(NULL, AV_LOG_INFO, ", start: ");
2655
            secs = ic->start_time / AV_TIME_BASE;
2656
            us = ic->start_time % AV_TIME_BASE;
2657
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2658
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2659
        }
2660
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2661
        if (ic->bit_rate) {
2662
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2663
        } else {
2664
            av_log(NULL, AV_LOG_INFO, "N/A");
2665
        }
2666
        av_log(NULL, AV_LOG_INFO, "\n");
2667
    }
2668
    if(ic->nb_programs) {
2669
        int j, k;
2670
        for(j=0; j<ic->nb_programs; j++) {
2671
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2672
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2673
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2674
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2675
         }
2676
    } else
2677
    for(i=0;i<ic->nb_streams;i++)
2678
        dump_stream_format(ic, i, index, is_output);
2679
}
2680

    
2681
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2682
{
2683
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2684
}
2685

    
2686
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2687
{
2688
    AVRational frame_rate;
2689
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2690
    *frame_rate_num= frame_rate.num;
2691
    *frame_rate_den= frame_rate.den;
2692
    return ret;
2693
}
2694

    
2695
/**
2696
 * Gets the current time in microseconds.
2697
 */
2698
int64_t av_gettime(void)
2699
{
2700
    struct timeval tv;
2701
    gettimeofday(&tv,NULL);
2702
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2703
}
2704

    
2705
int64_t parse_date(const char *datestr, int duration)
2706
{
2707
    const char *p;
2708
    int64_t t;
2709
    struct tm dt;
2710
    int i;
2711
    static const char *date_fmt[] = {
2712
        "%Y-%m-%d",
2713
        "%Y%m%d",
2714
    };
2715
    static const char *time_fmt[] = {
2716
        "%H:%M:%S",
2717
        "%H%M%S",
2718
    };
2719
    const char *q;
2720
    int is_utc, len;
2721
    char lastch;
2722
    int negative = 0;
2723

    
2724
#undef time
2725
    time_t now = time(0);
2726

    
2727
    len = strlen(datestr);
2728
    if (len > 0)
2729
        lastch = datestr[len - 1];
2730
    else
2731
        lastch = '\0';
2732
    is_utc = (lastch == 'z' || lastch == 'Z');
2733

    
2734
    memset(&dt, 0, sizeof(dt));
2735

    
2736
    p = datestr;
2737
    q = NULL;
2738
    if (!duration) {
2739
        /* parse the year-month-day part */
2740
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2741
            q = small_strptime(p, date_fmt[i], &dt);
2742
            if (q) {
2743
                break;
2744
            }
2745
        }
2746

    
2747
        /* if the year-month-day part is missing, then take the
2748
         * current year-month-day time */
2749
        if (!q) {
2750
            if (is_utc) {
2751
                dt = *gmtime(&now);
2752
            } else {
2753
                dt = *localtime(&now);
2754
            }
2755
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2756
        } else {
2757
            p = q;
2758
        }
2759

    
2760
        if (*p == 'T' || *p == 't' || *p == ' ')
2761
            p++;
2762

    
2763
        /* parse the hour-minute-second part */
2764
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2765
            q = small_strptime(p, time_fmt[i], &dt);
2766
            if (q) {
2767
                break;
2768
            }
2769
        }
2770
    } else {
2771
        /* parse datestr as a duration */
2772
        if (p[0] == '-') {
2773
            negative = 1;
2774
            ++p;
2775
        }
2776
        /* parse datestr as HH:MM:SS */
2777
        q = small_strptime(p, time_fmt[0], &dt);
2778
        if (!q) {
2779
            /* parse datestr as S+ */
2780
            dt.tm_sec = strtol(p, (char **)&q, 10);
2781
            if (q == p)
2782
                /* the parsing didn't succeed */
2783
                return INT64_MIN;
2784
            dt.tm_min = 0;
2785
            dt.tm_hour = 0;
2786
        }
2787
    }
2788

    
2789
    /* Now we have all the fields that we can get */
2790
    if (!q) {
2791
        return INT64_MIN;
2792
    }
2793

    
2794
    if (duration) {
2795
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2796
    } else {
2797
        dt.tm_isdst = -1;       /* unknown */
2798
        if (is_utc) {
2799
            t = mktimegm(&dt);
2800
        } else {
2801
            t = mktime(&dt);
2802
        }
2803
    }
2804

    
2805
    t *= 1000000;
2806

    
2807
    /* parse the .m... part */
2808
    if (*q == '.') {
2809
        int val, n;
2810
        q++;
2811
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2812
            if (!isdigit(*q))
2813
                break;
2814
            val += n * (*q - '0');
2815
        }
2816
        t += val;
2817
    }
2818
    return negative ? -t : t;
2819
}
2820

    
2821
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2822
{
2823
    const char *p;
2824
    char tag[128], *q;
2825

    
2826
    p = info;
2827
    if (*p == '?')
2828
        p++;
2829
    for(;;) {
2830
        q = tag;
2831
        while (*p != '\0' && *p != '=' && *p != '&') {
2832
            if ((q - tag) < sizeof(tag) - 1)
2833
                *q++ = *p;
2834
            p++;
2835
        }
2836
        *q = '\0';
2837
        q = arg;
2838
        if (*p == '=') {
2839
            p++;
2840
            while (*p != '&' && *p != '\0') {
2841
                if ((q - arg) < arg_size - 1) {
2842
                    if (*p == '+')
2843
                        *q++ = ' ';
2844
                    else
2845
                        *q++ = *p;
2846
                }
2847
                p++;
2848
            }
2849
            *q = '\0';
2850
        }
2851
        if (!strcmp(tag, tag1))
2852
            return 1;
2853
        if (*p != '&')
2854
            break;
2855
        p++;
2856
    }
2857
    return 0;
2858
}
2859

    
2860
int av_get_frame_filename(char *buf, int buf_size,
2861
                          const char *path, int number)
2862
{
2863
    const char *p;
2864
    char *q, buf1[20], c;
2865
    int nd, len, percentd_found;
2866

    
2867
    q = buf;
2868
    p = path;
2869
    percentd_found = 0;
2870
    for(;;) {
2871
        c = *p++;
2872
        if (c == '\0')
2873
            break;
2874
        if (c == '%') {
2875
            do {
2876
                nd = 0;
2877
                while (isdigit(*p)) {
2878
                    nd = nd * 10 + *p++ - '0';
2879
                }
2880
                c = *p++;
2881
            } while (isdigit(c));
2882

    
2883
            switch(c) {
2884
            case '%':
2885
                goto addchar;
2886
            case 'd':
2887
                if (percentd_found)
2888
                    goto fail;
2889
                percentd_found = 1;
2890
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2891
                len = strlen(buf1);
2892
                if ((q - buf + len) > buf_size - 1)
2893
                    goto fail;
2894
                memcpy(q, buf1, len);
2895
                q += len;
2896
                break;
2897
            default:
2898
                goto fail;
2899
            }
2900
        } else {
2901
        addchar:
2902
            if ((q - buf) < buf_size - 1)
2903
                *q++ = c;
2904
        }
2905
    }
2906
    if (!percentd_found)
2907
        goto fail;
2908
    *q = '\0';
2909
    return 0;
2910
 fail:
2911
    *q = '\0';
2912
    return -1;
2913
}
2914

    
2915
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2916
{
2917
    int len, i, j, c;
2918
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2919

    
2920
    for(i=0;i<size;i+=16) {
2921
        len = size - i;
2922
        if (len > 16)
2923
            len = 16;
2924
        PRINT("%08x ", i);
2925
        for(j=0;j<16;j++) {
2926
            if (j < len)
2927
                PRINT(" %02x", buf[i+j]);
2928
            else
2929
                PRINT("   ");
2930
        }
2931
        PRINT(" ");
2932
        for(j=0;j<len;j++) {
2933
            c = buf[i+j];
2934
            if (c < ' ' || c > '~')
2935
                c = '.';
2936
            PRINT("%c", c);
2937
        }
2938
        PRINT("\n");
2939
    }
2940
#undef PRINT
2941
}
2942

    
2943
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2944
{
2945
    hex_dump_internal(NULL, f, 0, buf, size);
2946
}
2947

    
2948
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2949
{
2950
    hex_dump_internal(avcl, NULL, level, buf, size);
2951
}
2952

    
2953
 //FIXME needs to know the time_base
2954
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2955
{
2956
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2957
    PRINT("stream #%d:\n", pkt->stream_index);
2958
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2959
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2960
    /* DTS is _always_ valid after av_read_frame() */
2961
    PRINT("  dts=");
2962
    if (pkt->dts == AV_NOPTS_VALUE)
2963
        PRINT("N/A");
2964
    else
2965
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2966
    /* PTS may not be known if B-frames are present. */
2967
    PRINT("  pts=");
2968
    if (pkt->pts == AV_NOPTS_VALUE)
2969
        PRINT("N/A");
2970
    else
2971
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2972
    PRINT("\n");
2973
    PRINT("  size=%d\n", pkt->size);
2974
#undef PRINT
2975
    if (dump_payload)
2976
        av_hex_dump(f, pkt->data, pkt->size);
2977
}
2978

    
2979
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2980
{
2981
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2982
}
2983

    
2984
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2985
{
2986
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2987
}
2988

    
2989
void url_split(char *proto, int proto_size,
2990
               char *authorization, int authorization_size,
2991
               char *hostname, int hostname_size,
2992
               int *port_ptr,
2993
               char *path, int path_size,
2994
               const char *url)
2995
{
2996
    const char *p, *ls, *at, *col, *brk;
2997

    
2998
    if (port_ptr)               *port_ptr = -1;
2999
    if (proto_size > 0)         proto[0] = 0;
3000
    if (authorization_size > 0) authorization[0] = 0;
3001
    if (hostname_size > 0)      hostname[0] = 0;
3002
    if (path_size > 0)          path[0] = 0;
3003

    
3004
    /* parse protocol */
3005
    if ((p = strchr(url, ':'))) {
3006
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3007
        p++; /* skip ':' */
3008
        if (*p == '/') p++;
3009
        if (*p == '/') p++;
3010
    } else {
3011
        /* no protocol means plain filename */
3012
        av_strlcpy(path, url, path_size);
3013
        return;
3014
    }
3015

    
3016
    /* separate path from hostname */
3017
    ls = strchr(p, '/');
3018
    if(!ls)
3019
        ls = strchr(p, '?');
3020
    if(ls)
3021
        av_strlcpy(path, ls, path_size);
3022
    else
3023
        ls = &p[strlen(p)]; // XXX
3024

    
3025
    /* the rest is hostname, use that to parse auth/port */
3026
    if (ls != p) {
3027
        /* authorization (user[:pass]@hostname) */
3028
        if ((at = strchr(p, '@')) && at < ls) {
3029
            av_strlcpy(authorization, p,
3030
                       FFMIN(authorization_size, at + 1 - p));
3031
            p = at + 1; /* skip '@' */
3032
        }
3033

    
3034
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3035
            /* [host]:port */
3036
            av_strlcpy(hostname, p + 1,
3037
                       FFMIN(hostname_size, brk - p));
3038
            if (brk[1] == ':' && port_ptr)
3039
                *port_ptr = atoi(brk + 2);
3040
        } else if ((col = strchr(p, ':')) && col < ls) {
3041
            av_strlcpy(hostname, p,
3042
                       FFMIN(col + 1 - p, hostname_size));
3043
            if (port_ptr) *port_ptr = atoi(col + 1);
3044
        } else
3045
            av_strlcpy(hostname, p,
3046
                       FFMIN(ls + 1 - p, hostname_size));
3047
    }
3048
}
3049

    
3050
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3051
                     int pts_num, int pts_den)
3052
{
3053
    s->pts_wrap_bits = pts_wrap_bits;
3054
    s->time_base.num = pts_num;
3055
    s->time_base.den = pts_den;
3056
}
3057

    
3058
/* fraction handling */
3059

    
3060
/**
3061
 * f = val + (num / den) + 0.5.
3062
 *
3063
 * 'num' is normalized so that it is such as 0 <= num < den.
3064
 *
3065
 * @param f fractional number
3066
 * @param val integer value
3067
 * @param num must be >= 0
3068
 * @param den must be >= 1
3069
 */
3070
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3071
{
3072
    num += (den >> 1);
3073
    if (num >= den) {
3074
        val += num / den;
3075
        num = num % den;
3076
    }
3077
    f->val = val;
3078
    f->num = num;
3079
    f->den = den;
3080
}
3081

    
3082
/**
3083
 * Fractional addition to f: f = f + (incr / f->den).
3084
 *
3085
 * @param f fractional number
3086
 * @param incr increment, can be positive or negative
3087
 */
3088
static void av_frac_add(AVFrac *f, int64_t incr)
3089
{
3090
    int64_t num, den;
3091

    
3092
    num = f->num + incr;
3093
    den = f->den;
3094
    if (num < 0) {
3095
        f->val += num / den;
3096
        num = num % den;
3097
        if (num < 0) {
3098
            num += den;
3099
            f->val--;
3100
        }
3101
    } else if (num >= den) {
3102
        f->val += num / den;
3103
        num = num % den;
3104
    }
3105
    f->num = num;
3106
}