Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ ca75a923

History | View | Annotate | Download (90.8 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 "opt.h"
23
#include "avstring.h"
24
#include "riff.h"
25
#include <sys/time.h>
26
#include <time.h>
27

    
28
#undef NDEBUG
29
#include <assert.h>
30

    
31
/**
32
 * @file libavformat/utils.c
33
 * Various utility functions for using ffmpeg library.
34
 */
35

    
36
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37
static void av_frac_add(AVFrac *f, int64_t incr);
38

    
39
/** head of registered input format linked list. */
40
AVInputFormat *first_iformat = NULL;
41
/** head of registered output format linked list. */
42
AVOutputFormat *first_oformat = NULL;
43

    
44
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
45
{
46
    if(f) return f->next;
47
    else  return first_iformat;
48
}
49

    
50
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
51
{
52
    if(f) return f->next;
53
    else  return first_oformat;
54
}
55

    
56
void av_register_input_format(AVInputFormat *format)
57
{
58
    AVInputFormat **p;
59
    p = &first_iformat;
60
    while (*p != NULL) p = &(*p)->next;
61
    *p = format;
62
    format->next = NULL;
63
}
64

    
65
void av_register_output_format(AVOutputFormat *format)
66
{
67
    AVOutputFormat **p;
68
    p = &first_oformat;
69
    while (*p != NULL) p = &(*p)->next;
70
    *p = format;
71
    format->next = NULL;
72
}
73

    
74
int match_ext(const char *filename, const char *extensions)
75
{
76
    const char *ext, *p;
77
    char ext1[32], *q;
78

    
79
    if(!filename)
80
        return 0;
81

    
82
    ext = strrchr(filename, '.');
83
    if (ext) {
84
        ext++;
85
        p = extensions;
86
        for(;;) {
87
            q = ext1;
88
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
89
                *q++ = *p++;
90
            *q = '\0';
91
            if (!strcasecmp(ext1, ext))
92
                return 1;
93
            if (*p == '\0')
94
                break;
95
            p++;
96
        }
97
    }
98
    return 0;
99
}
100

    
101
AVOutputFormat *guess_format(const char *short_name, const char *filename,
102
                             const char *mime_type)
103
{
104
    AVOutputFormat *fmt, *fmt_found;
105
    int score_max, score;
106

    
107
    /* specific test for image sequences */
108
#ifdef CONFIG_IMAGE2_MUXER
109
    if (!short_name && filename &&
110
        av_filename_number_test(filename) &&
111
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
112
        return guess_format("image2", NULL, NULL);
113
    }
114
#endif
115
    /* find the proper file type */
116
    fmt_found = NULL;
117
    score_max = 0;
118
    fmt = first_oformat;
119
    while (fmt != NULL) {
120
        score = 0;
121
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
122
            score += 100;
123
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
124
            score += 10;
125
        if (filename && fmt->extensions &&
126
            match_ext(filename, fmt->extensions)) {
127
            score += 5;
128
        }
129
        if (score > score_max) {
130
            score_max = score;
131
            fmt_found = fmt;
132
        }
133
        fmt = fmt->next;
134
    }
135
    return fmt_found;
136
}
137

    
138
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
139
                             const char *mime_type)
140
{
141
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
142

    
143
    if (fmt) {
144
        AVOutputFormat *stream_fmt;
145
        char stream_format_name[64];
146

    
147
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
148
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
149

    
150
        if (stream_fmt)
151
            fmt = stream_fmt;
152
    }
153

    
154
    return fmt;
155
}
156

    
157
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
158
                            const char *filename, const char *mime_type, enum CodecType type){
159
    if(type == CODEC_TYPE_VIDEO){
160
        enum CodecID codec_id= CODEC_ID_NONE;
161

    
162
#ifdef CONFIG_IMAGE2_MUXER
163
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
164
            codec_id= av_guess_image2_codec(filename);
165
        }
166
#endif
167
        if(codec_id == CODEC_ID_NONE)
168
            codec_id= fmt->video_codec;
169
        return codec_id;
170
    }else if(type == CODEC_TYPE_AUDIO)
171
        return fmt->audio_codec;
172
    else
173
        return CODEC_ID_NONE;
174
}
175

    
176
AVInputFormat *av_find_input_format(const char *short_name)
177
{
178
    AVInputFormat *fmt;
179
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
180
        if (!strcmp(fmt->name, short_name))
181
            return fmt;
182
    }
183
    return NULL;
184
}
185

    
186
/* memory handling */
187

    
188
void av_destruct_packet(AVPacket *pkt)
189
{
190
    av_free(pkt->data);
191
    pkt->data = NULL; pkt->size = 0;
192
}
193

    
194
void av_init_packet(AVPacket *pkt)
195
{
196
    pkt->pts   = AV_NOPTS_VALUE;
197
    pkt->dts   = AV_NOPTS_VALUE;
198
    pkt->pos   = -1;
199
    pkt->duration = 0;
200
    pkt->flags = 0;
201
    pkt->stream_index = 0;
202
    pkt->destruct= av_destruct_packet_nofree;
203
}
204

    
205
int av_new_packet(AVPacket *pkt, int size)
206
{
207
    uint8_t *data;
208
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
209
        return AVERROR(ENOMEM);
210
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
211
    if (!data)
212
        return AVERROR(ENOMEM);
213
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
214

    
215
    av_init_packet(pkt);
216
    pkt->data = data;
217
    pkt->size = size;
218
    pkt->destruct = av_destruct_packet;
219
    return 0;
220
}
221

    
222
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
223
{
224
    int ret= av_new_packet(pkt, size);
225

    
226
    if(ret<0)
227
        return ret;
228

    
229
    pkt->pos= url_ftell(s);
230

    
231
    ret= get_buffer(s, pkt->data, size);
232
    if(ret<=0)
233
        av_free_packet(pkt);
234
    else
235
        pkt->size= ret;
236

    
237
    return ret;
238
}
239

    
240
int av_dup_packet(AVPacket *pkt)
241
{
242
    if (pkt->destruct != av_destruct_packet) {
243
        uint8_t *data;
244
        /* we duplicate the packet and don't forget to put the padding
245
           again */
246
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
247
            return AVERROR(ENOMEM);
248
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
249
        if (!data) {
250
            return AVERROR(ENOMEM);
251
        }
252
        memcpy(data, pkt->data, pkt->size);
253
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
254
        pkt->data = data;
255
        pkt->destruct = av_destruct_packet;
256
    }
257
    return 0;
258
}
259

    
260
int av_filename_number_test(const char *filename)
261
{
262
    char buf[1024];
263
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
264
}
265

    
266
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
267
{
268
    AVInputFormat *fmt1, *fmt;
269
    int score;
270

    
271
    fmt = NULL;
272
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
273
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
274
            continue;
275
        score = 0;
276
        if (fmt1->read_probe) {
277
            score = fmt1->read_probe(pd);
278
        } else if (fmt1->extensions) {
279
            if (match_ext(pd->filename, fmt1->extensions)) {
280
                score = 50;
281
            }
282
        }
283
        if (score > *score_max) {
284
            *score_max = score;
285
            fmt = fmt1;
286
        }
287
    }
288
    return fmt;
289
}
290

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

    
296
/************************************************************/
297
/* input media file */
298

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

    
310
#define OFFSET(x) offsetof(AVFormatContext,x)
311
#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
312
//these names are too long to be readable
313
#define E AV_OPT_FLAG_ENCODING_PARAM
314
#define D AV_OPT_FLAG_DECODING_PARAM
315

    
316
static const AVOption options[]={
317
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
318
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
319
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
320
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
321
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
322
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
323
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
324
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
325
{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
326
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
327
{NULL},
328
};
329

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

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

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

    
340
    s->av_class = &av_format_context_class;
341

    
342
    av_opt_set_defaults(s);
343
}
344

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
490
}
491

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

    
494
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
495
{
496
    av_init_packet(pkt);
497
    return s->iformat->read_packet(s, pkt);
498
}
499

    
500
/**********************************************************/
501

    
502
/**
503
 * Get the number of samples of an audio frame. Return (-1) if error.
504
 */
505
static int get_audio_frame_size(AVCodecContext *enc, int size)
506
{
507
    int frame_size;
508

    
509
    if (enc->frame_size <= 1) {
510
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
511

    
512
        if (bits_per_sample) {
513
            if (enc->channels == 0)
514
                return -1;
515
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
516
        } else {
517
            /* used for example by ADPCM codecs */
518
            if (enc->bit_rate == 0)
519
                return -1;
520
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
521
        }
522
    } else {
523
        frame_size = enc->frame_size;
524
    }
525
    return frame_size;
526
}
527

    
528

    
529
/**
530
 * Return the frame duration in seconds, return 0 if not available.
531
 */
532
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
533
                                   AVCodecParserContext *pc, AVPacket *pkt)
534
{
535
    int frame_size;
536

    
537
    *pnum = 0;
538
    *pden = 0;
539
    switch(st->codec->codec_type) {
540
    case CODEC_TYPE_VIDEO:
541
        if(st->time_base.num*1000LL > st->time_base.den){
542
            *pnum = st->time_base.num;
543
            *pden = st->time_base.den;
544
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
545
            *pnum = st->codec->time_base.num;
546
            *pden = st->codec->time_base.den;
547
            if (pc && pc->repeat_pict) {
548
                *pden *= 2;
549
                *pnum = (*pnum) * (2 + pc->repeat_pict);
550
            }
551
        }
552
        break;
553
    case CODEC_TYPE_AUDIO:
554
        frame_size = get_audio_frame_size(st->codec, pkt->size);
555
        if (frame_size < 0)
556
            break;
557
        *pnum = frame_size;
558
        *pden = st->codec->sample_rate;
559
        break;
560
    default:
561
        break;
562
    }
563
}
564

    
565
static int is_intra_only(AVCodecContext *enc){
566
    if(enc->codec_type == CODEC_TYPE_AUDIO){
567
        return 1;
568
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
569
        switch(enc->codec_id){
570
        case CODEC_ID_MJPEG:
571
        case CODEC_ID_MJPEGB:
572
        case CODEC_ID_LJPEG:
573
        case CODEC_ID_RAWVIDEO:
574
        case CODEC_ID_DVVIDEO:
575
        case CODEC_ID_HUFFYUV:
576
        case CODEC_ID_FFVHUFF:
577
        case CODEC_ID_ASV1:
578
        case CODEC_ID_ASV2:
579
        case CODEC_ID_VCR1:
580
            return 1;
581
        default: break;
582
        }
583
    }
584
    return 0;
585
}
586

    
587
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
588
                                      int64_t dts, int64_t pts)
589
{
590
    AVStream *st= s->streams[stream_index];
591
    AVPacketList *pktl= s->packet_buffer;
592

    
593
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
594
        return;
595

    
596
    st->first_dts= dts - st->cur_dts;
597
    st->cur_dts= dts;
598

    
599
    for(; pktl; pktl= pktl->next){
600
        if(pktl->pkt.stream_index != stream_index)
601
            continue;
602
        //FIXME think more about this check
603
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
604
            pktl->pkt.pts += st->first_dts;
605

    
606
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
607
            pktl->pkt.dts += st->first_dts;
608

    
609
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
610
            st->start_time= pktl->pkt.pts;
611
    }
612
    if (st->start_time == AV_NOPTS_VALUE)
613
        st->start_time = pts;
614
}
615

    
616
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
617
                               AVCodecParserContext *pc, AVPacket *pkt)
618
{
619
    int num, den, presentation_delayed, delay, i;
620
    int64_t offset;
621

    
622
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
623
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
624
        pkt->dts -= 1LL<<st->pts_wrap_bits;
625
    }
626

    
627
    if (pkt->duration == 0) {
628
        compute_frame_duration(&num, &den, st, pc, pkt);
629
        if (den && num) {
630
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
631
        }
632
    }
633

    
634
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
635
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
636
        /* this will estimate bitrate based on this frame's duration and size */
637
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
638
        if(pkt->pts != AV_NOPTS_VALUE)
639
            pkt->pts += offset;
640
        if(pkt->dts != AV_NOPTS_VALUE)
641
            pkt->dts += offset;
642
    }
643

    
644
    /* do we have a video B frame ? */
645
    delay= st->codec->has_b_frames;
646
    presentation_delayed = 0;
647
    /* XXX: need has_b_frame, but cannot get it if the codec is
648
        not initialized */
649
    if (delay &&
650
        pc && pc->pict_type != FF_B_TYPE)
651
        presentation_delayed = 1;
652
    /* This may be redundant, but it should not hurt. */
653
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
654
        presentation_delayed = 1;
655

    
656
    if(st->cur_dts == AV_NOPTS_VALUE){
657
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
658
    }
659

    
660
//    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);
661
    /* interpolate PTS and DTS if they are not present */
662
    if(delay <=1){
663
        if (presentation_delayed) {
664
            /* DTS = decompression time stamp */
665
            /* PTS = presentation time stamp */
666
            if (pkt->dts == AV_NOPTS_VALUE)
667
                pkt->dts = st->last_IP_pts;
668
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
669
            if (pkt->dts == AV_NOPTS_VALUE)
670
                pkt->dts = st->cur_dts;
671

    
672
            /* this is tricky: the dts must be incremented by the duration
673
            of the frame we are displaying, i.e. the last I or P frame */
674
            if (st->last_IP_duration == 0)
675
                st->last_IP_duration = pkt->duration;
676
            st->cur_dts = pkt->dts + st->last_IP_duration;
677
            st->last_IP_duration  = pkt->duration;
678
            st->last_IP_pts= pkt->pts;
679
            /* cannot compute PTS if not present (we can compute it only
680
            by knowing the futur */
681
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
682
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
683
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
684
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
685
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
686
                    pkt->pts += pkt->duration;
687
    //                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);
688
                }
689
            }
690

    
691
            /* presentation is not delayed : PTS and DTS are the same */
692
            if(pkt->pts == AV_NOPTS_VALUE)
693
                pkt->pts = pkt->dts;
694
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
695
            if(pkt->pts == AV_NOPTS_VALUE)
696
                pkt->pts = st->cur_dts;
697
            pkt->dts = pkt->pts;
698
            st->cur_dts = pkt->pts + pkt->duration;
699
        }
700
    }
701

    
702
    if(pkt->pts != AV_NOPTS_VALUE){
703
        st->pts_buffer[0]= pkt->pts;
704
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
705
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
706
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
707
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
708
        if(pkt->dts == AV_NOPTS_VALUE)
709
            pkt->dts= st->pts_buffer[0];
710
        if(delay>1){
711
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
712
        }
713
        if(pkt->dts > st->cur_dts)
714
            st->cur_dts = pkt->dts;
715
    }
716

    
717
//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
718

    
719
    /* update flags */
720
    if(is_intra_only(st->codec))
721
        pkt->flags |= PKT_FLAG_KEY;
722
    else if (pc) {
723
        pkt->flags = 0;
724
        /* key frame computation */
725
            if (pc->pict_type == FF_I_TYPE)
726
                pkt->flags |= PKT_FLAG_KEY;
727
    }
728
}
729

    
730
void av_destruct_packet_nofree(AVPacket *pkt)
731
{
732
    pkt->data = NULL; pkt->size = 0;
733
}
734

    
735
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
736
{
737
    AVStream *st;
738
    int len, ret, i;
739

    
740
    av_init_packet(pkt);
741

    
742
    for(;;) {
743
        /* select current input stream component */
744
        st = s->cur_st;
745
        if (st) {
746
            if (!st->need_parsing || !st->parser) {
747
                /* no parsing needed: we just output the packet as is */
748
                /* raw data support */
749
                *pkt = s->cur_pkt;
750
                compute_pkt_fields(s, st, NULL, pkt);
751
                s->cur_st = NULL;
752
                break;
753
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
754
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
755
                                      s->cur_ptr, s->cur_len,
756
                                      s->cur_pkt.pts, s->cur_pkt.dts);
757
                s->cur_pkt.pts = AV_NOPTS_VALUE;
758
                s->cur_pkt.dts = AV_NOPTS_VALUE;
759
                /* increment read pointer */
760
                s->cur_ptr += len;
761
                s->cur_len -= len;
762

    
763
                /* return packet if any */
764
                if (pkt->size) {
765
                got_packet:
766
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
767
                    pkt->duration = 0;
768
                    pkt->stream_index = st->index;
769
                    pkt->pts = st->parser->pts;
770
                    pkt->dts = st->parser->dts;
771
                    pkt->destruct = av_destruct_packet_nofree;
772
                    compute_pkt_fields(s, st, st->parser, pkt);
773

    
774
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
775
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
776
                                           0, 0, AVINDEX_KEYFRAME);
777
                    }
778

    
779
                    break;
780
                }
781
            } else {
782
                /* free packet */
783
                av_free_packet(&s->cur_pkt);
784
                s->cur_st = NULL;
785
            }
786
        } else {
787
            /* read next packet */
788
            ret = av_read_packet(s, &s->cur_pkt);
789
            if (ret < 0) {
790
                if (ret == AVERROR(EAGAIN))
791
                    return ret;
792
                /* return the last frames, if any */
793
                for(i = 0; i < s->nb_streams; i++) {
794
                    st = s->streams[i];
795
                    if (st->parser && st->need_parsing) {
796
                        av_parser_parse(st->parser, st->codec,
797
                                        &pkt->data, &pkt->size,
798
                                        NULL, 0,
799
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
800
                        if (pkt->size)
801
                            goto got_packet;
802
                    }
803
                }
804
                /* no more packets: really terminates parsing */
805
                return ret;
806
            }
807

    
808
            st = s->streams[s->cur_pkt.stream_index];
809
            if(st->codec->debug & FF_DEBUG_PTS)
810
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
811
                    s->cur_pkt.stream_index,
812
                    s->cur_pkt.pts,
813
                    s->cur_pkt.dts,
814
                    s->cur_pkt.size);
815

    
816
            s->cur_st = st;
817
            s->cur_ptr = s->cur_pkt.data;
818
            s->cur_len = s->cur_pkt.size;
819
            if (st->need_parsing && !st->parser) {
820
                st->parser = av_parser_init(st->codec->codec_id);
821
                if (!st->parser) {
822
                    /* no parser available : just output the raw packets */
823
                    st->need_parsing = AVSTREAM_PARSE_NONE;
824
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
825
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
826
                }
827
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
828
                    st->parser->last_frame_offset=
829
                    st->parser->cur_offset= s->cur_pkt.pos;
830
                }
831
            }
832
        }
833
    }
834
    if(st->codec->debug & FF_DEBUG_PTS)
835
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
836
            pkt->stream_index,
837
            pkt->pts,
838
            pkt->dts,
839
            pkt->size);
840

    
841
    return 0;
842
}
843

    
844
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
845
    AVPacketList *pktl= s->packet_buffer;
846
    AVPacketList **plast_pktl= &s->packet_buffer;
847

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

    
850
    pktl = av_mallocz(sizeof(AVPacketList));
851
    if (!pktl)
852
        return NULL;
853

    
854
    /* add the packet in the buffered packet list */
855
    *plast_pktl = pktl;
856
    pktl->pkt= *pkt;
857
    return &pktl->pkt;
858
}
859

    
860
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
861
{
862
    AVPacketList *pktl;
863
    int eof=0;
864
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
865

    
866
    for(;;){
867
        pktl = s->packet_buffer;
868
        if (pktl) {
869
            AVPacket *next_pkt= &pktl->pkt;
870

    
871
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
872
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
873
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
874
                       && next_pkt->dts < pktl->pkt.dts
875
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
876
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
877
                        next_pkt->pts= pktl->pkt.dts;
878
                    }
879
                    pktl= pktl->next;
880
                }
881
                pktl = s->packet_buffer;
882
            }
883

    
884
            if(   next_pkt->pts != AV_NOPTS_VALUE
885
               || next_pkt->dts == AV_NOPTS_VALUE
886
               || !genpts || eof){
887
                /* read packet from packet buffer, if there is data */
888
                *pkt = *next_pkt;
889
                s->packet_buffer = pktl->next;
890
                av_free(pktl);
891
                return 0;
892
            }
893
        }
894
        if(genpts){
895
            int ret= av_read_frame_internal(s, pkt);
896
            if(ret<0){
897
                if(pktl && ret != AVERROR(EAGAIN)){
898
                    eof=1;
899
                    continue;
900
                }else
901
                    return ret;
902
            }
903

    
904
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
905
                return AVERROR(ENOMEM);
906
        }else{
907
            assert(!s->packet_buffer);
908
            return av_read_frame_internal(s, pkt);
909
        }
910
    }
911
}
912

    
913
/* XXX: suppress the packet queue */
914
static void flush_packet_queue(AVFormatContext *s)
915
{
916
    AVPacketList *pktl;
917

    
918
    for(;;) {
919
        pktl = s->packet_buffer;
920
        if (!pktl)
921
            break;
922
        s->packet_buffer = pktl->next;
923
        av_free_packet(&pktl->pkt);
924
        av_free(pktl);
925
    }
926
}
927

    
928
/*******************************************************/
929
/* seek support */
930

    
931
int av_find_default_stream_index(AVFormatContext *s)
932
{
933
    int i;
934
    AVStream *st;
935

    
936
    if (s->nb_streams <= 0)
937
        return -1;
938
    for(i = 0; i < s->nb_streams; i++) {
939
        st = s->streams[i];
940
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
941
            return i;
942
        }
943
    }
944
    return 0;
945
}
946

    
947
/**
948
 * Flush the frame reader.
949
 */
950
static void av_read_frame_flush(AVFormatContext *s)
951
{
952
    AVStream *st;
953
    int i;
954

    
955
    flush_packet_queue(s);
956

    
957
    /* free previous packet */
958
    if (s->cur_st) {
959
        if (s->cur_st->parser)
960
            av_free_packet(&s->cur_pkt);
961
        s->cur_st = NULL;
962
    }
963
    /* fail safe */
964
    s->cur_ptr = NULL;
965
    s->cur_len = 0;
966

    
967
    /* for each stream, reset read state */
968
    for(i = 0; i < s->nb_streams; i++) {
969
        st = s->streams[i];
970

    
971
        if (st->parser) {
972
            av_parser_close(st->parser);
973
            st->parser = NULL;
974
        }
975
        st->last_IP_pts = AV_NOPTS_VALUE;
976
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
977
    }
978
}
979

    
980
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
981
    int i;
982

    
983
    for(i = 0; i < s->nb_streams; i++) {
984
        AVStream *st = s->streams[i];
985

    
986
        st->cur_dts = av_rescale(timestamp,
987
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
988
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
989
    }
990
}
991

    
992
int av_add_index_entry(AVStream *st,
993
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
994
{
995
    AVIndexEntry *entries, *ie;
996
    int index;
997

    
998
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
999
        return -1;
1000

    
1001
    entries = av_fast_realloc(st->index_entries,
1002
                              &st->index_entries_allocated_size,
1003
                              (st->nb_index_entries + 1) *
1004
                              sizeof(AVIndexEntry));
1005
    if(!entries)
1006
        return -1;
1007

    
1008
    st->index_entries= entries;
1009

    
1010
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1011

    
1012
    if(index<0){
1013
        index= st->nb_index_entries++;
1014
        ie= &entries[index];
1015
        assert(index==0 || ie[-1].timestamp < timestamp);
1016
    }else{
1017
        ie= &entries[index];
1018
        if(ie->timestamp != timestamp){
1019
            if(ie->timestamp <= timestamp)
1020
                return -1;
1021
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1022
            st->nb_index_entries++;
1023
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1024
            distance= ie->min_distance;
1025
    }
1026

    
1027
    ie->pos = pos;
1028
    ie->timestamp = timestamp;
1029
    ie->min_distance= distance;
1030
    ie->size= size;
1031
    ie->flags = flags;
1032

    
1033
    return index;
1034
}
1035

    
1036
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1037
                              int flags)
1038
{
1039
    AVIndexEntry *entries= st->index_entries;
1040
    int nb_entries= st->nb_index_entries;
1041
    int a, b, m;
1042
    int64_t timestamp;
1043

    
1044
    a = - 1;
1045
    b = nb_entries;
1046

    
1047
    while (b - a > 1) {
1048
        m = (a + b) >> 1;
1049
        timestamp = entries[m].timestamp;
1050
        if(timestamp >= wanted_timestamp)
1051
            b = m;
1052
        if(timestamp <= wanted_timestamp)
1053
            a = m;
1054
    }
1055
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1056

    
1057
    if(!(flags & AVSEEK_FLAG_ANY)){
1058
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1059
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1060
        }
1061
    }
1062

    
1063
    if(m == nb_entries)
1064
        return -1;
1065
    return  m;
1066
}
1067

    
1068
#define DEBUG_SEEK
1069

    
1070
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1071
    AVInputFormat *avif= s->iformat;
1072
    int64_t pos_min, pos_max, pos, pos_limit;
1073
    int64_t ts_min, ts_max, ts;
1074
    int index;
1075
    AVStream *st;
1076

    
1077
    if (stream_index < 0)
1078
        return -1;
1079

    
1080
#ifdef DEBUG_SEEK
1081
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1082
#endif
1083

    
1084
    ts_max=
1085
    ts_min= AV_NOPTS_VALUE;
1086
    pos_limit= -1; //gcc falsely says it may be uninitialized
1087

    
1088
    st= s->streams[stream_index];
1089
    if(st->index_entries){
1090
        AVIndexEntry *e;
1091

    
1092
        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()
1093
        index= FFMAX(index, 0);
1094
        e= &st->index_entries[index];
1095

    
1096
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1097
            pos_min= e->pos;
1098
            ts_min= e->timestamp;
1099
#ifdef DEBUG_SEEK
1100
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1101
               pos_min,ts_min);
1102
#endif
1103
        }else{
1104
            assert(index==0);
1105
        }
1106

    
1107
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1108
        assert(index < st->nb_index_entries);
1109
        if(index >= 0){
1110
            e= &st->index_entries[index];
1111
            assert(e->timestamp >= target_ts);
1112
            pos_max= e->pos;
1113
            ts_max= e->timestamp;
1114
            pos_limit= pos_max - e->min_distance;
1115
#ifdef DEBUG_SEEK
1116
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1117
               pos_max,pos_limit, ts_max);
1118
#endif
1119
        }
1120
    }
1121

    
1122
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1123
    if(pos<0)
1124
        return -1;
1125

    
1126
    /* do the seek */
1127
    url_fseek(s->pb, pos, SEEK_SET);
1128

    
1129
    av_update_cur_dts(s, st, ts);
1130

    
1131
    return 0;
1132
}
1133

    
1134
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 )){
1135
    int64_t pos, ts;
1136
    int64_t start_pos, filesize;
1137
    int no_change;
1138

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

    
1143
    if(ts_min == AV_NOPTS_VALUE){
1144
        pos_min = s->data_offset;
1145
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1146
        if (ts_min == AV_NOPTS_VALUE)
1147
            return -1;
1148
    }
1149

    
1150
    if(ts_max == AV_NOPTS_VALUE){
1151
        int step= 1024;
1152
        filesize = url_fsize(s->pb);
1153
        pos_max = filesize - 1;
1154
        do{
1155
            pos_max -= step;
1156
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1157
            step += step;
1158
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1159
        if (ts_max == AV_NOPTS_VALUE)
1160
            return -1;
1161

    
1162
        for(;;){
1163
            int64_t tmp_pos= pos_max + 1;
1164
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1165
            if(tmp_ts == AV_NOPTS_VALUE)
1166
                break;
1167
            ts_max= tmp_ts;
1168
            pos_max= tmp_pos;
1169
            if(tmp_pos >= filesize)
1170
                break;
1171
        }
1172
        pos_limit= pos_max;
1173
    }
1174

    
1175
    if(ts_min > ts_max){
1176
        return -1;
1177
    }else if(ts_min == ts_max){
1178
        pos_limit= pos_min;
1179
    }
1180

    
1181
    no_change=0;
1182
    while (pos_min < pos_limit) {
1183
#ifdef DEBUG_SEEK
1184
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1185
               pos_min, pos_max,
1186
               ts_min, ts_max);
1187
#endif
1188
        assert(pos_limit <= pos_max);
1189

    
1190
        if(no_change==0){
1191
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1192
            // interpolate position (better than dichotomy)
1193
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1194
                + pos_min - approximate_keyframe_distance;
1195
        }else if(no_change==1){
1196
            // bisection, if interpolation failed to change min or max pos last time
1197
            pos = (pos_min + pos_limit)>>1;
1198
        }else{
1199
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1200
            pos=pos_min;
1201
        }
1202
        if(pos <= pos_min)
1203
            pos= pos_min + 1;
1204
        else if(pos > pos_limit)
1205
            pos= pos_limit;
1206
        start_pos= pos;
1207

    
1208
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1209
        if(pos == pos_max)
1210
            no_change++;
1211
        else
1212
            no_change=0;
1213
#ifdef DEBUG_SEEK
1214
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);
1215
#endif
1216
        if(ts == AV_NOPTS_VALUE){
1217
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1218
            return -1;
1219
        }
1220
        assert(ts != AV_NOPTS_VALUE);
1221
        if (target_ts <= ts) {
1222
            pos_limit = start_pos - 1;
1223
            pos_max = pos;
1224
            ts_max = ts;
1225
        }
1226
        if (target_ts >= ts) {
1227
            pos_min = pos;
1228
            ts_min = ts;
1229
        }
1230
    }
1231

    
1232
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1233
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1234
#ifdef DEBUG_SEEK
1235
    pos_min = pos;
1236
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1237
    pos_min++;
1238
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1239
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1240
           pos, ts_min, target_ts, ts_max);
1241
#endif
1242
    *ts_ret= ts;
1243
    return pos;
1244
}
1245

    
1246
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1247
    int64_t pos_min, pos_max;
1248
#if 0
1249
    AVStream *st;
1250

1251
    if (stream_index < 0)
1252
        return -1;
1253

1254
    st= s->streams[stream_index];
1255
#endif
1256

    
1257
    pos_min = s->data_offset;
1258
    pos_max = url_fsize(s->pb) - 1;
1259

    
1260
    if     (pos < pos_min) pos= pos_min;
1261
    else if(pos > pos_max) pos= pos_max;
1262

    
1263
    url_fseek(s->pb, pos, SEEK_SET);
1264

    
1265
#if 0
1266
    av_update_cur_dts(s, st, ts);
1267
#endif
1268
    return 0;
1269
}
1270

    
1271
static int av_seek_frame_generic(AVFormatContext *s,
1272
                                 int stream_index, int64_t timestamp, int flags)
1273
{
1274
    int index;
1275
    AVStream *st;
1276
    AVIndexEntry *ie;
1277

    
1278
    st = s->streams[stream_index];
1279

    
1280
    index = av_index_search_timestamp(st, timestamp, flags);
1281

    
1282
    if(index < 0 || index==st->nb_index_entries-1){
1283
        int i;
1284
        AVPacket pkt;
1285

    
1286
        if(st->index_entries && st->nb_index_entries){
1287
            ie= &st->index_entries[st->nb_index_entries-1];
1288
            url_fseek(s->pb, ie->pos, SEEK_SET);
1289
            av_update_cur_dts(s, st, ie->timestamp);
1290
        }else
1291
            url_fseek(s->pb, 0, SEEK_SET);
1292

    
1293
        for(i=0;; i++) {
1294
            int ret = av_read_frame(s, &pkt);
1295
            if(ret<0)
1296
                break;
1297
            av_free_packet(&pkt);
1298
            if(stream_index == pkt.stream_index){
1299
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1300
                    break;
1301
            }
1302
        }
1303
        index = av_index_search_timestamp(st, timestamp, flags);
1304
    }
1305
    if (index < 0)
1306
        return -1;
1307

    
1308
    av_read_frame_flush(s);
1309
    if (s->iformat->read_seek){
1310
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1311
            return 0;
1312
    }
1313
    ie = &st->index_entries[index];
1314
    url_fseek(s->pb, ie->pos, SEEK_SET);
1315

    
1316
    av_update_cur_dts(s, st, ie->timestamp);
1317

    
1318
    return 0;
1319
}
1320

    
1321
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1322
{
1323
    int ret;
1324
    AVStream *st;
1325

    
1326
    av_read_frame_flush(s);
1327

    
1328
    if(flags & AVSEEK_FLAG_BYTE)
1329
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1330

    
1331
    if(stream_index < 0){
1332
        stream_index= av_find_default_stream_index(s);
1333
        if(stream_index < 0)
1334
            return -1;
1335

    
1336
        st= s->streams[stream_index];
1337
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1338
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1339
    }
1340
    st= s->streams[stream_index];
1341

    
1342
    /* first, we try the format specific seek */
1343
    if (s->iformat->read_seek)
1344
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1345
    else
1346
        ret = -1;
1347
    if (ret >= 0) {
1348
        return 0;
1349
    }
1350

    
1351
    if(s->iformat->read_timestamp)
1352
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1353
    else
1354
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1355
}
1356

    
1357
/*******************************************************/
1358

    
1359
/**
1360
 * Returns TRUE if the stream has accurate duration in any stream.
1361
 *
1362
 * @return TRUE if the stream has accurate duration for at least one component.
1363
 */
1364
static int av_has_duration(AVFormatContext *ic)
1365
{
1366
    int i;
1367
    AVStream *st;
1368

    
1369
    for(i = 0;i < ic->nb_streams; i++) {
1370
        st = ic->streams[i];
1371
        if (st->duration != AV_NOPTS_VALUE)
1372
            return 1;
1373
    }
1374
    return 0;
1375
}
1376

    
1377
/**
1378
 * Estimate the stream timings from the one of each components.
1379
 *
1380
 * Also computes the global bitrate if possible.
1381
 */
1382
static void av_update_stream_timings(AVFormatContext *ic)
1383
{
1384
    int64_t start_time, start_time1, end_time, end_time1;
1385
    int64_t duration, duration1;
1386
    int i;
1387
    AVStream *st;
1388

    
1389
    start_time = INT64_MAX;
1390
    end_time = INT64_MIN;
1391
    duration = INT64_MIN;
1392
    for(i = 0;i < ic->nb_streams; i++) {
1393
        st = ic->streams[i];
1394
        if (st->start_time != AV_NOPTS_VALUE) {
1395
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1396
            if (start_time1 < start_time)
1397
                start_time = start_time1;
1398
            if (st->duration != AV_NOPTS_VALUE) {
1399
                end_time1 = start_time1
1400
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1401
                if (end_time1 > end_time)
1402
                    end_time = end_time1;
1403
            }
1404
        }
1405
        if (st->duration != AV_NOPTS_VALUE) {
1406
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1407
            if (duration1 > duration)
1408
                duration = duration1;
1409
        }
1410
    }
1411
    if (start_time != INT64_MAX) {
1412
        ic->start_time = start_time;
1413
        if (end_time != INT64_MIN) {
1414
            if (end_time - start_time > duration)
1415
                duration = end_time - start_time;
1416
        }
1417
    }
1418
    if (duration != INT64_MIN) {
1419
        ic->duration = duration;
1420
        if (ic->file_size > 0) {
1421
            /* compute the bit rate */
1422
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1423
                (double)ic->duration;
1424
        }
1425
    }
1426
}
1427

    
1428
static void fill_all_stream_timings(AVFormatContext *ic)
1429
{
1430
    int i;
1431
    AVStream *st;
1432

    
1433
    av_update_stream_timings(ic);
1434
    for(i = 0;i < ic->nb_streams; i++) {
1435
        st = ic->streams[i];
1436
        if (st->start_time == AV_NOPTS_VALUE) {
1437
            if(ic->start_time != AV_NOPTS_VALUE)
1438
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1439
            if(ic->duration != AV_NOPTS_VALUE)
1440
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1441
        }
1442
    }
1443
}
1444

    
1445
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1446
{
1447
    int64_t filesize, duration;
1448
    int bit_rate, i;
1449
    AVStream *st;
1450

    
1451
    /* if bit_rate is already set, we believe it */
1452
    if (ic->bit_rate == 0) {
1453
        bit_rate = 0;
1454
        for(i=0;i<ic->nb_streams;i++) {
1455
            st = ic->streams[i];
1456
            bit_rate += st->codec->bit_rate;
1457
        }
1458
        ic->bit_rate = bit_rate;
1459
    }
1460

    
1461
    /* if duration is already set, we believe it */
1462
    if (ic->duration == AV_NOPTS_VALUE &&
1463
        ic->bit_rate != 0 &&
1464
        ic->file_size != 0)  {
1465
        filesize = ic->file_size;
1466
        if (filesize > 0) {
1467
            for(i = 0; i < ic->nb_streams; i++) {
1468
                st = ic->streams[i];
1469
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1470
                if (st->duration == AV_NOPTS_VALUE)
1471
                    st->duration = duration;
1472
            }
1473
        }
1474
    }
1475
}
1476

    
1477
#define DURATION_MAX_READ_SIZE 250000
1478

    
1479
/* only usable for MPEG-PS streams */
1480
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1481
{
1482
    AVPacket pkt1, *pkt = &pkt1;
1483
    AVStream *st;
1484
    int read_size, i, ret;
1485
    int64_t end_time;
1486
    int64_t filesize, offset, duration;
1487

    
1488
    /* free previous packet */
1489
    if (ic->cur_st && ic->cur_st->parser)
1490
        av_free_packet(&ic->cur_pkt);
1491
    ic->cur_st = NULL;
1492

    
1493
    /* flush packet queue */
1494
    flush_packet_queue(ic);
1495

    
1496
    for(i=0;i<ic->nb_streams;i++) {
1497
        st = ic->streams[i];
1498
        if (st->parser) {
1499
            av_parser_close(st->parser);
1500
            st->parser= NULL;
1501
        }
1502
    }
1503

    
1504
    /* we read the first packets to get the first PTS (not fully
1505
       accurate, but it is enough now) */
1506
    url_fseek(ic->pb, 0, SEEK_SET);
1507
    read_size = 0;
1508
    for(;;) {
1509
        if (read_size >= DURATION_MAX_READ_SIZE)
1510
            break;
1511
        /* if all info is available, we can stop */
1512
        for(i = 0;i < ic->nb_streams; i++) {
1513
            st = ic->streams[i];
1514
            if (st->start_time == AV_NOPTS_VALUE)
1515
                break;
1516
        }
1517
        if (i == ic->nb_streams)
1518
            break;
1519

    
1520
        ret = av_read_packet(ic, pkt);
1521
        if (ret != 0)
1522
            break;
1523
        read_size += pkt->size;
1524
        st = ic->streams[pkt->stream_index];
1525
        if (pkt->pts != AV_NOPTS_VALUE) {
1526
            if (st->start_time == AV_NOPTS_VALUE)
1527
                st->start_time = pkt->pts;
1528
        }
1529
        av_free_packet(pkt);
1530
    }
1531

    
1532
    /* estimate the end time (duration) */
1533
    /* XXX: may need to support wrapping */
1534
    filesize = ic->file_size;
1535
    offset = filesize - DURATION_MAX_READ_SIZE;
1536
    if (offset < 0)
1537
        offset = 0;
1538

    
1539
    url_fseek(ic->pb, offset, SEEK_SET);
1540
    read_size = 0;
1541
    for(;;) {
1542
        if (read_size >= DURATION_MAX_READ_SIZE)
1543
            break;
1544

    
1545
        ret = av_read_packet(ic, pkt);
1546
        if (ret != 0)
1547
            break;
1548
        read_size += pkt->size;
1549
        st = ic->streams[pkt->stream_index];
1550
        if (pkt->pts != AV_NOPTS_VALUE &&
1551
            st->start_time != AV_NOPTS_VALUE) {
1552
            end_time = pkt->pts;
1553
            duration = end_time - st->start_time;
1554
            if (duration > 0) {
1555
                if (st->duration == AV_NOPTS_VALUE ||
1556
                    st->duration < duration)
1557
                    st->duration = duration;
1558
            }
1559
        }
1560
        av_free_packet(pkt);
1561
    }
1562

    
1563
    fill_all_stream_timings(ic);
1564

    
1565
    url_fseek(ic->pb, old_offset, SEEK_SET);
1566
    for(i=0; i<ic->nb_streams; i++){
1567
        st= ic->streams[i];
1568
        st->cur_dts= st->first_dts;
1569
        st->last_IP_pts = AV_NOPTS_VALUE;
1570
    }
1571
}
1572

    
1573
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1574
{
1575
    int64_t file_size;
1576

    
1577
    /* get the file size, if possible */
1578
    if (ic->iformat->flags & AVFMT_NOFILE) {
1579
        file_size = 0;
1580
    } else {
1581
        file_size = url_fsize(ic->pb);
1582
        if (file_size < 0)
1583
            file_size = 0;
1584
    }
1585
    ic->file_size = file_size;
1586

    
1587
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1588
         !strcmp(ic->iformat->name, "mpegts")) &&
1589
        file_size && !ic->pb->is_streamed) {
1590
        /* get accurate estimate from the PTSes */
1591
        av_estimate_timings_from_pts(ic, old_offset);
1592
    } else if (av_has_duration(ic)) {
1593
        /* at least one components has timings - we use them for all
1594
           the components */
1595
        fill_all_stream_timings(ic);
1596
    } else {
1597
        /* less precise: use bit rate info */
1598
        av_estimate_timings_from_bit_rate(ic);
1599
    }
1600
    av_update_stream_timings(ic);
1601

    
1602
#if 0
1603
    {
1604
        int i;
1605
        AVStream *st;
1606
        for(i = 0;i < ic->nb_streams; i++) {
1607
            st = ic->streams[i];
1608
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1609
               i, (double)st->start_time / AV_TIME_BASE,
1610
               (double)st->duration / AV_TIME_BASE);
1611
        }
1612
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1613
               (double)ic->start_time / AV_TIME_BASE,
1614
               (double)ic->duration / AV_TIME_BASE,
1615
               ic->bit_rate / 1000);
1616
    }
1617
#endif
1618
}
1619

    
1620
static int has_codec_parameters(AVCodecContext *enc)
1621
{
1622
    int val;
1623
    switch(enc->codec_type) {
1624
    case CODEC_TYPE_AUDIO:
1625
        val = enc->sample_rate;
1626
        break;
1627
    case CODEC_TYPE_VIDEO:
1628
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1629
        break;
1630
    default:
1631
        val = 1;
1632
        break;
1633
    }
1634
    return (enc->codec_id != CODEC_ID_NONE && val != 0);
1635
}
1636

    
1637
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1638
{
1639
    int16_t *samples;
1640
    AVCodec *codec;
1641
    int got_picture, data_size, ret=0;
1642
    AVFrame picture;
1643

    
1644
  if(!st->codec->codec){
1645
    codec = avcodec_find_decoder(st->codec->codec_id);
1646
    if (!codec)
1647
        return -1;
1648
    ret = avcodec_open(st->codec, codec);
1649
    if (ret < 0)
1650
        return ret;
1651
  }
1652

    
1653
  if(!has_codec_parameters(st->codec)){
1654
    switch(st->codec->codec_type) {
1655
    case CODEC_TYPE_VIDEO:
1656
        ret = avcodec_decode_video(st->codec, &picture,
1657
                                   &got_picture, (uint8_t *)data, size);
1658
        break;
1659
    case CODEC_TYPE_AUDIO:
1660
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1661
        samples = av_malloc(data_size);
1662
        if (!samples)
1663
            goto fail;
1664
        ret = avcodec_decode_audio2(st->codec, samples,
1665
                                    &data_size, (uint8_t *)data, size);
1666
        av_free(samples);
1667
        break;
1668
    default:
1669
        break;
1670
    }
1671
  }
1672
 fail:
1673
    return ret;
1674
}
1675

    
1676
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1677
{
1678
    AVInputFormat *fmt;
1679
    fmt = av_probe_input_format2(pd, 1, &score);
1680

    
1681
    if (fmt) {
1682
        if (strncmp(fmt->name, "mp3", 3) == 0)
1683
            st->codec->codec_id = CODEC_ID_MP3;
1684
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1685
            st->codec->codec_id = CODEC_ID_AC3;
1686
    }
1687
    return !!fmt;
1688
}
1689

    
1690
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1691
{
1692
    while (tags->id != CODEC_ID_NONE) {
1693
        if (tags->id == id)
1694
            return tags->tag;
1695
        tags++;
1696
    }
1697
    return 0;
1698
}
1699

    
1700
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1701
{
1702
    int i;
1703
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1704
        if(tag == tags[i].tag)
1705
            return tags[i].id;
1706
    }
1707
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1708
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1709
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1710
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1711
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1712
            return tags[i].id;
1713
    }
1714
    return CODEC_ID_NONE;
1715
}
1716

    
1717
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1718
{
1719
    int i;
1720
    for(i=0; tags && tags[i]; i++){
1721
        int tag= codec_get_tag(tags[i], id);
1722
        if(tag) return tag;
1723
    }
1724
    return 0;
1725
}
1726

    
1727
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1728
{
1729
    int i;
1730
    for(i=0; tags && tags[i]; i++){
1731
        enum CodecID id= codec_get_id(tags[i], tag);
1732
        if(id!=CODEC_ID_NONE) return id;
1733
    }
1734
    return CODEC_ID_NONE;
1735
}
1736

    
1737
/* absolute maximum size we read until we abort */
1738
#define MAX_READ_SIZE        5000000
1739

    
1740
#define MAX_STD_TIMEBASES (60*12+5)
1741
static int get_std_framerate(int i){
1742
    if(i<60*12) return i*1001;
1743
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1744
}
1745

    
1746
int av_find_stream_info(AVFormatContext *ic)
1747
{
1748
    int i, count, ret, read_size, j;
1749
    AVStream *st;
1750
    AVPacket pkt1, *pkt;
1751
    int64_t last_dts[MAX_STREAMS];
1752
    int duration_count[MAX_STREAMS]={0};
1753
    double (*duration_error)[MAX_STD_TIMEBASES];
1754
    offset_t old_offset = url_ftell(ic->pb);
1755
    int64_t codec_info_duration[MAX_STREAMS]={0};
1756
    int codec_info_nb_frames[MAX_STREAMS]={0};
1757
    AVProbeData probe_data[MAX_STREAMS];
1758
    int codec_identified[MAX_STREAMS]={0};
1759

    
1760
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1761
    if (!duration_error) return AVERROR(ENOMEM);
1762

    
1763
    for(i=0;i<ic->nb_streams;i++) {
1764
        st = ic->streams[i];
1765
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1766
/*            if(!st->time_base.num)
1767
                st->time_base= */
1768
            if(!st->codec->time_base.num)
1769
                st->codec->time_base= st->time_base;
1770
        }
1771
        //only for the split stuff
1772
        if (!st->parser) {
1773
            st->parser = av_parser_init(st->codec->codec_id);
1774
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1775
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1776
            }
1777
        }
1778
    }
1779

    
1780
    for(i=0;i<MAX_STREAMS;i++){
1781
        last_dts[i]= AV_NOPTS_VALUE;
1782
    }
1783

    
1784
    memset(probe_data, 0, sizeof(probe_data));
1785
    count = 0;
1786
    read_size = 0;
1787
    for(;;) {
1788
        /* check if one codec still needs to be handled */
1789
        for(i=0;i<ic->nb_streams;i++) {
1790
            st = ic->streams[i];
1791
            if (!has_codec_parameters(st->codec))
1792
                break;
1793
            /* variable fps and no guess at the real fps */
1794
            if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1795
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1796
                break;
1797
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1798
                break;
1799
            if(st->first_dts == AV_NOPTS_VALUE)
1800
                break;
1801
        }
1802
        if (i == ic->nb_streams) {
1803
            /* NOTE: if the format has no header, then we need to read
1804
               some packets to get most of the streams, so we cannot
1805
               stop here */
1806
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1807
                /* if we found the info for all the codecs, we can stop */
1808
                ret = count;
1809
                break;
1810
            }
1811
        }
1812
        /* we did not get all the codec info, but we read too much data */
1813
        if (read_size >= MAX_READ_SIZE) {
1814
            ret = count;
1815
            break;
1816
        }
1817

    
1818
        /* NOTE: a new stream can be added there if no header in file
1819
           (AVFMTCTX_NOHEADER) */
1820
        ret = av_read_frame_internal(ic, &pkt1);
1821
        if (ret < 0) {
1822
            /* EOF or error */
1823
            ret = -1; /* we could not have all the codec parameters before EOF */
1824
            for(i=0;i<ic->nb_streams;i++) {
1825
                st = ic->streams[i];
1826
                if (!has_codec_parameters(st->codec)){
1827
                    char buf[256];
1828
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1829
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1830
                } else {
1831
                    ret = 0;
1832
                }
1833
            }
1834
            break;
1835
        }
1836

    
1837
        pkt= add_to_pktbuf(ic, &pkt1);
1838
        if(av_dup_packet(pkt) < 0)
1839
            return AVERROR(ENOMEM);
1840

    
1841
        read_size += pkt->size;
1842

    
1843
        st = ic->streams[pkt->stream_index];
1844
        if(codec_info_nb_frames[st->index]>1)
1845
            codec_info_duration[st->index] += pkt->duration;
1846
        if (pkt->duration != 0)
1847
            codec_info_nb_frames[st->index]++;
1848

    
1849
        {
1850
            int index= pkt->stream_index;
1851
            int64_t last= last_dts[index];
1852
            int64_t duration= pkt->dts - last;
1853

    
1854
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1855
                double dur= duration * av_q2d(st->time_base);
1856

    
1857
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1858
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1859
                if(duration_count[index] < 2)
1860
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1861
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1862
                    int framerate= get_std_framerate(i);
1863
                    int ticks= lrintf(dur*framerate/(1001*12));
1864
                    double error= dur - ticks*1001*12/(double)framerate;
1865
                    duration_error[index][i] += error*error;
1866
                }
1867
                duration_count[index]++;
1868
            }
1869
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1870
                last_dts[pkt->stream_index]= pkt->dts;
1871

    
1872
            if (st->codec->codec_id == CODEC_ID_NONE) {
1873
                AVProbeData *pd = &(probe_data[st->index]);
1874
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1875
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1876
                pd->buf_size += pkt->size;
1877
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1878
            }
1879
        }
1880
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1881
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1882
            if(i){
1883
                st->codec->extradata_size= i;
1884
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1885
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1886
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1887
            }
1888
        }
1889

    
1890
        /* if still no information, we try to open the codec and to
1891
           decompress the frame. We try to avoid that in most cases as
1892
           it takes longer and uses more memory. For MPEG4, we need to
1893
           decompress for Quicktime. */
1894
        if (!has_codec_parameters(st->codec) /*&&
1895
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1896
             st->codec->codec_id == CODEC_ID_H264 ||
1897
             st->codec->codec_id == CODEC_ID_H263 ||
1898
             st->codec->codec_id == CODEC_ID_H261 ||
1899
             st->codec->codec_id == CODEC_ID_VORBIS ||
1900
             st->codec->codec_id == CODEC_ID_MJPEG ||
1901
             st->codec->codec_id == CODEC_ID_PNG ||
1902
             st->codec->codec_id == CODEC_ID_PAM ||
1903
             st->codec->codec_id == CODEC_ID_PGM ||
1904
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1905
             st->codec->codec_id == CODEC_ID_PBM ||
1906
             st->codec->codec_id == CODEC_ID_PPM ||
1907
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1908
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1909
            try_decode_frame(st, pkt->data, pkt->size);
1910

    
1911
        if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1912
            break;
1913
        }
1914
        count++;
1915
    }
1916

    
1917
    // close codecs which where opened in try_decode_frame()
1918
    for(i=0;i<ic->nb_streams;i++) {
1919
        st = ic->streams[i];
1920
        if(st->codec->codec)
1921
            avcodec_close(st->codec);
1922
    }
1923
    for(i=0;i<ic->nb_streams;i++) {
1924
        st = ic->streams[i];
1925
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1926
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1927
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1928

    
1929
            if(duration_count[i]
1930
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1931
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1932
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1933
                double best_error= 2*av_q2d(st->time_base);
1934
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1935

    
1936
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1937
                    double error= duration_error[i][j] * get_std_framerate(j);
1938
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1939
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1940
                    if(error < best_error){
1941
                        best_error= error;
1942
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1943
                    }
1944
                }
1945
            }
1946

    
1947
            if (!st->r_frame_rate.num){
1948
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1949
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1950
                    st->r_frame_rate.num = st->codec->time_base.den;
1951
                    st->r_frame_rate.den = st->codec->time_base.num;
1952
                }else{
1953
                    st->r_frame_rate.num = st->time_base.den;
1954
                    st->r_frame_rate.den = st->time_base.num;
1955
                }
1956
            }
1957
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1958
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1959
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
1960
                if (codec_identified[st->index]) {
1961
                    st->need_parsing = AVSTREAM_PARSE_FULL;
1962
                }
1963
            }
1964
            if(!st->codec->bits_per_sample)
1965
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1966
        }
1967
    }
1968

    
1969
    av_estimate_timings(ic, old_offset);
1970

    
1971
    for(i=0;i<ic->nb_streams;i++) {
1972
        st = ic->streams[i];
1973
        if (codec_identified[st->index])
1974
            break;
1975
    }
1976
    //FIXME this is a mess
1977
    if(i!=ic->nb_streams){
1978
        av_read_frame_flush(ic);
1979
        for(i=0;i<ic->nb_streams;i++) {
1980
            st = ic->streams[i];
1981
            if (codec_identified[st->index]) {
1982
                av_seek_frame(ic, st->index, 0.0, 0);
1983
            }
1984
            st->cur_dts= st->first_dts;
1985
        }
1986
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
1987
    }
1988

    
1989
#if 0
1990
    /* correct DTS for b frame streams with no timestamps */
1991
    for(i=0;i<ic->nb_streams;i++) {
1992
        st = ic->streams[i];
1993
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1994
            if(b-frames){
1995
                ppktl = &ic->packet_buffer;
1996
                while(ppkt1){
1997
                    if(ppkt1->stream_index != i)
1998
                        continue;
1999
                    if(ppkt1->pkt->dts < 0)
2000
                        break;
2001
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2002
                        break;
2003
                    ppkt1->pkt->dts -= delta;
2004
                    ppkt1= ppkt1->next;
2005
                }
2006
                if(ppkt1)
2007
                    continue;
2008
                st->cur_dts -= delta;
2009
            }
2010
        }
2011
    }
2012
#endif
2013

    
2014
    av_free(duration_error);
2015
    for(i=0;i<MAX_STREAMS;i++){
2016
        av_freep(&(probe_data[i].buf));
2017
    }
2018

    
2019
    return ret;
2020
}
2021

    
2022
/*******************************************************/
2023

    
2024
int av_read_play(AVFormatContext *s)
2025
{
2026
    if (s->iformat->read_play)
2027
        return s->iformat->read_play(s);
2028
    if (s->pb && s->pb->read_play)
2029
        return av_url_read_fplay(s->pb);
2030
    return AVERROR(ENOSYS);
2031
}
2032

    
2033
int av_read_pause(AVFormatContext *s)
2034
{
2035
    if (s->iformat->read_pause)
2036
        return s->iformat->read_pause(s);
2037
    if (s->pb && s->pb->read_pause)
2038
        return av_url_read_fpause(s->pb);
2039
    return AVERROR(ENOSYS);
2040
}
2041

    
2042
void av_close_input_file(AVFormatContext *s)
2043
{
2044
    int i;
2045
    AVStream *st;
2046

    
2047
    /* free previous packet */
2048
    if (s->cur_st && s->cur_st->parser)
2049
        av_free_packet(&s->cur_pkt);
2050

    
2051
    if (s->iformat->read_close)
2052
        s->iformat->read_close(s);
2053
    for(i=0;i<s->nb_streams;i++) {
2054
        /* free all data in a stream component */
2055
        st = s->streams[i];
2056
        if (st->parser) {
2057
            av_parser_close(st->parser);
2058
        }
2059
        av_free(st->index_entries);
2060
        av_free(st->codec->extradata);
2061
        av_free(st->codec);
2062
        av_free(st);
2063
    }
2064
    for(i=s->nb_programs-1; i>=0; i--) {
2065
        av_freep(&s->programs[i]->provider_name);
2066
        av_freep(&s->programs[i]->name);
2067
        av_freep(&s->programs[i]->stream_index);
2068
        av_freep(&s->programs[i]);
2069
    }
2070
    flush_packet_queue(s);
2071
    if (!(s->iformat->flags & AVFMT_NOFILE))
2072
        url_fclose(s->pb);
2073
    av_freep(&s->priv_data);
2074
    av_free(s);
2075
}
2076

    
2077
AVStream *av_new_stream(AVFormatContext *s, int id)
2078
{
2079
    AVStream *st;
2080
    int i;
2081

    
2082
    if (s->nb_streams >= MAX_STREAMS)
2083
        return NULL;
2084

    
2085
    st = av_mallocz(sizeof(AVStream));
2086
    if (!st)
2087
        return NULL;
2088

    
2089
    st->codec= avcodec_alloc_context();
2090
    if (s->iformat) {
2091
        /* no default bitrate if decoding */
2092
        st->codec->bit_rate = 0;
2093
    }
2094
    st->index = s->nb_streams;
2095
    st->id = id;
2096
    st->start_time = AV_NOPTS_VALUE;
2097
    st->duration = AV_NOPTS_VALUE;
2098
    st->cur_dts = AV_NOPTS_VALUE;
2099
    st->first_dts = AV_NOPTS_VALUE;
2100

    
2101
    /* default pts settings is MPEG like */
2102
    av_set_pts_info(st, 33, 1, 90000);
2103
    st->last_IP_pts = AV_NOPTS_VALUE;
2104
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2105
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2106

    
2107
    s->streams[s->nb_streams++] = st;
2108
    return st;
2109
}
2110

    
2111
AVProgram *av_new_program(AVFormatContext *ac, int id)
2112
{
2113
    AVProgram *program=NULL;
2114
    int i;
2115

    
2116
#ifdef DEBUG_SI
2117
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2118
#endif
2119

    
2120
    for(i=0; i<ac->nb_programs; i++)
2121
        if(ac->programs[i]->id == id)
2122
            program = ac->programs[i];
2123

    
2124
    if(!program){
2125
        program = av_mallocz(sizeof(AVProgram));
2126
        if (!program)
2127
            return NULL;
2128
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2129
        program->discard = AVDISCARD_NONE;
2130
    }
2131
    program->id = id;
2132

    
2133
    return program;
2134
}
2135

    
2136
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2137
{
2138
    assert(!provider_name == !name);
2139
    if(name){
2140
        av_free(program->provider_name);
2141
        av_free(program->         name);
2142
        program->provider_name = av_strdup(provider_name);
2143
        program->         name = av_strdup(         name);
2144
    }
2145
}
2146

    
2147

    
2148
/************************************************************/
2149
/* output media file */
2150

    
2151
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2152
{
2153
    int ret;
2154

    
2155
    if (s->oformat->priv_data_size > 0) {
2156
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2157
        if (!s->priv_data)
2158
            return AVERROR(ENOMEM);
2159
    } else
2160
        s->priv_data = NULL;
2161

    
2162
    if (s->oformat->set_parameters) {
2163
        ret = s->oformat->set_parameters(s, ap);
2164
        if (ret < 0)
2165
            return ret;
2166
    }
2167
    return 0;
2168
}
2169

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

    
2175
    // some sanity checks
2176
    for(i=0;i<s->nb_streams;i++) {
2177
        st = s->streams[i];
2178

    
2179
        switch (st->codec->codec_type) {
2180
        case CODEC_TYPE_AUDIO:
2181
            if(st->codec->sample_rate<=0){
2182
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2183
                return -1;
2184
            }
2185
            break;
2186
        case CODEC_TYPE_VIDEO:
2187
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2188
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2189
                return -1;
2190
            }
2191
            if(st->codec->width<=0 || st->codec->height<=0){
2192
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2193
                return -1;
2194
            }
2195
            break;
2196
        }
2197

    
2198
        if(s->oformat->codec_tag){
2199
            if(st->codec->codec_tag){
2200
                //FIXME
2201
                //check that tag + id is in the table
2202
                //if neither is in the table -> ok
2203
                //if tag is in the table with another id -> FAIL
2204
                //if id is in the table with another tag -> FAIL unless strict < ?
2205
            }else
2206
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2207
        }
2208
    }
2209

    
2210
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2211
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2212
        if (!s->priv_data)
2213
            return AVERROR(ENOMEM);
2214
    }
2215

    
2216
    if(s->oformat->write_header){
2217
        ret = s->oformat->write_header(s);
2218
        if (ret < 0)
2219
            return ret;
2220
    }
2221

    
2222
    /* init PTS generation */
2223
    for(i=0;i<s->nb_streams;i++) {
2224
        int64_t den = AV_NOPTS_VALUE;
2225
        st = s->streams[i];
2226

    
2227
        switch (st->codec->codec_type) {
2228
        case CODEC_TYPE_AUDIO:
2229
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2230
            break;
2231
        case CODEC_TYPE_VIDEO:
2232
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2233
            break;
2234
        default:
2235
            break;
2236
        }
2237
        if (den != AV_NOPTS_VALUE) {
2238
            if (den <= 0)
2239
                return AVERROR_INVALIDDATA;
2240
            av_frac_init(&st->pts, 0, 0, den);
2241
        }
2242
    }
2243
    return 0;
2244
}
2245

    
2246
//FIXME merge with compute_pkt_fields
2247
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2248
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2249
    int num, den, frame_size, i;
2250

    
2251
//    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);
2252

    
2253
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2254
        return -1;*/
2255

    
2256
    /* duration field */
2257
    if (pkt->duration == 0) {
2258
        compute_frame_duration(&num, &den, st, NULL, pkt);
2259
        if (den && num) {
2260
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2261
        }
2262
    }
2263

    
2264
    //XXX/FIXME this is a temporary hack until all encoders output pts
2265
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2266
        pkt->dts=
2267
//        pkt->pts= st->cur_dts;
2268
        pkt->pts= st->pts.val;
2269
    }
2270

    
2271
    //calculate dts from pts
2272
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2273
        st->pts_buffer[0]= pkt->pts;
2274
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2275
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2276
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2277
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2278

    
2279
        pkt->dts= st->pts_buffer[0];
2280
    }
2281

    
2282
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2283
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2284
        return -1;
2285
    }
2286
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2287
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2288
        return -1;
2289
    }
2290

    
2291
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2292
    st->cur_dts= pkt->dts;
2293
    st->pts.val= pkt->dts;
2294

    
2295
    /* update pts */
2296
    switch (st->codec->codec_type) {
2297
    case CODEC_TYPE_AUDIO:
2298
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2299

    
2300
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2301
           but it would be better if we had the real timestamps from the encoder */
2302
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2303
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2304
        }
2305
        break;
2306
    case CODEC_TYPE_VIDEO:
2307
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2308
        break;
2309
    default:
2310
        break;
2311
    }
2312
    return 0;
2313
}
2314

    
2315
static void truncate_ts(AVStream *st, AVPacket *pkt){
2316
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2317

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

    
2321
    if (pkt->pts != AV_NOPTS_VALUE)
2322
        pkt->pts &= pts_mask;
2323
    if (pkt->dts != AV_NOPTS_VALUE)
2324
        pkt->dts &= pts_mask;
2325
}
2326

    
2327
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2328
{
2329
    int ret;
2330

    
2331
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2332
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2333
        return ret;
2334

    
2335
    truncate_ts(s->streams[pkt->stream_index], pkt);
2336

    
2337
    ret= s->oformat->write_packet(s, pkt);
2338
    if(!ret)
2339
        ret= url_ferror(s->pb);
2340
    return ret;
2341
}
2342

    
2343
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2344
    AVPacketList *pktl, **next_point, *this_pktl;
2345
    int stream_count=0;
2346
    int streams[MAX_STREAMS];
2347

    
2348
    if(pkt){
2349
        AVStream *st= s->streams[ pkt->stream_index];
2350

    
2351
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2352

    
2353
        this_pktl = av_mallocz(sizeof(AVPacketList));
2354
        this_pktl->pkt= *pkt;
2355
        if(pkt->destruct == av_destruct_packet)
2356
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2357
        else
2358
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2359

    
2360
        next_point = &s->packet_buffer;
2361
        while(*next_point){
2362
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2363
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2364
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2365
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2366
                break;
2367
            next_point= &(*next_point)->next;
2368
        }
2369
        this_pktl->next= *next_point;
2370
        *next_point= this_pktl;
2371
    }
2372

    
2373
    memset(streams, 0, sizeof(streams));
2374
    pktl= s->packet_buffer;
2375
    while(pktl){
2376
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2377
        if(streams[ pktl->pkt.stream_index ] == 0)
2378
            stream_count++;
2379
        streams[ pktl->pkt.stream_index ]++;
2380
        pktl= pktl->next;
2381
    }
2382

    
2383
    if(s->nb_streams == stream_count || (flush && stream_count)){
2384
        pktl= s->packet_buffer;
2385
        *out= pktl->pkt;
2386

    
2387
        s->packet_buffer= pktl->next;
2388
        av_freep(&pktl);
2389
        return 1;
2390
    }else{
2391
        av_init_packet(out);
2392
        return 0;
2393
    }
2394
}
2395

    
2396
/**
2397
 * Interleaves a AVPacket correctly so it can be muxed.
2398
 * @param out the interleaved packet will be output here
2399
 * @param in the input packet
2400
 * @param flush 1 if no further packets are available as input and all
2401
 *              remaining packets should be output
2402
 * @return 1 if a packet was output, 0 if no packet could be output,
2403
 *         < 0 if an error occured
2404
 */
2405
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2406
    if(s->oformat->interleave_packet)
2407
        return s->oformat->interleave_packet(s, out, in, flush);
2408
    else
2409
        return av_interleave_packet_per_dts(s, out, in, flush);
2410
}
2411

    
2412
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2413
    AVStream *st= s->streams[ pkt->stream_index];
2414

    
2415
    //FIXME/XXX/HACK drop zero sized packets
2416
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2417
        return 0;
2418

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

    
2423
    if(pkt->dts == AV_NOPTS_VALUE)
2424
        return -1;
2425

    
2426
    for(;;){
2427
        AVPacket opkt;
2428
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2429
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2430
            return ret;
2431

    
2432
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2433
        ret= s->oformat->write_packet(s, &opkt);
2434

    
2435
        av_free_packet(&opkt);
2436
        pkt= NULL;
2437

    
2438
        if(ret<0)
2439
            return ret;
2440
        if(url_ferror(s->pb))
2441
            return url_ferror(s->pb);
2442
    }
2443
}
2444

    
2445
int av_write_trailer(AVFormatContext *s)
2446
{
2447
    int ret, i;
2448

    
2449
    for(;;){
2450
        AVPacket pkt;
2451
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2452
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2453
            goto fail;
2454
        if(!ret)
2455
            break;
2456

    
2457
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2458
        ret= s->oformat->write_packet(s, &pkt);
2459

    
2460
        av_free_packet(&pkt);
2461

    
2462
        if(ret<0)
2463
            goto fail;
2464
        if(url_ferror(s->pb))
2465
            goto fail;
2466
    }
2467

    
2468
    if(s->oformat->write_trailer)
2469
        ret = s->oformat->write_trailer(s);
2470
fail:
2471
    if(ret == 0)
2472
       ret=url_ferror(s->pb);
2473
    for(i=0;i<s->nb_streams;i++)
2474
        av_freep(&s->streams[i]->priv_data);
2475
    av_freep(&s->priv_data);
2476
    return ret;
2477
}
2478

    
2479
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2480
{
2481
    int i, j;
2482
    AVProgram *program=NULL;
2483
    void *tmp;
2484

    
2485
    for(i=0; i<ac->nb_programs; i++){
2486
        if(ac->programs[i]->id != progid)
2487
            continue;
2488
        program = ac->programs[i];
2489
        for(j=0; j<program->nb_stream_indexes; j++)
2490
            if(program->stream_index[j] == idx)
2491
                return;
2492

    
2493
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2494
        if(!tmp)
2495
            return;
2496
        program->stream_index = tmp;
2497
        program->stream_index[program->nb_stream_indexes++] = idx;
2498
        return;
2499
    }
2500
}
2501

    
2502
/* "user interface" functions */
2503
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2504
{
2505
    char buf[256];
2506
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2507
    AVStream *st = ic->streams[i];
2508
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2509
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2510
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2511
    /* the pid is an important information, so we display it */
2512
    /* XXX: add a generic system */
2513
    if (flags & AVFMT_SHOW_IDS)
2514
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2515
    if (strlen(st->language) > 0)
2516
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2517
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2518
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2519
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2520
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2521
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2522
/*      else if(st->time_base.den && st->time_base.num)
2523
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2524
        else
2525
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2526
    }
2527
    av_log(NULL, AV_LOG_INFO, "\n");
2528
}
2529

    
2530
void dump_format(AVFormatContext *ic,
2531
                 int index,
2532
                 const char *url,
2533
                 int is_output)
2534
{
2535
    int i;
2536

    
2537
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2538
            is_output ? "Output" : "Input",
2539
            index,
2540
            is_output ? ic->oformat->name : ic->iformat->name,
2541
            is_output ? "to" : "from", url);
2542
    if (!is_output) {
2543
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2544
        if (ic->duration != AV_NOPTS_VALUE) {
2545
            int hours, mins, secs, us;
2546
            secs = ic->duration / AV_TIME_BASE;
2547
            us = ic->duration % AV_TIME_BASE;
2548
            mins = secs / 60;
2549
            secs %= 60;
2550
            hours = mins / 60;
2551
            mins %= 60;
2552
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2553
                   (10 * us) / AV_TIME_BASE);
2554
        } else {
2555
            av_log(NULL, AV_LOG_INFO, "N/A");
2556
        }
2557
        if (ic->start_time != AV_NOPTS_VALUE) {
2558
            int secs, us;
2559
            av_log(NULL, AV_LOG_INFO, ", start: ");
2560
            secs = ic->start_time / AV_TIME_BASE;
2561
            us = ic->start_time % AV_TIME_BASE;
2562
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2563
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2564
        }
2565
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2566
        if (ic->bit_rate) {
2567
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2568
        } else {
2569
            av_log(NULL, AV_LOG_INFO, "N/A");
2570
        }
2571
        av_log(NULL, AV_LOG_INFO, "\n");
2572
    }
2573
    if(ic->nb_programs) {
2574
        int j, k;
2575
        for(j=0; j<ic->nb_programs; j++) {
2576
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2577
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2578
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2579
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2580
         }
2581
    } else
2582
    for(i=0;i<ic->nb_streams;i++)
2583
        dump_stream_format(ic, i, index, is_output);
2584
}
2585

    
2586
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2587
{
2588
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2589
}
2590

    
2591
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2592
{
2593
    AVRational frame_rate;
2594
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2595
    *frame_rate_num= frame_rate.num;
2596
    *frame_rate_den= frame_rate.den;
2597
    return ret;
2598
}
2599

    
2600
/**
2601
 * gets the current time in micro seconds.
2602
 */
2603
int64_t av_gettime(void)
2604
{
2605
    struct timeval tv;
2606
    gettimeofday(&tv,NULL);
2607
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2608
}
2609

    
2610
int64_t parse_date(const char *datestr, int duration)
2611
{
2612
    const char *p;
2613
    int64_t t;
2614
    struct tm dt;
2615
    int i;
2616
    static const char *date_fmt[] = {
2617
        "%Y-%m-%d",
2618
        "%Y%m%d",
2619
    };
2620
    static const char *time_fmt[] = {
2621
        "%H:%M:%S",
2622
        "%H%M%S",
2623
    };
2624
    const char *q;
2625
    int is_utc, len;
2626
    char lastch;
2627
    int negative = 0;
2628

    
2629
#undef time
2630
    time_t now = time(0);
2631

    
2632
    len = strlen(datestr);
2633
    if (len > 0)
2634
        lastch = datestr[len - 1];
2635
    else
2636
        lastch = '\0';
2637
    is_utc = (lastch == 'z' || lastch == 'Z');
2638

    
2639
    memset(&dt, 0, sizeof(dt));
2640

    
2641
    p = datestr;
2642
    q = NULL;
2643
    if (!duration) {
2644
        /* parse the year-month-day part */
2645
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2646
            q = small_strptime(p, date_fmt[i], &dt);
2647
            if (q) {
2648
                break;
2649
            }
2650
        }
2651

    
2652
        /* if the year-month-day part is missing, then take the
2653
         * current year-month-day time */
2654
        if (!q) {
2655
            if (is_utc) {
2656
                dt = *gmtime(&now);
2657
            } else {
2658
                dt = *localtime(&now);
2659
            }
2660
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2661
        } else {
2662
            p = q;
2663
        }
2664

    
2665
        if (*p == 'T' || *p == 't' || *p == ' ')
2666
            p++;
2667

    
2668
        /* parse the hour-minute-second part */
2669
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2670
            q = small_strptime(p, time_fmt[i], &dt);
2671
            if (q) {
2672
                break;
2673
            }
2674
        }
2675
    } else {
2676
        /* parse datestr as a duration */
2677
        if (p[0] == '-') {
2678
            negative = 1;
2679
            ++p;
2680
        }
2681
        /* parse datestr as HH:MM:SS */
2682
        q = small_strptime(p, time_fmt[0], &dt);
2683
        if (!q) {
2684
            /* parse datestr as S+ */
2685
            dt.tm_sec = strtol(p, (char **)&q, 10);
2686
            if (q == p)
2687
                /* the parsing didn't succeed */
2688
                return INT64_MIN;
2689
            dt.tm_min = 0;
2690
            dt.tm_hour = 0;
2691
        }
2692
    }
2693

    
2694
    /* Now we have all the fields that we can get */
2695
    if (!q) {
2696
        return INT64_MIN;
2697
    }
2698

    
2699
    if (duration) {
2700
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2701
    } else {
2702
        dt.tm_isdst = -1;       /* unknown */
2703
        if (is_utc) {
2704
            t = mktimegm(&dt);
2705
        } else {
2706
            t = mktime(&dt);
2707
        }
2708
    }
2709

    
2710
    t *= 1000000;
2711

    
2712
    /* parse the .m... part */
2713
    if (*q == '.') {
2714
        int val, n;
2715
        q++;
2716
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2717
            if (!isdigit(*q))
2718
                break;
2719
            val += n * (*q - '0');
2720
        }
2721
        t += val;
2722
    }
2723
    return negative ? -t : t;
2724
}
2725

    
2726
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2727
{
2728
    const char *p;
2729
    char tag[128], *q;
2730

    
2731
    p = info;
2732
    if (*p == '?')
2733
        p++;
2734
    for(;;) {
2735
        q = tag;
2736
        while (*p != '\0' && *p != '=' && *p != '&') {
2737
            if ((q - tag) < sizeof(tag) - 1)
2738
                *q++ = *p;
2739
            p++;
2740
        }
2741
        *q = '\0';
2742
        q = arg;
2743
        if (*p == '=') {
2744
            p++;
2745
            while (*p != '&' && *p != '\0') {
2746
                if ((q - arg) < arg_size - 1) {
2747
                    if (*p == '+')
2748
                        *q++ = ' ';
2749
                    else
2750
                        *q++ = *p;
2751
                }
2752
                p++;
2753
            }
2754
            *q = '\0';
2755
        }
2756
        if (!strcmp(tag, tag1))
2757
            return 1;
2758
        if (*p != '&')
2759
            break;
2760
        p++;
2761
    }
2762
    return 0;
2763
}
2764

    
2765
int av_get_frame_filename(char *buf, int buf_size,
2766
                          const char *path, int number)
2767
{
2768
    const char *p;
2769
    char *q, buf1[20], c;
2770
    int nd, len, percentd_found;
2771

    
2772
    q = buf;
2773
    p = path;
2774
    percentd_found = 0;
2775
    for(;;) {
2776
        c = *p++;
2777
        if (c == '\0')
2778
            break;
2779
        if (c == '%') {
2780
            do {
2781
                nd = 0;
2782
                while (isdigit(*p)) {
2783
                    nd = nd * 10 + *p++ - '0';
2784
                }
2785
                c = *p++;
2786
            } while (isdigit(c));
2787

    
2788
            switch(c) {
2789
            case '%':
2790
                goto addchar;
2791
            case 'd':
2792
                if (percentd_found)
2793
                    goto fail;
2794
                percentd_found = 1;
2795
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2796
                len = strlen(buf1);
2797
                if ((q - buf + len) > buf_size - 1)
2798
                    goto fail;
2799
                memcpy(q, buf1, len);
2800
                q += len;
2801
                break;
2802
            default:
2803
                goto fail;
2804
            }
2805
        } else {
2806
        addchar:
2807
            if ((q - buf) < buf_size - 1)
2808
                *q++ = c;
2809
        }
2810
    }
2811
    if (!percentd_found)
2812
        goto fail;
2813
    *q = '\0';
2814
    return 0;
2815
 fail:
2816
    *q = '\0';
2817
    return -1;
2818
}
2819

    
2820
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2821
{
2822
    int len, i, j, c;
2823
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2824

    
2825
    for(i=0;i<size;i+=16) {
2826
        len = size - i;
2827
        if (len > 16)
2828
            len = 16;
2829
        PRINT("%08x ", i);
2830
        for(j=0;j<16;j++) {
2831
            if (j < len)
2832
                PRINT(" %02x", buf[i+j]);
2833
            else
2834
                PRINT("   ");
2835
        }
2836
        PRINT(" ");
2837
        for(j=0;j<len;j++) {
2838
            c = buf[i+j];
2839
            if (c < ' ' || c > '~')
2840
                c = '.';
2841
            PRINT("%c", c);
2842
        }
2843
        PRINT("\n");
2844
    }
2845
#undef PRINT
2846
}
2847

    
2848
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2849
{
2850
    hex_dump_internal(NULL, f, 0, buf, size);
2851
}
2852

    
2853
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2854
{
2855
    hex_dump_internal(avcl, NULL, level, buf, size);
2856
}
2857

    
2858
 //FIXME needs to know the time_base
2859
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2860
{
2861
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2862
    PRINT("stream #%d:\n", pkt->stream_index);
2863
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2864
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2865
    /* DTS is _always_ valid after av_read_frame() */
2866
    PRINT("  dts=");
2867
    if (pkt->dts == AV_NOPTS_VALUE)
2868
        PRINT("N/A");
2869
    else
2870
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2871
    /* PTS may be not known if B frames are present */
2872
    PRINT("  pts=");
2873
    if (pkt->pts == AV_NOPTS_VALUE)
2874
        PRINT("N/A");
2875
    else
2876
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2877
    PRINT("\n");
2878
    PRINT("  size=%d\n", pkt->size);
2879
#undef PRINT
2880
    if (dump_payload)
2881
        av_hex_dump(f, pkt->data, pkt->size);
2882
}
2883

    
2884
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2885
{
2886
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2887
}
2888

    
2889
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2890
{
2891
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2892
}
2893

    
2894
void url_split(char *proto, int proto_size,
2895
               char *authorization, int authorization_size,
2896
               char *hostname, int hostname_size,
2897
               int *port_ptr,
2898
               char *path, int path_size,
2899
               const char *url)
2900
{
2901
    const char *p, *ls, *at, *col, *brk, *q;
2902

    
2903
    if (port_ptr)               *port_ptr = -1;
2904
    if (proto_size > 0)         proto[0] = 0;
2905
    if (authorization_size > 0) authorization[0] = 0;
2906
    if (hostname_size > 0)      hostname[0] = 0;
2907
    if (path_size > 0)          path[0] = 0;
2908

    
2909
    /* parse protocol */
2910
    if ((p = strchr(url, ':'))) {
2911
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2912
        p++; /* skip ':' */
2913
        if (*p == '/') p++;
2914
        if (*p == '/') p++;
2915
    } else {
2916
        /* no protocol means plain filename */
2917
        av_strlcpy(path, url, path_size);
2918
        return;
2919
    }
2920

    
2921
    /* separate path from hostname */
2922
    if ((ls = strchr(p, '/'))) {
2923
        if ((q = strchr(ls, '?')))
2924
            av_strlcpy(path, ls, FFMIN(path_size, q - ls + 1));
2925
        else
2926
            av_strlcpy(path, ls, path_size);
2927
    } else if (!(ls = strchr(p, '?')))
2928
        ls = &p[strlen(p)]; // XXX
2929

    
2930
    /* the rest is hostname, use that to parse auth/port */
2931
    if (ls != p) {
2932
        /* authorization (user[:pass]@hostname) */
2933
        if ((at = strchr(p, '@')) && at < ls) {
2934
            av_strlcpy(authorization, p,
2935
                       FFMIN(authorization_size, at + 1 - p));
2936
            p = at + 1; /* skip '@' */
2937
        }
2938

    
2939
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
2940
            /* [host]:port */
2941
            av_strlcpy(hostname, p + 1,
2942
                       FFMIN(hostname_size, brk - p));
2943
            if (brk[1] == ':' && port_ptr)
2944
                *port_ptr = atoi(brk + 2);
2945
        } else if ((col = strchr(p, ':')) && col < ls) {
2946
            av_strlcpy(hostname, p,
2947
                       FFMIN(col + 1 - p, hostname_size));
2948
            if (port_ptr) *port_ptr = atoi(col + 1);
2949
        } else
2950
            av_strlcpy(hostname, p,
2951
                       FFMIN(ls + 1 - p, hostname_size));
2952
    }
2953
}
2954

    
2955
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2956
                     int pts_num, int pts_den)
2957
{
2958
    s->pts_wrap_bits = pts_wrap_bits;
2959
    s->time_base.num = pts_num;
2960
    s->time_base.den = pts_den;
2961
}
2962

    
2963
/* fraction handling */
2964

    
2965
/**
2966
 * f = val + (num / den) + 0.5.
2967
 *
2968
 * 'num' is normalized so that it is such as 0 <= num < den.
2969
 *
2970
 * @param f fractional number
2971
 * @param val integer value
2972
 * @param num must be >= 0
2973
 * @param den must be >= 1
2974
 */
2975
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2976
{
2977
    num += (den >> 1);
2978
    if (num >= den) {
2979
        val += num / den;
2980
        num = num % den;
2981
    }
2982
    f->val = val;
2983
    f->num = num;
2984
    f->den = den;
2985
}
2986

    
2987
/**
2988
 * Fractionnal addition to f: f = f + (incr / f->den).
2989
 *
2990
 * @param f fractional number
2991
 * @param incr increment, can be positive or negative
2992
 */
2993
static void av_frac_add(AVFrac *f, int64_t incr)
2994
{
2995
    int64_t num, den;
2996

    
2997
    num = f->num + incr;
2998
    den = f->den;
2999
    if (num < 0) {
3000
        f->val += num / den;
3001
        num = num % den;
3002
        if (num < 0) {
3003
            num += den;
3004
            f->val--;
3005
        }
3006
    } else if (num >= den) {
3007
        f->val += num / den;
3008
        num = num % den;
3009
    }
3010
    f->num = num;
3011
}