Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 10a7571b

History | View | Annotate | Download (87 KB)

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

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

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

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

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

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

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

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

    
68
    if(!filename)
69
        return 0;
70

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

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

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

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

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

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

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

    
143
    return fmt;
144
}
145

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

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

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

    
175
/* memory handling */
176

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

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

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

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

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

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

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

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

    
226
    return ret;
227
}
228

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

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

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

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

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

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

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

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

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

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

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

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

    
328
    s->av_class = &av_format_context_class;
329

    
330
    av_opt_set_defaults(s);
331
}
332

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
495
}
496

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

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

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

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

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

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

    
533

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

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

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

    
592
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
593
                               AVCodecParserContext *pc, AVPacket *pkt)
594
{
595
    int num, den, presentation_delayed, delay, i;
596
    int64_t offset;
597

    
598
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
599
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
600
        pkt->dts -= 1LL<<st->pts_wrap_bits;
601
    }
602

    
603
    if (pkt->duration == 0) {
604
        compute_frame_duration(&num, &den, st, pc, pkt);
605
        if (den && num) {
606
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
607
        }
608
    }
609

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

    
620
    if(is_intra_only(st->codec))
621
        pkt->flags |= PKT_FLAG_KEY;
622

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

    
635
    if(st->cur_dts == AV_NOPTS_VALUE){
636
        st->cur_dts = -delay * pkt->duration;
637
    }
638

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

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

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

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

    
691
//    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);
692

    
693
    /* update flags */
694
    if (pc) {
695
        pkt->flags = 0;
696
        /* key frame computation */
697
            if (pc->pict_type == FF_I_TYPE)
698
                pkt->flags |= PKT_FLAG_KEY;
699
    }
700
}
701

    
702
void av_destruct_packet_nofree(AVPacket *pkt)
703
{
704
    pkt->data = NULL; pkt->size = 0;
705
}
706

    
707
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
708
{
709
    AVStream *st;
710
    int len, ret, i;
711

    
712
    av_init_packet(pkt);
713

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

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

    
746
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
747
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
748
                                           0, 0, AVINDEX_KEYFRAME);
749
                    }
750

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

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

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

    
813
    return 0;
814
}
815

    
816
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
817
{
818
    AVPacketList *pktl;
819
    int eof=0;
820
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
821

    
822
    for(;;){
823
        pktl = s->packet_buffer;
824
        if (pktl) {
825
            AVPacket *next_pkt= &pktl->pkt;
826

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

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

    
861
            /* duplicate the packet */
862
            if (av_dup_packet(pkt) < 0)
863
                return AVERROR(ENOMEM);
864

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

    
867
            pktl = av_mallocz(sizeof(AVPacketList));
868
            if (!pktl)
869
                return AVERROR(ENOMEM);
870

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

    
881
/* XXX: suppress the packet queue */
882
static void flush_packet_queue(AVFormatContext *s)
883
{
884
    AVPacketList *pktl;
885

    
886
    for(;;) {
887
        pktl = s->packet_buffer;
888
        if (!pktl)
889
            break;
890
        s->packet_buffer = pktl->next;
891
        av_free_packet(&pktl->pkt);
892
        av_free(pktl);
893
    }
894
}
895

    
896
/*******************************************************/
897
/* seek support */
898

    
899
int av_find_default_stream_index(AVFormatContext *s)
900
{
901
    int i;
902
    AVStream *st;
903

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

    
915
/**
916
 * Flush the frame reader.
917
 */
918
static void av_read_frame_flush(AVFormatContext *s)
919
{
920
    AVStream *st;
921
    int i;
922

    
923
    flush_packet_queue(s);
924

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

    
935
    /* for each stream, reset read state */
936
    for(i = 0; i < s->nb_streams; i++) {
937
        st = s->streams[i];
938

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

    
948
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
949
    int i;
950

    
951
    for(i = 0; i < s->nb_streams; i++) {
952
        AVStream *st = s->streams[i];
953

    
954
        st->cur_dts = av_rescale(timestamp,
955
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
956
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
957
    }
958
}
959

    
960
int av_add_index_entry(AVStream *st,
961
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
962
{
963
    AVIndexEntry *entries, *ie;
964
    int index;
965

    
966
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
967
        return -1;
968

    
969
    entries = av_fast_realloc(st->index_entries,
970
                              &st->index_entries_allocated_size,
971
                              (st->nb_index_entries + 1) *
972
                              sizeof(AVIndexEntry));
973
    if(!entries)
974
        return -1;
975

    
976
    st->index_entries= entries;
977

    
978
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
979

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

    
995
    ie->pos = pos;
996
    ie->timestamp = timestamp;
997
    ie->min_distance= distance;
998
    ie->size= size;
999
    ie->flags = flags;
1000

    
1001
    return index;
1002
}
1003

    
1004
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1005
                              int flags)
1006
{
1007
    AVIndexEntry *entries= st->index_entries;
1008
    int nb_entries= st->nb_index_entries;
1009
    int a, b, m;
1010
    int64_t timestamp;
1011

    
1012
    a = - 1;
1013
    b = nb_entries;
1014

    
1015
    while (b - a > 1) {
1016
        m = (a + b) >> 1;
1017
        timestamp = entries[m].timestamp;
1018
        if(timestamp >= wanted_timestamp)
1019
            b = m;
1020
        if(timestamp <= wanted_timestamp)
1021
            a = m;
1022
    }
1023
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1024

    
1025
    if(!(flags & AVSEEK_FLAG_ANY)){
1026
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1027
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1028
        }
1029
    }
1030

    
1031
    if(m == nb_entries)
1032
        return -1;
1033
    return  m;
1034
}
1035

    
1036
#define DEBUG_SEEK
1037

    
1038
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1039
    AVInputFormat *avif= s->iformat;
1040
    int64_t pos_min, pos_max, pos, pos_limit;
1041
    int64_t ts_min, ts_max, ts;
1042
    int index;
1043
    AVStream *st;
1044

    
1045
    if (stream_index < 0)
1046
        return -1;
1047

    
1048
#ifdef DEBUG_SEEK
1049
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1050
#endif
1051

    
1052
    ts_max=
1053
    ts_min= AV_NOPTS_VALUE;
1054
    pos_limit= -1; //gcc falsely says it may be uninitialized
1055

    
1056
    st= s->streams[stream_index];
1057
    if(st->index_entries){
1058
        AVIndexEntry *e;
1059

    
1060
        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()
1061
        index= FFMAX(index, 0);
1062
        e= &st->index_entries[index];
1063

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

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

    
1090
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1091
    if(pos<0)
1092
        return -1;
1093

    
1094
    /* do the seek */
1095
    url_fseek(&s->pb, pos, SEEK_SET);
1096

    
1097
    av_update_cur_dts(s, st, ts);
1098

    
1099
    return 0;
1100
}
1101

    
1102
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 )){
1103
    int64_t pos, ts;
1104
    int64_t start_pos, filesize;
1105
    int no_change;
1106

    
1107
#ifdef DEBUG_SEEK
1108
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1109
#endif
1110

    
1111
    if(ts_min == AV_NOPTS_VALUE){
1112
        pos_min = s->data_offset;
1113
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1114
        if (ts_min == AV_NOPTS_VALUE)
1115
            return -1;
1116
    }
1117

    
1118
    if(ts_max == AV_NOPTS_VALUE){
1119
        int step= 1024;
1120
        filesize = url_fsize(&s->pb);
1121
        pos_max = filesize - 1;
1122
        do{
1123
            pos_max -= step;
1124
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1125
            step += step;
1126
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1127
        if (ts_max == AV_NOPTS_VALUE)
1128
            return -1;
1129

    
1130
        for(;;){
1131
            int64_t tmp_pos= pos_max + 1;
1132
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1133
            if(tmp_ts == AV_NOPTS_VALUE)
1134
                break;
1135
            ts_max= tmp_ts;
1136
            pos_max= tmp_pos;
1137
            if(tmp_pos >= filesize)
1138
                break;
1139
        }
1140
        pos_limit= pos_max;
1141
    }
1142

    
1143
    if(ts_min > ts_max){
1144
        return -1;
1145
    }else if(ts_min == ts_max){
1146
        pos_limit= pos_min;
1147
    }
1148

    
1149
    no_change=0;
1150
    while (pos_min < pos_limit) {
1151
#ifdef DEBUG_SEEK
1152
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1153
               pos_min, pos_max,
1154
               ts_min, ts_max);
1155
#endif
1156
        assert(pos_limit <= pos_max);
1157

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

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

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

    
1214
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1215
    int64_t pos_min, pos_max;
1216
#if 0
1217
    AVStream *st;
1218

1219
    if (stream_index < 0)
1220
        return -1;
1221

1222
    st= s->streams[stream_index];
1223
#endif
1224

    
1225
    pos_min = s->data_offset;
1226
    pos_max = url_fsize(&s->pb) - 1;
1227

    
1228
    if     (pos < pos_min) pos= pos_min;
1229
    else if(pos > pos_max) pos= pos_max;
1230

    
1231
    url_fseek(&s->pb, pos, SEEK_SET);
1232

    
1233
#if 0
1234
    av_update_cur_dts(s, st, ts);
1235
#endif
1236
    return 0;
1237
}
1238

    
1239
static int av_seek_frame_generic(AVFormatContext *s,
1240
                                 int stream_index, int64_t timestamp, int flags)
1241
{
1242
    int index;
1243
    AVStream *st;
1244
    AVIndexEntry *ie;
1245

    
1246
    st = s->streams[stream_index];
1247

    
1248
    index = av_index_search_timestamp(st, timestamp, flags);
1249

    
1250
    if(index < 0 || index==st->nb_index_entries-1){
1251
        int i;
1252
        AVPacket pkt;
1253

    
1254
        if(st->index_entries && st->nb_index_entries){
1255
            ie= &st->index_entries[st->nb_index_entries-1];
1256
            url_fseek(&s->pb, ie->pos, SEEK_SET);
1257
            av_update_cur_dts(s, st, ie->timestamp);
1258
        }else
1259
            url_fseek(&s->pb, 0, SEEK_SET);
1260

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

    
1276
    av_read_frame_flush(s);
1277
    if (s->iformat->read_seek){
1278
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1279
            return 0;
1280
    }
1281
    ie = &st->index_entries[index];
1282
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1283

    
1284
    av_update_cur_dts(s, st, ie->timestamp);
1285

    
1286
    return 0;
1287
}
1288

    
1289
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1290
{
1291
    int ret;
1292
    AVStream *st;
1293

    
1294
    av_read_frame_flush(s);
1295

    
1296
    if(flags & AVSEEK_FLAG_BYTE)
1297
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1298

    
1299
    if(stream_index < 0){
1300
        stream_index= av_find_default_stream_index(s);
1301
        if(stream_index < 0)
1302
            return -1;
1303

    
1304
        st= s->streams[stream_index];
1305
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1306
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1307
    }
1308
    st= s->streams[stream_index];
1309

    
1310
    /* first, we try the format specific seek */
1311
    if (s->iformat->read_seek)
1312
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1313
    else
1314
        ret = -1;
1315
    if (ret >= 0) {
1316
        return 0;
1317
    }
1318

    
1319
    if(s->iformat->read_timestamp)
1320
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1321
    else
1322
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1323
}
1324

    
1325
/*******************************************************/
1326

    
1327
/**
1328
 * Returns TRUE if the stream has accurate timings in any stream.
1329
 *
1330
 * @return TRUE if the stream has accurate timings for at least one component.
1331
 */
1332
static int av_has_timings(AVFormatContext *ic)
1333
{
1334
    int i;
1335
    AVStream *st;
1336

    
1337
    for(i = 0;i < ic->nb_streams; i++) {
1338
        st = ic->streams[i];
1339
        if (st->start_time != AV_NOPTS_VALUE &&
1340
            st->duration != AV_NOPTS_VALUE)
1341
            return 1;
1342
    }
1343
    return 0;
1344
}
1345

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

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

    
1385
}
1386

    
1387
static void fill_all_stream_timings(AVFormatContext *ic)
1388
{
1389
    int i;
1390
    AVStream *st;
1391

    
1392
    av_update_stream_timings(ic);
1393
    for(i = 0;i < ic->nb_streams; i++) {
1394
        st = ic->streams[i];
1395
        if (st->start_time == AV_NOPTS_VALUE) {
1396
            if(ic->start_time != AV_NOPTS_VALUE)
1397
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1398
            if(ic->duration != AV_NOPTS_VALUE)
1399
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1400
        }
1401
    }
1402
}
1403

    
1404
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1405
{
1406
    int64_t filesize, duration;
1407
    int bit_rate, i;
1408
    AVStream *st;
1409

    
1410
    /* if bit_rate is already set, we believe it */
1411
    if (ic->bit_rate == 0) {
1412
        bit_rate = 0;
1413
        for(i=0;i<ic->nb_streams;i++) {
1414
            st = ic->streams[i];
1415
            bit_rate += st->codec->bit_rate;
1416
        }
1417
        ic->bit_rate = bit_rate;
1418
    }
1419

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

    
1439
#define DURATION_MAX_READ_SIZE 250000
1440

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

    
1450
    /* free previous packet */
1451
    if (ic->cur_st && ic->cur_st->parser)
1452
        av_free_packet(&ic->cur_pkt);
1453
    ic->cur_st = NULL;
1454

    
1455
    /* flush packet queue */
1456
    flush_packet_queue(ic);
1457

    
1458
    for(i=0;i<ic->nb_streams;i++) {
1459
        st = ic->streams[i];
1460
        if (st->parser) {
1461
            av_parser_close(st->parser);
1462
            st->parser= NULL;
1463
        }
1464
    }
1465

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

    
1482
        ret = av_read_packet(ic, pkt);
1483
        if (ret != 0)
1484
            break;
1485
        read_size += pkt->size;
1486
        st = ic->streams[pkt->stream_index];
1487
        if (pkt->pts != AV_NOPTS_VALUE) {
1488
            if (st->start_time == AV_NOPTS_VALUE)
1489
                st->start_time = pkt->pts;
1490
        }
1491
        av_free_packet(pkt);
1492
    }
1493

    
1494
    /* estimate the end time (duration) */
1495
    /* XXX: may need to support wrapping */
1496
    filesize = ic->file_size;
1497
    offset = filesize - DURATION_MAX_READ_SIZE;
1498
    if (offset < 0)
1499
        offset = 0;
1500

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

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

    
1532
    fill_all_stream_timings(ic);
1533

    
1534
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1535
}
1536

    
1537
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1538
{
1539
    int64_t file_size;
1540

    
1541
    /* get the file size, if possible */
1542
    if (ic->iformat->flags & AVFMT_NOFILE) {
1543
        file_size = 0;
1544
    } else {
1545
        file_size = url_fsize(&ic->pb);
1546
        if (file_size < 0)
1547
            file_size = 0;
1548
    }
1549
    ic->file_size = file_size;
1550

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

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

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

    
1601
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1602
{
1603
    int16_t *samples;
1604
    AVCodec *codec;
1605
    int got_picture, data_size, ret=0;
1606
    AVFrame picture;
1607

    
1608
  if(!st->codec->codec){
1609
    codec = avcodec_find_decoder(st->codec->codec_id);
1610
    if (!codec)
1611
        return -1;
1612
    ret = avcodec_open(st->codec, codec);
1613
    if (ret < 0)
1614
        return ret;
1615
  }
1616

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

    
1640
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1641
{
1642
    AVInputFormat *fmt;
1643
    fmt = av_probe_input_format2(pd, 1, &score);
1644

    
1645
    if (fmt) {
1646
        if (strncmp(fmt->name, "mp3", 3) == 0)
1647
            st->codec->codec_id = CODEC_ID_MP3;
1648
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1649
            st->codec->codec_id = CODEC_ID_AC3;
1650
    }
1651
    return !!fmt;
1652
}
1653

    
1654
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1655
{
1656
    while (tags->id != CODEC_ID_NONE) {
1657
        if (tags->id == id)
1658
            return tags->tag;
1659
        tags++;
1660
    }
1661
    return 0;
1662
}
1663

    
1664
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1665
{
1666
    int i;
1667
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1668
        if(tag == tags[i].tag)
1669
            return tags[i].id;
1670
    }
1671
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1672
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1673
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1674
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1675
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1676
            return tags[i].id;
1677
    }
1678
    return CODEC_ID_NONE;
1679
}
1680

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

    
1691
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1692
{
1693
    int i;
1694
    for(i=0; tags && tags[i]; i++){
1695
        enum CodecID id= codec_get_id(tags[i], tag);
1696
        if(id!=CODEC_ID_NONE) return id;
1697
    }
1698
    return CODEC_ID_NONE;
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(ENOMEM);
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(ENOMEM);
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(ENOMEM);
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 (st->time_base.den > 0 && 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]), 1);
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(ENOSYS);
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(ENOSYS);
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(ENOMEM);
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(ENOMEM);
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
/**
2500
 * gets the current time in micro seconds.
2501
 */
2502
int64_t av_gettime(void)
2503
{
2504
    struct timeval tv;
2505
    gettimeofday(&tv,NULL);
2506
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2507
}
2508

    
2509
int64_t parse_date(const char *datestr, int duration)
2510
{
2511
    const char *p;
2512
    int64_t t;
2513
    struct tm dt;
2514
    int i;
2515
    static const char *date_fmt[] = {
2516
        "%Y-%m-%d",
2517
        "%Y%m%d",
2518
    };
2519
    static const char *time_fmt[] = {
2520
        "%H:%M:%S",
2521
        "%H%M%S",
2522
    };
2523
    const char *q;
2524
    int is_utc, len;
2525
    char lastch;
2526
    int negative = 0;
2527

    
2528
#undef time
2529
    time_t now = time(0);
2530

    
2531
    len = strlen(datestr);
2532
    if (len > 0)
2533
        lastch = datestr[len - 1];
2534
    else
2535
        lastch = '\0';
2536
    is_utc = (lastch == 'z' || lastch == 'Z');
2537

    
2538
    memset(&dt, 0, sizeof(dt));
2539

    
2540
    p = datestr;
2541
    q = NULL;
2542
    if (!duration) {
2543
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2544
            q = small_strptime(p, date_fmt[i], &dt);
2545
            if (q) {
2546
                break;
2547
            }
2548
        }
2549

    
2550
        if (!q) {
2551
            if (is_utc) {
2552
                dt = *gmtime(&now);
2553
            } else {
2554
                dt = *localtime(&now);
2555
            }
2556
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2557
        } else {
2558
            p = q;
2559
        }
2560

    
2561
        if (*p == 'T' || *p == 't' || *p == ' ')
2562
            p++;
2563

    
2564
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2565
            q = small_strptime(p, time_fmt[i], &dt);
2566
            if (q) {
2567
                break;
2568
            }
2569
        }
2570
    } else {
2571
        if (p[0] == '-') {
2572
            negative = 1;
2573
            ++p;
2574
        }
2575
        q = small_strptime(p, time_fmt[0], &dt);
2576
        if (!q) {
2577
            dt.tm_sec = strtol(p, (char **)&q, 10);
2578
            dt.tm_min = 0;
2579
            dt.tm_hour = 0;
2580
        }
2581
    }
2582

    
2583
    /* Now we have all the fields that we can get */
2584
    if (!q) {
2585
        if (duration)
2586
            return 0;
2587
        else
2588
            return now * INT64_C(1000000);
2589
    }
2590

    
2591
    if (duration) {
2592
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2593
    } else {
2594
        dt.tm_isdst = -1;       /* unknown */
2595
        if (is_utc) {
2596
            t = mktimegm(&dt);
2597
        } else {
2598
            t = mktime(&dt);
2599
        }
2600
    }
2601

    
2602
    t *= 1000000;
2603

    
2604
    if (*q == '.') {
2605
        int val, n;
2606
        q++;
2607
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2608
            if (!isdigit(*q))
2609
                break;
2610
            val += n * (*q - '0');
2611
        }
2612
        t += val;
2613
    }
2614
    return negative ? -t : t;
2615
}
2616

    
2617
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2618
{
2619
    const char *p;
2620
    char tag[128], *q;
2621

    
2622
    p = info;
2623
    if (*p == '?')
2624
        p++;
2625
    for(;;) {
2626
        q = tag;
2627
        while (*p != '\0' && *p != '=' && *p != '&') {
2628
            if ((q - tag) < sizeof(tag) - 1)
2629
                *q++ = *p;
2630
            p++;
2631
        }
2632
        *q = '\0';
2633
        q = arg;
2634
        if (*p == '=') {
2635
            p++;
2636
            while (*p != '&' && *p != '\0') {
2637
                if ((q - arg) < arg_size - 1) {
2638
                    if (*p == '+')
2639
                        *q++ = ' ';
2640
                    else
2641
                        *q++ = *p;
2642
                }
2643
                p++;
2644
            }
2645
            *q = '\0';
2646
        }
2647
        if (!strcmp(tag, tag1))
2648
            return 1;
2649
        if (*p != '&')
2650
            break;
2651
        p++;
2652
    }
2653
    return 0;
2654
}
2655

    
2656
int av_get_frame_filename(char *buf, int buf_size,
2657
                          const char *path, int number)
2658
{
2659
    const char *p;
2660
    char *q, buf1[20], c;
2661
    int nd, len, percentd_found;
2662

    
2663
    q = buf;
2664
    p = path;
2665
    percentd_found = 0;
2666
    for(;;) {
2667
        c = *p++;
2668
        if (c == '\0')
2669
            break;
2670
        if (c == '%') {
2671
            do {
2672
                nd = 0;
2673
                while (isdigit(*p)) {
2674
                    nd = nd * 10 + *p++ - '0';
2675
                }
2676
                c = *p++;
2677
            } while (isdigit(c));
2678

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

    
2711
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2712
{
2713
    int len, i, j, c;
2714
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2715

    
2716
    for(i=0;i<size;i+=16) {
2717
        len = size - i;
2718
        if (len > 16)
2719
            len = 16;
2720
        PRINT("%08x ", i);
2721
        for(j=0;j<16;j++) {
2722
            if (j < len)
2723
                PRINT(" %02x", buf[i+j]);
2724
            else
2725
                PRINT("   ");
2726
        }
2727
        PRINT(" ");
2728
        for(j=0;j<len;j++) {
2729
            c = buf[i+j];
2730
            if (c < ' ' || c > '~')
2731
                c = '.';
2732
            PRINT("%c", c);
2733
        }
2734
        PRINT("\n");
2735
    }
2736
#undef PRINT
2737
}
2738

    
2739
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2740
{
2741
    hex_dump_internal(NULL, f, 0, buf, size);
2742
}
2743

    
2744
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2745
{
2746
    hex_dump_internal(avcl, NULL, level, buf, size);
2747
}
2748

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

    
2775
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2776
{
2777
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2778
}
2779

    
2780
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2781
{
2782
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2783
}
2784

    
2785
void url_split(char *proto, int proto_size,
2786
               char *authorization, int authorization_size,
2787
               char *hostname, int hostname_size,
2788
               int *port_ptr,
2789
               char *path, int path_size,
2790
               const char *url)
2791
{
2792
    const char *p;
2793
    char *q;
2794
    int port;
2795

    
2796
    port = -1;
2797

    
2798
    p = url;
2799
    q = proto;
2800
    while (*p != ':' && *p != '\0') {
2801
        if ((q - proto) < proto_size - 1)
2802
            *q++ = *p;
2803
        p++;
2804
    }
2805
    if (proto_size > 0)
2806
        *q = '\0';
2807
    if (authorization_size > 0)
2808
        authorization[0] = '\0';
2809
    if (*p == '\0') {
2810
        if (proto_size > 0)
2811
            proto[0] = '\0';
2812
        if (hostname_size > 0)
2813
            hostname[0] = '\0';
2814
        p = url;
2815
    } else {
2816
        char *at,*slash; // PETR: position of '@' character and '/' character
2817

    
2818
        p++;
2819
        if (*p == '/')
2820
            p++;
2821
        if (*p == '/')
2822
            p++;
2823
        at = strchr(p,'@'); // PETR: get the position of '@'
2824
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2825
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2826

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

    
2829
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2830
            if (*p == '@') {    // PETR: passed '@'
2831
              if (authorization_size > 0)
2832
                  *q = '\0';
2833
              q = hostname;
2834
              at = NULL;
2835
            } else if (!at) {   // PETR: hostname
2836
              if ((q - hostname) < hostname_size - 1)
2837
                  *q++ = *p;
2838
            } else {
2839
              if ((q - authorization) < authorization_size - 1)
2840
                *q++ = *p;
2841
            }
2842
            p++;
2843
        }
2844
        if (hostname_size > 0)
2845
            *q = '\0';
2846
        if (*p == ':') {
2847
            p++;
2848
            port = strtoul(p, (char **)&p, 10);
2849
        }
2850
    }
2851
    if (port_ptr)
2852
        *port_ptr = port;
2853
    av_strlcpy(path, p, path_size);
2854
}
2855

    
2856
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2857
                     int pts_num, int pts_den)
2858
{
2859
    s->pts_wrap_bits = pts_wrap_bits;
2860
    s->time_base.num = pts_num;
2861
    s->time_base.den = pts_den;
2862
}
2863

    
2864
/* fraction handling */
2865

    
2866
/**
2867
 * f = val + (num / den) + 0.5.
2868
 *
2869
 * 'num' is normalized so that it is such as 0 <= num < den.
2870
 *
2871
 * @param f fractional number
2872
 * @param val integer value
2873
 * @param num must be >= 0
2874
 * @param den must be >= 1
2875
 */
2876
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2877
{
2878
    num += (den >> 1);
2879
    if (num >= den) {
2880
        val += num / den;
2881
        num = num % den;
2882
    }
2883
    f->val = val;
2884
    f->num = num;
2885
    f->den = den;
2886
}
2887

    
2888
/**
2889
 * Fractionnal addition to f: f = f + (incr / f->den).
2890
 *
2891
 * @param f fractional number
2892
 * @param incr increment, can be positive or negative
2893
 */
2894
static void av_frac_add(AVFrac *f, int64_t incr)
2895
{
2896
    int64_t num, den;
2897

    
2898
    num = f->num + incr;
2899
    den = f->den;
2900
    if (num < 0) {
2901
        f->val += num / den;
2902
        num = num % den;
2903
        if (num < 0) {
2904
            num += den;
2905
            f->val--;
2906
        }
2907
    } else if (num >= den) {
2908
        f->val += num / den;
2909
        num = num % den;
2910
    }
2911
    f->num = num;
2912
}