Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ a23c9c4a

History | View | Annotate | Download (92.5 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 && st->time_base.den) {
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->filename);
2116
        av_free(st);
2117
    }
2118
    for(i=s->nb_programs-1; i>=0; i--) {
2119
        av_freep(&s->programs[i]->provider_name);
2120
        av_freep(&s->programs[i]->name);
2121
        av_freep(&s->programs[i]->stream_index);
2122
        av_freep(&s->programs[i]);
2123
    }
2124
    flush_packet_queue(s);
2125
    av_freep(&s->priv_data);
2126
    av_free(s);
2127
}
2128

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

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

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

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

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

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

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

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

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

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

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

    
2193
    return program;
2194
}
2195

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

    
2207

    
2208
/************************************************************/
2209
/* output media file */
2210

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2521
        av_free_packet(&pkt);
2522

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2771
    t *= 1000000;
2772

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3024
/* fraction handling */
3025

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

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

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