Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 3fdb6af9

History | View | Annotate | Download (94.4 KB)

1
/*
2
 * Various utilities for ffmpeg system
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 "allformats.h"
23
#include "opt.h"
24

    
25
#undef NDEBUG
26
#include <assert.h>
27

    
28
/**
29
 * @file libavformat/utils.c
30
 * Various utility functions for using ffmpeg library.
31
 */
32

    
33
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
34
static void av_frac_add(AVFrac *f, int64_t incr);
35

    
36
/** head of registered input format linked list. */
37
AVInputFormat *first_iformat = NULL;
38
/** head of registered output format linked list. */
39
AVOutputFormat *first_oformat = NULL;
40

    
41
void av_register_input_format(AVInputFormat *format)
42
{
43
    AVInputFormat **p;
44
    p = &first_iformat;
45
    while (*p != NULL) p = &(*p)->next;
46
    *p = format;
47
    format->next = NULL;
48
}
49

    
50
void av_register_output_format(AVOutputFormat *format)
51
{
52
    AVOutputFormat **p;
53
    p = &first_oformat;
54
    while (*p != NULL) p = &(*p)->next;
55
    *p = format;
56
    format->next = NULL;
57
}
58

    
59
int match_ext(const char *filename, const char *extensions)
60
{
61
    const char *ext, *p;
62
    char ext1[32], *q;
63

    
64
    if(!filename)
65
        return 0;
66

    
67
    ext = strrchr(filename, '.');
68
    if (ext) {
69
        ext++;
70
        p = extensions;
71
        for(;;) {
72
            q = ext1;
73
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
74
                *q++ = *p++;
75
            *q = '\0';
76
            if (!strcasecmp(ext1, ext))
77
                return 1;
78
            if (*p == '\0')
79
                break;
80
            p++;
81
        }
82
    }
83
    return 0;
84
}
85

    
86
AVOutputFormat *guess_format(const char *short_name, const char *filename,
87
                             const char *mime_type)
88
{
89
    AVOutputFormat *fmt, *fmt_found;
90
    int score_max, score;
91

    
92
    /* specific test for image sequences */
93
#ifdef CONFIG_IMAGE2_MUXER
94
    if (!short_name && filename &&
95
        av_filename_number_test(filename) &&
96
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
97
        return guess_format("image2", NULL, NULL);
98
    }
99
#endif
100
    /* find the proper file type */
101
    fmt_found = NULL;
102
    score_max = 0;
103
    fmt = first_oformat;
104
    while (fmt != NULL) {
105
        score = 0;
106
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
107
            score += 100;
108
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
109
            score += 10;
110
        if (filename && fmt->extensions &&
111
            match_ext(filename, fmt->extensions)) {
112
            score += 5;
113
        }
114
        if (score > score_max) {
115
            score_max = score;
116
            fmt_found = fmt;
117
        }
118
        fmt = fmt->next;
119
    }
120
    return fmt_found;
121
}
122

    
123
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
124
                             const char *mime_type)
125
{
126
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
127

    
128
    if (fmt) {
129
        AVOutputFormat *stream_fmt;
130
        char stream_format_name[64];
131

    
132
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
133
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
134

    
135
        if (stream_fmt)
136
            fmt = stream_fmt;
137
    }
138

    
139
    return fmt;
140
}
141

    
142
/**
143
 * Guesses the codec id based upon muxer and filename.
144
 */
145
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
146
                            const char *filename, const char *mime_type, enum CodecType type){
147
    if(type == CODEC_TYPE_VIDEO){
148
        enum CodecID codec_id= CODEC_ID_NONE;
149

    
150
#ifdef CONFIG_IMAGE2_MUXER
151
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
152
            codec_id= av_guess_image2_codec(filename);
153
        }
154
#endif
155
        if(codec_id == CODEC_ID_NONE)
156
            codec_id= fmt->video_codec;
157
        return codec_id;
158
    }else if(type == CODEC_TYPE_AUDIO)
159
        return fmt->audio_codec;
160
    else
161
        return CODEC_ID_NONE;
162
}
163

    
164
/**
165
 * finds AVInputFormat based on input format's short name.
166
 */
167
AVInputFormat *av_find_input_format(const char *short_name)
168
{
169
    AVInputFormat *fmt;
170
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
171
        if (!strcmp(fmt->name, short_name))
172
            return fmt;
173
    }
174
    return NULL;
175
}
176

    
177
/* memory handling */
178

    
179
/**
180
 * Default packet destructor.
181
 */
182
void av_destruct_packet(AVPacket *pkt)
183
{
184
    av_free(pkt->data);
185
    pkt->data = NULL; pkt->size = 0;
186
}
187

    
188
/**
189
 * Allocate the payload of a packet and intialized its fields to default values.
190
 *
191
 * @param pkt packet
192
 * @param size wanted payload size
193
 * @return 0 if OK. AVERROR_xxx otherwise.
194
 */
195
int av_new_packet(AVPacket *pkt, int size)
196
{
197
    uint8_t *data;
198
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
199
        return AVERROR_NOMEM;
200
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
201
    if (!data)
202
        return AVERROR_NOMEM;
203
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
204

    
205
    av_init_packet(pkt);
206
    pkt->data = data;
207
    pkt->size = size;
208
    pkt->destruct = av_destruct_packet;
209
    return 0;
210
}
211

    
212
/**
213
 * Allocate and read the payload of a packet and intialized its fields to default values.
214
 *
215
 * @param pkt packet
216
 * @param size wanted payload size
217
 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
218
 */
219
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
220
{
221
    int ret= av_new_packet(pkt, size);
222

    
223
    if(ret<0)
224
        return ret;
225

    
226
    pkt->pos= url_ftell(s);
227

    
228
    ret= get_buffer(s, pkt->data, size);
229
    if(ret<=0)
230
        av_free_packet(pkt);
231
    else
232
        pkt->size= ret;
233

    
234
    return ret;
235
}
236

    
237
/* This is a hack - the packet memory allocation stuff is broken. The
238
   packet is allocated if it was not really allocated */
239
int av_dup_packet(AVPacket *pkt)
240
{
241
    if (pkt->destruct != av_destruct_packet) {
242
        uint8_t *data;
243
        /* we duplicate the packet and don't forget to put the padding
244
           again */
245
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
246
            return AVERROR_NOMEM;
247
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
248
        if (!data) {
249
            return AVERROR_NOMEM;
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
/**
260
 * Check whether filename actually is a numbered sequence generator.
261
 *
262
 * @param filename possible numbered sequence string
263
 * @return 1 if a valid numbered sequence string, 0 otherwise.
264
 */
265
int av_filename_number_test(const char *filename)
266
{
267
    char buf[1024];
268
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
269
}
270

    
271
/**
272
 * Guess file format.
273
 *
274
 * @param is_opened whether the file is already opened, determines whether
275
 *                  demuxers with or without AVFMT_NOFILE are probed
276
 */
277
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
278
{
279
    AVInputFormat *fmt1, *fmt;
280
    int score, score_max;
281

    
282
    fmt = NULL;
283
    score_max = 0;
284
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
285
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
286
            continue;
287
        score = 0;
288
        if (fmt1->read_probe) {
289
            score = fmt1->read_probe(pd);
290
        } else if (fmt1->extensions) {
291
            if (match_ext(pd->filename, fmt1->extensions)) {
292
                score = 50;
293
            }
294
        }
295
        if (score > score_max) {
296
            score_max = score;
297
            fmt = fmt1;
298
        }
299
    }
300
    return fmt;
301
}
302

    
303
/************************************************************/
304
/* input media file */
305

    
306
/**
307
 * Open a media file from an IO stream. 'fmt' must be specified.
308
 */
309
static const char* format_to_name(void* ptr)
310
{
311
    AVFormatContext* fc = (AVFormatContext*) ptr;
312
    if(fc->iformat) return fc->iformat->name;
313
    else if(fc->oformat) return fc->oformat->name;
314
    else return "NULL";
315
}
316

    
317
#define OFFSET(x) offsetof(AVFormatContext,x)
318
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
319
//these names are too long to be readable
320
#define E AV_OPT_FLAG_ENCODING_PARAM
321
#define D AV_OPT_FLAG_DECODING_PARAM
322

    
323
static const AVOption options[]={
324
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
325
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
326
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
327
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
328
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
329
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
330
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
331
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
332
{"analyzeduration", NULL, OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
333
{NULL},
334
};
335

    
336
#undef E
337
#undef D
338
#undef DEFAULT
339

    
340
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
341

    
342
static void avformat_get_context_defaults(AVFormatContext *s)
343
{
344
    memset(s, 0, sizeof(AVFormatContext));
345

    
346
    s->av_class = &av_format_context_class;
347

    
348
    av_opt_set_defaults(s);
349
}
350

    
351
AVFormatContext *av_alloc_format_context(void)
352
{
353
    AVFormatContext *ic;
354
    ic = av_malloc(sizeof(AVFormatContext));
355
    if (!ic) return ic;
356
    avformat_get_context_defaults(ic);
357
    ic->av_class = &av_format_context_class;
358
    return ic;
359
}
360

    
361
/**
362
 * Allocates all the structures needed to read an input stream.
363
 *        This does not open the needed codecs for decoding the stream[s].
364
 */
365
int av_open_input_stream(AVFormatContext **ic_ptr,
366
                         ByteIOContext *pb, const char *filename,
367
                         AVInputFormat *fmt, AVFormatParameters *ap)
368
{
369
    int err;
370
    AVFormatContext *ic;
371
    AVFormatParameters default_ap;
372

    
373
    if(!ap){
374
        ap=&default_ap;
375
        memset(ap, 0, sizeof(default_ap));
376
    }
377

    
378
    if(!ap->prealloced_context)
379
        ic = av_alloc_format_context();
380
    else
381
        ic = *ic_ptr;
382
    if (!ic) {
383
        err = AVERROR_NOMEM;
384
        goto fail;
385
    }
386
    ic->iformat = fmt;
387
    if (pb)
388
        ic->pb = *pb;
389
    ic->duration = AV_NOPTS_VALUE;
390
    ic->start_time = AV_NOPTS_VALUE;
391
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
392

    
393
    /* allocate private data */
394
    if (fmt->priv_data_size > 0) {
395
        ic->priv_data = av_mallocz(fmt->priv_data_size);
396
        if (!ic->priv_data) {
397
            err = AVERROR_NOMEM;
398
            goto fail;
399
        }
400
    } else {
401
        ic->priv_data = NULL;
402
    }
403

    
404
    err = ic->iformat->read_header(ic, ap);
405
    if (err < 0)
406
        goto fail;
407

    
408
    if (pb && !ic->data_offset)
409
        ic->data_offset = url_ftell(&ic->pb);
410

    
411
    *ic_ptr = ic;
412
    return 0;
413
 fail:
414
    if (ic) {
415
        av_freep(&ic->priv_data);
416
    }
417
    av_free(ic);
418
    *ic_ptr = NULL;
419
    return err;
420
}
421

    
422
/** Size of probe buffer, for guessing file type from file contents. */
423
#define PROBE_BUF_MIN 2048
424
#define PROBE_BUF_MAX (1<<20)
425

    
426
/**
427
 * Open a media file as input. The codec are not opened. Only the file
428
 * header (if present) is read.
429
 *
430
 * @param ic_ptr the opened media file handle is put here
431
 * @param filename filename to open.
432
 * @param fmt if non NULL, force the file format to use
433
 * @param buf_size optional buffer size (zero if default is OK)
434
 * @param ap additionnal parameters needed when opening the file (NULL if default)
435
 * @return 0 if OK. AVERROR_xxx otherwise.
436
 */
437
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
438
                       AVInputFormat *fmt,
439
                       int buf_size,
440
                       AVFormatParameters *ap)
441
{
442
    int err, must_open_file, file_opened, probe_size;
443
    AVProbeData probe_data, *pd = &probe_data;
444
    ByteIOContext pb1, *pb = &pb1;
445

    
446
    file_opened = 0;
447
    pd->filename = "";
448
    if (filename)
449
        pd->filename = filename;
450
    pd->buf = NULL;
451
    pd->buf_size = 0;
452

    
453
    if (!fmt) {
454
        /* guess format if no file can be opened  */
455
        fmt = av_probe_input_format(pd, 0);
456
    }
457

    
458
    /* do not open file if the format does not need it. XXX: specific
459
       hack needed to handle RTSP/TCP */
460
    must_open_file = 1;
461
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
462
        must_open_file = 0;
463
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
464
    }
465

    
466
    if (!fmt || must_open_file) {
467
        /* if no file needed do not try to open one */
468
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
469
            err = AVERROR_IO;
470
            goto fail;
471
        }
472
        file_opened = 1;
473
        if (buf_size > 0) {
474
            url_setbufsize(pb, buf_size);
475
        }
476

    
477
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
478
            /* read probe data */
479
            pd->buf= av_realloc(pd->buf, probe_size);
480
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
481
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)AVERROR(EPIPE)) {
482
                url_fclose(pb);
483
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
484
                    file_opened = 0;
485
                    err = AVERROR_IO;
486
                    goto fail;
487
                }
488
            }
489
            /* guess file format */
490
            fmt = av_probe_input_format(pd, 1);
491
        }
492
        av_freep(&pd->buf);
493
    }
494

    
495
    /* if still no format found, error */
496
    if (!fmt) {
497
        err = AVERROR_NOFMT;
498
        goto fail;
499
    }
500

    
501
    /* XXX: suppress this hack for redirectors */
502
#ifdef CONFIG_NETWORK
503
    if (fmt == &redir_demuxer) {
504
        err = redir_open(ic_ptr, pb);
505
        url_fclose(pb);
506
        return err;
507
    }
508
#endif
509

    
510
    /* check filename in case of an image number is expected */
511
    if (fmt->flags & AVFMT_NEEDNUMBER) {
512
        if (!av_filename_number_test(filename)) {
513
            err = AVERROR_NUMEXPECTED;
514
            goto fail;
515
        }
516
    }
517
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
518
    if (err)
519
        goto fail;
520
    return 0;
521
 fail:
522
    av_freep(&pd->buf);
523
    if (file_opened)
524
        url_fclose(pb);
525
    *ic_ptr = NULL;
526
    return err;
527

    
528
}
529

    
530
/*******************************************************/
531

    
532
/**
533
 * Read a transport packet from a media file.
534
 *
535
 * This function is absolete and should never be used.
536
 * Use av_read_frame() instead.
537
 *
538
 * @param s media file handle
539
 * @param pkt is filled
540
 * @return 0 if OK. AVERROR_xxx if error.
541
 */
542
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
543
{
544
    return s->iformat->read_packet(s, pkt);
545
}
546

    
547
/**********************************************************/
548

    
549
/**
550
 * Get the number of samples of an audio frame. Return (-1) if error.
551
 */
552
static int get_audio_frame_size(AVCodecContext *enc, int size)
553
{
554
    int frame_size;
555

    
556
    if (enc->frame_size <= 1) {
557
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
558

    
559
        if (bits_per_sample) {
560
            if (enc->channels == 0)
561
                return -1;
562
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
563
        } else {
564
            /* used for example by ADPCM codecs */
565
            if (enc->bit_rate == 0)
566
                return -1;
567
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
568
        }
569
    } else {
570
        frame_size = enc->frame_size;
571
    }
572
    return frame_size;
573
}
574

    
575

    
576
/**
577
 * Return the frame duration in seconds, return 0 if not available.
578
 */
579
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
580
                                   AVCodecParserContext *pc, AVPacket *pkt)
581
{
582
    int frame_size;
583

    
584
    *pnum = 0;
585
    *pden = 0;
586
    switch(st->codec->codec_type) {
587
    case CODEC_TYPE_VIDEO:
588
        if(st->time_base.num*1000LL > st->time_base.den){
589
            *pnum = st->time_base.num;
590
            *pden = st->time_base.den;
591
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
592
            *pnum = st->codec->time_base.num;
593
            *pden = st->codec->time_base.den;
594
            if (pc && pc->repeat_pict) {
595
                *pden *= 2;
596
                *pnum = (*pnum) * (2 + pc->repeat_pict);
597
            }
598
        }
599
        break;
600
    case CODEC_TYPE_AUDIO:
601
        frame_size = get_audio_frame_size(st->codec, pkt->size);
602
        if (frame_size < 0)
603
            break;
604
        *pnum = frame_size;
605
        *pden = st->codec->sample_rate;
606
        break;
607
    default:
608
        break;
609
    }
610
}
611

    
612
static int is_intra_only(AVCodecContext *enc){
613
    if(enc->codec_type == CODEC_TYPE_AUDIO){
614
        return 1;
615
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
616
        switch(enc->codec_id){
617
        case CODEC_ID_MJPEG:
618
        case CODEC_ID_MJPEGB:
619
        case CODEC_ID_LJPEG:
620
        case CODEC_ID_RAWVIDEO:
621
        case CODEC_ID_DVVIDEO:
622
        case CODEC_ID_HUFFYUV:
623
        case CODEC_ID_FFVHUFF:
624
        case CODEC_ID_ASV1:
625
        case CODEC_ID_ASV2:
626
        case CODEC_ID_VCR1:
627
            return 1;
628
        default: break;
629
        }
630
    }
631
    return 0;
632
}
633

    
634
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
635
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
636
    int64_t delta= last_ts - mask/2;
637
    return  ((lsb - delta)&mask) + delta;
638
}
639

    
640
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
641
                               AVCodecParserContext *pc, AVPacket *pkt)
642
{
643
    int num, den, presentation_delayed;
644
    /* handle wrapping */
645
    if(st->cur_dts != AV_NOPTS_VALUE){
646
        if(pkt->pts != AV_NOPTS_VALUE)
647
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
648
        if(pkt->dts != AV_NOPTS_VALUE)
649
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
650
    }
651

    
652
    if (pkt->duration == 0) {
653
        compute_frame_duration(&num, &den, st, pc, pkt);
654
        if (den && num) {
655
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
656
        }
657
    }
658

    
659
    if(is_intra_only(st->codec))
660
        pkt->flags |= PKT_FLAG_KEY;
661

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

    
676
    if(st->cur_dts == AV_NOPTS_VALUE){
677
        if(presentation_delayed) st->cur_dts = -pkt->duration;
678
        else                     st->cur_dts = 0;
679
    }
680

    
681
//    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);
682
    /* interpolate PTS and DTS if they are not present */
683
    if (presentation_delayed) {
684
        /* DTS = decompression time stamp */
685
        /* PTS = presentation time stamp */
686
        if (pkt->dts == AV_NOPTS_VALUE) {
687
            /* if we know the last pts, use it */
688
            if(st->last_IP_pts != AV_NOPTS_VALUE)
689
                st->cur_dts = pkt->dts = st->last_IP_pts;
690
            else
691
                pkt->dts = st->cur_dts;
692
        } else {
693
            st->cur_dts = pkt->dts;
694
        }
695
        /* this is tricky: the dts must be incremented by the duration
696
           of the frame we are displaying, i.e. the last I or P frame */
697
        if (st->last_IP_duration == 0)
698
            st->cur_dts += pkt->duration;
699
        else
700
            st->cur_dts += st->last_IP_duration;
701
        st->last_IP_duration  = pkt->duration;
702
        st->last_IP_pts= pkt->pts;
703
        /* cannot compute PTS if not present (we can compute it only
704
           by knowing the futur */
705
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
706
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
707
            int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
708
            int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
709
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
710
                pkt->pts += pkt->duration;
711
//                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);
712
            }
713
        }
714

    
715
        /* presentation is not delayed : PTS and DTS are the same */
716
        if (pkt->pts == AV_NOPTS_VALUE) {
717
            if (pkt->dts == AV_NOPTS_VALUE) {
718
                pkt->pts = st->cur_dts;
719
                pkt->dts = st->cur_dts;
720
            }
721
            else {
722
                st->cur_dts = pkt->dts;
723
                pkt->pts = pkt->dts;
724
            }
725
        } else {
726
            st->cur_dts = pkt->pts;
727
            pkt->dts = pkt->pts;
728
        }
729
        st->cur_dts += pkt->duration;
730
    }
731
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
732

    
733
    /* update flags */
734
    if (pc) {
735
        pkt->flags = 0;
736
        /* key frame computation */
737
        switch(st->codec->codec_type) {
738
        case CODEC_TYPE_VIDEO:
739
            if (pc->pict_type == FF_I_TYPE)
740
                pkt->flags |= PKT_FLAG_KEY;
741
            break;
742
        case CODEC_TYPE_AUDIO:
743
            pkt->flags |= PKT_FLAG_KEY;
744
            break;
745
        default:
746
            break;
747
        }
748
    }
749
}
750

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

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

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

    
782
                /* return packet if any */
783
                if (pkt->size) {
784
                got_packet:
785
                    pkt->duration = 0;
786
                    pkt->stream_index = st->index;
787
                    pkt->pts = st->parser->pts;
788
                    pkt->dts = st->parser->dts;
789
                    pkt->destruct = av_destruct_packet_nofree;
790
                    compute_pkt_fields(s, st, st->parser, pkt);
791

    
792
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
793
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
794
                                           0, 0, AVINDEX_KEYFRAME);
795
                    }
796

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

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

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

    
859
    return 0;
860
}
861

    
862
/**
863
 * Return the next frame of a stream.
864
 *
865
 * The returned packet is valid
866
 * until the next av_read_frame() or until av_close_input_file() and
867
 * must be freed with av_free_packet. For video, the packet contains
868
 * exactly one frame. For audio, it contains an integer number of
869
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
870
 * data). If the audio frames have a variable size (e.g. MPEG audio),
871
 * then it contains one frame.
872
 *
873
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
874
 * values in AV_TIME_BASE unit (and guessed if the format cannot
875
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
876
 * has B frames, so it is better to rely on pkt->dts if you do not
877
 * decompress the payload.
878
 *
879
 * @return 0 if OK, < 0 if error or end of file.
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
            AVPacketList **plast_pktl= &s->packet_buffer;
917
            int ret= av_read_frame_internal(s, pkt);
918
            if(ret<0){
919
                if(pktl && ret != AVERROR(EAGAIN)){
920
                    eof=1;
921
                    continue;
922
                }else
923
                    return ret;
924
            }
925

    
926
            /* duplicate the packet */
927
            if (av_dup_packet(pkt) < 0)
928
                return AVERROR_NOMEM;
929

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

    
932
            pktl = av_mallocz(sizeof(AVPacketList));
933
            if (!pktl)
934
                return AVERROR_NOMEM;
935

    
936
            /* add the packet in the buffered packet list */
937
            *plast_pktl = pktl;
938
            pktl->pkt= *pkt;
939
        }else{
940
            assert(!s->packet_buffer);
941
            return av_read_frame_internal(s, pkt);
942
        }
943
    }
944
}
945

    
946
/* XXX: suppress the packet queue */
947
static void flush_packet_queue(AVFormatContext *s)
948
{
949
    AVPacketList *pktl;
950

    
951
    for(;;) {
952
        pktl = s->packet_buffer;
953
        if (!pktl)
954
            break;
955
        s->packet_buffer = pktl->next;
956
        av_free_packet(&pktl->pkt);
957
        av_free(pktl);
958
    }
959
}
960

    
961
/*******************************************************/
962
/* seek support */
963

    
964
int av_find_default_stream_index(AVFormatContext *s)
965
{
966
    int i;
967
    AVStream *st;
968

    
969
    if (s->nb_streams <= 0)
970
        return -1;
971
    for(i = 0; i < s->nb_streams; i++) {
972
        st = s->streams[i];
973
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
974
            return i;
975
        }
976
    }
977
    return 0;
978
}
979

    
980
/**
981
 * Flush the frame reader.
982
 */
983
static void av_read_frame_flush(AVFormatContext *s)
984
{
985
    AVStream *st;
986
    int i;
987

    
988
    flush_packet_queue(s);
989

    
990
    /* free previous packet */
991
    if (s->cur_st) {
992
        if (s->cur_st->parser)
993
            av_free_packet(&s->cur_pkt);
994
        s->cur_st = NULL;
995
    }
996
    /* fail safe */
997
    s->cur_ptr = NULL;
998
    s->cur_len = 0;
999

    
1000
    /* for each stream, reset read state */
1001
    for(i = 0; i < s->nb_streams; i++) {
1002
        st = s->streams[i];
1003

    
1004
        if (st->parser) {
1005
            av_parser_close(st->parser);
1006
            st->parser = NULL;
1007
        }
1008
        st->last_IP_pts = AV_NOPTS_VALUE;
1009
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1010
    }
1011
}
1012

    
1013
/**
1014
 * Updates cur_dts of all streams based on given timestamp and AVStream.
1015
 *
1016
 * Stream ref_st unchanged, others set cur_dts in their native timebase
1017
 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1018
 * @param timestamp new dts expressed in time_base of param ref_st
1019
 * @param ref_st reference stream giving time_base of param timestamp
1020
 */
1021
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1022
    int i;
1023

    
1024
    for(i = 0; i < s->nb_streams; i++) {
1025
        AVStream *st = s->streams[i];
1026

    
1027
        st->cur_dts = av_rescale(timestamp,
1028
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1029
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1030
    }
1031
}
1032

    
1033
/**
1034
 * Add a index entry into a sorted list updateing if it is already there.
1035
 *
1036
 * @param timestamp timestamp in the timebase of the given stream
1037
 */
1038
int av_add_index_entry(AVStream *st,
1039
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1040
{
1041
    AVIndexEntry *entries, *ie;
1042
    int index;
1043

    
1044
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1045
        return -1;
1046

    
1047
    entries = av_fast_realloc(st->index_entries,
1048
                              &st->index_entries_allocated_size,
1049
                              (st->nb_index_entries + 1) *
1050
                              sizeof(AVIndexEntry));
1051
    if(!entries)
1052
        return -1;
1053

    
1054
    st->index_entries= entries;
1055

    
1056
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1057

    
1058
    if(index<0){
1059
        index= st->nb_index_entries++;
1060
        ie= &entries[index];
1061
        assert(index==0 || ie[-1].timestamp < timestamp);
1062
    }else{
1063
        ie= &entries[index];
1064
        if(ie->timestamp != timestamp){
1065
            if(ie->timestamp <= timestamp)
1066
                return -1;
1067
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1068
            st->nb_index_entries++;
1069
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1070
            distance= ie->min_distance;
1071
    }
1072

    
1073
    ie->pos = pos;
1074
    ie->timestamp = timestamp;
1075
    ie->min_distance= distance;
1076
    ie->size= size;
1077
    ie->flags = flags;
1078

    
1079
    return index;
1080
}
1081

    
1082
/**
1083
 * build an index for raw streams using a parser.
1084
 */
1085
static void av_build_index_raw(AVFormatContext *s)
1086
{
1087
    AVPacket pkt1, *pkt = &pkt1;
1088
    int ret;
1089
    AVStream *st;
1090

    
1091
    st = s->streams[0];
1092
    av_read_frame_flush(s);
1093
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1094

    
1095
    for(;;) {
1096
        ret = av_read_frame(s, pkt);
1097
        if (ret < 0)
1098
            break;
1099
        if (pkt->stream_index == 0 && st->parser &&
1100
            (pkt->flags & PKT_FLAG_KEY)) {
1101
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1102
                            0, 0, AVINDEX_KEYFRAME);
1103
        }
1104
        av_free_packet(pkt);
1105
    }
1106
}
1107

    
1108
/**
1109
 * Returns TRUE if we deal with a raw stream.
1110
 *
1111
 * Raw codec data and parsing needed.
1112
 */
1113
static int is_raw_stream(AVFormatContext *s)
1114
{
1115
    AVStream *st;
1116

    
1117
    if (s->nb_streams != 1)
1118
        return 0;
1119
    st = s->streams[0];
1120
    if (!st->need_parsing)
1121
        return 0;
1122
    return 1;
1123
}
1124

    
1125
/**
1126
 * Gets the index for a specific timestamp.
1127
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1128
 *                 the timestamp which is <= the requested one, if backward is 0
1129
 *                 then it will be >=
1130
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1131
 * @return < 0 if no such timestamp could be found
1132
 */
1133
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1134
                              int flags)
1135
{
1136
    AVIndexEntry *entries= st->index_entries;
1137
    int nb_entries= st->nb_index_entries;
1138
    int a, b, m;
1139
    int64_t timestamp;
1140

    
1141
    a = - 1;
1142
    b = nb_entries;
1143

    
1144
    while (b - a > 1) {
1145
        m = (a + b) >> 1;
1146
        timestamp = entries[m].timestamp;
1147
        if(timestamp >= wanted_timestamp)
1148
            b = m;
1149
        if(timestamp <= wanted_timestamp)
1150
            a = m;
1151
    }
1152
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1153

    
1154
    if(!(flags & AVSEEK_FLAG_ANY)){
1155
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1156
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1157
        }
1158
    }
1159

    
1160
    if(m == nb_entries)
1161
        return -1;
1162
    return  m;
1163
}
1164

    
1165
#define DEBUG_SEEK
1166

    
1167
/**
1168
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1169
 * this isnt supposed to be called directly by a user application, but by demuxers
1170
 * @param target_ts target timestamp in the time base of the given stream
1171
 * @param stream_index stream number
1172
 */
1173
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1174
    AVInputFormat *avif= s->iformat;
1175
    int64_t pos_min, pos_max, pos, pos_limit;
1176
    int64_t ts_min, ts_max, ts;
1177
    int index;
1178
    AVStream *st;
1179

    
1180
    if (stream_index < 0)
1181
        return -1;
1182

    
1183
#ifdef DEBUG_SEEK
1184
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1185
#endif
1186

    
1187
    ts_max=
1188
    ts_min= AV_NOPTS_VALUE;
1189
    pos_limit= -1; //gcc falsely says it may be uninitalized
1190

    
1191
    st= s->streams[stream_index];
1192
    if(st->index_entries){
1193
        AVIndexEntry *e;
1194

    
1195
        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()
1196
        index= FFMAX(index, 0);
1197
        e= &st->index_entries[index];
1198

    
1199
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1200
            pos_min= e->pos;
1201
            ts_min= e->timestamp;
1202
#ifdef DEBUG_SEEK
1203
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1204
               pos_min,ts_min);
1205
#endif
1206
        }else{
1207
            assert(index==0);
1208
        }
1209

    
1210
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1211
        assert(index < st->nb_index_entries);
1212
        if(index >= 0){
1213
            e= &st->index_entries[index];
1214
            assert(e->timestamp >= target_ts);
1215
            pos_max= e->pos;
1216
            ts_max= e->timestamp;
1217
            pos_limit= pos_max - e->min_distance;
1218
#ifdef DEBUG_SEEK
1219
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1220
               pos_max,pos_limit, ts_max);
1221
#endif
1222
        }
1223
    }
1224

    
1225
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1226
    if(pos<0)
1227
        return -1;
1228

    
1229
    /* do the seek */
1230
    url_fseek(&s->pb, pos, SEEK_SET);
1231

    
1232
    av_update_cur_dts(s, st, ts);
1233

    
1234
    return 0;
1235
}
1236

    
1237
/**
1238
 * Does a binary search using read_timestamp().
1239
 * this isnt supposed to be called directly by a user application, but by demuxers
1240
 * @param target_ts target timestamp in the time base of the given stream
1241
 * @param stream_index stream number
1242
 */
1243
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 )){
1244
    int64_t pos, ts;
1245
    int64_t start_pos, filesize;
1246
    int no_change;
1247

    
1248
#ifdef DEBUG_SEEK
1249
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1250
#endif
1251

    
1252
    if(ts_min == AV_NOPTS_VALUE){
1253
        pos_min = s->data_offset;
1254
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1255
        if (ts_min == AV_NOPTS_VALUE)
1256
            return -1;
1257
    }
1258

    
1259
    if(ts_max == AV_NOPTS_VALUE){
1260
        int step= 1024;
1261
        filesize = url_fsize(&s->pb);
1262
        pos_max = filesize - 1;
1263
        do{
1264
            pos_max -= step;
1265
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1266
            step += step;
1267
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1268
        if (ts_max == AV_NOPTS_VALUE)
1269
            return -1;
1270

    
1271
        for(;;){
1272
            int64_t tmp_pos= pos_max + 1;
1273
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1274
            if(tmp_ts == AV_NOPTS_VALUE)
1275
                break;
1276
            ts_max= tmp_ts;
1277
            pos_max= tmp_pos;
1278
            if(tmp_pos >= filesize)
1279
                break;
1280
        }
1281
        pos_limit= pos_max;
1282
    }
1283

    
1284
    if(ts_min > ts_max){
1285
        return -1;
1286
    }else if(ts_min == ts_max){
1287
        pos_limit= pos_min;
1288
    }
1289

    
1290
    no_change=0;
1291
    while (pos_min < pos_limit) {
1292
#ifdef DEBUG_SEEK
1293
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1294
               pos_min, pos_max,
1295
               ts_min, ts_max);
1296
#endif
1297
        assert(pos_limit <= pos_max);
1298

    
1299
        if(no_change==0){
1300
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1301
            // interpolate position (better than dichotomy)
1302
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1303
                + pos_min - approximate_keyframe_distance;
1304
        }else if(no_change==1){
1305
            // bisection, if interpolation failed to change min or max pos last time
1306
            pos = (pos_min + pos_limit)>>1;
1307
        }else{
1308
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1309
            pos=pos_min;
1310
        }
1311
        if(pos <= pos_min)
1312
            pos= pos_min + 1;
1313
        else if(pos > pos_limit)
1314
            pos= pos_limit;
1315
        start_pos= pos;
1316

    
1317
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1318
        if(pos == pos_max)
1319
            no_change++;
1320
        else
1321
            no_change=0;
1322
#ifdef DEBUG_SEEK
1323
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);
1324
#endif
1325
        assert(ts != AV_NOPTS_VALUE);
1326
        if (target_ts <= ts) {
1327
            pos_limit = start_pos - 1;
1328
            pos_max = pos;
1329
            ts_max = ts;
1330
        }
1331
        if (target_ts >= ts) {
1332
            pos_min = pos;
1333
            ts_min = ts;
1334
        }
1335
    }
1336

    
1337
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1338
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1339
#ifdef DEBUG_SEEK
1340
    pos_min = pos;
1341
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1342
    pos_min++;
1343
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1344
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1345
           pos, ts_min, target_ts, ts_max);
1346
#endif
1347
    *ts_ret= ts;
1348
    return pos;
1349
}
1350

    
1351
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1352
    int64_t pos_min, pos_max;
1353
#if 0
1354
    AVStream *st;
1355

1356
    if (stream_index < 0)
1357
        return -1;
1358

1359
    st= s->streams[stream_index];
1360
#endif
1361

    
1362
    pos_min = s->data_offset;
1363
    pos_max = url_fsize(&s->pb) - 1;
1364

    
1365
    if     (pos < pos_min) pos= pos_min;
1366
    else if(pos > pos_max) pos= pos_max;
1367

    
1368
    url_fseek(&s->pb, pos, SEEK_SET);
1369

    
1370
#if 0
1371
    av_update_cur_dts(s, st, ts);
1372
#endif
1373
    return 0;
1374
}
1375

    
1376
static int av_seek_frame_generic(AVFormatContext *s,
1377
                                 int stream_index, int64_t timestamp, int flags)
1378
{
1379
    int index;
1380
    AVStream *st;
1381
    AVIndexEntry *ie;
1382

    
1383
    st = s->streams[stream_index];
1384

    
1385
    index = av_index_search_timestamp(st, timestamp, flags);
1386

    
1387
    if(index < 0){
1388
        int i;
1389
        AVPacket pkt;
1390

    
1391
        if(st->index_entries && st->nb_index_entries){
1392
            ie= &st->index_entries[st->nb_index_entries-1];
1393
            url_fseek(&s->pb, ie->pos, SEEK_SET);
1394
            av_update_cur_dts(s, st, ie->timestamp);
1395
        }else
1396
            url_fseek(&s->pb, 0, SEEK_SET);
1397

    
1398
        for(i=0;; i++) {
1399
            int ret = av_read_frame(s, &pkt);
1400
            if(ret<0)
1401
                break;
1402
            av_free_packet(&pkt);
1403
            if(stream_index == pkt.stream_index){
1404
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1405
                    break;
1406
            }
1407
        }
1408
        index = av_index_search_timestamp(st, timestamp, flags);
1409
    }
1410
    if (index < 0)
1411
        return -1;
1412

    
1413
    av_read_frame_flush(s);
1414
    if (s->iformat->read_seek){
1415
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1416
            return 0;
1417
    }
1418
    ie = &st->index_entries[index];
1419
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1420

    
1421
    av_update_cur_dts(s, st, ie->timestamp);
1422

    
1423
    return 0;
1424
}
1425

    
1426
/**
1427
 * Seek to the key frame at timestamp.
1428
 * 'timestamp' in 'stream_index'.
1429
 * @param stream_index If stream_index is (-1), a default
1430
 * stream is selected, and timestamp is automatically converted
1431
 * from AV_TIME_BASE units to the stream specific time_base.
1432
 * @param timestamp timestamp in AVStream.time_base units
1433
 *        or if there is no stream specified then in AV_TIME_BASE units
1434
 * @param flags flags which select direction and seeking mode
1435
 * @return >= 0 on success
1436
 */
1437
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1438
{
1439
    int ret;
1440
    AVStream *st;
1441

    
1442
    av_read_frame_flush(s);
1443

    
1444
    if(flags & AVSEEK_FLAG_BYTE)
1445
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1446

    
1447
    if(stream_index < 0){
1448
        stream_index= av_find_default_stream_index(s);
1449
        if(stream_index < 0)
1450
            return -1;
1451

    
1452
        st= s->streams[stream_index];
1453
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1454
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1455
    }
1456
    st= s->streams[stream_index];
1457

    
1458
    /* first, we try the format specific seek */
1459
    if (s->iformat->read_seek)
1460
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1461
    else
1462
        ret = -1;
1463
    if (ret >= 0) {
1464
        return 0;
1465
    }
1466

    
1467
    if(s->iformat->read_timestamp)
1468
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1469
    else
1470
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1471
}
1472

    
1473
/*******************************************************/
1474

    
1475
/**
1476
 * Returns TRUE if the stream has accurate timings in any stream.
1477
 *
1478
 * @return TRUE if the stream has accurate timings for at least one component.
1479
 */
1480
static int av_has_timings(AVFormatContext *ic)
1481
{
1482
    int i;
1483
    AVStream *st;
1484

    
1485
    for(i = 0;i < ic->nb_streams; i++) {
1486
        st = ic->streams[i];
1487
        if (st->start_time != AV_NOPTS_VALUE &&
1488
            st->duration != AV_NOPTS_VALUE)
1489
            return 1;
1490
    }
1491
    return 0;
1492
}
1493

    
1494
/**
1495
 * Estimate the stream timings from the one of each components.
1496
 *
1497
 * Also computes the global bitrate if possible.
1498
 */
1499
static void av_update_stream_timings(AVFormatContext *ic)
1500
{
1501
    int64_t start_time, start_time1, end_time, end_time1;
1502
    int i;
1503
    AVStream *st;
1504

    
1505
    start_time = INT64_MAX;
1506
    end_time = INT64_MIN;
1507
    for(i = 0;i < ic->nb_streams; i++) {
1508
        st = ic->streams[i];
1509
        if (st->start_time != AV_NOPTS_VALUE) {
1510
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1511
            if (start_time1 < start_time)
1512
                start_time = start_time1;
1513
            if (st->duration != AV_NOPTS_VALUE) {
1514
                end_time1 = start_time1
1515
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1516
                if (end_time1 > end_time)
1517
                    end_time = end_time1;
1518
            }
1519
        }
1520
    }
1521
    if (start_time != INT64_MAX) {
1522
        ic->start_time = start_time;
1523
        if (end_time != INT64_MIN) {
1524
            ic->duration = end_time - start_time;
1525
            if (ic->file_size > 0) {
1526
                /* compute the bit rate */
1527
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1528
                    (double)ic->duration;
1529
            }
1530
        }
1531
    }
1532

    
1533
}
1534

    
1535
static void fill_all_stream_timings(AVFormatContext *ic)
1536
{
1537
    int i;
1538
    AVStream *st;
1539

    
1540
    av_update_stream_timings(ic);
1541
    for(i = 0;i < ic->nb_streams; i++) {
1542
        st = ic->streams[i];
1543
        if (st->start_time == AV_NOPTS_VALUE) {
1544
            if(ic->start_time != AV_NOPTS_VALUE)
1545
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1546
            if(ic->duration != AV_NOPTS_VALUE)
1547
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1548
        }
1549
    }
1550
}
1551

    
1552
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1553
{
1554
    int64_t filesize, duration;
1555
    int bit_rate, i;
1556
    AVStream *st;
1557

    
1558
    /* if bit_rate is already set, we believe it */
1559
    if (ic->bit_rate == 0) {
1560
        bit_rate = 0;
1561
        for(i=0;i<ic->nb_streams;i++) {
1562
            st = ic->streams[i];
1563
            bit_rate += st->codec->bit_rate;
1564
        }
1565
        ic->bit_rate = bit_rate;
1566
    }
1567

    
1568
    /* if duration is already set, we believe it */
1569
    if (ic->duration == AV_NOPTS_VALUE &&
1570
        ic->bit_rate != 0 &&
1571
        ic->file_size != 0)  {
1572
        filesize = ic->file_size;
1573
        if (filesize > 0) {
1574
            for(i = 0; i < ic->nb_streams; i++) {
1575
                st = ic->streams[i];
1576
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1577
                if (st->start_time == AV_NOPTS_VALUE ||
1578
                    st->duration == AV_NOPTS_VALUE) {
1579
                    st->start_time = 0;
1580
                    st->duration = duration;
1581
                }
1582
            }
1583
        }
1584
    }
1585
}
1586

    
1587
#define DURATION_MAX_READ_SIZE 250000
1588

    
1589
/* only usable for MPEG-PS streams */
1590
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1591
{
1592
    AVPacket pkt1, *pkt = &pkt1;
1593
    AVStream *st;
1594
    int read_size, i, ret;
1595
    int64_t end_time;
1596
    int64_t filesize, offset, duration;
1597

    
1598
    /* free previous packet */
1599
    if (ic->cur_st && ic->cur_st->parser)
1600
        av_free_packet(&ic->cur_pkt);
1601
    ic->cur_st = NULL;
1602

    
1603
    /* flush packet queue */
1604
    flush_packet_queue(ic);
1605

    
1606
    for(i=0;i<ic->nb_streams;i++) {
1607
        st = ic->streams[i];
1608
        if (st->parser) {
1609
            av_parser_close(st->parser);
1610
            st->parser= NULL;
1611
        }
1612
    }
1613

    
1614
    /* we read the first packets to get the first PTS (not fully
1615
       accurate, but it is enough now) */
1616
    url_fseek(&ic->pb, 0, SEEK_SET);
1617
    read_size = 0;
1618
    for(;;) {
1619
        if (read_size >= DURATION_MAX_READ_SIZE)
1620
            break;
1621
        /* if all info is available, we can stop */
1622
        for(i = 0;i < ic->nb_streams; i++) {
1623
            st = ic->streams[i];
1624
            if (st->start_time == AV_NOPTS_VALUE)
1625
                break;
1626
        }
1627
        if (i == ic->nb_streams)
1628
            break;
1629

    
1630
        ret = av_read_packet(ic, pkt);
1631
        if (ret != 0)
1632
            break;
1633
        read_size += pkt->size;
1634
        st = ic->streams[pkt->stream_index];
1635
        if (pkt->pts != AV_NOPTS_VALUE) {
1636
            if (st->start_time == AV_NOPTS_VALUE)
1637
                st->start_time = pkt->pts;
1638
        }
1639
        av_free_packet(pkt);
1640
    }
1641

    
1642
    /* estimate the end time (duration) */
1643
    /* XXX: may need to support wrapping */
1644
    filesize = ic->file_size;
1645
    offset = filesize - DURATION_MAX_READ_SIZE;
1646
    if (offset < 0)
1647
        offset = 0;
1648

    
1649
    url_fseek(&ic->pb, offset, SEEK_SET);
1650
    read_size = 0;
1651
    for(;;) {
1652
        if (read_size >= DURATION_MAX_READ_SIZE)
1653
            break;
1654
        /* if all info is available, we can stop */
1655
        for(i = 0;i < ic->nb_streams; i++) {
1656
            st = ic->streams[i];
1657
            if (st->duration == AV_NOPTS_VALUE)
1658
                break;
1659
        }
1660
        if (i == ic->nb_streams)
1661
            break;
1662

    
1663
        ret = av_read_packet(ic, pkt);
1664
        if (ret != 0)
1665
            break;
1666
        read_size += pkt->size;
1667
        st = ic->streams[pkt->stream_index];
1668
        if (pkt->pts != AV_NOPTS_VALUE) {
1669
            end_time = pkt->pts;
1670
            duration = end_time - st->start_time;
1671
            if (duration > 0) {
1672
                if (st->duration == AV_NOPTS_VALUE ||
1673
                    st->duration < duration)
1674
                    st->duration = duration;
1675
            }
1676
        }
1677
        av_free_packet(pkt);
1678
    }
1679

    
1680
    fill_all_stream_timings(ic);
1681

    
1682
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1683
}
1684

    
1685
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1686
{
1687
    int64_t file_size;
1688

    
1689
    /* get the file size, if possible */
1690
    if (ic->iformat->flags & AVFMT_NOFILE) {
1691
        file_size = 0;
1692
    } else {
1693
        file_size = url_fsize(&ic->pb);
1694
        if (file_size < 0)
1695
            file_size = 0;
1696
    }
1697
    ic->file_size = file_size;
1698

    
1699
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1700
         !strcmp(ic->iformat->name, "mpegts")) &&
1701
        file_size && !ic->pb.is_streamed) {
1702
        /* get accurate estimate from the PTSes */
1703
        av_estimate_timings_from_pts(ic, old_offset);
1704
    } else if (av_has_timings(ic)) {
1705
        /* at least one components has timings - we use them for all
1706
           the components */
1707
        fill_all_stream_timings(ic);
1708
    } else {
1709
        /* less precise: use bit rate info */
1710
        av_estimate_timings_from_bit_rate(ic);
1711
    }
1712
    av_update_stream_timings(ic);
1713

    
1714
#if 0
1715
    {
1716
        int i;
1717
        AVStream *st;
1718
        for(i = 0;i < ic->nb_streams; i++) {
1719
            st = ic->streams[i];
1720
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1721
               i, (double)st->start_time / AV_TIME_BASE,
1722
               (double)st->duration / AV_TIME_BASE);
1723
        }
1724
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1725
               (double)ic->start_time / AV_TIME_BASE,
1726
               (double)ic->duration / AV_TIME_BASE,
1727
               ic->bit_rate / 1000);
1728
    }
1729
#endif
1730
}
1731

    
1732
static int has_codec_parameters(AVCodecContext *enc)
1733
{
1734
    int val;
1735
    switch(enc->codec_type) {
1736
    case CODEC_TYPE_AUDIO:
1737
        val = enc->sample_rate;
1738
        break;
1739
    case CODEC_TYPE_VIDEO:
1740
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1741
        break;
1742
    default:
1743
        val = 1;
1744
        break;
1745
    }
1746
    return (val != 0);
1747
}
1748

    
1749
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1750
{
1751
    int16_t *samples;
1752
    AVCodec *codec;
1753
    int got_picture, data_size, ret=0;
1754
    AVFrame picture;
1755

    
1756
  if(!st->codec->codec){
1757
    codec = avcodec_find_decoder(st->codec->codec_id);
1758
    if (!codec)
1759
        return -1;
1760
    ret = avcodec_open(st->codec, codec);
1761
    if (ret < 0)
1762
        return ret;
1763
  }
1764

    
1765
  if(!has_codec_parameters(st->codec)){
1766
    switch(st->codec->codec_type) {
1767
    case CODEC_TYPE_VIDEO:
1768
        ret = avcodec_decode_video(st->codec, &picture,
1769
                                   &got_picture, (uint8_t *)data, size);
1770
        break;
1771
    case CODEC_TYPE_AUDIO:
1772
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1773
        samples = av_malloc(data_size);
1774
        if (!samples)
1775
            goto fail;
1776
        ret = avcodec_decode_audio2(st->codec, samples,
1777
                                    &data_size, (uint8_t *)data, size);
1778
        av_free(samples);
1779
        break;
1780
    default:
1781
        break;
1782
    }
1783
  }
1784
 fail:
1785
    return ret;
1786
}
1787

    
1788
/* absolute maximum size we read until we abort */
1789
#define MAX_READ_SIZE        5000000
1790

    
1791
#define MAX_STD_TIMEBASES (60*12+5)
1792
static int get_std_framerate(int i){
1793
    if(i<60*12) return i*1001;
1794
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1795
}
1796

    
1797
/**
1798
 * Read packets of a media file to get stream information. This
1799
 * is useful for file formats with no headers such as MPEG. This
1800
 * function also computes the real frame rate in case of mpeg2 repeat
1801
 * frame mode.
1802
 * The logical file position is not changed by this function;
1803
 * examined packets may be buffered for later processing.
1804
 *
1805
 * @param ic media file handle
1806
 * @return >=0 if OK. AVERROR_xxx if error.
1807
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1808
 */
1809
int av_find_stream_info(AVFormatContext *ic)
1810
{
1811
    int i, count, ret, read_size, j;
1812
    AVStream *st;
1813
    AVPacket pkt1, *pkt;
1814
    AVPacketList *pktl=NULL, **ppktl;
1815
    int64_t last_dts[MAX_STREAMS];
1816
    int duration_count[MAX_STREAMS]={0};
1817
    double duration_error[MAX_STREAMS][MAX_STD_TIMEBASES]={{0}}; //FIXME malloc()?
1818
    offset_t old_offset = url_ftell(&ic->pb);
1819

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

    
1837
    for(i=0;i<MAX_STREAMS;i++){
1838
        last_dts[i]= AV_NOPTS_VALUE;
1839
    }
1840

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

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

    
1892
        pktl = av_mallocz(sizeof(AVPacketList));
1893
        if (!pktl) {
1894
            ret = AVERROR_NOMEM;
1895
            break;
1896
        }
1897

    
1898
        /* add the packet in the buffered packet list */
1899
        *ppktl = pktl;
1900
        ppktl = &pktl->next;
1901

    
1902
        pkt = &pktl->pkt;
1903
        *pkt = pkt1;
1904

    
1905
        /* duplicate the packet */
1906
        if (av_dup_packet(pkt) < 0) {
1907
            ret = AVERROR_NOMEM;
1908
            break;
1909
        }
1910

    
1911
        read_size += pkt->size;
1912

    
1913
        st = ic->streams[pkt->stream_index];
1914
        if(st->codec_info_nb_frames>1) //FIXME move codec_info_nb_frames and codec_info_duration from AVStream into this func
1915
            st->codec_info_duration += pkt->duration;
1916
        if (pkt->duration != 0)
1917
            st->codec_info_nb_frames++;
1918

    
1919
        {
1920
            int index= pkt->stream_index;
1921
            int64_t last= last_dts[index];
1922
            int64_t duration= pkt->dts - last;
1923

    
1924
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1925
                double dur= duration * av_q2d(st->time_base);
1926

    
1927
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1928
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1929
                if(duration_count[index] < 2)
1930
                    memset(duration_error, 0, sizeof(duration_error));
1931
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1932
                    int framerate= get_std_framerate(i);
1933
                    int ticks= lrintf(dur*framerate/(1001*12));
1934
                    double error= dur - ticks*1001*12/(double)framerate;
1935
                    duration_error[index][i] += error*error;
1936
                }
1937
                duration_count[index]++;
1938

    
1939
                if(st->codec_info_nb_frames == 0 && 0)
1940
                    st->codec_info_duration += duration;
1941
            }
1942
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1943
                last_dts[pkt->stream_index]= pkt->dts;
1944
        }
1945
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1946
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1947
            if(i){
1948
                st->codec->extradata_size= i;
1949
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1950
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1951
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1952
            }
1953
        }
1954

    
1955
        /* if still no information, we try to open the codec and to
1956
           decompress the frame. We try to avoid that in most cases as
1957
           it takes longer and uses more memory. For MPEG4, we need to
1958
           decompress for Quicktime. */
1959
        if (!has_codec_parameters(st->codec) /*&&
1960
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1961
             st->codec->codec_id == CODEC_ID_H264 ||
1962
             st->codec->codec_id == CODEC_ID_H263 ||
1963
             st->codec->codec_id == CODEC_ID_H261 ||
1964
             st->codec->codec_id == CODEC_ID_VORBIS ||
1965
             st->codec->codec_id == CODEC_ID_MJPEG ||
1966
             st->codec->codec_id == CODEC_ID_PNG ||
1967
             st->codec->codec_id == CODEC_ID_PAM ||
1968
             st->codec->codec_id == CODEC_ID_PGM ||
1969
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1970
             st->codec->codec_id == CODEC_ID_PBM ||
1971
             st->codec->codec_id == CODEC_ID_PPM ||
1972
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1973
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1974
            try_decode_frame(st, pkt->data, pkt->size);
1975

    
1976
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1977
            break;
1978
        }
1979
        count++;
1980
    }
1981

    
1982
    // close codecs which where opened in try_decode_frame()
1983
    for(i=0;i<ic->nb_streams;i++) {
1984
        st = ic->streams[i];
1985
        if(st->codec->codec)
1986
            avcodec_close(st->codec);
1987
    }
1988
    for(i=0;i<ic->nb_streams;i++) {
1989
        st = ic->streams[i];
1990
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1991
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1992
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1993

    
1994
            if(duration_count[i]
1995
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1996
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1997
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1998
                double best_error= 2*av_q2d(st->time_base);
1999
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2000

    
2001
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2002
                    double error= duration_error[i][j] * get_std_framerate(j);
2003
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2004
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2005
                    if(error < best_error){
2006
                        best_error= error;
2007
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2008
                    }
2009
                }
2010
            }
2011

    
2012
            if (!st->r_frame_rate.num){
2013
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2014
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2015
                    st->r_frame_rate.num = st->codec->time_base.den;
2016
                    st->r_frame_rate.den = st->codec->time_base.num;
2017
                }else{
2018
                    st->r_frame_rate.num = st->time_base.den;
2019
                    st->r_frame_rate.den = st->time_base.num;
2020
                }
2021
            }
2022
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2023
            if(!st->codec->bits_per_sample)
2024
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2025
        }
2026
    }
2027

    
2028
    av_estimate_timings(ic, old_offset);
2029
#if 0
2030
    /* correct DTS for b frame streams with no timestamps */
2031
    for(i=0;i<ic->nb_streams;i++) {
2032
        st = ic->streams[i];
2033
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2034
            if(b-frames){
2035
                ppktl = &ic->packet_buffer;
2036
                while(ppkt1){
2037
                    if(ppkt1->stream_index != i)
2038
                        continue;
2039
                    if(ppkt1->pkt->dts < 0)
2040
                        break;
2041
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2042
                        break;
2043
                    ppkt1->pkt->dts -= delta;
2044
                    ppkt1= ppkt1->next;
2045
                }
2046
                if(ppkt1)
2047
                    continue;
2048
                st->cur_dts -= delta;
2049
            }
2050
        }
2051
    }
2052
#endif
2053
    return ret;
2054
}
2055

    
2056
/*******************************************************/
2057

    
2058
/**
2059
 * start playing a network based stream (e.g. RTSP stream) at the
2060
 * current position
2061
 */
2062
int av_read_play(AVFormatContext *s)
2063
{
2064
    if (!s->iformat->read_play)
2065
        return AVERROR_NOTSUPP;
2066
    return s->iformat->read_play(s);
2067
}
2068

    
2069
/**
2070
 * Pause a network based stream (e.g. RTSP stream).
2071
 *
2072
 * Use av_read_play() to resume it.
2073
 */
2074
int av_read_pause(AVFormatContext *s)
2075
{
2076
    if (!s->iformat->read_pause)
2077
        return AVERROR_NOTSUPP;
2078
    return s->iformat->read_pause(s);
2079
}
2080

    
2081
/**
2082
 * Close a media file (but not its codecs).
2083
 *
2084
 * @param s media file handle
2085
 */
2086
void av_close_input_file(AVFormatContext *s)
2087
{
2088
    int i, must_open_file;
2089
    AVStream *st;
2090

    
2091
    /* free previous packet */
2092
    if (s->cur_st && s->cur_st->parser)
2093
        av_free_packet(&s->cur_pkt);
2094

    
2095
    if (s->iformat->read_close)
2096
        s->iformat->read_close(s);
2097
    for(i=0;i<s->nb_streams;i++) {
2098
        /* free all data in a stream component */
2099
        st = s->streams[i];
2100
        if (st->parser) {
2101
            av_parser_close(st->parser);
2102
        }
2103
        av_free(st->index_entries);
2104
        av_free(st->codec->extradata);
2105
        av_free(st->codec);
2106
        av_free(st);
2107
    }
2108
    flush_packet_queue(s);
2109
    must_open_file = 1;
2110
    if (s->iformat->flags & AVFMT_NOFILE) {
2111
        must_open_file = 0;
2112
    }
2113
    if (must_open_file) {
2114
        url_fclose(&s->pb);
2115
    }
2116
    av_freep(&s->priv_data);
2117
    av_free(s);
2118
}
2119

    
2120
/**
2121
 * Add a new stream to a media file.
2122
 *
2123
 * Can only be called in the read_header() function. If the flag
2124
 * AVFMTCTX_NOHEADER is in the format context, then new streams
2125
 * can be added in read_packet too.
2126
 *
2127
 * @param s media file handle
2128
 * @param id file format dependent stream id
2129
 */
2130
AVStream *av_new_stream(AVFormatContext *s, int id)
2131
{
2132
    AVStream *st;
2133
    int i;
2134

    
2135
    if (s->nb_streams >= MAX_STREAMS)
2136
        return NULL;
2137

    
2138
    st = av_mallocz(sizeof(AVStream));
2139
    if (!st)
2140
        return NULL;
2141

    
2142
    st->codec= avcodec_alloc_context();
2143
    if (s->iformat) {
2144
        /* no default bitrate if decoding */
2145
        st->codec->bit_rate = 0;
2146
    }
2147
    st->index = s->nb_streams;
2148
    st->id = id;
2149
    st->start_time = AV_NOPTS_VALUE;
2150
    st->duration = AV_NOPTS_VALUE;
2151
    st->cur_dts = AV_NOPTS_VALUE;
2152

    
2153
    /* default pts settings is MPEG like */
2154
    av_set_pts_info(st, 33, 1, 90000);
2155
    st->last_IP_pts = AV_NOPTS_VALUE;
2156
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2157
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2158

    
2159
    s->streams[s->nb_streams++] = st;
2160
    return st;
2161
}
2162

    
2163
/************************************************************/
2164
/* output media file */
2165

    
2166
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2167
{
2168
    int ret;
2169

    
2170
    if (s->oformat->priv_data_size > 0) {
2171
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2172
        if (!s->priv_data)
2173
            return AVERROR_NOMEM;
2174
    } else
2175
        s->priv_data = NULL;
2176

    
2177
    if (s->oformat->set_parameters) {
2178
        ret = s->oformat->set_parameters(s, ap);
2179
        if (ret < 0)
2180
            return ret;
2181
    }
2182
    return 0;
2183
}
2184

    
2185
/**
2186
 * allocate the stream private data and write the stream header to an
2187
 * output media file
2188
 *
2189
 * @param s media file handle
2190
 * @return 0 if OK. AVERROR_xxx if error.
2191
 */
2192
int av_write_header(AVFormatContext *s)
2193
{
2194
    int ret, i;
2195
    AVStream *st;
2196

    
2197
    // some sanity checks
2198
    for(i=0;i<s->nb_streams;i++) {
2199
        st = s->streams[i];
2200

    
2201
        switch (st->codec->codec_type) {
2202
        case CODEC_TYPE_AUDIO:
2203
            if(st->codec->sample_rate<=0){
2204
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2205
                return -1;
2206
            }
2207
            break;
2208
        case CODEC_TYPE_VIDEO:
2209
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2210
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2211
                return -1;
2212
            }
2213
            if(st->codec->width<=0 || st->codec->height<=0){
2214
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2215
                return -1;
2216
            }
2217
            break;
2218
        }
2219

    
2220
        if(s->oformat->codec_tag){
2221
            if(st->codec->codec_tag){
2222
                //FIXME
2223
                //check that tag + id is in the table
2224
                //if neither is in the table -> ok
2225
                //if tag is in the table with another id -> FAIL
2226
                //if id is in the table with another tag -> FAIL unless strict < ?
2227
            }else
2228
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2229
        }
2230
    }
2231

    
2232
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2233
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2234
        if (!s->priv_data)
2235
            return AVERROR_NOMEM;
2236
    }
2237

    
2238
    if(s->oformat->write_header){
2239
        ret = s->oformat->write_header(s);
2240
        if (ret < 0)
2241
            return ret;
2242
    }
2243

    
2244
    /* init PTS generation */
2245
    for(i=0;i<s->nb_streams;i++) {
2246
        int64_t den = AV_NOPTS_VALUE;
2247
        st = s->streams[i];
2248

    
2249
        switch (st->codec->codec_type) {
2250
        case CODEC_TYPE_AUDIO:
2251
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2252
            break;
2253
        case CODEC_TYPE_VIDEO:
2254
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2255
            break;
2256
        default:
2257
            break;
2258
        }
2259
        if (den != AV_NOPTS_VALUE) {
2260
            if (den <= 0)
2261
                return AVERROR_INVALIDDATA;
2262
            av_frac_init(&st->pts, 0, 0, den);
2263
        }
2264
    }
2265
    return 0;
2266
}
2267

    
2268
//FIXME merge with compute_pkt_fields
2269
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2270
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2271
    int num, den, frame_size, i;
2272

    
2273
//    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);
2274

    
2275
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2276
        return -1;*/
2277

    
2278
    /* duration field */
2279
    if (pkt->duration == 0) {
2280
        compute_frame_duration(&num, &den, st, NULL, pkt);
2281
        if (den && num) {
2282
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2283
        }
2284
    }
2285

    
2286
    //XXX/FIXME this is a temporary hack until all encoders output pts
2287
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2288
        pkt->dts=
2289
//        pkt->pts= st->cur_dts;
2290
        pkt->pts= st->pts.val;
2291
    }
2292

    
2293
    //calculate dts from pts
2294
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2295
        st->pts_buffer[0]= pkt->pts;
2296
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2297
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2298
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2299
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2300

    
2301
        pkt->dts= st->pts_buffer[0];
2302
    }
2303

    
2304
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2305
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2306
        return -1;
2307
    }
2308
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2309
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2310
        return -1;
2311
    }
2312

    
2313
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2314
    st->cur_dts= pkt->dts;
2315
    st->pts.val= pkt->dts;
2316

    
2317
    /* update pts */
2318
    switch (st->codec->codec_type) {
2319
    case CODEC_TYPE_AUDIO:
2320
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2321

    
2322
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2323
           but it would be better if we had the real timestamps from the encoder */
2324
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2325
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2326
        }
2327
        break;
2328
    case CODEC_TYPE_VIDEO:
2329
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2330
        break;
2331
    default:
2332
        break;
2333
    }
2334
    return 0;
2335
}
2336

    
2337
static void truncate_ts(AVStream *st, AVPacket *pkt){
2338
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2339

    
2340
//    if(pkt->dts < 0)
2341
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2342

    
2343
    if (pkt->pts != AV_NOPTS_VALUE)
2344
        pkt->pts &= pts_mask;
2345
    if (pkt->dts != AV_NOPTS_VALUE)
2346
        pkt->dts &= pts_mask;
2347
}
2348

    
2349
/**
2350
 * Write a packet to an output media file.
2351
 *
2352
 * The packet shall contain one audio or video frame.
2353
 * The packet must be correctly interleaved according to the container specification,
2354
 * if not then av_interleaved_write_frame must be used
2355
 *
2356
 * @param s media file handle
2357
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2358
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2359
 */
2360
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2361
{
2362
    int ret;
2363

    
2364
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2365
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2366
        return ret;
2367

    
2368
    truncate_ts(s->streams[pkt->stream_index], pkt);
2369

    
2370
    ret= s->oformat->write_packet(s, pkt);
2371
    if(!ret)
2372
        ret= url_ferror(&s->pb);
2373
    return ret;
2374
}
2375

    
2376
/**
2377
 * Interleave a packet per DTS in an output media file.
2378
 *
2379
 * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
2380
 * so they cannot be used after it, note calling av_free_packet() on them is still safe.
2381
 *
2382
 * @param s media file handle
2383
 * @param out the interleaved packet will be output here
2384
 * @param in the input packet
2385
 * @param flush 1 if no further packets are available as input and all
2386
 *              remaining packets should be output
2387
 * @return 1 if a packet was output, 0 if no packet could be output,
2388
 *         < 0 if an error occured
2389
 */
2390
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2391
    AVPacketList *pktl, **next_point, *this_pktl;
2392
    int stream_count=0;
2393
    int streams[MAX_STREAMS];
2394

    
2395
    if(pkt){
2396
        AVStream *st= s->streams[ pkt->stream_index];
2397

    
2398
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2399

    
2400
        this_pktl = av_mallocz(sizeof(AVPacketList));
2401
        this_pktl->pkt= *pkt;
2402
        if(pkt->destruct == av_destruct_packet)
2403
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2404
        else
2405
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2406

    
2407
        next_point = &s->packet_buffer;
2408
        while(*next_point){
2409
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2410
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2411
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2412
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2413
                break;
2414
            next_point= &(*next_point)->next;
2415
        }
2416
        this_pktl->next= *next_point;
2417
        *next_point= this_pktl;
2418
    }
2419

    
2420
    memset(streams, 0, sizeof(streams));
2421
    pktl= s->packet_buffer;
2422
    while(pktl){
2423
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2424
        if(streams[ pktl->pkt.stream_index ] == 0)
2425
            stream_count++;
2426
        streams[ pktl->pkt.stream_index ]++;
2427
        pktl= pktl->next;
2428
    }
2429

    
2430
    if(s->nb_streams == stream_count || (flush && stream_count)){
2431
        pktl= s->packet_buffer;
2432
        *out= pktl->pkt;
2433

    
2434
        s->packet_buffer= pktl->next;
2435
        av_freep(&pktl);
2436
        return 1;
2437
    }else{
2438
        av_init_packet(out);
2439
        return 0;
2440
    }
2441
}
2442

    
2443
/**
2444
 * Interleaves a AVPacket correctly so it can be muxed.
2445
 * @param out the interleaved packet will be output here
2446
 * @param in the input packet
2447
 * @param flush 1 if no further packets are available as input and all
2448
 *              remaining packets should be output
2449
 * @return 1 if a packet was output, 0 if no packet could be output,
2450
 *         < 0 if an error occured
2451
 */
2452
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2453
    if(s->oformat->interleave_packet)
2454
        return s->oformat->interleave_packet(s, out, in, flush);
2455
    else
2456
        return av_interleave_packet_per_dts(s, out, in, flush);
2457
}
2458

    
2459
/**
2460
 * Writes a packet to an output media file ensuring correct interleaving.
2461
 *
2462
 * The packet must contain one audio or video frame.
2463
 * If the packets are already correctly interleaved the application should
2464
 * call av_write_frame() instead as its slightly faster, its also important
2465
 * to keep in mind that completly non interleaved input will need huge amounts
2466
 * of memory to interleave with this, so its prefereable to interleave at the
2467
 * demuxer level
2468
 *
2469
 * @param s media file handle
2470
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2471
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
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
/**
2507
 * @brief Write the stream trailer to an output media file and
2508
 *        free the file private data.
2509
 *
2510
 * @param s media file handle
2511
 * @return 0 if OK. AVERROR_xxx if error.
2512
 */
2513
int av_write_trailer(AVFormatContext *s)
2514
{
2515
    int ret, i;
2516

    
2517
    for(;;){
2518
        AVPacket pkt;
2519
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2520
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2521
            goto fail;
2522
        if(!ret)
2523
            break;
2524

    
2525
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2526
        ret= s->oformat->write_packet(s, &pkt);
2527

    
2528
        av_free_packet(&pkt);
2529

    
2530
        if(ret<0)
2531
            goto fail;
2532
        if(url_ferror(&s->pb))
2533
            goto fail;
2534
    }
2535

    
2536
    if(s->oformat->write_trailer)
2537
        ret = s->oformat->write_trailer(s);
2538
fail:
2539
    if(ret == 0)
2540
       ret=url_ferror(&s->pb);
2541
    for(i=0;i<s->nb_streams;i++)
2542
        av_freep(&s->streams[i]->priv_data);
2543
    av_freep(&s->priv_data);
2544
    return ret;
2545
}
2546

    
2547
/* "user interface" functions */
2548

    
2549
void dump_format(AVFormatContext *ic,
2550
                 int index,
2551
                 const char *url,
2552
                 int is_output)
2553
{
2554
    int i, flags;
2555
    char buf[256];
2556

    
2557
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2558
            is_output ? "Output" : "Input",
2559
            index,
2560
            is_output ? ic->oformat->name : ic->iformat->name,
2561
            is_output ? "to" : "from", url);
2562
    if (!is_output) {
2563
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2564
        if (ic->duration != AV_NOPTS_VALUE) {
2565
            int hours, mins, secs, us;
2566
            secs = ic->duration / AV_TIME_BASE;
2567
            us = ic->duration % AV_TIME_BASE;
2568
            mins = secs / 60;
2569
            secs %= 60;
2570
            hours = mins / 60;
2571
            mins %= 60;
2572
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2573
                   (10 * us) / AV_TIME_BASE);
2574
        } else {
2575
            av_log(NULL, AV_LOG_INFO, "N/A");
2576
        }
2577
        if (ic->start_time != AV_NOPTS_VALUE) {
2578
            int secs, us;
2579
            av_log(NULL, AV_LOG_INFO, ", start: ");
2580
            secs = ic->start_time / AV_TIME_BASE;
2581
            us = ic->start_time % AV_TIME_BASE;
2582
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2583
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2584
        }
2585
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2586
        if (ic->bit_rate) {
2587
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2588
        } else {
2589
            av_log(NULL, AV_LOG_INFO, "N/A");
2590
        }
2591
        av_log(NULL, AV_LOG_INFO, "\n");
2592
    }
2593
    for(i=0;i<ic->nb_streams;i++) {
2594
        AVStream *st = ic->streams[i];
2595
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2596
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2597
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2598
        /* the pid is an important information, so we display it */
2599
        /* XXX: add a generic system */
2600
        if (is_output)
2601
            flags = ic->oformat->flags;
2602
        else
2603
            flags = ic->iformat->flags;
2604
        if (flags & AVFMT_SHOW_IDS) {
2605
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2606
        }
2607
        if (strlen(st->language) > 0) {
2608
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2609
        }
2610
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2611
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2612
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2613
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2614
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2615
/*            else if(st->time_base.den && st->time_base.num)
2616
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2617
            else
2618
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2619
        }
2620
        av_log(NULL, AV_LOG_INFO, "\n");
2621
    }
2622
}
2623

    
2624
typedef struct {
2625
    const char *abv;
2626
    int width, height;
2627
    int frame_rate, frame_rate_base;
2628
} AbvEntry;
2629

    
2630
static AbvEntry frame_abvs[] = {
2631
    { "ntsc",      720, 480, 30000, 1001 },
2632
    { "pal",       720, 576,    25,    1 },
2633
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2634
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2635
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2636
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2637
    { "film",      352, 240,    24,    1 },
2638
    { "ntsc-film", 352, 240, 24000, 1001 },
2639
    { "sqcif",     128,  96,     0,    0 },
2640
    { "qcif",      176, 144,     0,    0 },
2641
    { "cif",       352, 288,     0,    0 },
2642
    { "4cif",      704, 576,     0,    0 },
2643
};
2644

    
2645
/**
2646
 * parses width and height out of string str.
2647
 */
2648
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2649
{
2650
    int i;
2651
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2652
    const char *p;
2653
    int frame_width = 0, frame_height = 0;
2654

    
2655
    for(i=0;i<n;i++) {
2656
        if (!strcmp(frame_abvs[i].abv, str)) {
2657
            frame_width = frame_abvs[i].width;
2658
            frame_height = frame_abvs[i].height;
2659
            break;
2660
        }
2661
    }
2662
    if (i == n) {
2663
        p = str;
2664
        frame_width = strtol(p, (char **)&p, 10);
2665
        if (*p)
2666
            p++;
2667
        frame_height = strtol(p, (char **)&p, 10);
2668
    }
2669
    if (frame_width <= 0 || frame_height <= 0)
2670
        return -1;
2671
    *width_ptr = frame_width;
2672
    *height_ptr = frame_height;
2673
    return 0;
2674
}
2675

    
2676
/**
2677
 * Converts frame rate from string to a fraction.
2678
 *
2679
 * First we try to get an exact integer or fractional frame rate.
2680
 * If this fails we convert the frame rate to a double and return
2681
 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2682
 */
2683
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2684
{
2685
    int i;
2686
    char* cp;
2687

    
2688
    /* First, we check our abbreviation table */
2689
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2690
         if (!strcmp(frame_abvs[i].abv, arg)) {
2691
             *frame_rate = frame_abvs[i].frame_rate;
2692
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2693
             return 0;
2694
         }
2695

    
2696
    /* Then, we try to parse it as fraction */
2697
    cp = strchr(arg, '/');
2698
    if (!cp)
2699
        cp = strchr(arg, ':');
2700
    if (cp) {
2701
        char* cpp;
2702
        *frame_rate = strtol(arg, &cpp, 10);
2703
        if (cpp != arg || cpp == cp)
2704
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2705
        else
2706
           *frame_rate = 0;
2707
    }
2708
    else {
2709
        /* Finally we give up and parse it as double */
2710
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2711
        *frame_rate_base = time_base.den;
2712
        *frame_rate = time_base.num;
2713
    }
2714
    if (!*frame_rate || !*frame_rate_base)
2715
        return -1;
2716
    else
2717
        return 0;
2718
}
2719

    
2720
/**
2721
 * Converts date string to number of seconds since Jan 1st, 1970.
2722
 *
2723
 * @code
2724
 * Syntax:
2725
 * - If not a duration:
2726
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2727
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2728
 * Return the date in micro seconds since 1970
2729
 *
2730
 * - If a duration:
2731
 *  HH[:MM[:SS[.m...]]]
2732
 *  S+[.m...]
2733
 * @endcode
2734
 */
2735
#ifndef CONFIG_WINCE
2736
int64_t parse_date(const char *datestr, int duration)
2737
{
2738
    const char *p;
2739
    int64_t t;
2740
    struct tm dt;
2741
    int i;
2742
    static const char *date_fmt[] = {
2743
        "%Y-%m-%d",
2744
        "%Y%m%d",
2745
    };
2746
    static const char *time_fmt[] = {
2747
        "%H:%M:%S",
2748
        "%H%M%S",
2749
    };
2750
    const char *q;
2751
    int is_utc, len;
2752
    char lastch;
2753
    int negative = 0;
2754

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

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

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

    
2767
    p = datestr;
2768
    q = NULL;
2769
    if (!duration) {
2770
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2771
            q = small_strptime(p, date_fmt[i], &dt);
2772
            if (q) {
2773
                break;
2774
            }
2775
        }
2776

    
2777
        if (!q) {
2778
            if (is_utc) {
2779
                dt = *gmtime(&now);
2780
            } else {
2781
                dt = *localtime(&now);
2782
            }
2783
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2784
        } else {
2785
            p = q;
2786
        }
2787

    
2788
        if (*p == 'T' || *p == 't' || *p == ' ')
2789
            p++;
2790

    
2791
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2792
            q = small_strptime(p, time_fmt[i], &dt);
2793
            if (q) {
2794
                break;
2795
            }
2796
        }
2797
    } else {
2798
        if (p[0] == '-') {
2799
            negative = 1;
2800
            ++p;
2801
        }
2802
        q = small_strptime(p, time_fmt[0], &dt);
2803
        if (!q) {
2804
            dt.tm_sec = strtol(p, (char **)&q, 10);
2805
            dt.tm_min = 0;
2806
            dt.tm_hour = 0;
2807
        }
2808
    }
2809

    
2810
    /* Now we have all the fields that we can get */
2811
    if (!q) {
2812
        if (duration)
2813
            return 0;
2814
        else
2815
            return now * INT64_C(1000000);
2816
    }
2817

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

    
2829
    t *= 1000000;
2830

    
2831
    if (*q == '.') {
2832
        int val, n;
2833
        q++;
2834
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2835
            if (!isdigit(*q))
2836
                break;
2837
            val += n * (*q - '0');
2838
        }
2839
        t += val;
2840
    }
2841
    return negative ? -t : t;
2842
}
2843
#endif /* CONFIG_WINCE */
2844

    
2845
/**
2846
 * Attempts to find a specific tag in a URL.
2847
 *
2848
 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2849
 * Return 1 if found.
2850
 */
2851
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2852
{
2853
    const char *p;
2854
    char tag[128], *q;
2855

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

    
2890
/**
2891
 * Returns in 'buf' the path with '%d' replaced by number.
2892

2893
 * Also handles the '%0nd' format where 'n' is the total number
2894
 * of digits and '%%'.
2895
 *
2896
 * @param buf destination buffer
2897
 * @param buf_size destination buffer size
2898
 * @param path numbered sequence string
2899
 * @number frame number
2900
 * @return 0 if OK, -1 if format error.
2901
 */
2902
int av_get_frame_filename(char *buf, int buf_size,
2903
                          const char *path, int number)
2904
{
2905
    const char *p;
2906
    char *q, buf1[20], c;
2907
    int nd, len, percentd_found;
2908

    
2909
    q = buf;
2910
    p = path;
2911
    percentd_found = 0;
2912
    for(;;) {
2913
        c = *p++;
2914
        if (c == '\0')
2915
            break;
2916
        if (c == '%') {
2917
            do {
2918
                nd = 0;
2919
                while (isdigit(*p)) {
2920
                    nd = nd * 10 + *p++ - '0';
2921
                }
2922
                c = *p++;
2923
            } while (isdigit(c));
2924

    
2925
            switch(c) {
2926
            case '%':
2927
                goto addchar;
2928
            case 'd':
2929
                if (percentd_found)
2930
                    goto fail;
2931
                percentd_found = 1;
2932
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2933
                len = strlen(buf1);
2934
                if ((q - buf + len) > buf_size - 1)
2935
                    goto fail;
2936
                memcpy(q, buf1, len);
2937
                q += len;
2938
                break;
2939
            default:
2940
                goto fail;
2941
            }
2942
        } else {
2943
        addchar:
2944
            if ((q - buf) < buf_size - 1)
2945
                *q++ = c;
2946
        }
2947
    }
2948
    if (!percentd_found)
2949
        goto fail;
2950
    *q = '\0';
2951
    return 0;
2952
 fail:
2953
    *q = '\0';
2954
    return -1;
2955
}
2956

    
2957
/**
2958
 * Print  nice hexa dump of a buffer
2959
 * @param f stream for output
2960
 * @param buf buffer
2961
 * @param size buffer size
2962
 */
2963
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2964
{
2965
    int len, i, j, c;
2966

    
2967
    for(i=0;i<size;i+=16) {
2968
        len = size - i;
2969
        if (len > 16)
2970
            len = 16;
2971
        fprintf(f, "%08x ", i);
2972
        for(j=0;j<16;j++) {
2973
            if (j < len)
2974
                fprintf(f, " %02x", buf[i+j]);
2975
            else
2976
                fprintf(f, "   ");
2977
        }
2978
        fprintf(f, " ");
2979
        for(j=0;j<len;j++) {
2980
            c = buf[i+j];
2981
            if (c < ' ' || c > '~')
2982
                c = '.';
2983
            fprintf(f, "%c", c);
2984
        }
2985
        fprintf(f, "\n");
2986
    }
2987
}
2988

    
2989
/**
2990
 * Print on 'f' a nice dump of a packet
2991
 * @param f stream for output
2992
 * @param pkt packet to dump
2993
 * @param dump_payload true if the payload must be displayed too
2994
 */
2995
 //FIXME needs to know the time_base
2996
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2997
{
2998
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2999
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3000
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3001
    /* DTS is _always_ valid after av_read_frame() */
3002
    fprintf(f, "  dts=");
3003
    if (pkt->dts == AV_NOPTS_VALUE)
3004
        fprintf(f, "N/A");
3005
    else
3006
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3007
    /* PTS may be not known if B frames are present */
3008
    fprintf(f, "  pts=");
3009
    if (pkt->pts == AV_NOPTS_VALUE)
3010
        fprintf(f, "N/A");
3011
    else
3012
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3013
    fprintf(f, "\n");
3014
    fprintf(f, "  size=%d\n", pkt->size);
3015
    if (dump_payload)
3016
        av_hex_dump(f, pkt->data, pkt->size);
3017
}
3018

    
3019
void url_split(char *proto, int proto_size,
3020
               char *authorization, int authorization_size,
3021
               char *hostname, int hostname_size,
3022
               int *port_ptr,
3023
               char *path, int path_size,
3024
               const char *url)
3025
{
3026
    const char *p;
3027
    char *q;
3028
    int port;
3029

    
3030
    port = -1;
3031

    
3032
    p = url;
3033
    q = proto;
3034
    while (*p != ':' && *p != '\0') {
3035
        if ((q - proto) < proto_size - 1)
3036
            *q++ = *p;
3037
        p++;
3038
    }
3039
    if (proto_size > 0)
3040
        *q = '\0';
3041
    if (authorization_size > 0)
3042
        authorization[0] = '\0';
3043
    if (*p == '\0') {
3044
        if (proto_size > 0)
3045
            proto[0] = '\0';
3046
        if (hostname_size > 0)
3047
            hostname[0] = '\0';
3048
        p = url;
3049
    } else {
3050
        char *at,*slash; // PETR: position of '@' character and '/' character
3051

    
3052
        p++;
3053
        if (*p == '/')
3054
            p++;
3055
        if (*p == '/')
3056
            p++;
3057
        at = strchr(p,'@'); // PETR: get the position of '@'
3058
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
3059
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3060

    
3061
        q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
3062

    
3063
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3064
            if (*p == '@') {    // PETR: passed '@'
3065
              if (authorization_size > 0)
3066
                  *q = '\0';
3067
              q = hostname;
3068
              at = NULL;
3069
            } else if (!at) {   // PETR: hostname
3070
              if ((q - hostname) < hostname_size - 1)
3071
                  *q++ = *p;
3072
            } else {
3073
              if ((q - authorization) < authorization_size - 1)
3074
                *q++ = *p;
3075
            }
3076
            p++;
3077
        }
3078
        if (hostname_size > 0)
3079
            *q = '\0';
3080
        if (*p == ':') {
3081
            p++;
3082
            port = strtoul(p, (char **)&p, 10);
3083
        }
3084
    }
3085
    if (port_ptr)
3086
        *port_ptr = port;
3087
    pstrcpy(path, path_size, p);
3088
}
3089

    
3090
/**
3091
 * Set the pts for a given stream.
3092
 *
3093
 * @param s stream
3094
 * @param pts_wrap_bits number of bits effectively used by the pts
3095
 *        (used for wrap control, 33 is the value for MPEG)
3096
 * @param pts_num numerator to convert to seconds (MPEG: 1)
3097
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3098
 */
3099
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3100
                     int pts_num, int pts_den)
3101
{
3102
    s->pts_wrap_bits = pts_wrap_bits;
3103
    s->time_base.num = pts_num;
3104
    s->time_base.den = pts_den;
3105
}
3106

    
3107
/* fraction handling */
3108

    
3109
/**
3110
 * f = val + (num / den) + 0.5.
3111
 *
3112
 * 'num' is normalized so that it is such as 0 <= num < den.
3113
 *
3114
 * @param f fractional number
3115
 * @param val integer value
3116
 * @param num must be >= 0
3117
 * @param den must be >= 1
3118
 */
3119
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3120
{
3121
    num += (den >> 1);
3122
    if (num >= den) {
3123
        val += num / den;
3124
        num = num % den;
3125
    }
3126
    f->val = val;
3127
    f->num = num;
3128
    f->den = den;
3129
}
3130

    
3131
/**
3132
 * Fractionnal addition to f: f = f + (incr / f->den).
3133
 *
3134
 * @param f fractional number
3135
 * @param incr increment, can be positive or negative
3136
 */
3137
static void av_frac_add(AVFrac *f, int64_t incr)
3138
{
3139
    int64_t num, den;
3140

    
3141
    num = f->num + incr;
3142
    den = f->den;
3143
    if (num < 0) {
3144
        f->val += num / den;
3145
        num = num % den;
3146
        if (num < 0) {
3147
            num += den;
3148
            f->val--;
3149
        }
3150
    } else if (num >= den) {
3151
        f->val += num / den;
3152
        num = num % den;
3153
    }
3154
    f->num = num;
3155
}