Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ a74008a4

History | View | Annotate | Download (87.8 KB)

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

    
490
/**********************************************************/
491

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

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

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

    
518

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
803
    return 0;
804
}
805

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

    
812
    for(;;){
813
        pktl = s->packet_buffer;
814
        if (pktl) {
815
            AVPacket *next_pkt= &pktl->pkt;
816

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

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

    
851
            /* duplicate the packet */
852
            if (av_dup_packet(pkt) < 0)
853
                return AVERROR_NOMEM;
854

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

    
857
            pktl = av_mallocz(sizeof(AVPacketList));
858
            if (!pktl)
859
                return AVERROR_NOMEM;
860

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

    
871
/* XXX: suppress the packet queue */
872
static void flush_packet_queue(AVFormatContext *s)
873
{
874
    AVPacketList *pktl;
875

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

    
886
/*******************************************************/
887
/* seek support */
888

    
889
int av_find_default_stream_index(AVFormatContext *s)
890
{
891
    int i;
892
    AVStream *st;
893

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

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

    
913
    flush_packet_queue(s);
914

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

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

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

    
938
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
939
    int i;
940

    
941
    for(i = 0; i < s->nb_streams; i++) {
942
        AVStream *st = s->streams[i];
943

    
944
        st->cur_dts = av_rescale(timestamp,
945
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
946
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
947
    }
948
}
949

    
950
int av_add_index_entry(AVStream *st,
951
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
952
{
953
    AVIndexEntry *entries, *ie;
954
    int index;
955

    
956
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
957
        return -1;
958

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

    
966
    st->index_entries= entries;
967

    
968
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
969

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

    
985
    ie->pos = pos;
986
    ie->timestamp = timestamp;
987
    ie->min_distance= distance;
988
    ie->size= size;
989
    ie->flags = flags;
990

    
991
    return index;
992
}
993

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

    
1003
    st = s->streams[0];
1004
    av_read_frame_flush(s);
1005
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1006

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

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

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

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

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

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

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

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

    
1069
#define DEBUG_SEEK
1070

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

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

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

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

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

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

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

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

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

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

    
1130
    av_update_cur_dts(s, st, ts);
1131

    
1132
    return 0;
1133
}
1134

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

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

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

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

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

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

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

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

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

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

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

1248
    if (stream_index < 0)
1249
        return -1;
1250

1251
    st= s->streams[stream_index];
1252
#endif
1253

    
1254
    pos_min = s->data_offset;
1255
    pos_max = url_fsize(&s->pb) - 1;
1256

    
1257
    if     (pos < pos_min) pos= pos_min;
1258
    else if(pos > pos_max) pos= pos_max;
1259

    
1260
    url_fseek(&s->pb, pos, SEEK_SET);
1261

    
1262
#if 0
1263
    av_update_cur_dts(s, st, ts);
1264
#endif
1265
    return 0;
1266
}
1267

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

    
1275
    st = s->streams[stream_index];
1276

    
1277
    index = av_index_search_timestamp(st, timestamp, flags);
1278

    
1279
    if(index < 0){
1280
        int i;
1281
        AVPacket pkt;
1282

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

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

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

    
1313
    av_update_cur_dts(s, st, ie->timestamp);
1314

    
1315
    return 0;
1316
}
1317

    
1318
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1319
{
1320
    int ret;
1321
    AVStream *st;
1322

    
1323
    av_read_frame_flush(s);
1324

    
1325
    if(flags & AVSEEK_FLAG_BYTE)
1326
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1327

    
1328
    if(stream_index < 0){
1329
        stream_index= av_find_default_stream_index(s);
1330
        if(stream_index < 0)
1331
            return -1;
1332

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

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

    
1348
    if(s->iformat->read_timestamp)
1349
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1350
    else
1351
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1352
}
1353

    
1354
/*******************************************************/
1355

    
1356
/**
1357
 * Returns TRUE if the stream has accurate timings in any stream.
1358
 *
1359
 * @return TRUE if the stream has accurate timings for at least one component.
1360
 */
1361
static int av_has_timings(AVFormatContext *ic)
1362
{
1363
    int i;
1364
    AVStream *st;
1365

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

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

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

    
1414
}
1415

    
1416
static void fill_all_stream_timings(AVFormatContext *ic)
1417
{
1418
    int i;
1419
    AVStream *st;
1420

    
1421
    av_update_stream_timings(ic);
1422
    for(i = 0;i < ic->nb_streams; i++) {
1423
        st = ic->streams[i];
1424
        if (st->start_time == AV_NOPTS_VALUE) {
1425
            if(ic->start_time != AV_NOPTS_VALUE)
1426
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1427
            if(ic->duration != AV_NOPTS_VALUE)
1428
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1429
        }
1430
    }
1431
}
1432

    
1433
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1434
{
1435
    int64_t filesize, duration;
1436
    int bit_rate, i;
1437
    AVStream *st;
1438

    
1439
    /* if bit_rate is already set, we believe it */
1440
    if (ic->bit_rate == 0) {
1441
        bit_rate = 0;
1442
        for(i=0;i<ic->nb_streams;i++) {
1443
            st = ic->streams[i];
1444
            bit_rate += st->codec->bit_rate;
1445
        }
1446
        ic->bit_rate = bit_rate;
1447
    }
1448

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

    
1468
#define DURATION_MAX_READ_SIZE 250000
1469

    
1470
/* only usable for MPEG-PS streams */
1471
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1472
{
1473
    AVPacket pkt1, *pkt = &pkt1;
1474
    AVStream *st;
1475
    int read_size, i, ret;
1476
    int64_t end_time;
1477
    int64_t filesize, offset, duration;
1478

    
1479
    av_read_frame_flush(ic);
1480

    
1481
    /* we read the first packets to get the first PTS (not fully
1482
       accurate, but it is enough now) */
1483
    url_fseek(&ic->pb, 0, SEEK_SET);
1484
    read_size = 0;
1485
    for(;;) {
1486
        if (read_size >= DURATION_MAX_READ_SIZE)
1487
            break;
1488
        /* if all info is available, we can stop */
1489
        for(i = 0;i < ic->nb_streams; i++) {
1490
            st = ic->streams[i];
1491
            if (st->start_time == AV_NOPTS_VALUE)
1492
                break;
1493
        }
1494
        if (i == ic->nb_streams)
1495
            break;
1496

    
1497
        ret = av_read_packet(ic, pkt);
1498
        if (ret != 0)
1499
            break;
1500
        read_size += pkt->size;
1501
        st = ic->streams[pkt->stream_index];
1502
        if (pkt->pts != AV_NOPTS_VALUE) {
1503
            if (st->start_time == AV_NOPTS_VALUE)
1504
                st->start_time = pkt->pts;
1505
        }
1506
        av_free_packet(pkt);
1507
    }
1508

    
1509
    /* estimate the end time (duration) */
1510
    /* XXX: may need to support wrapping */
1511
    filesize = ic->file_size;
1512
    offset = filesize - DURATION_MAX_READ_SIZE;
1513
    if (offset < 0)
1514
        offset = 0;
1515

    
1516
    url_fseek(&ic->pb, offset, SEEK_SET);
1517
    read_size = 0;
1518
    for(;;) {
1519
        if (read_size >= DURATION_MAX_READ_SIZE)
1520
            break;
1521
        /* if all info is available, we can stop */
1522
        for(i = 0;i < ic->nb_streams; i++) {
1523
            st = ic->streams[i];
1524
            if (st->duration == AV_NOPTS_VALUE)
1525
                break;
1526
        }
1527
        if (i == ic->nb_streams)
1528
            break;
1529

    
1530
        ret = av_read_packet(ic, pkt);
1531
        if (ret != 0)
1532
            break;
1533
        read_size += pkt->size;
1534
        st = ic->streams[pkt->stream_index];
1535
        if (pkt->pts != AV_NOPTS_VALUE) {
1536
            end_time = pkt->pts;
1537
            duration = end_time - st->start_time;
1538
            if (duration > 0) {
1539
                if (st->duration == AV_NOPTS_VALUE ||
1540
                    st->duration < duration)
1541
                    st->duration = duration;
1542
            }
1543
        }
1544
        av_free_packet(pkt);
1545
    }
1546

    
1547
    fill_all_stream_timings(ic);
1548

    
1549
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1550
}
1551

    
1552
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1553
{
1554
    int64_t file_size;
1555

    
1556
    /* get the file size, if possible */
1557
    if (ic->iformat->flags & AVFMT_NOFILE) {
1558
        file_size = 0;
1559
    } else {
1560
        file_size = url_fsize(&ic->pb);
1561
        if (file_size < 0)
1562
            file_size = 0;
1563
    }
1564
    ic->file_size = file_size;
1565

    
1566
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1567
         !strcmp(ic->iformat->name, "mpegts")) &&
1568
        file_size && !ic->pb.is_streamed) {
1569
        /* get accurate estimate from the PTSes */
1570
        av_estimate_timings_from_pts(ic, old_offset);
1571
    } else if (av_has_timings(ic)) {
1572
        /* at least one components has timings - we use them for all
1573
           the components */
1574
        fill_all_stream_timings(ic);
1575
    } else {
1576
        /* less precise: use bit rate info */
1577
        av_estimate_timings_from_bit_rate(ic);
1578
    }
1579
    av_update_stream_timings(ic);
1580

    
1581
#if 0
1582
    {
1583
        int i;
1584
        AVStream *st;
1585
        for(i = 0;i < ic->nb_streams; i++) {
1586
            st = ic->streams[i];
1587
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1588
               i, (double)st->start_time / AV_TIME_BASE,
1589
               (double)st->duration / AV_TIME_BASE);
1590
        }
1591
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1592
               (double)ic->start_time / AV_TIME_BASE,
1593
               (double)ic->duration / AV_TIME_BASE,
1594
               ic->bit_rate / 1000);
1595
    }
1596
#endif
1597
}
1598

    
1599
static int has_codec_parameters(AVCodecContext *enc)
1600
{
1601
    int val;
1602
    switch(enc->codec_type) {
1603
    case CODEC_TYPE_AUDIO:
1604
        val = enc->sample_rate;
1605
        break;
1606
    case CODEC_TYPE_VIDEO:
1607
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1608
        break;
1609
    default:
1610
        val = 1;
1611
        break;
1612
    }
1613
    return (val != 0);
1614
}
1615

    
1616
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1617
{
1618
    int16_t *samples;
1619
    AVCodec *codec;
1620
    int got_picture, data_size, ret=0;
1621
    AVFrame picture;
1622

    
1623
  if(!st->codec->codec){
1624
    codec = avcodec_find_decoder(st->codec->codec_id);
1625
    if (!codec)
1626
        return -1;
1627
    ret = avcodec_open(st->codec, codec);
1628
    if (ret < 0)
1629
        return ret;
1630
  }
1631

    
1632
  if(!has_codec_parameters(st->codec)){
1633
    switch(st->codec->codec_type) {
1634
    case CODEC_TYPE_VIDEO:
1635
        ret = avcodec_decode_video(st->codec, &picture,
1636
                                   &got_picture, (uint8_t *)data, size);
1637
        break;
1638
    case CODEC_TYPE_AUDIO:
1639
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1640
        samples = av_malloc(data_size);
1641
        if (!samples)
1642
            goto fail;
1643
        ret = avcodec_decode_audio2(st->codec, samples,
1644
                                    &data_size, (uint8_t *)data, size);
1645
        av_free(samples);
1646
        break;
1647
    default:
1648
        break;
1649
    }
1650
  }
1651
 fail:
1652
    return ret;
1653
}
1654

    
1655
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1656
{
1657
    AVInputFormat *fmt;
1658
    fmt = av_probe_input_format2(pd, 1, &score);
1659

    
1660
    if (fmt) {
1661
        if (strncmp(fmt->name, "mp3", 3) == 0)
1662
            st->codec->codec_id = CODEC_ID_MP3;
1663
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1664
            st->codec->codec_id = CODEC_ID_AC3;
1665
    }
1666
    return fmt;
1667
}
1668

    
1669
/* absolute maximum size we read until we abort */
1670
#define MAX_READ_SIZE        5000000
1671

    
1672
#define MAX_STD_TIMEBASES (60*12+5)
1673
static int get_std_framerate(int i){
1674
    if(i<60*12) return i*1001;
1675
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1676
}
1677

    
1678
int av_find_stream_info(AVFormatContext *ic)
1679
{
1680
    int i, count, ret, read_size, j;
1681
    AVStream *st;
1682
    AVPacket pkt1, *pkt;
1683
    AVPacketList *pktl=NULL, **ppktl;
1684
    int64_t last_dts[MAX_STREAMS];
1685
    int duration_count[MAX_STREAMS]={0};
1686
    double (*duration_error)[MAX_STD_TIMEBASES];
1687
    offset_t old_offset = url_ftell(&ic->pb);
1688
    int64_t codec_info_duration[MAX_STREAMS]={0};
1689
    int codec_info_nb_frames[MAX_STREAMS]={0};
1690
    AVProbeData probe_data[MAX_STREAMS];
1691
    int codec_identified[MAX_STREAMS]={0};
1692

    
1693
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1694
    if (!duration_error) return AVERROR_NOMEM;
1695

    
1696
    for(i=0;i<ic->nb_streams;i++) {
1697
        st = ic->streams[i];
1698
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1699
/*            if(!st->time_base.num)
1700
                st->time_base= */
1701
            if(!st->codec->time_base.num)
1702
                st->codec->time_base= st->time_base;
1703
        }
1704
        //only for the split stuff
1705
        if (!st->parser) {
1706
            st->parser = av_parser_init(st->codec->codec_id);
1707
            if(st->need_parsing == 2 && st->parser){
1708
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1709
            }
1710
        }
1711
    }
1712

    
1713
    for(i=0;i<MAX_STREAMS;i++){
1714
        last_dts[i]= AV_NOPTS_VALUE;
1715
    }
1716

    
1717
    memset(probe_data, 0, sizeof(probe_data));
1718
    count = 0;
1719
    read_size = 0;
1720
    ppktl = &ic->packet_buffer;
1721
    for(;;) {
1722
        /* check if one codec still needs to be handled */
1723
        for(i=0;i<ic->nb_streams;i++) {
1724
            st = ic->streams[i];
1725
            if (!has_codec_parameters(st->codec))
1726
                break;
1727
            /* variable fps and no guess at the real fps */
1728
            if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1729
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1730
                break;
1731
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1732
                break;
1733
            if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1734
                st->codec->codec_id == CODEC_ID_NONE)
1735
                break;
1736
        }
1737
        if (i == ic->nb_streams) {
1738
            /* NOTE: if the format has no header, then we need to read
1739
               some packets to get most of the streams, so we cannot
1740
               stop here */
1741
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1742
                /* if we found the info for all the codecs, we can stop */
1743
                ret = count;
1744
                break;
1745
            }
1746
        }
1747
        /* we did not get all the codec info, but we read too much data */
1748
        if (read_size >= MAX_READ_SIZE) {
1749
            ret = count;
1750
            break;
1751
        }
1752

    
1753
        /* NOTE: a new stream can be added there if no header in file
1754
           (AVFMTCTX_NOHEADER) */
1755
        ret = av_read_frame_internal(ic, &pkt1);
1756
        if (ret < 0) {
1757
            /* EOF or error */
1758
            ret = -1; /* we could not have all the codec parameters before EOF */
1759
            for(i=0;i<ic->nb_streams;i++) {
1760
                st = ic->streams[i];
1761
                if (!has_codec_parameters(st->codec)){
1762
                    char buf[256];
1763
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1764
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1765
                } else {
1766
                    ret = 0;
1767
                }
1768
            }
1769
            break;
1770
        }
1771

    
1772
        pktl = av_mallocz(sizeof(AVPacketList));
1773
        if (!pktl) {
1774
            ret = AVERROR_NOMEM;
1775
            break;
1776
        }
1777

    
1778
        /* add the packet in the buffered packet list */
1779
        *ppktl = pktl;
1780
        ppktl = &pktl->next;
1781

    
1782
        pkt = &pktl->pkt;
1783
        *pkt = pkt1;
1784

    
1785
        /* duplicate the packet */
1786
        if (av_dup_packet(pkt) < 0) {
1787
            ret = AVERROR_NOMEM;
1788
            break;
1789
        }
1790

    
1791
        read_size += pkt->size;
1792

    
1793
        st = ic->streams[pkt->stream_index];
1794
        if(codec_info_nb_frames[st->index]>1)
1795
            codec_info_duration[st->index] += pkt->duration;
1796
        if (pkt->duration != 0)
1797
            codec_info_nb_frames[st->index]++;
1798

    
1799
        {
1800
            int index= pkt->stream_index;
1801
            int64_t last= last_dts[index];
1802
            int64_t duration= pkt->dts - last;
1803

    
1804
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1805
                double dur= duration * av_q2d(st->time_base);
1806

    
1807
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1808
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1809
                if(duration_count[index] < 2)
1810
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1811
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1812
                    int framerate= get_std_framerate(i);
1813
                    int ticks= lrintf(dur*framerate/(1001*12));
1814
                    double error= dur - ticks*1001*12/(double)framerate;
1815
                    duration_error[index][i] += error*error;
1816
                }
1817
                duration_count[index]++;
1818
            }
1819
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1820
                last_dts[pkt->stream_index]= pkt->dts;
1821

    
1822
            if (st->codec->codec_id == CODEC_ID_NONE) {
1823
                AVProbeData *pd = &(probe_data[st->index]);
1824
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1825
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1826
                pd->buf_size += pkt->size;
1827
            }
1828
        }
1829
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1830
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1831
            if(i){
1832
                st->codec->extradata_size= i;
1833
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1834
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1835
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1836
            }
1837
        }
1838

    
1839
        /* if still no information, we try to open the codec and to
1840
           decompress the frame. We try to avoid that in most cases as
1841
           it takes longer and uses more memory. For MPEG4, we need to
1842
           decompress for Quicktime. */
1843
        if (!has_codec_parameters(st->codec) /*&&
1844
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1845
             st->codec->codec_id == CODEC_ID_H264 ||
1846
             st->codec->codec_id == CODEC_ID_H263 ||
1847
             st->codec->codec_id == CODEC_ID_H261 ||
1848
             st->codec->codec_id == CODEC_ID_VORBIS ||
1849
             st->codec->codec_id == CODEC_ID_MJPEG ||
1850
             st->codec->codec_id == CODEC_ID_PNG ||
1851
             st->codec->codec_id == CODEC_ID_PAM ||
1852
             st->codec->codec_id == CODEC_ID_PGM ||
1853
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1854
             st->codec->codec_id == CODEC_ID_PBM ||
1855
             st->codec->codec_id == CODEC_ID_PPM ||
1856
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1857
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1858
            try_decode_frame(st, pkt->data, pkt->size);
1859

    
1860
        if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1861
            break;
1862
        }
1863
        count++;
1864
    }
1865

    
1866
    // close codecs which where opened in try_decode_frame()
1867
    for(i=0;i<ic->nb_streams;i++) {
1868
        st = ic->streams[i];
1869
        if(st->codec->codec)
1870
            avcodec_close(st->codec);
1871
    }
1872
    for(i=0;i<ic->nb_streams;i++) {
1873
        st = ic->streams[i];
1874
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1875
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1876
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1877

    
1878
            if(duration_count[i]
1879
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1880
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1881
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1882
                double best_error= 2*av_q2d(st->time_base);
1883
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1884

    
1885
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1886
                    double error= duration_error[i][j] * get_std_framerate(j);
1887
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1888
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1889
                    if(error < best_error){
1890
                        best_error= error;
1891
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1892
                    }
1893
                }
1894
            }
1895

    
1896
            if (!st->r_frame_rate.num){
1897
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1898
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1899
                    st->r_frame_rate.num = st->codec->time_base.den;
1900
                    st->r_frame_rate.den = st->codec->time_base.num;
1901
                }else{
1902
                    st->r_frame_rate.num = st->time_base.den;
1903
                    st->r_frame_rate.den = st->time_base.num;
1904
                }
1905
            }
1906
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1907
            if (st->codec->codec_id == CODEC_ID_NONE) {
1908
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1909
                if (codec_identified[st->index]) {
1910
                    st->need_parsing = 1;
1911
                }
1912
            }
1913
            if(!st->codec->bits_per_sample)
1914
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1915
        }
1916
    }
1917

    
1918
    av_estimate_timings(ic, old_offset);
1919

    
1920
    for(i=0;i<ic->nb_streams;i++) {
1921
        st = ic->streams[i];
1922
        if (codec_identified[st->index]) {
1923
            av_read_frame_flush(ic);
1924
            av_seek_frame(ic, st->index, 0.0, 0);
1925
            url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1926
        }
1927
    }
1928

    
1929
#if 0
1930
    /* correct DTS for b frame streams with no timestamps */
1931
    for(i=0;i<ic->nb_streams;i++) {
1932
        st = ic->streams[i];
1933
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1934
            if(b-frames){
1935
                ppktl = &ic->packet_buffer;
1936
                while(ppkt1){
1937
                    if(ppkt1->stream_index != i)
1938
                        continue;
1939
                    if(ppkt1->pkt->dts < 0)
1940
                        break;
1941
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1942
                        break;
1943
                    ppkt1->pkt->dts -= delta;
1944
                    ppkt1= ppkt1->next;
1945
                }
1946
                if(ppkt1)
1947
                    continue;
1948
                st->cur_dts -= delta;
1949
            }
1950
        }
1951
    }
1952
#endif
1953

    
1954
    av_free(duration_error);
1955
    for(i=0;i<MAX_STREAMS;i++){
1956
        av_freep(&(probe_data[i].buf));
1957
    }
1958

    
1959
    return ret;
1960
}
1961

    
1962
/*******************************************************/
1963

    
1964
int av_read_play(AVFormatContext *s)
1965
{
1966
    if (!s->iformat->read_play)
1967
        return AVERROR_NOTSUPP;
1968
    return s->iformat->read_play(s);
1969
}
1970

    
1971
int av_read_pause(AVFormatContext *s)
1972
{
1973
    if (!s->iformat->read_pause)
1974
        return AVERROR_NOTSUPP;
1975
    return s->iformat->read_pause(s);
1976
}
1977

    
1978
void av_close_input_file(AVFormatContext *s)
1979
{
1980
    int i, must_open_file;
1981
    AVStream *st;
1982

    
1983
    /* free previous packet */
1984
    if (s->cur_st && s->cur_st->parser)
1985
        av_free_packet(&s->cur_pkt);
1986

    
1987
    if (s->iformat->read_close)
1988
        s->iformat->read_close(s);
1989
    for(i=0;i<s->nb_streams;i++) {
1990
        /* free all data in a stream component */
1991
        st = s->streams[i];
1992
        if (st->parser) {
1993
            av_parser_close(st->parser);
1994
        }
1995
        av_free(st->index_entries);
1996
        av_free(st->codec->extradata);
1997
        av_free(st->codec);
1998
        av_free(st);
1999
    }
2000
    flush_packet_queue(s);
2001
    must_open_file = 1;
2002
    if (s->iformat->flags & AVFMT_NOFILE) {
2003
        must_open_file = 0;
2004
    }
2005
    if (must_open_file) {
2006
        url_fclose(&s->pb);
2007
    }
2008
    av_freep(&s->priv_data);
2009
    av_free(s);
2010
}
2011

    
2012
AVStream *av_new_stream(AVFormatContext *s, int id)
2013
{
2014
    AVStream *st;
2015
    int i;
2016

    
2017
    if (s->nb_streams >= MAX_STREAMS)
2018
        return NULL;
2019

    
2020
    st = av_mallocz(sizeof(AVStream));
2021
    if (!st)
2022
        return NULL;
2023

    
2024
    st->codec= avcodec_alloc_context();
2025
    if (s->iformat) {
2026
        /* no default bitrate if decoding */
2027
        st->codec->bit_rate = 0;
2028
    }
2029
    st->index = s->nb_streams;
2030
    st->id = id;
2031
    st->start_time = AV_NOPTS_VALUE;
2032
    st->duration = AV_NOPTS_VALUE;
2033
    st->cur_dts = AV_NOPTS_VALUE;
2034

    
2035
    /* default pts settings is MPEG like */
2036
    av_set_pts_info(st, 33, 1, 90000);
2037
    st->last_IP_pts = AV_NOPTS_VALUE;
2038
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2039
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2040

    
2041
    s->streams[s->nb_streams++] = st;
2042
    return st;
2043
}
2044

    
2045
/************************************************************/
2046
/* output media file */
2047

    
2048
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2049
{
2050
    int ret;
2051

    
2052
    if (s->oformat->priv_data_size > 0) {
2053
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2054
        if (!s->priv_data)
2055
            return AVERROR_NOMEM;
2056
    } else
2057
        s->priv_data = NULL;
2058

    
2059
    if (s->oformat->set_parameters) {
2060
        ret = s->oformat->set_parameters(s, ap);
2061
        if (ret < 0)
2062
            return ret;
2063
    }
2064
    return 0;
2065
}
2066

    
2067
int av_write_header(AVFormatContext *s)
2068
{
2069
    int ret, i;
2070
    AVStream *st;
2071

    
2072
    // some sanity checks
2073
    for(i=0;i<s->nb_streams;i++) {
2074
        st = s->streams[i];
2075

    
2076
        switch (st->codec->codec_type) {
2077
        case CODEC_TYPE_AUDIO:
2078
            if(st->codec->sample_rate<=0){
2079
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2080
                return -1;
2081
            }
2082
            break;
2083
        case CODEC_TYPE_VIDEO:
2084
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2085
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2086
                return -1;
2087
            }
2088
            if(st->codec->width<=0 || st->codec->height<=0){
2089
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2090
                return -1;
2091
            }
2092
            break;
2093
        }
2094

    
2095
        if(s->oformat->codec_tag){
2096
            if(st->codec->codec_tag){
2097
                //FIXME
2098
                //check that tag + id is in the table
2099
                //if neither is in the table -> ok
2100
                //if tag is in the table with another id -> FAIL
2101
                //if id is in the table with another tag -> FAIL unless strict < ?
2102
            }else
2103
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2104
        }
2105
    }
2106

    
2107
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2108
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2109
        if (!s->priv_data)
2110
            return AVERROR_NOMEM;
2111
    }
2112

    
2113
    if(s->oformat->write_header){
2114
        ret = s->oformat->write_header(s);
2115
        if (ret < 0)
2116
            return ret;
2117
    }
2118

    
2119
    /* init PTS generation */
2120
    for(i=0;i<s->nb_streams;i++) {
2121
        int64_t den = AV_NOPTS_VALUE;
2122
        st = s->streams[i];
2123

    
2124
        switch (st->codec->codec_type) {
2125
        case CODEC_TYPE_AUDIO:
2126
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2127
            break;
2128
        case CODEC_TYPE_VIDEO:
2129
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2130
            break;
2131
        default:
2132
            break;
2133
        }
2134
        if (den != AV_NOPTS_VALUE) {
2135
            if (den <= 0)
2136
                return AVERROR_INVALIDDATA;
2137
            av_frac_init(&st->pts, 0, 0, den);
2138
        }
2139
    }
2140
    return 0;
2141
}
2142

    
2143
//FIXME merge with compute_pkt_fields
2144
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2145
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2146
    int num, den, frame_size, i;
2147

    
2148
//    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);
2149

    
2150
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2151
        return -1;*/
2152

    
2153
    /* duration field */
2154
    if (pkt->duration == 0) {
2155
        compute_frame_duration(&num, &den, st, NULL, pkt);
2156
        if (den && num) {
2157
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2158
        }
2159
    }
2160

    
2161
    //XXX/FIXME this is a temporary hack until all encoders output pts
2162
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2163
        pkt->dts=
2164
//        pkt->pts= st->cur_dts;
2165
        pkt->pts= st->pts.val;
2166
    }
2167

    
2168
    //calculate dts from pts
2169
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2170
        st->pts_buffer[0]= pkt->pts;
2171
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2172
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2173
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2174
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2175

    
2176
        pkt->dts= st->pts_buffer[0];
2177
    }
2178

    
2179
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2180
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64" st:%d\n", st->cur_dts, pkt->dts, st->index);
2181
        return -1;
2182
    }
2183
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2184
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts (%"PRId64" < %"PRId64")\n",
2185
               pkt->pts, pkt->dts);
2186
        return -1;
2187
    }
2188

    
2189
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2190
    st->cur_dts= pkt->dts;
2191
    st->pts.val= pkt->dts;
2192

    
2193
    /* update pts */
2194
    switch (st->codec->codec_type) {
2195
    case CODEC_TYPE_AUDIO:
2196
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2197

    
2198
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2199
           but it would be better if we had the real timestamps from the encoder */
2200
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2201
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2202
        }
2203
        break;
2204
    case CODEC_TYPE_VIDEO:
2205
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2206
        break;
2207
    default:
2208
        break;
2209
    }
2210
    return 0;
2211
}
2212

    
2213
static void truncate_ts(AVStream *st, AVPacket *pkt){
2214
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2215

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

    
2219
    if (pkt->pts != AV_NOPTS_VALUE)
2220
        pkt->pts &= pts_mask;
2221
    if (pkt->dts != AV_NOPTS_VALUE)
2222
        pkt->dts &= pts_mask;
2223
}
2224

    
2225
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2226
{
2227
    int ret;
2228

    
2229
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2230
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2231
        return ret;
2232

    
2233
    truncate_ts(s->streams[pkt->stream_index], pkt);
2234

    
2235
    ret= s->oformat->write_packet(s, pkt);
2236
    if(!ret)
2237
        ret= url_ferror(&s->pb);
2238
    return ret;
2239
}
2240

    
2241
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2242
    AVPacketList *pktl, **next_point, *this_pktl;
2243
    int stream_count=0;
2244
    int streams[MAX_STREAMS];
2245

    
2246
    if(pkt){
2247
        AVStream *st= s->streams[ pkt->stream_index];
2248

    
2249
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2250

    
2251
        this_pktl = av_mallocz(sizeof(AVPacketList));
2252
        this_pktl->pkt= *pkt;
2253
        if(pkt->destruct == av_destruct_packet)
2254
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2255
        else
2256
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2257

    
2258
        next_point = &s->packet_buffer;
2259
        while(*next_point){
2260
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2261
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2262
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2263
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2264
                break;
2265
            next_point= &(*next_point)->next;
2266
        }
2267
        this_pktl->next= *next_point;
2268
        *next_point= this_pktl;
2269
    }
2270

    
2271
    memset(streams, 0, sizeof(streams));
2272
    pktl= s->packet_buffer;
2273
    while(pktl){
2274
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2275
        if(streams[ pktl->pkt.stream_index ] == 0)
2276
            stream_count++;
2277
        streams[ pktl->pkt.stream_index ]++;
2278
        pktl= pktl->next;
2279
    }
2280

    
2281
    if(s->nb_streams == stream_count || (flush && stream_count)){
2282
        pktl= s->packet_buffer;
2283
        *out= pktl->pkt;
2284

    
2285
        s->packet_buffer= pktl->next;
2286
        av_freep(&pktl);
2287
        return 1;
2288
    }else{
2289
        av_init_packet(out);
2290
        return 0;
2291
    }
2292
}
2293

    
2294
/**
2295
 * Interleaves a AVPacket correctly so it can be muxed.
2296
 * @param out the interleaved packet will be output here
2297
 * @param in the input packet
2298
 * @param flush 1 if no further packets are available as input and all
2299
 *              remaining packets should be output
2300
 * @return 1 if a packet was output, 0 if no packet could be output,
2301
 *         < 0 if an error occured
2302
 */
2303
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2304
    if(s->oformat->interleave_packet)
2305
        return s->oformat->interleave_packet(s, out, in, flush);
2306
    else
2307
        return av_interleave_packet_per_dts(s, out, in, flush);
2308
}
2309

    
2310
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2311
    AVStream *st= s->streams[ pkt->stream_index];
2312

    
2313
    //FIXME/XXX/HACK drop zero sized packets
2314
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2315
        return 0;
2316

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

    
2321
    if(pkt->dts == AV_NOPTS_VALUE)
2322
        return -1;
2323

    
2324
    for(;;){
2325
        AVPacket opkt;
2326
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2327
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2328
            return ret;
2329

    
2330
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2331
        ret= s->oformat->write_packet(s, &opkt);
2332

    
2333
        av_free_packet(&opkt);
2334
        pkt= NULL;
2335

    
2336
        if(ret<0)
2337
            return ret;
2338
        if(url_ferror(&s->pb))
2339
            return url_ferror(&s->pb);
2340
    }
2341
}
2342

    
2343
int av_write_trailer(AVFormatContext *s)
2344
{
2345
    int ret, i;
2346

    
2347
    for(;;){
2348
        AVPacket pkt;
2349
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2350
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2351
            goto fail;
2352
        if(!ret)
2353
            break;
2354

    
2355
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2356
        ret= s->oformat->write_packet(s, &pkt);
2357

    
2358
        av_free_packet(&pkt);
2359

    
2360
        if(ret<0)
2361
            goto fail;
2362
        if(url_ferror(&s->pb))
2363
            goto fail;
2364
    }
2365

    
2366
    if(s->oformat->write_trailer)
2367
        ret = s->oformat->write_trailer(s);
2368
fail:
2369
    if(ret == 0)
2370
       ret=url_ferror(&s->pb);
2371
    for(i=0;i<s->nb_streams;i++)
2372
        av_freep(&s->streams[i]->priv_data);
2373
    av_freep(&s->priv_data);
2374
    return ret;
2375
}
2376

    
2377
/* "user interface" functions */
2378

    
2379
void dump_format(AVFormatContext *ic,
2380
                 int index,
2381
                 const char *url,
2382
                 int is_output)
2383
{
2384
    int i, flags;
2385
    char buf[256];
2386

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

    
2454
typedef struct {
2455
    const char *abv;
2456
    int width, height;
2457
    int frame_rate, frame_rate_base;
2458
} AbvEntry;
2459

    
2460
static AbvEntry frame_abvs[] = {
2461
    { "ntsc",      720, 480, 30000, 1001 },
2462
    { "pal",       720, 576,    25,    1 },
2463
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2464
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2465
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2466
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2467
    { "film",      352, 240,    24,    1 },
2468
    { "ntsc-film", 352, 240, 24000, 1001 },
2469
    { "sqcif",     128,  96,     0,    0 },
2470
    { "qcif",      176, 144,     0,    0 },
2471
    { "cif",       352, 288,     0,    0 },
2472
    { "4cif",      704, 576,     0,    0 },
2473
};
2474

    
2475
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2476
{
2477
    int i;
2478
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2479
    const char *p;
2480
    int frame_width = 0, frame_height = 0;
2481

    
2482
    for(i=0;i<n;i++) {
2483
        if (!strcmp(frame_abvs[i].abv, str)) {
2484
            frame_width = frame_abvs[i].width;
2485
            frame_height = frame_abvs[i].height;
2486
            break;
2487
        }
2488
    }
2489
    if (i == n) {
2490
        p = str;
2491
        frame_width = strtol(p, (char **)&p, 10);
2492
        if (*p)
2493
            p++;
2494
        frame_height = strtol(p, (char **)&p, 10);
2495
    }
2496
    if (frame_width <= 0 || frame_height <= 0)
2497
        return -1;
2498
    *width_ptr = frame_width;
2499
    *height_ptr = frame_height;
2500
    return 0;
2501
}
2502

    
2503
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2504
{
2505
    int i;
2506
    char* cp;
2507

    
2508
    /* First, we check our abbreviation table */
2509
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2510
         if (!strcmp(frame_abvs[i].abv, arg)) {
2511
             *frame_rate = frame_abvs[i].frame_rate;
2512
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2513
             return 0;
2514
         }
2515

    
2516
    /* Then, we try to parse it as fraction */
2517
    cp = strchr(arg, '/');
2518
    if (!cp)
2519
        cp = strchr(arg, ':');
2520
    if (cp) {
2521
        char* cpp;
2522
        *frame_rate = strtol(arg, &cpp, 10);
2523
        if (cpp != arg || cpp == cp)
2524
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2525
        else
2526
           *frame_rate = 0;
2527
    }
2528
    else {
2529
        /* Finally we give up and parse it as double */
2530
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2531
        *frame_rate_base = time_base.den;
2532
        *frame_rate = time_base.num;
2533
    }
2534
    if (!*frame_rate || !*frame_rate_base)
2535
        return -1;
2536
    else
2537
        return 0;
2538
}
2539

    
2540
#ifndef CONFIG_WINCE
2541
int64_t parse_date(const char *datestr, int duration)
2542
{
2543
    const char *p;
2544
    int64_t t;
2545
    struct tm dt;
2546
    int i;
2547
    static const char *date_fmt[] = {
2548
        "%Y-%m-%d",
2549
        "%Y%m%d",
2550
    };
2551
    static const char *time_fmt[] = {
2552
        "%H:%M:%S",
2553
        "%H%M%S",
2554
    };
2555
    const char *q;
2556
    int is_utc, len;
2557
    char lastch;
2558
    int negative = 0;
2559

    
2560
#undef time
2561
    time_t now = time(0);
2562

    
2563
    len = strlen(datestr);
2564
    if (len > 0)
2565
        lastch = datestr[len - 1];
2566
    else
2567
        lastch = '\0';
2568
    is_utc = (lastch == 'z' || lastch == 'Z');
2569

    
2570
    memset(&dt, 0, sizeof(dt));
2571

    
2572
    p = datestr;
2573
    q = NULL;
2574
    if (!duration) {
2575
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2576
            q = small_strptime(p, date_fmt[i], &dt);
2577
            if (q) {
2578
                break;
2579
            }
2580
        }
2581

    
2582
        if (!q) {
2583
            if (is_utc) {
2584
                dt = *gmtime(&now);
2585
            } else {
2586
                dt = *localtime(&now);
2587
            }
2588
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2589
        } else {
2590
            p = q;
2591
        }
2592

    
2593
        if (*p == 'T' || *p == 't' || *p == ' ')
2594
            p++;
2595

    
2596
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2597
            q = small_strptime(p, time_fmt[i], &dt);
2598
            if (q) {
2599
                break;
2600
            }
2601
        }
2602
    } else {
2603
        if (p[0] == '-') {
2604
            negative = 1;
2605
            ++p;
2606
        }
2607
        q = small_strptime(p, time_fmt[0], &dt);
2608
        if (!q) {
2609
            dt.tm_sec = strtol(p, (char **)&q, 10);
2610
            dt.tm_min = 0;
2611
            dt.tm_hour = 0;
2612
        }
2613
    }
2614

    
2615
    /* Now we have all the fields that we can get */
2616
    if (!q) {
2617
        if (duration)
2618
            return 0;
2619
        else
2620
            return now * INT64_C(1000000);
2621
    }
2622

    
2623
    if (duration) {
2624
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2625
    } else {
2626
        dt.tm_isdst = -1;       /* unknown */
2627
        if (is_utc) {
2628
            t = mktimegm(&dt);
2629
        } else {
2630
            t = mktime(&dt);
2631
        }
2632
    }
2633

    
2634
    t *= 1000000;
2635

    
2636
    if (*q == '.') {
2637
        int val, n;
2638
        q++;
2639
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2640
            if (!isdigit(*q))
2641
                break;
2642
            val += n * (*q - '0');
2643
        }
2644
        t += val;
2645
    }
2646
    return negative ? -t : t;
2647
}
2648
#endif /* CONFIG_WINCE */
2649

    
2650
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2651
{
2652
    const char *p;
2653
    char tag[128], *q;
2654

    
2655
    p = info;
2656
    if (*p == '?')
2657
        p++;
2658
    for(;;) {
2659
        q = tag;
2660
        while (*p != '\0' && *p != '=' && *p != '&') {
2661
            if ((q - tag) < sizeof(tag) - 1)
2662
                *q++ = *p;
2663
            p++;
2664
        }
2665
        *q = '\0';
2666
        q = arg;
2667
        if (*p == '=') {
2668
            p++;
2669
            while (*p != '&' && *p != '\0') {
2670
                if ((q - arg) < arg_size - 1) {
2671
                    if (*p == '+')
2672
                        *q++ = ' ';
2673
                    else
2674
                        *q++ = *p;
2675
                }
2676
                p++;
2677
            }
2678
            *q = '\0';
2679
        }
2680
        if (!strcmp(tag, tag1))
2681
            return 1;
2682
        if (*p != '&')
2683
            break;
2684
        p++;
2685
    }
2686
    return 0;
2687
}
2688

    
2689
int av_get_frame_filename(char *buf, int buf_size,
2690
                          const char *path, int number)
2691
{
2692
    const char *p;
2693
    char *q, buf1[20], c;
2694
    int nd, len, percentd_found;
2695

    
2696
    q = buf;
2697
    p = path;
2698
    percentd_found = 0;
2699
    for(;;) {
2700
        c = *p++;
2701
        if (c == '\0')
2702
            break;
2703
        if (c == '%') {
2704
            do {
2705
                nd = 0;
2706
                while (isdigit(*p)) {
2707
                    nd = nd * 10 + *p++ - '0';
2708
                }
2709
                c = *p++;
2710
            } while (isdigit(c));
2711

    
2712
            switch(c) {
2713
            case '%':
2714
                goto addchar;
2715
            case 'd':
2716
                if (percentd_found)
2717
                    goto fail;
2718
                percentd_found = 1;
2719
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2720
                len = strlen(buf1);
2721
                if ((q - buf + len) > buf_size - 1)
2722
                    goto fail;
2723
                memcpy(q, buf1, len);
2724
                q += len;
2725
                break;
2726
            default:
2727
                goto fail;
2728
            }
2729
        } else {
2730
        addchar:
2731
            if ((q - buf) < buf_size - 1)
2732
                *q++ = c;
2733
        }
2734
    }
2735
    if (!percentd_found)
2736
        goto fail;
2737
    *q = '\0';
2738
    return 0;
2739
 fail:
2740
    *q = '\0';
2741
    return -1;
2742
}
2743

    
2744
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2745
{
2746
    int len, i, j, c;
2747
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2748

    
2749
    for(i=0;i<size;i+=16) {
2750
        len = size - i;
2751
        if (len > 16)
2752
            len = 16;
2753
        PRINT("%08x ", i);
2754
        for(j=0;j<16;j++) {
2755
            if (j < len)
2756
                PRINT(" %02x", buf[i+j]);
2757
            else
2758
                PRINT("   ");
2759
        }
2760
        PRINT(" ");
2761
        for(j=0;j<len;j++) {
2762
            c = buf[i+j];
2763
            if (c < ' ' || c > '~')
2764
                c = '.';
2765
            PRINT("%c", c);
2766
        }
2767
        PRINT("\n");
2768
    }
2769
#undef PRINT
2770
}
2771

    
2772
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2773
{
2774
    hex_dump_internal(NULL, f, 0, buf, size);
2775
}
2776

    
2777
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2778
{
2779
    hex_dump_internal(avcl, NULL, level, buf, size);
2780
}
2781

    
2782
 //FIXME needs to know the time_base
2783
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2784
{
2785
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2786
    PRINT("stream #%d:\n", pkt->stream_index);
2787
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2788
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2789
    /* DTS is _always_ valid after av_read_frame() */
2790
    PRINT("  dts=");
2791
    if (pkt->dts == AV_NOPTS_VALUE)
2792
        PRINT("N/A");
2793
    else
2794
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2795
    /* PTS may be not known if B frames are present */
2796
    PRINT("  pts=");
2797
    if (pkt->pts == AV_NOPTS_VALUE)
2798
        PRINT("N/A");
2799
    else
2800
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2801
    PRINT("\n");
2802
    PRINT("  size=%d\n", pkt->size);
2803
#undef PRINT
2804
    if (dump_payload)
2805
        av_hex_dump(f, pkt->data, pkt->size);
2806
}
2807

    
2808
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2809
{
2810
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2811
}
2812

    
2813
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2814
{
2815
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2816
}
2817

    
2818
void url_split(char *proto, int proto_size,
2819
               char *authorization, int authorization_size,
2820
               char *hostname, int hostname_size,
2821
               int *port_ptr,
2822
               char *path, int path_size,
2823
               const char *url)
2824
{
2825
    const char *p;
2826
    char *q;
2827
    int port;
2828

    
2829
    port = -1;
2830

    
2831
    p = url;
2832
    q = proto;
2833
    while (*p != ':' && *p != '\0') {
2834
        if ((q - proto) < proto_size - 1)
2835
            *q++ = *p;
2836
        p++;
2837
    }
2838
    if (proto_size > 0)
2839
        *q = '\0';
2840
    if (authorization_size > 0)
2841
        authorization[0] = '\0';
2842
    if (*p == '\0') {
2843
        if (proto_size > 0)
2844
            proto[0] = '\0';
2845
        if (hostname_size > 0)
2846
            hostname[0] = '\0';
2847
        p = url;
2848
    } else {
2849
        char *at,*slash; // PETR: position of '@' character and '/' character
2850

    
2851
        p++;
2852
        if (*p == '/')
2853
            p++;
2854
        if (*p == '/')
2855
            p++;
2856
        at = strchr(p,'@'); // PETR: get the position of '@'
2857
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2858
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2859

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

    
2862
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2863
            if (*p == '@') {    // PETR: passed '@'
2864
              if (authorization_size > 0)
2865
                  *q = '\0';
2866
              q = hostname;
2867
              at = NULL;
2868
            } else if (!at) {   // PETR: hostname
2869
              if ((q - hostname) < hostname_size - 1)
2870
                  *q++ = *p;
2871
            } else {
2872
              if ((q - authorization) < authorization_size - 1)
2873
                *q++ = *p;
2874
            }
2875
            p++;
2876
        }
2877
        if (hostname_size > 0)
2878
            *q = '\0';
2879
        if (*p == ':') {
2880
            p++;
2881
            port = strtoul(p, (char **)&p, 10);
2882
        }
2883
    }
2884
    if (port_ptr)
2885
        *port_ptr = port;
2886
    pstrcpy(path, path_size, p);
2887
}
2888

    
2889
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2890
                     int pts_num, int pts_den)
2891
{
2892
    s->pts_wrap_bits = pts_wrap_bits;
2893
    s->time_base.num = pts_num;
2894
    s->time_base.den = pts_den;
2895
}
2896

    
2897
/* fraction handling */
2898

    
2899
/**
2900
 * f = val + (num / den) + 0.5.
2901
 *
2902
 * 'num' is normalized so that it is such as 0 <= num < den.
2903
 *
2904
 * @param f fractional number
2905
 * @param val integer value
2906
 * @param num must be >= 0
2907
 * @param den must be >= 1
2908
 */
2909
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2910
{
2911
    num += (den >> 1);
2912
    if (num >= den) {
2913
        val += num / den;
2914
        num = num % den;
2915
    }
2916
    f->val = val;
2917
    f->num = num;
2918
    f->den = den;
2919
}
2920

    
2921
/**
2922
 * Fractionnal addition to f: f = f + (incr / f->den).
2923
 *
2924
 * @param f fractional number
2925
 * @param incr increment, can be positive or negative
2926
 */
2927
static void av_frac_add(AVFrac *f, int64_t incr)
2928
{
2929
    int64_t num, den;
2930

    
2931
    num = f->num + incr;
2932
    den = f->den;
2933
    if (num < 0) {
2934
        f->val += num / den;
2935
        num = num % den;
2936
        if (num < 0) {
2937
            num += den;
2938
            f->val--;
2939
        }
2940
    } else if (num >= den) {
2941
        f->val += num / den;
2942
        num = num % den;
2943
    }
2944
    f->num = num;
2945
}