Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 755bfeab

History | View | Annotate | Download (86.6 KB)

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

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

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

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

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

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

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

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

    
64
    if(!filename)
65
        return 0;
66

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

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

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

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

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

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

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

    
139
    return fmt;
140
}
141

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

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

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

    
171
/* memory handling */
172

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

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

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

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

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

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

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

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

    
222
    return ret;
223
}
224

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

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

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

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

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

    
281
/************************************************************/
282
/* input media file */
283

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

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

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

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

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

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

    
324
    s->av_class = &av_format_context_class;
325

    
326
    av_opt_set_defaults(s);
327
}
328

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
491
}
492

    
493
/*******************************************************/
494

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

    
501
/**********************************************************/
502

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

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

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

    
529

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
716
    av_init_packet(pkt);
717

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

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

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

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

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

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

    
817
    return 0;
818
}
819

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

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

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

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

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

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

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

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

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

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

    
900
/*******************************************************/
901
/* seek support */
902

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

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

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

    
927
    flush_packet_queue(s);
928

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

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

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

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

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

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

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

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

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

    
980
    st->index_entries= entries;
981

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

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

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

    
1005
    return index;
1006
}
1007

    
1008
/**
1009
 * build an index for raw streams using a parser.
1010
 */
1011
static void av_build_index_raw(AVFormatContext *s)
1012
{
1013
    AVPacket pkt1, *pkt = &pkt1;
1014
    int ret;
1015
    AVStream *st;
1016

    
1017
    st = s->streams[0];
1018
    av_read_frame_flush(s);
1019
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1020

    
1021
    for(;;) {
1022
        ret = av_read_frame(s, pkt);
1023
        if (ret < 0)
1024
            break;
1025
        if (pkt->stream_index == 0 && st->parser &&
1026
            (pkt->flags & PKT_FLAG_KEY)) {
1027
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1028
                            0, 0, AVINDEX_KEYFRAME);
1029
        }
1030
        av_free_packet(pkt);
1031
    }
1032
}
1033

    
1034
/**
1035
 * Returns TRUE if we deal with a raw stream.
1036
 *
1037
 * Raw codec data and parsing needed.
1038
 */
1039
static int is_raw_stream(AVFormatContext *s)
1040
{
1041
    AVStream *st;
1042

    
1043
    if (s->nb_streams != 1)
1044
        return 0;
1045
    st = s->streams[0];
1046
    if (!st->need_parsing)
1047
        return 0;
1048
    return 1;
1049
}
1050

    
1051
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1052
                              int flags)
1053
{
1054
    AVIndexEntry *entries= st->index_entries;
1055
    int nb_entries= st->nb_index_entries;
1056
    int a, b, m;
1057
    int64_t timestamp;
1058

    
1059
    a = - 1;
1060
    b = nb_entries;
1061

    
1062
    while (b - a > 1) {
1063
        m = (a + b) >> 1;
1064
        timestamp = entries[m].timestamp;
1065
        if(timestamp >= wanted_timestamp)
1066
            b = m;
1067
        if(timestamp <= wanted_timestamp)
1068
            a = m;
1069
    }
1070
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1071

    
1072
    if(!(flags & AVSEEK_FLAG_ANY)){
1073
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1074
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1075
        }
1076
    }
1077

    
1078
    if(m == nb_entries)
1079
        return -1;
1080
    return  m;
1081
}
1082

    
1083
#define DEBUG_SEEK
1084

    
1085
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1086
    AVInputFormat *avif= s->iformat;
1087
    int64_t pos_min, pos_max, pos, pos_limit;
1088
    int64_t ts_min, ts_max, ts;
1089
    int index;
1090
    AVStream *st;
1091

    
1092
    if (stream_index < 0)
1093
        return -1;
1094

    
1095
#ifdef DEBUG_SEEK
1096
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1097
#endif
1098

    
1099
    ts_max=
1100
    ts_min= AV_NOPTS_VALUE;
1101
    pos_limit= -1; //gcc falsely says it may be uninitalized
1102

    
1103
    st= s->streams[stream_index];
1104
    if(st->index_entries){
1105
        AVIndexEntry *e;
1106

    
1107
        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()
1108
        index= FFMAX(index, 0);
1109
        e= &st->index_entries[index];
1110

    
1111
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1112
            pos_min= e->pos;
1113
            ts_min= e->timestamp;
1114
#ifdef DEBUG_SEEK
1115
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1116
               pos_min,ts_min);
1117
#endif
1118
        }else{
1119
            assert(index==0);
1120
        }
1121

    
1122
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1123
        assert(index < st->nb_index_entries);
1124
        if(index >= 0){
1125
            e= &st->index_entries[index];
1126
            assert(e->timestamp >= target_ts);
1127
            pos_max= e->pos;
1128
            ts_max= e->timestamp;
1129
            pos_limit= pos_max - e->min_distance;
1130
#ifdef DEBUG_SEEK
1131
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1132
               pos_max,pos_limit, ts_max);
1133
#endif
1134
        }
1135
    }
1136

    
1137
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1138
    if(pos<0)
1139
        return -1;
1140

    
1141
    /* do the seek */
1142
    url_fseek(&s->pb, pos, SEEK_SET);
1143

    
1144
    av_update_cur_dts(s, st, ts);
1145

    
1146
    return 0;
1147
}
1148

    
1149
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 )){
1150
    int64_t pos, ts;
1151
    int64_t start_pos, filesize;
1152
    int no_change;
1153

    
1154
#ifdef DEBUG_SEEK
1155
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1156
#endif
1157

    
1158
    if(ts_min == AV_NOPTS_VALUE){
1159
        pos_min = s->data_offset;
1160
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1161
        if (ts_min == AV_NOPTS_VALUE)
1162
            return -1;
1163
    }
1164

    
1165
    if(ts_max == AV_NOPTS_VALUE){
1166
        int step= 1024;
1167
        filesize = url_fsize(&s->pb);
1168
        pos_max = filesize - 1;
1169
        do{
1170
            pos_max -= step;
1171
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1172
            step += step;
1173
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1174
        if (ts_max == AV_NOPTS_VALUE)
1175
            return -1;
1176

    
1177
        for(;;){
1178
            int64_t tmp_pos= pos_max + 1;
1179
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1180
            if(tmp_ts == AV_NOPTS_VALUE)
1181
                break;
1182
            ts_max= tmp_ts;
1183
            pos_max= tmp_pos;
1184
            if(tmp_pos >= filesize)
1185
                break;
1186
        }
1187
        pos_limit= pos_max;
1188
    }
1189

    
1190
    if(ts_min > ts_max){
1191
        return -1;
1192
    }else if(ts_min == ts_max){
1193
        pos_limit= pos_min;
1194
    }
1195

    
1196
    no_change=0;
1197
    while (pos_min < pos_limit) {
1198
#ifdef DEBUG_SEEK
1199
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1200
               pos_min, pos_max,
1201
               ts_min, ts_max);
1202
#endif
1203
        assert(pos_limit <= pos_max);
1204

    
1205
        if(no_change==0){
1206
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1207
            // interpolate position (better than dichotomy)
1208
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1209
                + pos_min - approximate_keyframe_distance;
1210
        }else if(no_change==1){
1211
            // bisection, if interpolation failed to change min or max pos last time
1212
            pos = (pos_min + pos_limit)>>1;
1213
        }else{
1214
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1215
            pos=pos_min;
1216
        }
1217
        if(pos <= pos_min)
1218
            pos= pos_min + 1;
1219
        else if(pos > pos_limit)
1220
            pos= pos_limit;
1221
        start_pos= pos;
1222

    
1223
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1224
        if(pos == pos_max)
1225
            no_change++;
1226
        else
1227
            no_change=0;
1228
#ifdef DEBUG_SEEK
1229
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);
1230
#endif
1231
        if(ts == AV_NOPTS_VALUE){
1232
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1233
            return -1;
1234
        }
1235
        assert(ts != AV_NOPTS_VALUE);
1236
        if (target_ts <= ts) {
1237
            pos_limit = start_pos - 1;
1238
            pos_max = pos;
1239
            ts_max = ts;
1240
        }
1241
        if (target_ts >= ts) {
1242
            pos_min = pos;
1243
            ts_min = ts;
1244
        }
1245
    }
1246

    
1247
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1248
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1249
#ifdef DEBUG_SEEK
1250
    pos_min = pos;
1251
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1252
    pos_min++;
1253
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1254
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1255
           pos, ts_min, target_ts, ts_max);
1256
#endif
1257
    *ts_ret= ts;
1258
    return pos;
1259
}
1260

    
1261
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1262
    int64_t pos_min, pos_max;
1263
#if 0
1264
    AVStream *st;
1265

1266
    if (stream_index < 0)
1267
        return -1;
1268

1269
    st= s->streams[stream_index];
1270
#endif
1271

    
1272
    pos_min = s->data_offset;
1273
    pos_max = url_fsize(&s->pb) - 1;
1274

    
1275
    if     (pos < pos_min) pos= pos_min;
1276
    else if(pos > pos_max) pos= pos_max;
1277

    
1278
    url_fseek(&s->pb, pos, SEEK_SET);
1279

    
1280
#if 0
1281
    av_update_cur_dts(s, st, ts);
1282
#endif
1283
    return 0;
1284
}
1285

    
1286
static int av_seek_frame_generic(AVFormatContext *s,
1287
                                 int stream_index, int64_t timestamp, int flags)
1288
{
1289
    int index;
1290
    AVStream *st;
1291
    AVIndexEntry *ie;
1292

    
1293
    st = s->streams[stream_index];
1294

    
1295
    index = av_index_search_timestamp(st, timestamp, flags);
1296

    
1297
    if(index < 0 || index==st->nb_index_entries-1){
1298
        int i;
1299
        AVPacket pkt;
1300

    
1301
        if(st->index_entries && st->nb_index_entries){
1302
            ie= &st->index_entries[st->nb_index_entries-1];
1303
            url_fseek(&s->pb, ie->pos, SEEK_SET);
1304
            av_update_cur_dts(s, st, ie->timestamp);
1305
        }else
1306
            url_fseek(&s->pb, 0, SEEK_SET);
1307

    
1308
        for(i=0;; i++) {
1309
            int ret = av_read_frame(s, &pkt);
1310
            if(ret<0)
1311
                break;
1312
            av_free_packet(&pkt);
1313
            if(stream_index == pkt.stream_index){
1314
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1315
                    break;
1316
            }
1317
        }
1318
        index = av_index_search_timestamp(st, timestamp, flags);
1319
    }
1320
    if (index < 0)
1321
        return -1;
1322

    
1323
    av_read_frame_flush(s);
1324
    if (s->iformat->read_seek){
1325
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1326
            return 0;
1327
    }
1328
    ie = &st->index_entries[index];
1329
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1330

    
1331
    av_update_cur_dts(s, st, ie->timestamp);
1332

    
1333
    return 0;
1334
}
1335

    
1336
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1337
{
1338
    int ret;
1339
    AVStream *st;
1340

    
1341
    av_read_frame_flush(s);
1342

    
1343
    if(flags & AVSEEK_FLAG_BYTE)
1344
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1345

    
1346
    if(stream_index < 0){
1347
        stream_index= av_find_default_stream_index(s);
1348
        if(stream_index < 0)
1349
            return -1;
1350

    
1351
        st= s->streams[stream_index];
1352
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1353
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1354
    }
1355
    st= s->streams[stream_index];
1356

    
1357
    /* first, we try the format specific seek */
1358
    if (s->iformat->read_seek)
1359
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1360
    else
1361
        ret = -1;
1362
    if (ret >= 0) {
1363
        return 0;
1364
    }
1365

    
1366
    if(s->iformat->read_timestamp)
1367
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1368
    else
1369
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1370
}
1371

    
1372
/*******************************************************/
1373

    
1374
/**
1375
 * Returns TRUE if the stream has accurate timings in any stream.
1376
 *
1377
 * @return TRUE if the stream has accurate timings for at least one component.
1378
 */
1379
static int av_has_timings(AVFormatContext *ic)
1380
{
1381
    int i;
1382
    AVStream *st;
1383

    
1384
    for(i = 0;i < ic->nb_streams; i++) {
1385
        st = ic->streams[i];
1386
        if (st->start_time != AV_NOPTS_VALUE &&
1387
            st->duration != AV_NOPTS_VALUE)
1388
            return 1;
1389
    }
1390
    return 0;
1391
}
1392

    
1393
/**
1394
 * Estimate the stream timings from the one of each components.
1395
 *
1396
 * Also computes the global bitrate if possible.
1397
 */
1398
static void av_update_stream_timings(AVFormatContext *ic)
1399
{
1400
    int64_t start_time, start_time1, end_time, end_time1;
1401
    int i;
1402
    AVStream *st;
1403

    
1404
    start_time = INT64_MAX;
1405
    end_time = INT64_MIN;
1406
    for(i = 0;i < ic->nb_streams; i++) {
1407
        st = ic->streams[i];
1408
        if (st->start_time != AV_NOPTS_VALUE) {
1409
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1410
            if (start_time1 < start_time)
1411
                start_time = start_time1;
1412
            if (st->duration != AV_NOPTS_VALUE) {
1413
                end_time1 = start_time1
1414
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1415
                if (end_time1 > end_time)
1416
                    end_time = end_time1;
1417
            }
1418
        }
1419
    }
1420
    if (start_time != INT64_MAX) {
1421
        ic->start_time = start_time;
1422
        if (end_time != INT64_MIN) {
1423
            ic->duration = end_time - start_time;
1424
            if (ic->file_size > 0) {
1425
                /* compute the bit rate */
1426
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1427
                    (double)ic->duration;
1428
            }
1429
        }
1430
    }
1431

    
1432
}
1433

    
1434
static void fill_all_stream_timings(AVFormatContext *ic)
1435
{
1436
    int i;
1437
    AVStream *st;
1438

    
1439
    av_update_stream_timings(ic);
1440
    for(i = 0;i < ic->nb_streams; i++) {
1441
        st = ic->streams[i];
1442
        if (st->start_time == AV_NOPTS_VALUE) {
1443
            if(ic->start_time != AV_NOPTS_VALUE)
1444
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1445
            if(ic->duration != AV_NOPTS_VALUE)
1446
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1447
        }
1448
    }
1449
}
1450

    
1451
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1452
{
1453
    int64_t filesize, duration;
1454
    int bit_rate, i;
1455
    AVStream *st;
1456

    
1457
    /* if bit_rate is already set, we believe it */
1458
    if (ic->bit_rate == 0) {
1459
        bit_rate = 0;
1460
        for(i=0;i<ic->nb_streams;i++) {
1461
            st = ic->streams[i];
1462
            bit_rate += st->codec->bit_rate;
1463
        }
1464
        ic->bit_rate = bit_rate;
1465
    }
1466

    
1467
    /* if duration is already set, we believe it */
1468
    if (ic->duration == AV_NOPTS_VALUE &&
1469
        ic->bit_rate != 0 &&
1470
        ic->file_size != 0)  {
1471
        filesize = ic->file_size;
1472
        if (filesize > 0) {
1473
            for(i = 0; i < ic->nb_streams; i++) {
1474
                st = ic->streams[i];
1475
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1476
                if (st->start_time == AV_NOPTS_VALUE ||
1477
                    st->duration == AV_NOPTS_VALUE) {
1478
                    st->start_time = 0;
1479
                    st->duration = duration;
1480
                }
1481
            }
1482
        }
1483
    }
1484
}
1485

    
1486
#define DURATION_MAX_READ_SIZE 250000
1487

    
1488
/* only usable for MPEG-PS streams */
1489
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1490
{
1491
    AVPacket pkt1, *pkt = &pkt1;
1492
    AVStream *st;
1493
    int read_size, i, ret;
1494
    int64_t end_time;
1495
    int64_t filesize, offset, duration;
1496

    
1497
    /* free previous packet */
1498
    if (ic->cur_st && ic->cur_st->parser)
1499
        av_free_packet(&ic->cur_pkt);
1500
    ic->cur_st = NULL;
1501

    
1502
    /* flush packet queue */
1503
    flush_packet_queue(ic);
1504

    
1505
    for(i=0;i<ic->nb_streams;i++) {
1506
        st = ic->streams[i];
1507
        if (st->parser) {
1508
            av_parser_close(st->parser);
1509
            st->parser= NULL;
1510
        }
1511
    }
1512

    
1513
    /* we read the first packets to get the first PTS (not fully
1514
       accurate, but it is enough now) */
1515
    url_fseek(&ic->pb, 0, SEEK_SET);
1516
    read_size = 0;
1517
    for(;;) {
1518
        if (read_size >= DURATION_MAX_READ_SIZE)
1519
            break;
1520
        /* if all info is available, we can stop */
1521
        for(i = 0;i < ic->nb_streams; i++) {
1522
            st = ic->streams[i];
1523
            if (st->start_time == AV_NOPTS_VALUE)
1524
                break;
1525
        }
1526
        if (i == ic->nb_streams)
1527
            break;
1528

    
1529
        ret = av_read_packet(ic, pkt);
1530
        if (ret != 0)
1531
            break;
1532
        read_size += pkt->size;
1533
        st = ic->streams[pkt->stream_index];
1534
        if (pkt->pts != AV_NOPTS_VALUE) {
1535
            if (st->start_time == AV_NOPTS_VALUE)
1536
                st->start_time = pkt->pts;
1537
        }
1538
        av_free_packet(pkt);
1539
    }
1540

    
1541
    /* estimate the end time (duration) */
1542
    /* XXX: may need to support wrapping */
1543
    filesize = ic->file_size;
1544
    offset = filesize - DURATION_MAX_READ_SIZE;
1545
    if (offset < 0)
1546
        offset = 0;
1547

    
1548
    url_fseek(&ic->pb, offset, SEEK_SET);
1549
    read_size = 0;
1550
    for(;;) {
1551
        if (read_size >= DURATION_MAX_READ_SIZE)
1552
            break;
1553
        /* if all info is available, we can stop */
1554
        for(i = 0;i < ic->nb_streams; i++) {
1555
            st = ic->streams[i];
1556
            if (st->duration == AV_NOPTS_VALUE)
1557
                break;
1558
        }
1559
        if (i == ic->nb_streams)
1560
            break;
1561

    
1562
        ret = av_read_packet(ic, pkt);
1563
        if (ret != 0)
1564
            break;
1565
        read_size += pkt->size;
1566
        st = ic->streams[pkt->stream_index];
1567
        if (pkt->pts != AV_NOPTS_VALUE) {
1568
            end_time = pkt->pts;
1569
            duration = end_time - st->start_time;
1570
            if (duration > 0) {
1571
                if (st->duration == AV_NOPTS_VALUE ||
1572
                    st->duration < duration)
1573
                    st->duration = duration;
1574
            }
1575
        }
1576
        av_free_packet(pkt);
1577
    }
1578

    
1579
    fill_all_stream_timings(ic);
1580

    
1581
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1582
}
1583

    
1584
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1585
{
1586
    int64_t file_size;
1587

    
1588
    /* get the file size, if possible */
1589
    if (ic->iformat->flags & AVFMT_NOFILE) {
1590
        file_size = 0;
1591
    } else {
1592
        file_size = url_fsize(&ic->pb);
1593
        if (file_size < 0)
1594
            file_size = 0;
1595
    }
1596
    ic->file_size = file_size;
1597

    
1598
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1599
         !strcmp(ic->iformat->name, "mpegts")) &&
1600
        file_size && !ic->pb.is_streamed) {
1601
        /* get accurate estimate from the PTSes */
1602
        av_estimate_timings_from_pts(ic, old_offset);
1603
    } else if (av_has_timings(ic)) {
1604
        /* at least one components has timings - we use them for all
1605
           the components */
1606
        fill_all_stream_timings(ic);
1607
    } else {
1608
        /* less precise: use bit rate info */
1609
        av_estimate_timings_from_bit_rate(ic);
1610
    }
1611
    av_update_stream_timings(ic);
1612

    
1613
#if 0
1614
    {
1615
        int i;
1616
        AVStream *st;
1617
        for(i = 0;i < ic->nb_streams; i++) {
1618
            st = ic->streams[i];
1619
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1620
               i, (double)st->start_time / AV_TIME_BASE,
1621
               (double)st->duration / AV_TIME_BASE);
1622
        }
1623
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1624
               (double)ic->start_time / AV_TIME_BASE,
1625
               (double)ic->duration / AV_TIME_BASE,
1626
               ic->bit_rate / 1000);
1627
    }
1628
#endif
1629
}
1630

    
1631
static int has_codec_parameters(AVCodecContext *enc)
1632
{
1633
    int val;
1634
    switch(enc->codec_type) {
1635
    case CODEC_TYPE_AUDIO:
1636
        val = enc->sample_rate;
1637
        break;
1638
    case CODEC_TYPE_VIDEO:
1639
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1640
        break;
1641
    default:
1642
        val = 1;
1643
        break;
1644
    }
1645
    return (val != 0);
1646
}
1647

    
1648
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1649
{
1650
    int16_t *samples;
1651
    AVCodec *codec;
1652
    int got_picture, data_size, ret=0;
1653
    AVFrame picture;
1654

    
1655
  if(!st->codec->codec){
1656
    codec = avcodec_find_decoder(st->codec->codec_id);
1657
    if (!codec)
1658
        return -1;
1659
    ret = avcodec_open(st->codec, codec);
1660
    if (ret < 0)
1661
        return ret;
1662
  }
1663

    
1664
  if(!has_codec_parameters(st->codec)){
1665
    switch(st->codec->codec_type) {
1666
    case CODEC_TYPE_VIDEO:
1667
        ret = avcodec_decode_video(st->codec, &picture,
1668
                                   &got_picture, (uint8_t *)data, size);
1669
        break;
1670
    case CODEC_TYPE_AUDIO:
1671
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1672
        samples = av_malloc(data_size);
1673
        if (!samples)
1674
            goto fail;
1675
        ret = avcodec_decode_audio2(st->codec, samples,
1676
                                    &data_size, (uint8_t *)data, size);
1677
        av_free(samples);
1678
        break;
1679
    default:
1680
        break;
1681
    }
1682
  }
1683
 fail:
1684
    return ret;
1685
}
1686

    
1687
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1688
{
1689
    AVInputFormat *fmt;
1690
    fmt = av_probe_input_format2(pd, 1, &score);
1691

    
1692
    if (fmt) {
1693
        if (strncmp(fmt->name, "mp3", 3) == 0)
1694
            st->codec->codec_id = CODEC_ID_MP3;
1695
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1696
            st->codec->codec_id = CODEC_ID_AC3;
1697
    }
1698
    return !!fmt;
1699
}
1700

    
1701
/* absolute maximum size we read until we abort */
1702
#define MAX_READ_SIZE        5000000
1703

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

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

    
1725
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1726
    if (!duration_error) return AVERROR_NOMEM;
1727

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

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

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

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

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

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

    
1814
        pkt = &pktl->pkt;
1815
        *pkt = pkt1;
1816

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

    
1823
        read_size += pkt->size;
1824

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

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

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

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

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

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

    
1892
        if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1893
            break;
1894
        }
1895
        count++;
1896
    }
1897

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

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

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

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

    
1950
    av_estimate_timings(ic, old_offset);
1951

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

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

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

    
1991
    return ret;
1992
}
1993

    
1994
/*******************************************************/
1995

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

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

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

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

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

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

    
2049
    if (s->nb_streams >= MAX_STREAMS)
2050
        return NULL;
2051

    
2052
    st = av_mallocz(sizeof(AVStream));
2053
    if (!st)
2054
        return NULL;
2055

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

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

    
2073
    s->streams[s->nb_streams++] = st;
2074
    return st;
2075
}
2076

    
2077
/************************************************************/
2078
/* output media file */
2079

    
2080
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2081
{
2082
    int ret;
2083

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

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

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

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

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

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

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

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

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

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

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

    
2180
//    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);
2181

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

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

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

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

    
2208
        pkt->dts= st->pts_buffer[0];
2209
    }
2210

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

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

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

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

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

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

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

    
2256
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2257
{
2258
    int ret;
2259

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

    
2264
    truncate_ts(s->streams[pkt->stream_index], pkt);
2265

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

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

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

    
2280
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2281

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

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

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

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

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

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

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

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

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

    
2352
    if(pkt->dts == AV_NOPTS_VALUE)
2353
        return -1;
2354

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

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

    
2364
        av_free_packet(&opkt);
2365
        pkt= NULL;
2366

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

    
2374
int av_write_trailer(AVFormatContext *s)
2375
{
2376
    int ret, i;
2377

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

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

    
2389
        av_free_packet(&pkt);
2390

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

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

    
2408
/* "user interface" functions */
2409

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

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

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

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

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

    
2518
#undef time
2519
    time_t now = time(0);
2520

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

    
2528
    memset(&dt, 0, sizeof(dt));
2529

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

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

    
2551
        if (*p == 'T' || *p == 't' || *p == ' ')
2552
            p++;
2553

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

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

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

    
2592
    t *= 1000000;
2593

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2786
    port = -1;
2787

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

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

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

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

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

    
2854
/* fraction handling */
2855

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

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

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