Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 41415d28

History | View | Annotate | Download (87.3 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
#include <sys/time.h>
27
#include <time.h>
28

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

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

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

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

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

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

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

    
68
    if(!filename)
69
        return 0;
70

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

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

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

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

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

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

    
139
        if (stream_fmt)
140
            fmt = stream_fmt;
141
    }
142

    
143
    return fmt;
144
}
145

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

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

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

    
175
/* memory handling */
176

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

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

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

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

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

    
215
    if(ret<0)
216
        return ret;
217

    
218
    pkt->pos= url_ftell(s);
219

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

    
226
    return ret;
227
}
228

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

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

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

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

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

    
285
/************************************************************/
286
/* input media file */
287

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

    
299
#define OFFSET(x) offsetof(AVFormatContext,x)
300
#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
301
//these names are too long to be readable
302
#define E AV_OPT_FLAG_ENCODING_PARAM
303
#define D AV_OPT_FLAG_DECODING_PARAM
304

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

    
318
#undef E
319
#undef D
320
#undef DEFAULT
321

    
322
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
323

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

    
328
    s->av_class = &av_format_context_class;
329

    
330
    av_opt_set_defaults(s);
331
}
332

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

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

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

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

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

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

    
386
    if (pb && !ic->data_offset)
387
        ic->data_offset = url_ftell(&ic->pb);
388

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

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

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

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

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

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

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

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

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

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

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

    
495
}
496

    
497
/*******************************************************/
498

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

    
505
/**********************************************************/
506

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

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

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

    
533

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

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

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

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

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

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

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

    
628
    if(is_intra_only(st->codec))
629
        pkt->flags |= PKT_FLAG_KEY;
630

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

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

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

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

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

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

    
699
//    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);
700

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

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

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

    
720
    av_init_packet(pkt);
721

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

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

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

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

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

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

    
821
    return 0;
822
}
823

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

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

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

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

    
869
            /* duplicate the packet */
870
            if (av_dup_packet(pkt) < 0)
871
                return AVERROR(ENOMEM);
872

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

    
875
            pktl = av_mallocz(sizeof(AVPacketList));
876
            if (!pktl)
877
                return AVERROR(ENOMEM);
878

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

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

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

    
904
/*******************************************************/
905
/* seek support */
906

    
907
int av_find_default_stream_index(AVFormatContext *s)
908
{
909
    int i;
910
    AVStream *st;
911

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

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

    
931
    flush_packet_queue(s);
932

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

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

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

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

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

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

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

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

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

    
984
    st->index_entries= entries;
985

    
986
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
987

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

    
1003
    ie->pos = pos;
1004
    ie->timestamp = timestamp;
1005
    ie->min_distance= distance;
1006
    ie->size= size;
1007
    ie->flags = flags;
1008

    
1009
    return index;
1010
}
1011

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

    
1020
    a = - 1;
1021
    b = nb_entries;
1022

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

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

    
1039
    if(m == nb_entries)
1040
        return -1;
1041
    return  m;
1042
}
1043

    
1044
#define DEBUG_SEEK
1045

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

    
1053
    if (stream_index < 0)
1054
        return -1;
1055

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

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

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

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

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

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

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

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

    
1105
    av_update_cur_dts(s, st, ts);
1106

    
1107
    return 0;
1108
}
1109

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

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

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

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

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

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

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

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

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

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

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

1227
    if (stream_index < 0)
1228
        return -1;
1229

1230
    st= s->streams[stream_index];
1231
#endif
1232

    
1233
    pos_min = s->data_offset;
1234
    pos_max = url_fsize(&s->pb) - 1;
1235

    
1236
    if     (pos < pos_min) pos= pos_min;
1237
    else if(pos > pos_max) pos= pos_max;
1238

    
1239
    url_fseek(&s->pb, pos, SEEK_SET);
1240

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

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

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

    
1256
    index = av_index_search_timestamp(st, timestamp, flags);
1257

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

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

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

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

    
1292
    av_update_cur_dts(s, st, ie->timestamp);
1293

    
1294
    return 0;
1295
}
1296

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

    
1302
    av_read_frame_flush(s);
1303

    
1304
    if(flags & AVSEEK_FLAG_BYTE)
1305
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1306

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

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

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

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

    
1333
/*******************************************************/
1334

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

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

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

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

    
1393
}
1394

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

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

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

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

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

    
1447
#define DURATION_MAX_READ_SIZE 250000
1448

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

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

    
1463
    /* flush packet queue */
1464
    flush_packet_queue(ic);
1465

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

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

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

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

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

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

    
1540
    fill_all_stream_timings(ic);
1541

    
1542
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1543
}
1544

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

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

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

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

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

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

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

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

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

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

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

    
1672
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1673
{
1674
    int i;
1675
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1676
        if(tag == tags[i].tag)
1677
            return tags[i].id;
1678
    }
1679
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1680
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1681
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1682
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1683
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1684
            return tags[i].id;
1685
    }
1686
    return CODEC_ID_NONE;
1687
}
1688

    
1689
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1690
{
1691
    int i;
1692
    for(i=0; tags && tags[i]; i++){
1693
        int tag= codec_get_tag(tags[i], id);
1694
        if(tag) return tag;
1695
    }
1696
    return 0;
1697
}
1698

    
1699
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1700
{
1701
    int i;
1702
    for(i=0; tags && tags[i]; i++){
1703
        enum CodecID id= codec_get_id(tags[i], tag);
1704
        if(id!=CODEC_ID_NONE) return id;
1705
    }
1706
    return CODEC_ID_NONE;
1707
}
1708

    
1709
/* absolute maximum size we read until we abort */
1710
#define MAX_READ_SIZE        5000000
1711

    
1712
#define MAX_STD_TIMEBASES (60*12+5)
1713
static int get_std_framerate(int i){
1714
    if(i<60*12) return i*1001;
1715
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1716
}
1717

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

    
1733
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1734
    if (!duration_error) return AVERROR(ENOMEM);
1735

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

    
1753
    for(i=0;i<MAX_STREAMS;i++){
1754
        last_dts[i]= AV_NOPTS_VALUE;
1755
    }
1756

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

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

    
1812
        pktl = av_mallocz(sizeof(AVPacketList));
1813
        if (!pktl) {
1814
            ret = AVERROR(ENOMEM);
1815
            break;
1816
        }
1817

    
1818
        /* add the packet in the buffered packet list */
1819
        *ppktl = pktl;
1820
        ppktl = &pktl->next;
1821

    
1822
        pkt = &pktl->pkt;
1823
        *pkt = pkt1;
1824

    
1825
        /* duplicate the packet */
1826
        if (av_dup_packet(pkt) < 0) {
1827
            ret = AVERROR(ENOMEM);
1828
            break;
1829
        }
1830

    
1831
        read_size += pkt->size;
1832

    
1833
        st = ic->streams[pkt->stream_index];
1834
        if(codec_info_nb_frames[st->index]>1)
1835
            codec_info_duration[st->index] += pkt->duration;
1836
        if (pkt->duration != 0)
1837
            codec_info_nb_frames[st->index]++;
1838

    
1839
        {
1840
            int index= pkt->stream_index;
1841
            int64_t last= last_dts[index];
1842
            int64_t duration= pkt->dts - last;
1843

    
1844
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1845
                double dur= duration * av_q2d(st->time_base);
1846

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

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

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

    
1900
        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) {
1901
            break;
1902
        }
1903
        count++;
1904
    }
1905

    
1906
    // close codecs which where opened in try_decode_frame()
1907
    for(i=0;i<ic->nb_streams;i++) {
1908
        st = ic->streams[i];
1909
        if(st->codec->codec)
1910
            avcodec_close(st->codec);
1911
    }
1912
    for(i=0;i<ic->nb_streams;i++) {
1913
        st = ic->streams[i];
1914
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1915
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1916
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1917

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

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

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

    
1958
    av_estimate_timings(ic, old_offset);
1959

    
1960
    for(i=0;i<ic->nb_streams;i++) {
1961
        st = ic->streams[i];
1962
        if (codec_identified[st->index]) {
1963
            av_read_frame_flush(ic);
1964
            av_seek_frame(ic, st->index, 0.0, 0);
1965
            url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1966
        }
1967
    }
1968

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

    
1994
    av_free(duration_error);
1995
    for(i=0;i<MAX_STREAMS;i++){
1996
        av_freep(&(probe_data[i].buf));
1997
    }
1998

    
1999
    return ret;
2000
}
2001

    
2002
/*******************************************************/
2003

    
2004
int av_read_play(AVFormatContext *s)
2005
{
2006
    if (!s->iformat->read_play)
2007
        return AVERROR(ENOSYS);
2008
    return s->iformat->read_play(s);
2009
}
2010

    
2011
int av_read_pause(AVFormatContext *s)
2012
{
2013
    if (!s->iformat->read_pause)
2014
        return AVERROR(ENOSYS);
2015
    return s->iformat->read_pause(s);
2016
}
2017

    
2018
void av_close_input_file(AVFormatContext *s)
2019
{
2020
    int i, must_open_file;
2021
    AVStream *st;
2022

    
2023
    /* free previous packet */
2024
    if (s->cur_st && s->cur_st->parser)
2025
        av_free_packet(&s->cur_pkt);
2026

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

    
2052
AVStream *av_new_stream(AVFormatContext *s, int id)
2053
{
2054
    AVStream *st;
2055
    int i;
2056

    
2057
    if (s->nb_streams >= MAX_STREAMS)
2058
        return NULL;
2059

    
2060
    st = av_mallocz(sizeof(AVStream));
2061
    if (!st)
2062
        return NULL;
2063

    
2064
    st->codec= avcodec_alloc_context();
2065
    if (s->iformat) {
2066
        /* no default bitrate if decoding */
2067
        st->codec->bit_rate = 0;
2068
    }
2069
    st->index = s->nb_streams;
2070
    st->id = id;
2071
    st->start_time = AV_NOPTS_VALUE;
2072
    st->duration = AV_NOPTS_VALUE;
2073
    st->cur_dts = AV_NOPTS_VALUE;
2074

    
2075
    /* default pts settings is MPEG like */
2076
    av_set_pts_info(st, 33, 1, 90000);
2077
    st->last_IP_pts = AV_NOPTS_VALUE;
2078
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2079
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2080

    
2081
    s->streams[s->nb_streams++] = st;
2082
    return st;
2083
}
2084

    
2085
/************************************************************/
2086
/* output media file */
2087

    
2088
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2089
{
2090
    int ret;
2091

    
2092
    if (s->oformat->priv_data_size > 0) {
2093
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2094
        if (!s->priv_data)
2095
            return AVERROR(ENOMEM);
2096
    } else
2097
        s->priv_data = NULL;
2098

    
2099
    if (s->oformat->set_parameters) {
2100
        ret = s->oformat->set_parameters(s, ap);
2101
        if (ret < 0)
2102
            return ret;
2103
    }
2104
    return 0;
2105
}
2106

    
2107
int av_write_header(AVFormatContext *s)
2108
{
2109
    int ret, i;
2110
    AVStream *st;
2111

    
2112
    // some sanity checks
2113
    for(i=0;i<s->nb_streams;i++) {
2114
        st = s->streams[i];
2115

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

    
2135
        if(s->oformat->codec_tag){
2136
            if(st->codec->codec_tag){
2137
                //FIXME
2138
                //check that tag + id is in the table
2139
                //if neither is in the table -> ok
2140
                //if tag is in the table with another id -> FAIL
2141
                //if id is in the table with another tag -> FAIL unless strict < ?
2142
            }else
2143
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2144
        }
2145
    }
2146

    
2147
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2148
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2149
        if (!s->priv_data)
2150
            return AVERROR(ENOMEM);
2151
    }
2152

    
2153
    if(s->oformat->write_header){
2154
        ret = s->oformat->write_header(s);
2155
        if (ret < 0)
2156
            return ret;
2157
    }
2158

    
2159
    /* init PTS generation */
2160
    for(i=0;i<s->nb_streams;i++) {
2161
        int64_t den = AV_NOPTS_VALUE;
2162
        st = s->streams[i];
2163

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

    
2183
//FIXME merge with compute_pkt_fields
2184
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2185
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2186
    int num, den, frame_size, i;
2187

    
2188
//    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);
2189

    
2190
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2191
        return -1;*/
2192

    
2193
    /* duration field */
2194
    if (pkt->duration == 0) {
2195
        compute_frame_duration(&num, &den, st, NULL, pkt);
2196
        if (den && num) {
2197
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2198
        }
2199
    }
2200

    
2201
    //XXX/FIXME this is a temporary hack until all encoders output pts
2202
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2203
        pkt->dts=
2204
//        pkt->pts= st->cur_dts;
2205
        pkt->pts= st->pts.val;
2206
    }
2207

    
2208
    //calculate dts from pts
2209
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2210
        st->pts_buffer[0]= pkt->pts;
2211
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2212
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2213
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2214
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2215

    
2216
        pkt->dts= st->pts_buffer[0];
2217
    }
2218

    
2219
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2220
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2221
        return -1;
2222
    }
2223
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2224
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2225
        return -1;
2226
    }
2227

    
2228
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2229
    st->cur_dts= pkt->dts;
2230
    st->pts.val= pkt->dts;
2231

    
2232
    /* update pts */
2233
    switch (st->codec->codec_type) {
2234
    case CODEC_TYPE_AUDIO:
2235
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2236

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

    
2252
static void truncate_ts(AVStream *st, AVPacket *pkt){
2253
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2254

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

    
2258
    if (pkt->pts != AV_NOPTS_VALUE)
2259
        pkt->pts &= pts_mask;
2260
    if (pkt->dts != AV_NOPTS_VALUE)
2261
        pkt->dts &= pts_mask;
2262
}
2263

    
2264
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2265
{
2266
    int ret;
2267

    
2268
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2269
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2270
        return ret;
2271

    
2272
    truncate_ts(s->streams[pkt->stream_index], pkt);
2273

    
2274
    ret= s->oformat->write_packet(s, pkt);
2275
    if(!ret)
2276
        ret= url_ferror(&s->pb);
2277
    return ret;
2278
}
2279

    
2280
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2281
    AVPacketList *pktl, **next_point, *this_pktl;
2282
    int stream_count=0;
2283
    int streams[MAX_STREAMS];
2284

    
2285
    if(pkt){
2286
        AVStream *st= s->streams[ pkt->stream_index];
2287

    
2288
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2289

    
2290
        this_pktl = av_mallocz(sizeof(AVPacketList));
2291
        this_pktl->pkt= *pkt;
2292
        if(pkt->destruct == av_destruct_packet)
2293
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2294
        else
2295
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2296

    
2297
        next_point = &s->packet_buffer;
2298
        while(*next_point){
2299
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2300
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2301
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2302
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2303
                break;
2304
            next_point= &(*next_point)->next;
2305
        }
2306
        this_pktl->next= *next_point;
2307
        *next_point= this_pktl;
2308
    }
2309

    
2310
    memset(streams, 0, sizeof(streams));
2311
    pktl= s->packet_buffer;
2312
    while(pktl){
2313
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2314
        if(streams[ pktl->pkt.stream_index ] == 0)
2315
            stream_count++;
2316
        streams[ pktl->pkt.stream_index ]++;
2317
        pktl= pktl->next;
2318
    }
2319

    
2320
    if(s->nb_streams == stream_count || (flush && stream_count)){
2321
        pktl= s->packet_buffer;
2322
        *out= pktl->pkt;
2323

    
2324
        s->packet_buffer= pktl->next;
2325
        av_freep(&pktl);
2326
        return 1;
2327
    }else{
2328
        av_init_packet(out);
2329
        return 0;
2330
    }
2331
}
2332

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

    
2349
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2350
    AVStream *st= s->streams[ pkt->stream_index];
2351

    
2352
    //FIXME/XXX/HACK drop zero sized packets
2353
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2354
        return 0;
2355

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

    
2360
    if(pkt->dts == AV_NOPTS_VALUE)
2361
        return -1;
2362

    
2363
    for(;;){
2364
        AVPacket opkt;
2365
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2366
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2367
            return ret;
2368

    
2369
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2370
        ret= s->oformat->write_packet(s, &opkt);
2371

    
2372
        av_free_packet(&opkt);
2373
        pkt= NULL;
2374

    
2375
        if(ret<0)
2376
            return ret;
2377
        if(url_ferror(&s->pb))
2378
            return url_ferror(&s->pb);
2379
    }
2380
}
2381

    
2382
int av_write_trailer(AVFormatContext *s)
2383
{
2384
    int ret, i;
2385

    
2386
    for(;;){
2387
        AVPacket pkt;
2388
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2389
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2390
            goto fail;
2391
        if(!ret)
2392
            break;
2393

    
2394
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2395
        ret= s->oformat->write_packet(s, &pkt);
2396

    
2397
        av_free_packet(&pkt);
2398

    
2399
        if(ret<0)
2400
            goto fail;
2401
        if(url_ferror(&s->pb))
2402
            goto fail;
2403
    }
2404

    
2405
    if(s->oformat->write_trailer)
2406
        ret = s->oformat->write_trailer(s);
2407
fail:
2408
    if(ret == 0)
2409
       ret=url_ferror(&s->pb);
2410
    for(i=0;i<s->nb_streams;i++)
2411
        av_freep(&s->streams[i]->priv_data);
2412
    av_freep(&s->priv_data);
2413
    return ret;
2414
}
2415

    
2416
/* "user interface" functions */
2417

    
2418
void dump_format(AVFormatContext *ic,
2419
                 int index,
2420
                 const char *url,
2421
                 int is_output)
2422
{
2423
    int i, flags;
2424
    char buf[256];
2425

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

    
2493
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2494
{
2495
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2496
}
2497

    
2498
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2499
{
2500
    AVRational frame_rate;
2501
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2502
    *frame_rate_num= frame_rate.num;
2503
    *frame_rate_den= frame_rate.den;
2504
    return ret;
2505
}
2506

    
2507
/**
2508
 * gets the current time in micro seconds.
2509
 */
2510
int64_t av_gettime(void)
2511
{
2512
    struct timeval tv;
2513
    gettimeofday(&tv,NULL);
2514
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2515
}
2516

    
2517
int64_t parse_date(const char *datestr, int duration)
2518
{
2519
    const char *p;
2520
    int64_t t;
2521
    struct tm dt;
2522
    int i;
2523
    static const char *date_fmt[] = {
2524
        "%Y-%m-%d",
2525
        "%Y%m%d",
2526
    };
2527
    static const char *time_fmt[] = {
2528
        "%H:%M:%S",
2529
        "%H%M%S",
2530
    };
2531
    const char *q;
2532
    int is_utc, len;
2533
    char lastch;
2534
    int negative = 0;
2535

    
2536
#undef time
2537
    time_t now = time(0);
2538

    
2539
    len = strlen(datestr);
2540
    if (len > 0)
2541
        lastch = datestr[len - 1];
2542
    else
2543
        lastch = '\0';
2544
    is_utc = (lastch == 'z' || lastch == 'Z');
2545

    
2546
    memset(&dt, 0, sizeof(dt));
2547

    
2548
    p = datestr;
2549
    q = NULL;
2550
    if (!duration) {
2551
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2552
            q = small_strptime(p, date_fmt[i], &dt);
2553
            if (q) {
2554
                break;
2555
            }
2556
        }
2557

    
2558
        if (!q) {
2559
            if (is_utc) {
2560
                dt = *gmtime(&now);
2561
            } else {
2562
                dt = *localtime(&now);
2563
            }
2564
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2565
        } else {
2566
            p = q;
2567
        }
2568

    
2569
        if (*p == 'T' || *p == 't' || *p == ' ')
2570
            p++;
2571

    
2572
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2573
            q = small_strptime(p, time_fmt[i], &dt);
2574
            if (q) {
2575
                break;
2576
            }
2577
        }
2578
    } else {
2579
        if (p[0] == '-') {
2580
            negative = 1;
2581
            ++p;
2582
        }
2583
        q = small_strptime(p, time_fmt[0], &dt);
2584
        if (!q) {
2585
            dt.tm_sec = strtol(p, (char **)&q, 10);
2586
            dt.tm_min = 0;
2587
            dt.tm_hour = 0;
2588
        }
2589
    }
2590

    
2591
    /* Now we have all the fields that we can get */
2592
    if (!q) {
2593
        if (duration)
2594
            return 0;
2595
        else
2596
            return now * INT64_C(1000000);
2597
    }
2598

    
2599
    if (duration) {
2600
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2601
    } else {
2602
        dt.tm_isdst = -1;       /* unknown */
2603
        if (is_utc) {
2604
            t = mktimegm(&dt);
2605
        } else {
2606
            t = mktime(&dt);
2607
        }
2608
    }
2609

    
2610
    t *= 1000000;
2611

    
2612
    if (*q == '.') {
2613
        int val, n;
2614
        q++;
2615
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2616
            if (!isdigit(*q))
2617
                break;
2618
            val += n * (*q - '0');
2619
        }
2620
        t += val;
2621
    }
2622
    return negative ? -t : t;
2623
}
2624

    
2625
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2626
{
2627
    const char *p;
2628
    char tag[128], *q;
2629

    
2630
    p = info;
2631
    if (*p == '?')
2632
        p++;
2633
    for(;;) {
2634
        q = tag;
2635
        while (*p != '\0' && *p != '=' && *p != '&') {
2636
            if ((q - tag) < sizeof(tag) - 1)
2637
                *q++ = *p;
2638
            p++;
2639
        }
2640
        *q = '\0';
2641
        q = arg;
2642
        if (*p == '=') {
2643
            p++;
2644
            while (*p != '&' && *p != '\0') {
2645
                if ((q - arg) < arg_size - 1) {
2646
                    if (*p == '+')
2647
                        *q++ = ' ';
2648
                    else
2649
                        *q++ = *p;
2650
                }
2651
                p++;
2652
            }
2653
            *q = '\0';
2654
        }
2655
        if (!strcmp(tag, tag1))
2656
            return 1;
2657
        if (*p != '&')
2658
            break;
2659
        p++;
2660
    }
2661
    return 0;
2662
}
2663

    
2664
int av_get_frame_filename(char *buf, int buf_size,
2665
                          const char *path, int number)
2666
{
2667
    const char *p;
2668
    char *q, buf1[20], c;
2669
    int nd, len, percentd_found;
2670

    
2671
    q = buf;
2672
    p = path;
2673
    percentd_found = 0;
2674
    for(;;) {
2675
        c = *p++;
2676
        if (c == '\0')
2677
            break;
2678
        if (c == '%') {
2679
            do {
2680
                nd = 0;
2681
                while (isdigit(*p)) {
2682
                    nd = nd * 10 + *p++ - '0';
2683
                }
2684
                c = *p++;
2685
            } while (isdigit(c));
2686

    
2687
            switch(c) {
2688
            case '%':
2689
                goto addchar;
2690
            case 'd':
2691
                if (percentd_found)
2692
                    goto fail;
2693
                percentd_found = 1;
2694
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2695
                len = strlen(buf1);
2696
                if ((q - buf + len) > buf_size - 1)
2697
                    goto fail;
2698
                memcpy(q, buf1, len);
2699
                q += len;
2700
                break;
2701
            default:
2702
                goto fail;
2703
            }
2704
        } else {
2705
        addchar:
2706
            if ((q - buf) < buf_size - 1)
2707
                *q++ = c;
2708
        }
2709
    }
2710
    if (!percentd_found)
2711
        goto fail;
2712
    *q = '\0';
2713
    return 0;
2714
 fail:
2715
    *q = '\0';
2716
    return -1;
2717
}
2718

    
2719
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2720
{
2721
    int len, i, j, c;
2722
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2723

    
2724
    for(i=0;i<size;i+=16) {
2725
        len = size - i;
2726
        if (len > 16)
2727
            len = 16;
2728
        PRINT("%08x ", i);
2729
        for(j=0;j<16;j++) {
2730
            if (j < len)
2731
                PRINT(" %02x", buf[i+j]);
2732
            else
2733
                PRINT("   ");
2734
        }
2735
        PRINT(" ");
2736
        for(j=0;j<len;j++) {
2737
            c = buf[i+j];
2738
            if (c < ' ' || c > '~')
2739
                c = '.';
2740
            PRINT("%c", c);
2741
        }
2742
        PRINT("\n");
2743
    }
2744
#undef PRINT
2745
}
2746

    
2747
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2748
{
2749
    hex_dump_internal(NULL, f, 0, buf, size);
2750
}
2751

    
2752
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2753
{
2754
    hex_dump_internal(avcl, NULL, level, buf, size);
2755
}
2756

    
2757
 //FIXME needs to know the time_base
2758
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2759
{
2760
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2761
    PRINT("stream #%d:\n", pkt->stream_index);
2762
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2763
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2764
    /* DTS is _always_ valid after av_read_frame() */
2765
    PRINT("  dts=");
2766
    if (pkt->dts == AV_NOPTS_VALUE)
2767
        PRINT("N/A");
2768
    else
2769
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2770
    /* PTS may be not known if B frames are present */
2771
    PRINT("  pts=");
2772
    if (pkt->pts == AV_NOPTS_VALUE)
2773
        PRINT("N/A");
2774
    else
2775
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2776
    PRINT("\n");
2777
    PRINT("  size=%d\n", pkt->size);
2778
#undef PRINT
2779
    if (dump_payload)
2780
        av_hex_dump(f, pkt->data, pkt->size);
2781
}
2782

    
2783
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2784
{
2785
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2786
}
2787

    
2788
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2789
{
2790
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2791
}
2792

    
2793
void url_split(char *proto, int proto_size,
2794
               char *authorization, int authorization_size,
2795
               char *hostname, int hostname_size,
2796
               int *port_ptr,
2797
               char *path, int path_size,
2798
               const char *url)
2799
{
2800
    const char *p;
2801
    char *q;
2802
    int port;
2803

    
2804
    port = -1;
2805

    
2806
    p = url;
2807
    q = proto;
2808
    while (*p != ':' && *p != '\0') {
2809
        if ((q - proto) < proto_size - 1)
2810
            *q++ = *p;
2811
        p++;
2812
    }
2813
    if (proto_size > 0)
2814
        *q = '\0';
2815
    if (authorization_size > 0)
2816
        authorization[0] = '\0';
2817
    if (*p == '\0') {
2818
        if (proto_size > 0)
2819
            proto[0] = '\0';
2820
        if (hostname_size > 0)
2821
            hostname[0] = '\0';
2822
        p = url;
2823
    } else {
2824
        char *at,*slash; // PETR: position of '@' character and '/' character
2825

    
2826
        p++;
2827
        if (*p == '/')
2828
            p++;
2829
        if (*p == '/')
2830
            p++;
2831
        at = strchr(p,'@'); // PETR: get the position of '@'
2832
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2833
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2834

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

    
2837
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2838
            if (*p == '@') {    // PETR: passed '@'
2839
              if (authorization_size > 0)
2840
                  *q = '\0';
2841
              q = hostname;
2842
              at = NULL;
2843
            } else if (!at) {   // PETR: hostname
2844
              if ((q - hostname) < hostname_size - 1)
2845
                  *q++ = *p;
2846
            } else {
2847
              if ((q - authorization) < authorization_size - 1)
2848
                *q++ = *p;
2849
            }
2850
            p++;
2851
        }
2852
        if (hostname_size > 0)
2853
            *q = '\0';
2854
        if (*p == ':') {
2855
            p++;
2856
            port = strtoul(p, (char **)&p, 10);
2857
        }
2858
    }
2859
    if (port_ptr)
2860
        *port_ptr = port;
2861
    av_strlcpy(path, p, path_size);
2862
}
2863

    
2864
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2865
                     int pts_num, int pts_den)
2866
{
2867
    s->pts_wrap_bits = pts_wrap_bits;
2868
    s->time_base.num = pts_num;
2869
    s->time_base.den = pts_den;
2870
}
2871

    
2872
/* fraction handling */
2873

    
2874
/**
2875
 * f = val + (num / den) + 0.5.
2876
 *
2877
 * 'num' is normalized so that it is such as 0 <= num < den.
2878
 *
2879
 * @param f fractional number
2880
 * @param val integer value
2881
 * @param num must be >= 0
2882
 * @param den must be >= 1
2883
 */
2884
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2885
{
2886
    num += (den >> 1);
2887
    if (num >= den) {
2888
        val += num / den;
2889
        num = num % den;
2890
    }
2891
    f->val = val;
2892
    f->num = num;
2893
    f->den = den;
2894
}
2895

    
2896
/**
2897
 * Fractionnal addition to f: f = f + (incr / f->den).
2898
 *
2899
 * @param f fractional number
2900
 * @param incr increment, can be positive or negative
2901
 */
2902
static void av_frac_add(AVFrac *f, int64_t incr)
2903
{
2904
    int64_t num, den;
2905

    
2906
    num = f->num + incr;
2907
    den = f->den;
2908
    if (num < 0) {
2909
        f->val += num / den;
2910
        num = num % den;
2911
        if (num < 0) {
2912
            num += den;
2913
            f->val--;
2914
        }
2915
    } else if (num >= den) {
2916
        f->val += num / den;
2917
        num = num % den;
2918
    }
2919
    f->num = num;
2920
}