Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ a85736f2

History | View | Annotate | Download (92.4 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 compute_pkt_fields(AVFormatContext *s, AVStream *st,
636
                               AVCodecParserContext *pc, AVPacket *pkt)
637
{
638
    int num, den, presentation_delayed, delay, i;
639
    int64_t offset;
640

    
641
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
642
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
643
        pkt->dts -= 1LL<<st->pts_wrap_bits;
644
    }
645

    
646
    if (pkt->duration == 0) {
647
        compute_frame_duration(&num, &den, st, pc, pkt);
648
        if (den && num) {
649
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
650
        }
651
    }
652

    
653
    /* correct timestamps with byte offset if demuxers only have timestamps
654
       on packet boundaries */
655
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
656
        /* this will estimate bitrate based on this frame's duration and size */
657
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
658
        if(pkt->pts != AV_NOPTS_VALUE)
659
            pkt->pts += offset;
660
        if(pkt->dts != AV_NOPTS_VALUE)
661
            pkt->dts += offset;
662
    }
663

    
664
    /* do we have a video B-frame ? */
665
    delay= st->codec->has_b_frames;
666
    presentation_delayed = 0;
667
    /* XXX: need has_b_frame, but cannot get it if the codec is
668
        not initialized */
669
    if (delay &&
670
        pc && pc->pict_type != FF_B_TYPE)
671
        presentation_delayed = 1;
672
    /* This may be redundant, but it should not hurt. */
673
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
674
        presentation_delayed = 1;
675

    
676
    if(st->cur_dts == AV_NOPTS_VALUE){
677
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
678
    }
679

    
680
//    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);
681
    /* interpolate PTS and DTS if they are not present */
682
    if(delay <=1){
683
        if (presentation_delayed) {
684
            /* DTS = decompression timestamp */
685
            /* PTS = presentation timestamp */
686
            if (pkt->dts == AV_NOPTS_VALUE)
687
                pkt->dts = st->last_IP_pts;
688
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
689
            if (pkt->dts == AV_NOPTS_VALUE)
690
                pkt->dts = st->cur_dts;
691

    
692
            /* this is tricky: the dts must be incremented by the duration
693
            of the frame we are displaying, i.e. the last I- or P-frame */
694
            if (st->last_IP_duration == 0)
695
                st->last_IP_duration = pkt->duration;
696
            st->cur_dts = pkt->dts + st->last_IP_duration;
697
            st->last_IP_duration  = pkt->duration;
698
            st->last_IP_pts= pkt->pts;
699
            /* cannot compute PTS if not present (we can compute it only
700
            by knowing the future */
701
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
702
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
703
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
704
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
705
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
706
                    pkt->pts += pkt->duration;
707
    //                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);
708
                }
709
            }
710

    
711
            /* presentation is not delayed : PTS and DTS are the same */
712
            if(pkt->pts == AV_NOPTS_VALUE)
713
                pkt->pts = pkt->dts;
714
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
715
            if(pkt->pts == AV_NOPTS_VALUE)
716
                pkt->pts = st->cur_dts;
717
            pkt->dts = pkt->pts;
718
            st->cur_dts = pkt->pts + pkt->duration;
719
        }
720
    }
721

    
722
    if(pkt->pts != AV_NOPTS_VALUE){
723
        st->pts_buffer[0]= pkt->pts;
724
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
725
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
726
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
727
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
728
        if(pkt->dts == AV_NOPTS_VALUE)
729
            pkt->dts= st->pts_buffer[0];
730
        if(delay>1){
731
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
732
        }
733
        if(pkt->dts > st->cur_dts)
734
            st->cur_dts = pkt->dts;
735
    }
736

    
737
//    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);
738

    
739
    /* update flags */
740
    if(is_intra_only(st->codec))
741
        pkt->flags |= PKT_FLAG_KEY;
742
    else if (pc) {
743
        pkt->flags = 0;
744
        /* keyframe computation */
745
            if (pc->pict_type == FF_I_TYPE)
746
                pkt->flags |= PKT_FLAG_KEY;
747
    }
748
}
749

    
750
void av_destruct_packet_nofree(AVPacket *pkt)
751
{
752
    pkt->data = NULL; pkt->size = 0;
753
}
754

    
755
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
756
{
757
    AVStream *st;
758
    int len, ret, i;
759

    
760
    av_init_packet(pkt);
761

    
762
    for(;;) {
763
        /* select current input stream component */
764
        st = s->cur_st;
765
        if (st) {
766
            if (!st->need_parsing || !st->parser) {
767
                /* no parsing needed: we just output the packet as is */
768
                /* raw data support */
769
                *pkt = s->cur_pkt;
770
                compute_pkt_fields(s, st, NULL, pkt);
771
                s->cur_st = NULL;
772
                break;
773
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
774
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
775
                                      s->cur_ptr, s->cur_len,
776
                                      s->cur_pkt.pts, s->cur_pkt.dts);
777
                s->cur_pkt.pts = AV_NOPTS_VALUE;
778
                s->cur_pkt.dts = AV_NOPTS_VALUE;
779
                /* increment read pointer */
780
                s->cur_ptr += len;
781
                s->cur_len -= len;
782

    
783
                /* return packet if any */
784
                if (pkt->size) {
785
                got_packet:
786
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
787
                    pkt->duration = 0;
788
                    pkt->stream_index = st->index;
789
                    pkt->pts = st->parser->pts;
790
                    pkt->dts = st->parser->dts;
791
                    pkt->destruct = av_destruct_packet_nofree;
792
                    compute_pkt_fields(s, st, st->parser, pkt);
793

    
794
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
795
                        ff_reduce_index(s, st->index);
796
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
797
                                           0, 0, AVINDEX_KEYFRAME);
798
                    }
799

    
800
                    break;
801
                }
802
            } else {
803
                /* free packet */
804
                av_free_packet(&s->cur_pkt);
805
                s->cur_st = NULL;
806
            }
807
        } else {
808
            /* read next packet */
809
            ret = av_read_packet(s, &s->cur_pkt);
810
            if (ret < 0) {
811
                if (ret == AVERROR(EAGAIN))
812
                    return ret;
813
                /* return the last frames, if any */
814
                for(i = 0; i < s->nb_streams; i++) {
815
                    st = s->streams[i];
816
                    if (st->parser && st->need_parsing) {
817
                        av_parser_parse(st->parser, st->codec,
818
                                        &pkt->data, &pkt->size,
819
                                        NULL, 0,
820
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
821
                        if (pkt->size)
822
                            goto got_packet;
823
                    }
824
                }
825
                /* no more packets: really terminate parsing */
826
                return ret;
827
            }
828

    
829
            st = s->streams[s->cur_pkt.stream_index];
830
            if(st->codec->debug & FF_DEBUG_PTS)
831
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
832
                    s->cur_pkt.stream_index,
833
                    s->cur_pkt.pts,
834
                    s->cur_pkt.dts,
835
                    s->cur_pkt.size);
836

    
837
            s->cur_st = st;
838
            s->cur_ptr = s->cur_pkt.data;
839
            s->cur_len = s->cur_pkt.size;
840
            if (st->need_parsing && !st->parser) {
841
                st->parser = av_parser_init(st->codec->codec_id);
842
                if (!st->parser) {
843
                    /* no parser available: just output the raw packets */
844
                    st->need_parsing = AVSTREAM_PARSE_NONE;
845
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
846
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
847
                }
848
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
849
                    st->parser->last_frame_offset=
850
                    st->parser->cur_offset= s->cur_pkt.pos;
851
                }
852
            }
853
        }
854
    }
855
    if(st->codec->debug & FF_DEBUG_PTS)
856
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
857
            pkt->stream_index,
858
            pkt->pts,
859
            pkt->dts,
860
            pkt->size);
861

    
862
    return 0;
863
}
864

    
865
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
866
    AVPacketList *pktl= s->packet_buffer;
867
    AVPacketList **plast_pktl= &s->packet_buffer;
868

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

    
871
    pktl = av_mallocz(sizeof(AVPacketList));
872
    if (!pktl)
873
        return NULL;
874

    
875
    /* add the packet in the buffered packet list */
876
    *plast_pktl = pktl;
877
    pktl->pkt= *pkt;
878
    return &pktl->pkt;
879
}
880

    
881
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
882
{
883
    AVPacketList *pktl;
884
    int eof=0;
885
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
886

    
887
    for(;;){
888
        pktl = s->packet_buffer;
889
        if (pktl) {
890
            AVPacket *next_pkt= &pktl->pkt;
891

    
892
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
893
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
894
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
895
                       && next_pkt->dts < pktl->pkt.dts
896
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
897
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
898
                        next_pkt->pts= pktl->pkt.dts;
899
                    }
900
                    pktl= pktl->next;
901
                }
902
                pktl = s->packet_buffer;
903
            }
904

    
905
            if(   next_pkt->pts != AV_NOPTS_VALUE
906
               || next_pkt->dts == AV_NOPTS_VALUE
907
               || !genpts || eof){
908
                /* read packet from packet buffer, if there is data */
909
                *pkt = *next_pkt;
910
                s->packet_buffer = pktl->next;
911
                av_free(pktl);
912
                return 0;
913
            }
914
        }
915
        if(genpts){
916
            int ret= av_read_frame_internal(s, pkt);
917
            if(ret<0){
918
                if(pktl && ret != AVERROR(EAGAIN)){
919
                    eof=1;
920
                    continue;
921
                }else
922
                    return ret;
923
            }
924

    
925
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
926
                return AVERROR(ENOMEM);
927
        }else{
928
            assert(!s->packet_buffer);
929
            return av_read_frame_internal(s, pkt);
930
        }
931
    }
932
}
933

    
934
/* XXX: suppress the packet queue */
935
static void flush_packet_queue(AVFormatContext *s)
936
{
937
    AVPacketList *pktl;
938

    
939
    for(;;) {
940
        pktl = s->packet_buffer;
941
        if (!pktl)
942
            break;
943
        s->packet_buffer = pktl->next;
944
        av_free_packet(&pktl->pkt);
945
        av_free(pktl);
946
    }
947
}
948

    
949
/*******************************************************/
950
/* seek support */
951

    
952
int av_find_default_stream_index(AVFormatContext *s)
953
{
954
    int i;
955
    AVStream *st;
956

    
957
    if (s->nb_streams <= 0)
958
        return -1;
959
    for(i = 0; i < s->nb_streams; i++) {
960
        st = s->streams[i];
961
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
962
            return i;
963
        }
964
    }
965
    return 0;
966
}
967

    
968
/**
969
 * Flush the frame reader.
970
 */
971
static void av_read_frame_flush(AVFormatContext *s)
972
{
973
    AVStream *st;
974
    int i;
975

    
976
    flush_packet_queue(s);
977

    
978
    /* free previous packet */
979
    if (s->cur_st) {
980
        if (s->cur_st->parser)
981
            av_free_packet(&s->cur_pkt);
982
        s->cur_st = NULL;
983
    }
984
    /* fail safe */
985
    s->cur_ptr = NULL;
986
    s->cur_len = 0;
987

    
988
    /* for each stream, reset read state */
989
    for(i = 0; i < s->nb_streams; i++) {
990
        st = s->streams[i];
991

    
992
        if (st->parser) {
993
            av_parser_close(st->parser);
994
            st->parser = NULL;
995
        }
996
        st->last_IP_pts = AV_NOPTS_VALUE;
997
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
998
    }
999
}
1000

    
1001
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1002
    int i;
1003

    
1004
    for(i = 0; i < s->nb_streams; i++) {
1005
        AVStream *st = s->streams[i];
1006

    
1007
        st->cur_dts = av_rescale(timestamp,
1008
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1009
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1010
    }
1011
}
1012

    
1013
void ff_reduce_index(AVFormatContext *s, int stream_index)
1014
{
1015
    AVStream *st= s->streams[stream_index];
1016
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1017

    
1018
    if((unsigned)st->nb_index_entries >= max_entries){
1019
        int i;
1020
        for(i=0; 2*i<st->nb_index_entries; i++)
1021
            st->index_entries[i]= st->index_entries[2*i];
1022
        st->nb_index_entries= i;
1023
    }
1024
}
1025

    
1026
int av_add_index_entry(AVStream *st,
1027
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1028
{
1029
    AVIndexEntry *entries, *ie;
1030
    int index;
1031

    
1032
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1033
        return -1;
1034

    
1035
    entries = av_fast_realloc(st->index_entries,
1036
                              &st->index_entries_allocated_size,
1037
                              (st->nb_index_entries + 1) *
1038
                              sizeof(AVIndexEntry));
1039
    if(!entries)
1040
        return -1;
1041

    
1042
    st->index_entries= entries;
1043

    
1044
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1045

    
1046
    if(index<0){
1047
        index= st->nb_index_entries++;
1048
        ie= &entries[index];
1049
        assert(index==0 || ie[-1].timestamp < timestamp);
1050
    }else{
1051
        ie= &entries[index];
1052
        if(ie->timestamp != timestamp){
1053
            if(ie->timestamp <= timestamp)
1054
                return -1;
1055
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1056
            st->nb_index_entries++;
1057
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1058
            distance= ie->min_distance;
1059
    }
1060

    
1061
    ie->pos = pos;
1062
    ie->timestamp = timestamp;
1063
    ie->min_distance= distance;
1064
    ie->size= size;
1065
    ie->flags = flags;
1066

    
1067
    return index;
1068
}
1069

    
1070
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1071
                              int flags)
1072
{
1073
    AVIndexEntry *entries= st->index_entries;
1074
    int nb_entries= st->nb_index_entries;
1075
    int a, b, m;
1076
    int64_t timestamp;
1077

    
1078
    a = - 1;
1079
    b = nb_entries;
1080

    
1081
    while (b - a > 1) {
1082
        m = (a + b) >> 1;
1083
        timestamp = entries[m].timestamp;
1084
        if(timestamp >= wanted_timestamp)
1085
            b = m;
1086
        if(timestamp <= wanted_timestamp)
1087
            a = m;
1088
    }
1089
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1090

    
1091
    if(!(flags & AVSEEK_FLAG_ANY)){
1092
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1093
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1094
        }
1095
    }
1096

    
1097
    if(m == nb_entries)
1098
        return -1;
1099
    return  m;
1100
}
1101

    
1102
#define DEBUG_SEEK
1103

    
1104
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1105
    AVInputFormat *avif= s->iformat;
1106
    int64_t pos_min, pos_max, pos, pos_limit;
1107
    int64_t ts_min, ts_max, ts;
1108
    int index;
1109
    AVStream *st;
1110

    
1111
    if (stream_index < 0)
1112
        return -1;
1113

    
1114
#ifdef DEBUG_SEEK
1115
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1116
#endif
1117

    
1118
    ts_max=
1119
    ts_min= AV_NOPTS_VALUE;
1120
    pos_limit= -1; //gcc falsely says it may be uninitialized
1121

    
1122
    st= s->streams[stream_index];
1123
    if(st->index_entries){
1124
        AVIndexEntry *e;
1125

    
1126
        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()
1127
        index= FFMAX(index, 0);
1128
        e= &st->index_entries[index];
1129

    
1130
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1131
            pos_min= e->pos;
1132
            ts_min= e->timestamp;
1133
#ifdef DEBUG_SEEK
1134
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1135
               pos_min,ts_min);
1136
#endif
1137
        }else{
1138
            assert(index==0);
1139
        }
1140

    
1141
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1142
        assert(index < st->nb_index_entries);
1143
        if(index >= 0){
1144
            e= &st->index_entries[index];
1145
            assert(e->timestamp >= target_ts);
1146
            pos_max= e->pos;
1147
            ts_max= e->timestamp;
1148
            pos_limit= pos_max - e->min_distance;
1149
#ifdef DEBUG_SEEK
1150
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1151
               pos_max,pos_limit, ts_max);
1152
#endif
1153
        }
1154
    }
1155

    
1156
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1157
    if(pos<0)
1158
        return -1;
1159

    
1160
    /* do the seek */
1161
    url_fseek(s->pb, pos, SEEK_SET);
1162

    
1163
    av_update_cur_dts(s, st, ts);
1164

    
1165
    return 0;
1166
}
1167

    
1168
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 )){
1169
    int64_t pos, ts;
1170
    int64_t start_pos, filesize;
1171
    int no_change;
1172

    
1173
#ifdef DEBUG_SEEK
1174
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1175
#endif
1176

    
1177
    if(ts_min == AV_NOPTS_VALUE){
1178
        pos_min = s->data_offset;
1179
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1180
        if (ts_min == AV_NOPTS_VALUE)
1181
            return -1;
1182
    }
1183

    
1184
    if(ts_max == AV_NOPTS_VALUE){
1185
        int step= 1024;
1186
        filesize = url_fsize(s->pb);
1187
        pos_max = filesize - 1;
1188
        do{
1189
            pos_max -= step;
1190
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1191
            step += step;
1192
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1193
        if (ts_max == AV_NOPTS_VALUE)
1194
            return -1;
1195

    
1196
        for(;;){
1197
            int64_t tmp_pos= pos_max + 1;
1198
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1199
            if(tmp_ts == AV_NOPTS_VALUE)
1200
                break;
1201
            ts_max= tmp_ts;
1202
            pos_max= tmp_pos;
1203
            if(tmp_pos >= filesize)
1204
                break;
1205
        }
1206
        pos_limit= pos_max;
1207
    }
1208

    
1209
    if(ts_min > ts_max){
1210
        return -1;
1211
    }else if(ts_min == ts_max){
1212
        pos_limit= pos_min;
1213
    }
1214

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

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

    
1243
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1244
        if(pos == pos_max)
1245
            no_change++;
1246
        else
1247
            no_change=0;
1248
#ifdef DEBUG_SEEK
1249
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);
1250
#endif
1251
        if(ts == AV_NOPTS_VALUE){
1252
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1253
            return -1;
1254
        }
1255
        assert(ts != AV_NOPTS_VALUE);
1256
        if (target_ts <= ts) {
1257
            pos_limit = start_pos - 1;
1258
            pos_max = pos;
1259
            ts_max = ts;
1260
        }
1261
        if (target_ts >= ts) {
1262
            pos_min = pos;
1263
            ts_min = ts;
1264
        }
1265
    }
1266

    
1267
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1268
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1269
#ifdef DEBUG_SEEK
1270
    pos_min = pos;
1271
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1272
    pos_min++;
1273
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1274
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1275
           pos, ts_min, target_ts, ts_max);
1276
#endif
1277
    *ts_ret= ts;
1278
    return pos;
1279
}
1280

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

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

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

    
1292
    pos_min = s->data_offset;
1293
    pos_max = url_fsize(s->pb) - 1;
1294

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

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

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

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

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

    
1315
    index = av_index_search_timestamp(st, timestamp, flags);
1316

    
1317
    if(index < 0 || index==st->nb_index_entries-1){
1318
        int i;
1319
        AVPacket pkt;
1320

    
1321
        if(st->index_entries && st->nb_index_entries){
1322
            ie= &st->index_entries[st->nb_index_entries-1];
1323
            url_fseek(s->pb, ie->pos, SEEK_SET);
1324
            av_update_cur_dts(s, st, ie->timestamp);
1325
        }else
1326
            url_fseek(s->pb, 0, SEEK_SET);
1327

    
1328
        for(i=0;; i++) {
1329
            int ret = av_read_frame(s, &pkt);
1330
            if(ret<0)
1331
                break;
1332
            av_free_packet(&pkt);
1333
            if(stream_index == pkt.stream_index){
1334
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1335
                    break;
1336
            }
1337
        }
1338
        index = av_index_search_timestamp(st, timestamp, flags);
1339
    }
1340
    if (index < 0)
1341
        return -1;
1342

    
1343
    av_read_frame_flush(s);
1344
    if (s->iformat->read_seek){
1345
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1346
            return 0;
1347
    }
1348
    ie = &st->index_entries[index];
1349
    url_fseek(s->pb, ie->pos, SEEK_SET);
1350

    
1351
    av_update_cur_dts(s, st, ie->timestamp);
1352

    
1353
    return 0;
1354
}
1355

    
1356
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1357
{
1358
    int ret;
1359
    AVStream *st;
1360

    
1361
    av_read_frame_flush(s);
1362

    
1363
    if(flags & AVSEEK_FLAG_BYTE)
1364
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1365

    
1366
    if(stream_index < 0){
1367
        stream_index= av_find_default_stream_index(s);
1368
        if(stream_index < 0)
1369
            return -1;
1370

    
1371
        st= s->streams[stream_index];
1372
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1373
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1374
    }
1375
    st= s->streams[stream_index];
1376

    
1377
    /* first, we try the format specific seek */
1378
    if (s->iformat->read_seek)
1379
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1380
    else
1381
        ret = -1;
1382
    if (ret >= 0) {
1383
        return 0;
1384
    }
1385

    
1386
    if(s->iformat->read_timestamp)
1387
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1388
    else
1389
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1390
}
1391

    
1392
/*******************************************************/
1393

    
1394
/**
1395
 * Returns TRUE if the stream has accurate duration in any stream.
1396
 *
1397
 * @return TRUE if the stream has accurate duration for at least one component.
1398
 */
1399
static int av_has_duration(AVFormatContext *ic)
1400
{
1401
    int i;
1402
    AVStream *st;
1403

    
1404
    for(i = 0;i < ic->nb_streams; i++) {
1405
        st = ic->streams[i];
1406
        if (st->duration != AV_NOPTS_VALUE)
1407
            return 1;
1408
    }
1409
    return 0;
1410
}
1411

    
1412
/**
1413
 * Estimate the stream timings from the one of each components.
1414
 *
1415
 * Also computes the global bitrate if possible.
1416
 */
1417
static void av_update_stream_timings(AVFormatContext *ic)
1418
{
1419
    int64_t start_time, start_time1, end_time, end_time1;
1420
    int64_t duration, duration1;
1421
    int i;
1422
    AVStream *st;
1423

    
1424
    start_time = INT64_MAX;
1425
    end_time = INT64_MIN;
1426
    duration = INT64_MIN;
1427
    for(i = 0;i < ic->nb_streams; i++) {
1428
        st = ic->streams[i];
1429
        if (st->start_time != AV_NOPTS_VALUE) {
1430
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1431
            if (start_time1 < start_time)
1432
                start_time = start_time1;
1433
            if (st->duration != AV_NOPTS_VALUE) {
1434
                end_time1 = start_time1
1435
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1436
                if (end_time1 > end_time)
1437
                    end_time = end_time1;
1438
            }
1439
        }
1440
        if (st->duration != AV_NOPTS_VALUE) {
1441
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1442
            if (duration1 > duration)
1443
                duration = duration1;
1444
        }
1445
    }
1446
    if (start_time != INT64_MAX) {
1447
        ic->start_time = start_time;
1448
        if (end_time != INT64_MIN) {
1449
            if (end_time - start_time > duration)
1450
                duration = end_time - start_time;
1451
        }
1452
    }
1453
    if (duration != INT64_MIN) {
1454
        ic->duration = duration;
1455
        if (ic->file_size > 0) {
1456
            /* compute the bitrate */
1457
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1458
                (double)ic->duration;
1459
        }
1460
    }
1461
}
1462

    
1463
static void fill_all_stream_timings(AVFormatContext *ic)
1464
{
1465
    int i;
1466
    AVStream *st;
1467

    
1468
    av_update_stream_timings(ic);
1469
    for(i = 0;i < ic->nb_streams; i++) {
1470
        st = ic->streams[i];
1471
        if (st->start_time == AV_NOPTS_VALUE) {
1472
            if(ic->start_time != AV_NOPTS_VALUE)
1473
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1474
            if(ic->duration != AV_NOPTS_VALUE)
1475
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1476
        }
1477
    }
1478
}
1479

    
1480
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1481
{
1482
    int64_t filesize, duration;
1483
    int bit_rate, i;
1484
    AVStream *st;
1485

    
1486
    /* if bit_rate is already set, we believe it */
1487
    if (ic->bit_rate == 0) {
1488
        bit_rate = 0;
1489
        for(i=0;i<ic->nb_streams;i++) {
1490
            st = ic->streams[i];
1491
            bit_rate += st->codec->bit_rate;
1492
        }
1493
        ic->bit_rate = bit_rate;
1494
    }
1495

    
1496
    /* if duration is already set, we believe it */
1497
    if (ic->duration == AV_NOPTS_VALUE &&
1498
        ic->bit_rate != 0 &&
1499
        ic->file_size != 0)  {
1500
        filesize = ic->file_size;
1501
        if (filesize > 0) {
1502
            for(i = 0; i < ic->nb_streams; i++) {
1503
                st = ic->streams[i];
1504
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1505
                if (st->duration == AV_NOPTS_VALUE)
1506
                    st->duration = duration;
1507
            }
1508
        }
1509
    }
1510
}
1511

    
1512
#define DURATION_MAX_READ_SIZE 250000
1513

    
1514
/* only usable for MPEG-PS streams */
1515
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1516
{
1517
    AVPacket pkt1, *pkt = &pkt1;
1518
    AVStream *st;
1519
    int read_size, i, ret;
1520
    int64_t end_time;
1521
    int64_t filesize, offset, duration;
1522

    
1523
    /* free previous packet */
1524
    if (ic->cur_st && ic->cur_st->parser)
1525
        av_free_packet(&ic->cur_pkt);
1526
    ic->cur_st = NULL;
1527

    
1528
    /* flush packet queue */
1529
    flush_packet_queue(ic);
1530

    
1531
    for(i=0;i<ic->nb_streams;i++) {
1532
        st = ic->streams[i];
1533
        if (st->parser) {
1534
            av_parser_close(st->parser);
1535
            st->parser= NULL;
1536
        }
1537
    }
1538

    
1539
    /* we read the first packets to get the first PTS (not fully
1540
       accurate, but it is enough now) */
1541
    url_fseek(ic->pb, 0, SEEK_SET);
1542
    read_size = 0;
1543
    for(;;) {
1544
        if (read_size >= DURATION_MAX_READ_SIZE)
1545
            break;
1546
        /* if all info is available, we can stop */
1547
        for(i = 0;i < ic->nb_streams; i++) {
1548
            st = ic->streams[i];
1549
            if (st->start_time == AV_NOPTS_VALUE)
1550
                break;
1551
        }
1552
        if (i == ic->nb_streams)
1553
            break;
1554

    
1555
        ret = av_read_packet(ic, pkt);
1556
        if (ret != 0)
1557
            break;
1558
        read_size += pkt->size;
1559
        st = ic->streams[pkt->stream_index];
1560
        if (pkt->pts != AV_NOPTS_VALUE) {
1561
            if (st->start_time == AV_NOPTS_VALUE)
1562
                st->start_time = pkt->pts;
1563
        }
1564
        av_free_packet(pkt);
1565
    }
1566

    
1567
    /* estimate the end time (duration) */
1568
    /* XXX: may need to support wrapping */
1569
    filesize = ic->file_size;
1570
    offset = filesize - DURATION_MAX_READ_SIZE;
1571
    if (offset < 0)
1572
        offset = 0;
1573

    
1574
    url_fseek(ic->pb, offset, SEEK_SET);
1575
    read_size = 0;
1576
    for(;;) {
1577
        if (read_size >= DURATION_MAX_READ_SIZE)
1578
            break;
1579

    
1580
        ret = av_read_packet(ic, pkt);
1581
        if (ret != 0)
1582
            break;
1583
        read_size += pkt->size;
1584
        st = ic->streams[pkt->stream_index];
1585
        if (pkt->pts != AV_NOPTS_VALUE &&
1586
            st->start_time != AV_NOPTS_VALUE) {
1587
            end_time = pkt->pts;
1588
            duration = end_time - st->start_time;
1589
            if (duration > 0) {
1590
                if (st->duration == AV_NOPTS_VALUE ||
1591
                    st->duration < duration)
1592
                    st->duration = duration;
1593
            }
1594
        }
1595
        av_free_packet(pkt);
1596
    }
1597

    
1598
    fill_all_stream_timings(ic);
1599

    
1600
    url_fseek(ic->pb, old_offset, SEEK_SET);
1601
    for(i=0; i<ic->nb_streams; i++){
1602
        st= ic->streams[i];
1603
        st->cur_dts= st->first_dts;
1604
        st->last_IP_pts = AV_NOPTS_VALUE;
1605
    }
1606
}
1607

    
1608
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1609
{
1610
    int64_t file_size;
1611

    
1612
    /* get the file size, if possible */
1613
    if (ic->iformat->flags & AVFMT_NOFILE) {
1614
        file_size = 0;
1615
    } else {
1616
        file_size = url_fsize(ic->pb);
1617
        if (file_size < 0)
1618
            file_size = 0;
1619
    }
1620
    ic->file_size = file_size;
1621

    
1622
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1623
         !strcmp(ic->iformat->name, "mpegts")) &&
1624
        file_size && !url_is_streamed(ic->pb)) {
1625
        /* get accurate estimate from the PTSes */
1626
        av_estimate_timings_from_pts(ic, old_offset);
1627
    } else if (av_has_duration(ic)) {
1628
        /* at least one component has timings - we use them for all
1629
           the components */
1630
        fill_all_stream_timings(ic);
1631
    } else {
1632
        /* less precise: use bitrate info */
1633
        av_estimate_timings_from_bit_rate(ic);
1634
    }
1635
    av_update_stream_timings(ic);
1636

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

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

    
1672
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1673
{
1674
    int16_t *samples;
1675
    AVCodec *codec;
1676
    int got_picture, data_size, ret=0;
1677
    AVFrame picture;
1678

    
1679
  if(!st->codec->codec){
1680
    codec = avcodec_find_decoder(st->codec->codec_id);
1681
    if (!codec)
1682
        return -1;
1683
    ret = avcodec_open(st->codec, codec);
1684
    if (ret < 0)
1685
        return ret;
1686
  }
1687

    
1688
  if(!has_codec_parameters(st->codec)){
1689
    switch(st->codec->codec_type) {
1690
    case CODEC_TYPE_VIDEO:
1691
        ret = avcodec_decode_video(st->codec, &picture,
1692
                                   &got_picture, (uint8_t *)data, size);
1693
        break;
1694
    case CODEC_TYPE_AUDIO:
1695
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1696
        samples = av_malloc(data_size);
1697
        if (!samples)
1698
            goto fail;
1699
        ret = avcodec_decode_audio2(st->codec, samples,
1700
                                    &data_size, (uint8_t *)data, size);
1701
        av_free(samples);
1702
        break;
1703
    default:
1704
        break;
1705
    }
1706
  }
1707
 fail:
1708
    return ret;
1709
}
1710

    
1711
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1712
{
1713
    AVInputFormat *fmt;
1714
    fmt = av_probe_input_format2(pd, 1, &score);
1715

    
1716
    if (fmt) {
1717
        if (strncmp(fmt->name, "mp3", 3) == 0)
1718
            st->codec->codec_id = CODEC_ID_MP3;
1719
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1720
            st->codec->codec_id = CODEC_ID_AC3;
1721
    }
1722
    return !!fmt;
1723
}
1724

    
1725
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1726
{
1727
    while (tags->id != CODEC_ID_NONE) {
1728
        if (tags->id == id)
1729
            return tags->tag;
1730
        tags++;
1731
    }
1732
    return 0;
1733
}
1734

    
1735
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1736
{
1737
    int i;
1738
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1739
        if(tag == tags[i].tag)
1740
            return tags[i].id;
1741
    }
1742
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1743
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1744
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1745
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1746
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1747
            return tags[i].id;
1748
    }
1749
    return CODEC_ID_NONE;
1750
}
1751

    
1752
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1753
{
1754
    int i;
1755
    for(i=0; tags && tags[i]; i++){
1756
        int tag= codec_get_tag(tags[i], id);
1757
        if(tag) return tag;
1758
    }
1759
    return 0;
1760
}
1761

    
1762
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1763
{
1764
    int i;
1765
    for(i=0; tags && tags[i]; i++){
1766
        enum CodecID id= codec_get_id(tags[i], tag);
1767
        if(id!=CODEC_ID_NONE) return id;
1768
    }
1769
    return CODEC_ID_NONE;
1770
}
1771

    
1772
/* absolute maximum size we read until we abort */
1773
#define MAX_READ_SIZE        5000000
1774

    
1775
#define MAX_STD_TIMEBASES (60*12+5)
1776
static int get_std_framerate(int i){
1777
    if(i<60*12) return i*1001;
1778
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1779
}
1780

    
1781
/*
1782
 * Is the time base unreliable.
1783
 * This is a heuristic to balance between quick acceptance of the values in
1784
 * the headers vs. some extra checks.
1785
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1786
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1787
 * And there are "variable" fps files this needs to detect as well.
1788
 */
1789
static int tb_unreliable(AVCodecContext *c){
1790
    if(   c->time_base.den >= 101L*c->time_base.num
1791
       || c->time_base.den <    5L*c->time_base.num
1792
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1793
       || c->codec_tag == ff_get_fourcc("XVID")*/
1794
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1795
        return 1;
1796
    return 0;
1797
}
1798

    
1799
int av_find_stream_info(AVFormatContext *ic)
1800
{
1801
    int i, count, ret, read_size, j;
1802
    AVStream *st;
1803
    AVPacket pkt1, *pkt;
1804
    int64_t last_dts[MAX_STREAMS];
1805
    int duration_count[MAX_STREAMS]={0};
1806
    double (*duration_error)[MAX_STD_TIMEBASES];
1807
    offset_t old_offset = url_ftell(ic->pb);
1808
    int64_t codec_info_duration[MAX_STREAMS]={0};
1809
    int codec_info_nb_frames[MAX_STREAMS]={0};
1810
    AVProbeData probe_data[MAX_STREAMS];
1811
    int codec_identified[MAX_STREAMS]={0};
1812

    
1813
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1814
    if (!duration_error) return AVERROR(ENOMEM);
1815

    
1816
    for(i=0;i<ic->nb_streams;i++) {
1817
        st = ic->streams[i];
1818
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1819
/*            if(!st->time_base.num)
1820
                st->time_base= */
1821
            if(!st->codec->time_base.num)
1822
                st->codec->time_base= st->time_base;
1823
        }
1824
        //only for the split stuff
1825
        if (!st->parser) {
1826
            st->parser = av_parser_init(st->codec->codec_id);
1827
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1828
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1829
            }
1830
        }
1831
    }
1832

    
1833
    for(i=0;i<MAX_STREAMS;i++){
1834
        last_dts[i]= AV_NOPTS_VALUE;
1835
    }
1836

    
1837
    memset(probe_data, 0, sizeof(probe_data));
1838
    count = 0;
1839
    read_size = 0;
1840
    for(;;) {
1841
        /* check if one codec still needs to be handled */
1842
        for(i=0;i<ic->nb_streams;i++) {
1843
            st = ic->streams[i];
1844
            if (!has_codec_parameters(st->codec))
1845
                break;
1846
            /* variable fps and no guess at the real fps */
1847
            if(   tb_unreliable(st->codec)
1848
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1849
                break;
1850
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1851
                break;
1852
            if(st->first_dts == AV_NOPTS_VALUE)
1853
                break;
1854
        }
1855
        if (i == ic->nb_streams) {
1856
            /* NOTE: if the format has no header, then we need to read
1857
               some packets to get most of the streams, so we cannot
1858
               stop here */
1859
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1860
                /* if we found the info for all the codecs, we can stop */
1861
                ret = count;
1862
                break;
1863
            }
1864
        }
1865
        /* we did not get all the codec info, but we read too much data */
1866
        if (read_size >= MAX_READ_SIZE) {
1867
            ret = count;
1868
            break;
1869
        }
1870

    
1871
        /* NOTE: a new stream can be added there if no header in file
1872
           (AVFMTCTX_NOHEADER) */
1873
        ret = av_read_frame_internal(ic, &pkt1);
1874
        if (ret < 0) {
1875
            /* EOF or error */
1876
            ret = -1; /* we could not have all the codec parameters before EOF */
1877
            for(i=0;i<ic->nb_streams;i++) {
1878
                st = ic->streams[i];
1879
                if (!has_codec_parameters(st->codec)){
1880
                    char buf[256];
1881
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1882
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1883
                } else {
1884
                    ret = 0;
1885
                }
1886
            }
1887
            break;
1888
        }
1889

    
1890
        pkt= add_to_pktbuf(ic, &pkt1);
1891
        if(av_dup_packet(pkt) < 0)
1892
            return AVERROR(ENOMEM);
1893

    
1894
        read_size += pkt->size;
1895

    
1896
        st = ic->streams[pkt->stream_index];
1897
        if(codec_info_nb_frames[st->index]>1)
1898
            codec_info_duration[st->index] += pkt->duration;
1899
        if (pkt->duration != 0)
1900
            codec_info_nb_frames[st->index]++;
1901

    
1902
        {
1903
            int index= pkt->stream_index;
1904
            int64_t last= last_dts[index];
1905
            int64_t duration= pkt->dts - last;
1906

    
1907
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1908
                double dur= duration * av_q2d(st->time_base);
1909

    
1910
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1911
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1912
                if(duration_count[index] < 2)
1913
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1914
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1915
                    int framerate= get_std_framerate(i);
1916
                    int ticks= lrintf(dur*framerate/(1001*12));
1917
                    double error= dur - ticks*1001*12/(double)framerate;
1918
                    duration_error[index][i] += error*error;
1919
                }
1920
                duration_count[index]++;
1921
            }
1922
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1923
                last_dts[pkt->stream_index]= pkt->dts;
1924

    
1925
            if (st->codec->codec_id == CODEC_ID_NONE) {
1926
                AVProbeData *pd = &(probe_data[st->index]);
1927
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1928
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1929
                pd->buf_size += pkt->size;
1930
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1931
            }
1932
        }
1933
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1934
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1935
            if(i){
1936
                st->codec->extradata_size= i;
1937
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1938
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1939
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1940
            }
1941
        }
1942

    
1943
        /* if still no information, we try to open the codec and to
1944
           decompress the frame. We try to avoid that in most cases as
1945
           it takes longer and uses more memory. For MPEG-4, we need to
1946
           decompress for QuickTime. */
1947
        if (!has_codec_parameters(st->codec) /*&&
1948
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1949
             st->codec->codec_id == CODEC_ID_H264 ||
1950
             st->codec->codec_id == CODEC_ID_H263 ||
1951
             st->codec->codec_id == CODEC_ID_H261 ||
1952
             st->codec->codec_id == CODEC_ID_VORBIS ||
1953
             st->codec->codec_id == CODEC_ID_MJPEG ||
1954
             st->codec->codec_id == CODEC_ID_PNG ||
1955
             st->codec->codec_id == CODEC_ID_PAM ||
1956
             st->codec->codec_id == CODEC_ID_PGM ||
1957
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1958
             st->codec->codec_id == CODEC_ID_PBM ||
1959
             st->codec->codec_id == CODEC_ID_PPM ||
1960
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1961
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1962
            try_decode_frame(st, pkt->data, pkt->size);
1963

    
1964
        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) {
1965
            break;
1966
        }
1967
        count++;
1968
    }
1969

    
1970
    // close codecs which where opened in try_decode_frame()
1971
    for(i=0;i<ic->nb_streams;i++) {
1972
        st = ic->streams[i];
1973
        if(st->codec->codec)
1974
            avcodec_close(st->codec);
1975
    }
1976
    for(i=0;i<ic->nb_streams;i++) {
1977
        st = ic->streams[i];
1978
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1979
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1980
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1981

    
1982
            if(duration_count[i]
1983
               && tb_unreliable(st->codec) /*&&
1984
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
1985
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1986
                double best_error= 2*av_q2d(st->time_base);
1987
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1988

    
1989
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1990
                    double error= duration_error[i][j] * get_std_framerate(j);
1991
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1992
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1993
                    if(error < best_error){
1994
                        best_error= error;
1995
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1996
                    }
1997
                }
1998
            }
1999

    
2000
            if (!st->r_frame_rate.num){
2001
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2002
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2003
                    st->r_frame_rate.num = st->codec->time_base.den;
2004
                    st->r_frame_rate.den = st->codec->time_base.num;
2005
                }else{
2006
                    st->r_frame_rate.num = st->time_base.den;
2007
                    st->r_frame_rate.den = st->time_base.num;
2008
                }
2009
            }
2010
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2011
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2012
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2013
                if (codec_identified[st->index]) {
2014
                    st->need_parsing = AVSTREAM_PARSE_FULL;
2015
                }
2016
            }
2017
            if(!st->codec->bits_per_sample)
2018
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2019
        }
2020
    }
2021

    
2022
    av_estimate_timings(ic, old_offset);
2023

    
2024
    for(i=0;i<ic->nb_streams;i++) {
2025
        st = ic->streams[i];
2026
        if (codec_identified[st->index])
2027
            break;
2028
    }
2029
    //FIXME this is a mess
2030
    if(i!=ic->nb_streams){
2031
        av_read_frame_flush(ic);
2032
        for(i=0;i<ic->nb_streams;i++) {
2033
            st = ic->streams[i];
2034
            if (codec_identified[st->index]) {
2035
                av_seek_frame(ic, st->index, 0.0, 0);
2036
            }
2037
            st->cur_dts= st->first_dts;
2038
        }
2039
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2040
    }
2041

    
2042
#if 0
2043
    /* correct DTS for B-frame streams with no timestamps */
2044
    for(i=0;i<ic->nb_streams;i++) {
2045
        st = ic->streams[i];
2046
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2047
            if(b-frames){
2048
                ppktl = &ic->packet_buffer;
2049
                while(ppkt1){
2050
                    if(ppkt1->stream_index != i)
2051
                        continue;
2052
                    if(ppkt1->pkt->dts < 0)
2053
                        break;
2054
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2055
                        break;
2056
                    ppkt1->pkt->dts -= delta;
2057
                    ppkt1= ppkt1->next;
2058
                }
2059
                if(ppkt1)
2060
                    continue;
2061
                st->cur_dts -= delta;
2062
            }
2063
        }
2064
    }
2065
#endif
2066

    
2067
    av_free(duration_error);
2068
    for(i=0;i<MAX_STREAMS;i++){
2069
        av_freep(&(probe_data[i].buf));
2070
    }
2071

    
2072
    return ret;
2073
}
2074

    
2075
/*******************************************************/
2076

    
2077
int av_read_play(AVFormatContext *s)
2078
{
2079
    if (s->iformat->read_play)
2080
        return s->iformat->read_play(s);
2081
    if (s->pb)
2082
        return av_url_read_fpause(s->pb, 0);
2083
    return AVERROR(ENOSYS);
2084
}
2085

    
2086
int av_read_pause(AVFormatContext *s)
2087
{
2088
    if (s->iformat->read_pause)
2089
        return s->iformat->read_pause(s);
2090
    if (s->pb)
2091
        return av_url_read_fpause(s->pb, 1);
2092
    return AVERROR(ENOSYS);
2093
}
2094

    
2095
void av_close_input_stream(AVFormatContext *s)
2096
{
2097
    int i;
2098
    AVStream *st;
2099

    
2100
    /* free previous packet */
2101
    if (s->cur_st && s->cur_st->parser)
2102
        av_free_packet(&s->cur_pkt);
2103

    
2104
    if (s->iformat->read_close)
2105
        s->iformat->read_close(s);
2106
    for(i=0;i<s->nb_streams;i++) {
2107
        /* free all data in a stream component */
2108
        st = s->streams[i];
2109
        if (st->parser) {
2110
            av_parser_close(st->parser);
2111
        }
2112
        av_free(st->index_entries);
2113
        av_free(st->codec->extradata);
2114
        av_free(st->codec);
2115
        av_free(st);
2116
    }
2117
    for(i=s->nb_programs-1; i>=0; i--) {
2118
        av_freep(&s->programs[i]->provider_name);
2119
        av_freep(&s->programs[i]->name);
2120
        av_freep(&s->programs[i]->stream_index);
2121
        av_freep(&s->programs[i]);
2122
    }
2123
    flush_packet_queue(s);
2124
    av_freep(&s->priv_data);
2125
    av_free(s);
2126
}
2127

    
2128
void av_close_input_file(AVFormatContext *s)
2129
{
2130
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2131
    av_close_input_stream(s);
2132
    if (pb)
2133
        url_fclose(pb);
2134
}
2135

    
2136
AVStream *av_new_stream(AVFormatContext *s, int id)
2137
{
2138
    AVStream *st;
2139
    int i;
2140

    
2141
    if (s->nb_streams >= MAX_STREAMS)
2142
        return NULL;
2143

    
2144
    st = av_mallocz(sizeof(AVStream));
2145
    if (!st)
2146
        return NULL;
2147

    
2148
    st->codec= avcodec_alloc_context();
2149
    if (s->iformat) {
2150
        /* no default bitrate if decoding */
2151
        st->codec->bit_rate = 0;
2152
    }
2153
    st->index = s->nb_streams;
2154
    st->id = id;
2155
    st->start_time = AV_NOPTS_VALUE;
2156
    st->duration = AV_NOPTS_VALUE;
2157
    st->cur_dts = AV_NOPTS_VALUE;
2158
    st->first_dts = AV_NOPTS_VALUE;
2159

    
2160
    /* default pts setting is MPEG-like */
2161
    av_set_pts_info(st, 33, 1, 90000);
2162
    st->last_IP_pts = AV_NOPTS_VALUE;
2163
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2164
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2165

    
2166
    s->streams[s->nb_streams++] = st;
2167
    return st;
2168
}
2169

    
2170
AVProgram *av_new_program(AVFormatContext *ac, int id)
2171
{
2172
    AVProgram *program=NULL;
2173
    int i;
2174

    
2175
#ifdef DEBUG_SI
2176
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2177
#endif
2178

    
2179
    for(i=0; i<ac->nb_programs; i++)
2180
        if(ac->programs[i]->id == id)
2181
            program = ac->programs[i];
2182

    
2183
    if(!program){
2184
        program = av_mallocz(sizeof(AVProgram));
2185
        if (!program)
2186
            return NULL;
2187
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2188
        program->discard = AVDISCARD_NONE;
2189
    }
2190
    program->id = id;
2191

    
2192
    return program;
2193
}
2194

    
2195
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2196
{
2197
    assert(!provider_name == !name);
2198
    if(name){
2199
        av_free(program->provider_name);
2200
        av_free(program->         name);
2201
        program->provider_name = av_strdup(provider_name);
2202
        program->         name = av_strdup(         name);
2203
    }
2204
}
2205

    
2206

    
2207
/************************************************************/
2208
/* output media file */
2209

    
2210
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2211
{
2212
    int ret;
2213

    
2214
    if (s->oformat->priv_data_size > 0) {
2215
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2216
        if (!s->priv_data)
2217
            return AVERROR(ENOMEM);
2218
    } else
2219
        s->priv_data = NULL;
2220

    
2221
    if (s->oformat->set_parameters) {
2222
        ret = s->oformat->set_parameters(s, ap);
2223
        if (ret < 0)
2224
            return ret;
2225
    }
2226
    return 0;
2227
}
2228

    
2229
int av_write_header(AVFormatContext *s)
2230
{
2231
    int ret, i;
2232
    AVStream *st;
2233

    
2234
    // some sanity checks
2235
    for(i=0;i<s->nb_streams;i++) {
2236
        st = s->streams[i];
2237

    
2238
        switch (st->codec->codec_type) {
2239
        case CODEC_TYPE_AUDIO:
2240
            if(st->codec->sample_rate<=0){
2241
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2242
                return -1;
2243
            }
2244
            break;
2245
        case CODEC_TYPE_VIDEO:
2246
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2247
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2248
                return -1;
2249
            }
2250
            if(st->codec->width<=0 || st->codec->height<=0){
2251
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2252
                return -1;
2253
            }
2254
            break;
2255
        }
2256

    
2257
        if(s->oformat->codec_tag){
2258
            if(st->codec->codec_tag){
2259
                //FIXME
2260
                //check that tag + id is in the table
2261
                //if neither is in the table -> OK
2262
                //if tag is in the table with another id -> FAIL
2263
                //if id is in the table with another tag -> FAIL unless strict < ?
2264
            }else
2265
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2266
        }
2267
    }
2268

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

    
2275
    if(s->oformat->write_header){
2276
        ret = s->oformat->write_header(s);
2277
        if (ret < 0)
2278
            return ret;
2279
    }
2280

    
2281
    /* init PTS generation */
2282
    for(i=0;i<s->nb_streams;i++) {
2283
        int64_t den = AV_NOPTS_VALUE;
2284
        st = s->streams[i];
2285

    
2286
        switch (st->codec->codec_type) {
2287
        case CODEC_TYPE_AUDIO:
2288
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2289
            break;
2290
        case CODEC_TYPE_VIDEO:
2291
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2292
            break;
2293
        default:
2294
            break;
2295
        }
2296
        if (den != AV_NOPTS_VALUE) {
2297
            if (den <= 0)
2298
                return AVERROR_INVALIDDATA;
2299
            av_frac_init(&st->pts, 0, 0, den);
2300
        }
2301
    }
2302
    return 0;
2303
}
2304

    
2305
//FIXME merge with compute_pkt_fields
2306
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2307
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2308
    int num, den, frame_size, i;
2309

    
2310
//    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);
2311

    
2312
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2313
        return -1;*/
2314

    
2315
    /* duration field */
2316
    if (pkt->duration == 0) {
2317
        compute_frame_duration(&num, &den, st, NULL, pkt);
2318
        if (den && num) {
2319
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2320
        }
2321
    }
2322

    
2323
    //XXX/FIXME this is a temporary hack until all encoders output pts
2324
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2325
        pkt->dts=
2326
//        pkt->pts= st->cur_dts;
2327
        pkt->pts= st->pts.val;
2328
    }
2329

    
2330
    //calculate dts from pts
2331
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2332
        st->pts_buffer[0]= pkt->pts;
2333
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2334
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2335
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2336
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2337

    
2338
        pkt->dts= st->pts_buffer[0];
2339
    }
2340

    
2341
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2342
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2343
        return -1;
2344
    }
2345
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2346
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2347
        return -1;
2348
    }
2349

    
2350
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2351
    st->cur_dts= pkt->dts;
2352
    st->pts.val= pkt->dts;
2353

    
2354
    /* update pts */
2355
    switch (st->codec->codec_type) {
2356
    case CODEC_TYPE_AUDIO:
2357
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2358

    
2359
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2360
           likely equal to the encoder delay, but it would be better if we
2361
           had the real timestamps from the encoder */
2362
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2363
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2364
        }
2365
        break;
2366
    case CODEC_TYPE_VIDEO:
2367
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2368
        break;
2369
    default:
2370
        break;
2371
    }
2372
    return 0;
2373
}
2374

    
2375
static void truncate_ts(AVStream *st, AVPacket *pkt){
2376
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2377

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

    
2381
    if (pkt->pts != AV_NOPTS_VALUE)
2382
        pkt->pts &= pts_mask;
2383
    if (pkt->dts != AV_NOPTS_VALUE)
2384
        pkt->dts &= pts_mask;
2385
}
2386

    
2387
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2388
{
2389
    int ret;
2390

    
2391
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2392
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2393
        return ret;
2394

    
2395
    truncate_ts(s->streams[pkt->stream_index], pkt);
2396

    
2397
    ret= s->oformat->write_packet(s, pkt);
2398
    if(!ret)
2399
        ret= url_ferror(s->pb);
2400
    return ret;
2401
}
2402

    
2403
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2404
    AVPacketList *pktl, **next_point, *this_pktl;
2405
    int stream_count=0;
2406
    int streams[MAX_STREAMS];
2407

    
2408
    if(pkt){
2409
        AVStream *st= s->streams[ pkt->stream_index];
2410

    
2411
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2412

    
2413
        this_pktl = av_mallocz(sizeof(AVPacketList));
2414
        this_pktl->pkt= *pkt;
2415
        if(pkt->destruct == av_destruct_packet)
2416
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2417
        else
2418
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2419

    
2420
        next_point = &s->packet_buffer;
2421
        while(*next_point){
2422
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2423
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2424
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2425
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2426
                break;
2427
            next_point= &(*next_point)->next;
2428
        }
2429
        this_pktl->next= *next_point;
2430
        *next_point= this_pktl;
2431
    }
2432

    
2433
    memset(streams, 0, sizeof(streams));
2434
    pktl= s->packet_buffer;
2435
    while(pktl){
2436
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2437
        if(streams[ pktl->pkt.stream_index ] == 0)
2438
            stream_count++;
2439
        streams[ pktl->pkt.stream_index ]++;
2440
        pktl= pktl->next;
2441
    }
2442

    
2443
    if(s->nb_streams == stream_count || (flush && stream_count)){
2444
        pktl= s->packet_buffer;
2445
        *out= pktl->pkt;
2446

    
2447
        s->packet_buffer= pktl->next;
2448
        av_freep(&pktl);
2449
        return 1;
2450
    }else{
2451
        av_init_packet(out);
2452
        return 0;
2453
    }
2454
}
2455

    
2456
/**
2457
 * Interleaves an AVPacket correctly so it can be muxed.
2458
 * @param out the interleaved packet will be output here
2459
 * @param in the input packet
2460
 * @param flush 1 if no further packets are available as input and all
2461
 *              remaining packets should be output
2462
 * @return 1 if a packet was output, 0 if no packet could be output,
2463
 *         < 0 if an error occured
2464
 */
2465
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2466
    if(s->oformat->interleave_packet)
2467
        return s->oformat->interleave_packet(s, out, in, flush);
2468
    else
2469
        return av_interleave_packet_per_dts(s, out, in, flush);
2470
}
2471

    
2472
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2473
    AVStream *st= s->streams[ pkt->stream_index];
2474

    
2475
    //FIXME/XXX/HACK drop zero sized packets
2476
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2477
        return 0;
2478

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

    
2483
    if(pkt->dts == AV_NOPTS_VALUE)
2484
        return -1;
2485

    
2486
    for(;;){
2487
        AVPacket opkt;
2488
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2489
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2490
            return ret;
2491

    
2492
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2493
        ret= s->oformat->write_packet(s, &opkt);
2494

    
2495
        av_free_packet(&opkt);
2496
        pkt= NULL;
2497

    
2498
        if(ret<0)
2499
            return ret;
2500
        if(url_ferror(s->pb))
2501
            return url_ferror(s->pb);
2502
    }
2503
}
2504

    
2505
int av_write_trailer(AVFormatContext *s)
2506
{
2507
    int ret, i;
2508

    
2509
    for(;;){
2510
        AVPacket pkt;
2511
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2512
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2513
            goto fail;
2514
        if(!ret)
2515
            break;
2516

    
2517
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2518
        ret= s->oformat->write_packet(s, &pkt);
2519

    
2520
        av_free_packet(&pkt);
2521

    
2522
        if(ret<0)
2523
            goto fail;
2524
        if(url_ferror(s->pb))
2525
            goto fail;
2526
    }
2527

    
2528
    if(s->oformat->write_trailer)
2529
        ret = s->oformat->write_trailer(s);
2530
fail:
2531
    if(ret == 0)
2532
       ret=url_ferror(s->pb);
2533
    for(i=0;i<s->nb_streams;i++)
2534
        av_freep(&s->streams[i]->priv_data);
2535
    av_freep(&s->priv_data);
2536
    return ret;
2537
}
2538

    
2539
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2540
{
2541
    int i, j;
2542
    AVProgram *program=NULL;
2543
    void *tmp;
2544

    
2545
    for(i=0; i<ac->nb_programs; i++){
2546
        if(ac->programs[i]->id != progid)
2547
            continue;
2548
        program = ac->programs[i];
2549
        for(j=0; j<program->nb_stream_indexes; j++)
2550
            if(program->stream_index[j] == idx)
2551
                return;
2552

    
2553
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2554
        if(!tmp)
2555
            return;
2556
        program->stream_index = tmp;
2557
        program->stream_index[program->nb_stream_indexes++] = idx;
2558
        return;
2559
    }
2560
}
2561

    
2562
/* "user interface" functions */
2563
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2564
{
2565
    char buf[256];
2566
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2567
    AVStream *st = ic->streams[i];
2568
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2569
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2570
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2571
    /* the pid is an important information, so we display it */
2572
    /* XXX: add a generic system */
2573
    if (flags & AVFMT_SHOW_IDS)
2574
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2575
    if (strlen(st->language) > 0)
2576
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2577
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2578
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2579
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2580
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2581
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2582
/*      else if(st->time_base.den && st->time_base.num)
2583
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2584
        else
2585
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2586
    }
2587
    av_log(NULL, AV_LOG_INFO, "\n");
2588
}
2589

    
2590
void dump_format(AVFormatContext *ic,
2591
                 int index,
2592
                 const char *url,
2593
                 int is_output)
2594
{
2595
    int i;
2596

    
2597
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2598
            is_output ? "Output" : "Input",
2599
            index,
2600
            is_output ? ic->oformat->name : ic->iformat->name,
2601
            is_output ? "to" : "from", url);
2602
    if (!is_output) {
2603
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2604
        if (ic->duration != AV_NOPTS_VALUE) {
2605
            int hours, mins, secs, us;
2606
            secs = ic->duration / AV_TIME_BASE;
2607
            us = ic->duration % AV_TIME_BASE;
2608
            mins = secs / 60;
2609
            secs %= 60;
2610
            hours = mins / 60;
2611
            mins %= 60;
2612
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2613
                   (10 * us) / AV_TIME_BASE);
2614
        } else {
2615
            av_log(NULL, AV_LOG_INFO, "N/A");
2616
        }
2617
        if (ic->start_time != AV_NOPTS_VALUE) {
2618
            int secs, us;
2619
            av_log(NULL, AV_LOG_INFO, ", start: ");
2620
            secs = ic->start_time / AV_TIME_BASE;
2621
            us = ic->start_time % AV_TIME_BASE;
2622
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2623
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2624
        }
2625
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2626
        if (ic->bit_rate) {
2627
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2628
        } else {
2629
            av_log(NULL, AV_LOG_INFO, "N/A");
2630
        }
2631
        av_log(NULL, AV_LOG_INFO, "\n");
2632
    }
2633
    if(ic->nb_programs) {
2634
        int j, k;
2635
        for(j=0; j<ic->nb_programs; j++) {
2636
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2637
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2638
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2639
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2640
         }
2641
    } else
2642
    for(i=0;i<ic->nb_streams;i++)
2643
        dump_stream_format(ic, i, index, is_output);
2644
}
2645

    
2646
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2647
{
2648
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2649
}
2650

    
2651
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2652
{
2653
    AVRational frame_rate;
2654
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2655
    *frame_rate_num= frame_rate.num;
2656
    *frame_rate_den= frame_rate.den;
2657
    return ret;
2658
}
2659

    
2660
/**
2661
 * Gets the current time in microseconds.
2662
 */
2663
int64_t av_gettime(void)
2664
{
2665
    struct timeval tv;
2666
    gettimeofday(&tv,NULL);
2667
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2668
}
2669

    
2670
int64_t parse_date(const char *datestr, int duration)
2671
{
2672
    const char *p;
2673
    int64_t t;
2674
    struct tm dt;
2675
    int i;
2676
    static const char *date_fmt[] = {
2677
        "%Y-%m-%d",
2678
        "%Y%m%d",
2679
    };
2680
    static const char *time_fmt[] = {
2681
        "%H:%M:%S",
2682
        "%H%M%S",
2683
    };
2684
    const char *q;
2685
    int is_utc, len;
2686
    char lastch;
2687
    int negative = 0;
2688

    
2689
#undef time
2690
    time_t now = time(0);
2691

    
2692
    len = strlen(datestr);
2693
    if (len > 0)
2694
        lastch = datestr[len - 1];
2695
    else
2696
        lastch = '\0';
2697
    is_utc = (lastch == 'z' || lastch == 'Z');
2698

    
2699
    memset(&dt, 0, sizeof(dt));
2700

    
2701
    p = datestr;
2702
    q = NULL;
2703
    if (!duration) {
2704
        /* parse the year-month-day part */
2705
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2706
            q = small_strptime(p, date_fmt[i], &dt);
2707
            if (q) {
2708
                break;
2709
            }
2710
        }
2711

    
2712
        /* if the year-month-day part is missing, then take the
2713
         * current year-month-day time */
2714
        if (!q) {
2715
            if (is_utc) {
2716
                dt = *gmtime(&now);
2717
            } else {
2718
                dt = *localtime(&now);
2719
            }
2720
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2721
        } else {
2722
            p = q;
2723
        }
2724

    
2725
        if (*p == 'T' || *p == 't' || *p == ' ')
2726
            p++;
2727

    
2728
        /* parse the hour-minute-second part */
2729
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2730
            q = small_strptime(p, time_fmt[i], &dt);
2731
            if (q) {
2732
                break;
2733
            }
2734
        }
2735
    } else {
2736
        /* parse datestr as a duration */
2737
        if (p[0] == '-') {
2738
            negative = 1;
2739
            ++p;
2740
        }
2741
        /* parse datestr as HH:MM:SS */
2742
        q = small_strptime(p, time_fmt[0], &dt);
2743
        if (!q) {
2744
            /* parse datestr as S+ */
2745
            dt.tm_sec = strtol(p, (char **)&q, 10);
2746
            if (q == p)
2747
                /* the parsing didn't succeed */
2748
                return INT64_MIN;
2749
            dt.tm_min = 0;
2750
            dt.tm_hour = 0;
2751
        }
2752
    }
2753

    
2754
    /* Now we have all the fields that we can get */
2755
    if (!q) {
2756
        return INT64_MIN;
2757
    }
2758

    
2759
    if (duration) {
2760
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2761
    } else {
2762
        dt.tm_isdst = -1;       /* unknown */
2763
        if (is_utc) {
2764
            t = mktimegm(&dt);
2765
        } else {
2766
            t = mktime(&dt);
2767
        }
2768
    }
2769

    
2770
    t *= 1000000;
2771

    
2772
    /* parse the .m... part */
2773
    if (*q == '.') {
2774
        int val, n;
2775
        q++;
2776
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2777
            if (!isdigit(*q))
2778
                break;
2779
            val += n * (*q - '0');
2780
        }
2781
        t += val;
2782
    }
2783
    return negative ? -t : t;
2784
}
2785

    
2786
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2787
{
2788
    const char *p;
2789
    char tag[128], *q;
2790

    
2791
    p = info;
2792
    if (*p == '?')
2793
        p++;
2794
    for(;;) {
2795
        q = tag;
2796
        while (*p != '\0' && *p != '=' && *p != '&') {
2797
            if ((q - tag) < sizeof(tag) - 1)
2798
                *q++ = *p;
2799
            p++;
2800
        }
2801
        *q = '\0';
2802
        q = arg;
2803
        if (*p == '=') {
2804
            p++;
2805
            while (*p != '&' && *p != '\0') {
2806
                if ((q - arg) < arg_size - 1) {
2807
                    if (*p == '+')
2808
                        *q++ = ' ';
2809
                    else
2810
                        *q++ = *p;
2811
                }
2812
                p++;
2813
            }
2814
            *q = '\0';
2815
        }
2816
        if (!strcmp(tag, tag1))
2817
            return 1;
2818
        if (*p != '&')
2819
            break;
2820
        p++;
2821
    }
2822
    return 0;
2823
}
2824

    
2825
int av_get_frame_filename(char *buf, int buf_size,
2826
                          const char *path, int number)
2827
{
2828
    const char *p;
2829
    char *q, buf1[20], c;
2830
    int nd, len, percentd_found;
2831

    
2832
    q = buf;
2833
    p = path;
2834
    percentd_found = 0;
2835
    for(;;) {
2836
        c = *p++;
2837
        if (c == '\0')
2838
            break;
2839
        if (c == '%') {
2840
            do {
2841
                nd = 0;
2842
                while (isdigit(*p)) {
2843
                    nd = nd * 10 + *p++ - '0';
2844
                }
2845
                c = *p++;
2846
            } while (isdigit(c));
2847

    
2848
            switch(c) {
2849
            case '%':
2850
                goto addchar;
2851
            case 'd':
2852
                if (percentd_found)
2853
                    goto fail;
2854
                percentd_found = 1;
2855
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2856
                len = strlen(buf1);
2857
                if ((q - buf + len) > buf_size - 1)
2858
                    goto fail;
2859
                memcpy(q, buf1, len);
2860
                q += len;
2861
                break;
2862
            default:
2863
                goto fail;
2864
            }
2865
        } else {
2866
        addchar:
2867
            if ((q - buf) < buf_size - 1)
2868
                *q++ = c;
2869
        }
2870
    }
2871
    if (!percentd_found)
2872
        goto fail;
2873
    *q = '\0';
2874
    return 0;
2875
 fail:
2876
    *q = '\0';
2877
    return -1;
2878
}
2879

    
2880
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2881
{
2882
    int len, i, j, c;
2883
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2884

    
2885
    for(i=0;i<size;i+=16) {
2886
        len = size - i;
2887
        if (len > 16)
2888
            len = 16;
2889
        PRINT("%08x ", i);
2890
        for(j=0;j<16;j++) {
2891
            if (j < len)
2892
                PRINT(" %02x", buf[i+j]);
2893
            else
2894
                PRINT("   ");
2895
        }
2896
        PRINT(" ");
2897
        for(j=0;j<len;j++) {
2898
            c = buf[i+j];
2899
            if (c < ' ' || c > '~')
2900
                c = '.';
2901
            PRINT("%c", c);
2902
        }
2903
        PRINT("\n");
2904
    }
2905
#undef PRINT
2906
}
2907

    
2908
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2909
{
2910
    hex_dump_internal(NULL, f, 0, buf, size);
2911
}
2912

    
2913
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2914
{
2915
    hex_dump_internal(avcl, NULL, level, buf, size);
2916
}
2917

    
2918
 //FIXME needs to know the time_base
2919
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2920
{
2921
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2922
    PRINT("stream #%d:\n", pkt->stream_index);
2923
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2924
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2925
    /* DTS is _always_ valid after av_read_frame() */
2926
    PRINT("  dts=");
2927
    if (pkt->dts == AV_NOPTS_VALUE)
2928
        PRINT("N/A");
2929
    else
2930
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2931
    /* PTS may not be known if B-frames are present. */
2932
    PRINT("  pts=");
2933
    if (pkt->pts == AV_NOPTS_VALUE)
2934
        PRINT("N/A");
2935
    else
2936
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2937
    PRINT("\n");
2938
    PRINT("  size=%d\n", pkt->size);
2939
#undef PRINT
2940
    if (dump_payload)
2941
        av_hex_dump(f, pkt->data, pkt->size);
2942
}
2943

    
2944
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2945
{
2946
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2947
}
2948

    
2949
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2950
{
2951
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2952
}
2953

    
2954
void url_split(char *proto, int proto_size,
2955
               char *authorization, int authorization_size,
2956
               char *hostname, int hostname_size,
2957
               int *port_ptr,
2958
               char *path, int path_size,
2959
               const char *url)
2960
{
2961
    const char *p, *ls, *at, *col, *brk;
2962

    
2963
    if (port_ptr)               *port_ptr = -1;
2964
    if (proto_size > 0)         proto[0] = 0;
2965
    if (authorization_size > 0) authorization[0] = 0;
2966
    if (hostname_size > 0)      hostname[0] = 0;
2967
    if (path_size > 0)          path[0] = 0;
2968

    
2969
    /* parse protocol */
2970
    if ((p = strchr(url, ':'))) {
2971
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2972
        p++; /* skip ':' */
2973
        if (*p == '/') p++;
2974
        if (*p == '/') p++;
2975
    } else {
2976
        /* no protocol means plain filename */
2977
        av_strlcpy(path, url, path_size);
2978
        return;
2979
    }
2980

    
2981
    /* separate path from hostname */
2982
    ls = strchr(p, '/');
2983
    if(!ls)
2984
        ls = strchr(p, '?');
2985
    if(ls)
2986
        av_strlcpy(path, ls, path_size);
2987
    else
2988
        ls = &p[strlen(p)]; // XXX
2989

    
2990
    /* the rest is hostname, use that to parse auth/port */
2991
    if (ls != p) {
2992
        /* authorization (user[:pass]@hostname) */
2993
        if ((at = strchr(p, '@')) && at < ls) {
2994
            av_strlcpy(authorization, p,
2995
                       FFMIN(authorization_size, at + 1 - p));
2996
            p = at + 1; /* skip '@' */
2997
        }
2998

    
2999
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3000
            /* [host]:port */
3001
            av_strlcpy(hostname, p + 1,
3002
                       FFMIN(hostname_size, brk - p));
3003
            if (brk[1] == ':' && port_ptr)
3004
                *port_ptr = atoi(brk + 2);
3005
        } else if ((col = strchr(p, ':')) && col < ls) {
3006
            av_strlcpy(hostname, p,
3007
                       FFMIN(col + 1 - p, hostname_size));
3008
            if (port_ptr) *port_ptr = atoi(col + 1);
3009
        } else
3010
            av_strlcpy(hostname, p,
3011
                       FFMIN(ls + 1 - p, hostname_size));
3012
    }
3013
}
3014

    
3015
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3016
                     int pts_num, int pts_den)
3017
{
3018
    s->pts_wrap_bits = pts_wrap_bits;
3019
    s->time_base.num = pts_num;
3020
    s->time_base.den = pts_den;
3021
}
3022

    
3023
/* fraction handling */
3024

    
3025
/**
3026
 * f = val + (num / den) + 0.5.
3027
 *
3028
 * 'num' is normalized so that it is such as 0 <= num < den.
3029
 *
3030
 * @param f fractional number
3031
 * @param val integer value
3032
 * @param num must be >= 0
3033
 * @param den must be >= 1
3034
 */
3035
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3036
{
3037
    num += (den >> 1);
3038
    if (num >= den) {
3039
        val += num / den;
3040
        num = num % den;
3041
    }
3042
    f->val = val;
3043
    f->num = num;
3044
    f->den = den;
3045
}
3046

    
3047
/**
3048
 * Fractional addition to f: f = f + (incr / f->den).
3049
 *
3050
 * @param f fractional number
3051
 * @param incr increment, can be positive or negative
3052
 */
3053
static void av_frac_add(AVFrac *f, int64_t incr)
3054
{
3055
    int64_t num, den;
3056

    
3057
    num = f->num + incr;
3058
    den = f->den;
3059
    if (num < 0) {
3060
        f->val += num / den;
3061
        num = num % den;
3062
        if (num < 0) {
3063
            num += den;
3064
            f->val--;
3065
        }
3066
    } else if (num >= den) {
3067
        f->val += num / den;
3068
        num = num % den;
3069
    }
3070
    f->num = num;
3071
}