Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ efd5fc53

History | View | Annotate | Download (89.4 KB)

1
/*
2
 * Various utilities for ffmpeg system
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#include "avformat.h"
22
#include "allformats.h"
23
#include "opt.h"
24

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

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

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

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

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

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

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

    
64
    if(!filename)
65
        return 0;
66

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

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

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

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

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

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

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

    
139
    return fmt;
140
}
141

    
142
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
143
                            const char *filename, const char *mime_type, enum CodecType type){
144
    if(type == CODEC_TYPE_VIDEO){
145
        enum CodecID codec_id= CODEC_ID_NONE;
146

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

    
161
AVInputFormat *av_find_input_format(const char *short_name)
162
{
163
    AVInputFormat *fmt;
164
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
165
        if (!strcmp(fmt->name, short_name))
166
            return fmt;
167
    }
168
    return NULL;
169
}
170

    
171
/* memory handling */
172

    
173
void av_destruct_packet(AVPacket *pkt)
174
{
175
    av_free(pkt->data);
176
    pkt->data = NULL; pkt->size = 0;
177
}
178

    
179
int av_new_packet(AVPacket *pkt, int size)
180
{
181
    uint8_t *data;
182
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
183
        return AVERROR_NOMEM;
184
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
185
    if (!data)
186
        return AVERROR_NOMEM;
187
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
188

    
189
    av_init_packet(pkt);
190
    pkt->data = data;
191
    pkt->size = size;
192
    pkt->destruct = av_destruct_packet;
193
    return 0;
194
}
195

    
196
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
197
{
198
    int ret= av_new_packet(pkt, size);
199

    
200
    if(ret<0)
201
        return ret;
202

    
203
    pkt->pos= url_ftell(s);
204

    
205
    ret= get_buffer(s, pkt->data, size);
206
    if(ret<=0)
207
        av_free_packet(pkt);
208
    else
209
        pkt->size= ret;
210

    
211
    return ret;
212
}
213

    
214
int av_dup_packet(AVPacket *pkt)
215
{
216
    if (pkt->destruct != av_destruct_packet) {
217
        uint8_t *data;
218
        /* we duplicate the packet and don't forget to put the padding
219
           again */
220
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
221
            return AVERROR_NOMEM;
222
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
223
        if (!data) {
224
            return AVERROR_NOMEM;
225
        }
226
        memcpy(data, pkt->data, pkt->size);
227
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
228
        pkt->data = data;
229
        pkt->destruct = av_destruct_packet;
230
    }
231
    return 0;
232
}
233

    
234
int av_filename_number_test(const char *filename)
235
{
236
    char buf[1024];
237
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
238
}
239

    
240
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
241
{
242
    AVInputFormat *fmt1, *fmt;
243
    int score;
244

    
245
    fmt = NULL;
246
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
247
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
248
            continue;
249
        score = 0;
250
        if (fmt1->read_probe) {
251
            score = fmt1->read_probe(pd);
252
        } else if (fmt1->extensions) {
253
            if (match_ext(pd->filename, fmt1->extensions)) {
254
                score = 50;
255
            }
256
        }
257
        if (score > *score_max) {
258
            *score_max = score;
259
            fmt = fmt1;
260
        }
261
    }
262
    return fmt;
263
}
264

    
265
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
266
    int score=0;
267
    return av_probe_input_format2(pd, is_opened, &score);
268
}
269

    
270
/************************************************************/
271
/* input media file */
272

    
273
/**
274
 * Open a media file from an IO stream. 'fmt' must be specified.
275
 */
276
static const char* format_to_name(void* ptr)
277
{
278
    AVFormatContext* fc = (AVFormatContext*) ptr;
279
    if(fc->iformat) return fc->iformat->name;
280
    else if(fc->oformat) return fc->oformat->name;
281
    else return "NULL";
282
}
283

    
284
#define OFFSET(x) offsetof(AVFormatContext,x)
285
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
286
//these names are too long to be readable
287
#define E AV_OPT_FLAG_ENCODING_PARAM
288
#define D AV_OPT_FLAG_DECODING_PARAM
289

    
290
static const AVOption options[]={
291
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
292
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
293
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
294
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
295
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
296
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
297
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
298
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
299
{"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},
300
{NULL},
301
};
302

    
303
#undef E
304
#undef D
305
#undef DEFAULT
306

    
307
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
308

    
309
static void avformat_get_context_defaults(AVFormatContext *s)
310
{
311
    memset(s, 0, sizeof(AVFormatContext));
312

    
313
    s->av_class = &av_format_context_class;
314

    
315
    av_opt_set_defaults(s);
316
}
317

    
318
AVFormatContext *av_alloc_format_context(void)
319
{
320
    AVFormatContext *ic;
321
    ic = av_malloc(sizeof(AVFormatContext));
322
    if (!ic) return ic;
323
    avformat_get_context_defaults(ic);
324
    ic->av_class = &av_format_context_class;
325
    return ic;
326
}
327

    
328
int av_open_input_stream(AVFormatContext **ic_ptr,
329
                         ByteIOContext *pb, const char *filename,
330
                         AVInputFormat *fmt, AVFormatParameters *ap)
331
{
332
    int err;
333
    AVFormatContext *ic;
334
    AVFormatParameters default_ap;
335

    
336
    if(!ap){
337
        ap=&default_ap;
338
        memset(ap, 0, sizeof(default_ap));
339
    }
340

    
341
    if(!ap->prealloced_context)
342
        ic = av_alloc_format_context();
343
    else
344
        ic = *ic_ptr;
345
    if (!ic) {
346
        err = AVERROR_NOMEM;
347
        goto fail;
348
    }
349
    ic->iformat = fmt;
350
    if (pb)
351
        ic->pb = *pb;
352
    ic->duration = AV_NOPTS_VALUE;
353
    ic->start_time = AV_NOPTS_VALUE;
354
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
355

    
356
    /* allocate private data */
357
    if (fmt->priv_data_size > 0) {
358
        ic->priv_data = av_mallocz(fmt->priv_data_size);
359
        if (!ic->priv_data) {
360
            err = AVERROR_NOMEM;
361
            goto fail;
362
        }
363
    } else {
364
        ic->priv_data = NULL;
365
    }
366

    
367
    err = ic->iformat->read_header(ic, ap);
368
    if (err < 0)
369
        goto fail;
370

    
371
    if (pb && !ic->data_offset)
372
        ic->data_offset = url_ftell(&ic->pb);
373

    
374
    *ic_ptr = ic;
375
    return 0;
376
 fail:
377
    if (ic) {
378
        av_freep(&ic->priv_data);
379
    }
380
    av_free(ic);
381
    *ic_ptr = NULL;
382
    return err;
383
}
384

    
385
/** Size of probe buffer, for guessing file type from file contents. */
386
#define PROBE_BUF_MIN 2048
387
#define PROBE_BUF_MAX (1<<20)
388

    
389
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
390
                       AVInputFormat *fmt,
391
                       int buf_size,
392
                       AVFormatParameters *ap)
393
{
394
    int err, must_open_file, file_opened, probe_size;
395
    AVProbeData probe_data, *pd = &probe_data;
396
    ByteIOContext pb1, *pb = &pb1;
397

    
398
    file_opened = 0;
399
    pd->filename = "";
400
    if (filename)
401
        pd->filename = filename;
402
    pd->buf = NULL;
403
    pd->buf_size = 0;
404

    
405
    if (!fmt) {
406
        /* guess format if no file can be opened  */
407
        fmt = av_probe_input_format(pd, 0);
408
    }
409

    
410
    /* do not open file if the format does not need it. XXX: specific
411
       hack needed to handle RTSP/TCP */
412
    must_open_file = 1;
413
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
414
        must_open_file = 0;
415
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
416
    }
417

    
418
    if (!fmt || must_open_file) {
419
        /* if no file needed do not try to open one */
420
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
421
            err = AVERROR_IO;
422
            goto fail;
423
        }
424
        file_opened = 1;
425
        if (buf_size > 0) {
426
            url_setbufsize(pb, buf_size);
427
        }
428

    
429
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
430
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
431
            /* read probe data */
432
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
433
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
434
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
435
                url_fclose(pb);
436
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
437
                    file_opened = 0;
438
                    err = AVERROR_IO;
439
                    goto fail;
440
                }
441
            }
442
            /* guess file format */
443
            fmt = av_probe_input_format2(pd, 1, &score);
444
        }
445
        av_freep(&pd->buf);
446
    }
447

    
448
    /* if still no format found, error */
449
    if (!fmt) {
450
        err = AVERROR_NOFMT;
451
        goto fail;
452
    }
453

    
454
    /* XXX: suppress this hack for redirectors */
455
#ifdef CONFIG_REDIR_DEMUXER
456
    if (fmt == &redir_demuxer) {
457
        err = redir_open(ic_ptr, pb);
458
        url_fclose(pb);
459
        return err;
460
    }
461
#endif
462

    
463
    /* check filename in case of an image number is expected */
464
    if (fmt->flags & AVFMT_NEEDNUMBER) {
465
        if (!av_filename_number_test(filename)) {
466
            err = AVERROR_NUMEXPECTED;
467
            goto fail;
468
        }
469
    }
470
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
471
    if (err)
472
        goto fail;
473
    return 0;
474
 fail:
475
    av_freep(&pd->buf);
476
    if (file_opened)
477
        url_fclose(pb);
478
    *ic_ptr = NULL;
479
    return err;
480

    
481
}
482

    
483
/*******************************************************/
484

    
485
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
486
{
487
    av_init_packet(pkt);
488
    return s->iformat->read_packet(s, pkt);
489
}
490

    
491
/**********************************************************/
492

    
493
/**
494
 * Get the number of samples of an audio frame. Return (-1) if error.
495
 */
496
static int get_audio_frame_size(AVCodecContext *enc, int size)
497
{
498
    int frame_size;
499

    
500
    if (enc->frame_size <= 1) {
501
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
502

    
503
        if (bits_per_sample) {
504
            if (enc->channels == 0)
505
                return -1;
506
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
507
        } else {
508
            /* used for example by ADPCM codecs */
509
            if (enc->bit_rate == 0)
510
                return -1;
511
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
512
        }
513
    } else {
514
        frame_size = enc->frame_size;
515
    }
516
    return frame_size;
517
}
518

    
519

    
520
/**
521
 * Return the frame duration in seconds, return 0 if not available.
522
 */
523
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
524
                                   AVCodecParserContext *pc, AVPacket *pkt)
525
{
526
    int frame_size;
527

    
528
    *pnum = 0;
529
    *pden = 0;
530
    switch(st->codec->codec_type) {
531
    case CODEC_TYPE_VIDEO:
532
        if(st->time_base.num*1000LL > st->time_base.den){
533
            *pnum = st->time_base.num;
534
            *pden = st->time_base.den;
535
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
536
            *pnum = st->codec->time_base.num;
537
            *pden = st->codec->time_base.den;
538
            if (pc && pc->repeat_pict) {
539
                *pden *= 2;
540
                *pnum = (*pnum) * (2 + pc->repeat_pict);
541
            }
542
        }
543
        break;
544
    case CODEC_TYPE_AUDIO:
545
        frame_size = get_audio_frame_size(st->codec, pkt->size);
546
        if (frame_size < 0)
547
            break;
548
        *pnum = frame_size;
549
        *pden = st->codec->sample_rate;
550
        break;
551
    default:
552
        break;
553
    }
554
}
555

    
556
static int is_intra_only(AVCodecContext *enc){
557
    if(enc->codec_type == CODEC_TYPE_AUDIO){
558
        return 1;
559
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
560
        switch(enc->codec_id){
561
        case CODEC_ID_MJPEG:
562
        case CODEC_ID_MJPEGB:
563
        case CODEC_ID_LJPEG:
564
        case CODEC_ID_RAWVIDEO:
565
        case CODEC_ID_DVVIDEO:
566
        case CODEC_ID_HUFFYUV:
567
        case CODEC_ID_FFVHUFF:
568
        case CODEC_ID_ASV1:
569
        case CODEC_ID_ASV2:
570
        case CODEC_ID_VCR1:
571
            return 1;
572
        default: break;
573
        }
574
    }
575
    return 0;
576
}
577

    
578
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
579
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
580
    int64_t delta= last_ts - mask/2;
581
    return  ((lsb - delta)&mask) + delta;
582
}
583

    
584
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
585
                               AVCodecParserContext *pc, AVPacket *pkt)
586
{
587
    int num, den, presentation_delayed, delay, i;
588
    int64_t offset;
589
    /* handle wrapping */
590
    if(st->cur_dts != AV_NOPTS_VALUE){
591
        if(pkt->pts != AV_NOPTS_VALUE)
592
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
593
        if(pkt->dts != AV_NOPTS_VALUE)
594
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
595
    }
596

    
597
    if (pkt->duration == 0) {
598
        compute_frame_duration(&num, &den, st, pc, pkt);
599
        if (den && num) {
600
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
601
        }
602
    }
603

    
604
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
605
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
606
        /* this will estimate bitrate based on this frame's duration and size */
607
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
608
        if(pkt->pts != AV_NOPTS_VALUE)
609
            pkt->pts += offset;
610
        if(pkt->dts != AV_NOPTS_VALUE)
611
            pkt->dts += offset;
612
    }
613

    
614
    if(is_intra_only(st->codec))
615
        pkt->flags |= PKT_FLAG_KEY;
616

    
617
    /* do we have a video B frame ? */
618
    delay= st->codec->has_b_frames;
619
    presentation_delayed = 0;
620
    /* XXX: need has_b_frame, but cannot get it if the codec is
621
        not initialized */
622
    if (delay &&
623
        pc && pc->pict_type != FF_B_TYPE)
624
        presentation_delayed = 1;
625
    /* this may be redundant, but it shouldnt hurt */
626
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
627
        presentation_delayed = 1;
628

    
629
    if(st->cur_dts == AV_NOPTS_VALUE){
630
        st->cur_dts = -delay * pkt->duration;
631
    }
632

    
633
//    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);
634
    /* interpolate PTS and DTS if they are not present */
635
    if(delay <=1){
636
        if (presentation_delayed) {
637
            /* DTS = decompression time stamp */
638
            /* PTS = presentation time stamp */
639
            if (pkt->dts == AV_NOPTS_VALUE)
640
                pkt->dts = st->last_IP_pts;
641
            if (pkt->dts == AV_NOPTS_VALUE)
642
                pkt->dts = st->cur_dts;
643

    
644
            /* this is tricky: the dts must be incremented by the duration
645
            of the frame we are displaying, i.e. the last I or P frame */
646
            if (st->last_IP_duration == 0)
647
                st->last_IP_duration = pkt->duration;
648
            st->cur_dts = pkt->dts + st->last_IP_duration;
649
            st->last_IP_duration  = pkt->duration;
650
            st->last_IP_pts= pkt->pts;
651
            /* cannot compute PTS if not present (we can compute it only
652
            by knowing the futur */
653
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
654
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
655
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
656
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
657
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
658
                    pkt->pts += pkt->duration;
659
    //                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);
660
                }
661
            }
662

    
663
            /* presentation is not delayed : PTS and DTS are the same */
664
            if(pkt->pts == AV_NOPTS_VALUE)
665
                pkt->pts = pkt->dts;
666
            if(pkt->pts == AV_NOPTS_VALUE)
667
                pkt->pts = st->cur_dts;
668
            pkt->dts = pkt->pts;
669
            st->cur_dts = pkt->pts + pkt->duration;
670
        }
671
    }
672

    
673
    if(pkt->pts != AV_NOPTS_VALUE){
674
        st->pts_buffer[0]= pkt->pts;
675
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
676
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
677
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
678
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
679
        if(pkt->dts == AV_NOPTS_VALUE)
680
            pkt->dts= st->pts_buffer[0];
681
        if(pkt->dts > st->cur_dts)
682
            st->cur_dts = pkt->dts;
683
    }
684

    
685
//    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);
686

    
687
    /* update flags */
688
    if (pc) {
689
        pkt->flags = 0;
690
        /* key frame computation */
691
            if (pc->pict_type == FF_I_TYPE)
692
                pkt->flags |= PKT_FLAG_KEY;
693
    }
694
}
695

    
696
void av_destruct_packet_nofree(AVPacket *pkt)
697
{
698
    pkt->data = NULL; pkt->size = 0;
699
}
700

    
701
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
702
{
703
    AVStream *st;
704
    int len, ret, i;
705

    
706
    av_init_packet(pkt);
707

    
708
    for(;;) {
709
        /* select current input stream component */
710
        st = s->cur_st;
711
        if (st) {
712
            if (!st->need_parsing || !st->parser) {
713
                /* no parsing needed: we just output the packet as is */
714
                /* raw data support */
715
                *pkt = s->cur_pkt;
716
                compute_pkt_fields(s, st, NULL, pkt);
717
                s->cur_st = NULL;
718
                break;
719
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
720
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
721
                                      s->cur_ptr, s->cur_len,
722
                                      s->cur_pkt.pts, s->cur_pkt.dts);
723
                s->cur_pkt.pts = AV_NOPTS_VALUE;
724
                s->cur_pkt.dts = AV_NOPTS_VALUE;
725
                /* increment read pointer */
726
                s->cur_ptr += len;
727
                s->cur_len -= len;
728

    
729
                /* return packet if any */
730
                if (pkt->size) {
731
                got_packet:
732
                    pkt->duration = 0;
733
                    pkt->stream_index = st->index;
734
                    pkt->pts = st->parser->pts;
735
                    pkt->dts = st->parser->dts;
736
                    pkt->destruct = av_destruct_packet_nofree;
737
                    compute_pkt_fields(s, st, st->parser, pkt);
738

    
739
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
740
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
741
                                           0, 0, AVINDEX_KEYFRAME);
742
                    }
743

    
744
                    break;
745
                }
746
            } else {
747
                /* free packet */
748
                av_free_packet(&s->cur_pkt);
749
                s->cur_st = NULL;
750
            }
751
        } else {
752
            /* read next packet */
753
            ret = av_read_packet(s, &s->cur_pkt);
754
            if (ret < 0) {
755
                if (ret == AVERROR(EAGAIN))
756
                    return ret;
757
                /* return the last frames, if any */
758
                for(i = 0; i < s->nb_streams; i++) {
759
                    st = s->streams[i];
760
                    if (st->parser && st->need_parsing) {
761
                        av_parser_parse(st->parser, st->codec,
762
                                        &pkt->data, &pkt->size,
763
                                        NULL, 0,
764
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
765
                        if (pkt->size)
766
                            goto got_packet;
767
                    }
768
                }
769
                /* no more packets: really terminates parsing */
770
                return ret;
771
            }
772

    
773
            st = s->streams[s->cur_pkt.stream_index];
774
            if(st->codec->debug & FF_DEBUG_PTS)
775
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
776
                    s->cur_pkt.stream_index,
777
                    s->cur_pkt.pts,
778
                    s->cur_pkt.dts,
779
                    s->cur_pkt.size);
780

    
781
            s->cur_st = st;
782
            s->cur_ptr = s->cur_pkt.data;
783
            s->cur_len = s->cur_pkt.size;
784
            if (st->need_parsing && !st->parser) {
785
                st->parser = av_parser_init(st->codec->codec_id);
786
                if (!st->parser) {
787
                    /* no parser available : just output the raw packets */
788
                    st->need_parsing = AVSTREAM_PARSE_NONE;
789
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
790
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
791
                }
792
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
793
                    st->parser->last_frame_offset=
794
                    st->parser->cur_offset= s->cur_pkt.pos;
795
                }
796
            }
797
        }
798
    }
799
    if(st->codec->debug & FF_DEBUG_PTS)
800
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
801
            pkt->stream_index,
802
            pkt->pts,
803
            pkt->dts,
804
            pkt->size);
805

    
806
    return 0;
807
}
808

    
809
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
810
{
811
    AVPacketList *pktl;
812
    int eof=0;
813
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
814

    
815
    for(;;){
816
        pktl = s->packet_buffer;
817
        if (pktl) {
818
            AVPacket *next_pkt= &pktl->pkt;
819

    
820
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
821
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
822
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
823
                       && next_pkt->dts < pktl->pkt.dts
824
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
825
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
826
                        next_pkt->pts= pktl->pkt.dts;
827
                    }
828
                    pktl= pktl->next;
829
                }
830
                pktl = s->packet_buffer;
831
            }
832

    
833
            if(   next_pkt->pts != AV_NOPTS_VALUE
834
               || next_pkt->dts == AV_NOPTS_VALUE
835
               || !genpts || eof){
836
                /* read packet from packet buffer, if there is data */
837
                *pkt = *next_pkt;
838
                s->packet_buffer = pktl->next;
839
                av_free(pktl);
840
                return 0;
841
            }
842
        }
843
        if(genpts){
844
            AVPacketList **plast_pktl= &s->packet_buffer;
845
            int ret= av_read_frame_internal(s, pkt);
846
            if(ret<0){
847
                if(pktl && ret != AVERROR(EAGAIN)){
848
                    eof=1;
849
                    continue;
850
                }else
851
                    return ret;
852
            }
853

    
854
            /* duplicate the packet */
855
            if (av_dup_packet(pkt) < 0)
856
                return AVERROR_NOMEM;
857

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

    
860
            pktl = av_mallocz(sizeof(AVPacketList));
861
            if (!pktl)
862
                return AVERROR_NOMEM;
863

    
864
            /* add the packet in the buffered packet list */
865
            *plast_pktl = pktl;
866
            pktl->pkt= *pkt;
867
        }else{
868
            assert(!s->packet_buffer);
869
            return av_read_frame_internal(s, pkt);
870
        }
871
    }
872
}
873

    
874
/* XXX: suppress the packet queue */
875
static void flush_packet_queue(AVFormatContext *s)
876
{
877
    AVPacketList *pktl;
878

    
879
    for(;;) {
880
        pktl = s->packet_buffer;
881
        if (!pktl)
882
            break;
883
        s->packet_buffer = pktl->next;
884
        av_free_packet(&pktl->pkt);
885
        av_free(pktl);
886
    }
887
}
888

    
889
/*******************************************************/
890
/* seek support */
891

    
892
int av_find_default_stream_index(AVFormatContext *s)
893
{
894
    int i;
895
    AVStream *st;
896

    
897
    if (s->nb_streams <= 0)
898
        return -1;
899
    for(i = 0; i < s->nb_streams; i++) {
900
        st = s->streams[i];
901
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
902
            return i;
903
        }
904
    }
905
    return 0;
906
}
907

    
908
/**
909
 * Flush the frame reader.
910
 */
911
static void av_read_frame_flush(AVFormatContext *s)
912
{
913
    AVStream *st;
914
    int i;
915

    
916
    flush_packet_queue(s);
917

    
918
    /* free previous packet */
919
    if (s->cur_st) {
920
        if (s->cur_st->parser)
921
            av_free_packet(&s->cur_pkt);
922
        s->cur_st = NULL;
923
    }
924
    /* fail safe */
925
    s->cur_ptr = NULL;
926
    s->cur_len = 0;
927

    
928
    /* for each stream, reset read state */
929
    for(i = 0; i < s->nb_streams; i++) {
930
        st = s->streams[i];
931

    
932
        if (st->parser) {
933
            av_parser_close(st->parser);
934
            st->parser = NULL;
935
        }
936
        st->last_IP_pts = AV_NOPTS_VALUE;
937
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
938
    }
939
}
940

    
941
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
942
    int i;
943

    
944
    for(i = 0; i < s->nb_streams; i++) {
945
        AVStream *st = s->streams[i];
946

    
947
        st->cur_dts = av_rescale(timestamp,
948
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
949
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
950
    }
951
}
952

    
953
int av_add_index_entry(AVStream *st,
954
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
955
{
956
    AVIndexEntry *entries, *ie;
957
    int index;
958

    
959
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
960
        return -1;
961

    
962
    entries = av_fast_realloc(st->index_entries,
963
                              &st->index_entries_allocated_size,
964
                              (st->nb_index_entries + 1) *
965
                              sizeof(AVIndexEntry));
966
    if(!entries)
967
        return -1;
968

    
969
    st->index_entries= entries;
970

    
971
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
972

    
973
    if(index<0){
974
        index= st->nb_index_entries++;
975
        ie= &entries[index];
976
        assert(index==0 || ie[-1].timestamp < timestamp);
977
    }else{
978
        ie= &entries[index];
979
        if(ie->timestamp != timestamp){
980
            if(ie->timestamp <= timestamp)
981
                return -1;
982
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
983
            st->nb_index_entries++;
984
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
985
            distance= ie->min_distance;
986
    }
987

    
988
    ie->pos = pos;
989
    ie->timestamp = timestamp;
990
    ie->min_distance= distance;
991
    ie->size= size;
992
    ie->flags = flags;
993

    
994
    return index;
995
}
996

    
997
/**
998
 * build an index for raw streams using a parser.
999
 */
1000
static void av_build_index_raw(AVFormatContext *s)
1001
{
1002
    AVPacket pkt1, *pkt = &pkt1;
1003
    int ret;
1004
    AVStream *st;
1005

    
1006
    st = s->streams[0];
1007
    av_read_frame_flush(s);
1008
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1009

    
1010
    for(;;) {
1011
        ret = av_read_frame(s, pkt);
1012
        if (ret < 0)
1013
            break;
1014
        if (pkt->stream_index == 0 && st->parser &&
1015
            (pkt->flags & PKT_FLAG_KEY)) {
1016
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1017
                            0, 0, AVINDEX_KEYFRAME);
1018
        }
1019
        av_free_packet(pkt);
1020
    }
1021
}
1022

    
1023
/**
1024
 * Returns TRUE if we deal with a raw stream.
1025
 *
1026
 * Raw codec data and parsing needed.
1027
 */
1028
static int is_raw_stream(AVFormatContext *s)
1029
{
1030
    AVStream *st;
1031

    
1032
    if (s->nb_streams != 1)
1033
        return 0;
1034
    st = s->streams[0];
1035
    if (!st->need_parsing)
1036
        return 0;
1037
    return 1;
1038
}
1039

    
1040
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1041
                              int flags)
1042
{
1043
    AVIndexEntry *entries= st->index_entries;
1044
    int nb_entries= st->nb_index_entries;
1045
    int a, b, m;
1046
    int64_t timestamp;
1047

    
1048
    a = - 1;
1049
    b = nb_entries;
1050

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

    
1061
    if(!(flags & AVSEEK_FLAG_ANY)){
1062
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1063
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1064
        }
1065
    }
1066

    
1067
    if(m == nb_entries)
1068
        return -1;
1069
    return  m;
1070
}
1071

    
1072
#define DEBUG_SEEK
1073

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

    
1081
    if (stream_index < 0)
1082
        return -1;
1083

    
1084
#ifdef DEBUG_SEEK
1085
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1086
#endif
1087

    
1088
    ts_max=
1089
    ts_min= AV_NOPTS_VALUE;
1090
    pos_limit= -1; //gcc falsely says it may be uninitalized
1091

    
1092
    st= s->streams[stream_index];
1093
    if(st->index_entries){
1094
        AVIndexEntry *e;
1095

    
1096
        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()
1097
        index= FFMAX(index, 0);
1098
        e= &st->index_entries[index];
1099

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

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

    
1126
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1127
    if(pos<0)
1128
        return -1;
1129

    
1130
    /* do the seek */
1131
    url_fseek(&s->pb, pos, SEEK_SET);
1132

    
1133
    av_update_cur_dts(s, st, ts);
1134

    
1135
    return 0;
1136
}
1137

    
1138
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 )){
1139
    int64_t pos, ts;
1140
    int64_t start_pos, filesize;
1141
    int no_change;
1142

    
1143
#ifdef DEBUG_SEEK
1144
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1145
#endif
1146

    
1147
    if(ts_min == AV_NOPTS_VALUE){
1148
        pos_min = s->data_offset;
1149
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1150
        if (ts_min == AV_NOPTS_VALUE)
1151
            return -1;
1152
    }
1153

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

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

    
1179
    if(ts_min > ts_max){
1180
        return -1;
1181
    }else if(ts_min == ts_max){
1182
        pos_limit= pos_min;
1183
    }
1184

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

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

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

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

    
1250
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1251
    int64_t pos_min, pos_max;
1252
#if 0
1253
    AVStream *st;
1254

1255
    if (stream_index < 0)
1256
        return -1;
1257

1258
    st= s->streams[stream_index];
1259
#endif
1260

    
1261
    pos_min = s->data_offset;
1262
    pos_max = url_fsize(&s->pb) - 1;
1263

    
1264
    if     (pos < pos_min) pos= pos_min;
1265
    else if(pos > pos_max) pos= pos_max;
1266

    
1267
    url_fseek(&s->pb, pos, SEEK_SET);
1268

    
1269
#if 0
1270
    av_update_cur_dts(s, st, ts);
1271
#endif
1272
    return 0;
1273
}
1274

    
1275
static int av_seek_frame_generic(AVFormatContext *s,
1276
                                 int stream_index, int64_t timestamp, int flags)
1277
{
1278
    int index;
1279
    AVStream *st;
1280
    AVIndexEntry *ie;
1281

    
1282
    st = s->streams[stream_index];
1283

    
1284
    index = av_index_search_timestamp(st, timestamp, flags);
1285

    
1286
    if(index < 0 || index==st->nb_index_entries-1){
1287
        int i;
1288
        AVPacket pkt;
1289

    
1290
        if(st->index_entries && st->nb_index_entries){
1291
            ie= &st->index_entries[st->nb_index_entries-1];
1292
            url_fseek(&s->pb, ie->pos, SEEK_SET);
1293
            av_update_cur_dts(s, st, ie->timestamp);
1294
        }else
1295
            url_fseek(&s->pb, 0, SEEK_SET);
1296

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

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

    
1320
    av_update_cur_dts(s, st, ie->timestamp);
1321

    
1322
    return 0;
1323
}
1324

    
1325
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1326
{
1327
    int ret;
1328
    AVStream *st;
1329

    
1330
    av_read_frame_flush(s);
1331

    
1332
    if(flags & AVSEEK_FLAG_BYTE)
1333
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1334

    
1335
    if(stream_index < 0){
1336
        stream_index= av_find_default_stream_index(s);
1337
        if(stream_index < 0)
1338
            return -1;
1339

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

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

    
1355
    if(s->iformat->read_timestamp)
1356
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1357
    else
1358
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1359
}
1360

    
1361
/*******************************************************/
1362

    
1363
/**
1364
 * Returns TRUE if the stream has accurate timings in any stream.
1365
 *
1366
 * @return TRUE if the stream has accurate timings for at least one component.
1367
 */
1368
static int av_has_timings(AVFormatContext *ic)
1369
{
1370
    int i;
1371
    AVStream *st;
1372

    
1373
    for(i = 0;i < ic->nb_streams; i++) {
1374
        st = ic->streams[i];
1375
        if (st->start_time != AV_NOPTS_VALUE &&
1376
            st->duration != AV_NOPTS_VALUE)
1377
            return 1;
1378
    }
1379
    return 0;
1380
}
1381

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

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

    
1421
}
1422

    
1423
static void fill_all_stream_timings(AVFormatContext *ic)
1424
{
1425
    int i;
1426
    AVStream *st;
1427

    
1428
    av_update_stream_timings(ic);
1429
    for(i = 0;i < ic->nb_streams; i++) {
1430
        st = ic->streams[i];
1431
        if (st->start_time == AV_NOPTS_VALUE) {
1432
            if(ic->start_time != AV_NOPTS_VALUE)
1433
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1434
            if(ic->duration != AV_NOPTS_VALUE)
1435
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1436
        }
1437
    }
1438
}
1439

    
1440
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1441
{
1442
    int64_t filesize, duration;
1443
    int bit_rate, i;
1444
    AVStream *st;
1445

    
1446
    /* if bit_rate is already set, we believe it */
1447
    if (ic->bit_rate == 0) {
1448
        bit_rate = 0;
1449
        for(i=0;i<ic->nb_streams;i++) {
1450
            st = ic->streams[i];
1451
            bit_rate += st->codec->bit_rate;
1452
        }
1453
        ic->bit_rate = bit_rate;
1454
    }
1455

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

    
1475
#define DURATION_MAX_READ_SIZE 250000
1476

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

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

    
1491
    /* flush packet queue */
1492
    flush_packet_queue(ic);
1493

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

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

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

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

    
1537
    url_fseek(&ic->pb, offset, SEEK_SET);
1538
    read_size = 0;
1539
    for(;;) {
1540
        if (read_size >= DURATION_MAX_READ_SIZE)
1541
            break;
1542
        /* if all info is available, we can stop */
1543
        for(i = 0;i < ic->nb_streams; i++) {
1544
            st = ic->streams[i];
1545
            if (st->duration == AV_NOPTS_VALUE)
1546
                break;
1547
        }
1548
        if (i == ic->nb_streams)
1549
            break;
1550

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

    
1568
    fill_all_stream_timings(ic);
1569

    
1570
    url_fseek(&ic->pb, old_offset, SEEK_SET);
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_timings(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 (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
/* absolute maximum size we read until we abort */
1691
#define MAX_READ_SIZE        5000000
1692

    
1693
#define MAX_STD_TIMEBASES (60*12+5)
1694
static int get_std_framerate(int i){
1695
    if(i<60*12) return i*1001;
1696
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1697
}
1698

    
1699
int av_find_stream_info(AVFormatContext *ic)
1700
{
1701
    int i, count, ret, read_size, j;
1702
    AVStream *st;
1703
    AVPacket pkt1, *pkt;
1704
    AVPacketList *pktl=NULL, **ppktl;
1705
    int64_t last_dts[MAX_STREAMS];
1706
    int duration_count[MAX_STREAMS]={0};
1707
    double (*duration_error)[MAX_STD_TIMEBASES];
1708
    offset_t old_offset = url_ftell(&ic->pb);
1709
    int64_t codec_info_duration[MAX_STREAMS]={0};
1710
    int codec_info_nb_frames[MAX_STREAMS]={0};
1711
    AVProbeData probe_data[MAX_STREAMS];
1712
    int codec_identified[MAX_STREAMS]={0};
1713

    
1714
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1715
    if (!duration_error) return AVERROR_NOMEM;
1716

    
1717
    for(i=0;i<ic->nb_streams;i++) {
1718
        st = ic->streams[i];
1719
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1720
/*            if(!st->time_base.num)
1721
                st->time_base= */
1722
            if(!st->codec->time_base.num)
1723
                st->codec->time_base= st->time_base;
1724
        }
1725
        //only for the split stuff
1726
        if (!st->parser) {
1727
            st->parser = av_parser_init(st->codec->codec_id);
1728
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1729
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1730
            }
1731
        }
1732
    }
1733

    
1734
    for(i=0;i<MAX_STREAMS;i++){
1735
        last_dts[i]= AV_NOPTS_VALUE;
1736
    }
1737

    
1738
    memset(probe_data, 0, sizeof(probe_data));
1739
    count = 0;
1740
    read_size = 0;
1741
    ppktl = &ic->packet_buffer;
1742
    for(;;) {
1743
        /* check if one codec still needs to be handled */
1744
        for(i=0;i<ic->nb_streams;i++) {
1745
            st = ic->streams[i];
1746
            if (!has_codec_parameters(st->codec))
1747
                break;
1748
            /* variable fps and no guess at the real fps */
1749
            if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1750
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1751
                break;
1752
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1753
                break;
1754
            if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1755
                st->codec->codec_id == CODEC_ID_NONE)
1756
                break;
1757
        }
1758
        if (i == ic->nb_streams) {
1759
            /* NOTE: if the format has no header, then we need to read
1760
               some packets to get most of the streams, so we cannot
1761
               stop here */
1762
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1763
                /* if we found the info for all the codecs, we can stop */
1764
                ret = count;
1765
                break;
1766
            }
1767
        }
1768
        /* we did not get all the codec info, but we read too much data */
1769
        if (read_size >= MAX_READ_SIZE) {
1770
            ret = count;
1771
            break;
1772
        }
1773

    
1774
        /* NOTE: a new stream can be added there if no header in file
1775
           (AVFMTCTX_NOHEADER) */
1776
        ret = av_read_frame_internal(ic, &pkt1);
1777
        if (ret < 0) {
1778
            /* EOF or error */
1779
            ret = -1; /* we could not have all the codec parameters before EOF */
1780
            for(i=0;i<ic->nb_streams;i++) {
1781
                st = ic->streams[i];
1782
                if (!has_codec_parameters(st->codec)){
1783
                    char buf[256];
1784
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1785
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1786
                } else {
1787
                    ret = 0;
1788
                }
1789
            }
1790
            break;
1791
        }
1792

    
1793
        pktl = av_mallocz(sizeof(AVPacketList));
1794
        if (!pktl) {
1795
            ret = AVERROR_NOMEM;
1796
            break;
1797
        }
1798

    
1799
        /* add the packet in the buffered packet list */
1800
        *ppktl = pktl;
1801
        ppktl = &pktl->next;
1802

    
1803
        pkt = &pktl->pkt;
1804
        *pkt = pkt1;
1805

    
1806
        /* duplicate the packet */
1807
        if (av_dup_packet(pkt) < 0) {
1808
            ret = AVERROR_NOMEM;
1809
            break;
1810
        }
1811

    
1812
        read_size += pkt->size;
1813

    
1814
        st = ic->streams[pkt->stream_index];
1815
        if(codec_info_nb_frames[st->index]>1)
1816
            codec_info_duration[st->index] += pkt->duration;
1817
        if (pkt->duration != 0)
1818
            codec_info_nb_frames[st->index]++;
1819

    
1820
        {
1821
            int index= pkt->stream_index;
1822
            int64_t last= last_dts[index];
1823
            int64_t duration= pkt->dts - last;
1824

    
1825
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1826
                double dur= duration * av_q2d(st->time_base);
1827

    
1828
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1829
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1830
                if(duration_count[index] < 2)
1831
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1832
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1833
                    int framerate= get_std_framerate(i);
1834
                    int ticks= lrintf(dur*framerate/(1001*12));
1835
                    double error= dur - ticks*1001*12/(double)framerate;
1836
                    duration_error[index][i] += error*error;
1837
                }
1838
                duration_count[index]++;
1839
            }
1840
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1841
                last_dts[pkt->stream_index]= pkt->dts;
1842

    
1843
            if (st->codec->codec_id == CODEC_ID_NONE) {
1844
                AVProbeData *pd = &(probe_data[st->index]);
1845
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1846
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1847
                pd->buf_size += pkt->size;
1848
            }
1849
        }
1850
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1851
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1852
            if(i){
1853
                st->codec->extradata_size= i;
1854
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1855
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1856
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1857
            }
1858
        }
1859

    
1860
        /* if still no information, we try to open the codec and to
1861
           decompress the frame. We try to avoid that in most cases as
1862
           it takes longer and uses more memory. For MPEG4, we need to
1863
           decompress for Quicktime. */
1864
        if (!has_codec_parameters(st->codec) /*&&
1865
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1866
             st->codec->codec_id == CODEC_ID_H264 ||
1867
             st->codec->codec_id == CODEC_ID_H263 ||
1868
             st->codec->codec_id == CODEC_ID_H261 ||
1869
             st->codec->codec_id == CODEC_ID_VORBIS ||
1870
             st->codec->codec_id == CODEC_ID_MJPEG ||
1871
             st->codec->codec_id == CODEC_ID_PNG ||
1872
             st->codec->codec_id == CODEC_ID_PAM ||
1873
             st->codec->codec_id == CODEC_ID_PGM ||
1874
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1875
             st->codec->codec_id == CODEC_ID_PBM ||
1876
             st->codec->codec_id == CODEC_ID_PPM ||
1877
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1878
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1879
            try_decode_frame(st, pkt->data, pkt->size);
1880

    
1881
        if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1882
            break;
1883
        }
1884
        count++;
1885
    }
1886

    
1887
    // close codecs which where opened in try_decode_frame()
1888
    for(i=0;i<ic->nb_streams;i++) {
1889
        st = ic->streams[i];
1890
        if(st->codec->codec)
1891
            avcodec_close(st->codec);
1892
    }
1893
    for(i=0;i<ic->nb_streams;i++) {
1894
        st = ic->streams[i];
1895
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1896
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1897
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1898

    
1899
            if(duration_count[i]
1900
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1901
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1902
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1903
                double best_error= 2*av_q2d(st->time_base);
1904
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1905

    
1906
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1907
                    double error= duration_error[i][j] * get_std_framerate(j);
1908
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1909
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1910
                    if(error < best_error){
1911
                        best_error= error;
1912
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1913
                    }
1914
                }
1915
            }
1916

    
1917
            if (!st->r_frame_rate.num){
1918
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1919
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1920
                    st->r_frame_rate.num = st->codec->time_base.den;
1921
                    st->r_frame_rate.den = st->codec->time_base.num;
1922
                }else{
1923
                    st->r_frame_rate.num = st->time_base.den;
1924
                    st->r_frame_rate.den = st->time_base.num;
1925
                }
1926
            }
1927
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1928
            if (st->codec->codec_id == CODEC_ID_NONE) {
1929
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1930
                if (codec_identified[st->index]) {
1931
                    st->need_parsing = AVSTREAM_PARSE_FULL;
1932
                }
1933
            }
1934
            if(!st->codec->bits_per_sample)
1935
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1936
        }
1937
    }
1938

    
1939
    av_estimate_timings(ic, old_offset);
1940

    
1941
    for(i=0;i<ic->nb_streams;i++) {
1942
        st = ic->streams[i];
1943
        if (codec_identified[st->index]) {
1944
            av_read_frame_flush(ic);
1945
            av_seek_frame(ic, st->index, 0.0, 0);
1946
            url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1947
        }
1948
    }
1949

    
1950
#if 0
1951
    /* correct DTS for b frame streams with no timestamps */
1952
    for(i=0;i<ic->nb_streams;i++) {
1953
        st = ic->streams[i];
1954
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1955
            if(b-frames){
1956
                ppktl = &ic->packet_buffer;
1957
                while(ppkt1){
1958
                    if(ppkt1->stream_index != i)
1959
                        continue;
1960
                    if(ppkt1->pkt->dts < 0)
1961
                        break;
1962
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1963
                        break;
1964
                    ppkt1->pkt->dts -= delta;
1965
                    ppkt1= ppkt1->next;
1966
                }
1967
                if(ppkt1)
1968
                    continue;
1969
                st->cur_dts -= delta;
1970
            }
1971
        }
1972
    }
1973
#endif
1974

    
1975
    av_free(duration_error);
1976
    for(i=0;i<MAX_STREAMS;i++){
1977
        av_freep(&(probe_data[i].buf));
1978
    }
1979

    
1980
    return ret;
1981
}
1982

    
1983
/*******************************************************/
1984

    
1985
int av_read_play(AVFormatContext *s)
1986
{
1987
    if (!s->iformat->read_play)
1988
        return AVERROR_NOTSUPP;
1989
    return s->iformat->read_play(s);
1990
}
1991

    
1992
int av_read_pause(AVFormatContext *s)
1993
{
1994
    if (!s->iformat->read_pause)
1995
        return AVERROR_NOTSUPP;
1996
    return s->iformat->read_pause(s);
1997
}
1998

    
1999
void av_close_input_file(AVFormatContext *s)
2000
{
2001
    int i, must_open_file;
2002
    AVStream *st;
2003

    
2004
    /* free previous packet */
2005
    if (s->cur_st && s->cur_st->parser)
2006
        av_free_packet(&s->cur_pkt);
2007

    
2008
    if (s->iformat->read_close)
2009
        s->iformat->read_close(s);
2010
    for(i=0;i<s->nb_streams;i++) {
2011
        /* free all data in a stream component */
2012
        st = s->streams[i];
2013
        if (st->parser) {
2014
            av_parser_close(st->parser);
2015
        }
2016
        av_free(st->index_entries);
2017
        av_free(st->codec->extradata);
2018
        av_free(st->codec);
2019
        av_free(st);
2020
    }
2021
    flush_packet_queue(s);
2022
    must_open_file = 1;
2023
    if (s->iformat->flags & AVFMT_NOFILE) {
2024
        must_open_file = 0;
2025
    }
2026
    if (must_open_file) {
2027
        url_fclose(&s->pb);
2028
    }
2029
    av_freep(&s->priv_data);
2030
    av_free(s);
2031
}
2032

    
2033
AVStream *av_new_stream(AVFormatContext *s, int id)
2034
{
2035
    AVStream *st;
2036
    int i;
2037

    
2038
    if (s->nb_streams >= MAX_STREAMS)
2039
        return NULL;
2040

    
2041
    st = av_mallocz(sizeof(AVStream));
2042
    if (!st)
2043
        return NULL;
2044

    
2045
    st->codec= avcodec_alloc_context();
2046
    if (s->iformat) {
2047
        /* no default bitrate if decoding */
2048
        st->codec->bit_rate = 0;
2049
    }
2050
    st->index = s->nb_streams;
2051
    st->id = id;
2052
    st->start_time = AV_NOPTS_VALUE;
2053
    st->duration = AV_NOPTS_VALUE;
2054
    st->cur_dts = AV_NOPTS_VALUE;
2055

    
2056
    /* default pts settings is MPEG like */
2057
    av_set_pts_info(st, 33, 1, 90000);
2058
    st->last_IP_pts = AV_NOPTS_VALUE;
2059
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2060
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2061

    
2062
    s->streams[s->nb_streams++] = st;
2063
    return st;
2064
}
2065

    
2066
/************************************************************/
2067
/* output media file */
2068

    
2069
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2070
{
2071
    int ret;
2072

    
2073
    if (s->oformat->priv_data_size > 0) {
2074
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2075
        if (!s->priv_data)
2076
            return AVERROR_NOMEM;
2077
    } else
2078
        s->priv_data = NULL;
2079

    
2080
    if (s->oformat->set_parameters) {
2081
        ret = s->oformat->set_parameters(s, ap);
2082
        if (ret < 0)
2083
            return ret;
2084
    }
2085
    return 0;
2086
}
2087

    
2088
int av_write_header(AVFormatContext *s)
2089
{
2090
    int ret, i;
2091
    AVStream *st;
2092

    
2093
    // some sanity checks
2094
    for(i=0;i<s->nb_streams;i++) {
2095
        st = s->streams[i];
2096

    
2097
        switch (st->codec->codec_type) {
2098
        case CODEC_TYPE_AUDIO:
2099
            if(st->codec->sample_rate<=0){
2100
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2101
                return -1;
2102
            }
2103
            break;
2104
        case CODEC_TYPE_VIDEO:
2105
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2106
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2107
                return -1;
2108
            }
2109
            if(st->codec->width<=0 || st->codec->height<=0){
2110
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2111
                return -1;
2112
            }
2113
            break;
2114
        }
2115

    
2116
        if(s->oformat->codec_tag){
2117
            if(st->codec->codec_tag){
2118
                //FIXME
2119
                //check that tag + id is in the table
2120
                //if neither is in the table -> ok
2121
                //if tag is in the table with another id -> FAIL
2122
                //if id is in the table with another tag -> FAIL unless strict < ?
2123
            }else
2124
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2125
        }
2126
    }
2127

    
2128
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2129
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2130
        if (!s->priv_data)
2131
            return AVERROR_NOMEM;
2132
    }
2133

    
2134
    if(s->oformat->write_header){
2135
        ret = s->oformat->write_header(s);
2136
        if (ret < 0)
2137
            return ret;
2138
    }
2139

    
2140
    /* init PTS generation */
2141
    for(i=0;i<s->nb_streams;i++) {
2142
        int64_t den = AV_NOPTS_VALUE;
2143
        st = s->streams[i];
2144

    
2145
        switch (st->codec->codec_type) {
2146
        case CODEC_TYPE_AUDIO:
2147
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2148
            break;
2149
        case CODEC_TYPE_VIDEO:
2150
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2151
            break;
2152
        default:
2153
            break;
2154
        }
2155
        if (den != AV_NOPTS_VALUE) {
2156
            if (den <= 0)
2157
                return AVERROR_INVALIDDATA;
2158
            av_frac_init(&st->pts, 0, 0, den);
2159
        }
2160
    }
2161
    return 0;
2162
}
2163

    
2164
//FIXME merge with compute_pkt_fields
2165
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2166
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2167
    int num, den, frame_size, i;
2168

    
2169
//    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);
2170

    
2171
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2172
        return -1;*/
2173

    
2174
    /* duration field */
2175
    if (pkt->duration == 0) {
2176
        compute_frame_duration(&num, &den, st, NULL, pkt);
2177
        if (den && num) {
2178
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2179
        }
2180
    }
2181

    
2182
    //XXX/FIXME this is a temporary hack until all encoders output pts
2183
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2184
        pkt->dts=
2185
//        pkt->pts= st->cur_dts;
2186
        pkt->pts= st->pts.val;
2187
    }
2188

    
2189
    //calculate dts from pts
2190
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2191
        st->pts_buffer[0]= pkt->pts;
2192
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2193
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2194
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2195
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2196

    
2197
        pkt->dts= st->pts_buffer[0];
2198
    }
2199

    
2200
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2201
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2202
        return -1;
2203
    }
2204
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2205
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2206
        return -1;
2207
    }
2208

    
2209
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2210
    st->cur_dts= pkt->dts;
2211
    st->pts.val= pkt->dts;
2212

    
2213
    /* update pts */
2214
    switch (st->codec->codec_type) {
2215
    case CODEC_TYPE_AUDIO:
2216
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2217

    
2218
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2219
           but it would be better if we had the real timestamps from the encoder */
2220
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2221
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2222
        }
2223
        break;
2224
    case CODEC_TYPE_VIDEO:
2225
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2226
        break;
2227
    default:
2228
        break;
2229
    }
2230
    return 0;
2231
}
2232

    
2233
static void truncate_ts(AVStream *st, AVPacket *pkt){
2234
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2235

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

    
2239
    if (pkt->pts != AV_NOPTS_VALUE)
2240
        pkt->pts &= pts_mask;
2241
    if (pkt->dts != AV_NOPTS_VALUE)
2242
        pkt->dts &= pts_mask;
2243
}
2244

    
2245
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2246
{
2247
    int ret;
2248

    
2249
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2250
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2251
        return ret;
2252

    
2253
    truncate_ts(s->streams[pkt->stream_index], pkt);
2254

    
2255
    ret= s->oformat->write_packet(s, pkt);
2256
    if(!ret)
2257
        ret= url_ferror(&s->pb);
2258
    return ret;
2259
}
2260

    
2261
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2262
    AVPacketList *pktl, **next_point, *this_pktl;
2263
    int stream_count=0;
2264
    int streams[MAX_STREAMS];
2265

    
2266
    if(pkt){
2267
        AVStream *st= s->streams[ pkt->stream_index];
2268

    
2269
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2270

    
2271
        this_pktl = av_mallocz(sizeof(AVPacketList));
2272
        this_pktl->pkt= *pkt;
2273
        if(pkt->destruct == av_destruct_packet)
2274
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2275
        else
2276
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2277

    
2278
        next_point = &s->packet_buffer;
2279
        while(*next_point){
2280
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2281
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2282
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2283
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2284
                break;
2285
            next_point= &(*next_point)->next;
2286
        }
2287
        this_pktl->next= *next_point;
2288
        *next_point= this_pktl;
2289
    }
2290

    
2291
    memset(streams, 0, sizeof(streams));
2292
    pktl= s->packet_buffer;
2293
    while(pktl){
2294
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2295
        if(streams[ pktl->pkt.stream_index ] == 0)
2296
            stream_count++;
2297
        streams[ pktl->pkt.stream_index ]++;
2298
        pktl= pktl->next;
2299
    }
2300

    
2301
    if(s->nb_streams == stream_count || (flush && stream_count)){
2302
        pktl= s->packet_buffer;
2303
        *out= pktl->pkt;
2304

    
2305
        s->packet_buffer= pktl->next;
2306
        av_freep(&pktl);
2307
        return 1;
2308
    }else{
2309
        av_init_packet(out);
2310
        return 0;
2311
    }
2312
}
2313

    
2314
/**
2315
 * Interleaves a AVPacket correctly so it can be muxed.
2316
 * @param out the interleaved packet will be output here
2317
 * @param in the input packet
2318
 * @param flush 1 if no further packets are available as input and all
2319
 *              remaining packets should be output
2320
 * @return 1 if a packet was output, 0 if no packet could be output,
2321
 *         < 0 if an error occured
2322
 */
2323
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2324
    if(s->oformat->interleave_packet)
2325
        return s->oformat->interleave_packet(s, out, in, flush);
2326
    else
2327
        return av_interleave_packet_per_dts(s, out, in, flush);
2328
}
2329

    
2330
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2331
    AVStream *st= s->streams[ pkt->stream_index];
2332

    
2333
    //FIXME/XXX/HACK drop zero sized packets
2334
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2335
        return 0;
2336

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

    
2341
    if(pkt->dts == AV_NOPTS_VALUE)
2342
        return -1;
2343

    
2344
    for(;;){
2345
        AVPacket opkt;
2346
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2347
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2348
            return ret;
2349

    
2350
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2351
        ret= s->oformat->write_packet(s, &opkt);
2352

    
2353
        av_free_packet(&opkt);
2354
        pkt= NULL;
2355

    
2356
        if(ret<0)
2357
            return ret;
2358
        if(url_ferror(&s->pb))
2359
            return url_ferror(&s->pb);
2360
    }
2361
}
2362

    
2363
int av_write_trailer(AVFormatContext *s)
2364
{
2365
    int ret, i;
2366

    
2367
    for(;;){
2368
        AVPacket pkt;
2369
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2370
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2371
            goto fail;
2372
        if(!ret)
2373
            break;
2374

    
2375
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2376
        ret= s->oformat->write_packet(s, &pkt);
2377

    
2378
        av_free_packet(&pkt);
2379

    
2380
        if(ret<0)
2381
            goto fail;
2382
        if(url_ferror(&s->pb))
2383
            goto fail;
2384
    }
2385

    
2386
    if(s->oformat->write_trailer)
2387
        ret = s->oformat->write_trailer(s);
2388
fail:
2389
    if(ret == 0)
2390
       ret=url_ferror(&s->pb);
2391
    for(i=0;i<s->nb_streams;i++)
2392
        av_freep(&s->streams[i]->priv_data);
2393
    av_freep(&s->priv_data);
2394
    return ret;
2395
}
2396

    
2397
/* "user interface" functions */
2398

    
2399
void dump_format(AVFormatContext *ic,
2400
                 int index,
2401
                 const char *url,
2402
                 int is_output)
2403
{
2404
    int i, flags;
2405
    char buf[256];
2406

    
2407
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2408
            is_output ? "Output" : "Input",
2409
            index,
2410
            is_output ? ic->oformat->name : ic->iformat->name,
2411
            is_output ? "to" : "from", url);
2412
    if (!is_output) {
2413
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2414
        if (ic->duration != AV_NOPTS_VALUE) {
2415
            int hours, mins, secs, us;
2416
            secs = ic->duration / AV_TIME_BASE;
2417
            us = ic->duration % AV_TIME_BASE;
2418
            mins = secs / 60;
2419
            secs %= 60;
2420
            hours = mins / 60;
2421
            mins %= 60;
2422
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2423
                   (10 * us) / AV_TIME_BASE);
2424
        } else {
2425
            av_log(NULL, AV_LOG_INFO, "N/A");
2426
        }
2427
        if (ic->start_time != AV_NOPTS_VALUE) {
2428
            int secs, us;
2429
            av_log(NULL, AV_LOG_INFO, ", start: ");
2430
            secs = ic->start_time / AV_TIME_BASE;
2431
            us = ic->start_time % AV_TIME_BASE;
2432
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2433
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2434
        }
2435
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2436
        if (ic->bit_rate) {
2437
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2438
        } else {
2439
            av_log(NULL, AV_LOG_INFO, "N/A");
2440
        }
2441
        av_log(NULL, AV_LOG_INFO, "\n");
2442
    }
2443
    for(i=0;i<ic->nb_streams;i++) {
2444
        AVStream *st = ic->streams[i];
2445
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2446
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2447
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2448
        /* the pid is an important information, so we display it */
2449
        /* XXX: add a generic system */
2450
        if (is_output)
2451
            flags = ic->oformat->flags;
2452
        else
2453
            flags = ic->iformat->flags;
2454
        if (flags & AVFMT_SHOW_IDS) {
2455
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2456
        }
2457
        if (strlen(st->language) > 0) {
2458
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2459
        }
2460
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2461
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2462
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2463
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2464
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2465
/*            else if(st->time_base.den && st->time_base.num)
2466
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2467
            else
2468
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2469
        }
2470
        av_log(NULL, AV_LOG_INFO, "\n");
2471
    }
2472
}
2473

    
2474
typedef struct {
2475
    const char *abv;
2476
    int width, height;
2477
    int frame_rate, frame_rate_base;
2478
} AbvEntry;
2479

    
2480
static AbvEntry frame_abvs[] = {
2481
    { "ntsc",      720, 480, 30000, 1001 },
2482
    { "pal",       720, 576,    25,    1 },
2483
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2484
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2485
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2486
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2487
    { "film",      352, 240,    24,    1 },
2488
    { "ntsc-film", 352, 240, 24000, 1001 },
2489
    { "sqcif",     128,  96,     0,    0 },
2490
    { "qcif",      176, 144,     0,    0 },
2491
    { "cif",       352, 288,     0,    0 },
2492
    { "4cif",      704, 576,     0,    0 },
2493
    { "qqvga",     160, 120,     0,    0 },
2494
    { "qvga",      320, 240,     0,    0 },
2495
    { "vga",       640, 480,     0,    0 },
2496
    { "svga",      800, 600,     0,    0 },
2497
    { "xga",      1024, 768,     0,    0 },
2498
    { "uxga",     1600,1200,     0,    0 },
2499
    { "qxga",     2048,1536,     0,    0 },
2500
    { "sxga",     1280,1024,     0,    0 },
2501
    { "qsxga",    2560,2048,     0,    0 },
2502
    { "hsxga",    5120,4096,     0,    0 },
2503
    { "wvga",      852, 480,     0,    0 },
2504
    { "wxga",     1366, 768,     0,    0 },
2505
    { "wsxga",    1600,1024,     0,    0 },
2506
    { "wuxga",    1920,1200,     0,    0 },
2507
    { "woxga",    2560,1600,     0,    0 },
2508
    { "wqsxga",   3200,2048,     0,    0 },
2509
    { "wquxga",   3840,2400,     0,    0 },
2510
    { "whsxga",   6400,4096,     0,    0 },
2511
    { "whuxga",   7680,4800,     0,    0 },
2512
    { "cga",       320, 200,     0,    0 },
2513
    { "ega",       640, 350,     0,    0 },
2514
    { "hd480",     852, 480,     0,    0 },
2515
    { "hd720",    1280, 720,     0,    0 },
2516
    { "hd1080",   1920,1080,     0,    0 },
2517
};
2518

    
2519
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2520
{
2521
    int i;
2522
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2523
    const char *p;
2524
    int frame_width = 0, frame_height = 0;
2525

    
2526
    for(i=0;i<n;i++) {
2527
        if (!strcmp(frame_abvs[i].abv, str)) {
2528
            frame_width = frame_abvs[i].width;
2529
            frame_height = frame_abvs[i].height;
2530
            break;
2531
        }
2532
    }
2533
    if (i == n) {
2534
        p = str;
2535
        frame_width = strtol(p, (char **)&p, 10);
2536
        if (*p)
2537
            p++;
2538
        frame_height = strtol(p, (char **)&p, 10);
2539
    }
2540
    if (frame_width <= 0 || frame_height <= 0)
2541
        return -1;
2542
    *width_ptr = frame_width;
2543
    *height_ptr = frame_height;
2544
    return 0;
2545
}
2546

    
2547
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2548
{
2549
    int i;
2550
    char* cp;
2551

    
2552
    /* First, we check our abbreviation table */
2553
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2554
         if (!strcmp(frame_abvs[i].abv, arg)) {
2555
             *frame_rate = frame_abvs[i].frame_rate;
2556
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2557
             return 0;
2558
         }
2559

    
2560
    /* Then, we try to parse it as fraction */
2561
    cp = strchr(arg, '/');
2562
    if (!cp)
2563
        cp = strchr(arg, ':');
2564
    if (cp) {
2565
        char* cpp;
2566
        *frame_rate = strtol(arg, &cpp, 10);
2567
        if (cpp != arg || cpp == cp)
2568
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2569
        else
2570
           *frame_rate = 0;
2571
    }
2572
    else {
2573
        /* Finally we give up and parse it as double */
2574
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2575
        *frame_rate_base = time_base.den;
2576
        *frame_rate = time_base.num;
2577
    }
2578
    if (!*frame_rate || !*frame_rate_base)
2579
        return -1;
2580
    else
2581
        return 0;
2582
}
2583

    
2584
int64_t parse_date(const char *datestr, int duration)
2585
{
2586
    const char *p;
2587
    int64_t t;
2588
    struct tm dt;
2589
    int i;
2590
    static const char *date_fmt[] = {
2591
        "%Y-%m-%d",
2592
        "%Y%m%d",
2593
    };
2594
    static const char *time_fmt[] = {
2595
        "%H:%M:%S",
2596
        "%H%M%S",
2597
    };
2598
    const char *q;
2599
    int is_utc, len;
2600
    char lastch;
2601
    int negative = 0;
2602

    
2603
#undef time
2604
    time_t now = time(0);
2605

    
2606
    len = strlen(datestr);
2607
    if (len > 0)
2608
        lastch = datestr[len - 1];
2609
    else
2610
        lastch = '\0';
2611
    is_utc = (lastch == 'z' || lastch == 'Z');
2612

    
2613
    memset(&dt, 0, sizeof(dt));
2614

    
2615
    p = datestr;
2616
    q = NULL;
2617
    if (!duration) {
2618
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2619
            q = small_strptime(p, date_fmt[i], &dt);
2620
            if (q) {
2621
                break;
2622
            }
2623
        }
2624

    
2625
        if (!q) {
2626
            if (is_utc) {
2627
                dt = *gmtime(&now);
2628
            } else {
2629
                dt = *localtime(&now);
2630
            }
2631
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2632
        } else {
2633
            p = q;
2634
        }
2635

    
2636
        if (*p == 'T' || *p == 't' || *p == ' ')
2637
            p++;
2638

    
2639
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2640
            q = small_strptime(p, time_fmt[i], &dt);
2641
            if (q) {
2642
                break;
2643
            }
2644
        }
2645
    } else {
2646
        if (p[0] == '-') {
2647
            negative = 1;
2648
            ++p;
2649
        }
2650
        q = small_strptime(p, time_fmt[0], &dt);
2651
        if (!q) {
2652
            dt.tm_sec = strtol(p, (char **)&q, 10);
2653
            dt.tm_min = 0;
2654
            dt.tm_hour = 0;
2655
        }
2656
    }
2657

    
2658
    /* Now we have all the fields that we can get */
2659
    if (!q) {
2660
        if (duration)
2661
            return 0;
2662
        else
2663
            return now * INT64_C(1000000);
2664
    }
2665

    
2666
    if (duration) {
2667
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2668
    } else {
2669
        dt.tm_isdst = -1;       /* unknown */
2670
        if (is_utc) {
2671
            t = mktimegm(&dt);
2672
        } else {
2673
            t = mktime(&dt);
2674
        }
2675
    }
2676

    
2677
    t *= 1000000;
2678

    
2679
    if (*q == '.') {
2680
        int val, n;
2681
        q++;
2682
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2683
            if (!isdigit(*q))
2684
                break;
2685
            val += n * (*q - '0');
2686
        }
2687
        t += val;
2688
    }
2689
    return negative ? -t : t;
2690
}
2691

    
2692
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2693
{
2694
    const char *p;
2695
    char tag[128], *q;
2696

    
2697
    p = info;
2698
    if (*p == '?')
2699
        p++;
2700
    for(;;) {
2701
        q = tag;
2702
        while (*p != '\0' && *p != '=' && *p != '&') {
2703
            if ((q - tag) < sizeof(tag) - 1)
2704
                *q++ = *p;
2705
            p++;
2706
        }
2707
        *q = '\0';
2708
        q = arg;
2709
        if (*p == '=') {
2710
            p++;
2711
            while (*p != '&' && *p != '\0') {
2712
                if ((q - arg) < arg_size - 1) {
2713
                    if (*p == '+')
2714
                        *q++ = ' ';
2715
                    else
2716
                        *q++ = *p;
2717
                }
2718
                p++;
2719
            }
2720
            *q = '\0';
2721
        }
2722
        if (!strcmp(tag, tag1))
2723
            return 1;
2724
        if (*p != '&')
2725
            break;
2726
        p++;
2727
    }
2728
    return 0;
2729
}
2730

    
2731
int av_get_frame_filename(char *buf, int buf_size,
2732
                          const char *path, int number)
2733
{
2734
    const char *p;
2735
    char *q, buf1[20], c;
2736
    int nd, len, percentd_found;
2737

    
2738
    q = buf;
2739
    p = path;
2740
    percentd_found = 0;
2741
    for(;;) {
2742
        c = *p++;
2743
        if (c == '\0')
2744
            break;
2745
        if (c == '%') {
2746
            do {
2747
                nd = 0;
2748
                while (isdigit(*p)) {
2749
                    nd = nd * 10 + *p++ - '0';
2750
                }
2751
                c = *p++;
2752
            } while (isdigit(c));
2753

    
2754
            switch(c) {
2755
            case '%':
2756
                goto addchar;
2757
            case 'd':
2758
                if (percentd_found)
2759
                    goto fail;
2760
                percentd_found = 1;
2761
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2762
                len = strlen(buf1);
2763
                if ((q - buf + len) > buf_size - 1)
2764
                    goto fail;
2765
                memcpy(q, buf1, len);
2766
                q += len;
2767
                break;
2768
            default:
2769
                goto fail;
2770
            }
2771
        } else {
2772
        addchar:
2773
            if ((q - buf) < buf_size - 1)
2774
                *q++ = c;
2775
        }
2776
    }
2777
    if (!percentd_found)
2778
        goto fail;
2779
    *q = '\0';
2780
    return 0;
2781
 fail:
2782
    *q = '\0';
2783
    return -1;
2784
}
2785

    
2786
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2787
{
2788
    int len, i, j, c;
2789
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2790

    
2791
    for(i=0;i<size;i+=16) {
2792
        len = size - i;
2793
        if (len > 16)
2794
            len = 16;
2795
        PRINT("%08x ", i);
2796
        for(j=0;j<16;j++) {
2797
            if (j < len)
2798
                PRINT(" %02x", buf[i+j]);
2799
            else
2800
                PRINT("   ");
2801
        }
2802
        PRINT(" ");
2803
        for(j=0;j<len;j++) {
2804
            c = buf[i+j];
2805
            if (c < ' ' || c > '~')
2806
                c = '.';
2807
            PRINT("%c", c);
2808
        }
2809
        PRINT("\n");
2810
    }
2811
#undef PRINT
2812
}
2813

    
2814
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2815
{
2816
    hex_dump_internal(NULL, f, 0, buf, size);
2817
}
2818

    
2819
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2820
{
2821
    hex_dump_internal(avcl, NULL, level, buf, size);
2822
}
2823

    
2824
 //FIXME needs to know the time_base
2825
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2826
{
2827
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2828
    PRINT("stream #%d:\n", pkt->stream_index);
2829
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2830
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2831
    /* DTS is _always_ valid after av_read_frame() */
2832
    PRINT("  dts=");
2833
    if (pkt->dts == AV_NOPTS_VALUE)
2834
        PRINT("N/A");
2835
    else
2836
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2837
    /* PTS may be not known if B frames are present */
2838
    PRINT("  pts=");
2839
    if (pkt->pts == AV_NOPTS_VALUE)
2840
        PRINT("N/A");
2841
    else
2842
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2843
    PRINT("\n");
2844
    PRINT("  size=%d\n", pkt->size);
2845
#undef PRINT
2846
    if (dump_payload)
2847
        av_hex_dump(f, pkt->data, pkt->size);
2848
}
2849

    
2850
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2851
{
2852
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2853
}
2854

    
2855
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2856
{
2857
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2858
}
2859

    
2860
void url_split(char *proto, int proto_size,
2861
               char *authorization, int authorization_size,
2862
               char *hostname, int hostname_size,
2863
               int *port_ptr,
2864
               char *path, int path_size,
2865
               const char *url)
2866
{
2867
    const char *p;
2868
    char *q;
2869
    int port;
2870

    
2871
    port = -1;
2872

    
2873
    p = url;
2874
    q = proto;
2875
    while (*p != ':' && *p != '\0') {
2876
        if ((q - proto) < proto_size - 1)
2877
            *q++ = *p;
2878
        p++;
2879
    }
2880
    if (proto_size > 0)
2881
        *q = '\0';
2882
    if (authorization_size > 0)
2883
        authorization[0] = '\0';
2884
    if (*p == '\0') {
2885
        if (proto_size > 0)
2886
            proto[0] = '\0';
2887
        if (hostname_size > 0)
2888
            hostname[0] = '\0';
2889
        p = url;
2890
    } else {
2891
        char *at,*slash; // PETR: position of '@' character and '/' character
2892

    
2893
        p++;
2894
        if (*p == '/')
2895
            p++;
2896
        if (*p == '/')
2897
            p++;
2898
        at = strchr(p,'@'); // PETR: get the position of '@'
2899
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2900
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2901

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

    
2904
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2905
            if (*p == '@') {    // PETR: passed '@'
2906
              if (authorization_size > 0)
2907
                  *q = '\0';
2908
              q = hostname;
2909
              at = NULL;
2910
            } else if (!at) {   // PETR: hostname
2911
              if ((q - hostname) < hostname_size - 1)
2912
                  *q++ = *p;
2913
            } else {
2914
              if ((q - authorization) < authorization_size - 1)
2915
                *q++ = *p;
2916
            }
2917
            p++;
2918
        }
2919
        if (hostname_size > 0)
2920
            *q = '\0';
2921
        if (*p == ':') {
2922
            p++;
2923
            port = strtoul(p, (char **)&p, 10);
2924
        }
2925
    }
2926
    if (port_ptr)
2927
        *port_ptr = port;
2928
    pstrcpy(path, path_size, p);
2929
}
2930

    
2931
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2932
                     int pts_num, int pts_den)
2933
{
2934
    s->pts_wrap_bits = pts_wrap_bits;
2935
    s->time_base.num = pts_num;
2936
    s->time_base.den = pts_den;
2937
}
2938

    
2939
/* fraction handling */
2940

    
2941
/**
2942
 * f = val + (num / den) + 0.5.
2943
 *
2944
 * 'num' is normalized so that it is such as 0 <= num < den.
2945
 *
2946
 * @param f fractional number
2947
 * @param val integer value
2948
 * @param num must be >= 0
2949
 * @param den must be >= 1
2950
 */
2951
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2952
{
2953
    num += (den >> 1);
2954
    if (num >= den) {
2955
        val += num / den;
2956
        num = num % den;
2957
    }
2958
    f->val = val;
2959
    f->num = num;
2960
    f->den = den;
2961
}
2962

    
2963
/**
2964
 * Fractionnal addition to f: f = f + (incr / f->den).
2965
 *
2966
 * @param f fractional number
2967
 * @param incr increment, can be positive or negative
2968
 */
2969
static void av_frac_add(AVFrac *f, int64_t incr)
2970
{
2971
    int64_t num, den;
2972

    
2973
    num = f->num + incr;
2974
    den = f->den;
2975
    if (num < 0) {
2976
        f->val += num / den;
2977
        num = num % den;
2978
        if (num < 0) {
2979
            num += den;
2980
            f->val--;
2981
        }
2982
    } else if (num >= den) {
2983
        f->val += num / den;
2984
        num = num % den;
2985
    }
2986
    f->num = num;
2987
}