Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ b3fc0925

History | View | Annotate | Download (86.9 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
#include "avstring.h"
25
#include "riff.h"
26

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

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

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

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

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

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

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

    
66
    if(!filename)
67
        return 0;
68

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

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

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

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

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

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

    
137
        if (stream_fmt)
138
            fmt = stream_fmt;
139
    }
140

    
141
    return fmt;
142
}
143

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

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

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

    
173
/* memory handling */
174

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

    
181
void av_init_packet(AVPacket *pkt)
182
{
183
    pkt->pts   = AV_NOPTS_VALUE;
184
    pkt->dts   = AV_NOPTS_VALUE;
185
    pkt->pos   = -1;
186
    pkt->duration = 0;
187
    pkt->flags = 0;
188
    pkt->stream_index = 0;
189
    pkt->destruct= av_destruct_packet_nofree;
190
}
191

    
192
int av_new_packet(AVPacket *pkt, int size)
193
{
194
    uint8_t *data;
195
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
196
        return AVERROR_NOMEM;
197
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
198
    if (!data)
199
        return AVERROR_NOMEM;
200
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
201

    
202
    av_init_packet(pkt);
203
    pkt->data = data;
204
    pkt->size = size;
205
    pkt->destruct = av_destruct_packet;
206
    return 0;
207
}
208

    
209
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
210
{
211
    int ret= av_new_packet(pkt, size);
212

    
213
    if(ret<0)
214
        return ret;
215

    
216
    pkt->pos= url_ftell(s);
217

    
218
    ret= get_buffer(s, pkt->data, size);
219
    if(ret<=0)
220
        av_free_packet(pkt);
221
    else
222
        pkt->size= ret;
223

    
224
    return ret;
225
}
226

    
227
int av_dup_packet(AVPacket *pkt)
228
{
229
    if (pkt->destruct != av_destruct_packet) {
230
        uint8_t *data;
231
        /* we duplicate the packet and don't forget to put the padding
232
           again */
233
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
234
            return AVERROR_NOMEM;
235
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
236
        if (!data) {
237
            return AVERROR_NOMEM;
238
        }
239
        memcpy(data, pkt->data, pkt->size);
240
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
241
        pkt->data = data;
242
        pkt->destruct = av_destruct_packet;
243
    }
244
    return 0;
245
}
246

    
247
int av_filename_number_test(const char *filename)
248
{
249
    char buf[1024];
250
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
251
}
252

    
253
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
254
{
255
    AVInputFormat *fmt1, *fmt;
256
    int score;
257

    
258
    fmt = NULL;
259
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
260
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
261
            continue;
262
        score = 0;
263
        if (fmt1->read_probe) {
264
            score = fmt1->read_probe(pd);
265
        } else if (fmt1->extensions) {
266
            if (match_ext(pd->filename, fmt1->extensions)) {
267
                score = 50;
268
            }
269
        }
270
        if (score > *score_max) {
271
            *score_max = score;
272
            fmt = fmt1;
273
        }
274
    }
275
    return fmt;
276
}
277

    
278
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
279
    int score=0;
280
    return av_probe_input_format2(pd, is_opened, &score);
281
}
282

    
283
/************************************************************/
284
/* input media file */
285

    
286
/**
287
 * Open a media file from an IO stream. 'fmt' must be specified.
288
 */
289
static const char* format_to_name(void* ptr)
290
{
291
    AVFormatContext* fc = (AVFormatContext*) ptr;
292
    if(fc->iformat) return fc->iformat->name;
293
    else if(fc->oformat) return fc->oformat->name;
294
    else return "NULL";
295
}
296

    
297
#define OFFSET(x) offsetof(AVFormatContext,x)
298
#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
299
//these names are too long to be readable
300
#define E AV_OPT_FLAG_ENCODING_PARAM
301
#define D AV_OPT_FLAG_DECODING_PARAM
302

    
303
static const AVOption options[]={
304
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
305
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
306
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
307
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
308
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
309
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
310
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
311
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
312
{"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},
313
{NULL},
314
};
315

    
316
#undef E
317
#undef D
318
#undef DEFAULT
319

    
320
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
321

    
322
static void avformat_get_context_defaults(AVFormatContext *s)
323
{
324
    memset(s, 0, sizeof(AVFormatContext));
325

    
326
    s->av_class = &av_format_context_class;
327

    
328
    av_opt_set_defaults(s);
329
}
330

    
331
AVFormatContext *av_alloc_format_context(void)
332
{
333
    AVFormatContext *ic;
334
    ic = av_malloc(sizeof(AVFormatContext));
335
    if (!ic) return ic;
336
    avformat_get_context_defaults(ic);
337
    ic->av_class = &av_format_context_class;
338
    return ic;
339
}
340

    
341
int av_open_input_stream(AVFormatContext **ic_ptr,
342
                         ByteIOContext *pb, const char *filename,
343
                         AVInputFormat *fmt, AVFormatParameters *ap)
344
{
345
    int err;
346
    AVFormatContext *ic;
347
    AVFormatParameters default_ap;
348

    
349
    if(!ap){
350
        ap=&default_ap;
351
        memset(ap, 0, sizeof(default_ap));
352
    }
353

    
354
    if(!ap->prealloced_context)
355
        ic = av_alloc_format_context();
356
    else
357
        ic = *ic_ptr;
358
    if (!ic) {
359
        err = AVERROR_NOMEM;
360
        goto fail;
361
    }
362
    ic->iformat = fmt;
363
    if (pb)
364
        ic->pb = *pb;
365
    ic->duration = AV_NOPTS_VALUE;
366
    ic->start_time = AV_NOPTS_VALUE;
367
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
368

    
369
    /* allocate private data */
370
    if (fmt->priv_data_size > 0) {
371
        ic->priv_data = av_mallocz(fmt->priv_data_size);
372
        if (!ic->priv_data) {
373
            err = AVERROR_NOMEM;
374
            goto fail;
375
        }
376
    } else {
377
        ic->priv_data = NULL;
378
    }
379

    
380
    err = ic->iformat->read_header(ic, ap);
381
    if (err < 0)
382
        goto fail;
383

    
384
    if (pb && !ic->data_offset)
385
        ic->data_offset = url_ftell(&ic->pb);
386

    
387
    *ic_ptr = ic;
388
    return 0;
389
 fail:
390
    if (ic) {
391
        av_freep(&ic->priv_data);
392
    }
393
    av_free(ic);
394
    *ic_ptr = NULL;
395
    return err;
396
}
397

    
398
/** Size of probe buffer, for guessing file type from file contents. */
399
#define PROBE_BUF_MIN 2048
400
#define PROBE_BUF_MAX (1<<20)
401

    
402
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
403
                       AVInputFormat *fmt,
404
                       int buf_size,
405
                       AVFormatParameters *ap)
406
{
407
    int err, must_open_file, file_opened, probe_size;
408
    AVProbeData probe_data, *pd = &probe_data;
409
    ByteIOContext pb1, *pb = &pb1;
410

    
411
    file_opened = 0;
412
    pd->filename = "";
413
    if (filename)
414
        pd->filename = filename;
415
    pd->buf = NULL;
416
    pd->buf_size = 0;
417

    
418
    if (!fmt) {
419
        /* guess format if no file can be opened  */
420
        fmt = av_probe_input_format(pd, 0);
421
    }
422

    
423
    /* do not open file if the format does not need it. XXX: specific
424
       hack needed to handle RTSP/TCP */
425
    must_open_file = 1;
426
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
427
        must_open_file = 0;
428
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise it is uninitialized
429
    }
430

    
431
    if (!fmt || must_open_file) {
432
        /* if no file needed do not try to open one */
433
        if ((err=url_fopen(pb, filename, URL_RDONLY)) < 0) {
434
            goto fail;
435
        }
436
        file_opened = 1;
437
        if (buf_size > 0) {
438
            url_setbufsize(pb, buf_size);
439
        }
440

    
441
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
442
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
443
            /* read probe data */
444
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
445
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
446
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
447
                url_fclose(pb);
448
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
449
                    file_opened = 0;
450
                    err = AVERROR_IO;
451
                    goto fail;
452
                }
453
            }
454
            /* guess file format */
455
            fmt = av_probe_input_format2(pd, 1, &score);
456
        }
457
        av_freep(&pd->buf);
458
    }
459

    
460
    /* if still no format found, error */
461
    if (!fmt) {
462
        err = AVERROR_NOFMT;
463
        goto fail;
464
    }
465

    
466
    /* XXX: suppress this hack for redirectors */
467
#ifdef CONFIG_REDIR_DEMUXER
468
    if (fmt == &redir_demuxer) {
469
        err = redir_open(ic_ptr, pb);
470
        url_fclose(pb);
471
        return err;
472
    }
473
#endif
474

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

    
493
}
494

    
495
/*******************************************************/
496

    
497
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
498
{
499
    av_init_packet(pkt);
500
    return s->iformat->read_packet(s, pkt);
501
}
502

    
503
/**********************************************************/
504

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

    
512
    if (enc->frame_size <= 1) {
513
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
514

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

    
531

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

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

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

    
590
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
591
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
592
    int64_t delta= last_ts - mask/2;
593
    return  ((lsb - delta)&mask) + delta;
594
}
595

    
596
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
597
                               AVCodecParserContext *pc, AVPacket *pkt)
598
{
599
    int num, den, presentation_delayed, delay, i;
600
    int64_t offset;
601
    /* handle wrapping */
602
    if(st->cur_dts != AV_NOPTS_VALUE){
603
        if(pkt->pts != AV_NOPTS_VALUE)
604
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
605
        if(pkt->dts != AV_NOPTS_VALUE)
606
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
607
    }
608

    
609
    if (pkt->duration == 0) {
610
        compute_frame_duration(&num, &den, st, pc, pkt);
611
        if (den && num) {
612
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
613
        }
614
    }
615

    
616
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
617
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
618
        /* this will estimate bitrate based on this frame's duration and size */
619
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
620
        if(pkt->pts != AV_NOPTS_VALUE)
621
            pkt->pts += offset;
622
        if(pkt->dts != AV_NOPTS_VALUE)
623
            pkt->dts += offset;
624
    }
625

    
626
    if(is_intra_only(st->codec))
627
        pkt->flags |= PKT_FLAG_KEY;
628

    
629
    /* do we have a video B frame ? */
630
    delay= st->codec->has_b_frames;
631
    presentation_delayed = 0;
632
    /* XXX: need has_b_frame, but cannot get it if the codec is
633
        not initialized */
634
    if (delay &&
635
        pc && pc->pict_type != FF_B_TYPE)
636
        presentation_delayed = 1;
637
    /* This may be redundant, but it should not hurt. */
638
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
639
        presentation_delayed = 1;
640

    
641
    if(st->cur_dts == AV_NOPTS_VALUE){
642
        st->cur_dts = -delay * pkt->duration;
643
    }
644

    
645
//    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);
646
    /* interpolate PTS and DTS if they are not present */
647
    if(delay <=1){
648
        if (presentation_delayed) {
649
            /* DTS = decompression time stamp */
650
            /* PTS = presentation time stamp */
651
            if (pkt->dts == AV_NOPTS_VALUE)
652
                pkt->dts = st->last_IP_pts;
653
            if (pkt->dts == AV_NOPTS_VALUE)
654
                pkt->dts = st->cur_dts;
655

    
656
            /* this is tricky: the dts must be incremented by the duration
657
            of the frame we are displaying, i.e. the last I or P frame */
658
            if (st->last_IP_duration == 0)
659
                st->last_IP_duration = pkt->duration;
660
            st->cur_dts = pkt->dts + st->last_IP_duration;
661
            st->last_IP_duration  = pkt->duration;
662
            st->last_IP_pts= pkt->pts;
663
            /* cannot compute PTS if not present (we can compute it only
664
            by knowing the futur */
665
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
666
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
667
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
668
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
669
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
670
                    pkt->pts += pkt->duration;
671
    //                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);
672
                }
673
            }
674

    
675
            /* presentation is not delayed : PTS and DTS are the same */
676
            if(pkt->pts == AV_NOPTS_VALUE)
677
                pkt->pts = pkt->dts;
678
            if(pkt->pts == AV_NOPTS_VALUE)
679
                pkt->pts = st->cur_dts;
680
            pkt->dts = pkt->pts;
681
            st->cur_dts = pkt->pts + pkt->duration;
682
        }
683
    }
684

    
685
    if(pkt->pts != AV_NOPTS_VALUE){
686
        st->pts_buffer[0]= pkt->pts;
687
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
688
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
689
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
690
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
691
        if(pkt->dts == AV_NOPTS_VALUE)
692
            pkt->dts= st->pts_buffer[0];
693
        if(pkt->dts > st->cur_dts)
694
            st->cur_dts = pkt->dts;
695
    }
696

    
697
//    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);
698

    
699
    /* update flags */
700
    if (pc) {
701
        pkt->flags = 0;
702
        /* key frame computation */
703
            if (pc->pict_type == FF_I_TYPE)
704
                pkt->flags |= PKT_FLAG_KEY;
705
    }
706
}
707

    
708
void av_destruct_packet_nofree(AVPacket *pkt)
709
{
710
    pkt->data = NULL; pkt->size = 0;
711
}
712

    
713
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
714
{
715
    AVStream *st;
716
    int len, ret, i;
717

    
718
    av_init_packet(pkt);
719

    
720
    for(;;) {
721
        /* select current input stream component */
722
        st = s->cur_st;
723
        if (st) {
724
            if (!st->need_parsing || !st->parser) {
725
                /* no parsing needed: we just output the packet as is */
726
                /* raw data support */
727
                *pkt = s->cur_pkt;
728
                compute_pkt_fields(s, st, NULL, pkt);
729
                s->cur_st = NULL;
730
                break;
731
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
732
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
733
                                      s->cur_ptr, s->cur_len,
734
                                      s->cur_pkt.pts, s->cur_pkt.dts);
735
                s->cur_pkt.pts = AV_NOPTS_VALUE;
736
                s->cur_pkt.dts = AV_NOPTS_VALUE;
737
                /* increment read pointer */
738
                s->cur_ptr += len;
739
                s->cur_len -= len;
740

    
741
                /* return packet if any */
742
                if (pkt->size) {
743
                got_packet:
744
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
745
                    pkt->duration = 0;
746
                    pkt->stream_index = st->index;
747
                    pkt->pts = st->parser->pts;
748
                    pkt->dts = st->parser->dts;
749
                    pkt->destruct = av_destruct_packet_nofree;
750
                    compute_pkt_fields(s, st, st->parser, pkt);
751

    
752
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
753
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
754
                                           0, 0, AVINDEX_KEYFRAME);
755
                    }
756

    
757
                    break;
758
                }
759
            } else {
760
                /* free packet */
761
                av_free_packet(&s->cur_pkt);
762
                s->cur_st = NULL;
763
            }
764
        } else {
765
            /* read next packet */
766
            ret = av_read_packet(s, &s->cur_pkt);
767
            if (ret < 0) {
768
                if (ret == AVERROR(EAGAIN))
769
                    return ret;
770
                /* return the last frames, if any */
771
                for(i = 0; i < s->nb_streams; i++) {
772
                    st = s->streams[i];
773
                    if (st->parser && st->need_parsing) {
774
                        av_parser_parse(st->parser, st->codec,
775
                                        &pkt->data, &pkt->size,
776
                                        NULL, 0,
777
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
778
                        if (pkt->size)
779
                            goto got_packet;
780
                    }
781
                }
782
                /* no more packets: really terminates parsing */
783
                return ret;
784
            }
785

    
786
            st = s->streams[s->cur_pkt.stream_index];
787
            if(st->codec->debug & FF_DEBUG_PTS)
788
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
789
                    s->cur_pkt.stream_index,
790
                    s->cur_pkt.pts,
791
                    s->cur_pkt.dts,
792
                    s->cur_pkt.size);
793

    
794
            s->cur_st = st;
795
            s->cur_ptr = s->cur_pkt.data;
796
            s->cur_len = s->cur_pkt.size;
797
            if (st->need_parsing && !st->parser) {
798
                st->parser = av_parser_init(st->codec->codec_id);
799
                if (!st->parser) {
800
                    /* no parser available : just output the raw packets */
801
                    st->need_parsing = AVSTREAM_PARSE_NONE;
802
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
803
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
804
                }
805
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
806
                    st->parser->last_frame_offset=
807
                    st->parser->cur_offset= s->cur_pkt.pos;
808
                }
809
            }
810
        }
811
    }
812
    if(st->codec->debug & FF_DEBUG_PTS)
813
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
814
            pkt->stream_index,
815
            pkt->pts,
816
            pkt->dts,
817
            pkt->size);
818

    
819
    return 0;
820
}
821

    
822
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
823
{
824
    AVPacketList *pktl;
825
    int eof=0;
826
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
827

    
828
    for(;;){
829
        pktl = s->packet_buffer;
830
        if (pktl) {
831
            AVPacket *next_pkt= &pktl->pkt;
832

    
833
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
834
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
835
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
836
                       && next_pkt->dts < pktl->pkt.dts
837
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
838
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
839
                        next_pkt->pts= pktl->pkt.dts;
840
                    }
841
                    pktl= pktl->next;
842
                }
843
                pktl = s->packet_buffer;
844
            }
845

    
846
            if(   next_pkt->pts != AV_NOPTS_VALUE
847
               || next_pkt->dts == AV_NOPTS_VALUE
848
               || !genpts || eof){
849
                /* read packet from packet buffer, if there is data */
850
                *pkt = *next_pkt;
851
                s->packet_buffer = pktl->next;
852
                av_free(pktl);
853
                return 0;
854
            }
855
        }
856
        if(genpts){
857
            AVPacketList **plast_pktl= &s->packet_buffer;
858
            int ret= av_read_frame_internal(s, pkt);
859
            if(ret<0){
860
                if(pktl && ret != AVERROR(EAGAIN)){
861
                    eof=1;
862
                    continue;
863
                }else
864
                    return ret;
865
            }
866

    
867
            /* duplicate the packet */
868
            if (av_dup_packet(pkt) < 0)
869
                return AVERROR_NOMEM;
870

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

    
873
            pktl = av_mallocz(sizeof(AVPacketList));
874
            if (!pktl)
875
                return AVERROR_NOMEM;
876

    
877
            /* add the packet in the buffered packet list */
878
            *plast_pktl = pktl;
879
            pktl->pkt= *pkt;
880
        }else{
881
            assert(!s->packet_buffer);
882
            return av_read_frame_internal(s, pkt);
883
        }
884
    }
885
}
886

    
887
/* XXX: suppress the packet queue */
888
static void flush_packet_queue(AVFormatContext *s)
889
{
890
    AVPacketList *pktl;
891

    
892
    for(;;) {
893
        pktl = s->packet_buffer;
894
        if (!pktl)
895
            break;
896
        s->packet_buffer = pktl->next;
897
        av_free_packet(&pktl->pkt);
898
        av_free(pktl);
899
    }
900
}
901

    
902
/*******************************************************/
903
/* seek support */
904

    
905
int av_find_default_stream_index(AVFormatContext *s)
906
{
907
    int i;
908
    AVStream *st;
909

    
910
    if (s->nb_streams <= 0)
911
        return -1;
912
    for(i = 0; i < s->nb_streams; i++) {
913
        st = s->streams[i];
914
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
915
            return i;
916
        }
917
    }
918
    return 0;
919
}
920

    
921
/**
922
 * Flush the frame reader.
923
 */
924
static void av_read_frame_flush(AVFormatContext *s)
925
{
926
    AVStream *st;
927
    int i;
928

    
929
    flush_packet_queue(s);
930

    
931
    /* free previous packet */
932
    if (s->cur_st) {
933
        if (s->cur_st->parser)
934
            av_free_packet(&s->cur_pkt);
935
        s->cur_st = NULL;
936
    }
937
    /* fail safe */
938
    s->cur_ptr = NULL;
939
    s->cur_len = 0;
940

    
941
    /* for each stream, reset read state */
942
    for(i = 0; i < s->nb_streams; i++) {
943
        st = s->streams[i];
944

    
945
        if (st->parser) {
946
            av_parser_close(st->parser);
947
            st->parser = NULL;
948
        }
949
        st->last_IP_pts = AV_NOPTS_VALUE;
950
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
951
    }
952
}
953

    
954
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
955
    int i;
956

    
957
    for(i = 0; i < s->nb_streams; i++) {
958
        AVStream *st = s->streams[i];
959

    
960
        st->cur_dts = av_rescale(timestamp,
961
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
962
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
963
    }
964
}
965

    
966
int av_add_index_entry(AVStream *st,
967
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
968
{
969
    AVIndexEntry *entries, *ie;
970
    int index;
971

    
972
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
973
        return -1;
974

    
975
    entries = av_fast_realloc(st->index_entries,
976
                              &st->index_entries_allocated_size,
977
                              (st->nb_index_entries + 1) *
978
                              sizeof(AVIndexEntry));
979
    if(!entries)
980
        return -1;
981

    
982
    st->index_entries= entries;
983

    
984
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
985

    
986
    if(index<0){
987
        index= st->nb_index_entries++;
988
        ie= &entries[index];
989
        assert(index==0 || ie[-1].timestamp < timestamp);
990
    }else{
991
        ie= &entries[index];
992
        if(ie->timestamp != timestamp){
993
            if(ie->timestamp <= timestamp)
994
                return -1;
995
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
996
            st->nb_index_entries++;
997
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
998
            distance= ie->min_distance;
999
    }
1000

    
1001
    ie->pos = pos;
1002
    ie->timestamp = timestamp;
1003
    ie->min_distance= distance;
1004
    ie->size= size;
1005
    ie->flags = flags;
1006

    
1007
    return index;
1008
}
1009

    
1010
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1011
                              int flags)
1012
{
1013
    AVIndexEntry *entries= st->index_entries;
1014
    int nb_entries= st->nb_index_entries;
1015
    int a, b, m;
1016
    int64_t timestamp;
1017

    
1018
    a = - 1;
1019
    b = nb_entries;
1020

    
1021
    while (b - a > 1) {
1022
        m = (a + b) >> 1;
1023
        timestamp = entries[m].timestamp;
1024
        if(timestamp >= wanted_timestamp)
1025
            b = m;
1026
        if(timestamp <= wanted_timestamp)
1027
            a = m;
1028
    }
1029
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1030

    
1031
    if(!(flags & AVSEEK_FLAG_ANY)){
1032
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1033
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1034
        }
1035
    }
1036

    
1037
    if(m == nb_entries)
1038
        return -1;
1039
    return  m;
1040
}
1041

    
1042
#define DEBUG_SEEK
1043

    
1044
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1045
    AVInputFormat *avif= s->iformat;
1046
    int64_t pos_min, pos_max, pos, pos_limit;
1047
    int64_t ts_min, ts_max, ts;
1048
    int index;
1049
    AVStream *st;
1050

    
1051
    if (stream_index < 0)
1052
        return -1;
1053

    
1054
#ifdef DEBUG_SEEK
1055
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1056
#endif
1057

    
1058
    ts_max=
1059
    ts_min= AV_NOPTS_VALUE;
1060
    pos_limit= -1; //gcc falsely says it may be uninitialized
1061

    
1062
    st= s->streams[stream_index];
1063
    if(st->index_entries){
1064
        AVIndexEntry *e;
1065

    
1066
        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()
1067
        index= FFMAX(index, 0);
1068
        e= &st->index_entries[index];
1069

    
1070
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1071
            pos_min= e->pos;
1072
            ts_min= e->timestamp;
1073
#ifdef DEBUG_SEEK
1074
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1075
               pos_min,ts_min);
1076
#endif
1077
        }else{
1078
            assert(index==0);
1079
        }
1080

    
1081
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1082
        assert(index < st->nb_index_entries);
1083
        if(index >= 0){
1084
            e= &st->index_entries[index];
1085
            assert(e->timestamp >= target_ts);
1086
            pos_max= e->pos;
1087
            ts_max= e->timestamp;
1088
            pos_limit= pos_max - e->min_distance;
1089
#ifdef DEBUG_SEEK
1090
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1091
               pos_max,pos_limit, ts_max);
1092
#endif
1093
        }
1094
    }
1095

    
1096
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1097
    if(pos<0)
1098
        return -1;
1099

    
1100
    /* do the seek */
1101
    url_fseek(&s->pb, pos, SEEK_SET);
1102

    
1103
    av_update_cur_dts(s, st, ts);
1104

    
1105
    return 0;
1106
}
1107

    
1108
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 )){
1109
    int64_t pos, ts;
1110
    int64_t start_pos, filesize;
1111
    int no_change;
1112

    
1113
#ifdef DEBUG_SEEK
1114
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1115
#endif
1116

    
1117
    if(ts_min == AV_NOPTS_VALUE){
1118
        pos_min = s->data_offset;
1119
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1120
        if (ts_min == AV_NOPTS_VALUE)
1121
            return -1;
1122
    }
1123

    
1124
    if(ts_max == AV_NOPTS_VALUE){
1125
        int step= 1024;
1126
        filesize = url_fsize(&s->pb);
1127
        pos_max = filesize - 1;
1128
        do{
1129
            pos_max -= step;
1130
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1131
            step += step;
1132
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1133
        if (ts_max == AV_NOPTS_VALUE)
1134
            return -1;
1135

    
1136
        for(;;){
1137
            int64_t tmp_pos= pos_max + 1;
1138
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1139
            if(tmp_ts == AV_NOPTS_VALUE)
1140
                break;
1141
            ts_max= tmp_ts;
1142
            pos_max= tmp_pos;
1143
            if(tmp_pos >= filesize)
1144
                break;
1145
        }
1146
        pos_limit= pos_max;
1147
    }
1148

    
1149
    if(ts_min > ts_max){
1150
        return -1;
1151
    }else if(ts_min == ts_max){
1152
        pos_limit= pos_min;
1153
    }
1154

    
1155
    no_change=0;
1156
    while (pos_min < pos_limit) {
1157
#ifdef DEBUG_SEEK
1158
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1159
               pos_min, pos_max,
1160
               ts_min, ts_max);
1161
#endif
1162
        assert(pos_limit <= pos_max);
1163

    
1164
        if(no_change==0){
1165
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1166
            // interpolate position (better than dichotomy)
1167
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1168
                + pos_min - approximate_keyframe_distance;
1169
        }else if(no_change==1){
1170
            // bisection, if interpolation failed to change min or max pos last time
1171
            pos = (pos_min + pos_limit)>>1;
1172
        }else{
1173
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1174
            pos=pos_min;
1175
        }
1176
        if(pos <= pos_min)
1177
            pos= pos_min + 1;
1178
        else if(pos > pos_limit)
1179
            pos= pos_limit;
1180
        start_pos= pos;
1181

    
1182
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1183
        if(pos == pos_max)
1184
            no_change++;
1185
        else
1186
            no_change=0;
1187
#ifdef DEBUG_SEEK
1188
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);
1189
#endif
1190
        if(ts == AV_NOPTS_VALUE){
1191
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1192
            return -1;
1193
        }
1194
        assert(ts != AV_NOPTS_VALUE);
1195
        if (target_ts <= ts) {
1196
            pos_limit = start_pos - 1;
1197
            pos_max = pos;
1198
            ts_max = ts;
1199
        }
1200
        if (target_ts >= ts) {
1201
            pos_min = pos;
1202
            ts_min = ts;
1203
        }
1204
    }
1205

    
1206
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1207
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1208
#ifdef DEBUG_SEEK
1209
    pos_min = pos;
1210
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1211
    pos_min++;
1212
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1213
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1214
           pos, ts_min, target_ts, ts_max);
1215
#endif
1216
    *ts_ret= ts;
1217
    return pos;
1218
}
1219

    
1220
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1221
    int64_t pos_min, pos_max;
1222
#if 0
1223
    AVStream *st;
1224

1225
    if (stream_index < 0)
1226
        return -1;
1227

1228
    st= s->streams[stream_index];
1229
#endif
1230

    
1231
    pos_min = s->data_offset;
1232
    pos_max = url_fsize(&s->pb) - 1;
1233

    
1234
    if     (pos < pos_min) pos= pos_min;
1235
    else if(pos > pos_max) pos= pos_max;
1236

    
1237
    url_fseek(&s->pb, pos, SEEK_SET);
1238

    
1239
#if 0
1240
    av_update_cur_dts(s, st, ts);
1241
#endif
1242
    return 0;
1243
}
1244

    
1245
static int av_seek_frame_generic(AVFormatContext *s,
1246
                                 int stream_index, int64_t timestamp, int flags)
1247
{
1248
    int index;
1249
    AVStream *st;
1250
    AVIndexEntry *ie;
1251

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

    
1254
    index = av_index_search_timestamp(st, timestamp, flags);
1255

    
1256
    if(index < 0 || index==st->nb_index_entries-1){
1257
        int i;
1258
        AVPacket pkt;
1259

    
1260
        if(st->index_entries && st->nb_index_entries){
1261
            ie= &st->index_entries[st->nb_index_entries-1];
1262
            url_fseek(&s->pb, ie->pos, SEEK_SET);
1263
            av_update_cur_dts(s, st, ie->timestamp);
1264
        }else
1265
            url_fseek(&s->pb, 0, SEEK_SET);
1266

    
1267
        for(i=0;; i++) {
1268
            int ret = av_read_frame(s, &pkt);
1269
            if(ret<0)
1270
                break;
1271
            av_free_packet(&pkt);
1272
            if(stream_index == pkt.stream_index){
1273
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1274
                    break;
1275
            }
1276
        }
1277
        index = av_index_search_timestamp(st, timestamp, flags);
1278
    }
1279
    if (index < 0)
1280
        return -1;
1281

    
1282
    av_read_frame_flush(s);
1283
    if (s->iformat->read_seek){
1284
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1285
            return 0;
1286
    }
1287
    ie = &st->index_entries[index];
1288
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1289

    
1290
    av_update_cur_dts(s, st, ie->timestamp);
1291

    
1292
    return 0;
1293
}
1294

    
1295
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1296
{
1297
    int ret;
1298
    AVStream *st;
1299

    
1300
    av_read_frame_flush(s);
1301

    
1302
    if(flags & AVSEEK_FLAG_BYTE)
1303
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1304

    
1305
    if(stream_index < 0){
1306
        stream_index= av_find_default_stream_index(s);
1307
        if(stream_index < 0)
1308
            return -1;
1309

    
1310
        st= s->streams[stream_index];
1311
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1312
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1313
    }
1314
    st= s->streams[stream_index];
1315

    
1316
    /* first, we try the format specific seek */
1317
    if (s->iformat->read_seek)
1318
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1319
    else
1320
        ret = -1;
1321
    if (ret >= 0) {
1322
        return 0;
1323
    }
1324

    
1325
    if(s->iformat->read_timestamp)
1326
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1327
    else
1328
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1329
}
1330

    
1331
/*******************************************************/
1332

    
1333
/**
1334
 * Returns TRUE if the stream has accurate timings in any stream.
1335
 *
1336
 * @return TRUE if the stream has accurate timings for at least one component.
1337
 */
1338
static int av_has_timings(AVFormatContext *ic)
1339
{
1340
    int i;
1341
    AVStream *st;
1342

    
1343
    for(i = 0;i < ic->nb_streams; i++) {
1344
        st = ic->streams[i];
1345
        if (st->start_time != AV_NOPTS_VALUE &&
1346
            st->duration != AV_NOPTS_VALUE)
1347
            return 1;
1348
    }
1349
    return 0;
1350
}
1351

    
1352
/**
1353
 * Estimate the stream timings from the one of each components.
1354
 *
1355
 * Also computes the global bitrate if possible.
1356
 */
1357
static void av_update_stream_timings(AVFormatContext *ic)
1358
{
1359
    int64_t start_time, start_time1, end_time, end_time1;
1360
    int i;
1361
    AVStream *st;
1362

    
1363
    start_time = INT64_MAX;
1364
    end_time = INT64_MIN;
1365
    for(i = 0;i < ic->nb_streams; i++) {
1366
        st = ic->streams[i];
1367
        if (st->start_time != AV_NOPTS_VALUE) {
1368
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1369
            if (start_time1 < start_time)
1370
                start_time = start_time1;
1371
            if (st->duration != AV_NOPTS_VALUE) {
1372
                end_time1 = start_time1
1373
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1374
                if (end_time1 > end_time)
1375
                    end_time = end_time1;
1376
            }
1377
        }
1378
    }
1379
    if (start_time != INT64_MAX) {
1380
        ic->start_time = start_time;
1381
        if (end_time != INT64_MIN) {
1382
            ic->duration = end_time - start_time;
1383
            if (ic->file_size > 0) {
1384
                /* compute the bit rate */
1385
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1386
                    (double)ic->duration;
1387
            }
1388
        }
1389
    }
1390

    
1391
}
1392

    
1393
static void fill_all_stream_timings(AVFormatContext *ic)
1394
{
1395
    int i;
1396
    AVStream *st;
1397

    
1398
    av_update_stream_timings(ic);
1399
    for(i = 0;i < ic->nb_streams; i++) {
1400
        st = ic->streams[i];
1401
        if (st->start_time == AV_NOPTS_VALUE) {
1402
            if(ic->start_time != AV_NOPTS_VALUE)
1403
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1404
            if(ic->duration != AV_NOPTS_VALUE)
1405
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1406
        }
1407
    }
1408
}
1409

    
1410
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1411
{
1412
    int64_t filesize, duration;
1413
    int bit_rate, i;
1414
    AVStream *st;
1415

    
1416
    /* if bit_rate is already set, we believe it */
1417
    if (ic->bit_rate == 0) {
1418
        bit_rate = 0;
1419
        for(i=0;i<ic->nb_streams;i++) {
1420
            st = ic->streams[i];
1421
            bit_rate += st->codec->bit_rate;
1422
        }
1423
        ic->bit_rate = bit_rate;
1424
    }
1425

    
1426
    /* if duration is already set, we believe it */
1427
    if (ic->duration == AV_NOPTS_VALUE &&
1428
        ic->bit_rate != 0 &&
1429
        ic->file_size != 0)  {
1430
        filesize = ic->file_size;
1431
        if (filesize > 0) {
1432
            for(i = 0; i < ic->nb_streams; i++) {
1433
                st = ic->streams[i];
1434
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1435
                if (st->start_time == AV_NOPTS_VALUE ||
1436
                    st->duration == AV_NOPTS_VALUE) {
1437
                    st->start_time = 0;
1438
                    st->duration = duration;
1439
                }
1440
            }
1441
        }
1442
    }
1443
}
1444

    
1445
#define DURATION_MAX_READ_SIZE 250000
1446

    
1447
/* only usable for MPEG-PS streams */
1448
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1449
{
1450
    AVPacket pkt1, *pkt = &pkt1;
1451
    AVStream *st;
1452
    int read_size, i, ret;
1453
    int64_t end_time;
1454
    int64_t filesize, offset, duration;
1455

    
1456
    /* free previous packet */
1457
    if (ic->cur_st && ic->cur_st->parser)
1458
        av_free_packet(&ic->cur_pkt);
1459
    ic->cur_st = NULL;
1460

    
1461
    /* flush packet queue */
1462
    flush_packet_queue(ic);
1463

    
1464
    for(i=0;i<ic->nb_streams;i++) {
1465
        st = ic->streams[i];
1466
        if (st->parser) {
1467
            av_parser_close(st->parser);
1468
            st->parser= NULL;
1469
        }
1470
    }
1471

    
1472
    /* we read the first packets to get the first PTS (not fully
1473
       accurate, but it is enough now) */
1474
    url_fseek(&ic->pb, 0, SEEK_SET);
1475
    read_size = 0;
1476
    for(;;) {
1477
        if (read_size >= DURATION_MAX_READ_SIZE)
1478
            break;
1479
        /* if all info is available, we can stop */
1480
        for(i = 0;i < ic->nb_streams; i++) {
1481
            st = ic->streams[i];
1482
            if (st->start_time == AV_NOPTS_VALUE)
1483
                break;
1484
        }
1485
        if (i == ic->nb_streams)
1486
            break;
1487

    
1488
        ret = av_read_packet(ic, pkt);
1489
        if (ret != 0)
1490
            break;
1491
        read_size += pkt->size;
1492
        st = ic->streams[pkt->stream_index];
1493
        if (pkt->pts != AV_NOPTS_VALUE) {
1494
            if (st->start_time == AV_NOPTS_VALUE)
1495
                st->start_time = pkt->pts;
1496
        }
1497
        av_free_packet(pkt);
1498
    }
1499

    
1500
    /* estimate the end time (duration) */
1501
    /* XXX: may need to support wrapping */
1502
    filesize = ic->file_size;
1503
    offset = filesize - DURATION_MAX_READ_SIZE;
1504
    if (offset < 0)
1505
        offset = 0;
1506

    
1507
    url_fseek(&ic->pb, offset, SEEK_SET);
1508
    read_size = 0;
1509
    for(;;) {
1510
        if (read_size >= DURATION_MAX_READ_SIZE)
1511
            break;
1512
        /* if all info is available, we can stop */
1513
        for(i = 0;i < ic->nb_streams; i++) {
1514
            st = ic->streams[i];
1515
            if (st->duration == AV_NOPTS_VALUE)
1516
                break;
1517
        }
1518
        if (i == ic->nb_streams)
1519
            break;
1520

    
1521
        ret = av_read_packet(ic, pkt);
1522
        if (ret != 0)
1523
            break;
1524
        read_size += pkt->size;
1525
        st = ic->streams[pkt->stream_index];
1526
        if (pkt->pts != AV_NOPTS_VALUE) {
1527
            end_time = pkt->pts;
1528
            duration = end_time - st->start_time;
1529
            if (duration > 0) {
1530
                if (st->duration == AV_NOPTS_VALUE ||
1531
                    st->duration < duration)
1532
                    st->duration = duration;
1533
            }
1534
        }
1535
        av_free_packet(pkt);
1536
    }
1537

    
1538
    fill_all_stream_timings(ic);
1539

    
1540
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1541
}
1542

    
1543
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1544
{
1545
    int64_t file_size;
1546

    
1547
    /* get the file size, if possible */
1548
    if (ic->iformat->flags & AVFMT_NOFILE) {
1549
        file_size = 0;
1550
    } else {
1551
        file_size = url_fsize(&ic->pb);
1552
        if (file_size < 0)
1553
            file_size = 0;
1554
    }
1555
    ic->file_size = file_size;
1556

    
1557
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1558
         !strcmp(ic->iformat->name, "mpegts")) &&
1559
        file_size && !ic->pb.is_streamed) {
1560
        /* get accurate estimate from the PTSes */
1561
        av_estimate_timings_from_pts(ic, old_offset);
1562
    } else if (av_has_timings(ic)) {
1563
        /* at least one components has timings - we use them for all
1564
           the components */
1565
        fill_all_stream_timings(ic);
1566
    } else {
1567
        /* less precise: use bit rate info */
1568
        av_estimate_timings_from_bit_rate(ic);
1569
    }
1570
    av_update_stream_timings(ic);
1571

    
1572
#if 0
1573
    {
1574
        int i;
1575
        AVStream *st;
1576
        for(i = 0;i < ic->nb_streams; i++) {
1577
            st = ic->streams[i];
1578
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1579
               i, (double)st->start_time / AV_TIME_BASE,
1580
               (double)st->duration / AV_TIME_BASE);
1581
        }
1582
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1583
               (double)ic->start_time / AV_TIME_BASE,
1584
               (double)ic->duration / AV_TIME_BASE,
1585
               ic->bit_rate / 1000);
1586
    }
1587
#endif
1588
}
1589

    
1590
static int has_codec_parameters(AVCodecContext *enc)
1591
{
1592
    int val;
1593
    switch(enc->codec_type) {
1594
    case CODEC_TYPE_AUDIO:
1595
        val = enc->sample_rate;
1596
        break;
1597
    case CODEC_TYPE_VIDEO:
1598
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1599
        break;
1600
    default:
1601
        val = 1;
1602
        break;
1603
    }
1604
    return (val != 0);
1605
}
1606

    
1607
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1608
{
1609
    int16_t *samples;
1610
    AVCodec *codec;
1611
    int got_picture, data_size, ret=0;
1612
    AVFrame picture;
1613

    
1614
  if(!st->codec->codec){
1615
    codec = avcodec_find_decoder(st->codec->codec_id);
1616
    if (!codec)
1617
        return -1;
1618
    ret = avcodec_open(st->codec, codec);
1619
    if (ret < 0)
1620
        return ret;
1621
  }
1622

    
1623
  if(!has_codec_parameters(st->codec)){
1624
    switch(st->codec->codec_type) {
1625
    case CODEC_TYPE_VIDEO:
1626
        ret = avcodec_decode_video(st->codec, &picture,
1627
                                   &got_picture, (uint8_t *)data, size);
1628
        break;
1629
    case CODEC_TYPE_AUDIO:
1630
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1631
        samples = av_malloc(data_size);
1632
        if (!samples)
1633
            goto fail;
1634
        ret = avcodec_decode_audio2(st->codec, samples,
1635
                                    &data_size, (uint8_t *)data, size);
1636
        av_free(samples);
1637
        break;
1638
    default:
1639
        break;
1640
    }
1641
  }
1642
 fail:
1643
    return ret;
1644
}
1645

    
1646
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1647
{
1648
    AVInputFormat *fmt;
1649
    fmt = av_probe_input_format2(pd, 1, &score);
1650

    
1651
    if (fmt) {
1652
        if (strncmp(fmt->name, "mp3", 3) == 0)
1653
            st->codec->codec_id = CODEC_ID_MP3;
1654
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1655
            st->codec->codec_id = CODEC_ID_AC3;
1656
    }
1657
    return !!fmt;
1658
}
1659

    
1660
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1661
{
1662
    while (tags->id != CODEC_ID_NONE) {
1663
        if (tags->id == id)
1664
            return tags->tag;
1665
        tags++;
1666
    }
1667
    return 0;
1668
}
1669

    
1670
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1671
{
1672
    while (tags->id != CODEC_ID_NONE) {
1673
        if(   toupper((tag >> 0)&0xFF) == toupper((tags->tag >> 0)&0xFF)
1674
           && toupper((tag >> 8)&0xFF) == toupper((tags->tag >> 8)&0xFF)
1675
           && toupper((tag >>16)&0xFF) == toupper((tags->tag >>16)&0xFF)
1676
           && toupper((tag >>24)&0xFF) == toupper((tags->tag >>24)&0xFF))
1677
            return tags->id;
1678
        tags++;
1679
    }
1680
    return CODEC_ID_NONE;
1681
}
1682

    
1683
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1684
{
1685
    int i;
1686
    for(i=0; tags && tags[i]; i++){
1687
        int tag= codec_get_tag(tags[i], id);
1688
        if(tag) return tag;
1689
    }
1690
    return 0;
1691
}
1692

    
1693
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1694
{
1695
    int i;
1696
    for(i=0; tags && tags[i]; i++){
1697
        enum CodecID id= codec_get_id(tags[i], tag);
1698
        if(id!=CODEC_ID_NONE) return id;
1699
    }
1700
    return CODEC_ID_NONE;
1701
}
1702

    
1703
/* absolute maximum size we read until we abort */
1704
#define MAX_READ_SIZE        5000000
1705

    
1706
#define MAX_STD_TIMEBASES (60*12+5)
1707
static int get_std_framerate(int i){
1708
    if(i<60*12) return i*1001;
1709
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1710
}
1711

    
1712
int av_find_stream_info(AVFormatContext *ic)
1713
{
1714
    int i, count, ret, read_size, j;
1715
    AVStream *st;
1716
    AVPacket pkt1, *pkt;
1717
    AVPacketList *pktl=NULL, **ppktl;
1718
    int64_t last_dts[MAX_STREAMS];
1719
    int duration_count[MAX_STREAMS]={0};
1720
    double (*duration_error)[MAX_STD_TIMEBASES];
1721
    offset_t old_offset = url_ftell(&ic->pb);
1722
    int64_t codec_info_duration[MAX_STREAMS]={0};
1723
    int codec_info_nb_frames[MAX_STREAMS]={0};
1724
    AVProbeData probe_data[MAX_STREAMS];
1725
    int codec_identified[MAX_STREAMS]={0};
1726

    
1727
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1728
    if (!duration_error) return AVERROR_NOMEM;
1729

    
1730
    for(i=0;i<ic->nb_streams;i++) {
1731
        st = ic->streams[i];
1732
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1733
/*            if(!st->time_base.num)
1734
                st->time_base= */
1735
            if(!st->codec->time_base.num)
1736
                st->codec->time_base= st->time_base;
1737
        }
1738
        //only for the split stuff
1739
        if (!st->parser) {
1740
            st->parser = av_parser_init(st->codec->codec_id);
1741
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1742
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1743
            }
1744
        }
1745
    }
1746

    
1747
    for(i=0;i<MAX_STREAMS;i++){
1748
        last_dts[i]= AV_NOPTS_VALUE;
1749
    }
1750

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

    
1787
        /* NOTE: a new stream can be added there if no header in file
1788
           (AVFMTCTX_NOHEADER) */
1789
        ret = av_read_frame_internal(ic, &pkt1);
1790
        if (ret < 0) {
1791
            /* EOF or error */
1792
            ret = -1; /* we could not have all the codec parameters before EOF */
1793
            for(i=0;i<ic->nb_streams;i++) {
1794
                st = ic->streams[i];
1795
                if (!has_codec_parameters(st->codec)){
1796
                    char buf[256];
1797
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1798
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1799
                } else {
1800
                    ret = 0;
1801
                }
1802
            }
1803
            break;
1804
        }
1805

    
1806
        pktl = av_mallocz(sizeof(AVPacketList));
1807
        if (!pktl) {
1808
            ret = AVERROR_NOMEM;
1809
            break;
1810
        }
1811

    
1812
        /* add the packet in the buffered packet list */
1813
        *ppktl = pktl;
1814
        ppktl = &pktl->next;
1815

    
1816
        pkt = &pktl->pkt;
1817
        *pkt = pkt1;
1818

    
1819
        /* duplicate the packet */
1820
        if (av_dup_packet(pkt) < 0) {
1821
            ret = AVERROR_NOMEM;
1822
            break;
1823
        }
1824

    
1825
        read_size += pkt->size;
1826

    
1827
        st = ic->streams[pkt->stream_index];
1828
        if(codec_info_nb_frames[st->index]>1)
1829
            codec_info_duration[st->index] += pkt->duration;
1830
        if (pkt->duration != 0)
1831
            codec_info_nb_frames[st->index]++;
1832

    
1833
        {
1834
            int index= pkt->stream_index;
1835
            int64_t last= last_dts[index];
1836
            int64_t duration= pkt->dts - last;
1837

    
1838
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1839
                double dur= duration * av_q2d(st->time_base);
1840

    
1841
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1842
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1843
                if(duration_count[index] < 2)
1844
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1845
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1846
                    int framerate= get_std_framerate(i);
1847
                    int ticks= lrintf(dur*framerate/(1001*12));
1848
                    double error= dur - ticks*1001*12/(double)framerate;
1849
                    duration_error[index][i] += error*error;
1850
                }
1851
                duration_count[index]++;
1852
            }
1853
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1854
                last_dts[pkt->stream_index]= pkt->dts;
1855

    
1856
            if (st->codec->codec_id == CODEC_ID_NONE) {
1857
                AVProbeData *pd = &(probe_data[st->index]);
1858
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1859
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1860
                pd->buf_size += pkt->size;
1861
            }
1862
        }
1863
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1864
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1865
            if(i){
1866
                st->codec->extradata_size= i;
1867
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1868
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1869
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1870
            }
1871
        }
1872

    
1873
        /* if still no information, we try to open the codec and to
1874
           decompress the frame. We try to avoid that in most cases as
1875
           it takes longer and uses more memory. For MPEG4, we need to
1876
           decompress for Quicktime. */
1877
        if (!has_codec_parameters(st->codec) /*&&
1878
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1879
             st->codec->codec_id == CODEC_ID_H264 ||
1880
             st->codec->codec_id == CODEC_ID_H263 ||
1881
             st->codec->codec_id == CODEC_ID_H261 ||
1882
             st->codec->codec_id == CODEC_ID_VORBIS ||
1883
             st->codec->codec_id == CODEC_ID_MJPEG ||
1884
             st->codec->codec_id == CODEC_ID_PNG ||
1885
             st->codec->codec_id == CODEC_ID_PAM ||
1886
             st->codec->codec_id == CODEC_ID_PGM ||
1887
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1888
             st->codec->codec_id == CODEC_ID_PBM ||
1889
             st->codec->codec_id == CODEC_ID_PPM ||
1890
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1891
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1892
            try_decode_frame(st, pkt->data, pkt->size);
1893

    
1894
        if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1895
            break;
1896
        }
1897
        count++;
1898
    }
1899

    
1900
    // close codecs which where opened in try_decode_frame()
1901
    for(i=0;i<ic->nb_streams;i++) {
1902
        st = ic->streams[i];
1903
        if(st->codec->codec)
1904
            avcodec_close(st->codec);
1905
    }
1906
    for(i=0;i<ic->nb_streams;i++) {
1907
        st = ic->streams[i];
1908
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1909
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1910
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1911

    
1912
            if(duration_count[i]
1913
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1914
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1915
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1916
                double best_error= 2*av_q2d(st->time_base);
1917
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1918

    
1919
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1920
                    double error= duration_error[i][j] * get_std_framerate(j);
1921
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1922
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1923
                    if(error < best_error){
1924
                        best_error= error;
1925
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1926
                    }
1927
                }
1928
            }
1929

    
1930
            if (!st->r_frame_rate.num){
1931
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1932
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1933
                    st->r_frame_rate.num = st->codec->time_base.den;
1934
                    st->r_frame_rate.den = st->codec->time_base.num;
1935
                }else{
1936
                    st->r_frame_rate.num = st->time_base.den;
1937
                    st->r_frame_rate.den = st->time_base.num;
1938
                }
1939
            }
1940
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1941
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1942
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1943
                if (codec_identified[st->index]) {
1944
                    st->need_parsing = AVSTREAM_PARSE_FULL;
1945
                }
1946
            }
1947
            if(!st->codec->bits_per_sample)
1948
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1949
        }
1950
    }
1951

    
1952
    av_estimate_timings(ic, old_offset);
1953

    
1954
    for(i=0;i<ic->nb_streams;i++) {
1955
        st = ic->streams[i];
1956
        if (codec_identified[st->index]) {
1957
            av_read_frame_flush(ic);
1958
            av_seek_frame(ic, st->index, 0.0, 0);
1959
            url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1960
        }
1961
    }
1962

    
1963
#if 0
1964
    /* correct DTS for b frame streams with no timestamps */
1965
    for(i=0;i<ic->nb_streams;i++) {
1966
        st = ic->streams[i];
1967
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1968
            if(b-frames){
1969
                ppktl = &ic->packet_buffer;
1970
                while(ppkt1){
1971
                    if(ppkt1->stream_index != i)
1972
                        continue;
1973
                    if(ppkt1->pkt->dts < 0)
1974
                        break;
1975
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1976
                        break;
1977
                    ppkt1->pkt->dts -= delta;
1978
                    ppkt1= ppkt1->next;
1979
                }
1980
                if(ppkt1)
1981
                    continue;
1982
                st->cur_dts -= delta;
1983
            }
1984
        }
1985
    }
1986
#endif
1987

    
1988
    av_free(duration_error);
1989
    for(i=0;i<MAX_STREAMS;i++){
1990
        av_freep(&(probe_data[i].buf));
1991
    }
1992

    
1993
    return ret;
1994
}
1995

    
1996
/*******************************************************/
1997

    
1998
int av_read_play(AVFormatContext *s)
1999
{
2000
    if (!s->iformat->read_play)
2001
        return AVERROR_NOTSUPP;
2002
    return s->iformat->read_play(s);
2003
}
2004

    
2005
int av_read_pause(AVFormatContext *s)
2006
{
2007
    if (!s->iformat->read_pause)
2008
        return AVERROR_NOTSUPP;
2009
    return s->iformat->read_pause(s);
2010
}
2011

    
2012
void av_close_input_file(AVFormatContext *s)
2013
{
2014
    int i, must_open_file;
2015
    AVStream *st;
2016

    
2017
    /* free previous packet */
2018
    if (s->cur_st && s->cur_st->parser)
2019
        av_free_packet(&s->cur_pkt);
2020

    
2021
    if (s->iformat->read_close)
2022
        s->iformat->read_close(s);
2023
    for(i=0;i<s->nb_streams;i++) {
2024
        /* free all data in a stream component */
2025
        st = s->streams[i];
2026
        if (st->parser) {
2027
            av_parser_close(st->parser);
2028
        }
2029
        av_free(st->index_entries);
2030
        av_free(st->codec->extradata);
2031
        av_free(st->codec);
2032
        av_free(st);
2033
    }
2034
    flush_packet_queue(s);
2035
    must_open_file = 1;
2036
    if (s->iformat->flags & AVFMT_NOFILE) {
2037
        must_open_file = 0;
2038
    }
2039
    if (must_open_file) {
2040
        url_fclose(&s->pb);
2041
    }
2042
    av_freep(&s->priv_data);
2043
    av_free(s);
2044
}
2045

    
2046
AVStream *av_new_stream(AVFormatContext *s, int id)
2047
{
2048
    AVStream *st;
2049
    int i;
2050

    
2051
    if (s->nb_streams >= MAX_STREAMS)
2052
        return NULL;
2053

    
2054
    st = av_mallocz(sizeof(AVStream));
2055
    if (!st)
2056
        return NULL;
2057

    
2058
    st->codec= avcodec_alloc_context();
2059
    if (s->iformat) {
2060
        /* no default bitrate if decoding */
2061
        st->codec->bit_rate = 0;
2062
    }
2063
    st->index = s->nb_streams;
2064
    st->id = id;
2065
    st->start_time = AV_NOPTS_VALUE;
2066
    st->duration = AV_NOPTS_VALUE;
2067
    st->cur_dts = AV_NOPTS_VALUE;
2068

    
2069
    /* default pts settings is MPEG like */
2070
    av_set_pts_info(st, 33, 1, 90000);
2071
    st->last_IP_pts = AV_NOPTS_VALUE;
2072
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2073
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2074

    
2075
    s->streams[s->nb_streams++] = st;
2076
    return st;
2077
}
2078

    
2079
/************************************************************/
2080
/* output media file */
2081

    
2082
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2083
{
2084
    int ret;
2085

    
2086
    if (s->oformat->priv_data_size > 0) {
2087
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2088
        if (!s->priv_data)
2089
            return AVERROR_NOMEM;
2090
    } else
2091
        s->priv_data = NULL;
2092

    
2093
    if (s->oformat->set_parameters) {
2094
        ret = s->oformat->set_parameters(s, ap);
2095
        if (ret < 0)
2096
            return ret;
2097
    }
2098
    return 0;
2099
}
2100

    
2101
int av_write_header(AVFormatContext *s)
2102
{
2103
    int ret, i;
2104
    AVStream *st;
2105

    
2106
    // some sanity checks
2107
    for(i=0;i<s->nb_streams;i++) {
2108
        st = s->streams[i];
2109

    
2110
        switch (st->codec->codec_type) {
2111
        case CODEC_TYPE_AUDIO:
2112
            if(st->codec->sample_rate<=0){
2113
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2114
                return -1;
2115
            }
2116
            break;
2117
        case CODEC_TYPE_VIDEO:
2118
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2119
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2120
                return -1;
2121
            }
2122
            if(st->codec->width<=0 || st->codec->height<=0){
2123
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2124
                return -1;
2125
            }
2126
            break;
2127
        }
2128

    
2129
        if(s->oformat->codec_tag){
2130
            if(st->codec->codec_tag){
2131
                //FIXME
2132
                //check that tag + id is in the table
2133
                //if neither is in the table -> ok
2134
                //if tag is in the table with another id -> FAIL
2135
                //if id is in the table with another tag -> FAIL unless strict < ?
2136
            }else
2137
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2138
        }
2139
    }
2140

    
2141
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2142
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2143
        if (!s->priv_data)
2144
            return AVERROR_NOMEM;
2145
    }
2146

    
2147
    if(s->oformat->write_header){
2148
        ret = s->oformat->write_header(s);
2149
        if (ret < 0)
2150
            return ret;
2151
    }
2152

    
2153
    /* init PTS generation */
2154
    for(i=0;i<s->nb_streams;i++) {
2155
        int64_t den = AV_NOPTS_VALUE;
2156
        st = s->streams[i];
2157

    
2158
        switch (st->codec->codec_type) {
2159
        case CODEC_TYPE_AUDIO:
2160
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2161
            break;
2162
        case CODEC_TYPE_VIDEO:
2163
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2164
            break;
2165
        default:
2166
            break;
2167
        }
2168
        if (den != AV_NOPTS_VALUE) {
2169
            if (den <= 0)
2170
                return AVERROR_INVALIDDATA;
2171
            av_frac_init(&st->pts, 0, 0, den);
2172
        }
2173
    }
2174
    return 0;
2175
}
2176

    
2177
//FIXME merge with compute_pkt_fields
2178
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2179
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2180
    int num, den, frame_size, i;
2181

    
2182
//    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);
2183

    
2184
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2185
        return -1;*/
2186

    
2187
    /* duration field */
2188
    if (pkt->duration == 0) {
2189
        compute_frame_duration(&num, &den, st, NULL, pkt);
2190
        if (den && num) {
2191
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2192
        }
2193
    }
2194

    
2195
    //XXX/FIXME this is a temporary hack until all encoders output pts
2196
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2197
        pkt->dts=
2198
//        pkt->pts= st->cur_dts;
2199
        pkt->pts= st->pts.val;
2200
    }
2201

    
2202
    //calculate dts from pts
2203
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2204
        st->pts_buffer[0]= pkt->pts;
2205
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2206
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2207
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2208
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2209

    
2210
        pkt->dts= st->pts_buffer[0];
2211
    }
2212

    
2213
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2214
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2215
        return -1;
2216
    }
2217
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2218
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2219
        return -1;
2220
    }
2221

    
2222
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2223
    st->cur_dts= pkt->dts;
2224
    st->pts.val= pkt->dts;
2225

    
2226
    /* update pts */
2227
    switch (st->codec->codec_type) {
2228
    case CODEC_TYPE_AUDIO:
2229
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2230

    
2231
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2232
           but it would be better if we had the real timestamps from the encoder */
2233
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2234
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2235
        }
2236
        break;
2237
    case CODEC_TYPE_VIDEO:
2238
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2239
        break;
2240
    default:
2241
        break;
2242
    }
2243
    return 0;
2244
}
2245

    
2246
static void truncate_ts(AVStream *st, AVPacket *pkt){
2247
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2248

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

    
2252
    if (pkt->pts != AV_NOPTS_VALUE)
2253
        pkt->pts &= pts_mask;
2254
    if (pkt->dts != AV_NOPTS_VALUE)
2255
        pkt->dts &= pts_mask;
2256
}
2257

    
2258
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2259
{
2260
    int ret;
2261

    
2262
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2263
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2264
        return ret;
2265

    
2266
    truncate_ts(s->streams[pkt->stream_index], pkt);
2267

    
2268
    ret= s->oformat->write_packet(s, pkt);
2269
    if(!ret)
2270
        ret= url_ferror(&s->pb);
2271
    return ret;
2272
}
2273

    
2274
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2275
    AVPacketList *pktl, **next_point, *this_pktl;
2276
    int stream_count=0;
2277
    int streams[MAX_STREAMS];
2278

    
2279
    if(pkt){
2280
        AVStream *st= s->streams[ pkt->stream_index];
2281

    
2282
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2283

    
2284
        this_pktl = av_mallocz(sizeof(AVPacketList));
2285
        this_pktl->pkt= *pkt;
2286
        if(pkt->destruct == av_destruct_packet)
2287
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2288
        else
2289
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2290

    
2291
        next_point = &s->packet_buffer;
2292
        while(*next_point){
2293
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2294
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2295
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2296
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2297
                break;
2298
            next_point= &(*next_point)->next;
2299
        }
2300
        this_pktl->next= *next_point;
2301
        *next_point= this_pktl;
2302
    }
2303

    
2304
    memset(streams, 0, sizeof(streams));
2305
    pktl= s->packet_buffer;
2306
    while(pktl){
2307
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2308
        if(streams[ pktl->pkt.stream_index ] == 0)
2309
            stream_count++;
2310
        streams[ pktl->pkt.stream_index ]++;
2311
        pktl= pktl->next;
2312
    }
2313

    
2314
    if(s->nb_streams == stream_count || (flush && stream_count)){
2315
        pktl= s->packet_buffer;
2316
        *out= pktl->pkt;
2317

    
2318
        s->packet_buffer= pktl->next;
2319
        av_freep(&pktl);
2320
        return 1;
2321
    }else{
2322
        av_init_packet(out);
2323
        return 0;
2324
    }
2325
}
2326

    
2327
/**
2328
 * Interleaves a AVPacket correctly so it can be muxed.
2329
 * @param out the interleaved packet will be output here
2330
 * @param in the input packet
2331
 * @param flush 1 if no further packets are available as input and all
2332
 *              remaining packets should be output
2333
 * @return 1 if a packet was output, 0 if no packet could be output,
2334
 *         < 0 if an error occured
2335
 */
2336
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2337
    if(s->oformat->interleave_packet)
2338
        return s->oformat->interleave_packet(s, out, in, flush);
2339
    else
2340
        return av_interleave_packet_per_dts(s, out, in, flush);
2341
}
2342

    
2343
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2344
    AVStream *st= s->streams[ pkt->stream_index];
2345

    
2346
    //FIXME/XXX/HACK drop zero sized packets
2347
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2348
        return 0;
2349

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

    
2354
    if(pkt->dts == AV_NOPTS_VALUE)
2355
        return -1;
2356

    
2357
    for(;;){
2358
        AVPacket opkt;
2359
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2360
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2361
            return ret;
2362

    
2363
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2364
        ret= s->oformat->write_packet(s, &opkt);
2365

    
2366
        av_free_packet(&opkt);
2367
        pkt= NULL;
2368

    
2369
        if(ret<0)
2370
            return ret;
2371
        if(url_ferror(&s->pb))
2372
            return url_ferror(&s->pb);
2373
    }
2374
}
2375

    
2376
int av_write_trailer(AVFormatContext *s)
2377
{
2378
    int ret, i;
2379

    
2380
    for(;;){
2381
        AVPacket pkt;
2382
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2383
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2384
            goto fail;
2385
        if(!ret)
2386
            break;
2387

    
2388
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2389
        ret= s->oformat->write_packet(s, &pkt);
2390

    
2391
        av_free_packet(&pkt);
2392

    
2393
        if(ret<0)
2394
            goto fail;
2395
        if(url_ferror(&s->pb))
2396
            goto fail;
2397
    }
2398

    
2399
    if(s->oformat->write_trailer)
2400
        ret = s->oformat->write_trailer(s);
2401
fail:
2402
    if(ret == 0)
2403
       ret=url_ferror(&s->pb);
2404
    for(i=0;i<s->nb_streams;i++)
2405
        av_freep(&s->streams[i]->priv_data);
2406
    av_freep(&s->priv_data);
2407
    return ret;
2408
}
2409

    
2410
/* "user interface" functions */
2411

    
2412
void dump_format(AVFormatContext *ic,
2413
                 int index,
2414
                 const char *url,
2415
                 int is_output)
2416
{
2417
    int i, flags;
2418
    char buf[256];
2419

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

    
2487
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2488
{
2489
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2490
}
2491

    
2492
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2493
{
2494
    AVRational frame_rate;
2495
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2496
    *frame_rate_num= frame_rate.num;
2497
    *frame_rate_den= frame_rate.den;
2498
    return ret;
2499
}
2500

    
2501
int64_t parse_date(const char *datestr, int duration)
2502
{
2503
    const char *p;
2504
    int64_t t;
2505
    struct tm dt;
2506
    int i;
2507
    static const char *date_fmt[] = {
2508
        "%Y-%m-%d",
2509
        "%Y%m%d",
2510
    };
2511
    static const char *time_fmt[] = {
2512
        "%H:%M:%S",
2513
        "%H%M%S",
2514
    };
2515
    const char *q;
2516
    int is_utc, len;
2517
    char lastch;
2518
    int negative = 0;
2519

    
2520
#undef time
2521
    time_t now = time(0);
2522

    
2523
    len = strlen(datestr);
2524
    if (len > 0)
2525
        lastch = datestr[len - 1];
2526
    else
2527
        lastch = '\0';
2528
    is_utc = (lastch == 'z' || lastch == 'Z');
2529

    
2530
    memset(&dt, 0, sizeof(dt));
2531

    
2532
    p = datestr;
2533
    q = NULL;
2534
    if (!duration) {
2535
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2536
            q = small_strptime(p, date_fmt[i], &dt);
2537
            if (q) {
2538
                break;
2539
            }
2540
        }
2541

    
2542
        if (!q) {
2543
            if (is_utc) {
2544
                dt = *gmtime(&now);
2545
            } else {
2546
                dt = *localtime(&now);
2547
            }
2548
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2549
        } else {
2550
            p = q;
2551
        }
2552

    
2553
        if (*p == 'T' || *p == 't' || *p == ' ')
2554
            p++;
2555

    
2556
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2557
            q = small_strptime(p, time_fmt[i], &dt);
2558
            if (q) {
2559
                break;
2560
            }
2561
        }
2562
    } else {
2563
        if (p[0] == '-') {
2564
            negative = 1;
2565
            ++p;
2566
        }
2567
        q = small_strptime(p, time_fmt[0], &dt);
2568
        if (!q) {
2569
            dt.tm_sec = strtol(p, (char **)&q, 10);
2570
            dt.tm_min = 0;
2571
            dt.tm_hour = 0;
2572
        }
2573
    }
2574

    
2575
    /* Now we have all the fields that we can get */
2576
    if (!q) {
2577
        if (duration)
2578
            return 0;
2579
        else
2580
            return now * INT64_C(1000000);
2581
    }
2582

    
2583
    if (duration) {
2584
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2585
    } else {
2586
        dt.tm_isdst = -1;       /* unknown */
2587
        if (is_utc) {
2588
            t = mktimegm(&dt);
2589
        } else {
2590
            t = mktime(&dt);
2591
        }
2592
    }
2593

    
2594
    t *= 1000000;
2595

    
2596
    if (*q == '.') {
2597
        int val, n;
2598
        q++;
2599
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2600
            if (!isdigit(*q))
2601
                break;
2602
            val += n * (*q - '0');
2603
        }
2604
        t += val;
2605
    }
2606
    return negative ? -t : t;
2607
}
2608

    
2609
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2610
{
2611
    const char *p;
2612
    char tag[128], *q;
2613

    
2614
    p = info;
2615
    if (*p == '?')
2616
        p++;
2617
    for(;;) {
2618
        q = tag;
2619
        while (*p != '\0' && *p != '=' && *p != '&') {
2620
            if ((q - tag) < sizeof(tag) - 1)
2621
                *q++ = *p;
2622
            p++;
2623
        }
2624
        *q = '\0';
2625
        q = arg;
2626
        if (*p == '=') {
2627
            p++;
2628
            while (*p != '&' && *p != '\0') {
2629
                if ((q - arg) < arg_size - 1) {
2630
                    if (*p == '+')
2631
                        *q++ = ' ';
2632
                    else
2633
                        *q++ = *p;
2634
                }
2635
                p++;
2636
            }
2637
            *q = '\0';
2638
        }
2639
        if (!strcmp(tag, tag1))
2640
            return 1;
2641
        if (*p != '&')
2642
            break;
2643
        p++;
2644
    }
2645
    return 0;
2646
}
2647

    
2648
int av_get_frame_filename(char *buf, int buf_size,
2649
                          const char *path, int number)
2650
{
2651
    const char *p;
2652
    char *q, buf1[20], c;
2653
    int nd, len, percentd_found;
2654

    
2655
    q = buf;
2656
    p = path;
2657
    percentd_found = 0;
2658
    for(;;) {
2659
        c = *p++;
2660
        if (c == '\0')
2661
            break;
2662
        if (c == '%') {
2663
            do {
2664
                nd = 0;
2665
                while (isdigit(*p)) {
2666
                    nd = nd * 10 + *p++ - '0';
2667
                }
2668
                c = *p++;
2669
            } while (isdigit(c));
2670

    
2671
            switch(c) {
2672
            case '%':
2673
                goto addchar;
2674
            case 'd':
2675
                if (percentd_found)
2676
                    goto fail;
2677
                percentd_found = 1;
2678
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2679
                len = strlen(buf1);
2680
                if ((q - buf + len) > buf_size - 1)
2681
                    goto fail;
2682
                memcpy(q, buf1, len);
2683
                q += len;
2684
                break;
2685
            default:
2686
                goto fail;
2687
            }
2688
        } else {
2689
        addchar:
2690
            if ((q - buf) < buf_size - 1)
2691
                *q++ = c;
2692
        }
2693
    }
2694
    if (!percentd_found)
2695
        goto fail;
2696
    *q = '\0';
2697
    return 0;
2698
 fail:
2699
    *q = '\0';
2700
    return -1;
2701
}
2702

    
2703
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2704
{
2705
    int len, i, j, c;
2706
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2707

    
2708
    for(i=0;i<size;i+=16) {
2709
        len = size - i;
2710
        if (len > 16)
2711
            len = 16;
2712
        PRINT("%08x ", i);
2713
        for(j=0;j<16;j++) {
2714
            if (j < len)
2715
                PRINT(" %02x", buf[i+j]);
2716
            else
2717
                PRINT("   ");
2718
        }
2719
        PRINT(" ");
2720
        for(j=0;j<len;j++) {
2721
            c = buf[i+j];
2722
            if (c < ' ' || c > '~')
2723
                c = '.';
2724
            PRINT("%c", c);
2725
        }
2726
        PRINT("\n");
2727
    }
2728
#undef PRINT
2729
}
2730

    
2731
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2732
{
2733
    hex_dump_internal(NULL, f, 0, buf, size);
2734
}
2735

    
2736
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2737
{
2738
    hex_dump_internal(avcl, NULL, level, buf, size);
2739
}
2740

    
2741
 //FIXME needs to know the time_base
2742
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2743
{
2744
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2745
    PRINT("stream #%d:\n", pkt->stream_index);
2746
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2747
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2748
    /* DTS is _always_ valid after av_read_frame() */
2749
    PRINT("  dts=");
2750
    if (pkt->dts == AV_NOPTS_VALUE)
2751
        PRINT("N/A");
2752
    else
2753
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2754
    /* PTS may be not known if B frames are present */
2755
    PRINT("  pts=");
2756
    if (pkt->pts == AV_NOPTS_VALUE)
2757
        PRINT("N/A");
2758
    else
2759
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2760
    PRINT("\n");
2761
    PRINT("  size=%d\n", pkt->size);
2762
#undef PRINT
2763
    if (dump_payload)
2764
        av_hex_dump(f, pkt->data, pkt->size);
2765
}
2766

    
2767
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2768
{
2769
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2770
}
2771

    
2772
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2773
{
2774
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2775
}
2776

    
2777
void url_split(char *proto, int proto_size,
2778
               char *authorization, int authorization_size,
2779
               char *hostname, int hostname_size,
2780
               int *port_ptr,
2781
               char *path, int path_size,
2782
               const char *url)
2783
{
2784
    const char *p;
2785
    char *q;
2786
    int port;
2787

    
2788
    port = -1;
2789

    
2790
    p = url;
2791
    q = proto;
2792
    while (*p != ':' && *p != '\0') {
2793
        if ((q - proto) < proto_size - 1)
2794
            *q++ = *p;
2795
        p++;
2796
    }
2797
    if (proto_size > 0)
2798
        *q = '\0';
2799
    if (authorization_size > 0)
2800
        authorization[0] = '\0';
2801
    if (*p == '\0') {
2802
        if (proto_size > 0)
2803
            proto[0] = '\0';
2804
        if (hostname_size > 0)
2805
            hostname[0] = '\0';
2806
        p = url;
2807
    } else {
2808
        char *at,*slash; // PETR: position of '@' character and '/' character
2809

    
2810
        p++;
2811
        if (*p == '/')
2812
            p++;
2813
        if (*p == '/')
2814
            p++;
2815
        at = strchr(p,'@'); // PETR: get the position of '@'
2816
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2817
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2818

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

    
2821
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2822
            if (*p == '@') {    // PETR: passed '@'
2823
              if (authorization_size > 0)
2824
                  *q = '\0';
2825
              q = hostname;
2826
              at = NULL;
2827
            } else if (!at) {   // PETR: hostname
2828
              if ((q - hostname) < hostname_size - 1)
2829
                  *q++ = *p;
2830
            } else {
2831
              if ((q - authorization) < authorization_size - 1)
2832
                *q++ = *p;
2833
            }
2834
            p++;
2835
        }
2836
        if (hostname_size > 0)
2837
            *q = '\0';
2838
        if (*p == ':') {
2839
            p++;
2840
            port = strtoul(p, (char **)&p, 10);
2841
        }
2842
    }
2843
    if (port_ptr)
2844
        *port_ptr = port;
2845
    av_strlcpy(path, p, path_size);
2846
}
2847

    
2848
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2849
                     int pts_num, int pts_den)
2850
{
2851
    s->pts_wrap_bits = pts_wrap_bits;
2852
    s->time_base.num = pts_num;
2853
    s->time_base.den = pts_den;
2854
}
2855

    
2856
/* fraction handling */
2857

    
2858
/**
2859
 * f = val + (num / den) + 0.5.
2860
 *
2861
 * 'num' is normalized so that it is such as 0 <= num < den.
2862
 *
2863
 * @param f fractional number
2864
 * @param val integer value
2865
 * @param num must be >= 0
2866
 * @param den must be >= 1
2867
 */
2868
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2869
{
2870
    num += (den >> 1);
2871
    if (num >= den) {
2872
        val += num / den;
2873
        num = num % den;
2874
    }
2875
    f->val = val;
2876
    f->num = num;
2877
    f->den = den;
2878
}
2879

    
2880
/**
2881
 * Fractionnal addition to f: f = f + (incr / f->den).
2882
 *
2883
 * @param f fractional number
2884
 * @param incr increment, can be positive or negative
2885
 */
2886
static void av_frac_add(AVFrac *f, int64_t incr)
2887
{
2888
    int64_t num, den;
2889

    
2890
    num = f->num + incr;
2891
    den = f->den;
2892
    if (num < 0) {
2893
        f->val += num / den;
2894
        num = num % den;
2895
        if (num < 0) {
2896
            num += den;
2897
            f->val--;
2898
        }
2899
    } else if (num >= den) {
2900
        f->val += num / den;
2901
        num = num % den;
2902
    }
2903
    f->num = num;
2904
}