Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 14d194d5

History | View | Annotate | Download (85.7 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

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

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

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

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

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

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

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

    
65
    if(!filename)
66
        return 0;
67

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

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

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

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

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

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

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

    
140
    return fmt;
141
}
142

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

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

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

    
172
/* memory handling */
173

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

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

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

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

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

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

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

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

    
223
    return ret;
224
}
225

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

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

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

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

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

    
282
/************************************************************/
283
/* input media file */
284

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

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

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

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

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

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

    
325
    s->av_class = &av_format_context_class;
326

    
327
    av_opt_set_defaults(s);
328
}
329

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
492
}
493

    
494
/*******************************************************/
495

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

    
502
/**********************************************************/
503

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

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

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

    
530

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
717
    av_init_packet(pkt);
718

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

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

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

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

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

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

    
818
    return 0;
819
}
820

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

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

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

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

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

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

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

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

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

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

    
901
/*******************************************************/
902
/* seek support */
903

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

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

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

    
928
    flush_packet_queue(s);
929

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

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

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

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

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

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

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

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

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

    
981
    st->index_entries= entries;
982

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

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

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

    
1006
    return index;
1007
}
1008

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

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

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

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

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

    
1041
#define DEBUG_SEEK
1042

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

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

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

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

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

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

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

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

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

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

    
1102
    av_update_cur_dts(s, st, ts);
1103

    
1104
    return 0;
1105
}
1106

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1291
    return 0;
1292
}
1293

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

    
1299
    av_read_frame_flush(s);
1300

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

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

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

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

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

    
1330
/*******************************************************/
1331

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

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

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

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

    
1390
}
1391

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

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

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

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

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

    
1444
#define DURATION_MAX_READ_SIZE 250000
1445

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

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

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

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

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

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

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

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

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

    
1537
    fill_all_stream_timings(ic);
1538

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

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

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

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

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

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

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

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

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

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

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

    
1659
/* absolute maximum size we read until we abort */
1660
#define MAX_READ_SIZE        5000000
1661

    
1662
#define MAX_STD_TIMEBASES (60*12+5)
1663
static int get_std_framerate(int i){
1664
    if(i<60*12) return i*1001;
1665
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1666
}
1667

    
1668
int av_find_stream_info(AVFormatContext *ic)
1669
{
1670
    int i, count, ret, read_size, j;
1671
    AVStream *st;
1672
    AVPacket pkt1, *pkt;
1673
    AVPacketList *pktl=NULL, **ppktl;
1674
    int64_t last_dts[MAX_STREAMS];
1675
    int duration_count[MAX_STREAMS]={0};
1676
    double (*duration_error)[MAX_STD_TIMEBASES];
1677
    offset_t old_offset = url_ftell(&ic->pb);
1678
    int64_t codec_info_duration[MAX_STREAMS]={0};
1679
    int codec_info_nb_frames[MAX_STREAMS]={0};
1680
    AVProbeData probe_data[MAX_STREAMS];
1681
    int codec_identified[MAX_STREAMS]={0};
1682

    
1683
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1684
    if (!duration_error) return AVERROR_NOMEM;
1685

    
1686
    for(i=0;i<ic->nb_streams;i++) {
1687
        st = ic->streams[i];
1688
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1689
/*            if(!st->time_base.num)
1690
                st->time_base= */
1691
            if(!st->codec->time_base.num)
1692
                st->codec->time_base= st->time_base;
1693
        }
1694
        //only for the split stuff
1695
        if (!st->parser) {
1696
            st->parser = av_parser_init(st->codec->codec_id);
1697
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1698
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1699
            }
1700
        }
1701
    }
1702

    
1703
    for(i=0;i<MAX_STREAMS;i++){
1704
        last_dts[i]= AV_NOPTS_VALUE;
1705
    }
1706

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

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

    
1762
        pktl = av_mallocz(sizeof(AVPacketList));
1763
        if (!pktl) {
1764
            ret = AVERROR_NOMEM;
1765
            break;
1766
        }
1767

    
1768
        /* add the packet in the buffered packet list */
1769
        *ppktl = pktl;
1770
        ppktl = &pktl->next;
1771

    
1772
        pkt = &pktl->pkt;
1773
        *pkt = pkt1;
1774

    
1775
        /* duplicate the packet */
1776
        if (av_dup_packet(pkt) < 0) {
1777
            ret = AVERROR_NOMEM;
1778
            break;
1779
        }
1780

    
1781
        read_size += pkt->size;
1782

    
1783
        st = ic->streams[pkt->stream_index];
1784
        if(codec_info_nb_frames[st->index]>1)
1785
            codec_info_duration[st->index] += pkt->duration;
1786
        if (pkt->duration != 0)
1787
            codec_info_nb_frames[st->index]++;
1788

    
1789
        {
1790
            int index= pkt->stream_index;
1791
            int64_t last= last_dts[index];
1792
            int64_t duration= pkt->dts - last;
1793

    
1794
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1795
                double dur= duration * av_q2d(st->time_base);
1796

    
1797
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1798
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1799
                if(duration_count[index] < 2)
1800
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1801
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1802
                    int framerate= get_std_framerate(i);
1803
                    int ticks= lrintf(dur*framerate/(1001*12));
1804
                    double error= dur - ticks*1001*12/(double)framerate;
1805
                    duration_error[index][i] += error*error;
1806
                }
1807
                duration_count[index]++;
1808
            }
1809
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1810
                last_dts[pkt->stream_index]= pkt->dts;
1811

    
1812
            if (st->codec->codec_id == CODEC_ID_NONE) {
1813
                AVProbeData *pd = &(probe_data[st->index]);
1814
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1815
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1816
                pd->buf_size += pkt->size;
1817
            }
1818
        }
1819
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1820
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1821
            if(i){
1822
                st->codec->extradata_size= i;
1823
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1824
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1825
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1826
            }
1827
        }
1828

    
1829
        /* if still no information, we try to open the codec and to
1830
           decompress the frame. We try to avoid that in most cases as
1831
           it takes longer and uses more memory. For MPEG4, we need to
1832
           decompress for Quicktime. */
1833
        if (!has_codec_parameters(st->codec) /*&&
1834
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1835
             st->codec->codec_id == CODEC_ID_H264 ||
1836
             st->codec->codec_id == CODEC_ID_H263 ||
1837
             st->codec->codec_id == CODEC_ID_H261 ||
1838
             st->codec->codec_id == CODEC_ID_VORBIS ||
1839
             st->codec->codec_id == CODEC_ID_MJPEG ||
1840
             st->codec->codec_id == CODEC_ID_PNG ||
1841
             st->codec->codec_id == CODEC_ID_PAM ||
1842
             st->codec->codec_id == CODEC_ID_PGM ||
1843
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1844
             st->codec->codec_id == CODEC_ID_PBM ||
1845
             st->codec->codec_id == CODEC_ID_PPM ||
1846
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1847
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1848
            try_decode_frame(st, pkt->data, pkt->size);
1849

    
1850
        if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1851
            break;
1852
        }
1853
        count++;
1854
    }
1855

    
1856
    // close codecs which where opened in try_decode_frame()
1857
    for(i=0;i<ic->nb_streams;i++) {
1858
        st = ic->streams[i];
1859
        if(st->codec->codec)
1860
            avcodec_close(st->codec);
1861
    }
1862
    for(i=0;i<ic->nb_streams;i++) {
1863
        st = ic->streams[i];
1864
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1865
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1866
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1867

    
1868
            if(duration_count[i]
1869
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1870
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1871
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1872
                double best_error= 2*av_q2d(st->time_base);
1873
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1874

    
1875
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1876
                    double error= duration_error[i][j] * get_std_framerate(j);
1877
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1878
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1879
                    if(error < best_error){
1880
                        best_error= error;
1881
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1882
                    }
1883
                }
1884
            }
1885

    
1886
            if (!st->r_frame_rate.num){
1887
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1888
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1889
                    st->r_frame_rate.num = st->codec->time_base.den;
1890
                    st->r_frame_rate.den = st->codec->time_base.num;
1891
                }else{
1892
                    st->r_frame_rate.num = st->time_base.den;
1893
                    st->r_frame_rate.den = st->time_base.num;
1894
                }
1895
            }
1896
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1897
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1898
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1899
                if (codec_identified[st->index]) {
1900
                    st->need_parsing = AVSTREAM_PARSE_FULL;
1901
                }
1902
            }
1903
            if(!st->codec->bits_per_sample)
1904
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1905
        }
1906
    }
1907

    
1908
    av_estimate_timings(ic, old_offset);
1909

    
1910
    for(i=0;i<ic->nb_streams;i++) {
1911
        st = ic->streams[i];
1912
        if (codec_identified[st->index]) {
1913
            av_read_frame_flush(ic);
1914
            av_seek_frame(ic, st->index, 0.0, 0);
1915
            url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1916
        }
1917
    }
1918

    
1919
#if 0
1920
    /* correct DTS for b frame streams with no timestamps */
1921
    for(i=0;i<ic->nb_streams;i++) {
1922
        st = ic->streams[i];
1923
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1924
            if(b-frames){
1925
                ppktl = &ic->packet_buffer;
1926
                while(ppkt1){
1927
                    if(ppkt1->stream_index != i)
1928
                        continue;
1929
                    if(ppkt1->pkt->dts < 0)
1930
                        break;
1931
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1932
                        break;
1933
                    ppkt1->pkt->dts -= delta;
1934
                    ppkt1= ppkt1->next;
1935
                }
1936
                if(ppkt1)
1937
                    continue;
1938
                st->cur_dts -= delta;
1939
            }
1940
        }
1941
    }
1942
#endif
1943

    
1944
    av_free(duration_error);
1945
    for(i=0;i<MAX_STREAMS;i++){
1946
        av_freep(&(probe_data[i].buf));
1947
    }
1948

    
1949
    return ret;
1950
}
1951

    
1952
/*******************************************************/
1953

    
1954
int av_read_play(AVFormatContext *s)
1955
{
1956
    if (!s->iformat->read_play)
1957
        return AVERROR_NOTSUPP;
1958
    return s->iformat->read_play(s);
1959
}
1960

    
1961
int av_read_pause(AVFormatContext *s)
1962
{
1963
    if (!s->iformat->read_pause)
1964
        return AVERROR_NOTSUPP;
1965
    return s->iformat->read_pause(s);
1966
}
1967

    
1968
void av_close_input_file(AVFormatContext *s)
1969
{
1970
    int i, must_open_file;
1971
    AVStream *st;
1972

    
1973
    /* free previous packet */
1974
    if (s->cur_st && s->cur_st->parser)
1975
        av_free_packet(&s->cur_pkt);
1976

    
1977
    if (s->iformat->read_close)
1978
        s->iformat->read_close(s);
1979
    for(i=0;i<s->nb_streams;i++) {
1980
        /* free all data in a stream component */
1981
        st = s->streams[i];
1982
        if (st->parser) {
1983
            av_parser_close(st->parser);
1984
        }
1985
        av_free(st->index_entries);
1986
        av_free(st->codec->extradata);
1987
        av_free(st->codec);
1988
        av_free(st);
1989
    }
1990
    flush_packet_queue(s);
1991
    must_open_file = 1;
1992
    if (s->iformat->flags & AVFMT_NOFILE) {
1993
        must_open_file = 0;
1994
    }
1995
    if (must_open_file) {
1996
        url_fclose(&s->pb);
1997
    }
1998
    av_freep(&s->priv_data);
1999
    av_free(s);
2000
}
2001

    
2002
AVStream *av_new_stream(AVFormatContext *s, int id)
2003
{
2004
    AVStream *st;
2005
    int i;
2006

    
2007
    if (s->nb_streams >= MAX_STREAMS)
2008
        return NULL;
2009

    
2010
    st = av_mallocz(sizeof(AVStream));
2011
    if (!st)
2012
        return NULL;
2013

    
2014
    st->codec= avcodec_alloc_context();
2015
    if (s->iformat) {
2016
        /* no default bitrate if decoding */
2017
        st->codec->bit_rate = 0;
2018
    }
2019
    st->index = s->nb_streams;
2020
    st->id = id;
2021
    st->start_time = AV_NOPTS_VALUE;
2022
    st->duration = AV_NOPTS_VALUE;
2023
    st->cur_dts = AV_NOPTS_VALUE;
2024

    
2025
    /* default pts settings is MPEG like */
2026
    av_set_pts_info(st, 33, 1, 90000);
2027
    st->last_IP_pts = AV_NOPTS_VALUE;
2028
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2029
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2030

    
2031
    s->streams[s->nb_streams++] = st;
2032
    return st;
2033
}
2034

    
2035
/************************************************************/
2036
/* output media file */
2037

    
2038
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2039
{
2040
    int ret;
2041

    
2042
    if (s->oformat->priv_data_size > 0) {
2043
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2044
        if (!s->priv_data)
2045
            return AVERROR_NOMEM;
2046
    } else
2047
        s->priv_data = NULL;
2048

    
2049
    if (s->oformat->set_parameters) {
2050
        ret = s->oformat->set_parameters(s, ap);
2051
        if (ret < 0)
2052
            return ret;
2053
    }
2054
    return 0;
2055
}
2056

    
2057
int av_write_header(AVFormatContext *s)
2058
{
2059
    int ret, i;
2060
    AVStream *st;
2061

    
2062
    // some sanity checks
2063
    for(i=0;i<s->nb_streams;i++) {
2064
        st = s->streams[i];
2065

    
2066
        switch (st->codec->codec_type) {
2067
        case CODEC_TYPE_AUDIO:
2068
            if(st->codec->sample_rate<=0){
2069
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2070
                return -1;
2071
            }
2072
            break;
2073
        case CODEC_TYPE_VIDEO:
2074
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2075
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2076
                return -1;
2077
            }
2078
            if(st->codec->width<=0 || st->codec->height<=0){
2079
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2080
                return -1;
2081
            }
2082
            break;
2083
        }
2084

    
2085
        if(s->oformat->codec_tag){
2086
            if(st->codec->codec_tag){
2087
                //FIXME
2088
                //check that tag + id is in the table
2089
                //if neither is in the table -> ok
2090
                //if tag is in the table with another id -> FAIL
2091
                //if id is in the table with another tag -> FAIL unless strict < ?
2092
            }else
2093
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2094
        }
2095
    }
2096

    
2097
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2098
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2099
        if (!s->priv_data)
2100
            return AVERROR_NOMEM;
2101
    }
2102

    
2103
    if(s->oformat->write_header){
2104
        ret = s->oformat->write_header(s);
2105
        if (ret < 0)
2106
            return ret;
2107
    }
2108

    
2109
    /* init PTS generation */
2110
    for(i=0;i<s->nb_streams;i++) {
2111
        int64_t den = AV_NOPTS_VALUE;
2112
        st = s->streams[i];
2113

    
2114
        switch (st->codec->codec_type) {
2115
        case CODEC_TYPE_AUDIO:
2116
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2117
            break;
2118
        case CODEC_TYPE_VIDEO:
2119
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2120
            break;
2121
        default:
2122
            break;
2123
        }
2124
        if (den != AV_NOPTS_VALUE) {
2125
            if (den <= 0)
2126
                return AVERROR_INVALIDDATA;
2127
            av_frac_init(&st->pts, 0, 0, den);
2128
        }
2129
    }
2130
    return 0;
2131
}
2132

    
2133
//FIXME merge with compute_pkt_fields
2134
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2135
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2136
    int num, den, frame_size, i;
2137

    
2138
//    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);
2139

    
2140
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2141
        return -1;*/
2142

    
2143
    /* duration field */
2144
    if (pkt->duration == 0) {
2145
        compute_frame_duration(&num, &den, st, NULL, pkt);
2146
        if (den && num) {
2147
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2148
        }
2149
    }
2150

    
2151
    //XXX/FIXME this is a temporary hack until all encoders output pts
2152
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2153
        pkt->dts=
2154
//        pkt->pts= st->cur_dts;
2155
        pkt->pts= st->pts.val;
2156
    }
2157

    
2158
    //calculate dts from pts
2159
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2160
        st->pts_buffer[0]= pkt->pts;
2161
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2162
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2163
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2164
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2165

    
2166
        pkt->dts= st->pts_buffer[0];
2167
    }
2168

    
2169
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2170
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2171
        return -1;
2172
    }
2173
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2174
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2175
        return -1;
2176
    }
2177

    
2178
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2179
    st->cur_dts= pkt->dts;
2180
    st->pts.val= pkt->dts;
2181

    
2182
    /* update pts */
2183
    switch (st->codec->codec_type) {
2184
    case CODEC_TYPE_AUDIO:
2185
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2186

    
2187
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2188
           but it would be better if we had the real timestamps from the encoder */
2189
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2190
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2191
        }
2192
        break;
2193
    case CODEC_TYPE_VIDEO:
2194
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2195
        break;
2196
    default:
2197
        break;
2198
    }
2199
    return 0;
2200
}
2201

    
2202
static void truncate_ts(AVStream *st, AVPacket *pkt){
2203
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2204

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

    
2208
    if (pkt->pts != AV_NOPTS_VALUE)
2209
        pkt->pts &= pts_mask;
2210
    if (pkt->dts != AV_NOPTS_VALUE)
2211
        pkt->dts &= pts_mask;
2212
}
2213

    
2214
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2215
{
2216
    int ret;
2217

    
2218
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2219
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2220
        return ret;
2221

    
2222
    truncate_ts(s->streams[pkt->stream_index], pkt);
2223

    
2224
    ret= s->oformat->write_packet(s, pkt);
2225
    if(!ret)
2226
        ret= url_ferror(&s->pb);
2227
    return ret;
2228
}
2229

    
2230
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2231
    AVPacketList *pktl, **next_point, *this_pktl;
2232
    int stream_count=0;
2233
    int streams[MAX_STREAMS];
2234

    
2235
    if(pkt){
2236
        AVStream *st= s->streams[ pkt->stream_index];
2237

    
2238
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2239

    
2240
        this_pktl = av_mallocz(sizeof(AVPacketList));
2241
        this_pktl->pkt= *pkt;
2242
        if(pkt->destruct == av_destruct_packet)
2243
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2244
        else
2245
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2246

    
2247
        next_point = &s->packet_buffer;
2248
        while(*next_point){
2249
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2250
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2251
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2252
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2253
                break;
2254
            next_point= &(*next_point)->next;
2255
        }
2256
        this_pktl->next= *next_point;
2257
        *next_point= this_pktl;
2258
    }
2259

    
2260
    memset(streams, 0, sizeof(streams));
2261
    pktl= s->packet_buffer;
2262
    while(pktl){
2263
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2264
        if(streams[ pktl->pkt.stream_index ] == 0)
2265
            stream_count++;
2266
        streams[ pktl->pkt.stream_index ]++;
2267
        pktl= pktl->next;
2268
    }
2269

    
2270
    if(s->nb_streams == stream_count || (flush && stream_count)){
2271
        pktl= s->packet_buffer;
2272
        *out= pktl->pkt;
2273

    
2274
        s->packet_buffer= pktl->next;
2275
        av_freep(&pktl);
2276
        return 1;
2277
    }else{
2278
        av_init_packet(out);
2279
        return 0;
2280
    }
2281
}
2282

    
2283
/**
2284
 * Interleaves a AVPacket correctly so it can be muxed.
2285
 * @param out the interleaved packet will be output here
2286
 * @param in the input packet
2287
 * @param flush 1 if no further packets are available as input and all
2288
 *              remaining packets should be output
2289
 * @return 1 if a packet was output, 0 if no packet could be output,
2290
 *         < 0 if an error occured
2291
 */
2292
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2293
    if(s->oformat->interleave_packet)
2294
        return s->oformat->interleave_packet(s, out, in, flush);
2295
    else
2296
        return av_interleave_packet_per_dts(s, out, in, flush);
2297
}
2298

    
2299
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2300
    AVStream *st= s->streams[ pkt->stream_index];
2301

    
2302
    //FIXME/XXX/HACK drop zero sized packets
2303
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2304
        return 0;
2305

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

    
2310
    if(pkt->dts == AV_NOPTS_VALUE)
2311
        return -1;
2312

    
2313
    for(;;){
2314
        AVPacket opkt;
2315
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2316
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2317
            return ret;
2318

    
2319
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2320
        ret= s->oformat->write_packet(s, &opkt);
2321

    
2322
        av_free_packet(&opkt);
2323
        pkt= NULL;
2324

    
2325
        if(ret<0)
2326
            return ret;
2327
        if(url_ferror(&s->pb))
2328
            return url_ferror(&s->pb);
2329
    }
2330
}
2331

    
2332
int av_write_trailer(AVFormatContext *s)
2333
{
2334
    int ret, i;
2335

    
2336
    for(;;){
2337
        AVPacket pkt;
2338
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2339
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2340
            goto fail;
2341
        if(!ret)
2342
            break;
2343

    
2344
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2345
        ret= s->oformat->write_packet(s, &pkt);
2346

    
2347
        av_free_packet(&pkt);
2348

    
2349
        if(ret<0)
2350
            goto fail;
2351
        if(url_ferror(&s->pb))
2352
            goto fail;
2353
    }
2354

    
2355
    if(s->oformat->write_trailer)
2356
        ret = s->oformat->write_trailer(s);
2357
fail:
2358
    if(ret == 0)
2359
       ret=url_ferror(&s->pb);
2360
    for(i=0;i<s->nb_streams;i++)
2361
        av_freep(&s->streams[i]->priv_data);
2362
    av_freep(&s->priv_data);
2363
    return ret;
2364
}
2365

    
2366
/* "user interface" functions */
2367

    
2368
void dump_format(AVFormatContext *ic,
2369
                 int index,
2370
                 const char *url,
2371
                 int is_output)
2372
{
2373
    int i, flags;
2374
    char buf[256];
2375

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

    
2443
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2444
{
2445
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2446
}
2447

    
2448
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2449
{
2450
    AVRational frame_rate;
2451
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2452
    *frame_rate_num= frame_rate.num;
2453
    *frame_rate_den= frame_rate.den;
2454
    return ret;
2455
}
2456

    
2457
int64_t parse_date(const char *datestr, int duration)
2458
{
2459
    const char *p;
2460
    int64_t t;
2461
    struct tm dt;
2462
    int i;
2463
    static const char *date_fmt[] = {
2464
        "%Y-%m-%d",
2465
        "%Y%m%d",
2466
    };
2467
    static const char *time_fmt[] = {
2468
        "%H:%M:%S",
2469
        "%H%M%S",
2470
    };
2471
    const char *q;
2472
    int is_utc, len;
2473
    char lastch;
2474
    int negative = 0;
2475

    
2476
#undef time
2477
    time_t now = time(0);
2478

    
2479
    len = strlen(datestr);
2480
    if (len > 0)
2481
        lastch = datestr[len - 1];
2482
    else
2483
        lastch = '\0';
2484
    is_utc = (lastch == 'z' || lastch == 'Z');
2485

    
2486
    memset(&dt, 0, sizeof(dt));
2487

    
2488
    p = datestr;
2489
    q = NULL;
2490
    if (!duration) {
2491
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2492
            q = small_strptime(p, date_fmt[i], &dt);
2493
            if (q) {
2494
                break;
2495
            }
2496
        }
2497

    
2498
        if (!q) {
2499
            if (is_utc) {
2500
                dt = *gmtime(&now);
2501
            } else {
2502
                dt = *localtime(&now);
2503
            }
2504
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2505
        } else {
2506
            p = q;
2507
        }
2508

    
2509
        if (*p == 'T' || *p == 't' || *p == ' ')
2510
            p++;
2511

    
2512
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2513
            q = small_strptime(p, time_fmt[i], &dt);
2514
            if (q) {
2515
                break;
2516
            }
2517
        }
2518
    } else {
2519
        if (p[0] == '-') {
2520
            negative = 1;
2521
            ++p;
2522
        }
2523
        q = small_strptime(p, time_fmt[0], &dt);
2524
        if (!q) {
2525
            dt.tm_sec = strtol(p, (char **)&q, 10);
2526
            dt.tm_min = 0;
2527
            dt.tm_hour = 0;
2528
        }
2529
    }
2530

    
2531
    /* Now we have all the fields that we can get */
2532
    if (!q) {
2533
        if (duration)
2534
            return 0;
2535
        else
2536
            return now * INT64_C(1000000);
2537
    }
2538

    
2539
    if (duration) {
2540
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2541
    } else {
2542
        dt.tm_isdst = -1;       /* unknown */
2543
        if (is_utc) {
2544
            t = mktimegm(&dt);
2545
        } else {
2546
            t = mktime(&dt);
2547
        }
2548
    }
2549

    
2550
    t *= 1000000;
2551

    
2552
    if (*q == '.') {
2553
        int val, n;
2554
        q++;
2555
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2556
            if (!isdigit(*q))
2557
                break;
2558
            val += n * (*q - '0');
2559
        }
2560
        t += val;
2561
    }
2562
    return negative ? -t : t;
2563
}
2564

    
2565
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2566
{
2567
    const char *p;
2568
    char tag[128], *q;
2569

    
2570
    p = info;
2571
    if (*p == '?')
2572
        p++;
2573
    for(;;) {
2574
        q = tag;
2575
        while (*p != '\0' && *p != '=' && *p != '&') {
2576
            if ((q - tag) < sizeof(tag) - 1)
2577
                *q++ = *p;
2578
            p++;
2579
        }
2580
        *q = '\0';
2581
        q = arg;
2582
        if (*p == '=') {
2583
            p++;
2584
            while (*p != '&' && *p != '\0') {
2585
                if ((q - arg) < arg_size - 1) {
2586
                    if (*p == '+')
2587
                        *q++ = ' ';
2588
                    else
2589
                        *q++ = *p;
2590
                }
2591
                p++;
2592
            }
2593
            *q = '\0';
2594
        }
2595
        if (!strcmp(tag, tag1))
2596
            return 1;
2597
        if (*p != '&')
2598
            break;
2599
        p++;
2600
    }
2601
    return 0;
2602
}
2603

    
2604
int av_get_frame_filename(char *buf, int buf_size,
2605
                          const char *path, int number)
2606
{
2607
    const char *p;
2608
    char *q, buf1[20], c;
2609
    int nd, len, percentd_found;
2610

    
2611
    q = buf;
2612
    p = path;
2613
    percentd_found = 0;
2614
    for(;;) {
2615
        c = *p++;
2616
        if (c == '\0')
2617
            break;
2618
        if (c == '%') {
2619
            do {
2620
                nd = 0;
2621
                while (isdigit(*p)) {
2622
                    nd = nd * 10 + *p++ - '0';
2623
                }
2624
                c = *p++;
2625
            } while (isdigit(c));
2626

    
2627
            switch(c) {
2628
            case '%':
2629
                goto addchar;
2630
            case 'd':
2631
                if (percentd_found)
2632
                    goto fail;
2633
                percentd_found = 1;
2634
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2635
                len = strlen(buf1);
2636
                if ((q - buf + len) > buf_size - 1)
2637
                    goto fail;
2638
                memcpy(q, buf1, len);
2639
                q += len;
2640
                break;
2641
            default:
2642
                goto fail;
2643
            }
2644
        } else {
2645
        addchar:
2646
            if ((q - buf) < buf_size - 1)
2647
                *q++ = c;
2648
        }
2649
    }
2650
    if (!percentd_found)
2651
        goto fail;
2652
    *q = '\0';
2653
    return 0;
2654
 fail:
2655
    *q = '\0';
2656
    return -1;
2657
}
2658

    
2659
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2660
{
2661
    int len, i, j, c;
2662
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2663

    
2664
    for(i=0;i<size;i+=16) {
2665
        len = size - i;
2666
        if (len > 16)
2667
            len = 16;
2668
        PRINT("%08x ", i);
2669
        for(j=0;j<16;j++) {
2670
            if (j < len)
2671
                PRINT(" %02x", buf[i+j]);
2672
            else
2673
                PRINT("   ");
2674
        }
2675
        PRINT(" ");
2676
        for(j=0;j<len;j++) {
2677
            c = buf[i+j];
2678
            if (c < ' ' || c > '~')
2679
                c = '.';
2680
            PRINT("%c", c);
2681
        }
2682
        PRINT("\n");
2683
    }
2684
#undef PRINT
2685
}
2686

    
2687
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2688
{
2689
    hex_dump_internal(NULL, f, 0, buf, size);
2690
}
2691

    
2692
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2693
{
2694
    hex_dump_internal(avcl, NULL, level, buf, size);
2695
}
2696

    
2697
 //FIXME needs to know the time_base
2698
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2699
{
2700
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2701
    PRINT("stream #%d:\n", pkt->stream_index);
2702
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2703
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2704
    /* DTS is _always_ valid after av_read_frame() */
2705
    PRINT("  dts=");
2706
    if (pkt->dts == AV_NOPTS_VALUE)
2707
        PRINT("N/A");
2708
    else
2709
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2710
    /* PTS may be not known if B frames are present */
2711
    PRINT("  pts=");
2712
    if (pkt->pts == AV_NOPTS_VALUE)
2713
        PRINT("N/A");
2714
    else
2715
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2716
    PRINT("\n");
2717
    PRINT("  size=%d\n", pkt->size);
2718
#undef PRINT
2719
    if (dump_payload)
2720
        av_hex_dump(f, pkt->data, pkt->size);
2721
}
2722

    
2723
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2724
{
2725
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2726
}
2727

    
2728
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2729
{
2730
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2731
}
2732

    
2733
void url_split(char *proto, int proto_size,
2734
               char *authorization, int authorization_size,
2735
               char *hostname, int hostname_size,
2736
               int *port_ptr,
2737
               char *path, int path_size,
2738
               const char *url)
2739
{
2740
    const char *p;
2741
    char *q;
2742
    int port;
2743

    
2744
    port = -1;
2745

    
2746
    p = url;
2747
    q = proto;
2748
    while (*p != ':' && *p != '\0') {
2749
        if ((q - proto) < proto_size - 1)
2750
            *q++ = *p;
2751
        p++;
2752
    }
2753
    if (proto_size > 0)
2754
        *q = '\0';
2755
    if (authorization_size > 0)
2756
        authorization[0] = '\0';
2757
    if (*p == '\0') {
2758
        if (proto_size > 0)
2759
            proto[0] = '\0';
2760
        if (hostname_size > 0)
2761
            hostname[0] = '\0';
2762
        p = url;
2763
    } else {
2764
        char *at,*slash; // PETR: position of '@' character and '/' character
2765

    
2766
        p++;
2767
        if (*p == '/')
2768
            p++;
2769
        if (*p == '/')
2770
            p++;
2771
        at = strchr(p,'@'); // PETR: get the position of '@'
2772
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2773
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2774

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

    
2777
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2778
            if (*p == '@') {    // PETR: passed '@'
2779
              if (authorization_size > 0)
2780
                  *q = '\0';
2781
              q = hostname;
2782
              at = NULL;
2783
            } else if (!at) {   // PETR: hostname
2784
              if ((q - hostname) < hostname_size - 1)
2785
                  *q++ = *p;
2786
            } else {
2787
              if ((q - authorization) < authorization_size - 1)
2788
                *q++ = *p;
2789
            }
2790
            p++;
2791
        }
2792
        if (hostname_size > 0)
2793
            *q = '\0';
2794
        if (*p == ':') {
2795
            p++;
2796
            port = strtoul(p, (char **)&p, 10);
2797
        }
2798
    }
2799
    if (port_ptr)
2800
        *port_ptr = port;
2801
    av_strlcpy(path, p, path_size);
2802
}
2803

    
2804
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2805
                     int pts_num, int pts_den)
2806
{
2807
    s->pts_wrap_bits = pts_wrap_bits;
2808
    s->time_base.num = pts_num;
2809
    s->time_base.den = pts_den;
2810
}
2811

    
2812
/* fraction handling */
2813

    
2814
/**
2815
 * f = val + (num / den) + 0.5.
2816
 *
2817
 * 'num' is normalized so that it is such as 0 <= num < den.
2818
 *
2819
 * @param f fractional number
2820
 * @param val integer value
2821
 * @param num must be >= 0
2822
 * @param den must be >= 1
2823
 */
2824
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2825
{
2826
    num += (den >> 1);
2827
    if (num >= den) {
2828
        val += num / den;
2829
        num = num % den;
2830
    }
2831
    f->val = val;
2832
    f->num = num;
2833
    f->den = den;
2834
}
2835

    
2836
/**
2837
 * Fractionnal addition to f: f = f + (incr / f->den).
2838
 *
2839
 * @param f fractional number
2840
 * @param incr increment, can be positive or negative
2841
 */
2842
static void av_frac_add(AVFrac *f, int64_t incr)
2843
{
2844
    int64_t num, den;
2845

    
2846
    num = f->num + incr;
2847
    den = f->den;
2848
    if (num < 0) {
2849
        f->val += num / den;
2850
        num = num % den;
2851
        if (num < 0) {
2852
            num += den;
2853
            f->val--;
2854
        }
2855
    } else if (num >= den) {
2856
        f->val += num / den;
2857
        num = num % den;
2858
    }
2859
    f->num = num;
2860
}